@bendyline/gilde 0.1.37 → 0.1.39

package/data/craftbook-templates/re/release-readiness-review/versions/1.0.2/test.json

@@ -0,0 +1,113 @@
+{
+  "schemaVersion": 1,
+  "title": "Release Readiness Review smoke eval",
+  "objective": "Self-contained smoke eval for the Release Readiness Review craftbook using the corpus generic harness.",
+  "tags": [
+    "corpus"
+  ],
+  "prompt": "We need a release readiness review for the returns-desk work. The backgound info is in source/brief.md — have a look and write it up in report.md.",
+  "setup": {
+    "projectName": "Release Readiness Review Eval",
+    "about": "Self-contained eval project for release-readiness-review. Seeded inputs are under workspace/source or workspace/fixtures; final deliverable is workspace/report.md.",
+    "missionObjectives": "Use the Release Readiness Review craftbook/template, read the seeded local fixtures, and write report.md without network calls, real credentials, or live services.",
+    "files": [
+      {
+        "path": "source/brief.md",
+        "content": "# Release Readiness Review 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: release-readiness-review - Release Readiness Review.\n"
+      }
+    ],
+    "worker": {
+      "name": "Jules",
+      "role": "Writer"
+    },
+    "craftbookParams": {
+      "workPath": "tasks/eval"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "report.md is a source-grounded markdown artifact with required facts and actions.",
+    "deliverables": [
+      {
+        "path": "report.md",
+        "kind": "markdown-report",
+        "minBytes": 1000,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "source/brief\\.md|Brief",
+            "flags": "i",
+            "label": "cite or name the seeded source"
+          },
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "18\\b[\\s\\S]{0,30}\\bSKUs",
+            "flags": "i",
+            "label": "include the 18-SKU pilot scope"
+          },
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "18\\s*hours|6\\s*hours",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "14\\.2%|8\\.9%",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "status silence|photo submission",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "automated status emails|barcode|Finance",
+            "flags": "i"
+          }
+        ]
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "report.md",
+      "kind": "markdown"
+    },
+    "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": [
+    "source-grounded prose",
+    "section structure",
+    "next-action clarity"
+  ]
+}

package/data/craftbook-templates/re/reliability-review/versions/1.0.2/craftbook.json

