@bendyline/gilde 0.1.51 → 0.1.52

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

@@ -0,0 +1,312 @@
+{
+  "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"
+  ],
+  "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 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",
+      "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": "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",
+      "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": "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",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "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": "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",
+      "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/ed/edit-notes/versions/1.0.3/test.json

@@ -0,0 +1,146 @@
+{
+  "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"
+    }
+  },
+  "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"
+  ]
+}