@bendyline/gilde 0.1.26 → 0.1.28

package/data/craftbook-templates/im/image-set-index/versions/1.2.1/craftbook.json

@@ -0,0 +1,179 @@
+{
+  "id": "image-set-index",
+  "name": "Index & Describe an Image Set",
+  "description": "Given a folder of images, produce a structured index that describes each one (caption, tags, notable content) in a consistent schema, then validates coverage and consistency. For cataloguing, search, or alt-text generation over an image collection.\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 index (planner) — fields per image + output schema + criteria → gated on artifact `image-index/schema.md` (markdown-notes)\n2. Describe each image (developer) — read each image, write structured descriptions → gated on `work/image-descriptions.json` (json)\n3. Assemble the index (developer) — write the index file in the chosen format → gated on `index.json` (json)\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "scope",
+  "triggers": [
+    "index images",
+    "describe images",
+    "caption a folder",
+    "image catalog"
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the index",
+      "description": "fields per image + output schema + criteria",
+      "prompt": "Decide the index schema before describing anything. The final output is workspace `index.json` with an `images` array; define fields per image (filename, caption, tags, dominantColors, orientation, containsText, and qualityFlags), controlled vocabulary rules, and an **acceptance-criteria checklist** (\"every source image has exactly one record\", \"captions are 1-2 sentences\", \"tags use a consistent vocabulary\", \"the JSON parses\"). Save the schema + checklist to artifact `image-index/schema.md` with `write_artifact`; note the path in task notes.",
+      "suggestedRole": "planner",
+      "advanceWhen": {
+        "file": "image-index/schema.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "image-index/schema.md",
+            "bytes": 500,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "image-index/schema.md",
+            "sniff": "nonempty",
+            "artifact": true
+          },
+          {
+            "kind": "contains",
+            "file": "image-index/schema.md",
+            "pattern": "filename[\\s\\S]*caption[\\s\\S]*tags",
+            "flags": "i",
+            "label": "core schema fields",
+            "artifact": true
+          },
+          {
+            "kind": "contains",
+            "file": "image-index/schema.md",
+            "pattern": "every|coverage|exactly one",
+            "flags": "i",
+            "label": "coverage criterion",
+            "artifact": true
+          }
+        ],
+        "onReject": "scope",
+        "maxAttempts": 3
+      },
+      "next": "describe"
+    },
+    {
+      "id": "describe",
+      "name": "Describe each image",
+      "description": "read each image, write structured descriptions",
+      "prompt": "Read artifact `image-index/schema.md` with `read_artifact`, then list the source image folder with workspace tools. For each image, use the available image-reading or description capability to populate the schema. If the user supplied an authoritative metadata sidecar because image binaries or vision are unavailable, read it with `read_file`, preserve only its facts, and record that limitation. Keep vocabulary consistent and do not skip or invent images. Stage the complete per-image array as valid workspace JSON at `work/image-descriptions.json` with `write_file`.",
+      "suggestedRole": "developer",
+      "consumes": [
+        {
+          "file": "image-index/schema.md",
+          "artifact": true
+        }
+      ],
+      "advanceWhen": {
+        "file": "work/image-descriptions.json",
+        "minBytes": 1,
+        "sniff": "json-valid"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "work/image-descriptions.json",
+            "bytes": 300
+          },
+          {
+            "kind": "contains",
+            "file": "work/image-descriptions.json",
+            "pattern": "\"filename\"[\\s\\S]*\"caption\"[\\s\\S]*\"tags\"",
+            "flags": "i",
+            "label": "per-image fields"
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkJsonValid",
+            "scope": "standard",
+            "inputs": {
+              "file": "work/image-descriptions.json"
+            }
+          }
+        ],
+        "onReject": "describe",
+        "maxAttempts": 3
+      },
+      "next": "assemble"
+    },
+    {
+      "id": "assemble",
+      "name": "Assemble the index",
+      "description": "write the index file in the chosen format",
+      "prompt": "Read workspace `work/image-descriptions.json` with `read_file`, reconcile it against the complete source-folder or sidecar listing, and write the final JSON object to workspace `index.json` with `write_file`. Ensure the `images` array has exactly one record per source filename, every required field is present, and vocabulary is consistent. On a loop-back, fix only the named gaps (missing/extra records, malformed JSON, inconsistent tags). `write_task_note` the index path and an explicit coverage count (records vs source images).",
+      "suggestedRole": "developer",
+      "consumes": [
+        {
+          "file": "work/image-descriptions.json"
+        }
+      ],
+      "advanceWhen": {
+        "file": "index.json",
+        "minBytes": 1,
+        "sniff": "json-valid"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "index.json",
+            "bytes": 500
+          },
+          {
+            "kind": "contains",
+            "file": "index.json",
+            "pattern": "\"images\"\\s*:",
+            "flags": "i",
+            "label": "images array"
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkJsonValid",
+            "scope": "standard",
+            "inputs": {
+              "file": "index.json"
+            }
+          }
+        ],
+        "onReject": "assemble",
+        "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": "Read workspace `index.json`, `work/image-descriptions.json`, and the source-folder listing with workspace tools, plus artifact `image-index/schema.md` with `read_artifact`. Check coverage and consistency: does every source image have exactly one record, do all required fields exist, do captions/tags follow the schema and a consistent vocabulary, and does the file parse? Spot-check descriptions against actual images when available. Write PASS/FAIL per criterion.\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: \"assemble\" })` 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": "index.json"
+        }
+      ],
+      "next": "assemble"
+    },
+    {
+      "id": "finish",
+      "name": "Finish",
+      "description": "All acceptance criteria met. Stamp a short summary and report DONE.",
+      "prompt": "Every criterion passed. Write a DONE summary: index path, format, image count, and a one-line note that coverage is complete and the schema is consistent.",
+      "suggestedRole": "developer",
+      "terminal": true
+    }
+  ],
+  "version": "1.2.1",
+  "releasedAt": "2026-08-14T00:00:00Z"
+}

