@bendyline/gilde 0.1.37 → 0.1.39

package/data/craftbook-templates/ch/changelog-writeup/versions/1.0.2/craftbook.json

@@ -0,0 +1,119 @@
+{
+  "id": "changelog-writeup",
+  "name": "Human-Readable Changelog",
+  "description": "Turn raw commit/PR history into a human-readable changelog that users actually understand: a developer first gathers and triages the merged changes since the last release into user-facing buckets (Added, Changed, Fixed, Deprecated, Removed, Security), filtering out noise like internal refactors, then a copywriter rewrites each entry in plain, benefit-oriented language with breaking changes called out. Covers changelog, release notes, what's new, version notes, and Keep a Changelog format. Gathering and triaging before writing is the point: a small model that first separates user-facing changes from internal churn avoids the changelog that lists 'bump deps' next to a breaking API change with equal weight.\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. Gather & triage changes (developer) — collect merged changes and bucket the user-facing ones → gated on artifact `{{workPath}}/gather.md` (markdown-notes)\n2. Write the changelog (copywriter) — rewrite entries in plain, user-facing language → gated on `CHANGELOG.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": "gather",
+  "triggers": [
+    "write a changelog",
+    "generate release notes",
+    "whats new writeup",
+    "changelog from commits",
+    "version notes"
+  ],
+  "steps": [
+    {
+      "id": "gather",
+      "name": "Gather & triage changes",
+      "description": "collect merged changes and bucket the user-facing ones",
+      "prompt": "1) Determine the version range (since the last tag/release). 2) Collect the merged commits/PRs in that range (use git log or the available VCS tools). 3) Triage each into a Keep-a-Changelog bucket: Added, Changed, Deprecated, Removed, Fixed, Security — or DROP if it is internal-only (refactors, test/CI tweaks, dependency bumps with no user impact). 4) Flag BREAKING changes explicitly and note any required migration step. 5) For each kept change, jot the raw description and the PR/commit reference. Write an acceptance-criteria checklist (e.g. 'every user-facing change is captured'; 'internal noise is excluded'; 'changes are bucketed correctly'; 'breaking changes flagged with migration notes'; 'version and date present'). Use write_task_note for the triaged change list + checklist, and write the same to the produces path. No prose changelog yet.\n\nThe deliverable `{{workPath}}/gather.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": "{{workPath}}/gather.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/gather.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/gather.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "gather",
+        "maxAttempts": 3
+      },
+      "next": "write"
+    },
+    {
+      "id": "write",
+      "name": "Write the changelog",
+      "description": "rewrite entries in plain, user-facing language",
+      "prompt": "Write the changelog from the triaged list in Keep a Changelog style. 1) Header: '## [version] - YYYY-MM-DD'. 2) Group entries under the standard H3 buckets (Added/Changed/Deprecated/Removed/Fixed/Security) — include only non-empty buckets. 3) Rewrite each entry as one plain sentence focused on what the USER can now do or what changed for them, not the implementation ('Added dark mode toggle in settings', not 'Implemented theme state reducer'). 4) Put BREAKING CHANGES in a prominent callout at the top with migration instructions. 5) Keep entries terse and parallel in structure; link PRs/issues if available. Output GitHub-flavored markdown. Save to the produces path and note bucket counts.",
+      "suggestedRole": "copywriter",
+      "advanceWhen": {
+        "file": "CHANGELOG.md",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "CHANGELOG.md",
+            "bytes": 500
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkContains",
+            "scope": "standard",
+            "inputs": {
+              "file": "CHANGELOG.md",
+              "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+              "flags": "i"
+            }
+          }
+        ],
+        "onReject": "write",
+        "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 CHANGELOG.md against the triaged list. Check EACH criterion and write PASS/FAIL: (a) every user-facing change from the triage is present; (b) internal noise (refactors, dep bumps, CI) is excluded; (c) entries are in the correct buckets; (d) breaking changes are prominently flagged with migration notes; (e) entries are in plain, user-focused language; (f) version header and date present. A changelog that dumps raw commit messages or buries a breaking change FAILS — loop back to write.\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: \"write\" })` 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": "CHANGELOG.md"
+        }
+      ],
+      "next": "write"
+    },
+    {
+      "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.2",
+  "releasedAt": "2026-08-21T00:00:00Z",
+  "paramSchema": {
+    "type": "object",
+    "properties": {
+      "workPath": {
+        "type": "string",
+        "title": "Working folder",
+        "description": "Per-task working folder in the artifacts drawer. Defaults to this task's own folder so runs never collide; override with a stable name when you deliberately want runs to share files.",
+        "default": "{{task.dir}}"
+      }
+    }
+  },
+  "minGezelVersion": "1.26233"
+}

