@bendyline/gilde 0.1.50 → 0.1.52

package/data/craftbook-templates/sp/spreadsheet-model/versions/1.0.3/craftbook.json

@@ -0,0 +1,221 @@
+{
+  "id": "spreadsheet-model",
+  "name": "Spreadsheet / Financial Model",
+  "description": "Build a working spreadsheet-style model (budget, forecast, unit economics, pricing, or scenario calculator) with clearly separated inputs, calculations, and outputs. Scopes the model's purpose, drivers, and assumptions FIRST so the formulas have a contract, then builds the model with live formulas and labeled assumption cells, then verifies the math by hand-checking key outputs and a sanity scenario. Use this for a financial model, budget calculator, ROI/forecast spreadsheet, unit-economics model, or any input-driven calculator.\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 model (planner) — lock the purpose, drivers, assumptions, and outputs → gated on artifact `{{workPath}}/scope.md` (markdown-notes)\n2. Build the model (developer) — implement the model with live formulas and labeled cells → 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": [
+    "build a financial model",
+    "make a budget spreadsheet",
+    "unit economics model",
+    "forecast spreadsheet",
+    "roi calculator"
+  ],
+  "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}}"
+      }
+    }
+  },
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the model",
+      "description": "lock the purpose, drivers, assumptions, and outputs",
+      "prompt": "Define the model's contract before building. Step 1: state the question the model answers and the single primary output (e.g. 'monthly net profit', '12-month cash runway'). Step 2: list the input drivers (assumptions a user changes) with a default value and unit for each. Step 3: list the calculated rows and the formula logic in words ('revenue = units * price'; 'gross margin = revenue - COGS'). Step 4: define the time axis or scenario columns if any. Step 5: write an acceptance-criteria checklist ('inputs, calcs, and outputs are visually separated', 'every assumption is a labeled editable cell', 'totals reconcile', 'changing an input flows through to the output', 'a documented sanity scenario produces the expected value'). Call write_task_note and write the driver list + formula logic + checklist to {{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": "build",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "audio",
+          "browser-automation",
+          "code-execution",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web",
+          "workspace-fs-write"
+        ],
+        "outputMedium": "artifact",
+        "additionalOutputMedia": [
+          "task-note"
+        ]
+      }
+    },
+    {
+      "id": "build",
+      "name": "Build the model",
+      "description": "implement the model with live formulas and labeled cells",
+      "prompt": "Build the model as a single interactive index.html that behaves like a spreadsheet. Step 1: lay out three clearly labeled zones — Assumptions (editable inputs), Calculations, and Outputs. Step 2: implement every calculated row with a live formula derived from the inputs (changing an input recomputes downstream values in the page). Step 3: label each cell with its name and unit; format currency/percent appropriately. Step 4: add the time/scenario columns from the scope and ensure totals sum correctly. Step 5: seed the default assumptions and show the primary output prominently. On a loop-back, fix only the named gaps. Call write_task_note with the path and the computed default output.",
+      "suggestedRole": "developer",
+      "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": "build",
+        "maxAttempts": 4
+      },
+      "next": "evaluate",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "artifacts",
+          "audio",
+          "browser-automation",
+          "code-execution",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web"
+        ],
+        "outputMedium": "workspace",
+        "additionalOutputMedia": [
+          "task-note"
+        ]
+      }
+    },
+    {
+      "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 index.html and exercise it as a spreadsheet, verifying the math, not just the layout. Step 1: confirm inputs, calculations, and outputs are visually separated and every assumption is a labeled, editable cell with a unit. Step 2: independently compute the primary output by hand from the default assumptions and confirm the model agrees. Step 3: change one driver to a round number, re-derive the expected output by hand, and confirm the model recomputes to it live (the flow-through works). Step 4: run the documented sanity scenario and check it hits the expected value. Step 5: confirm totals reconcile (subtotals sum to totals) and no calculated value is hardcoded where it should reference an input. Write PASS/FAIL per criterion; any FAIL loops back to build.\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": "index.html"
+        }
+      ],
+      "next": "build",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "artifacts",
+          "audio",
+          "browser-automation",
+          "code-execution",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web",
+          "workspace-fs-write"
+        ],
+        "outputMedium": "task-note"
+      }
+    },
+    {
+      "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,
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "artifacts",
+          "audio",
+          "browser-automation",
+          "code-execution",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web",
+          "workspace-fs-write"
+        ],
+        "outputMedium": "task-note"
+      }
+    }
+  ],
+  "version": "1.0.3",
+  "releasedAt": "2026-09-01T20:00:00Z",
+  "minGezelVersion": "1.26233"
+}

