@bendyline/gilde 0.1.26 → 0.1.28

package/data/craftbook-templates/ep/episode-plan/versions/1.0.1/craftbook.json

@@ -0,0 +1,140 @@
+{
+  "id": "episode-plan",
+  "name": "Plan the Episode",
+  "description": "Turn the idea backlog and last episode's loose threads into a locked plan for the next episode: a rundown with timed segments, what to prep, and a record date — so the show ships on rhythm instead of on adrenaline. Locks the episode goal and the acceptance checklist FIRST, then builds the timed rundown, then writes the brief with prep owners and the record date. Use for planning the next episode, episode rundowns, show planning, and 'what's the next episode'.\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 episode (planner) — backlog picture, episode goal, plan rules → gated on artifact `notes/scope.md` (markdown-notes)\n2. Build the rundown (producer) — timed segments, per-segment needs, open questions → gated on artifact `notes/rundown.md` (markdown-notes)\n3. Write the episode brief (copywriter) — title options, final rundown, prep list with owners, record date → 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": [
+    "plan the next episode",
+    "episode plan",
+    "what's our next episode",
+    "plan next week's show",
+    "episode rundown"
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the episode",
+      "description": "backlog picture, episode goal, plan rules",
+      "prompt": "Define the episode before anything gets produced. Step 1: read episodes.json from the workspace — the idea backlog, the publishing cadence, the last few shipped episodes and any loose threads or listener notes they left behind. Step 2: confirm with the owner which idea leads the next episode and what the episode is FOR — the one thing a listener should take away. Step 3: set the plan rules — target length, the segment shape the show uses, guests or clips that need lead time, and the record date that keeps the cadence. Step 4: write an acceptance-criteria checklist ('every segment has a minute mark and a purpose', 'segment minutes add up to the target length', 'every prep item has an owner and a by-date', 'the record date beats the publish date', 'loose threads from last episode are picked up or consciously dropped'). Call write_task_note with the chosen idea + record date + 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": "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": "rundown"
+    },
+    {
+      "id": "rundown",
+      "name": "Build the rundown",
+      "description": "timed segments, per-segment needs, open questions",
+      "prompt": "Build the rundown against the locked goal. Step 1: draft the segment list — cold open to outro — with a minute mark and a one-line purpose per segment. Step 2: for each segment, note what it needs: a guest, a clip, research, an ad read, or nothing but the host. Step 3: check the math — segment minutes must add up to the target length, with the big segment where the energy belongs. Step 4: list the open questions the owner must answer before record day. Step 5: write the full rundown to notes/rundown.md and call write_task_note with the segment count and the total minutes.\n\nThe deliverable `notes/rundown.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": "notes/rundown.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "notes/rundown.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "notes/rundown.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "rundown",
+        "maxAttempts": 3
+      },
+      "next": "report"
+    },
+    {
+      "id": "report",
+      "name": "Write the episode brief",
+      "description": "title options, final rundown, prep list with owners, record date",
+      "prompt": "Write the episode brief from the rundown. Step 1: open with the episode goal and two or three title options that would make the target listener stop scrolling. Step 2: lay out the final rundown — every segment with its minute mark and purpose. Step 3: write the prep list — each item with an owner and a by-date, ordered by lead time, longest first. Step 4: state the record date and the publish date it protects. Step 5: keep it one page, warm and specific — this is the sheet the host glances at before hitting record. Write report.md and call write_task_note with the report path and the record date.\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": 1500,
+            "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 and notes/rundown.md and verify every criterion from notes/scope.md: every segment carries a minute mark and a purpose, the minutes add up to the target length, every prep item names an owner and a by-date, the record date is set and beats the publish date, and last episode's loose threads are picked up or consciously dropped. Cross-check the brief against episodes.json — the chosen idea must come from the backlog or the owner, never from thin air. Write PASS/FAIL per criterion; on any failure, name the gap and loop back to report.\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: \"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": "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.1",
+  "releasedAt": "2026-08-14T00:00:00Z"
+}

package/data/craftbook-templates/ep/episode-plan/versions/1.0.1/test.json

