@sechroom/cli 2026.7.32 → 2026.8.1

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { readFileSync as readFileSync18 } from "fs";
+import { readFileSync as readFileSync19 } from "fs";
 import { Command } from "commander";
 
 // src/auth.ts
@@ -1573,7 +1573,367 @@ import {
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
+// src/executor-run/request.ts
+var AuthExpiredError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AuthExpiredError";
+  }
+};
+var HttpError = class extends Error {
+  constructor(status, method, path, body) {
+    super(`${method} ${path} failed (${status}): ${body}`);
+    this.status = status;
+    this.method = method;
+    this.path = path;
+    this.body = body;
+    this.name = "HttpError";
+  }
+  status;
+  method;
+  path;
+  body;
+};
+function createAuthedRequest(cfg, deps = {}) {
+  const getToken = deps.getToken ?? requireToken;
+  const refresh = deps.refreshToken ?? forceRefreshToken;
+  const doFetch = deps.fetch ?? fetch;
+  const call = async (path, init, token) => doFetch(`${cfg.baseUrl}${path}`, {
+    ...init,
+    headers: {
+      authorization: `Bearer ${token}`,
+      tenant: cfg.tenant,
+      "content-type": "application/json",
+      "x-sechroom-surface": "cli",
+      ...init?.headers
+    }
+  });
+  return async (path, init) => {
+    const method = init?.method ?? "GET";
+    let token;
+    try {
+      token = await getToken(cfg);
+    } catch (error) {
+      throw new AuthExpiredError(
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+    let response = await call(path, init, token);
+    if (response.status === 401) {
+      let fresh;
+      try {
+        fresh = await refresh(cfg);
+      } catch (error) {
+        throw new AuthExpiredError(
+          error instanceof Error ? error.message : String(error)
+        );
+      }
+      response = await call(path, init, fresh);
+      if (response.status === 401)
+        throw new AuthExpiredError(
+          `${method} ${path} still 401 after token refresh \u2014 re-authenticate (\`sechroom login\`).`
+        );
+    }
+    if (!response.ok)
+      throw new HttpError(
+        response.status,
+        method,
+        path,
+        await safeText(response)
+      );
+    return await response.json();
+  };
+}
+async function safeText(response) {
+  try {
+    return await response.text();
+  } catch {
+    return "";
+  }
+}
+
+// src/executor-run/driver.ts
+function verdictFor(terminalStatus) {
+  switch (terminalStatus) {
+    case "completed":
+      return "pass";
+    case "needs_approval":
+    case "cancelled":
+    case "canceled":
+      return "blocked";
+    case "error":
+    default:
+      return "soft-fail";
+  }
+}
+var DEFAULT_TRANSIENT_BACKOFF = {
+  baseMs: 2e3,
+  maxMs: 6e4,
+  maxConsecutive: 20
+};
+var BackoffCeilingExhaustedError = class extends Error {
+  constructor(attempts, lastError) {
+    super(
+      `driven executor exiting: ${attempts} consecutive API interruptions exhausted the backoff ceiling \u2014 last error: ${String(lastError)}`
+    );
+    this.attempts = attempts;
+    this.lastError = lastError;
+    this.name = "BackoffCeilingExhaustedError";
+  }
+  attempts;
+  lastError;
+};
+async function runDriverLoop(ports, options) {
+  const summary = {
+    processed: 0,
+    completed: 0,
+    abandoned: 0
+  };
+  const backoff = { ...DEFAULT_TRANSIENT_BACKOFF, ...options.transientBackoff };
+  let admissionDeferred = false;
+  let consecutiveTransient = 0;
+  const materializationFailures = /* @__PURE__ */ new Map();
+  while (!options.stopping()) {
+    try {
+      if (ports.checkAdmission) {
+        const admission = await ports.checkAdmission();
+        if (!admission.ok) {
+          admissionDeferred = true;
+          ports.log(
+            `ADMISSION DEFERRED \u2014 not claiming: ${admission.reason ?? "usage budget exhausted"}`
+          );
+          await ports.waitForWake(options.pollMs);
+          continue;
+        }
+        if (admissionDeferred) {
+          admissionDeferred = false;
+          ports.log("admission recovered \u2014 resuming claims");
+        }
+      }
+      if (ports.checkRootReady) {
+        const ready = await ports.checkRootReady();
+        if (!ready.ok) {
+          ports.log(
+            `root not ready \u2014 not claiming: ${ready.reason ?? "unknown"}`
+          );
+          await ports.waitForWake(options.pollMs);
+          continue;
+        }
+      }
+      const claim = await ports.claimNext();
+      if (consecutiveTransient > 0) {
+        ports.log(
+          `API reachable again after ${consecutiveTransient} interruption(s) \u2014 resuming`
+        );
+        consecutiveTransient = 0;
+      }
+      if (!claim) {
+        await ports.waitForWake(options.pollMs);
+        continue;
+      }
+      summary.processed++;
+      ports.log(`claimed ${claim.memoryId} (lease ${claim.leaseId})`);
+      let task;
+      try {
+        task = await ports.loadTask(claim.memoryId);
+        materializationFailures.delete(claim.memoryId);
+      } catch (error) {
+        if (error instanceof AuthExpiredError) throw error;
+        const failures = (materializationFailures.get(claim.memoryId) ?? 0) + 1;
+        materializationFailures.set(claim.memoryId, failures);
+        if (failures > backoff.maxConsecutive) {
+          ports.log(
+            `FATAL: task ${claim.memoryId} failed materialization ${backoff.maxConsecutive} consecutive times \u2014 deregistering and exiting (loud). Its lease was never heartbeaten and expires to re-offer within \u2264120s; the task is not lost. Last error: ${String(error)}`
+          );
+          throw new BackoffCeilingExhaustedError(backoff.maxConsecutive, error);
+        }
+        throw error;
+      }
+      const stopHeartbeat = ports.startLeaseHeartbeat(claim);
+      let result;
+      try {
+        result = await ports.runTurn(task, claim);
+      } catch (e) {
+        if (e instanceof AuthExpiredError) throw e;
+        result = { status: "crashed", reason: String(e) };
+      } finally {
+        stopHeartbeat();
+      }
+      if (result.status === "crashed" || result.status === "timeout") {
+        summary.abandoned++;
+        ports.log(
+          `ABANDONED ${claim.memoryId}: ${result.status === "timeout" ? "turn timed out" : result.reason} \u2014 lease will expire and the task re-offers (work may re-run).`
+        );
+      } else {
+        const verdict = verdictFor(result.packet?.terminal_status);
+        let text2 = closeoutText(task, result);
+        if (ports.deliver) {
+          try {
+            const delivery = await ports.deliver(
+              claim,
+              task,
+              verdict,
+              result.status === "completed" ? result.fileChangeCount ?? 0 : 0
+            );
+            ports.log(`delivery: ${delivery.note}`);
+            text2 += `
+
+Delivery: ${delivery.note}`;
+          } catch (e) {
+            if (e instanceof AuthExpiredError) throw e;
+            ports.log(
+              `delivery threw (continuing to completion): ${String(e)}`
+            );
+            text2 += `
+
+Delivery: FAILED unexpectedly (${String(e)}) \u2014 changes remain in the executor root.`;
+          }
+        }
+        try {
+          const done = await ports.completeLease(
+            claim,
+            verdict,
+            text2,
+            `${task.title} \u2014 driven closeout`
+          );
+          summary.completed++;
+          ports.log(
+            `completed ${claim.memoryId} verdict:${verdict} \u2192 ${done.completionMemoryId ?? done.outcome}`
+          );
+        } catch (e) {
+          if (e instanceof AuthExpiredError) throw e;
+          summary.abandoned++;
+          ports.log(
+            `COMPLETE REJECTED for ${claim.memoryId} (${String(e)}) \u2014 task will re-offer; investigate the heartbeat gap.`
+          );
+        }
+      }
+    } catch (e) {
+      if (e instanceof BackoffCeilingExhaustedError) throw e;
+      if (e instanceof AuthExpiredError) throw e;
+      consecutiveTransient++;
+      if (consecutiveTransient > backoff.maxConsecutive) {
+        ports.log(
+          `FATAL: ${backoff.maxConsecutive} consecutive API interruptions exhausted the backoff ceiling \u2014 deregistering and exiting (loud). Last error: ${String(e)}`
+        );
+        throw new BackoffCeilingExhaustedError(backoff.maxConsecutive, e);
+      }
+      const delay = Math.min(
+        backoff.baseMs * 2 ** (consecutiveTransient - 1),
+        backoff.maxMs
+      );
+      ports.log(
+        `API interruption (${consecutiveTransient}/${backoff.maxConsecutive}) \u2014 backing off ${delay}ms and continuing: ${String(e)}`
+      );
+      await ports.waitForWake(delay);
+      continue;
+    }
+    if (options.once) break;
+  }
+  return summary;
+}
+function closeoutText(task, result) {
+  if (!result.packet)
+    return `Driven codex run ended without a sechroom_closeout packet (soft-fail). Last agent message:
+
+${result.lastAgentMessage || "(none)"}`;
+  const evidence = result.packet.evidence?.length ? `
+
+Evidence:
+${result.packet.evidence.map((e) => `- ${e}`).join("\n")}` : "";
+  return `${result.packet.summary}${evidence}
+
+(terminal_status: ${result.packet.terminal_status}; driven by sechroom executor run.)`;
+}
+function startLeaseHeartbeat(beat, log, intervalMs = 3e4, timers = {}) {
+  const schedule = timers.setInterval ?? setInterval;
+  const cancel = timers.clearInterval ?? clearInterval;
+  const timer = schedule(() => {
+    void beat().catch(
+      (e) => log(`lease heartbeat failed (retrying next beat): ${String(e)}`)
+    );
+  }, intervalMs);
+  timer.unref?.();
+  return () => cancel(timer);
+}
+
+// src/executor-run/task-context.ts
+async function materializeClaimedTask(request, memoryId) {
+  const card = await request(
+    `/tasks/${encodeURIComponent(memoryId)}/card`
+  );
+  const pointer = card.contextPack;
+  let components = [];
+  if (pointer && (!pointer.slug || !pointer.version))
+    throw new Error(
+      `task ${card.taskId} carried an incomplete context-pack pointer; refusing delivery`
+    );
+  if (pointer?.slug && pointer.version) {
+    try {
+      const pkg = await request(
+        `/bundles/${encodeURIComponent(pointer.slug)}/versions/${encodeURIComponent(pointer.version)}/package`
+      );
+      components = validatePackage(pkg, pointer.slug, pointer.version);
+    } catch (error) {
+      throw new Error(
+        `task ${card.taskId} context pack ${pointer.slug}@${pointer.version} could not be materialized before delivery: ${String(error)}`,
+        { cause: error }
+      );
+    }
+  }
+  return {
+    title: card.title ?? memoryId,
+    text: assemblePrompt(card, components)
+  };
+}
+function validatePackage(value, expectedSlug, expectedVersion) {
+  if (value === null || typeof value !== "object")
+    throw new Error("package response was not an object");
+  const pkg = value;
+  if (pkg.slug !== expectedSlug || pkg.version !== expectedVersion)
+    throw new Error(
+      `package identity mismatch (expected ${expectedSlug}@${expectedVersion}, received ${String(pkg.slug)}@${String(pkg.version)})`
+    );
+  if (!Array.isArray(pkg.components) || pkg.components.length === 0)
+    throw new Error("package carried no components");
+  for (const [index, component] of pkg.components.entries()) {
+    if (component === null || typeof component !== "object" || typeof component.slug !== "string" || typeof component.sourceId !== "string" || !Number.isInteger(component.sourceVersion) || component.sourceVersion < 1 || typeof component.body !== "string") {
+      throw new Error(
+        `package component ${index + 1} lacked pinned source provenance or body`
+      );
+    }
+  }
+  return pkg.components;
+}
+function assemblePrompt(card, components) {
+  const sections = [
+    `# Task: ${card.title}`,
+    `## Objective
+${card.task.objective}`,
+    `## Acceptance
+${card.task.acceptance}`,
+    `## Boundaries
+${card.task.boundaries}`,
+    `## Closeout
+${card.task.closeout}`
+  ];
+  if (components.length > 0)
+    sections.push(
+      `## Task context
+${components.map(renderComponent).join("\n\n")}`
+    );
+  return sections.join("\n\n");
+}
+function renderComponent(component) {
+  return [
+    `<!-- sechroom-task-context component=${JSON.stringify(component.slug)} id=${JSON.stringify(component.sourceId)} sourceVersion=${component.sourceVersion} -->`,
+    `### ${component.title?.trim() || component.sourceId}`,
+    component.body
+  ].join("\n");
+}
+
 // src/commands/executor.ts
+import { execFileSync } from "child_process";
 import { existsSync as existsSync8, mkdirSync as mkdirSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync8 } from "fs";
 import { dirname as dirname8, join as join11 } from "path";
 
@@ -1732,95 +2092,16 @@ function ensureSemIgnored(semPath) {
       appendFileSync(target.path, `${sep2}${STATE_DIR_IGNORE}
 `);
     } else {
-      writeFileSync4(target.path, `${STATE_DIR_IGNORE}
-`);
-    }
-  } catch {
-  }
-}
-
-// src/commands/executor-run.ts
-import { join as join10, resolve as resolve3 } from "path";
-
-// src/executor-run/request.ts
-var AuthExpiredError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "AuthExpiredError";
-  }
-};
-var HttpError = class extends Error {
-  constructor(status, method, path, body) {
-    super(`${method} ${path} failed (${status}): ${body}`);
-    this.status = status;
-    this.method = method;
-    this.path = path;
-    this.body = body;
-    this.name = "HttpError";
-  }
-  status;
-  method;
-  path;
-  body;
-};
-function createAuthedRequest(cfg, deps = {}) {
-  const getToken = deps.getToken ?? requireToken;
-  const refresh = deps.refreshToken ?? forceRefreshToken;
-  const doFetch = deps.fetch ?? fetch;
-  const call = async (path, init, token) => doFetch(`${cfg.baseUrl}${path}`, {
-    ...init,
-    headers: {
-      authorization: `Bearer ${token}`,
-      tenant: cfg.tenant,
-      "content-type": "application/json",
-      "x-sechroom-surface": "cli",
-      ...init?.headers
-    }
-  });
-  return async (path, init) => {
-    const method = init?.method ?? "GET";
-    let token;
-    try {
-      token = await getToken(cfg);
-    } catch (error) {
-      throw new AuthExpiredError(
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-    let response = await call(path, init, token);
-    if (response.status === 401) {
-      let fresh;
-      try {
-        fresh = await refresh(cfg);
-      } catch (error) {
-        throw new AuthExpiredError(
-          error instanceof Error ? error.message : String(error)
-        );
-      }
-      response = await call(path, init, fresh);
-      if (response.status === 401)
-        throw new AuthExpiredError(
-          `${method} ${path} still 401 after token refresh \u2014 re-authenticate (\`sechroom login\`).`
-        );
-    }
-    if (!response.ok)
-      throw new HttpError(
-        response.status,
-        method,
-        path,
-        await safeText(response)
-      );
-    return await response.json();
-  };
-}
-async function safeText(response) {
-  try {
-    return await response.text();
+      writeFileSync4(target.path, `${STATE_DIR_IGNORE}
+`);
+    }
   } catch {
-    return "";
   }
 }
 
+// src/commands/executor-run.ts
+import { join as join10, resolve as resolve3 } from "path";
+
 // src/executor-run/usage.ts
 import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync5 } from "fs";
 import { dirname as dirname3 } from "path";
