relacibo.github.io

{
  "type": "object",
  "properties": {
    "flow_id": {
      "type": "string"
    },
    "description": {
      "type": "string",
      "description": "Complete, independently executable instruction (Markdown allowed); start with a short key statement (user-facing — German)"
    },
    "ingredients": {
      "type": "array",
      "description": "Ingredients of this card as chips ({name, amount}). The app renders them INLINE right after the step text, the amount always visible (\"Mehl · 250 g\"). If an amount is given here, do NOT repeat it in the description text (\"fold in the flour\" instead of \"fold in 250 g of flour\"). The ingredient list (ingredients modal) is derived automatically from all card chips — one line per ingredient, colored by flow. \"To taste\" ingredients (salt, oil) go without amount; only list them if the card actually uses them.",
      "items": {
        "type": "object",
        "properties": {
          "name": {
            "type": "string",
            "description": "Ingredient, e.g. \"Basmatireis\" (user-facing — German)"
          },
          "amount": {
            "type": "string",
            "description": "Amount, e.g. \"300 g\" or \"2 Stück\" — empty/omitted for \"to taste\""
          }
        },
        "required": [
          "name"
        ]
      }
    },
    "after_step_id": {
      "type": "string",
      "description": "Optional: stable ID of the step to insert behind (otherwise appended at the end)"
    },
    "priority": {
      "type": "string",
      "enum": [
        "normal",
        "high"
      ],
      "description": "\"high\" for time-critical steps (e.g. something in the oven): the card sits at the top of \"Jetzt\" and pulses (a real alarm). A \"high\" step may have at most ONE dependency (the step whose completion — possibly plus delay — determines the wait). Use sparingly."
    },
    "score": {
      "type": "number",
      "description": "Optional scheduling hint (default 0): the higher, the further up in the active queue (\"do this first\"). Not an alarm — that is priority \"high\". Put the value directly on the time-critical step (e.g. the step that must happen right after a wait: \"drain the fat\" after resting, \"dough into the oven\" after proofing). The engine automatically pulls all preceding steps up with it recursively — the score propagates backwards over depends_on, even through waiting times. Predecessors therefore need no score of their own. Only set it if the default would be wrong."
    },
    "depends_on": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "flow_id": {
            "type": "string"
          },
          "step_id": {
            "type": "string",
            "description": "Stable step ID (from get_cook_state)"
          },
          "timer_seconds": {
            "type": "number",
            "description": "Optional delay in seconds: the card only becomes free X seconds AFTER this dependency completes (\"I will join X seconds after this card\")."
          }
        },
        "required": [
          "flow_id",
          "step_id"
        ]
      },
      "description": "Optional dependencies (steps that must finish first). There is NO implicit ordering — without depends_on a step runs immediately in parallel. Chain every follow-up step explicitly to its predecessor (including step 2 → step 1). EVERY time span in the recipe MUST be modeled as timer_seconds on the edge to the follow-up card (\"simmer for 10 minutes\" → follow-up card with timer_seconds 600). WAITING TIME vs. active work: the edge means passive waiting (baking, steeping, chilling). If the RESULT determines the end (\"until golden\", \"until creamy\") or the cook is active (\"bring to a boil while stirring\"), there is NO edge — the time belongs in the card's own description. Time spans go at the END of the triggering card (key statement first); the waiting follow-up card mentions NO time, only what to do once it elapses. If the recipe ends with a waiting period, append a final step that waits via timer_seconds (\"carve and serve\"). Across flows the edge is the scheduling tool: \"whip the cream\" hangs with a smaller timer_seconds on the SAME anchor as the waiting card — it appears shortly before it. PLAN AS LATE AS POSSIBLE (with buffer): results that age (preheated oven, whipped cream, melted butter) must NOT sit free at the start — anchor them so they are ready exactly when they are needed. Millet example: [bring to a boil] →(540s)→ [let it swell] →(600s)→ [fluff up]. \"Preheat oven to 180°\" (≈ 5 min) should be hot when the swelling ends: attach it with timer_seconds=300 to the swelling card — math: timer = swelling time 600 − preheat time 300, so the oven starts 5 min before the swelling ends and is exactly on time. The math lives in timer_seconds, not in the description. When in doubt, start slightly earlier — a hot oven holds its temperature, waiting food gets cold."
    }
  },
  "required": [
    "flow_id",
    "description"
  ]
}