relacibo.github.io

{
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "description": "Name, e.g. \"Reis\" (user-facing — German)"
    },
    "icon": {
      "type": "string",
      "description": "Matching emoji, e.g. \"🍚\" — identifies the flow visually"
    },
    "steps": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "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"
              ]
            }
          },
          "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": {
                "step_index": {
                  "type": "number",
                  "description": "Predecessor within THIS new flow: 0-based index of the step in the steps array (must be smaller than the own index)."
                },
                "flow_id": {
                  "type": "string",
                  "description": "For predecessors in a different, already existing flow"
                },
                "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\")."
                }
              }
            },
            "description": "Optional dependencies. There is NO implicit ordering — without depends_on a step runs immediately in parallel. Chain every follow-up step explicitly to its predecessor: within this new flow via step_index, to existing steps of other flows via flow_id + step_id. 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": [
          "description"
        ]
      },
      "description": "Step sequence"
    }
  },
  "required": [
    "name",
    "icon",
    "steps"
  ]
}