@@ -0,0 +1,97 @@
+{
+  "schemaVersion": 1,
+  "title": "Plan the Episode — backlog to locked rundown",
+  "objective": "Measure whether the episode-plan craftbook turns a seeded episode store and listener feedback into a locked episode brief with a timed rundown, prep owners, and a record date.",
+  "tags": [
+    "corpus"
+  ],
+  "prompt": "Can you plan next weeks episode? our running notes are in episodes.json and there's listener feedback in source/feedback.md — plan into report.md",
+  "setup": {
+    "projectName": "Shelf Life Podcast",
+    "about": "Podcast studio project for Shelf Life, a weekly show about books and the people who make them. The episode store is workspace/episodes.json; listener feedback lands under workspace/source.",
+    "missionObjectives": "Keep the show shipping on its weekly rhythm. Plans are grounded in the episode store and listener feedback — no live services, no real credentials.",
+    "files": [
+      {
+        "path": "episodes.json",
+        "content": "{\n  \"show\": \"Shelf Life\",\n  \"cadence\": \"weekly — records Thursday, publishes Monday\",\n  \"targetMinutes\": 45,\n  \"episodes\": [\n    {\n      \"number\": 10,\n      \"title\": \"The Library Cart Economy\",\n      \"publishedAt\": \"2026-06-29\",\n      \"looseThreads\": [\"listener mail about mobile libraries never answered on air\"]\n    },\n    {\n      \"number\": 11,\n      \"title\": \"Why Paperbacks Survive\",\n      \"publishedAt\": \"2026-07-06\",\n      \"looseThreads\": [\"promised a follow-up on print-on-demand costs\"]\n    },\n    {\n      \"number\": 12,\n      \"title\": \"Interview: The Last Bookbinder\",\n      \"publishedAt\": \"2026-07-13\",\n      \"looseThreads\": [\"the bookbinder offered to come back with her apprentice\"]\n    }\n  ],\n  \"ideaBacklog\": [\n    {\n      \"idea\": \"Print-on-demand: the real costs\",\n      \"notes\": \"pairs with the episode 11 follow-up promise; host has the numbers already\"\n    },\n    {\n      \"idea\": \"School libraries after the budget cuts\",\n      \"notes\": \"needs a guest — two weeks lead time minimum\"\n    },\n    {\n      \"idea\": \"Audiobook narrators nobody credits\",\n      \"notes\": \"evergreen, no lead time, host can carry it solo\"\n    }\n  ]\n}\n"
+      },
+      {
+        "path": "source/feedback.md",
+        "content": "# Listener feedback — week of 2026-07-13\n\n- \"You promised the print-on-demand cost breakdown two episodes ago. Still waiting!\" — Sam R., email\n- \"The bookbinder interview was the best episode this year. More craftspeople please.\" — review\n- \"Episodes have been running long lately. 45 minutes is the sweet spot.\" — voicemail\n- \"Whatever happened to the mobile libraries question from the mailbag?\" — Discord\n"
+      }
+    ],
+    "worker": {
+      "name": "Fenna",
+      "role": "Producer"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "report.md is a one-page episode brief: title options, a rundown with minute marks, a prep list with owners, and a record date — grounded in the backlog and the feedback.",
+    "deliverables": [
+      {
+        "path": "report.md",
+        "kind": "markdown-report",
+        "minBytes": 1500,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "segment|rundown",
+            "flags": "i",
+            "label": "rundown present"
+          },
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "\\d{1,2}\\s*(min|:)",
+            "flags": "i",
+            "label": "minute marks on segments"
+          },
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "prep|before record",
+            "flags": "i",
+            "label": "prep list present"
+          }
+        ]
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "report.md",
+      "kind": "markdown"
+    },
+    "axes": [
+      {
+        "name": "structure",
+        "description": "The brief reads as one page a host can glance at before recording: goal, titles, timed rundown, prep list, record date."
+      },
+      {
+        "name": "grounding",
+        "description": "The chosen episode comes from the idea backlog and the loose threads; the listener feedback visibly shaped the plan."
+      },
+      {
+        "name": "actionability",
+        "description": "Prep items carry owners and by-dates; segment minutes add up to the target length."
+      },
+      {
+        "name": "tone",
+        "description": "Warm and specific — a producer's brief, not a form."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "backlog grounding",
+    "timed rundown",
+    "prep ownership"
+  ]
+}

