@bendyline/gilde 0.1.50 → 0.1.52

package/data/craftbook-templates/pl/plan/versions/1.0.1/craftbook.json

@@ -0,0 +1,222 @@
+{
+  "id": "plan",
+  "name": "Plan",
+  "description": "Author a PLAN for a piece of work as a reviewable **draft task** — the gezel equivalent of `/plan` in other tools.\n\nUnlike a normal craftbook, this one's deliverable is not a workspace file: it's a high-quality *draft task* (a plan) that the user reviews and then activates to run. Invoke it via the `start_plan` tool, which creates the draft and an authoring task that walks this craftbook. The authoring gates inspect the draft being built (via the authoring task's `craftbookParams.draftRef`), so a weak model can't skip the parts that make a plan good.\n\nSteps:\n\n1. **Frame the goal** (planner) — write a strong \"about\" on the draft and set 3–8 concrete **outcomes** (what should be created or updated at success). Gated by `checkPlanFramed`.\n2. **Design the build steps** (planner) — add ordered build steps to the draft, each given a concrete static deliverable + enforced gate via `set_step_deliverable`. Gated by `checkStepsHaveDeliverables`.\n3. **Add the verification step** (planner) — append a terminal step (via `add_verification_step`) that confirms every outcome with evidence before the task can close. Gated by `checkVerificationStep`.\n4. **Review the plan** (planner) — sanity-check the whole graph. Gated by `checkPlanReady`, which returns one list of any remaining gaps.\n5. **Hand off to the user** (planner, terminal) — summarize the plan and tell the user to review and **activate** it.\n\nWhen activated (draft → active), the produced task runs its build steps — each looping back on a missed deliverable — and its terminal step verifies the outcomes were kept.\n",
+  "entryStepId": "frame",
+  "triggers": [
+    "plan this",
+    "make a plan",
+    "plan for",
+    "/plan"
+  ],
+  "steps": [
+    {
+      "id": "frame",
+      "name": "Frame the goal",
+      "description": "Write a strong 'about' and set the outcomes on the draft plan.",
+      "prompt": "You are drafting a PLAN. The plan is a separate **draft task** — its ref is in your task's `craftbookParams.draftRef` (shown in your task description / entry note). Everything you author here targets that draft via the `task` argument.\n\n**Do two things:**\n\n1. **Write a strong \"about\".** Call `update_task({ task: \"<draftRef>\", description })` with a clear job-to-be-done from the user's perspective — what success looks like, in 120+ characters.\n2. **Set the outcomes.** Call `set_outcomes({ task: \"<draftRef>\", outcomes: [ ... ] })` with 3–8 concrete, individually-verifiable statements of what should be **created or updated** at completion (e.g. \"An index.html with a playable snake game and a game-over/restart screen\", \"A README documenting how to run it\").\n\nWhen done, call `advance_task_step({ ref, stepId: \"frame\", next: \"outline\" })`. The gate rejects until the draft has a real about and at least 3 outcomes — fix what it names and advance again.",
+      "suggestedRole": "planner",
+      "gate": {
+        "at": "completion",
+        "scripts": [
+          {
+            "name": "checkPlanFramed",
+            "scope": "standard",
+            "inputs": {}
+          }
+        ],
+        "onReject": "frame",
+        "maxAttempts": 4
+      },
+      "next": "outline",
+      "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": "none"
+      }
+    },
+    {
+      "id": "outline",
+      "name": "Design the build steps",
+      "description": "Add ordered build steps to the draft, each gated on a concrete static deliverable.",
+      "prompt": "Design the implementation as an ordered series of **build steps** on the draft (`craftbookParams.draftRef`). Each build step must produce a **concrete static file** with an enforced gate.\n\nThe draft starts with one placeholder step named **\"Implement\"**. First call `craftbook_read({ task: \"<draftRef>\" })` and note the actual id of that placeholder step. Then either:\n- repurpose that exact step with `craftbook_update_step({ task: \"<draftRef>\", stepId: \"<actualId>\", name, prompt, suggestedRole })`, then immediately call `set_step_deliverable({ task: \"<draftRef>\", stepId: \"<actualId>\", path, kind })`; or\n- remove that exact step with `craftbook_remove_step({ task: \"<draftRef>\", stepId: \"<actualId>\" })` after you have added the real build steps.\n\nFor each added step, in order:\n1. `craftbook_add_step({ task: \"<draftRef>\", name, prompt, suggestedRole })` — a concrete, instructive step (e.g. name \"Build the game\", role \"developer\", a prompt that says exactly what to make).\n2. Call `craftbook_read({ task: \"<draftRef>\" })` and use the actual id of the step you just added.\n3. `set_step_deliverable({ task: \"<draftRef>\", stepId: \"<actualId>\", path, kind })` — declare the named file it produces and auto-attach the gate. Pick `kind` to match the artifact: `html-page` / `html-game` / `markdown-report` / `code-with-tests` / `json` / etc.\n\nDo not invent step ids like `build` unless `craftbook_read` shows that exact id. Do not advance while any build step lacks `advanceWhen`/`gate`. Order the steps so each builds on the last. When every build step has a deliverable, call `advance_task_step({ ref, stepId: \"outline\", next: \"verify-step\" })`. The gate lists any step still missing a deliverable.",
+      "suggestedRole": "planner",
+      "gate": {
+        "at": "completion",
+        "scripts": [
+          {
+            "name": "checkStepsHaveDeliverables",
+            "scope": "standard",
+            "inputs": {}
+          }
+        ],
+        "onReject": "outline",
+        "maxAttempts": 4
+      },
+      "next": "verify-step",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "artifacts",
+          "audio",
+          "browser-automation",
+          "code-execution",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web",
+          "workspace-fs-write"
+        ],
+        "outputMedium": "none"
+      }
+    },
+    {
+      "id": "verify-step",
+      "name": "Add the verification step",
+      "description": "Append a terminal verification step that checks the outcomes were kept.",
+      "prompt": "Add the final **verification step** to the draft (`craftbookParams.draftRef`): call `add_verification_step({ task: \"<draftRef>\" })`. This appends a terminal step — gated by `checkOutcomesMet` — that makes the executor confirm each outcome (with evidence) before the task can close. Pass a custom `prompt` only if you need domain-specific verification instructions.\n\nThen call `advance_task_step({ ref, stepId: \"verify-step\", next: \"review\" })`. The gate rejects until the draft has a terminal step that verifies the outcomes.",
+      "suggestedRole": "planner",
+      "gate": {
+        "at": "completion",
+        "scripts": [
+          {
+            "name": "checkVerificationStep",
+            "scope": "standard",
+            "inputs": {}
+          }
+        ],
+        "onReject": "verify-step",
+        "maxAttempts": 4
+      },
+      "next": "review",
+      "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": "none"
+      }
+    },
+    {
+      "id": "review",
+      "name": "Review the plan",
+      "description": "Sanity-check the whole plan before handing it to the user.",
+      "prompt": "Final check before handing the plan to the user. `craftbook_read({ task: \"<draftRef>\" })` and sanity-check: the steps are ordered sensibly, each build step has a deliverable, and the last step verifies the outcomes. Fix anything off with the `craftbook_*` / `set_step_deliverable` tools on the draft.\n\nWhen the plan is solid, call `advance_task_step({ ref, stepId: \"review\", next: \"done\" })`. The gate returns a single list of anything still missing (thin about, fewer than 3 outcomes, ungated steps, or no verification step).",
+      "suggestedRole": "planner",
+      "gate": {
+        "at": "completion",
+        "scripts": [
+          {
+            "name": "checkPlanReady",
+            "scope": "standard",
+            "inputs": {}
+          }
+        ],
+        "onReject": "review",
+        "maxAttempts": 4
+      },
+      "next": "done",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "artifacts",
+          "audio",
+          "browser-automation",
+          "code-execution",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web",
+          "workspace-fs-write"
+        ],
+        "outputMedium": "none"
+      }
+    },
+    {
+      "id": "done",
+      "name": "Hand off to the user",
+      "description": "Summarize the plan and tell the user to review and activate it.",
+      "prompt": "The plan is ready. Summarize it for the user in your reply: mention the draft task **<draftRef>** by its ref (so it renders as a reviewable plan card), and recap the about, the outcomes, and the build steps. Tell the user they can **review and activate** the plan to run it — or ask you to tweak it first. Then report DONE.",
+      "suggestedRole": "planner",
+      "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": "none"
+      }
+    }
+  ],
+  "version": "1.0.1",
+  "releasedAt": "2026-09-01T20:00:00Z"
+}

