@bendyline/gilde 0.1.38 → 0.1.39

package/data/craftbook-templates/me/meeting-summary-audio/versions/1.0.2/craftbook.json

@@ -0,0 +1,121 @@
+{
+  "id": "meeting-summary-audio",
+  "name": "Meeting Recording to Minutes & Actions",
+  "description": "Turn a meeting recording into structured minutes plus a clear action-item list — who agreed to do what by when — derived from the audio. Transcribes the recording FIRST (with speaker labels so attribution is possible), then summarizes into decisions, discussion, and assigned action items with owners and due dates. The transcribe-then-summarize ordering is essential: you cannot reliably attribute decisions and owners without first knowing who said what, and minutes without owners are useless.\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. Transcribe the meeting (developer) — STT with speaker labels + timestamps → gated on artifact `{{workPath}}/transcript.md` (markdown-doc)\n2. Summarize into minutes & actions (copywriter) — decisions, discussion, action items with owners + dates → gated on `minutes.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": "transcribe",
+  "triggers": [
+    "meeting minutes from recording",
+    "summarize this meeting",
+    "action items from a call",
+    "turn a recording into notes",
+    "who agreed to what"
+  ],
+  "steps": [
+    {
+      "id": "transcribe",
+      "name": "Transcribe the meeting",
+      "description": "STT with speaker labels + timestamps",
+      "prompt": "Get an attributable transcript BEFORE summarizing. Step 1: record the source (path, duration, and attendee names if known). Step 2: run speech-to-text over the WHOLE recording with diarization, labeling speakers (map to real names where you can infer them from introductions). Step 3: timestamp utterances so decisions/actions can cite a moment. Step 4: lightly clean filler for readability but keep commitments verbatim. Step 5: write the labeled transcript to `{{workPath}}/transcript.md` via write_task_note AND the produces path, and note its final timestamp vs the duration so coverage is checkable. On a loop-back, fix only flagged attribution/coverage gaps.\n\nThe deliverable `{{workPath}}/transcript.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": "developer",
+      "advanceWhen": {
+        "file": "{{workPath}}/transcript.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/transcript.md",
+            "bytes": 500,
+            "artifact": true
+          },
+          {
+            "kind": "contains",
+            "file": "{{workPath}}/transcript.md",
+            "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+            "flags": "i",
+            "label": "at least one markdown heading",
+            "artifact": true
+          }
+        ],
+        "onReject": "transcribe",
+        "maxAttempts": 3
+      },
+      "next": "summarize"
+    },
+    {
+      "id": "summarize",
+      "name": "Summarize into minutes & actions",
+      "description": "decisions, discussion, action items with owners + dates",
+      "prompt": "Write the minutes from the transcript. Step 1: lead with meeting metadata (title, date if known, attendees). Step 2: write a 'Decisions' section — each decision a tight bullet, with who made/agreed it. Step 3: write a 'Discussion' section summarizing key points by topic (not a re-transcription). Step 4: write an 'Action Items' section as a checklist where EVERY item has an explicit owner and a due date (write 'owner: TBD' / 'due: TBD' only if truly unstated — never silently drop the field). Step 5: add an 'Open Questions' section for anything unresolved. Do not invent commitments not in the transcript; attribute owners only when the transcript supports it. Write it all to `minutes.md` with clear headers. write_task_note the path and the action-item count. On a loop-back, fix only the flagged sections.",
+      "suggestedRole": "copywriter",
+      "advanceWhen": {
+        "file": "minutes.md",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "minutes.md",
+            "bytes": 500
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkContains",
+            "scope": "standard",
+            "inputs": {
+              "file": "minutes.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": "Check the minutes against the recording. Step 1: confirm `minutes.md` has Decisions, Discussion, Action Items, and Open Questions sections with metadata up top (PASS/FAIL). Step 2: confirm EVERY action item has an owner and a due-date field (explicit or TBD) — no item missing the fields. Step 3: spot-check 3 decisions/actions against the transcript — each is real and attributed correctly, nothing invented. Step 4: confirm the summary is condensed (not a re-transcription) yet covers the major topics. Step 5: confirm transcript coverage reached the end of the recording. 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: \"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": "minutes.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"
+}

package/data/craftbook-templates/me/meeting-summary-audio/versions/1.0.2/test.json

@@ -0,0 +1,106 @@
+{
+  "schemaVersion": 1,
+  "title": "Meeting Recording to Minutes & Actions smoke eval",
+  "objective": "Self-contained smoke eval for the Meeting Recording to Minutes & Actions 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": "Meeting Recording to Minutes & Actions Eval",
+    "about": "Self-contained eval project for meeting-summary-audio. Seeded inputs are under workspace/source or workspace/fixtures; final deliverable is workspace/media-plan.json.",
+    "missionObjectives": "Use the Meeting Recording to Minutes & Actions 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": "# Meeting Recording to Minutes & Actions 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: meeting-summary-audio - Meeting Recording to Minutes & Actions.\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": "meeting-summary-audio-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/me/memory-prompt-session/versions/1.0.2/craftbook.json

@@ -0,0 +1,127 @@
+{
+  "id": "memory-prompt-session",
+  "name": "Memory Session",
+  "description": "Run one guided memory session and bank it properly: pick the theme the timeline is hungriest for, follow the thread of feeling through the recorded conversation, and file the session with the follow-up questions that keep the next one alive. Locks the theme and question set FIRST, then captures the session in the teller's own words, then files it in the store with the threads to pull next time. Use for memory sessions, filing an interview with a parent or grandparent, memoir capture, and 'what should I ask next time'.\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 session (planner) — theme from the timeline's gaps, question set, capture rules → gated on artifact `{{workPath}}/scope.md` (markdown-notes)\n2. Capture the session (interviewer) — session record in the teller's own words under sessions/\n3. File the session (archivist) — store record updated, chapter-worthy moments, follow-up threads → 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": [
+    "file the memory session",
+    "run a memory session",
+    "we recorded a session with mom",
+    "what should I ask next time",
+    "bank the interview"
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the session",
+      "description": "theme from the timeline's gaps, question set, capture rules",
+      "prompt": "Choose the session's aim before pressing record — or before opening the transcript. Step 1: read sessions.json and timeline.md from the workspace — what has been captured already, and which years and themes the timeline is hungriest for. Step 2: pick the session theme with the owner and draft the question set — open questions that follow feeling, not chronology ('what did the kitchen smell like' beats 'what year was that'). Step 3: write an acceptance-criteria checklist ('the session file preserves the teller's own words and phrasings', 'the session is recorded in the store with its date and theme', 'the report names the moments worth a chapter, each with the teller's words', 'at least three follow-up threads, each with the question to open it'). Call write_task_note with the theme + question set + checklist and write {{workPath}}/scope.md.\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": "capture"
+    },
+    {
+      "id": "capture",
+      "name": "Capture the session",
+      "description": "session record in the teller's own words under sessions/",
+      "prompt": "Bank the session from the recording. Step 1: work from the session recording's transcript — through the project's transcription capabilities, or from a transcript file the owner provides. Step 2: shape it gently into a session record: keep the teller's own words and phrasings verbatim, keep the digressions (they are where the good material lives), and mark the interviewer's questions so the thread stays followable. Step 3: note the moments where the feeling changed — a laugh, a pause, a subject change — right where they happened. Step 4: save the session record in the sessions/ folder named for the date (for example sessions/2026-07-18-session.md) and call write_task_note with the path and the themes touched.",
+      "suggestedRole": "interviewer",
+      "next": "file"
+    },
+    {
+      "id": "file",
+      "name": "File the session",
+      "description": "store record updated, chapter-worthy moments, follow-up threads",
+      "prompt": "File the session and set up the next one. Step 1: record the session in the store through the project's memoir capabilities — date, teller, theme, and the session file's path — so sessions.json stays the index of everything banked. Step 2: write {{workPath}}/report.md: what was captured this session in a few warm lines, the moments worth a chapter (quote the teller's words for each), and at least three follow-up threads — each one a specific question for next time, aimed at a gap the session opened. Step 3: note anything the teller said to come back to, or asked to keep private — that instruction outranks everything. Call write_task_note with the chapter-worthy count and the top follow-up question.\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": "archivist",
+      "advanceWhen": {
+        "file": "{{workPath}}/report.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/report.md",
+            "bytes": 1000,
+            "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": "file",
+        "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 the new session file under sessions/ and verify every criterion from {{workPath}}/scope.md: the session file preserves the teller's own words (spot-check the report's quotes against the session file — they must be verbatim), the session is recorded in the store with date and theme, the chapter-worthy moments are named with the teller's words, and there are at least three follow-up threads each carrying a real question. Write PASS/FAIL per criterion; on any failure, name the gap and loop back to file.\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: \"file\" })` 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": "file"
+    },
+    {
+      "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/me/memory-prompt-session/versions/1.0.2/test.json

@@ -0,0 +1,115 @@
+{
+  "schemaVersion": 1,
+  "title": "Memory Session — the bakery years",
+  "objective": "Measure whether the memory-prompt-session craftbook banks a recorded session in the teller's own words, files it in the store, and produces real follow-up threads.",
+  "tags": [
+    "corpus"
+  ],
+  "prompt": "i recorded a long chat with mom about her bakery years — transcript is in recordings/session3.txt. can you file it as a sesion and tell me what to ask next time?",
+  "setup": {
+    "projectName": "Mam's Memoir",
+    "about": "Memoir studio project capturing Els's life story, one recorded session at a time. Session recordings land under workspace/recordings; banked sessions live under workspace/sessions with workspace/sessions.json as the index; workspace/timeline.md tracks which years are covered.",
+    "missionObjectives": "Bank every session faithfully — the teller's own words, filed and indexed — and keep the next session alive with follow-up questions. Grounded in the seeded transcript; no live services, no real credentials.",
+    "files": [
+      {
+        "path": "recordings/session3.txt",
+        "content": "Session 3 — recorded 2026-07-17, kitchen table. Teller: Mam (Els). Interviewer: Jip.\n\nJIP: You always call them the bakery years. Start wherever you want.\n\nELS: We took over the bakery on the Vissersdijk in 1978. Your father signed the papers with flour already on his sleeves, that is how sure he was. I was twenty-six and I had never once seen four o'clock in the morning. By that first winter I could tell the time by the ovens without looking at a clock.\n\nJIP: What did the mornings feel like?\n\nELS: Cold, then warm. That was the whole day, cold then warm. The front of the shop was ice until the ovens caught up. I kneaded with my coat on until six. The smell of the first proof — that is the smell I will want on my last day, I think. Yeast and warm linen.\n\nJIP: Who came in?\n\nELS: Everyone came in. The harbor men at five thirty, before anyone else was awake. They never spoke before the first roll, not one word, and I learned not to speak either. Mrs. Terpstra every Thursday for the raisin loaf, and she paid in coins she counted twice. Children after school with their cents pressed flat and sweaty in their hands.\n\nJIP: Was it ever bad?\n\nELS: The strike year was bad. I will not dress it up. Nineteen eighty-four, the flour price doubled in one season and we did not sleep for the mathematics of it. Your father wanted to sell. I said the ovens stay lit, and I took in mending in the afternoons so they could. Nobody in the town knew that. I did the mending in the back room with the curtain closed.\n\nJIP: I never knew that either.\n\nELS: You were four. You knew the mixing bowl and the licking spoon, that was your whole world. You used to sleep in the flour sacks like a cat. The customers asked after you like you were part of the inventory.\n\nJIP: Why did it end?\n\nELS: My hands, mostly. And the supermarket on the ring road, a little. We sold in 1990 to the Boonstra boy, who let it become a phone shop, which I have decided not to be bitter about. I kept the shop bell. It is in the box under the stairs with the wedding things. When I shake it I am twenty-six again, cold then warm.\n\nJIP: We should stop, your tea is cold.\n\nELS: The tea is always cold when the talking is good. Next time I will tell you about the wedding cakes. The ones I made and the one I never got to make. Ask me about that one, will you? Do not let me wriggle out of it.\n\n[recording ends 58:14]\n"
+      },
+      {
+        "path": "sessions.json",
+        "content": "{\n  \"teller\": \"Els\",\n  \"sessions\": [\n    {\n      \"date\": \"2026-06-07\",\n      \"theme\": \"the childhood house on the dike\",\n      \"summary\": \"Growing up in the 1950s, six siblings, the flood stories.\"\n    },\n    {\n      \"date\": \"2026-06-28\",\n      \"theme\": \"meeting Pa\",\n      \"summary\": \"The dance hall in 1971, the borrowed bicycle, the first winter together.\"\n    }\n  ]\n}\n"
+      },
+      {
+        "path": "timeline.md",
+        "content": "# Els — timeline coverage\n\n- 1950s — childhood on the dike: covered (session 1)\n- 1960s — school years, first job: thin, one anecdote only\n- 1971-1977 — meeting Pa, early marriage: covered (session 2)\n- 1978-1990 — the bakery years: BIGGEST GAP, nothing banked yet\n- 1990s — after the bakery: nothing\n"
+      }
+    ],
+    "worker": {
+      "name": "Milan",
+      "role": "Archivist"
+    },
+    "craftbookParams": {
+      "workPath": "tasks/eval"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "The session is banked under sessions/ in the teller's own words, and tasks/eval/report.md names the chapter-worthy moments with verbatim quotes plus at least three follow-up questions.",
+    "deliverables": [
+      {
+        "path": "tasks/eval/report.md",
+        "kind": "markdown-report",
+        "minBytes": 1000,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "tasks/eval/report.md",
+            "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/report.md",
+            "pattern": "follow",
+            "flags": "i",
+            "label": "follow-up threads present"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/report.md",
+            "pattern": "\\?",
+            "label": "real questions for next time"
+          },
+          {
+            "kind": "valuesSubsetOf",
+            "file": "tasks/eval/report.md",
+            "sourceFiles": [
+              "recordings/session3.txt"
+            ],
+            "pattern": "[\"“]([^\"”\\n]{15,120})[\"”]",
+            "label": "quoted teller phrases are verbatim from the transcript"
+          }
+        ]
+      }
+    ],
+    "checks": [
+      {
+        "kind": "fileCount",
+        "ext": [
+          "md"
+        ],
+        "min": 1,
+        "dir": "sessions"
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "tasks/eval/report.md",
+      "kind": "markdown"
+    },
+    "axes": [
+      {
+        "name": "listening",
+        "description": "The report follows the feeling of the session — the mending secret, the shop bell — not just the chronology."
+      },
+      {
+        "name": "capture fidelity",
+        "description": "The banked session preserves the teller's own words and phrasings; report quotes are verbatim."
+      },
+      {
+        "name": "follow-threads",
+        "description": "At least three specific follow-up questions aimed at gaps the session opened, including the one the teller explicitly asked to be asked."
+      },
+      {
+        "name": "warmth",
+        "description": "Reads like family archiving, not data entry."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "verbatim capture",
+    "follow-up questions",
+    "session filing"
+  ]
+}

package/data/craftbook-templates/me/message-queue-consumer/versions/1.0.2/craftbook.json

@@ -0,0 +1,159 @@
+{
+  "id": "message-queue-consumer",
+  "name": "Message Queue Consumer / Worker",
+  "description": "Build a queue consumer/worker that pulls messages off a queue, processes them reliably, and handles failures with retries and a dead-letter path — at-least-once delivery done right. Scopes the messaging contract FIRST — the message schema, ack/nack semantics, idempotency key, retry/backoff policy, dead-letter rules, and concurrency — then implements the consumer loop with ack-after-success and DLQ routing, then tests success, retry, poison-message, and duplicate-delivery handling. Covers queue consumers, at-least-once vs at-most-once, ack/nack, idempotent processing, retry with backoff, dead-letter queues, and poison-message isolation.\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 consumer (planner) — lock message schema, ack/retry/DLQ, idempotency → gated on artifact `{{workPath}}/scope.md` (markdown-notes)\n2. Build the consumer (developer) — implement the consume loop with retry + DLQ → gated on `src/consumer.js` (code-module)\n3. Test reliability (developer) — test success, retry, poison-message, duplicates → gated on `src/consumer.test.js` (code-with-tests)\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "scope",
+  "triggers": [
+    "build a queue consumer",
+    "message worker",
+    "process queue messages",
+    "handle a message queue",
+    "dead letter queue worker"
+  ],
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the consumer",
+      "description": "lock message schema, ack/retry/DLQ, idempotency",
+      "prompt": "Scope the queue consumer before coding — reliable messaging lives in the policy details. Step 1: Define the MESSAGE schema and the work each message represents. Step 2: Decide the delivery semantics and ACK strategy: ack only AFTER successful processing (at-least-once) so a crash mid-process redelivers, vs ack-on-receipt. Step 3: Define IDEMPOTENCY — the dedupe key and how processing-once is guaranteed under redelivery. Step 4: Define the failure policy: retry count and BACKOFF, and when a message is poison (route to a DEAD-LETTER queue after N attempts) rather than blocking the queue forever. Step 5: Decide concurrency/prefetch. Step 6: Write a numbered acceptance-criteria checklist of 5-9 items (e.g. 'a successful message is acked and processed once', 'a transient failure is retried with backoff', 'a poison message goes to the DLQ after N attempts', 'a duplicate delivery is processed only once'). `write_task_note` the scope + checklist and write the same 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": "build"
+    },
+    {
+      "id": "build",
+      "name": "Build the consumer",
+      "description": "implement the consume loop with retry + DLQ",
+      "prompt": "Implement the consumer to the scope as a runnable worker. Step 1: Pull messages and validate each against the schema. Step 2: Process, then ACK only on success; on failure NACK/requeue so the message is redelivered (at-least-once). Step 3: Make processing IDEMPOTENT — check the dedupe key before applying side-effects so redelivery/duplicates do not double-apply. Step 4: Track attempt count; retry transient failures with BACKOFF, and after the scoped max attempts route the message to the DEAD-LETTER queue instead of looping forever. Step 5: Honor the concurrency/prefetch setting and log per-message outcome. Use an in-memory queue/DLQ if none specified. Write the worker to the produces path. On a loop-back, fix only the named gap. `write_task_note` the file path and which criteria now pass.",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "src/consumer.js",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "src/consumer.js",
+            "bytes": 200
+          },
+          {
+            "kind": "sniff",
+            "file": "src/consumer.js",
+            "sniff": "nonempty"
+          },
+          {
+            "kind": "esmImports",
+            "file": "src/consumer.js"
+          },
+          {
+            "kind": "sourceParses",
+            "file": "src/consumer.js"
+          }
+        ],
+        "onReject": "build",
+        "maxAttempts": 3
+      },
+      "next": "test"
+    },
+    {
+      "id": "test",
+      "name": "Test reliability",
+      "description": "test success, retry, poison-message, duplicates",
+      "prompt": "Write tests for the consumer's reliability behavior. Step 1: Assert a good message is processed exactly once and acked. Step 2: Inject a transient failure and assert the message is retried (with backoff) and eventually succeeds. Step 3: Inject a permanently-failing (poison) message and assert it lands in the DLQ after the max attempts and does NOT block the queue. Step 4: Deliver the same message id twice and assert the side-effect is applied only once (idempotency). `write_task_note` the test file path and pass/fail count.",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "src/consumer.test.js",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "src/consumer.js",
+            "bytes": 200
+          },
+          {
+            "kind": "sniff",
+            "file": "src/consumer.js",
+            "sniff": "nonempty"
+          },
+          {
+            "kind": "esmImports",
+            "file": "src/consumer.js"
+          },
+          {
+            "kind": "sourceParses",
+            "file": "src/consumer.js"
+          }
+        ],
+        "onReject": "test",
+        "maxAttempts": 4
+      },
+      "next": "evaluate"
+    },
+    {
+      "id": "evaluate",
+      "name": "Evaluate",
+      "description": "Grade the deliverable against every acceptance criterion. All pass → finish; any fail → loop back and fix the gap.",
+      "prompt": "Run the tests and drive the consumer. For EACH acceptance criterion: confirm a successful message is processed once and acked, confirm a transient failure is retried with backoff, confirm a poison message reaches the DLQ after N attempts without blocking, and confirm duplicate delivery is processed only once. Write PASS/FAIL per criterion; a poison message that blocks the queue or a duplicate that double-applies is a FAIL.\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": "src/consumer.js"
+        }
+      ],
+      "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"
+}