@@ -0,0 +1,165 @@
+{
+  "id": "reliability-review",
+  "name": "Reliability & Resilience Review",
+  "description": "Review a codebase for production reliability and resilience risks across asynchronous work, external dependencies, state transitions, resource lifecycles, and recovery paths. Uses the repository and per-file indexes to map failure domains, verifies likely issues in source and tests, and leaves a prioritized morning report covering timeouts, retries, idempotency, cancellation, concurrency, backpressure, cleanup, graceful shutdown, observability, and disaster recovery. Use for a weekly reliability sweep, resilience review, failure-mode audit, or pre-production hardening review.\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. Map failure domains (reviewer) — inventory stateful and asynchronous boundaries plus their reliability contract → gated on artifact `{{workPath}}/reliability/failure-map.md` (markdown-notes)\n2. Verify failure handling (reviewer) — trace representative failures through source and tests → gated on artifact `{{workPath}}/reliability/evidence.md` (markdown-notes)\n3. Write the reliability report (reviewer) — ranked failure-mode report with concrete hardening work → gated on artifact `{{workPath}}/reliability-review.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": "model",
+  "triggers": [
+    "reliability review",
+    "resilience audit",
+    "review failure modes",
+    "weekly production hardening",
+    "find reliability risks",
+    "nightly reliability sweep"
+  ],
+  "toolsets": [
+    {
+      "toolsetId": "builtin.code-intel",
+      "autoAllow": true,
+      "reason": "map failure domains and verify indexed reliability leads in source"
+    },
+    {
+      "toolsetId": "builtin.code-execution",
+      "autoAllow": true,
+      "reason": "run safe existing tests or focused diagnostic scripts when available"
+    }
+  ],
+  "steps": [
+    {
+      "id": "model",
+      "name": "Map failure domains",
+      "description": "inventory stateful and asynchronous boundaries plus their reliability contract",
+      "prompt": "Call `map_repo`, `list_file_issues`, and targeted `search_code` queries for queues/jobs, timers, promises, subprocesses, network/database/filesystem calls, caches, locks, transactions, startup/shutdown, and persistence. Build a failure-domain map: critical user journeys, state owners, external dependencies, retry boundaries, resource lifecycles, and recovery expectations. For each boundary define the reliability contract: timeout, retry/backoff/jitter, idempotency, cancellation, concurrency limit/backpressure, cleanup, error propagation, monitoring, and recovery. Record index coverage and areas not statically observable. Write the map and prioritized audit plan to `{{workPath}}/reliability/failure-map.md`.\n\nThe deliverable `{{workPath}}/reliability/failure-map.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}}/reliability/failure-map.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/reliability/failure-map.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/reliability/failure-map.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "model",
+        "maxAttempts": 3
+      },
+      "next": "verify"
+    },
+    {
+      "id": "verify",
+      "name": "Verify failure handling",
+      "description": "trace representative failures through source and tests",
+      "prompt": "For each high-impact boundary, inspect the relevant symbols and callers with `file_review`, `outline_file`, `read_symbol`, and `find_references`. Trace representative failures: slow/hung dependency, transient failure, duplicate delivery, partial write, cancellation, concurrent mutation, process restart, disk full/corrupt state, and shutdown during work. Locate tests and run safe existing checks when practical. Confirm whether timeouts are bounded; retries have caps/backoff/jitter and do not multiply side effects; operations are idempotent; cancellations and errors propagate; resources/timers/listeners/subprocesses are released; transactions or durable journals protect multi-step state; startup and shutdown are safe; and operators get useful signals. Record confirmed issues and verified-safe controls with real file:line/test/command evidence in `{{workPath}}/reliability/evidence.md`.\n\nThe deliverable `{{workPath}}/reliability/evidence.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}}/reliability/evidence.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/reliability/evidence.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/reliability/evidence.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "verify",
+        "maxAttempts": 3
+      },
+      "next": "report"
+    },
+    {
+      "id": "report",
+      "name": "Write the reliability report",
+      "description": "ranked failure-mode report with concrete hardening work",
+      "prompt": "Write `{{workPath}}/reliability-review.md` with `## Verdict`, `## Coverage and assumptions`, `## Failure-domain scorecard`, `## Findings`, `## Verified controls`, `## Not verified`, and `## Hardening sequence`. Each finding must cite real file:line or test/command evidence, state the initiating failure, propagation path, user/operator impact, likelihood, severity, and a concrete remediation plus the failure-injection/regression test to add. Rank by impact × likelihood × recoverability. Distinguish a missing control from a merely untested control. Do not demand distributed-systems machinery for local, low-risk code. On a loop-back, fix only named gaps.\n\nThe deliverable `{{workPath}}/reliability-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}}/reliability-review.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/reliability-review.md",
+            "bytes": 1800,
+            "artifact": true
+          },
+          {
+            "kind": "contains",
+            "file": "{{workPath}}/reliability-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": "Grade `{{workPath}}/reliability-review.md`: (1) critical failure domains and contracts are mapped; (2) findings cite real source/test/command evidence; (3) timeouts, retries/backoff, idempotency, cancellation, concurrency/backpressure, cleanup, partial writes, restart, and shutdown were considered where relevant; (4) propagation and user/operator impact are explained; (5) each remediation includes a failure-injection or regression test; (6) verified controls and unverified areas are explicit; (7) priorities reflect impact, likelihood, and recoverability without overengineering. PASS all or loop back.\n\nThe deliverable lives in the project's artifacts drawer — open `{{workPath}}/reliability-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}}/reliability-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"
+}

package/data/craftbook-templates/re/reliability-review/versions/1.0.2/test.json

