@bendyline/gilde 0.1.37 → 0.1.39

package/data/craftbook-templates/an/anomaly-scan/versions/1.0.2/craftbook.json

@@ -0,0 +1,153 @@
+{
+  "id": "anomaly-scan",
+  "name": "Anomaly / Outlier Scan",
+  "description": "Scan a dataset for anomalies and outliers and report what is genuinely unusual versus expected noise. Defines the detection criteria and thresholds FIRST (statistical and rule-based, with an explicit definition of 'anomalous') so findings are reproducible, then runs the scan to flag and rank suspect records, then writes a prioritized report a human can triage. Use this for outlier detection, anomaly scanning, finding bad records, fraud/error spotting, or surfacing data points that don't fit.\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. Define detection criteria (data-analyst) — lock what counts as anomalous and the thresholds → gated on artifact `{{workPath}}/criteria.md` (markdown-notes)\n2. Run the scan (developer) — apply the criteria and emit ranked flagged records → gated on `data/anomalies.json` (json)\n3. Report the findings (copywriter) — write a prioritized, triage-ready anomaly report → gated on artifact `{{workPath}}/report.md` (markdown-report)\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "criteria",
+  "triggers": [
+    "find anomalies",
+    "detect outliers",
+    "scan for bad records",
+    "spot unusual data",
+    "outlier detection"
+  ],
+  "steps": [
+    {
+      "id": "criteria",
+      "name": "Define detection criteria",
+      "description": "lock what counts as anomalous and the thresholds",
+      "prompt": "Define exactly what 'anomalous' means before scanning, so results are reproducible. Step 1: choose which columns/metrics to scan and the expected normal behavior of each. Step 2: pick detection methods per column — statistical (z-score > 3, IQR fence at 1.5x, percentile cutoffs) for numerics; rule-based (impossible/contradictory values, future dates, out-of-domain categories, broken referential integrity) where rules apply. Step 3: set concrete thresholds and a severity scale (e.g. high = impossible value or z > 4; medium = z 3-4). Step 4: decide how to rank flagged records. Step 5: write an acceptance-criteria checklist ('every method has a stated threshold', 'each flag records the rule it tripped and a severity', 'findings are ranked', 'false-positive rate is considered'). Call write_task_note and write the methods + thresholds + checklist to {{workPath}}/criteria.md. No scanning yet.\n\nThe deliverable `{{workPath}}/criteria.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": "data-analyst",
+      "advanceWhen": {
+        "file": "{{workPath}}/criteria.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/criteria.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/criteria.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "criteria",
+        "maxAttempts": 3
+      },
+      "next": "scan"
+    },
+    {
+      "id": "scan",
+      "name": "Run the scan",
+      "description": "apply the criteria and emit ranked flagged records",
+      "prompt": "Apply the detection criteria to the full dataset deterministically. Step 1: compute the per-column statistics the thresholds need (mean/stdev, quartiles, value-domain sets). Step 2: evaluate every record against each method and collect the flags it trips, with the measured value and the threshold it breached. Step 3: assign each flagged record a severity and a reason string. Step 4: rank flagged records by severity then magnitude. Step 5: emit data/anomalies.json — a ranked list of { record id/row, column, value, rule, threshold, severity } plus a summary count by severity. Do not flag records that don't breach a stated threshold. Call write_task_note with the counts by severity and the top findings.",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "data/anomalies.json",
+        "minBytes": 1,
+        "sniff": "json-valid"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "data/anomalies.json",
+            "bytes": 2
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkJsonValid",
+            "scope": "standard",
+            "inputs": {
+              "file": "data/anomalies.json"
+            }
+          }
+        ],
+        "onReject": "scan",
+        "maxAttempts": 3
+      },
+      "next": "report"
+    },
+    {
+      "id": "report",
+      "name": "Report the findings",
+      "description": "write a prioritized, triage-ready anomaly report",
+      "prompt": "Turn the flagged records into a report a human can triage — use only what the scan found. Step 1: open with a summary: how many records scanned, how many flagged, and the breakdown by severity. Step 2: list the top findings highest-severity first, each with the record, the value, what's wrong, and why it tripped (the rule + threshold). Step 3: group repeated patterns ('14 rows have a negative price') rather than listing each identically. Step 4: separate likely-real anomalies from probable noise/false-positives and say which deserve action. Step 5: end with recommended next steps. Write the report to {{workPath}}/report.md and call write_task_note with the path. On a loop-back, fix only the named gaps.\n\nThe deliverable `{{workPath}}/report.md` lands in the project's artifacts drawer — write it with `write_artifact` and read it back with `read_artifact`; the shipped workspace stays untouched.",
+      "suggestedRole": "copywriter",
+      "advanceWhen": {
+        "file": "{{workPath}}/report.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/report.md",
+            "bytes": 1500,
+            "artifact": true
+          },
+          {
+            "kind": "contains",
+            "file": "{{workPath}}/report.md",
+            "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+            "flags": "i",
+            "label": "at least one markdown heading",
+            "artifact": true
+          }
+        ],
+        "onReject": "report",
+        "maxAttempts": 4
+      },
+      "next": "evaluate"
+    },
+    {
+      "id": "evaluate",
+      "name": "Evaluate",
+      "description": "Grade the deliverable against every acceptance criterion. All pass → finish; any fail → loop back and fix the gap.",
+      "prompt": "Read {{workPath}}/report.md and cross-check it against {{workPath}}/criteria.md and data/anomalies.json. Verify: every detection method named a concrete threshold; each reported flag records the rule it tripped, the value, and a severity; findings are ranked highest-severity first; repeated patterns are grouped, not duplicated; and likely false-positives are separated from real anomalies. Re-derive two flagged records from the criteria to confirm they genuinely breach a threshold (no spurious flags). Write PASS/FAIL per criterion; any FAIL loops back to report.\n\nThe deliverable lives in the project's artifacts drawer — open `{{workPath}}/report.md` with `read_artifact`, not `read_file`.\n\nThen route — this is the whole point of the loop:\n\n- **Every criterion PASSES →** call `advance_task_step({ ref, stepId: \"evaluate\", next: \"finish\" })`.\n- **Any criterion FAILS →** write the specific gaps to notes, then call `advance_task_step({ ref, stepId: \"evaluate\", next: \"report\" })` to loop back. The builder fixes exactly those gaps.\n\nNever route to `finish` while any criterion is unmet. The build phase's completion gate already blocked a grossly-incomplete deliverable; your job is the judgment an automated check cannot make (does it actually work, read well, look right). After ~3 unproductive loops, stop and report DONE_WITH_CONCERNS so the user can step in.",
+      "suggestedRole": "reviewer",
+      "consumes": [
+        {
+          "file": "{{workPath}}/report.md",
+          "artifact": true
+        }
+      ],
+      "next": "report"
+    },
+    {
+      "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/an/anomaly-scan/versions/1.0.2/test.json

@@ -0,0 +1,123 @@
+{
+  "schemaVersion": 1,
+  "title": "Anomaly scan over seeded orders data",
+  "objective": "Measure whether the anomaly-scan craftbook defines reproducible criteria, emits machine-readable flags, and writes a triage-ready report.",
+  "tags": [
+    "data"
+  ],
+  "prompt": "In the `Anomaly Scan Eval` project, read `data/orders.csv`, define concrete anomaly thresholds, write `data/anomalies.json`, and then write `tasks/eval/report.md` ranking the findings. The report must separate likely real problems from probable noise.",
+  "setup": {
+    "projectName": "Anomaly Scan Eval",
+    "about": "Self-contained eval project for anomaly-scan. The source dataset is workspace/data/orders.csv.",
+    "missionObjectives": "Find and explain anomalous order rows with explicit rules, JSON flags, severities, and a triage report.",
+    "files": [
+      {
+        "path": "data/orders.csv",
+        "content": "order_id,order_date,sku,quantity,revenue,region\nO-1001,2026-05-01,CHAIR-1,2,240,West\nO-1002,2026-05-01,LAMP-2,1,80,East\nO-1003,2026-05-02,DESK-5,1,620,West\nO-1004,2026-05-02,CHAIR-1,3,360,South\nO-1005,2026-05-03,LAMP-2,2,160,East\nO-1006,2026-05-03,DESK-5,1,610,West\nO-1007,2026-05-04,CHAIR-1,4,-480,West\nO-1008,2026-05-04,LAMP-2,1,82,North\nO-1009,2026-05-05,DESK-5,50,30500,West\nO-1010,2028-01-01,LAMP-2,1,80,East\nO-1011,2026-05-06,CHAIR-1,2,242,South\nO-1012,2026-05-06,DESK-5,1,615,West\nO-1013,2026-05-07,LAMP-2,0,0,East\n"
+      }
+    ],
+    "worker": {
+      "name": "Cato",
+      "role": "Data Analyst"
+    },
+    "craftbookParams": {
+      "workPath": "tasks/eval"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "workspace/report.md and data/anomalies.json identify the seeded anomalous rows with rules, thresholds, severity, and triage guidance.",
+    "deliverables": [
+      {
+        "path": "tasks/eval/report.md",
+        "kind": "markdown-report",
+        "minBytes": 1800,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "tasks/eval/report.md",
+            "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/report.md",
+            "pattern": "O-1007|O-1009|O-1010|O-1013",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/report.md",
+            "pattern": "negative|future|quantity|outlier|threshold|severity",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/report.md",
+            "pattern": "likely real|probable noise|false positive",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/report.md",
+            "pattern": "recommended next steps|triage|action",
+            "flags": "i"
+          }
+        ]
+      },
+      {
+        "path": "data/anomalies.json",
+        "kind": "json",
+        "minBytes": 300,
+        "checks": [
+          {
+            "kind": "sniff",
+            "file": "data/anomalies.json",
+            "sniff": "json-valid"
+          },
+          {
+            "kind": "contains",
+            "file": "data/anomalies.json",
+            "pattern": "O-1007|O-1009|O-1010|O-1013",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "data/anomalies.json",
+            "pattern": "severity|rule|threshold|summary",
+            "flags": "i"
+          }
+        ]
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "tasks/eval/report.md",
+      "kind": "markdown"
+    },
+    "axes": [
+      {
+        "name": "accuracy",
+        "description": "Computed figures are correct against the seeded records."
+      },
+      {
+        "name": "grounding",
+        "description": "Every claim traces to the seeded data — nothing invented."
+      },
+      {
+        "name": "structure",
+        "description": "Tables and sections make the analysis checkable at a glance."
+      },
+      {
+        "name": "actionability",
+        "description": "Recommendations follow from the findings and are concretely doable."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "criteria first",
+    "JSON flags",
+    "ranked triage report"
+  ]
+}

package/data/craftbook-templates/ap/api-contract-review/versions/1.1.2/craftbook.json

@@ -0,0 +1,153 @@
+{
+  "id": "api-contract-review",
+  "name": "API Contract Review",
+  "description": "Review an API contract or specification (OpenAPI/REST/GraphQL) for correctness, consistency, and developer ergonomics, then produce a findings report. First scopes the surface and locks an API design checklist (resource naming and HTTP semantics, status codes, pagination and filtering, error schema consistency, auth, versioning and backward compatibility, idempotency, and schema/type rigor), then reviews each endpoint and type against those rules and REST/GraphQL best practices, then writes a findings report rating each issue and giving the corrected contract snippet. Use this for an API design review, reviewing an OpenAPI/Swagger spec, a REST or GraphQL contract review, endpoint/schema critique, or checking an API for consistency and backward compatibility before it ships — it returns specific, spec-anchored fixes rather than 'make the API cleaner'.\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 contract review (reviewer) — map the surface, lock an API design checklist → gated on artifact `{{workPath}}/scope.md` (markdown-notes)\n2. Review the endpoints (developer) — check each operation + type against the rules → gated on artifact `{{workPath}}/review.md` (markdown-notes)\n3. Write the contract report (reviewer) — findings with corrected snippets + compat verdict → gated on artifact `{{workPath}}/api-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": "scope",
+  "triggers": [
+    "api contract review",
+    "review my openapi spec",
+    "review this REST API",
+    "graphql schema review",
+    "is this api backward compatible",
+    "api design review"
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the contract review",
+      "description": "map the surface, lock an API design checklist",
+      "prompt": "Step 1: Read the contract (OpenAPI/Swagger YAML/JSON, a GraphQL SDL, or the route/handler definitions) and inventory every endpoint/operation/type with its method, path, params, request/response schema, and auth. Step 2: Note whether this is a NEW API or a CHANGE to an existing one (if a change, backward compatibility is a first-class criterion). Step 3: Write an API acceptance-criteria checklist covering: resource naming (nouns, plural collections, consistent casing) and correct HTTP-method semantics; correct and consistent status codes (201 on create, 204 on empty, 4xx vs 5xx); a single consistent error schema across all endpoints; pagination/filtering/sorting conventions applied uniformly; auth declared per operation; explicit versioning and no breaking changes (no removed/renamed fields, no narrowed types, no new required inputs) for changes; idempotency for unsafe-but-retried operations; and schema rigor (required vs optional correct, enums constrained, types precise, examples present). Step 4: State the pass condition for each. Write the surface inventory + checklist to `write_task_note` AND `{{workPath}}/scope.md`. No findings 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": "review"
+    },
+    {
+      "id": "review",
+      "name": "Review the endpoints",
+      "description": "check each operation + type against the rules",
+      "prompt": "Step 1: Walk EACH endpoint/operation against the checklist: verify the method matches the action, the path is a sensible resource, the status codes are correct and complete (including error codes), the request/response schemas are precise, and auth is declared. Step 2: Walk EACH type/schema: required vs optional fields are right, enums and formats constrain values, nullability is intentional, and naming is consistent. Step 3: Cross-cut the whole surface for consistency: do all errors share one schema, is pagination uniform, is casing consistent, are similar resources modeled the same way. Step 4: For a CHANGE, diff against the prior contract and flag every breaking change. Step 5: For each finding capture: the operation/type, the rule violated, the impact on a client developer, severity, and the CORRECTED snippet (the fixed YAML/SDL/schema fragment). Good looks like: a finding with a before/after contract snippet, not 'improve error handling'. Stage findings to `write_task_note`. Do not write the report yet.\n\nThe deliverable `{{workPath}}/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": "developer",
+      "advanceWhen": {
+        "file": "{{workPath}}/review.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/review.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/review.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "review",
+        "maxAttempts": 3
+      },
+      "next": "report"
+    },
+    {
+      "id": "report",
+      "name": "Write the contract report",
+      "description": "findings with corrected snippets + compat verdict",
+      "prompt": "Step 1: Open `{{workPath}}/api-review.md` and write a verdict: Approve / Approve-with-changes / Request-changes, and for a change an explicit Backward-compatible: yes/no. Step 2: Add a '## Breaking changes' section first if any (each with the operation and the corrected approach), then '## Blocking' and '## Non-blocking' findings, each as `operation/type — rule — impact — corrected snippet`. Step 3: Add a '## Consistency' section for cross-cutting issues (error schema, pagination, casing). Step 4: Add a '## Strengths' note on what the contract gets right. Every finding must cite the operation/type and include a concrete corrected snippet — no generic advice. On a loop-back, fix only the named gaps. `write_task_note` the report path, the compatibility verdict, and the count of blocking findings.\n\nThe deliverable `{{workPath}}/api-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}}/api-review.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/api-review.md",
+            "bytes": 1500,
+            "artifact": true
+          },
+          {
+            "kind": "contains",
+            "file": "{{workPath}}/api-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}}/api-review.md` and grade it against the scope checklist. Check EACH criterion and write PASS/FAIL with a one-line reason: (1) every endpoint/operation and type was reviewed; (2) HTTP-method/status-code semantics were checked; (3) error schema, pagination, and naming consistency were assessed across the surface; (4) for a change, backward compatibility is explicitly stated and any breaking change is flagged; (5) each finding includes a concrete corrected contract snippet; (6) findings are prioritized (breaking/blocking/non-blocking); (7) the verdict 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}}/api-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}}/api-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.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"
+}

package/data/craftbook-templates/ap/api-contract-review/versions/1.1.2/test.json

@@ -0,0 +1,118 @@
+{
+  "schemaVersion": 1,
+  "title": "API Contract Review codebase eval",
+  "objective": "Measure whether the review reconciles an OpenAPI contract with its handler and catches consistency, semantics, auth, and pagination defects.",
+  "tags": [
+    "corpus"
+  ],
+  "prompt": "Use the API Contract Review craftbook for a codebase-wide API design pass. Compare openapi.yaml with src/routes.ts and write tasks/eval/api-review.md with corrected snippets. Do not edit the contract or handler.",
+  "setup": {
+    "projectName": "API Design Maintenance Eval",
+    "about": "A small REST API whose contract and implementation contain deliberate design and drift defects.",
+    "missionObjectives": "Produce an evidence-backed API design report covering every seeded operation and its implementation.",
+    "files": [
+      {
+        "path": "openapi.yaml",
+        "content": "openapi: 3.0.3\ninfo: { title: Widget API, version: 1.0.0 }\npaths:\n  /getWidgets:\n    get:\n      responses:\n        '200':\n          description: widgets\n          content:\n            application/json:\n              schema: { type: array, items: { $ref: '#/components/schemas/Widget' } }\n  /widgets:\n    post:\n      requestBody:\n        required: true\n        content:\n          application/json:\n            schema: { $ref: '#/components/schemas/Widget' }\n      responses:\n        '200': { description: created }\ncomponents:\n  schemas:\n    Widget:\n      type: object\n      properties:\n        id: { type: string }\n        display_name: { type: string }\n"
+      },
+      {
+        "path": "src/routes.ts",
+        "content": "app.get('/widgets', async (_req, res) => res.json(await db.widgets.all()));\napp.post('/widgets', async (req, res) => {\n  const widget = await db.widgets.create(req.body);\n  res.status(200).json(widget);\n});\napp.get('/widgets/:id', async (req, res) => {\n  const item = await db.widgets.get(req.params.id);\n  if (!item) return res.status(404).json({ message: 'missing' });\n  res.json(item);\n});\n"
+      }
+    ],
+    "worker": {
+      "name": "Rae",
+      "role": "Reviewer"
+    },
+    "craftbookParams": {
+      "workPath": "tasks/eval"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "tasks/eval/api-review.md covers every seeded operation, contract/implementation drift, and corrected contract snippets.",
+    "deliverables": [
+      {
+        "path": "tasks/eval/api-review.md",
+        "kind": "markdown-report",
+        "minBytes": 1400,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "tasks/eval/api-review.md",
+            "pattern": "openapi\\.yaml|src/routes\\.ts",
+            "flags": "i",
+            "label": "real evidence"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/api-review.md",
+            "pattern": "/getWidgets|resource naming|noun",
+            "flags": "i",
+            "label": "resource naming"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/api-review.md",
+            "pattern": "201|created",
+            "flags": "i",
+            "label": "create response semantics"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/api-review.md",
+            "pattern": "pagination|cursor|limit",
+            "flags": "i",
+            "label": "collection pagination"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/api-review.md",
+            "pattern": "auth|security",
+            "flags": "i",
+            "label": "auth coverage"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/api-review.md",
+            "pattern": "/widgets/:id|not documented|drift",
+            "flags": "i",
+            "label": "implementation drift"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/api-review.md",
+            "pattern": "```(?:ya?ml|json)?[\\s\\S]{20,}```",
+            "flags": "i",
+            "label": "corrected snippet"
+          }
+        ]
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "tasks/eval/api-review.md",
+      "kind": "markdown"
+    },
+    "axes": [
+      {
+        "name": "surface coverage",
+        "description": "The contract and all implemented operations are reconciled."
+      },
+      {
+        "name": "design rigor",
+        "description": "Semantics, consistency, auth, pagination, and schema quality are reviewed."
+      },
+      {
+        "name": "actionability",
+        "description": "Findings include concrete corrected snippets and compatibility impact."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "contract-implementation reconciliation",
+    "API semantics",
+    "corrected snippets"
+  ]
+}