@bendyline/gilde 0.1.27 → 0.1.28

package/data/craftbook-templates/re/receipt-ocr-ledger/versions/1.0.1/craftbook.json

@@ -0,0 +1,140 @@
+{
+  "id": "receipt-ocr-ledger",
+  "name": "Receipts to Expense Ledger",
+  "description": "Turn a folder of receipt photos/PDFs into a clean expense ledger: OCR each receipt, extract vendor, date, line items, tax, and total, assign an expense category, and reconcile that each extracted total matches its line items. Locks the per-receipt field schema, the category set, and the math/reconciliation rules FIRST, then OCRs and extracts each receipt into rows, then verifies every receipt was processed, totals reconcile, currencies/dates are normalized, and low-confidence reads are flagged for review. Defining the schema and the total-equals-line-items check before extraction is what keeps an expense ledger trustworthy for reimbursement or tax.\n\nA gallery craftbook generated from an archetype spec. It runs\n`phase → (per-phase gate) → … → evaluate → (loop) → finish`. Each build\nphase that produces a checkable artifact is followed by a **runtime\ngate-checkpoint** — the runtime verifies the artifact and routes with no\nmodel turn, looping back to redo the phase on a miss. The final `evaluate`\nstep holds a static deliverable gate plus a reviewer QA pass. What it adds\nover the generic `build-loop`: a specialist role per phase, a\ndomain-correct ordering, and a concrete per-phase quality bar.\n\nDeliverables marked \"artifact\" land in the project's artifacts drawer (`write_artifact` / `read_artifact`), not the shipped workspace — review output is not product source.\n\nPhases:\n\n1. Scope the ledger (planner) — per-receipt schema, categories, reconciliation rules → gated on artifact `notes/scope.md` (markdown-notes)\n2. OCR and extract (developer) — read each receipt, extract fields, categorize, reconcile → gated on `ledger.json` (json)\n3. Verify the ledger (reviewer) — coverage, reconciliation, normalization, review flags → gated on artifact `notes/verify.md` (markdown-notes)\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "scope",
+  "triggers": [
+    "scan my receipts",
+    "receipts to a spreadsheet",
+    "extract receipt totals",
+    "expense report from receipts",
+    "OCR receipts into a ledger"
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the ledger",
+      "description": "per-receipt schema, categories, reconciliation rules",
+      "prompt": "Define the ledger contract before reading receipts. Step 1: identify the receipts folder and the file types (jpg, png, pdf). Step 2: define the per-receipt schema (file, vendor, date, currency, line items[{desc, amount}], subtotal, tax, total, category, confidence, needs_review). Step 3: define the closed expense-category set (e.g. Meals, Travel, Supplies, Software, Other) — every receipt gets exactly one. Step 4: define the math/reconciliation rule — sum(line items) + tax should equal total within a small tolerance; a mismatch sets needs_review. Step 5: define normalization (dates → ISO, amounts numeric to two decimals, a single output currency or a currency column) and the confidence threshold below which a row is flagged. Step 6: write an acceptance-criteria checklist ('every receipt file produces a row', 'amounts numeric and dates ISO', 'total reconciles to line items + tax within tolerance else flagged', 'category is in-set', 'low-confidence reads flagged for review', 'a grand total across receipts is reported'). Call write_task_note with schema + categories + rules + checklist and write notes/scope.md. No OCR yet.\n\nThe deliverable `notes/scope.md` lands in the project's artifacts drawer — write it with `write_artifact` and read it back with `read_artifact`; the shipped workspace stays untouched.",
+      "suggestedRole": "planner",
+      "advanceWhen": {
+        "file": "notes/scope.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "notes/scope.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "notes/scope.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "scope",
+        "maxAttempts": 3
+      },
+      "next": "extract"
+    },
+    {
+      "id": "extract",
+      "name": "OCR and extract",
+      "description": "read each receipt, extract fields, categorize, reconcile",
+      "prompt": "Process every receipt into a ledger row to the locked schema. Step 1: list the folder and, for each receipt, use the available OCR/vision capability to read the text. Step 2: extract vendor, date, line items, subtotal, tax, and total; normalize dates to ISO and amounts to numbers. Step 3: assign exactly one in-set category from the vendor/items. Step 4: reconcile — check sum(line items)+tax ≈ total within tolerance; on mismatch or low OCR confidence, set needs_review with a note rather than silently trusting it. Step 5: write all rows to the output file (JSON), confirm it parses, and compute a grand total across receipts. Do not skip any receipt; if one is unreadable, still emit a row flagged needs_review. Call write_task_note with the output path, the receipt count, and how many are flagged.",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "ledger.json",
+        "minBytes": 1,
+        "sniff": "json-valid"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "ledger.json",
+            "bytes": 2
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkJsonValid",
+            "scope": "standard",
+            "inputs": {
+              "file": "ledger.json"
+            }
+          }
+        ],
+        "onReject": "extract",
+        "maxAttempts": 3
+      },
+      "next": "verify"
+    },
+    {
+      "id": "verify",
+      "name": "Verify the ledger",
+      "description": "coverage, reconciliation, normalization, review flags",
+      "prompt": "Verify the ledger against scope. Step 1: confirm the file parses and there is one row per receipt file in the folder — none skipped. Step 2: confirm amounts are numeric to two decimals and dates are ISO. Step 3: confirm reconciliation ran — rows where line items + tax do not match the total within tolerance are flagged needs_review, and clean rows actually balance (re-check 3 by hand). Step 4: confirm categories are all in-set and low-confidence/unreadable receipts are flagged rather than silently accepted. Step 5: confirm the grand total equals the sum of the row totals. Write PASS/FAIL per criterion to notes/verify.md and task notes; on failure, name the receipts and loop back to extract.\n\nThe deliverable `notes/verify.md` lands in the project's artifacts drawer — write it with `write_artifact` and read it back with `read_artifact`; the shipped workspace stays untouched.",
+      "suggestedRole": "reviewer",
+      "advanceWhen": {
+        "file": "notes/verify.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "ledger.json",
+            "bytes": 2
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkJsonValid",
+            "scope": "standard",
+            "inputs": {
+              "file": "ledger.json"
+            }
+          }
+        ],
+        "onReject": "verify",
+        "maxAttempts": 4
+      },
+      "next": "evaluate"
+    },
+    {
+      "id": "evaluate",
+      "name": "Evaluate",
+      "description": "Grade the deliverable against every acceptance criterion. All pass → finish; any fail → loop back and fix the gap.",
+      "prompt": "Open ledger.json and verify every criterion from notes/scope.md: one row per receipt file (none skipped, unreadable ones flagged), amounts numeric to two decimals and dates ISO, reconciliation flags rows where line items + tax do not match the total within tolerance while clean rows balance (re-check 3 by hand), categories all in-set, low-confidence reads flagged, and the grand total equals the sum of row totals. Write PASS/FAIL per criterion; on any failure, name the receipts and loop back to extract.\n\nThen route — this is the whole point of the loop:\n\n- **Every criterion PASSES →** call `advance_task_step({ ref, stepId: \"evaluate\", next: \"finish\" })`.\n- **Any criterion FAILS →** write the specific gaps to notes, then call `advance_task_step({ ref, stepId: \"evaluate\", next: \"extract\" })` to loop back. The builder fixes exactly those gaps.\n\nNever route to `finish` while any criterion is unmet. The build phase's completion gate already blocked a grossly-incomplete deliverable; your job is the judgment an automated check cannot make (does it actually work, read well, look right). After ~3 unproductive loops, stop and report DONE_WITH_CONCERNS so the user can step in.",
+      "suggestedRole": "reviewer",
+      "consumes": [
+        {
+          "file": "ledger.json"
+        }
+      ],
+      "next": "extract"
+    },
+    {
+      "id": "finish",
+      "name": "Finish",
+      "description": "All acceptance criteria met. Stamp a short summary and report DONE.",
+      "prompt": "Every acceptance criterion passed. Write a one-paragraph DONE summary to task notes via `write_task_note`: what was built, the deliverable path(s), and a one-line confirmation that each criterion is met. Then report DONE.",
+      "suggestedRole": "developer",
+      "terminal": true
+    }
+  ],
+  "version": "1.0.1",
+  "releasedAt": "2026-08-14T00:00:00Z"
+}

