@bendyline/gilde 0.1.38 → 0.1.39

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

@@ -0,0 +1,135 @@
+{
+  "schemaVersion": 1,
+  "title": "Page Spread — page 3 from script to lettered panels",
+  "objective": "Measure whether the page-spread craftbook produces page 3 as planned panels generated against the character kit's anchors and an assembled spread whose captions and balloons are conserved verbatim from the script.",
+  "tags": [
+    "html-page"
+  ],
+  "prompt": "lets do page 3 — the beats are in the story notes and Pips sheet is in the character kit. panel it out and lay up the sperad",
+  "setup": {
+    "projectName": "The Lighthouse Summer Comic",
+    "about": "Comic maker project. Scripts live under workspace/story (page 3 is workspace/story/page-3.md). Character kits live under workspace/characters — Pip's manifest is workspace/characters/pip/sheet.json. Page spreads land under workspace/pages/<number>: page 3's panels and spread.html go in workspace/pages/3.",
+    "missionObjectives": "Continuity over convenience: every figure anchored to the character kit's persisted references, captions and balloons verbatim from the script. No live services, no real credentials.",
+    "files": [
+      {
+        "path": "story/page-3.md",
+        "content": "# Page 3 — The Missed Ferry\n\nBEAT 1 — Wide on the empty dock, morning light. The ferry is a speck on the water.\nCAPTION: The ferry left without them.\n\nBEAT 2 — Pip at the dock's edge, scarf whipped by wind, determined face.\nPIP: We can still make the lighthouse by dark.\n\nBEAT 3 — Close on Marta hoisting the rowboat's rope, skeptical, hair escaping her cap.\nMARTA: In THAT boat? It leaks on Tuesdays.\n\nBEAT 4 — The little rowboat pushing off, Pip at the bow like a figurehead, town shrinking behind.\nCAPTION: It was, unfortunately, a Tuesday.\n"
+      },
+      {
+        "path": "characters/pip/sheet.json",
+        "content": "[\n  {\n    \"pose\": \"sitting\",\n    \"file\": \"characters/pip/ref-sit.png\",\n    \"seed\": 411203,\n    \"prompt\": \"wire-haired terrier Pip, sand-yellow coat, mustard scarf, one ear up one folded, sitting on harbor wall, storm-blue background, clean comic ink and flat color\"\n  },\n  {\n    \"pose\": \"running\",\n    \"file\": \"characters/pip/ref-run.png\",\n    \"seed\": 411207,\n    \"prompt\": \"wire-haired terrier Pip, sand-yellow coat, mustard scarf streaming, one ear up one folded, running flat-out, side view, storm-blue background, clean comic ink and flat color\"\n  },\n  {\n    \"pose\": \"determined\",\n    \"file\": \"characters/pip/ref-determined.png\",\n    \"seed\": 411211,\n    \"prompt\": \"wire-haired terrier Pip, close-up, leaning forward, determined brow, mustard scarf, one ear up one folded, storm-blue background, clean comic ink and flat color\"\n  },\n  {\n    \"pose\": \"worried\",\n    \"file\": \"characters/pip/ref-worried.png\",\n    \"seed\": 411219,\n    \"prompt\": \"wire-haired terrier Pip, both ears down, knotted brow, mustard scarf, sitting small, storm-blue background, clean comic ink and flat color\"\n  }\n]\n"
+      },
+      {
+        "path": "characters/pip/ref-sit.png",
+        "content": "placeholder reference image: Pip sitting\n"
+      },
+      {
+        "path": "characters/pip/ref-run.png",
+        "content": "placeholder reference image: Pip running\n"
+      },
+      {
+        "path": "characters/pip/ref-determined.png",
+        "content": "placeholder reference image: Pip determined\n"
+      },
+      {
+        "path": "characters/pip/ref-worried.png",
+        "content": "placeholder reference image: Pip worried\n"
+      }
+    ],
+    "worker": {
+      "name": "Joost",
+      "role": "Verhalenverteller"
+    },
+    "craftbookParams": {
+      "workPath": "tasks/eval"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "pages/3 holds 3+ panel images generated from the kit's anchors and a lettered spread.html whose captions and balloons match the script word for word.",
+    "checks": [
+      {
+        "kind": "fileCount",
+        "ext": [
+          "png"
+        ],
+        "min": 3,
+        "dir": "pages/3"
+      }
+    ],
+    "deliverables": [
+      {
+        "path": "pages/3/spread.html",
+        "kind": "html-page",
+        "minBytes": 1500,
+        "checks": [
+          {
+            "kind": "cssMinBytes",
+            "bytes": 650,
+            "file": "pages/3/spread.html"
+          },
+          {
+            "kind": "contains",
+            "file": "pages/3/spread.html",
+            "pattern": "make the lighthouse by dark",
+            "flags": "i",
+            "label": "Pip's balloon conserved verbatim"
+          },
+          {
+            "kind": "contains",
+            "file": "pages/3/spread.html",
+            "pattern": "The ferry left without them",
+            "flags": "i",
+            "label": "opening caption conserved verbatim"
+          },
+          {
+            "kind": "contains",
+            "file": "pages/3/spread.html",
+            "pattern": "It leaks on Tuesdays",
+            "flags": "i",
+            "label": "Marta's balloon conserved verbatim"
+          },
+          {
+            "kind": "judge",
+            "file": "pages/3/spread.html",
+            "rubric": "The spread lays the panels in reading order with captions and balloons attached to the right panels; the panel plan anchored every figure to the character manifest's references (seeds/prompts) rather than describing the characters from memory.",
+            "sourceFiles": [
+              "story/page-3.md",
+              "characters/pip/sheet.json"
+            ],
+            "label": "continuity and lettering"
+          }
+        ]
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "pages/3/spread.html",
+      "kind": "html"
+    },
+    "axes": [
+      {
+        "name": "continuity",
+        "description": "Figures are generated from the kit's persisted anchors — page 3's Pip is the sheet's Pip, same silhouette, palette, and scarf."
+      },
+      {
+        "name": "panel flow",
+        "description": "Panels follow the script's beats in reading order; the eye never wonders where to go next."
+      },
+      {
+        "name": "lettering",
+        "description": "Captions and balloons are verbatim from the script, placed with their panels, tails pointing at the speaker."
+      },
+      {
+        "name": "storytelling",
+        "description": "Framing choices serve the beats — the wide dock feels empty, the rowboat launch feels small and brave."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "sheet-anchored panels",
+    "verbatim lettering",
+    "reading order"
+  ]
+}

package/data/craftbook-templates/pa/parser-grammar/versions/1.0.2/craftbook.json

@@ -0,0 +1,159 @@
+{
+  "id": "parser-grammar",
+  "name": "Parser / DSL for a Small Grammar",
+  "description": "Build a parser for a small domain-specific language or data format — tokenize, parse to an AST, and report clear errors on malformed input. Designs the grammar FIRST — the token set, the grammar rules (BNF-style), operator precedence, the AST node shapes, and the error strategy — then implements lexer + parser producing the AST, then tests valid inputs parse to the right AST and invalid inputs fail with useful errors. Covers tokenization/lexing, recursive-descent parsing, grammar rules, operator precedence, AST construction, and helpful parse-error messages.\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. Grammar design (planner) — lock tokens, grammar rules, precedence, AST shapes → gated on artifact `{{workPath}}/grammar-design.md` (markdown-notes)\n2. Build the parser (developer) — implement lexer + parser → AST → gated on `src/parser.js` (code-module)\n3. Test the parser (developer) — test valid ASTs and useful error reporting → gated on `src/parser.test.js` (code-with-tests)\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "grammar-design",
+  "triggers": [
+    "build a parser",
+    "parse a dsl",
+    "write a grammar and parser",
+    "tokenize and parse",
+    "make a mini language"
+  ],
+  "steps": [
+    {
+      "id": "grammar-design",
+      "name": "Grammar design",
+      "description": "lock tokens, grammar rules, precedence, AST shapes",
+      "prompt": "Design the grammar before writing the parser. Step 1: Define the TOKEN set (literals, identifiers, operators, keywords, punctuation, whitespace handling). Step 2: Write the grammar rules in a BNF-style notation, and for any expressions, define OPERATOR PRECEDENCE and associativity explicitly. Step 3: Define the AST node shapes the parser will produce for each rule. Step 4: Decide the error strategy: what counts as a syntax error and what a good error message looks like (position + expected). Step 5: Write a numbered acceptance-criteria checklist of 5-9 items with concrete example inputs (e.g. '`1 + 2 * 3` parses with `*` bound tighter than `+`', 'a valid program produces the documented AST', 'unbalanced parens produce a clear error with a position', 'an unexpected token is reported, not swallowed'). `write_task_note` the grammar + AST shapes + examples + checklist and write the same to the produces path.\n\nThe deliverable `{{workPath}}/grammar-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": "planner",
+      "advanceWhen": {
+        "file": "{{workPath}}/grammar-design.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/grammar-design.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/grammar-design.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "grammar-design",
+        "maxAttempts": 3
+      },
+      "next": "build"
+    },
+    {
+      "id": "build",
+      "name": "Build the parser",
+      "description": "implement lexer + parser → AST",
+      "prompt": "Implement the parser to the grammar. Step 1: Write the LEXER that turns source text into a token stream per the token set, tracking positions for error messages. Step 2: Write the PARSER (recursive descent is fine) that consumes tokens and builds the AST per the grammar rules, respecting the defined operator precedence and associativity. Step 3: On malformed input, raise a clear syntax error with the position and what was expected — never silently produce a wrong AST or swallow extra tokens. Step 4: Ensure a fully-consumed valid input yields exactly the documented AST shape. Write the parser to the produces path. On a loop-back, fix only the named gaps. `write_task_note` the file path and which criteria now pass.",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "src/parser.js",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "src/parser.js",
+            "bytes": 200
+          },
+          {
+            "kind": "sniff",
+            "file": "src/parser.js",
+            "sniff": "nonempty"
+          },
+          {
+            "kind": "esmImports",
+            "file": "src/parser.js"
+          },
+          {
+            "kind": "sourceParses",
+            "file": "src/parser.js"
+          }
+        ],
+        "onReject": "build",
+        "maxAttempts": 3
+      },
+      "next": "test"
+    },
+    {
+      "id": "test",
+      "name": "Test the parser",
+      "description": "test valid ASTs and useful error reporting",
+      "prompt": "Write tests from the grammar's example inputs. Step 1: For each valid example, assert the parser produces the EXACT expected AST shape. Step 2: Add precedence tests (e.g. `1 + 2 * 3`) asserting the tree groups operators correctly. Step 3: For malformed inputs (unexpected token, unbalanced delimiters, trailing garbage), assert the parser raises a syntax error that includes a position/expectation — not a generic crash or a silently-wrong AST. Step 4: Assert valid input is fully consumed. `write_task_note` the test file path and pass/fail count.",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "src/parser.test.js",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "src/parser.js",
+            "bytes": 200
+          },
+          {
+            "kind": "sniff",
+            "file": "src/parser.js",
+            "sniff": "nonempty"
+          },
+          {
+            "kind": "esmImports",
+            "file": "src/parser.js"
+          },
+          {
+            "kind": "sourceParses",
+            "file": "src/parser.js"
+          }
+        ],
+        "onReject": "test",
+        "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": "Run the tests and parse sample inputs. For EACH acceptance criterion: confirm valid inputs produce the documented AST, confirm operator precedence/associativity is correct, confirm malformed inputs raise clear positioned errors (not crashes or wrong ASTs), and confirm valid input is fully consumed. Write PASS/FAIL per criterion.\n\nThen route — this is the whole point of the loop:\n\n- **Every criterion PASSES →** call `advance_task_step({ ref, stepId: \"evaluate\", next: \"finish\" })`.\n- **Any criterion FAILS →** write the specific gaps to notes, then call `advance_task_step({ ref, stepId: \"evaluate\", next: \"build\" })` 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": "src/parser.js"
+        }
+      ],
+      "next": "build"
+    },
+    {
+      "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/pa/parser-grammar/versions/1.0.2/test.json

@@ -0,0 +1,95 @@
+{
+  "schemaVersion": 1,
+  "title": "Parser / DSL for a Small Grammar smoke eval",
+  "objective": "Self-contained smoke eval for the Parser / DSL for a Small Grammar craftbook using the code generic harness.",
+  "tags": [
+    "code"
+  ],
+  "prompt": "We need a small Node helper for this — the requirments are in source/requirements.md. Put it in src/solution.mjs.",
+  "setup": {
+    "projectName": "Parser / DSL for a Small Grammar Eval",
+    "about": "Self-contained eval project for parser-grammar. Seeded inputs are under workspace/source or workspace/fixtures; final deliverable is workspace/src/solution.mjs.",
+    "missionObjectives": "Use the Parser / DSL for a Small Grammar craftbook/template, read the seeded local fixtures, and write src/solution.mjs without network calls, real credentials, or live services.",
+    "files": [
+      {
+        "path": "source/brief.md",
+        "content": "# Parser / DSL for a Small Grammar 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: parser-grammar - Parser / DSL for a Small Grammar.\n"
+      },
+      {
+        "path": "source/requirements.md",
+        "content": "# Runner Requirements\n\nBuild a dependency-free Node ESM helper for Boreal Desk support operations. Export at least one function. Include a tiny self-test section using node:assert or an equivalent assertion helper. Use fixture values for 18 -> 6 hour response time and 14.2 -> 8.9 refund leakage.\n"
+      }
+    ],
+    "worker": {
+      "name": "Jules",
+      "role": "Developer"
+    },
+    "craftbookParams": {
+      "workPath": "tasks/eval"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "src/solution.mjs is a local ESM module with basic self-test scaffolding.",
+    "deliverables": [
+      {
+        "path": "src/solution.mjs",
+        "kind": "code-with-tests",
+        "minBytes": 1500,
+        "checks": [
+          {
+            "kind": "esmImports",
+            "file": "src/solution.mjs"
+          },
+          {
+            "kind": "contains",
+            "file": "src/solution.mjs",
+            "pattern": "export\\s+(function|const|class)|export\\s*\\{",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "src/solution.mjs",
+            "pattern": "assert|test|describe|it|expect",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "src/solution.mjs",
+            "pattern": "18|6|14\\.2|8\\.9|Boreal",
+            "flags": "i"
+          }
+        ]
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "src/solution.mjs",
+      "kind": "typescript"
+    },
+    "axes": [
+      {
+        "name": "correctness",
+        "description": "The module does what the requirements ask, with sensible edge handling."
+      },
+      {
+        "name": "verification",
+        "description": "Self-tests exercise real behavior, not trivial truths."
+      },
+      {
+        "name": "clarity",
+        "description": "Exports, naming, and structure make the module usable without reading every line."
+      },
+      {
+        "name": "robustness",
+        "description": "Invalid input and boundary cases fail loudly rather than silently."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "runnable ESM",
+    "test scaffolding",
+    "local fixtures"
+  ]
+}

package/data/craftbook-templates/pe/perf-audit/versions/1.0.2/craftbook.json

@@ -0,0 +1,153 @@
+{
+  "id": "perf-audit",
+  "name": "Performance Audit",
+  "description": "Audit an application or page for performance problems with measurements, then produce a report of the highest-impact optimizations. First scopes the workloads and locks a performance budget and checklist (load time and Core Web Vitals, bundle/asset weight, render and main-thread cost, network waterfall and request count, server/query latency, memory and re-render churn), then MEASURES each against a baseline using real profiling rather than guessing, then writes a report that ranks bottlenecks by impact-vs-effort with a specific fix and the expected gain for each. Use this for a performance audit, speed optimization, finding bottlenecks, a Lighthouse-style review, reducing load time, or profiling slowness — it grounds every recommendation in a measured number and an estimated payoff, not 'it feels slow'.\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 perf budget (reviewer) — lock workloads, a budget, and a metrics checklist → gated on artifact `{{workPath}}/scope.md` (markdown-notes)\n2. Measure the baseline (developer) — profile each workload, locate the real bottlenecks → gated on artifact `{{workPath}}/measure.md` (markdown-notes)\n3. Write the perf report (reviewer) — rank optimizations by impact vs effort → gated on artifact `{{workPath}}/perf-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": [
+    "performance audit",
+    "why is this slow",
+    "find the bottleneck",
+    "optimize load time",
+    "speed this up",
+    "profile the app"
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the perf budget",
+      "description": "lock workloads, a budget, and a metrics checklist",
+      "prompt": "Step 1: Identify the workloads to audit (the slow page/route/endpoint/operation and its typical usage). Step 2: Write a performance acceptance-criteria checklist with concrete budgets, drawn from the relevant metrics: page load and Core Web Vitals (LCP < 2.5s, CLS < 0.1, INP < 200ms), total JS/CSS/image transfer weight, time-to-interactive and main-thread blocking, request count and waterfall serialization, server response and DB query latency (and N+1 detection), and memory growth / excessive re-renders for SPAs. Step 3: For each metric, set the target/budget for THIS app and note the current pain. Step 4: Decide the measurement method and environment (Lighthouse/devtools/profiler/timing logs if available; otherwise read the code and reason about asymptotic and I/O costs). Write the workloads + budgeted checklist + method to `write_task_note` AND `{{workPath}}/scope.md`. No optimizing yet — define 'fast enough' first.\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": "reviewer",
+      "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": "measure"
+    },
+    {
+      "id": "measure",
+      "name": "Measure the baseline",
+      "description": "profile each workload, locate the real bottlenecks",
+      "prompt": "Step 1: Establish a baseline by MEASURING each metric in the checklist (run Lighthouse/devtools/a profiler, time the endpoint, inspect the network waterfall and bundle, log query times). If no live env, statically analyze: bundle composition, algorithmic complexity of hot paths, query patterns, and render triggers. Step 2: For each metric over budget, drill into WHY — which asset is heaviest, which function dominates the flame chart, which query is slow or repeated, which component re-renders needlessly. Step 3: Record the actual numbers (e.g. 'LCP 4.1s; main.js is 480KB, 60% is moment.js+lodash'; 'GET /feed: 1.2s, runs 1+N queries, N≈40'). Step 4: For each bottleneck, identify the fix and ESTIMATE the expected gain and the effort. Step 5: Separate confirmed bottlenecks from suspicions you could not measure. Good looks like: every claim has a number behind it. Stage measurements to `write_task_note`. Do not write the report yet.\n\nThe deliverable `{{workPath}}/measure.md` lands in the project's artifacts drawer — write it with `write_artifact` and read it back with `read_artifact`; the shipped workspace stays untouched.",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "{{workPath}}/measure.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/measure.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/measure.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "measure",
+        "maxAttempts": 3
+      },
+      "next": "report"
+    },
+    {
+      "id": "report",
+      "name": "Write the perf report",
+      "description": "rank optimizations by impact vs effort",
+      "prompt": "Step 1: Open `{{workPath}}/perf-report.md` and write a '## Summary' table of each metric: budget vs measured vs PASS/FAIL. Step 2: Add a '## Recommendations' section ranked by impact-vs-effort; each entry: the bottleneck (with its measured number), the specific fix (e.g. 'code-split the editor route and lazy-load it', 'replace the 1+N with a single JOIN/batch', 'serve images as WebP at 2x and add width/height'), the ESTIMATED gain, and the effort. Step 3: Add a '## Quick wins' callout for the high-impact/low-effort items to do first. Step 4: Add a '## Needs measurement' section for suspicions not yet confirmed. Every recommendation must cite a measured number and an expected payoff — no generic 'optimize images'. On a loop-back, fix only the named gaps. `write_task_note` the report path and the count of failing metrics.\n\nThe deliverable `{{workPath}}/perf-report.md` lands in the project's artifacts drawer — write it with `write_artifact` and read it back with `read_artifact`; the shipped workspace stays untouched.",
+      "suggestedRole": "reviewer",
+      "advanceWhen": {
+        "file": "{{workPath}}/perf-report.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/perf-report.md",
+            "bytes": 1500,
+            "artifact": true
+          },
+          {
+            "kind": "contains",
+            "file": "{{workPath}}/perf-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}}/perf-report.md` and grade it against the scope budget checklist. Check EACH criterion and write PASS/FAIL with a one-line reason: (1) every metric in the budget was measured (number present, not estimated by feel); (2) each metric shows budget vs measured vs pass/fail; (3) each recommendation is tied to a measured bottleneck with a specific fix; (4) each recommendation has an estimated gain and effort; (5) recommendations are ranked by impact vs effort with quick-wins called out; (6) no hand-wavy advice without a number. If any criterion fails, name the exact gap and loop back.\n\nThe deliverable lives in the project's artifacts drawer — open `{{workPath}}/perf-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}}/perf-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"
+}