@bendyline/gilde 0.1.50 → 0.1.52

package/data/craftbook-templates/ro/root-cause-investigation/versions/2.0.6/test.json

@@ -0,0 +1,157 @@
+{
+  "schemaVersion": 1,
+  "title": "Root-Cause Investigation — decimal cart total regression",
+  "objective": "Require the Root-Cause Investigation craftbook to reproduce a deterministic failure, identify the causal mechanism before editing, implement the smallest fix, and prove the regression test passes.",
+  "tags": [
+    "workflow",
+    "debugging",
+    "code-with-tests",
+    "node"
+  ],
+  "prompt": "Use the Root-Cause Investigation craftbook to diagnose the failing decimal cart-total behavior in this workspace. First reproduce it with the existing dependency-free test and preserve concrete evidence; do not edit until a causal hypothesis has been tested. Then make the smallest correct source change, keep the regression coverage, and write the craftbook's artifacts, including `tasks/eval/reports/root-cause-investigation.md`. The final report must cite the files inspected, distinguish root cause from symptom, include the exact verification command and result, and describe a safe rollback.",
+  "setup": {
+    "projectName": "Decimal cart total regression",
+    "about": "A tiny dependency-free Node project with one reproducible arithmetic defect. The initial test is expected to fail.",
+    "missionObjectives": "Restore exact cent-based addition for decimal prices without broad refactoring and leave a passing regression test plus an evidence-backed investigation report.",
+    "files": [
+      {
+        "path": "package.json",
+        "content": "{\n  \"name\": \"cart-total-fixture\",\n  \"private\": true,\n  \"type\": \"module\"\n}\n"
+      },
+      {
+        "path": "src/cart-total.js",
+        "content": "/** Sum display-price strings and return a two-decimal total. */\nexport function cartTotal(prices) {\n  const cents = prices.reduce((sum, price) => sum + parseInt(price, 10) * 100, 0);\n  return (cents / 100).toFixed(2);\n}\n"
+      },
+      {
+        "path": "tests/cart-total.test.mjs",
+        "content": "import test from 'node:test';\nimport assert from 'node:assert/strict';\nimport { cartTotal } from '../src/cart-total.js';\n\ntest('keeps cents when totaling decimal display prices', () => {\n  assert.equal(cartTotal(['19.99', '5.50']), '25.49');\n});\n\ntest('handles a single whole-dollar price', () => {\n  assert.equal(cartTotal(['7.00']), '7.00');\n});\n"
+      },
+      {
+        "path": "source/incident.md",
+        "content": "# Incident note\n\nCheckout preview showed **$24.00** for line items **$19.99** and **$5.50**. The expected total is **$25.49**. The defect appeared after price inputs changed from integer-dollar strings to two-decimal display strings. No production data migration is in scope.\n"
+      },
+      {
+        "path": "tests/verify-cart-total.mjs",
+        "content": "import assert from 'node:assert/strict';\nimport { cartTotal } from '../src/cart-total.js';\n\nconst cases = [\n  [['19.99', '5.50'], '25.49'],\n  [['0.10', '0.20'], '0.30'],\n  [['12.34', '0.66'], '13.00'],\n  [['7.00'], '7.00'],\n  [['1.01', '2.02', '3.03'], '6.06'],\n];\nfor (const [prices, expected] of cases) assert.equal(cartTotal(prices), expected, prices.join(' + '));\nconsole.log('CART_TOTAL_ORACLE_OK 5/5');\n",
+        "surface": "harness"
+      }
+    ],
+    "craftbookParams": {
+      "workPath": "tasks/eval"
+    }
+  },
+  "mocks": [],
+  "success": {
+    "summary": "The decimal regression is fixed by a diagnosed causal change, the existing test passes, and the craftbook report preserves reproducible evidence.",
+    "deliverables": [
+      {
+        "path": "tasks/eval/reports/root-cause-investigation.md",
+        "kind": "markdown-report",
+        "artifact": true,
+        "minBytes": 1200,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "tasks/eval/reports/root-cause-investigation.md",
+            "pattern": "^#{1,3}\\s+Root cause\\b[\\s\\S]*^#{1,3}\\s+(Fix|Changed files)\\b[\\s\\S]*^#{1,3}\\s+(Regression coverage|Verification)\\b[\\s\\S]*^#{1,3}\\s+Rollback\\b",
+            "flags": "im",
+            "label": "root cause through rollback sections"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/reports/root-cause-investigation.md",
+            "pattern": "parseInt|truncat(?:e|ed|ion)|discard(?:s|ed)?\\s+(?:the\\s+)?(?:decimal|fractional|cent)",
+            "flags": "i",
+            "label": "causal mechanism"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/reports/root-cause-investigation.md",
+            "pattern": "node\\s+--test\\s+tests/cart-total\\.test\\.mjs[\\s\\S]*(pass|2\\s+tests?|exit(?:ed)?\\s+0)",
+            "flags": "i",
+            "label": "verification command and result"
+          },
+          {
+            "kind": "citationsResolve",
+            "file": "tasks/eval/reports/root-cause-investigation.md",
+            "minCitations": 2
+          }
+        ]
+      }
+    ],
+    "checks": [
+      {
+        "kind": "notContains",
+        "file": "src/cart-total.js",
+        "pattern": "\\bparseInt\\s*\\(",
+        "label": "lossy integer parsing removed"
+      },
+      {
+        "kind": "sourceParses",
+        "file": "src/cart-total.js"
+      },
+      {
+        "kind": "nodeRuns",
+        "file": "tests/cart-total.test.mjs",
+        "timeoutMs": 20000
+      },
+      {
+        "kind": "nodeScriptPasses",
+        "script": "tests/verify-cart-total.mjs",
+        "requiredOutput": [
+          {
+            "pattern": "CART_TOTAL_ORACLE_OK 5/5",
+            "label": "hidden multi-case regression oracle"
+          }
+        ]
+      }
+    ],
+    "taskNotes": {
+      "minBytes": 180,
+      "checks": [
+        {
+          "kind": "contains",
+          "file": "task-notes.md",
+          "pattern": "\\bDONE\\b[\\s\\S]*(node\\s+--test|tests/cart-total\\.test\\.mjs)[\\s\\S]*tasks/eval/reports/root-cause-investigation\\.md",
+          "flags": "i",
+          "label": "terminal note records proof and report"
+        }
+      ],
+      "requireCraftbookTask": true
+    },
+    "taskGraph": {
+      "requireCraftbookTask": true,
+      "requireTerminalStep": true
+    },
+    "unchangedFixtures": [
+      "package.json",
+      "tests/cart-total.test.mjs",
+      "source/incident.md"
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "tasks/eval/reports/root-cause-investigation.md",
+      "kind": "markdown"
+    },
+    "axes": [
+      {
+        "name": "Causal rigor",
+        "description": "The report explains why the observed inputs fail in this implementation and distinguishes causal evidence from guesses."
+      },
+      {
+        "name": "Fix discipline",
+        "description": "The source change is minimal, directly addresses the diagnosed mechanism, and avoids unrelated refactoring."
+      },
+      {
+        "name": "Verification quality",
+        "description": "Reproduction, regression coverage, final command result, blast radius, and rollback are concrete and auditable."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "Diagnosis precedes source edits",
+    "The fix preserves decimal cents and passes the dependency-free test",
+    "The final report cites real workspace files and includes rollback"
+  ]
+}

