@sechroom/cli 2026.7.27 → 2026.7.29

package/dist/index.js

@@ -428,6 +428,30 @@ async function requireToken(cfg) {
   }
   return cached.accessToken;
 }
+async function forceRefreshToken(cfg) {
+  if (process.env.SECHROOM_TOKEN)
+    throw new Error(
+      "SECHROOM_TOKEN was rejected (401) and cannot be refreshed \u2014 mint a fresh bearer and re-export SECHROOM_TOKEN."
+    );
+  const cached = readAccount(cfg.account);
+  if (!cached?.refreshToken)
+    throw new Error(
+      `Session for account "${cfg.account}" was rejected (401) and has no refresh token. Run \`sechroom login --account ${cfg.account}\` again.`
+    );
+  const meta = await discover(cfg.baseUrl);
+  const res = await fetch(meta.token_endpoint, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: cached.refreshToken
+    })
+  });
+  if (!res.ok)
+    throw new Error(`Token refresh failed (${res.status}). Run \`sechroom login --account ${cfg.account}\` again.`);
+  persistTokenResponse(cfg.account, cfg.baseUrl, await res.json());
+  return readAccount(cfg.account).accessToken;
+}
 
 // src/client.ts
 import createClient from "openapi-fetch";
@@ -903,9 +927,9 @@ function writeSkillsLock(dir, lock) {
   mkdirSync2(dir, { recursive: true });
   writeFileSync2(join2(dir, SKILLS_LOCK), JSON.stringify(lock, null, 2) + "\n");
 }
-function recordMaterialisedSkills(dir, slug, skills, meta = {}) {
+function recordMaterialisedSkills(dir, slug2, skills, meta = {}) {
   const lock = readSkillsLock(dir);
-  lock[slug] = { surface: meta.surface, skills: [...skills].sort() };
+  lock[slug2] = { surface: meta.surface, skills: [...skills].sort() };
   writeSkillsLock(dir, lock);
 }
 
@@ -1429,7 +1453,7 @@ function runList(spec, cmd, opts) {
   const out = targets.map((t) => {
     const lock = readSkillsLock(t.dir);
     const entries = Object.entries(lock).flatMap(
-      ([slug, e]) => (e.skills ?? []).map((name) => ({ slug, name, present: existsSync3(join4(t.dir, name)) }))
+      ([slug2, e]) => (e.skills ?? []).map((name) => ({ slug: slug2, name, present: existsSync3(join4(t.dir, name)) }))
     );
     return { client: t.client, surface: t.surface, dir: t.dir, label: t.label, entries };
   });
@@ -1448,7 +1472,7 @@ function runList(spec, cmd, opts) {
 }
 function runClean(spec, cmd, opts, slugArg) {
   const g = cmd.optsWithGlobals();
-  const slug = slugArg || DEFAULT_SKILLS_SLUG;
+  const slug2 = slugArg || DEFAULT_SKILLS_SLUG;
   let scope;
   try {
     scope = scopeOf(opts);
@@ -1468,7 +1492,7 @@ function runClean(spec, cmd, opts, slugArg) {
   const missing = [];
   for (const t of targets) {
     const lock = readSkillsLock(t.dir);
-    const entry = lock[slug];
+    const entry = lock[slug2];
     if (!entry) {
       missing.push(join4(t.dir, SKILLS_LOCK));
       continue;
@@ -1481,16 +1505,16 @@ function runClean(spec, cmd, opts, slugArg) {
         removed.push(name);
       }
     }
-    delete lock[slug];
+    delete lock[slug2];
     writeSkillsLock(t.dir, lock);
     cleaned.push({ client: t.client, surface: t.surface, dir: t.dir, removed });
   }
   if (cleaned.length === 0) {
-    return fail(`No materialised ${spec.kind}s recorded for '${slug}' in ${missing.join(", ")}.`);
+    return fail(`No materialised ${spec.kind}s recorded for '${slug2}' in ${missing.join(", ")}.`);
   }
-  if (json) return emit({ kind: spec.kind, client: selection, slug, cleaned, missing }, true);
+  if (json) return emit({ kind: spec.kind, client: selection, slug: slug2, cleaned, missing }, true);
   for (const c of cleaned) {
-    console.log(style.green(`Removed ${c.removed.length} ${spec.kind}(s) for ${slug} from ${c.dir}`));
+    console.log(style.green(`Removed ${c.removed.length} ${spec.kind}(s) for ${slug2} from ${c.dir}`));
   }
 }
 
@@ -1518,8 +1542,8 @@ target:gpt-codex-agent), the dispatchable workers your loop skills call
 }
 
 // src/commands/channel.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync7 } from "fs";
-import { dirname as dirname6, join as join9 } from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync8 } from "fs";
+import { dirname as dirname8, join as join11 } from "path";
 import {
   HttpTransportType,
   HubConnectionBuilder
@@ -1528,8 +1552,8 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/commands/executor.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync6 } from "fs";
-import { dirname as dirname5, join as join8 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync7 } from "fs";
+import { dirname as dirname7, join as join10 } from "path";
 
 // src/sem.ts
 import { dirname as dirname2, join as join5 } from "path";
@@ -1693,14 +1717,770 @@ function ensureSemIgnored(semPath) {
   }
 }
 
