@bendyline/gilde 0.1.39 → 0.1.40

package/data/craftbook-templates/co/comprehensive-codebase-review/versions/1.0.0/test.json

@@ -0,0 +1,160 @@
+{
+  "schemaVersion": 1,
+  "title": "Comprehensive Codebase Review multi-dimension eval",
+  "objective": "Measure whether the review verifies planted architecture, duplication, hygiene, and lightweight-security problems in real source, states its index coverage honestly, and delivers a consultant report with a grounded scorecard, systemic themes, and a machine-readable findings file.",
+  "tags": [
+    "corpus"
+  ],
+  "prompt": "Use the Comprehensive Codebase Review craftbook to do a deep, consultant-level review of this codebase and its architecture. Write the report to tasks/eval/codebase-review.md. Do not change source.",
+  "setup": {
+    "projectName": "Comprehensive Review Eval",
+    "about": "A small web service with deliberate problems in several dimensions: duplicated parsing logic, a hardcoded token, debug prints, dead code, and a leaky module boundary.",
+    "missionObjectives": "Verify problems in source across architecture, duplication, hygiene, and security; grade each dimension; separate quick wins from strategic work.",
+    "files": [
+      {
+        "path": "src/routes/orders.ts",
+        "content": "import { db } from '../storage/db';\nexport async function postOrder(req, res) {\n  // TODO: validate\n  // TODO: auth\n  // TODO: rate limit\n  const items = String(req.body.items || '');\n  const parsed = items.split(',').map(s => { const [sku, qty] = s.split(':'); return { sku: sku.trim(), qty: Number(qty || 1) }; });\n  console.log('DEBUG order', parsed);\n  const rows = await db.query(\"INSERT INTO orders (items) VALUES ('\" + items + \"')\");\n  res.json({ ok: true, rows });\n}\n"
+      },
+      {
+        "path": "src/routes/quotes.ts",
+        "content": "export async function postQuote(req, res) {\n  const items = String(req.body.items || '');\n  const parsed = items.split(',').map(s => { const [sku, qty] = s.split(':'); return { sku: sku.trim(), qty: Number(qty || 1) }; });\n  res.json({ quote: parsed.length * 10 });\n}\n"
+      },
+      {
+        "path": "src/storage/db.ts",
+        "content": "import { postOrder } from '../routes/orders';\nexport const API_TOKEN = 'sk-live-9f2a71c04d8e';\nexport const db = { query: async (sql) => { return [{ sql }]; } };\nexport function legacyMigrate() { /* unused since v2 */ return null; }\n"
+      },
+      {
+        "path": "test/quotes.test.ts",
+        "content": "test('quotes', async () => {\n  expect(1 + 1).toBe(2);\n});\n"
+      },
+      {
+        "path": "README.md",
+        "content": "# Order service\nA tiny order and quote service.\n"
+      }
+    ],
+    "worker": {
+      "name": "Rae",
+      "role": "Reviewer"
+    },
+    "craftbookParams": {
+      "workPath": "tasks/eval"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "tasks/eval/codebase-review.md verifies the planted problems with real file citations, grades at least five dimensions, clusters findings into root-cause themes, and ships a machine-readable findings JSON beside it.",
+    "deliverables": [
+      {
+        "path": "tasks/eval/codebase-review.md",
+        "kind": "markdown-report",
+        "artifact": true,
+        "minBytes": 2500,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "tasks/eval/codebase-review.md",
+            "pattern": "##\\s+Executive summary[\\s\\S]*##\\s+Scorecard[\\s\\S]*##\\s+Systemic themes[\\s\\S]*##\\s+Findings[\\s\\S]*##\\s+Quick wins",
+            "flags": "i",
+            "label": "consultant report sections",
+            "artifact": true
+          },
+          {
+            "kind": "tableShape",
+            "file": "tasks/eval/codebase-review.md",
+            "requiredColumns": [
+              "Dimension",
+              "Grade"
+            ],
+            "artifact": true
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/codebase-review.md",
+            "pattern": "src/routes/(orders|quotes)\\.ts",
+            "flags": "i",
+            "label": "duplication evidence cites a real route file",
+            "artifact": true
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/codebase-review.md",
+            "pattern": "API_TOKEN|hard-?coded (secret|token|credential)",
+            "flags": "i",
+            "label": "the planted hardcoded token is found",
+            "artifact": true
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/codebase-review.md",
+            "pattern": "console\\.log|debug (print|logging|output)",
+            "flags": "i",
+            "label": "the planted debug print is found",
+            "artifact": true
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/codebase-review.md",
+            "pattern": "root[\\s-]?cause",
+            "flags": "i",
+            "label": "themes analyze root cause",
+            "artifact": true
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/codebase-review.md",
+            "pattern": "Index coverage",
+            "flags": "i",
+            "label": "index coverage is stated",
+            "artifact": true
+          }
+        ]
+      },
+      {
+        "path": "tasks/eval/codebase-review-findings.json",
+        "kind": "json",
+        "artifact": true,
+        "minBytes": 100,
+        "checks": [
+          {
+            "kind": "sniff",
+            "file": "tasks/eval/codebase-review-findings.json",
+            "sniff": "json-valid",
+            "artifact": true
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/codebase-review-findings.json",
+            "pattern": "\"severity\"[\\s\\S]*\"remediation\"",
+            "label": "structured findings with severity and remediation",
+            "artifact": true
+          }
+        ]
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "tasks/eval/codebase-review.md",
+      "kind": "markdown"
+    },
+    "axes": [
+      {
+        "name": "verification",
+        "description": "Findings cite real files and lines; the duplicated parser, SQL string-building, hardcoded token, debug print, dead export, and storage-imports-routes boundary leak are found rather than invented."
+      },
+      {
+        "name": "synthesis",
+        "description": "Findings cluster into root-cause themes with blast radius; the scorecard grades follow the evidence."
+      },
+      {
+        "name": "actionability",
+        "description": "Quick wins are safe and bounded; strategic recommendations name seams, sequence, and behavior-preserving tests; deeper specialist reviews are suggested where warranted."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "verified findings across dimensions",
+    "honest coverage statement",
+    "consultant-grade prioritization"
+  ]
+}

package/data/craftbook-templates/co/config-scaffold/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "config-scaffold",
   "role": "project-starter",
+  "category": "code-build",
   "name": "Project Config Scaffold",
   "description": "Bootstrap a project's configuration — the tooling, linter, formatter, tsconfig/compiler, scripts, and ignore files — into a coherent, conflict-free baseline that actually works together. Scopes the config surface FIRST — every tool, its config file, the settings, and how they must agree (formatter vs linter, strict compiler) — then writes the config files and scripts, then verifies the toolchain runs clean with no conflicts. Covers linter/formatter config, compiler/tsconfig, package scripts, editorconfig, gitignore, and ensuring tools do not fight each other.",
   "tags": [

package/data/craftbook-templates/co/content-accuracy-review/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "content-accuracy-review",
   "role": "maintenance-review",
+  "category": "research",
   "name": "Content Accuracy Review",
   "description": "Fact-check a piece of content for accuracy and produce a claim-by-claim verification report. First scopes the content and extracts every checkable claim (statistics, dates, quotes, attributions, causal and factual statements) and locks a verification standard, then verifies each claim against authoritative sources rating it true/false/misleading/unverifiable with the supporting evidence, then writes a report flagging every inaccuracy with the correction and source plus an overall trust rating. Use this for a fact-check, accuracy review, content verification, checking claims and statistics, source-checking an article, or vetting content before publishing — it returns a claim-level verdict backed by cited sources rather than a vague 'seems accurate'.",
   "tags": [

package/data/craftbook-templates/co/content-deck/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "content-deck",
   "role": "general",
+  "category": "design",
   "name": "Slide Deck from Content",
   "description": "Turn a body of source content into a presentation deck. Outlines the narrative first, designs a consistent slide look, then builds the deck (HTML slides), evaluating for narrative flow and visual consistency.",
   "tags": [

package/data/craftbook-templates/co/contract-template/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "contract-template",
   "role": "general",
+  "category": "business",
   "name": "Contract Template (Non-Legal-Advice)",
   "description": "Draft a reusable, plain-language agreement template — service agreement, NDA, freelance contract, or terms — with clearly marked fill-in fields, structured numbered clauses, and a prominent non-legal-advice disclaimer. Scopes the parties, obligations, and risk allocation FIRST, drafts clear enforceable-style clauses with placeholders for the variable terms, then has a reviewer check completeness and flag anything that genuinely needs a lawyer. NOT legal advice — every output must say so. Use for templated agreements you will adapt and have counsel review.",
   "tags": [

package/data/craftbook-templates/co/cookbook-layout/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "cookbook-layout",
   "role": "general",
+  "category": "personal",
   "name": "Lay Out the Cookbook",
   "description": "Assemble the heirloom: every tested recipe in its chapter, the provenance kept beside the food — whose recipe it was, what table it came from — chapter intros in the family's voice, print-ready pages. The book that exists because someone finally sat down and made it. Locks the inclusion rule FIRST — tested recipes in, untested listed for the next round, never silently dropped — then lays out the chapters, then proofs every eligible recipe made it in with its story intact. Use for laying out the family cookbook, the heirloom recipe book, 'print the cookbook', and a recipe book for the grandchildren.",
   "tags": [

package/data/craftbook-templates/co/copy-review/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "copy-review",
   "role": "maintenance-review",
+  "category": "writing",
   "name": "Editorial & Tone Review",
   "description": "Run an editorial review on a piece of content for clarity, correctness, and brand voice, then produce a line-edit report and a clean revised version. First scopes the audience, purpose, and voice/style rules and locks an editorial checklist (grammar and spelling, clarity and concision, consistent terminology, active voice, reading level, tone match, scannability, and CTA strength), then reviews the copy line-by-line against those rules marking every issue with a suggested rewrite, then writes a report of categorized edits plus a clean revised draft. Use this for a copy review, editorial pass, proofreading, line edit, tone/voice review, or tightening writing — it returns specific tracked edits with rewrites and a polished final draft rather than 'tighten this up'.",
   "tags": [

package/data/craftbook-templates/co/corpus-email-digest/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "corpus-email-digest",
   "role": "general",
+  "category": "business",
   "name": "Daily Email Digest from a Corpus",
   "description": "Produce an email-ready digest that summarizes a corpus of content (docs, feeds, notes) for a recurring send. Scopes what matters and the format first, drafts the digest in a consistent voice, then builds the email-ready output and evaluates for accuracy and scannability.",
   "tags": [

package/data/craftbook-templates/co/corpus-synthesis/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "corpus-synthesis",
   "role": "general",
+  "category": "research",
   "name": "Corpus Synthesis",
   "description": "Read a provided corpus of documents and synthesize it into a single coherent overview: a planner sets the synthesis question and the extraction schema, a researcher reads every document and extracts structured notes keyed back to each source, and a copywriter synthesizes the extracts into a unified narrative organized by idea rather than by document. The ordering matters because synthesizing before reading everything privileges the first few documents, and a write-up keyed to documents instead of ideas just summarizes each file; locking a synthesis question and per-document extraction first guarantees full coverage and a real cross-document synthesis. Use this for synthesizing a folder of docs/notes/papers, 'pull together everything we know about X', cross-document summaries, knowledge consolidation, and meeting/research-note synthesis.",
   "tags": [

package/data/craftbook-templates/co/cover-letter/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "cover-letter",
   "role": "general",
+  "category": "business",
   "name": "Tailored Cover Letter",
   "description": "Write a tailored, one-page cover letter that maps a candidate's real background to a specific job's requirements: it first scopes the role's key requirements, the company hook, and the 3-4 strongest matching proof points from the applicant's experience, then drafts a focused letter with a specific opening, evidence-backed body paragraphs, and a confident close. Covers cover letter, job application letter, motivation letter, application writing, and personalized cover letter. Scoping the role-to-experience mapping before writing is the point: a small model that picks the strongest evidence for THIS job avoids the generic, one-size-fits-all letter that could be sent anywhere and lists duties instead of proving fit.",
   "tags": [

package/data/craftbook-templates/cr/crm-update-batch/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "crm-update-batch",
   "role": "general",
+  "category": "business",
   "name": "Bulk CRM Update from Notes",
   "description": "Turn unstructured notes (call logs, meeting recaps, email threads) into a batch of structured CRM updates: per-contact field changes, activity logs, and next-step tasks as a validated import file. Scopes the CRM field schema and extraction rules FIRST (which objects/fields, allowed picklist values, the match-or-create key, required fields), then a developer extracts and maps every note into rows against that schema, then a reviewer validates the batch for schema-conformance and that no update mutates a field without evidence in the source. Scoping the schema before extraction is what makes the import load cleanly and prevents fabricated field values. Use for CRM data entry, bulk contact updates, importing notes into Salesforce/HubSpot, activity logging, and turning call notes into pipeline updates.",
   "tags": [

package/data/craftbook-templates/cr/cron-job/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "cron-job",
   "role": "project-starter",
+  "category": "code-ops",
   "name": "Scheduled Batch Job",
   "description": "Build a scheduled batch job that runs on a cadence, processes a unit of work, is safe to re-run, and reports its outcome. Scopes the job FIRST — trigger cadence, the work it does, batch/chunk size, idempotency, failure/partial-failure handling, and observable output — then implements the runnable job, then tests a clean run, an empty run, a partial-failure run, and re-run safety. Covers cron scheduling semantics, batch processing, idempotent reruns, chunking, structured logging, exit codes, and graceful partial-failure handling.",
   "tags": [

package/data/craftbook-templates/cr/crossword-forge/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "crossword-forge",
   "role": "general",
+  "category": "design",
   "name": "Forge a Crossword",
   "description": "Construct a personalized crossword and prove it works before anyone's pencil touches it: the grid actually interlocks, every entry sits in the grid exactly where its number says, every clue is tuned to the solver — and the whole thing ships as a printable page with the solution kept decently out of sight. Locks the theme and the word list FIRST, then constructs the mechanically-verified grid, then renders the printable puzzle. Use for making a crossword, a personalized puzzle for the family, 'a crossword with the grandkids' names in it', and printable puzzle gifts.",
   "tags": [

package/data/craftbook-templates/cs/csv-transformer/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "csv-transformer",
   "role": "general",
+  "category": "code-data",
   "name": "CSV / Tabular Transformer",
   "description": "Reshape and convert tabular data from one schema to another: rename and reorder columns, split or merge fields, derive new columns, pivot/unpivot, change format (CSV<->JSON<->TSV), and filter rows. Locks the input and target schema and the field-by-field mapping FIRST (so the transform is a contract, not guesswork), then builds the transform and emits the output, then verifies row counts and a sample mapping. Use this for reshaping a CSV, converting data formats, remapping columns, flattening JSON to a table, or reformatting an export for another tool.",
   "tags": [

package/data/craftbook-templates/da/dashboard-spec/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "dashboard-spec",
   "role": "general",
+  "category": "code-docs",
   "name": "Dashboard Specification",
   "description": "Specify a dashboard from the questions it must answer, before anyone builds it — the artifact that prevents a chart-salad dashboard nobody uses. Scopes the audience, the decisions, and the questions FIRST, then designs the dashboard layout: which widgets/charts answer which question, their metric definitions, filters, refresh, and visual hierarchy. The output is a build-ready spec, not the dashboard itself. Use this for planning a dashboard, a BI/reporting spec, a metrics dashboard design, deciding what charts a dashboard needs, or a dashboard requirements doc.",
   "tags": [

package/data/craftbook-templates/da/data-dictionary/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "data-dictionary",
   "role": "general",
+  "category": "code-data",
   "name": "Data Dictionary",
   "description": "Document a dataset's schema as a clear, complete data dictionary so others can use it without guessing. Inspects the data FIRST to derive each column's real type, value domain, null rate, units, and relationships from the actual values (not assumptions), then writes a readable dictionary with one entry per column plus dataset-level context. Use this for documenting a schema, building a data dictionary, a column glossary, a table reference, or onboarding docs for a dataset.",
   "tags": [

package/data/craftbook-templates/da/data-export-migrate/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "data-export-migrate",
   "role": "general",
+  "category": "code-data",
   "name": "Migrate Data Between Tools",
   "description": "Migrate records from a source tool/format to a destination tool/format — CRM to CRM, spreadsheet to app, JSON export to a new API — with a field mapping, value transforms, and a reconciliation that proves nothing was lost or corrupted. Locks the source→destination field map, the transform/normalization rules, and the reconciliation criteria FIRST, then builds the extract-transform-load with a dry-run preview, then verifies record counts match, key fields round-trip, and a diff report flags any mismatch. Mapping-and-reconciliation-before-load is the discipline that makes a migration trustworthy rather than a one-shot leap of faith.",
   "tags": [

package/data/craftbook-templates/da/data-join-merge/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "data-join-merge",
   "role": "general",
+  "category": "code-data",
   "name": "Join / Merge Two Datasets",
   "description": "Combine two datasets into one reconciled table on a shared key, correctly handling the join type, key mismatches, and duplicate fan-out. Profiles both sources and locks the join key, join type, and conflict rules FIRST (so the merge doesn't silently drop or duplicate rows), then builds the joined output, then verifies the match rate and that no row count exploded. Use this for joining two tables, merging datasets, a VLOOKUP-style match, enriching one file from another, or reconciling records across two sources.",
   "tags": [

package/data/craftbook-templates/da/data-pipeline-etl/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "data-pipeline-etl",
   "role": "project-starter",
+  "category": "code-data",
   "name": "ETL / Ingest Pipeline",
   "description": "Build an extract-transform-load pipeline that ingests source data, reshapes it to a target schema, and loads it with validation at every stage. Locks the schemas FIRST — source shape, target shape, the field-by-field transform/mapping, type coercions, and the data-quality rules — then implements extract→transform→load with row-level error capture, then a reviewer validates output conformance, row counts, and reject handling. Covers ETL stages, schema mapping, type coercion, data validation, idempotent loads, dead-letter/reject rows, and reconciliation counts.",
   "tags": [

package/data/craftbook-templates/da/data-quality-audit/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "data-quality-audit",
   "role": "maintenance-review",
+  "category": "code-data",
   "name": "Data Quality Audit",
   "description": "Audit a dataset against explicit data-quality rules and produce a scorecard of where it passes and fails across completeness, validity, consistency, uniqueness, and timeliness. Defines the quality rules and dimensions FIRST (so 'quality' is measurable, not a vibe), then runs the audit to measure each rule with pass rates and failing examples, then writes a prioritized report with an overall score and remediation steps. Use this for a data quality audit, data health check, validation report, data-quality scorecard, or assessing whether a dataset is trustworthy.",
   "tags": [

package/data/craftbook-templates/da/data-to-report/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "data-to-report",
   "role": "general",
+  "category": "research",
   "name": "Dataset to Narrative Report",
   "description": "Turn a dataset into a written, evidence-backed analytical report that a non-technical reader can act on. Analyzes the data FIRST to surface the real findings (key metrics, segments, trends, surprises) with supporting numbers, then writes a narrative that leads with the takeaway and traces every claim to a figure, then builds the polished report document with sections, a summary table, and an explicit limitations note. Use this for turning raw numbers into an insights report, executive summary, data storytelling, or a findings write-up stakeholders will read.",
   "tags": [

package/data/craftbook-templates/da/data-viz-page/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "data-viz-page",
   "role": "project-starter",
+  "category": "code-build",
   "name": "Data Visualization Explorer",
   "description": "Build a single interactive chart or data explorer page — bar, line, scatter, or pie — driven by sample or provided data, with controls to filter, switch series, or change the dimension and a tooltip on hover. Scopes the dataset and the question the chart answers first, then the chart type and encodings, then implements a canvas or SVG chart with real interactivity. A chart that does not map data to pixels correctly is worse than a table, so the data and chart-design phases lock the encoding and the axes before any rendering code.",
   "tags": [

package/data/craftbook-templates/da/dataset-clean/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "dataset-clean",
   "role": "general",
+  "category": "code-data",
   "name": "Clean a Dataset",
   "description": "Profile, clean, and validate a messy CSV/TSV/JSON dataset into an analysis-ready table. Profiles the raw data FIRST (row/column counts, types, null rates, duplicates, outliers, encoding) so cleaning decisions are evidence-based, then applies deterministic transforms (dedup, type coercion, null handling, whitespace/case normalization, value standardization), then validates the cleaned output against the same profile so nothing was silently dropped or corrupted. Use this for data wrangling, tidying, deduplication, normalizing dirty spreadsheets, and prepping raw exports for charts or modeling.",
   "tags": [

package/data/craftbook-templates/db/db-index-tuning/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "db-index-tuning",
   "role": "maintenance-review",
+  "category": "code-data",
   "name": "Diagnose + Add Database Indexes",
   "description": "Diagnose slow database queries and add the right indexes — driven by the query plan, not by hunches — then prove the speedup without harming writes. Analyzes FIRST with EXPLAIN/query plans to find the actual full scans and missing indexes, then adds the targeted indexes (right columns, right order, covering where it helps), then a reviewer confirms the plans now use the index and queries are faster. Covers EXPLAIN/query plans, full-table-scan detection, composite index column order, covering indexes, selectivity, and the write-amplification tradeoff.",
   "tags": [

package/data/craftbook-templates/de/deep-security-review/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "deep-security-review",
   "role": "maintenance-review",
+  "category": "code-review",
   "name": "Deep Security Review",
   "description": "Run a slow, thorough, WHOLE-CODEBASE security audit that looks for SYSTEMIC weaknesses — a vulnerability class repeated across many routes, a missing control at an architectural layer, inconsistent authorization, ad-hoc secret handling, a trust-boundary violation — not just isolated issues in one file. First reconnoiters the whole system using gezel's static security index (dependency inventory, attack surface, source/sink findings, taint reachability), then builds a threat model to find the highest-blast-radius areas, then audits those areas holistically confirming real source-to-sink paths and consistency of controls across every entry point, then clusters findings into root-cause systemic themes, then writes a prioritized report with a machine-readable findings file. Use this for a deep or systemic security review, a codebase security audit, a nightly security sweep, or finding security issues across a whole project — it is intentionally broader and deeper than a PR-time diff review (see pr-security-review for that).",
   "tags": [

package/data/craftbook-templates/de/dependency-audit/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "dependency-audit",
   "role": "maintenance-review",
+  "category": "code-review",
   "name": "Dependency Audit",
   "description": "Audit a project's dependencies for security, staleness, license, and maintenance risk, then produce a prioritized remediation report. First scans the manifest and lockfile to inventory every dependency with its installed vs latest version, known CVEs, license, and maintenance signals, then assesses each into a risk tier weighing severity, exploitability, breaking-change cost, and removability, then writes a report with a concrete upgrade/replace/remove action and order for each risky dependency. Use this for a dependency audit, supply-chain review, checking for vulnerable or outdated packages, license compliance, npm/pip audit triage, or reducing dependency risk — it turns a raw audit dump into a prioritized, justified action plan rather than a wall of warnings.",
   "tags": [

package/data/craftbook-templates/de/deploy-checklist/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "deploy-checklist",
   "role": "general",
+  "category": "code-release",
   "name": "Deploy Checklist",
   "description": "Author and then actually execute a pre-deploy verification checklist for shipping a release to production — the concrete gates that must be green before the deploy button is pressed: tests passing, build clean, migrations reviewed, config/secrets present, feature flags set, rollback path confirmed, and observability/alerts ready. A planner scopes the checklist tailored to this service and risk level, a developer runs each item and records real evidence (command output, links, screenshots) for pass or fail, and a reviewer signs off go/no-go. Use this before a production deploy, a release cut-over, or any 'are we ready to ship?' gate where skipping a step causes outages.",
   "tags": [

package/data/craftbook-templates/de/design-review/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "design-review",
   "role": "maintenance-review",
+  "category": "design",
   "name": "UX & Visual Design Review",
   "description": "Critique a UI's user experience and visual design and produce a prioritized design-review report. First scopes the screens and flows and locks a heuristic checklist (visual hierarchy, spacing rhythm and alignment, typographic scale, color and contrast, consistency, affordance and feedback, empty/loading/error states, and the primary task's friction), then reviews each screen against those heuristics with a designer's eye for both polish and usability, then writes a findings report rating each issue by impact with a concrete, specific design fix. Use this for a design review, UX critique, visual QA, design feedback, a heuristic evaluation, or 'does this look and feel right' — it gives actionable, specific design fixes (exact spacing, color, hierarchy changes) rather than 'make it pop'.",
   "tags": [

package/data/craftbook-templates/de/design-system-consultation/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "design-system-consultation",
   "role": "maintenance-review",
+  "category": "design",
   "name": "Design System Consultation",
   "description": "Interview for product context and taste, then propose a full design system — type, color, layout, motion — and capture it as a DESIGN.md with live preview pages.",
   "tags": [

package/data/craftbook-templates/di/diagram-from-text/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "diagram-from-text",
   "role": "general",
+  "category": "code-docs",
   "name": "Diagram from Text",
   "description": "Render a clear technical diagram — flowchart, architecture, sequence, ER, or org chart — from a plain-language description, as code-defined (Mermaid/Graphviz/SVG) so it is editable and version-controllable rather than a flat picture. Spec FIRST the diagram type, the exact nodes and edges, and the layout direction, because diagrams fail when relationships are wrong or the graph is an unreadable tangle; then build the diagram so it renders, with every described entity and relationship present and labeled. Covers flowcharts, architecture diagrams, sequence diagrams, ER diagrams, org charts, mind maps, and diagram-as-code.",
   "tags": [

package/data/craftbook-templates/di/digest-from-feeds/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "digest-from-feeds",
   "role": "general",
+  "category": "research",
   "name": "RSS / Feed Digest",
   "description": "Build a recurring digest from RSS/Atom feeds or news sources: fetch the latest items in the window, dedupe and cluster by topic, then write a scannable digest with one-line takes and source links. Scopes the feed list and digest format FIRST (which feeds, the time window, topic sections, item cap, ranking signal), then a developer fetches and normalizes the feed items into a deduped item list, then a copywriter writes the curated digest from those items only. Scoping sources and the window before fetching is what keeps the digest fresh, deduped, and within length instead of an unranked firehose. Use for RSS digests, news roundups, feed summaries, content curation, and recurring reading digests.",
   "tags": [

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

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "doc-intake-pipeline",
   "role": "general",
+  "category": "business",
   "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.",
   "tags": [

package/data/craftbook-templates/do/doc-rewrite/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "doc-rewrite",
   "role": "general",
+  "category": "code-docs",
   "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.",
   "tags": [

package/data/craftbook-templates/do/dockerize-app/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "dockerize-app",
   "role": "maintenance-review",
+  "category": "code-release",
   "name": "Containerize a Service",
   "description": "Containerize an application with a production-grade Dockerfile — small, secure, reproducible, and buildable — plus the supporting files to run it. Scopes the container contract FIRST — base image, build vs runtime stages, dependencies, exposed port, entrypoint, env config, and the size/security bar — then writes the Dockerfile + .dockerignore + compose, then a reviewer confirms it builds, runs, and meets the bar. Covers multi-stage builds, slim base images, layer caching, non-root user, .dockerignore, healthchecks, EXPOSE/ENTRYPOINT, and reproducible image builds.",
   "tags": [

package/data/craftbook-templates/do/docs-site/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "docs-site",
   "role": "project-starter",
+  "category": "code-docs",
   "name": "Documentation Site",
   "description": "Build a single-page documentation site with a sidebar table of contents, anchored sections, code blocks, and in-page navigation — the kind of reference page a library or API ships. Locks the information architecture (the section tree and ordering) first, then a readable docs visual design with good typography and code styling, then builds the HTML with working anchor links and a sticky sidebar. Getting the IA right before layout is what makes docs findable; a small model that jumps straight to HTML produces an unnavigable wall of text.",
   "tags": [

package/data/craftbook-templates/do/documentation-drift-review/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "documentation-drift-review",
   "role": "maintenance-review",
+  "category": "code-docs",
   "name": "Documentation Drift Review",
   "description": "Review project documentation against the code, configuration, commands, API surface, and shipped behavior to find stale or misleading guidance. Uses the indexed docs and source map to verify examples and references instead of proofreading in isolation, then leaves a prioritized morning report with exact doc locations, source-of-truth evidence, corrected text, owners, and a prevention plan. Use for a weekly docs-health sweep, documentation accuracy review, stale README audit, or finding runbook and API-documentation drift.",
   "tags": [

package/data/craftbook-templates/dr/draft-social-post/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "draft-social-post",
   "role": "general",
+  "category": "marketing",
   "name": "Draft a Social Post",
   "description": "Draft one social post from idea to approved copy. Reads your voice guide and recent posts, grounds the angle in what your feeds actually responded to, drafts the base message, then fits a variant to each platform's limits — Bluesky 300 graphemes, X 280 characters, Instagram captions with the hook in the first 125 characters, LinkedIn up to 3000 characters in a professional register — with hashtags where idiomatic, alt text for media, and thread splits when the copy runs long. Then it stops for your review: approve, ask for a revision round, or approve and queue to Bluesky through the outbox. Covers social media copywriting, tweet and thread drafting, Bluesky posts, Instagram captions, post scheduling, and a human approval gate. Nothing is ever published without your say-so.",
   "tags": [

package/data/craftbook-templates/dr/drive-wrap-up/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "drive-wrap-up",
   "role": "general",
+  "category": "personal",
   "name": "Fundraiser Wrap-Up",
   "description": "Close a fundraising drive properly: verify the final numbers against the donation ledger, confirm every donor was thanked (or finish the thank-yous now), and write the wrap-up story — the total, what the money does, and the people who made it happen — ready to share with the community and hand to the next organizer. Locks the wrap-up's claims and the thank-you completeness check FIRST, then verifies against the ledger, then writes the story. Use for ending a fundraiser, drive wrap-up reports, final fundraising totals, and community thank-you posts.",
   "tags": [

package/data/craftbook-templates/du/due-diligence-brief/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "due-diligence-brief",
   "role": "general",
+  "category": "research",
   "name": "Due-Diligence Brief",
   "description": "Produce a structured due-diligence brief on an entity (company, vendor, investment, partner): a planner locks the diligence dimensions and red-flag criteria, a researcher gathers verifiable facts and risk signals per dimension with sources, and a copywriter writes a decision-oriented brief with findings, risks, and an overall read. The ordering matters because diligence without locked dimensions misses a category (e.g. legal, financial, reputational) and a brief without a red-flag rubric buries the risks; fixing the dimensions and what counts as a flag first makes the brief decision-ready and defensible. Use this for vendor/partner due diligence, investment diligence, background briefs on a company or person, risk assessments, and 'should we work with / invest in X' questions.",
   "tags": [

package/data/craftbook-templates/eb/ebook-compile/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "ebook-compile",
   "role": "general",
+  "category": "writing",
   "name": "Ebook Compile",
   "description": "Compile a collection of notes, articles, or chapter drafts into a coherent, readable ebook — with a title page, table of contents, consistently formatted chapters, and front/back matter — output as a single navigable HTML book. Outlines the chapter structure and through-line FIRST (so disparate notes become a real book, not a pile), writes/edits each chapter to a consistent voice and adds connective tissue, then builds the compiled HTML with a linked TOC and chapter navigation. Use for turning a blog backlog, course notes, or drafts into a downloadable ebook.",
   "tags": [

package/data/craftbook-templates/ed/edit-notes/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "edit-notes",
   "role": "maintenance-review",
+  "category": "media",
   "name": "Edit Notes Pass",
   "description": "Review the footage like an editor: timestamped notes on pacing and cuts read against the transcript and the media index, then a machine-readable cut list the assembly step can execute — opinion upstream, precision downstream. Locks the review criteria FIRST (every keep or cut carries a timecode and a reason, b-roll gaps get named), then writes the edit notes, then distills them into the cut list — so the creative call and the executable record never drift apart. Use for edit passes, footage reviews, 'what should we cut', cutlist prep, and tightening a video that drags.",
   "tags": [

package/data/craftbook-templates/em/email-sequence/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "email-sequence",
   "role": "general",
+  "category": "marketing",
   "name": "Lifecycle Email Sequence",
   "description": "Design and build a multi-email lifecycle sequence (welcome, onboarding, nurture, re-engagement) that moves a subscriber from one stage to the next: it first maps the customer journey — entry trigger, the goal of each email, send timing/cadence, and the one CTA per email — then drafts every email's subject line, preview text, and body to its single goal, then builds the sequence into a client-safe, inline-styled HTML email set ready to load into an ESP. Covers email sequence, drip campaign, welcome series, onboarding emails, nurture sequence, and lifecycle marketing. Journey-mapping before writing is the point: a small model that assigns each email one job and one CTA avoids the redundant sequence where every email says the same thing and asks for everything at once.",
   "tags": [

package/data/craftbook-templates/em/email-template/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "email-template",
   "role": "project-starter",
+  "category": "marketing",
   "name": "Responsive HTML Email",
   "description": "Build a responsive HTML email template that renders across email clients — Outlook, Gmail, Apple Mail — using table-based layout, inline styles, and bulletproof buttons, for a newsletter, transactional, or promo send. Designs the visual structure and the client-safe constraints first, writes the copy, then builds the table-based HTML with all CSS inlined. Email is not the web: external CSS, flexbox, and modern selectors break, so the design phase locks the table layout and inline-only rule before any markup, the ordering that keeps a small model from producing a div-and-class email that renders broken in Outlook.",
   "tags": [

package/data/craftbook-templates/en/engineering-retrospective/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "engineering-retrospective",
   "role": "maintenance-review",
+  "category": "business",
   "name": "Engineering Retrospective",
   "description": "Build a data-grounded engineering retrospective from git history: activity, hotspots, review patterns, and per-person growth notes for a given window.",
   "tags": [

package/data/craftbook-templates/ep/episode-plan/manifest.json

@@ -3,6 +3,7 @@
   "kind": "craftbook-template",
   "id": "episode-plan",
   "role": "general",
+  "category": "media",
   "name": "Plan the Episode",
   "description": "Turn the idea backlog and last episode's loose threads into a locked plan for the next episode: a rundown with timed segments, what to prep, and a record date — so the show ships on rhythm instead of on adrenaline. Locks the episode goal and the acceptance checklist FIRST, then builds the timed rundown, then writes the brief with prep owners and the record date. Use for planning the next episode, episode rundowns, show planning, and 'what's the next episode'.",
   "tags": [