@bendyline/gilde 0.1.38 → 0.1.39

package/data/craftbook-templates/do/doc-intake-pipeline/versions/1.0.2/craftbook.json

@@ -0,0 +1,160 @@
+{
+  "id": "doc-intake-pipeline",
+  "name": "Classify and Route Incoming Documents",
+  "description": "Build a document-intake pipeline that classifies each incoming file (invoice, contract, resume, receipt, ID, support ticket, other) into a fixed type set, extracts a few key fields per type, and routes it to the right destination folder with a normalized filename. Locks the document-type taxonomy, per-type extraction fields, and the routing/naming rules FIRST, then builds the classify-extract-route loop, then verifies every input file was handled, classifications are in-set with an 'other' fallback, and routing is deterministic. Taxonomy-and-routing-before-build prevents files from silently vanishing or piling into a misc bucket.\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 pipeline (planner) — doc-type taxonomy, per-type fields, routing rules → gated on artifact `{{workPath}}/scope.md` (markdown-notes)\n2. Build the pipeline (developer) — classify, extract key fields, route + rename, log → gated on `intake.py` (code-module)\n3. Verify the pipeline (reviewer) — coverage, in-set types, deterministic routing → gated on artifact `{{workPath}}/verify.md` (markdown-notes)\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "scope",
+  "triggers": [
+    "sort incoming documents",
+    "classify and file documents",
+    "auto-route a folder of files",
+    "document intake pipeline",
+    "organize a dump of files"
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the pipeline",
+      "description": "doc-type taxonomy, per-type fields, routing rules",
+      "prompt": "Define the intake contract before building. Step 1: identify the inbox/source folder and the file types present (PDF, image, docx, email). Step 2: define the closed document-type taxonomy (e.g. invoice, contract, receipt, resume, id-document, support-ticket, other) — every file lands in exactly one, with 'other' as the explicit fallback. Step 3: for each type, list the few key fields to extract (e.g. invoice → vendor, date, total, invoice_no) and the classification signals (keywords, layout cues). Step 4: define routing and naming: destination folder per type and a normalized filename template (e.g. {type}/{date}_{vendor}_{id}.pdf), plus the dedup rule for name collisions. Step 5: write an acceptance-criteria checklist ('every input file classified into exactly one in-set type', 'an other bucket exists and is used not abused', 'per-type key fields extracted', 'each file routed and renamed deterministically', 'no file lost or overwritten', 'an intake manifest logs every file with source→destination'). Call write_task_note with taxonomy + fields + routing + checklist and write {{workPath}}/scope.md. No build 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": "planner",
+      "advanceWhen": {
+        "file": "{{workPath}}/scope.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/scope.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/scope.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "scope",
+        "maxAttempts": 3
+      },
+      "next": "build"
+    },
+    {
+      "id": "build",
+      "name": "Build the pipeline",
+      "description": "classify, extract key fields, route + rename, log",
+      "prompt": "Implement the intake pipeline to the locked contract. Step 1: enumerate every file in the source folder. Step 2: classify each into exactly one taxonomy type using the agreed signals; when confidence is low, route to 'other' rather than guessing a specific type. Step 3: extract the per-type key fields and capture them in the manifest. Step 4: route the file to its destination folder and rename it per the template, applying the collision/dedup rule so nothing is overwritten. Step 5: append an intake-manifest row per file (source path, type, extracted fields, destination path, status) and write the manifest. Make it a runnable module and write it; confirm the manifest parses. Call write_task_note with the module path, the manifest path, and per-type counts.",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "intake.py",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "intake.py",
+            "bytes": 200
+          },
+          {
+            "kind": "sniff",
+            "file": "intake.py",
+            "sniff": "nonempty"
+          },
+          {
+            "kind": "esmImports",
+            "file": "intake.py"
+          },
+          {
+            "kind": "sourceParses",
+            "file": "intake.py"
+          }
+        ],
+        "onReject": "build",
+        "maxAttempts": 3
+      },
+      "next": "verify"
+    },
+    {
+      "id": "verify",
+      "name": "Verify the pipeline",
+      "description": "coverage, in-set types, deterministic routing",
+      "prompt": "Verify the pipeline against scope. Step 1: confirm it runs and produces an intake manifest. Step 2: check coverage — the manifest has one row per source file and the count of routed files equals the count of input files (nothing lost). Step 3: confirm every classification is an in-set type and that 'other' is used for genuinely ambiguous files but not as a dumping ground for everything. Step 4: confirm routing is deterministic and collision-safe — re-running classifies the same file identically and no destination file was overwritten. Step 5: spot-check 5 files: correct type, extracted fields match the document, filename matches the template. Write PASS/FAIL per criterion to {{workPath}}/verify.md and task notes; on failure, name the files and loop back to build.\n\nThe deliverable `{{workPath}}/verify.md` lands in the project's artifacts drawer — write it with `write_artifact` and read it back with `read_artifact`; the shipped workspace stays untouched.",
+      "suggestedRole": "reviewer",
+      "advanceWhen": {
+        "file": "{{workPath}}/verify.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "intake.py",
+            "bytes": 200
+          },
+          {
+            "kind": "sniff",
+            "file": "intake.py",
+            "sniff": "nonempty"
+          },
+          {
+            "kind": "esmImports",
+            "file": "intake.py"
+          },
+          {
+            "kind": "sourceParses",
+            "file": "intake.py"
+          }
+        ],
+        "onReject": "verify",
+        "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 intake.py (or trace it) and verify every criterion from {{workPath}}/scope.md against the intake manifest. Confirm: one manifest row per source file with routed count equal to input count (no files lost or overwritten), every classification is in-set with 'other' used appropriately, per-type key fields are extracted, filenames follow the template, and routing is deterministic on re-run. Spot-check 5 files. Write PASS/FAIL per criterion; on any failure, name the files and loop back to build.\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": "intake.py"
+        }
+      ],
+      "next": "build"
+    },
+    {
+      "id": "finish",
+      "name": "Finish",
+      "description": "All acceptance criteria met. Stamp a short summary and report DONE.",
+      "prompt": "Every acceptance criterion passed. Write a one-paragraph DONE summary to task notes via `write_task_note`: what was built, the deliverable path(s), and a one-line confirmation that each criterion is met. Then report DONE.",
+      "suggestedRole": "developer",
+      "terminal": true
+    }
+  ],
+  "version": "1.0.2",
+  "releasedAt": "2026-08-21T00:00:00Z",
+  "paramSchema": {
+    "type": "object",
+    "properties": {
+      "workPath": {
+        "type": "string",
+        "title": "Working folder",
+        "description": "Per-task working folder in the artifacts drawer. Defaults to this task's own folder so runs never collide; override with a stable name when you deliberately want runs to share files.",
+        "default": "{{task.dir}}"
+      }
+    }
+  },
+  "minGezelVersion": "1.26233"
+}

