@bendyline/gilde 0.1.37 → 0.1.39

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

@@ -0,0 +1,149 @@
+{
+  "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"
+  ],
+  "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"
+    },
+    {
+      "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"
+    },
+    {
+      "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"
+    },
+    {
+      "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"
+    },
+    {
+      "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/sp/sprite-sheet/versions/1.0.2/test.json

@@ -0,0 +1,106 @@
+{
+  "schemaVersion": 1,
+  "title": "Game Sprite Sheet smoke eval",
+  "objective": "Self-contained smoke eval for the Game Sprite Sheet craftbook using the media generic harness.",
+  "tags": [
+    "media"
+  ],
+  "prompt": "Our media files are all listd in source/media-index.csv. Can you put together the production plan for them as media-plan.json?",
+  "setup": {
+    "projectName": "Game Sprite Sheet Eval",
+    "about": "Self-contained eval project for sprite-sheet. Seeded inputs are under workspace/source or workspace/fixtures; final deliverable is workspace/media-plan.json.",
+    "missionObjectives": "Use the Game Sprite Sheet craftbook/template, read the seeded local fixtures, and write media-plan.json without network calls, real credentials, or live services.",
+    "files": [
+      {
+        "path": "source/brief.md",
+        "content": "# Game Sprite Sheet 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: sprite-sheet - Game Sprite Sheet.\n"
+      },
+      {
+        "path": "source/media-index.csv",
+        "content": "filename,type,duration_or_size,notes\npilot-interview.wav,audio,00:02:15,mentions response time and status silence\nreturns-desk.png,image,1600x900,shows intake form and photo evidence step\nlaunch-clip.mp4,video,00:01:05,shows barcode exception handling\n"
+      }
+    ],
+    "worker": {
+      "name": "Jules",
+      "role": "Producer"
+    },
+    "craftbookParams": {
+      "workPath": "tasks/eval"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "media-plan.json is a valid JSON media-production manifest grounded in seeded fixture metadata.",
+    "deliverables": [
+      {
+        "path": "media-plan.json",
+        "kind": "json",
+        "minBytes": 700,
+        "checks": [
+          {
+            "kind": "sniff",
+            "file": "media-plan.json",
+            "sniff": "json-valid"
+          },
+          {
+            "kind": "contains",
+            "file": "media-plan.json",
+            "pattern": "pilot-interview\\.wav|returns-desk\\.png|launch-clip\\.mp4",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "media-plan.json",
+            "pattern": "outputs|assets|steps|cues|verification",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "media-plan.json",
+            "pattern": "accessibility|alt|caption|transcript|metadata",
+            "flags": "i"
+          }
+        ]
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "media-plan.json",
+      "kind": "json"
+    },
+    "axes": [
+      {
+        "name": "completeness",
+        "description": "The manifest covers sources, outputs, and processing steps end to end."
+      },
+      {
+        "name": "grounding",
+        "description": "Only seeded media fixtures are referenced, with faithful metadata."
+      },
+      {
+        "name": "accessibility",
+        "description": "Alt text, captions, or transcripts are planned wherever the class requires."
+      },
+      {
+        "name": "precision",
+        "description": "Timestamps, crops, and cues are specific enough to execute."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "media fixture handling",
+    "structured manifest",
+    "verification metadata"
+  ],
+  "extensions": {
+    "legacySimulators": [
+      {
+        "id": "sprite-sheet-media-fixtures",
+        "kind": "data-source",
+        "status": "implemented",
+        "description": "Seeded local media index replacing real audio, video, image generation, and external media metadata services."
+      }
+    ]
+  }
+}

package/data/craftbook-templates/sq/sql-analysis/versions/1.0.2/craftbook.json

@@ -0,0 +1,121 @@
+{
+  "id": "sql-analysis",
+  "name": "Answer a Question with SQL",
+  "description": "Answer a specific business question against a database or table set with a correct, readable SQL query and a short written answer. Scopes the question, the tables/columns, and the grain FIRST (so the query measures the right thing at the right level), then writes and runs the query as a data-analyst, then verifies the result with a sanity check and an explanation. Use this for SQL analysis, querying a database, writing a report query, computing a metric in SQL, or answering 'how many / what's the trend' from tables.\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 question (planner) — lock the question, tables, grain, and filters → gated on artifact `{{workPath}}/question-scope.md` (markdown-notes)\n2. Write and run the query (data-analyst) — author a correct, readable query and capture the result → gated on `query.sql` (code-module)\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "question-scope",
+  "triggers": [
+    "answer this with sql",
+    "write a sql query",
+    "query the database",
+    "compute a metric in sql",
+    "sql analysis"
+  ],
+  "steps": [
+    {
+      "id": "question-scope",
+      "name": "Scope the question",
+      "description": "lock the question, tables, grain, and filters",
+      "prompt": "Pin down exactly what the query must compute before writing SQL. Step 1: restate the business question as a precise metric ('count of distinct paying users who signed up in Q1', not 'how many users'). Step 2: identify the tables and the columns involved, and the join keys between them. Step 3: state the GRAIN of the answer (one row per user? per day? a single scalar?) and any filters (date range, status, dedup rule). Step 4: define edge cases (nulls, soft-deletes, duplicates, timezone). Step 5: write an acceptance-criteria checklist ('answers the exact restated question', 'joins on the correct keys', 'filters match the stated scope', 'handles nulls/dupes correctly', 'result is at the stated grain'). Call write_task_note and write the restated question + schema map + grain + checklist to {{workPath}}/question-scope.md.\n\nThe deliverable `{{workPath}}/question-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}}/question-scope.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/question-scope.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/question-scope.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "question-scope",
+        "maxAttempts": 3
+      },
+      "next": "query"
+    },
+    {
+      "id": "query",
+      "name": "Write and run the query",
+      "description": "author a correct, readable query and capture the result",
+      "prompt": "Write the SQL that answers the scoped question and run it if a database capability is available. Step 1: write a readable query — CTEs over deep nesting, explicit column lists, clear aliases, and a comment stating what it returns. Step 2: apply the scoped filters, joins, and dedup rule; pick the correct aggregate (COUNT(DISTINCT ...) vs COUNT(*)) for the grain. Step 3: run it (or, if no DB is reachable, dry-run against the schema and reason about the result), and capture the returned rows/value. Step 4: write the query to query.sql and record the result. Call write_task_note with the query, the result, and the assumptions baked in. On a loop-back, fix only the named correctness gaps.",
+      "suggestedRole": "data-analyst",
+      "advanceWhen": {
+        "file": "query.sql",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "query.sql",
+            "bytes": 200
+          },
+          {
+            "kind": "sniff",
+            "file": "query.sql",
+            "sniff": "nonempty"
+          },
+          {
+            "kind": "esmImports",
+            "file": "query.sql"
+          },
+          {
+            "kind": "sourceParses",
+            "file": "query.sql"
+          }
+        ],
+        "onReject": "query",
+        "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": "Read query.sql and verify it is correct, not just runnable. Step 1: confirm it answers the exact restated question, the joins use the correct keys, the aggregate matches the stated grain (e.g. COUNT(DISTINCT) where dedup is required), and the filters match scope. Step 2: re-reason about the classic SQL traps yourself — fan-out from a one-to-many join inflating counts, NULLs silently dropping rows in filters, and a missing DISTINCT. Step 3: sanity-check the captured result's magnitude against a back-of-envelope expectation and flag if it's implausible (e.g. more paying users than total users). Step 4: state in one sentence what the number means in business terms. Write PASS/FAIL per criterion; any FAIL loops back to query.\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: \"query\" })` 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": "query.sql"
+        }
+      ],
+      "next": "query"
+    },
+    {
+      "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/sq/sql-analysis/versions/1.0.2/test.json

@@ -0,0 +1,107 @@
+{
+  "schemaVersion": 1,
+  "title": "Answer a Question with SQL smoke eval",
+  "objective": "Self-contained smoke eval for the Answer a Question with SQL 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": "Answer a Question with SQL Eval",
+    "about": "Self-contained eval project for sql-analysis. Seeded inputs are under workspace/source or workspace/fixtures; final deliverable is workspace/analysis.md.",
+    "missionObjectives": "Use the Answer a Question with SQL 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": "# Answer a Question with SQL 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: sql-analysis - Answer a Question with SQL.\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/st/standup-summary/versions/1.0.2/craftbook.json

@@ -0,0 +1,119 @@
+{
+  "id": "standup-summary",
+  "name": "Standup / Team Update Summary",
+  "description": "Condense a pile of raw team updates (standup messages, async check-ins, channel dumps) into one clean summary grouped by person or workstream, surfacing blockers and decisions. Scopes the grouping axis and summary shape FIRST (by-person vs by-project, what counts as a blocker, the yesterday/today/blockers frame), then a copywriter compresses every raw update into that frame without dropping anyone. The scope-first step prevents a 4B model from rambling and guarantees blockers get their own callout section instead of being buried. Use for daily standup summaries, async update rollups, team check-in digests, and turning Slack threads into a readable recap.\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 summary (planner) — lock the grouping axis, frame, and blocker definition → gated on artifact `{{workPath}}/scope.md` (markdown-notes)\n2. Summarize (copywriter) — compress every update into the locked frame → gated on `summary.md` (markdown-doc)\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "scope",
+  "triggers": [
+    "summarize standup",
+    "team update summary",
+    "async check-in rollup",
+    "standup recap",
+    "summarize these updates"
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the summary",
+      "description": "lock the grouping axis, frame, and blocker definition",
+      "prompt": "Decide the summary's shape before compressing anything. (1) Pick the grouping axis — by person or by workstream/project — based on the raw input. (2) Lock the per-item frame (default: Yesterday / Today / Blockers, or Done / Doing / Blocked). (3) Define what counts as a blocker (an explicit ask, a dependency on someone, the words blocked/stuck/waiting) so blockers can be lifted into a dedicated top section. (4) Decide a Decisions callout if the updates contain any. Write an acceptance-criteria checklist ('every contributor/workstream from the input appears', 'each item uses the locked frame', 'all blockers are also collected into one top Blockers section', 'no raw update is dropped', 'one line per update item') plus the grouping + frame to {{workPath}}/scope.md via write_task_note AND the produces path. No summarizing yet.\n\nThe deliverable `{{workPath}}/scope.md` lands in the project's artifacts drawer — write it with `write_artifact` and read it back with `read_artifact`; the shipped workspace stays untouched.",
+      "suggestedRole": "planner",
+      "advanceWhen": {
+        "file": "{{workPath}}/scope.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/scope.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/scope.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "scope",
+        "maxAttempts": 3
+      },
+      "next": "summarize"
+    },
+    {
+      "id": "summarize",
+      "name": "Summarize",
+      "description": "compress every update into the locked frame",
+      "prompt": "Write summary.md from the raw updates using the locked grouping and frame. (1) Open with a 'Blockers & asks' section that lifts EVERY blocker (per the locked definition) to the top, each tagged with who is blocked and who they need. (2) Then one block per person/workstream in the locked frame, one tight line per item — strip filler, keep the signal (what shipped, what's next, hard numbers). (3) Add a Decisions section only if the input contains decisions. Include every contributor from the input even if their update was thin (write '(no update)'). Invent nothing; if an item is ambiguous, keep it verbatim-ish rather than guessing. On a loop-back, fix only the flagged blocks. Write the path and a count (contributors covered, blockers surfaced) to notes via write_task_note.",
+      "suggestedRole": "copywriter",
+      "advanceWhen": {
+        "file": "summary.md",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "summary.md",
+            "bytes": 500
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkContains",
+            "scope": "standard",
+            "inputs": {
+              "file": "summary.md",
+              "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+              "flags": "i"
+            }
+          }
+        ],
+        "onReject": "summarize",
+        "maxAttempts": 4
+      },
+      "next": "evaluate"
+    },
+    {
+      "id": "evaluate",
+      "name": "Evaluate",
+      "description": "Grade the deliverable against every acceptance criterion. All pass → finish; any fail → loop back and fix the gap.",
+      "prompt": "QA summary.md against the locked criteria. (1) Cross-check the contributor/workstream list against the raw input — every one present? FAIL on any drop. (2) Confirm a top Blockers section exists and that every blocker matching the locked definition appears there, attributed. (3) Confirm each item uses the locked frame and is one tight line (no paragraphs). (4) Spot-check 3 items against the raw input for accuracy and no fabrication. (5) Confirm Decisions appears iff the input had decisions. Write PASS/FAIL per criterion with the specific gaps.\n\nThen route — this is the whole point of the loop:\n\n- **Every criterion PASSES →** call `advance_task_step({ ref, stepId: \"evaluate\", next: \"finish\" })`.\n- **Any criterion FAILS →** write the specific gaps to notes, then call `advance_task_step({ ref, stepId: \"evaluate\", next: \"summarize\" })` 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": "summary.md"
+        }
+      ],
+      "next": "summarize"
+    },
+    {
+      "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"
+}