+// src/commands/executor-run.ts
+import { join as join9, resolve as resolve2 } from "path";
+
+// src/executor-run/claim.ts
+var SUCCESS = /* @__PURE__ */ new Set(["Claimed", "AlreadyHeld"]);
+async function claimNextTask(deps) {
+  const { request, executorInstanceId } = deps;
+  const sleep = deps.sleep ?? ((ms) => new Promise((resolve5) => setTimeout(resolve5, ms)));
+  const idempotencyKey = deps.idempotencyKey ?? ((offer) => `executor-run:${offer.generationId}`);
+  const tokenVersion = deps.tokenVersion ?? 1;
+  const log = deps.log ?? (() => {
+  });
+  const base = `/me/executor-instances/${encodeURIComponent(executorInstanceId)}`;
+  const offers = await request(`${base}/dispatch-offers`);
+  if (offers.length === 0) return null;
+  const head = offers[0];
+  if (head.suggestedClaimDelayMs > 0) await sleep(head.suggestedClaimDelayMs);
+  const next = await request(
+    `${base}/dispatch-offers/claim-next`,
+    {
+      method: "POST",
+      body: JSON.stringify({ idempotencyKey: idempotencyKey(head) })
+    }
+  );
+  if (SUCCESS.has(next.outcome)) return toClaimed(next, tokenVersion, next.offer ?? head);
+  if (next.outcome === "NoOffer") return null;
+  log(
+    `claim-next returned ${next.outcome}; falling through to direct per-generation claim`
+  );
+  for (const offer of offers) {
+    const direct = await request(`/me/executor-task-claims`, {
+      method: "POST",
+      body: JSON.stringify({
+        generationId: offer.generationId,
+        executorInstanceId
+      })
+    });
+    if (SUCCESS.has(direct.outcome)) return toClaimed(direct, tokenVersion, offer);
+  }
+  return null;
+}
+function toClaimed(result, tokenVersion, offer) {
+  const lease = result.lease;
+  const claimToken = result.claimToken;
+  if (!lease?.id || !claimToken) return null;
+  return {
+    outcome: result.outcome,
+    leaseId: lease.id,
+    claimToken,
+    tokenVersion,
+    memoryId: lease.memoryId,
+    workspaceId: lease.workspaceId,
+    generationId: lease.generationId,
+    decompositionId: decompositionIdFrom(offer?.tags ?? [])
+  };
+}
+function decompositionIdFrom(tags) {
+  const tag = tags.find((value) => value.startsWith("wlp-decomposition:"));
+  return tag?.slice("wlp-decomposition:".length) || void 0;
+}
+
+// src/executor-run/codex.ts
+import {
+  execFile,
+  spawn
+} from "child_process";
+import { createInterface } from "readline";
+import { promisify } from "util";
+
+// src/executor-run/usage.ts
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync5 } from "fs";
+import { dirname as dirname3 } from "path";
+function rateLimitMethod(method) {
+  return /rate_?limits/i.test(method);
+}
+function parseRateLimitPayload(params) {
+  const wrapper = object(params.rateLimits) ?? object(params.rate_limits) ?? params;
+  const primary = parseWindow(wrapper.primary);
+  const secondary = parseWindow(wrapper.secondary);
+  if (!primary && !secondary) return void 0;
+  return { primary, secondary };
+}
+function parseWindow(value) {
+  const obj = object(value);
+  if (!obj) return void 0;
+  const usedPercent = numberOf(obj, "used_percent", "usedPercent");
+  if (usedPercent === void 0) return void 0;
+  return {
+    usedPercent,
+    windowMinutes: numberOf(obj, "window_minutes", "windowMinutes"),
+    resetsInSeconds: numberOf(obj, "resets_in_seconds", "resetsInSeconds")
+  };
+}
+function object(value) {
+  return value && typeof value === "object" ? value : void 0;
+}
+function numberOf(obj, ...keys) {
+  for (const key of keys) if (typeof obj[key] === "number") return obj[key];
+  return void 0;
+}
+function rateLimitRemaining(state, nowMs) {
+  const elapsedSeconds = Math.max(0, (nowMs - state.capturedAtMs) / 1e3);
+  let binding;
+  for (const window of ["primary", "secondary"]) {
+    const captured = state[window];
+    if (!captured) continue;
+    if (captured.resetsInSeconds !== void 0 && captured.resetsInSeconds <= elapsedSeconds)
+      continue;
+    const remainingPercent = Math.max(0, 100 - captured.usedPercent);
+    if (!binding || remainingPercent < binding.remainingPercent)
+      binding = {
+        remainingPercent,
+        window,
+        resetsInSeconds: captured.resetsInSeconds === void 0 ? void 0 : Math.round(captured.resetsInSeconds - elapsedSeconds)
+      };
+  }
+  return binding;
+}
+function admissionDecision(state, reservePercent, nowMs) {
+  if (!state) return { ok: true };
+  const remaining = rateLimitRemaining(state, nowMs);
+  if (!remaining) return { ok: true };
+  if (remaining.remainingPercent > reservePercent) return { ok: true, remaining };
+  const resets = remaining.resetsInSeconds === void 0 ? "" : `; resets in ~${remaining.resetsInSeconds}s`;
+  return {
+    ok: false,
+    remaining,
+    reason: `rate-limit remaining ${remaining.remainingPercent.toFixed(1)}% (${remaining.window} window) is at or below the ${reservePercent}% reserve${resets}`
+  };
+}
+function formatTokenMeter(used, window) {
+  const pct = window > 0 ? (used / window * 100).toFixed(1) : "?";
+  return `${used.toLocaleString("en-US")} / ${window.toLocaleString("en-US")} (${pct}%)`;
+}
+var UsageTracker = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  totals = { tokensIn: 0, tokensOut: 0 };
+  perTask = /* @__PURE__ */ new Map();
+  latest;
+  limits;
+  deferred = false;
+  /** Fold one `thread/tokenUsage/updated` parse into the instance running totals.
+   *  Payload counters are cumulative within a turn but reset across turns/resumes,
+   *  so totals accumulate deltas; a counter that shrank is a fresh turn's counter
+   *  and contributes its full value. */
+  recordUsage(taskId, usage) {
+    const previous = this.perTask.get(taskId);
+    this.totals.tokensIn += delta(usage.tokensIn, previous?.tokensIn);
+    this.totals.tokensOut += delta(usage.tokensOut, previous?.tokensOut);
+    this.perTask.set(taskId, { tokensIn: usage.tokensIn, tokensOut: usage.tokensOut });
+    this.latest = usage;
+    this.append({
+      type: "usage",
+      taskId,
+      modelId: usage.modelId,
+      tokensIn: usage.tokensIn,
+      tokensOut: usage.tokensOut,
+      contextUsed: usage.contextUsed,
+      contextWindow: usage.contextWindow,
+      instanceTokensIn: this.totals.tokensIn,
+      instanceTokensOut: this.totals.tokensOut
+    });
+    this.options.log(this.statusLine());
+  }
+  /** Fold a rate-limit payload (dedicated notification or embedded in a usage
+   *  payload) into the admission state. */
+  recordRateLimits(payload) {
+    this.limits = { ...payload, capturedAtMs: this.now() };
+    const remaining = rateLimitRemaining(this.limits, this.now());
+    this.append({
+      type: "rate-limits",
+      primary: payload.primary ?? null,
+      secondary: payload.secondary ?? null,
+      remainingPercent: remaining?.remainingPercent ?? null
+    });
+    this.options.log(
+      `rate-limit update: ${remaining ? `remaining ${remaining.remainingPercent.toFixed(1)}% (${remaining.window} window)` : "all windows recovered"}`
+    );
+  }
+  /** The claim-time admission verdict. Transitions (admit→defer, defer→admit)
+   *  land in the JSONL record; the loud per-cycle logging is the driver loop's. */
+  admission() {
+    const decision = admissionDecision(
+      this.limits,
+      this.options.reservePercent,
+      this.now()
+    );
+    if (decision.ok !== !this.deferred) {
+      this.deferred = !decision.ok;
+      this.append({
+        type: "admission",
+        ok: decision.ok,
+        reservePercent: this.options.reservePercent,
+        reason: decision.ok ? null : decision.reason
+      });
+    }
+    return decision.ok ? { ok: true } : { ok: false, reason: decision.reason };
+  }
+  /** Per-instance running totals + turn meter + rate-limit remaining, for the
+   *  driver status output. */
+  statusLine() {
+    const parts = [
+      `instance total in ${this.totals.tokensIn.toLocaleString("en-US")} out ${this.totals.tokensOut.toLocaleString("en-US")} across ${this.perTask.size} task(s)`
+    ];
+    if (this.latest)
+      parts.push(`turn ${formatTokenMeter(this.latest.contextUsed, this.latest.contextWindow)}`);
+    const remaining = this.limits ? rateLimitRemaining(this.limits, this.now()) : void 0;
+    parts.push(
+      remaining ? `rate-limit remaining ${remaining.remainingPercent.toFixed(1)}%` : "rate-limit remaining unknown"
+    );
+    return `usage[${this.options.instanceKey}]: ${parts.join("; ")}`;
+  }
+  append(record) {
+    this.options.appendRecord?.({
+      ts: new Date(this.now()).toISOString(),
+      instanceKey: this.options.instanceKey,
+      ...record
+    });
+  }
+  now() {
+    return this.options.now?.() ?? Date.now();
+  }
+};
+function delta(current, previous) {
+  if (previous === void 0) return current;
+  const d = current - previous;
+  return d < 0 ? current : d;
+}
+function createUsageLogAppender(path, log) {
+  let warned = false;
+  let dirReady = false;
+  return (record) => {
+    try {
+      if (!dirReady) {
+        mkdirSync5(dirname3(path), { recursive: true });
+        dirReady = true;
+      }
+      appendFileSync2(path, `${JSON.stringify(record)}
+`);
+    } catch (error) {
+      if (warned) return;
+      warned = true;
+      log(`usage log append failed (${String(error)}) \u2014 continuing without ${path}`);
+    }
+  };
+}
+
+// src/executor-run/codex.ts
+var execFileAsync = promisify(execFile);
+function shouldResumeTimedOutTurn(input) {
+  return input.outcome === "timeout" && !input.hasPacket && Boolean(input.threadId) && (input.contextUsed > 0 || input.detailEventCount > 0 || input.lastAgentMessage.length > 0);
+}
+function parseCodexUsage(params, previous) {
+  const info = object2(params.tokenUsageInfo) ?? params;
+  const last = object2(info.last) ?? object2(info.lastTokenUsage) ?? object2(info.last_turn);
+  const total = object2(info.total) ?? object2(info.totalTokenUsage) ?? info;
+  const resumed = Boolean(params.resumed ?? info.resumed ?? last);
+  const spend = resumed && last ? last : total;
+  const tokensIn = numberOf2(spend, "input_tokens", "inputTokens", "input") ?? previous?.tokensIn ?? 0;
+  const tokensOut = numberOf2(spend, "output_tokens", "outputTokens", "output") ?? previous?.tokensOut ?? 0;
+  const contextUsed = numberOf2(last ?? spend, "total_tokens", "totalTokens", "total") ?? tokensIn + tokensOut;
+  const contextWindow = numberOf2(params, "modelContextWindow", "contextWindow") ?? numberOf2(info, "modelContextWindow", "contextWindow") ?? previous?.contextWindow ?? 0;
+  const modelId = stringOf(params, "model", "modelId") ?? stringOf(info, "model", "modelId") ?? previous?.modelId ?? null;
+  return { tokensIn, tokensOut, contextUsed, contextWindow, modelId };
+}
+function object2(value) {
+  return value && typeof value === "object" ? value : void 0;
+}
+function numberOf2(obj, ...keys) {
+  for (const key of keys) if (typeof obj[key] === "number") return obj[key];
+  return void 0;
+}
+function stringOf(obj, ...keys) {
+  for (const key of keys) if (typeof obj[key] === "string") return obj[key];
+  return void 0;
+}
+function renderUsage(usage) {
+  return `tokens ${formatTokenMeter(usage.contextUsed, usage.contextWindow)}, thread total ${(usage.tokensIn + usage.tokensOut).toLocaleString("en-US")}`;
+}
+function mapThreadItem(msg) {
+  const method = msg.method ?? "";
+  if (!method.includes("item")) return void 0;
+  const type = String(msg.params?.type ?? msg.params?.itemType ?? method);
+  const text2 = JSON.stringify({ method, type, id: msg.params?.id ?? null });
+  if (/approval/i.test(type)) return { kind: "Approval", text: text2 };
+  if (/commandExecution|fileChange|contextCompaction|agentMessage|userMessage/i.test(type))
+    return { kind: /agentMessage|userMessage/i.test(type) ? "Raw" : "Parsed", text: text2 };
+  return void 0;
+}
+function verdictForTelemetry(status) {
+  if (status === "completed") return "pass";
+  if (status === "needs_approval" || status === "cancelled" || status === "canceled") return "blocked";
+  return "soft-fail";
+}
+var CodexAppServer = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  child;
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  onServerRequest;
+  onNotification;
+  exited;
+  cliVersion;
+  /** Spawn the child + initialize. Idempotent per instance. */
+  async start() {
+    if (this.child) return;
+    this.cliVersion ??= await pinCodexVersion(this.options.codexBin, this.options.log);
+    const child = spawn(this.options.codexBin, ["app-server", "--stdio"], {
+      cwd: this.options.cwd,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.child = child;
+    child.on("exit", (code) => {
+      this.exited = { code };
+      const failure = new Error(`codex app-server exited (${code ?? "signal"})`);
+      for (const waiter of this.pending.values()) waiter.reject(failure);
+      this.pending.clear();
+    });
+    child.stderr.on(
+      "data",
+      (chunk) => this.options.log(`codex! ${chunk.toString().trimEnd()}`)
+    );
+    createInterface({ input: child.stdout }).on(
+      "line",
+      (line) => this.onLine(line)
+    );
+    await this.request("initialize", {
+      clientInfo: { name: "sechroom-executor-run", version: "0" },
+      capabilities: { experimentalApi: true }
+    });
+  }
+  get alive() {
+    return this.child !== void 0 && this.exited === void 0;
+  }
+  /**
+   * Run one task as one thread+turn; resolves when the server reports
+   * `turn/completed` (a server→client REQUEST, per the Looper-verified protocol),
+   * the child dies, or the timeout lapses.
+   */
+  async runTask(prompt, telemetry) {
+    let packet;
+    let lastAgentMessage = "";
+    let threadId = "";
+    let turnId = "";
+    let usage;
+    const detailEvents = [];
+    const modelId = this.options.model ?? null;
+    const event = (kind, text2 = null) => ({
+      taskId: telemetry?.taskId ?? "",
+      kind,
+      tokensIn: null,
+      tokensOut: null,
+      contextUsed: null,
+      contextWindow: null,
+      text: text2,
+      approvalState: null,
+      verdict: null,
+      modelId,
+      executorInstanceId: this.options.executorInstanceId,
+      leaseId: telemetry?.leaseId ?? null,
+      turnId: turnId || null
+    });
+    this.onNotification = (msg) => {
+      if (msg.method === "thread/tokenUsage/updated") {
+        usage = parseCodexUsage(msg.params ?? {}, usage);
+        this.options.log(renderUsage(usage));
+        this.options.onUsage?.(telemetry?.taskId ?? "", usage);
+        this.tapRateLimits(msg.params ?? {});
+        return;
+      }
+      const mapped = mapThreadItem(msg);
+      if (mapped) detailEvents.push(event(mapped.kind, mapped.text));
+    };
+    const terminal = new Promise((resolve5) => {
+      this.onServerRequest = (msg) => {
+        const method = msg.method ?? "";
+        if (terminalMethod(method)) {
+          this.respond(msg.id, {});
+          resolve5("completed");
+          return;
+        }
+        if (method === "item/tool/call") {
+          const name = String(msg.params?.name ?? msg.params?.tool ?? "");
+          const args = msg.params?.arguments ?? msg.params?.input ?? {};
+          if (name === "sechroom_closeout") {
+            packet = {
+              terminal_status: String(args.terminal_status ?? "completed"),
+              summary: String(args.summary ?? ""),
+              evidence: Array.isArray(args.evidence) ? args.evidence.map(String) : void 0
+            };
+            this.respond(msg.id, toolText("closeout accepted"));
+            return;
+          }
+          if (name === "sechroom_lifecycle_signal") {
+            detailEvents.push(event("Parsed", `phase:${String(args.phase ?? "?")}:${String(args.status ?? "?")}`));
+            this.options.log(
+              `lifecycle ${String(args.phase ?? "?")}:${String(args.status ?? "?")} \u2014 ${String(args.summary ?? "")}`
+            );
+            this.respond(msg.id, toolText("ok"));
+            return;
+          }
+          this.options.log(`unknown dynamic tool '${name}' \u2014 acknowledged empty`);
+          this.respond(msg.id, toolText("unsupported tool"));
+          return;
+        }
+        if (method.endsWith("requestApproval") || method.includes("elicitation")) {
+          detailEvents.push({ ...event("Approval", method), approvalState: "denied" });
+          this.options.log(
+            `approval requested (${method}) under approvalPolicy=never \u2014 DENIED (unattended run)`
+          );
+          this.respond(msg.id, { decision: "denied" });
+          return;
+        }
+        this.respond(msg.id, {});
+      };
+    });
+    try {
+      const started = await this.request("thread/start", {
+        cwd: this.options.cwd,
+        approvalPolicy: "never",
+        sandbox: this.options.sandbox,
+        ephemeral: false,
+        developerInstructions: prompt,
+        dynamicTools: dynamicToolDefinitions()
+      });
+      threadId = String(
+        started.threadId ?? started.thread?.id ?? ""
+      );
+      const turn = await this.request("turn/start", {
+        threadId,
+        ...this.options.model ? { model: this.options.model } : {},
+        input: [{ type: "text", text: "Begin the task now." }]
+      });
+      turnId = String(
+        turn.turnId ?? turn.turn?.id ?? ""
+      );
+    } catch (e) {
+      return { status: "crashed", reason: String(e) };
+    }
+    let outcome = await Promise.race([
+      terminal,
+      this.exitAsResult(),
+      timeout(this.options.turnTimeoutMs)
+    ]);
+    if (shouldResumeTimedOutTurn({
+      outcome,
+      hasPacket: Boolean(packet),
+      threadId,
+      contextUsed: usage?.contextUsed ?? 0,
+      detailEventCount: detailEvents.length,
+      lastAgentMessage
+    })) {
+      this.options.log(
+        `fresh turn timed out after ${this.options.turnTimeoutMs}ms with substantial work \u2014 resuming thread ${threadId}`
+      );
+      try {
+        await this.request("turn/interrupt", { threadId, turnId });
+        await this.request("thread/resume", { threadId });
+        const resumed = await this.request("turn/start", {
+          threadId,
+          ...this.options.model ? { model: this.options.model } : {},
+          input: [
+            {
+              type: "text",
+              text: "Resume the interrupted work from this saved thread. Finish the task and call sechroom_closeout."
+            }
+          ]
+        });
+        turnId = String(
+          resumed.turnId ?? resumed.turn?.id ?? ""
+        );
+        outcome = await Promise.race([
+          terminal,
+          this.exitAsResult(),
+          timeout(this.options.resumeTurnTimeoutMs)
+        ]);
+      } catch (error) {
+        return { status: "crashed", reason: `thread resume failed: ${String(error)}` };
+      }
+    }
+    if (outcome === "timeout")
+      return packet ? { status: "completed", packet, lastAgentMessage } : { status: "timeout" };
+    if (outcome !== "completed")
+      return { status: "crashed", reason: String(outcome) };
+    if (!packet && threadId) {
+      try {
+        await this.request("turn/start", {
+          threadId,
+          input: [
+            {
+              type: "text",
+              text: "The turn ended without a sechroom_closeout call. Call sechroom_closeout NOW with terminal_status, summary, and evidence."
+            }
+          ]
+        });
+        await Promise.race([terminal, this.exitAsResult(), timeout(6e4)]);
+      } catch {
+      }
+    }
+    await this.emitTurnTelemetry(telemetry, event, detailEvents, usage, packet).catch(
+      (error) => this.options.log(`telemetry emit failed (non-fatal): ${String(error)}`)
+    );
+    return { status: "completed", packet, lastAgentMessage };
+  }
+  async emitTurnTelemetry(context, makeEvent, details, usage, packet) {
+    if (!context?.decompositionId) {
+      this.options.log("telemetry absent: claimed task carried no wlp-decomposition tag");
+      return;
+    }
+    const verdict = verdictForTelemetry(packet?.terminal_status);
+    const terminal = {
+      ...makeEvent("Terminal", packet?.summary ?? null),
+      tokensIn: usage?.tokensIn ?? null,
+      tokensOut: usage?.tokensOut ?? null,
+      contextUsed: usage?.contextUsed ?? null,
+      contextWindow: usage?.contextWindow ?? null,
+      modelId: usage?.modelId ?? this.options.model ?? null,
+      verdict
+    };
+    await this.options.emitTelemetry(
+      context.decompositionId,
+      verdict === "pass" ? [terminal] : [...details, terminal]
+    );
+  }
+  /** turn/interrupt — the graceful-shutdown drain boundary. Best-effort. */
+  async interrupt() {
+    try {
+      await this.request("turn/interrupt", {});
+    } catch {
+    }
+  }
+  stop() {
+    this.child?.kill("SIGTERM");
+    this.child = void 0;
+  }
+  request(method, params) {
+    const child = this.child;
+    if (!child || this.exited)
+      return Promise.reject(new Error("codex app-server is not running"));
+    const id = this.nextId++;
+    return new Promise((resolve5, reject) => {
+      this.pending.set(id, { resolve: resolve5, reject });
+      child.stdin.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n");
+    });
+  }
+  respond(id, result) {
+    if (id === void 0 || !this.child) return;
+    this.child.stdin.write(JSON.stringify({ jsonrpc: "2.0", id, result }) + "\n");
+  }
+  onLine(line) {
+    if (!line.trim()) return;
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      this.options.log(`codex? ${line}`);
+      return;
+    }
+    if (msg.id !== void 0 && (msg.result !== void 0 || msg.error)) {
+      const waiter = this.pending.get(msg.id);
+      if (waiter) {
+        this.pending.delete(msg.id);
+        if (msg.error)
+          waiter.reject(new Error(msg.error.message ?? "app-server error"));
+        else waiter.resolve(msg.result);
+        return;
+      }
+    }
+    if (msg.method && msg.id !== void 0) {
+      this.onServerRequest?.(msg);
+      return;
+    }
+    if (msg.method && rateLimitMethod(msg.method)) this.tapRateLimits(msg.params ?? {});
+    if (msg.method) this.onNotification?.(msg);
+    if (msg.method && terminalMethod(msg.method)) {
+      this.onServerRequest?.(msg);
+      return;
+    }
+  }
+  tapRateLimits(params) {
+    const parsed = parseRateLimitPayload(params);
+    if (parsed) this.options.onRateLimits?.(parsed);
+  }
+  exitAsResult() {
+    return new Promise((resolve5) => {
+      this.child?.once(
+        "exit",
+        (code) => resolve5(`app-server exited (${code ?? "signal"})`)
+      );
+    });
+  }
+};
+async function pinCodexVersion(bin, log) {
+  try {
+    const { stdout } = await execFileAsync(bin, ["--version"]);
+    const version = stdout.trim();
+    log(`codex version: ${version}`);
+    return version;
+  } catch (error) {
+    log(
+      `warning: could not pin codex version: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return void 0;
+  }
+}
+function toolText(text2) {
+  return { success: true, contentItems: [{ type: "inputText", text: text2 }] };
+}
+function terminalMethod(method) {
+  return method === "turn/completed" || method.endsWith("/turn/completed");
+}
+function timeout(ms) {
+  return new Promise((resolve5) => setTimeout(() => resolve5("timeout"), ms).unref?.());
+}
+function dynamicToolDefinitions() {
+  return [
+    {
+      name: "sechroom_closeout",
+      description: "Submit the task's terminal closeout. REQUIRED before ending the turn: call with the honest terminal_status, a summary of what was done, and evidence (files changed, tests run, checks).",
+      inputSchema: {
+        type: "object",
+        properties: {
+          terminal_status: {
+            type: "string",
+            enum: ["completed", "needs_approval", "error", "cancelled"]
+          },
+          summary: { type: "string" },
+          evidence: { type: "array", items: { type: "string" } }
+        },
+        required: ["terminal_status", "summary"]
+      }
+    },
+    {
+      name: "sechroom_lifecycle_signal",
+      description: "Report phase progress: call with phase (start|work|verify|closeout) and status (started|completed|skipped|blocked) at each phase boundary.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          phase: { type: "string" },
+          status: { type: "string" },
+          summary: { type: "string" }
+        },
+        required: ["phase", "status", "summary"]
+      }
+    }
+  ];
+}
+
+// src/executor-run/fleet.ts
+import { readFile } from "fs/promises";
+import { resolve } from "path";
+import { spawn as spawn2 } from "child_process";
+async function readFleetConfig(path) {
+  const parsed = JSON.parse(await readFile(resolve(path), "utf8"));
+  if (!Array.isArray(parsed.instances) || parsed.instances.length === 0)
+    throw new Error("fleet config must contain a non-empty 'instances' array");
+  const keys = /* @__PURE__ */ new Set();
+  for (const entry of parsed.instances) {
+    if (!entry || typeof entry.root !== "string" || typeof entry.instanceKey !== "string")
+      throw new Error("each fleet instance requires string 'root' and 'instanceKey'");
+    if (keys.has(entry.instanceKey)) throw new Error(`duplicate fleet instanceKey '${entry.instanceKey}'`);
+    keys.add(entry.instanceKey);
+  }
+  return parsed;
+}
+function entryArgs(entry) {
+  const args = ["executor", "run", "--root", resolve(entry.root), "--instance-key", entry.instanceKey];
+  const value = (flag, v) => {
+    if (v !== void 0) args.push(flag, String(v));
+  };
+  value("--lane", entry.lane);
+  value("--model", entry.model);
+  value("--connector", entry.connector);
+  value("--ttl", entry.ttl);
+  value("--poll-interval", entry.pollInterval);
+  value("--heartbeat-interval", entry.heartbeatInterval);
+  value("--turn-timeout", entry.turnTimeout);
+  value("--resume-turn-timeout", entry.resumeTurnTimeout);
+  value("--drain-timeout", entry.drainTimeout);
+  value("--codex-bin", entry.codexBin);
+  value("--sandbox", entry.sandbox);
+  value("--usage-reserve", entry.usageReserve);
+  return args;
+}
+function superviseFleet(config2, options = {}) {
+  const log = options.log ?? ((line) => process.stderr.write(`${line}
+`));
+  const states = /* @__PURE__ */ new Map();
+  const children = /* @__PURE__ */ new Map();
+  let stopping = false;
+  let resolveDone;
+  const done = new Promise((resolvePromise) => {
+    resolveDone = resolvePromise;
+  });
+  const status = () => log(`[fleet] ${[...states].map(([key, state]) => `${key}=${state}`).join(" ")}`);
+  const spawnEntry = options.spawnEntry ?? ((entry, args) => {
+    const script = process.argv[1];
+    if (!script) throw new Error("cannot locate the sechroom CLI entrypoint");
+    return spawn2(process.execPath, [script, ...args], {
+      cwd: resolve(entry.root),
+      stdio: ["ignore", "pipe", "pipe"],
+      env: process.env
+    });
+  });
+  for (const entry of config2.instances) {
+    const child = spawnEntry(entry, entryArgs(entry));
+    children.set(entry.instanceKey, child);
+    states.set(entry.instanceKey, "live");
+    const prefix = (text2) => {
+      for (const line of text2.replace(/\n$/, "").split("\n")) log(`[${entry.instanceKey}] ${line}`);
+    };
+    const concrete = child;
+    concrete.stdout?.on("data", (chunk) => prefix(String(chunk)));
+    concrete.stderr?.on("data", (chunk) => prefix(String(chunk)));
+    child.on("exit", (code, signal) => {
+      states.set(entry.instanceKey, "exited");
+      log(`[${entry.instanceKey}] exited (${signal ?? code ?? "unknown"})`);
+      status();
+      if ([...states.values()].every((state) => state === "exited")) resolveDone();
+    });
+  }
+  status();
+  return {
+    done,
+    shutdown(signal = "SIGINT") {
+      if (stopping) return done;
+      stopping = true;
+      for (const [key, child] of children) {
+        if (states.get(key) !== "exited") {
+          states.set(key, "stopping");
+          child.kill(signal);
+        }
+      }
+      status();
+      return done;
+    },
+    states
+  };
+}
+
+// src/commands/telemetry.ts
+import {
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync7,
+  readFileSync as readFileSync5,
+  rmSync as rmSync3,
+  writeFileSync as writeFileSync6
+} from "fs";
+import { dirname as dirname6, join as join8 } from "path";
+
 // src/commands/hook-install.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "fs";
-import { delimiter, dirname as dirname4, join as join7 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "fs";
+import { delimiter, dirname as dirname5, join as join7 } from "path";
 
 // src/setup/clients.ts
 import { existsSync as existsSync5 } from "fs";
 import { homedir as homedir3 } from "os";
-import { dirname as dirname3, join as join6 } from "path";
+import { dirname as dirname4, join as join6 } from "path";
 function claudeDesktopConfigPath(home) {
   switch (process.platform) {
     case "darwin":
@@ -1760,7 +2540,7 @@ function detectInstalledClients(cwd) {
   const home = homedir3();
   const detected = [];
   if (resolveClaudeTargets({}).some((t) => existsSync5(t.dir))) detected.push("claude-code");
-  if (existsSync5(dirname3(claudeDesktopConfigPath(home)))) detected.push("claude-desktop");
+  if (existsSync5(dirname4(claudeDesktopConfigPath(home)))) detected.push("claude-desktop");
   if (resolveCodexHomes({}).some((d) => existsSync5(d))) detected.push("codex");
   if (existsSync5(join6(home, ".cursor")) || existsSync5(join6(cwd, ".cursor"))) detected.push("cursor");
   if (existsSync5(join6(home, ".gemini"))) detected.push("antigravity");
@@ -1817,7 +2597,7 @@ function installHooksJson(path, commands, dryRun) {
   const added = mergeHooks(config2, commands);
   if (added === 0 && existed) return { path, status: "current" };
   if (!dryRun) {
-    mkdirSync5(dirname4(path), { recursive: true });
+    mkdirSync6(dirname5(path), { recursive: true });
     writeFileSync5(path, JSON.stringify(config2, null, 2) + "\n");
   }
   return { path, status: existed ? "merged" : "created" };
@@ -1857,7 +2637,7 @@ function installCodexFeatureFlag(path, dryRun) {
   const { next, changed } = ensureCodexFeaturesHooks(content);
   if (!changed) return { path, status: "current" };
   if (!dryRun) {
-    mkdirSync5(dirname4(path), { recursive: true });
+    mkdirSync6(dirname5(path), { recursive: true });
     writeFileSync5(path, next);
   }
   return { path, status: existed ? "merged" : "created" };
@@ -1920,65 +2700,1077 @@ function warnIfSechroomNotOnPath(write = (s) => void process.stderr.write(s)) {
   return true;
 }
 
-// src/commands/executor.ts
-function executorSubscriptionInput(name) {
-  return {
-    name,
-    enabled: true,
-    filter: { tags: ["kind:task"], workspaceScope: [] }
-  };
-}
-function executorRegistrationInput(state, deliverySubscriptionId) {
-  return {
-    relayId: state.relayId,
-    instanceKey: state.instanceKey,
-    laneId: state.laneId ?? state.instanceKey,
-    runtimeKind: parseRuntimeKind(state.runtime),
-    activationMode: "Attached",
-    deliverySubscriptionId,
-    connectorId: state.connectorId,
-    claimedCapabilityKeys: state.capabilityKeys,
-    toolSetRef: null,
-    ttlSeconds: state.ttlSeconds
-  };
-}
-var EXECUTOR_STATE = "executor.json";
-var EXECUTOR_PULSE_COMMAND = "sechroom executor hook-pulse";
-var EXECUTOR_STOP_COMMAND = "sechroom executor hook-stop";
-var CLAUDE_EXECUTOR_HOOKS = {
-  SessionStart: EXECUTOR_PULSE_COMMAND,
-  UserPromptSubmit: EXECUTOR_PULSE_COMMAND,
-  PreToolUse: EXECUTOR_PULSE_COMMAND,
-  Stop: EXECUTOR_PULSE_COMMAND,
-  SessionEnd: EXECUTOR_STOP_COMMAND
-};
-var CODEX_EXECUTOR_HOOKS = {
-  SessionStart: EXECUTOR_PULSE_COMMAND,
-  UserPromptSubmit: EXECUTOR_PULSE_COMMAND,
-  PreToolUse: EXECUTOR_PULSE_COMMAND,
-  Stop: EXECUTOR_PULSE_COMMAND
-};
-function registerExecutor(program2) {
-  const executor = program2.command("executor").description(
-    "Register and operate a local Claude Code/Codex executor advertisement"
+// src/commands/telemetry.ts
+function registerTelemetry(program2) {
+  const telemetry = program2.command("telemetry").description(
+    "Emit WLP run telemetry (an executor leg's progress events) into a decomposition run"
   );
-  executor.command("install").description(
-    "Configure this checkout's harness to advertise itself as a WLP executor"
-  ).option("--connector <id>", "Approved local-session ConnectorDefinition id").option(
-    "--instance-key <key>",
-    "Stable executor identity (defaults to .sechroom/lane.json code-lane)"
-  ).option(
-    "--lane-id <lane>",
-    "Canonical affinity lane (defaults to .sechroom/lane.json code-lane)"
-  ).option("--runtime <kind>", "claude-code | codex").option("--surface <surface>", "claude | codex").option(
-    "--capability <key...>",
-    "Capability operation keys claimed by this instance"
+  telemetry.command("emit").description(
+    "POST one progress event to /decompositions/{id}/run/telemetry (the 5a ingest)"
+  ).requiredOption(
+    "--decomposition <id>",
+    "Decomposition id whose run this event belongs to"
+  ).requiredOption("--task <id>", "Task id this event belongs to").requiredOption(
+    "--kind <kind>",
+    "Event kind: raw | parsed | approval | terminal"
   ).option(
-    "--relay <id>",
-    "Relay identity shared by sibling instances",
-    "sechroom-cli-local"
+    "--tokens-in <n>",
+    "Cumulative input tokens (spend meter)",
+    parseIntOpt
   ).option(
-    "--subscription-name <name>",
+    "--tokens-out <n>",
+    "Cumulative output tokens (spend meter)",
+    parseIntOpt
+  ).option(
+    "--context-used <n>",
+    "Context tokens currently used (occupancy meter)",
+    parseIntOpt
+  ).option(
+    "--context-window <n>",
+    "Context window size (occupancy meter)",
+    parseIntOpt
+  ).option("--text <s>", "Raw/parsed payload text").option("--approval <state>", "Approval gate state (approval events)").option(
+    "--verdict <v>",
+    "Typed verdict (terminal events): pass | soft-fail | plan-invalid | blocked"
+  ).action(async (opts, cmd) => {
+    const json = Boolean(cmd.optsWithGlobals().json);
+    const cfg = resolveConfig(cmd.optsWithGlobals());
+    const event = {
+      taskId: opts.task,
+      kind: normalizeKind(opts.kind),
+      tokensIn: opts.tokensIn ?? null,
+      tokensOut: opts.tokensOut ?? null,
+      contextUsed: opts.contextUsed ?? null,
+      contextWindow: opts.contextWindow ?? null,
+      text: opts.text ?? null,
+      approvalState: opts.approval ?? null,
+      verdict: opts.verdict ?? null
+    };
+    let body;
+    try {
+      body = await postTelemetry(cfg, opts.decomposition, [event]);
+    } catch (e) {
+      return fail(`Telemetry emit failed: ${e.message}`);
+    }
+    if (json) {
+      emit(body, true);
+    } else {
+      process.stderr.write(
+        style.green("telemetry emitted") + style.dim(
+          ` \u2014 ${event.kind} for task ${opts.task}; run now carries ${body.eventCount} event${body.eventCount === 1 ? "" : "s"}
+`
+        )
+      );
+    }
+  });
+  telemetry.command("show <decompositionId>").description(
+    "Read a run's telemetry \u2014 per-task meters + the raw/parsed/approval/terminal timeline (GET /decompositions/{id}/run/telemetry). Returns hasTelemetry:false, not an error, before any event is ingested \u2014 so an unstarted run and a stalled one read differently. The read side of this group; `emit` is the source side. (FR-sechroom-442 slice 1 step 4; mirrors the work_plan_run_telemetry MCP tool.)"
+  ).action(async (decompositionId, _opts, cmd) => {
+    const globals = cmd.optsWithGlobals();
+    const cfg = resolveConfig(globals);
+    const data = await runApi("Reading run telemetry", async () => {
+      const client = await makeClient(cfg);
+      return client.GET("/decompositions/{id}/run/telemetry", {
+        params: { path: { id: decompositionId } }
+      });
+    });
+    emitAction(
+      data.hasTelemetry ? `read telemetry for ${style.bold(decompositionId)}` : `no telemetry yet for ${style.bold(decompositionId)} (run not started or not yet reporting)`,
+      data,
+      globals.json
+    );
+  });
+  telemetry.command("bind").description(
+    "Bind this checkout to a decomposition+task so the Stop hook auto-emits per-turn telemetry"
+  ).requiredOption(
+    "--decomposition <id>",
+    "Decomposition id this session executes"
+  ).requiredOption("--task <id>", "Task id this session executes").action((opts, cmd) => {
+    const json = Boolean(cmd.optsWithGlobals().json);
+    const dir = join8(process.cwd(), ".sechroom");
+    mkdirSync7(dir, { recursive: true });
+    const path = join8(dir, BINDING_FILE);
+    const binding = {
+      decompositionId: opts.decomposition,
+      taskId: opts.task
+    };
+    writeFileSync6(path, JSON.stringify(binding, null, 2) + "\n");
+    ensureStateDirIgnored(process.cwd());
+    if (json) {
+      emit({ bound: true, ...binding, path }, true);
+    } else {
+      process.stdout.write(
+        style.green("telemetry bound") + style.dim(
+          ` \u2014 decomposition ${binding.decompositionId}, task ${binding.taskId} (${path})
+`
+        )
+      );
+    }
+  });
+  telemetry.command("unbind").description("Clear this checkout's telemetry binding").action((_opts, cmd) => {
+    const json = Boolean(cmd.optsWithGlobals().json);
+    const path = join8(process.cwd(), ".sechroom", BINDING_FILE);
+    const existed = existsSync7(path);
+    if (existed) rmSync3(path);
+    if (json) emit({ unbound: existed, path }, true);
+    else
+      process.stdout.write(
+        existed ? "telemetry binding cleared\n" : "no telemetry binding to clear\n"
+      );
+  });
+  telemetry.command("hook").description(
+    "Per-turn telemetry self-report for Claude Code hooks \u2014 Stop/SubagentStop \u2192 parsed + terminal, Notification/PermissionDenied \u2192 approval (reads stdin; no-op unless bound). Fail-soft."
+  ).action(async (_opts, cmd) => {
+    try {
+      const raw = await readStdin();
+      const input = parseHookInput(raw);
+      const cwd = input.cwd ?? process.cwd();
+      const binding = findBinding(cwd);
+      if (!binding) return process.exit(0);
+      const usage = input.transcript_path ? parseTranscript(input.transcript_path) : null;
+      const events = buildHookEvents(input, usage, binding.taskId);
+      if (events.length === 0) return process.exit(0);
+      const cfg = resolveConfig(cmd.optsWithGlobals());
+      await postTelemetry(cfg, binding.decompositionId, events);
+      return process.exit(0);
+    } catch {
+      return process.exit(0);
+    }
+  });
+  telemetry.command("install").description(
+    "Wire the per-turn telemetry Stop hook into Claude Code settings (also folded into `sechroom hook install`)"
+  ).option(
+    "--scope <scope>",
+    "global (config dir / CLAUDE_CONFIG_DIR) or project (<cwd>/.claude) \u2014 default global"
+  ).option("--local", "alias for --scope project").option("--dry-run", "Print what would change; write nothing").action((opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    const dryRun = Boolean(opts.dryRun);
+    const cwd = process.cwd();
+    let scope;
+    try {
+      scope = opts.local ? "project" : resolveScope(opts.scope);
+    } catch (err2) {
+      process.stderr.write(`${err2.message}
+`);
+      return process.exit(2);
+    }
+    const targets = resolveClaudeTargets({
+      override: g.claudeConfigDir,
+      scope,
+      cwd
+    });
+    const commands = {
+      Stop: "sechroom telemetry hook",
+      SubagentStop: "sechroom telemetry hook",
+      Notification: "sechroom telemetry hook",
+      PermissionDenied: "sechroom telemetry hook"
+    };
+    try {
+      const multi = targets.length > 1;
+      const results = targets.map((t) => {
+        const r = installClaudeCommands(t.dir, commands, dryRun);
+        process.stdout.write(
+          `${HOOK_SURFACE_LABEL.claude}${multi ? ` (${t.label})` : ""}:
+`
+        );
+        process.stdout.write(describe(r, dryRun) + "\n");
+        return r;
+      });
+      if (dryRun) {
+        process.stdout.write("\n(dry run \u2014 no files were written.)\n");
+      } else if (results.every((r) => r.status === "current")) {
+        process.stdout.write("\nAlready up to date \u2014 nothing to change.\n");
+      } else {
+        process.stdout.write(
+          "\nRestart your agent for the hook to take effect, then bind a task with `sechroom telemetry bind`.\n"
+        );
+      }
+    } catch (err2) {
+      process.stderr.write(
+        `telemetry install failed: ${err2.message}
+`
+      );
+      return process.exit(1);
+    }
+    warnIfSechroomNotOnPath();
+    return process.exit(0);
+  });
+}
+var BINDING_FILE = "telemetry.json";
+async function postTelemetry(cfg, decompositionId, events) {
+  const token = await requireToken(cfg);
+  const resp = await fetch(
+    `${cfg.baseUrl}/decompositions/${encodeURIComponent(decompositionId)}/run/telemetry`,
+    {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${token}`,
+        tenant: cfg.tenant,
+        "content-type": "application/json",
+        "x-sechroom-surface": "cli"
+      },
+      body: JSON.stringify({ events })
+    }
+  );
+  if (!resp.ok) throw new Error(`HTTP ${resp.status}: ${await resp.text()}`);
+  return await resp.json();
+}
+function findBinding(start) {
+  let dir = start;
+  for (; ; ) {
+    const path = join8(dir, ".sechroom", BINDING_FILE);
+    if (existsSync7(path)) {
+      try {
+        const b = JSON.parse(
+          readFileSync5(path, "utf8")
+        );
+        if (b.decompositionId && b.taskId)
+          return { decompositionId: b.decompositionId, taskId: b.taskId };
+      } catch {
+      }
+      return null;
+    }
+    const parent = dirname6(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function parseTranscript(path) {
+  if (!existsSync7(path)) return null;
+  let tokensIn = 0;
+  let tokensOut = 0;
+  let contextUsed = 0;
+  let model = "";
+  for (const line of readFileSync5(path, "utf8").split("\n")) {
+    if (!line.trim()) continue;
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const usage = obj.type === "assistant" ? obj.message?.usage : void 0;
+    if (!usage) continue;
+    const input = (usage.input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0);
+    tokensIn += input;
+    tokensOut += usage.output_tokens ?? 0;
+    contextUsed = input;
+    if (obj.message?.model) model = obj.message.model;
+  }
+  if (tokensIn === 0 && tokensOut === 0) return null;
+  return { tokensIn, tokensOut, contextUsed, contextWindow: windowFor(model, contextUsed), modelId: model || null };
+}
+function windowFor(model, contextUsed = 0) {
+  const m = model.toLowerCase();
+  if (m.includes("[1m]") || m.includes("-1m")) return 1e6;
+  return contextUsed > 2e5 ? 1e6 : 2e5;
+}
+function buildHookEvents(input, usage, taskId) {
+  const events = [];
+  const base = (kind, over) => ({
+    taskId,
+    kind,
+    tokensIn: null,
+    tokensOut: null,
+    contextUsed: null,
+    contextWindow: null,
+    text: null,
+    approvalState: null,
+    verdict: null,
+    modelId: null,
+    ...over
+  });
+  if (usage) {
+    events.push(
+      base("Parsed", {
+        tokensIn: usage.tokensIn,
+        tokensOut: usage.tokensOut,
+        contextUsed: usage.contextUsed,
+        contextWindow: usage.contextWindow,
+        modelId: usage.modelId
+      })
+    );
+  }
+  switch (input.hook_event_name) {
+    case "PermissionDenied":
+      events.push(
+        base("Approval", {
+          approvalState: "denied",
+          text: input.tool_name ?? input.message ?? null
+        })
+      );
+      break;
+    case "Notification":
+      if (isPermissionNotification(input))
+        events.push(base("Approval", { text: input.message ?? null }));
+      break;
+    case "Stop":
+    case "SubagentStop":
+      events.push(base("Terminal", { text: input.last_assistant_message ?? null }));
+      break;
+  }
+  return events;
+}
+function isPermissionNotification(input) {
+  const t = (input.notification_type ?? input.type ?? "").toLowerCase();
+  if (t) return t.includes("permission");
+  return (input.message ?? "").toLowerCase().includes("permission");
+}
+async function readStdin() {
+  if (process.stdin.isTTY) return "";
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf8");
+}
+function parseHookInput(raw) {
+  if (!raw.trim()) return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+var KINDS = {
+  raw: "Raw",
+  parsed: "Parsed",
+  approval: "Approval",
+  terminal: "Terminal"
+};
+function normalizeKind(k) {
+  const v = KINDS[k.toLowerCase()];
+  if (!v)
+    fail(
+      `Unknown --kind '${k}'. Expected one of: raw, parsed, approval, terminal.`
+    );
+  return v;
+}
+function parseIntOpt(v) {
+  const n = Number.parseInt(v, 10);
+  if (Number.isNaN(n)) fail(`Expected an integer, got '${v}'.`);
+  return n;
+}
+
+// src/executor-run/delivery.ts
+import { execFile as execFile2 } from "child_process";
+function createGitRunner(rootDir) {
+  return (bin, args) => new Promise((resolve5) => {
+    execFile2(
+      bin,
+      bin === "git" ? ["-C", rootDir, ...args] : args,
+      { cwd: rootDir, maxBuffer: 10 * 1024 * 1024 },
+      (error, stdout, stderr) => resolve5({ ok: !error, stdout: String(stdout), stderr: String(stderr) })
+    );
+  });
+}
+function porcelainPaths(stdout) {
+  return stdout.split("\n").map((line) => line.trimEnd()).filter((line) => line.length > 3).map((line) => {
+    const path = line.slice(3);
+    const arrow = path.indexOf(" -> ");
+    return arrow >= 0 ? path.slice(arrow + 4) : path;
+  });
+}
+async function snapshotRoot(git) {
+  const branch = await git("git", ["rev-parse", "--abbrev-ref", "HEAD"]);
+  const status = await git("git", ["status", "--porcelain"]);
+  return {
+    baseBranch: branch.ok ? branch.stdout.trim() : "HEAD",
+    dirtyPaths: status.ok ? porcelainPaths(status.stdout) : []
+  };
+}
+async function checkRootReady(git, allowDirty) {
+  const snapshot = await snapshotRoot(git);
+  if (snapshot.dirtyPaths.length === 0 || allowDirty)
+    return { ok: true, snapshot };
+  return {
+    ok: false,
+    snapshot,
+    reason: `root has ${snapshot.dirtyPaths.length} uncommitted path(s) (e.g. ${snapshot.dirtyPaths[0]}) \u2014 refusing to claim; commit/clean it or pass --allow-dirty-root`
+  };
+}
+async function deliverTurn(git, options) {
+  const status = await git("git", ["status", "--porcelain"]);
+  if (!status.ok)
+    return { delivered: false, note: `delivery skipped \u2014 git status failed: ${status.stderr.trim()}` };
+  const preDirty = new Set(options.snapshot.dirtyPaths);
+  const turnPaths = porcelainPaths(status.stdout).filter((p) => !preDirty.has(p));
+  if (turnPaths.length === 0)
+    return { delivered: false, note: "no file changes produced by the turn \u2014 nothing to deliver" };
+  const branch = await freeBranchName(git, `task/${slug(options.taskId)}`);
+  const created = await git("git", ["checkout", "-b", branch]);
+  if (!created.ok)
+    return {
+      delivered: false,
+      note: `delivery FAILED \u2014 could not create branch ${branch}: ${created.stderr.trim()} (changes remain uncommitted in the root)`
+    };
+  const notes = [];
+  try {
+    const added = await git("git", ["add", "--", ...turnPaths]);
+    if (!added.ok) return failBack(`git add failed: ${added.stderr.trim()}`);
+    const committed = await git("git", [
+      "commit",
+      "-m",
+      commitMessage(options)
+    ]);
+    if (!committed.ok) return failBack(`git commit failed: ${committed.stderr.trim()}`);
+    const sha = (await git("git", ["rev-parse", "--short", "HEAD"])).stdout.trim();
+    const pushed = await git("git", ["push", "-u", "origin", branch]);
+    if (!pushed.ok)
+      notes.push(`push failed (${firstLine(pushed.stderr)}) \u2014 branch is local-only`);
+    let prUrl;
+    if (options.raisePr && pushed.ok) {
+      const pr = await git("gh", [
+        "pr",
+        "create",
+        "--head",
+        branch,
+        "--title",
+        `task(${options.taskId}): ${options.title}`,
+        "--body",
+        prBody(options, sha)
+      ]);
+      if (pr.ok) prUrl = firstLine(pr.stdout);
+      else notes.push(`PR raise failed (${firstLine(pr.stderr)}) \u2014 raise manually from ${branch}`);
+    }
+    notes.unshift(
+      `delivered ${turnPaths.length} path(s) to ${branch} @ ${sha}${prUrl ? ` \u2014 PR ${prUrl}` : ""}`
+    );
+    return { delivered: true, branch, sha, prUrl, note: notes.join("; ") };
+  } finally {
+    const back = await git("git", ["checkout", options.snapshot.baseBranch]);
+    if (!back.ok)
+      options.log(
+        `delivery: could not return root to ${options.snapshot.baseBranch}: ${back.stderr.trim()}`
+      );
+  }
+  function failBack(reason) {
+    return { delivered: false, branch, note: `delivery FAILED \u2014 ${reason}` };
+  }
+}
+async function freeBranchName(git, base) {
+  for (let i = 0; ; i++) {
+    const candidate = i === 0 ? base : `${base}-${i + 1}`;
+    const exists = await git("git", [
+      "rev-parse",
+      "--verify",
+      "--quiet",
+      `refs/heads/${candidate}`
+    ]);
+    if (!exists.ok) return candidate;
+  }
+}
+function slug(taskId) {
+  return taskId.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function commitMessage(options) {
+  return `task(${options.taskId}): ${options.title} [verdict:${options.verdict}]
+
+Driven-executor delivery (FR-sechroom-496): work produced by the sandboxed codex turn, landed by the driver.
+
+Delivered-By: sechroom executor run (${options.deliveredBy})`;
+}
+function prBody(options, sha) {
+  return `Driven-executor delivery for WLP task \`${options.taskId}\` (verdict: ${options.verdict}, commit ${sha}).
+
+Work produced by a sandboxed codex turn and landed by the unsandboxed driver (FR-sechroom-496). Review against the task's acceptance before merge.`;
+}
+function firstLine(text2) {
+  return text2.trim().split("\n")[0] ?? "";
+}
+
+// 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";
+  }
+}
+async function runDriverLoop(ports, options) {
+  const summary = { processed: 0, completed: 0, abandoned: 0 };
+  let admissionDeferred = false;
+  while (!options.stopping()) {
+    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 (!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);
+          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.`
+        );
+      }
+    }
+    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/commands/executor-run.ts
+function registerExecutorRunCommand(executor) {
+  executor.command("fleet").description("Run multiple isolated driven codex executors from one config file").requiredOption("--config <file>", "JSON fleet config").action(async (opts) => {
+    const fleet = superviseFleet(await readFleetConfig(String(opts.config)));
+    const stop = () => void fleet.shutdown("SIGINT");
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    try {
+      await fleet.done;
+    } finally {
+      process.off("SIGINT", stop);
+      process.off("SIGTERM", stop);
+    }
+  });
+  executor.command("run").description(
+    "Run a driven codex executor: claim, execute, heartbeat, and complete dispatched tasks unattended"
+  ).option("--runtime <kind>", "Runtime to drive (only codex today)", "codex").option("--model <model>", "codex model override").option("--sandbox <mode>", "codex sandbox mode", "workspace-write").option(
+    "--root <dir>",
+    "Working directory for the spawned codex turns (e.g. ../sechroom_4)",
+    process.cwd()
+  ).option(
+    "--codex-bin <bin>",
+    "codex binary (or CODEX_BIN)",
+    process.env.CODEX_BIN ?? "codex"
+  ).option(
+    "--instance-key <key>",
+    "Registration identity (defaults to installed executor.json)"
+  ).option(
+    "--lane <lane>",
+    "Affinity lane + completion source (defaults to instance key)"
+  ).option(
+    "--connector <id>",
+    "Approved connector id (defaults to installed executor.json)"
+  ).option("--ttl <seconds>", "Advertisement TTL (30-600)").option("--once", "Process a single task, then exit", false).option(
+    "--no-deliver",
+    "Skip driver-side delivery (branch/commit/push of the turn's changes)"
+  ).option(
+    "--allow-dirty-root",
+    "Claim even when the root has uncommitted changes (they are fenced out of the delivery commit)",
+    false
+  ).option("--no-pr", "Deliver without raising a PR (branch + push only)").option("--poll-interval <seconds>", "Offer reconciliation interval", "5").option(
+    "--heartbeat-interval <seconds>",
+    "Lease heartbeat cadence",
+    "30"
+  ).option("--turn-timeout <seconds>", "Fresh turn timeout", "300").option("--resume-turn-timeout <seconds>", "Resumed turn timeout", "1200").option(
+    "--drain-timeout <seconds>",
+    "On shutdown, seconds to let an in-flight turn finish before interrupting",
+    "30"
+  ).option(
+    "--usage-reserve <percent>",
+    "Rate-limit reserve: defer claiming new tasks while remaining is at or below this percent",
+    "2"
+  ).action(async (opts, cmd) => {
+    if (String(opts.runtime).toLowerCase() !== "codex")
+      fail("executor run drives runtime codex only (claude-code stays attached)");
+    const located = readExecutorState();
+    if (!located)
+      fail(
+        "executor run requires an installed executor advertisement; run `sechroom executor install` first."
+      );
+    if (located.state.runtime !== "codex")
+      fail(
+        `this checkout's executor advertisement is runtime '${located.state.runtime}' \u2014 reinstall with --runtime codex.`
+      );
+    located.state = {
+      ...located.state,
+      instanceKey: opts.instanceKey ? String(opts.instanceKey) : located.state.instanceKey,
+      laneId: opts.lane ? String(opts.lane) : located.state.laneId,
+      connectorId: opts.connector ? String(opts.connector) : located.state.connectorId,
+      ttlSeconds: opts.ttl ? Number.parseInt(String(opts.ttl), 10) : located.state.ttlSeconds
+    };
+    const heartbeatMs = Number.parseInt(String(opts.heartbeatInterval), 10) * 1e3;
+    if (heartbeatMs >= 12e4)
+      fail("--heartbeat-interval must be shorter than the 120s 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)");
+    const cfg = resolveConfig(cmd.optsWithGlobals());
+    const instance = await ensureExecutorInstance(cfg, located);
+    const log = (line) => process.stderr.write(style.dim(`[run] ${line}
+`));
+    const request = createAuthedRequest(cfg);
+    const rootDir = resolve2(String(opts.root));
+    const usageLogPath = join9(
+      rootDir,
+      ".sechroom",
+      `executor-usage-${located.state.instanceKey.replace(/[^\w.-]/g, "-")}.jsonl`
+    );
+    const usageTracker = new UsageTracker({
+      instanceKey: located.state.instanceKey,
+      reservePercent: usageReserve,
+      log,
+      appendRecord: createUsageLogAppender(usageLogPath, log)
+    });
+    const appServer = new CodexAppServer({
+      codexBin: String(opts.codexBin),
+      cwd: rootDir,
+      model: opts.model ? String(opts.model) : void 0,
+      sandbox: String(opts.sandbox),
+      turnTimeoutMs: Number.parseInt(String(opts.turnTimeout), 10) * 1e3,
+      resumeTurnTimeoutMs: Number.parseInt(String(opts.resumeTurnTimeout), 10) * 1e3,
+      log,
+      executorInstanceId: instance.id,
+      emitTelemetry: (decompositionId, events) => postTelemetry(cfg, decompositionId, events).then(() => void 0),
+      onUsage: (taskId, usage) => usageTracker.recordUsage(taskId, usage),
+      onRateLimits: (limits) => usageTracker.recordRateLimits(limits)
+    });
+    await appServer.start();
+    log(`codex app-server up (${String(opts.codexBin)})`);
+    let stopping = false;
+    let turnInFlight = false;
+    const requestStop = () => {
+      if (stopping) return;
+      stopping = true;
+      wake();
+      log("shutdown requested \u2014 finishing up");
+      if (turnInFlight) {
+        const drainMs = Number.parseInt(String(opts.drainTimeout), 10) * 1e3;
+        setTimeout(() => void appServer.interrupt(), drainMs).unref?.();
+      }
+    };
+    process.once("SIGINT", requestStop);
+    process.once("SIGTERM", requestStop);
+    let wake = () => {
+    };
+    const wakeSignal = () => new Promise((resolve5) => {
+      wake = resolve5;
+    });
+    let connStop = async () => {
+    };
+    try {
+      const conn = await openConnection(cfg, () => wake(), instance.id);
+      connStop = () => conn.stop();
+    } catch (e) {
+      log(`SignalR wake leg unavailable (${String(e)}) \u2014 poll-only`);
+    }
+    const stopAdvertisementHeartbeat = startExecutorHeartbeat(
+      () => request(
+        `/me/executor-instances/${encodeURIComponent(instance.id)}/refresh`,
+        {
+          method: "POST",
+          body: JSON.stringify({ ttlSeconds: located.state.ttlSeconds })
+        }
+      ),
+      located.state.refreshAfterSeconds * 1e3,
+      { onError: (e) => log(`advertisement refresh failed: ${String(e)}`) }
+    );
+    const gitRunner = createGitRunner(rootDir);
+    let rootSnapshot;
+    const deliveryPorts = opts.deliver === false ? {} : {
+      checkRootReady: async () => {
+        const ready = await checkRootReady(
+          gitRunner,
+          Boolean(opts.allowDirtyRoot)
+        );
+        rootSnapshot = ready.snapshot;
+        return { ok: ready.ok, reason: ready.reason };
+      },
+      deliver: (claim, task, verdict) => deliverTurn(gitRunner, {
+        taskId: claim.memoryId,
+        title: task.title,
+        verdict,
+        snapshot: rootSnapshot ?? {
+          baseBranch: "HEAD",
+          dirtyPaths: []
+        },
+        deliveredBy: located.state.laneId ?? located.state.instanceKey,
+        raisePr: opts.pr !== false,
+        log
+      })
+    };
+    const ports = {
+      ...deliveryPorts,
+      checkAdmission: async () => usageTracker.admission(),
+      claimNext: () => claimNext(request, instance.id, log),
+      loadTask: (memoryId) => loadTask(request, memoryId, log),
+      startLeaseHeartbeat: (claim) => startLeaseHeartbeat(
+        () => request(
+          `/me/executor-task-leases/${encodeURIComponent(claim.leaseId)}/heartbeat`,
+          {
+            method: "POST",
+            body: JSON.stringify({
+              claimToken: claim.claimToken,
+              tokenVersion: claim.tokenVersion
+            })
+          }
+        ),
+        log,
+        heartbeatMs
+      ),
+      runTurn: async (task, claim) => {
+        if (!appServer.alive) {
+          log("codex app-server died between tasks \u2014 respawning");
+          await appServer.start();
+        }
+        turnInFlight = true;
+        try {
+          return await appServer.runTask(taskPrompt(task), {
+            taskId: claim.memoryId,
+            leaseId: claim.leaseId,
+            decompositionId: claim.decompositionId
+          });
+        } finally {
+          turnInFlight = false;
+        }
+      },
+      completeLease: (claim, verdict, text2, title) => request(
+        `/me/executor-task-leases/${encodeURIComponent(claim.leaseId)}/complete`,
+        {
+          method: "POST",
+          body: JSON.stringify({
+            executorInstanceId: instance.id,
+            claimToken: claim.claimToken,
+            tokenVersion: claim.tokenVersion,
+            verdict,
+            text: text2,
+            source: located.state.laneId ?? located.state.instanceKey,
+            title
+          })
+        }
+      ),
+      log,
+      waitForWake: (ms) => Promise.race([
+        new Promise((resolve5) => {
+          setTimeout(resolve5, ms).unref?.();
+        }),
+        wakeSignal()
+      ])
+    };
+    log(
+      `driven executor live \u2014 instance ${located.state.instanceKey}, lane ${located.state.laneId ?? located.state.instanceKey}${opts.once ? ", single-task mode" : ""}`
+    );
+    log(`usage log \u2192 ${usageLogPath}; admission reserve ${usageReserve}%`);
+    try {
+      const summary = await runDriverLoop(ports, {
+        once: Boolean(opts.once),
+        pollMs: Number.parseInt(String(opts.pollInterval), 10) * 1e3,
+        stopping: () => stopping,
+        source: located.state.laneId ?? located.state.instanceKey
+      });
+      log(
+        `done \u2014 processed ${summary.processed}, completed ${summary.completed}, abandoned ${summary.abandoned}`
+      );
+    } catch (error) {
+      if (error instanceof AuthExpiredError) {
+        process.stderr.write(
+          style.dim(`[run] auth expired: ${error.message}
+`)
+        );
+        process.exitCode = 1;
+      } else {
+        throw error;
+      }
+    } finally {
+      stopAdvertisementHeartbeat();
+      await connStop().catch(() => {
+      });
+      try {
+        await request(
+          `/me/executor-instances/${encodeURIComponent(instance.id)}`,
+          { method: "DELETE", body: JSON.stringify({}) }
+        );
+        log("deregistered");
+      } catch (e) {
+        log(`deregister failed (${String(e)}) \u2014 advertisement will expire by TTL`);
+      }
+      appServer.stop();
+    }
+  });
+}
+async function claimNext(request, instanceId, log) {
+  const claimed = await claimNextTask({ request, executorInstanceId: instanceId, log });
+  if (!claimed) return void 0;
+  return {
+    memoryId: claimed.memoryId,
+    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) };
+}
+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.
+
+${task.text}
+
+Call sechroom_lifecycle_signal at each phase boundary (start/work/verify/closeout). When the work is done \u2014 or honestly cannot be \u2014 end by calling sechroom_closeout with the true terminal_status, a summary, and evidence. Never end the turn without calling sechroom_closeout.`;
+}
+
+// src/commands/executor.ts
+function executorSubscriptionInput(name) {
+  return {
+    name,
+    enabled: true,
+    filter: { tags: ["kind:task"], workspaceScope: [] }
+  };
+}
+function executorRegistrationInput(state, deliverySubscriptionId) {
+  return {
+    relayId: state.relayId,
+    instanceKey: state.instanceKey,
+    laneId: state.laneId ?? state.instanceKey,
+    runtimeKind: parseRuntimeKind(state.runtime),
+    activationMode: "Attached",
+    deliverySubscriptionId,
+    connectorId: state.connectorId,
+    claimedCapabilityKeys: state.capabilityKeys,
+    toolSetRef: null,
+    ttlSeconds: state.ttlSeconds
+  };
+}
+var EXECUTOR_STATE = "executor.json";
+var EXECUTOR_PULSE_COMMAND = "sechroom executor hook-pulse";
+var EXECUTOR_STOP_COMMAND = "sechroom executor hook-stop";
+var CLAUDE_EXECUTOR_HOOKS = {
+  SessionStart: EXECUTOR_PULSE_COMMAND,
+  UserPromptSubmit: EXECUTOR_PULSE_COMMAND,
+  PreToolUse: EXECUTOR_PULSE_COMMAND,
+  Stop: EXECUTOR_PULSE_COMMAND,
+  SessionEnd: EXECUTOR_STOP_COMMAND
+};
+var CODEX_EXECUTOR_HOOKS = {
+  SessionStart: EXECUTOR_PULSE_COMMAND,
+  UserPromptSubmit: EXECUTOR_PULSE_COMMAND,
+  PreToolUse: EXECUTOR_PULSE_COMMAND,
+  Stop: EXECUTOR_PULSE_COMMAND
+};
+function registerExecutor(program2) {
+  const executor = program2.command("executor").description(
+    "Register and operate a local Claude Code/Codex executor advertisement"
+  );
+  executor.command("install").description(
+    "Configure this checkout's harness to advertise itself as a WLP executor"
+  ).option("--connector <id>", "Approved local-session ConnectorDefinition id").option(
+    "--instance-key <key>",
+    "Stable executor identity (defaults to .sechroom/lane.json code-lane)"
+  ).option(
+    "--lane-id <lane>",
+    "Canonical affinity lane (defaults to .sechroom/lane.json code-lane)"
+  ).option("--runtime <kind>", "claude-code | codex").option("--surface <surface>", "claude | codex").option(
+    "--capability <key...>",
+    "Capability operation keys claimed by this instance"
+  ).option(
+    "--relay <id>",
+    "Relay identity shared by sibling instances",
+    "sechroom-cli-local"
+  ).option(
+    "--subscription-name <name>",
     "SignalR delivery binding name",
     "executor-dispatch"
   ).option("--ttl <seconds>", "Advertisement TTL (30-600)", parseInteger, 600).option(
@@ -2048,8 +3840,8 @@ function registerExecutor(program2) {
     if (opts.refreshAfter >= opts.ttl)
       fail("refresh-after must be shorter than the TTL");
     const sem = readSem();
-    const checkout = sem ? dirname5(dirname5(sem.path)) : process.cwd();
-    const statePath = join8(checkout, ".sechroom", EXECUTOR_STATE);
+    const checkout = sem ? dirname7(dirname7(sem.path)) : process.cwd();
+    const statePath = join10(checkout, ".sechroom", EXECUTOR_STATE);
     const state = {
       schemaVersion: 1,
       instanceKey,
@@ -2063,14 +3855,14 @@ function registerExecutor(program2) {
       refreshAfterSeconds: opts.refreshAfter
     };
     if (!opts.dryRun) {
-      mkdirSync6(dirname5(statePath), { recursive: true });
-      writeFileSync6(statePath, JSON.stringify(state, null, 2) + "\n");
+      mkdirSync8(dirname7(statePath), { recursive: true });
+      writeFileSync7(statePath, JSON.stringify(state, null, 2) + "\n");
       ensureStateDirIgnored(checkout);
     }
     const configuredClaudeDirs = globals.claudeConfigDir || process.env.CLAUDE_CONFIG_DIR ? resolveClaudeTargets({ override: globals.claudeConfigDir }).map(
       (target) => target.dir
-    ) : [join8(checkout, ".claude")];
-    const configuredCodexHomes = globals.codexHome || process.env.CODEX_HOME ? resolveCodexHomes({ override: globals.codexHome }) : [join8(checkout, ".codex")];
+    ) : [join10(checkout, ".claude")];
+    const configuredCodexHomes = globals.codexHome || process.env.CODEX_HOME ? resolveCodexHomes({ override: globals.codexHome }) : [join10(checkout, ".codex")];
     const hookTargets = surface === "claude" ? configuredClaudeDirs : configuredCodexHomes;
     for (const target of hookTargets) {
       const results = surface === "claude" ? [
@@ -2114,7 +3906,7 @@ function registerExecutor(program2) {
       );
       delete located.state.instanceId;
       delete located.state.lastRefreshAt;
-      writeFileSync6(
+      writeFileSync7(
         located.path,
         JSON.stringify(located.state, null, 2) + "\n"
       );
@@ -2253,6 +4045,7 @@ function registerExecutor(program2) {
     );
     emit(data, Boolean(cmd.optsWithGlobals().json));
   });
+  registerExecutorRunCommand(executor);
 }
 function parseRuntimeKind(value) {
   switch (value.trim().toLowerCase()) {
@@ -2305,19 +4098,19 @@ async function ensureExecutorInstance(cfg, located) {
   const data = await registerInstance(cfg, state);
   state.instanceId = data.id;
   state.lastRefreshAt = (/* @__PURE__ */ new Date()).toISOString();
-  writeFileSync6(path, JSON.stringify(state, null, 2) + "\n");
+  writeFileSync7(path, JSON.stringify(state, null, 2) + "\n");
   return data;
 }
 function readExecutorState(start = process.cwd()) {
   const semPath = resolveSemPathForRead(start);
   const sem = semPath ? readSem(semPath) : void 0;
-  const path = join8(
-    sem ? dirname5(sem.path) : join8(start, ".sechroom"),
+  const path = join10(
+    sem ? dirname7(sem.path) : join10(start, ".sechroom"),
     EXECUTOR_STATE
   );
-  if (!existsSync7(path)) return void 0;
+  if (!existsSync8(path)) return void 0;
   return {
-    state: JSON.parse(readFileSync5(path, "utf8")),
+    state: JSON.parse(readFileSync6(path, "utf8")),
     path
   };
 }
@@ -2349,11 +4142,11 @@ function parseInteger(value) {
   return parsed;
 }
 function holdHeartbeat(tick, intervalMs) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve5, reject) => {
     const timer = setInterval(() => void tick().catch(reject), intervalMs);
     const stop = () => {
       clearInterval(timer);
-      resolve3();
+      resolve5();
     };
     process.once("SIGINT", stop);
     process.once("SIGTERM", stop);
@@ -2504,7 +4297,7 @@ function registerChannel(program2) {
     "MCP server + subscription name (idempotent per name)",
     "sechroom-channel"
   ).option("--dry-run", "Print what would change; write nothing").action((opts) => {
-    const path = join9(process.cwd(), ".mcp.json");
+    const path = join11(process.cwd(), ".mcp.json");
     const dryRun = Boolean(opts.dryRun);
     const args = ["channel", "mcp"];
     const entry = { command: "sechroom", args };
@@ -2514,8 +4307,8 @@ function registerChannel(program2) {
     const status = JSON.stringify(existing) === JSON.stringify(entry) ? "current" : existing ? "updated" : "created";
     if (status !== "current" && !dryRun) {
       config2.mcpServers[opts.name] = entry;
-      mkdirSync7(dirname6(path), { recursive: true });
-      writeFileSync7(path, JSON.stringify(config2, null, 2) + "\n");
+      mkdirSync9(dirname8(path), { recursive: true });
+      writeFileSync8(path, JSON.stringify(config2, null, 2) + "\n");
     }
     const verb = status === "current" ? "already configured" : dryRun ? `would ${status === "created" ? "create" : "update"}` : status;
     process.stdout.write(`${style.green("channel")} ${path} (${verb})
