@bendyline/gilde 0.1.38 → 0.1.39

package/data/craftbook-templates/co/competitive-analysis/versions/1.0.2/test.json

@@ -0,0 +1,119 @@
+{
+  "schemaVersion": 1,
+  "title": "Evidence-backed competitive matrix",
+  "objective": "Measure whether the competitive-analysis craftbook creates a complete cited matrix and a recommendation grounded in seeded competitor facts.",
+  "tags": [
+    "html-page"
+  ],
+  "prompt": "In the `Competitive Analysis Eval` project, read `source/competitor-briefs.md` and write `tasks/eval/analysis.md`: compare HarborCRM against AtlasOps, Deskline, and RelayFlow across target customer, pricing, automations, integrations, reporting, and weaknesses. Include a markdown comparison matrix, sources/citations from the seeded briefs, competitive gaps, and a recommendation for where HarborCRM should compete.",
+  "setup": {
+    "projectName": "Competitive Analysis Eval",
+    "about": "Self-contained eval project for competitive-analysis. All competitor facts are seeded in workspace/source/competitor-briefs.md.",
+    "missionObjectives": "Write a cited competitive analysis with a complete matrix, evidence-backed cells, competitive gaps, and a recommendation tied to the seeded facts.",
+    "files": [
+      {
+        "path": "source/competitor-briefs.md",
+        "content": "# Seeded competitor evidence\n\n[1] HarborCRM: Our product for regional wholesalers. Pricing is $149/user/month. Strengths: EDI order follow-up, inventory-aware reminders, native QuickBooks and NetSuite exports. Weaknesses: no built-in AI email summarization, reporting is CSV-first.\n\n[2] AtlasOps: Targets enterprise operations teams. Pricing starts at $40k/year platform fee plus seats. Strengths: workflow automations, approval routing, SSO, audit logs. Weaknesses: slow onboarding and limited wholesale-specific templates.\n\n[3] Deskline: Targets SMB support teams. Pricing is $79/user/month. Strengths: shared inbox, AI email summaries, helpdesk integrations, fast setup. Weaknesses: weak inventory context and no EDI order workflow.\n\n[4] RelayFlow: Targets logistics coordinators. Pricing is usage-based at $0.08/order event. Strengths: carrier tracking integrations, exception alerts, SLA dashboards. Weaknesses: not a CRM, limited account history, weak finance exports.\n"
+      }
+    ],
+    "worker": {
+      "name": "Iris",
+      "role": "Researcher"
+    },
+    "craftbookParams": {
+      "workPath": "tasks/eval"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "workspace/analysis.md contains a complete cited matrix, all four products, all dimensions, competitive gaps, and an evidence-tied recommendation.",
+    "deliverables": [
+      {
+        "path": "tasks/eval/analysis.md",
+        "kind": "markdown-report",
+        "minBytes": 2400,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "tasks/eval/analysis.md",
+            "pattern": "HarborCRM|AtlasOps|Deskline|RelayFlow"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/analysis.md",
+            "pattern": "target customer|pricing|automation|integration|reporting|weakness",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/analysis.md",
+            "pattern": "\\|.*\\|.*\\|",
+            "flags": "m"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/analysis.md",
+            "pattern": "\\[1\\]|\\[2\\]|\\[3\\]|\\[4\\]"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/analysis.md",
+            "pattern": "competitive gap|gap|recommendation|compete",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/analysis.md",
+            "pattern": "EDI|QuickBooks|NetSuite|AI email|carrier tracking",
+            "flags": "i"
+          },
+          {
+            "kind": "notContains",
+            "file": "tasks/eval/analysis.md",
+            "pattern": "TBD|unknown|not available",
+            "flags": "i"
+          }
+        ]
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "tasks/eval/analysis.md",
+      "kind": "markdown"
+    },
+    "axes": [
+      {
+        "name": "structure",
+        "description": "Layout and hierarchy fit the content; sections are scannable and coherent."
+      },
+      {
+        "name": "grounding",
+        "description": "Seeded source content is used faithfully — no invented facts or dropped requirements."
+      },
+      {
+        "name": "interactivity",
+        "description": "Controls and states the page claims to offer actually work."
+      },
+      {
+        "name": "polish",
+        "description": "Styling is intentional and responsive rather than unstyled or broken."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "evidence-backed cells",
+    "complete matrix",
+    "recommendation from facts"
+  ],
+  "extensions": {
+    "legacySimulators": [
+      {
+        "id": "seeded-competitor-corpus",
+        "kind": "data-source",
+        "status": "implemented",
+        "description": "Local evidence corpus replacing live web research for competitor facts."
+      }
+    ]
+  }
+}

package/data/craftbook-templates/co/config-scaffold/versions/1.0.2/craftbook.json

@@ -0,0 +1,117 @@
+{
+  "id": "config-scaffold",
+  "name": "Project Config Scaffold",
+  "description": "Bootstrap a project's configuration — the tooling, linter, formatter, tsconfig/compiler, scripts, and ignore files — into a coherent, conflict-free baseline that actually works together. Scopes the config surface FIRST — every tool, its config file, the settings, and how they must agree (formatter vs linter, strict compiler) — then writes the config files and scripts, then verifies the toolchain runs clean with no conflicts. Covers linter/formatter config, compiler/tsconfig, package scripts, editorconfig, gitignore, and ensuring tools do not fight each other.\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 config (planner) — lock the tools, files, settings, and agreements → gated on artifact `{{workPath}}/scope.md` (markdown-notes)\n2. Write the config (developer) — create the config files + scripts to the plan → gated on `package.json` (json)\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "scope",
+  "triggers": [
+    "scaffold project config",
+    "set up linting and formatting",
+    "bootstrap a project",
+    "create config files",
+    "tooling setup"
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the config",
+      "description": "lock the tools, files, settings, and agreements",
+      "prompt": "Scope the configuration before writing files. Step 1: List the tools the project needs (formatter, linter, compiler/type-checker, test runner, etc.) and the config file each one reads. Step 2: For each, decide the key settings (e.g. strict compiler, line width, rule set). Step 3: Crucially, decide how the tools must AGREE so they do not fight — e.g. the linter defers formatting to the formatter, the compiler target matches the runtime. Step 4: Decide the package scripts (lint, format, typecheck, test, build) and the ignore files (.gitignore, tool ignores, .editorconfig). Step 5: Write a numbered acceptance-criteria checklist of 5-9 items (e.g. 'every script runs without error', 'formatter and linter do not conflict', 'the type-checker passes on the scaffold', 'ignore files exclude build output and deps'). `write_task_note` the config plan + checklist and write the same to the produces path.\n\nThe deliverable `{{workPath}}/scope.md` lands in the project's artifacts drawer — write it with `write_artifact` and read it back with `read_artifact`; the shipped workspace stays untouched.",
+      "suggestedRole": "planner",
+      "advanceWhen": {
+        "file": "{{workPath}}/scope.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/scope.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/scope.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "scope",
+        "maxAttempts": 3
+      },
+      "next": "build"
+    },
+    {
+      "id": "build",
+      "name": "Write the config",
+      "description": "create the config files + scripts to the plan",
+      "prompt": "Create the configuration files to the plan. Step 1: Write each tool's config file with the scoped settings, and the package manifest's scripts (lint/format/typecheck/test/build) wired to real commands. Step 2: Configure the linter and formatter to defer to each other so they do not conflict, and align the compiler target with the runtime. Step 3: Write the ignore files (.gitignore, tool-specific ignores, .editorconfig) excluding deps and build output. Step 4: Run each script (lint, format --check, typecheck) on the scaffold and confirm they pass without errors or conflicting complaints. Write the primary manifest/config to the produces path. On a loop-back, fix only the named conflict/gap. `write_task_note` the file paths and which criteria now pass.",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "package.json",
+        "minBytes": 1,
+        "sniff": "json-valid"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "package.json",
+            "bytes": 2
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkJsonValid",
+            "scope": "standard",
+            "inputs": {
+              "file": "package.json"
+            }
+          }
+        ],
+        "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": "Run each configured script on the scaffold. For EACH acceptance criterion: confirm lint, format-check, typecheck, and build/test scripts run without error, confirm the formatter and linter do NOT fight each other (no rule both formats and lints in conflict), confirm the type-checker passes, and confirm ignore files exclude deps/build output. Write PASS/FAIL per criterion; a formatter-vs-linter conflict is a FAIL.\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": "package.json"
+        }
+      ],
+      "next": "build"
+    },
+    {
+      "id": "finish",
+      "name": "Finish",
+      "description": "All acceptance criteria met. Stamp a short summary and report DONE.",
+      "prompt": "Every acceptance criterion passed. Write a one-paragraph DONE summary to task notes via `write_task_note`: what was built, the deliverable path(s), and a one-line confirmation that each criterion is met. Then report DONE.",
+      "suggestedRole": "developer",
+      "terminal": true
+    }
+  ],
+  "version": "1.0.2",
+  "releasedAt": "2026-08-21T00:00:00Z",
+  "paramSchema": {
+    "type": "object",
+    "properties": {
+      "workPath": {
+        "type": "string",
+        "title": "Working folder",
+        "description": "Per-task working folder in the artifacts drawer. Defaults to this task's own folder so runs never collide; override with a stable name when you deliberately want runs to share files.",
+        "default": "{{task.dir}}"
+      }
+    }
+  },
+  "minGezelVersion": "1.26233"
+}

