@bendyline/gilde 0.1.37 → 0.1.39

package/data/craftbook-templates/on/one-pager/versions/1.0.2/craftbook.json

@@ -0,0 +1,155 @@
+{
+  "id": "one-pager",
+  "name": "One-Pager Brief",
+  "description": "Create a single-page brief or summary that fits one printed page and lands one message fast — a product one-pager, executive summary, project brief, or leave-behind. Scopes the single audience + the one thing they must remember FIRST, then designs a tight one-page layout (headline, scannable sections, a sidebar of facts), then writes punchy copy that fits the page — ruthless about cutting anything that pushes past one page. Use when the answer must be skimmable in 60 seconds on a single sheet.\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 brief (planner) — one audience, one takeaway, the must-include facts → gated on artifact `{{workPath}}/scope.md` (markdown-notes)\n2. Design the layout (designer) — one-page grid: headline band, columns, fact sidebar, print rule → gated on artifact `{{workPath}}/design.md` (markdown-notes)\n3. Write and assemble (copywriter) — write punchy copy into index.html within the page + word budgets → gated on `index.html` (html-page)\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "scope",
+  "triggers": [
+    "one pager",
+    "one-page brief",
+    "executive summary",
+    "leave behind",
+    "product one sheet",
+    "make a one page summary"
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the brief",
+      "description": "one audience, one takeaway, the must-include facts",
+      "prompt": "Constrain hard — this is ONE page. Step 1: name the single audience and the one sentence you want them to remember after reading. Step 2: list the must-include facts and cut everything else; a one-pager that needs two pages has failed scoping. Step 3: choose the section set that fits one page: a headline + subhead, a short context paragraph, 3-4 scannable value/benefit points, and a small facts/contact sidebar (stats, pricing, links). Step 4: set a word budget per zone (e.g. subhead <= 15 words, each point <= 20 words) so the page cannot overflow. Step 5: write an acceptance-criteria checklist ('fits on one printed page', 'headline states the one takeaway', '3-4 scannable points, each one line', 'a facts/contact block is present', 'no section exceeds its word budget'). Write the scope + word budgets + checklist via write_task_note AND to {{workPath}}/scope.md. No layout or final copy 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": "design"
+    },
+    {
+      "id": "design",
+      "name": "Design the layout",
+      "description": "one-page grid: headline band, columns, fact sidebar, print rule",
+      "prompt": "Design a layout that physically fits one page. Step 1: choose page size (Letter/A4 via @page) with tight margins and a single visual hierarchy: a headline band at top, a main column for the points, and a narrow sidebar for the facts/contact block. Step 2: pick a palette with exact hex (ink, background, one accent) and a type scale where the headline dominates and body stays compact. Step 3: define how the 3-4 points render (icon-less bullets or small labeled blocks) and how the sidebar facts render (label + value rows). Step 4: set the print rule so the whole thing is exactly one page — constrain total height and use break-inside:avoid. Step 5: write a visual-criteria checklist ('single page, no overflow', 'headline is the dominant element', 'sidebar visually distinct from main column', 'consistent accent color'). Write the layout spec + checklist via write_task_note AND to {{workPath}}/design.md. No copy yet.\n\nThe deliverable `{{workPath}}/design.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": "designer",
+      "advanceWhen": {
+        "file": "{{workPath}}/design.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/design.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/design.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "design",
+        "maxAttempts": 3
+      },
+      "next": "write"
+    },
+    {
+      "id": "write",
+      "name": "Write and assemble",
+      "description": "write punchy copy into index.html within the page + word budgets",
+      "prompt": "Write the copy and assemble it into the one-page layout as a single self-contained index.html (inline CSS with the @page/print rule). Step 1: write a headline that states the one takeaway and a subhead within its word budget. Step 2: write the short context paragraph and the 3-4 value points, each one line within budget — punchy, benefit-led, no filler. Step 3: fill the facts/contact sidebar with the must-include facts as label/value rows. Step 4: drop everything into the locked layout with the exact palette and type scale; confirm it occupies exactly one page (trim copy if it overflows — cutting words is the job, not adding pages). On a loop-back, fix ONLY the named gaps. Write the path + a note confirming it fits one page via write_task_note.",
+      "suggestedRole": "copywriter",
+      "advanceWhen": {
+        "file": "index.html",
+        "minBytes": 1,
+        "sniff": "html-complete"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "index.html",
+            "bytes": 800
+          },
+          {
+            "kind": "htmlLint",
+            "file": "index.html"
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkHtmlComplete",
+            "scope": "standard",
+            "inputs": {
+              "file": "index.html"
+            }
+          }
+        ],
+        "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": "QA the one-pager. Step 1: open/render index.html and, if print-preview is available, confirm it is EXACTLY one page with no overflow onto a second sheet. Step 2: check EACH acceptance criterion: headline states the one takeaway, there are 3-4 scannable one-line points, a facts/contact block is present and visually distinct, no zone exceeds its word budget, the accent color is consistent and the headline dominates. Step 3: read it as the target audience and confirm the one message lands in under 60 seconds. Write PASS/FAIL per criterion; if it overflows one page, FAIL the page-fit criterion and loop back to trim.\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": "index.html"
+        }
+      ],
+      "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/on/one-pager/versions/1.0.2/test.json