@@ -0,0 +1,115 @@
+{
+  "schemaVersion": 1,
+  "title": "Reliability & Resilience Review failure-path eval",
+  "objective": "Measure whether the review traces seeded retry, timeout, idempotency, cleanup, and recovery risks and proposes failure-injection tests.",
+  "tags": [
+    "corpus"
+  ],
+  "prompt": "Use the Reliability & Resilience Review craftbook for a weekly production-hardening pass. Review the seeded worker and write tasks/eval/reliability-review.md. Do not change source.",
+  "setup": {
+    "projectName": "Reliability Maintenance Eval",
+    "about": "A tiny background worker with deliberate unbounded retries, missing timeout/cancellation, duplicate side-effect, and leaked interval risks.",
+    "missionObjectives": "Trace how failures propagate and leave concrete controls plus regression/failure-injection tests.",
+    "files": [
+      {
+        "path": "src/worker.ts",
+        "content": "let running = false;\nexport function startWorker(queue, billing, db) {\n  running = true;\n  setInterval(async () => {\n    if (!running) return;\n    const job = await queue.next();\n    if (!job) return;\n    while (true) {\n      try {\n        await billing.charge(job.customerId, job.amount);\n        await db.markProcessed(job.id);\n        break;\n      } catch (_err) {\n        // retry immediately forever\n      }\n    }\n  }, 10);\n}\nexport function stopWorker() { running = false; }\n"
+      },
+      {
+        "path": "test/worker.test.ts",
+        "content": "test('starts', () => { startWorker(queue, billing, db); expect(true).toBe(true); });\n"
+      },
+      {
+        "path": "docs/slo.md",
+        "content": "# Worker contract\n\nA job may be delivered more than once. Billing must happen at most once. Shutdown must finish or return the active job within 5 seconds. Transient dependencies should be retried with bounded exponential backoff.\n"
+      }
+    ],
+    "worker": {
+      "name": "Rae",
+      "role": "Reviewer"
+    },
+    "craftbookParams": {
+      "workPath": "tasks/eval"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "tasks/eval/reliability-review.md traces every seeded failure mode and pairs remediations with exact failure-injection tests.",
+    "deliverables": [
+      {
+        "path": "tasks/eval/reliability-review.md",
+        "kind": "markdown-report",
+        "minBytes": 1500,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "tasks/eval/reliability-review.md",
+            "pattern": "src/worker\\.ts:[0-9]+|src/worker\\.ts",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/reliability-review.md",
+            "pattern": "unbounded|while \\(true\\)|retry",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/reliability-review.md",
+            "pattern": "backoff|jitter|retry cap",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/reliability-review.md",
+            "pattern": "timeout|cancellation|Abort",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/reliability-review.md",
+            "pattern": "idempoten|at most once|duplicate.*charge",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/reliability-review.md",
+            "pattern": "clearInterval|interval|shutdown|cleanup",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/reliability-review.md",
+            "pattern": "failure-injection|test[\\s\\S]{0,160}(duplicate|transient|shutdown|timeout)",
+            "flags": "i"
+          }
+        ]
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "tasks/eval/reliability-review.md",
+      "kind": "markdown"
+    },
+    "axes": [
+      {
+        "name": "failure modeling",
+        "description": "Initiating failures, propagation, and user/operator impact are explicit."
+      },
+      {
+        "name": "control coverage",
+        "description": "Timeouts, retries, idempotency, cancellation, cleanup, and shutdown are addressed."
+      },
+      {
+        "name": "verification plan",
+        "description": "Each remediation has a concrete failure-injection or regression test."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "failure propagation",
+    "bounded resilience controls",
+    "failure-injection tests"
+  ]
+}

package/data/craftbook-templates/re/report-pdf/versions/1.1.2/craftbook.json

@@ -0,0 +1,185 @@
+{
+  "id": "report-pdf",
+  "name": "Formatted PDF Report",
+  "description": "Produce a polished PDF report without turning the work into a web-development project. The workflow locks the audience, source facts, section order, and acceptance criteria; a copywriter writes the full source as ordinary Markdown in report.md; then the same content specialist uses DocBlocks to convert the Markdown directly to PDF, preview the pages, repair the source if needed, and save {{workPath}}/report.pdf in the project's artifacts drawer.\n\nThe source of truth remains report.md. HTML, CSS, browser print APIs, hand-built PDF syntax, and raw binary writes are explicitly out of scope. The DocBlocks toolset is pre-authorized for the active craftbook, so a Developer is not needed merely to format or export the report.\n\nWorking files under {{workPath}}/, reviews/, and reports/ live in the project artifacts drawer and must be read and written with the artifact tools. User-facing source files remain in the workspace.",
+  "entryStepId": "outline",
+  "triggers": [
+    "formatted report",
+    "make a pdf report",
+    "create a pdf",
+    "export this report to pdf",
+    "quarterly report",
+    "printable document",
+    "report with cover page"
+  ],
+  "toolsets": [
+    {
+      "toolsetId": "docblocks",
+      "sourceId": "bundled",
+      "autoAllow": true,
+      "reason": "convert report.md directly to PDF, preview the rendered pages, and save the finished file without a prompt per call"
+    }
+  ],
+  "steps": [
+    {
+      "id": "outline",
+      "name": "Outline the report",
+      "description": "Lock the audience, source facts, section order, and acceptance criteria.",
+      "prompt": "Plan the report before writing it. 1. Identify the audience, the decision or takeaway the report must support, and every source file or user-provided fact the report may use. 2. Lock the section order: title block, executive summary, body sections, recommendations/conclusion, and appendix or references when needed. 3. For each body section, state its purpose and the facts, figures, or tables it must contain; never invent a missing metric. 4. Decide whether the user requested Letter or A4 pages. 5. Write a numbered acceptance checklist that includes source fidelity, complete section coverage, a stand-alone executive summary, captioned/referenced tables or figures, explicit recommendations, and a real saved PDF in the artifacts drawer. Write the outline and checklist to {{workPath}}/outline.md and call write_task_note with the audience, page size, and section count. Do not write HTML, CSS, or body prose.\n\nStore `{{workPath}}/outline.md` in the artifacts drawer with `write_artifact`, then verify it with `read_artifact`; do not write this working file to the workspace.",
+      "suggestedRole": "planner",
+      "advanceWhen": {
+        "file": "{{workPath}}/outline.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/outline.md",
+            "bytes": 180,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/outline.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "outline",
+        "maxAttempts": 3
+      },
+      "next": "write"
+    },
+    {
+      "id": "write",
+      "name": "Write the Markdown report",
+      "description": "Write the complete report.md source to the locked outline.",
+      "prompt": "Write the complete report to report.md as ordinary Markdown. Follow {{workPath}}/outline.md exactly: 1. Start with one H1 title and a short metadata block for author/date when known. 2. Write a concise executive summary that stands alone. 3. Write every body section in order with clear H2/H3 headings and real prose grounded only in the supplied sources. 4. Use Markdown tables for structured comparisons and Markdown images only for existing, workspace-readable assets; give every table or figure a caption and refer to it in the prose. 5. End with the explicit recommendations/conclusion and any references or appendix from the outline. 6. Check every acceptance criterion and repair the Markdown before advancing. Do not create report.html, CSS, OOXML, or PDF bytes yourself. Call write_task_note with the report.md path, word count, and section count.\n\nOpen `{{workPath}}/outline.md` from the artifacts drawer with `read_artifact` before working.",
+      "suggestedRole": "copywriter",
+      "advanceWhen": {
+        "file": "report.md",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "report.md",
+            "bytes": 1000
+          },
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "(?:^|\\n)#\\s+\\S",
+            "label": "an H1 report title"
+          },
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "(?:^|\\n)##\\s+\\S",
+            "label": "at least one report section"
+          }
+        ],
+        "onReject": "write",
+        "maxAttempts": 4
+      },
+      "next": "publish",
+      "consumes": [
+        {
+          "file": "{{workPath}}/outline.md",
+          "artifact": true
+        }
+      ]
+    },
+    {
+      "id": "publish",
+      "name": "Publish the PDF",
+      "description": "Convert report.md with DocBlocks, preview every page, and save {{workPath}}/report.pdf.",
+      "prompt": "Publish report.md as a real PDF with the pre-authorized DocBlocks tools. 1. Call list_roots first; identify the read-enabled project workspace root and the write-enabled project artifacts root. If no write root exists, report the exact blocker instead of substituting HTML. 2. Optionally call get_authoring_context with targetFormat \"pdf\" and goal \"visual-polish\" when theme or target details would help; plain Markdown needs no preflight. 3. Call convert_document with source `{ \"kind\": \"file\", \"rootId\": <workspace root id>, \"path\": \"report.md\" }`, one PDF target using the Letter/A4 choice from {{workPath}}/outline.md, a restrained theme when appropriate, `autoTemplates: true`, and the report title. 4. Call preview_document on the returned PDF artifact URI and inspect all pages (paginate if there are more than 20): title present, headings and tables intact, no clipped or nearly empty pages, readable hierarchy. If visual QA fails, fix report.md and convert again; never patch generated PDF bytes. 5. Call save_artifact with that artifact URI and destination `{ \"rootId\": <artifacts root id>, \"path\": \"{{workPath}}/report.pdf\", \"ifExists\": \"error\" }`. On a loop-back where {{workPath}}/report.pdf already exists, replace it only with `ifExists: \"replace\"` plus the current expectedSha256 from the earlier save result. 6. Call write_task_note with the saved path, page count, theme, and preview result. Do not build HTML or use a browser PDF printer.\n\nOpen `{{workPath}}/outline.md` from the artifacts drawer with `read_artifact` before working.",
+      "suggestedRole": "copywriter",
+      "advanceWhen": {
+        "file": "{{workPath}}/report.pdf",
+        "minBytes": 1,
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/report.pdf",
+            "bytes": 1000,
+            "artifact": true
+          }
+        ],
+        "onReject": "publish",
+        "maxAttempts": 4
+      },
+      "next": "evaluate",
+      "consumes": [
+        {
+          "file": "{{workPath}}/outline.md",
+          "artifact": true
+        },
+        {
+          "file": "report.md"
+        }
+      ]
+    },
+    {
+      "id": "evaluate",
+      "name": "Evaluate",
+      "description": "Review the saved PDF against the locked content and layout criteria.",
+      "prompt": "Review the saved artifact {{workPath}}/report.pdf against every criterion in {{workPath}}/outline.md. Use list_roots to identify the artifacts root and preview_document with source `{ \"kind\": \"file\", \"rootId\": <artifacts root id>, \"path\": \"{{workPath}}/report.pdf\" }`; inspect all pages. Confirm the PDF opens, the title and executive summary are present, sections follow the outline, supplied facts are preserved without invention, tables/figures are legible and captioned, there are no clipped or accidental blank pages, and the report closes with explicit recommendations. Write PASS/FAIL for every criterion and name the page/section for any failure.\n\nThen route:\n\n- Every criterion PASSES → call `advance_task_step({ ref, stepId: \"evaluate\", next: \"finish\" })`.\n- Any criterion FAILS → write the exact gaps to task notes, then call `advance_task_step({ ref, stepId: \"evaluate\", next: \"write\" })` so the Markdown source is repaired and republished.\n\nNever route to finish while any criterion is unmet. After about three unproductive loops, stop with DONE_WITH_CONCERNS for the user.\n\nOpen `{{workPath}}/outline.md`, `{{workPath}}/report.pdf` from the artifacts drawer with `read_artifact` before working.",
+      "suggestedRole": "reviewer",
+      "next": "write",
+      "consumes": [
+        {
+          "file": "{{workPath}}/outline.md",
+          "artifact": true
+        },
+        {
+          "file": "{{workPath}}/report.pdf",
+          "artifact": true
+        }
+      ]
+    },
+    {
+      "id": "finish",
+      "name": "Finish",
+      "description": "All content and PDF checks passed.",
+      "prompt": "Every acceptance criterion passed. Call write_task_note with a short DONE summary naming report.md as the source and artifacts/report.pdf as the finished deliverable, plus the page count and confirmation that visual preview passed. Then report DONE.\n\nOpen `{{workPath}}/report.pdf` from the artifacts drawer with `read_artifact` before working.",
+      "suggestedRole": "copywriter",
+      "terminal": true,
+      "consumes": [
+        {
+          "file": "report.md"
+        },
+        {
+          "file": "{{workPath}}/report.pdf",
+          "artifact": true
+        }
+      ]
+    }
+  ],
+  "version": "1.1.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"
+}