@bendyline/gilde 0.1.38 → 0.1.40

package/data/craftbook-templates/cr/cron-job/versions/1.0.2/test.json

@@ -0,0 +1,107 @@
+{
+  "schemaVersion": 1,
+  "title": "Scheduled Batch Job smoke eval",
+  "objective": "Self-contained smoke eval for the Scheduled Batch Job 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": "Scheduled Batch Job Eval",
+    "about": "Self-contained eval project for cron-job. Seeded inputs are under workspace/source or workspace/fixtures; final deliverable is workspace/analysis.md.",
+    "missionObjectives": "Use the Scheduled Batch Job 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": "# Scheduled Batch Job 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: cron-job - Scheduled Batch Job.\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/cr/crossword-forge/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "crossword-forge",
   "role": "general",
+  "category": "design",
   "name": "Forge a Crossword",
   "description": "Construct a personalized crossword and prove it works before anyone's pencil touches it: the grid actually interlocks, every entry sits in the grid exactly where its number says, every clue is tuned to the solver — and the whole thing ships as a printable page with the solution kept decently out of sight. Locks the theme and the word list FIRST, then constructs the mechanically-verified grid, then renders the printable puzzle. Use for making a crossword, a personalized puzzle for the family, 'a crossword with the grandkids' names in it', and printable puzzle gifts.",
   "tags": [

package/data/craftbook-templates/cr/crossword-forge/versions/1.0.2/craftbook.json

@@ -0,0 +1,176 @@
+{
+  "id": "crossword-forge",
+  "name": "Forge a Crossword",
+  "description": "Construct a personalized crossword and prove it works before anyone's pencil touches it: the grid actually interlocks, every entry sits in the grid exactly where its number says, every clue is tuned to the solver — and the whole thing ships as a printable page with the solution kept decently out of sight. Locks the theme and the word list FIRST, then constructs the mechanically-verified grid, then renders the printable puzzle. Use for making a crossword, a personalized puzzle for the family, 'a crossword with the grandkids' names in it', and printable puzzle gifts.\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 puzzle (puzzle-maker) — theme and word list from the personal material, construction rules → gated on artifact `{{workPath}}/scope.md` (markdown-notes)\n2. Construct the grid (developer) — verified puzzle data — grid, entries, clues → gated on `puzzle.json` (json)\n3. Render the printable page (developer) — printable grid and clues, solution out of sight, shelf copy filed → gated on `puzzle.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": [
+    "make a crossword",
+    "crossword for the family",
+    "personalized crossword puzzle",
+    "forge a crossword",
+    "printable crossword"
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the puzzle",
+      "description": "theme and word list from the personal material, construction rules",
+      "prompt": "Set the build before placing a letter. Step 1: gather the personal material — the task's params (theme, names, size) and any notes in the workspace about the solvers: names, places, pets, running jokes. Step 2: draft the word list — the personal entries first, filler words only where the grid needs them to interlock, everything spellable in plain uppercase letters. Step 3: lock the construction rules — grid size from the size param (small about 9x9, medium about 13x13, large about 15x15), every entry placed in the grid and crossing at least one other entry, no entry without a clue, clue difficulty tuned to the solvers. Step 4: write an acceptance-criteria checklist ('every entry reads out of the grid at its stated coordinates', 'every crossing agrees letter for letter', 'every entry has a clue at the target difficulty', 'the personal words made it into the grid', 'the rendered page prints cleanly with the solution out of casual sight'). Call write_task_note with the theme + word 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": "puzzle-maker",
+      "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": "construct"
+    },
+    {
+      "id": "construct",
+      "name": "Construct the grid",
+      "description": "verified puzzle data — grid, entries, clues",
+      "prompt": "Construct the puzzle as data at puzzle.json. Step 1: build the grid — uppercase letters in filled cells, '.' for blocks — placing every word from the locked list so the entries interlock. Step 2: write it as JSON with this exact shape: { \"title\": ..., \"size\": { \"rows\": N, \"cols\": N }, \"grid\": [ one string per row ], \"entries\": [ { \"number\", \"answer\", \"row\", \"col\", \"direction\": \"across\" or \"down\", \"clue\" } ] } — rows and columns zero-indexed from the top-left. Step 3: verify your own work cell by cell before completing — every answer must read out of the grid exactly at its coordinates and every crossing letter must agree; the gate re-checks this mechanically and names any entry that lies. Step 4: write the clues into the entries — personal entries clued with the in-jokes, fillers clued honestly at the target difficulty. Call write_task_note with the grid size and the entry count.",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "puzzle.json",
+        "minBytes": 1,
+        "sniff": "json-valid"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "puzzle.json",
+            "bytes": 400
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkJsonValid",
+            "scope": "standard",
+            "inputs": {
+              "file": "puzzle.json"
+            }
+          }
+        ],
+        "onReject": "construct",
+        "maxAttempts": 3
+      },
+      "next": "render"
+    },
+    {
+      "id": "render",
+      "name": "Render the printable page",
+      "description": "printable grid and clues, solution out of sight, shelf copy filed",
+      "prompt": "Render the playable, printable page at puzzle.html. Step 1: draw the empty numbered grid from puzzle.json — blocks and cell numbers exactly as the data has them — beside the across and down clue lists. Step 2: make it print-ready — an @page rule, print styles, the grid sized so a pencil fits in the squares. Step 3: keep the solution out of casual sight — behind a toggle on screen and on its own page in print, never beside the blank grid. Step 4: any script on the page must actually run — check it before completing. Step 5: file a dated copy of puzzle.json and puzzle.html into the puzzles/ shelf named for the theme, so the pack-layout ritual can find them later. Call write_task_note with the page path and the shelf copies.",
+      "suggestedRole": "developer",
+      "consumes": [
+        {
+          "file": "puzzle.json"
+        }
+      ],
+      "advanceWhen": {
+        "file": "puzzle.html",
+        "minBytes": 1,
+        "sniff": "html-complete"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "puzzle.html",
+            "bytes": 800
+          },
+          {
+            "kind": "htmlLint",
+            "file": "puzzle.html"
+          },
+          {
+            "kind": "cssMinBytes",
+            "bytes": 650,
+            "file": "puzzle.html"
+          },
+          {
+            "kind": "contains",
+            "file": "puzzle.html",
+            "pattern": "@page|@media\\s+print",
+            "flags": "i",
+            "label": "print CSS"
+          },
+          {
+            "kind": "jsParses",
+            "file": "puzzle.html"
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkHtmlComplete",
+            "scope": "standard",
+            "inputs": {
+              "file": "puzzle.html"
+            }
+          }
+        ],
+        "onReject": "render",
+        "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 puzzle.json and puzzle.html and verify every criterion from {{workPath}}/scope.md: read three entries out of the grid by their coordinates and confirm each matches its answer, check one crossing square agrees in both directions, confirm every entry has a clue and the personal words from the scope made it in, and check the rendered page — the grid matches the data, the clue numbers line up, and the solution stays out of sight on screen and in print. Write PASS/FAIL per criterion; on any failure, name the entry or cell and loop back to construct.\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: \"construct\" })` 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": "puzzle.html"
+        }
+      ],
+      "next": "construct"
+    },
+    {
+      "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/cr/crossword-forge/versions/1.0.2/test.json

@@ -0,0 +1,138 @@
+{
+  "schemaVersion": 1,
+  "title": "Forge a Crossword — personal words to a verified printable grid",
+  "objective": "Measure whether the crossword-forge craftbook constructs a mechanically-valid interlocking crossword from the seeded family notes — entries readable out of the grid at their coordinates, every entry clued — rendered as a printable page with the solution out of sight.",
+  "tags": [
+    "html-page"
+  ],
+  "prompt": "can you make a crossword for the grandkids with there names and our dog in it? printable pls",
+  "setup": {
+    "projectName": "Loon Lake Puzzle Almanac",
+    "about": "Puzzle almanac project for the Halloran family. Notes about the solvers live at workspace/notes/family.md; finished puzzles are filed on the workspace/puzzles shelf. The working puzzle is workspace/puzzle.json with its printable page at workspace/puzzle.html.",
+    "missionObjectives": "The grid must actually interlock and verify — every entry readable out of the grid at its coordinates, every entry clued. Personalization comes from the family notes. No live services, no real credentials.",
+    "files": [
+      {
+        "path": "tasks/eval/family.md",
+        "content": "# The solvers\n\nGrandkids: Nora (12, reigning flashlight-tag champion), Felix (10, dinosaur phase never ended),\nImani (9, reads above her grade and knows it), Theo (7, will need help with the long ones).\n\nThe dog: Biscuit — golden retriever, eats crayons, beloved.\n\nPlaces: the cabin at Loon Lake, the porch swing, Grandpa's garden.\n\nRunning jokes: Grandpa's burnt pancakes, the canoe that tipped twice in one day,\nflashlight tag after dark, \"who fed Biscuit already?\"\n"
+      },
+      {
+        "path": "checks/verify-puzzle.mjs",
+        "content": "// Eval-only re-check: verifies puzzle.json is a real, solvable crossword.\n// Exits 0 and prints PUZZLE OK when every entry reads out of the grid at its\n// coordinates, every entry has a clue, and the entries interlock.\nimport { readFileSync } from 'node:fs';\n\nfunction fail(message) {\n  console.error('PUZZLE BROKEN: ' + message);\n  process.exit(1);\n}\n\nlet puzzle;\ntry {\n  puzzle = JSON.parse(readFileSync('puzzle.json', 'utf8'));\n} catch (err) {\n  fail('puzzle.json missing or not valid JSON (' + err.message + ')');\n}\n\nconst grid = puzzle.grid;\nif (!Array.isArray(grid) || grid.length < 5 || !grid.every((r) => typeof r === 'string')) {\n  fail('grid must be an array of at least 5 row strings');\n}\nconst width = grid[0].length;\nfor (let r = 0; r < grid.length; r++) {\n  if (grid[r].length !== width) fail('row ' + r + ' width differs from row 0');\n  if (!/^[A-Z.]+$/.test(grid[r])) fail('row ' + r + ' has characters outside A-Z and \".\"');\n}\n\nconst entries = puzzle.entries;\nif (!Array.isArray(entries) || entries.length < 4) fail('need at least 4 entries');\n\nconst owners = new Map();\nlet across = 0;\nlet down = 0;\nfor (const e of entries) {\n  const label = typeof e.answer === 'string' && e.answer ? e.answer : 'entry #' + (e.number ?? '?');\n  if (typeof e.answer !== 'string' || !/^[A-Z]{2,}$/.test(e.answer)) fail(label + ': bad answer');\n  if (e.direction !== 'across' && e.direction !== 'down') fail(label + ': bad direction');\n  if (!Number.isInteger(e.row) || !Number.isInteger(e.col)) fail(label + ': bad coordinates');\n  if (typeof e.clue !== 'string' || e.clue.trim().length === 0) fail(label + ': missing clue');\n  if (e.direction === 'across') across++;\n  else down++;\n  for (let i = 0; i < e.answer.length; i++) {\n    const r = e.direction === 'down' ? e.row + i : e.row;\n    const c = e.direction === 'across' ? e.col + i : e.col;\n    if (r < 0 || r >= grid.length || c < 0 || c >= width) fail(label + ' runs off the grid');\n    if (grid[r][c] !== e.answer[i]) {\n      fail(label + ': grid has \"' + grid[r][c] + '\" at ' + r + ',' + c + ' expected \"' + e.answer[i] + '\"');\n    }\n    const key = r + ',' + c;\n    if (!owners.has(key)) owners.set(key, new Set());\n    owners.get(key).add(e.direction + ':' + label);\n  }\n}\nif (across === 0 || down === 0) fail('need both across and down entries');\n\nfor (const e of entries) {\n  let interlocks = false;\n  for (let i = 0; i < e.answer.length && !interlocks; i++) {\n    const r = e.direction === 'down' ? e.row + i : e.row;\n    const c = e.direction === 'across' ? e.col + i : e.col;\n    for (const owner of owners.get(r + ',' + c) ?? []) {\n      if (!owner.startsWith(e.direction + ':')) interlocks = true;\n    }\n  }\n  if (!interlocks) fail(e.answer + ' does not cross any other entry');\n}\n\nconsole.log('PUZZLE OK: ' + entries.length + ' entries (' + across + ' across, ' + down + ' down) verified');\n"
+      }
+    ],
+    "worker": {
+      "name": "Wouter",
+      "role": "Puzzle maker"
+    },
+    "craftbookParams": {
+      "workPath": "tasks/eval"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "puzzle.json is a verified interlocking crossword carrying the personal words; puzzle.html is a printable page with clue lists and the solution kept out of sight.",
+    "deliverables": [
+      {
+        "path": "puzzle.json",
+        "kind": "json",
+        "minBytes": 400,
+        "checks": [
+          {
+            "kind": "sniff",
+            "file": "puzzle.json",
+            "sniff": "json-valid"
+          },
+          {
+            "kind": "nodeScriptPasses",
+            "script": "checks/verify-puzzle.mjs",
+            "timeoutMs": 5000,
+            "requiredOutput": [
+              {
+                "pattern": "PUZZLE OK",
+                "label": "grid verifies as solvable"
+              }
+            ]
+          },
+          {
+            "kind": "contains",
+            "file": "puzzle.json",
+            "pattern": "NORA|FELIX|IMANI|THEO",
+            "label": "a grandkid name made the grid"
+          },
+          {
+            "kind": "contains",
+            "file": "puzzle.json",
+            "pattern": "BISCUIT",
+            "label": "the dog made the grid"
+          }
+        ]
+      },
+      {
+        "path": "puzzle.html",
+        "kind": "html-page",
+        "minBytes": 2000,
+        "checks": [
+          {
+            "kind": "cssMinBytes",
+            "bytes": 650,
+            "file": "puzzle.html"
+          },
+          {
+            "kind": "jsParses",
+            "file": "puzzle.html"
+          },
+          {
+            "kind": "contains",
+            "file": "puzzle.html",
+            "pattern": "@page|@media\\s+print",
+            "flags": "i",
+            "label": "print CSS"
+          },
+          {
+            "kind": "contains",
+            "file": "puzzle.html",
+            "pattern": "Across",
+            "flags": "i",
+            "label": "across clue list"
+          },
+          {
+            "kind": "contains",
+            "file": "puzzle.html",
+            "pattern": "Down",
+            "flags": "i",
+            "label": "down clue list"
+          }
+        ]
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "puzzle.html",
+      "kind": "html"
+    },
+    "axes": [
+      {
+        "name": "solvability",
+        "description": "The grid interlocks and the clue numbering matches the grid — a solver could actually finish it."
+      },
+      {
+        "name": "personalization",
+        "description": "The names, the dog, and the running jokes from the family notes carry the puzzle; fillers stay in the background."
+      },
+      {
+        "name": "clue craft",
+        "description": "Clues are tuned to the solvers — in-jokes for the personal entries, honest difficulty for the fillers, help-sized for the youngest."
+      },
+      {
+        "name": "print readiness",
+        "description": "The page prints with pencil-sized squares and the solution on its own page, never beside the blank grid."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "verified interlocking grid",
+    "grounded personalization",
+    "solution out of sight"
+  ]
+}

package/data/craftbook-templates/cs/csv-transformer/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "csv-transformer",
   "role": "general",
+  "category": "code-data",
   "name": "CSV / Tabular Transformer",
   "description": "Reshape and convert tabular data from one schema to another: rename and reorder columns, split or merge fields, derive new columns, pivot/unpivot, change format (CSV<->JSON<->TSV), and filter rows. Locks the input and target schema and the field-by-field mapping FIRST (so the transform is a contract, not guesswork), then builds the transform and emits the output, then verifies row counts and a sample mapping. Use this for reshaping a CSV, converting data formats, remapping columns, flattening JSON to a table, or reformatting an export for another tool.",
   "tags": [

package/data/craftbook-templates/cs/csv-transformer/versions/1.2.3/craftbook.json

@@ -0,0 +1,113 @@
+{
+  "id": "csv-transformer",
+  "name": "CSV / Tabular Transformer",
+  "description": "Reshape and convert tabular data from one schema to another: rename and reorder columns, split or merge fields, derive new columns, pivot/unpivot, change format (CSV<->JSON<->TSV), and filter rows. Locks the input and target schema and the field-by-field mapping FIRST (so the transform is a contract, not guesswork), then builds the transform and emits the output, then verifies row counts and a sample mapping. Use this for reshaping a CSV, converting data formats, remapping columns, flattening JSON to a table, or reformatting an export for another tool.\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 schema mapping (planner) — lock the input schema, target schema, and field-by-field mapping → gated on artifact `{{workPath}}/schema-scope.md` (markdown-notes)\n2. Build the transform (developer) — apply the mapping and emit the target file → gated on `data/output.csv` (data-file)\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "schema-scope",
+  "triggers": [
+    "reshape a csv",
+    "convert csv to json",
+    "remap columns",
+    "transform tabular data",
+    "reformat a data export"
+  ],
+  "steps": [
+    {
+      "id": "schema-scope",
+      "name": "Scope the schema mapping",
+      "description": "lock the input schema, target schema, and field-by-field mapping",
+      "prompt": "Define the transform contract before writing any code. Step 1: document the INPUT schema (columns, types, format/delimiter) from a sample of the source. Step 2: document the TARGET schema (columns, types, order, output format). Step 3: write the field-by-field mapping table: each target column = which source column(s) and the transform (rename, cast, split on delimiter, concatenate, derive via formula, constant). Step 4: define row-level rules — filters to apply, dedup, how to handle missing source values, and pivot/unpivot if the shape changes. Step 5: write an acceptance-criteria checklist ('output has exactly the target columns in order', 'output parses in the target format', 'row count matches the filter rule', 'a sampled row maps correctly end-to-end', 'no data type errors'). Call write_task_note and write the mapping table + rules + checklist to {{workPath}}/schema-scope.md.\n\nThe deliverable `{{workPath}}/schema-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}}/schema-scope.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/schema-scope.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/schema-scope.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "schema-scope",
+        "maxAttempts": 3
+      },
+      "next": "build"
+    },
+    {
+      "id": "build",
+      "name": "Build the transform",
+      "description": "apply the mapping and emit the target file",
+      "prompt": "Implement the transform exactly to the mapping table. Step 1: read the input with the correct delimiter/encoding. Step 2: apply each target column's rule in order (rename, cast, split/join, derive, constant); reshape (pivot/unpivot) if specified. Step 3: apply row filters and dedup; track rows-in vs rows-out and the reason for any drop. Step 4: write the output to data/output.csv (or the requested format/extension) with the target columns in the exact specified order and a header row. Step 5: ensure the output parses (valid CSV/JSON) and types are clean (no '1.0' where an int is expected). On a loop-back, fix only the named gaps. Call write_task_note with the path and rows-in/rows-out.",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "data/output.csv",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "data/output.csv",
+            "bytes": 120
+          },
+          {
+            "kind": "sniff",
+            "file": "data/output.csv",
+            "sniff": "data-table"
+          }
+        ],
+        "onReject": "build",
+        "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 data/output.csv and verify it matches the schema-scope contract. Step 1: confirm it parses in the target format and has EXACTLY the target columns in the specified order. Step 2: re-count the rows and reconcile against input — the count must equal input rows after the documented filter/dedup, with the delta explained. Step 3: pick 3 source rows and trace them through the mapping by hand to confirm each target field is correct end-to-end. Step 4: scan for type errors (e.g. '1.0' where an int is expected) and stray nulls the mapping didn't intend. 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": "data/output.csv"
+        }
+      ],
+      "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.2.3",
+  "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"
+}