@bendyline/gilde 0.1.50 → 0.1.52

package/data/craftbook-templates/tr/transcribe-audio/versions/1.0.3/craftbook.json

@@ -0,0 +1,218 @@
+{
+  "id": "transcribe-audio",
+  "name": "Transcribe Audio or Video",
+  "description": "Convert an audio or video recording into an accurate, readable transcript using speech-to-text, with speaker labels and timestamps. Scopes the output format, speaker-labeling, and timestamp granularity FIRST so the transcript is usable downstream (search, subtitles, minutes), then transcribes the full recording end-to-end, then verifies coverage against the recording's duration and checks for dropped segments. The scope-first ordering matters because deciding timestamp cadence and speaker handling up front is what separates a clean, searchable transcript from a wall of unattributed text.\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 transcript (planner) — format, speaker labels, timestamp cadence, glossary → gated on artifact `{{workPath}}/scope.md` (markdown-notes)\n2. Transcribe the recording (developer) — run STT over the full file, label speakers, timestamp → gated on `transcript.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": [
+    "transcribe this audio",
+    "transcribe a video",
+    "speech to text",
+    "get a transcript",
+    "convert recording to text"
+  ],
+  "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}}"
+      }
+    }
+  },
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the transcript",
+      "description": "format, speaker labels, timestamp cadence, glossary",
+      "prompt": "Define what a good transcript looks like BEFORE transcribing. Step 1: record the source file (path, format, duration in seconds). Step 2: pick the output format (plain markdown, or timestamped blocks like `[00:01:23] Speaker 1: ...`) and the timestamp cadence (per-utterance, every N seconds, or per-paragraph). Step 3: decide speaker handling (diarize into Speaker 1/2…, or single-speaker) and how to label them. Step 4: build a small glossary of names/terms/acronyms likely in the audio so they transcribe correctly. Step 5: decide cleanup level (verbatim with ums, or lightly edited for readability). Write an acceptance-criteria checklist (transcript spans the full duration with a final timestamp near the end, every block is timestamped, speakers are labeled consistently, glossary terms spelled correctly, output parses as the chosen format) 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",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "audio",
+          "browser-automation",
+          "code-execution",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web",
+          "workspace-fs-write"
+        ],
+        "outputMedium": "artifact",
+        "additionalOutputMedia": [
+          "task-note"
+        ]
+      }
+    },
+    {
+      "id": "transcribe",
+      "name": "Transcribe the recording",
+      "description": "run STT over the full file, label speakers, timestamp",
+      "prompt": "Produce the transcript to the locked format. Step 1: run the speech-to-text capability over the WHOLE file (chunk long files on silence boundaries and stitch, keeping running timestamps so they stay monotonic across chunks). Step 2: apply speaker labels and the chosen timestamp cadence. Step 3: apply the glossary — correct names/terms the recognizer got wrong. Step 4: apply the chosen cleanup level. Step 5: write the result to `transcript.md` in the locked format and confirm it parses. write_task_note the transcript path, its final timestamp, and the recording duration so coverage is checkable. On a loop-back, fix only the flagged gaps (missing tail, mislabeled speakers, glossary misspellings).",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "transcript.md",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "transcript.md",
+            "bytes": 500
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkContains",
+            "scope": "standard",
+            "inputs": {
+              "file": "transcript.md",
+              "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+              "flags": "i"
+            }
+          }
+        ],
+        "onReject": "transcribe",
+        "maxAttempts": 4
+      },
+      "next": "evaluate",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "artifacts",
+          "browser-automation",
+          "code-execution",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web"
+        ],
+        "outputMedium": "workspace",
+        "additionalOutputMedia": [
+          "task-note"
+        ]
+      }
+    },
+    {
+      "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 accuracy and coverage. Step 1: confirm the LAST timestamp is within a small margin of the recording's duration (no dropped tail) — PASS/FAIL coverage. Step 2: confirm every block is timestamped and speakers are labeled consistently throughout. Step 3: spot-check 3 timestamps against the audio (if an audio capability exists) — does the text match what is said there? Step 4: confirm glossary terms/names are spelled correctly. Step 5: confirm the file parses as the chosen format. 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: \"transcribe\" })` 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": "transcript.md"
+        }
+      ],
+      "next": "transcribe",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "artifacts",
+          "audio",
+          "browser-automation",
+          "code-execution",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web",
+          "workspace-fs-write"
+        ],
+        "outputMedium": "task-note"
+      }
+    },
+    {
+      "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,
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "artifacts",
+          "audio",
+          "browser-automation",
+          "code-execution",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web",
+          "workspace-fs-write"
+        ],
+        "outputMedium": "task-note"
+      }
+    }
+  ],
+  "version": "1.0.3",
+  "releasedAt": "2026-09-01T20:00:00Z",
+  "minGezelVersion": "1.26233"
+}