package/data/craftbook-templates/co/config-scaffold/versions/1.0.2/test.json

@@ -0,0 +1,123 @@
+{
+  "schemaVersion": 1,
+  "title": "Project package config scaffold",
+  "objective": "Measure whether the config-scaffold craftbook scopes runtime/tooling choices and writes a coherent package.json.",
+  "tags": [
+    "corpus"
+  ],
+  "prompt": "In the `Config Scaffold Eval` project, write `package.json` for a TypeScript Vite widget library called `harbor-widget-kit`. Include module type, exports, files, engines, scripts for dev/build/test/lint/typecheck, dependencies for @vitejs/plugin-react or vite/react as appropriate, devDependencies for TypeScript, Vitest, ESLint, and Prettier, and a packageManager field. Keep it valid JSON.",
+  "setup": {
+    "projectName": "Config Scaffold Eval",
+    "about": "Self-contained eval project for config-scaffold. The deliverable is workspace/package.json.",
+    "missionObjectives": "Produce a valid, coherent package.json scaffold for a TypeScript Vite widget library.",
+    "files": [],
+    "worker": {
+      "name": "Melle",
+      "role": "Developer"
+    },
+    "craftbookParams": {
+      "workPath": "tasks/eval"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "package.json is valid JSON and includes the expected package metadata, scripts, engines, and tool dependencies.",
+    "deliverables": [
+      {
+        "path": "package.json",
+        "kind": "json",
+        "minBytes": 600,
+        "checks": [
+          {
+            "kind": "sniff",
+            "file": "package.json",
+            "sniff": "json-valid"
+          },
+          {
+            "kind": "contains",
+            "file": "package.json",
+            "pattern": "harbor-widget-kit",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "package.json",
+            "pattern": "scripts",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "package.json",
+            "pattern": "dev|build|test|lint|typecheck",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "package.json",
+            "pattern": "dependencies|devDependencies",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "package.json",
+            "pattern": "typescript|tsc",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "package.json",
+            "pattern": "vite",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "package.json",
+            "pattern": "vitest",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "package.json",
+            "pattern": "eslint|prettier",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "package.json",
+            "pattern": "engines|packageManager",
+            "flags": "i"
+          }
+        ]
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "package.json",
+      "kind": "json"
+    },
+    "axes": [
+      {
+        "name": "grounding",
+        "description": "Seeded facts appear faithfully and the source is cited."
+      },
+      {
+        "name": "structure",
+        "description": "Sections progress logically for the artifact class."
+      },
+      {
+        "name": "completeness",
+        "description": "Required elements (risks, next actions, scope) are all present."
+      },
+      {
+        "name": "tone",
+        "description": "The register fits the audience and artifact class."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "config completeness",
+    "tooling coherence",
+    "valid JSON"
+  ]
+}

package/data/craftbook-templates/co/content-accuracy-review/versions/1.0.2/craftbook.json

@@ -0,0 +1,153 @@
+{
+  "id": "content-accuracy-review",
+  "name": "Content Accuracy Review",
+  "description": "Fact-check a piece of content for accuracy and produce a claim-by-claim verification report. First scopes the content and extracts every checkable claim (statistics, dates, quotes, attributions, causal and factual statements) and locks a verification standard, then verifies each claim against authoritative sources rating it true/false/misleading/unverifiable with the supporting evidence, then writes a report flagging every inaccuracy with the correction and source plus an overall trust rating. Use this for a fact-check, accuracy review, content verification, checking claims and statistics, source-checking an article, or vetting content before publishing — it returns a claim-level verdict backed by cited sources rather than a vague 'seems accurate'.\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 + extract claims (reviewer) — extract every checkable claim, lock the standard → gated on artifact `{{workPath}}/scope.md` (markdown-notes)\n2. Verify each claim (researcher) — check claims against sources, rate each → gated on artifact `{{workPath}}/verify.md` (markdown-notes)\n3. Write the accuracy report (reviewer) — claim-by-claim verdicts + corrections → gated on artifact `{{workPath}}/accuracy-review.md` (markdown-report)\n\nSource discipline:\n\n- Extract only checkable claims that appear in the supplied content.\n- Verify against the supplied or fetched sources; never create extra claims, companies, metrics, quotes, or source sections to make the report longer.\n- Preserve enough of the original claim text that a reader can trace each verdict back to the draft.\n- Mark unsupported but plausible claims as `UNVERIFIABLE` or `FALSE` according to the evidence, not as true by assumption.\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "scope",
+  "triggers": [
+    "fact check this",
+    "accuracy review",
+    "verify these claims",
+    "is this content accurate",
+    "source-check this article",
+    "vet this before publishing"
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope + extract claims",
+      "description": "extract every checkable claim, lock the standard",
+      "prompt": "Step 1: Read the content and EXTRACT every checkable claim into a numbered list — statistics and numbers, dates, named quotes and their attributions, causal statements ('X causes Y'), definitions, and any assertion presented as fact. Step 2: For each claim, note what kind it is and what evidence would settle it. Step 3: Separate verifiable facts from opinion/analysis (opinions are out of scope for accuracy but note unsupported opinions stated as fact). Step 4: Write the acceptance-criteria checklist / verification standard, e.g. 'every factual claim is extracted', 'each claim is checked against at least one authoritative source', 'a claim with no reliable source is marked unverifiable, not assumed true', 'corrections cite their source'. Step 5: Note the source quality bar (primary/official sources over secondary). Write the numbered claim list + standard to `write_task_note` AND `{{workPath}}/scope.md`. No verification 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": "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": "verify"
+    },
+    {
+      "id": "verify",
+      "name": "Verify each claim",
+      "description": "check claims against sources, rate each",
+      "prompt": "Step 1: For EACH numbered claim, find authoritative evidence (use web search/fetch if available, prioritizing primary and official sources; otherwise reason from well-established knowledge and clearly mark anything you cannot externally confirm). Step 2: Rate each claim: TRUE (supported), FALSE (contradicted), MISLEADING (technically true but framed to deceive, or missing critical context), or UNVERIFIABLE (no reliable source found). Step 3: For every claim capture: the rating, the supporting source(s) with title/URL, a one-line evidence note, and — for false/misleading — the CORRECT statement. Step 4: Be adversarial: check whether a statistic is current, whether a quote is accurate and in context, and whether an attribution is right. Step 5: Do NOT mark a claim true just because it is plausible — require evidence, and prefer 'unverifiable' to a guess. Good looks like: each claim with a verdict and a citable source. Stage the verified claim table to `write_task_note`. Do not write the report yet.\n\nThe deliverable `{{workPath}}/verify.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": "researcher",
+      "advanceWhen": {
+        "file": "{{workPath}}/verify.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/verify.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/verify.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "verify",
+        "maxAttempts": 3
+      },
+      "next": "report"
+    },
+    {
+      "id": "report",
+      "name": "Write the accuracy report",
+      "description": "claim-by-claim verdicts + corrections",
+      "prompt": "Step 1: Open `{{workPath}}/accuracy-review.md` and write an overall trust rating (e.g. Accurate / Mostly accurate with fixes / Significant inaccuracies) with the count of false/misleading/unverifiable claims. Step 2: Add an '## Issues' section listing every FALSE, MISLEADING, and UNVERIFIABLE claim first: the original claim, the verdict, the correct statement, and the cited source. Step 3: Add a '## Verified claims' section confirming the claims that checked out (with sources), so the review's rigor is visible. Step 4: Add a '## Sources' list of everything consulted. Step 5: Note any claim that needs a subject-matter expert. Every issue must include a correction and a source citation; never assert a correction without evidence. On a loop-back, fix only the named gaps. `write_task_note` the report path and the counts by verdict.\n\nThe deliverable `{{workPath}}/accuracy-review.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}}/accuracy-review.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/accuracy-review.md",
+            "bytes": 1500,
+            "artifact": true
+          },
+          {
+            "kind": "contains",
+            "file": "{{workPath}}/accuracy-review.md",
+            "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+            "flags": "i",
+            "label": "at least one markdown heading",
+            "artifact": true
+          }
+        ],
+        "onReject": "report",
+        "maxAttempts": 4
+      },
+      "next": "evaluate"
+    },
+    {
+      "id": "evaluate",
+      "name": "Evaluate",
+      "description": "Grade the deliverable against every acceptance criterion. All pass → finish; any fail → loop back and fix the gap.",
+      "prompt": "Open `{{workPath}}/accuracy-review.md` and grade it against the scope standard. Check EACH criterion and write PASS/FAIL with a one-line reason: (1) every checkable claim from the content was extracted and addressed; (2) each claim has a verdict (true/false/misleading/unverifiable); (3) each false/misleading claim has a correction AND a cited source; (4) verified claims cite their sources; (5) unverifiable claims are marked as such rather than assumed true; (6) a sources list is present; (7) the overall trust rating matches the findings. If any criterion fails, name the exact gap and loop back.\n\nThe deliverable lives in the project's artifacts drawer — open `{{workPath}}/accuracy-review.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}}/accuracy-review.md",
+          "artifact": true
+        }
+      ],
+      "next": "report"
+    },
+    {
+      "id": "finish",
+      "name": "Finish",
+      "description": "All acceptance criteria met. Stamp a short summary and report DONE.",
+      "prompt": "Every acceptance criterion passed. Write a one-paragraph DONE summary to task notes via `write_task_note`: what was built, the deliverable path(s), and a one-line confirmation that each criterion is met. Then report DONE.",
+      "suggestedRole": "developer",
+      "terminal": true
+    }
+  ],
+  "version": "1.0.2",
+  "releasedAt": "2026-08-21T00:00:00Z",
+  "paramSchema": {
+    "type": "object",
+    "properties": {
+      "workPath": {
+        "type": "string",
+        "title": "Working folder",
+        "description": "Per-task working folder in the artifacts drawer. Defaults to this task's own folder so runs never collide; override with a stable name when you deliberately want runs to share files.",
+        "default": "{{task.dir}}"
+      }
+    }
+  },
+  "minGezelVersion": "1.26233"
+}