@@ -2606,7 +4399,7 @@ function startExecutorHeartbeat(refresh, intervalMilliseconds, dependencies = {}
 }
 async function drainClaims(cfg, executorInstanceId, deliver, dependencies = {}) {
   const request = dependencies.request ?? api;
-  const sleep = dependencies.sleep ?? ((milliseconds) => new Promise((resolve3) => setTimeout(resolve3, milliseconds)));
+  const sleep = dependencies.sleep ?? ((milliseconds) => new Promise((resolve5) => setTimeout(resolve5, milliseconds)));
   const idempotencyKey = dependencies.idempotencyKey ?? ((offer) => `channel:${offer.generationId}`);
   const state = dependencies.state ?? {};
   for (; ; ) {
@@ -2651,8 +4444,8 @@ async function drainClaims(cfg, executorInstanceId, deliver, dependencies = {})
   }
 }
 function readMcpConfig(path) {
-  if (!existsSync8(path)) return {};
-  const raw = readFileSync6(path, "utf8");
+  if (!existsSync9(path)) return {};
+  const raw = readFileSync7(path, "utf8");
   if (!raw.trim()) return {};
   try {
     return JSON.parse(raw);
@@ -2680,9 +4473,9 @@ async function openConnection(cfg, onEvent, executorInstanceId) {
   return conn;
 }
 function holdOpen(conn) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve5) => {
     const stop = () => {
-      void conn.stop().finally(resolve3);
+      void conn.stop().finally(resolve5);
     };
     process.on("SIGINT", stop);
     process.on("SIGTERM", stop);
@@ -2808,20 +4601,20 @@ Examples:
 }
 
 // src/commands/checkpoint.ts
-import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname8, join as join11 } from "path";
+import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname10, join as join13 } from "path";
 
 // src/commands/hook.ts
 import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync9, mkdirSync as mkdirSync8, readFileSync as readFileSync7, statSync as statSync2, writeFileSync as writeFileSync8 } from "fs";
