@bendyline/gilde 0.1.38 → 0.1.39

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

@@ -0,0 +1,152 @@
+{
+  "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 `{{workPath}}/scope.md` (markdown-notes)\n2. Build the rundown (producer) — timed segments, per-segment needs, open questions → gated on artifact `{{workPath}}/rundown.md` (markdown-notes)\n3. Write the episode brief (copywriter) — title options, final rundown, prep list with owners, record date → 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": [
+    "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 {{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": "planner",
+      "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": "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 {{workPath}}/rundown.md and call write_task_note with the segment count and the total minutes.\n\nThe deliverable `{{workPath}}/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": "{{workPath}}/rundown.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/rundown.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/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 {{workPath}}/report.md and call write_task_note with the report path and the record date.\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": "copywriter",
+      "advanceWhen": {
+        "file": "{{workPath}}/report.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/report.md",
+            "bytes": 1500,
+            "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 and {{workPath}}/rundown.md and verify every criterion from {{workPath}}/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 `{{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.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/ep/episode-plan/versions/1.0.2/test.json

@@ -0,0 +1,100 @@
+{
+  "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 tasks/eval/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      \"tasks/eval\": \"pairs with the episode 11 follow-up promise; host has the numbers already\"\n    },\n    {\n      \"idea\": \"School libraries after the budget cuts\",\n      \"tasks/eval\": \"needs a guest — two weeks lead time minimum\"\n    },\n    {\n      \"idea\": \"Audiobook narrators nobody credits\",\n      \"tasks/eval\": \"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"
+    },
+    "craftbookParams": {
+      "workPath": "tasks/eval"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "tasks/eval/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": "tasks/eval/report.md",
+        "kind": "markdown-report",
+        "minBytes": 1500,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "tasks/eval/report.md",
+            "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/report.md",
+            "pattern": "segment|rundown",
+            "flags": "i",
+            "label": "rundown present"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/report.md",
+            "pattern": "\\d{1,2}\\s*(min|:)",
+            "flags": "i",
+            "label": "minute marks on segments"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/report.md",
+            "pattern": "prep|before record",
+            "flags": "i",
+            "label": "prep list present"
+          }
+        ]
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "tasks/eval/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.2/craftbook.json

@@ -0,0 +1,119 @@
+{
+  "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 `{{workPath}}/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 {{workPath}}/scope.md via write_task_note AND the produces path. No prose playbook yet.\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": "planner",
+      "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": "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.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/es/escalation-playbook/versions/1.0.2/test.json

@@ -0,0 +1,113 @@
+{
+  "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"
+    },
+    "craftbookParams": {
+      "workPath": "tasks/eval"
+    }
+  },
+  "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"
+  ]
+}