package/data/craftbook-templates/do/doc-intake-pipeline/versions/1.0.2/test.json

@@ -0,0 +1,107 @@
+{
+  "schemaVersion": 1,
+  "title": "Classify and Route Incoming Documents smoke eval",
+  "objective": "Self-contained smoke eval for the Classify and Route Incoming Documents craftbook using the data generic harness.",
+  "tags": [
+    "data"
+  ],
+  "prompt": "I dropped our numbers in source/records.csv. Can you look at the data, analyze it, and put togehter some results in analysis.md?",
+  "setup": {
+    "projectName": "Classify and Route Incoming Documents Eval",
+    "about": "Self-contained eval project for doc-intake-pipeline. Seeded inputs are under workspace/source or workspace/fixtures; final deliverable is workspace/analysis.md.",
+    "missionObjectives": "Use the Classify and Route Incoming Documents craftbook/template, read the seeded local fixtures, and write analysis.md without network calls, real credentials, or live services.",
+    "files": [
+      {
+        "path": "source/brief.md",
+        "content": "# Classify and Route Incoming Documents 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: doc-intake-pipeline - Classify and Route Incoming Documents.\n"
+      },
+      {
+        "path": "source/records.csv",
+        "content": "customer,region,orders,revenue_usd,churn_risk\nAster,North,12,1440,low\nBoreal,South,8,720,medium\nCedar,West,15,2100,high\nDune,North,5,500,low\n"
+      }
+    ],
+    "worker": {
+      "name": "Jules",
+      "role": "Data Analyst"
+    },
+    "craftbookParams": {
+      "workPath": "tasks/eval"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "analysis.md is a seeded-data analysis with deterministic computed facts.",
+    "deliverables": [
+      {
+        "path": "analysis.md",
+        "kind": "markdown-report",
+        "minBytes": 900,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "analysis.md",
+            "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "analysis.md",
+            "pattern": "40\\b",
+            "flags": "i",
+            "label": "include total orders of 40"
+          },
+          {
+            "kind": "contains",
+            "file": "analysis.md",
+            "pattern": "\\$?4,?760\\b",
+            "flags": "i",
+            "label": "include total revenue of 4760"
+          },
+          {
+            "kind": "contains",
+            "file": "analysis.md",
+            "pattern": "Cedar",
+            "flags": "i",
+            "label": "identify Cedar as top revenue and high risk"
+          },
+          {
+            "kind": "contains",
+            "file": "analysis.md",
+            "pattern": "high",
+            "flags": "i",
+            "label": "include churn-risk finding"
+          }
+        ]
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "analysis.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": [
+    "seeded data reading",
+    "computed facts",
+    "recommendation grounding"
+  ]
+}

package/data/craftbook-templates/do/doc-rewrite/versions/1.0.2/craftbook.json

@@ -0,0 +1,119 @@
+{
+  "id": "doc-rewrite",
+  "name": "Documentation Rewrite",
+  "description": "Rewrite confusing existing documentation into clear, scannable, task-oriented prose without losing any technical fact: it first audits the current doc to catalog every problem — buried steps, undefined jargon, missing prerequisites, broken structure — and locks a clarity checklist, then rewrites the doc to fix exactly those issues while preserving every accurate instruction. Covers documentation rewrite, doc cleanup, clarify docs, improve README, restructure guide, and technical editing. Auditing before rewriting is the point: a small model that first inventories what is wrong rewrites with intent and preserves the facts, instead of producing a prettier doc that quietly drops a critical step.\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. Audit the doc (reviewer) — catalog every clarity defect and lock the fix checklist → gated on artifact `{{workPath}}/audit.md` (markdown-notes)\n2. Rewrite the doc (copywriter) — rewrite to the target structure, fixing every audited defect → gated on `rewritten-doc.md` (markdown-doc)\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "audit",
+  "triggers": [
+    "rewrite this documentation",
+    "clarify the docs",
+    "improve the readme",
+    "clean up this guide",
+    "restructure docs"
+  ],
+  "steps": [
+    {
+      "id": "audit",
+      "name": "Audit the doc",
+      "description": "catalog every clarity defect and lock the fix checklist",
+      "prompt": "1) Read the existing documentation closely as a new reader would. 2) Catalog every defect with its location: undefined jargon/acronyms, missing prerequisites, steps in the wrong order or buried in prose, passive/ambiguous instructions, missing examples, broken or inconsistent structure, and anything factually unclear. 3) Extract and list the technical facts/steps that MUST be preserved verbatim in meaning (the source of truth — these cannot be lost). 4) Propose the target structure (overview → prerequisites → step-by-step → troubleshooting/reference). Write an acceptance-criteria checklist (e.g. 'every preserved fact survives the rewrite'; 'all jargon defined on first use'; 'prerequisites stated up front'; 'instructions are imperative and numbered'; 'has at least one concrete example'; 'scannable headings'). Use write_task_note for the defect list + preserved-facts list + checklist, and write the same to the produces path. No rewrite yet.\n\nThe deliverable `{{workPath}}/audit.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}}/audit.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/audit.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/audit.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "audit",
+        "maxAttempts": 3
+      },
+      "next": "rewrite"
+    },
+    {
+      "id": "rewrite",
+      "name": "Rewrite the doc",
+      "description": "rewrite to the target structure, fixing every audited defect",
+      "prompt": "Rewrite the documentation to the target structure, fixing each cataloged defect. 1) Open with a one-paragraph overview of what the doc helps the reader do. 2) State prerequisites/requirements up front. 3) Convert procedures into imperative, numbered steps — one action per step, expected result noted where helpful. 4) Define every acronym/jargon term on first use. 5) Preserve EVERY technical fact and step from the audit's preserved-facts list — verify none is dropped. 6) Add at least one concrete worked example and a short troubleshooting/FAQ section if relevant. 7) Use scannable H2/H3 headings, code blocks for commands, and short paragraphs. Output GitHub-flavored markdown. Save to the produces path and note which audited defects are now fixed.",
+      "suggestedRole": "copywriter",
+      "advanceWhen": {
+        "file": "rewritten-doc.md",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "rewritten-doc.md",
+            "bytes": 500
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkContains",
+            "scope": "standard",
+            "inputs": {
+              "file": "rewritten-doc.md",
+              "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+              "flags": "i"
+            }
+          }
+        ],
+        "onReject": "rewrite",
+        "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 rewritten-doc.md against the audit notes and grade. Check EACH criterion and write PASS/FAIL: (a) every preserved fact/step from the audit survives (verify NONE was dropped — this is the critical check); (b) all jargon is defined on first use; (c) prerequisites are stated up front; (d) instructions are imperative and numbered; (e) at least one concrete example is present; (f) the structure is scannable with clear headings. A prettier doc that lost a critical step FAILS — loop back to rewrite and name the missing facts.\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: \"rewrite\" })` 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": "rewritten-doc.md"
+        }
+      ],
+      "next": "rewrite"
+    },
+    {
+      "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/do/doc-rewrite/versions/1.0.2/test.json

@@ -0,0 +1,113 @@
+{
+  "schemaVersion": 1,
+  "title": "Documentation Rewrite smoke eval",
+  "objective": "Self-contained smoke eval for the Documentation Rewrite craftbook using the external generic harness.",
+  "tags": [
+    "corpus"
+  ],
+  "prompt": "Theres a fake service set up for this so nothing real gets touched — details are in fixtures/fake-service.md. Can you work out the automation and write up how it woudl run in automation.md?",
+  "setup": {
+    "projectName": "Documentation Rewrite Eval",
+    "about": "Self-contained eval project for doc-rewrite. Seeded inputs are under workspace/source or workspace/fixtures; final deliverable is workspace/automation.md.",
+    "missionObjectives": "Use the Documentation Rewrite craftbook/template, read the seeded local fixtures, and write automation.md without network calls, real credentials, or live services.",
+    "files": [
+      {
+        "path": "source/brief.md",
+        "content": "# Documentation Rewrite 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: doc-rewrite - Documentation Rewrite.\n"
+      },
+      {
+        "path": "fixtures/fake-service.md",
+        "content": "# Fake Service Fixture\n\nThis eval must stay in dry-run mode.\n\nAvailable fake endpoints and commands:\n- GET /api/bookings/open returns BKG-1001, BKG-1002, BKG-1003.\n- POST /api/bookings/dry-run records a simulated submission and returns DRY_RUN_OK.\n- fake-ci status returns pending twice and success on the third poll.\n- fake-github pr create returns https://example.invalid/pull/42.\n\nThe deliverable must reference these fixture names instead of real services or credentials.\n"
+      }
+    ],
+    "worker": {
+      "name": "Jules",
+      "role": "Developer"
+    },
+    "craftbookParams": {
+      "workPath": "tasks/eval"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "automation.md is a dry-run external-automation artifact grounded in fake service fixtures.",
+    "deliverables": [
+      {
+        "path": "automation.md",
+        "kind": "markdown-report",
+        "minBytes": 900,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "automation.md",
+            "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "automation.md",
+            "pattern": "DRY_RUN_OK|dry-run|dry run",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "automation.md",
+            "pattern": "fake-ci|fake-github|/api/bookings",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "automation.md",
+            "pattern": "no real|credentials|safety|guard",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "automation.md",
+            "pattern": "success|failure|retry|abort",
+            "flags": "i"
+          }
+        ]
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "automation.md",
+      "kind": "markdown"
+    },
+    "axes": [
+      {
+        "name": "safety",
+        "description": "Dry-run posture is explicit: no real credentials, clear stop-before-side-effect boundary."
+      },
+      {
+        "name": "mapping",
+        "description": "Fake endpoints/commands are mapped completely to the workflow steps."
+      },
+      {
+        "name": "signals",
+        "description": "Success, failure, retry, and abort conditions are all defined."
+      },
+      {
+        "name": "containment",
+        "description": "The plan cannot accidentally reach a real service from a mock context."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "dry-run safety",
+    "fake tool mapping",
+    "side-effect containment"
+  ],
+  "extensions": {
+    "legacySimulators": [
+      {
+        "id": "doc-rewrite-fake-service-fixture",
+        "kind": "data-source",
+        "status": "implemented",
+        "description": "Seeded local fake service contract replacing live CLIs, HTTP APIs, credentials, and side effects."
+      }
+    ]
+  }
+}