package/data/craftbook-templates/re/receipt-ocr-ledger/versions/1.0.1/test.json

@@ -0,0 +1,104 @@
+{
+  "schemaVersion": 1,
+  "title": "Receipts to Expense Ledger smoke eval",
+  "objective": "Self-contained smoke eval for the Receipts to Expense Ledger craftbook using the data generic harness.",
+  "tags": [
+    "data"
+  ],
+  "prompt": "I dropped our numbers in source/records.csv. Can you look at the data, analyze it, and put togehter some results in analysis.md?",
+  "setup": {
+    "projectName": "Receipts to Expense Ledger Eval",
+    "about": "Self-contained eval project for receipt-ocr-ledger. Seeded inputs are under workspace/source or workspace/fixtures; final deliverable is workspace/analysis.md.",
+    "missionObjectives": "Use the Receipts to Expense Ledger craftbook/template, read the seeded local fixtures, and write analysis.md without network calls, real credentials, or live services.",
+    "files": [
+      {
+        "path": "source/brief.md",
+        "content": "# Receipts to Expense Ledger Eval Brief\n\nClient: Boreal Desk, a home-office accessories company.\nAudience: operations leads who need an artifact they can use this week.\n\nFixed source facts for grounding:\n- The returns desk pilot covered 18 SKUs.\n- Median first response improved from 18 hours to 6 hours.\n- Preventable refund leakage fell from 14.2% to 8.9%.\n- The top unresolved complaint is status silence after photo submission.\n- Required next actions are automated status emails, barcode-exception training, and a weekly Finance exception export.\n\nUse these facts when the task asks for prose, analysis, copy, UI content, or test data. Do not use live web services, real credentials, or current outside data.\n\nCraftbook under test: receipt-ocr-ledger - Receipts to Expense Ledger.\n"
+      },
+      {
+        "path": "source/records.csv",
+        "content": "customer,region,orders,revenue_usd,churn_risk\nAster,North,12,1440,low\nBoreal,South,8,720,medium\nCedar,West,15,2100,high\nDune,North,5,500,low\n"
+      }
+    ],
+    "worker": {
+      "name": "Jules",
+      "role": "Data Analyst"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "analysis.md is a seeded-data analysis with deterministic computed facts.",
+    "deliverables": [
+      {
+        "path": "analysis.md",
+        "kind": "markdown-report",
+        "minBytes": 900,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "analysis.md",
+            "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "analysis.md",
+            "pattern": "40\\b",
+            "flags": "i",
+            "label": "include total orders of 40"
+          },
+          {
+            "kind": "contains",
+            "file": "analysis.md",
+            "pattern": "\\$?4,?760\\b",
+            "flags": "i",
+            "label": "include total revenue of 4760"
+          },
+          {
+            "kind": "contains",
+            "file": "analysis.md",
+            "pattern": "Cedar",
+            "flags": "i",
+            "label": "identify Cedar as top revenue and high risk"
+          },
+          {
+            "kind": "contains",
+            "file": "analysis.md",
+            "pattern": "high",
+            "flags": "i",
+            "label": "include churn-risk finding"
+          }
+        ]
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "analysis.md",
+      "kind": "markdown"
+    },
+    "axes": [
+      {
+        "name": "accuracy",
+        "description": "Computed figures are correct against the seeded records."
+      },
+      {
+        "name": "grounding",
+        "description": "Every claim traces to the seeded data — nothing invented."
+      },
+      {
+        "name": "structure",
+        "description": "Tables and sections make the analysis checkable at a glance."
+      },
+      {
+        "name": "actionability",
+        "description": "Recommendations follow from the findings and are concretely doable."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "seeded data reading",
+    "computed facts",
+    "recommendation grounding"
+  ]
+}

package/data/craftbook-templates/re/recipe-capture/versions/1.0.1/craftbook.json

@@ -0,0 +1,140 @@
+{
+  "id": "recipe-capture",
+  "name": "Capture a Recipe Card",
+  "description": "Rescue a handwritten recipe card without sanding off its soul: transcribe the original faithfully — spelling quirks, margin notes, and all — standardize quantities in a separate block alongside (never instead of) the original wording, and pin the provenance note: whose card, whose kitchen, what they always changed. Locks the capture rules FIRST, then captures each card into the book, then logs what needs a test-cook and what to ask the family. Use for capturing recipe cards, 'get oma's cards into the book', preserving family recipes, and recipe transcription.\n\nA gallery craftbook generated from an archetype spec. It runs\n`phase → (per-phase gate) → … → evaluate → (loop) → finish`. Each build\nphase that produces a checkable artifact is followed by a **runtime\ngate-checkpoint** — the runtime verifies the artifact and routes with no\nmodel turn, looping back to redo the phase on a miss. The final `evaluate`\nstep holds a static deliverable gate plus a reviewer QA pass. What it adds\nover the generic `build-loop`: a specialist role per phase, a\ndomain-correct ordering, and a concrete per-phase quality bar.\n\nDeliverables marked \"artifact\" land in the project's artifacts drawer (`write_artifact` / `read_artifact`), not the shipped workspace — review output is not product source.\n\nPhases:\n\n1. Scope the capture (kitchen-master) — card intake notes read, capture rules locked → gated on artifact `notes/scope.md` (markdown-notes)\n2. Capture the cards (archivist) — one faithful recipe file per card, recorded in the book → gated on artifact `notes/capture.md` (markdown-notes)\n3. Write the capture log (copywriter) — what went in, what needs a test-cook, questions for the family → gated on artifact `report.md` (markdown-report)\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "scope",
+  "triggers": [
+    "capture a recipe card",
+    "get this recipe into the book",
+    "transcribe oma's card",
+    "add a family recipe",
+    "preserve this recipe"
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the capture",
+      "description": "card intake notes read, capture rules locked",
+      "prompt": "Define the capture before transcribing a word. Step 1: read the card intake notes waiting in inbox/ and the recipe book's store (recipes.json) — what is already in the book and how entries are shaped. Step 2: lock the capture rules — the original wording is preserved exactly, spelling quirks, margin notes and all; every recipe carries its provenance (whose card, whose kitchen, what they always changed); the standardized ingredients-and-steps block sits alongside the original text, clearly separated, never replacing it; anything unreadable becomes a question, not a guess. Step 3: write an acceptance-criteria checklist ('every card captured as its own recipe file under recipes/', 'original text verbatim with margin notes kept and marked', 'provenance line on every recipe', 'standardized block separate from the original', 'each captured recipe recorded in the book's store'). Call write_task_note with the card count + rules + checklist and write notes/scope.md.\n\nThe deliverable `notes/scope.md` lands in the project's artifacts drawer — write it with `write_artifact` and read it back with `read_artifact`; the shipped workspace stays untouched.",
+      "suggestedRole": "kitchen-master",
+      "advanceWhen": {
+        "file": "notes/scope.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "notes/scope.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "notes/scope.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "scope",
+        "maxAttempts": 3
+      },
+      "next": "capture"
+    },
+    {
+      "id": "capture",
+      "name": "Capture the cards",
+      "description": "one faithful recipe file per card, recorded in the book",
+      "prompt": "Capture each card against the locked rules. Step 1: for every card note in inbox/, write a recipe file under recipes/ — a title, the provenance line, the original text transcribed faithfully (margin notes included and marked as margin notes), and then a clearly separated standardized block with an Ingredients list and numbered steps. Step 2: record each captured recipe in the book's store through the project's recipe capabilities — title, provenance, and the file it lives in. Step 3: where the card is ambiguous or unreadable, keep the original as written and add the question inline rather than smoothing it over. Step 4: write a per-card capture log to notes/capture.md — what was captured, what was preserved as-is, what needs asking. Call write_task_note with the captured count.\n\nThe deliverable `notes/capture.md` lands in the project's artifacts drawer — write it with `write_artifact` and read it back with `read_artifact`; the shipped workspace stays untouched.",
+      "suggestedRole": "archivist",
+      "advanceWhen": {
+        "file": "notes/capture.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "notes/capture.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "notes/capture.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "capture",
+        "maxAttempts": 3
+      },
+      "next": "report"
+    },
+    {
+      "id": "report",
+      "name": "Write the capture log",
+      "description": "what went in, what needs a test-cook, questions for the family",
+      "prompt": "Write the capture log for the family from your notes. Step 1: list what went into the book this session — each recipe with whose card it was. Step 2: name what needs a test-cook before it counts as verified, and why (an ambiguous quantity, a step that assumes the cook's hands already knew). Step 3: list the questions for the family — margin notes worth explaining, names and dates worth pinning down — so the next phone call captures them. Step 4: keep it warm; this is family history in food form. Write report.md and call write_task_note with the captured count and the top question.\n\nThe deliverable `report.md` lands in the project's artifacts drawer — write it with `write_artifact` and read it back with `read_artifact`; the shipped workspace stays untouched.",
+      "suggestedRole": "copywriter",
+      "advanceWhen": {
+        "file": "report.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "report.md",
+            "bytes": 800,
+            "artifact": true
+          },
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+            "flags": "i",
+            "label": "at least one markdown heading",
+            "artifact": true
+          }
+        ],
+        "onReject": "report",
+        "maxAttempts": 4
+      },
+      "next": "evaluate"
+    },
+    {
+      "id": "evaluate",
+      "name": "Evaluate",
+      "description": "Grade the deliverable against every acceptance criterion. All pass → finish; any fail → loop back and fix the gap.",
+      "prompt": "Open report.md, notes/capture.md, and the recipe files under recipes/ and verify every criterion from notes/scope.md: every inbox card became its own recipe file, the original wording is verbatim (spot-check phrases against the card notes — no silent corrections), margin notes survived and are marked as such, every recipe carries a provenance line, the standardized block is present and separate from the original, and each captured recipe is recorded in the book's store. Write PASS/FAIL per criterion; on any failure, name the gap and loop back to capture.\n\nThe deliverable lives in the project's artifacts drawer — open `report.md` with `read_artifact`, not `read_file`.\n\nThen route — this is the whole point of the loop:\n\n- **Every criterion PASSES →** call `advance_task_step({ ref, stepId: \"evaluate\", next: \"finish\" })`.\n- **Any criterion FAILS →** write the specific gaps to notes, then call `advance_task_step({ ref, stepId: \"evaluate\", next: \"capture\" })` to loop back. The builder fixes exactly those gaps.\n\nNever route to `finish` while any criterion is unmet. The build phase's completion gate already blocked a grossly-incomplete deliverable; your job is the judgment an automated check cannot make (does it actually work, read well, look right). After ~3 unproductive loops, stop and report DONE_WITH_CONCERNS so the user can step in.",
+      "suggestedRole": "reviewer",
+      "consumes": [
+        {
+          "file": "report.md",
+          "artifact": true
+        }
+      ],
+      "next": "capture"
+    },
+    {
+      "id": "finish",
+      "name": "Finish",
+      "description": "All acceptance criteria met. Stamp a short summary and report DONE.",
+      "prompt": "Every acceptance criterion passed. Write a one-paragraph DONE summary to task notes via `write_task_note`: what was built, the deliverable path(s), and a one-line confirmation that each criterion is met. Then report DONE.",
+      "suggestedRole": "developer",
+      "terminal": true
+    }
+  ],
+  "version": "1.0.1",
+  "releasedAt": "2026-08-14T00:00:00Z"
+}