-import { dirname as dirname7, join as join10 } from "path";
-async function readStdin() {
+import { existsSync as existsSync10, mkdirSync as mkdirSync10, readFileSync as readFileSync8, statSync as statSync2, writeFileSync as writeFileSync9 } from "fs";
+import { dirname as dirname9, join as join12 } from "path";
+async function readStdin2() {
   if (process.stdin.isTTY) return "";
   const chunks = [];
   for await (const chunk of process.stdin) chunks.push(chunk);
   return Buffer.concat(chunks).toString("utf8");
 }
-function parseHookInput(raw) {
+function parseHookInput2(raw) {
   if (!raw.trim()) return {};
   try {
     return JSON.parse(raw);
@@ -2838,13 +4631,13 @@ function resolveLane(flagLane, cwd) {
   if (!base) return void 0;
   return applyWorktreeLaneSuffix(base, start);
 }
-var INTENT_FILE = join10(".sechroom", "continuity.json");
+var INTENT_FILE = join12(".sechroom", "continuity.json");
 function resolveIntentPath(start) {
   let dir = start;
   for (; ; ) {
-    const candidate = join10(dir, INTENT_FILE);
-    if (existsSync9(candidate)) return candidate;
-    const parent = dirname7(dir);
+    const candidate = join12(dir, INTENT_FILE);
+    if (existsSync10(candidate)) return candidate;
+    const parent = dirname9(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
@@ -2853,7 +4646,7 @@ function readIntent(start) {
   const path = resolveIntentPath(start);
   if (!path) return void 0;
   try {
-    return JSON.parse(readFileSync7(path, "utf8"));
+    return JSON.parse(readFileSync8(path, "utf8"));
   } catch {
     return void 0;
   }
@@ -2895,14 +4688,14 @@ async function saveSnapshotFromIntent(cmd, cwd, laneFlag, scopeFlag, defaultScop
 }
 function ledgerPath(start) {
   const intent = resolveIntentPath(start);
-  const dir = intent ? dirname7(intent) : join10(start, ".sechroom");
-  return join10(dir, ".checkpoint-state.json");
+  const dir = intent ? dirname9(intent) : join12(start, ".sechroom");
+  return join12(dir, ".checkpoint-state.json");
 }
 function readLedger(start) {
   try {
     const p = ledgerPath(start);
-    if (!existsSync9(p)) return {};
-    return JSON.parse(readFileSync7(p, "utf8"));
+    if (!existsSync10(p)) return {};
+    return JSON.parse(readFileSync8(p, "utf8"));
   } catch {
     return {};
   }
@@ -2949,13 +4742,13 @@ function recordPush(start, intent) {
     } catch {
       mtimeMs = void 0;
     }
-    mkdirSync8(dirname7(p), { recursive: true });
+    mkdirSync10(dirname9(p), { recursive: true });
     const ledger = {
       lastEpochMs: Date.now(),
       lastMtimeMs: mtimeMs,
       lastHash: intentHash(intent)
     };
-    writeFileSync8(p, JSON.stringify(ledger) + "\n");
+    writeFileSync9(p, JSON.stringify(ledger) + "\n");
   } catch {
   }
 }
@@ -3015,8 +4808,8 @@ Fail-soft: no lane / no auth / no-or-partial intent file / API error -> exit 0,
   );
   hook.command("session-start").description("Resume the checkout's lane and emit continuity context for a SessionStart hook").option("--lane <laneId>", "Override the resolved lane (else SECHROOM_LANE, else ./.sechroom/lane.json code-lane)").option("--surface <surface>", "Target surface: claude | codex (output is identical for session-start)", "claude").option("--max-artifacts <n>", "Cap artifacts in the resume bundle").action(async (opts, cmd) => {
     try {
-      const raw = await readStdin();
-      const input = parseHookInput(raw);
+      const raw = await readStdin2();
+      const input = parseHookInput2(raw);
       const lane = resolveLane(opts.lane, input.cwd);
       if (!lane) return process.exit(0);
       const semPath = resolveSemPathForRead(input.cwd ?? process.cwd());
@@ -3041,8 +4834,8 @@ Fail-soft: no lane / no auth / no-or-partial intent file / API error -> exit 0,
   });
   hook.command("pre-compact").description("Save a continuity snapshot from the agent-maintained intent file on a PreCompact hook").option("--lane <laneId>", "Override the resolved lane (else SECHROOM_LANE, else ./.sechroom/lane.json code-lane)").option("--scope <scope>", "Snapshot scope (else the intent file's `scope`, else 'compaction')").option("--surface <surface>", "Target surface: claude | codex (lifecycle-only on both)", "claude").action(async (opts, cmd) => {
     try {
-      const raw = await readStdin();
-      const input = parseHookInput(raw);
+      const raw = await readStdin2();
+      const input = parseHookInput2(raw);
       const cwd = input.cwd ?? process.cwd();
       await saveSnapshotFromIntent(cmd, cwd, opts.lane, opts.scope, "compaction", { skipIfUnchanged: true });
       return process.exit(0);
@@ -3055,8 +4848,8 @@ Fail-soft: no lane / no auth / no-or-partial intent file / API error -> exit 0,
     "skip if a hook checkpoint ran within this many minutes \u2014 for high-frequency triggers like Codex Stop (Claude SessionEnd passes none)"
   ).action(async (opts, cmd) => {
     try {
-      const raw = await readStdin();
-      const input = parseHookInput(raw);
+      const raw = await readStdin2();
+      const input = parseHookInput2(raw);
       const cwd = input.cwd ?? process.cwd();
       const debounce = opts.debounceMinutes != null ? Number(opts.debounceMinutes) : 0;
       if (debounce > 0 && recentlyCheckpointed(cwd, debounce)) return process.exit(0);
@@ -3208,10 +5001,10 @@ Examples:
       const client = await makeClient(cfg);
       return client.POST("/continuity/snapshots", { body });
     });
-    const path = resolveIntentPath(cwd) ?? join11(cwd, INTENT_FILE);
+    const path = resolveIntentPath(cwd) ?? join13(cwd, INTENT_FILE);
     const fileBody = { ...merged, scope, lastSnapshotId: data.snapshotId };
-    mkdirSync9(dirname8(path), { recursive: true });
-    writeFileSync9(path, JSON.stringify(fileBody, null, 2) + "\n");
+    mkdirSync11(dirname10(path), { recursive: true });
+    writeFileSync10(path, JSON.stringify(fileBody, null, 2) + "\n");
     recordPush(cwd, merged);
     if (json) {
       emit({ snapshotId: data.snapshotId, lane, scope, file: path }, true);
@@ -3225,7 +5018,7 @@ Examples:
 }
 
 // src/commands/close.ts
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 var VERDICTS = ["pass", "soft-fail", "plan-invalid", "blocked"];
 function registerClose(program2) {
   program2.command("close").description(
@@ -3266,7 +5059,7 @@ Examples:
       );
     let bodyText;
     try {
-      bodyText = opts.file ? readFileSync8(opts.file, "utf8") : readFileSync8(0, "utf8");
+      bodyText = opts.file ? readFileSync9(opts.file, "utf8") : readFileSync9(0, "utf8");
     } catch {
       fail(
         opts.file ? `could not read --file ${opts.file}` : "no closeout body \u2014 pass --file <path> or pipe it on stdin"
@@ -3557,7 +5350,7 @@ Examples:
 }
 
 // src/commands/work-plan.ts
-import { readFile } from "fs/promises";
+import { readFile as readFile2 } from "fs/promises";
 function registerWorkPlan(program2) {
   const workPlan = program2.command("work-plan").description(
     "Drive a work plan: create one from a brief, then execute / accept / reject"
@@ -3568,9 +5361,13 @@ function registerWorkPlan(program2) {
 Examples:
   $ sechroom work-plan create mem_XXXX
   $ sechroom work-plan create-from-tasks mem_XXXX --file plan.json
+  $ sechroom work-plan append wlp_XXXX --file append.json
   $ sechroom work-plan get-plan wlp_XXXX
   $ sechroom work-plan execute wlp_XXXX
   $ sechroom work-plan publish-context-pack wlp_XXXX
+  $ sechroom work-plan resume wlp_XXXX
+  $ sechroom work-plan return-for-revision wlp_XXXX --notes "Split the migration task"
+  $ sechroom work-plan list --status Accepted --brief mem_XXXX
   $ sechroom work-plan accept wlp_XXXX
   $ sechroom work-plan reject wlp_XXXX --reason "wrong shape"`
   );
@@ -3580,38 +5377,57 @@ Examples:
     const cfg = resolveConfig(cmd.optsWithGlobals());
     const data = await runApi("Creating work plan", async () => {
       const client = await makeClient(cfg);
-      return client.POST("/work-briefs/{id}/decompose", {
+      return client.POST("/work-briefs/{id}/decompose", {
+        params: { path: { id: briefId } },
+        body: { id: briefId }
+      });
+    });
+    emitAction(
+      `created work plan from ${style.bold(briefId)} \u2192 ${style.bold(data.suggestionId)}`,
+      data,
+      cmd.optsWithGlobals().json
+    );
+  });
+  workPlan.command("create-from-tasks <briefId>").description(
+    "Create a work plan from a hand-authored JSON task list; tasks may carry Unix-millisecond wakeAtMs"
+  ).requiredOption(
+    "--file <path>",
+    "JSON file containing { project, tasks, source? }; use - for stdin"
+  ).action(async (briefId, opts, cmd) => {
+    const raw = opts.file === "-" ? await readStdin3() : await readFile2(opts.file, "utf8");
+    const body = parsePlanInput(raw, opts.file);
+    const cfg = resolveConfig(cmd.optsWithGlobals());
+    const data = await runApi("Creating work plan from tasks", async () => {
+      const client = await makeClient(cfg);
+      return client.POST("/work-briefs/{id}/decompose-from-plan", {
         params: { path: { id: briefId } },
-        body: { id: briefId }
+        body
       });
     });
     emitAction(
-      `created work plan from ${style.bold(briefId)} \u2192 ${style.bold(data.suggestionId)}`,
+      `created ${style.bold(data.suggestionId)} from ${data.taskCount} hand-authored task(s)`,
       data,
       cmd.optsWithGlobals().json
     );
   });
-  workPlan.command("create-from-tasks <briefId>").description(
-    "Create a work plan from a hand-authored JSON task list; tasks may carry Unix-millisecond wakeAtMs"
+  workPlan.command("append <decompositionId>").description(
+    "Append hand-authored task(s) to a running work plan; they land proposed until ratified (POST /decompositions/{id}/append-tasks)"
   ).requiredOption(
     "--file <path>",
-    "JSON file containing { project, tasks, source? }; use - for stdin"
-  ).action(async (briefId, opts, cmd) => {
-    const raw = opts.file === "-" ? await readStdin2() : await readFile(opts.file, "utf8");
-    const body = parsePlanInput(raw, opts.file);
+    "JSON file containing { tasks, gates? } (the AppendTasksInput shape); use - for stdin"
+  ).action(async (decompositionId, opts, cmd) => {
+    const raw = opts.file === "-" ? await readStdin3() : await readFile2(opts.file, "utf8");
+    const body = parseAppendInput(raw, opts.file);
     const cfg = resolveConfig(cmd.optsWithGlobals());
-    const data = await runApi(
-      "Creating work plan from tasks",
-      async () => {
-        const client = await makeClient(cfg);
-        return client.POST("/work-briefs/{id}/decompose-from-plan", {
-          params: { path: { id: briefId } },
-          body
-        });
-      }
-    );
+    const data = await runApi("Appending tasks to work plan", async () => {
+      const client = await makeClient(cfg);
+      return client.POST("/decompositions/{id}/append-tasks", {
+        params: { path: { id: decompositionId } },
+        body
+      });
+    });
     emitAction(
-      `created ${style.bold(data.suggestionId)} from ${data.taskCount} hand-authored task(s)`,
+      `appended ${style.bold(String(data.appendedTaskIds.length))} task(s) to ${style.bold(decompositionId)}`,
       data,
       cmd.optsWithGlobals().json
     );
@@ -3666,6 +5482,70 @@ Examples:
       cmd.optsWithGlobals().json
     );
   });
+  workPlan.command("resume <decompositionId>").description(
+    "Resume a failed work-plan decomposition (POST /decompositions/{id}/resume)"
+  ).action(async (decompositionId, _opts, cmd) => {
+    const globals = cmd.optsWithGlobals();
+    const cfg = resolveConfig(globals);
+    const data = await runApi("Resuming work plan", async () => {
+      const client = await makeClient(cfg);
+      return client.POST("/decompositions/{id}/resume", {
+        params: { path: { id: decompositionId } },
+        body: {}
+      });
+    });
+    emitAction(
+      `resumed work plan ${style.bold(decompositionId)} \u2192 ${data.status}`,
+      data,
+      globals.json
+    );
+  });
+  workPlan.command("return-for-revision <decompositionId>").description(
+    "Return a candidate work plan for revision (POST /decompositions/{id}/return-for-revision)"
+  ).requiredOption(
+    "--notes <text>",
+    "Revision notes for the next decomposition attempt"
+  ).action(async (decompositionId, opts, cmd) => {
+    const globals = cmd.optsWithGlobals();
+    const cfg = resolveConfig(globals);
+    const data = await runApi(
+      "Returning work plan for revision",
+      async () => {
+        const client = await makeClient(cfg);
+        return client.POST("/decompositions/{id}/return-for-revision", {
+          params: { path: { id: decompositionId } },
+          body: { notes: opts.notes }
+        });
+      }
+    );
+    emitAction(
+      `returned ${style.bold(decompositionId)} \u2192 ${style.bold(data.newSuggestionId)}`,
+      data,
+      globals.json
+    );
+  });
+  workPlan.command("list").description("List work plans, newest-first (GET /decompositions)").option("--status <status>", "Filter by decomposition status").option("--brief <briefId>", "Filter by work-brief memory id").option("--page <n>", "1-based page number", (v) => Number.parseInt(v, 10)).option("--page-size <n>", "Page size", (v) => Number.parseInt(v, 10)).action(async (opts, cmd) => {
+    const globals = cmd.optsWithGlobals();
+    const cfg = resolveConfig(globals);
+    const data = await runApi("Listing work plans", async () => {
+      const client = await makeClient(cfg);
+      return client.GET("/decompositions", {
+        params: {
+          query: {
+            status: opts.status,
+            briefId: opts.brief,
+            page: opts.page,
+            pageSize: opts.pageSize
+          }
+        }
+      });
+    });
+    emitAction(
+      `listed ${style.bold(String(data.items.length))} of ${data.count} work plan(s)`,
+      data,
+      globals.json
+    );
+  });
   workPlan.command("accept <decompositionId>").description(
     "Accept a Pending work plan \u2014 promote + ratify its Tasks (POST /decompositions/{id}/accept)"
   ).action(async (decompositionId, _opts, cmd) => {
@@ -3701,6 +5581,19 @@ Examples:
     );
   });
 }
+function parseAppendInput(raw, sourceName = "append input") {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(
+      `${sourceName} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (!value || typeof value !== "object" || !Array.isArray(value.tasks))
+    throw new Error(`${sourceName} must contain an object with a tasks array`);
+  return value;
+}
 function parsePlanInput(raw, sourceName = "plan input") {
   let value;
   try {
@@ -3714,7 +5607,7 @@ function parsePlanInput(raw, sourceName = "plan input") {
     throw new Error(`${sourceName} must contain an object with a tasks array`);
   return value;
 }
-async function readStdin2() {
+async function readStdin3() {
   const chunks = [];
   for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));
   return Buffer.concat(chunks).toString("utf8");
@@ -4231,8 +6124,8 @@ Examples:
 
 // src/setup/apply.ts
 import { createHash as createHash3 } from "crypto";
-import { mkdirSync as mkdirSync10, readFileSync as readFileSync9, writeFileSync as writeFileSync10, existsSync as existsSync10 } from "fs";
-import { dirname as dirname9 } from "path";
+import { mkdirSync as mkdirSync12, readFileSync as readFileSync10, writeFileSync as writeFileSync11, existsSync as existsSync11 } from "fs";
+import { dirname as dirname11 } from "path";
 var MARKER_BEGIN = "<!-- @sechroom/cli:begin";
 var MARKER_END = "<!-- @sechroom/cli:end";
 function normalizeBody(s) {
@@ -4285,22 +6178,22 @@ function parseManagedBlock(content, block) {
   return null;
 }
 function ensureDir2(path) {
-  mkdirSync10(dirname9(path), { recursive: true });
+  mkdirSync12(dirname11(path), { recursive: true });
 }
 function readOr(path, fallback) {
   try {
-    return readFileSync9(path, "utf8");
+    return readFileSync10(path, "utf8");
   } catch {
     return fallback;
   }
 }
 function mergeMcpJson(path, snippet, dryRun) {
   const incoming = JSON.parse(snippet);
-  const existed = existsSync10(path);
+  const existed = existsSync11(path);
   let current = {};
   if (existed) {
     try {
-      current = JSON.parse(readFileSync9(path, "utf8"));
+      current = JSON.parse(readFileSync10(path, "utf8"));
     } catch {
       return { kind: "mcp", path, status: "skipped", note: "existing file isn't valid JSON \u2014 left untouched" };
     }
@@ -4308,26 +6201,26 @@ function mergeMcpJson(path, snippet, dryRun) {
   current.mcpServers = { ...current.mcpServers ?? {}, ...incoming.mcpServers ?? {} };
   if (dryRun) return { kind: "mcp", path, status: "dry-run" };
   ensureDir2(path);
-  writeFileSync10(path, JSON.stringify(current, null, 2) + "\n", { mode: 384 });
+  writeFileSync11(path, JSON.stringify(current, null, 2) + "\n", { mode: 384 });
   return { kind: "mcp", path, status: existed ? "merged" : "created" };
 }
 function mergeCodexToml(path, snippet, dryRun) {
-  const existed = existsSync10(path);
+  const existed = existsSync11(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);
-  writeFileSync10(path, next, { mode: 384 });
+  writeFileSync11(path, next, { mode: 384 });
   return { kind: "mcp", path, status: existed ? "merged" : "created" };
 }
 function writeInstructionBlock(path, write, dryRun) {
-  const existed = existsSync10(path);
+  const existed = existsSync11(path);
   const next = computeBlockFile(readOr(path, ""), write);
   if (dryRun) return { kind: "instruction", path, status: "dry-run" };
   ensureDir2(path);
-  writeFileSync10(path, next);
+  writeFileSync11(path, next);
   return { kind: "instruction", path, status: existed ? "merged" : "created" };
 }
 function computeBlockFile(current, write) {
@@ -4368,7 +6261,7 @@ function applyBlock(path, write, mode, dryRun) {
     const next = computeBlockFile(current, write);
     if (!dryRun) {
       ensureDir2(proposedPath);
-      writeFileSync10(proposedPath, next);
+      writeFileSync11(proposedPath, next);
     }
     return {
       kind: "instruction",
@@ -4498,8 +6391,8 @@ auto-resumes where you left off and checkpoints working state before compacting.
 }
 
 // src/setup/skills-offer.ts
-import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync11 } from "fs";
-import { join as join12 } from "path";
+import { mkdirSync as mkdirSync13, writeFileSync as writeFileSync12 } from "fs";
+import { join as join14 } from "path";
 
 // src/setup/lane-pin.ts
 var CODE_LANE_PREFIX_BY_CLIENT = {
@@ -4615,8 +6508,8 @@ Found ${summary} available to you for ${surface}.
   if (skills.length > 0) {
     const written = [];
     for (const s of skills) {
-      mkdirSync11(join12(sDir, s.name), { recursive: true });
-      writeFileSync11(join12(sDir, s.name, "SKILL.md"), s.body.endsWith("\n") ? s.body : s.body + "\n");
+      mkdirSync13(join14(sDir, s.name), { recursive: true });
+      writeFileSync12(join14(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 });
@@ -4624,11 +6517,11 @@ Found ${summary} available to you for ${surface}.
 `);
   }
   if (agents.length > 0) {
-    mkdirSync11(aDir, { recursive: true });
+    mkdirSync13(aDir, { recursive: true });
     const written = [];
     for (const a of agents) {
       const file = `${a.name}.md`;
-      writeFileSync11(join12(aDir, file), a.body.endsWith("\n") ? a.body : a.body + "\n");
+      writeFileSync12(join14(aDir, file), a.body.endsWith("\n") ? a.body : a.body + "\n");
       written.push(file);
     }
     recordMaterialisedSkills(aDir, DEFAULT_SKILLS_SLUG, written, { surface });
@@ -4963,12 +6856,12 @@ Examples:
     });
     emit(data, cmd.optsWithGlobals().json);
   });
-  namespace.command("show <slug>").description("Show a namespace's details (GET /mcp-aggregator/namespaces/{slug}). For the tool list it exposes, point an OpenAPI client at /t/{tenant}/namespaces/{slug}/api/openapi.json.").action(async (slug, _opts, cmd) => {
+  namespace.command("show <slug>").description("Show a namespace's details (GET /mcp-aggregator/namespaces/{slug}). For the tool list it exposes, point an OpenAPI client at /t/{tenant}/namespaces/{slug}/api/openapi.json.").action(async (slug2, _opts, cmd) => {
     const cfg = resolveConfig(cmd.optsWithGlobals());
     const data = await runApi("Fetching namespace", async () => {
       const client = await makeClient(cfg);
       return client.GET("/mcp-aggregator/namespaces/{slug}", {
-        params: { path: { slug } }
+        params: { path: { slug: slug2 } }
       });
     });
     emit(data, cmd.optsWithGlobals().json);
@@ -4977,11 +6870,11 @@ Examples:
     "--client <list>",
     `comma-separated clients (${ALL_CLIENT_KEYS.join(", ")}) or 'all'`,
     DEFAULT_CLIENT_KEY
-  ).option("--dry-run", "print what would be written without writing", false).action(async (slug, opts, cmd) => {
+  ).option("--dry-run", "print what would be written without writing", false).action(async (slug2, opts, cmd) => {
     const cfg = resolveConfig(cmd.optsWithGlobals());
     const setup = await withSpinner(
       "Fetching setup descriptors",
-      () => fetchSetup(cfg, slug)
+      () => fetchSetup(cfg, slug2)
     );
     const targets = clientTargets(process.cwd());
     const keys = resolveClientKeys(opts.client);
@@ -4999,25 +6892,25 @@ Examples:
       if (!json) printActions(target, actions);
     }
     if (json) {
-      emit({ namespace: slug, dryRun: Boolean(opts.dryRun), clients: result }, true);
+      emit({ namespace: slug2, dryRun: Boolean(opts.dryRun), clients: result }, true);
       return;
     }
     process.stdout.write(
       opts.dryRun ? "\n(dry run \u2014 nothing written)\n" : `
-Wired to namespace '${slug}'. Restart your AI client (or reload MCP) to pick it up.
+Wired to namespace '${slug2}'. Restart your AI client (or reload MCP) to pick it up.
 `
     );
   });
 }
 
 // src/commands/onboard.ts
-import { existsSync as existsSync12 } from "fs";
-import { basename as basename2, join as join14 } from "path";
+import { existsSync as existsSync13 } from "fs";
+import { basename as basename2, join as join16 } from "path";
 
 // src/commands/fanout.ts
 import { spawnSync } from "child_process";
-import { existsSync as existsSync11, readFileSync as readFileSync10, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
-import { isAbsolute, join as join13, resolve } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync11, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
+import { isAbsolute, join as join15, resolve as resolve3 } from "path";
 var ICON = {
   refresh: "\u21BB",
   bind: "+",
@@ -5025,7 +6918,7 @@ var ICON = {
   "skip-unbound": "\u26A0"
 };
 function resolveChildDir(path, root) {
-  return isAbsolute(path) ? path : resolve(root, path);
+  return isAbsolute(path) ? path : resolve3(root, path);
 }
 function discoverChildren(root) {
   let names;
@@ -5037,21 +6930,21 @@ function discoverChildren(root) {
   const out = [];
   for (const name of names.sort()) {
     if (name.startsWith(".") || name === "node_modules") continue;
-    const dir = join13(root, name);
+    const dir = join15(root, name);
     try {
       if (!statSync3(dir).isDirectory()) continue;
     } catch {
       continue;
     }
-    if (existsSync11(join13(dir, ".git")) || committedBindingPath(dir)) out.push(name);
+    if (existsSync12(join15(dir, ".git")) || committedBindingPath(dir)) out.push(name);
   }
   return out;
 }
 function readManifest(path) {
-  if (!existsSync11(path)) return null;
+  if (!existsSync12(path)) return null;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync10(path, "utf8"));
+    parsed = JSON.parse(readFileSync11(path, "utf8"));
   } catch (err2) {
     throw new Error(`couldn't parse ${path}: ${err2 instanceof Error ? err2.message : String(err2)}`);
   }
@@ -5417,10 +7310,10 @@ async function chooseScope(scopeFlag, yes) {
 }
 async function planRecurseChild(entry, root, client, opts) {
   const dir = resolveChildDir(entry.path, root);
-  if (!existsSync12(dir)) {
+  if (!existsSync13(dir)) {
     return { label: entry.path, dir, disposition: "skip-missing", argv: [], reason: "directory does not exist" };
   }
-  if (existsSync12(join14(dir, ".sechroom.json"))) {
+  if (existsSync13(join16(dir, ".sechroom.json"))) {
     return {
       label: entry.path,
       dir,
@@ -5493,7 +7386,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 = join14(root, ".sechroom", "repos.json");
+  const manifestPath = join16(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}`;
@@ -6026,31 +7919,31 @@ Examples:
 
 // src/commands/reset.ts
 import { homedir as homedir4 } from "os";
-import { join as join15 } from "path";
-import { existsSync as existsSync13, readFileSync as readFileSync11, rmSync as rmSync3 } from "fs";
+import { join as join17 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync12, rmSync as rmSync4 } from "fs";
 var SKILLS_LOCK2 = ".sechroom-skills.json";
-var localSkillsDir = () => join15(process.cwd(), ".claude", "skills");
-var globalSkillsDir = () => join15(homedir4(), ".claude", "skills");
-var localAgentsDir = () => join15(process.cwd(), ".claude", "agents");
-var globalAgentsDir = () => join15(homedir4(), ".claude", "agents");
+var localSkillsDir = () => join17(process.cwd(), ".claude", "skills");
+var globalSkillsDir = () => join17(homedir4(), ".claude", "skills");
+var localAgentsDir = () => join17(process.cwd(), ".claude", "agents");
+var globalAgentsDir = () => join17(homedir4(), ".claude", "agents");
 function removeMaterialisedSkills(dir) {
   const removed = [];
-  const lockPath = join15(dir, SKILLS_LOCK2);
-  if (!existsSync13(lockPath)) return removed;
+  const lockPath = join17(dir, SKILLS_LOCK2);
+  if (!existsSync14(lockPath)) return removed;
   try {
-    const lock = JSON.parse(readFileSync11(lockPath, "utf8"));
+    const lock = JSON.parse(readFileSync12(lockPath, "utf8"));
     for (const entry of Object.values(lock)) {
       for (const name of entry.skills ?? []) {
-        const p = join15(dir, name);
-        if (existsSync13(p)) {
-          rmSync3(p, { recursive: true, force: true });
+        const p = join17(dir, name);
+        if (existsSync14(p)) {
+          rmSync4(p, { recursive: true, force: true });
           removed.push(p);
         }
       }
     }
   } catch {
   }
-  rmSync3(lockPath, { force: true });
+  rmSync4(lockPath, { force: true });
   removed.push(lockPath);
   return removed;
 }
@@ -6087,19 +7980,19 @@ function registerReset(program2) {
       }
     }
     const removed = [];
-    const stateDir = join15(process.cwd(), ".sechroom");
-    if (existsSync13(stateDir)) {
-      rmSync3(stateDir, { recursive: true, force: true });
+    const stateDir = join17(process.cwd(), ".sechroom");
+    if (existsSync14(stateDir)) {
+      rmSync4(stateDir, { recursive: true, force: true });
       removed.push(stateDir);
     }
-    const legacyCfg = join15(process.cwd(), ".sechroom.json");
-    if (existsSync13(legacyCfg)) {
-      rmSync3(legacyCfg, { force: true });
+    const legacyCfg = join17(process.cwd(), ".sechroom.json");
+    if (existsSync14(legacyCfg)) {
+      rmSync4(legacyCfg, { force: true });
       removed.push(legacyCfg);
     }
-    const legacySem = join15(process.cwd(), ".sem");
-    if (existsSync13(legacySem)) {
-      rmSync3(legacySem, { force: true });
+    const legacySem = join17(process.cwd(), ".sem");
+    if (existsSync14(legacySem)) {
+      rmSync4(legacySem, { force: true });
       removed.push(legacySem);
     }
     removed.push(...removeMaterialisedSkills(localSkillsDir()));
@@ -6124,8 +8017,8 @@ function registerReset(program2) {
 }
 
 // src/commands/skills.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync12, statSync as statSync4, writeFileSync as writeFileSync12 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync14, statSync as statSync4, writeFileSync as writeFileSync13 } from "fs";
+import { join as join18 } from "path";
 function filenameFromDisposition(header) {
   if (!header) return void 0;
   const m = /filename\*?=(?:UTF-8'')?"?([^";]+)"?/i.exec(header);
@@ -6133,11 +8026,11 @@ function filenameFromDisposition(header) {
 }
 function resolveOutputPath(output, serverFilename) {
   const filename = serverFilename || "skills.zip";
-  if (!output) return join16(process.cwd(), filename);
-  const looksLikeDir = output.endsWith("/") || existsSync14(output) && statSync4(output).isDirectory();
+  if (!output) return join18(process.cwd(), filename);
+  const looksLikeDir = output.endsWith("/") || existsSync15(output) && statSync4(output).isDirectory();
   if (looksLikeDir) {
-    mkdirSync12(output, { recursive: true });
-    return join16(output, filename);
+    mkdirSync14(output, { recursive: true });
+    return join18(output, filename);
   }
   return output;
 }
@@ -6168,7 +8061,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);
-  writeFileSync12(path, buf);
+  writeFileSync13(path, buf);
   return { path, bytes: buf.length, filename };
 }
 function registerSkills(program2) {
@@ -6342,12 +8235,12 @@ clients select all; an unconfigured machine preserves the legacy Claude default.
 }
 
 // src/commands/sweep.ts
-import { existsSync as existsSync15 } from "fs";
-import { dirname as dirname10, join as join17, resolve as resolve2 } from "path";
-var DEFAULT_MANIFEST = join17(".sechroom", "repos.json");
+import { existsSync as existsSync16 } from "fs";
+import { dirname as dirname12, join as join19, resolve as resolve4 } from "path";
+var DEFAULT_MANIFEST = join19(".sechroom", "repos.json");
 function planEntry(entry, root) {
   const dir = resolveChildDir(entry.path, root);
-  if (!existsSync15(dir)) {
+  if (!existsSync16(dir)) {
     return { label: entry.path, dir, disposition: "skip-missing", argv: [], reason: "directory does not exist" };
   }
   if (committedBindingPath(dir)) {
@@ -6400,400 +8293,44 @@ Per repo (paths resolve relative to the manifest's root):
   ${ICON["skip-unbound"]} no workspace unbound + no workspaceId in manifest  \u2192 skipped (add one, or onboard manually)
 
 Examples:
-  $ sechroom sweep --dry-run            preview every repo's disposition, run nothing
-  $ sechroom sweep                      onboard the whole tree from the root
-  $ sechroom --tenant ocd sweep         force a tenant for every child (else each resolves its own)`
-  ).action((opts, cmd) => {
-    const g = cmd.optsWithGlobals();
-    const json = Boolean(g.json);
-    const dryRun = Boolean(opts.dryRun);
-    const manifestPath = resolve2(opts.manifest);
-    let repos;
-    try {
-      repos = readManifest(manifestPath);
-    } catch (err2) {
-      fail(err2 instanceof Error ? err2.message : String(err2));
-    }
-    if (repos === null) {
-      fail(`no manifest at ${manifestPath} \u2014 create ./.sechroom/repos.json, or use \`sechroom onboard --recurse\` to auto-discover (see \`sechroom sweep --help\`).`);
-    }
-    if (repos.length === 0) {
-      if (json) process.stdout.write(JSON.stringify({ manifest: manifestPath, repos: [] }) + "\n");
-      else process.stderr.write(`${warn("\u26A0")} ${manifestPath} lists no repos \u2014 nothing to do.
-`);
-      return;
-    }
-    const root = dirname10(dirname10(manifestPath));
-    const plans = repos.map((entry) => planEntry(entry, root));
-    if (!json) {
-      process.stderr.write(
-        `${style.bold("sweep")} ${style.dim(`(${plans.length} repo${plans.length === 1 ? "" : "s"} from ${manifestPath})`)}
-`
-      );
-    }
-    const results = runChildren(plans, { globals: passthroughGlobals(g), dryRun, json });
-    if (json) {
-      process.stdout.write(JSON.stringify({ manifest: manifestPath, dryRun, repos: results }) + "\n");
-      return;
-    }
-    summarizeFanout(results, { dryRun });
-  });
-}
-
-// src/commands/telemetry.ts
-import {
-  existsSync as existsSync16,
-  mkdirSync as mkdirSync13,
-  readFileSync as readFileSync12,
-  rmSync as rmSync4,
-  writeFileSync as writeFileSync13
-} from "fs";
-import { dirname as dirname11, join as join18 } from "path";
-function registerTelemetry(program2) {
-  const telemetry = program2.command("telemetry").description(
-    "Emit WLP run telemetry (an executor leg's progress events) into a decomposition run"
-  );
-  telemetry.command("emit").description(
-    "POST one progress event to /decompositions/{id}/run/telemetry (the 5a ingest)"
-  ).requiredOption(
-    "--decomposition <id>",
-    "Decomposition id whose run this event belongs to"
-  ).requiredOption("--task <id>", "Task id this event belongs to").requiredOption(
-    "--kind <kind>",
-    "Event kind: raw | parsed | approval | terminal"
-  ).option(
-    "--tokens-in <n>",
-    "Cumulative input tokens (spend meter)",
-    parseIntOpt
-  ).option(
-    "--tokens-out <n>",
-    "Cumulative output tokens (spend meter)",
-    parseIntOpt
-  ).option(
-    "--context-used <n>",
-    "Context tokens currently used (occupancy meter)",
-    parseIntOpt
-  ).option(
-    "--context-window <n>",
-    "Context window size (occupancy meter)",
-    parseIntOpt
-  ).option("--text <s>", "Raw/parsed payload text").option("--approval <state>", "Approval gate state (approval events)").option(
-    "--verdict <v>",
-    "Typed verdict (terminal events): pass | soft-fail | plan-invalid | blocked"
-  ).action(async (opts, cmd) => {
-    const json = Boolean(cmd.optsWithGlobals().json);
-    const cfg = resolveConfig(cmd.optsWithGlobals());
-    const event = {
-      taskId: opts.task,
-      kind: normalizeKind(opts.kind),
-      tokensIn: opts.tokensIn ?? null,
-      tokensOut: opts.tokensOut ?? null,
-      contextUsed: opts.contextUsed ?? null,
-      contextWindow: opts.contextWindow ?? null,
-      text: opts.text ?? null,
-      approvalState: opts.approval ?? null,
-      verdict: opts.verdict ?? null
-    };
-    let body;
-    try {
-      body = await postTelemetry(cfg, opts.decomposition, [event]);
-    } catch (e) {
-      return fail(`Telemetry emit failed: ${e.message}`);
-    }
-    if (json) {
-      emit(body, true);
-    } else {
-      process.stderr.write(
-        style.green("telemetry emitted") + style.dim(
-          ` \u2014 ${event.kind} for task ${opts.task}; run now carries ${body.eventCount} event${body.eventCount === 1 ? "" : "s"}
-`
-        )
-      );
-    }
-  });
-  telemetry.command("show <decompositionId>").description(
-    "Read a run's telemetry \u2014 per-task meters + the raw/parsed/approval/terminal timeline (GET /decompositions/{id}/run/telemetry). Returns hasTelemetry:false, not an error, before any event is ingested \u2014 so an unstarted run and a stalled one read differently. The read side of this group; `emit` is the source side. (FR-sechroom-442 slice 1 step 4; mirrors the work_plan_run_telemetry MCP tool.)"
-  ).action(async (decompositionId, _opts, cmd) => {
-    const globals = cmd.optsWithGlobals();
-    const cfg = resolveConfig(globals);
-    const data = await runApi("Reading run telemetry", async () => {
-      const client = await makeClient(cfg);
-      return client.GET("/decompositions/{id}/run/telemetry", {
-        params: { path: { id: decompositionId } }
-      });
-    });
-    emitAction(
-      data.hasTelemetry ? `read telemetry for ${style.bold(decompositionId)}` : `no telemetry yet for ${style.bold(decompositionId)} (run not started or not yet reporting)`,
-      data,
-      globals.json
-    );
-  });
-  telemetry.command("bind").description(
-    "Bind this checkout to a decomposition+task so the Stop hook auto-emits per-turn telemetry"
-  ).requiredOption(
-    "--decomposition <id>",
-    "Decomposition id this session executes"
-  ).requiredOption("--task <id>", "Task id this session executes").action((opts, cmd) => {
-    const json = Boolean(cmd.optsWithGlobals().json);
-    const dir = join18(process.cwd(), ".sechroom");
-    mkdirSync13(dir, { recursive: true });
-    const path = join18(dir, BINDING_FILE);
-    const binding = {
-      decompositionId: opts.decomposition,
-      taskId: opts.task
-    };
-    writeFileSync13(path, JSON.stringify(binding, null, 2) + "\n");
-    ensureStateDirIgnored(process.cwd());
-    if (json) {
-      emit({ bound: true, ...binding, path }, true);
-    } else {
-      process.stdout.write(
-        style.green("telemetry bound") + style.dim(
-          ` \u2014 decomposition ${binding.decompositionId}, task ${binding.taskId} (${path})
-`
-        )
-      );
-    }
-  });
-  telemetry.command("unbind").description("Clear this checkout's telemetry binding").action((_opts, cmd) => {
-    const json = Boolean(cmd.optsWithGlobals().json);
-    const path = join18(process.cwd(), ".sechroom", BINDING_FILE);
-    const existed = existsSync16(path);
-    if (existed) rmSync4(path);
-    if (json) emit({ unbound: existed, path }, true);
-    else
-      process.stdout.write(
-        existed ? "telemetry binding cleared\n" : "no telemetry binding to clear\n"
-      );
-  });
-  telemetry.command("hook").description(
-    "Per-turn telemetry self-report for Claude Code hooks \u2014 Stop/SubagentStop \u2192 parsed + terminal, Notification/PermissionDenied \u2192 approval (reads stdin; no-op unless bound). Fail-soft."
-  ).action(async (_opts, cmd) => {
-    try {
-      const raw = await readStdin3();
-      const input = parseHookInput2(raw);
-      const cwd = input.cwd ?? process.cwd();
-      const binding = findBinding(cwd);
-      if (!binding) return process.exit(0);
-      const usage = input.transcript_path ? parseTranscript(input.transcript_path) : null;
-      const events = buildHookEvents(input, usage, binding.taskId);
-      if (events.length === 0) return process.exit(0);
-      const cfg = resolveConfig(cmd.optsWithGlobals());
-      await postTelemetry(cfg, binding.decompositionId, events);
-      return process.exit(0);
-    } catch {
-      return process.exit(0);
-    }
-  });
-  telemetry.command("install").description(
-    "Wire the per-turn telemetry Stop hook into Claude Code settings (also folded into `sechroom hook install`)"
-  ).option(
-    "--scope <scope>",
-    "global (config dir / CLAUDE_CONFIG_DIR) or project (<cwd>/.claude) \u2014 default global"
-  ).option("--local", "alias for --scope project").option("--dry-run", "Print what would change; write nothing").action((opts, cmd) => {
+  $ sechroom sweep --dry-run            preview every repo's disposition, run nothing
+  $ sechroom sweep                      onboard the whole tree from the root
+  $ sechroom --tenant ocd sweep         force a tenant for every child (else each resolves its own)`
+  ).action((opts, cmd) => {
     const g = cmd.optsWithGlobals();
+    const json = Boolean(g.json);
     const dryRun = Boolean(opts.dryRun);
-    const cwd = process.cwd();
-    let scope;
+    const manifestPath = resolve4(opts.manifest);
+    let repos;
     try {
-      scope = opts.local ? "project" : resolveScope(opts.scope);
+      repos = readManifest(manifestPath);
     } catch (err2) {
-      process.stderr.write(`${err2.message}
+      fail(err2 instanceof Error ? err2.message : String(err2));
+    }
+    if (repos === null) {
+      fail(`no manifest at ${manifestPath} \u2014 create ./.sechroom/repos.json, or use \`sechroom onboard --recurse\` to auto-discover (see \`sechroom sweep --help\`).`);
+    }
+    if (repos.length === 0) {
+      if (json) process.stdout.write(JSON.stringify({ manifest: manifestPath, repos: [] }) + "\n");
+      else process.stderr.write(`${warn("\u26A0")} ${manifestPath} lists no repos \u2014 nothing to do.
 `);
-      return process.exit(2);
+      return;
     }
-    const targets = resolveClaudeTargets({
-      override: g.claudeConfigDir,
-      scope,
-      cwd
-    });
-    const commands = {
-      Stop: "sechroom telemetry hook",
-      SubagentStop: "sechroom telemetry hook",
-      Notification: "sechroom telemetry hook",
-      PermissionDenied: "sechroom telemetry hook"
-    };
-    try {
-      const multi = targets.length > 1;
-      const results = targets.map((t) => {
-        const r = installClaudeCommands(t.dir, commands, dryRun);
-        process.stdout.write(
-          `${HOOK_SURFACE_LABEL.claude}${multi ? ` (${t.label})` : ""}:
-`
-        );
-        process.stdout.write(describe(r, dryRun) + "\n");
-        return r;
-      });
-      if (dryRun) {
-        process.stdout.write("\n(dry run \u2014 no files were written.)\n");
-      } else if (results.every((r) => r.status === "current")) {
-        process.stdout.write("\nAlready up to date \u2014 nothing to change.\n");
-      } else {
-        process.stdout.write(
-          "\nRestart your agent for the hook to take effect, then bind a task with `sechroom telemetry bind`.\n"
-        );
-      }
-    } catch (err2) {
+    const root = dirname12(dirname12(manifestPath));
+    const plans = repos.map((entry) => planEntry(entry, root));
+    if (!json) {
       process.stderr.write(
-        `telemetry install failed: ${err2.message}
+        `${style.bold("sweep")} ${style.dim(`(${plans.length} repo${plans.length === 1 ? "" : "s"} from ${manifestPath})`)}
 `
       );
-      return process.exit(1);
-    }
-    warnIfSechroomNotOnPath();
-    return process.exit(0);
-  });
-}
-var BINDING_FILE = "telemetry.json";
-async function postTelemetry(cfg, decompositionId, events) {
-  const token = await requireToken(cfg);
-  const resp = await fetch(
-    `${cfg.baseUrl}/decompositions/${encodeURIComponent(decompositionId)}/run/telemetry`,
-    {
-      method: "POST",
-      headers: {
-        authorization: `Bearer ${token}`,
-        tenant: cfg.tenant,
-        "content-type": "application/json",
-        "x-sechroom-surface": "cli"
-      },
-      body: JSON.stringify({ events })
-    }
-  );
-  if (!resp.ok) throw new Error(`HTTP ${resp.status}: ${await resp.text()}`);
-  return await resp.json();
-}
-function findBinding(start) {
-  let dir = start;
-  for (; ; ) {
-    const path = join18(dir, ".sechroom", BINDING_FILE);
-    if (existsSync16(path)) {
-      try {
-        const b = JSON.parse(
-          readFileSync12(path, "utf8")
-        );
-        if (b.decompositionId && b.taskId)
-          return { decompositionId: b.decompositionId, taskId: b.taskId };
-      } catch {
-      }
-      return null;
     }
-    const parent = dirname11(dir);
-    if (parent === dir) return null;
-    dir = parent;
-  }
-}
-function parseTranscript(path) {
-  if (!existsSync16(path)) return null;
-  let tokensIn = 0;
-  let tokensOut = 0;
-  let contextUsed = 0;
-  let model = "";
-  for (const line of readFileSync12(path, "utf8").split("\n")) {
-    if (!line.trim()) continue;
-    let obj;
-    try {
-      obj = JSON.parse(line);
-    } catch {
-      continue;
+    const results = runChildren(plans, { globals: passthroughGlobals(g), dryRun, json });
+    if (json) {
+      process.stdout.write(JSON.stringify({ manifest: manifestPath, dryRun, repos: results }) + "\n");
+      return;
     }
-    const usage = obj.type === "assistant" ? obj.message?.usage : void 0;
-    if (!usage) continue;
-    const input = (usage.input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0);
-    tokensIn += input;
-    tokensOut += usage.output_tokens ?? 0;
-    contextUsed = input;
-    if (obj.message?.model) model = obj.message.model;
-  }
-  if (tokensIn === 0 && tokensOut === 0) return null;
-  return { tokensIn, tokensOut, contextUsed, contextWindow: windowFor(model, contextUsed) };
-}
-function windowFor(model, contextUsed = 0) {
-  const m = model.toLowerCase();
-  if (m.includes("[1m]") || m.includes("-1m")) return 1e6;
-  return contextUsed > 2e5 ? 1e6 : 2e5;
-}
-function buildHookEvents(input, usage, taskId) {
-  const events = [];
-  const base = (kind, over) => ({
-    taskId,
-    kind,
-    tokensIn: null,
-    tokensOut: null,
-    contextUsed: null,
-    contextWindow: null,
-    text: null,
-    approvalState: null,
-    verdict: null,
-    ...over
+    summarizeFanout(results, { dryRun });
   });
-  if (usage) {
-    events.push(
-      base("Parsed", {
-        tokensIn: usage.tokensIn,
-        tokensOut: usage.tokensOut,
-        contextUsed: usage.contextUsed,
-        contextWindow: usage.contextWindow
-      })
-    );
-  }
-  switch (input.hook_event_name) {
-    case "PermissionDenied":
-      events.push(
-        base("Approval", {
-          approvalState: "denied",
-          text: input.tool_name ?? input.message ?? null
-        })
-      );
-      break;
-    case "Notification":
-      if (isPermissionNotification(input))
-        events.push(base("Approval", { text: input.message ?? null }));
-      break;
-    case "Stop":
-    case "SubagentStop":
-      events.push(base("Terminal", { text: input.last_assistant_message ?? null }));
-      break;
-  }
-  return events;
-}
-function isPermissionNotification(input) {
-  const t = (input.notification_type ?? input.type ?? "").toLowerCase();
-  if (t) return t.includes("permission");
-  return (input.message ?? "").toLowerCase().includes("permission");
-}
-async function readStdin3() {
-  if (process.stdin.isTTY) return "";
-  const chunks = [];
-  for await (const chunk of process.stdin) chunks.push(chunk);
-  return Buffer.concat(chunks).toString("utf8");
-}
-function parseHookInput2(raw) {
-  if (!raw.trim()) return {};
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return {};
-  }
-}
-var KINDS = {
-  raw: "Raw",
-  parsed: "Parsed",
-  approval: "Approval",
-  terminal: "Terminal"
-};
-function normalizeKind(k) {
-  const v = KINDS[k.toLowerCase()];
-  if (!v)
-    fail(
-      `Unknown --kind '${k}'. Expected one of: raw, parsed, approval, terminal.`
-    );
-  return v;
-}
-function parseIntOpt(v) {
-  const n = Number.parseInt(v, 10);
-  if (Number.isNaN(n)) fail(`Expected an integer, got '${v}'.`);
-  return n;
 }
 
 // src/commands/worklog.ts
@@ -7001,11 +8538,43 @@ function registerWorkBrief(program2) {
 Examples:
   $ sechroom work-brief pause mem_XXXX --reason-code operator-hold --source claude-code-chris
   $ sechroom work-brief resume mem_XXXX --reason-code operator-resume --source claude-code-chris --reason "Ready to continue"
-  $ sechroom work-brief cancel mem_XXXX --reason-code operator-stopped --source claude-code-chris --reason "Work no longer required"`
+  $ sechroom work-brief cancel mem_XXXX --reason-code operator-stopped --source claude-code-chris --reason "Work no longer required"
+  $ sechroom work-brief park mem_XXXX --source claude-code-chris
+  $ sechroom work-brief unpark mem_XXXX --source claude-code-chris
+  $ sechroom work-brief supersede mem_XXXX --source claude-code-chris`
   );
   registerLifecycleAction(workBrief, "pause");
   registerLifecycleAction(workBrief, "resume");
   registerLifecycleAction(workBrief, "cancel");
+  registerStatusAction(workBrief, "park", "status:parked");
+  registerStatusAction(workBrief, "unpark", "status:ready_for_decomposition");
+  registerStatusAction(workBrief, "supersede", "status:superseded");
+}
+function registerStatusAction(workBrief, action, to) {
+  workBrief.command(`${action} <briefId>`).description(
+    `${capitalize(action)} a work brief via its governed status transition`
+  ).requiredOption(
+    "--source <source>",
+    "Calling surface or lane recorded on the contribution"
+  ).action(async (briefId, opts, cmd) => {
+    const globals = cmd.optsWithGlobals();
+    const cfg = resolveConfig(globals);
+    const data = await runApi(
+      `${capitalize(action)}ing work brief`,
+      async () => {
+        const client = await makeClient(cfg);
+        return client.POST("/work-briefs/{id}/status", {
+          params: { path: { id: briefId } },
+          body: { id: briefId, to, source: opts.source }
+        });
+      }
+    );
+    emitAction(
+      `${action} work brief ${style.bold(briefId)} \u2192 ${data.to}`,
+      data,
+      globals.json
+    );
+  });
 }
 function registerLifecycleAction(workBrief, action) {
   const presentParticiple = action === "pause" ? "Pausing" : action === "resume" ? "Resuming" : "Cancelling";
@@ -7043,17 +8612,24 @@ function capitalize(value) {
 }
 
 // src/commands/work-task.ts
+import { readFile as readFile3 } from "fs/promises";
 function registerWorkTask(program2) {
-  const workTask = program2.command("work-task").description("Read work tasks and close them out (list \xB7 card \xB7 mark-no-residue)");
+  const workTask = program2.command("work-task").description(
+    "Read work tasks and close them out (list \xB7 card \xB7 mark-no-residue)"
+  );
   workTask.addHelpText(
     "after",
     `
 Examples:
   $ sechroom work-task list --status in-progress --lane claude-code-chris
   $ sechroom work-task card mem_XXXX
-  $ sechroom work-task mark-no-residue mem_XXXX --decomposition wlp_XXXX`
+  $ sechroom work-task mark-no-residue mem_XXXX --decomposition wlp_XXXX
+  $ sechroom work-task residue-produce mem_XXXX --file residue.json`
   );
-  workTask.command("list").description("List work tasks, newest-first (GET /work-tasks)").option("--shape <shape>", "Filter: bare | managed").option("--lane <lane>", "Filter by dispatch-lane value, e.g. claude-code-chris").option("--status <status>", "Filter by status value, e.g. in-progress").option("--page <n>", "1-based page number", (v) => Number.parseInt(v, 10)).option(
+  workTask.command("list").description("List work tasks, newest-first (GET /work-tasks)").option("--shape <shape>", "Filter: bare | managed").option(
+    "--lane <lane>",
+    "Filter by dispatch-lane value, e.g. claude-code-chris"
+  ).option("--status <status>", "Filter by status value, e.g. in-progress").option("--page <n>", "1-based page number", (v) => Number.parseInt(v, 10)).option(
     "--page-size <n>",
     "Page size (default 50, capped 200)",
     (v) => Number.parseInt(v, 10)
@@ -7080,7 +8656,9 @@ Examples:
       globals.json
     );
   });
-  workTask.command("card <taskId>").description("Read one task's runnable card \u2014 its full working instructions (GET /tasks/{id}/card)").action(async (taskId, _opts, cmd) => {
+  workTask.command("card <taskId>").description(
+    "Read one task's runnable card \u2014 its full working instructions (GET /tasks/{id}/card)"
+  ).action(async (taskId, _opts, cmd) => {
     const globals = cmd.optsWithGlobals();
     const cfg = resolveConfig(globals);
     const data = await runApi("Reading task card", async () => {
@@ -7091,26 +8669,67 @@ Examples:
     });
     emitAction(`read card ${style.bold(taskId)}`, data, globals.json);
   });
-  workTask.command("mark-no-residue <taskId>").description(
-    "Mark a task as having produced no residue \u2014 the explicit no-residue marker that lets a lane finish a run it drove end-to-end (POST /work-tasks/mark-no-residue)"
+  workTask.command("residue-produce <taskId>").description(
+    "Produce typed residue for a work task (POST /work-tasks/produce-residue)"
   ).requiredOption(
-    "--decomposition <id>",
-    "The work plan id (wlp_\u2026) the task belongs to \u2014 the marker is keyed (decompositionId, taskId)"
+    "--file <path>",
+    "JSON file containing a residues array; use - for stdin"
   ).action(async (taskId, opts, cmd) => {
+    const raw = opts.file === "-" ? await readStdin4() : await readFile3(opts.file, "utf8");
+    const body = parseResidueInput(raw, opts.file, taskId);
     const globals = cmd.optsWithGlobals();
     const cfg = resolveConfig(globals);
-    const data = await runApi("Marking task no-residue", async () => {
+    const data = await runApi("Producing task residue", async () => {
       const client = await makeClient(cfg);
-      return client.POST("/work-tasks/mark-no-residue", {
-        body: { taskId, decompositionId: opts.decomposition }
-      });
+      return client.POST("/work-tasks/produce-residue", { body });
     });
     emitAction(
-      `marked ${style.bold(taskId)} no-residue (minted: ${data.minted})`,
+      `produced ${style.bold(String(data.produced.length))} residue item(s) for ${style.bold(taskId)}`,
       data,
       globals.json
     );
   });
+  workTask.command("mark-no-residue <taskId>").description(
+    "Mark a task as having produced no residue \u2014 the explicit no-residue marker that lets a lane finish a run it drove end-to-end (POST /work-tasks/mark-no-residue)"
+  ).requiredOption(
+    "--decomposition <id>",
+    "The work plan id (wlp_\u2026) the task belongs to \u2014 the marker is keyed (decompositionId, taskId)"
+  ).action(
+    async (taskId, opts, cmd) => {
+      const globals = cmd.optsWithGlobals();
+      const cfg = resolveConfig(globals);
+      const data = await runApi("Marking task no-residue", async () => {
+        const client = await makeClient(cfg);
+        return client.POST("/work-tasks/mark-no-residue", {
+          body: { taskId, decompositionId: opts.decomposition }
+        });
+      });
+      emitAction(
+        `marked ${style.bold(taskId)} no-residue (minted: ${data.minted})`,
+        data,
+        globals.json
+      );
+    }
+  );
+}
+function parseResidueInput(raw, sourceName, taskId) {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(
+      `${sourceName} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const residues = Array.isArray(value) ? value : value && typeof value === "object" ? value.residues : void 0;
+  if (!Array.isArray(residues) || residues.length === 0)
+    throw new Error(`${sourceName} must contain a non-empty residues array`);
+  return { taskId, residues };
+}
+async function readStdin4() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));
+  return Buffer.concat(chunks).toString("utf8");
 }
 
 // src/index.ts