package/data/craftbook-templates/pl/plan/versions/1.0.1/test.json

@@ -0,0 +1,91 @@
+{
+  "schemaVersion": 1,
+  "title": "Reviewable draft task plan",
+  "objective": "Measure whether the plan craftbook creates a real draft task with a substantial about, concrete outcomes, gated build steps, and a terminal verification step.",
+  "tags": [
+    "planning"
+  ],
+  "prompt": "In the `Plan Eval` project, author a reviewable draft plan for building a self-contained `index.html` bug triage board for a small support team. The eventual board should let users add bugs, assign severity, filter open/closed items, and show a summary. Use the plan flow/start_plan rather than building the board now: the output should be a draft task with strong outcomes, ordered gated build steps, and a final verification step for the user to review and activate. Important: every non-terminal build step on the draft, including the initial placeholder step if you keep or rename it, must get `set_step_deliverable({ task: \"<draftRef>\", stepId, path: \"index.html\", kind: \"html-page\" })` before you finish.",
+  "setup": {
+    "projectName": "Plan Eval",
+    "about": "Self-contained eval project for the plan craftbook. The deliverable is a reviewable draft task, not workspace files.",
+    "missionObjectives": "Author a high-quality draft task plan for a bug triage board, including outcomes, gated build steps, and verification before activation. A build step is not gated until set_step_deliverable is called on that exact step.",
+    "files": [],
+    "worker": {
+      "name": "Pieter",
+      "role": "Planner"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "A task sourced from the plan craftbook points to a draft task with outcomes, gated build steps, and terminal verification.",
+    "taskGraph": {
+      "checks": [
+        {
+          "kind": "contains",
+          "file": "task-graph.md",
+          "pattern": "index.html",
+          "flags": "i"
+        },
+        {
+          "kind": "contains",
+          "file": "task-graph.md",
+          "pattern": "bug|triage",
+          "flags": "i"
+        },
+        {
+          "kind": "contains",
+          "file": "task-graph.md",
+          "pattern": "severity",
+          "flags": "i"
+        },
+        {
+          "kind": "contains",
+          "file": "task-graph.md",
+          "pattern": "verify|outcome|evidence",
+          "flags": "i"
+        }
+      ],
+      "requireCraftbookTask": true,
+      "requireDraftRef": true,
+      "draft": {
+        "status": "draft",
+        "minDescriptionBytes": 120,
+        "minOutcomes": 3,
+        "minSteps": 3,
+        "requireTerminalVerification": true,
+        "requireGatedBuildSteps": true
+      }
+    }
+  },
+  "rubric": {
+    "artifact": {
+      "path": "task-graph.md",
+      "kind": "markdown"
+    },
+    "axes": [
+      {
+        "name": "playability",
+        "description": "The game is actually playable: input works, state advances, and a session can be completed."
+      },
+      {
+        "name": "completeness",
+        "description": "Core loop, scoring/win-lose, and restart are all present rather than stubbed."
+      },
+      {
+        "name": "polish",
+        "description": "Visual design and feedback (motion, states, messages) feel deliberate, not default."
+      },
+      {
+        "name": "robustness",
+        "description": "No console errors, dead controls, or states the player can get stuck in."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "task-native deliverable",
+    "outcomes",
+    "gated build steps",
+    "verification step"
+  ]
+}

package/data/craftbook-templates/pl/playtest-report/versions/1.0.2/test.json

@@ -19,9 +19,6 @@
     "worker": {
       "name": "Roos",
       "role": "Reviewer"
-    },
-    "craftbookParams": {
-      "workPath": "tasks/eval"
     }
   },
   "mocks": [],

package/data/craftbook-templates/pl/playtest-report/versions/1.0.3/craftbook.json

@@ -0,0 +1,277 @@
+{
+  "id": "playtest-report",
+  "name": "Playtest Report",
+  "description": "Playtest like it matters: a structured pass over the mechanics, the edge inputs, and the score loop, every finding written with its repro steps — a ranked fix list, not vibes. Locks the test plan FIRST — what to try and what correct looks like — then plays through it taking notes, then writes the findings with a ranked issue table. Use for playtesting a game before sharing it, 'is the game actually solid', bug hunts on an arcade page, pre-release game QA, and turning playtest feelings into a fix list.\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. Write the test plan (reviewer) — mechanics list, edge inputs, what the score loop should do → gated on artifact `{{workPath}}/scope.md` (markdown-notes)\n2. Play through the plan (reviewer) — structured playthrough notes, observed versus expected, with repros → gated on artifact `{{workPath}}/playtest.md` (markdown-notes)\n3. Write the findings (copywriter) — ranked issue table, repros attached, honest verdict → gated on artifact `{{workPath}}/report.md` (markdown-report)\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "scope",
+  "triggers": [
+    "playtest the game",
+    "is the game solid",
+    "test the arcade game before i share it",
+    "find the bugs in the game",
+    "playtest report"
+  ],
+  "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": "Write the test plan",
+      "description": "mechanics list, edge inputs, what the score loop should do",
+      "prompt": "Plan the playtest before playing a frame. Step 1: read index.html from the workspace and list the mechanics — movement, actions, collisions, scoring, lives or health, game over, restart — and how the score is kept between rounds. Step 2: write the edge-input list — keys mashed and held, action during game over, restarting mid-motion, playing again three times in a row, anything a ten-year-old with a keyboard would do in the first minute. Step 3: state what correct looks like per item — especially the score loop: what the score should read after a restart, and what should carry over versus reset. Step 4: write an acceptance-criteria checklist ('every mechanic exercised', 'every edge input tried', 'every finding has repro steps', 'findings ranked by player impact', 'the score loop gets an explicit verdict'). Call write_task_note with the plan size + 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": "reviewer",
+      "advanceWhen": {
+        "file": "{{workPath}}/scope.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/scope.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/scope.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "scope",
+        "maxAttempts": 3
+      },
+      "next": "test",
+      "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": "test",
+      "name": "Play through the plan",
+      "description": "structured playthrough notes, observed versus expected, with repros",
+      "prompt": "Work the plan against the code and write down what actually happens. Step 1: walk each mechanic and each edge input through the game's logic, tracing the code path the input takes; record observed versus expected for every item — passes too, not just failures. Step 2: for every mismatch, write the repro then and there: the exact steps, what happens, what should happen; a finding without a repro is a rumor. Step 3: give the score loop special care — trace a full round, game over, and restart, and record exactly what the score does at each point. Step 4: write the structured notes to {{workPath}}/playtest.md and call write_task_note with the pass/fail counts.\n\nThe deliverable `{{workPath}}/playtest.md` lands in the project's artifacts drawer — write it with `write_artifact` and read it back with `read_artifact`; the shipped workspace stays untouched.",
+      "suggestedRole": "reviewer",
+      "advanceWhen": {
+        "file": "{{workPath}}/playtest.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/playtest.md",
+            "bytes": 800,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/playtest.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "test",
+        "maxAttempts": 3
+      },
+      "next": "report",
+      "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": "report",
+      "name": "Write the findings",
+      "description": "ranked issue table, repros attached, honest verdict",
+      "prompt": "Write the playtest report at {{workPath}}/report.md. Step 1: open with the honest one-paragraph verdict — what state the game is in and whether it is ready to share. Step 2: the issue table — a Markdown table with columns Issue, Severity, and Repro, one row per finding, ranked by player impact (what ruins a session outranks what merely looks off). Step 3: under the table, give each finding its detail — the full repro steps, what happens, what should happen, and where in the code the trail leads. Step 4: state the score-loop verdict explicitly, and close with what passed cleanly so the good news is on record too. Write {{workPath}}/report.md and call write_task_note with the finding count and the top-ranked issue.\n\nThe deliverable `{{workPath}}/report.md` lands in the project's artifacts drawer — write it with `write_artifact` and read it back with `read_artifact`; the shipped workspace stays untouched.",
+      "suggestedRole": "copywriter",
+      "advanceWhen": {
+        "file": "{{workPath}}/report.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/report.md",
+            "bytes": 1200,
+            "artifact": true
+          },
+          {
+            "kind": "contains",
+            "file": "{{workPath}}/report.md",
+            "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+            "flags": "i",
+            "label": "at least one markdown heading",
+            "artifact": true
+          }
+        ],
+        "onReject": "report",
+        "maxAttempts": 4
+      },
+      "next": "evaluate",
+      "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": "evaluate",
+      "name": "Evaluate",
+      "description": "Grade the deliverable against every acceptance criterion. All pass → finish; any fail → loop back and fix the gap.",
+      "prompt": "Open {{workPath}}/report.md and {{workPath}}/playtest.md against {{workPath}}/scope.md and verify every criterion: every mechanic and edge input from the plan appears in the notes with observed versus expected; every finding in the report carries repro steps a stranger could follow — re-trace one against the code to check it is real, a finding that does not reproduce is worse than none; the table ranks by player impact with severities that match the prose; and the score loop has its explicit verdict. Write PASS/FAIL per criterion; on any failure, name the finding or the gap and loop back to report.\n\nThe deliverable lives in the project's artifacts drawer — open `{{workPath}}/report.md` with `read_artifact`, not `read_file`.\n\nThen route — this is the whole point of the loop:\n\n- **Every criterion PASSES →** call `advance_task_step({ ref, stepId: \"evaluate\", next: \"finish\" })`.\n- **Any criterion FAILS →** write the specific gaps to notes, then call `advance_task_step({ ref, stepId: \"evaluate\", next: \"report\" })` to loop back. The builder fixes exactly those gaps.\n\nNever route to `finish` while any criterion is unmet. The build phase's completion gate already blocked a grossly-incomplete deliverable; your job is the judgment an automated check cannot make (does it actually work, read well, look right). After ~3 unproductive loops, stop and report DONE_WITH_CONCERNS so the user can step in.",
+      "suggestedRole": "reviewer",
+      "consumes": [
+        {
+          "file": "{{workPath}}/report.md",
+          "artifact": true
+        }
+      ],
+      "next": "report",
+      "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": "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"
+}