@bendyline/gilde 0.1.37 → 0.1.39

package/data/craftbook-templates/ed/edit-notes/versions/1.0.2/craftbook.json

@@ -0,0 +1,188 @@
+{
+  "id": "edit-notes",
+  "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.\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 review (regisseur) — footage inventory, transcript read, review criteria locked → gated on artifact `{{workPath}}/scope.md` (markdown-notes)\n2. Write the edit notes (reviewer) — timestamped pacing and cut notes, clip by clip → gated on artifact `{{workPath}}/edit-notes.md` (markdown-notes)\n3. Build the cut list (developer) — the machine-readable record of every edit decision → gated on `cutlist.json` (json)\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "scope",
+  "triggers": [
+    "edit pass",
+    "review the footage",
+    "make a cutlist",
+    "what should we cut",
+    "tighten the video"
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the review",
+      "description": "footage inventory, transcript read, review criteria locked",
+      "prompt": "Define the edit pass before forming a single opinion. Step 1: read media/index.json from the workspace — every clip with its id and duration — and read the transcript under transcripts/ plus the storyboard or brief if one exists, so you know what the piece is trying to be. Step 2: lock the review criteria — every keep-or-cut call carries a timecode and a stated reason, pacing judgments name the specific stretch that drags or rushes, b-roll gaps are named where the footage cannot carry the point, and no note references footage that is not in the index. Step 3: define what the cut list must record for each decision — which clip, the in and out points, the action (keep, cut, trim, reorder), and a short note tying it back to the edit notes. Step 4: write an acceptance-criteria checklist ('every note carries a timecode', 'every cut decision has a reason', 'every cut-list row points at a real clip', 'in and out points sit inside that clip's duration', 'the draggy stretches are addressed, not just observed'). Call write_task_note with the clip count + criteria + checklist and write {{workPath}}/scope.md. No reviewing 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": "regisseur",
+      "advanceWhen": {
+        "file": "{{workPath}}/scope.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/scope.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/scope.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "scope",
+        "maxAttempts": 3
+      },
+      "next": "review"
+    },
+    {
+      "id": "review",
+      "name": "Write the edit notes",
+      "description": "timestamped pacing and cut notes, clip by clip",
+      "prompt": "Review the footage against the locked criteria. Step 1: walk the transcript and the media index clip by clip, in story order, and write timestamped notes — what works, what drags, where the energy dips, where a cut or trim would help. Every observation carries a timecode in mm:ss form and names its clip. Step 2: for each stretch that drags, say exactly what to do about it — trim from where to where, cut entirely, or reorder — and why the piece is better for it. Step 3: name the b-roll gaps: the moments where the words need cover the footage does not have, so the owner can plan pickups. Step 4: keep opinions honest and concrete — 'the intro runs long' is a note, 'trim 0:12-0:38, the point lands at 0:39' is an edit. Write the notes to {{workPath}}/edit-notes.md and call write_task_note with the count of cut decisions and the biggest pacing problem found.\n\nThe deliverable `{{workPath}}/edit-notes.md` lands in the project's artifacts drawer — write it with `write_artifact` and read it back with `read_artifact`; the shipped workspace stays untouched.",
+      "suggestedRole": "reviewer",
+      "advanceWhen": {
+        "file": "{{workPath}}/edit-notes.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/edit-notes.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/edit-notes.md",
+            "sniff": "nonempty",
+            "artifact": true
+          },
+          {
+            "kind": "contains",
+            "file": "{{workPath}}/edit-notes.md",
+            "pattern": "\\d{1,2}:\\d{2}",
+            "label": "the edit notes carry mm:ss timecodes",
+            "artifact": true
+          }
+        ],
+        "onReject": "review",
+        "maxAttempts": 3
+      },
+      "next": "cutlist"
+    },
+    {
+      "id": "cutlist",
+      "name": "Build the cut list",
+      "description": "the machine-readable record of every edit decision",
+      "prompt": "Distill the edit notes into the cut list the assembly step can execute. Step 1: for every decision in {{workPath}}/edit-notes.md, write one record to cutlist.json as a JSON array — each record with the clip id exactly as it appears in media/index.json, the in and out points, the action (keep, cut, trim, or reorder), and a short note carrying the reason over from the edit notes. Step 2: verify precision as you go — every clip id must exist in the media index, and every in and out point must sit within that clip's duration; a cut list that references invented footage or impossible timecodes is worse than no cut list. Step 3: order the records in final-piece order so the assembly reads top to bottom. Step 4: re-read the result once as JSON — valid, complete, no decision from the notes left behind. Call write_task_note with the record count and the total runtime the kept material adds up to.\n\nBefore working, open the artifact input `{{workPath}}/edit-notes.md` with `read_artifact`; do not look for it in the workspace.",
+      "suggestedRole": "developer",
+      "consumes": [
+        {
+          "file": "{{workPath}}/edit-notes.md",
+          "artifact": true
+        }
+      ],
+      "advanceWhen": {
+        "file": "cutlist.json",
+        "minBytes": 1,
+        "sniff": "json-valid"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "cutlist.json",
+            "bytes": 2
+          },
+          {
+            "kind": "recordSchema",
+            "file": "cutlist.json",
+            "fields": [
+              {
+                "name": "clip",
+                "type": "nonempty"
+              },
+              {
+                "name": "in"
+              },
+              {
+                "name": "out"
+              },
+              {
+                "name": "action",
+                "type": "nonempty"
+              },
+              {
+                "name": "note",
+                "required": false
+              }
+            ],
+            "minRows": 3
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkJsonValid",
+            "scope": "standard",
+            "inputs": {
+              "file": "cutlist.json"
+            }
+          }
+        ],
+        "onReject": "cutlist",
+        "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 cutlist.json, {{workPath}}/edit-notes.md, and media/index.json and verify every criterion from {{workPath}}/scope.md: every cut-list record names a clip id that exists in the media index, every in and out point sits inside that clip's duration, every record's action traces back to a timestamped note with a reason, the notes address the pacing problems rather than just observing them, and the b-roll gaps are named. Write PASS/FAIL per criterion; on any failure, name the offending record or note and loop back to cutlist.\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: \"cutlist\" })` 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": "cutlist.json"
+        }
+      ],
+      "next": "cutlist"
+    },
+    {
+      "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/ed/edit-notes/versions/1.0.2/test.json

@@ -0,0 +1,149 @@
+{
+  "schemaVersion": 1,
+  "title": "Edit Notes Pass smoke eval",
+  "objective": "Task-specific eval for the Edit Notes Pass craftbook: five indexed clips and a raw transcript with a draggy middle (an interview tangent and a repeated demo step) become timestamped edit notes and a machine-readable cutlist that references only real footage within real durations.",
+  "tags": [
+    "data"
+  ],
+  "prompt": "footage for the workshop video is indexed and the trancript is in — can you do an edit pass and give me a cutlist? somethings draggy in the middle",
+  "setup": {
+    "projectName": "Video Workshop — Edit Notes Eval",
+    "about": "Self-contained eval project for edit-notes. The clip index is media/index.json (five clips with durations in seconds), the raw transcript is transcripts/raw.txt (per-clip mm:ss timecodes), and the storyboard is storyboard.md. The edit notes go to tasks/eval/edit-notes.md and the cut list to cutlist.json.",
+    "missionObjectives": "Use the Edit Notes Pass craftbook/template, review the seeded transcript against the media index, and produce timestamped edit notes plus cutlist.json. Every cut decision carries a timecode and a reason; no invented footage. No live services or real media tools — this is the review-and-cutlist half.",
+    "files": [
+      {
+        "path": "media/index.json",
+        "content": "[\n  {\n    \"id\": \"c01-intro\",\n    \"file\": \"media/c01-intro.mp4\",\n    \"durationSeconds\": 48\n  },\n  {\n    \"id\": \"c02-interview\",\n    \"file\": \"media/c02-interview.mp4\",\n    \"durationSeconds\": 184\n  },\n  {\n    \"id\": \"c03-broll-shop\",\n    \"file\": \"media/c03-broll-shop.mp4\",\n    \"durationSeconds\": 62\n  },\n  {\n    \"id\": \"c04-demo\",\n    \"file\": \"media/c04-demo.mp4\",\n    \"durationSeconds\": 141\n  },\n  {\n    \"id\": \"c05-outro\",\n    \"file\": \"media/c05-outro.mp4\",\n    \"durationSeconds\": 39\n  }\n]\n"
+      },
+      {
+        "path": "transcripts/raw.txt",
+        "content": "Workshop video - raw transcript (rough auto pass, per-clip timecodes)\n\n[c01-intro]\n0:00 Welcome back to the workshop. Today we are building the dovetail jig I promised.\n0:19 Quick look at the finished jig so you know where we are headed.\n0:41 (dead air while the camera gets adjusted)\n\n[c02-interview]\n0:00 So the first thing people get wrong with dovetails is the layout, every time.\n0:35 The story of my first jig - it was awful, but it cut straight, and that is the point.\n1:20 ...and that reminds me of the time at the timber yard, there was this dog that guarded the offcuts bin... (long tangent, drifts well away from the jig)\n2:40 Anyway, back to the jig. The key measurement is the pin width at the baseline.\n2:58 If your pins are proud by even a millimeter, the joint telegraphs it.\n\n[c03-broll-shop]\n(no speech - bench shots, clamps closing, shavings falling, glue-up)\n\n[c04-demo]\n0:00 Set the fence to twelve degrees and lock it before anything else.\n0:48 Now we cut the tails first. Watch the offcut side, not the blade.\n1:22 Let me do that cut again from the other angle... (repeats the same step, adds nothing new)\n1:50 (silent repositioning)\n2:21 And the fit test - listen for that squeak. That squeak is the whole video.\n\n[c05-outro]\n0:00 If you build one, send me a photo. I read everything.\n0:24 Next week: the box joint jig, which is somehow more controversial.\n"
+      },
+      {
+        "path": "storyboard.md",
+        "content": "# Workshop video - storyboard\n\nShape: cold open on the finished jig, intro, expert interview for the why,\nshop b-roll to breathe, the demo as the spine, outro with the ask.\nTarget: a tight six minutes. The interview and demo are allowed to flex,\nbut nothing stays in that does not earn its seconds.\n"
+      }
+    ],
+    "worker": {
+      "name": "Teun",
+      "role": "Editor"
+    },
+    "craftbookParams": {
+      "workPath": "tasks/eval"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "cutlist.json is a machine-readable record of real edit decisions: every row names a clip from media/index.json with in/out points and an action, the notes carry mm:ss timecodes and address the draggy middle, and the b-roll picture is considered.",
+    "deliverables": [
+      {
+        "path": "cutlist.json",
+        "kind": "json",
+        "checks": [
+          {
+            "kind": "recordSchema",
+            "file": "cutlist.json",
+            "fields": [
+              {
+                "name": "clip",
+                "type": "nonempty"
+              },
+              {
+                "name": "in"
+              },
+              {
+                "name": "out"
+              },
+              {
+                "name": "action",
+                "type": "nonempty"
+              },
+              {
+                "name": "note",
+                "required": false
+              }
+            ],
+            "minRows": 3
+          },
+          {
+            "kind": "valuesSubsetOf",
+            "file": "cutlist.json",
+            "sourceFiles": [
+              "media/index.json"
+            ],
+            "pattern": "\"clip\"\\s*:\\s*\"([^\"]+)\"",
+            "label": "every cutlist row references a clip that exists in the media index"
+          }
+        ]
+      },
+      {
+        "path": "tasks/eval/edit-notes.md",
+        "kind": "markdown-notes",
+        "minBytes": 400,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "tasks/eval/edit-notes.md",
+            "pattern": "\\d{1,2}:\\d{2}",
+            "label": "the edit notes carry mm:ss timecodes"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/edit-notes.md",
+            "pattern": "tangent|timber|drags|drift",
+            "flags": "i",
+            "label": "the interview tangent in the middle is called out"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/edit-notes.md",
+            "pattern": "repeat|again|redundant|duplicate",
+            "flags": "i",
+            "label": "the repeated demo step is called out"
+          }
+        ]
+      }
+    ],
+    "checks": [
+      {
+        "kind": "judge",
+        "file": "cutlist.json",
+        "rubric": "Every in/out point in the cutlist sits within the referenced clip's duration from media/index.json, and the rows that trim or cut the middle correspond to the transcript's tangent (c02-interview around 1:20-2:40) and repeated demo step (c04-demo around 1:22-1:50) rather than arbitrary stretches.",
+        "sourceFiles": [
+          "media/index.json",
+          "transcripts/raw.txt"
+        ],
+        "label": "timecode precision and grounded cuts"
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "cutlist.json",
+      "kind": "json"
+    },
+    "axes": [
+      {
+        "name": "editorial-judgment",
+        "description": "Cuts and keeps serve the piece; the draggy middle is actually fixed, not just observed."
+      },
+      {
+        "name": "timecode-precision",
+        "description": "In/out points are concrete, inside clip durations, and consistent between notes and cutlist."
+      },
+      {
+        "name": "pacing-analysis",
+        "description": "The notes explain where energy dips and why, clip by clip."
+      },
+      {
+        "name": "actionability",
+        "description": "An assembly step could execute the cutlist top to bottom without asking questions."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "grounded cut decisions",
+    "timecode precision",
+    "no invented footage"
+  ]
+}

package/data/craftbook-templates/em/email-sequence/versions/1.0.2/craftbook.json

@@ -0,0 +1,154 @@
+{
+  "id": "email-sequence",
+  "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.\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. Journey scope (planner) — map the sequence: trigger, per-email goal, cadence, one CTA each → gated on artifact `{{workPath}}/journey-scope.md` (markdown-notes)\n2. Draft the emails (copywriter) — write each email to its single goal and CTA → gated on artifact `{{workPath}}/draft.md` (markdown-notes)\n3. Build the email set (developer) — render the sequence to client-safe inline-styled HTML → gated on `index.html` (html-page)\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "journey-scope",
+  "triggers": [
+    "build an email sequence",
+    "welcome email series",
+    "drip campaign",
+    "nurture sequence",
+    "onboarding emails"
+  ],
+  "steps": [
+    {
+      "id": "journey-scope",
+      "name": "Journey scope",
+      "description": "map the sequence: trigger, per-email goal, cadence, one CTA each",
+      "prompt": "1) Define the sequence type and entry trigger (e.g. signed up, abandoned cart, went inactive). 2) Define the end goal (activate, convert, re-engage). 3) Lay out the emails in order — for EACH email specify: its single goal, send timing/delay (e.g. Day 0, Day 2, Day 5), the one CTA, and the key message. Each email does ONE job. 4) Note the audience and tone. Write an acceptance-criteria checklist (e.g. 'each email has exactly one goal and one CTA'; 'no two emails are redundant'; 'cadence/timing specified per email'; 'subject lines are distinct and curiosity/benefit-driven'; 'the arc progresses toward the end goal'; 'unsubscribe link present in each'). Use write_task_note for the journey map + per-email plan + checklist, and write the same to the produces path. No email copy yet.\n\nThe deliverable `{{workPath}}/journey-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}}/journey-scope.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/journey-scope.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/journey-scope.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "journey-scope",
+        "maxAttempts": 3
+      },
+      "next": "draft"
+    },
+    {
+      "id": "draft",
+      "name": "Draft the emails",
+      "description": "write each email to its single goal and CTA",
+      "prompt": "Write every email in the sequence to its mapped goal. 1) For each email provide: subject line (<=50 chars, distinct from the others), preview/preheader text (<=90 chars), and body. 2) The body serves the email's ONE goal and drives its ONE CTA — do not cram in unrelated asks. 3) Make the sequence progress: later emails build on earlier ones, none is redundant. 4) Keep a consistent brand voice, short scannable paragraphs, and a single primary CTA button per email. 5) Record each email's send timing from the map. Save the drafted copy (with email number, timing, subject, preview, body, CTA) to the produces path as structured markdown. Note which checklist items pass.\n\nThe deliverable `{{workPath}}/draft.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}}/draft.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/draft.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/draft.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "draft",
+        "maxAttempts": 3
+      },
+      "next": "build"
+    },
+    {
+      "id": "build",
+      "name": "Build the email set",
+      "description": "render the sequence to client-safe inline-styled HTML",
+      "prompt": "Build the approved copy into a deliverable, client-safe HTML email sequence in a single index.html. 1) Render each email as its own clearly separated section/block within the page (with a heading like 'Email 1 — Day 0 — subject'), so the whole sequence is previewable in one file. 2) Use email-safe HTML: inline styles only (no external CSS or <style> reliance), table-based layout where needed, web-safe fonts, and absolute links. 3) Include the subject and preview text as labeled metadata, a single prominent CTA button per email, and an unsubscribe link in each email's footer. 4) Keep it responsive at common widths. On a loop-back, fix only the named gaps. Save to the produces path (index.html) and note the email count.",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "index.html",
+        "minBytes": 1,
+        "sniff": "html-complete"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "index.html",
+            "bytes": 800
+          },
+          {
+            "kind": "htmlLint",
+            "file": "index.html"
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkHtmlComplete",
+            "scope": "standard",
+            "inputs": {
+              "file": "index.html"
+            }
+          }
+        ],
+        "onReject": "build",
+        "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 index.html (render it if a browser/QA capability is available; otherwise read the source) and grade against the checklist. Check EACH criterion and write PASS/FAIL: (a) every planned email is present as a labeled section with subject + preview + body; (b) each email has exactly one CTA and one goal; (c) no two emails are redundant and the arc progresses toward the end goal; (d) subject lines are distinct and within length; (e) styles are inline/email-safe (no reliance on external CSS); (f) an unsubscribe link is present in each email. A sequence where emails are redundant or use non-email-safe CSS FAILS — 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": "index.html"
+        }
+      ],
+      "next": "build"
+    },
+    {
+      "id": "finish",
+      "name": "Finish",
+      "description": "All acceptance criteria met. Stamp a short summary and report DONE.",
+      "prompt": "Every acceptance criterion passed. Write a one-paragraph DONE summary to task notes via `write_task_note`: what was built, the deliverable path(s), and a one-line confirmation that each criterion is met. Then report DONE.",
+      "suggestedRole": "developer",
+      "terminal": true
+    }
+  ],
+  "version": "1.0.2",
+  "releasedAt": "2026-08-21T00:00:00Z",
+  "paramSchema": {
+    "type": "object",
+    "properties": {
+      "workPath": {
+        "type": "string",
+        "title": "Working folder",
+        "description": "Per-task working folder in the artifacts drawer. Defaults to this task's own folder so runs never collide; override with a stable name when you deliberately want runs to share files.",
+        "default": "{{task.dir}}"
+      }
+    }
+  },
+  "minGezelVersion": "1.26233"
+}

