@bendyline/gilde 0.1.37 → 0.1.39

package/data/craftbook-templates/su/subscription-audit/versions/1.0.2/craftbook.json

@@ -0,0 +1,152 @@
+{
+  "id": "subscription-audit",
+  "name": "Audit Recurring Subscriptions",
+  "description": "Audit a set of transactions or a vendor list to find every recurring subscription, normalize each to a monthly cost, surface duplicates, price hikes, and zombie/unused services, and produce a prioritized cancel/keep recommendation report. Locks the recurrence-detection rule, the normalization (to monthly), and the recommendation criteria FIRST, then detects and analyzes the recurring charges, then writes a clear report whose every recommendation is backed by the evidence in the data. Defining what counts as 'recurring' and how to rank cancel candidates before analyzing is what makes the audit actionable rather than a list of guesses.\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 audit (data-analyst) — recurrence rule, monthly normalization, recommendation criteria → gated on artifact `{{workPath}}/scope.md` (markdown-notes)\n2. Detect and analyze (data-analyst) — find recurring charges, normalize, flag, rank → gated on artifact `{{workPath}}/analyze.md` (markdown-notes)\n3. Write the report (copywriter) — evidence-backed cancel/keep recommendation report → gated on artifact `{{workPath}}/report.md` (markdown-report)\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "scope",
+  "triggers": [
+    "audit my subscriptions",
+    "find recurring charges",
+    "cancel unused subscriptions",
+    "subscription spend report",
+    "where is my money going"
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the audit",
+      "description": "recurrence rule, monthly normalization, recommendation criteria",
+      "prompt": "Define the audit method before analyzing. Step 1: identify the input (a transactions file, or a list of services with amount + cadence) and its columns. Step 2: define the recurrence-detection rule — what makes a charge a subscription (same/near merchant recurring at a regular interval: monthly/quarterly/annual, within an amount tolerance). Step 3: define normalization to a comparable monthly cost (annual ÷ 12, quarterly ÷ 3) so everything is apples-to-apples, and the total monthly and annual run-rate. Step 4: define the flags and recommendation criteria — duplicate/overlapping services, a price increase vs the prior occurrence, and 'zombie' candidates (high cost and/or low apparent usage) — and how to rank cancel candidates (e.g. by annual cost × redundancy). Step 5: write an acceptance-criteria checklist ('every recurring charge detected and listed', 'each normalized to monthly correctly', 'duplicates and price hikes flagged with evidence', 'a ranked cancel/keep recommendation per subscription', 'monthly and annual totals reported', 'no recommendation without supporting data'). Call write_task_note with the rule + normalization + criteria + checklist and write {{workPath}}/scope.md. No analysis 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": "data-analyst",
+      "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": "analyze"
+    },
+    {
+      "id": "analyze",
+      "name": "Detect and analyze",
+      "description": "find recurring charges, normalize, flag, rank",
+      "prompt": "Analyze the input to the locked rule. Step 1: group transactions by normalized merchant and detect recurring series matching the cadence + amount-tolerance rule. Step 2: for each detected subscription, record name, cadence, last amount, normalized monthly cost, and first/last seen. Step 3: compute flags from the evidence — duplicates/overlaps (two services in the same category), price increases (this amount > prior occurrence), and zombie candidates per the criteria. Step 4: rank cancel candidates by the agreed scoring and compute the total monthly and annual run-rate plus the potential savings if the cancel candidates are dropped. Step 5: write the structured findings (the per-subscription table + totals + flags) to a notes file so the report phase has clean inputs. Call write_task_note with the subscription count, the monthly/annual totals, and the top cancel candidates.\n\nThe deliverable `{{workPath}}/analyze.md` lands in the project's artifacts drawer — write it with `write_artifact` and read it back with `read_artifact`; the shipped workspace stays untouched.",
+      "suggestedRole": "data-analyst",
+      "advanceWhen": {
+        "file": "{{workPath}}/analyze.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/analyze.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/analyze.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "analyze",
+        "maxAttempts": 3
+      },
+      "next": "report"
+    },
+    {
+      "id": "report",
+      "name": "Write the report",
+      "description": "evidence-backed cancel/keep recommendation report",
+      "prompt": "Write the subscription audit report from the analysis. Step 1: open with a headline summary — total monthly spend, annual run-rate, and the potential savings. Step 2: include a clear table of every detected subscription: name, cadence, monthly-normalized cost, annual cost, and any flags (duplicate, price hike, zombie). Step 3: give a prioritized recommendations section — cancel/keep/review per subscription, ordered by impact, each with a one-line rationale tied to the evidence (cost, redundancy, price change). Step 4: ensure every recommendation traces to a fact in the analysis — no unsupported claims. Step 5: close with the total savings if the recommended cancels are actioned. Write the report as a markdown report with section headers. Call write_task_note with the report path and the headline savings figure.\n\nThe deliverable `{{workPath}}/report.md` lands in the project's artifacts drawer — write it with `write_artifact` and read it back with `read_artifact`; the shipped workspace stays untouched.",
+      "suggestedRole": "copywriter",
+      "advanceWhen": {
+        "file": "{{workPath}}/report.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/report.md",
+            "bytes": 1500,
+            "artifact": true
+          },
+          {
+            "kind": "contains",
+            "file": "{{workPath}}/report.md",
+            "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+            "flags": "i",
+            "label": "at least one markdown heading",
+            "artifact": true
+          }
+        ],
+        "onReject": "report",
+        "maxAttempts": 4
+      },
+      "next": "evaluate"
+    },
+    {
+      "id": "evaluate",
+      "name": "Evaluate",
+      "description": "Grade the deliverable against every acceptance criterion. All pass → finish; any fail → loop back and fix the gap.",
+      "prompt": "Open {{workPath}}/report.md (and {{workPath}}/analyze.md) and verify every criterion from {{workPath}}/scope.md: every recurring charge is detected and listed, each is normalized to a monthly cost correctly (re-check 2 conversions), duplicates and price hikes are flagged with evidence, every cancel/keep recommendation is ranked by impact and backed by a fact in the data, and monthly + annual totals plus potential savings are reported. Confirm no recommendation lacks supporting evidence. Write PASS/FAIL per criterion; on any failure, name the gap and loop back to report.\n\nThe deliverable lives in the project's artifacts drawer — open `{{workPath}}/report.md` with `read_artifact`, not `read_file`.\n\nThen route — this is the whole point of the loop:\n\n- **Every criterion PASSES →** call `advance_task_step({ ref, stepId: \"evaluate\", next: \"finish\" })`.\n- **Any criterion FAILS →** write the specific gaps to notes, then call `advance_task_step({ ref, stepId: \"evaluate\", next: \"report\" })` to loop back. The builder fixes exactly those gaps.\n\nNever route to `finish` while any criterion is unmet. The build phase's completion gate already blocked a grossly-incomplete deliverable; your job is the judgment an automated check cannot make (does it actually work, read well, look right). After ~3 unproductive loops, stop and report DONE_WITH_CONCERNS so the user can step in.",
+      "suggestedRole": "reviewer",
+      "consumes": [
+        {
+          "file": "{{workPath}}/report.md",
+          "artifact": true
+        }
+      ],
+      "next": "report"
+    },
+    {
+      "id": "finish",
+      "name": "Finish",
+      "description": "All acceptance criteria met. Stamp a short summary and report DONE.",
+      "prompt": "Every acceptance criterion passed. Write a one-paragraph DONE summary to task notes via `write_task_note`: what was built, the deliverable path(s), and a one-line confirmation that each criterion is met. Then report DONE.",
+      "suggestedRole": "developer",
+      "terminal": true
+    }
+  ],
+  "version": "1.0.2",
+  "releasedAt": "2026-08-21T00:00:00Z",
+  "paramSchema": {
+    "type": "object",
+    "properties": {
+      "workPath": {
+        "type": "string",
+        "title": "Working folder",
+        "description": "Per-task working folder in the artifacts drawer. Defaults to this task's own folder so runs never collide; override with a stable name when you deliberately want runs to share files.",
+        "default": "{{task.dir}}"
+      }
+    }
+  },
+  "minGezelVersion": "1.26233"
+}

