wicked-garden 12.42.0 → 12.43.0

package/.claude-plugin/marketplace.json

@@ -1 +1 @@
-{"name": "wicked-garden", "owner": {"name": "Mike Parcewski"}, "plugins": [{"name": "wicked-garden", "source": "./", "description": "Your coding agent already plans and swarms \u2014 Wicked Garden is the curated toolkit for what it can't: proof-not-claims gates, code links grep can't see, deterministic refactor, cross-session memory, real multi-model second opinions. Don't fight the harness; fill its gaps. The gate needs wicked-vault (a self-contained infra peer, installed directly) and re-derives through garden's built-in engine; estate/bus are opt-in layers (wicked-testing and wicked-brain are retired \u2014 QE ships in-catalog as the qe domain, memory lives in wicked-estate).", "version": "12.42.0"}], "version": "12.42.0"}
+{"name": "wicked-garden", "owner": {"name": "Mike Parcewski"}, "plugins": [{"name": "wicked-garden", "source": "./", "description": "Your coding agent already plans and swarms \u2014 Wicked Garden is the curated toolkit for what it can't: proof-not-claims gates, code links grep can't see, deterministic refactor, cross-session memory, real multi-model second opinions. Don't fight the harness; fill its gaps. The gate needs wicked-vault (a self-contained infra peer, installed directly) and re-derives through garden's built-in engine; estate/bus are opt-in layers (wicked-testing and wicked-brain are retired \u2014 QE ships in-catalog as the qe domain, memory lives in wicked-estate).", "version": "12.43.0"}], "version": "12.43.0"}

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "wicked-garden",
-  "version": "12.42.0",
+  "version": "12.43.0",
   "description": "Your coding agent's harness already plans and swarms; Wicked Garden is the curated toolkit for what it can't do alone. Proof, not claims \u2014 gates re-derive 'done' through the internal loom engine (fail-closed, independently attested via wicked-vault), so a self-asserted pass can't lie its way green. Relationships grep can't see \u2014 the wicked-estate code graph + injected bus/dispatch/capability/archetype edges power blast-radius & lineage. Plus deterministic multi-file refactor (wicked-patch), cross-session memory + knowledge (the mem domain over wicked-estate), real multi-model second opinions (jam:council), portable expertise as on-demand skill-refs, and evidence-gated testing (the in-catalog qe domain). It reads the shape of your work to apply the right rigor \u2014 steering, not a pipeline \u2014 then gets out of the way. The compiler stamps a self-contained evidence gate into any repo that runs with no wicked-garden installed. Don't fight the harness; fill its gaps. The evidence gate requires wicked-vault, a self-contained infra peer wicked-garden installs directly; wicked-bus is an opt-in layer \u2014 install what you'll use, the toolkit works without the rest.",
   "wicked_vault_version": "^0.5.0",
   "wicked_ledger_version": "^0.4.0",

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## [Unreleased]
 
