@bendyline/gilde 0.1.38 → 0.1.40

package/data/craftbook-templates/re/research-to-document/versions/1.2.2/craftbook.json

@@ -0,0 +1,228 @@
+{
+  "id": "research-to-document",
+  "name": "Word Document from Content or Research",
+  "description": "Produce a real Word document from supplied notes, existing workspace content, or a research question. The workflow locks the audience and document structure, inventories the provided evidence (and researches only when the user actually asked for new research), writes the complete source as report.md, then uses the pre-authorized DocBlocks toolset to convert directly to DOCX, preview the pages, and save {{workPath}}/report.docx in the artifacts drawer. PDF can be emitted in the same conversion call when requested.\n\nPlain Markdown is the source of truth. DocBlocks 2.3.x needs no validation preflight: convert_document reports diagnostics and preview_document supplies visual evidence. Never call the removed validate_document tool, hand-assemble OOXML, or substitute HTML for a requested DOCX.\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": "scope",
+  "triggers": [
+    "create a word document",
+    "make a docx",
+    "export this as docx",
+    "turn this content into a word document",
+    "research and write a document",
+    "research this and put it in word",
+    "write a cited briefing document"
+  ],
+  "toolsets": [
+    {
+      "toolsetId": "docblocks",
+      "sourceId": "bundled",
+      "autoAllow": true,
+      "reason": "convert report.md directly to DOCX or PDF, preview pages, and save the finished document without a prompt per call"
+    }
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the document",
+      "description": "Lock audience, source boundary, structure, requested formats, and acceptance criteria.",
+      "prompt": "Scope the document before writing. 1. State the audience, purpose, and decision/takeaway. 2. Inventory the supplied content and named workspace files. Decide whether the user asked for new research; if not, explicitly prohibit adding outside facts. 3. Lock the section order, citation style when relevant, and whether the durable output is DOCX only or DOCX plus PDF. 4. Identify tables, figures, and existing media assets that must survive conversion. 5. Write acceptance criteria covering source fidelity, section coverage, citations when needed, readable page layout, and real saved binary files in artifacts. Write {{workPath}}/scope.md and call write_task_note with the source boundary, section count, and target formats.\n\nStore `{{workPath}}/scope.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}}/scope.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/scope.md",
+            "bytes": 180,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/scope.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "scope",
+        "maxAttempts": 3
+      },
+      "next": "sources"
+    },
+    {
+      "id": "sources",
+      "name": "Prepare the source log",
+      "description": "Record supplied sources and gather new evidence only when research was requested.",
+      "prompt": "Prepare {{workPath}}/sources.md to the boundary in {{workPath}}/scope.md. If the user supplied the content and did not ask for research, list each supplied file or message section and the facts it contributes; do not browse or add outside claims. If new research was requested, gather credible sources, record title/publisher/date/URL or workspace path, extract only the facts relevant to the outline, and cross-check consequential claims. Assign stable citation keys when citations are required. Mark unsupported gaps rather than guessing. Call write_task_note with the source count and unresolved gaps.\n\nOpen `{{workPath}}/scope.md` from the artifacts drawer with `read_artifact` before working. Store `{{workPath}}/sources.md` in the artifacts drawer with `write_artifact`, then verify it with `read_artifact`; do not write this working file to the workspace.",
+      "suggestedRole": "researcher",
+      "advanceWhen": {
+        "file": "{{workPath}}/sources.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/sources.md",
+            "bytes": 160,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/sources.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "sources",
+        "maxAttempts": 3
+      },
+      "next": "write",
+      "consumes": [
+        {
+          "file": "{{workPath}}/scope.md",
+          "artifact": true
+        }
+      ]
+    },
+    {
+      "id": "write",
+      "name": "Write the Markdown document",
+      "description": "Write the complete report.md source from the locked outline and source log.",
+      "prompt": "Write report.md as the complete document source. 1. Follow {{workPath}}/scope.md section order exactly, starting with one H1 title and a concise opening summary. 2. Use clear H2/H3 sections and real prose grounded only in {{workPath}}/sources.md. 3. Use Markdown tables for structured comparisons and existing workspace images only when the scope calls for them; add meaningful alt text, captions, and in-prose references. 4. Cite claims with the locked style and include references when research was requested. 5. End with the requested conclusion, recommendation, or next steps. 6. Check every content criterion before advancing. Do not create DOCX XML, HTML, or base64. Call write_task_note with the path, word count, and section count.\n\nOpen `{{workPath}}/scope.md`, `{{workPath}}/sources.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 document title"
+          },
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "(?:^|\\n)##\\s+\\S",
+            "label": "at least one document section"
+          }
+        ],
+        "onReject": "write",
+        "maxAttempts": 4
+      },
+      "next": "publish",
+      "consumes": [
+        {
+          "file": "{{workPath}}/scope.md",
+          "artifact": true
+        },
+        {
+          "file": "{{workPath}}/sources.md",
+          "artifact": true
+        }
+      ]
+    },
+    {
+      "id": "publish",
+      "name": "Publish the Word document",
+      "description": "Convert report.md with DocBlocks, preview every page, and save {{workPath}}/report.docx plus optional PDF.",
+      "prompt": "Publish report.md with the pre-authorized DocBlocks tools. 1. Call list_roots first and identify the read-enabled workspace root and write-enabled artifacts root. If no write root exists, report the blocker instead of substituting Markdown or HTML as the finished file. 2. Optionally call get_authoring_context with targetFormat \"docx\" and goal \"content-first\" when target details or templates would help; no preflight is required. 3. Call convert_document once with source `{ \"kind\": \"file\", \"rootId\": <workspace root id>, \"path\": \"report.md\" }`, a DOCX target using editable-native fidelity and the document title, plus a PDF target in the SAME call only when {{workPath}}/scope.md requests PDF. Use a restrained theme when appropriate and `autoTemplates: true`. 4. Call preview_document on the DOCX artifact URI and inspect all pages (paginate after 20): title and headings present, tables intact, images/captions placed, citations/references readable, no clipped or accidental blank pages. Repair report.md and reconvert on failure. 5. Call save_artifact for the DOCX artifact URI with destination `{ \"rootId\": <artifacts root id>, \"path\": \"{{workPath}}/report.docx\", \"ifExists\": \"error\" }`; call save_artifact for report.pdf when requested. On loop-back, replace only with the current expectedSha256. 6. Call write_task_note with target paths, page count, theme, and preview result. Do not call validate_document; it is not part of the current DocBlocks MCP.\n\nOpen `{{workPath}}/scope.md` from the artifacts drawer with `read_artifact` before working.",
+      "suggestedRole": "copywriter",
+      "advanceWhen": {
+        "file": "{{workPath}}/report.docx",
+        "minBytes": 1,
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/report.docx",
+            "bytes": 1000,
+            "artifact": true
+          }
+        ],
+        "onReject": "publish",
+        "maxAttempts": 4
+      },
+      "next": "evaluate",
+      "consumes": [
+        {
+          "file": "{{workPath}}/scope.md",
+          "artifact": true
+        },
+        {
+          "file": "report.md"
+        }
+      ]
+    },
+    {
+      "id": "evaluate",
+      "name": "Evaluate",
+      "description": "Review the saved Word document against every content and layout criterion.",
+      "prompt": "Review artifacts/report.docx against every criterion in {{workPath}}/scope.md. Use list_roots to identify the artifacts root and preview_document with source `{ \"kind\": \"file\", \"rootId\": <artifacts root id>, \"path\": \"{{workPath}}/report.docx\" }`; inspect all pages. Confirm the file is a real DOCX, supplied content is preserved without invention, every section appears in order, citations and references resolve when required, tables/images/captions remain legible, and no content is clipped or stranded on accidental blank pages. Confirm report.pdf exists too when requested. Write PASS/FAIL per 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\" })`.\n\nNever route to finish while any criterion is unmet. After about three unproductive loops, stop with DONE_WITH_CONCERNS.\n\nOpen `{{workPath}}/scope.md`, `{{workPath}}/report.docx` from the artifacts drawer with `read_artifact` before working.",
+      "suggestedRole": "reviewer",
+      "next": "write",
+      "consumes": [
+        {
+          "file": "{{workPath}}/scope.md",
+          "artifact": true
+        },
+        {
+          "file": "{{workPath}}/report.docx",
+          "artifact": true
+        }
+      ]
+    },
+    {
+      "id": "finish",
+      "name": "Finish",
+      "description": "All source, content, and Word-document 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.docx (plus report.pdf when requested) as the finished deliverable, plus the page count and confirmation that visual preview passed. Then report DONE.\n\nOpen `{{workPath}}/report.docx` from the artifacts drawer with `read_artifact` before working.",
+      "suggestedRole": "copywriter",
+      "terminal": true,
+      "consumes": [
+        {
+          "file": "report.md"
+        },
+        {
+          "file": "{{workPath}}/report.docx",
+          "artifact": true
+        }
+      ]
+    }
+  ],
+  "version": "1.2.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/research-to-document/versions/1.2.2/test.json