package/data/craftbook-templates/su/subscription-audit/versions/1.0.2/test.json

@@ -0,0 +1,107 @@
+{
+  "schemaVersion": 1,
+  "title": "Audit Recurring Subscriptions smoke eval",
+  "objective": "Self-contained smoke eval for the Audit Recurring Subscriptions 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": "Audit Recurring Subscriptions Eval",
+    "about": "Self-contained eval project for subscription-audit. Seeded inputs are under workspace/source or workspace/fixtures; final deliverable is workspace/analysis.md.",
+    "missionObjectives": "Use the Audit Recurring Subscriptions 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": "# Audit Recurring Subscriptions 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: subscription-audit - Audit Recurring Subscriptions.\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/su/subtitle-generator/versions/1.0.2/craftbook.json

@@ -0,0 +1,140 @@
+{
+  "id": "subtitle-generator",
+  "name": "Subtitle & Caption Generator",
+  "description": "Generate time-synced subtitles/captions for a video in a standard caption format (SRT or WebVTT), so the video is accessible and watchable without sound. Scopes the caption format and timing/reading-speed rules FIRST, transcribes the audio with precise word timings, then formats those into properly cued, line-length-limited caption cues. The transcribe-then-format split is deliberate: getting accurate text and timings is a different skill from chunking them into readable, on-screen-friendly cues that respect reading speed and never overlap.\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 captions (planner) — format (SRT/VTT), timing rules, line limits, language → gated on artifact `{{workPath}}/scope.md` (markdown-notes)\n2. Transcribe with timings (developer) — STT the audio into word/segment timestamps → gated on artifact `{{workPath}}/timed-segments.json` (json)\n3. Format the caption file (developer) — chunk timed text into valid SRT/VTT cues → gated on `captions.srt` (generic-file)\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "scope",
+  "triggers": [
+    "generate subtitles",
+    "make captions for a video",
+    "create an srt file",
+    "add closed captions",
+    "subtitle this video"
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the captions",
+      "description": "format (SRT/VTT), timing rules, line limits, language",
+      "prompt": "Lock the caption rules BEFORE generating. Step 1: record the source video (path, duration) and the language. Step 2: pick the format — SRT (`HH:MM:SS,mmm`) or WebVTT (`HH:MM:SS.mmm` with a `WEBVTT` header). Step 3: set readability rules: max ~42 chars per line, max 2 lines per cue, min ~1s and max ~7s per cue, reading speed under ~17 chars/second, and a small gap between cues so none overlap. Step 4: decide how to handle non-speech (e.g. `[music]`, `[applause]`) and speaker IDs if multiple speakers. Write an acceptance-criteria checklist (valid SRT/VTT that a player can load, sequential cue numbering, monotonic non-overlapping timecodes, lines within the char limit, last cue ends near video duration) and decisions to `{{workPath}}/scope.md` via write_task_note AND to the produces path.\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": "transcribe"
+    },
+    {
+      "id": "transcribe",
+      "name": "Transcribe with timings",
+      "description": "STT the audio into word/segment timestamps",
+      "prompt": "Produce timed text the formatter can chunk. Step 1: extract/take the audio track and run speech-to-text over the WHOLE recording to get segments with start/end timestamps (word-level if the engine supports it — it makes cue splitting far cleaner). Step 2: keep timestamps monotonic across any chunk boundaries. Step 3: mark non-speech events per the scope rules. Step 4: write the raw timed segments to `{{workPath}}/timed-segments.json` (each: text, start, end) via write_task_note and the produces path so the format phase has structured input, not prose. Do not chunk into final cues yet — that is the next phase. On a loop-back from format, fix timing/coverage gaps here only if the issue is bad source timings.\n\nThe deliverable `{{workPath}}/timed-segments.json` lands in the project's artifacts drawer — write it with `write_artifact` and read it back with `read_artifact`; the shipped workspace stays untouched.",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "{{workPath}}/timed-segments.json",
+        "minBytes": 1,
+        "sniff": "json-valid",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/timed-segments.json",
+            "bytes": 2,
+            "artifact": true
+          }
+        ],
+        "onReject": "transcribe",
+        "maxAttempts": 3
+      },
+      "next": "format"
+    },
+    {
+      "id": "format",
+      "name": "Format the caption file",
+      "description": "chunk timed text into valid SRT/VTT cues",
+      "prompt": "Turn timed segments into a valid caption file. Step 1: emit the format header (none for SRT; `WEBVTT` for VTT). Step 2: walk the timed segments and pack words into cues that respect the scope's char/line/duration/reading-speed limits — split a long segment into multiple cues at natural pauses, splitting timecodes proportionally. Step 3: number cues sequentially (SRT) and write each cue's `start --> end` timecode in the EXACT format, then 1-2 text lines. Step 4: ensure no two cues overlap and the last cue ends at/just before the video duration. Step 5: write `captions.srt` (or `.vtt`) and validate it parses (try loading it, or re-parse the structure). write_task_note the caption path and cue count. On a loop-back, fix only the flagged cues (overlap, over-long lines, bad timecode format).",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "captions.srt",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "captions.srt",
+            "bytes": 200
+          },
+          {
+            "kind": "sniff",
+            "file": "captions.srt",
+            "sniff": "nonempty"
+          }
+        ],
+        "onReject": "format",
+        "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": "Validate the caption file like a player would. Step 1: parse it — valid header (VTT), sequential numbering (SRT), and every timecode in the exact `HH:MM:SS,mmm`/`.mmm` format (PASS/FAIL). Step 2: confirm timecodes are monotonic and NO two cues overlap. Step 3: confirm cue durations and line lengths are within the scoped limits (sample several). Step 4: confirm the final cue ends within a small margin of the video duration (no dropped tail). Step 5: spot-check 3 cues against the audio if possible — text and timing align. Write PASS/FAIL per criterion.\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: \"format\" })` 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": "captions.srt"
+        }
+      ],
+      "next": "format"
+    },
+    {
+      "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/su/subtitle-generator/versions/1.0.2/test.json

@@ -0,0 +1,106 @@
+{
+  "schemaVersion": 1,
+  "title": "Subtitle & Caption Generator smoke eval",
+  "objective": "Self-contained smoke eval for the Subtitle & Caption Generator craftbook using the media generic harness.",
+  "tags": [
+    "media"
+  ],
+  "prompt": "Our media files are all listd in source/media-index.csv. Can you put together the production plan for them as media-plan.json?",
+  "setup": {
+    "projectName": "Subtitle & Caption Generator Eval",
+    "about": "Self-contained eval project for subtitle-generator. Seeded inputs are under workspace/source or workspace/fixtures; final deliverable is workspace/media-plan.json.",
+    "missionObjectives": "Use the Subtitle & Caption Generator craftbook/template, read the seeded local fixtures, and write media-plan.json without network calls, real credentials, or live services.",
+    "files": [
+      {
+        "path": "source/brief.md",
+        "content": "# Subtitle & Caption Generator 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: subtitle-generator - Subtitle & Caption Generator.\n"
+      },
+      {
+        "path": "source/media-index.csv",
+        "content": "filename,type,duration_or_size,notes\npilot-interview.wav,audio,00:02:15,mentions response time and status silence\nreturns-desk.png,image,1600x900,shows intake form and photo evidence step\nlaunch-clip.mp4,video,00:01:05,shows barcode exception handling\n"
+      }
+    ],
+    "worker": {
+      "name": "Jules",
+      "role": "Producer"
+    },
+    "craftbookParams": {
+      "workPath": "tasks/eval"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "media-plan.json is a valid JSON media-production manifest grounded in seeded fixture metadata.",
+    "deliverables": [
+      {
+        "path": "media-plan.json",
+        "kind": "json",
+        "minBytes": 700,
+        "checks": [
+          {
+            "kind": "sniff",
+            "file": "media-plan.json",
+            "sniff": "json-valid"
+          },
+          {
+            "kind": "contains",
+            "file": "media-plan.json",
+            "pattern": "pilot-interview\\.wav|returns-desk\\.png|launch-clip\\.mp4",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "media-plan.json",
+            "pattern": "outputs|assets|steps|cues|verification",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "media-plan.json",
+            "pattern": "accessibility|alt|caption|transcript|metadata",
+            "flags": "i"
+          }
+        ]
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "media-plan.json",
+      "kind": "json"
+    },
+    "axes": [
+      {
+        "name": "completeness",
+        "description": "The manifest covers sources, outputs, and processing steps end to end."
+      },
+      {
+        "name": "grounding",
+        "description": "Only seeded media fixtures are referenced, with faithful metadata."
+      },
+      {
+        "name": "accessibility",
+        "description": "Alt text, captions, or transcripts are planned wherever the class requires."
+      },
+      {
+        "name": "precision",
+        "description": "Timestamps, crops, and cues are specific enough to execute."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "media fixture handling",
+    "structured manifest",
+    "verification metadata"
+  ],
+  "extensions": {
+    "legacySimulators": [
+      {
+        "id": "subtitle-generator-media-fixtures",
+        "kind": "data-source",
+        "status": "implemented",
+        "description": "Seeded local media index replacing real audio, video, image generation, and external media metadata services."
+      }
+    ]
+  }
+}

package/data/craftbook-templates/su/summarize-long/versions/1.0.2/craftbook.json

@@ -0,0 +1,119 @@
+{
+  "id": "summarize-long",
+  "name": "Summarize a Long Document",
+  "description": "Distill a long document into a faithful, well-structured summary at a chosen depth: it first scopes the audience, the target length and format (TL;DR line, executive summary, or bulleted key points), and what the reader must take away, then writes the summary capturing every major point and decision in proportion, with nothing invented and nothing critical dropped. Covers summarize, TL;DR, executive summary, condense a document, key takeaways, and abstract writing. Scoping audience and depth before summarizing is the point: a small model that knows who it is for and how long it should be avoids both the bloated near-copy and the lossy summary that omits the document's actual conclusion.\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. Summary scope (planner) — lock audience, depth, format, and required takeaways → gated on artifact `{{workPath}}/scope.md` (markdown-notes)\n2. Write the summary (copywriter) — write the faithful summary to the locked depth and format → gated on `summary.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": "scope",
+  "triggers": [
+    "summarize this document",
+    "write a tldr",
+    "executive summary",
+    "condense this",
+    "key takeaways"
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Summary scope",
+      "description": "lock audience, depth, format, and required takeaways",
+      "prompt": "1) Identify the audience and why they need the summary (decision, briefing, study). 2) Choose the format and depth: a one-line TL;DR, a 3-5 sentence executive summary, a bulleted key-points list, or a layered combination — and set a target length (e.g. <=200 words). 3) Skim the document and list its major sections/arguments and, critically, its main conclusion or recommendation (this MUST appear in the summary). 4) Decide what is in-scope vs droppable detail. Write an acceptance-criteria checklist (e.g. 'captures the document's main conclusion'; 'covers every major point in proportion to its weight'; 'within target length'; 'no claim absent from the source'; 'matches the chosen format'; 'understandable without the original'). Use write_task_note for the scope + section map + checklist, and write the same to the produces path. No summary prose 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": "summarize"
+    },
+    {
+      "id": "summarize",
+      "name": "Write the summary",
+      "description": "write the faithful summary to the locked depth and format",
+      "prompt": "Write the summary to the scoped format and length. 1) Lead with the single most important point or conclusion. 2) Cover every major section/argument in proportion to its importance — do not over-weight the intro or skip the conclusion. 3) Write in your own words; do not copy long passages. 4) Include nothing not present in the source — no inference presented as the document's claim. 5) Make it stand alone: a reader who never sees the original should grasp the key content. 6) Output the chosen format in markdown (e.g. a 'TL;DR:' line then an 'Executive summary' paragraph then 'Key points' bullets, as scoped). Save to the produces path and note the final word count.",
+      "suggestedRole": "copywriter",
+      "advanceWhen": {
+        "file": "summary.md",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "summary.md",
+            "bytes": 500
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkContains",
+            "scope": "standard",
+            "inputs": {
+              "file": "summary.md",
+              "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+              "flags": "i"
+            }
+          }
+        ],
+        "onReject": "summarize",
+        "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 summary.md against the source and the scope. Check EACH criterion and write PASS/FAIL: (a) the document's main conclusion/recommendation is present; (b) every major point is covered in proportion (no critical section dropped); (c) within the target length; (d) no claim that is absent from or misrepresents the source; (e) matches the chosen format; (f) understandable on its own. A summary that drops the conclusion or invents claims FAILS — loop back to summarize and name the gaps.\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: \"summarize\" })` 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": "summary.md"
+        }
+      ],
+      "next": "summarize"
+    },
+    {
+      "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"
+}