@bendyline/gilde 0.1.26 → 0.1.28

package/data/craftbook-templates/ba/backup-routine/versions/1.0.1/craftbook.json

@@ -0,0 +1,148 @@
+{
+  "id": "backup-routine",
+  "name": "Scheduled Backup or Export",
+  "description": "Build a scheduled, idempotent backup/export routine that snapshots data (files, a database, or an app export) to a timestamped, optionally compressed destination, prunes old backups by a retention policy, and verifies each backup is restorable. Locks what to back up, the destination layout, the retention policy, and the integrity check FIRST, then builds the snapshot-write-verify-prune routine, then verifies a fresh backup is created, integrity-checked, and that retention deletes only what it should. Defining retention and an integrity check up front is the wisdom that turns backups from a false sense of safety into a tested recovery path.\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 backup (planner) — sources, destination layout, retention, integrity check → gated on artifact `notes/scope.md` (markdown-notes)\n2. Build the routine (developer) — snapshot, write, integrity-check, prune, log → gated on `backup.sh` (code-module)\n3. Verify the routine (reviewer) — fresh backup, integrity, safe retention, idempotency → gated on artifact `notes/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": [
+    "set up a backup",
+    "scheduled export",
+    "automate backups",
+    "backup my database",
+    "nightly backup routine"
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the backup",
+      "description": "sources, destination layout, retention, integrity check",
+      "prompt": "Define the backup contract before building. Step 1: list exactly what to back up (which directories / which database / which export endpoint) and what to exclude. Step 2: define the destination and naming layout (e.g. backups/{name}-{YYYYMMDD-HHMMSS}.tar.gz) and whether to compress and/or checksum. Step 3: define the retention policy precisely (e.g. keep last N, or keep dailies 7d + weeklies 4w) and confirm it can never delete the only/most-recent backup. Step 4: define the integrity check that proves a backup is restorable (verify the archive lists/extracts, the checksum matches, or a row-count/sentinel survives a test restore). Step 5: write an acceptance-criteria checklist ('a fresh timestamped backup is produced each run', 'backup passes the integrity check', 'retention prunes only out-of-policy backups and never the newest', 'run is idempotent and logs each backup', 'a failed source aborts with a non-zero status, no silent empty backup'). Call write_task_note with sources + layout + retention + integrity + checklist and write notes/scope.md. No code yet.\n\nThe deliverable `notes/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": "notes/scope.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "notes/scope.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "notes/scope.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "scope",
+        "maxAttempts": 3
+      },
+      "next": "build"
+    },
+    {
+      "id": "build",
+      "name": "Build the routine",
+      "description": "snapshot, write, integrity-check, prune, log",
+      "prompt": "Implement the backup routine to the locked contract. Step 1: snapshot the sources into a timestamped artifact at the destination (compress/checksum as scoped); fail loudly with a non-zero exit if a source is missing or empty rather than writing a hollow archive. Step 2: run the integrity check immediately after writing (list/extract the archive, verify the checksum) and mark the backup verified only if it passes. Step 3: apply the retention policy — compute which backups are out-of-policy and delete only those, with a hard guard that never removes the most-recent verified backup. Step 4: append a backup-log entry (timestamp, size, checksum, verified, pruned list). Step 5: write the routine as a cron-friendly runnable module. Call write_task_note with the module path, the destination layout, and how integrity + retention are enforced.",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "backup.sh",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "backup.sh",
+            "bytes": 200
+          },
+          {
+            "kind": "sniff",
+            "file": "backup.sh",
+            "sniff": "nonempty"
+          },
+          {
+            "kind": "esmImports",
+            "file": "backup.sh"
+          },
+          {
+            "kind": "sourceParses",
+            "file": "backup.sh"
+          }
+        ],
+        "onReject": "build",
+        "maxAttempts": 3
+      },
+      "next": "verify"
+    },
+    {
+      "id": "verify",
+      "name": "Verify the routine",
+      "description": "fresh backup, integrity, safe retention, idempotency",
+      "prompt": "Verify the routine against scope. Step 1: confirm a run produces a fresh timestamped backup at the destination. Step 2: confirm the integrity check actually runs and that a corrupted/empty backup would be caught (the verified flag is meaningful). Step 3: confirm retention deletes only out-of-policy backups and that the newest verified backup is protected even at the retention boundary. Step 4: confirm idempotency and failure handling — a re-run does not clobber prior backups, and a missing source causes a non-zero exit with no hollow archive written. Step 5: confirm each backup is logged. Write PASS/FAIL per criterion to notes/verify.md and task notes; on failure, name it and loop back to build.\n\nThe deliverable `notes/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": "notes/verify.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "backup.sh",
+            "bytes": 200
+          },
+          {
+            "kind": "sniff",
+            "file": "backup.sh",
+            "sniff": "nonempty"
+          },
+          {
+            "kind": "esmImports",
+            "file": "backup.sh"
+          },
+          {
+            "kind": "sourceParses",
+            "file": "backup.sh"
+          }
+        ],
+        "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 backup.sh in a scratch location (or trace it) and verify every criterion from notes/scope.md: a fresh timestamped backup is created, the integrity check runs and is meaningful, retention prunes only out-of-policy backups and never the newest verified one, a missing source aborts non-zero with no hollow archive, runs are idempotent, and each backup is logged. Write PASS/FAIL per criterion; on any failure, name it 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": "backup.sh"
+        }
+      ],
+      "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.1",
+  "releasedAt": "2026-08-14T00:00:00Z"
+}