@@ -0,0 +1,243 @@
+{
+  "schemaVersion": 1,
+  "title": "Word Document DocBlocks artifact-surface eval",
+  "objective": "Verify the research-to-document craftbook carries a reviewed Markdown source all the way to a real editable DOCX in the ARTIFACTS drawer via the DocBlocks template route (list_templates / describe_template / convert_document / preview_document / save_artifact) — the surface and tool family powerpoint-deck's workspace-copy route does not cover.",
+  "tags": [
+    "external",
+    "documents"
+  ],
+  "prompt": "Read `source/brief.md` and publish a Word document.\n\n1. Write the complete document source to `report.md`: a title, executive summary, compact metrics table, findings, and next actions. Do not create HTML or document XML by hand.\n2. Publish it with the pre-authorized DocBlocks tools. Call `list_roots` to find the read-enabled workspace root and the write-enabled artifacts root. Call `list_templates` and `describe_template` to choose a document template and follow its section expectations. Then `convert_document` to DOCX, `preview_document` to confirm it rendered, and `save_artifact` to persist it to `tasks/eval/report.docx` in the artifacts drawer.\n\nThe finished deliverable is the real DOCX at `tasks/eval/report.docx` in the artifacts drawer. Markdown, HTML, or hand-built OOXML written to that path is not a substitute.",
+  "setup": {
+    "projectName": "Word Document from Content Eval",
+    "about": "The reviewed source is Markdown and is converted to an editable DOCX by DocBlocks. The finished document lands in the project ARTIFACTS drawer, not the workspace.",
+    "missionObjectives": "Create a complete, source-grounded report.md, then convert and save it as a real artifacts-drawer tasks/eval/report.docx through the DocBlocks template route.",
+    "files": [
+      {
+        "path": "source/brief.md",
+        "content": "# Boreal Desk Returns Pilot\n\nAudience: operations leaders.\n\nFacts:\n- Pilot coverage: 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- Top unresolved complaint: status silence after photo submission.\n- Next actions: automated status emails, barcode-exception training, weekly Finance exception export.\n\nDo not invent other metrics."
+      }
+    ],
+    "worker": {
+      "name": "Jules",
+      "role": "Copywriter"
+    },
+    "craftbookParams": {
+      "workPath": "tasks/eval"
+    }
+  },
+  "mocks": [
+    {
+      "kind": "mcp",
+      "id": "docblocks",
+      "toolsetId": "docblocks",
+      "description": "Deterministic fake DocBlocks MCP for template selection, DOCX conversion, preview, and artifact-drawer saving.",
+      "tools": [
+        {
+          "name": "list_roots",
+          "description": "List the workspace read root and artifacts write root.",
+          "resultTemplate": {
+            "roots": [
+              {
+                "id": "workspace",
+                "name": "workspace",
+                "capabilities": [
+                  "read"
+                ]
+              },
+              {
+                "id": "artifacts",
+                "name": "artifacts",
+                "capabilities": [
+                  "read",
+                  "write"
+                ]
+              }
+            ]
+          }
+        },
+        {
+          "name": "get_authoring_context",
+          "description": "Return optional DOCX authoring guidance.",
+          "resultTemplate": {
+            "targetFormat": "docx",
+            "guidance": "Content-first Markdown; one H1 title, H2 sections, real tables."
+          }
+        },
+        {
+          "name": "list_templates",
+          "description": "List the document templates available for DOCX conversion.",
+          "resultTemplate": {
+            "templates": [
+              {
+                "id": "briefing-report",
+                "label": "Briefing report",
+                "formats": [
+                  "docx",
+                  "pdf"
+                ]
+              },
+              {
+                "id": "one-pager",
+                "label": "Executive one-pager",
+                "formats": [
+                  "docx"
+                ]
+              },
+              {
+                "id": "slide-notes",
+                "label": "Slide notes",
+                "formats": [
+                  "pptx"
+                ]
+              }
+            ]
+          }
+        },
+        {
+          "name": "describe_template",
+          "description": "Describe a template's expected sections and styles.",
+          "resultTemplate": {
+            "id": "briefing-report",
+            "sections": [
+              "Title",
+              "Executive summary",
+              "Metrics",
+              "Findings",
+              "Next actions"
+            ],
+            "styles": {
+              "heading": "Heading 1",
+              "table": "Grid Table 4"
+            }
+          }
+        },
+        {
+          "name": "convert_document",
+          "description": "Convert approved Markdown to a deterministic DOCX artifact URI.",
+          "resultTemplate": {
+            "artifacts": [
+              {
+                "format": "docx",
+                "uri": "mock://docblocks/report.docx",
+                "sha256": "3333333333333333333333333333333333333333333333333333333333333333"
+              }
+            ],
+            "diagnostics": []
+          }
+        },
+        {
+          "name": "preview_document",
+          "description": "Return deterministic page-preview evidence.",
+          "resultTemplate": {
+            "pages": 4,
+            "overflow": false,
+            "missingStyles": [],
+            "previewed": true
+          }
+        },
+        {
+          "name": "save_artifact",
+          "description": "Save the converted DOCX into the project artifacts drawer.",
+          "resultTemplate": {
+            "ok": true,
+            "bytes": 2100,
+            "sha256": "4444444444444444444444444444444444444444444444444444444444444444"
+          },
+          "writeFixture": {
+            "surface": "artifact",
+            "pathArgument": "destination.path",
+            "fixture": "minimal-docx"
+          }
+        }
+      ]
+    }
+  ],
+  "success": {
+    "summary": "report.md is a complete source-grounded Markdown document, and artifacts/report.docx is a real ZIP-shaped DOCX produced through the DocBlocks template route rather than written by hand.",
+    "deliverables": [
+      {
+        "path": "report.md",
+        "kind": "markdown-report",
+        "minBytes": 1000,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "(?:^|\\n)#\\s+.+",
+            "flags": "m"
+          },
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "executive summary",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "18\\s+SKUs|18\\s+hours|6\\s+hours|14\\.2%|8\\.9%",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "automated status emails|barcode-exception training|weekly Finance exception export",
+            "flags": "i"
+          },
+          {
+            "kind": "notContains",
+            "file": "report.md",
+            "pattern": "<html|<style|word/document\\.xml|base64",
+            "flags": "i"
+          }
+        ]
+      }
+    ],
+    "mocks": [
+      {
+        "service": "docblocks",
+        "requiredTools": [
+          "list_roots",
+          "list_templates",
+          "describe_template",
+          "convert_document",
+          "preview_document",
+          "save_artifact"
+        ]
+      }
+    ],
+    "checks": [
+      {
+        "kind": "binaryDocument",
+        "file": "tasks/eval/report.docx",
+        "artifact": true,
+        "minBytes": 800
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "report.md",
+      "kind": "markdown"
+    },
+    "axes": [
+      {
+        "name": "grounding",
+        "description": "Every metric and action comes from the seeded brief."
+      },
+      {
+        "name": "structure",
+        "description": "The source has a usable title, summary, sections, table, and next actions."
+      },
+      {
+        "name": "convertibility",
+        "description": "The Markdown is complete enough for direct DocBlocks DOCX conversion without HTML or XML."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "Markdown source quality",
+    "DOCX readiness",
+    "no HTML or OOXML intermediary"
+  ]
+}

package/data/craftbook-templates/re/rest-api/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "rest-api",
   "role": "project-starter",
+  "category": "code-data",
   "name": "REST API Service",
   "description": "Build a RESTful HTTP API service with resource endpoints, JSON request/response bodies, status codes, validation, and error handling. Locks the contract FIRST — resources, routes, verbs, request/response shapes, status-code map, auth, and pagination — so the implementation has a fixed target, then builds the server, then writes endpoint tests that exercise every route and error case. Covers CRUD endpoints, RESTful routing, OpenAPI-style contract, HTTP status codes, input validation, JSON serialization, and integration tests against the running handler.",
   "tags": [

package/data/craftbook-templates/re/rest-api/versions/1.0.3/craftbook.json

@@ -0,0 +1,159 @@
+{
+  "id": "rest-api",
+  "name": "REST API Service",
+  "description": "Build a RESTful HTTP API service with resource endpoints, JSON request/response bodies, status codes, validation, and error handling. Locks the contract FIRST — resources, routes, verbs, request/response shapes, status-code map, auth, and pagination — so the implementation has a fixed target, then builds the server, then writes endpoint tests that exercise every route and error case. Covers CRUD endpoints, RESTful routing, OpenAPI-style contract, HTTP status codes, input validation, JSON serialization, and integration tests against the running handler.\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. Contract design (planner) — lock resources, routes, request/response shapes, status codes → gated on artifact `{{workPath}}/contract-design.md` (markdown-notes)\n2. Build the service (developer) — implement the server to the locked contract → gated on `src/server.js` (code-module)\n3. Write endpoint tests (developer) — test every route, status code, and error path → gated on `src/server.test.js` (code-with-tests)\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "contract-design",
+  "triggers": [
+    "build a rest api",
+    "create an http api",
+    "crud endpoints",
+    "make a backend api",
+    "json api service"
+  ],
+  "steps": [
+    {
+      "id": "contract-design",
+      "name": "Contract design",
+      "description": "lock resources, routes, request/response shapes, status codes",
+      "prompt": "Design the API contract before any server code. Step 1: List the resources (nouns) the API exposes and the operations on each. Step 2: For every endpoint write the exact method + path (e.g. `GET /users/:id`, `POST /users`), with no base path/version prefix unless the source brief explicitly requires one, plus the request body/query shape, the success response shape and status code, and the error responses with their status codes (400 validation, 404 missing, 409 conflict, 401/403 auth). Step 3: Decide cross-cutting rules: content-type (`application/json`), pagination scheme for list endpoints, auth mechanism (or none), and the canonical error envelope (e.g. `{ error: { code, message } }`). Step 4: Write a numbered acceptance-criteria checklist of 5-9 concrete, testable items (e.g. 'POST /users with valid body returns 201 + the created resource with an id', 'GET on a missing id returns 404 with the error envelope', 'a malformed body returns 400, never 500'). Step 5: `write_task_note` the full contract table + the checklist, and write the same to the produces path. No implementation yet.\n\nThe deliverable `{{workPath}}/contract-design.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}}/contract-design.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/contract-design.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/contract-design.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "contract-design",
+        "maxAttempts": 3
+      },
+      "next": "build"
+    },
+    {
+      "id": "build",
+      "name": "Build the service",
+      "description": "implement the server to the locked contract",
+      "prompt": "Implement the API server in a single runnable source file that satisfies the contract exactly. Step 1: Wire a minimal HTTP server/router (standard library or the project's framework) with one handler per endpoint from the contract. If using Node built-ins, use a normal top-level import such as `import http from \"node:http\"` or `import { createServer } from \"node:http\"`; do not hide standard-library imports behind dynamic `await import()` inside a synchronous factory. Step 2: Parse and VALIDATE every request body/param before acting; on invalid input return the 400 error envelope, never let it reach a 500. Step 3: Return the exact status codes and response shapes the contract specifies, with `Content-Type: application/json`; after writing any auth, validation, not-found, or success response, immediately `return` so the handler cannot write headers twice. Step 4: Implement the error envelope and a catch-all so unexpected errors return a clean 500 with the envelope, not a stack trace. Use an in-memory store if no DB was specified. On a loop-back, fix only the gaps the reviewer named — do not regress passing routes. `write_task_note` the file path and which criteria now pass.",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "src/server.js",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "src/server.js",
+            "bytes": 200
+          },
+          {
+            "kind": "sniff",
+            "file": "src/server.js",
+            "sniff": "nonempty"
+          },
+          {
+            "kind": "esmImports",
+            "file": "src/server.js"
+          },
+          {
+            "kind": "sourceParses",
+            "file": "src/server.js"
+          }
+        ],
+        "onReject": "build",
+        "maxAttempts": 3
+      },
+      "next": "test"
+    },
+    {
+      "id": "test",
+      "name": "Write endpoint tests",
+      "description": "test every route, status code, and error path",
+      "prompt": "Write integration tests that exercise the running handler against every acceptance criterion. Step 1: For each endpoint, assert the happy path: correct status code AND response shape. Step 2: Assert each error path the contract names — 400 on bad input, 404 on missing, 401/403 on auth, 409 on conflict. Step 3: Assert the error envelope shape is consistent across all error responses. Step 4: Include at least one round-trip test (create then read back) to prove state is wired. For self-contained Node HTTP tests, start the server on `listen(0)`, read the assigned port from `server.address().port`, use built-in `fetch`, and close the server in `finally`. Make the tests runnable and self-contained. `write_task_note` the test file path and the pass/fail count.",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "src/server.test.js",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "src/server.js",
+            "bytes": 200
+          },
+          {
+            "kind": "sniff",
+            "file": "src/server.js",
+            "sniff": "nonempty"
+          },
+          {
+            "kind": "esmImports",
+            "file": "src/server.js"
+          },
+          {
+            "kind": "sourceParses",
+            "file": "src/server.js"
+          }
+        ],
+        "onReject": "test",
+        "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 the test suite and exercise the API. For EACH acceptance criterion: confirm the endpoint returns the documented status code and response shape, confirm every error path returns the correct code with the error envelope (and never a raw 500/stack trace on bad input), and confirm at least one create→read round-trip works. Write PASS/FAIL per criterion with the offending route on any 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": "src/server.js"
+        }
+      ],
+      "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.3",
+  "releasedAt": "2026-08-21T00:00:00Z",
+  "paramSchema": {
+    "type": "object",
+    "properties": {
+      "workPath": {
+        "type": "string",
+        "title": "Working folder",
+        "description": "Per-task working folder in the artifacts drawer. Defaults to this task's own folder so runs never collide; override with a stable name when you deliberately want runs to share files.",
+        "default": "{{task.dir}}"
+      }
+    }
+  },
+  "minGezelVersion": "1.26233"
+}