@@ -0,0 +1,113 @@
+{
+  "schemaVersion": 1,
+  "title": "One-Pager Brief smoke eval",
+  "objective": "Self-contained smoke eval for the One-Pager Brief craftbook using the corpus generic harness.",
+  "tags": [
+    "corpus"
+  ],
+  "prompt": "We need a one-pager brief 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": "One-Pager Brief Eval",
+    "about": "Self-contained eval project for one-pager. Seeded inputs are under workspace/source or workspace/fixtures; final deliverable is workspace/report.md.",
+    "missionObjectives": "Use the One-Pager Brief 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": "# One-Pager Brief 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: one-pager - One-Pager Brief.\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"
+  ]
+}

package/data/craftbook-templates/op/ops-runbook/versions/1.0.2/craftbook.json

@@ -0,0 +1,124 @@
+{
+  "id": "ops-runbook",
+  "name": "Execute an Ops Runbook",
+  "version": "1.0.2",
+  "releasedAt": "2026-08-21T00:00:00Z",
+  "description": "Execute a written operational procedure step by step with verification and a stop-on-anomaly rule. Inventories the runbook and its preconditions FIRST, then executes each step in order — act, verify the step's own check, record verbatim evidence in a run log — halting immediately when observed state does not match what the procedure expects, then writes an outcome report (clean completion, or a halt report naming the failing step, expected vs. observed, and the steps deliberately not executed). Recording verbatim evidence and refusing to run past an anomaly is the wisdom that separates a trustworthy operator from one who papers over broken state.\n\nPhases:\n\n1. Inventory the runbook (researcher) — read the procedure end-to-end, list every step with its verification check, confirm preconditions → gated on `{{workPath}}/runbook-inventory.md`\n2. Execute and record (researcher) — per step: act, verify, record verbatim evidence; STOP at the first anomaly, never fabricate entries for steps that did not run → gated on `runlog.md`, loops back on a thin or evidence-free log\n3. Report the outcome (researcher) — COMPLETED summary or HALTED report naming the failing step with expected vs. observed → completion-gated on `{{workPath}}/outcome.md`; the gate's reject blocks task completion until the report is honest and specific\n\nThe execute gate never advances an empty log, and the stop-on-anomaly rule outranks finishing: a halted run with an honest log and halt report is a successful execution of this book.\n\n\nWorking files under {{workPath}}/, reviews/, and reports/ live in the project artifacts drawer; source and user-facing output files remain in the workspace.",
+  "entryStepId": "inventory",
+  "triggers": [
+    "run the runbook",
+    "execute this procedure",
+    "follow the maintenance procedure",
+    "run this checklist",
+    "execute the runbook steps"
+  ],
+  "steps": [
+    {
+      "id": "inventory",
+      "name": "Inventory the runbook",
+      "description": "read the procedure end-to-end, list steps and checks, confirm preconditions",
+      "prompt": "Read the entire procedure BEFORE executing anything. Step 1: locate the runbook document in the workspace and read it end-to-end; if steps are numbered, keep their numbering. Step 2: for each procedure step, write down the action, the verification check that proves it worked, and the exact evidence the procedure asks you to record (values, identifiers, checksums — these must later appear verbatim in the run log). Step 3: confirm the preconditions — the files and state the procedure assumes exist — by reading them now; name anything missing. Step 4: note the procedure's own reporting conventions (the run-log path, any halt/outcome report it names) — you will honor those exact paths. Step 5: restate the stop rule in one line: at the first verification mismatch, STOP — no later step runs, no entry is invented. Write the inventory to {{workPath}}/runbook-inventory.md and call write_task_note with a two-line summary. Do NOT execute any procedure step yet.\n\nStore `{{workPath}}/runbook-inventory.md` in the artifacts drawer with `write_artifact` and verify them with `read_artifact`; do not write these working files to the workspace.",
+      "suggestedRole": "researcher",
+      "advanceWhen": {
+        "file": "{{workPath}}/runbook-inventory.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/runbook-inventory.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/runbook-inventory.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "inventory",
+        "maxAttempts": 3
+      },
+      "next": "execute"
+    },
+    {
+      "id": "execute",
+      "name": "Execute and record",
+      "description": "per step: act, verify, record verbatim evidence; STOP at the first anomaly",
+      "prompt": "Execute the procedure strictly in order, one step at a time. For each step: (a) perform exactly the action written — no substitutions, no combining steps; (b) run the step's verification check by reading the actual state it names; (c) append a heading for that step to runlog.md (also write to any run-log path the procedure itself names) recording the evidence VERBATIM — the exact values, identifiers, and checksums you observed, copied character-for-character, never paraphrased. STOP-ON-ANOMALY: the moment a verification does not match what the procedure expects, record that step as FAILED with expected vs. observed (both verbatim), and STOP — do not execute any later step, do not write any later step's outputs, and never invent a log entry for a step that did not run. A halted run with an honest log is a correct execution of this phase; running past a mismatch is the failure mode. Call write_task_note with how far the run got and whether it halted.",
+      "suggestedRole": "researcher",
+      "advanceWhen": {
+        "file": "runlog.md",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "runlog.md",
+            "bytes": 300
+          },
+          {
+            "kind": "sniff",
+            "file": "runlog.md",
+            "sniff": "nonempty"
+          }
+        ],
+        "onReject": "execute",
+        "maxAttempts": 4
+      },
+      "next": "report"
+    },
+    {
+      "id": "report",
+      "name": "Report the outcome",
+      "description": "COMPLETED summary or HALTED report with expected vs. observed",
+      "prompt": "Write the outcome report. Step 1: state the status on the first line of {{workPath}}/outcome.md — COMPLETED (every step executed and verified) or HALTED (stopped at an anomaly). Step 2: if HALTED, name the failing step by number, quote expected vs. observed VERBATIM from the run log, list the steps that were deliberately not executed, and recommend only what the procedure itself prescribes for a halt — no speculative fixes. Step 3: if the procedure names its own outcome or halt report (for example halt-report.md), write that file too, at exactly the path it names, carrying the same facts. Step 4: cross-check the report against runlog.md — every claim in the report must appear in the log. Call write_task_note with the status line, then report DONE.\n\nStore `{{workPath}}/outcome.md` in the artifacts drawer with `write_artifact` and verify them with `read_artifact`; do not write these working files to the workspace.",
+      "suggestedRole": "researcher",
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/outcome.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/outcome.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "report",
+        "maxAttempts": 3
+      },
+      "terminal": true,
+      "consumes": [
+        {
+          "file": "runlog.md"
+        }
+      ]
+    }
+  ],
+  "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/op/ops-runbook/versions/1.0.2/test.json