package/data/craftbook-templates/im/image-set-index/versions/1.2.1/test.json

@@ -0,0 +1,180 @@
+{
+  "schemaVersion": 1,
+  "title": "Deterministic image-index workflow",
+  "objective": "Run the Index & Describe an Image Set craftbook against deterministic metadata, verifying schema-first staging, exact coverage, valid JSON, and no invented images.",
+  "tags": [
+    "media",
+    "json",
+    "workflow"
+  ],
+  "prompt": "Use the Index & Describe an Image Set craftbook. This text-only local-model eval supplies authoritative vision metadata in workspace `images/descriptions.csv`; read it as the sidecar for the four named images. Define the schema first, stage valid JSON in workspace `work/image-descriptions.json`, and write final workspace `index.json` as an object with an `images` array containing exactly one record per source filename. Each record must include filename, caption, tags, dominantColors, orientation, containsText, and qualityFlags. Use only the sidecar facts and report coverage as 4/4.",
+  "setup": {
+    "projectName": "Image Set Index Eval",
+    "about": "Self-contained workflow eval for a non-vision local model. The seeded descriptions.csv is authoritative image metadata; the schema belongs in artifacts, while staged and final JSON belong in the workspace.",
+    "missionObjectives": "Index all four seeded images into valid JSON with exact filenames, complete required fields, controlled tags, consistent arrays/booleans, and no invented images.",
+    "files": [
+      {
+        "path": "images/descriptions.csv",
+        "content": "filename,caption,tags,dominantColors,orientation,containsText,qualityFlags\nmarket-stand.jpg,Outdoor produce stand with crates of greens,produce;outdoor;market,green;wood;white,landscape,false,usable\npacking-sheet.png,Spreadsheet screenshot showing Thursday packing counts,spreadsheet;packing;counts,white;blue;gray,landscape,true,text-heavy\nvolunteer-badge.jpg,Close-up volunteer badge on a red lanyard,volunteer;badge;people,red;white;black,portrait,true,cropped\npickup-line.jpg,Members waiting near pickup tables at dusk,pickup;members;queue,navy;yellow;gray,landscape,false,low-light\n"
+      },
+      {
+        "path": "tests/verify-index.mjs",
+        "content": "import { readFileSync } from 'node:fs';\n\nconst expected = ['market-stand.jpg', 'packing-sheet.png', 'pickup-line.jpg', 'volunteer-badge.jpg'];\nconst required = ['filename', 'caption', 'tags', 'dominantColors', 'orientation', 'containsText', 'qualityFlags'];\nconst doc = JSON.parse(readFileSync('index.json', 'utf8'));\nif (!Array.isArray(doc.images)) throw new Error('images must be an array');\nif (doc.images.length !== expected.length) throw new Error(`expected 4 records, got ${doc.images.length}`);\nconst names = doc.images.map((row) => row.filename).sort();\nif (JSON.stringify(names) !== JSON.stringify(expected)) throw new Error(`filename coverage mismatch: ${names.join(', ')}`);\nfor (const row of doc.images) {\n  for (const field of required) if (!(field in row)) throw new Error(`${row.filename}: missing ${field}`);\n  if (typeof row.caption !== 'string' || row.caption.trim().length < 12) throw new Error(`${row.filename}: caption too short`);\n  if (!Array.isArray(row.tags) || row.tags.length < 2) throw new Error(`${row.filename}: tags must be an array`);\n  if (!Array.isArray(row.dominantColors) || row.dominantColors.length < 2) throw new Error(`${row.filename}: dominantColors must be an array`);\n  if (typeof row.containsText !== 'boolean') throw new Error(`${row.filename}: containsText must be boolean`);\n  if (!Array.isArray(row.qualityFlags)) throw new Error(`${row.filename}: qualityFlags must be an array`);\n}\nconsole.log('INDEX_OK 4/4');\n",
+        "surface": "harness"
+      }
+    ],
+    "worker": {
+      "name": "Iris",
+      "role": "Analyst"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "A craftbook task records a schema artifact, stages valid per-image JSON, and ships index.json with exact 4/4 fixture coverage.",
+    "deliverables": [
+      {
+        "path": "index.json",
+        "kind": "json",
+        "minBytes": 900,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "index.json",
+            "pattern": "market-stand\\.jpg"
+          },
+          {
+            "kind": "contains",
+            "file": "index.json",
+            "pattern": "packing-sheet\\.png"
+          },
+          {
+            "kind": "contains",
+            "file": "index.json",
+            "pattern": "volunteer-badge\\.jpg"
+          },
+          {
+            "kind": "contains",
+            "file": "index.json",
+            "pattern": "pickup-line\\.jpg"
+          },
+          {
+            "kind": "contains",
+            "file": "index.json",
+            "pattern": "dominantColors[\\s\\S]*containsText[\\s\\S]*qualityFlags"
+          },
+          {
+            "kind": "notContains",
+            "file": "index.json",
+            "pattern": "hero\\.png|logo\\.png|unknown",
+            "flags": "i"
+          }
+        ]
+      },
+      {
+        "path": "work/image-descriptions.json",
+        "kind": "json",
+        "minBytes": 700,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "work/image-descriptions.json",
+            "pattern": "filename[\\s\\S]*caption[\\s\\S]*tags",
+            "flags": "i"
+          }
+        ]
+      }
+    ],
+    "checks": [
+      {
+        "kind": "minBytes",
+        "file": "image-index/schema.md",
+        "bytes": 500,
+        "artifact": true
+      },
+      {
+        "kind": "contains",
+        "file": "image-index/schema.md",
+        "pattern": "filename[\\s\\S]*caption[\\s\\S]*tags[\\s\\S]*dominantColors",
+        "flags": "i",
+        "artifact": true
+      },
+      {
+        "kind": "nodeScriptPasses",
+        "script": "tests/verify-index.mjs",
+        "requiredOutput": [
+          {
+            "pattern": "INDEX_OK 4/4",
+            "label": "exact image coverage"
+          }
+        ]
+      }
+    ],
+    "taskNotes": {
+      "minBytes": 160,
+      "checks": [
+        {
+          "kind": "contains",
+          "file": "task-notes.md",
+          "pattern": "4/4|four of four|coverage.*4",
+          "flags": "i"
+        },
+        {
+          "kind": "contains",
+          "file": "task-notes.md",
+          "pattern": "schema\\.md",
+          "flags": "i"
+        },
+        {
+          "kind": "contains",
+          "file": "task-notes.md",
+          "pattern": "image-descriptions\\.json",
+          "flags": "i"
+        },
+        {
+          "kind": "contains",
+          "file": "task-notes.md",
+          "pattern": "index\\.json",
+          "flags": "i"
+        }
+      ],
+      "requireCraftbookTask": true
+    },
+    "taskGraph": {
+      "requireCraftbookTask": true,
+      "requireTerminalStep": true
+    },
+    "unchangedFixtures": [
+      "images/descriptions.csv"
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "index.json",
+      "kind": "json"
+    },
+    "axes": [
+      {
+        "name": "schema consistency",
+        "description": "Every record uses the same types and required fields, with arrays and booleans represented consistently."
+      },
+      {
+        "name": "grounding",
+        "description": "Captions, tags, colors, orientation, text flags, and quality flags preserve only the authoritative sidecar facts."
+      },
+      {
+        "name": "coverage",
+        "description": "Every source filename appears exactly once, with no missing or invented images."
+      },
+      {
+        "name": "workflow evidence",
+        "description": "The schema artifact and staged JSON demonstrate a schema-first, reviewable indexing workflow."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "craftbook attribution",
+    "schema-first indexing",
+    "executable exact-coverage check",
+    "text-only vision surrogate"
+  ]
+}