@@ -2141,7 +2422,7 @@ var SUCCESS = /* @__PURE__ */ new Set(["Claimed", "AlreadyHeld"]);
 var CONTENTION_STATUSES = /* @__PURE__ */ new Set([409, 410]);
 async function claimNextTask(deps) {
   const { request, executorInstanceId } = deps;
-  const sleep = deps.sleep ?? ((ms) => new Promise((resolve8) => setTimeout(resolve8, ms)));
+  const sleep = deps.sleep ?? ((ms) => new Promise((resolve9) => setTimeout(resolve9, ms)));
   const idempotencyKey = deps.idempotencyKey ?? ((offer) => `executor-run:${offer.generationId}`);
   const tokenVersion = deps.tokenVersion ?? 1;
   const log = deps.log ?? (() => {
@@ -2471,12 +2752,12 @@ var CodexAppServer = class {
       ))
         fileChangeCount += 1;
     };
-    const terminal = new Promise((resolve8) => {
+    const terminal = new Promise((resolve9) => {
       this.onServerRequest = (msg) => {
         const method = msg.method ?? "";
         if (terminalMethod(method)) {
           this.respond(msg.id, {});
-          resolve8("completed");
+          resolve9("completed");
           return;
         }
         if (method === "item/tool/call") {
@@ -2663,14 +2944,14 @@ var CodexAppServer = class {
     if (!child || this.exited)
       return Promise.reject(new Error("codex app-server is not running"));
     const id = this.nextId++;
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve9, reject) => {
       let timer;
       const clearTimer = () => {
         if (timer) clearTimeout(timer);
       };
       const resolvePending = (value) => {
         clearTimer();
-        resolve8(value);
+        resolve9(value);
       };
       const rejectPending = (error) => {
         clearTimer();
@@ -2736,10 +3017,10 @@ var CodexAppServer = class {
     if (parsed) this.options.onRateLimits?.(parsed);
   }
   exitAsResult() {
-    return new Promise((resolve8) => {
+    return new Promise((resolve9) => {
       this.child?.once(
         "exit",
-        (code) => resolve8(`app-server exited (${code ?? "signal"})`)
+        (code) => resolve9(`app-server exited (${code ?? "signal"})`)
       );
     });
   }
@@ -2765,7 +3046,7 @@ function terminalMethod(method) {
 }
 function timeout(ms) {
   return new Promise(
-    (resolve8) => setTimeout(() => resolve8("timeout"), ms).unref?.()
+    (resolve9) => setTimeout(() => resolve9("timeout"), ms).unref?.()
   );
 }
 function dynamicToolDefinitions() {
@@ -2805,12 +3086,12 @@ function dynamicToolDefinitions() {
 // src/executor-run/delivery.ts
 import { execFile as execFile2 } from "child_process";
 function createGitRunner(rootDir) {
-  return (bin, args) => new Promise((resolve8) => {
+  return (bin, args) => new Promise((resolve9) => {
     execFile2(
       bin,
       bin === "git" ? ["-C", rootDir, ...args] : args,
       { cwd: rootDir, maxBuffer: 10 * 1024 * 1024 },
-      (error, stdout, stderr) => resolve8({
+      (error, stdout, stderr) => resolve9({
         ok: !error,
         stdout: String(stdout),
         stderr: String(stderr)
@@ -2955,194 +3236,6 @@ function firstLine(text2) {
   return text2.trim().split("\n")[0] ?? "";
 }
 
-// src/executor-run/driver.ts
-function verdictFor(terminalStatus) {
-  switch (terminalStatus) {
-    case "completed":
-      return "pass";
-    case "needs_approval":
-    case "cancelled":
-    case "canceled":
-      return "blocked";
-    case "error":
-    default:
-      return "soft-fail";
-  }
-}
-var DEFAULT_TRANSIENT_BACKOFF = {
-  baseMs: 2e3,
-  maxMs: 6e4,
-  maxConsecutive: 20
-};
-var BackoffCeilingExhaustedError = class extends Error {
-  constructor(attempts, lastError) {
-    super(
-      `driven executor exiting: ${attempts} consecutive API interruptions exhausted the backoff ceiling \u2014 last error: ${String(lastError)}`
-    );
-    this.attempts = attempts;
-    this.lastError = lastError;
-    this.name = "BackoffCeilingExhaustedError";
-  }
-  attempts;
-  lastError;
-};
-async function runDriverLoop(ports, options) {
-  const summary = {
-    processed: 0,
-    completed: 0,
-    abandoned: 0
-  };
-  const backoff = { ...DEFAULT_TRANSIENT_BACKOFF, ...options.transientBackoff };
-  let admissionDeferred = false;
-  let consecutiveTransient = 0;
-  while (!options.stopping()) {
-    try {
-      if (ports.checkAdmission) {
-        const admission = await ports.checkAdmission();
-        if (!admission.ok) {
-          admissionDeferred = true;
-          ports.log(
-            `ADMISSION DEFERRED \u2014 not claiming: ${admission.reason ?? "usage budget exhausted"}`
-          );
-          await ports.waitForWake(options.pollMs);
-          continue;
-        }
-        if (admissionDeferred) {
-          admissionDeferred = false;
-          ports.log("admission recovered \u2014 resuming claims");
-        }
-      }
-      if (ports.checkRootReady) {
-        const ready = await ports.checkRootReady();
-        if (!ready.ok) {
-          ports.log(
-            `root not ready \u2014 not claiming: ${ready.reason ?? "unknown"}`
-          );
-          await ports.waitForWake(options.pollMs);
-          continue;
-        }
-      }
-      const claim = await ports.claimNext();
-      if (consecutiveTransient > 0) {
-        ports.log(
-          `API reachable again after ${consecutiveTransient} interruption(s) \u2014 resuming`
-        );
-        consecutiveTransient = 0;
-      }
-      if (!claim) {
-        await ports.waitForWake(options.pollMs);
-        continue;
-      }
-      summary.processed++;
-      ports.log(`claimed ${claim.memoryId} (lease ${claim.leaseId})`);
-      const task = await ports.loadTask(claim.memoryId);
-      const stopHeartbeat = ports.startLeaseHeartbeat(claim);
-      let result;
-      try {
-        result = await ports.runTurn(task, claim);
-      } catch (e) {
-        if (e instanceof AuthExpiredError) throw e;
-        result = { status: "crashed", reason: String(e) };
-      } finally {
-        stopHeartbeat();
-      }
-      if (result.status === "crashed" || result.status === "timeout") {
-        summary.abandoned++;
-        ports.log(
-          `ABANDONED ${claim.memoryId}: ${result.status === "timeout" ? "turn timed out" : result.reason} \u2014 lease will expire and the task re-offers (work may re-run).`
-        );
-      } else {
-        const verdict = verdictFor(result.packet?.terminal_status);
-        let text2 = closeoutText(task, result);
-        if (ports.deliver) {
-          try {
-            const delivery = await ports.deliver(
-              claim,
-              task,
-              verdict,
-              result.status === "completed" ? result.fileChangeCount ?? 0 : 0
-            );
-            ports.log(`delivery: ${delivery.note}`);
-            text2 += `
-
-Delivery: ${delivery.note}`;
-          } catch (e) {
-            if (e instanceof AuthExpiredError) throw e;
-            ports.log(
-              `delivery threw (continuing to completion): ${String(e)}`
-            );
-            text2 += `
-
-Delivery: FAILED unexpectedly (${String(e)}) \u2014 changes remain in the executor root.`;
-          }
-        }
-        try {
-          const done = await ports.completeLease(
-            claim,
-            verdict,
-            text2,
-            `${task.title} \u2014 driven closeout`
-          );
-          summary.completed++;
-          ports.log(
-            `completed ${claim.memoryId} verdict:${verdict} \u2192 ${done.completionMemoryId ?? done.outcome}`
-          );
-        } catch (e) {
-          if (e instanceof AuthExpiredError) throw e;
-          summary.abandoned++;
-          ports.log(
-            `COMPLETE REJECTED for ${claim.memoryId} (${String(e)}) \u2014 task will re-offer; investigate the heartbeat gap.`
-          );
-        }
-      }
-    } catch (e) {
-      if (e instanceof AuthExpiredError) throw e;
-      consecutiveTransient++;
-      if (consecutiveTransient > backoff.maxConsecutive) {
-        ports.log(
-          `FATAL: ${backoff.maxConsecutive} consecutive API interruptions exhausted the backoff ceiling \u2014 deregistering and exiting (loud). Last error: ${String(e)}`
-        );
-        throw new BackoffCeilingExhaustedError(backoff.maxConsecutive, e);
-      }
-      const delay = Math.min(
-        backoff.baseMs * 2 ** (consecutiveTransient - 1),
-        backoff.maxMs
-      );
-      ports.log(
-        `API interruption (${consecutiveTransient}/${backoff.maxConsecutive}) \u2014 backing off ${delay}ms and continuing: ${String(e)}`
-      );
-      await ports.waitForWake(delay);
-      continue;
-    }
-    if (options.once) break;
-  }
-  return summary;
-}
-function closeoutText(task, result) {
-  if (!result.packet)
-    return `Driven codex run ended without a sechroom_closeout packet (soft-fail). Last agent message:
-
-${result.lastAgentMessage || "(none)"}`;
-  const evidence = result.packet.evidence?.length ? `
-
-Evidence:
-${result.packet.evidence.map((e) => `- ${e}`).join("\n")}` : "";
-  return `${result.packet.summary}${evidence}
-
-(terminal_status: ${result.packet.terminal_status}; driven by sechroom executor run.)`;
-}
-function startLeaseHeartbeat(beat, log, intervalMs = 3e4, timers = {}) {
-  const schedule = timers.setInterval ?? setInterval;
-  const cancel = timers.clearInterval ?? clearInterval;
-  const timer = schedule(() => {
-    void beat().catch(
-      (e) => log(`lease heartbeat failed (retrying next beat): ${String(e)}`)
-    );
-  }, intervalMs);
-  timer.unref?.();
-  return () => cancel(timer);
-}
-
 // src/executor-run/fleet.ts
 import { spawn as spawn2 } from "child_process";
 import { createHash as createHash2 } from "crypto";
@@ -4616,6 +4709,7 @@ function registerTelemetry(program2) {
       const cwd = input.cwd ?? process.cwd();
       const binding = findBinding(cwd);
       if (!binding) return process.exit(0);
+      const cfg = resolveConfig(cmd.optsWithGlobals());
       const usage = input.transcript_path ? parseTranscript(input.transcript_path) : null;
       const configRoot = resolveClaudeConfigRoot(
         process.env.CLAUDE_CONFIG_DIR,
@@ -4628,7 +4722,10 @@ function registerTelemetry(program2) {
         configRoot
       );
       if (events.length === 0) return process.exit(0);
-      const cfg = resolveConfig(cmd.optsWithGlobals());
+      const taskId = await taskIdForHook(cfg, binding);
+      if (!taskId) {
+        for (const event of events) delete event.taskId;
+      }
       await postTelemetry(cfg, binding.decompositionId, events);
       return process.exit(0);
     } catch {
@@ -4723,7 +4820,20 @@ function findBinding(start) {
           readFileSync6(path, "utf8")
         );
         if (b.decompositionId && b.taskId)
-          return { decompositionId: b.decompositionId, taskId: b.taskId };
+          return {
+            decompositionId: b.decompositionId,
+            taskId: b.taskId,
+            activeTaskCheckedAt: b.activeTaskCheckedAt,
+            lifecycleWarning: b.lifecycleWarning,
+            path
+          };
+        if (b.decompositionId && b.invalidatedTaskId && b.invalidatedReason === "terminal-task")
+          return {
+            decompositionId: b.decompositionId,
+            invalidatedTaskId: b.invalidatedTaskId,
+            invalidatedReason: b.invalidatedReason,
+            path
+          };
       } catch {
       }
       return null;
@@ -4733,6 +4843,109 @@ function findBinding(start) {
     dir = parent;
   }
 }
+var TERMINAL_TASK_STATUSES = /* @__PURE__ */ new Set([
+  "done",
+  "superseded",
+  "cancelled",
+  "abandoned-by-policy"
+]);
+var ACTIVE_TASK_CACHE_TTL_MS = 5 * 60 * 1e3;
+function isTerminalTaskStatus(status) {
+  return TERMINAL_TASK_STATUSES.has(status);
+}
+async function taskIdForHook(cfg, binding) {
+  if (!binding.taskId) return void 0;
+  if (hasFreshActiveTaskCache(binding)) return binding.taskId;
+  const verdict = await getTaskLifecycleVerdict(cfg, binding);
+  if (verdict === "active") {
+    cacheActiveBindingIfCurrent(binding);
+    return binding.taskId;
+  }
+  if (verdict === "indeterminate") return binding.taskId;
+  invalidateBindingIfCurrent(binding);
+  return void 0;
+}
+function hasFreshActiveTaskCache(binding) {
+  if (!binding.activeTaskCheckedAt) return false;
+  const checkedAt = Date.parse(binding.activeTaskCheckedAt);
+  return !Number.isNaN(checkedAt) && Date.now() - checkedAt >= 0 && Date.now() - checkedAt < ACTIVE_TASK_CACHE_TTL_MS;
+}
+async function getTaskLifecycleVerdict(cfg, binding) {
+  try {
+    const client = await makeClient(cfg);
+    const result = await client.GET("/tasks/{id}/card", {
+      params: { path: { id: binding.taskId } }
+    });
+    if (result.response.status === 403) {
+      if (binding.lifecycleWarning !== "insufficient-permission") {
+        process.stderr.write(
+          "lifecycle check unavailable: insufficient permission \u2014 server door remains authoritative\n"
+        );
+        markLifecycleWarningIfCurrent(binding);
+      }
+      return "indeterminate";
+    }
+    if (!result.response.ok || !result.data) return "indeterminate";
+    return isTerminalTaskStatus(result.data.status) ? "terminal" : "active";
+  } catch {
+    return "indeterminate";
+  }
+}
+function markLifecycleWarningIfCurrent(binding) {
+  try {
+    const current = JSON.parse(
+      readFileSync6(binding.path, "utf8")
+    );
+    if (current.decompositionId !== binding.decompositionId || current.taskId !== binding.taskId)
+      return;
+    const warned = {
+      decompositionId: binding.decompositionId,
+      taskId: binding.taskId,
+      activeTaskCheckedAt: current.activeTaskCheckedAt,
+      lifecycleWarning: "insufficient-permission"
+    };
+    writeFileSync7(binding.path, JSON.stringify(warned, null, 2) + "\n");
+  } catch {
+  }
+}
+function cacheActiveBindingIfCurrent(binding) {
+  try {
+    const current = JSON.parse(
+      readFileSync6(binding.path, "utf8")
+    );
+    if (current.decompositionId !== binding.decompositionId || current.taskId !== binding.taskId)
+      return;
+    const cached = {
+      decompositionId: binding.decompositionId,
+      taskId: binding.taskId,
+      activeTaskCheckedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    writeFileSync7(binding.path, JSON.stringify(cached, null, 2) + "\n");
+  } catch {
+  }
+}
+function invalidateBindingIfCurrent(binding) {
+  try {
+    const current = JSON.parse(
+      readFileSync6(binding.path, "utf8")
+    );
+    if (current.decompositionId !== binding.decompositionId || current.taskId !== binding.taskId)
+      return;
+    writeFileSync7(
+      binding.path,
+      JSON.stringify(
+        {
+          decompositionId: binding.decompositionId,
+          invalidatedTaskId: binding.taskId,
+          invalidatedReason: "terminal-task"
+        },
+        null,
+        2
+      ) + "\n"
+    );
+  } catch {
+  }
+}
 function parseTranscript(path) {
   if (!existsSync7(path)) return null;
   let tokensIn = 0;
@@ -5158,11 +5371,16 @@ function registerExecutorRunCommand(executor) {
       // Driver-side claim exclusion: the flag (repeatable) overlays the installed
       // state (flag wins when present), else the persisted excludeTags carry through.
       // Local-only — never sent in the advertisement (server schema untouched).
-      excludeTags: opts.excludeTag ?? located.state.excludeTags
+      excludeTags: opts.excludeTag ?? located.state.excludeTags,
+      modelId: opts.model ? String(opts.model) : located.state.modelId,
+      runtimeVersion: detectRuntimeVersion("codex", String(opts.codexBin)) ?? located.state.runtimeVersion
     };
     const heartbeatMs = Number.parseInt(String(opts.heartbeatInterval), 10) * 1e3;
-    if (heartbeatMs >= 12e4)
-      fail("--heartbeat-interval must be shorter than the 120s lease TTL");
+    const taskLeaseTtlMs = (located.state.taskLeaseTtlSeconds ?? 120) * 1e3;
+    if (heartbeatMs >= taskLeaseTtlMs)
+      fail(
+        `--heartbeat-interval must be shorter than the ${taskLeaseTtlMs / 1e3}s task lease TTL`
+      );
     const usageReserve = Number.parseFloat(String(opts.usageReserve));
     if (!Number.isFinite(usageReserve) || usageReserve < 0 || usageReserve >= 100)
       fail("--usage-reserve must be a percent in [0, 100)");
@@ -5231,8 +5449,8 @@ function registerExecutorRunCommand(executor) {
     await appServer.start();
     log(`codex app-server up (${String(opts.codexBin)})`);
     let signalCapacityTerminal;
-    const capacityTerminal = new Promise((resolve8) => {
-      signalCapacityTerminal = resolve8;
+    const capacityTerminal = new Promise((resolve9) => {
+      signalCapacityTerminal = resolve9;
     });
     let stopCapacityCapture = () => {
     };
@@ -5252,8 +5470,8 @@ function registerExecutorRunCommand(executor) {
     process.once("SIGTERM", requestStop);
     let wake = () => {
     };
-    const wakeSignal = () => new Promise((resolve8) => {
-      wake = resolve8;
+    const wakeSignal = () => new Promise((resolve9) => {
+      wake = resolve9;
     });
     let connStop = async () => {
     };
@@ -5313,7 +5531,7 @@ function registerExecutorRunCommand(executor) {
         return admission;
       },
       claimNext: async () => await fleetInbox.waitForClaim() ?? await claimNext(request, instance.id, log, excludeTags, skipLog),
-      loadTask: (memoryId) => loadTask(request, memoryId, log),
+      loadTask: (memoryId) => materializeClaimedTask(request, memoryId),
       startLeaseHeartbeat: (claim) => startLeaseHeartbeat(
         () => request(
           `/me/executor-task-leases/${encodeURIComponent(claim.leaseId)}/heartbeat`,
@@ -5372,8 +5590,8 @@ function registerExecutorRunCommand(executor) {
       ),
       log,
       waitForWake: (ms) => Promise.race([
-        new Promise((resolve8) => {
-          setTimeout(resolve8, ms).unref?.();
+        new Promise((resolve9) => {
+          setTimeout(resolve9, ms).unref?.();
         }),
         wakeSignal()
       ])
@@ -5521,49 +5739,9 @@ async function claimNext(request, instanceId, log, excludeTags, skipLog) {
     leaseId: claimed.leaseId,
     claimToken: claimed.claimToken,
     tokenVersion: claimed.tokenVersion,
-    decompositionId: claimed.decompositionId
-  };
-}
-async function loadTask(request, memoryId, log) {
-  const card = await request(
-    `/tasks/${encodeURIComponent(memoryId)}/card`
-  );
-  let packText = "";
-  const pointer = card.contextPack;
-  if (pointer?.slug && pointer.version) {
-    try {
-      const pkg = await request(
-        `/bundles/${encodeURIComponent(pointer.slug)}/versions/${encodeURIComponent(pointer.version)}/package`
-      );
-      packText = (pkg.components ?? []).map((c) => `### ${c.title ?? "context"}
-${c.body}`).join("\n\n");
-    } catch (error) {
-      log(
-        `warning: task ${card.taskId} context pack (${pointer.slug}@${pointer.version}) failed to resolve (${String(error)}) \u2014 running on card body only`
-      );
-    }
-  }
-  return {
-    title: card.title ?? memoryId,
-    text: assemblePrompt(card, packText)
+    decompositionId: claimed.decompositionId
   };
 }
-function assemblePrompt(card, packText) {
-  const sections = [
-    `# Task: ${card.title}`,
-    `## Objective
-${card.task.objective}`,
-    `## Acceptance
-${card.task.acceptance}`,
-    `## Boundaries
-${card.task.boundaries}`,
-    `## Closeout
-${card.task.closeout}`
-  ];
-  if (packText) sections.push(`## Context pack
-${packText}`);
-  return sections.join("\n\n");
-}
 function taskPrompt(task) {
   return `You are a driven executor working ONE dispatched Work Layer task.
 
@@ -5590,6 +5768,10 @@ function executorRegistrationInput(state, deliverySubscriptionId, activationMode
     deliverySubscriptionId,
     connectorId: state.connectorId,
     claimedCapabilityKeys: state.capabilityKeys,
+    taskLeaseTtlSeconds: state.taskLeaseTtlSeconds ?? 120,
+    modelId: state.modelId ?? null,
+    runtimeVersion: state.runtimeVersion ?? null,
+    effortLabel: state.effortLabel ?? null,
     claimPolicy: parseClaimPolicy(state.claimPolicy),
     claimTags: state.claimTags ?? [],
     toolSetRef: null,
@@ -5647,6 +5829,11 @@ function registerExecutor(program2) {
     "SignalR delivery binding name",
     "executor-dispatch"
   ).option("--ttl <seconds>", "Advertisement TTL (30-600)", parseInteger, 600).option(
+    "--task-lease-ttl <seconds>",
+    "Task lease TTL (60-86400)",
+    parseInteger,
+    120
+  ).option("--model-id <id>", "Driver model identity").option("--effort-label <label>", "Optional driver effort label").option(
     "--refresh-after <seconds>",
     "Minimum age before a hook refreshes",
     parseInteger,
@@ -5716,6 +5903,8 @@ function registerExecutor(program2) {
     const sem = readSem();
     const checkout = sem ? dirname8(dirname8(sem.path)) : process.cwd();
     const statePath = join11(checkout, ".sechroom", EXECUTOR_STATE);
+    const previous = existsSync8(statePath) ? JSON.parse(readFileSync7(statePath, "utf8")) : void 0;
+    const canUpdateExisting = previous?.instanceId && previous.instanceKey === instanceKey && previous.laneId === laneId && previous.runtime === (runtime.toLowerCase() === "codex" ? "codex" : "claude-code") && previous.relayId === opts.relay && previous.connectorId === connector;
     const state = {
       schemaVersion: 1,
       instanceKey,
@@ -5723,13 +5912,18 @@ function registerExecutor(program2) {
       runtime: runtime.toLowerCase() === "codex" ? "codex" : "claude-code",
       connectorId: connector,
       capabilityKeys: capabilities ?? [],
+      taskLeaseTtlSeconds: opts.taskLeaseTtl,
+      modelId: opts.modelId,
+      effortLabel: opts.effortLabel,
       claimPolicy: (opts.claimPolicy ?? "open").toLowerCase() === "restricted" ? "restricted" : "open",
       claimTags: opts.claimTag ?? [],
       excludeTags: opts.excludeTag ?? [],
       relayId: opts.relay,
       subscriptionName: opts.subscriptionName,
       ttlSeconds: opts.ttl,
-      refreshAfterSeconds: opts.refreshAfter
+      refreshAfterSeconds: opts.refreshAfter,
+      instanceId: canUpdateExisting ? previous.instanceId : void 0,
+      runtimeVersion: canUpdateExisting ? previous.runtimeVersion : void 0
     };
     if (!opts.dryRun) {
       mkdirSync9(dirname8(statePath), { recursive: true });
@@ -5767,6 +5961,7 @@ function registerExecutor(program2) {
     if (state.instanceId && age < state.refreshAfterSeconds * 1e3) return;
     const cfg = resolveConfig(cmd.optsWithGlobals());
     try {
+      refreshRuntimeVersion(state);
       await ensureExecutorInstance(cfg, { state, path });
     } catch {
     }
@@ -5853,7 +6048,12 @@ function registerExecutor(program2) {
     "--activation-mode <mode>",
     "attached | detached \u2014 detached marks a fleet run as a service that outlives its shell (default attached)",
     "attached"
-  ).option("--ttl <seconds>", "Advertisement TTL (30-600)", parseInteger, 120).action(async (opts, cmd) => {
+  ).option("--ttl <seconds>", "Advertisement TTL (30-600)", parseInteger, 120).option(
+    "--task-lease-ttl <seconds>",
+    "Task lease TTL (60-86400)",
+    parseInteger,
+    120
+  ).option("--model-id <id>", "Driver model identity").option("--effort-label <label>", "Optional driver effort label").action(async (opts, cmd) => {
     const cfg = resolveConfig(cmd.optsWithGlobals());
     const subscription = await api(
       cfg,
@@ -5883,6 +6083,12 @@ function registerExecutor(program2) {
           deliverySubscriptionId: subscription.id,
           connectorId: opts.connector,
           claimedCapabilityKeys: opts.capability ?? [],
+          taskLeaseTtlSeconds: opts.taskLeaseTtl,
+          modelId: opts.modelId ?? null,
+          runtimeVersion: detectRuntimeVersion(
+            String(opts.runtime).toLowerCase() === "codex" ? "codex" : "claude-code"
+          ),
+          effortLabel: opts.effortLabel ?? null,
           claimPolicy: parseClaimPolicy(opts.claimPolicy),
           claimTags: opts.claimTag ?? [],
           toolSetRef: opts.toolSetRef ?? null,
@@ -6017,6 +6223,31 @@ function registerExecutor(program2) {
     );
     emit(data, Boolean(cmd.optsWithGlobals().json));
   });
+  executor.command("update <id>").description(
+    "Update executor capabilities, bounded lease TTL, and model identity in place"
+  ).option("--capability <key...>", "Capability operation keys").option(
+    "--task-lease-ttl <seconds>",
+    "Task lease TTL (60-86400)",
+    parseInteger
+  ).option("--model-id <id>", "Driver model identity").option("--runtime-version <version>", "Driver runtime/version identity").option("--effort-label <label>", "Optional driver effort label").option(
+    "--deregister-others",
+    "Deregister the caller's other active advertisements",
+    false
+  ).action(async (id, opts, cmd) => {
+    const data = await updateExecutorAdvertisement(
+      resolveConfig(cmd.optsWithGlobals()),
+      id,
+      {
+        capabilityKeys: opts.capability,
+        taskLeaseTtlSeconds: opts.taskLeaseTtl,
+        deregisterOthers: opts.deregisterOthers,
+        modelId: opts.modelId,
+        runtimeVersion: opts.runtimeVersion,
+        effortLabel: opts.effortLabel
+      }
+    );
+    emit(data, Boolean(cmd.optsWithGlobals().json));
+  });
   executor.command("deregister <id>").description("Stop advertising this executor instance").action(async (id, _opts, cmd) => {
     const cfg = resolveConfig(cmd.optsWithGlobals());
     const data = await api(
@@ -6138,12 +6369,87 @@ async function deregisterInstance(cfg, id) {
 async function ensureExecutorInstance(cfg, located, activationMode = "Attached") {
   const { state, path } = located;
   state.laneId ??= state.instanceKey;
-  const data = await registerInstance(cfg, state, activationMode);
+  state.taskLeaseTtlSeconds ??= 120;
+  refreshRuntimeVersion(state);
+  let data;
+  if (state.instanceId) {
+    const updated = await tryUpdateExecutorAdvertisement(
+      cfg,
+      state.instanceId,
+      {
+        capabilityKeys: state.capabilityKeys,
+        taskLeaseTtlSeconds: state.taskLeaseTtlSeconds,
+        deregisterOthers: false,
+        modelId: state.modelId,
+        runtimeVersion: state.runtimeVersion,
+        effortLabel: state.effortLabel,
+        laneId: state.laneId,
+        claimPolicy: parseClaimPolicy(state.claimPolicy),
+        claimTags: state.claimTags ?? [],
+        parentId: state.parentId ?? null,
+        repairRegistrationState: true
+      }
+    );
+    data = updated ? await refreshExecutorInstance(cfg, state.instanceId, state.ttlSeconds) : await registerInstance(cfg, state, activationMode);
+  } else {
+    data = await registerInstance(cfg, state, activationMode);
+  }
   state.instanceId = data.id;
   state.lastRefreshAt = (/* @__PURE__ */ new Date()).toISOString();
   writeFileSync8(path, JSON.stringify(state, null, 2) + "\n");
   return data;
 }
+async function updateExecutorAdvertisement(cfg, id, input) {
+  return await tryUpdateExecutorAdvertisement(cfg, id, input) ?? fail(`no active executor instance '${id}' is owned by the current operator`);
+}
+async function tryUpdateExecutorAdvertisement(cfg, id, input) {
+  const token = await requireToken(cfg);
+  const path = `/me/executor-instances/${encodeURIComponent(id)}`;
+  const response = await fetch(`${cfg.baseUrl}${path}`, {
+    method: "PUT",
+    headers: {
+      authorization: `Bearer ${token}`,
+      tenant: cfg.tenant,
+      "content-type": "application/json",
+      "x-sechroom-surface": "cli"
+    },
+    body: JSON.stringify({
+      claimedCapabilityKeys: input.capabilityKeys,
+      taskLeaseTtlSeconds: input.taskLeaseTtlSeconds,
+      deregisterOthers: input.deregisterOthers,
+      modelId: input.modelId ?? null,
+      runtimeVersion: input.runtimeVersion,
+      effortLabel: input.effortLabel,
+      laneId: input.laneId,
+      claimPolicy: input.claimPolicy,
+      claimTags: input.claimTags,
+      parentId: input.parentId,
+      repairRegistrationState: input.repairRegistrationState
+    })
+  });
+  if (response.ok) return response.json();
+  const detail = await response.text();
+  if ((response.status === 400 || response.status === 404) && detail.includes("No active executor instance"))
+    return void 0;
+  return fail(`PUT ${path} failed (${response.status}): ${detail}`);
+}
+function detectRuntimeVersion(runtime, binaryOverride) {
+  const binary = binaryOverride ?? (runtime === "codex" ? "codex" : "claude");
+  try {
+    return execFileSync(binary, ["--version"], {
+      encoding: "utf8",
+      timeout: 2e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function refreshRuntimeVersion(state, binaryOverride) {
+  const detected = detectRuntimeVersion(state.runtime, binaryOverride);
+  if (detected) state.runtimeVersion = detected;
+  return state.runtimeVersion;
+}
 function readExecutorState(start = process.cwd()) {
   const semPath = resolveSemPathForRead(start);
   const sem = semPath ? readSem(semPath) : void 0;
@@ -6185,11 +6491,11 @@ function parseInteger(value) {
   return parsed;
 }
 function holdHeartbeat(tick, intervalMs) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const timer = setInterval(() => void tick().catch(reject), intervalMs);
     const stop = () => {
       clearInterval(timer);
-      resolve8();
+      resolve9();
     };
     process.once("SIGINT", stop);
     process.once("SIGTERM", stop);
@@ -6201,33 +6507,26 @@ function registerChannel(program2) {
   const channel = program2.command("channel").description(
     "Receive matched substrate events over the held SignalR push leg (D-WLP-9)"
   );
-  const withFilterOpts = (c) => c.option(
-    "--name <name>",
-    "Deprecated: ignored; the installed executor selects its delivery subscription"
-  ).option(
-    "--tag <tag...>",
-    "Deprecated: executor eligibility comes from the installed capability advertisement"
-  ).option(
-    "--workspace <wsp...>",
-    "Deprecated: workspace authority is resolved by the server"
-  ).option(
-    "--executor-instance <id>",
-    "Deprecated: the instance is read from .sechroom/executor.json"
-  );
-  withFilterOpts(
-    channel.command("connect").description(
-      "Register a SignalR subscription and stream matched events to stdout"
-    )
-  ).action(async (opts, cmd) => {
+  channel.command("connect").description(
+    "Register an executor advertisement, claim exact offers, and stream tasks to stdout"
+  ).action(async (_opts, cmd) => {
     const json = Boolean(cmd.optsWithGlobals().json);
     const cfg = resolveConfig(cmd.optsWithGlobals());
-    warnLegacyChannelOptions(opts);
     const located = requireExecutorState();
     const instance = await ensureExecutorInstance(cfg, located);
-    const deliver = (payload) => process.stdout.write(
-      (typeof payload === "string" ? payload : JSON.stringify(payload)) + "\n"
+    const deliver = createTaskClaimDelivery(
+      cfg,
+      (payload) => process.stdout.write(
+        (typeof payload === "string" ? payload : JSON.stringify(payload)) + "\n"
+      )
+    );
+    const leaseHeartbeats = createChannelLeaseHeartbeatManager(
+      cfg,
+      located.state.taskLeaseTtlSeconds ?? 120
     );
-    const drain = createClaimDrain(cfg, instance.id, deliver);
+    const drain = createClaimDrain(cfg, instance.id, deliver, {
+      onClaimed: leaseHeartbeats.onClaimed
+    });
     const conn = await openConnection(
       cfg,
       () => {
@@ -6238,8 +6537,7 @@ function registerChannel(program2) {
       },
       instance.id
     );
-    await drain();
-    const stopReconciliation = startOfferReconciliation(drain);
+    const stopReconciliation = startClaimReconciliation(drain);
     const stopHeartbeat = startExecutorHeartbeat(
       () => refreshExecutorInstance(cfg, instance.id, located.state.ttlSeconds),
       located.state.refreshAfterSeconds * 1e3
@@ -6268,36 +6566,37 @@ function registerChannel(program2) {
     } finally {
       stopReconciliation();
       stopHeartbeat();
+      leaseHeartbeats.stop();
     }
   });
-  withFilterOpts(
-    channel.command("mcp").description(
-      "Run as a Claude Code channel (local-stdio MCP server) \u2014 push matched events into the session"
-    )
-  ).action(async (opts, cmd) => {
+  channel.command("mcp").description(
+    "Run as a Claude Code channel (local-stdio MCP server) \u2014 claim and push dispatched tasks into the session"
+  ).action(async (_opts, cmd) => {
     const cfg = resolveConfig(cmd.optsWithGlobals());
-    warnLegacyChannelOptions(opts);
     const located = requireExecutorState();
     const instance = await ensureExecutorInstance(cfg, located);
     const mcp = new Server(
       { name: "sechroom", version: "0.1.0" },
       {
         capabilities: { experimental: { "claude/channel": {} } },
-        instructions: 'Matched Sechroom substrate events arrive as <channel source="sechroom"> tags. A WLP dispatch delivered here has already been atomically claimed for this executor. Load the memory id from the event and retain the lease and claim token for holder-bound completion.'
+        instructions: 'A WLP dispatch arrives as a <channel source="sechroom"> tag containing the complete runnable task card followed by its pinned task context. Treat it as the task-time layer on top of the session floor; do not refetch or substitute live memory bodies. Retain memory_id, lease_id, and claim_token from the metadata for holder-bound completion.'
       }
     );
     await mcp.connect(new StdioServerTransport());
-    const deliver = (payload) => {
-      const { content, meta } = summarizeEvent(payload);
-      void mcp.notification({
+    const deliver = createTaskClaimDelivery(cfg, async (payload) => {
+      const { content, meta } = summarizeTaskClaim(payload);
+      await mcp.notification({
         method: "notifications/claude/channel",
         params: { content, meta }
-      }).catch(
-        (e) => process.stderr.write(err(`channel push failed: ${String(e)}
-`))
-      );
-    };
-    const drain = createClaimDrain(cfg, instance.id, deliver);
+      });
+    });
+    const leaseHeartbeats = createChannelLeaseHeartbeatManager(
+      cfg,
+      located.state.taskLeaseTtlSeconds ?? 120
+    );
+    const drain = createClaimDrain(cfg, instance.id, deliver, {
+      onClaimed: leaseHeartbeats.onClaimed
+    });
     const conn = await openConnection(
       cfg,
       () => {
@@ -6308,8 +6607,7 @@ function registerChannel(program2) {
       },
       instance.id
     );
-    await drain();
-    const stopReconciliation = startOfferReconciliation(drain);
+    const stopReconciliation = startClaimReconciliation(drain);
     const stopHeartbeat = startExecutorHeartbeat(
       () => refreshExecutorInstance(cfg, instance.id, located.state.ttlSeconds),
       located.state.refreshAfterSeconds * 1e3
@@ -6325,31 +6623,23 @@ function registerChannel(program2) {
     } finally {
       stopReconciliation();
       stopHeartbeat();
+      leaseHeartbeats.stop();
     }
   });
   channel.command("install").description(
     "Wire `sechroom channel mcp` into the project .mcp.json as a Claude Code channel MCP server (idempotent)"
-  ).option(
-    "--workspace <wsp...>",
-    "Deprecated: accepted only to migrate an existing managed entry"
-  ).option(
-    "--tag <tag...>",
-    "Deprecated: accepted only to migrate an existing managed entry"
-  ).option(
-    "--name <name>",
-    "MCP server + subscription name (idempotent per name)",
-    "sechroom-channel"
   ).option("--dry-run", "Print what would change; write nothing").action((opts) => {
     const path = join12(process.cwd(), ".mcp.json");
     const dryRun = Boolean(opts.dryRun);
+    const name = "sechroom-channel";
     const args = ["channel", "mcp"];
     const entry = { command: "sechroom", args };
     const config2 = readMcpConfig(path);
     config2.mcpServers ??= {};
-    const existing = config2.mcpServers[opts.name];
+    const existing = config2.mcpServers[name];
     const status = JSON.stringify(existing) === JSON.stringify(entry) ? "current" : existing ? "updated" : "created";
     if (status !== "current" && !dryRun) {
-      config2.mcpServers[opts.name] = entry;
+      config2.mcpServers[name] = entry;
       mkdirSync10(dirname9(path), { recursive: true });
       writeFileSync9(path, JSON.stringify(config2, null, 2) + "\n");
     }
@@ -6357,7 +6647,7 @@ function registerChannel(program2) {
     process.stdout.write(`${style.green("channel")} ${path} (${verb})
 `);
     process.stdout.write(
-      style.dim(`  server "${opts.name}": sechroom ${args.join(" ")}
+      style.dim(`  server "${name}": sechroom ${args.join(" ")}
 `)
     );
     if (status !== "current") {
@@ -6365,18 +6655,12 @@ function registerChannel(program2) {
         style.dim(
           `
 Load it (Channels research preview) by launching your agent with:
-  claude --dangerously-load-development-channels server:${opts.name}
+  claude --dangerously-load-development-channels server:${name}
 `
         )
       );
     }
     warnIfSechroomNotOnPath();
-    if ((opts.workspace?.length ?? 0) > 0 || (opts.tag?.length ?? 0) > 0)
-      process.stderr.write(
-        style.dim(
-          "channel: --workspace/--tag are retired; the managed entry now uses the installed executor advertisement.\n"
-        )
-      );
   });
   channel.addHelpText(
     "after",
@@ -6398,15 +6682,6 @@ function requireExecutorState() {
     );
   return located;
 }
-function warnLegacyChannelOptions(opts) {
-  if (!opts.name && (opts.workspace?.length ?? 0) === 0 && (opts.tag?.length ?? 0) === 0 && !opts.executorInstance)
-    return;
-  process.stderr.write(
-    style.dim(
-      "channel: --name, --workspace, --tag, and --executor-instance are retired; delivery, eligibility, and identity come from the installed executor advertisement.\n"
-    )
-  );
-}
 function createClaimDrain(cfg, executorInstanceId, deliver, dependencies = {}) {
   let active2;
   const state = {};
@@ -6430,21 +6705,88 @@ function startOfferReconciliation(drain, intervalMilliseconds = 5e3, dependencie
   }, intervalMilliseconds);
   return () => cancel(timer);
 }
+function startClaimReconciliation(drain, intervalMilliseconds = 5e3, dependencies = {}) {
+  const onError = dependencies.onError ?? ((error) => process.stderr.write(err(`channel claim failed: ${String(error)}
+`)));
+  void drain().catch(onError);
+  return startOfferReconciliation(drain, intervalMilliseconds, {
+    ...dependencies,
+    onError
+  });
+}
 function startExecutorHeartbeat(refresh, intervalMilliseconds, dependencies = {}) {
   const schedule = dependencies.setInterval ?? setInterval;
   const cancel = dependencies.clearInterval ?? clearInterval;
-  const onError = dependencies.onError ?? ((error) => process.stderr.write(err(`channel heartbeat failed: ${String(error)}
-`)));
+  const onError = dependencies.onError ?? ((error) => process.stderr.write(
+    err(`channel heartbeat failed: ${String(error)}
+`)
+  ));
   const timer = schedule(() => {
     void refresh().catch(onError);
   }, intervalMilliseconds);
   return () => cancel(timer);
 }
+function startChannelTaskLeaseHeartbeat(cfg, claim, intervalMilliseconds = 3e4, dependencies = {}) {
+  const leaseId = claim.lease?.id;
+  const claimToken = claim.claimToken;
+  if (!leaseId || !claimToken) return void 0;
+  const request = dependencies.request ?? api;
+  const onError = dependencies.onError ?? ((value) => process.stderr.write(
+    err(`channel lease heartbeat failed: ${String(value)}
+`)
+  ));
+  return startLeaseHeartbeat(
+    () => request(
+      cfg,
+      `/me/executor-task-leases/${encodeURIComponent(leaseId)}/heartbeat`,
+      {
+        method: "POST",
+        body: JSON.stringify({
+          claimToken,
+          tokenVersion: claim.tokenVersion ?? 1
+        })
+      }
+    ),
+    onError,
+    intervalMilliseconds,
+    {
+      setInterval: dependencies.setInterval,
+      clearInterval: dependencies.clearInterval
+    }
+  );
+}
+function createChannelLeaseHeartbeatManager(cfg, taskLeaseTtlSeconds) {
+  const stops = /* @__PURE__ */ new Map();
+  const intervalMilliseconds = Math.max(
+    1e3,
+    Math.min(3e4, Math.floor(taskLeaseTtlSeconds * 1e3 / 4))
+  );
+  return {
+    onClaimed: (claim) => {
+      const leaseId = claim.lease?.id;
+      if (!leaseId || stops.has(leaseId)) return;
+      const stop = startChannelTaskLeaseHeartbeat(
+        cfg,
+        claim,
+        intervalMilliseconds
+      );
+      if (stop) stops.set(leaseId, stop);
+    },
+    stop: () => {
+      for (const stop of stops.values()) stop();
+      stops.clear();
+    }
+  };
+}
 async function drainClaims(cfg, executorInstanceId, deliver, dependencies = {}) {
   const request = dependencies.request ?? api;
-  const sleep = dependencies.sleep ?? ((milliseconds) => new Promise((resolve8) => setTimeout(resolve8, milliseconds)));
+  const sleep = dependencies.sleep ?? ((milliseconds) => new Promise((resolve9) => setTimeout(resolve9, milliseconds)));
   const idempotencyKey = dependencies.idempotencyKey ?? ((offer) => `channel:${offer.generationId}`);
   const state = dependencies.state ?? {};
+  const deliverClaim = async (claim) => {
+    dependencies.onClaimed?.(claim);
+    await deliver(claim);
+  };
   for (; ; ) {
     if (state.pendingIdempotencyKey) {
       const replay = await request(
@@ -6455,11 +6797,12 @@ async function drainClaims(cfg, executorInstanceId, deliver, dependencies = {})
           body: JSON.stringify({ idempotencyKey: state.pendingIdempotencyKey })
         }
       );
-      state.pendingIdempotencyKey = void 0;
       if (replay.outcome === "Claimed" || replay.outcome === "AlreadyHeld") {
-        deliver(replay);
+        await deliverClaim(replay);
+        state.pendingIdempotencyKey = void 0;
         continue;
       }
+      state.pendingIdempotencyKey = void 0;
       return;
     }
     const offers = await request(
@@ -6479,11 +6822,13 @@ async function drainClaims(cfg, executorInstanceId, deliver, dependencies = {})
         body: JSON.stringify({ idempotencyKey: state.pendingIdempotencyKey })
       }
     );
+    if (claim.outcome === "Claimed" || claim.outcome === "AlreadyHeld") {
+      await deliverClaim(claim);
+      state.pendingIdempotencyKey = void 0;
+      continue;
+    }
     state.pendingIdempotencyKey = void 0;
-    if (claim.outcome === "NoOffer") return;
-    if (claim.outcome === "Claimed" || claim.outcome === "AlreadyHeld")
-      deliver(claim);
-    else return;
+    return;
   }
 }
 function readMcpConfig(path) {
@@ -6516,9 +6861,9 @@ async function openConnection(cfg, onEvent, executorInstanceId) {
   return conn;
 }
 function holdOpen(conn) {
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     const stop = () => {
-      void conn.stop().finally(resolve8);
+      void conn.stop().finally(resolve9);
     };
     process.on("SIGINT", stop);
     process.on("SIGTERM", stop);
@@ -6544,18 +6889,35 @@ function parseEvent(payload) {
     tags: Array.isArray(rawTags) ? rawTags.filter((t) => typeof t === "string") : void 0
   };
 }
-function summarizeEvent(payload) {
-  const { eventType, memoryId, workspaceId } = parseEvent(payload);
-  const content = memoryId ? `${eventType}: ${memoryId}${workspaceId ? ` (workspace ${workspaceId})` : ""}` : typeof payload === "string" ? payload : JSON.stringify(payload);
+function createTaskClaimDelivery(cfg, deliver, dependencies = {}) {
+  const request = dependencies.request ?? api;
+  return async (claim) => {
+    const memoryId = claim.lease?.memoryId || claim.offer?.memoryId;
+    if (!memoryId)
+      throw new Error(
+        "claimed task response carried no memory id; refusing attached-channel delivery"
+      );
+    const task = await materializeClaimedTask(
+      (path, init) => request(cfg, path, init),
+      memoryId
+    );
+    await deliver({ ...claim, task });
+  };
+}
+function summarizeTaskClaim(payload) {
+  const { task, ...claim } = payload;
+  const parsed = parseEvent(claim);
+  const memoryId = parsed.memoryId || claim.lease?.memoryId || claim.offer?.memoryId || "";
+  const workspaceId = parsed.workspaceId || claim.lease?.workspaceId || claim.offer?.workspaceId || "";
   const meta = {};
-  if (eventType) meta.event_type = eventType;
+  if (parsed.eventType) meta.event_type = parsed.eventType;
   if (memoryId) meta.memory_id = memoryId;
   if (workspaceId) meta.workspace_id = workspaceId;
-  const claim = payload ?? {};
   if (claim.outcome) meta.claim_outcome = claim.outcome;
   if (claim.lease?.id) meta.lease_id = claim.lease.id;
   if (claim.claimToken) meta.claim_token = claim.claimToken;
-  return { content, meta };
+  meta.context_layer = "task";
+  return { content: task.text, meta };
 }
 function str(v) {
   return typeof v === "string" ? v : v == null ? "" : String(v);
@@ -6644,16 +7006,16 @@ Examples:
 }
 
 // src/commands/checkpoint.ts
-import { mkdirSync as mkdirSync14, writeFileSync as writeFileSync13 } from "fs";
-import { dirname as dirname13, join as join15 } from "path";
+import { mkdirSync as mkdirSync15, writeFileSync as writeFileSync14 } from "fs";
+import { dirname as dirname14, join as join16 } from "path";
 
 // src/commands/hook.ts
-import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync11, mkdirSync as mkdirSync13, readFileSync as readFileSync10, statSync as statSync2, writeFileSync as writeFileSync12 } from "fs";
-import { dirname as dirname12, join as join14 } from "path";
+import { createHash as createHash4 } from "crypto";
+import { existsSync as existsSync12, mkdirSync as mkdirSync14, readFileSync as readFileSync11, statSync as statSync3, writeFileSync as writeFileSync13 } from "fs";
+import { dirname as dirname13, join as join15 } from "path";
 
 // src/commands/lane-commit-hook.ts
-import { execFileSync } from "child_process";
+import { execFileSync as execFileSync2 } from "child_process";
 import {
   chmodSync,
   existsSync as existsSync10,
@@ -6717,90 +7079,427 @@ ${current.slice(shebang.length)}`;
 ${MANAGED_BLOCK}
 ${current}`;
 }
-function managedBlockPattern() {
-  return new RegExp(
-    `${BEGIN.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\s\\S]*?${END.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`
+function managedBlockPattern() {
+  return new RegExp(
+    `${BEGIN.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\s\\S]*?${END.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`
+  );
+}
+function chainWrapper(incumbentName) {
+  return `#!/bin/sh
+${MANAGED_BLOCK}
+hook_dir=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
+exec "$hook_dir/${incumbentName}" "$@"
+`;
+}
+function nextIncumbentPath(path) {
+  const base = `${path}${INCUMBENT_SUFFIX}`;
+  if (!existsSync10(base)) return base;
+  for (let index = 2; ; index++) {
+    const candidate = `${base}.${index}`;
+    if (!existsSync10(candidate)) return candidate;
+  }
+}
+function resolveHookPath(root, hookName) {
+  const gitPath = execFileSync2(
+    "git",
+    ["-C", root, "rev-parse", "--git-path", `hooks/${hookName}`],
+    {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }
+  ).trim();
+  return isAbsolute(gitPath) ? gitPath : resolve4(root, gitPath);
+}
+function removeLegacyPrepareCommitMsgLeg(root) {
+  const path = resolveHookPath(root, LEGACY_HOOK_NAME);
+  if (!existsSync10(path)) return;
+  const current = readFileSync9(path, "utf8");
+  const pattern = managedBlockPattern();
+  if (!pattern.test(current)) return;
+  const next = current.replace(pattern, "").replace(/\n{3,}/g, "\n\n").trimEnd();
+  if (!next || next === "#!/bin/sh") {
+    unlinkSync(path);
+    return;
+  }
+  writeFileSync10(path, `${next}
+`, "utf8");
+  chmodSync(path, 493);
+}
+function installLaneCommitHook(start) {
+  try {
+    const root = execFileSync2("git", ["-C", start, "rev-parse", "--show-toplevel"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    removeLegacyPrepareCommitMsgLeg(root);
+    const path = resolveHookPath(root, HOOK_NAME);
+    const current = existsSync10(path) ? readFileSync9(path, "utf8") : "";
+    let next;
+    if (current && !isShellHook(current)) {
+      const incumbentPath = nextIncumbentPath(path);
+      renameSync(path, incumbentPath);
+      chmodSync(incumbentPath, 493);
+      next = chainWrapper(basename2(incumbentPath));
+    } else {
+      next = insertManagedBlock(current);
+    }
+    if (next !== current) {
+      mkdirSync11(dirname10(path), { recursive: true });
+      writeFileSync10(path, next.endsWith("\n") ? next : `${next}
+`, "utf8");
+    }
+    chmodSync(path, 493);
+    return path;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/commands/session-context.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { mkdirSync as mkdirSync13, renameSync as renameSync3, rmSync as rmSync6, writeFileSync as writeFileSync12 } from "fs";
+import { dirname as dirname12, join as join14 } from "path";
+
+// src/setup/skill-composition-materialise.ts
+import { createHash as createHash3, randomUUID } from "crypto";
+import {
+  existsSync as existsSync11,
+  mkdirSync as mkdirSync12,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync10,
+  renameSync as renameSync2,
+  rmdirSync,
+  rmSync as rmSync5,
+  statSync as statSync2,
+  writeFileSync as writeFileSync11
+} from "fs";
+import { dirname as dirname11, isAbsolute as isAbsolute2, join as join13, relative, resolve as resolve5 } from "path";
+var COMPILED_SKILL_LOCK = join13(
+  ".sechroom",
+  "compiled-skill-materialisation.json"
+);
+var GIT_EXCLUDE_BEGIN = "# sechroom compiled skills: begin";
+var GIT_EXCLUDE_END = "# sechroom compiled skills: end";
+function materialiseCompiledSkillCompositions(cwd, payload, options = {}) {
+  const holds = [...payload.holds ?? []];
+  if (payload.preserveExisting || holds.some((hold) => hold.skillName == null))
+    return { items: [], holds };
+  const destinations = resolveDestinations(cwd, options);
+  const desired = /* @__PURE__ */ new Map();
+  const ambiguous = /* @__PURE__ */ new Set();
+  for (const skill of payload.skills) {
+    if (!isSafePathSegment(skill.name)) {
+      holds.push({
+        code: "compiled-skill-name-invalid",
+        reason: `Compiled skill '${skill.name}' is not a safe path segment.`,
+        bundleSlug: skill.bundleSlug,
+        skillName: skill.name
+      });
+      continue;
+    }
+    const body = withFinalNewline(skill.body);
+    for (const rawTarget of skill.targets) {
+      if (!isSupportedTarget(rawTarget)) {
+        holds.push({
+          code: "compiled-skill-target-unsupported",
+          reason: `Compiled skill '${skill.name}' names unsupported target:${rawTarget}.`,
+          bundleSlug: skill.bundleSlug,
+          skillName: skill.name
+        });
+        continue;
+      }
+      for (const destination of destinations.filter(
+        (candidate) => candidate.target === rawTarget
+      )) {
+        const key = entryKey(rawTarget, skill.name, destination.skillsRoot);
+        if (desired.has(key) || ambiguous.has(key)) {
+          holds.push({
+            code: "compiled-skill-identity-ambiguous",
+            reason: `More than one compiled composition resolved '${skill.name}' for target:${rawTarget}.`,
+            bundleSlug: skill.bundleSlug,
+            skillName: skill.name
+          });
+          desired.delete(key);
+          ambiguous.add(key);
+          continue;
+        }
+        desired.set(key, {
+          target: rawTarget,
+          skillsRoot: destination.skillsRoot,
+          skill,
+          body
+        });
+      }
+    }
+  }
+  for (const [key, value] of desired) {
+    if (holds.some(
+      (hold) => hold.skillName === value.skill.name && (hold.bundleSlug == null || hold.bundleSlug === value.skill.bundleSlug)
+    )) {
+      desired.delete(key);
+    }
+  }
+  const lockPath = join13(cwd, COMPILED_SKILL_LOCK);
+  const previous = readLock(lockPath, destinations);
+  const next = {
+    version: 2,
+    entries: { ...previous.entries }
+  };
+  const items = [];
+  for (const [key, value] of desired) {
+    const path = skillPath(value.skillsRoot, value.skill.name);
+    const directory = dirname11(path);
+    const prior = previous.entries[key];
+    const existing = existsSync11(path) ? readFileSync10(path, "utf8") : void 0;
+    const existingHash = existing === void 0 ? void 0 : sha256(existing);
+    const owned = prior !== void 0 && prior.skillsRoot === value.skillsRoot && existing !== void 0 && (existingHash === prior.contentHash || existingHash === prior.previousContentHash);
+    const recoverableMissing = prior !== void 0 && existing === void 0;
+    if (existing !== void 0 && !owned) {
+      delete next.entries[key];
+      items.push({
+        target: value.target,
+        name: value.skill.name,
+        path,
+        status: "collision",
+        reason: "existing SKILL.md is not owned by the compiled-skill materializer"
+      });
+      continue;
+    }
+    if (existing === void 0 && existsSync11(directory) && !recoverableMissing) {
+      delete next.entries[key];
+      items.push({
+        target: value.target,
+        name: value.skill.name,
+        path,
+        status: "collision",
+        reason: "existing skill directory is not owned by the compiled-skill materializer"
+      });
+      continue;
+    }
+    const contentHash = sha256(value.body);
+    const finalEntry = {
+      target: value.target,
+      name: value.skill.name,
+      skillsRoot: value.skillsRoot,
+      bundleSlug: value.skill.bundleSlug,
+      bundleVersion: value.skill.bundleVersion,
+      manifestHash: value.skill.manifestHash,
+      contentHash
+    };
+    let status;
+    if (existing === value.body) {
+      status = "unchanged";
+      next.entries[key] = finalEntry;
+      writeLock(lockPath, next);
+    } else {
+      next.entries[key] = {
+        ...finalEntry,
+        previousContentHash: existingHash
+      };
+      writeLock(lockPath, next);
+      mkdirSync12(directory, { recursive: true });
+      if (existingHash !== void 0 && (!existsSync11(path) || sha256(readFileSync10(path, "utf8")) !== existingHash)) {
+        delete next.entries[key];
+        writeLock(lockPath, next);
+        items.push({
+          target: value.target,
+          name: value.skill.name,
+          path,
+          status: "collision",
+          reason: "owned SKILL.md changed during reconciliation; preserved byte-identical"
+        });
+        continue;
+      }
+      writeAtomic(path, value.body);
+      status = existing === void 0 ? "written" : "updated";
+      next.entries[key] = finalEntry;
+      writeLock(lockPath, next);
+    }
+    items.push({ target: value.target, name: value.skill.name, path, status });
+  }
+  for (const [key, prior] of Object.entries(previous.entries)) {
+    if (desired.has(key)) continue;
+    const path = skillPath(prior.skillsRoot, prior.name);
+    const removed = removeOwnedFile(path, [
+      prior.contentHash,
+      prior.previousContentHash
+    ]);
+    if (removed === "collision") {
+      items.push({
+        target: prior.target,
+        name: prior.name,
+        path,
+        status: "collision",
+        reason: "previously materialized SKILL.md was edited; preserved byte-identical"
+      });
+    } else if (removed === "removed") {
+      removeDirectoryIfEmpty(dirname11(path));
+      items.push({
+        target: prior.target,
+        name: prior.name,
+        path,
+        status: "removed"
+      });
+    }
+    delete next.entries[key];
+    writeLock(lockPath, next);
+  }
+  writeLock(lockPath, next);
+  syncGitExcludes(cwd, next);
+  return { items, holds };
+}
+function isSupportedTarget(value) {
+  return value === "claude-code" || value === "gpt-codex";
+}
+function isSafePathSegment(value) {
+  return value.length > 0 && value !== "." && value !== ".." && !value.includes("/") && !value.includes("\\") && !value.includes("\0");
+}
+function resolveDestinations(cwd, options) {
+  const destinations = [
+    {
+      target: "claude-code",
+      skillsRoot: resolve5(cwd, ".claude", "skills")
+    }
+  ];
+  const codexHomes = options.codexHomes ?? resolveCodexHomes({
+    override: options.codexHomeOverride,
+    scope: "global"
+  });
+  for (const home of codexHomes) {
+    destinations.push({
+      target: "gpt-codex",
+      skillsRoot: resolve5(home, "skills")
+    });
+  }
+  return destinations.filter(
+    (candidate, index, all) => all.findIndex(
+      (other) => other.target === candidate.target && other.skillsRoot === candidate.skillsRoot
+    ) === index
   );
 }
-function chainWrapper(incumbentName) {
-  return `#!/bin/sh
-${MANAGED_BLOCK}
-hook_dir=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
-exec "$hook_dir/${incumbentName}" "$@"
-`;
+function entryKey(target, name, skillsRoot) {
+  return `${target}:${sha256(skillsRoot)}:${name}`;
 }
-function nextIncumbentPath(path) {
-  const base = `${path}${INCUMBENT_SUFFIX}`;
-  if (!existsSync10(base)) return base;
-  for (let index = 2; ; index++) {
-    const candidate = `${base}.${index}`;
-    if (!existsSync10(candidate)) return candidate;
-  }
+function skillPath(skillsRoot, name) {
+  return join13(skillsRoot, name, "SKILL.md");
 }
-function resolveHookPath(root, hookName) {
-  const gitPath = execFileSync(
-    "git",
-    ["-C", root, "rev-parse", "--git-path", `hooks/${hookName}`],
-    {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"]
+function withFinalNewline(body) {
+  return body.endsWith("\n") ? body : body + "\n";
+}
+function sha256(value) {
+  return createHash3("sha256").update(value, "utf8").digest("hex");
+}
+function readLock(path, destinations) {
+  const allowedRoots = new Set(
+    destinations.map(
+      (destination) => `${destination.target}\0${destination.skillsRoot}`
+    )
+  );
+  try {
+    const parsed = JSON.parse(readFileSync10(path, "utf8"));
+    if (parsed.version === 2 && parsed.entries && typeof parsed.entries === "object") {
+      const entries = {};
+      for (const [key, candidate] of Object.entries(parsed.entries)) {
+        if (!isLockEntry(candidate) || key !== entryKey(candidate.target, candidate.name, candidate.skillsRoot))
+          continue;
+        if (!allowedRoots.has(`${candidate.target}\0${candidate.skillsRoot}`))
+          continue;
+        entries[key] = candidate;
+      }
+      return { version: 2, entries };
     }
-  ).trim();
-  return isAbsolute(gitPath) ? gitPath : resolve4(root, gitPath);
+  } catch {
+  }
+  return { version: 2, entries: {} };
 }
-function removeLegacyPrepareCommitMsgLeg(root) {
-  const path = resolveHookPath(root, LEGACY_HOOK_NAME);
-  if (!existsSync10(path)) return;
-  const current = readFileSync9(path, "utf8");
-  const pattern = managedBlockPattern();
-  if (!pattern.test(current)) return;
-  const next = current.replace(pattern, "").replace(/\n{3,}/g, "\n\n").trimEnd();
-  if (!next || next === "#!/bin/sh") {
-    unlinkSync(path);
-    return;
+function isLockEntry(value) {
+  if (value === null || typeof value !== "object") return false;
+  const candidate = value;
+  return isSupportedTarget(String(candidate.target)) && typeof candidate.name === "string" && isSafePathSegment(candidate.name) && typeof candidate.skillsRoot === "string" && isAbsolute2(candidate.skillsRoot) && typeof candidate.bundleSlug === "string" && typeof candidate.bundleVersion === "string" && typeof candidate.manifestHash === "string" && typeof candidate.contentHash === "string" && /^[0-9a-f]{64}$/.test(candidate.contentHash) && (candidate.previousContentHash === void 0 || typeof candidate.previousContentHash === "string" && /^[0-9a-f]{64}$/.test(candidate.previousContentHash));
+}
+function writeLock(path, lock) {
+  mkdirSync12(dirname11(path), { recursive: true });
+  writeAtomic(path, JSON.stringify(lock, null, 2) + "\n");
+}
+function writeAtomic(path, body) {
+  const temporary = `${path}.sechroom-${process.pid}.tmp`;
+  writeFileSync11(temporary, body);
+  renameSync2(temporary, path);
+}
+function removeOwnedFile(path, acceptableHashes) {
+  const quarantine = `${path}.sechroom-retire-${process.pid}-${randomUUID()}`;
+  try {
+    renameSync2(path, quarantine);
+  } catch (error) {
+    if (error.code === "ENOENT") return "missing";
+    throw error;
   }
-  writeFileSync10(path, `${next}
-`, "utf8");
-  chmodSync(path, 493);
+  const quarantinedHash = sha256(readFileSync10(quarantine, "utf8"));
+  if (acceptableHashes.includes(quarantinedHash)) {
+    rmSync5(quarantine);
+    return "removed";
+  }
+  if (!existsSync11(path)) {
+    renameSync2(quarantine, path);
+  } else {
+    renameSync2(quarantine, `${path}.sechroom-preserved-${randomUUID()}`);
+  }
+  return "collision";
 }
-function installLaneCommitHook(start) {
+function syncGitExcludes(cwd, lock) {
+  const path = gitExcludePath(cwd);
+  if (!path) return;
+  let current = "";
   try {
-    const root = execFileSync("git", ["-C", start, "rev-parse", "--show-toplevel"], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"]
-    }).trim();
-    removeLegacyPrepareCommitMsgLeg(root);
-    const path = resolveHookPath(root, HOOK_NAME);
-    const current = existsSync10(path) ? readFileSync9(path, "utf8") : "";
-    let next;
-    if (current && !isShellHook(current)) {
-      const incumbentPath = nextIncumbentPath(path);
-      renameSync(path, incumbentPath);
-      chmodSync(incumbentPath, 493);
-      next = chainWrapper(basename2(incumbentPath));
-    } else {
-      next = insertManagedBlock(current);
-    }
-    if (next !== current) {
-      mkdirSync11(dirname10(path), { recursive: true });
-      writeFileSync10(path, next.endsWith("\n") ? next : `${next}
-`, "utf8");
-    }
-    chmodSync(path, 493);
-    return path;
+    current = readFileSync10(path, "utf8");
+  } catch {
+  }
+  const withoutOwnedBlock = removeOwnedExcludeBlock(current);
+  const patterns = Object.values(lock.entries).filter((entry) => entry.target === "claude-code").map((entry) => relative(cwd, skillPath(entry.skillsRoot, entry.name))).filter(
+    (entryPath) => entryPath.length > 0 && !isAbsolute2(entryPath) && entryPath !== ".." && !entryPath.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`)
+  ).map((entryPath) => `/${entryPath.replaceAll("\\", "/")}`).sort();
+  const block = patterns.length === 0 ? "" : [GIT_EXCLUDE_BEGIN, ...patterns, GIT_EXCLUDE_END, ""].join("\n");
+  const separator = withoutOwnedBlock.length > 0 && !withoutOwnedBlock.endsWith("\n") && block ? "\n" : "";
+  const updated = withoutOwnedBlock + separator + block;
+  if (updated === current) return;
+  mkdirSync12(dirname11(path), { recursive: true });
+  writeAtomic(path, updated);
+}
+function gitExcludePath(cwd) {
+  const dotGit = join13(cwd, ".git");
+  try {
+    if (statSync2(dotGit).isDirectory()) return join13(dotGit, "info", "exclude");
+    const pointer = readFileSync10(dotGit, "utf8").trim();
+    if (!pointer.startsWith("gitdir:")) return void 0;
+    const raw = pointer.slice("gitdir:".length).trim();
+    const gitDir = isAbsolute2(raw) ? raw : resolve5(cwd, raw);
+    return join13(gitDir, "info", "exclude");
   } catch {
     return void 0;
   }
 }
+function removeOwnedExcludeBlock(body) {
+  const start = body.indexOf(GIT_EXCLUDE_BEGIN);
+  if (start < 0) return body;
+  const endMarker = body.indexOf(GIT_EXCLUDE_END, start);
+  if (endMarker < 0) return body;
+  let end = endMarker + GIT_EXCLUDE_END.length;
+  if (body.slice(end, end + 2) === "\r\n") end += 2;
+  else if (body[end] === "\n") end += 1;
+  return body.slice(0, start) + body.slice(end);
+}
+function removeDirectoryIfEmpty(path) {
+  try {
+    if (readdirSync2(path).length === 0) rmdirSync(path);
+  } catch {
+  }
+}
 
 // src/commands/session-context.ts
-import { randomUUID } from "crypto";
-import { mkdirSync as mkdirSync12, renameSync as renameSync2, rmSync as rmSync5, writeFileSync as writeFileSync11 } from "fs";
-import { dirname as dirname11, join as join13 } from "path";
-var DYNAMIC_AGENT_CONTEXT_FILE = join13(".sechroom", "CLAUDE.md");
+var DYNAMIC_AGENT_CONTEXT_FILE = join14(".sechroom", "CLAUDE.md");
 function checkoutRoot(start) {
   const semPath = resolveSemPathForRead(start);
-  return semPath ? dirname11(dirname11(semPath)) : start;
+  return semPath ? dirname12(dirname12(semPath)) : start;
 }
 function renderSessionContext(result, lane) {
   if (result.status === "hold") {
@@ -6832,22 +7531,36 @@ function renderSessionContext(result, lane) {
   }
   return lines.join("\n");
 }
-function writeSessionContext(start, lane, result) {
-  const path = join13(checkoutRoot(start), DYNAMIC_AGENT_CONTEXT_FILE);
+function writeSessionContext(start, lane, result, options = {}) {
+  const root = checkoutRoot(start);
+  const path = join14(root, DYNAMIC_AGENT_CONTEXT_FILE);
+  const skills = materialiseCompiledSkillCompositions(
+    root,
+    result.status === "hold" ? {
+      skills: [],
+      holds: [{
+        code: "session-context-hold",
+        reason: result.reason?.trim() || "Session context resolution held without a reason.",
+        skillName: null
+      }],
+      preserveExisting: true
+    } : { skills: result.skills },
+    options
+  );
   const context = renderSessionContext(result, lane);
-  mkdirSync12(dirname11(path), { recursive: true });
-  const temporaryPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  mkdirSync13(dirname12(path), { recursive: true });
+  const temporaryPath = `${path}.${process.pid}.${randomUUID2()}.tmp`;
   try {
-    writeFileSync11(temporaryPath, context.endsWith("\n") ? context : `${context}
+    writeFileSync12(temporaryPath, context.endsWith("\n") ? context : `${context}
 `, "utf8");
-    renameSync2(temporaryPath, path);
+    renameSync3(temporaryPath, path);
   } catch (error) {
-    rmSync5(temporaryPath, { force: true });
+    rmSync6(temporaryPath, { force: true });
     throw error;
   }
-  return { status: result.status, path, context };
+  return { status: result.status, path, context, skills };
 }
-async function materializeSessionContext(client, cfg, lane, start) {
+async function materializeSessionContext(client, cfg, lane, start, options = {}) {
   const { data, error, response } = await client.POST("/session-context/resolve", {
     body: {
       laneId: lane,
@@ -6858,7 +7571,15 @@ async function materializeSessionContext(client, cfg, lane, start) {
     const detail = error ? JSON.stringify(error) : `HTTP ${response?.status ?? "unknown"}`;
     throw new Error(`session context resolution failed: ${detail}`);
   }
-  return writeSessionContext(start, lane, data);
+  assertSessionContextResult(data);
+  return writeSessionContext(start, lane, data, options);
+}
+function assertSessionContextResult(value) {
+  if (value === null || typeof value !== "object" || !["ready", "hold"].includes(String(value.status)) || !Array.isArray(value.members) || !Array.isArray(value.skills)) {
+    throw new Error(
+      "session context resolution returned an invalid payload; preserving existing compiled skills"
+    );
+  }
 }
 
 // src/commands/hook.ts
@@ -6885,13 +7606,13 @@ function resolveLane(flagLane, cwd) {
   if (!base) return void 0;
   return applyWorktreeLaneSuffix(base, start);
 }
-var INTENT_FILE = join14(".sechroom", "continuity.json");
+var INTENT_FILE = join15(".sechroom", "continuity.json");
 function resolveIntentPath(start) {
   let dir = start;
   for (; ; ) {
-    const candidate = join14(dir, INTENT_FILE);
-    if (existsSync11(candidate)) return candidate;
-    const parent = dirname12(dir);
+    const candidate = join15(dir, INTENT_FILE);
+    if (existsSync12(candidate)) return candidate;
+    const parent = dirname13(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
@@ -6900,7 +7621,7 @@ function readIntent(start) {
   const path = resolveIntentPath(start);
   if (!path) return void 0;
   try {
-    return JSON.parse(readFileSync10(path, "utf8"));
+    return JSON.parse(readFileSync11(path, "utf8"));
   } catch {
     return void 0;
   }
@@ -6942,14 +7663,14 @@ async function saveSnapshotFromIntent(cmd, cwd, laneFlag, scopeFlag, defaultScop
 }
 function ledgerPath(start) {
   const intent = resolveIntentPath(start);
-  const dir = intent ? dirname12(intent) : join14(start, ".sechroom");
-  return join14(dir, ".checkpoint-state.json");
+  const dir = intent ? dirname13(intent) : join15(start, ".sechroom");
+  return join15(dir, ".checkpoint-state.json");
 }
 function readLedger(start) {
   try {
     const p = ledgerPath(start);
-    if (!existsSync11(p)) return {};
-    return JSON.parse(readFileSync10(p, "utf8"));
+    if (!existsSync12(p)) return {};
+    return JSON.parse(readFileSync11(p, "utf8"));
   } catch {
     return {};
   }
@@ -6968,7 +7689,7 @@ function intentHash(i) {
     artifacts: i.artifacts ?? [],
     confidence: i.confidence ?? null
   });
-  return createHash3("sha256").update(canonical, "utf8").digest("hex");
+  return createHash4("sha256").update(canonical, "utf8").digest("hex");
 }
 function recentlyCheckpointed(start, minutes) {
   const { lastEpochMs } = readLedger(start);
@@ -6980,7 +7701,7 @@ function unchangedSinceLastPush(start, intent) {
   const path = resolveIntentPath(start);
   if (path && ledger.lastMtimeMs != null) {
     try {
-      if (statSync2(path).mtimeMs <= ledger.lastMtimeMs) return true;
+      if (statSync3(path).mtimeMs <= ledger.lastMtimeMs) return true;
     } catch {
     }
   }
@@ -6992,17 +7713,17 @@ function recordPush(start, intent) {
     const path = resolveIntentPath(start);
     let mtimeMs;
     try {
-      if (path) mtimeMs = statSync2(path).mtimeMs;
+      if (path) mtimeMs = statSync3(path).mtimeMs;
     } catch {
       mtimeMs = void 0;
     }
-    mkdirSync13(dirname12(p), { recursive: true });
+    mkdirSync14(dirname13(p), { recursive: true });
     const ledger = {
       lastEpochMs: Date.now(),
       lastMtimeMs: mtimeMs,
       lastHash: intentHash(intent)
     };
-    writeFileSync12(p, JSON.stringify(ledger) + "\n");
+    writeFileSync13(p, JSON.stringify(ledger) + "\n");
   } catch {
   }
 }
@@ -7070,18 +7791,34 @@ Fail-soft: failures exit 0 and never block; session-context refresh failures ren
       installLaneCommitHook(cwd);
       const semPath = resolveSemPathForRead(cwd);
       if (semPath) ensureContinuityScaffold(semPath);
-      let dynamic = writeSessionContext(cwd, lane, {
-        status: "hold",
-        workspaceId: null,
-        reason: "SESSION_CONTEXT_UNAVAILABLE: the session-start hook could not refresh the pinned context (transport or authentication failure).",
-        members: []
-      });
+      const globals = cmd.optsWithGlobals();
+      const materialisationOptions = {
+        codexHomeOverride: globals.codexHome
+      };
+      let dynamic = writeSessionContext(
+        cwd,
+        lane,
+        {
+          status: "hold",
+          workspaceId: null,
+          reason: "SESSION_CONTEXT_UNAVAILABLE: the session-start hook could not refresh the pinned context (transport or authentication failure).",
+          members: [],
+          skills: []
+        },
+        materialisationOptions
+      );
       let continuity = null;
       try {
-        const cfg = resolveConfig(cmd.optsWithGlobals(), cwd);
+        const cfg = resolveConfig(globals, cwd);
         const client = await makeClient(cfg);
         try {
-          dynamic = await materializeSessionContext(client, cfg, lane, cwd);
+          dynamic = await materializeSessionContext(
+            client,
+            cfg,
+            lane,
+            cwd,
+            materialisationOptions
+          );
         } catch {
         }
         try {
@@ -7285,10 +8022,10 @@ Examples:
       const client = await makeClient(cfg);
       return client.POST("/continuity/snapshots", { body });
     });
-    const path = resolveIntentPath(cwd) ?? join15(cwd, INTENT_FILE);
+    const path = resolveIntentPath(cwd) ?? join16(cwd, INTENT_FILE);
     const fileBody = { ...merged, scope, lastSnapshotId: data.snapshotId };
-    mkdirSync14(dirname13(path), { recursive: true });
-    writeFileSync13(path, JSON.stringify(fileBody, null, 2) + "\n");
+    mkdirSync15(dirname14(path), { recursive: true });
+    writeFileSync14(path, JSON.stringify(fileBody, null, 2) + "\n");
     recordPush(cwd, merged);
     if (json) {
       emit({ snapshotId: data.snapshotId, lane, scope, file: path }, true);
@@ -7302,7 +8039,7 @@ Examples:
 }
 
 // src/commands/close.ts
-import { readFileSync as readFileSync11 } from "fs";
+import { readFileSync as readFileSync12 } from "fs";
 var VERDICTS = ["pass", "soft-fail", "plan-invalid", "blocked"];
 function registerClose(program2) {
   program2.command("close").description(
@@ -7343,7 +8080,7 @@ Examples:
       );
     let bodyText;
     try {
-      bodyText = opts.file ? readFileSync11(opts.file, "utf8") : readFileSync11(0, "utf8");
+      bodyText = opts.file ? readFileSync12(opts.file, "utf8") : readFileSync12(0, "utf8");
     } catch {
       fail(
         opts.file ? `could not read --file ${opts.file}` : "no closeout body \u2014 pass --file <path> or pipe it on stdin"
@@ -7475,7 +8212,9 @@ Examples:
 
 // src/commands/continuity.ts
 function registerContinuity(program2) {
-  const continuity = program2.command("continuity").description("Continuity snapshots: checkpoint and resume work");
+  const continuity = program2.command("continuity").description(
+    "Continuity snapshots: checkpoint, resume, and recover displaced work"
+  );
   continuity.addHelpText(
     "after",
     `
@@ -7488,7 +8227,13 @@ Examples:
   $ sechroom continuity snapshot-get csn_XXXX --json
   $ sechroom continuity resume-me --max-artifacts 20
   $ sechroom continuity changed-since --since 2026-06-01T00:00:00Z
-  $ sechroom continuity grant csn_XXXX --grantee usr_XXXX`
+  $ sechroom continuity grant csn_XXXX --grantee usr_XXXX
+
+Displaced snapshot recovery surfaces:
+  CLI discovery: sechroom continuity snapshots --lane <laneId> --json
+  CLI inspection: sechroom continuity snapshot-get <snapshotId> --json
+  MCP adoption: continuity_adopt_snapshot
+  Canonical long form: https://github.com/OcdLimited/sechroom/blob/main/frontend/apps/cli/DEVELOPMENT.md#recover-a-displaced-continuity-snapshot`
   );
   continuity.command("snapshot-create").description("Create a continuity snapshot (POST /continuity/snapshots)").requiredOption("--lane <laneId>", "Lane id (e.g. claude-code-chris)").requiredOption("--scope <scope>", "Snapshot scope (e.g. loop-spec)").requiredOption("--objective <text>", "Current objective").requiredOption("--state <text>", "Current state").requiredOption("--last-action <text>", "Last meaningful action").requiredOption("--next-action <text>", "Next intended action").requiredOption("--resume-instruction <text>", "Resume instruction").option("--constraint <text...>", "Active constraints (repeatable)").option("--question <text...>", "Open questions (repeatable)").option("--surface-marker <text...>", "Surface markers (repeatable)").option("--artifact <id...>", "Relevant artifact ids (repeatable)").option("--confidence <n>", "Confidence 0..1").action(async (opts, cmd) => {
     const cfg = resolveConfig(cmd.optsWithGlobals());
@@ -7513,15 +8258,30 @@ Examples:
     });
     emitAction(`created snapshot ${style.bold(data.snapshotId)}`, data, cmd.optsWithGlobals().json);
   });
-  continuity.command("snapshot-get <id>").description("Fetch a snapshot by id (GET /continuity/snapshots/{id})").action(async (id, _opts, cmd) => {
+  continuity.command("snapshot-get <id>").description(
+    "Fetch one of the caller's snapshots by id; use --all for the tenant-wide admin door"
+  ).option(
+    "--all",
+    "Use the tenant-wide Owner/Manager endpoint (GET /continuity/snapshots/{id})",
+    false
+  ).action(async (id, opts, cmd) => {
     const cfg = resolveConfig(cmd.optsWithGlobals());
     const data = await runApi("Fetching snapshot", async () => {
       const client = await makeClient(cfg);
-      return client.GET("/continuity/snapshots/{id}", { params: { path: { id } } });
+      const result = await client.GET(snapshotGetPath(Boolean(opts.all)), {
+        params: { path: { id } }
+      });
+      const hint = snapshotGetNotFoundHint(
+        Boolean(opts.all),
+        result.response.status
+      );
+      return hint ? { ...result, error: hint } : result;
     });
     emit(data, cmd.optsWithGlobals().json);
   });
-  continuity.command("snapshots").description("List the caller's own snapshots (GET /me/continuity/snapshots)").option("--scope <scope>", "Filter by scope").option("--lane <laneId>", "Filter by lane id").action(async (opts, cmd) => {
+  continuity.command("snapshots").description(
+    "List the caller's own snapshots, including displaced recovery candidates (GET /me/continuity/snapshots)"
+  ).option("--scope <scope>", "Filter by scope").option("--lane <laneId>", "Filter by lane id").action(async (opts, cmd) => {
     const cfg = resolveConfig(cmd.optsWithGlobals());
     const data = await runApi("Listing snapshots", async () => {
       const client = await makeClient(cfg);
@@ -7632,6 +8392,12 @@ Examples:
     );
   });
 }
+function snapshotGetPath(includeAll) {
+  return includeAll ? "/continuity/snapshots/{id}" : "/me/continuity/snapshots/{id}";
+}
+function snapshotGetNotFoundHint(includeAll, status) {
+  return !includeAll && status === 404 ? "Snapshot not found among your own snapshots. Owners and Managers can retry with --all to use the tenant-wide door." : void 0;
+}
 
 // src/commands/work-plan.ts
 import { readFile as readFile2 } from "fs/promises";
@@ -8033,13 +8799,13 @@ Examples:
 }
 
 // src/commands/herdr.ts
-import { readFileSync as readFileSync12 } from "fs";
+import { readFileSync as readFileSync13 } from "fs";
 import { basename as basename3 } from "path";
 
 // src/herdr/client.ts
 import { createConnection as createConnection2 } from "net";
 import { homedir as homedir5 } from "os";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 var DEFAULT_HERDR_SOCKET_RELATIVE = ".config/herdr/herdr.sock";
 var HerdrUnreachableError = class extends Error {
   constructor(socketPath, reason) {
@@ -8064,7 +8830,7 @@ function resolveSocketPath(flag, env = process.env, home = homedir5()) {
   if (fromFlag) return fromFlag;
   const fromEnv = env.HERDR_SOCKET?.trim();
   if (fromEnv) return fromEnv;
-  return join16(home, DEFAULT_HERDR_SOCKET_RELATIVE);
+  return join17(home, DEFAULT_HERDR_SOCKET_RELATIVE);
 }
 function expandTarget(target) {
   const trimmed = target.trim();
@@ -8287,19 +9053,19 @@ function herdrStream(socketPath, subscriptions, onEvent, options = {}) {
   });
 }
 function abortableSleep(milliseconds, signal) {
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     if (signal?.aborted) {
-      resolve8();
+      resolve9();
       return;
     }
     let timer;
     const onAbort = () => {
       clearTimeout(timer);
-      resolve8();
+      resolve9();
     };
     timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve8();
+      resolve9();
     }, milliseconds);
     signal?.addEventListener("abort", onAbort, { once: true });
   });
@@ -8322,6 +9088,7 @@ var HERDR_READ_SOURCES = [
 ];
 var DEFAULT_READ_LINES = 40;
 var DEFAULT_READ_SOURCE = "recent";
+var DEFAULT_WAIT_STATUSES = ["idle", "done"];
 var TITLE_WIDTH = 48;
 var STREAM_HEALTHY_MS = 3e4;
 var WAIT_FOR_PANES_MAX_MS = 5e3;
@@ -8402,7 +9169,7 @@ function parseSource(value, fallback = DEFAULT_READ_SOURCE) {
   }
   return match;
 }
-function resolveSendText(textArgs, useStdin, readStdin5 = () => readFileSync12(0, "utf8")) {
+function resolveSendText(textArgs, useStdin, readStdin5 = () => readFileSync13(0, "utf8")) {
   if (useStdin) {
     if (textArgs.length > 0) {
       throw new Error(
@@ -8550,6 +9317,176 @@ async function runSend(ports, target, text2, json) {
     json
   );
 }
+function parseWaitStatuses(values) {
+  const statuses = (values ?? [...DEFAULT_WAIT_STATUSES]).flatMap((value) => value.split(",")).map((value) => value.trim().toLowerCase()).filter((value) => value.length > 0);
+  if (statuses.length === 0) {
+    throw new Error("--until expects at least one status");
+  }
+  return new Set(statuses);
+}
+function parseWaitTimeout(value) {
+  if (value === void 0) return void 0;
+  const seconds = Number(value);
+  if (!Number.isFinite(seconds) || seconds <= 0) {
+    throw new Error(
+      `--timeout expects a positive number of seconds (got '${value}')`
+    );
+  }
+  return seconds;
+}
+var HerdrWaitTimeoutError = class extends Error {
+  constructor(timeoutSeconds, targets, statuses) {
+    super(
+      `herdr wait timed out after ${timeoutSeconds}s waiting for ${targets.join(", ")} to reach ${statuses.join(", ")}`
+    );
+    this.timeoutSeconds = timeoutSeconds;
+    this.targets = targets;
+    this.statuses = statuses;
+    this.name = "HerdrWaitTimeoutError";
+  }
+  timeoutSeconds;
+  targets;
+  statuses;
+};
+function formatWaitRecord(record) {
+  return `${record.pane_id} ${record.cwd?.trim() || "?"} [${agentLabel(record, record.pane_id)}]: ${displayStatus(record.agent_status)}`;
+}
+async function runWait(ports, targets, options) {
+  const targetIds = [...new Set(targets.map(expandTarget))];
+  const statuses = parseWaitStatuses(options.statuses);
+  const timeoutSeconds = options.timeoutSeconds;
+  const write = options.write ?? ((line) => process.stdout.write(`${line}
+`));
+  const warn2 = options.warn ?? ((line) => process.stderr.write(`${line}
+`));
+  const now = options.now ?? Date.now;
+  const controller = new AbortController();
+  let timedOut = false;
+  let completed = false;
+  const onExternalAbort = () => controller.abort();
+  if (options.signal?.aborted) return;
+  options.signal?.addEventListener("abort", onExternalAbort, { once: true });
+  const timeout2 = timeoutSeconds === void 0 ? void 0 : setTimeout(() => {
+    timedOut = true;
+    controller.abort();
+  }, timeoutSeconds * 1e3);
+  const aborted = /* @__PURE__ */ Symbol("aborted");
+  const abortPromise = new Promise((resolve9) => {
+    controller.signal.addEventListener("abort", () => resolve9(aborted), {
+      once: true
+    });
+  });
+  const raceAbort = (operation) => Promise.race([operation, abortPromise]);
+  const throwIfTimedOut = () => {
+    if (timedOut && timeoutSeconds !== void 0) {
+      throw new HerdrWaitTimeoutError(timeoutSeconds, targetIds, [...statuses]);
+    }
+  };
+  const remaining = new Set(targetIds);
+  let seed = /* @__PURE__ */ new Map();
+  let attempt = 0;
+  const settle = (agent, paneId, status) => {
+    if (!remaining.has(paneId)) return;
+    const record = {
+      agent: agent?.agent ?? "?",
+      ...agent,
+      pane_id: paneId,
+      agent_status: status
+    };
+    write(options.json ? JSON.stringify(record) : formatWaitRecord(record));
+    remaining.delete(paneId);
+    if (!options.all || remaining.size === 0) {
+      completed = true;
+      controller.abort();
+    }
+  };
+  try {
+    while (!controller.signal.aborted) {
+      try {
+        const listed = await raceAbort(
+          ports.request("agent.list", {})
+        );
+        if (listed === aborted) break;
+        const current = listed.agents ?? [];
+        const fresh = indexAgents(current);
+        for (const paneId of [...remaining]) {
+          const currentAgent = fresh.get(paneId);
+          if (currentAgent === void 0) {
+            settle(seed.get(paneId), paneId, "exited");
+            continue;
+          }
+          const status = currentAgent.agent_status?.trim().toLowerCase();
+          if (status !== void 0 && statuses.has(status)) {
+            settle(currentAgent, paneId, currentAgent.agent_status ?? status);
+          }
+        }
+        seed = fresh;
+        if (completed || remaining.size === 0) return;
+        const subscriptions = buildWatchSubscriptions(
+          current.filter((agent) => remaining.has(agent.pane_id))
+        );
+        let carriedTraffic = false;
+        let relistNeeded = false;
+        const startedAt = now();
+        const cycle = new AbortController();
+        const stopCycle = () => cycle.abort();
+        controller.signal.addEventListener("abort", stopCycle, { once: true });
+        try {
+          const streamed = await raceAbort(
+            ports.stream(
+              subscriptions,
+              (raw) => {
+                carriedTraffic = true;
+                const event = normalizeWatchEvent(raw);
+                if (event === null || needsRelistFallback(event)) {
+                  relistNeeded = true;
+                  cycle.abort();
+                  return;
+                }
+                if (!remaining.has(event.paneId)) return;
+                const known = seed.get(event.paneId);
+                if (event.type === "pane.exited") {
+                  settle(known, event.paneId, "exited");
+                  return;
+                }
+                const status = event.to?.trim().toLowerCase();
+                if (known && event.to) known.agent_status = event.to;
+                if (status !== void 0 && statuses.has(status)) {
+                  settle(known, event.paneId, event.to ?? status);
+                }
+              },
+              {
+                signal: cycle.signal,
+                onWarning: (message) => warn2(`herdr wait: ${message}`)
+              }
+            )
+          );
+          if (streamed === aborted) break;
+        } finally {
+          controller.signal.removeEventListener("abort", stopCycle);
+        }
+        if (completed) return;
+        if (relistNeeded) continue;
+        if (carriedTraffic || now() - startedAt >= STREAM_HEALTHY_MS) {
+          attempt = 0;
+        }
+      } catch (error) {
+        throwIfTimedOut();
+        if (controller.signal.aborted) return;
+        warn2(`herdr wait: ${formatFailureMessage(error)}`);
+      }
+      if (controller.signal.aborted) break;
+      const delay = watchBackoffMs(attempt);
+      attempt += 1;
+      const slept = await raceAbort(ports.sleep(delay, controller.signal));
+      if (slept === aborted) break;
+    }
+    throwIfTimedOut();
+  } finally {
+    if (timeout2 !== void 0) clearTimeout(timeout2);
+    options.signal?.removeEventListener("abort", onExternalAbort);
+  }
+}
 async function runWatch(ports, options) {
   const write = options.write ?? ((line) => process.stdout.write(`${line}
 `));
@@ -8688,7 +9625,7 @@ function exitCleanlyOnBrokenPipe(stream, exit = (code) => process.exit(code), re
 }
 function registerHerdr(program2) {
   const herdr = program2.command("herdr").description(
-    "Drive local Herdr agents (herdr.dev) over its Unix-socket API \u2014 list, read, send, watch"
+    "Drive local Herdr agents (herdr.dev) over its Unix-socket API \u2014 list, read, send, wait, watch"
   );
   herdr.addHelpText(
     "after",
@@ -8701,6 +9638,10 @@ Examples:
   $ sechroom herdr read w6:p1 --source visible  only what's on screen
   $ sechroom herdr send w6 "run the tests and report back"
   $ cat brief.md | sechroom herdr send w6:p1 --stdin      long dispatch from stdin
+  $ sechroom herdr wait w3 w6                 return when either pane is idle or done
+  $ sechroom herdr wait w3 w6 --all           wait until both panes have settled
+  $ sechroom herdr wait w6 --until blocked --timeout 300
+  $ sechroom herdr wait w6 --json             machine-readable settling pane
   $ sechroom herdr watch                        live status transitions; Ctrl-C to stop
   $ sechroom herdr watch --json | jq .           one JSON object per event
 
@@ -8731,6 +9672,40 @@ AGPL \u2014 no Herdr code is vendored here.`
       fail(error);
     }
   });
+  withSocket(
+    herdr.command("wait <targets...>").description(
+      "Block until any target settles (idle or done by default); --all waits for every target"
+    ).option("--all", "Wait for every target instead of the first to settle").option(
+      "--until <status...>",
+      `Statuses that count as settled (default ${DEFAULT_WAIT_STATUSES.join(", ")})`
+    ).option("--timeout <seconds>", "Stop waiting after this many seconds")
+  ).action(async (targets, opts, cmd) => {
+    exitCleanlyOnBrokenPipe(process.stdout);
+    const controller = new AbortController();
+    const onSignal = () => controller.abort();
+    process.once("SIGINT", onSignal);
+    process.once("SIGTERM", onSignal);
+    try {
+      await runWait(portsFor(opts), targets, {
+        all: Boolean(opts.all),
+        json: Boolean(cmd.optsWithGlobals().json),
+        statuses: opts.until,
+        timeoutSeconds: parseWaitTimeout(opts.timeout),
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (error instanceof HerdrWaitTimeoutError) {
+        process.stderr.write(`error: ${error.message}
+`);
+        process.exitCode = 2;
+        return;
+      }
+      fail(error);
+    } finally {
+      process.off("SIGINT", onSignal);
+      process.off("SIGTERM", onSignal);
+    }
+  });
   withSocket(
     herdr.command("read <target>").description(
       `Print a pane's text (default ${DEFAULT_READ_LINES} lines, source ${DEFAULT_READ_SOURCE})`
@@ -8873,11 +9848,11 @@ Examples:
 }
 
 // src/commands/memory.ts
-import { readFileSync as readFileSync14 } from "fs";
+import { readFileSync as readFileSync15 } from "fs";
 
 // src/commands/memory-import.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync13, realpathSync, statSync as statSync3 } from "fs";
-import { basename as basename4, join as join17, resolve as resolve5 } from "path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync14, realpathSync, statSync as statSync4 } from "fs";
+import { basename as basename4, join as join18, resolve as resolve6 } from "path";
 var MARKDOWN_RE = /\.(md|markdown)$/i;
 function isMarkdownPath(path) {
   return MARKDOWN_RE.test(path);
@@ -8897,25 +9872,25 @@ function collectImportFiles(inputs, opts = {}) {
     try {
       key = realpathSync(path);
     } catch {
-      key = resolve5(path);
+      key = resolve6(path);
     }
     if (seen.has(key)) return;
     seen.add(key);
     files.push(path);
   };
   const walk = (dir) => {
-    const entries = readdirSync2(dir, { withFileTypes: true }).sort(
+    const entries = readdirSync3(dir, { withFileTypes: true }).sort(
       (a, b) => a.name.localeCompare(b.name)
     );
     for (const entry of entries) {
       if (entry.name.startsWith(".")) continue;
-      const child = join17(dir, entry.name);
+      const child = join18(dir, entry.name);
       let isDirectory = entry.isDirectory();
       let isFile = entry.isFile();
       if (entry.isSymbolicLink()) {
         let target;
         try {
-          target = statSync3(child);
+          target = statSync4(child);
         } catch {
           skipped.push({ path: child, reason: "broken symlink" });
           continue;
@@ -8953,7 +9928,7 @@ function collectImportFiles(inputs, opts = {}) {
   for (const input of inputs) {
     let isDirectory;
     try {
-      isDirectory = statSync3(input).isDirectory();
+      isDirectory = statSync4(input).isDirectory();
     } catch {
       missing.push(input);
       continue;
@@ -8969,7 +9944,7 @@ function buildImportPlan(collected) {
   for (const path of collected.files) {
     let text2;
     try {
-      text2 = readFileSync13(path, "utf8");
+      text2 = readFileSync14(path, "utf8");
     } catch (error) {
       throw new Error(
         `couldn't read ${path}: ${error instanceof Error ? error.message : String(error)}`
@@ -9070,7 +10045,7 @@ function resolveCreateBody(textOpt, fileOpt) {
   }
   if (textOpt != null) return { text: textOpt, defaultTitle: null };
   const fromStdin = fileOpt === "-";
-  const text2 = fromStdin ? readFileSync14(0, "utf8") : readFileSync14(String(fileOpt), "utf8");
+  const text2 = fromStdin ? readFileSync15(0, "utf8") : readFileSync15(String(fileOpt), "utf8");
   if (text2.trim().length === 0) {
     fail(fromStdin ? "Stdin was empty." : `File is empty: ${fileOpt}`);
   }
@@ -9689,16 +10664,17 @@ ${plan.rows.map(
 }
 
 // src/setup/apply.ts
-import { createHash as createHash4 } from "crypto";
-import { mkdirSync as mkdirSync15, readFileSync as readFileSync15, writeFileSync as writeFileSync14, existsSync as existsSync12 } from "fs";
-import { dirname as dirname14 } from "path";
+import { createHash as createHash5 } from "crypto";
+import { mkdirSync as mkdirSync16, readFileSync as readFileSync16, writeFileSync as writeFileSync15, existsSync as existsSync13 } from "fs";
+import { dirname as dirname15 } from "path";
 var MARKER_BEGIN = "<!-- @sechroom/cli:begin";
 var MARKER_END = "<!-- @sechroom/cli:end";
+var BOOTSTRAP_STUB_REFUSAL = "This file carries pointers only";
 function normalizeBody(s) {
   return s.replace(/\r\n/g, "\n").trim();
 }
 function bodySha256(body) {
-  return createHash4("sha256").update(normalizeBody(body), "utf8").digest("hex");
+  return createHash5("sha256").update(normalizeBody(body), "utf8").digest("hex");
 }
 function renderBlock(write) {
   const body = normalizeBody(write.body);
@@ -9744,22 +10720,22 @@ function parseManagedBlock(content, block) {
   return null;
 }
 function ensureDir2(path) {
-  mkdirSync15(dirname14(path), { recursive: true });
+  mkdirSync16(dirname15(path), { recursive: true });
 }
 function readOr(path, fallback) {
   try {
-    return readFileSync15(path, "utf8");
+    return readFileSync16(path, "utf8");
   } catch {
     return fallback;
   }
 }
 function mergeMcpJson(path, snippet, dryRun) {
   const incoming = JSON.parse(snippet);
-  const existed = existsSync12(path);
+  const existed = existsSync13(path);
   let current = {};
   if (existed) {
     try {
-      current = JSON.parse(readFileSync15(path, "utf8"));
+      current = JSON.parse(readFileSync16(path, "utf8"));
     } catch {
       return { kind: "mcp", path, status: "skipped", note: "existing file isn't valid JSON \u2014 left untouched" };
     }
@@ -9767,27 +10743,27 @@ function mergeMcpJson(path, snippet, dryRun) {
   current.mcpServers = { ...current.mcpServers ?? {}, ...incoming.mcpServers ?? {} };
   if (dryRun) return { kind: "mcp", path, status: "dry-run" };
   ensureDir2(path);
-  writeFileSync14(path, JSON.stringify(current, null, 2) + "\n", { mode: 384 });
+  writeFileSync15(path, JSON.stringify(current, null, 2) + "\n", { mode: 384 });
   return { kind: "mcp", path, status: existed ? "merged" : "created" };
 }
 function mergeCodexToml(path, snippet, dryRun) {
-  const existed = existsSync12(path);
+  const existed = existsSync13(path);
   let body = readOr(path, "");
   body = body.replace(/(^|\n)\[mcp_servers\.sechroom\][^[]*/, "\n").replace(/\n{3,}/g, "\n\n");
   const trimmed = body.trim();
   const next = (trimmed.length > 0 ? trimmed + "\n\n" : "") + snippet.trim() + "\n";
   if (dryRun) return { kind: "mcp", path, status: "dry-run" };
   ensureDir2(path);
-  writeFileSync14(path, next, { mode: 384 });
+  writeFileSync15(path, next, { mode: 384 });
   return { kind: "mcp", path, status: existed ? "merged" : "created" };
 }
 function writeInstructionBlock(path, write, dryRun) {
-  const existed = existsSync12(path);
+  const existed = existsSync13(path);
   const next = computeBlockFile(readOr(path, ""), write);
-  if (dryRun) return { kind: "instruction", path, status: "dry-run" };
+  if (dryRun) return { kind: "instruction", path, status: "dry-run", block: write.block };
   ensureDir2(path);
-  writeFileSync14(path, next);
-  return { kind: "instruction", path, status: existed ? "merged" : "created" };
+  writeFileSync15(path, next);
+  return { kind: "instruction", path, status: existed ? "merged" : "created", block: write.block };
 }
 function computeBlockFile(current, write) {
   const rendered = renderBlock(write);
@@ -9802,7 +10778,12 @@ ${rendered}` : rendered;
 }
 function evaluateBlock(content, block, serverBody) {
   const onDisk = parseManagedBlock(content, block);
-  if (!onDisk) return "absent";
+  if (!onDisk) {
+    const hasManagedMarker = content.includes(MARKER_BEGIN) || content.includes(MARKER_END);
+    if (!hasManagedMarker && content.includes(BOOTSTRAP_STUB_REFUSAL))
+      return "stub";
+    return "absent";
+  }
   const actual = bodySha256(onDisk.body);
   if (onDisk.sha256 && actual !== onDisk.sha256) return "drift";
   return actual === bodySha256(serverBody) ? "current" : "stale";
@@ -9816,24 +10797,36 @@ function applyBlock(path, write, mode, dryRun) {
       path,
       status: state === "current" ? "current" : "skipped",
       eval: state,
-      note: state === "current" ? void 0 : `would ${state === "absent" ? "write" : "refresh"} (${state})`
+      block: write.block,
+      note: state === "current" ? void 0 : state === "stub" ? "dynamic chain pointer file \u2014 no static managed block to check" : `would ${state === "absent" ? "write" : "refresh"} (${state})`
+    };
+  }
+  if (state === "stub") {
+    return {
+      kind: "instruction",
+      path,
+      status: "skipped",
+      eval: "stub",
+      block: write.block,
+      note: "dynamic chain pointer file \u2014 managed blocks were not written"
     };
   }
   if (state === "current") {
-    return { kind: "instruction", path, status: "current", eval: "current" };
+    return { kind: "instruction", path, status: "current", eval: "current", block: write.block };
   }
   if (state === "drift" && mode !== "force") {
     const proposedPath = `${path}.proposed`;
     const next = computeBlockFile(current, write);
     if (!dryRun) {
       ensureDir2(proposedPath);
-      writeFileSync14(proposedPath, next);
+      writeFileSync15(proposedPath, next);
     }
     return {
       kind: "instruction",
       path,
       status: "skipped",
       eval: "drift",
+      block: write.block,
       proposedPath,
       note: `local edits \u2014 wrote ${proposedPath} (original left untouched)`
     };
@@ -9957,8 +10950,8 @@ auto-resumes where you left off and checkpoints working state before compacting.
 }
 
 // src/setup/skills-offer.ts
-import { mkdirSync as mkdirSync16, writeFileSync as writeFileSync15 } from "fs";
-import { join as join18 } from "path";
+import { mkdirSync as mkdirSync17, writeFileSync as writeFileSync16 } from "fs";
+import { join as join19 } from "path";
 
 // src/setup/lane-pin.ts
 var CODE_LANE_PREFIX_BY_CLIENT = {
@@ -10074,8 +11067,8 @@ Found ${summary} available to you for ${surface}.
   if (skills.length > 0) {
     const written = [];
     for (const s of skills) {
-      mkdirSync16(join18(sDir, s.name), { recursive: true });
-      writeFileSync15(join18(sDir, s.name, "SKILL.md"), s.body.endsWith("\n") ? s.body : s.body + "\n");
+      mkdirSync17(join19(sDir, s.name), { recursive: true });
+      writeFileSync16(join19(sDir, s.name, "SKILL.md"), s.body.endsWith("\n") ? s.body : s.body + "\n");
       written.push(s.name);
     }
     recordMaterialisedSkills(sDir, DEFAULT_SKILLS_SLUG, written, { surface });
@@ -10083,11 +11076,11 @@ Found ${summary} available to you for ${surface}.
 `);
   }
   if (agents.length > 0) {
-    mkdirSync16(aDir, { recursive: true });
+    mkdirSync17(aDir, { recursive: true });
     const written = [];
     for (const a of agents) {
       const file = `${a.name}.md`;
-      writeFileSync15(join18(aDir, file), a.body.endsWith("\n") ? a.body : a.body + "\n");
+      writeFileSync16(join19(aDir, file), a.body.endsWith("\n") ? a.body : a.body + "\n");
       written.push(file);
     }
     recordMaterialisedSkills(aDir, DEFAULT_SKILLS_SLUG, written, { surface });
@@ -10102,6 +11095,21 @@ Found ${summary} available to you for ${surface}.
 }
 
 // src/commands/setup.ts
+var CONVENTION_REGEN_CLIENTS = ["claude-code", "codex"];
+function buildConventionDraft(title, rawKind, rawBody) {
+  const kind = String(rawKind).toLowerCase() === "standard" ? "standard" : "reference";
+  const body = typeof rawBody === "string" && rawBody.trim().length > 0 ? rawBody.trim() : "_TODO: write this section, then edit the memo and re-run the regen._";
+  return {
+    title,
+    kind,
+    body,
+    text: `# ${title}
+
+${body}
+`,
+    tags: ["agent-setup-bundle", "scope:sechroom", `kind:${kind}`, "archetype:document"]
+  };
+}
 function copyChoice(opts) {
   return opts.copy === true ? "yes" : opts.copy === false ? "no" : "ask";
 }
@@ -10158,27 +11166,72 @@ ${client.label} (${client.key}):
 function resolveEvalMode(opts) {
   return opts.check ? "check" : opts.force ? "force" : "apply";
 }
-function summarizeEval(result, mode, json, dryRun) {
-  const counts = { current: 0, stale: 0, drift: 0, absent: 0 };
-  for (const { actions } of result) for (const a of actions) if (a.eval) counts[a.eval]++;
-  const wouldChange = counts.stale + counts.drift + counts.absent;
-  if (mode === "check") {
-    if (!json) {
-      if (wouldChange === 0) {
-        process.stdout.write("\u2713 all instruction blocks are up to date.\n");
-      } else {
-        const bits = [];
-        if (counts.stale) bits.push(`${counts.stale} out of date`);
-        if (counts.drift) bits.push(`${counts.drift} with local edits`);
-        if (counts.absent) bits.push(`${counts.absent} not yet written`);
-        process.stderr.write(
-          `\u26A0 ${wouldChange} instruction block(s) would change: ${bits.join(", ")}. Re-run with ${style.cyan("--refresh")}.
+function buildCheckReport(result) {
+  const counts = {
+    current: 0,
+    stale: 0,
+    drift: 0,
+    absent: 0,
+    stub: 0
+  };
+  const blocks = [];
+  for (const { client, actions } of result) {
+    for (const action of actions) {
+      if (!action.eval) continue;
+      counts[action.eval]++;
+      blocks.push({
+        client,
+        path: action.path,
+        block: action.block ?? "unknown",
+        state: action.eval
+      });
+    }
+  }
+  return {
+    eval: counts,
+    wouldChange: counts.stale + counts.drift + counts.absent,
+    blocks
+  };
+}
+function reportCheckAndExit(result, json, refreshCommand, jsonContext = {}) {
+  const report = buildCheckReport(result);
+  if (json) {
+    emit(
+      {
+        check: true,
+        ...jsonContext,
+        ...report,
+        clients: result
+      },
+      true
+    );
+  } else if (report.wouldChange === 0) {
+    if (report.eval.stub) {
+      const files = report.eval.stub === 1 ? "file" : "files";
+      process.stdout.write(
+        `\u2713 ${report.eval.stub} dynamic chain pointer ${files}; no static managed blocks to check.
 `
-        );
-      }
+      );
+    } else {
+      process.stdout.write("\u2713 all instruction blocks are up to date.\n");
     }
-    process.exit(wouldChange === 0 ? 0 : 1);
+  } else {
+    const bits = [];
+    if (report.eval.stale) bits.push(`${report.eval.stale} out of date`);
+    if (report.eval.drift) bits.push(`${report.eval.drift} with local edits`);
+    if (report.eval.absent) bits.push(`${report.eval.absent} not yet written`);
+    process.stderr.write(
+      `\u26A0 ${report.wouldChange} instruction block(s) would change: ${bits.join(", ")}. Run ${style.cyan(refreshCommand)}.
+`
+    );
+  }
+  process.exit(report.wouldChange === 0 ? 0 : 1);
+}
+function summarizeEval(result, mode, json, dryRun) {
+  if (mode === "check") {
+    reportCheckAndExit(result, json, "--refresh");
   }
+  const { eval: counts } = buildCheckReport(result);
   if (json) return;
   if (!dryRun && counts.stale) {
     process.stderr.write(`\u21BB refreshed ${counts.stale} section(s) the server had moved
@@ -10213,7 +11266,7 @@ async function resolveNamespaceChoice(cfg, flag) {
   return picked === GLOBAL_NAMESPACE ? null : picked;
 }
 function registerInit(program2) {
-  program2.command("init").description("Wire this project for sechroom: write MCP config + agent instruction files from the server's setup descriptors").option("--client <list...>", `clients to wire \u2014 space- or comma-separated (${ALL_CLIENT_KEYS.join(", ")}) or 'all'`, DEFAULT_CLIENT_KEY).option("--scope <scope>", "install skills/agents/hooks 'global' (config dir / CLAUDE_CONFIG_DIR) or 'project' (<cwd>/.claude) \u2014 default global", "global").option("--dry-run", "print what would be written without writing", false).option("--mcp-only", "only write MCP config (skip agent files)", false).option("--agent-files-only", "only write agent instruction files (skip MCP config)", false).option("--copy", "make a personal copy of the agent instructions you can edit (default: prompt on a TTY, else skip)").option("--namespace <slug>", "MCP namespace for the connection URL (interactive picker if omitted on a TTY; defaults to tenant-global)").option("--refresh", "refresh out-of-date agent-file blocks in place (local edits preserved to .proposed)", false).option("--force", "rewrite agent-file managed blocks, overwriting local edits inside the markers", false).option("--check", "report whether agent files would change and exit (0 = current, 1 = stale/drift/absent); writes nothing", false).addHelpText(
+  program2.command("init").description("Wire this project for sechroom: write MCP config + agent instruction files from the server's setup descriptors").option("--client <list...>", `clients to wire \u2014 space- or comma-separated (${ALL_CLIENT_KEYS.join(", ")}) or 'all'`, DEFAULT_CLIENT_KEY).option("--scope <scope>", "install skills/agents/hooks 'global' (config dir / CLAUDE_CONFIG_DIR) or 'project' (<cwd>/.claude) \u2014 default global", "global").option("--dry-run", "print what would be written without writing", false).option("--mcp-only", "only write MCP config (skip agent files)", false).option("--agent-files-only", "only write agent instruction files (skip MCP config)", false).option("--copy", "make a personal copy of the agent instructions you can edit (default: prompt on a TTY, else skip)").option("--namespace <slug>", "MCP namespace for the connection URL (interactive picker if omitted on a TTY; defaults to tenant-global)").option("--refresh", "refresh out-of-date agent-file blocks in place (local edits preserved to .proposed)", false).option("--force", "rewrite agent-file managed blocks, overwriting local edits inside the markers", false).option("--check", "report whether agent files would change and exit (0 = current/stub, 1 = stale/drift/absent); writes nothing", false).addHelpText(
     "after",
     `
 Examples:
@@ -10221,11 +11274,15 @@ Examples:
   $ sechroom init --client all          claude-code, claude-desktop, codex, cursor, antigravity
   $ sechroom init --client codex cursor   space-separated (comma also works)
   $ sechroom init --mcp-only            just the MCP config (skip agent files)
+  $ sechroom init --agent-files-only --check   CI gate: nonzero exit if agent files are out of date
   $ sechroom init --dry-run --json      preview the writes, change nothing`
   ).action(async (opts, cmd) => {
     const cfg = resolveConfig(cmd.optsWithGlobals());
     const mode = resolveEvalMode(opts);
     const check = mode === "check";
+    if (check && opts.mcpOnly) {
+      fail("--check inspects agent files and cannot be combined with --mcp-only.");
+    }
     const namespaceSlug = await resolveNamespaceChoice(cfg, opts.namespace);
     const setup = await withSpinner(
       "Fetching setup descriptors",
@@ -10261,12 +11318,12 @@ Examples:
       if (!json && !check) printActions(target, actions);
     }
     summarizeEval(result, mode, Boolean(json), Boolean(opts.dryRun));
-    if (!json && !opts.dryRun && !opts.mcpOnly) {
+    if (!json && !opts.dryRun && !opts.mcpOnly && !check) {
       for (const t of claudeTargets) {
         await maybeOfferSkills(cfg, personalWorkspaceId, { yes: false, dryRun: Boolean(opts.dryRun), surface: "claude-code", configDir: t.dir });
       }
     }
-    if (!json && !opts.dryRun && !opts.mcpOnly) {
+    if (!json && !opts.dryRun && !opts.mcpOnly && !check) {
       await maybeOfferHooks({ yes: false, dryRun: Boolean(opts.dryRun), cwd: process.cwd(), scope, claudeConfigDir: g.claudeConfigDir, codexHome: g.codexHome });
     }
     if (json) {
@@ -10286,12 +11343,12 @@ Next \u2014 verify: ${verify.description}
     );
   });
 }
-function registerSetup(program2) {
+function registerSetup(program2, deps = {}) {
   const setup = program2.command("setup").description("Granular onboarding steps (init runs these together)");
   setup.command("mcp <clients...>").description(`Write only the MCP config for one or more clients (${ALL_CLIENT_KEYS.join(", ")}, or 'all')`).option("--dry-run", "print what would be written without writing", false).option("--namespace <slug>", "MCP namespace for the connection URL (interactive picker if omitted on a TTY; defaults to tenant-global)").addHelpText("after", "\nExamples:\n  $ sechroom setup mcp codex\n  $ sechroom setup mcp claude-code codex\n  $ sechroom setup mcp all").action(async (clients, opts, cmd) => {
     await runClients(clients, cmd, { dryRun: Boolean(opts.dryRun), mcp: true, agentFiles: false, namespace: opts.namespace });
   });
-  setup.command("agent-files <clients...>").description(`Write only the agent instruction file(s) for one or more clients (${ALL_CLIENT_KEYS.join(", ")}, or 'all')`).option("--dry-run", "print what would be written without writing", false).option("--copy", "make a personal copy you can edit (default: prompt on a TTY, else skip)").option("--refresh", "refresh out-of-date blocks in place (local edits preserved to .proposed)", false).option("--force", "rewrite managed blocks, overwriting local edits inside the markers", false).option("--check", "report whether anything would change and exit (0 = current, 1 = stale/drift/absent); writes nothing", false).addHelpText("after", "\nExamples:\n  $ sechroom setup agent-files claude-code        CLAUDE.md\n  $ sechroom setup agent-files claude-code codex  CLAUDE.md + AGENTS.md in one run\n  $ sechroom setup agent-files all --check        CI gate: nonzero exit if out of date\n  $ sechroom setup agent-files claude-code --force   overwrite local edits in the managed block").action(async (clients, opts, cmd) => {
+  setup.command("agent-files <clients...>").description(`Write only the agent instruction file(s) for one or more clients (${ALL_CLIENT_KEYS.join(", ")}, or 'all')`).option("--dry-run", "print what would be written without writing", false).option("--copy", "make a personal copy you can edit (default: prompt on a TTY, else skip)").option("--refresh", "refresh out-of-date blocks in place (local edits preserved to .proposed)", false).option("--force", "rewrite managed blocks, overwriting local edits inside the markers", false).option("--check", "report whether anything would change and exit (0 = current/stub, 1 = stale/drift/absent); writes nothing", false).addHelpText("after", "\nExamples:\n  $ sechroom setup agent-files claude-code        CLAUDE.md\n  $ sechroom setup agent-files claude-code codex  CLAUDE.md + AGENTS.md in one run\n  $ sechroom setup agent-files all --check        CI gate: nonzero exit if out of date\n  $ sechroom setup agent-files claude-code --force   overwrite local edits in the managed block").action(async (clients, opts, cmd) => {
     await runClients(clients, cmd, { dryRun: Boolean(opts.dryRun), mcp: false, agentFiles: true, copy: opts.copy, mode: resolveEvalMode(opts) });
   });
   setup.command("new-convention <title...>").description("Scaffold a workspace-conventions section: author a correctly-tagged memo (header as first body line) + regen the agent files").option("--kind <kind>", "reference | standard (orders the section; reference first)", "reference").option("--workspace <id>", "workspace to author in (default: the bound workspace)").option("--body <markdown>", "section body (default: a TODO scaffold to edit later)").option("--no-regen", "skip the agent-files regen after authoring").option("--dry-run", "print what would be authored; write nothing", false).addHelpText(
@@ -10314,29 +11371,33 @@ Examples:
     const workspaceId = opts.workspace ?? cfg.workspaceId;
     if (!workspaceId)
       fail("no workspace \u2014 pass --workspace <id> or bind one (`sechroom config set --local workspaceId <id>`).");
-    const kind = String(opts.kind).toLowerCase() === "standard" ? "standard" : "reference";
-    const body = typeof opts.body === "string" && opts.body.trim().length > 0 ? opts.body.trim() : "_TODO: write this section, then edit the memo and re-run the regen._";
-    const text2 = `# ${title}
-
-${body}
-`;
-    const tags = ["agent-setup-bundle", "scope:sechroom", `kind:${kind}`, "archetype:document"];
+    const draft = buildConventionDraft(title, opts.kind, opts.body);
     if (opts.dryRun) {
-      emit({ dryRun: true, workspaceId, title, kind, tags, text: text2 }, json);
+      emit(
+        {
+          dryRun: true,
+          workspaceId,
+          title: draft.title,
+          kind: draft.kind,
+          tags: draft.tags,
+          text: draft.text
+        },
+        json
+      );
       return;
     }
-    const data = await runApi("Authoring convention memo", async () => {
+    const data = deps.authorConvention ? await deps.authorConvention({ cfg, draft, workspaceId }) : await runApi("Authoring convention memo", async () => {
       const client = await makeClient(cfg);
       return client.POST("/memories", {
         body: {
-          text: text2,
-          type: kind,
+          text: draft.text,
+          type: draft.kind,
           content: "{}",
           confidence: 1,
           source: "cli-new-convention",
           archetype: "Document",
-          title,
-          tags,
+          title: draft.title,
+          tags: draft.tags,
           owner: { type: "Workspace", id: workspaceId }
         }
       });
@@ -10353,7 +11414,8 @@ ${body}
       else process.stdout.write("Skipped regen (--no-regen). Run `sechroom setup agent-files all` to apply.\n");
       return;
     }
-    await runClients(["claude-code", "codex"], cmd, {
+    const regenerate = deps.regenerateConvention ?? runClients;
+    await regenerate([...CONVENTION_REGEN_CLIENTS], cmd, {
       dryRun: false,
       mcp: false,
       agentFiles: true,
@@ -10470,13 +11532,13 @@ Wired to namespace '${slug2}'. Restart your AI client (or reload MCP) to pick it
 }
 
 // src/commands/onboard.ts
-import { existsSync as existsSync14 } from "fs";
-import { basename as basename5, join as join20 } from "path";
+import { existsSync as existsSync15 } from "fs";
+import { basename as basename5, join as join21 } from "path";
 
 // src/commands/fanout.ts
 import { spawnSync } from "child_process";
-import { existsSync as existsSync13, readFileSync as readFileSync16, readdirSync as readdirSync3, statSync as statSync4 } from "fs";
-import { isAbsolute as isAbsolute2, join as join19, resolve as resolve6 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync17, readdirSync as readdirSync4, statSync as statSync5 } from "fs";
+import { isAbsolute as isAbsolute3, join as join20, resolve as resolve7 } from "path";
 var ICON = {
   refresh: "\u21BB",
   bind: "+",
@@ -10484,33 +11546,33 @@ var ICON = {
   "skip-unbound": "\u26A0"
 };
 function resolveChildDir(path, root) {
-  return isAbsolute2(path) ? path : resolve6(root, path);
+  return isAbsolute3(path) ? path : resolve7(root, path);
 }
 function discoverChildren(root) {
   let names;
   try {
-    names = readdirSync3(root);
+    names = readdirSync4(root);
   } catch {
     return [];
   }
   const out = [];
   for (const name of names.sort()) {
     if (name.startsWith(".") || name === "node_modules") continue;
-    const dir = join19(root, name);
+    const dir = join20(root, name);
     try {
-      if (!statSync4(dir).isDirectory()) continue;
+      if (!statSync5(dir).isDirectory()) continue;
     } catch {
       continue;
     }
-    if (existsSync13(join19(dir, ".git")) || committedBindingPath(dir)) out.push(name);
+    if (existsSync14(join20(dir, ".git")) || committedBindingPath(dir)) out.push(name);
   }
   return out;
 }
 function readManifest(path) {
-  if (!existsSync13(path)) return null;
+  if (!existsSync14(path)) return null;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync16(path, "utf8"));
+    parsed = JSON.parse(readFileSync17(path, "utf8"));
   } catch (err2) {
     throw new Error(`couldn't parse ${path}: ${err2 instanceof Error ? err2.message : String(err2)}`);
   }
@@ -10876,10 +11938,10 @@ async function chooseScope(scopeFlag, yes) {
 }
 async function planRecurseChild(entry, root, client, opts) {
   const dir = resolveChildDir(entry.path, root);
-  if (!existsSync14(dir)) {
+  if (!existsSync15(dir)) {
     return { label: entry.path, dir, disposition: "skip-missing", argv: [], reason: "directory does not exist" };
   }
-  if (existsSync14(join20(dir, ".sechroom.json"))) {
+  if (existsSync15(join21(dir, ".sechroom.json"))) {
     return {
       label: entry.path,
       dir,
@@ -10952,7 +12014,7 @@ This fan-out will pin the same lane in every repo:
 async function runRecurse(cfg, g, opts) {
   const { yes, dryRun, json } = opts;
   const root = process.cwd();
-  const manifestPath = join20(root, ".sechroom", "repos.json");
+  const manifestPath = join21(root, ".sechroom", "repos.json");
   const fromManifest = readManifest(manifestPath);
   const entries = fromManifest ?? discoverChildren(root).map((path) => ({ path }));
   const sourceLabel = fromManifest ? `manifest ${manifestPath}` : `auto-discovered under ${root}`;
@@ -10980,7 +12042,7 @@ async function runRecurse(cfg, g, opts) {
   summarizeFanout(results, { dryRun });
 }
 function registerOnboard(program2) {
-  program2.command("onboard").description("Guided first-run setup: configure, sign in, set timezone, detect clients, and wire this project").option("--recurse", "orchestration-root mode: onboard every child repo under this dir (auto-discovered, or from ./.sechroom/repos.json) \u2014 refreshes bound repos, prompts a workspace per new one", false).option("--lane <id>", "set the code-lane (substrate source identity) explicitly instead of inferring it; with --recurse it's used for every child repo").option("--design-lane <id>", "set the design-lane explicitly (substrate-authoring identity); with --recurse applies to every child").option("--client <list...>", `clients to wire \u2014 space- or comma-separated (${ALL_CLIENT_KEYS.join(", ")}) or 'all' (default: auto-detected)`).option("--scope <scope>", "install skills/agents/hooks 'global' (config dir / CLAUDE_CONFIG_DIR) or 'project' (<cwd>/.claude) \u2014 default: prompt, else global").option("--local", "save the binding (tenant + base URL + workspace) to a committed .sechroom.json in this repo instead of the global config", false).option("--here", "with --local: write the binding at THIS directory even when a parent already carries one \u2014 binds a subtree (e.g. a monorepo's frontend/) to its own workspace", false).option("--workspace <id>", "bind this directory to a workspace (skips the interactive workspace pick)").option("--cli-only", "configure the CLI only \u2014 don't wire any AI client (no MCP config, no agent files)", false).option("--no-mcp", "skip the MCP server config (.mcp.json etc.); still write the agent instruction files").option("--copy", "make a personal copy of the agent instructions you can edit (default: prompt on a TTY, else skip)").option("--dry-run", "walk through without writing files or changing the profile", false).option("--refresh", "re-fetch descriptors and refresh any out-of-date managed blocks (local edits preserved to .proposed)", false).option("--force", "rewrite every managed block, overwriting local edits inside the markers (content outside untouched)", false).option("--check", "report whether anything would change and exit (0 = all current, 1 = stale/drift/absent); writes nothing", false).option("-y, --yes", "non-interactive: accept defaults (system timezone, detected clients, global config, full wire)", false).addHelpText(
+  program2.command("onboard").description("Guided first-run setup: configure, sign in, set timezone, detect clients, and wire this project").option("--recurse", "orchestration-root mode: onboard every child repo under this dir (auto-discovered, or from ./.sechroom/repos.json) \u2014 refreshes bound repos, prompts a workspace per new one", false).option("--lane <id>", "set the code-lane (substrate source identity) explicitly instead of inferring it; with --recurse it's used for every child repo").option("--design-lane <id>", "set the design-lane explicitly (substrate-authoring identity); with --recurse applies to every child").option("--client <list...>", `clients to wire \u2014 space- or comma-separated (${ALL_CLIENT_KEYS.join(", ")}) or 'all' (default: auto-detected)`).option("--scope <scope>", "install skills/agents/hooks 'global' (config dir / CLAUDE_CONFIG_DIR) or 'project' (<cwd>/.claude) \u2014 default: prompt, else global").option("--local", "save the binding (tenant + base URL + workspace) to a committed .sechroom.json in this repo instead of the global config", false).option("--here", "with --local: write the binding at THIS directory even when a parent already carries one \u2014 binds a subtree (e.g. a monorepo's frontend/) to its own workspace", false).option("--workspace <id>", "bind this directory to a workspace (skips the interactive workspace pick)").option("--cli-only", "configure the CLI only \u2014 don't wire any AI client (no MCP config, no agent files)", false).option("--no-mcp", "skip the MCP server config (.mcp.json etc.); still write the agent instruction files").option("--copy", "make a personal copy of the agent instructions you can edit (default: prompt on a TTY, else skip)").option("--dry-run", "walk through without writing files or changing the profile", false).option("--refresh", "re-fetch descriptors and refresh any out-of-date managed blocks (local edits preserved to .proposed)", false).option("--force", "rewrite every managed block, overwriting local edits inside the markers (content outside untouched)", false).option("--check", "report whether anything would change and exit (0 = current/stub, 1 = stale/drift/absent); writes nothing", false).option("-y, --yes", "non-interactive: accept defaults (system timezone, detected clients, global config, full wire)", false).addHelpText(
     "after",
     `
 Examples:
@@ -11002,6 +12064,9 @@ Examples:
     const mode = opts.check ? "check" : opts.force ? "force" : "apply";
     const check = mode === "check";
     const yes = Boolean(opts.yes) || check;
+    if (check && (opts.recurse || opts.cliOnly)) {
+      fail("--check inspects this project's agent files and cannot be combined with --recurse or --cli-only.");
+    }
     if (opts.lane) process.env.SECHROOM_CODE_LANE = opts.lane;
     if (opts.designLane) process.env.SECHROOM_DESIGN_LANE = opts.designLane;
     if (opts.recurse) {
@@ -11069,27 +12134,19 @@ Try: ${style.cyan('sechroom memory search "..."')}  or  ${style.cyan("sechroom -
       result.push({ client: key, actions });
       if (!json && !check) printActions(target, actions);
     }
-    const evalCounts = { current: 0, stale: 0, drift: 0, absent: 0 };
-    for (const { actions } of result) for (const a of actions) if (a.eval) evalCounts[a.eval]++;
-    const wouldChange = evalCounts.stale + evalCounts.drift + evalCounts.absent;
     if (check) {
-      if (json) {
-        emit({ check: true, baseUrl: cfg.baseUrl, tenant: cfg.tenant, workspaceId: cfg.workspaceId ?? null, eval: evalCounts, wouldChange, clients: result }, true);
-      } else if (wouldChange === 0) {
-        process.stdout.write(`${ok("\u2713")} all instruction blocks are up to date.
-`);
-      } else {
-        const bits = [];
-        if (evalCounts.stale) bits.push(`${evalCounts.stale} out of date`);
-        if (evalCounts.drift) bits.push(`${evalCounts.drift} with local edits`);
-        if (evalCounts.absent) bits.push(`${evalCounts.absent} not yet written`);
-        process.stderr.write(
-          `${warn("\u26A0")} ${wouldChange} instruction block(s) would change: ${bits.join(", ")}. Run ${style.cyan("sechroom onboard --refresh")}.
-`
-        );
-      }
-      process.exit(wouldChange === 0 ? 0 : 1);
+      reportCheckAndExit(
+        result,
+        json,
+        "sechroom onboard --refresh",
+        {
+          baseUrl: cfg.baseUrl,
+          tenant: cfg.tenant,
+          workspaceId: cfg.workspaceId ?? null
+        }
+      );
     }
+    const evalCounts = buildCheckReport(result).eval;
     if (!json && !dryRun) {
       await ensureLanePin(cfg, { yes, dryRun, clients: keys });
     }
@@ -11485,31 +12542,31 @@ Examples:
 
 // src/commands/reset.ts
 import { homedir as homedir6 } from "os";
-import { join as join21 } from "path";
-import { existsSync as existsSync15, readFileSync as readFileSync17, rmSync as rmSync6 } from "fs";
+import { join as join22 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync18, rmSync as rmSync7 } from "fs";
 var SKILLS_LOCK2 = ".sechroom-skills.json";
-var localSkillsDir = () => join21(process.cwd(), ".claude", "skills");
-var globalSkillsDir = () => join21(homedir6(), ".claude", "skills");
-var localAgentsDir = () => join21(process.cwd(), ".claude", "agents");
-var globalAgentsDir = () => join21(homedir6(), ".claude", "agents");
+var localSkillsDir = () => join22(process.cwd(), ".claude", "skills");
+var globalSkillsDir = () => join22(homedir6(), ".claude", "skills");
+var localAgentsDir = () => join22(process.cwd(), ".claude", "agents");
+var globalAgentsDir = () => join22(homedir6(), ".claude", "agents");
 function removeMaterialisedSkills(dir) {
   const removed = [];
-  const lockPath = join21(dir, SKILLS_LOCK2);
-  if (!existsSync15(lockPath)) return removed;
+  const lockPath = join22(dir, SKILLS_LOCK2);
+  if (!existsSync16(lockPath)) return removed;
   try {
-    const lock = JSON.parse(readFileSync17(lockPath, "utf8"));
+    const lock = JSON.parse(readFileSync18(lockPath, "utf8"));
     for (const entry of Object.values(lock)) {
       for (const name of entry.skills ?? []) {
-        const p = join21(dir, name);
-        if (existsSync15(p)) {
-          rmSync6(p, { recursive: true, force: true });
+        const p = join22(dir, name);
+        if (existsSync16(p)) {
+          rmSync7(p, { recursive: true, force: true });
           removed.push(p);
         }
       }
     }
   } catch {
   }
-  rmSync6(lockPath, { force: true });
+  rmSync7(lockPath, { force: true });
   removed.push(lockPath);
   return removed;
 }
@@ -11546,19 +12603,19 @@ function registerReset(program2) {
       }
     }
     const removed = [];
-    const stateDir = join21(process.cwd(), ".sechroom");
-    if (existsSync15(stateDir)) {
-      rmSync6(stateDir, { recursive: true, force: true });
+    const stateDir = join22(process.cwd(), ".sechroom");
+    if (existsSync16(stateDir)) {
+      rmSync7(stateDir, { recursive: true, force: true });
       removed.push(stateDir);
     }
-    const legacyCfg = join21(process.cwd(), ".sechroom.json");
-    if (existsSync15(legacyCfg)) {
-      rmSync6(legacyCfg, { force: true });
+    const legacyCfg = join22(process.cwd(), ".sechroom.json");
+    if (existsSync16(legacyCfg)) {
+      rmSync7(legacyCfg, { force: true });
       removed.push(legacyCfg);
     }
-    const legacySem = join21(process.cwd(), ".sem");
-    if (existsSync15(legacySem)) {
-      rmSync6(legacySem, { force: true });
+    const legacySem = join22(process.cwd(), ".sem");
+    if (existsSync16(legacySem)) {
+      rmSync7(legacySem, { force: true });
       removed.push(legacySem);
     }
     removed.push(...removeMaterialisedSkills(localSkillsDir()));
@@ -11583,8 +12640,8 @@ function registerReset(program2) {
 }
 
 // src/commands/skills.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync17, statSync as statSync5, writeFileSync as writeFileSync16 } from "fs";
-import { join as join22 } from "path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync18, statSync as statSync6, writeFileSync as writeFileSync17 } from "fs";
+import { join as join23 } from "path";
 function filenameFromDisposition(header) {
   if (!header) return void 0;
   const m = /filename\*?=(?:UTF-8'')?"?([^";]+)"?/i.exec(header);
@@ -11592,11 +12649,11 @@ function filenameFromDisposition(header) {
 }
 function resolveOutputPath(output, serverFilename) {
   const filename = serverFilename || "skills.zip";
-  if (!output) return join22(process.cwd(), filename);
-  const looksLikeDir = output.endsWith("/") || existsSync16(output) && statSync5(output).isDirectory();
+  if (!output) return join23(process.cwd(), filename);
+  const looksLikeDir = output.endsWith("/") || existsSync17(output) && statSync6(output).isDirectory();
   if (looksLikeDir) {
-    mkdirSync17(output, { recursive: true });
-    return join22(output, filename);
+    mkdirSync18(output, { recursive: true });
+    return join23(output, filename);
   }
   return output;
 }
@@ -11627,7 +12684,7 @@ async function downloadZip(label, call, output) {
   const buf = Buffer.from(res.data);
   const filename = filenameFromDisposition(res.response.headers.get("content-disposition")) ?? "skills.zip";
   const path = resolveOutputPath(output, filename);
-  writeFileSync16(path, buf);
+  writeFileSync17(path, buf);
   return { path, bytes: buf.length, filename };
 }
 function registerSkills(program2) {
@@ -11801,12 +12858,12 @@ clients select all; an unconfigured machine preserves the legacy Claude default.
 }
 
 // src/commands/sweep.ts
-import { existsSync as existsSync17 } from "fs";
-import { dirname as dirname15, join as join23, resolve as resolve7 } from "path";
-var DEFAULT_MANIFEST = join23(".sechroom", "repos.json");
+import { existsSync as existsSync18 } from "fs";
+import { dirname as dirname16, join as join24, resolve as resolve8 } from "path";
+var DEFAULT_MANIFEST = join24(".sechroom", "repos.json");
 function planEntry(entry, root) {
   const dir = resolveChildDir(entry.path, root);
-  if (!existsSync17(dir)) {
+  if (!existsSync18(dir)) {
     return { label: entry.path, dir, disposition: "skip-missing", argv: [], reason: "directory does not exist" };
   }
   if (committedBindingPath(dir)) {
@@ -11866,7 +12923,7 @@ Examples:
     const g = cmd.optsWithGlobals();
     const json = Boolean(g.json);
     const dryRun = Boolean(opts.dryRun);
-    const manifestPath = resolve7(opts.manifest);
+    const manifestPath = resolve8(opts.manifest);
     let repos;
     try {
       repos = readManifest(manifestPath);
@@ -11882,7 +12939,7 @@ Examples:
 `);
       return;
     }
-    const root = dirname15(dirname15(manifestPath));
+    const root = dirname16(dirname16(manifestPath));
     const plans = repos.map((entry) => planEntry(entry, root));
     if (!json) {
       process.stderr.write(
@@ -12302,7 +13359,7 @@ async function readStdin4() {
 function resolveVersion() {
   try {
     const pkg = JSON.parse(
-      readFileSync18(new URL("../package.json", import.meta.url), "utf8")
+      readFileSync19(new URL("../package.json", import.meta.url), "utf8")
     );
     return pkg.version ?? "0.0.0";
   } catch {