package/data/craftbook-templates/re/recipe-capture/versions/1.0.1/test.json

@@ -0,0 +1,128 @@
+{
+  "schemaVersion": 1,
+  "title": "Capture a Recipe Card smoke eval",
+  "objective": "Task-specific eval for the Capture a Recipe Card craftbook: two pre-extracted card scans become faithful recipe files with provenance and a separate standardized block, recorded in the book's store.",
+  "tags": [
+    "corpus"
+  ],
+  "prompt": "scanned two of omas cards — the transcriptions are in inbox/card-1.txt and inbox/card-2.txt. can you get them into the book propperly?",
+  "setup": {
+    "projectName": "Family Recipe Book — Card Capture Eval",
+    "about": "Self-contained eval project for recipe-capture. The card photos have already been pre-extracted into plain-text scan notes under inbox/ (the text as written, plus margin notes). Captured recipes go under recipes/ and are recorded in recipes.json; the capture log goes to report.md.",
+    "missionObjectives": "Use the Capture a Recipe Card craftbook/template, work only from the seeded card notes, and finish with the recipe files, an updated recipes.json, and report.md — no network calls, real credentials, or live services.",
+    "files": [
+      {
+        "path": "inbox/card-1.txt",
+        "content": "CARD SCAN NOTE (pre-extracted from photo card-1.jpg)\n\nTitle on card: Appelkoek\nHandwriting: Oma Riet's, blue ink, grease spot lower right corner\n\nText as written:\n'2 kopjes flour, 150 g butter (cold!), 3/4 kopje brown sugar, 2 apples - the sour ones, 1 tsp cinnamon, pinch of salt. Rub butter into flour. Sugar, then apples in thin slices. Oven: hot, until it smells right, about 40 min.'\n\nMargin note, pencil, different hand: 'she always used twice the butter'\n"
+      },
+      {
+        "path": "inbox/card-2.txt",
+        "content": "CARD SCAN NOTE (pre-extracted from photo card-2.jpg)\n\nTitle on card: Speculaas\nHandwriting: Oma Riet's, black ink, top corner torn\n\nText as written:\n'250 g flour, 125 g cold butter, 100 g dark brown sugar, 2 tbsp speculaaskruiden, 3 tbsp milk, pinch salt. Knead, rest overnight (cold). Roll thin. Oven 160 for 20-25 min.'\n\nMargin note, same hand: 'St Nicolaas - double batch'\n"
+      },
+      {
+        "path": "recipes.json",
+        "content": "[]\n"
+      }
+    ],
+    "worker": {
+      "name": "Bep",
+      "role": "Archivist"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "Both cards become recipe files under recipes/ with provenance kept beside the food, the store records each capture, and the log flags what needs a test-cook.",
+    "deliverables": [
+      {
+        "path": "report.md",
+        "kind": "markdown-report",
+        "minBytes": 500,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "Oma|Riet",
+            "label": "provenance carried into the capture log"
+          },
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "\\?",
+            "label": "questions for the family are actually asked"
+          },
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "test[- ]?cook|try (it|the)|verify",
+            "flags": "i",
+            "label": "test-cook needs named"
+          }
+        ]
+      }
+    ],
+    "checks": [
+      {
+        "kind": "fileCount",
+        "ext": [
+          "md"
+        ],
+        "min": 2,
+        "dir": "recipes"
+      },
+      {
+        "kind": "recordSchema",
+        "file": "recipes.json",
+        "fields": [
+          {
+            "name": "title",
+            "type": "nonempty"
+          },
+          {
+            "name": "provenance",
+            "type": "nonempty"
+          },
+          {
+            "name": "file",
+            "type": "nonempty"
+          }
+        ],
+        "minRows": 2
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "report.md",
+      "kind": "markdown"
+    },
+    "axes": [
+      {
+        "name": "provenance",
+        "description": "Every recipe names whose card it was, and the margin notes survive, marked as margin notes."
+      },
+      {
+        "name": "fidelity",
+        "description": "Original wording and quantities are transcribed exactly — no silent corrections or smoothing."
+      },
+      {
+        "name": "standardization",
+        "description": "A clear standardized ingredients-and-steps block sits alongside, never replacing, the original."
+      },
+      {
+        "name": "warmth",
+        "description": "The capture log reads like family history in food form, not a data-entry receipt."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "verbatim transcription",
+    "provenance preservation",
+    "original-versus-standardized separation"
+  ]
+}

package/data/craftbook-templates/re/record-a-relative/versions/1.0.1/craftbook.json

@@ -0,0 +1,115 @@
+{
+  "id": "record-a-relative",
+  "name": "Record a Relative",
+  "description": "Bank an elder's interview while the telling is fresh: file the transcript, pull the people, places, and dates into the family record with their source, and write the follow-up questions — because the questions you didn't ask are the ones that vanish. Locks the extraction rules FIRST (every fact carries its quote, uncertain stays uncertain), then files the transcript, then updates the tree and surfaces the conflicts. Use for filing a family interview, recording a relative's stories, pulling facts into the tree, and 'we interviewed grandma'.\n\nA gallery craftbook generated from an archetype spec. It runs\n`phase → (per-phase gate) → … → evaluate → (loop) → finish`. Each build\nphase that produces a checkable artifact is followed by a **runtime\ngate-checkpoint** — the runtime verifies the artifact and routes with no\nmodel turn, looping back to redo the phase on a miss. The final `evaluate`\nstep holds a static deliverable gate plus a reviewer QA pass. What it adds\nover the generic `build-loop`: a specialist role per phase, a\ndomain-correct ordering, and a concrete per-phase quality bar.\n\nDeliverables marked \"artifact\" land in the project's artifacts drawer (`write_artifact` / `read_artifact`), not the shipped workspace — review output is not product source.\n\nPhases:\n\n1. Scope the extraction (genealogist) — target branch, extraction rules, fact-sourcing checklist → gated on artifact `notes/scope.md` (markdown-notes)\n2. File the transcript (archivist) — speaker-labeled transcript with a header, under interviews/\n3. Extract the facts (genealogist) — facts with quotes into the tree, conflicts surfaced, follow-ups → gated on artifact `report.md` (markdown-report)\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "scope",
+  "triggers": [
+    "file the interview with oma",
+    "we interviewed grandma",
+    "pull the family facts from the transcript",
+    "record a relative",
+    "bank the elder interview"
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the extraction",
+      "description": "target branch, extraction rules, fact-sourcing checklist",
+      "prompt": "Aim the interview at the tree before extracting a single fact. Step 1: read tree.json from the workspace — the people, the branches, the facts already recorded and the ones marked uncertain. Step 2: identify the relative who was interviewed and which branch facts this interview can confirm, correct, or newly supply. Step 3: lock the extraction rules — every fact carries the teller's quote or the transcript line behind it; a fact that conflicts with the tree is surfaced as a conflict, never silently overwritten; uncertain stays uncertain ('she thought it was 1954' is recorded as thought, not fact). Step 4: write the acceptance-criteria checklist from those rules, plus 'the transcript is filed under interviews/' and 'follow-up questions written for the gaps the interview opened'. Call write_task_note with the relative + target branch + checklist and write notes/scope.md.\n\nThe deliverable `notes/scope.md` lands in the project's artifacts drawer — write it with `write_artifact` and read it back with `read_artifact`; the shipped workspace stays untouched.",
+      "suggestedRole": "genealogist",
+      "advanceWhen": {
+        "file": "notes/scope.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "notes/scope.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "notes/scope.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "scope",
+        "maxAttempts": 3
+      },
+      "next": "file"
+    },
+    {
+      "id": "file",
+      "name": "File the transcript",
+      "description": "speaker-labeled transcript with a header, under interviews/",
+      "prompt": "Get the interview on file where the family can find it in fifty years. Step 1: if a transcript file was provided, start from it; otherwise produce one from the recording through the project's transcription capabilities. Step 2: label the speakers and add a header — who was interviewed, by whom, when and where. Step 3: save it in the interviews/ folder named for the relative and the date (for example interviews/oma-2026-07.md). Keep the telling verbatim — the phrasing is part of the record. Step 4: call write_task_note with the path.",
+      "suggestedRole": "archivist",
+      "next": "extract"
+    },
+    {
+      "id": "extract",
+      "name": "Extract the facts",
+      "description": "facts with quotes into the tree, conflicts surfaced, follow-ups",
+      "prompt": "Pull the facts into the record with their sources. Step 1: walk the transcript and list every person, place, date, and event it attests — each with the quote behind it. Step 2: compare against tree.json: which facts confirm the tree, which are new, and which conflict with what is recorded — update the tree through the project's family-record capabilities for confirmations and additions, and surface every conflict for the owner instead of picking a winner. Step 3: write report.md: the facts captured (each with its quote), the conflicts with the existing tree stated plainly, and the follow-up questions to ask while asking is still possible. Step 4: call write_task_note with the fact count, the conflict count, and the top follow-up question.\n\nThe deliverable `report.md` lands in the project's artifacts drawer — write it with `write_artifact` and read it back with `read_artifact`; the shipped workspace stays untouched.",
+      "suggestedRole": "genealogist",
+      "advanceWhen": {
+        "file": "report.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "report.md",
+            "bytes": 1200,
+            "artifact": true
+          },
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+            "flags": "i",
+            "label": "at least one markdown heading",
+            "artifact": true
+          }
+        ],
+        "onReject": "extract",
+        "maxAttempts": 4
+      },
+      "next": "evaluate"
+    },
+    {
+      "id": "evaluate",
+      "name": "Evaluate",
+      "description": "Grade the deliverable against every acceptance criterion. All pass → finish; any fail → loop back and fix the gap.",
+      "prompt": "Open report.md beside the interview transcript and tree.json and verify every criterion from notes/scope.md: every fact in the report carries a quote that actually appears in the transcript (spot-check five — a quote that isn't there is fabrication), every date and name in the report exists in the transcript or the tree, conflicts with the tree are surfaced as conflicts rather than silently resolved, uncertain memories are recorded as uncertain, and the follow-up questions are real questions aimed at real gaps. Write PASS/FAIL per criterion; on any failure, name the gap and loop back to extract.\n\nThe deliverable lives in the project's artifacts drawer — open `report.md` with `read_artifact`, not `read_file`.\n\nThen route — this is the whole point of the loop:\n\n- **Every criterion PASSES →** call `advance_task_step({ ref, stepId: \"evaluate\", next: \"finish\" })`.\n- **Any criterion FAILS →** write the specific gaps to notes, then call `advance_task_step({ ref, stepId: \"evaluate\", next: \"extract\" })` to loop back. The builder fixes exactly those gaps.\n\nNever route to `finish` while any criterion is unmet. The build phase's completion gate already blocked a grossly-incomplete deliverable; your job is the judgment an automated check cannot make (does it actually work, read well, look right). After ~3 unproductive loops, stop and report DONE_WITH_CONCERNS so the user can step in.",
+      "suggestedRole": "reviewer",
+      "consumes": [
+        {
+          "file": "report.md",
+          "artifact": true
+        }
+      ],
+      "next": "extract"
+    },
+    {
+      "id": "finish",
+      "name": "Finish",
+      "description": "All acceptance criteria met. Stamp a short summary and report DONE.",
+      "prompt": "Every acceptance criterion passed. Write a one-paragraph DONE summary to task notes via `write_task_note`: what was built, the deliverable path(s), and a one-line confirmation that each criterion is met. Then report DONE.",
+      "suggestedRole": "developer",
+      "terminal": true
+    }
+  ],
+  "version": "1.0.1",
+  "releasedAt": "2026-08-14T00:00:00Z"
+}