package/data/craftbook-templates/ba/backup-routine/versions/1.0.1/test.json

@@ -0,0 +1,108 @@
+{
+  "schemaVersion": 1,
+  "title": "Cron-friendly backup script from retention brief",
+  "objective": "Measure whether the backup-routine craftbook scopes retention and integrity before producing a cautious backup script.",
+  "tags": [
+    "data"
+  ],
+  "prompt": "In the `Backup Routine Eval` project, read `source/backup-brief.md` and write `backup.sh`: a cron-friendly shell script that snapshots the source directory, writes a timestamped compressed archive, computes a checksum, verifies integrity, prunes old backups safely, logs each run, and exits non-zero on missing or empty sources.",
+  "setup": {
+    "projectName": "Backup Routine Eval",
+    "about": "Self-contained eval project for backup-routine. The operational brief is in workspace/source/backup-brief.md and the deliverable is workspace/backup.sh.",
+    "missionObjectives": "Write a cautious backup script with retention, integrity checking, newest-backup protection, logging, and explicit failure handling.",
+    "files": [
+      {
+        "path": "source/backup-brief.md",
+        "content": "# Backup routine brief\n\nSource directory: ./var/app-data. Exclude cache/ and tmp/. Destination: ./backups. Archive name: app-data-YYYYMMDD-HHMMSS.tar.gz. Retention: keep the last 7 verified backups and never delete the newest verified backup. Integrity: write a SHA-256 checksum file and verify the archive can be listed before marking it verified. Log file: backup.log with timestamp, archive path, size, checksum, verified flag, and pruned files. Failure handling: missing or empty source must abort non-zero and must not write a hollow archive.\n"
+      }
+    ],
+    "worker": {
+      "name": "Daan",
+      "role": "Developer"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "workspace/backup.sh is a runnable-looking shell routine with timestamped archive, checksum verification, retention pruning, logging, and guarded failure behavior.",
+    "deliverables": [
+      {
+        "path": "backup.sh",
+        "kind": "generic-file",
+        "minBytes": 1600,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "backup.sh",
+            "pattern": "set -euo pipefail|set -eu",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "backup.sh",
+            "pattern": "tar|gzip|\\.tar\\.gz",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "backup.sh",
+            "pattern": "sha256sum|shasum",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "backup.sh",
+            "pattern": "retention|keep|prune|delete",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "backup.sh",
+            "pattern": "newest|latest|verified",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "backup.sh",
+            "pattern": "backup.log|log",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "backup.sh",
+            "pattern": "exit 1|return 1|non-zero|missing|empty",
+            "flags": "i"
+          }
+        ]
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "backup.sh",
+      "kind": "text"
+    },
+    "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": [
+    "integrity check",
+    "safe retention",
+    "non-zero failure handling"
+  ]
+}

package/data/craftbook-templates/bl/blog-post/versions/1.0.1/craftbook.json

@@ -0,0 +1,143 @@
+{
+  "id": "blog-post",
+  "name": "SEO Blog Post",
+  "description": "Write a complete, SEO-aware blog post that ranks and reads well: it locks the primary keyword, search intent, target reader, and a heading-by-heading outline FIRST, then drafts the full article in a single human voice with the keyword woven naturally into the title, intro, and H2s, and finally runs an editorial pass for clarity, flow, factual accuracy, and on-page SEO. Covers blog article, SEO content, how-to guide, listicle, thought-leadership post, content marketing, and organic-traffic writing. The scope-first ordering is the point: a small model that picks the keyword and outline before drafting avoids the classic failure of a rambling post that buries its topic and never satisfies the searcher's intent.\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. Keyword & outline scope (planner) — lock the primary keyword, intent, reader, and H2 outline → gated on artifact `notes/keyword-scope.md` (markdown-notes)\n2. Draft the article (copywriter) — write the full post to the locked outline and keyword plan → gated on `blog-post.md` (markdown-doc)\n3. Editorial pass (reviewer) — tighten clarity, flow, accuracy, and on-page SEO → gated on `blog-post.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": "keyword-scope",
+  "triggers": [
+    "write a blog post",
+    "seo article",
+    "write a how-to guide",
+    "create blog content",
+    "ranking article"
+  ],
+  "steps": [
+    {
+      "id": "keyword-scope",
+      "name": "Keyword & outline scope",
+      "description": "lock the primary keyword, intent, reader, and H2 outline",
+      "prompt": "1) Identify the PRIMARY keyword/phrase the post targets and the matching search intent (informational, comparison, how-to, or commercial). 2) Define the target reader in one sentence (who they are, what they already know, what they want to leave with). 3) List 3-5 secondary keywords/related terms to weave in naturally. 4) Write the working title (must contain the primary keyword, ideally near the front) plus a 1-sentence meta description under 155 characters. 5) Produce a heading-by-heading outline: H1 (title), a hook intro, 4-7 H2 sections each with a one-line summary of what it covers, and a closing/CTA section. 6) Set the target word count (e.g. 1200-1600) and reading level. Write an acceptance-criteria checklist (e.g. 'primary keyword appears in title, first 100 words, and at least 2 H2s'; 'every outlined H2 is covered'; 'single consistent voice, no AI filler phrases like \"in today's fast-paced world\"'; 'ends with a clear CTA'; 'within target word count +/-15%'). Use write_task_note to record the keyword strategy, outline, and checklist, and write the same content to the produces path. No prose drafting yet.\n\nThe deliverable `notes/keyword-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": "notes/keyword-scope.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "notes/keyword-scope.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "notes/keyword-scope.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "keyword-scope",
+        "maxAttempts": 3
+      },
+      "next": "draft"
+    },
+    {
+      "id": "draft",
+      "name": "Draft the article",
+      "description": "write the full post to the locked outline and keyword plan",
+      "prompt": "Write the complete article to the locked outline. 1) Open with a hook intro (2-3 sentences) that names the reader's problem and previews the payoff; place the primary keyword in the first 100 words. 2) Write every outlined H2 section in full prose with concrete examples, short paragraphs (2-4 sentences), and lists where they aid scanning. 3) Weave secondary keywords in naturally — never keyword-stuff. 4) Use one consistent, specific voice; cut filler and hedging. 5) Close with the CTA section from the outline. 6) Output GitHub-flavored markdown with the H1 title at top, proper H2/H3 headers, and the meta description as an HTML comment or front-matter line at the top. Write the full post to the produces path and use write_task_note to record word count and which checklist items you believe pass.",
+      "suggestedRole": "copywriter",
+      "advanceWhen": {
+        "file": "blog-post.md",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "blog-post.md",
+            "bytes": 500
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkContains",
+            "scope": "standard",
+            "inputs": {
+              "file": "blog-post.md",
+              "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+              "flags": "i"
+            }
+          }
+        ],
+        "onReject": "draft",
+        "maxAttempts": 3
+      },
+      "next": "edit"
+    },
+    {
+      "id": "edit",
+      "name": "Editorial pass",
+      "description": "tighten clarity, flow, accuracy, and on-page SEO",
+      "prompt": "Edit the draft in place against the checklist. 1) Read top to bottom for flow: does each section follow logically, are transitions smooth, is the voice consistent? 2) Cut every filler phrase, redundancy, and hedge; tighten long sentences. 3) Verify on-page SEO: primary keyword in title, first 100 words, and >=2 H2s; meta description present and under 155 chars; headings are descriptive. 4) Fact-check any concrete claim and flag/remove anything you cannot stand behind. 5) Confirm word count is within target and the CTA is clear. Rewrite weak passages directly rather than just commenting. Save the polished version back to the produces path and note any criteria still unmet.",
+      "suggestedRole": "reviewer",
+      "advanceWhen": {
+        "file": "blog-post.md",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "blog-post.md",
+            "bytes": 500
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkContains",
+            "scope": "standard",
+            "inputs": {
+              "file": "blog-post.md",
+              "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+              "flags": "i"
+            }
+          }
+        ],
+        "onReject": "edit",
+        "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 the final blog-post.md end to end and grade against the locked checklist. Check EACH criterion and write PASS/FAIL with a one-line reason: (a) primary keyword in title, first 100 words, and >=2 H2s; (b) every outlined H2 is present and substantive; (c) single consistent voice with no AI-filler phrases; (d) meta description present and under 155 characters; (e) clear CTA at the end; (f) word count within target +/-15%; (g) no unsupported factual claims. A post that is fluent but ignores the keyword plan or drops outlined sections FAILS.\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: \"draft\" })` 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": "blog-post.md"
+        }
+      ],
+      "next": "draft"
+    },
+    {
+      "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.1",
+  "releasedAt": "2026-08-14T00:00:00Z"
+}