package/data/craftbook-templates/in/inbox-triage/versions/1.0.1/craftbook.json

@@ -0,0 +1,140 @@
+{
+  "id": "inbox-triage",
+  "name": "Inbox Triage & Reply Drafts",
+  "description": "Triage a batch of incoming emails or messages into priority buckets and draft replies for the ones that need them. Locks the triage rules and bucket taxonomy FIRST (urgent / needs-reply / FYI / archive, plus the criteria for each and a reply policy), then classifies every message deterministically against those rules, then a copywriter drafts on-voice replies only for the messages flagged needs-reply. The rules-before-triage ordering is what stops a small model from inventing ad-hoc categories and gives the reviewer something to grade. Use for inbox zero, support-queue triage, email sorting, message prioritization, and auto-drafting responses.\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. Rules scope (planner) — lock the bucket taxonomy + triage rules + reply policy → gated on artifact `notes/rules-scope.md` (markdown-notes)\n2. Triage (developer) — classify every message against the locked rules → gated on artifact `notes/triage.md` (markdown-notes)\n3. Draft replies (copywriter) — write on-voice replies for the flagged messages → gated on `drafts.md` (markdown-doc)\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "rules-scope",
+  "triggers": [
+    "triage my inbox",
+    "sort these emails",
+    "draft replies",
+    "inbox zero",
+    "prioritize my messages"
+  ],
+  "steps": [
+    {
+      "id": "rules-scope",
+      "name": "Rules scope",
+      "description": "lock the bucket taxonomy + triage rules + reply policy",
+      "prompt": "Define the triage system BEFORE touching any message. (1) Lock a small bucket taxonomy — exactly four: Urgent (needs action today), Needs-reply (a response is expected but not urgent), FYI (read-and-keep, no reply), Archive (no action). (2) Write 1-2 plain-language rules per bucket so classification is reproducible (e.g. 'Urgent = sender is a customer AND message contains a deadline within 48h OR the word \"blocked\"'). (3) Set a reply policy: which buckets get drafted (Urgent + Needs-reply), the target length (2-4 sentences), the voice, and any auto-close phrasing. (4) Decide the output schema: a markdown table with columns sender, subject, bucket, one-line reason, reply-needed (Y/N). Good looks like rules a different person could apply and reach the same buckets. Write an acceptance-criteria checklist ('every message lands in exactly one bucket', 'every Urgent/Needs-reply item has a drafted reply', 'no message is dropped', 'each classification cites the rule that fired') and the rules/schema to notes/rules-scope.md via write_task_note AND to the produces path.\n\nThe deliverable `notes/rules-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/rules-scope.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "notes/rules-scope.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "notes/rules-scope.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "rules-scope",
+        "maxAttempts": 3
+      },
+      "next": "triage"
+    },
+    {
+      "id": "triage",
+      "name": "Triage",
+      "description": "classify every message against the locked rules",
+      "prompt": "Read the message corpus (inbox export, pasted threads, or the connected mail tool). For EACH message, apply the locked rules and record: sender, subject/snippet, the assigned bucket, a one-line reason that names the rule that fired, and reply-needed Y/N. Process every message — do not sample or skip. Keep classification mechanical: when two rules could fire, the highest-severity bucket wins (Urgent > Needs-reply > FYI > Archive). Write the full classification table to notes/triage.md via write_task_note. Stage it incrementally so progress is observable, and end with a count line (N messages, M urgent, K needs-reply).\n\nThe deliverable `notes/triage.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": "developer",
+      "advanceWhen": {
+        "file": "notes/triage.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "notes/triage.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "notes/triage.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "triage",
+        "maxAttempts": 3
+      },
+      "next": "draft"
+    },
+    {
+      "id": "draft",
+      "name": "Draft replies",
+      "description": "write on-voice replies for the flagged messages",
+      "prompt": "Write a reply for EVERY message flagged reply-needed=Y in the triage table — and only those. Each draft: a clear subject (Re: …), a greeting, 2-4 sentences that directly answer or acknowledge the message and state the next step, and an on-voice sign-off matching the locked reply policy. Do not invent facts, commitments, or dates not present in the source thread; where information is missing, write a placeholder in [brackets] the user can fill. Assemble all drafts into a single drafts.md, one section per message keyed by sender + subject, with the original snippet quoted above each draft for context. On a loop-back, fix only the replies the reviewer flagged. Write the path and a count (drafts written vs replies needed) to notes via write_task_note.",
+      "suggestedRole": "copywriter",
+      "advanceWhen": {
+        "file": "drafts.md",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "drafts.md",
+            "bytes": 500
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkContains",
+            "scope": "standard",
+            "inputs": {
+              "file": "drafts.md",
+              "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+              "flags": "i"
+            }
+          }
+        ],
+        "onReject": "draft",
+        "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": "QA the triage and drafts against the locked criteria. (1) Open notes/triage.md and confirm every message in the corpus appears exactly once — count rows vs source messages; FAIL on any drop or duplicate. (2) Spot-check 3-4 classifications against the rules: does the cited rule actually fire for that message? (3) Open drafts.md and confirm there is a draft for every reply-needed=Y row and none for the others. (4) Read 2-3 drafts: do they answer the actual message, stay on-voice, invent no facts/dates, and bracket missing info rather than fabricating it? (5) Confirm bucket precedence was applied (no message double-bucketed). Write PASS/FAIL with the specific failing items per criterion.\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: \"draft\" })` 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": "drafts.md"
+        }
+      ],
+      "next": "draft"
+    },
+    {
+      "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/in/inbox-triage/versions/1.0.1/test.json

@@ -0,0 +1,104 @@
+{
+  "schemaVersion": 1,
+  "title": "Inbox Triage & Reply Drafts smoke eval",
+  "objective": "Self-contained smoke eval for the Inbox Triage & Reply Drafts 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": "Inbox Triage & Reply Drafts Eval",
+    "about": "Self-contained eval project for inbox-triage. Seeded inputs are under workspace/source or workspace/fixtures; final deliverable is workspace/analysis.md.",
+    "missionObjectives": "Use the Inbox Triage & Reply Drafts 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": "# Inbox Triage & Reply Drafts 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: inbox-triage - Inbox Triage & Reply Drafts.\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"
+  ]
+}