package/data/craftbook-templates/ch/changelog-writeup/versions/1.0.2/test.json

@@ -0,0 +1,132 @@
+{
+  "schemaVersion": 1,
+  "title": "User-facing changelog from seeded release notes",
+  "objective": "Measure whether the changelog-writeup craftbook filters internal noise, buckets user-facing changes, and calls out breaking changes.",
+  "tags": [
+    "corpus"
+  ],
+  "prompt": "In the `Changelog Writeup Eval` project, read `source/merged-changes.md` and write `CHANGELOG.md` for version 2.4.0 dated 2026-06-27. Include user-facing Added, Changed, Fixed, and Security buckets as appropriate, exclude internal-only noise, and put the breaking API change in a prominent migration note.",
+  "setup": {
+    "projectName": "Changelog Writeup Eval",
+    "about": "Self-contained eval project for the changelog-writeup craftbook. Source changes are in workspace/source/merged-changes.md.",
+    "missionObjectives": "Produce a plain-language Keep a Changelog style CHANGELOG.md from seeded merged changes, excluding internal noise and highlighting breaking changes.",
+    "files": [
+      {
+        "path": "source/merged-changes.md",
+        "content": "# Merged Changes Since 2.3.0\n\n- PR #418 Added CSV export for filtered inventory reports.\n- PR #421 Changed webhook payload field `customerId` to `customer_id`; breaking for existing integrations.\n- PR #424 Fixed duplicate shipment status emails when labels were regenerated.\n- PR #425 Security: tightened SAML certificate expiry validation.\n- PR #426 Internal: refactored reducer names; no user-facing change.\n- PR #427 CI: upgraded lint runner.\n"
+      }
+    ],
+    "worker": {
+      "name": "Maud",
+      "role": "Writer"
+    },
+    "craftbookParams": {
+      "workPath": "tasks/eval"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "workspace/CHANGELOG.md has version/date, buckets, user-facing entries, breaking migration note, and excludes internal noise.",
+    "deliverables": [
+      {
+        "path": "CHANGELOG.md",
+        "kind": "markdown-doc",
+        "minBytes": 1200,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "CHANGELOG.md",
+            "pattern": "2\\.4\\.0|2026-06-27"
+          },
+          {
+            "kind": "contains",
+            "file": "CHANGELOG.md",
+            "pattern": "Added",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "CHANGELOG.md",
+            "pattern": "Changed",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "CHANGELOG.md",
+            "pattern": "Fixed",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "CHANGELOG.md",
+            "pattern": "Security",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "CHANGELOG.md",
+            "pattern": "CSV export|inventory reports",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "CHANGELOG.md",
+            "pattern": "customerId|customer_id|migration|breaking",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "CHANGELOG.md",
+            "pattern": "duplicate shipment status emails|SAML",
+            "flags": "i"
+          },
+          {
+            "kind": "notContains",
+            "file": "CHANGELOG.md",
+            "pattern": "reducer|lint runner|CI:",
+            "flags": "i"
+          }
+        ]
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "CHANGELOG.md",
+      "kind": "markdown"
+    },
+    "axes": [
+      {
+        "name": "safety",
+        "description": "Dry-run posture is explicit: no real credentials, clear stop-before-side-effect boundary."
+      },
+      {
+        "name": "mapping",
+        "description": "Fake endpoints/commands are mapped completely to the workflow steps."
+      },
+      {
+        "name": "signals",
+        "description": "Success, failure, retry, and abort conditions are all defined."
+      },
+      {
+        "name": "containment",
+        "description": "The plan cannot accidentally reach a real service from a mock context."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "triage before writing",
+    "breaking change visibility",
+    "plain user language"
+  ],
+  "extensions": {
+    "legacySimulators": [
+      {
+        "id": "changelog-writeup-fake-service-fixture",
+        "kind": "data-source",
+        "status": "implemented",
+        "description": "Seeded local fake service contract replacing live CLIs, HTTP APIs, credentials, and side effects."
+      }
+    ]
+  }
+}

package/data/craftbook-templates/ch/chapter-narration-run/versions/1.0.3/craftbook.json

@@ -0,0 +1,135 @@
+{
+  "id": "chapter-narration-run",
+  "name": "Narrate a Chapter",
+  "description": "Take one chapter from manuscript to narrated audio, deliberately: a narration script with pronunciations and pauses marked before anything renders, the audio driven through the project's narration capabilities with a run log, and a listen-check against the text — no skipped paragraphs, no mangled names. Locks the chapter and the style sheet FIRST (voice, pace, every proper noun's pronunciation), then preps the script, then renders, then checks coverage. Use for narrating a chapter, audiobook recording runs, text-to-speech passes, and 'read chapter two aloud'.\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 chapter (producer) — chapter locked, style sheet read, pronunciation list built → gated on artifact `{{workPath}}/scope.md` (markdown-notes)\n2. Prep the narration script (copywriter) — the chapter as a marked-up narration script\n3. Render the audio (developer) — the chapter rendered to audio with its run log\n4. Listen-check and report (reviewer) — coverage and name check against the manuscript, run report → gated on artifact `{{workPath}}/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": [
+    "narrate the chapter",
+    "record chapter two",
+    "render the narration",
+    "audiobook chapter run",
+    "read the chapter aloud"
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the chapter",
+      "description": "chapter locked, style sheet read, pronunciation list built",
+      "prompt": "Define the narration run before prepping a word. Step 1: identify the chapter being narrated and read it end to end from the manuscript under manuscript/. Step 2: read the narration style sheet at narration/style.md — the voice, the pace, the pause conventions — and treat it as law for this run. Step 3: build the pronunciation list — every proper noun and unusual name in the chapter, each with its pronunciation from the style sheet; for any name the style sheet does not cover, propose a pronunciation and flag it for the owner rather than letting the render guess. Step 4: write an acceptance-criteria checklist ('narration script covers the full chapter, nothing skipped', 'every listed name carries pronunciation markup', 'pauses marked per the style sheet', 'rendered through the project's narration script via run_installed_script with a status-ok log', 'listen-check confirms coverage and names'). Call write_task_note with the chapter, the pronunciation-list size + checklist, and write {{workPath}}/scope.md.\n\nThe deliverable `{{workPath}}/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": "producer",
+      "advanceWhen": {
+        "file": "{{workPath}}/scope.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/scope.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/scope.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "scope",
+        "maxAttempts": 3
+      },
+      "next": "prep"
+    },
+    {
+      "id": "prep",
+      "name": "Prep the narration script",
+      "description": "the chapter as a marked-up narration script",
+      "prompt": "Turn the chapter into the script the narration engine reads. Step 1: carry the chapter's full text into a narration script at narration/scripts/, named for the chapter — every paragraph present, in order, nothing summarized away; a narration script is the text plus markup, never a digest. Step 2: mark it up per the style sheet — pronunciation markup on every name from the locked list at its first occurrence, pause marks at scene breaks and where the prose needs air, and any pace notes the style sheet calls for. Step 3: re-read against the manuscript once, checking coverage paragraph by paragraph. Call write_task_note with the script path, its word count, and the count of pronunciation marks placed.",
+      "suggestedRole": "copywriter",
+      "next": "render"
+    },
+    {
+      "id": "render",
+      "name": "Render the audio",
+      "description": "the chapter rendered to audio with its run log",
+      "prompt": "Render the narration. Step 1: the narration engine is a project script — call list_scripts to find it, then run it with run_installed_script({ name: \"<script name>\" }); never run it with run_nodejs_script and never reimplement it. It reads the narration script from narration/scripts/, writes the chapter's audio into audio/ named for the chapter, and writes a run log beside it as JSON with a status field and the word count it processed. Step 2: if run_installed_script reports an error or the log flags names it could not resolve, read the error text, fix the script's markup, and run it again — never write the audio or its log yourself; the log is evidence the engine ran. Step 3: once it succeeds, read the log and confirm status ok and a word count in line with the script's. Call write_task_note with the audio path, the log's word count, and anything the log flagged.",
+      "suggestedRole": "developer",
+      "next": "report"
+    },
+    {
+      "id": "report",
+      "name": "Listen-check and report",
+      "description": "coverage and name check against the manuscript, run report",
+      "prompt": "Check the render against the text, then write the run report. Step 1: verify coverage — the log's word count against the script's, and the script's paragraphs against the manuscript's; a skipped paragraph is the failure this ritual exists to catch. Step 2: verify the names — every pronunciation from the locked list was marked in the script and none were flagged unresolved by the run log. Step 3: write {{workPath}}/report.md — the chapter, the audio path and duration or word count from the log, the coverage result stated plainly, the pronunciation check result name by name, and anything flagged for the owner (proposed pronunciations awaiting approval, spots worth a human listen). Call write_task_note with the report path and the coverage verdict.\n\nThe deliverable `{{workPath}}/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": "reviewer",
+      "advanceWhen": {
+        "file": "{{workPath}}/report.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/report.md",
+            "bytes": 600,
+            "artifact": true
+          },
+          {
+            "kind": "contains",
+            "file": "{{workPath}}/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 {{workPath}}/report.md, the run log in audio/, the narration script in narration/scripts/, and the manuscript chapter and verify every criterion from {{workPath}}/scope.md: the script covers the full chapter with nothing skipped, every locked name carries pronunciation markup, the log reports status ok with a word count consistent with the script, and the report states the coverage and name-check results honestly. Write PASS/FAIL per criterion; on any failure, name the gap and loop back to report — or to prep if the script itself is the problem.\n\nThe deliverable lives in the project's artifacts drawer — open `{{workPath}}/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: \"report\" })` 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": "{{workPath}}/report.md",
+          "artifact": true
+        }
+      ],
+      "next": "report"
+    },
+    {
+      "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.3",
+  "releasedAt": "2026-08-21T00:00:00Z",
+  "paramSchema": {
+    "type": "object",
+    "properties": {
+      "workPath": {
+        "type": "string",
+        "title": "Working folder",
+        "description": "Per-task working folder in the artifacts drawer. Defaults to this task's own folder so runs never collide; override with a stable name when you deliberately want runs to share files.",
+        "default": "{{task.dir}}"
+      }
+    }
+  },
+  "minGezelVersion": "1.26233"
+}

package/data/craftbook-templates/ch/chapter-narration-run/versions/1.0.3/test.json

@@ -0,0 +1,158 @@
+{
+  "schemaVersion": 1,
+  "title": "Narrate a Chapter smoke eval",
+  "objective": "Task-specific eval for the Narrate a Chapter craftbook: chapter two (three tricky Irish and Scottish names) is prepped into a marked-up narration script, rendered through the fake narration engine, and listen-checked — with the name missing from the style sheet flagged, not guessed.",
+  "tags": [
+    "external"
+  ],
+  "prompt": "can you narrate chapter 2 with the fake voice engine thats wired up? watch the character names, the pronounciations trip everyone up",
+  "setup": {
+    "projectName": "Audiobook Studio — Chapter Narration Eval",
+    "about": "Self-contained eval project for chapter-narration-run. The manuscript chapter is manuscript/chapter-02.md and the narration style sheet is narration/style.md (markup conventions plus the pronunciations on file). The narration script goes to narration/scripts/chapter-02-script.md; the fake narration engine is the ready-made mock-probe project script — it reads every script under narration/scripts/ and writes audio/chapter-02.wav plus audio/chapter-02-log.json. The listen-check report goes to tasks/eval/report.md.",
+    "missionObjectives": "Use the Narrate a Chapter craftbook/template, prep the full chapter into a marked-up narration script per the style sheet, render through the provided mock-probe script, and listen-check coverage and names in tasks/eval/report.md. Names not on the style sheet get a proposed pronunciation flagged for the owner, never guessed silently. No real narration engines or services — only the wired fake.",
+    "files": [
+      {
+        "path": "manuscript/chapter-02.md",
+        "content": "# Chapter Two - The Ferry at Dusk\n\nSaoirse counted the coins twice before sliding them across the worn brass\nplate. The ferryman did not look up. Behind her, the harbor lamps were\ncoming on one by one, and the gulls had gone quiet the way they always did\njust before the tide turned.\n\n\"Two for the crossing,\" she said. \"One of us is a dog.\"\n\nThe ferryman looked up then. Tadhg, to his credit, sat very straight and\ntried to look like a dog with a ticket. The wind came off the water smelling\nof iron and kelp, and somewhere out past the breakwater a bell buoy kept its\nslow, patient time.\n\nThey had been walking since the morning of the second day, since the door\nin the sea wall that should not have opened and did. Saoirse had stopped\nasking how Tadhg knew the way. He knew it the way water knows downhill.\n\nEilidh was waiting on the far shore. That was the whole of the plan, and\nsaying it out loud made it sound even thinner than it was. Eilidh, who had\nsent one letter in four years, in handwriting that got smaller with every\nline, as if the words were trying to hide. Eilidh, who signed it only with\nthe old mark they had invented under the school stairs, the one that meant\ncome anyway.\n\nThe ferry moved off with no sound but the water folding along its sides.\nSaoirse kept her eyes on the far shore lights and her hand on the warm\nscruff of Tadhg's neck.\n\n\"When we get there,\" she said quietly, \"let me do the talking.\"\n\nTadhg said nothing, which from Tadhg was a whole opinion.\n\nThe crossing took the length of one slow bell. When the hull touched the\nfar dock, the lamps went out all at once, every one of them, as if the\nshore had drawn a breath. And there, at the end of the dock, stood a small\nfigure with a lantern, handwriting-small against the dark.\n\n\"You came anyway,\" said Eilidh.\n"
+      },
+      {
+        "path": "narration/style.md",
+        "content": "# Narration style sheet\n\nVoice: warm, unhurried, close to the listener. Evening-reading pace,\nabout 150 words a minute. Let the quiet moments stay quiet.\n\nMarkup conventions for narration scripts:\n- Pronunciation: mark a name at its first occurrence as [pron: Name = SOUNDS-like].\n- Pauses: [pause] at scene breaks and wherever the prose needs air.\n- Pace: [slow] ... [/slow] around passages to be read deliberately.\n\nPronunciations on file:\n- [pron: Saoirse = SEER-sha]\n- [pron: Tadhg = TIGE] (rhymes with tiger without the r)\n\nAny name not on this list gets a proposed pronunciation flagged for the\nowner before the render - the engine must never guess.\n"
+      }
+    ],
+    "worker": {
+      "name": "Lot",
+      "role": "Producer"
+    },
+    "craftbookParams": {
+      "workPath": "tasks/eval"
+    }
+  },
+  "mocks": [
+    {
+      "kind": "cli",
+      "id": "probe",
+      "description": "Provenance-trusted project script `mock-probe` that runs the fake narration engine: reads the narration scripts under narration/scripts/ and writes the stub wav plus a run log per chapter into audio/.",
+      "shim": {
+        "path": "scripts/mock-probe.ts",
+        "content": "import { defineScript, gezel } from '@bendyline/gezel-sdk';\n\nexport const meta = defineScript({\n  name: 'mock-probe',\n  description:\n    'Fake narration engine for this eval: reads every narration script under narration/scripts/, then writes a stub wav per chapter into audio/ plus a run log with the word count and the pronunciation-mark count.',\n  inputs: {},\n  outputs: {\n    runs: { type: 'string', description: 'JSON array of run logs, one per narration script rendered.' },\n  },\n  requires: ['workspace.read', 'workspace.write'],\n});\n\nconst entries = await gezel.fs.list('narration/scripts');\nconst scripts = entries.filter((entry) => !entry.isDirectory && entry.name.endsWith('-script.md'));\nif (scripts.length === 0) {\n  throw new Error('no narration script found under narration/scripts, expected <chapter>-script.md');\n}\nconst results = [];\nfor (const entry of scripts) {\n  const path = `narration/scripts/${entry.name}`;\n  const text = await gezel.fs.read(path);\n  const slug = entry.name.replace(/-script\\.md$/, '');\n  const wordCount = text.split(/\\s+/).filter((word) => word.length > 0).length;\n  const pronunciationMarks = (text.match(/\\[pron:/g) ?? []).length;\n  if (wordCount < 50) {\n    throw new Error(`narration script ${path} is too short to be a full chapter (${wordCount} words)`);\n  }\n  const log = { status: 'ok', engine: 'mock-tts', script: path, wordCount, pronunciationMarks };\n  await gezel.fs.write(`audio/${slug}.wav`, `MOCKWAV ${slug} stub\\n${'0'.repeat(2048)}\\n`);\n  await gezel.fs.write(`audio/${slug}-log.json`, `${JSON.stringify(log, null, 2)}\\n`);\n  results.push(log);\n}\ngezel.output({ runs: JSON.stringify(results) });\n"
+      }
+    }
+  ],
+  "success": {
+    "summary": "The narration script covers the full chapter with pronunciation and pause markup, the fake engine produced the wav and a status-ok log, and the report states coverage and flags Eilidh (absent from the style sheet) with a proposal.",
+    "deliverables": [
+      {
+        "path": "narration/scripts/chapter-02-script.md",
+        "kind": "markdown-doc",
+        "minBytes": 1000,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "narration/scripts/chapter-02-script.md",
+            "pattern": "\\[pron:",
+            "label": "pronunciation markup is present"
+          },
+          {
+            "kind": "contains",
+            "file": "narration/scripts/chapter-02-script.md",
+            "pattern": "\\[pause\\]",
+            "label": "pause marks are placed"
+          },
+          {
+            "kind": "valuesSubsetOf",
+            "file": "narration/scripts/chapter-02-script.md",
+            "sourceFiles": [
+              "manuscript/chapter-02.md"
+            ],
+            "pattern": "\\[pron:\\s*([A-Za-z]+)",
+            "label": "every pronunciation mark names a character from the manuscript"
+          }
+        ]
+      },
+      {
+        "path": "audio/chapter-02.wav",
+        "kind": "audio-file",
+        "minBytes": 500
+      },
+      {
+        "path": "audio/chapter-02-log.json",
+        "kind": "json",
+        "checks": [
+          {
+            "kind": "jsonPathEquals",
+            "file": "audio/chapter-02-log.json",
+            "path": "status",
+            "value": "ok",
+            "label": "the narration run log reports status ok"
+          }
+        ]
+      },
+      {
+        "path": "tasks/eval/report.md",
+        "kind": "markdown-report",
+        "minBytes": 400,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "tasks/eval/report.md",
+            "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/report.md",
+            "pattern": "coverage|complete|skipped",
+            "flags": "i",
+            "label": "a coverage claim is made"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/report.md",
+            "pattern": "Eilidh",
+            "label": "the name missing from the style sheet is addressed"
+          },
+          {
+            "kind": "judge",
+            "file": "tasks/eval/report.md",
+            "rubric": "The report flags Eilidh as absent from the style sheet with a proposed pronunciation awaiting the owner rather than a silent guess, and its coverage claim is consistent with the run log's word count and the script.",
+            "sourceFiles": [
+              "narration/style.md",
+              "audio/chapter-02-log.json"
+            ],
+            "label": "flagged, never guessed"
+          }
+        ]
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "tasks/eval/report.md",
+      "kind": "markdown"
+    },
+    "axes": [
+      {
+        "name": "pronunciation-care",
+        "description": "Every tricky name is marked at first occurrence; the unlisted one is flagged with a proposal."
+      },
+      {
+        "name": "pacing-markup",
+        "description": "Pauses and pace marks follow the style sheet where the prose needs air."
+      },
+      {
+        "name": "qa-rigor",
+        "description": "Coverage is verified against the manuscript, not assumed."
+      },
+      {
+        "name": "fidelity",
+        "description": "The script is the full chapter text, nothing summarized away."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "full-text coverage",
+    "pronunciation flagged not guessed",
+    "run-log grounding"
+  ]
+}

package/data/craftbook-templates/ch/chapter-weave/versions/1.0.2/craftbook.json

@@ -0,0 +1,86 @@
+{
+  "id": "chapter-weave",
+  "name": "Weave a Chapter",
+  "description": "Weave the banked sessions into one memoir chapter in the teller's voice: every scene traceable to something actually said, gaps marked for a future session instead of invented — the ritual that turns interviews into a book. Locks the chapter's arc and the no-invention rules FIRST, then drafts from session material only, with a faithfulness pass that loops until every detail traces. Use for drafting a memoir chapter, weaving sessions into a story, and 'turn the interviews into a chapter'.\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 chapter (editor) — chapter arc from the sessions, no-invention rules, target file → gated on artifact `{{workPath}}/scope.md` (markdown-notes)\n2. Draft the chapter (writer) — the woven chapter under chapters/, session material only\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "scope",
+  "triggers": [
+    "weave the sessions into a chapter",
+    "draft a memoir chapter",
+    "turn the interviews into a chapter",
+    "write the next chapter",
+    "chapter from the sessions"
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the chapter",
+      "description": "chapter arc from the sessions, no-invention rules, target file",
+      "prompt": "Choose the chapter before writing a line. Step 1: read every session file under sessions/ (and sessions.json for the index) — what themes recur, which sessions overlap, and where the material is thick enough to hold a chapter. Step 2: pick the chapter's arc with the owner — the span of time or the thread of feeling it covers, and where it opens and closes. Step 3: lock the weaving rules: no invented events — every scene traces to something actually said; the teller's phrasings survive the prose; where sessions contradict each other, the contradiction is surfaced, not silently resolved; where the record has a hole, the gap is marked inline for a future session, never papered over. Step 4: write the acceptance-criteria checklist from those rules, name the chapter file under chapters/ (the path the owner asks for, or chapters/<slug>.md named for the arc), and call write_task_note with the arc + checklist. Write {{workPath}}/scope.md.\n\nThe deliverable `{{workPath}}/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": "editor",
+      "advanceWhen": {
+        "file": "{{workPath}}/scope.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/scope.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/scope.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "scope",
+        "maxAttempts": 3
+      },
+      "next": "draft"
+    },
+    {
+      "id": "draft",
+      "name": "Draft the chapter",
+      "description": "the woven chapter under chapters/, session material only",
+      "prompt": "Weave the chapter from session material only. Step 1: gather every passage across the sessions that belongs to the locked arc. Step 2: write the chapter in the teller's voice — their rhythms, their words for things — with the narrative connective tissue kept thin and honest. Step 3: where the teller told it two ways, keep both tellings visible ('she remembered it as...; in another telling...'). Step 4: where the arc needs something the sessions never said, mark the gap inline — [gap: ask about ...] — and move on. Step 5: save the chapter under chapters/ at the path locked in scope, make it substantial (a real chapter, not an outline), and call write_task_note with the word count and the gap count.",
+      "suggestedRole": "writer",
+      "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 the chapter under chapters/ beside every session file it draws on, and verify every criterion from {{workPath}}/scope.md: pick five concrete events or details in the chapter and find each one in a session file — any detail with no source is invented and fails the whole pass; the teller's phrasings survive (spot-check three passages); contradictions between sessions are surfaced in the text, not resolved silently; gaps are marked inline, not smoothed over. Write PASS/FAIL per criterion; on any failure, name the invented detail or missed criterion and loop back to draft.\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. If you advance without a target, the loop sends you back by design. After ~3 unproductive loops, stop and report DONE_WITH_CONCERNS so the user can step in.",
+      "suggestedRole": "reviewer",
+      "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.2",
+  "releasedAt": "2026-08-21T00:00:00Z",
+  "paramSchema": {
+    "type": "object",
+    "properties": {
+      "workPath": {
+        "type": "string",
+        "title": "Working folder",
+        "description": "Per-task working folder in the artifacts drawer. Defaults to this task's own folder so runs never collide; override with a stable name when you deliberately want runs to share files.",
+        "default": "{{task.dir}}"
+      }
+    }
+  },
+  "minGezelVersion": "1.26233"
+}