package/data/craftbook-templates/es/escalation-playbook/versions/1.0.1/craftbook.json

@@ -0,0 +1,107 @@
+{
+  "id": "escalation-playbook",
+  "name": "On-Call Escalation Playbook",
+  "description": "Author an on-call escalation playbook: the severity ladder, who-to-page-when escalation tiers with timeouts, communication cadence to stakeholders, and the step-by-step actions for each severity. Scopes the severity definitions and escalation policy FIRST (SEV levels with concrete examples, tier timeouts, roles, comms channels and cadence), then a copywriter writes the playbook in clear, do-this-now imperative steps, then a reviewer validates it for completeness and that no severity dead-ends without an escalation path. Scoping the SEV ladder and timeouts before writing prose is what makes the playbook unambiguous at 3am. Use for on-call runbooks, incident escalation policy, paging tiers, severity ladders, and SRE escalation procedures.\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 policy (planner) — lock SEV levels, escalation tiers, timeouts, and comms → gated on artifact `notes/scope.md` (markdown-notes)\n2. Write the playbook (copywriter) — write do-this-now steps for each severity → gated on `playbook.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": "scope",
+  "triggers": [
+    "escalation playbook",
+    "on-call escalation",
+    "paging tiers",
+    "severity ladder",
+    "incident escalation policy"
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the policy",
+      "description": "lock SEV levels, escalation tiers, timeouts, and comms",
+      "prompt": "Define the escalation policy before writing prose. (1) Lock a severity ladder (e.g. SEV1 critical/total outage, SEV2 major degradation, SEV3 minor) with a concrete example and an impact definition for each. (2) For each SEV, define the escalation tiers: who is paged first, the timeout before escalating to the next tier (e.g. 'no ack in 10 min → page secondary; 20 min → page EM'), and the final backstop. (3) Define the incident roles (Incident Commander, Comms lead, Scribe) and when each is invoked. (4) Lock the stakeholder communication cadence per SEV (channel + update frequency, e.g. SEV1 = status page + every 30 min). Write an acceptance-criteria checklist ('every SEV has impact definition + example', 'every SEV has a full escalation tier chain with timeouts ending in a backstop', 'roles defined and triggered per SEV', 'comms cadence specified per SEV', 'no SEV dead-ends without escalation') plus the ladder/tier tables to notes/scope.md via write_task_note AND the produces path. No prose playbook 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": "write"
+    },
+    {
+      "id": "write",
+      "name": "Write the playbook",
+      "description": "write do-this-now steps for each severity",
+      "prompt": "Write playbook.md from the locked policy as a 3am-readable runbook. (1) Open with the severity ladder table (SEV, impact, example) and a one-paragraph 'how to use this'. (2) For EACH severity, write a numbered, imperative step list — Detect & declare → Assign roles → Mitigate → Escalate (with the exact tier timeouts) → Communicate (channel + cadence) → Stand down. Use second-person commands ('Page the primary on-call. If no ack in 10 minutes, page the secondary.'). (3) Include the escalation tier chain inline for each SEV with the timeouts spelled out, ending in a backstop with no dead-end (a tier that escalates to nobody). (4) Add a Communications section with templated stakeholder update snippets per SEV. (5) End with a post-incident handoff/postmortem trigger. No ambiguity, no prose digressions — every line is an action or a fact. On a loop-back fix only the flagged sections. Write the path to notes via write_task_note.",
+      "suggestedRole": "copywriter",
+      "advanceWhen": {
+        "file": "playbook.md",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "playbook.md",
+            "bytes": 500
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkContains",
+            "scope": "standard",
+            "inputs": {
+              "file": "playbook.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": "Validate playbook.md against every locked criterion. (1) Confirm every SEV from the scope has impact definition, example, and its own complete imperative step list (declare → roles → mitigate → escalate → communicate → stand down). (2) Trace each SEV's escalation chain end-to-end: are the tier timeouts present and does the chain end in a backstop with no dead-end (a tier that escalates to nobody)? FAIL if any SEV dead-ends. (3) Confirm roles are defined and their trigger points stated per SEV, and the per-SEV comms cadence + channels + templated update snippets exist. (4) Read 2 step lists for ambiguity — a tired on-call must be able to follow them literally. Write PASS/FAIL per criterion with the specific gaps.\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": "playbook.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.1",
+  "releasedAt": "2026-08-14T00:00:00Z"
+}

package/data/craftbook-templates/es/escalation-playbook/versions/1.0.1/test.json

@@ -0,0 +1,110 @@
+{
+  "schemaVersion": 1,
+  "title": "On-Call Escalation Playbook smoke eval",
+  "objective": "Self-contained smoke eval for the On-Call Escalation Playbook craftbook using the corpus generic harness.",
+  "tags": [
+    "corpus"
+  ],
+  "prompt": "We need a on-call escalation playbook for the returns-desk work. The backgound info is in source/brief.md — have a look and write it up in report.md.",
+  "setup": {
+    "projectName": "On-Call Escalation Playbook Eval",
+    "about": "Self-contained eval project for escalation-playbook. Seeded inputs are under workspace/source or workspace/fixtures; final deliverable is workspace/report.md.",
+    "missionObjectives": "Use the On-Call Escalation Playbook craftbook/template, read the seeded local fixtures, and write report.md without network calls, real credentials, or live services.",
+    "files": [
+      {
+        "path": "source/brief.md",
+        "content": "# On-Call Escalation Playbook 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: escalation-playbook - On-Call Escalation Playbook.\n"
+      }
+    ],
+    "worker": {
+      "name": "Jules",
+      "role": "Writer"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "report.md is a source-grounded markdown artifact with required facts and actions.",
+    "deliverables": [
+      {
+        "path": "report.md",
+        "kind": "markdown-report",
+        "minBytes": 1000,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "source/brief\\.md|Brief",
+            "flags": "i",
+            "label": "cite or name the seeded source"
+          },
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "18\\b[\\s\\S]{0,30}\\bSKUs",
+            "flags": "i",
+            "label": "include the 18-SKU pilot scope"
+          },
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "18\\s*hours|6\\s*hours",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "14\\.2%|8\\.9%",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "status silence|photo submission",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "automated status emails|barcode|Finance",
+            "flags": "i"
+          }
+        ]
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "report.md",
+      "kind": "markdown"
+    },
+    "axes": [
+      {
+        "name": "grounding",
+        "description": "Seeded facts appear faithfully and the source is cited."
+      },
+      {
+        "name": "structure",
+        "description": "Sections progress logically for the artifact class."
+      },
+      {
+        "name": "completeness",
+        "description": "Required elements (risks, next actions, scope) are all present."
+      },
+      {
+        "name": "tone",
+        "description": "The register fits the audience and artifact class."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "source-grounded prose",
+    "section structure",
+    "next-action clarity"
+  ]
+}

package/data/craftbook-templates/ev/evidence-brief/versions/1.0.1/craftbook.json

@@ -0,0 +1,146 @@
+{
+  "id": "evidence-brief",
+  "name": "Decision Evidence Brief",
+  "description": "Answer a specific decision question with a weighted, confidence-rated evidence brief: a planner frames the decision and the options, locks the evidence criteria and a confidence scale, a researcher gathers evidence for and against each option and rates the strength of each piece, and a copywriter writes a decision-oriented brief that states a recommendation with explicit confidence levels and the key uncertainties. The ordering matters because evidence gathered before framing the decision is unfocused and a recommendation without a confidence scale hides how strong the case really is; fixing the question, the options, and a confidence rubric first produces an honest, decision-ready brief. Use this for evidence-based decision support, 'what does the evidence say we should do about X', recommendation memos, weighing options with confidence levels, and policy/strategy briefs grounded in sources.\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. Frame the decision (planner) — decision question, options, evidence + confidence rubric → gated on artifact `notes/scope.md` (markdown-notes)\n2. Gather & rate evidence (researcher) — evidence for/against each option, strength-rated + cited → gated on artifact `notes/evidence.md` (markdown-notes)\n3. Write the brief (copywriter) — recommendation with confidence + key uncertainties → gated on artifact `brief.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": [
+    "evidence brief",
+    "what does the evidence say we should do",
+    "decision support memo",
+    "recommendation with confidence levels",
+    "weigh the options with evidence"
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Frame the decision",
+      "description": "decision question, options, evidence + confidence rubric",
+      "prompt": "1. State the exact decision question and the discrete options on the table (including 'do nothing' if relevant) in a few lines. 2. Lock the criteria that good evidence must meet for this decision (relevance, source quality, recency) and a confidence scale: High / Medium / Low, with a one-line definition of each (e.g. High = multiple independent strong sources agree). 3. Decide how evidence maps to a recommendation (e.g. weigh strength-rated evidence for/against each option). 4. Write an acceptance-criteria checklist (e.g. 'evidence is gathered for AND against each option', 'each piece of evidence is rated for strength and cited', 'the recommendation states an explicit confidence level', 'key uncertainties and what would change the recommendation are listed', 'no recommendation exceeds the confidence its evidence supports'). 5. Record decisions. Call write_task_note with the question, options, confidence scale, and checklist; write the same to 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": "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": "research"
+    },
+    {
+      "id": "research",
+      "name": "Gather & rate evidence",
+      "description": "evidence for/against each option, strength-rated + cited",
+      "prompt": "1. For each option, gather evidence both FOR and AGAINST into notes/evidence.md: the finding, its source [n], the date, and a strength rating per the locked confidence scale with a reason (sample size, source quality, corroboration). 2. Actively seek disconfirming evidence for the option you suspect is best — steelman the alternatives so the brief is not a foregone conclusion. 3. Corroborate strong claims across independent sources before rating them High. 4. Explicitly record what is unknown and what evidence would resolve it. 5. Mark anything you cannot verify UNVERIFIED. Good looks like a balanced, strength-rated evidence file per option. Do not write the recommendation yet.\n\nThe deliverable `notes/evidence.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": "researcher",
+      "advanceWhen": {
+        "file": "notes/evidence.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "notes/evidence.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "notes/evidence.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "research",
+        "maxAttempts": 3
+      },
+      "next": "write"
+    },
+    {
+      "id": "write",
+      "name": "Write the brief",
+      "description": "recommendation with confidence + key uncertainties",
+      "prompt": "1. Write brief.md: a bottom-line recommendation up top stating which option and at what confidence level (High/Medium/Low), then a section per option laying out evidence for and against with each piece's strength rating and citation [n], then a 'Key uncertainties & what would change this' section. 2. Calibrate the stated confidence to the evidence — do not claim High confidence on Low/Medium evidence; if the evidence is thin, say so plainly. 3. Present the alternatives fairly, including the strongest case against your recommendation. 4. Add a References list from notes/evidence.md so every [n] resolves. 5. Keep it decision-ready and scannable. 6. On a loop-back, fix only the named gaps. 7. Call write_task_note with the brief path and which criteria now pass.\n\nBefore working, open the artifact input `notes/evidence.md` with `read_artifact`; do not look for it in the workspace.\n\nThe deliverable `brief.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",
+      "consumes": [
+        {
+          "file": "notes/evidence.md",
+          "artifact": true
+        }
+      ],
+      "advanceWhen": {
+        "file": "brief.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "brief.md",
+            "bytes": 1500,
+            "artifact": true
+          },
+          {
+            "kind": "contains",
+            "file": "brief.md",
+            "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+            "flags": "i",
+            "label": "at least one markdown heading",
+            "artifact": true
+          }
+        ],
+        "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": "Open brief.md and check EACH criterion PASS/FAIL: (1) evidence is presented for AND against each option (not one-sided); (2) each piece of evidence is strength-rated and cited (spot-check 3 against notes/evidence.md); (3) the recommendation states an explicit confidence level; (4) the stated confidence is calibrated to the evidence — a High-confidence call must rest on multiple strong corroborated sources; (5) a 'key uncertainties / what would change this' section exists; (6) the strongest counter-case is acknowledged. A one-sided brief, or one claiming more confidence than its evidence supports, FAILS.\n\nThe deliverable lives in the project's artifacts drawer — open `brief.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: \"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": "brief.md",
+          "artifact": true
+        }
+      ],
+      "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.1",
+  "releasedAt": "2026-08-14T00:00:00Z"
+}