package/data/craftbook-templates/em/email-sequence/versions/1.0.2/test.json

@@ -0,0 +1,100 @@
+{
+  "schemaVersion": 1,
+  "title": "Lifecycle Email Sequence smoke eval",
+  "objective": "Self-contained smoke eval for the Lifecycle Email Sequence craftbook using the html-page generic harness.",
+  "tags": [
+    "html-page"
+  ],
+  "prompt": "Can you biuld us a little page for this? The content notes are in source/page-content.md. Save it as index.html — one file, nothing fancy needed on our end.",
+  "setup": {
+    "projectName": "Lifecycle Email Sequence Eval",
+    "about": "Self-contained eval project for email-sequence. Seeded inputs are under workspace/source or workspace/fixtures; final deliverable is workspace/index.html.",
+    "missionObjectives": "Use the Lifecycle Email Sequence craftbook/template, read the seeded local fixtures, and write index.html without network calls, real credentials, or live services.",
+    "files": [
+      {
+        "path": "source/brief.md",
+        "content": "# Lifecycle Email Sequence 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: email-sequence - Lifecycle Email Sequence.\n"
+      },
+      {
+        "path": "source/page-content.md",
+        "content": "# Boreal Desk Support Board\n\nBuild content around a support operations board. Required labels: Open issues, Status silence, Response time, Refund leakage, Next action. Required metric text: 18 hours to 6 hours and 14.2% to 8.9%.\n"
+      }
+    ],
+    "worker": {
+      "name": "Jules",
+      "role": "Developer"
+    },
+    "craftbookParams": {
+      "workPath": "tasks/eval"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "index.html is a source-grounded self-contained HTML page/tool.",
+    "deliverables": [
+      {
+        "path": "index.html",
+        "kind": "html-page",
+        "minBytes": 3000,
+        "checks": [
+          {
+            "kind": "cssMinBytes",
+            "bytes": 650,
+            "file": "index.html"
+          },
+          {
+            "kind": "jsParses",
+            "file": "index.html"
+          },
+          {
+            "kind": "contains",
+            "file": "index.html",
+            "pattern": "Boreal|Support Board|returns",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "index.html",
+            "pattern": "18\\s*hours|6\\s*hours|14\\.2%|8\\.9%",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "index.html",
+            "pattern": "button|input|filter|tab|card|section|nav",
+            "flags": "i"
+          }
+        ]
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "index.html",
+      "kind": "html"
+    },
+    "axes": [
+      {
+        "name": "structure",
+        "description": "Layout and hierarchy fit the content; sections are scannable and coherent."
+      },
+      {
+        "name": "grounding",
+        "description": "Seeded source content is used faithfully — no invented facts or dropped requirements."
+      },
+      {
+        "name": "interactivity",
+        "description": "Controls and states the page claims to offer actually work."
+      },
+      {
+        "name": "polish",
+        "description": "Styling is intentional and responsive rather than unstyled or broken."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "self-contained UI",
+    "source grounding",
+    "responsive structure"
+  ]
+}