package/data/craftbook-templates/sp/spreadsheet-model/versions/1.0.3/test.json

@@ -0,0 +1,160 @@
+{
+  "schemaVersion": 1,
+  "title": "Spreadsheet / Financial Model smoke eval",
+  "objective": "Measure whether the spreadsheet-model craftbook rolls a seeded record set up CORRECTLY (checked against a harness-owned arithmetic oracle rather than digit-substring matching) and turns the roll-up into a decision-useful read-out.",
+  "tags": [
+    "data"
+  ],
+  "prompt": "I dropped our numbers in `source/records.csv`. Work them up into a small model and a written read-out.\n\n1. `data/model.json` — the computed roll-ups, using EXACTLY this schema. Money is whole US dollars, shares are percentages rounded to 2 decimal places:\n```json\n{\n  \"totals\": { \"orders\": 0, \"revenue_usd\": 0, \"avg_revenue_per_order_usd\": 0 },\n  \"by_region\": { \"North\": { \"orders\": 0, \"revenue_usd\": 0 },\n                 \"South\": { \"orders\": 0, \"revenue_usd\": 0 },\n                 \"West\":  { \"orders\": 0, \"revenue_usd\": 0 } },\n  \"top_customer_by_revenue\": \"\",\n  \"high_risk_revenue_usd\": 0,\n  \"high_risk_revenue_share_pct\": 0.0\n}\n```\n`high_risk_*` covers only rows whose `churn_risk` is `high`.\n\n2. `analysis.md` — a short analysis for operations leads that restates those figures, names the concentration risk, and recommends a next action. Use only the figures in `data/model.json`; do not introduce new numbers.",
+  "setup": {
+    "projectName": "Spreadsheet / Financial Model Eval",
+    "about": "Self-contained eval project for spreadsheet-model. Seeded inputs are under workspace/source or workspace/fixtures; final deliverable is workspace/analysis.md.",
+    "missionObjectives": "Compute data/model.json under the locked schema from source/records.csv, then write analysis.md restating those figures with a concentration-risk finding and a next action.",
+    "files": [
+      {
+        "path": "source/brief.md",
+        "content": "# Spreadsheet / Financial Model 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: spreadsheet-model - Spreadsheet / Financial Model.\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"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "data/model.json carries the correct roll-ups under the locked schema and analysis.md restates them with the single-account concentration risk called out.",
+    "deliverables": [
+      {
+        "path": "data/model.json",
+        "kind": "json",
+        "minBytes": 120,
+        "checks": [
+          {
+            "kind": "jsonPathEquals",
+            "file": "data/model.json",
+            "path": "totals.orders",
+            "value": 40,
+            "label": "12 + 8 + 15 + 5 = 40 orders"
+          },
+          {
+            "kind": "jsonPathEquals",
+            "file": "data/model.json",
+            "path": "totals.revenue_usd",
+            "value": 4760,
+            "label": "1440 + 720 + 2100 + 500 = 4,760"
+          },
+          {
+            "kind": "jsonPathEquals",
+            "file": "data/model.json",
+            "path": "totals.avg_revenue_per_order_usd",
+            "value": 119,
+            "label": "4,760 / 40 = 119 per order"
+          },
+          {
+            "kind": "jsonPathEquals",
+            "file": "data/model.json",
+            "path": "by_region.North.orders",
+            "value": 17,
+            "label": "North is Aster (12) + Dune (5)"
+          },
+          {
+            "kind": "jsonPathEquals",
+            "file": "data/model.json",
+            "path": "by_region.North.revenue_usd",
+            "value": 1940,
+            "label": "North is 1440 + 500 = 1,940"
+          },
+          {
+            "kind": "jsonPathEquals",
+            "file": "data/model.json",
+            "path": "by_region.West.revenue_usd",
+            "value": 2100,
+            "label": "West is Cedar alone"
+          },
+          {
+            "kind": "jsonPathEquals",
+            "file": "data/model.json",
+            "path": "top_customer_by_revenue",
+            "value": "Cedar",
+            "label": "Cedar is the largest account by revenue"
+          },
+          {
+            "kind": "jsonPathEquals",
+            "file": "data/model.json",
+            "path": "high_risk_revenue_usd",
+            "value": 2100,
+            "label": "only Cedar carries churn_risk=high"
+          },
+          {
+            "kind": "jsonPathEquals",
+            "file": "data/model.json",
+            "path": "high_risk_revenue_share_pct",
+            "value": 44.12,
+            "label": "2100 / 4760 = 44.12% of revenue sits in one high-risk account"
+          }
+        ]
+      },
+      {
+        "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": "\\$?4,?760\\b",
+            "flags": "i",
+            "label": "restate total revenue of 4,760"
+          },
+          {
+            "kind": "contains",
+            "file": "analysis.md",
+            "pattern": "Cedar",
+            "flags": "i",
+            "label": "name Cedar as the top-revenue, high-churn-risk account"
+          }
+        ]
+      }
+    ]
+  },
+  "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/sp/sprite-sheet/versions/1.0.2/test.json

@@ -23,9 +23,6 @@
     "worker": {
       "name": "Jules",
       "role": "Producer"
-    },
-    "craftbookParams": {
-      "workPath": "tasks/eval"
     }
   },
   "mocks": [],