package/data/craftbook-templates/bl/blog-post/versions/1.0.1/test.json

@@ -0,0 +1,118 @@
+{
+  "schemaVersion": 1,
+  "title": "SEO-aware how-to blog post",
+  "objective": "Measure whether the blog-post craftbook scopes keyword intent and outline before producing a complete, SEO-aware article grounded in seeded product notes.",
+  "tags": [
+    "corpus"
+  ],
+  "prompt": "In the `Blog Post Eval` project, read `source/brief.md` and write `blog-post.md`: a how-to article targeting the primary keyword \"sustainable packaging checklist\" for operations managers at small ecommerce brands. It needs a meta description, H1 title, at least five H2 sections, practical checklist content, the seeded Harbor & Finch facts, and a clear CTA. Do not invent statistics beyond the source notes.",
+  "setup": {
+    "projectName": "Blog Post Eval",
+    "about": "Self-contained eval project for the blog-post craftbook. Source notes are in workspace/source/brief.md and the deliverable is workspace/blog-post.md.",
+    "missionObjectives": "Produce a scoped, SEO-aware markdown article with meta description, H1/H2 structure, source-grounded examples, checklist advice, and CTA.",
+    "files": [
+      {
+        "path": "source/brief.md",
+        "content": "# Sustainable Packaging Brief\n\nAudience: operations managers at ecommerce brands shipping 1,000-15,000 parcels per month.\nPrimary keyword: sustainable packaging checklist.\nReader intent: practical how-to before choosing packaging vendors.\nSeed facts:\n- Harbor & Finch cut filler material by 32% after right-sizing mailers.\n- Their damage rate stayed under 1.8% during a 60-day pilot.\n- Warehouse staff need a packing-station card, not a long policy PDF.\n- Finance wants packaging cost tracked per shipped order.\n- The CTA should invite teams to run a two-week packaging audit.\n"
+      }
+    ],
+    "worker": {
+      "name": "Nora",
+      "role": "Writer"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "workspace/blog-post.md is a complete markdown article with SEO metadata, H1/H2 structure, seeded facts, checklist guidance, and CTA.",
+    "deliverables": [
+      {
+        "path": "blog-post.md",
+        "kind": "markdown-doc",
+        "minBytes": 2200,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "blog-post.md",
+            "pattern": "meta description",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "blog-post.md",
+            "pattern": "^#\\s+",
+            "flags": "im"
+          },
+          {
+            "kind": "contains",
+            "file": "blog-post.md",
+            "pattern": "sustainable packaging checklist",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "blog-post.md",
+            "pattern": "##\\s+",
+            "flags": "m"
+          },
+          {
+            "kind": "contains",
+            "file": "blog-post.md",
+            "pattern": "32%|1\\.8%|60-day",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "blog-post.md",
+            "pattern": "packing-station card|cost tracked per shipped order",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "blog-post.md",
+            "pattern": "two-week packaging audit|CTA|call",
+            "flags": "i"
+          }
+        ]
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "blog-post.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": [
+    "keyword scope",
+    "outline-first writing",
+    "source-grounded article"
+  ],
+  "extensions": {
+    "legacySimulators": [
+      {
+        "id": "blog-post-fake-service-fixture",
+        "kind": "data-source",
+        "status": "implemented",
+        "description": "Seeded local fake service contract replacing live CLIs, HTTP APIs, credentials, and side effects."
+      }
+    ]
+  }
+}