@@ -0,0 +1,107 @@
+{
+  "schemaVersion": 1,
+  "title": "Execute an Ops Runbook smoke eval",
+  "objective": "Self-contained smoke eval for the Execute an Ops Runbook craftbook using the data generic harness.",
+  "tags": [
+    "data"
+  ],
+  "prompt": "I dropped our numbers in source/records.csv. Can you look at the data, analyze it, and put togehter some results in analysis.md?",
+  "setup": {
+    "projectName": "Execute an Ops Runbook Eval",
+    "about": "Self-contained eval project for ops-runbook. Seeded inputs are under workspace/source or workspace/fixtures; final deliverable is workspace/analysis.md.",
+    "missionObjectives": "Use the Execute an Ops Runbook craftbook/template, read the seeded local fixtures, and write analysis.md without network calls, real credentials, or live services.",
+    "files": [
+      {
+        "path": "source/brief.md",
+        "content": "# Execute an Ops Runbook 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: ops-runbook - Execute an Ops Runbook.\n"
+      },
+      {
+        "path": "source/records.csv",
+        "content": "customer,region,orders,revenue_usd,churn_risk\nAster,North,12,1440,low\nBoreal,South,8,720,medium\nCedar,West,15,2100,high\nDune,North,5,500,low\n"
+      }
+    ],
+    "worker": {
+      "name": "Jules",
+      "role": "Data Analyst"
+    },
+    "craftbookParams": {
+      "workPath": "tasks/eval"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "analysis.md is a seeded-data analysis with deterministic computed facts.",
+    "deliverables": [
+      {
+        "path": "analysis.md",
+        "kind": "markdown-report",
+        "minBytes": 900,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "analysis.md",
+            "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "analysis.md",
+            "pattern": "40\\b",
+            "flags": "i",
+            "label": "include total orders of 40"
+          },
+          {
+            "kind": "contains",
+            "file": "analysis.md",
+            "pattern": "\\$?4,?760\\b",
+            "flags": "i",
+            "label": "include total revenue of 4760"
+          },
+          {
+            "kind": "contains",
+            "file": "analysis.md",
+            "pattern": "Cedar",
+            "flags": "i",
+            "label": "identify Cedar as top revenue and high risk"
+          },
+          {
+            "kind": "contains",
+            "file": "analysis.md",
+            "pattern": "high",
+            "flags": "i",
+            "label": "include churn-risk finding"
+          }
+        ]
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "analysis.md",
+      "kind": "markdown"
+    },
+    "axes": [
+      {
+        "name": "accuracy",
+        "description": "Computed figures are correct against the seeded records."
+      },
+      {
+        "name": "grounding",
+        "description": "Every claim traces to the seeded data — nothing invented."
+      },
+      {
+        "name": "structure",
+        "description": "Tables and sections make the analysis checkable at a glance."
+      },
+      {
+        "name": "actionability",
+        "description": "Recommendations follow from the findings and are concretely doable."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "seeded data reading",
+    "computed facts",
+    "recommendation grounding"
+  ]
+}

package/data/craftbook-templates/pa/page-spread/versions/1.0.2/craftbook.json

@@ -0,0 +1,94 @@
+{
+  "id": "page-spread",
+  "name": "Page Spread",
+  "description": "Produce one page spread from script to panels: beats planned, panel art generated against the character sheets — never freehand from memory — lettered and laid out as the page the reader turns to. Locks the panel plan FIRST — each panel naming the sheet references that anchor it and the caption text it carries — then generates the panels from those anchors, then assembles the lettered spread. Use for producing a comic page, 'let's do page three', panel-and-letter passes, turning a script page into art, and the per-page ritual of a whole book.\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. Plan the panels (verhalenverteller) — script beats to panels, each anchored to a character sheet → gated on artifact `{{workPath}}/scope.md` (markdown-notes)\n2. Generate the panels (image-generator) — panel art from the sheet anchors, never from memory\n3. Assemble the spread (designer) — panels laid in reading order, captions and balloons lettered\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "scope",
+  "triggers": [
+    "produce the page spread",
+    "let's do the next page",
+    "panel out the script",
+    "turn the script page into panels",
+    "lay up the spread"
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Plan the panels",
+      "description": "script beats to panels, each anchored to a character sheet",
+      "prompt": "Break the page before generating a pixel. Step 1: read the page's script from the story notes and the character kits under characters/ — each character's manifest carries the references, seeds, and prompts that lock their look. Step 2: break the script into beats and assign each beat a panel — the moment, the framing, and who is in frame. Step 3: for every character in every panel, name the exact sheet reference (and its seed and prompt from the manifest) that anchors how they are drawn — a panel drawn from memory instead of the sheet is how page twelve stops matching page one. Step 4: copy the caption and balloon text for each panel verbatim from the script — the letterer changes nothing. Step 5: write an acceptance-criteria checklist ('every script beat has a panel', 'every figure anchored to a named sheet reference', 'captions and balloons verbatim from the script', 'panels read in order on the assembled page'). Call write_task_note with the panel count + 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": "verhalenverteller",
+      "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": "panels"
+    },
+    {
+      "id": "panels",
+      "name": "Generate the panels",
+      "description": "panel art from the sheet anchors, never from memory",
+      "prompt": "Generate the page's panels into pages/<number>/ (the folder named for the page). Step 1: for each planned panel, build the generation prompt FROM the anchors — start from the sheet reference's persisted prompt and seed out of the character's manifest, then add the panel's moment and framing; the sheet is the source of truth for how every character looks. Step 2: generate through the project's image capabilities, at least three panels, saved as pages/<number>/panel-1.png, panel-2.png, and so on in reading order. Step 3: after each panel, check it against the plan — right characters, right moment, silhouette and palette matching the sheet; regenerate what drifted before moving on. Call write_task_note with the panel count and which sheet references anchored each.",
+      "suggestedRole": "image-generator",
+      "next": "assemble"
+    },
+    {
+      "id": "assemble",
+      "name": "Assemble the spread",
+      "description": "panels laid in reading order, captions and balloons lettered",
+      "prompt": "Assemble the page at pages/<number>/spread.html. Step 1: lay the panels in reading order with honest gutters — the eye should never wonder which panel is next. Step 2: letter it — the captions and balloon text from the plan, verbatim from the script, placed with the panel they belong to, tails pointing at the speaker. Step 3: style it as a page — panel borders, gutter rhythm, type that reads at page size, all in one self-contained file. Step 4: read the finished page top to bottom once as a reader would and fix anything that stumbles. Call write_task_note with the spread path and the panel order.",
+      "suggestedRole": "designer",
+      "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 page folder under pages/ beside {{workPath}}/scope.md, the script, and the character manifests, and verify every criterion: every script beat has its panel and the panels sit in reading order; every figure traces to the sheet reference the plan named — check the plan's anchors against the characters/ manifests, continuity is the whole point of this book; the captions and balloons on the spread match the script verbatim — a letterer who paraphrases is rewriting the author; and the assembled page reads clean top to bottom. Write PASS/FAIL per criterion; on any failure, name the panel and the gap and loop back to panels.\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: \"panels\" })` 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",
+      "next": "panels"
+    },
+    {
+      "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"
+}