+## [12.43.0] — 2026-10-05
+
+### Fixed
+- **Walkthrough tool: the proof root is what crew's walkthrough view and acceptance read (wicked-garden#1208).** `scripts/demo/walkthrough.mjs record` wrote only `{key, verdict, failed_at_sec}` per chapter, `progress.json` only at the end, its segments under `<root>/segments/`, no planned chapter list and no stitched take — so crew's view (`GET /runs/:id/walkthrough`, WT-W1) showed "Starting the app" for the whole recording, then a failed chapter by its key with no title, no check, no frame and nothing to watch. The tool now writes crew's contract: `chapters.json` (`{key, title, blurb, tags, resets}`) before the app starts; `progress.json` `{state: "starting_app"}` → `{state: "recording", chapter, index, total}` per chapter → `{state: "judging"}`; `result.json` with a top-level `tree` and per chapter `title`, `takes`, `failed_at_sec` (the earliest failing check's `at_sec`, else the take's `failure.json` — DES §4.5), `failed_frame` (the earliest failing on-screen check's frame, else one cut from the take at `failed_at_sec`), `proves`, `legs` and `checks[] {id, kind, sentence, passed, at_sec, evidence[] (root-relative paths), vault_entry, detail}`; the segments under `demo-video/segments/<key>/`, and the take stitched from each chapter's kept video (the good take, else the failed take the recorder kept) into `demo-video/demo.mp4` with `demo-video/chapters.md` markers and `demo-video/poster.jpg`. **The seal is now the form crew recomputes** (`walkthrough-acceptance.ts`, WT-W2): sha256 over `"<sha256 hex>  <posix relative path>\n"` lines in UTF-8 byte order — the tool hashed `"<path>:<sha>\n"` in locale order, so every live take would have been denied as "walkthrough evidence changed after it was sealed". Like crew, the seal refuses a root holding a link or a non-regular entry outside `app/`/`data/`, or a file it cannot read: `record` then writes `INCONCLUSIVE` with `cause: unsealable_root` and prints the seal line with `bundle_sha: null` (crew reads it as not sealed and denies); `seal --root` exits 1 and says why. A chapter whose take failed has its kept video published at `demo-video/segments/<key>/segment.mp4` too (a copy; `guard.json` and `failed-<take>/failure.json` still say it failed), since that is the one path crew reads a chapter as recorded from. A segment key outside `^[a-z0-9][a-z0-9-]*$` (what `record.mjs` and crew accept) is refused as `storyline_refused`, naming the key, instead of being dropped by the view silently. `record.mjs` exports `stitchParts` (the one stitch, also used by its own `--stitch`) and `extractFrame`. Tests: `tests/demo/test_walkthrough.py` (the seal against a Python recompute of crew's form, `chapters.json`, the running progress read mid-take, the key rule, and a PASS+FAIL recording checked field by field).
+- **`_estate_client.py` keeps estate's diagnostics block (wicked-garden#1211).** The shim read `content[0]` of an MCP result only; estate's RetrievalTools put `STALENESS:` (and since estate#242 `CLAMPED:`, plus `LEXICAL-FALLBACK:`) in the second text block, so every skill going through the shim could not tell a stale or clamped answer from a fresh, complete one. `_unwrap_blocks(envelope)` returns `(payload, diagnostics_lines)`, `call_blocks(tool, arguments)` returns `{"result", "diagnostics"}`, and the CLI's `call` action — the command every skill names — prints `{"result": …, "diagnostics": [...]}` so the seat reading stdout sees the marker (additive: `result` is where it always was; a consumer that never reads `diagnostics` sees no change). `call`/`_unwrap` keep their one-value contract. The search skill and its hotspots ref say where the marker now appears. The governed read-verb allowlist the skill lint mirrors (`tests/test_skill_governed_grounding.py`) is unchanged: wicked-core's `ESTATE_READ_VERBS` still lacks `lineage`/`traverse`/`hotspots` (wicked-core#729 open), and garden must not coach a verb the fence denies.
+
+### Changed
+- **Domain vendor: the schema bundle `VERSION` follows the owner to 1.2.1.** wicked-core#699 bumped its governance schema bundle to 1.2.1 (conformance-rules 1.2.0 declares the DC-S1 project-rule fields it already documented). `skills/domain/vendor/VERSION` now matches, so `tests/domain/test_schema_vendor_pin.py` passes again against a current wicked-core checkout. `domain-model.schema.json` is byte-unchanged, and documents still carry `schema_version: "1.0.0"`.
+
 ## [12.42.0] — 2026-10-03
 
 ### Changed
@@ -971,7 +980,8 @@ through `v9.2.18`. Major themes across that span:
 
 For each of those releases, see the corresponding tag in git history.
 
-[Unreleased]: https://github.com/mikeparcewski/wicked-garden/compare/v12.42.0...HEAD
+[Unreleased]: https://github.com/mikeparcewski/wicked-garden/compare/v12.43.0...HEAD
+[12.43.0]: https://github.com/mikeparcewski/wicked-garden/compare/v12.42.0...v12.43.0
 [12.42.0]: https://github.com/mikeparcewski/wicked-garden/compare/v12.41.0...v12.42.0
 [12.41.0]: https://github.com/mikeparcewski/wicked-garden/compare/v12.40.0...v12.41.0
 [12.40.0]: https://github.com/mikeparcewski/wicked-garden/compare/v12.39.0...v12.40.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wicked-garden",
-  "version": "12.42.0",
+  "version": "12.43.0",
   "type": "module",
   "description": "Curated toolkit for what AI coding agents can't do alone: evidence-gated work, codegraph relationships, deterministic multi-file refactor, multi-model second opinions, and cross-session memory. Installs as a Claude Code plugin.",
   "keywords": [

package/scripts/_estate_client.py

@@ -727,31 +727,51 @@ def _rpc(method: str, params: dict, *, timeout: float) -> Optional[dict]:
     return responses.get(2)
 
 
-def _unwrap(envelope: Optional[dict]) -> Optional[Any]:
-    """Extract a tool's payload from an MCP tools/call envelope.
-
-    Estate wraps results as {"result": {"content": [{"type":"text","text": …}],
-    "isError": bool}}. The text is usually the tool's own JSON string, which is
-    parsed and returned; a tool that emits plain (non-JSON) text gets its text
-    handed back verbatim as a str. Returns None on error / isError=true /
-    a malformed envelope shape.
+def _unwrap_blocks(envelope: Optional[dict]) -> "tuple[Optional[Any], list[str]]":
+    """Extract a tool's payload AND its diagnostics from an MCP tools/call envelope.
+
+    Estate wraps results as {"result": {"content": [{"type":"text","text": …}, …],
+    "isError": bool}}. `content[0]` is the tool's own JSON string, which is parsed
+    and returned (a tool that emits plain, non-JSON text gets its text handed back
+    verbatim as a str). `content[1]`, when present, is the diagnostics block the
+    estate MCP server appends (`wicked-estate-mcp/src/lib.rs`, "Append diagnostics
+    as a second text block"): one line each — `STALENESS: …` (W7.4 freshness),
+    `CLAMPED: …` (estate#242, a bound the server lowered), `LEXICAL-FALLBACK: …`.
+    They are returned as a list of lines so a caller can tell a stale or clamped
+    answer from a fresh, complete one (wicked-garden#1211).
+
+    Returns (None, []) on error / isError=true / a malformed envelope shape.
     """
     if not isinstance(envelope, dict):
-        return None
+        return None, []
     result = envelope.get("result")
     if not isinstance(result, dict) or result.get("isError"):
-        return None
+        return None, []
     content = result.get("content")
     if not isinstance(content, list) or not content:
-        return None
+        return None, []
     text = content[0].get("text") if isinstance(content[0], dict) else None
     if text is None:
-        return None
+        return None, []
     try:
-        return json.loads(text)
+        payload: Any = json.loads(text)
     except (json.JSONDecodeError, TypeError):
         # Some tools may return plain text; hand it back verbatim.
-        return text
+        payload = text
+    diagnostics: list[str] = []
+    for block in content[1:]:
+        more = block.get("text") if isinstance(block, dict) else None
+        if isinstance(more, str):
+            diagnostics.extend(line for line in more.split("\n") if line.strip())
+    return payload, diagnostics
+
+
+def _unwrap(envelope: Optional[dict]) -> Optional[Any]:
+    """The payload alone (`content[0]` parsed) — see `_unwrap_blocks` for both blocks.
+
+    Returns None on error / isError=true / a malformed envelope shape.
+    """
+    return _unwrap_blocks(envelope)[0]
 
 
 # ─────────────────────────────────────────────────────────────────────────────
@@ -791,6 +811,24 @@ def call(tool: str, arguments: Optional[dict] = None, timeout: float = 8.0) -> O
         return None
 
 
+def call_blocks(tool: str, arguments: Optional[dict] = None, timeout: float = 8.0) -> Optional[dict]:
+    """Like `call`, but keep the diagnostics block (wicked-garden#1211).
+
+    Returns {"result": <parsed payload>, "diagnostics": [<line>, …]} — the
+    `STALENESS:` / `CLAMPED:` / `LEXICAL-FALLBACK:` lines estate rides in the
+    second content block — or None when estate is unreachable or the tool
+    errored (the same fail-open shape as `call`).
+    """
+    try:
+        env = _rpc("tools/call", {"name": tool, "arguments": arguments or {}}, timeout=timeout)
+    except Exception:
+        return None
+    payload, diagnostics = _unwrap_blocks(env)
+    if payload is None and not diagnostics:
+        return None
+    return {"result": payload, "diagnostics": diagnostics}
+
+
 def call_raw(tool: str, arguments: Optional[dict] = None, timeout: float = 8.0) -> Optional[dict]:
     """Like `call`, but return the full MCP envelope (for callers that need
     `isError` / staleness diagnostics). Fail-open (None)."""
@@ -1053,7 +1091,11 @@ def main(argv: list) -> int:
         if not tool:
             _emit({"error": "call requires {\"tool\": \"<ToolName>\", \"arguments\": {...}}"})
             return 1
-        _emit({"result": call(tool, args.get("arguments", {}))})
+        # Both blocks, in-band (wicked-garden#1211): the seat reading stdout sees the
+        # `STALENESS:` / `CLAMPED:` lines beside the payload, as the MCP caller does.
+        blocks = call_blocks(tool, args.get("arguments", {}))
+        _emit({"result": blocks["result"] if blocks else None,
+               "diagnostics": blocks["diagnostics"] if blocks else []})
     elif action == "propose":
         kind_type = args.get("kind_type")
         payload = args.get("payload")

package/scripts/demo/record.mjs

@@ -79,6 +79,49 @@ export function failedAtInVideo(dir, failedAt, trimStart = SEGMENT_TRIM_START) {
   }
 }
 
+// ---- exported stitch ---------------------------------------------------------------------------
+/**
+ * Join segment videos (same codec, size and frame rate — every take is cut by buildVideo) into one MP4 with
+ * chapter metadata, without re-encoding. `parts` = [{ title, file }] in take order; `workDir` holds the two
+ * ffmpeg list files. Returns the `| m:ss | Title |` marker rows (chapters.md) and the total seconds.
+ */
+export function stitchParts(parts, outFile, { ffmpeg = "ffmpeg", title = "Demo", workDir }) {
+  const ffprobe = ffprobeOf(ffmpeg);
+  const probeSeconds = (file) => {
+    const r = spawnSync(ffprobe, ["-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", file], { encoding: "utf8" });
+    if (r.status !== 0) throw new Error(`ffprobe failed on ${file}: ${r.stderr}`);
+    return Number(r.stdout.trim());
+  };
+  if (!parts.length) throw new Error("no segments recorded yet");
+  fs.mkdirSync(workDir, { recursive: true });
+  const list = path.join(workDir, "concat.txt");
+  fs.writeFileSync(list, parts.map((p) => `file '${p.file.replace(/\\/g, "/").replace(/'/g, "'\\''")}'`).join("\n") + "\n");
+  let at = 0;
+  const meta = [";FFMETADATA1", `title=${String(title).replace(/[=;#\\\n]/g, " ")}`];
+  const rows = ["| Time | Chapter |", "|---|---|"];
+  for (const p of parts) {
+    const d = probeSeconds(p.file);
+    meta.push("[CHAPTER]", "TIMEBASE=1/1000", `START=${Math.round(at * 1000)}`, `END=${Math.round((at + d) * 1000)}`, `title=${String(p.title).replace(/[=;#\\\n]/g, " ")}`);
+    rows.push(`| ${Math.floor(at / 60)}:${String(Math.floor(at % 60)).padStart(2, "0")} | ${p.title} |`);
+    at += d;
+  }
+  const metaFile = path.join(workDir, "chapters.ffmeta");
+  fs.writeFileSync(metaFile, meta.join("\n") + "\n");
+  const r = spawnSync(ffmpeg, ["-y", "-f", "concat", "-safe", "0", "-i", list, "-i", metaFile, "-map", "0", "-map_metadata", "1",
+    "-map_chapters", "1", "-map", "-0:d", "-c", "copy", "-movflags", "+faststart", outFile], { stdio: ["ignore", "ignore", "pipe"] });
+  if (r.status !== 0) throw new Error(`stitch failed: ${r.stderr?.toString().slice(-1500)}`);
+  return { seconds: at, rows };
+}
+
+/** One frame of a video as a JPEG (`atSec` into it); false when ffmpeg could not decode one there. */
+export function extractFrame(video, atSec, outFile, { ffmpeg = "ffmpeg" } = {}) {
+  const r = spawnSync(ffmpeg, ["-y", "-ss", String(Math.max(0, atSec)), "-i", video, "-frames:v", "1", "-q:v", "3", outFile],
+    { stdio: ["ignore", "ignore", "pipe"] });
+  const ok = r.status === 0 && fs.existsSync(outFile) && fs.statSync(outFile).size > 0;
+  if (!ok) fs.rmSync(outFile, { force: true });
+  return ok;
+}
+
 // ---- exported recorder factory -----------------------------------------------------------------
 /**
  * Build a reusable per-segment recorder bound to a story context.
@@ -241,7 +284,6 @@ export function makeSegmentRecorder({
 // ---- CLI entry point (only runs when invoked directly) -----------------------------------------
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
   const FFMPEG = process.env.FFMPEG || "ffmpeg";
-  const FFPROBE = ffprobeOf(FFMPEG);
 
   function usage(msg) {
     if (msg) console.error(`error: ${msg}\n`);
@@ -302,12 +344,6 @@ if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
   const readTimings = (key) => { try { return JSON.parse(fs.readFileSync(path.join(segDir(key), "timings.json"), "utf8")); } catch { return {}; } };
 
   // ---- stitch ----
-  function probeSeconds(file) {
-    const r = spawnSync(FFPROBE, ["-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", file], { encoding: "utf8" });
-    if (r.status !== 0) throw new Error(`ffprobe failed on ${file}: ${r.stderr}`);
-    return Number(r.stdout.trim());
-  }
-
   /** A segment's guard.json (how its last take was recorded), or null when it has none. */
   function readGuard(key) {
     try { return JSON.parse(fs.readFileSync(path.join(segDir(key), "guard.json"), "utf8")); } catch { return null; }
@@ -333,24 +369,10 @@ if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
     refuseFailedTakes();
     const segs = SEGMENTS.filter((s) => fs.existsSync(segVideo(s.key)));
     const missing = SEGMENTS.filter((s) => !fs.existsSync(segVideo(s.key))).map((s) => s.key);
-    if (!segs.length) throw new Error("no segments recorded yet");
-    const list = path.join(SEG_DIR, "concat.txt");
-    fs.writeFileSync(list, segs.map((s) => `file '${segVideo(s.key).replace(/\\/g, "/").replace(/'/g, "'\\''")}'`).join("\n") + "\n");
-    let at = 0;
-    const meta = [";FFMETADATA1", `title=${(story.title || "Demo").replace(/[=;#\\\n]/g, " ")}`];
-    const rows = ["| Time | Chapter |", "|---|---|"];
-    for (const s of segs) {
-      const d = probeSeconds(segVideo(s.key));
-      const title = s.intro ? "Introduction" : s.title;
-      meta.push("[CHAPTER]", "TIMEBASE=1/1000", `START=${Math.round(at * 1000)}`, `END=${Math.round((at + d) * 1000)}`, `title=${title.replace(/[=;#\\\n]/g, " ")}`);
-      rows.push(`| ${Math.floor(at / 60)}:${String(Math.floor(at % 60)).padStart(2, "0")} | ${title} |`);
-      at += d;
-    }
-    fs.writeFileSync(path.join(SEG_DIR, "chapters.ffmeta"), meta.join("\n") + "\n");
-    // Segments share codec, size and frame rate, so they join without re-encoding.
-    const r = spawnSync(FFMPEG, ["-y", "-f", "concat", "-safe", "0", "-i", list, "-i", path.join(SEG_DIR, "chapters.ffmeta"), "-map", "0", "-map_metadata", "1",
-      "-map_chapters", "1", "-map", "-0:d", "-c", "copy", "-movflags", "+faststart", FINAL], { stdio: ["ignore", "ignore", "pipe"] });
-    if (r.status !== 0) throw new Error(`stitch failed: ${r.stderr?.toString().slice(-1500)}`);
+    const { seconds: at, rows } = stitchParts(
+      segs.map((s) => ({ title: s.intro ? "Introduction" : s.title, file: segVideo(s.key) })),
+      FINAL, { ffmpeg: FFMPEG, title: story.title || "Demo", workDir: SEG_DIR },
+    );
     fs.writeFileSync(path.join(OUT, "chapters.md"), rows.join("\n") + "\n");
     fs.writeFileSync(path.join(OUT, "timings.json"), JSON.stringify(Object.fromEntries(SEGMENTS.map((s) => [s.key, readTimings(s.key)])), null, 2));
     // How the stitched segments were recorded: read-only only when every one of them was (a segment recorded

package/scripts/demo/walkthrough.mjs

@@ -7,6 +7,23 @@
 // Required env for record: WICKED_EVIDENCE_ROOT, WICKED_RUN_ID, WICKED_RUN_UNIT, WICKED_TREE
 // Safety: WICKED_WALKTHROUGH_JAIL must be set; without it writes INCONCLUSIVE(unjailed_host) and exits 0.
 //
+// What the proof root holds is ONE contract with crew's walkthrough view and acceptance
+// (wicked-crew `packages/crew/src/api/recording.ts` WT-W1, `qe/walkthrough-acceptance.ts` WT-W2;
+// wicked-garden#1208):
+//   chapters.json   the planned list, written before the app starts: [{key, title, blurb, tags, resets}]
+//   progress.json   while it runs: {state: "starting_app"} → {state: "recording", chapter, index, total}
+//                   → {state: "judging"}; at the end {state: "judging", overall, chapters}
+//   result.json     {overall, tree, cause?, reason?, chapters: [{key, title, verdict, takes, failed_at_sec,
+//                   failed_frame, proves, legs, checks: [{id, kind, sentence, passed, at_sec, evidence[],
+//                   vault_entry, detail}]}]} — evidence[] and failed_frame are root-relative paths
+//   demo-video/     segments/<key>/segment.mp4 (a kept failed take: segments/<key>/failed-<take>/), the
+//                   stitched take demo.mp4, poster.jpg, chapters.md (`| m:ss | Title |` markers)
+//   capture/, vault/, .wicked-qe/, storyline.mjs — the checks' evidence, contracts and ledger
+// The seal's bundle_sha is the form crew recomputes: sha256 over the lines "<sha256 hex>  <posix relative
+// path>\n" of every regular file under the root except top-level app/ and data/, sorted in UTF-8 byte order.
+// A link or a non-regular entry anywhere else, or an unreadable file, makes the root UNSEALABLE (crew refuses
+// it too): result.json becomes INCONCLUSIVE(unsealable_root) and the seal line carries bundle_sha: null.
+//
 // Runtime: wicked-garden run scripts/demo/walkthrough.mjs <action> [args]
 //   Manual alternative: node scripts/demo/walkthrough.mjs <action> [args]
 
@@ -19,7 +36,7 @@ import { pathToFileURL } from "node:url";
 import { createRequire } from "node:module";
 import { tmpdir } from "node:os";
 
-import { makeSegmentRecorder, failedAtInVideo, SEGMENT_TRIM_START } from "./record.mjs";
+import { makeSegmentRecorder, failedAtInVideo, stitchParts, extractFrame, SEGMENT_TRIM_START } from "./record.mjs";
 import { fixtureOrigin } from "./readonly.mjs";
 import { crewRunStamp } from "../qe/lib/crew-run.mjs";
 
@@ -40,7 +57,11 @@ if (action !== "record" && action !== "seal") {
 if (action === "seal") {
   const sealRoot = argVal("--root") ?? process.env.WICKED_EVIDENCE_ROOT;
   if (!sealRoot) { process.stderr.write("seal: --root <dir> required\n"); process.exit(2); }
-  const sha = computeBundleSha(path.resolve(sealRoot));
+  let sha;
+  try { sha = computeBundleSha(path.resolve(sealRoot)); } catch (e) {
+    process.stderr.write(`seal: ${e.message}\n`);
+    process.exit(1);
+  }
   process.stdout.write(JSON.stringify({ bundle_sha: sha }) + "\n");
   process.exit(0);
 }
@@ -83,11 +104,7 @@ if (!process.env.WICKED_WALKTHROUGH_JAIL) {
   const unjailedChapters = tryStaticSegmentKeys(_earlyStoryPath);
   writeResult(ROOT, { overall: "INCONCLUSIVE", cause: "unjailed_host", chapters: unjailedChapters });
   writeProgress(ROOT, { overall: "INCONCLUSIVE", cause: "unjailed_host" });
-  const sha = computeBundleSha(ROOT);
-  process.stdout.write("WALKTHROUGH-SEAL " + JSON.stringify({
-    tree: TREE, storyline_sha: null, contract_shas: {}, bundle_sha: sha,
-    overall: "INCONCLUSIVE", cause: "unjailed_host", chapters: unjailedChapters,
-  }) + "\n");
+  finishWithSeal(ROOT, { tree: TREE, storyline_sha: null, contract_shas: {}, overall: "INCONCLUSIVE", cause: "unjailed_host", chapters: unjailedChapters });
   process.exit(0);
 }
 
@@ -117,27 +134,88 @@ function writeProgress(root, obj) {
   fs.writeFileSync(path.join(root, "progress.json"), JSON.stringify(obj, null, 2) + "\n");
 }
 
-/** sha256 over sorted (rel:sha\n) of every file under root except app/ and data/. */
+/** The storyline's chapters (non-intro segments), in order. */
+function storyChapters(story) {
+  return (Array.isArray(story?.segments) ? story.segments : []).filter((s) => !s.intro);
+}
+
+/** Every chapter as INCONCLUSIVE, with its title — what a refusal after the storyline loaded lists. */
+function chapterStubs(story) {
+  return storyChapters(story).map((s) => ({ key: s.key, title: s.title ?? s.key, verdict: "INCONCLUSIVE" }));
+}
+
+/** The planned list crew's view shows while the tool runs (the demo chapter shape). */
+function writeChaptersJson(root, story) {
+  const strs = (v) => (Array.isArray(v) ? v.filter((x) => typeof x === "string") : []);
+  const chapters = storyChapters(story).map((s) => ({
+    key: s.key,
+    title: typeof s.title === "string" ? s.title : s.key,
+    blurb: typeof s.blurb === "string" ? s.blurb : "",
+    tags: strs(s.tags),
+    resets: strs(s.resets),
+  }));
+  fs.writeFileSync(path.join(root, "chapters.json"), JSON.stringify(chapters, null, 2) + "\n");
+}
+
+/**
+ * The seal crew recomputes at every read (`walkthrough-acceptance.ts` computeBundleSha): sha256 over one line
+ * `<sha256 hex of the file>  <posix relative path>\n` (two spaces, as `sha256sum` prints) per regular file under
+ * the root except the top-level `app/` and `data/` subtrees, sorted in UTF-8 byte order (`LC_ALL=C sort`).
+ * Any other form reads as "walkthrough evidence changed after it was sealed" on crew's side. Like crew, it
+ * refuses (throws, `code: "unsealable_root"`) a link or a non-regular entry outside app/ and data/, and an
+ * entry it cannot read — crew would compute no seal for such a root, so none is claimed here either.
+ */
 function computeBundleSha(root) {
   const pairs = [];
   walkForSeal(root, root, pairs);
-  pairs.sort((a, b) => a[0].localeCompare(b[0]));
+  pairs.sort((a, b) => Buffer.compare(Buffer.from(a[0], "utf8"), Buffer.from(b[0], "utf8")));
   const h = crypto.createHash("sha256");
-  for (const [rel, sha] of pairs) h.update(`${rel}:${sha}\n`);
+  for (const [rel, sha] of pairs) h.update(`${sha}  ${rel}\n`, "utf8");
   return h.digest("hex");
 }
 
+function unsealable(why) {
+  const err = new Error(`unsealable proof root: ${why}`);
+  err.code = "unsealable_root";
+  return err;
+}
+
 function walkForSeal(root, dir, out) {
   let entries;
-  try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch (e) {
+    throw unsealable(`${path.relative(root, dir).split(path.sep).join("/") || "."} could not be read: ${e.message}`);
+  }
   for (const e of entries) {
     const full = path.join(dir, e.name);
-    const rel = path.relative(root, full);
-    const top = rel.split(path.sep)[0];
+    const rel = path.relative(root, full).split(path.sep).join("/");
+    const top = rel.split("/")[0];
     if (top === "app" || top === "data") continue;
+    if (e.isSymbolicLink()) throw unsealable(`the proof root holds a link at ${rel}`);
     if (e.isDirectory()) { walkForSeal(root, full, out); }
-    else if (e.isFile()) { try { out.push([rel, sha256File(full)]); } catch { /* skip unreadable */ } }
+    else if (e.isFile()) {
+      try { out.push([rel, sha256File(full)]); } catch (err) { throw unsealable(`${rel} could not be read: ${err.message}`); }
+    } else throw unsealable(`the proof root holds a non-regular entry at ${rel}`);
+  }
+}
+
+/**
+ * The one way out of `record`: seal the root and print the WALKTHROUGH-SEAL line. When the root cannot be
+ * sealed, result.json and progress.json are rewritten as INCONCLUSIVE(unsealable_root) with every chapter
+ * INCONCLUSIVE and the line carries `bundle_sha: null` — crew reads that as "not sealed" and denies.
+ */
+function finishWithSeal(root, { tree, storyline_sha, contract_shas, overall, cause, reason, chapters }) {
+  let bundle_sha;
+  try { bundle_sha = computeBundleSha(root); } catch (e) {
+    process.stderr.write(`walkthrough: ${e.message}\n`);
+    overall = "INCONCLUSIVE"; cause = "unsealable_root"; reason = e.message; bundle_sha = null;
+    chapters = chapters.map((c) => ({ ...c, verdict: "INCONCLUSIVE" }));
+    writeResult(root, { overall, tree, cause, reason, chapters });
+    writeProgress(root, { overall, cause, chapters: chapters.map(({ key, verdict }) => ({ key, verdict })) });
   }
+  const seal = { tree, storyline_sha, contract_shas, bundle_sha, overall };
+  if (cause) seal.cause = cause;
+  seal.chapters = chapters.map(({ key, verdict }) => ({ key, verdict }));
+  process.stdout.write("WALKTHROUGH-SEAL " + JSON.stringify(seal) + "\n");
 }
 
 async function freePort() {
@@ -502,10 +580,14 @@ function judgeChapter(seg, captures, failedAtSec, { crossCheck = null, vaultEntr
     claims.push({
       id: def.id,
       kind: def.kind,
+      sentence: typeof def.sentence === "string" ? def.sentence : "",
       verdict: claimVerdict,
+      passed: claimVerdict === "PASS" ? true : claimVerdict === "FAIL" ? false : null,
       at_sec: cap?.at_sec ?? null,
       evidence: cap ? evidenceListForCapture(cap, def) : [],
+      evidence_paths: cap ? evidencePathsForCapture(cap, def) : [],
       vault_entry: vaultEntries[def.id] ?? null,
+      detail: claimDetail(claimVerdict, cap, vaultAvailable && !vaultError ? vaultClaimsMap[def.id] : undefined, vaultAvailable, vaultError),
     });
   }
 
@@ -514,7 +596,34 @@ function judgeChapter(seg, captures, failedAtSec, { crossCheck = null, vaultEntr
   if (!vaultAvailable || vaultError) verdict = "INCONCLUSIVE";
   else if (verdict === "PASS" && (crossCheck.overall !== "PASS" || !declared)) verdict = "INCONCLUSIVE";
 
-  return { verdict, claims, failed_at_sec: failedAtSec ?? null, proves: seg.proves ?? [] };
+  // DES §4.5: failed_at_sec is the earliest at_sec among the failing checks, otherwise the take's failure.json.
+  const failingAt = claims.filter((c) => c.verdict === "FAIL" && typeof c.at_sec === "number").map((c) => c.at_sec);
+  const failed_at_sec = failingAt.length ? Math.min(...failingAt) : failedAtSec ?? null;
+
+  return { verdict, claims, failed_at_sec, proves: seg.proves ?? [], legs: Array.isArray(seg.legs) ? seg.legs : [] };
+}
+
+/** One sentence on why a check is not a plain PASS (crew's `checks[].detail`); null for a PASS without a note. */
+function claimDetail(claimVerdict, cap, vaultClaim, vaultAvailable, vaultError) {
+  if (!vaultAvailable) return "vault unavailable: no cross-check could run";
+  if (vaultError) return "vault cross-check returned ERROR";
+  if (cap?._verifier_error) return `collector error: ${cap._verifier_error}`;
+  if (!cap) return "never reached: ctx.check was not called for this id";
+  if (!vaultClaim) return "not recorded in the vault";
+  if (claimVerdict === "PASS") return null;
+  const status = vaultClaim.result ?? vaultClaim.verifier_status ?? claimVerdict;
+  const why = [vaultClaim.reason, vaultClaim.message, vaultClaim.detail].find((v) => typeof v === "string" && v);
+  return why ? `vault ${status}: ${why}` : `vault ${status}`;
+}
+
+/** The root-relative files behind a capture, as crew serves them (`/walkthrough/file?path=`). */
+function evidencePathsForCapture(capture, def) {
+  switch (def.kind) {
+    case "locator": return capture.frame ? [capture.frame] : [];
+    case "probe": return capture.parsed_path ? [capture.parsed_path] : [];
+    case "artifact": return capture.path && capture.sha256 ? [path.posix.join("data", capture.path.split(path.sep).join("/"))] : [];
+    default: return [];
+  }
 }
 
 // ---- manifest writing ----------------------------------------------------------
@@ -749,8 +858,7 @@ async function main() {
   if (!fs.existsSync(storyPath)) {
     writeResult(ROOT, { overall: "INCONCLUSIVE", cause: "storyline_refused", reason: `storyline not found: ${storyPath}`, chapters: [] });
     writeProgress(ROOT, { overall: "INCONCLUSIVE", cause: "storyline_refused" });
-    const sha = computeBundleSha(ROOT);
-    process.stdout.write("WALKTHROUGH-SEAL " + JSON.stringify({ tree: TREE, storyline_sha: null, contract_shas: {}, bundle_sha: sha, overall: "INCONCLUSIVE", cause: "storyline_refused", chapters: [] }) + "\n");
+    finishWithSeal(ROOT, { tree: TREE, storyline_sha: null, contract_shas: {}, overall: "INCONCLUSIVE", cause: "storyline_refused", chapters: [] });
     process.exit(0);
   }
 
@@ -767,48 +875,49 @@ async function main() {
     const refusedChapters = tryStaticSegmentKeys(storyPath);
     writeResult(ROOT, { overall: "INCONCLUSIVE", cause: "storyline_refused", reason: e.message, chapters: refusedChapters });
     writeProgress(ROOT, { overall: "INCONCLUSIVE", cause: "storyline_refused" });
-    const sha = computeBundleSha(ROOT);
-    process.stdout.write("WALKTHROUGH-SEAL " + JSON.stringify({ tree: TREE, storyline_sha: storySha, contract_shas: {}, bundle_sha: sha, overall: "INCONCLUSIVE", cause: "storyline_refused", chapters: refusedChapters }) + "\n");
+    finishWithSeal(ROOT, { tree: TREE, storyline_sha: storySha, contract_shas: {}, overall: "INCONCLUSIVE", cause: "storyline_refused", chapters: refusedChapters });
     process.exit(0);
   }
 
   if (!story?.fixture?.start || !Array.isArray(story?.segments)) {
-    const chapters = Array.isArray(story?.segments)
-      ? story.segments.filter((s) => !s.intro).map((s) => ({ key: s.key, verdict: "INCONCLUSIVE" }))
-      : [];
+    const chapters = chapterStubs(story);
     writeResult(ROOT, { overall: "INCONCLUSIVE", cause: "storyline_refused", reason: "storyline missing fixture.start or segments[]", chapters });
     writeProgress(ROOT, { overall: "INCONCLUSIVE", cause: "storyline_refused" });
-    const sha = computeBundleSha(ROOT);
-    process.stdout.write("WALKTHROUGH-SEAL " + JSON.stringify({ tree: TREE, storyline_sha: storySha, contract_shas: {}, bundle_sha: sha, overall: "INCONCLUSIVE", cause: "storyline_refused", chapters }) + "\n");
+    finishWithSeal(ROOT, { tree: TREE, storyline_sha: storySha, contract_shas: {}, overall: "INCONCLUSIVE", cause: "storyline_refused", chapters: chapters });
     process.exit(0);
   }
 
-  // Chapter keys and check ids become path segments under <root>; refuse anything that could escape.
+  // Chapter keys and check ids become path segments under <root>; refuse anything that could escape. A
+  // segment key is also what record.mjs and crew's view accept (`^[a-z0-9][a-z0-9-]*$`): a key outside it
+  // would be dropped by the view silently, so it is refused here, by name.
+  const SEGMENT_KEY = /^[a-z0-9][a-z0-9-]*$/;
   const SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
   const badIds = [];
   for (const s of story.segments) {
-    if (!s.intro && !SAFE_ID.test(String(s.key ?? ""))) badIds.push(`segment key ${JSON.stringify(s.key)}`);
+    if (!SEGMENT_KEY.test(String(s.key ?? ""))) badIds.push(`segment key ${JSON.stringify(s.key)} (lowercase letters, digits and hyphens only)`);
     for (const c of s.checks ?? []) if (!SAFE_ID.test(String(c.id ?? ""))) badIds.push(`check id ${JSON.stringify(c.id)}`);
   }
   if (badIds.length) {
-    const chapters = story.segments.filter((s) => !s.intro).map((s) => ({ key: s.key, verdict: "INCONCLUSIVE" }));
+    const chapters = chapterStubs(story);
     writeResult(ROOT, { overall: "INCONCLUSIVE", cause: "storyline_refused", reason: `unsafe identifiers: ${badIds.join(", ")}`, chapters });
     writeProgress(ROOT, { overall: "INCONCLUSIVE", cause: "storyline_refused" });
-    const sha = computeBundleSha(ROOT);
-    process.stdout.write("WALKTHROUGH-SEAL " + JSON.stringify({ tree: TREE, storyline_sha: storySha, contract_shas: {}, bundle_sha: sha, overall: "INCONCLUSIVE", cause: "storyline_refused", chapters }) + "\n");
+    finishWithSeal(ROOT, { tree: TREE, storyline_sha: storySha, contract_shas: {}, overall: "INCONCLUSIVE", cause: "storyline_refused", chapters: chapters });
     process.exit(0);
   }
 
+  // The planned list for the view, then the first running state — before anything slow.
+  writeChaptersJson(ROOT, story);
+  writeProgress(ROOT, { state: "starting_app" });
+
   // 2. Git archive WICKED_TREE into <root>/app/
   const appDir = path.join(ROOT, "app");
-  const allChapters = story.segments.filter((s) => !s.intro).map((s) => ({ key: s.key, verdict: "INCONCLUSIVE" }));
+  const allChapters = chapterStubs(story);
   try {
     await gitArchive(TREE, appDir);
   } catch (e) {
     writeResult(ROOT, { overall: "INCONCLUSIVE", cause: "fixture_unavailable", reason: `git archive failed: ${e.message}`, chapters: allChapters });
     writeProgress(ROOT, { overall: "INCONCLUSIVE", cause: "fixture_unavailable" });
-    const sha = computeBundleSha(ROOT);
-    process.stdout.write("WALKTHROUGH-SEAL " + JSON.stringify({ tree: TREE, storyline_sha: storySha, contract_shas: {}, bundle_sha: sha, overall: "INCONCLUSIVE", cause: "fixture_unavailable", chapters: allChapters }) + "\n");
+    finishWithSeal(ROOT, { tree: TREE, storyline_sha: storySha, contract_shas: {}, overall: "INCONCLUSIVE", cause: "fixture_unavailable", chapters: allChapters });
     process.exit(0);
   }
 
@@ -864,16 +973,16 @@ async function main() {
     await Promise.race([pollFixtureReady(story.fixture, fixtureOriginStr), _spawnErrPromise]);
   } catch (e) {
     killFixture();
-    const chapters = story.segments.filter((s) => !s.intro).map((s) => ({ key: s.key, verdict: "INCONCLUSIVE" }));
+    const chapters = chapterStubs(story);
     writeResult(ROOT, { overall: "INCONCLUSIVE", cause: "fixture_unavailable", reason: e.message, chapters });
     writeProgress(ROOT, { overall: "INCONCLUSIVE", cause: "fixture_unavailable" });
-    const sha = computeBundleSha(ROOT);
-    process.stdout.write("WALKTHROUGH-SEAL " + JSON.stringify({ tree: TREE, storyline_sha: storySha, contract_shas: {}, bundle_sha: sha, overall: "INCONCLUSIVE", cause: "fixture_unavailable", chapters }) + "\n");
+    finishWithSeal(ROOT, { tree: TREE, storyline_sha: storySha, contract_shas: {}, overall: "INCONCLUSIVE", cause: "fixture_unavailable", chapters: chapters });
     process.exit(0);
   }
 
   const writableOrigin = fixtureOrigin(fixtureOriginStr);
-  const segmentsDir = path.join(ROOT, "segments");
+  const demoVideoDir = path.join(ROOT, "demo-video");
+  const segmentsDir = path.join(demoVideoDir, "segments");
   const brand = { name: story.title || "Walkthrough", accent: story.brand?.accent ?? "#ee0000", logoSvg: story.brand?.logoSvg ?? "" };
 
   // 4-5. Record each segment with check capture
@@ -968,6 +1077,7 @@ async function main() {
         claims: chapterResults[s.key]?.claims ?? [],
         failed_at_sec: chapterResults[s.key]?.failed_at_sec ?? null,
         proves: s.proves ?? [],
+        legs: Array.isArray(s.legs) ? s.legs : [],
         _cause: cause,
       };
       if (!(s.key in contractShas)) {
@@ -976,10 +1086,12 @@ async function main() {
     }
   }
 
+  const chapterOrder = storyChapters(story).map((s) => s.key);
   for (const seg of story.segments) {
     if (seg.intro) continue;
     consoleErrBuf.current = [];
     if (!chapterCaptures[seg.key]) chapterCaptures[seg.key] = {};
+    writeProgress(ROOT, { state: "recording", chapter: seg.key, index: chapterOrder.indexOf(seg.key) + 1, total: chapterOrder.length });
 
     // Check disk cap before each chapter — a global cause that makes EVERY chapter INCONCLUSIVE
     if (DISK_CAP > 0 && dirSizeBytes(ROOT) > DISK_CAP) {
@@ -1044,6 +1156,18 @@ async function main() {
     );
   }
 
+  writeProgress(ROOT, { state: "judging" });
+
+  // A chapter whose take failed has its video only under failed-<take>/; crew's view reads a chapter as
+  // recorded from demo-video/segments/<key>/segment.mp4 alone, so the kept take is published there too (a
+  // regular-file copy — a link would make the root unsealable). guard.json (failed: true) and
+  // failed-<take>/failure.json keep saying what it is.
+  for (const seg of storyChapters(story)) {
+    const canonical = path.join(segmentsDir, seg.key, "segment.mp4");
+    const kept = path.join(segmentsDir, seg.key, `failed-${takeMap[seg.key] ?? 1}`, "segment.mp4");
+    if (!fs.existsSync(canonical) && fs.existsSync(kept)) fs.copyFileSync(kept, canonical);
+  }
+
   // 6. Validate per-chapter manifests BEFORE writing ledger rows.
   //    Any manifest violation makes the chapter INCONCLUSIVE — including FAIL chapters.
   for (const seg of story.segments.filter((s) => !s.intro)) {
@@ -1122,23 +1246,67 @@ async function main() {
       : "INCONCLUSIVE";
   }
 
-  // 7. Write result.json + progress.json
-  const resultChapters = Object.entries(chapterResults).map(([key, r]) => ({ key, verdict: r.verdict, failed_at_sec: r.failed_at_sec }));
-  const resultObj = { overall: finalOverall, chapters: resultChapters };
+  // 7. The take as crew's view plays it: each chapter's video (the good take, or the failed take published
+  //    above), stitched in order with chapter markers and a poster; a FAIL chapter's frame.
+  const FFMPEG_BIN = process.env.FFMPEG || "ffmpeg";
+  const segVideoOf = (seg) => {
+    const video = path.join(segmentsDir, seg.key, "segment.mp4");
+    return fs.existsSync(video) ? video : null;
+  };
+  const failedFrames = {};
+  for (const seg of storyChapters(story)) {
+    const r = chapterResults[seg.key];
+    if (!r || r.verdict !== "FAIL") continue;
+    // The earliest failing on-screen check already has its frame; otherwise cut one from the take.
+    const failing = r.claims.filter((c) => c.verdict === "FAIL" && typeof c.at_sec === "number").sort((a, b) => a.at_sec - b.at_sec);
+    const withFrame = failing.find((c) => c.evidence_paths.some((e) => e.endsWith(".png")));
+    if (withFrame) { failedFrames[seg.key] = withFrame.evidence_paths.find((e) => e.endsWith(".png")); continue; }
+    const video = segVideoOf(seg);
+    if (video && typeof r.failed_at_sec === "number") {
+      const out = path.join(segmentsDir, seg.key, "failed-frame.jpg");
+      if (extractFrame(video, r.failed_at_sec, out, { ffmpeg: FFMPEG_BIN })) failedFrames[seg.key] = path.relative(ROOT, out).split(path.sep).join("/");
+    }
+  }
+  const parts = story.segments.map((seg) => ({ seg, file: segVideoOf(seg) })).filter((p) => p.file !== null)
+    .map((p) => ({ title: p.seg.intro ? "Introduction" : p.seg.title, file: p.file }));
+  if (parts.length) {
+    try {
+      const { rows } = stitchParts(parts, path.join(demoVideoDir, "demo.mp4"), { ffmpeg: FFMPEG_BIN, title: story.title || "Walkthrough", workDir: segmentsDir });
+      fs.writeFileSync(path.join(demoVideoDir, "chapters.md"), rows.join("\n") + "\n");
+      extractFrame(path.join(demoVideoDir, "demo.mp4"), 1.0, path.join(demoVideoDir, "poster.jpg"), { ffmpeg: FFMPEG_BIN })
+        || extractFrame(path.join(demoVideoDir, "demo.mp4"), 0, path.join(demoVideoDir, "poster.jpg"), { ffmpeg: FFMPEG_BIN });
+    } catch (e) {
+      // The verdicts stand without a stitched take; crew shows no video rather than a wrong one.
+      process.stderr.write(`walkthrough: stitch skipped: ${e.message}\n`);
+      fs.rmSync(path.join(demoVideoDir, "demo.mp4"), { force: true });
+    }
+  }
+
+  // 8. Write result.json + progress.json — the chapters as crew's view reads them.
+  const titleOf = Object.fromEntries(storyChapters(story).map((s) => [s.key, s.title ?? s.key]));
+  const resultChapters = Object.entries(chapterResults).map(([key, r]) => ({
+    key,
+    title: titleOf[key] ?? key,
+    verdict: r.verdict,
+    takes: takeMap[key] ?? 1,
+    failed_at_sec: r.failed_at_sec ?? null,
+    failed_frame: failedFrames[key] ?? null,
+    proves: r.proves ?? [],
+    legs: r.legs ?? [],
+    checks: (r.claims ?? []).map((c) => ({
+      id: c.id, kind: c.kind, sentence: c.sentence, passed: c.passed, at_sec: c.at_sec,
+      evidence: c.evidence_paths, vault_entry: c.vault_entry, detail: c.detail,
+    })),
+  }));
+  const resultObj = { overall: finalOverall, tree: TREE, chapters: resultChapters };
   if (diskCapHit) resultObj.cause = "disk_cap";
   writeResult(ROOT, resultObj);
-  writeProgress(ROOT, { overall: finalOverall, chapters: resultChapters });
-
-  // 8. Print WALKTHROUGH-SEAL
-  const bundleSha = computeBundleSha(ROOT);
-  process.stdout.write("WALKTHROUGH-SEAL " + JSON.stringify({
-    tree: TREE,
-    storyline_sha: storySha,
-    contract_shas: contractShas,
-    bundle_sha: bundleSha,
-    overall: finalOverall,
-    chapters: resultChapters.map(({ key, verdict }) => ({ key, verdict })),
-  }) + "\n");
+  // `state` stays "judging" so crew's view (which reads progress only while the unit is distributed) does not
+  // snap back to "Starting the app" between this write and the unit completing.
+  writeProgress(ROOT, { state: "judging", overall: finalOverall, chapters: resultChapters.map(({ key, verdict }) => ({ key, verdict })) });
+
+  // 9. Print WALKTHROUGH-SEAL
+  finishWithSeal(ROOT, { tree: TREE, storyline_sha: storySha, contract_shas: contractShas, overall: finalOverall, chapters: resultChapters });
 
   killFixture();
   process.exit(0);

package/skills/domain/vendor/README.md

@@ -15,7 +15,7 @@ is history, not the contract.
 
 | | |
 |---|---|
-| Bundle version (`VERSION`) | `1.2.0` — mirrors the owner's `schemas/VERSION` (re-vendored 2026-09-11 from wicked-core `main` @ `e421e87`) |
+| Bundle version (`VERSION`) | `1.2.1` — mirrors the owner's `schemas/VERSION` (synced 2026-10-04 to wicked-core `main` @ `0f419c3`; `domain-model.schema.json` byte-unchanged since the 2026-09-11 re-vendor) |
 | Schema contract version (`$id` / `metadata.schema_version`) | `1.0.0` |
 | Schema `$id` | `https://wickedagile.com/schemas/domain-model/1.0.0` |
 | Canonical source | `wicked-core/crates/wicked-governance/schemas/domain-model.schema.json` |
@@ -26,7 +26,9 @@ is history, not the contract.
 The **bundle** `VERSION` bumps when ANY schema in the owner's 4-file bundle
 changes (the 1.0.0→1.1.0 bump added `conformance-rules.schema.json` to the
 bundle; the 1.1.0→1.2.0 bump was the STEERING unification's optional fields on
-`conformance-rules.schema.json` — this file was byte-untouched both times). The
+`conformance-rules.schema.json`; the 1.2.0→1.2.1 bump was conformance-rules 1.2.0's
+optional DC-S1 project-rule fields, wicked-core#699 — this file was byte-untouched
+every time). The
 **contract version** a document carries (`metadata.schema_version`,
 const-pinned by the schema, matching the `$id` segment) is independent — the
 schemas document that independence themselves. Documents emitted here still carry

package/skills/domain/vendor/VERSION

@@ -1 +1 @@
-1.2.0
+1.2.1

package/skills/search/SKILL.md

@@ -71,7 +71,8 @@ external engine, no Node version floor.
 where you are the agent): the graph is handed to you already indexed and the write CLI is **never**
 yours: never `wicked-estate index`, never `wicked-estate scip|tfstate|import-telemetry|compact|watch`,
 never `wicked-estate clusters --annotate`. A stale graph is *reported* through its
-`STALENESS` marker, not rebuilt. Binary resolution: `WICKED_ESTATE_BIN` env → `PATH` → `~/.local/bin`.
+`STALENESS` marker, not rebuilt — the shim's `call` prints it under `diagnostics`, beside any
+`CLAMPED:` line (a bound the server lowered), so read that list before trusting a result. Binary resolution: `WICKED_ESTATE_BIN` env → `PATH` → `~/.local/bin`.
 
 ## Resolving symbols + the one way to the graph (shared by every action)
 

package/skills/search/refs/hotspots.md

@@ -7,7 +7,8 @@ god-objects, coupling hotspots, and high-impact refactor targets.
 
 ## Instructions
 
-1. **Freshness** — read the `STALENESS` marker the result carries and report it. The graph is
+1. **Freshness** — read the `STALENESS` marker the result carries (the shim's `call` output lists
+   it under `diagnostics`, with any `CLAMPED:` line) and report it. The graph is
    rebuilt by an operator at a terminal (`wicked-estate index <path>` — the search skill's
    `index` action), never from a seat.
 2. **The estate `RankHotspots` tool through the read-only shim** — the one way, on every seat