package/data/craftbook-templates/tr/transcribe-audio/versions/1.0.3/test.json

@@ -0,0 +1,103 @@
+{
+  "schemaVersion": 1,
+  "title": "Transcribe Audio or Video smoke eval",
+  "objective": "Self-contained smoke eval for the Transcribe Audio or Video 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": "Transcribe Audio or Video Eval",
+    "about": "Self-contained eval project for transcribe-audio. Seeded inputs are under workspace/source or workspace/fixtures; final deliverable is workspace/media-plan.json.",
+    "missionObjectives": "Use the Transcribe Audio or Video 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": "# Transcribe Audio or Video 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: transcribe-audio - Transcribe Audio or Video.\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"
+    }
+  },
+  "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": "transcribe-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/tr/transcribe-index/versions/1.0.3/craftbook.json

@@ -0,0 +1,329 @@
+{
+  "id": "transcribe-index",
+  "name": "Transcribe and Index a Tape",
+  "description": "Give one tape the ten-second-findability treatment: transcript on file, then every moment worth finding indexed with its timecode and people tags — so 'the clip of Opa's 80th toast' becomes a query, not an afternoon of scrubbing. Locks the tape's metadata and the indexing rules FIRST (timecoded moments, people tags drawn from the family roster, searchable descriptions), then lands the transcript, then the clip records, then a tape summary with the highlights. Use for indexing a digitized tape, making home videos searchable, cataloging family footage, and 'what is on this tape'.\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 tape (filmarchivaris) — tape metadata, the family roster, indexing rules locked → gated on artifact `{{workPath}}/scope.md` (markdown-notes)\n2. Land the transcript (transcriber) — the tape's transcript on file, timestamped and speaker-marked\n3. Index the moments (archivist) — clip records appended: tape, timecode, people, description → gated on `clips.json` (json)\n4. Write the tape summary (copywriter) — what is on the tape, the highlights, who appears → 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": [
+    "index the tape",
+    "transcribe the tape",
+    "what is on this tape",
+    "make the tape searchable",
+    "catalog the footage"
+  ],
+  "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}}"
+      }
+    }
+  },
+  "steps": [
+    {
+      "id": "scope",
+      "name": "Scope the tape",
+      "description": "tape metadata, the family roster, indexing rules locked",
+      "prompt": "Define the indexing job before touching the tape. Step 1: identify the tape being indexed — its label or number, roughly when it was shot, and where its transcript lands under transcripts/ (when a transcript is already on file there, this run verifies and indexes it rather than re-transcribing). Step 2: read family.md from the workspace — the roster of names is the controlled vocabulary for people tags; a tag that is not on the roster is a typo waiting to break search. Step 3: read clips.json to see how prior tapes were indexed, and lock the indexing rules — every moment worth finding gets a record with the tape, the timecode where it starts, the people in it tagged from the roster, and a description written the way someone would actually search for it ('Opa's toast at the 80th', not 'man speaking'). Step 4: write an acceptance-criteria checklist ('transcript on file under transcripts/', 'every notable moment indexed with its timecode', 'every people tag matches the roster', 'descriptions are searchable phrases', 'existing clip records untouched'). Call write_task_note with the tape id + roster size + 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": "filmarchivaris",
+      "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": "transcript",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "audio",
+          "browser-automation",
+          "code-execution",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web",
+          "workspace-fs-write"
+        ],
+        "outputMedium": "artifact",
+        "additionalOutputMedia": [
+          "task-note"
+        ]
+      }
+    },
+    {
+      "id": "transcript",
+      "name": "Land the transcript",
+      "description": "the tape's transcript on file, timestamped and speaker-marked",
+      "prompt": "Get the tape's transcript on file. Step 1: produce the transcript through the project's transcription capabilities — or, when a transcript for this tape is already provided under transcripts/, read it end to end and treat it as the source. Step 2: make sure it carries what indexing needs — timestamps through the recording and speaker names where voices are identifiable from the family roster; normalize obvious mis-hearings of family names against family.md. Step 3: save the result under transcripts/ named for the tape, and skim once for the moments that will matter — celebrations, first words, arrivals, the stories people tell — noting rough timecodes as you go. Call write_task_note with the transcript path, its rough duration, and the count of candidate moments spotted.",
+      "suggestedRole": "transcriber",
+      "next": "index",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "artifacts",
+          "audio",
+          "browser-automation",
+          "code-execution",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web",
+          "workspace-fs-write"
+        ],
+        "outputMedium": "task-note"
+      }
+    },
+    {
+      "id": "index",
+      "name": "Index the moments",
+      "description": "clip records appended: tape, timecode, people, description",
+      "prompt": "Index every moment worth finding. Step 1: walk the transcript and pick the moments someone will one day search for — the toast, the song, the argument about the recipe, the baby's first steps in the background. Aim for completeness over polish: a missed moment is invisible forever. Step 2: for each moment, append a record to clips.json through the project's archive capabilities — the tape id, the timecode where the moment starts (matching a timestamp in the transcript), the people in it as an array of roster names from family.md, and a searchable description. Step 3: never edit or drop the existing records from prior tapes — this is an append, and the archive's history is the point. Step 4: re-read clips.json once — valid JSON, new records complete, timecodes real. Call write_task_note with the count of new records and the single best moment found.",
+      "suggestedRole": "archivist",
+      "advanceWhen": {
+        "file": "clips.json",
+        "minBytes": 1,
+        "sniff": "json-valid"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "clips.json",
+            "bytes": 2
+          },
+          {
+            "kind": "recordSchema",
+            "file": "clips.json",
+            "fields": [
+              {
+                "name": "tape",
+                "type": "nonempty"
+              },
+              {
+                "name": "timecode",
+                "type": "nonempty"
+              },
+              {
+                "name": "people"
+              },
+              {
+                "name": "description",
+                "type": "nonempty"
+              }
+            ],
+            "minRows": 5
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkJsonValid",
+            "scope": "standard",
+            "inputs": {
+              "file": "clips.json"
+            }
+          }
+        ],
+        "onReject": "index",
+        "maxAttempts": 3
+      },
+      "next": "report",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "artifacts",
+          "audio",
+          "browser-automation",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web"
+        ],
+        "outputMedium": "workspace",
+        "additionalOutputMedia": [
+          "task-note"
+        ]
+      }
+    },
+    {
+      "id": "report",
+      "name": "Write the tape summary",
+      "description": "what is on the tape, the highlights, who appears",
+      "prompt": "Write the tape summary the family actually reads. Step 1: open with what the tape is — when it was shot, the occasions it covers, roughly how long it runs. Step 2: give the highlights — the five or so best moments with their timecodes, written warmly enough that someone wants to go watch them. Step 3: list who appears on the tape, drawn from the people tags just indexed. Step 4: close with how to find things — a line noting that every indexed moment is searchable in the archive by person or description. Keep it to a page; this is a family document, not a catalog printout. Write {{workPath}}/report.md and call write_task_note with the report path and the indexed-moment count.\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": 800,
+            "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",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "audio",
+          "browser-automation",
+          "code-execution",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web",
+          "workspace-fs-write"
+        ],
+        "outputMedium": "artifact",
+        "additionalOutputMedia": [
+          "task-note"
+        ]
+      }
+    },
+    {
+      "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, clips.json, the transcript under transcripts/, and family.md and verify every criterion from {{workPath}}/scope.md: the transcript is on file and timestamped, every new clip record carries a timecode that appears in the transcript, every people tag matches a roster name exactly, descriptions read as searchable phrases rather than shrugs, prior tapes' records are untouched, and the summary's highlights point at real indexed moments. Write PASS/FAIL per criterion; on any failure, name the offending record and loop back to index.\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: \"index\" })` 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": "index",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "audio",
+          "browser-automation",
+          "code-execution",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web",
+          "workspace-fs-write"
+        ],
+        "outputMedium": "task-note"
+      }
+    },
+    {
+      "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,
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "artifacts",
+          "audio",
+          "browser-automation",
+          "code-execution",
+          "craftbooks",
+          "data-tables",
+          "entity-intel",
+          "git",
+          "image-intel",
+          "images",
+          "role-delegation",
+          "role-delegation-escalation",
+          "security-intel",
+          "team-management",
+          "videos",
+          "web",
+          "workspace-fs-write"
+        ],
+        "outputMedium": "task-note"
+      }
+    }
+  ],
+  "version": "1.0.3",
+  "releasedAt": "2026-09-01T20:00:00Z",
+  "minGezelVersion": "1.26233"
+}