package/data/craftbook-templates/sp/sprite-sheet/versions/1.0.3/craftbook.json

@@ -0,0 +1,271 @@
+{
+  "id": "sprite-sheet",
+  "name": "Game Sprite Sheet",
+  "description": "Produce a game-ready sprite sheet — a character or object with its animation frames (idle, walk, jump, attack) on a uniform grid — plus the frame metadata (JSON atlas) a game engine needs to slice it. Lock the style and the frame inventory FIRST (cell size, pivot, palette, which animations and how many frames each) because a sprite sheet is only usable if every cell is the same size and the pivot is consistent; then generate the frames and pack them into a sheet with a matching atlas. Covers sprite sheets, game art, animation frames, texture atlases, pixel-art characters, and 2D game assets.\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. Style & frame scope (game-designer) — lock cell size, pivot, palette, and frame inventory → gated on artifact `{{workPath}}/style-scope.md` (markdown-notes)\n2. Generate frames (image-generator) — draw each animation frame on the uniform cell → gated on `assets` (image-set)\n3. Pack the sheet + atlas (developer) — compose the grid sheet and emit the JSON atlas → gated on `atlas.json` (json)\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "style-scope",
+  "triggers": [
+    "make a sprite sheet",
+    "game character sprites",
+    "animation frames for a game",
+    "texture atlas",
+    "pixel art sprite sheet"
+  ],
+  "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}}"
+      }
+    }
+  },
+  "steps": [
+    {
+      "id": "style-scope",
+      "name": "Style & frame scope",
+      "description": "lock cell size, pivot, palette, and frame inventory",
+      "prompt": "1) Lock the sprite style: pixel-art vs vector, the uniform CELL size (e.g. 32x32), the pivot/anchor convention (e.g. bottom-center for ground contact), and a tight palette. 2) Enumerate the animation set and frame counts: e.g. idle (2), walk (4), jump (2), attack (3) — name each and its frame order. 3) Decide sheet layout (one animation per row) and the atlas format (a JSON listing each frame's x/y/w/h and animation grouping). 4) Write an acceptance-criteria checklist: 'all cells are exactly NxN', 'pivot is consistent across frames', 'every named animation has its frame count', 'the JSON atlas indexes every frame', 'frames in an animation read as a smooth loop'. 5) Record style + inventory + checklist via write_task_note AND to {{workPath}}/style-scope.md. No art yet.\n\nThe deliverable `{{workPath}}/style-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": "game-designer",
+      "advanceWhen": {
+        "file": "{{workPath}}/style-scope.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/style-scope.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/style-scope.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "style-scope",
+        "maxAttempts": 3
+      },
+      "next": "generate",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "audio",
+          "browser-automation",
+          "code-execution",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web",
+          "workspace-fs-write"
+        ],
+        "outputMedium": "artifact",
+        "additionalOutputMedia": [
+          "task-note"
+        ]
+      }
+    },
+    {
+      "id": "generate",
+      "name": "Generate frames",
+      "description": "draw each animation frame on the uniform cell",
+      "prompt": "1) Read style-scope.md. 2) Draw each frame on the locked cell size with the consistent pivot — the character's feet (or chosen anchor) must sit at the same point every frame so it doesn't jitter when animated. 3) Keep the palette and silhouette consistent across frames; within an animation, make consecutive frames flow (a clean loop for walk/idle). 4) Produce frames for every named animation and frame count. 5) Save the individual frames and/or the packed sheet into assets/ (e.g. assets/spritesheet.png plus frames if helpful). 6) Sanity-check by mentally flipping through each animation. Good looks like: cells that, played in order, animate smoothly with no pivot drift.",
+      "suggestedRole": "image-generator",
+      "advanceWhen": {
+        "file": "assets",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "fileCount",
+            "ext": [
+              "png",
+              "jpg",
+              "jpeg",
+              "svg",
+              "webp"
+            ],
+            "min": 3,
+            "dir": "assets"
+          }
+        ],
+        "onReject": "generate",
+        "maxAttempts": 3
+      },
+      "next": "pack",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "artifacts",
+          "audio",
+          "browser-automation",
+          "code-execution",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web"
+        ],
+        "outputMedium": "workspace"
+      }
+    },
+    {
+      "id": "pack",
+      "name": "Pack the sheet + atlas",
+      "description": "compose the grid sheet and emit the JSON atlas",
+      "prompt": "1) Compose all frames into a single sprite sheet image laid out one animation per row on the uniform grid (no padding drift between cells). 2) Emit a JSON atlas at the agreed path: for each frame, its name, x/y/w/h on the sheet, and which animation + order it belongs to; group frames by animation. 3) Build a tiny index.html preview that loads the sheet and plays each animation by stepping its frames (a simple setInterval) so the loop is verifiable. 4) Ensure the atlas JSON parses and every frame's rect actually lands on a real cell. 5) On a loop-back, fix only named gaps (misaligned cell, missing frame, wrong rect). 6) write_task_note the sheet path, atlas path, and frame totals. The gated deliverable is the JSON atlas.",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "atlas.json",
+        "minBytes": 1,
+        "sniff": "json-valid"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "atlas.json",
+            "bytes": 2
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkJsonValid",
+            "scope": "standard",
+            "inputs": {
+              "file": "atlas.json"
+            }
+          }
+        ],
+        "onReject": "pack",
+        "maxAttempts": 4
+      },
+      "next": "evaluate",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "artifacts",
+          "audio",
+          "browser-automation",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web"
+        ],
+        "outputMedium": "workspace",
+        "additionalOutputMedia": [
+          "task-note"
+        ]
+      }
+    },
+    {
+      "id": "evaluate",
+      "name": "Evaluate",
+      "description": "Grade the deliverable against every acceptance criterion. All pass → finish; any fail → loop back and fix the gap.",
+      "prompt": "1) Confirm assets/ holds the sprite sheet and atlas.json parses as valid JSON (PASS/FAIL). 2) Check the atlas against style-scope.md: every named animation present with its frame count, every frame rect is NxN on a real cell (PASS/FAIL). 3) Open the preview (or trace the sheet) — do frames in each animation align to a consistent pivot and read as a smooth loop (PASS/FAIL)? 4) Confirm cell sizes are uniform with no drift. 5) Write PASS/FAIL per criterion. Misalignment/missing frames → loop back to pack (or generate if art is wrong).\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: \"pack\" })` 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": "atlas.json"
+        }
+      ],
+      "next": "pack",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "artifacts",
+          "audio",
+          "browser-automation",
+          "code-execution",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web",
+          "workspace-fs-write"
+        ],
+        "outputMedium": "task-note"
+      }
+    },
+    {
+      "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,
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "artifacts",
+          "audio",
+          "browser-automation",
+          "code-execution",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web",
+          "workspace-fs-write"
+        ],
+        "outputMedium": "task-note"
+      }
+    }
+  ],
+  "version": "1.0.3",
+  "releasedAt": "2026-09-01T20:00:00Z",
+  "minGezelVersion": "1.26233"
+}