package/data/craftbook-templates/ro/rough-cut-assembly/versions/1.0.3/test.json

@@ -23,9 +23,6 @@
     "worker": {
       "name": "Daan",
       "role": "Developer"
-    },
-    "craftbookParams": {
-      "workPath": "tasks/eval"
     }
   },
   "mocks": [

package/data/craftbook-templates/ro/rough-cut-assembly/versions/1.0.4/craftbook.json

@@ -0,0 +1,302 @@
+{
+  "id": "rough-cut-assembly",
+  "name": "Rough Cut Assembly",
+  "description": "Execute the cut list and prove it ran: every clip verified against the media index before anything renders, the assembly driven through the project's media pipeline with a run log, and the result checked against the expected duration — an assembly you can trust unwatched. Locks the pre-flight checks FIRST (clips exist, in and out points sit inside their durations, failure handling decided), then runs the assembly, then verifies and reports. Use for rough cuts, assembling a cutlist, executing an edit pass, render runs, and 'put the cut together'.\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. Pre-flight the cut list (werkmeester) — cutlist validated against the media index, run plan locked → gated on artifact `{{workPath}}/scope.md` (markdown-notes)\n2. Run the assembly (developer) — the cutlist executed through the media pipeline, log on disk → gated on `renders/assembly-log.json` (json)\n3. Verify and report (reviewer) — expected versus actual, segment count, the honest run report → gated on artifact `{{workPath}}/report.md` (markdown-report)\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "scope",
+  "triggers": [
+    "assemble the rough cut",
+    "run the cutlist",
+    "put the cut together",
+    "render the rough cut",
+    "execute the edit"
+  ],
+  "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": "Pre-flight the cut list",
+      "description": "cutlist validated against the media index, run plan locked",
+      "prompt": "Verify before you render — an assembly that runs on a bad cut list wastes the whole pass. Step 1: read cutlist.json and media/index.json from the workspace and check every record: the clip id exists in the index, the in point is before the out point, and both sit inside that clip's duration. List every violation precisely; if any exist, stop and report them instead of assembling around them. Step 2: compute the expected output — how many segments, and the total duration the kept material should add up to — so the verify phase has a number to check against. Step 3: lock the run plan — the assembly runs through the project's pipeline script via the run_installed_script tool, it writes its run log to renders/assembly-log.json with a status field, and on any failure the run stops and the error is reported rather than papered over. Step 4: write an acceptance-criteria checklist ('every cutlist record validated before the run', 'the render exists at renders/rough-cut.mp4', 'the run log reports status ok', 'actual duration matches the expected duration', 'the report states what ran and what to spot-check'). Call write_task_note with the segment count + expected duration + 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": "werkmeester",
+      "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": "assemble",
+      "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",
+          "workspace-fs-write"
+        ],
+        "outputMedium": "artifact",
+        "additionalOutputMedia": [
+          "task-note"
+        ]
+      }
+    },
+    {
+      "id": "assemble",
+      "name": "Run the assembly",
+      "description": "the cutlist executed through the media pipeline, log on disk",
+      "prompt": "Execute the validated cut list. Step 1: the assembly pipeline is a project script — call list_scripts to find it, then run it with run_installed_script({ name: \"<script name>\" }); never run it with run_nodejs_script and never reimplement it. It reads cutlist.json and media/index.json, refuses unknown clips and out-of-range timecodes, and writes the render to renders/rough-cut.mp4 plus its run log to renders/assembly-log.json. Step 2: if run_installed_script reports an error, read the error text, fix exactly what it names (a cutlist record, a path), and run it again — never write renders/assembly-log.json yourself; the log is evidence the pipeline ran, not decoration. Step 3: once the run succeeds, read renders/assembly-log.json and confirm it reports status ok with the clips it assembled and the duration it computed. Call write_task_note with the run outcome, the segment count, and the computed duration.",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "renders/assembly-log.json",
+        "minBytes": 1,
+        "sniff": "json-valid"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "renders/assembly-log.json",
+            "bytes": 2
+          },
+          {
+            "kind": "minBytes",
+            "file": "renders/rough-cut.mp4",
+            "bytes": 200
+          },
+          {
+            "kind": "jsonPathEquals",
+            "file": "renders/assembly-log.json",
+            "path": "status",
+            "value": "ok",
+            "label": "the assembly log reports status ok"
+          }
+        ],
+        "scripts": [
+          {
+            "name": "checkJsonValid",
+            "scope": "standard",
+            "inputs": {
+              "file": "renders/assembly-log.json"
+            }
+          }
+        ],
+        "onReject": "assemble",
+        "maxAttempts": 3
+      },
+      "next": "report",
+      "toolPolicy": {
+        "disallowBuiltinToolsets": [
+          "ai-apps",
+          "archives",
+          "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": "Verify and report",
+      "description": "expected versus actual, segment count, the honest run report",
+      "prompt": "Check the run against the numbers locked in scope, then write the run report. Step 1: compare the log's computed duration against the expected duration from {{workPath}}/scope.md and the log's clip list against the cut list — every segment accounted for, nothing extra, nothing dropped. Step 2: write {{workPath}}/report.md — what was assembled (segments, total duration, source clip count), the expected-versus-actual duration comparison with the delta stated plainly, any warnings the log carried, and the two or three moments a human should spot-check first when they watch the cut. Step 3: if the numbers do not match, say so plainly and name the likely cause — a report that hides a mismatch defeats the whole ritual. Call write_task_note with the report path and the expected-versus-actual result.\n\nBefore working, open the artifact input `{{workPath}}/scope.md` with `read_artifact`; do not look for it in the workspace.\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": "reviewer",
+      "consumes": [
+        {
+          "file": "{{workPath}}/scope.md",
+          "artifact": true
+        }
+      ],
+      "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": "duration",
+            "flags": "i",
+            "label": "the report compares expected versus actual duration",
+            "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",
+          "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": "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, renders/assembly-log.json, and cutlist.json and verify every criterion from {{workPath}}/scope.md: the render exists at renders/rough-cut.mp4, the log reports status ok, every clip in the log's list appears in the cut list (and nothing extra), the expected-versus-actual duration comparison is stated with real numbers from the log, and the report names what to spot-check. Write PASS/FAIL per criterion; on any failure, name the gap and loop back to report — or to assemble if the run itself is the problem.\n\nThe deliverable lives in the project's artifacts drawer — open `{{workPath}}/report.md` with `read_artifact`, not `read_file`.\n\nThen route — this is the whole point of the loop:\n\n- **Every criterion PASSES →** call `advance_task_step({ ref, stepId: \"evaluate\", next: \"finish\" })`.\n- **Any criterion FAILS →** write the specific gaps to notes, then call `advance_task_step({ ref, stepId: \"evaluate\", next: \"report\" })` to loop back. The builder fixes exactly those gaps.\n\nNever route to `finish` while any criterion is unmet. The build phase's completion gate already blocked a grossly-incomplete deliverable; your job is the judgment an automated check cannot make (does it actually work, read well, look right). After ~3 unproductive loops, stop and report DONE_WITH_CONCERNS so the user can step in.",
+      "suggestedRole": "reviewer",
+      "consumes": [
+        {
+          "file": "{{workPath}}/report.md",
+          "artifact": true
+        }
+      ],
+      "next": "report",
+      "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.4",
+  "releasedAt": "2026-09-01T20:00:00Z",
+  "minGezelVersion": "1.26233"
+}

package/data/craftbook-templates/ro/rough-cut-assembly/versions/1.0.4/test.json

@@ -0,0 +1,137 @@
+{
+  "schemaVersion": 1,
+  "title": "Rough Cut Assembly smoke eval",
+  "objective": "Task-specific eval for the Rough Cut Assembly craftbook: a ready cutlist and media index are pre-flighted, executed through the fake assembly pipeline (a provenance-trusted workspace script that refuses unknown clips and bad timecodes), and verified against the expected duration.",
+  "tags": [
+    "external"
+  ],
+  "prompt": "cutlist is ready — can you asemble the rough cut with the fake pipeline thats wired up and check it came out right?",
+  "setup": {
+    "projectName": "Video Workshop — Rough Cut Eval",
+    "about": "Self-contained eval project for rough-cut-assembly. The cut list is cutlist.json and the clip index is media/index.json (durations in seconds). The fake media-assembly pipeline is the ready-made mock-probe project script: it validates the cutlist, writes the stub render to renders/rough-cut.mp4, and writes its run log to renders/assembly-log.json. The run report goes to tasks/eval/report.md.",
+    "missionObjectives": "Use the Rough Cut Assembly craftbook/template, pre-flight cutlist.json against media/index.json, run the assembly through the provided mock-probe script, and verify the log against the expected duration in tasks/eval/report.md. No real media tools, services, or credentials — only the wired fake pipeline.",
+    "files": [
+      {
+        "path": "cutlist.json",
+        "content": "[\n  {\n    \"clip\": \"c01-intro\",\n    \"in\": 0,\n    \"out\": 41,\n    \"action\": \"keep\",\n    \"note\": \"cold open plus intro, trim the dead air\"\n  },\n  {\n    \"clip\": \"c02-interview\",\n    \"in\": 0,\n    \"out\": 80,\n    \"action\": \"keep\",\n    \"note\": \"layout point and the first-jig story\"\n  },\n  {\n    \"clip\": \"c02-interview\",\n    \"in\": 80,\n    \"out\": 160,\n    \"action\": \"cut\",\n    \"note\": \"timber-yard tangent, off topic\"\n  },\n  {\n    \"clip\": \"c02-interview\",\n    \"in\": 160,\n    \"out\": 184,\n    \"action\": \"keep\",\n    \"note\": \"key measurement and the millimeter line\"\n  },\n  {\n    \"clip\": \"c03-broll-shop\",\n    \"in\": 0,\n    \"out\": 20,\n    \"action\": \"trim\",\n    \"note\": \"one breath of b-roll between talk and demo\"\n  },\n  {\n    \"clip\": \"c04-demo\",\n    \"in\": 0,\n    \"out\": 82,\n    \"action\": \"keep\",\n    \"note\": \"fence setting through the tails cut\"\n  },\n  {\n    \"clip\": \"c04-demo\",\n    \"in\": 82,\n    \"out\": 110,\n    \"action\": \"cut\",\n    \"note\": \"repeated cut adds nothing\"\n  },\n  {\n    \"clip\": \"c04-demo\",\n    \"in\": 110,\n    \"out\": 141,\n    \"action\": \"keep\",\n    \"note\": \"the fit test and the squeak\"\n  },\n  {\n    \"clip\": \"c05-outro\",\n    \"in\": 0,\n    \"out\": 30,\n    \"action\": \"keep\",\n    \"note\": \"the ask and the tease\"\n  }\n]\n"
+      },
+      {
+        "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"
+      }
+    ],
+    "worker": {
+      "name": "Daan",
+      "role": "Developer"
+    }
+  },
+  "mocks": [
+    {
+      "kind": "cli",
+      "id": "probe",
+      "description": "Provenance-trusted project script `mock-probe` that executes the fake media-assembly pipeline: validates cutlist.json against media/index.json and writes the stub render plus its run log.",
+      "shim": {
+        "path": "scripts/mock-probe.ts",
+        "content": "import { defineScript, gezel } from '@bendyline/gezel-sdk';\n\nexport const meta = defineScript({\n  name: 'mock-probe',\n  description:\n    'Fake media-assembly pipeline for this eval: validates cutlist.json against media/index.json, refuses unknown clips and out-of-range timecodes, then writes the stub render to renders/rough-cut.mp4 and its run log to renders/assembly-log.json.',\n  inputs: {},\n  outputs: {\n    log: { type: 'string', description: 'The assembly run log JSON written to renders/assembly-log.json.' },\n  },\n  requires: ['workspace.read', 'workspace.write'],\n});\n\nconst cutlist = JSON.parse(await gezel.fs.read('cutlist.json'));\nconst index = JSON.parse(await gezel.fs.read('media/index.json'));\nif (!Array.isArray(cutlist) || cutlist.length === 0) {\n  throw new Error('cutlist.json must be a non-empty JSON array');\n}\nconst byId = new Map(index.map((clip) => [clip.id, clip]));\nlet total = 0;\nconst assembled = [];\nfor (const row of cutlist) {\n  const clip = byId.get(row.clip);\n  if (!clip) throw new Error(`unknown clip in cutlist: ${row.clip} is not in media/index.json`);\n  if (\n    typeof row.in !== 'number' ||\n    typeof row.out !== 'number' ||\n    row.in < 0 ||\n    row.out <= row.in ||\n    row.out > clip.durationSeconds\n  ) {\n    throw new Error(\n      `timecodes out of range for ${row.clip}: in=${row.in} out=${row.out} duration=${clip.durationSeconds}`,\n    );\n  }\n  if (row.action === 'cut') continue;\n  total += row.out - row.in;\n  assembled.push(row.clip);\n}\nif (assembled.length === 0) throw new Error('every cutlist row was a cut, nothing to assemble');\nconst log = {\n  status: 'ok',\n  engine: 'mock-assemble',\n  segments: assembled.length,\n  clips: assembled,\n  totalDurationSeconds: Math.round(total * 100) / 100,\n};\nawait gezel.fs.write('renders/rough-cut.mp4', `MOCKMP4 rough cut stub\\n${'0'.repeat(2048)}\\n`);\nawait gezel.fs.write('renders/assembly-log.json', `${JSON.stringify(log, null, 2)}\\n`);\ngezel.output({ log: JSON.stringify(log) });\n"
+      }
+    }
+  ],
+  "success": {
+    "summary": "The render and its status-ok log exist because the fake pipeline actually ran, the log's clips all come from the cutlist, and tasks/eval/report.md compares expected versus actual duration with real numbers.",
+    "deliverables": [
+      {
+        "path": "renders/rough-cut.mp4",
+        "kind": "generic-file",
+        "minBytes": 200
+      },
+      {
+        "path": "renders/assembly-log.json",
+        "kind": "json",
+        "checks": [
+          {
+            "kind": "jsonPathEquals",
+            "file": "renders/assembly-log.json",
+            "path": "status",
+            "value": "ok",
+            "label": "the assembly log reports status ok"
+          },
+          {
+            "kind": "valuesSubsetOf",
+            "file": "renders/assembly-log.json",
+            "sourceFiles": [
+              "cutlist.json"
+            ],
+            "pattern": "\"(c\\d{2}-[a-z-]+)\"",
+            "label": "every clip in the log comes from the cutlist"
+          }
+        ]
+      },
+      {
+        "path": "tasks/eval/report.md",
+        "kind": "markdown-report",
+        "minBytes": 600,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "tasks/eval/report.md",
+            "pattern": "(?:^|\\n)#{1,3}\\s+\\S",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/report.md",
+            "pattern": "duration",
+            "flags": "i",
+            "label": "the report talks about duration"
+          },
+          {
+            "kind": "contains",
+            "file": "tasks/eval/report.md",
+            "pattern": "expected|actual",
+            "flags": "i",
+            "label": "expected versus actual is stated"
+          },
+          {
+            "kind": "judge",
+            "file": "tasks/eval/report.md",
+            "rubric": "The report's segment count and duration figures match renders/assembly-log.json, the expected duration was computed from the cutlist before the run, and any mismatch is stated plainly rather than smoothed over.",
+            "sourceFiles": [
+              "renders/assembly-log.json",
+              "cutlist.json"
+            ],
+            "label": "numbers trace to the log"
+          }
+        ]
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "tasks/eval/report.md",
+      "kind": "markdown"
+    },
+    "axes": [
+      {
+        "name": "pipeline-discipline",
+        "description": "The assembly ran through the provided pipeline; the log is evidence of a real run, never hand-written."
+      },
+      {
+        "name": "pre-flight",
+        "description": "The cutlist was validated against the media index before rendering."
+      },
+      {
+        "name": "error-handling",
+        "description": "The run plan names what happens on failure; problems stop the run instead of being papered over."
+      },
+      {
+        "name": "summary-clarity",
+        "description": "The report reads at a glance: what ran, the numbers, what to spot-check."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "run-log grounding",
+    "pre-flight verification",
+    "honest duration comparison"
+  ]
+}

package/data/craftbook-templates/ru/runbook/versions/1.0.2/test.json

@@ -19,9 +19,6 @@
     "worker": {
       "name": "Sanne",
       "role": "SRE Writer"
-    },
-    "craftbookParams": {
-      "workPath": "tasks/eval"
     }
   },
   "mocks": [],