@wrongstack/cli 0.297.0 → 0.298.1

package/dist/{cli-main-GOY5YGVL.js → cli-main-7QLL2PY6.js}

@@ -1,6 +1,13 @@
 import {
   runProjectPicker
 } from "./chunk-5N34EWJR.js";
+import {
+  ensureProjectDataDir,
+  findProject,
+  generateSlug,
+  loadManifest,
+  saveManifest
+} from "./chunk-JUHRI6OV.js";
 import {
   createHqCommandDispatcher
 } from "./chunk-OP47B3IX.js";
@@ -16,7 +23,7 @@ import {
   persistTelegramConfig,
   removeSuggestions,
   setSuggestions
-} from "./chunk-QZKWRNIP.js";
+} from "./chunk-V3XH6XBJ.js";
 import {
   startCliHqConnection
 } from "./chunk-JW75HY4F.js";
@@ -32,24 +39,17 @@ import {
 } from "./chunk-XTIXVJXP.js";
 import {
   setupPlugins
-} from "./chunk-QUNHS6O3.js";
-import {
-  ensureProjectDataDir,
-  findProject,
-  generateSlug,
-  loadManifest,
-  saveManifest
-} from "./chunk-JUHRI6OV.js";
+} from "./chunk-4U3DMA2Y.js";
 import {
   PLUGIN_AUDIT_ENTRIES,
   runPluginManagementCommand
-} from "./chunk-XWEGWYDU.js";
+} from "./chunk-PEKUKUCH.js";
 import {
   configureSimpleUiRuntimeContext,
   detectProjectFacts,
   makeConfirmAwaiter,
   renderAgentsTemplate
-} from "./chunk-IHBYBYGA.js";
+} from "./chunk-A6Q5KGLV.js";
 import "./chunk-QD544J2B.js";
 import {
   fmtTaskResultLine,
@@ -61,7 +61,7 @@ import {
 } from "./chunk-XJXDOF63.js";
 import {
   buildWin32CmdShimInvocation
-} from "./chunk-VJUEZZYB.js";
+} from "./chunk-U3SS4NRH.js";
 import {
   checkForUpdate
 } from "./chunk-F4PEGAJZ.js";
@@ -70,7 +70,7 @@ import {
   loadCachedAcpRegistry,
   refreshAcpRegistry,
   setupProvider
-} from "./chunk-AZESNNIC.js";
+} from "./chunk-4HH3YGG4.js";
 import {
   addCustomProvider,
   addKeyForCatalogProvider,
@@ -80,7 +80,7 @@ import {
   runClaudeOAuthLogin,
   runCopilotOAuthLogin,
   validateFamily
-} from "./chunk-JBTFWWKV.js";
+} from "./chunk-I2BM6FK6.js";
 import {
   LOCAL_LLM_PRESETS,
   parseSpawnFlags
@@ -90,7 +90,7 @@ import {
 } from "./chunk-66T43Q4Y.js";
 import {
   runCodexOAuthLogin
-} from "./chunk-TADVX644.js";
+} from "./chunk-GO3TJICK.js";
 import {
   activeLabel,
   loadConfigProviders,
@@ -110,7 +110,7 @@ import {
 } from "./chunk-7OCVIDC7.js";
 
 // src/cli-main.ts
-import * as path30 from "node:path";
+import * as path31 from "node:path";
 import { FLEET_ROSTER as FLEET_ROSTER5, mailboxSessionTag as mailboxSessionTag5 } from "@wrongstack/core/coordination";
 import { gatedEnhancerReasoning } from "@wrongstack/core/execution";
 import { TOKENS as TOKENS9 } from "@wrongstack/core/kernel";
@@ -787,7 +787,7 @@ function resolveTaskConcurrency() {
 var WORKTREE_PHASE_CONCURRENCY = 4;
 var MAX_CMD_OUTPUT = 2e5;
 function gitText(args, cwd) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     let child;
     try {
       child = spawn("git", args, {
@@ -812,8 +812,8 @@ function gitText(args, cwd) {
     };
     child.stdout?.on("data", emit);
     child.stderr?.on("data", emit);
-    child.on("error", () => resolve7({ code: 1, out: chunks.join("") }));
-    child.on("close", (code) => resolve7({ code: code ?? 1, out: chunks.join("").trim() }));
+    child.on("error", () => resolve8({ code: 1, out: chunks.join("") }));
+    child.on("close", (code) => resolve8({ code: code ?? 1, out: chunks.join("").trim() }));
   });
 }
 async function isGitRepo(cwd) {
@@ -862,7 +862,7 @@ function runCmd(cmd, args, cwd, shell = false) {
       });
     }
   }
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     const chunks = [];
     let child;
     try {
@@ -885,11 +885,11 @@ function runCmd(cmd, args, cwd, shell = false) {
     };
     child.stdout?.on("data", append);
     child.stderr?.on("data", append);
-    child.on("error", (e) => resolve7({ code: 1, out: `${chunks.join("")}${String(e)}` }));
+    child.on("error", (e) => resolve8({ code: 1, out: `${chunks.join("")}${String(e)}` }));
     child.on("close", (code) => {
       let out = chunks.join("");
       if (out.length > MAX_CMD_OUTPUT) out = out.slice(-MAX_CMD_OUTPUT);
-      resolve7({ code: code ?? 1, out: out.trim() });
+      resolve8({ code: code ?? 1, out: out.trim() });
     });
   });
 }
@@ -1447,9 +1447,385 @@ async function launchEternalFromFlag(deps) {
 }
 
 // src/cli-main-helpers.ts
+import { getSharedProjectMailbox } from "@wrongstack/core/coordination";
+import { createGovernanceMutationSnapshotBridge } from "@wrongstack/runtime/governance-mutation-snapshot-bridge";
+import { sanitizeGovernanceMessage } from "@wrongstack/runtime/governance-sanitize";
+
+// src/boot/governance-evidence-candidate.ts
 import {
-  getSharedProjectMailbox
-} from "@wrongstack/core/coordination";
+  createGovernanceEvidenceCandidate,
+  GOVERNANCE_EVIDENCE_CANDIDATE_SCHEMA_VERSION
+} from "@wrongstack/runtime/governance-bootstrap";
+
+// src/boot/governance-shadow-bridge.ts
+var SHADOW_SOURCE = "wrongstack.cli.shadow.v1";
+function optional(key, value) {
+  return value === void 0 ? {} : { [key]: value };
+}
+function createGovernanceShadowBridge(input) {
+  const disposers = [];
+  let closed = false;
+  let warned = false;
+  const warnOnce = (message, context) => {
+    if (warned || closed) return;
+    warned = true;
+    input.logger.warn(message, context);
+  };
+  const observe = (observation) => {
+    if (closed) return;
+    try {
+      void input.sink.observe(observation).then(
+        (result) => {
+          if (!result.recorded) {
+            warnOnce("governance: shadow observation was not recorded", {
+              code: result.code,
+              message: result.message
+            });
+          }
+        },
+        (error) => {
+          warnOnce("governance: shadow observation failed open", {
+            message: error instanceof Error ? error.message : String(error)
+          });
+        }
+      );
+    } catch (error) {
+      warnOnce("governance: shadow observation failed open", {
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  };
+  const on = (event, map) => {
+    disposers.push(input.events.on(event, (payload) => observe(map(payload))));
+  };
+  const traced = (payload, taskId, boardId) => ({
+    ...payload,
+    trace: input.trace.snapshot(taskId, boardId)
+  });
+  on("agent.run.started", (event) => ({
+    taskId: event.ctx.currentKanbanTaskId ?? null,
+    category: "status_changed",
+    observedAt: event.at,
+    payload: traced(
+      {
+        entity: "agent_run",
+        observer: SHADOW_SOURCE,
+        phase: "started",
+        model: event.model,
+        ...optional("sessionId", event.sessionId),
+        ...optional("agentId", event.ctx.agentId),
+        ...optional("agentName", event.ctx.agentName),
+        ...optional("traceId", event.ctx.traceId)
+      },
+      event.ctx.currentKanbanTaskId ?? null,
+      event.ctx.currentKanbanBoardId
+    )
+  }));
+  on("agent.run.completed", (event) => ({
+    taskId: event.ctx.currentKanbanTaskId ?? null,
+    category: "status_changed",
+    observedAt: event.at,
+    payload: traced(
+      {
+        entity: "agent_run",
+        observer: SHADOW_SOURCE,
+        phase: "completed",
+        status: event.status,
+        iterations: event.iterations,
+        durationMs: event.durationMs,
+        ...optional("sessionId", event.sessionId),
+        ...optional("agentId", event.ctx.agentId),
+        ...optional("agentName", event.ctx.agentName),
+        ...optional("traceId", event.ctx.traceId)
+      },
+      event.ctx.currentKanbanTaskId ?? null,
+      event.ctx.currentKanbanBoardId
+    )
+  }));
+  on("agent.run.error", (event) => ({
+    taskId: event.ctx.currentKanbanTaskId ?? null,
+    category: "failure_reported",
+    observedAt: event.at,
+    payload: traced(
+      {
+        entity: "agent_run",
+        observer: SHADOW_SOURCE,
+        phase: "error",
+        durationMs: event.durationMs,
+        errorName: event.err.name,
+        ...optional("sessionId", event.sessionId),
+        ...optional("agentId", event.ctx.agentId),
+        ...optional("agentName", event.ctx.agentName),
+        ...optional("traceId", event.ctx.traceId)
+      },
+      event.ctx.currentKanbanTaskId ?? null,
+      event.ctx.currentKanbanBoardId
+    )
+  }));
+  on("tool.started", (event) => ({
+    taskId: event.taskId ?? null,
+    category: "tool_invoked",
+    observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    payload: traced(
+      {
+        phase: "started",
+        observer: SHADOW_SOURCE,
+        toolCallId: event.id,
+        toolName: event.name,
+        ...optional("sessionId", event.sessionId),
+        ...optional("traceId", event.traceId),
+        ...optional("agentId", event.agentId),
+        ...optional("agentName", event.agentName),
+        ...optional("boardId", event.boardId),
+        ...optional("provider", event.provider),
+        ...optional("model", event.model)
+      },
+      event.taskId ?? null,
+      event.boardId
+    )
+  }));
+  on("permission.evaluated", (event) => ({
+    taskId: event.taskId ?? null,
+    category: "tool_invoked",
+    observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    payload: traced(
+      {
+        phase: "authorized",
+        observer: SHADOW_SOURCE,
+        toolCallId: event.id,
+        toolName: event.name,
+        inputHash: event.inputHash,
+        policyDecision: event.policyDecision,
+        effectiveDecision: event.effectiveDecision,
+        decisionSource: event.decisionSource,
+        yoloEnabled: event.yoloEnabled,
+        capabilityDowngraded: event.capabilityDowngraded,
+        ...optional("sessionId", event.sessionId),
+        ...optional("traceId", event.traceId),
+        ...optional("agentId", event.agentId),
+        ...optional("riskTier", event.riskTier),
+        ...optional("boundaryDecision", event.boundaryDecision),
+        ...optional("boardId", event.boardId),
+        ...optional("provider", event.provider),
+        ...optional("model", event.model)
+      },
+      event.taskId ?? null,
+      event.boardId
+    )
+  }));
+  on("tool.executed", (event) => ({
+    taskId: event.taskId ?? null,
+    category: "tool_invoked",
+    observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    payload: traced(
+      {
+        phase: "completed",
+        observer: SHADOW_SOURCE,
+        toolName: event.name,
+        durationMs: event.durationMs,
+        ok: event.ok,
+        ...optional("mutating", event.mutating),
+        ...optional("toolCallId", event.id),
+        ...optional("sessionId", event.sessionId),
+        ...optional("traceId", event.traceId),
+        ...optional("agentId", event.agentId),
+        ...optional("agentName", event.agentName),
+        ...optional("outputBytes", event.outputBytes),
+        ...optional("outputTokens", event.outputTokens),
+        ...optional("outputLines", event.outputLines),
+        ...optional("boardId", event.boardId),
+        ...optional("provider", event.provider),
+        ...optional("model", event.model)
+      },
+      event.taskId ?? null,
+      event.boardId
+    )
+  }));
+  on("tool.executed", (event) => {
+    const trace = input.trace.snapshot(event.taskId ?? null, event.boardId);
+    return {
+      taskId: event.taskId ?? null,
+      category: "evidence_candidate",
+      observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      payload: {
+        observer: SHADOW_SOURCE,
+        ...createGovernanceEvidenceCandidate(trace, {
+          toolCallId: event.id,
+          toolName: event.name,
+          ok: event.ok,
+          durationMs: event.durationMs,
+          outputBytes: event.outputBytes,
+          outputTokens: event.outputTokens,
+          outputLines: event.outputLines
+        }),
+        trace
+      }
+    };
+  });
+  on("checkpoint.written", (event) => {
+    input.trace.updateWorkspaceCheckpoint(event.promptIndex, event.ts, event.workspaceCheckpoint);
+    return {
+      taskId: null,
+      category: "status_changed",
+      observedAt: event.ts,
+      payload: traced(
+        {
+          entity: "workspace_checkpoint",
+          observer: SHADOW_SOURCE,
+          phase: "captured",
+          promptIndex: event.promptIndex,
+          fileCount: event.fileCount
+        },
+        null
+      )
+    };
+  });
+  disposers.push(
+    input.events.on("storage.write", (event) => {
+      if (event.store !== "plan" || event.outcome !== "success" || !input.trace.matchesPlanPath(event.filePath)) {
+        return;
+      }
+      void input.trace.refreshPlan().then((plan) => {
+        observe({
+          taskId: null,
+          category: "plan_updated",
+          observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          payload: traced(
+            {
+              entity: "session_plan",
+              observer: SHADOW_SOURCE,
+              phase: "persisted",
+              plan
+            },
+            null
+          )
+        });
+      });
+    })
+  );
+  return Object.freeze({
+    close: () => {
+      if (closed) return;
+      closed = true;
+      for (const dispose of disposers.splice(0)) dispose();
+    }
+  });
+}
+
+// src/boot/governance-trace-context.ts
+import { createHash } from "node:crypto";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+var MAX_GOVERNANCE_PLAN_BYTES = 1024 * 1024;
+var MAX_GOVERNANCE_ACTIVE_STEP_IDS = 128;
+var DEFAULT_DEPENDENCIES = {
+  readFile: (filePath) => fs.readFile(filePath, "utf8"),
+  now: () => (/* @__PURE__ */ new Date()).toISOString()
+};
+function normalizedPath(input) {
+  const resolved = path.resolve(input);
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function validTimestamp(value) {
+  return typeof value === "string" && Number.isFinite(Date.parse(value));
+}
+function planTrace(raw, observedAt) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return Object.freeze({ state: "invalid" });
+  }
+  if (!parsed || typeof parsed !== "object") return Object.freeze({ state: "invalid" });
+  const record = parsed;
+  if (record["version"] !== 1 || !Array.isArray(record["items"])) {
+    return Object.freeze({ state: "invalid" });
+  }
+  const statuses = { open: 0, in_progress: 0, done: 0 };
+  const activeStepIds = [];
+  for (const entry of record["items"]) {
+    if (!entry || typeof entry !== "object") return Object.freeze({ state: "invalid" });
+    const item = entry;
+    const id = item["id"];
+    const status = item["status"];
+    if (typeof id !== "string" || status !== "open" && status !== "in_progress" && status !== "done") {
+      return Object.freeze({ state: "invalid" });
+    }
+    statuses[status]++;
+    if (status === "in_progress" && activeStepIds.length < MAX_GOVERNANCE_ACTIVE_STEP_IDS) {
+      activeStepIds.push(id);
+    }
+  }
+  return Object.freeze({
+    state: "available",
+    schemaVersion: 1,
+    fingerprint: createHash("sha256").update(raw, "utf8").digest("hex"),
+    ...validTimestamp(record["updatedAt"]) ? { updatedAt: record["updatedAt"] } : {},
+    observedAt,
+    itemCount: record["items"].length,
+    openCount: statuses.open,
+    inProgressCount: statuses.in_progress,
+    doneCount: statuses.done,
+    activeStepIds: Object.freeze(activeStepIds),
+    activeStepIdsTruncated: statuses.in_progress > activeStepIds.length
+  });
+}
+var LiveGovernanceTraceContext = class {
+  #sessionId;
+  #planPath;
+  #dependencies;
+  #plan = Object.freeze({ state: "missing" });
+  #workspace = Object.freeze({ state: "not_captured" });
+  #planGeneration = 0;
+  constructor(sessionId, planPath, dependencies) {
+    this.#sessionId = sessionId;
+    this.#planPath = normalizedPath(planPath);
+    this.#dependencies = dependencies;
+  }
+  matchesPlanPath(candidate) {
+    return normalizedPath(candidate) === this.#planPath;
+  }
+  async refreshPlan() {
+    const generation = ++this.#planGeneration;
+    this.#plan = Object.freeze({ state: "refreshing", observedAt: this.#dependencies.now() });
+    let next;
+    try {
+      const raw = await this.#dependencies.readFile(this.#planPath);
+      next = Buffer.byteLength(raw, "utf8") > MAX_GOVERNANCE_PLAN_BYTES ? Object.freeze({ state: "unreadable" }) : planTrace(raw, this.#dependencies.now());
+    } catch (error) {
+      next = Object.freeze({
+        state: error.code === "ENOENT" ? "missing" : "unreadable"
+      });
+    }
+    if (generation === this.#planGeneration) this.#plan = next;
+    return this.#plan;
+  }
+  updateWorkspaceCheckpoint(promptIndex, observedAt, checkpoint) {
+    this.#workspace = checkpoint ? Object.freeze({
+      state: "captured",
+      promptIndex,
+      manifestHash: checkpoint.manifestHash,
+      baseHead: checkpoint.baseHead,
+      entryCount: checkpoint.entryCount,
+      unresolvedCount: checkpoint.unresolvedCount,
+      capturedAt: checkpoint.capturedAt,
+      coverage: checkpoint.coverage
+    }) : Object.freeze({ state: "unavailable", promptIndex, observedAt });
+  }
+  snapshot(taskId, boardId) {
+    return Object.freeze({
+      sessionId: this.#sessionId,
+      task: taskId ? Object.freeze({ scope: "kanban_task", taskId, boardId: boardId ?? null }) : Object.freeze({ scope: "session" }),
+      plan: this.#plan,
+      workspace: this.#workspace
+    });
+  }
+};
+async function createGovernanceTraceContext(input, dependencies = DEFAULT_DEPENDENCIES) {
+  const context = new LiveGovernanceTraceContext(input.sessionId, input.planPath, dependencies);
+  await context.refreshPlan();
+  return context;
+}
 
 // src/context-limit.ts
 import { toErrorMessage } from "@wrongstack/core/utils";
@@ -1565,6 +1941,98 @@ function positiveNumber(value) {
 }
 
 // src/cli-main-helpers.ts
+var WRONGSTACK_GOVERNANCE_ENV = "WRONGSTACK_GOVERNANCE";
+var DEFAULT_GOVERNANCE_DEPENDENCIES = {
+  load: () => import("@wrongstack/runtime/governance-bootstrap")
+};
+function governanceRuntimeEnabled(environment) {
+  return environment[WRONGSTACK_GOVERNANCE_ENV]?.trim() === "1";
+}
+async function bootstrapCliGovernance(options, dependencies = DEFAULT_GOVERNANCE_DEPENDENCIES) {
+  if (!governanceRuntimeEnabled(options.environment)) {
+    return Object.freeze({ mode: "disabled", reason: "feature_flag_off" });
+  }
+  let loaded;
+  try {
+    loaded = await dependencies.load();
+  } catch (error) {
+    return Object.freeze({
+      mode: "legacy",
+      code: "module_unavailable",
+      phase: "bootstrap",
+      message: sanitizeGovernanceMessage(error instanceof Error ? error.message : String(error)),
+      cleanup: "not_required"
+    });
+  }
+  try {
+    return await loaded.bootstrapGovernanceRuntime({
+      projectRoot: options.projectRoot,
+      projectId: options.projectId,
+      adminClientId: options.adminClientId,
+      modelClientId: options.modelClientId,
+      modelCapabilities: options.modelCapabilities,
+      ...options.adminTtlMs === void 0 ? {} : { adminTtlMs: options.adminTtlMs },
+      ...options.modelTtlMs === void 0 ? {} : { modelTtlMs: options.modelTtlMs },
+      ...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs },
+      ...options.existingAdmin === void 0 ? {} : { existingAdmin: options.existingAdmin }
+    });
+  } catch (error) {
+    return Object.freeze({
+      mode: "legacy",
+      code: "bootstrap_failed",
+      phase: "bootstrap",
+      message: sanitizeGovernanceMessage(error instanceof Error ? error.message : String(error)),
+      cleanup: "unavailable"
+    });
+  }
+}
+async function setupCliGovernance(input) {
+  const result = await bootstrapCliGovernance({
+    environment: process.env,
+    projectRoot: input.projectRoot,
+    projectId: input.projectId,
+    adminClientId: `cli-control-${process.pid}-${input.sessionId}`,
+    modelClientId: `cli-model-${input.sessionId}`,
+    modelCapabilities: ["task_read", "command_submit", "shadow_observe"]
+  });
+  if (result.mode === "governed") {
+    const snapshot = result.handle.snapshot();
+    input.contextMeta["governance"] = snapshot;
+    input.logger.info(`governance: ${snapshot.source} session-scoped control plane`);
+    const trace = await createGovernanceTraceContext({
+      sessionId: input.sessionId,
+      planPath: input.planPath
+    });
+    const shadow = createGovernanceShadowBridge({
+      events: input.events,
+      sink: result.handle,
+      logger: input.logger,
+      trace
+    });
+    const mutationSnapshots = createGovernanceMutationSnapshotBridge({
+      events: input.events,
+      sink: result.handle,
+      captureWorkspaceCheckpoint: input.captureWorkspaceCheckpoint,
+      logger: input.logger
+    });
+    return Object.freeze({
+      installToolBoundary: (pipelines) => mutationSnapshots.installToolBoundary(pipelines),
+      close: async () => {
+        await mutationSnapshots.close();
+        shadow.close();
+        return result.handle.close();
+      }
+    });
+  } else if (result.mode === "legacy") {
+    input.contextMeta["governance"] = result;
+    input.logger.warn(`governance: legacy fallback (${result.code})`, {
+      phase: result.phase,
+      cleanup: result.cleanup,
+      message: result.message
+    });
+  }
+  return void 0;
+}
 function createTeardownEventRegistrar(events, teardownHandlers) {
   return (event, handler) => {
     events.on(event, handler);
@@ -1941,13 +2409,13 @@ function wireSessionEvents(deps) {
 // src/session-stats.ts
 import { color as color4 } from "@wrongstack/core/utils";
 var SESSION_STATS_MAX_PATHS = 1e4;
-function addBoundedPath(set, path31) {
-  if (set.has(path31)) return;
+function addBoundedPath(set, path32) {
+  if (set.has(path32)) return;
   if (set.size >= SESSION_STATS_MAX_PATHS) {
     const oldest = set.values().next().value;
     if (oldest !== void 0) set.delete(oldest);
   }
-  set.add(path31);
+  set.add(path32);
 }
 var SessionStats = class {
   tokenCounter;
@@ -1986,11 +2454,11 @@ var SessionStats = class {
       if (tool.name === "bash") this.bashCommands++;
       else if (tool.name === "fetch") this.fetches++;
       if (!tool.ok) return;
-      const path31 = typeof input?.path === "string" ? input.path : void 0;
-      if (tool.name === "read" && path31) addBoundedPath(this.readPaths, path31);
-      else if (tool.name === "edit" && path31) addBoundedPath(this.editedPaths, path31);
-      else if (tool.name === "write" && path31) {
-        addBoundedPath(this.writtenPaths, path31);
+      const path32 = typeof input?.path === "string" ? input.path : void 0;
+      if (tool.name === "read" && path32) addBoundedPath(this.readPaths, path32);
+      else if (tool.name === "edit" && path32) addBoundedPath(this.editedPaths, path32);
+      else if (tool.name === "write" && path32) {
+        addBoundedPath(this.writtenPaths, path32);
         const content = typeof input?.content === "string" ? input.content : "";
         this.bytesWritten += Buffer.byteLength(content, "utf8");
       }
@@ -2223,15 +2691,15 @@ import {
 import { wstackGlobalRoot } from "@wrongstack/core/utils";
 
 // src/fleet/host-helpers.ts
-import * as path from "node:path";
+import * as path2 from "node:path";
 import {
   makeSubagentResultTool
 } from "@wrongstack/core/coordination";
 import { ToolCapabilities, WIDE_SUBAGENT_CAPABILITIES } from "@wrongstack/core/security";
 import { makePreferSideConflictResolver } from "@wrongstack/sdd";
 function isInsideDirectory(root, candidate) {
-  const relative5 = path.relative(path.resolve(root), path.resolve(candidate));
-  return relative5 === "" || !relative5.startsWith("..") && !path.isAbsolute(relative5);
+  const relative5 = path2.relative(path2.resolve(root), path2.resolve(candidate));
+  return relative5 === "" || !relative5.startsWith("..") && !path2.isAbsolute(relative5);
 }
 function isAgentAvailable(schedule, at = /* @__PURE__ */ new Date()) {
   const parts = new Intl.DateTimeFormat("en-US", {
@@ -2508,19 +2976,19 @@ function emitHostLifecycleCompleted(events, sessionId, taskId, result) {
 }
 
 // src/fleet/host-paths.ts
-import * as path2 from "node:path";
+import * as path3 from "node:path";
 function applyFleetRootDefaults(opts) {
   if (opts.fleetRoot && !opts.manifestPath) {
-    opts.manifestPath = path2.join(opts.fleetRoot, "fleet.json");
+    opts.manifestPath = path3.join(opts.fleetRoot, "fleet.json");
   }
   if (opts.fleetRoot && !opts.sharedScratchpadPath) {
-    opts.sharedScratchpadPath = path2.join(opts.fleetRoot, "shared");
+    opts.sharedScratchpadPath = path3.join(opts.fleetRoot, "shared");
   }
   if (opts.fleetRoot && !opts.sessionsRoot) {
-    opts.sessionsRoot = path2.join(opts.fleetRoot, "subagents");
+    opts.sessionsRoot = path3.join(opts.fleetRoot, "subagents");
   }
   if (opts.fleetRoot && !opts.stateCheckpointPath) {
-    opts.stateCheckpointPath = path2.join(opts.fleetRoot, "director-state.json");
+    opts.stateCheckpointPath = path3.join(opts.fleetRoot, "director-state.json");
   }
 }
 
@@ -2685,7 +3153,7 @@ function registerCoordinatorLifecycleHandlers(input) {
 // src/fleet/host-subagent-factory.ts
 import { randomUUID } from "node:crypto";
 import { existsSync, statSync } from "node:fs";
-import * as path4 from "node:path";
+import * as path5 from "node:path";
 import {
   Agent,
   Context,
@@ -2715,7 +3183,7 @@ import { EventBus } from "@wrongstack/core/kernel";
 import { AutoApprovePermissionPolicy } from "@wrongstack/core/security";
 
 // src/fleet/host-event-bridge.ts
-import * as path3 from "node:path";
+import * as path4 from "node:path";
 var BRIDGE_TEXT_CAP = 360;
 var BRIDGE_OUTPUT_CAP = 4096;
 function compactText(value, cap = BRIDGE_TEXT_CAP) {
@@ -2822,8 +3290,8 @@ function installSubagentEventBridge(opts) {
     if (e.event.type !== "file_changed") return;
     const rawPath = e.event.path ?? (typeof e.event.data?.["path"] === "string" ? e.event.data["path"] : void 0);
     if (!rawPath) return;
-    const filePath = path3.normalize(
-      path3.isAbsolute(rawPath) ? rawPath : path3.resolve(projectRoot, rawPath)
+    const filePath = path4.normalize(
+      path4.isAbsolute(rawPath) ? rawPath : path4.resolve(projectRoot, rawPath)
     );
     hostEvents.emit("file.activity", {
       filePath,
@@ -3121,8 +3589,8 @@ function createHostSubagentFactory(config, host) {
         availabilityNotice = `${message} This protected system role may continue, but should minimize non-urgent work.`;
       }
     }
-    const assignedCheckout = subCfg.cwd && path4.isAbsolute(subCfg.cwd) ? subCfg.cwd : host.deps.projectRoot;
-    let subCwd = projectCfg?.cwd ? path4.resolve(assignedCheckout, projectCfg.cwd) : effectiveCfg.cwd ?? host.deps.cwd;
+    const assignedCheckout = subCfg.cwd && path5.isAbsolute(subCfg.cwd) ? subCfg.cwd : host.deps.projectRoot;
+    let subCwd = projectCfg?.cwd ? path5.resolve(assignedCheckout, projectCfg.cwd) : effectiveCfg.cwd ?? host.deps.cwd;
     if (projectCfg?.cwd && !isInsideDirectory(assignedCheckout, subCwd)) {
       throw new Error(
         `Agent "${effectiveCfg.role ?? effectiveCfg.name}" cwd escapes its assigned checkout.`
@@ -3260,6 +3728,7 @@ ${audienceMemory.map((text) => `- ${text}`).join("\n")}`
     });
     installDesignStudioMiddleware({ pipelines, ctx });
     installSubagentAutoCompaction(pipelines, ctx, config.context, events);
+    host.deps.installToolBoundary?.(pipelines);
     const agent = new Agent({
       container: host.deps.container,
       tools: baseRegistry,
@@ -3638,7 +4107,7 @@ function createHostStatusBroadcaster(input) {
 
 // src/fleet/host-director-builder.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
-import * as path5 from "node:path";
+import * as path6 from "node:path";
 import {
   DEFAULT_MAX_FLEET_SPAWNS,
   FleetManager,
@@ -3670,7 +4139,7 @@ function prepareHostDirectorRuntime(input) {
   const fleetLifecycle = config.fleet?.lifecycle;
   const configuredIdleTimeoutMs = opts.subagentIdleTimeoutMs ?? fleetLifecycle?.idleTimeoutMs;
   const subagentIdleTimeoutMs = typeof configuredIdleTimeoutMs === "number" && Number.isFinite(configuredIdleTimeoutMs) && configuredIdleTimeoutMs >= 0 ? configuredIdleTimeoutMs : 3e5;
-  const defaultScratchpad = opts.sharedScratchpadPath || (opts.sessionsRoot && opts.directorRunId ? path5.join(opts.sessionsRoot, opts.directorRunId, "shared") : void 0);
+  const defaultScratchpad = opts.sharedScratchpadPath || (opts.sessionsRoot && opts.directorRunId ? path6.join(opts.sessionsRoot, opts.directorRunId, "shared") : void 0);
   const worktreePolicy = resolveFleetWorktreePolicy(config);
   const worktrees = worktreePolicy.enabled === false || worktreePolicy.mode === "off" ? void 0 : new WorktreeManager2({
     projectRoot: deps.projectRoot,
@@ -4553,7 +5022,8 @@ function setupBrainAndOrchestration(deps) {
     maxConcurrent,
     effectiveMaxContextRef,
     mcpRegistry,
-    sessResult
+    sessResult,
+    installToolBoundary
   } = deps;
   const profileConfigPath = activeProfileConfigPath(wpaths, config);
   const brainCfg = resolveBrainConfigDefaults(config.brain, {
@@ -4739,7 +5209,8 @@ function setupBrainAndOrchestration(deps) {
       projectRoot,
       cwd,
       skillLoader,
-      secretScrubber: container.resolve(TOKENS6.SecretScrubber)
+      secretScrubber: container.resolve(TOKENS6.SecretScrubber),
+      ...installToolBoundary ? { installToolBoundary } : {}
     },
     {
       manifestPath,
@@ -4860,9 +5331,9 @@ import { FLEET_ROSTER as FLEET_ROSTER3 } from "@wrongstack/core/coordination";
 import { SddRunRegistry } from "@wrongstack/sdd";
 
 // src/services/statusline-config.ts
-import * as fs from "node:fs/promises";
+import * as fs2 from "node:fs/promises";
 import * as os from "node:os";
-import * as path6 from "node:path";
+import * as path7 from "node:path";
 import { atomicWrite, resolveWstackPaths } from "@wrongstack/core/utils";
 import { ERROR_CODES, FsError } from "@wrongstack/core/types";
 import { toErrorMessage as toErrorMessage3 } from "@wrongstack/core/utils";
@@ -4934,7 +5405,7 @@ function isMissingKnownStatuslineKeys(value) {
 }
 async function loadStatuslineConfig() {
   try {
-    const raw = await fs.readFile(resolveConfigPath(), "utf8");
+    const raw = await fs2.readFile(resolveConfigPath(), "utf8");
     return normalizeStatuslineConfig(JSON.parse(raw));
   } catch {
     return { ...DEFAULTS };
@@ -4942,7 +5413,7 @@ async function loadStatuslineConfig() {
 }
 async function ensureStatuslineConfig() {
   try {
-    const raw = await fs.readFile(resolveConfigPath(), "utf8");
+    const raw = await fs2.readFile(resolveConfigPath(), "utf8");
     const parsed = JSON.parse(raw);
     const config = normalizeStatuslineConfig(parsed);
     if (isMissingKnownStatuslineKeys(parsed)) await saveStatuslineConfig(config);
@@ -4959,7 +5430,7 @@ async function ensureStatuslineConfig() {
 async function saveStatuslineConfig(config) {
   const configPath = resolveConfigPath();
   try {
-    await fs.mkdir(path6.dirname(configPath), { recursive: true });
+    await fs2.mkdir(path7.dirname(configPath), { recursive: true });
     await atomicWrite(configPath, JSON.stringify(config, null, 2));
   } catch (error) {
     throw new FsError({
@@ -5146,7 +5617,7 @@ async function spawnAgent(director, role, task, maxIterations) {
 }
 
 // src/wiring/dep-watcher.ts
-import * as path7 from "node:path";
+import * as path8 from "node:path";
 import { startTechStackConsumer } from "@wrongstack/core/coordination";
 import {
   getSharedProjectMailbox as getSharedProjectMailbox6,
@@ -5157,7 +5628,7 @@ function setupDepWatcherConsumers(deps) {
   let techStackConsumerDispose;
   if (dwCfg?.["enabled"] === true) {
     try {
-      const projectDir = path7.join(globalRoot, "projects", projectSlug);
+      const projectDir = path8.join(globalRoot, "projects", projectSlug);
       const tsMailbox = getSharedProjectMailbox6(projectDir, events);
       const fileAuthorOpts = {
         storageDir: projectDir,
@@ -5190,7 +5661,7 @@ function setupDepWatcherConsumers(deps) {
   let pkgOutdatedDispose;
   if (dwCfg?.["enabled"] === true) {
     try {
-      const projectDir = path7.join(globalRoot, "projects", projectSlug);
+      const projectDir = path8.join(globalRoot, "projects", projectSlug);
       const pkgMailbox = getSharedProjectMailbox6(projectDir, events);
       const pkgTrackerOpts = {
         storageDir: projectDir,
@@ -5233,7 +5704,7 @@ function setupDepWatcherConsumers(deps) {
 }
 
 // src/wiring/dep-watcher-bridge.ts
-import * as path8 from "node:path";
+import * as path9 from "node:path";
 import {
   attachDepWatcherBridge,
   getSharedProjectMailbox as getSharedProjectMailbox7
@@ -5245,7 +5716,7 @@ function setupDepWatcherBridge(deps) {
   let depWatcherDispose;
   if (dwCfg?.["enabled"] === true) {
     try {
-      const projectDir = path8.join(wpaths.globalRoot, "projects", wpaths.projectSlug);
+      const projectDir = path9.join(wpaths.globalRoot, "projects", wpaths.projectSlug);
       const dwMailbox = getSharedProjectMailbox7(projectDir, events);
       depWatcherDispose = attachDepWatcherBridge({
         events,
@@ -5269,7 +5740,7 @@ function setupDepWatcherBridge(deps) {
 }
 
 // src/wiring/director-setup.ts
-import * as path9 from "node:path";
+import * as path10 from "node:path";
 import { expectDefined as expectDefined2 } from "@wrongstack/core/utils";
 import { createAgentMonitorService } from "@wrongstack/core/coordination";
 import { sessionScopedPath as sessionScopedPath2 } from "@wrongstack/core/utils";
@@ -5310,15 +5781,15 @@ function setupDirectorAndAutonomy(deps) {
     }
   };
   const fleetRoot = directorMode ? sessionScopedPath2(wpaths.projectSessions, session.id, "") : void 0;
-  const manifestPath = directorMode ? typeof process.env["WRONGSTACK_FLEET_MANIFEST"] === "string" ? process.env["WRONGSTACK_FLEET_MANIFEST"] : path9.join(expectDefined2(fleetRoot), "fleet.json") : void 0;
-  const sharedScratchpadPath = directorMode ? path9.join(expectDefined2(fleetRoot), "shared") : void 0;
-  const subagentSessionsRoot = directorMode ? path9.join(expectDefined2(fleetRoot), "subagents") : void 0;
-  const stateCheckpointPath = directorMode ? path9.join(expectDefined2(fleetRoot), "director-state.json") : void 0;
+  const manifestPath = directorMode ? typeof process.env["WRONGSTACK_FLEET_MANIFEST"] === "string" ? process.env["WRONGSTACK_FLEET_MANIFEST"] : path10.join(expectDefined2(fleetRoot), "fleet.json") : void 0;
+  const sharedScratchpadPath = directorMode ? path10.join(expectDefined2(fleetRoot), "shared") : void 0;
+  const subagentSessionsRoot = directorMode ? path10.join(expectDefined2(fleetRoot), "subagents") : void 0;
+  const stateCheckpointPath = directorMode ? path10.join(expectDefined2(fleetRoot), "director-state.json") : void 0;
   const fleetRootForPromotion = sessionScopedPath2(wpaths.projectSessions, session.id, "");
   const agentMonitor = createAgentMonitorService({
     events,
     sessionId: session.id,
-    transcriptsDir: path9.join(fleetRootForPromotion, "subagents", "transcripts"),
+    transcriptsDir: path10.join(fleetRootForPromotion, "subagents", "transcripts"),
     maxEntriesPerAgent: 500,
     streamEnabled: false
   });
@@ -5403,12 +5874,14 @@ function createEternalCommandHandlers(input) {
 }
 
 // src/wiring/fleet-command-handlers.ts
-import * as fs2 from "node:fs/promises";
-import * as path10 from "node:path";
-import { AgentError as AgentError3 } from "@wrongstack/core/types";
-import { color as color6, expectDefined as expectDefined3 } from "@wrongstack/core/utils";
+import { createReadStream } from "node:fs";
+import * as fs3 from "node:fs/promises";
+import * as path11 from "node:path";
+import { createInterface } from "node:readline";
 import { FLEET_ROSTER as FLEET_ROSTER4 } from "@wrongstack/core/coordination";
 import { loadDirectorState } from "@wrongstack/core/storage";
+import { AgentError as AgentError3 } from "@wrongstack/core/types";
+import { color as color6, expectDefined as expectDefined3 } from "@wrongstack/core/utils";
 function createFleetCommandHandlers(input) {
   return {
     onSpawn: async (description, options) => {
@@ -5622,8 +6095,9 @@ async function killFleet2(director) {
   }
   return killed;
 }
+var MAX_INLINE_RAW_TRANSCRIPT_BYTES = 2 * 1024 * 1024;
 async function readFleetLog(fleetRoot, subagentId, mode) {
-  const transcripts = await findTranscripts(path10.join(fleetRoot, "subagents"));
+  const transcripts = await findTranscripts(path11.join(fleetRoot, "subagents"));
   if (transcripts === null) {
     return "No fleet transcripts on disk \u2014 no subagents have been spawned for this session.";
   }
@@ -5650,30 +6124,39 @@ async function readFleetLog(fleetRoot, subagentId, mode) {
     ].join("\n");
   }
   const transcript = expectDefined3(matches[0]);
-  const raw = await fs2.readFile(transcript.file, "utf8");
-  return mode === "raw" ? raw : summarizeTranscript(transcript, raw);
+  if (mode === "raw") {
+    if (transcript.size > MAX_INLINE_RAW_TRANSCRIPT_BYTES) {
+      return [
+        `Transcript is ${(transcript.size / 1024 / 1024).toFixed(1)} MiB; refusing to load it into chat history.`,
+        `Read it directly from: ${transcript.file}`,
+        `Inline raw limit: ${MAX_INLINE_RAW_TRANSCRIPT_BYTES / 1024 / 1024} MiB.`
+      ].join("\n");
+    }
+    return fs3.readFile(transcript.file, "utf8");
+  }
+  return summarizeTranscript(transcript);
 }
 async function findTranscripts(root) {
   let runIds;
   try {
-    runIds = await fs2.readdir(root);
+    runIds = await fs3.readdir(root);
   } catch {
     return null;
   }
   const byRun = await Promise.all(
     runIds.map(async (runId) => {
-      const directory = path10.join(root, runId);
+      const directory = path11.join(root, runId);
       let files;
       try {
-        files = await fs2.readdir(directory);
+        files = await fs3.readdir(directory);
       } catch {
         return [];
       }
       const found = await Promise.all(
         files.filter((file) => file.endsWith(".jsonl")).map(async (file) => {
-          const fullPath = path10.join(directory, file);
+          const fullPath = path11.join(directory, file);
           try {
-            const stat5 = await fs2.stat(fullPath);
+            const stat5 = await fs3.stat(fullPath);
             return {
               runId,
               subagentId: file.replace(/\.jsonl$/, ""),
@@ -5690,35 +6173,52 @@ async function findTranscripts(root) {
   );
   return byRun.flat();
 }
-function summarizeTranscript(transcript, raw) {
-  const lines = raw.split("\n").filter((line) => line.trim());
+async function summarizeTranscript(transcript) {
   const counts = {};
   const tools = /* @__PURE__ */ new Map();
   let firstUser = null;
   let lastResponse = null;
   let iterations = 0;
-  for (const line of lines) {
+  let eventCount = 0;
+  let streamError;
+  const stream = createReadStream(transcript.file, { encoding: "utf8" });
+  const lines = createInterface({ input: stream, crlfDelay: Infinity });
+  try {
     try {
-      const event = JSON.parse(line);
-      counts[event.type] = (counts[event.type] ?? 0) + 1;
-      if (event.type === "user_input" && !firstUser) firstUser = eventText(event.content).slice(0, 120);
-      if (event.type === "llm_response") {
-        const text = eventText(event.content);
-        if (text) lastResponse = text.slice(0, 240);
-        iterations++;
-      }
-      if (event.type === "tool_use" && event.name) {
-        tools.set(event.name, (tools.get(event.name) ?? 0) + 1);
+      for await (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const event = JSON.parse(line);
+          eventCount++;
+          counts[event.type] = (counts[event.type] ?? 0) + 1;
+          if (event.type === "user_input" && !firstUser)
+            firstUser = eventText(event.content).slice(0, 120);
+          if (event.type === "llm_response") {
+            const text = eventText(event.content);
+            if (text) lastResponse = text.slice(0, 240);
+            iterations++;
+          }
+          if (event.type === "tool_use" && event.name) {
+            tools.set(event.name, (tools.get(event.name) ?? 0) + 1);
+          }
+        } catch {
+        }
       }
-    } catch {
+    } catch (err) {
+      streamError = err;
     }
+  } finally {
+    lines.close();
+    stream.destroy();
   }
+  const degradedNote = streamError ? color6.dim(`  (summary truncated: ${streamError.message ?? "stream error"})`) : null;
   const breakdown = tools.size > 0 ? [...tools.entries()].sort((a, b) => b[1] - a[1]).map(([name, count]) => `${name}\xD7${count}`).join(", ") : "(none)";
   const output = [
     color6.bold(`Subagent ${transcript.subagentId}`) + color6.dim(`  (run ${transcript.runId})`),
-    `  ${lines.length} events  \xB7  ${iterations} llm iterations  \xB7  ${(transcript.size / 1024).toFixed(1)} KB`,
+    `  ${eventCount} events  \xB7  ${iterations} llm iterations  \xB7  ${(transcript.size / 1024).toFixed(1)} KB`,
     `  tools: ${breakdown}`
   ];
+  if (degradedNote) output.push(degradedNote);
   if (firstUser) output.push("", color6.dim("  task:"), `  ${firstUser}`);
   if (lastResponse) output.push("", color6.dim("  last response:"), `  ${lastResponse}`);
   output.push("", color6.dim("  event mix:"));
@@ -5738,7 +6238,7 @@ function eventText(content) {
 async function retryInterruptedTasks(input, taskId) {
   const director = await input.multiAgentHost.ensureDirector();
   if (!director) return "Director is not available.";
-  const prior = await loadDirectorState(path10.join(input.fleetRoot, "director-state.json"));
+  const prior = await loadDirectorState(path11.join(input.fleetRoot, "director-state.json"));
   if (!prior) return "No prior director-state.json found \u2014 nothing to retry.";
   const interrupted = prior.tasks.filter(
     (task) => task.status === "running" || task.status === "pending"
@@ -5795,7 +6295,7 @@ async function retryInterruptedTasks(input, taskId) {
 }
 
 // src/wiring/hq-telemetry.ts
-import * as path11 from "node:path";
+import * as path12 from "node:path";
 import {
   startBrainTelemetryBridge,
   startCostTelemetryBridge,
@@ -5804,6 +6304,97 @@ import {
   startToolTelemetryBridge,
   startWorktreeTelemetryBridge
 } from "@wrongstack/core/hq";
+
+// src/governance-hq-telemetry.ts
+import {
+  readGovernanceDaemonOperatorStatus
+} from "@wrongstack/runtime/governance-bootstrap";
+var GOVERNANCE_HQ_SNAPSHOT_INTERVAL_MS = 15e3;
+function unavailableAction(code) {
+  return code === "broker_missing" ? "observe" : "investigate";
+}
+function projectGovernanceHqSnapshot(projectId, observedAt, result) {
+  if (!result.available) {
+    return {
+      schemaVersion: 1,
+      projectId,
+      observedAt,
+      available: false,
+      signal: {
+        level: "unavailable",
+        code: result.code,
+        operatorAction: unavailableAction(result.code),
+        executionDisposition: "continue"
+      }
+    };
+  }
+  const status = result.status;
+  return {
+    schemaVersion: 1,
+    projectId,
+    observedAt,
+    available: true,
+    signal: {
+      level: status.signal.level,
+      code: status.signal.code,
+      operatorAction: status.signal.operatorAction,
+      executionDisposition: "continue"
+    },
+    daemon: { pid: status.pid, startedAt: status.startedAt },
+    attachmentBroker: status.attachmentBroker === null ? null : {
+      state: status.attachmentBroker.state,
+      health: status.attachmentBroker.health,
+      consecutiveFailures: status.attachmentBroker.consecutiveFailures,
+      pendingRevocations: status.attachmentBroker.pendingRevocations,
+      auditHealthy: status.attachmentBroker.auditHealthy,
+      ...status.attachmentBroker.expiresAt ? { expiresAt: status.attachmentBroker.expiresAt } : {},
+      ...status.attachmentBroker.nextActionAt ? { nextActionAt: status.attachmentBroker.nextActionAt } : {}
+    }
+  };
+}
+function startGovernanceHqTelemetry(options) {
+  const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const readStatus = options.readStatus ?? readGovernanceDaemonOperatorStatus;
+  let stopped = false;
+  let inFlight = false;
+  const publish = async () => {
+    if (stopped || inFlight) return;
+    inFlight = true;
+    try {
+      let result;
+      try {
+        result = await readStatus(options.projectRoot);
+      } catch {
+        result = {
+          available: false,
+          code: "connection_failed",
+          message: "Governance status reader failed."
+        };
+      }
+      if (stopped) return;
+      const payload = projectGovernanceHqSnapshot(
+        options.publisher.project.projectId,
+        now(),
+        result
+      );
+      options.publisher.publishEvent({ type: "governance.snapshot", payload });
+    } finally {
+      inFlight = false;
+    }
+  };
+  void publish();
+  const timer = setInterval(
+    () => void publish(),
+    options.intervalMs ?? GOVERNANCE_HQ_SNAPSHOT_INTERVAL_MS
+  );
+  timer.unref?.();
+  return () => {
+    stopped = true;
+    clearInterval(timer);
+  };
+}
+
+// src/wiring/hq-telemetry.ts
 function setupHqTelemetry(deps) {
   const {
     events,
@@ -5833,7 +6424,7 @@ function setupHqTelemetry(deps) {
   const hqConnection = startCliHqConnection({
     clientKind: tuiOwnsScreen ? "tui" : "cli",
     projectRoot,
-    projectName: path11.basename(projectRoot),
+    projectName: path12.basename(projectRoot),
     appConfig: config,
     onCommand: hqOnCommand,
     capabilities: [
@@ -5860,7 +6451,7 @@ function setupHqTelemetry(deps) {
           events,
           sessionId: session.id,
           projectRoot,
-          projectName: path11.basename(projectRoot),
+          projectName: path12.basename(projectRoot),
           globalRoot,
           writer: session,
           // biome-ignore lint/suspicious/noExplicitAny: initialAgents shape
@@ -5880,6 +6471,10 @@ function setupHqTelemetry(deps) {
         );
       } catch {
       }
+      try {
+        stopHqAuxBridges.push(startGovernanceHqTelemetry({ publisher, projectRoot }));
+      } catch {
+      }
       try {
         publisher.publishEvent({
           type: "mcp.health.snapshot",
@@ -5976,7 +6571,7 @@ function setupHqTelemetry(deps) {
 }
 
 // src/wiring/lifecycle-plugins.ts
-import * as path14 from "node:path";
+import * as path15 from "node:path";
 import { getSharedProjectMailbox as getSharedProjectMailbox8 } from "@wrongstack/core/coordination";
 import { countShellHooks, HookRegistry, HookRunner, shellHooksEqual } from "@wrongstack/core/hooks";
 import { allServers } from "@wrongstack/core/infrastructure";
@@ -6051,8 +6646,8 @@ function installDesignStudio(deps) {
 
 // src/wiring/metrics.ts
 import { constants as fsConstants, writeFileSync } from "node:fs";
-import * as fs3 from "node:fs/promises";
-import * as path12 from "node:path";
+import * as fs4 from "node:fs/promises";
+import * as path13 from "node:path";
 import {
   DefaultHealthRegistry,
   InMemoryMetricsSink,
@@ -6198,7 +6793,7 @@ function setupMetrics(params) {
     name: "session-store",
     check: async () => {
       try {
-        await fs3.access(wpaths.projectSessions, fsConstants.R_OK | fsConstants.W_OK);
+        await fs4.access(wpaths.projectSessions, fsConstants.R_OK | fsConstants.W_OK);
         return { status: "healthy" };
       } catch {
         return { status: "unhealthy", detail: "session storage is not readable and writable" };
@@ -6209,7 +6804,7 @@ function setupMetrics(params) {
     name: "project-storage",
     check: async () => {
       try {
-        await fs3.access(wpaths.projectDir, fsConstants.R_OK | fsConstants.W_OK);
+        await fs4.access(wpaths.projectDir, fsConstants.R_OK | fsConstants.W_OK);
         return { status: "healthy" };
       } catch {
         return { status: "unhealthy", detail: "project storage is not readable and writable" };
@@ -6223,7 +6818,7 @@ function setupMetrics(params) {
   const dumpMetrics = () => {
     if (!metricsSink) return;
     try {
-      const out = path12.join(wpaths.projectSessions, "metrics.json");
+      const out = path13.join(wpaths.projectSessions, "metrics.json");
       const snap = metricsSink.snapshot();
       writeFileSync(out, JSON.stringify(snap, null, 2));
     } catch {
@@ -6271,11 +6866,11 @@ import { wstackGlobalRoot as wstackGlobalRoot2 } from "@wrongstack/core/utils";
 
 // src/mailbox-bridge-bootstrap.ts
 import { spawn as spawn2 } from "node:child_process";
-import * as path13 from "node:path";
+import * as path14 from "node:path";
 import { readLiveLock } from "@wrongstack/core/coordination";
 var MAILBOX_BRIDGE_BOOTSTRAP_TIMEOUT_MS = 5e3;
 async function tryAcquireMailboxBridge(opts) {
-  const lockPath = path13.join(opts.projectDir, ".mailbox-bridge.lock");
+  const lockPath = path14.join(opts.projectDir, ".mailbox-bridge.lock");
   const spawnFn = opts.spawnFn ?? defaultSpawn;
   const existing = await readLiveLock(opts.projectDir);
   if (existing.kind === "live") {
@@ -6714,7 +7309,7 @@ async function setupLifecycleAndPlugins(deps) {
   });
   agent.extensions.register(createLifecycleHooksExtension(hookRunner));
   const mcpTokenStore = new MCPVaultTokenStore(
-    path14.join(wpaths.projectDir, "mcp-auth.json"),
+    path15.join(wpaths.projectDir, "mcp-auth.json"),
     vault
   );
   const mcpAuthorizationManager = new MCPAuthorizationManager({ store: mcpTokenStore });
@@ -6810,7 +7405,7 @@ async function setupLifecycleAndPlugins(deps) {
 }
 
 // src/wiring/management-tools.ts
-import * as fs4 from "node:fs/promises";
+import * as fs5 from "node:fs/promises";
 import { createFallbackManageTools, createPluginManagerTool } from "@wrongstack/core/tools";
 function registerCliManagementTools({
   toolRegistry,
@@ -6821,23 +7416,23 @@ function registerCliManagementTools({
   const fallbackManageTools = createFallbackManageTools({
     getConfig: () => configStore.get(),
     updateConfig: async (mutate) => {
-      const raw = await fs4.readFile(profileConfigPath, "utf8").catch(() => "{}");
+      const raw = await fs5.readFile(profileConfigPath, "utf8").catch(() => "{}");
       const parsed = JSON.parse(raw);
       mutate(parsed);
-      await fs4.writeFile(profileConfigPath, JSON.stringify(parsed, null, 2), { mode: 384 });
+      await fs5.writeFile(profileConfigPath, JSON.stringify(parsed, null, 2), { mode: 384 });
       configStore.update(parsed);
     },
     // Interactive key entry for REPL mode reads a line from stdin without echo.
     ...stdinInteractive ? {
       requestInput: async (prompt) => {
-        const { createInterface } = await import("node:readline");
-        const rl = createInterface({ input: process.stdin, output: process.stdout });
-        return new Promise((resolve7) => {
+        const { createInterface: createInterface2 } = await import("node:readline");
+        const rl = createInterface2({ input: process.stdin, output: process.stdout });
+        return new Promise((resolve8) => {
           rl.question(`
 ${prompt}
 > `, (answer) => {
             rl.close();
-            resolve7(answer);
+            resolve8(answer);
           });
         });
       }
@@ -6883,9 +7478,13 @@ ${prompt}
 
 // src/wiring/provider-runtime-setup.ts
 import { createFallbackModelExtension as createFallbackModelExtension2 } from "@wrongstack/core/agent";
+import {
+  readProviderSnapshot,
+  SessionMemoryConsolidator,
+  watchProviderConfig
+} from "@wrongstack/core/storage";
 import { withCatalogCapabilities as withCatalogCapabilities2 } from "@wrongstack/providers";
 import { getSageService } from "@wrongstack/sage";
-import { readProviderSnapshot, SessionMemoryConsolidator, watchProviderConfig } from "@wrongstack/core/storage";
 function serializeProviderRuntimeSnapshot(snapshot) {
   return JSON.stringify(snapshot);
 }
@@ -6985,6 +7584,7 @@ function setupProviderRuntime(deps) {
   });
   const ROUTING_FIELDS = [
     "fallbackModels",
+    "fallbackBridge",
     "fallbackProfiles",
     "favoriteModels",
     "favoriteModelsOnly",
@@ -7021,6 +7621,7 @@ function setupProviderRuntime(deps) {
             ...snap.apiKey !== void 0 ? { apiKey: snap.apiKey } : merged.apiKey !== void 0 ? { apiKey: merged.apiKey } : {},
             ...snap.baseUrl !== void 0 ? { baseUrl: snap.baseUrl } : merged.baseUrl !== void 0 ? { baseUrl: merged.baseUrl } : {},
             ...snap.fallbackModels !== void 0 ? { fallbackModels: snap.fallbackModels } : merged.fallbackModels !== void 0 ? { fallbackModels: merged.fallbackModels } : {},
+            ...snap.fallbackBridge !== void 0 ? { fallbackBridge: snap.fallbackBridge } : merged.fallbackBridge !== void 0 ? { fallbackBridge: merged.fallbackBridge } : {},
             ...snap.fallbackProfiles !== void 0 ? { fallbackProfiles: snap.fallbackProfiles } : merged.fallbackProfiles !== void 0 ? { fallbackProfiles: merged.fallbackProfiles } : {},
             ...snap.favoriteModels !== void 0 ? { favoriteModels: snap.favoriteModels } : merged.favoriteModels !== void 0 ? { favoriteModels: merged.favoriteModels } : {},
             ...snap.favoriteModelsOnly !== void 0 ? { favoriteModelsOnly: snap.favoriteModelsOnly } : merged.favoriteModelsOnly !== void 0 ? { favoriteModelsOnly: merged.favoriteModelsOnly } : {},
@@ -7092,14 +7693,14 @@ function setupProviderRuntime(deps) {
 }
 
 // src/wiring/provider-status.ts
-import * as fs5 from "node:fs/promises";
+import * as fs6 from "node:fs/promises";
 import { ProviderModelStatusTracker } from "@wrongstack/core/coordination";
 import { atomicWrite as atomicWrite2, withFileLock } from "@wrongstack/core/utils";
 async function setupProviderStatus(input) {
   const tracker = new ProviderModelStatusTracker({ events: input.events });
   const statusFile = input.paths.profileProviderStatus(input.paths.profileName);
   try {
-    const saved = JSON.parse(await fs5.readFile(statusFile, "utf8"));
+    const saved = JSON.parse(await fs6.readFile(statusFile, "utf8"));
     const restored = tracker.restoreSnapshot(saved);
     if (restored > 0) input.logger.info(`Restored ${restored} provider waiting-room entries`);
   } catch (error) {
@@ -7111,7 +7712,7 @@ async function setupProviderStatus(input) {
     tracker.sweepExpired();
     if (syncRunning) return;
     syncRunning = true;
-    void fs5.readFile(statusFile, "utf8").then((raw) => tracker.restoreSnapshot(JSON.parse(raw))).catch((error) => warnUnlessMissing(input.logger, "sync", error)).finally(() => {
+    void fs6.readFile(statusFile, "utf8").then((raw) => tracker.restoreSnapshot(JSON.parse(raw))).catch((error) => warnUnlessMissing(input.logger, "sync", error)).finally(() => {
       syncRunning = false;
     });
   }, 3e4);
@@ -7126,7 +7727,7 @@ async function setupProviderStatus(input) {
       await withFileLock(statusFile, async () => {
         let statuses = [];
         try {
-          const current = JSON.parse(await fs5.readFile(statusFile, "utf8"));
+          const current = JSON.parse(await fs6.readFile(statusFile, "utf8"));
           if (Array.isArray(current.statuses)) statuses = current.statuses;
         } catch (error) {
           if (error.code !== "ENOENT") throw error;
@@ -7359,7 +7960,7 @@ function applyLiveSettings(input, settings) {
 import { getToolDescriptionMode } from "@wrongstack/core/utils";
 
 // src/wiring/codebase-index.ts
-import * as path15 from "node:path";
+import * as path16 from "node:path";
 import {
   cancelPendingReindexes,
   enqueueReindex,
@@ -7405,9 +8006,9 @@ async function setupCodebaseIndexing(deps) {
             const fp = payload.toolUse.input?.path;
             if (typeof fp === "string" && fp.length > 0) {
               const activeRoot = payload.ctx.projectRoot;
-              const abs = path15.resolve(payload.ctx.cwd, fp);
-              const rel = path15.relative(activeRoot, abs);
-              const inside = rel !== ".." && !rel.startsWith(`..${path15.sep}`) && !path15.isAbsolute(rel);
+              const abs = path16.resolve(payload.ctx.cwd, fp);
+              const rel = path16.relative(activeRoot, abs);
+              const inside = rel !== ".." && !rel.startsWith(`..${path16.sep}`) && !path16.isAbsolute(rel);
               if (inside && isIndexableFile(abs)) {
                 enqueueReindex({ projectRoot: activeRoot, files: [abs], debounceMs, onError });
               }
@@ -7464,7 +8065,8 @@ function setupSage(deps) {
         verifyOnMutation: cfg?.hygiene?.autoOnFileChange,
         triggers: cfg?.inject?.triggers,
         tracker: injectionTracker,
-        events: deps.events
+        events: deps.events,
+        getSessionId: deps.getSessionId
       })
     );
   }
@@ -7841,12 +8443,12 @@ function createSddHandlers(deps) {
     const sddApi = await import("@wrongstack/sdd");
     let worktrees;
     if (process.env["WRONGSTACK_SDD_WORKTREES"] !== "0") {
-      const inGit = await new Promise((resolve7) => {
+      const inGit = await new Promise((resolve8) => {
         let resolved = false;
         const settle = (v) => {
           if (resolved) return;
           resolved = true;
-          resolve7(v);
+          resolve8(v);
         };
         try {
           const child = spawn3("git", ["rev-parse", "--is-inside-work-tree"], {
@@ -8023,7 +8625,7 @@ function createSddHandlers(deps) {
 
 // src/wiring/session.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
-import * as path16 from "node:path";
+import * as path17 from "node:path";
 import { Context as Context2 } from "@wrongstack/core/agent";
 import { ProviderCacheLedger } from "@wrongstack/core/infrastructure";
 import {
@@ -8102,7 +8704,7 @@ async function setupSession(params) {
   const sessionId = expectDefined4(session?.id, "active session id");
   const sessionDir = sessionScopedPath3(wpaths.projectSessions, sessionId, "");
   const attachments = new DefaultAttachmentStore({
-    spoolDir: path16.join(sessionDir, "attachments")
+    spoolDir: path17.join(sessionDir, "attachments")
   });
   const ctxSignal = new AbortController().signal;
   const traceId = randomBytes2(16).toString("hex");
@@ -8210,7 +8812,7 @@ async function setupSession(params) {
   if (resumeId) {
     try {
       const fleetRoot = sessionDir;
-      dirState = await loadDirectorState2(path16.join(fleetRoot, "director-state.json"));
+      dirState = await loadDirectorState2(path17.join(fleetRoot, "director-state.json"));
       if (dirState) {
         const tCounts = {};
         for (const t of dirState.tasks) tCounts[t.status] = (tCounts[t.status] ?? 0) + 1;
@@ -8665,7 +9267,7 @@ async function disposeSession(input) {
   }
 }
 async function checkUncommittedChanges(projectRoot) {
-  const result = await new Promise((resolve7, reject) => {
+  const result = await new Promise((resolve8, reject) => {
     const child = spawn4("git", ["status", "--porcelain"], {
       cwd: projectRoot,
       stdio: ["ignore", "pipe", "pipe"],
@@ -8677,7 +9279,7 @@ async function checkUncommittedChanges(projectRoot) {
       stdout += data;
     });
     child.on("error", reject);
-    child.on("close", (code) => resolve7({ stdout, code: code ?? 0 }));
+    child.on("close", (code) => resolve8({ stdout, code: code ?? 0 }));
   });
   if (!result.stdout.trim()) return void 0;
   const count = result.stdout.split("\n").filter(Boolean).length;
@@ -8724,7 +9326,7 @@ function formatDiagnostics(input) {
 
 // src/wiring/session-registry.ts
 import { execFile } from "node:child_process";
-import * as path17 from "node:path";
+import * as path18 from "node:path";
 async function setupSessionRegistry(deps) {
   const { wpaths, projectRoot, session, context, tuiOwnsScreen, events } = deps;
   let tracker;
@@ -8734,9 +9336,9 @@ async function setupSessionRegistry(deps) {
   try {
     const { getSessionRegistry: getSessionRegistry2, AgentStatusTracker, FleetNotifier } = await import("@wrongstack/core/storage");
     const registry = getSessionRegistry2(wpaths.globalRoot);
-    const projectSlug = path17.basename(wpaths.projectDir);
-    const projectName = path17.basename(projectRoot);
-    let gitBranch = await new Promise((resolve7) => {
+    const projectSlug = path18.basename(wpaths.projectDir);
+    const projectName = path18.basename(projectRoot);
+    let gitBranch = await new Promise((resolve8) => {
       execFile(
         "git",
         ["rev-parse", "--abbrev-ref", "HEAD"],
@@ -8747,7 +9349,7 @@ async function setupSessionRegistry(deps) {
           windowsHide: true,
           maxBuffer: 64 * 1024
         },
-        (error, stdout) => resolve7(error ? void 0 : stdout.trim() || void 0)
+        (error, stdout) => resolve8(error ? void 0 : stdout.trim() || void 0)
       );
     });
     if (gitBranch === "HEAD") gitBranch = void 0;
@@ -9743,7 +10345,7 @@ ${color13.dim("YOLO enabled; tool calls run without approval unless an explicit
 
 // src/slash-commands/brain.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
-import { readFile as readFile6 } from "node:fs/promises";
+import { readFile as readFile7 } from "node:fs/promises";
 import { color as color14 } from "@wrongstack/core/utils";
 import { parseModelRef } from "@wrongstack/core/agent";
 var RISK_LEVELS = /* @__PURE__ */ new Set(["off", "low", "medium", "high", "all"]);
@@ -10104,7 +10706,7 @@ function buildBrainCommand(opts) {
         const n = Math.max(1, Math.min(100, Number.parseInt(rest[0] ?? "15", 10) || 15));
         let raw;
         try {
-          raw = await readFile6(ledgerPath, "utf8");
+          raw = await readFile7(ledgerPath, "utf8");
         } catch {
           const msg3 = `No ledger entries yet (${ledgerPath}).`;
           opts.renderer.write(msg3);
@@ -10972,7 +11574,7 @@ function buildCompactCommand(opts) {
 }
 
 // src/slash-commands/context.ts
-import * as fs6 from "node:fs/promises";
+import * as fs7 from "node:fs/promises";
 import { atomicWrite as atomicWrite3, color as color18, getContextBreakdown, repairToolUseAdjacency } from "@wrongstack/core/utils";
 import { formatContextWindowModeList, getContextWindowMode, resolveContextWindowPolicy as resolveContextWindowPolicy2 } from "@wrongstack/core/types";
 function buildContextCommand(opts) {
@@ -11308,7 +11910,7 @@ async function persistContextConfig(opts, patch) {
   const configPath = activeProfileConfigPath(opts.paths, opts.configStore.get());
   let raw = "{}";
   try {
-    raw = await fs6.readFile(configPath, "utf8");
+    raw = await fs7.readFile(configPath, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") {
       return `Could not read ${configPath}: ${err.message}`;
@@ -11706,9 +12308,23 @@ function listRoles() {
 }
 
 // src/slash-commands/design.ts
-import * as fs7 from "node:fs/promises";
-import * as path18 from "node:path";
-import { applyTokenOverrides, clearActiveKit, clearPersistedActiveKit, getDesignKitLoader, getDesignState, isDesignStack, loadActiveKit, materializeTokens, recordOverrides, resolveSemanticTune, setActiveKit, setDesignOverrides } from "@wrongstack/core/design";
+import * as fs8 from "node:fs/promises";
+import * as path19 from "node:path";
+import {
+  applyTokenOverrides,
+  clearActiveKit,
+  clearPersistedActiveKit,
+  getDesignKitLoader,
+  getDesignState,
+  isDesignStack,
+  loadActiveKit,
+  materializeTokens,
+  recordOverrides,
+  resolveMaterializeTarget,
+  resolveSemanticTune,
+  setActiveKit,
+  setDesignOverrides
+} from "@wrongstack/core/design";
 import { color as color20 } from "@wrongstack/core/utils";
 function parseOverridePairs(tokens) {
   const out = {};
@@ -11792,7 +12408,9 @@ ${color20.dim("Pin one with /design <kit-id> [stack].")}`
         };
         const patch = resolveSemanticTune(tune);
         if (Object.keys(patch).length === 0) {
-          return { message: 'Usage: /design tune radius=lg density=compact font="\u2026" motion=snappy' };
+          return {
+            message: 'Usage: /design tune radius=lg density=compact font="\u2026" motion=snappy'
+          };
         }
         const merged = await recordOverrides(opts.projectRoot, patch, (/* @__PURE__ */ new Date()).toISOString());
         if (!merged) {
@@ -11819,7 +12437,9 @@ ${menu}` };
         await clearPersistedActiveKit(opts.projectRoot);
         if (ctx) setActiveKit(ctx, kit2.id, stack2, {});
         return {
-          message: color20.green(`Swapped to design kit "${kit2.name}" (${kit2.id}). Old overrides dropped.`),
+          message: color20.green(
+            `Swapped to design kit "${kit2.name}" (${kit2.id}). Old overrides dropped.`
+          ),
           runText: `design use ${kit2.id}${stack2 ? ` --stack ${stack2}` : ""}`,
           metadata: { designKit: kit2.id, ...stack2 ? { designStack: stack2 } : {} }
         };
@@ -11841,10 +12461,15 @@ ${menu}` };
           kitId: active2.kit,
           outPath
         });
-        const abs = path18.join(opts.projectRoot, result.path);
+        let abs;
         try {
-          await fs7.mkdir(path18.dirname(abs), { recursive: true });
-          await fs7.writeFile(abs, result.content);
+          abs = await resolveMaterializeTarget(result.path, opts.projectRoot);
+        } catch (e) {
+          return { message: e.message };
+        }
+        try {
+          await fs8.mkdir(path19.dirname(abs), { recursive: true });
+          await fs8.writeFile(abs, result.content);
         } catch (e) {
           return { message: `Failed to write ${result.path}: ${e.message}` };
         }
@@ -11891,7 +12516,7 @@ The following characters are not allowed: ; & | < > ^ $ , ( ) { } [ ] ! # % ' "
   }
 }
 function runCommand(cmd, cwd, timeout) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     validateCommand(cmd);
     const opts = {
       cwd,
@@ -11904,7 +12529,7 @@ function runCommand(cmd, cwd, timeout) {
       shell: process.platform === "win32"
     };
     execFile2(cmd, [], opts, (error, stdout, stderr) => {
-      resolve7({
+      resolve8({
         stdout,
         stderr,
         exitCode: typeof error?.code === "number" ? error.code : 0,
@@ -12011,13 +12636,13 @@ function buildStatsCommand(opts) {
 }
 
 // src/slash-commands/doctor.ts
-import * as fs8 from "node:fs/promises";
-import * as path19 from "node:path";
+import * as fs9 from "node:fs/promises";
+import * as path20 from "node:path";
 import { atomicWrite as atomicWrite4, color as color22 } from "@wrongstack/core/utils";
 
 // src/config-doctor.ts
-import { validateAgainstSchema } from "@wrongstack/core/utils";
 import { isSecretField } from "@wrongstack/core/security";
+import { validateAgainstSchema } from "@wrongstack/core/utils";
 var KNOWN_TOP_LEVEL_KEYS = [
   "version",
   "provider",
@@ -12038,6 +12663,7 @@ var KNOWN_TOP_LEVEL_KEYS = [
   "acp",
   "agents",
   "fallbackModels",
+  "fallbackBridge",
   "fallbackProfiles",
   "fallbackAuto",
   "hooks",
@@ -12069,7 +12695,12 @@ var KNOWN_TOP_LEVEL_KEYS = [
 ];
 var BOOLEAN_FIELDS = ["hints", "debugStream", "yolo", "nextPrediction"];
 var AUTONOMY_ENUMS = {
-  defaultMode: ["off", "suggest", "auto"],
+  // Parity with `AutonomyMode` (cli/src/services/autonomy-mode.ts) and the
+  // TUI settings picker; the persist layer (`pref-helpers.ts`) now
+  // round-trips all five modes instead of silently dropping 'eternal' /
+  // 'eternal-parallel', and the doctor must accept them too or it would
+  // flag a config that the rest of the system happily writes.
+  defaultMode: ["off", "suggest", "auto", "eternal", "eternal-parallel"],
   enhanceLanguage: ["original", "english"]
 };
 var AUTONOMY_BOOLEANS = ["enhance"];
@@ -12430,17 +13061,17 @@ function diagnoseConfig(cfg, plugins = []) {
 function scanPlaintextSecrets(node, prefix, findings) {
   if (!isPlainObject(node)) return;
   for (const [key, value] of Object.entries(node)) {
-    const path31 = prefix ? `${prefix}.${key}` : key;
+    const path32 = prefix ? `${prefix}.${key}` : key;
     if (typeof value === "string") {
       if (value.length > 0 && isSecretField(key) && !value.startsWith(ENC_PREFIX)) {
         findings.push({
-          path: path31,
+          path: path32,
           problem: "looks like a plaintext secret (not vault-encrypted) \u2014 it will be encrypted on next boot",
           severity: "warning"
         });
       }
     } else if (isPlainObject(value)) {
-      scanPlaintextSecrets(value, path31, findings);
+      scanPlaintextSecrets(value, path32, findings);
     }
   }
 }
@@ -12463,7 +13094,7 @@ function buildDoctorCommand(opts) {
   ].join("\n");
   async function loadPluginSchemas() {
     try {
-      const { BUILTIN_PLUGIN_FACTORIES } = await import("./plugins-4LJ5IUBI.js");
+      const { BUILTIN_PLUGIN_FACTORIES } = await import("./plugins-ETY6W3DC.js");
       const settled = await Promise.allSettled(BUILTIN_PLUGIN_FACTORIES.map((f) => f()));
       const loaded = [];
       for (const s of settled) {
@@ -12482,11 +13113,11 @@ function buildDoctorCommand(opts) {
     return `  ${icon} ${color22.cyan(f.path)} \u2014 ${f.problem}${fix}`;
   }
   async function findParsableBackup(file) {
-    const dir = path19.dirname(file);
-    const base = path19.basename(file);
+    const dir = path20.dirname(file);
+    const base = path20.basename(file);
     const candidates = [`${base}.last`];
     try {
-      const siblings = await fs8.readdir(dir);
+      const siblings = await fs9.readdir(dir);
       candidates.push(
         ...siblings.filter((f) => f.startsWith(`${base}.`) && f.endsWith(".bak")).sort().reverse()
       );
@@ -12494,7 +13125,7 @@ function buildDoctorCommand(opts) {
     }
     for (const name of candidates) {
       try {
-        const raw = await fs8.readFile(path19.join(dir, name), "utf8");
+        const raw = await fs9.readFile(path20.join(dir, name), "utf8");
         JSON.parse(raw);
         return { name, raw };
       } catch {
@@ -12547,7 +13178,7 @@ function buildDoctorCommand(opts) {
       for (const target of targets) {
         let raw;
         try {
-          raw = await fs8.readFile(target.file, "utf8");
+          raw = await fs9.readFile(target.file, "utf8");
         } catch {
           if (!target.isProject) {
             lines.push(
@@ -12615,7 +13246,7 @@ function buildDoctorCommand(opts) {
           await atomicWrite4(target.file, JSON.stringify(report.fixed, null, 2));
           if (!target.isProject) {
             try {
-              const homeFn = () => path19.dirname(path19.dirname(target.file));
+              const homeFn = () => path20.dirname(path20.dirname(target.file));
               await appendHistory(
                 parsed,
                 report.fixed,
@@ -12860,7 +13491,7 @@ function buildFKeyAliasCommands(opts) {
 }
 
 // src/slash-commands/fallback.ts
-import * as fs9 from "node:fs/promises";
+import * as fs10 from "node:fs/promises";
 import {
   normalizeModelRef,
   parseModelRef as parseModelRef2,
@@ -12904,7 +13535,7 @@ async function patchGlobalConfig(globalConfigPath, mutate) {
   let raw = "{}";
   let fileExists2 = true;
   try {
-    raw = await fs9.readFile(globalConfigPath, "utf8");
+    raw = await fs10.readFile(globalConfigPath, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
     fileExists2 = false;
@@ -12936,6 +13567,8 @@ function buildFallbackCommand(opts) {
     "  /fallback add <model>           Append a model on the leader provider",
     "  /fallback remove <n|ref>        Remove by 1-based index or exact reference",
     "  /fallback clear                 Empty the explicit chain",
+    "  /fallback bridge set <provider/model>  Set the first continuity route",
+    "  /fallback bridge clear          Disable the continuity route",
     "  /fallback auto on|off           Toggle the auto-derived smart default",
     "  /fallback profile set <name> <ref,ref,...>  Create or replace a named chain",
     "  /fallback profile use <name>     Make a profile the leader fallback chain",
@@ -12954,12 +13587,14 @@ function buildFallbackCommand(opts) {
     const explicit = config.fallbackModels ?? [];
     const profiles = config.fallbackProfiles ?? {};
     const favorites = config.favoriteModels ?? [];
+    const bridge = config.fallbackBridge?.trim();
     const auto = config.fallbackAuto !== false;
     const filteredReason = (ref) => refInactiveReason(ref, config);
     const lines = [
       `${color24.bold("WrongStack")} ${color24.dim("\u2014 Fallback chain")}`,
       "",
       `  ${color24.bold("leader")}  ${color24.cyan(`${config.provider}/${config.model}`)}`,
+      `  ${color24.bold("bridge")}  ${bridge ? color24.cyan(bridge) : color24.dim("(disabled)")}  ${color24.dim("/fallback bridge set <provider/model>")}`,
       ""
     ];
     if (explicit.length > 0) {
@@ -13038,6 +13673,37 @@ function buildFallbackCommand(opts) {
       const globalConfigPath = activeProfileConfigPath(opts.paths, config);
       const explicit = [...config.fallbackModels ?? []];
       try {
+        if (sub === "bridge") {
+          const action = (parts[1] ?? "").toLowerCase();
+          if (action === "clear" || action === "off") {
+            await patchGlobalConfig(globalConfigPath, (cfg) => {
+              delete cfg.fallbackBridge;
+            });
+            opts.configStore.update({ fallbackBridge: "" });
+            return { message: `${color24.green("\u2713")} continuity bridge disabled` };
+          }
+          if (action !== "set") {
+            return {
+              message: `${color24.amber("Usage:")} /fallback bridge set <provider/model> | clear`
+            };
+          }
+          const ref = normalizeRef(parts.slice(2).join(" "));
+          const parsed = parseModelRef2(ref);
+          if (!ref || !parsed.provider || !parsed.model) {
+            return {
+              message: `${color24.amber("Usage:")} /fallback bridge set <provider/model>`
+            };
+          }
+          const invalid = refInvalidReason(ref, config);
+          if (invalid) {
+            return { message: `${color24.red("Cannot set bridge")}: "${ref}" \u2014 ${invalid}` };
+          }
+          const decrypted = await patchGlobalConfig(globalConfigPath, (cfg) => {
+            cfg.fallbackBridge = ref;
+          });
+          opts.configStore.update({ fallbackBridge: decrypted.fallbackBridge });
+          return { message: `${color24.green("\u2713")} continuity bridge \u2192 ${color24.cyan(ref)}` };
+        }
         if (sub === "add") {
           const ref = normalizeRef(parts.slice(1).join(" "));
           if (!ref) {
@@ -14600,7 +15266,7 @@ import { assessCommitSafety } from "@wrongstack/core/coordination";
 import { color as color27, toErrorMessage as toErrorMessage14 } from "@wrongstack/core/utils";
 async function runGit(args, cwd) {
   try {
-    return await new Promise((resolve7, reject) => {
+    return await new Promise((resolve8, reject) => {
       const child = spawn5("git", args, {
         cwd,
         stdio: ["ignore", "pipe", "pipe"],
@@ -14618,7 +15284,7 @@ async function runGit(args, cwd) {
       child.on("error", (err) => {
         reject(new Error(`Failed to run git: ${err.message}`));
       });
-      child.on("close", (code) => resolve7({ stdout, stderr, code: code ?? 0 }));
+      child.on("close", (code) => resolve8({ stdout, stderr, code: code ?? 0 }));
     });
   } catch (err) {
     throw new Error(toErrorMessage14(err));
@@ -14920,7 +15586,7 @@ ${color27.dim("(dry-run)")}`
 }
 
 // src/slash-commands/gitid.ts
-import * as fs10 from "node:fs/promises";
+import * as fs11 from "node:fs/promises";
 import { toErrorMessage as toErrorMessage15 } from "@wrongstack/core/utils";
 import { atomicWrite as atomicWrite6, color as color28, configureChildEnvGitIdentity as configureChildEnvGitIdentity2, getChildEnvGitIdentity } from "@wrongstack/core/utils";
 import { ConfigError as ConfigError2 } from "@wrongstack/core/types";
@@ -14932,7 +15598,7 @@ async function patchGlobalConfig2(globalConfigPath, mutate) {
   let raw = "{}";
   let fileExists2 = true;
   try {
-    raw = await fs10.readFile(globalConfigPath, "utf8");
+    raw = await fs11.readFile(globalConfigPath, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
     fileExists2 = false;
@@ -15069,7 +15735,7 @@ function buildGitIdCommand(opts) {
 
 // src/slash-commands/goal.ts
 import * as fsp from "node:fs/promises";
-import * as path20 from "node:path";
+import * as path21 from "node:path";
 import { ConfigError as ConfigError3 } from "@wrongstack/core/types";
 import { PhaseStore as PhaseStore2 } from "@wrongstack/core/goal";
 function getStore(opts) {
@@ -15121,7 +15787,7 @@ function formatPhaseList(graph) {
 }
 async function gatherProjectContext2(projectRoot) {
   try {
-    const raw = await fsp.readFile(path20.join(projectRoot, "package.json"), "utf8");
+    const raw = await fsp.readFile(path21.join(projectRoot, "package.json"), "utf8");
     const pkg = JSON.parse(raw);
     const parts = [
       `Project: ${String(pkg.name ?? "unknown")}`,
@@ -15395,8 +16061,8 @@ function buildHelpCommand(opts) {
 }
 
 // src/slash-commands/init.ts
-import * as fs11 from "node:fs/promises";
-import * as path21 from "node:path";
+import * as fs12 from "node:fs/promises";
+import * as path22 from "node:path";
 import { color as color30 } from "@wrongstack/core/utils";
 function buildInitCommand(opts) {
   return {
@@ -15405,24 +16071,24 @@ function buildInitCommand(opts) {
     description: "Create or update .wrongstack/AGENTS.md project context for the system prompt.",
     async run(_args, ctx) {
       const root = ctx?.projectRoot ?? opts.projectRoot ?? process.cwd();
-      const dir = path21.join(root, ".wrongstack");
-      const file = path21.join(dir, "AGENTS.md");
+      const dir = path22.join(root, ".wrongstack");
+      const file = path22.join(dir, "AGENTS.md");
       const isFirstInit = !await fileExists(file);
       const detected = await detectProjectFacts(root);
       const body = renderAgentsTemplate(detected);
-      await fs11.mkdir(dir, { recursive: true });
+      await fs12.mkdir(dir, { recursive: true });
       let backedUp = false;
       if (!isFirstInit) {
         try {
-          await fs11.copyFile(file, `${file}.bak`);
+          await fs12.copyFile(file, `${file}.bak`);
           backedUp = true;
         } catch {
         }
       }
-      await fs11.writeFile(file, body, "utf8");
+      await fs12.writeFile(file, body, "utf8");
       let nodePkg = false;
       try {
-        await fs11.access(path21.join(root, "package.json"));
+        await fs12.access(path22.join(root, "package.json"));
         nodePkg = true;
       } catch {
       }
@@ -15460,7 +16126,7 @@ function buildInitCommand(opts) {
 }
 async function fileExists(filePath) {
   try {
-    await fs11.access(filePath);
+    await fs12.access(filePath);
     return true;
   } catch {
     return false;
@@ -17112,9 +17778,9 @@ function buildMailboxDemoCommand(opts) {
 
 // src/slash-commands/mailbox-serve.ts
 import { spawn as spawn6 } from "node:child_process";
-import * as fs12 from "node:fs/promises";
+import * as fs13 from "node:fs/promises";
 import * as os2 from "node:os";
-import * as path22 from "node:path";
+import * as path23 from "node:path";
 import { resolveProjectDir as resolveProjectDir5 } from "@wrongstack/core/coordination";
 import { wstackGlobalRoot as wstackGlobalRoot5 } from "@wrongstack/core/utils";
 function buildMailboxServeCommand(opts) {
@@ -17156,8 +17822,8 @@ function buildMailboxServeCommand(opts) {
       }
       const cwd = opts.paths?.projectDir ?? opts.cwd;
       const projectDir = resolveProjectDir5(cwd, wstackGlobalRoot5());
-      const tokenPath = path22.join(projectDir, ".mailbox.token");
-      const pidFile = path22.join(os2.tmpdir(), `wstack-mailbox-bridge-${path22.basename(projectDir)}.pid`);
+      const tokenPath = path23.join(projectDir, ".mailbox.token");
+      const pidFile = path23.join(os2.tmpdir(), `wstack-mailbox-bridge-${path23.basename(projectDir)}.pid`);
       const cliEntry = process.argv[1];
       const isWin = process.platform === "win32";
       let wstackCmd;
@@ -17184,7 +17850,7 @@ function buildMailboxServeCommand(opts) {
       });
       child.unref();
       try {
-        await fs12.writeFile(pidFile, String(child.pid ?? ""), { mode: 384 });
+        await fs13.writeFile(pidFile, String(child.pid ?? ""), { mode: 384 });
       } catch {
       }
       const head = [];
@@ -19198,7 +19864,7 @@ ${targetMode.description}`
 }
 
 // src/slash-commands/modelcaps.ts
-import * as fs13 from "node:fs/promises";
+import * as fs14 from "node:fs/promises";
 import { color as color36 } from "@wrongstack/core/utils";
 function fmtTokens(n) {
   if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
@@ -19275,7 +19941,7 @@ function buildModelCapsCommand(opts) {
       }
       let providers;
       try {
-        const raw = await fs13.readFile(cachePath, "utf8");
+        const raw = await fs14.readFile(cachePath, "utf8");
         const parsed = JSON.parse(raw);
         const payload = parsed.payload ?? parsed;
         providers = Object.entries(payload).map(([id, p]) => ({
@@ -19358,7 +20024,7 @@ function buildModelCapsCommand(opts) {
 }
 
 // src/slash-commands/models.ts
-import * as fs14 from "node:fs/promises";
+import * as fs15 from "node:fs/promises";
 import { toErrorMessage as toErrorMessage18 } from "@wrongstack/core/utils";
 import { atomicWrite as atomicWrite7, color as color37 } from "@wrongstack/core/utils";
 import { ConfigError as ConfigError4, ToolValidationError as ToolValidationError4 } from "@wrongstack/core/types";
@@ -19368,7 +20034,7 @@ async function patchProfileConfig(mutate, profileConfigPath) {
   let raw = "{}";
   let fileExists2 = true;
   try {
-    raw = await fs14.readFile(targetPath, "utf8");
+    raw = await fs15.readFile(targetPath, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
     fileExists2 = false;
@@ -20048,7 +20714,7 @@ function buildPluginCommand(opts) {
 }
 
 // src/slash-commands/profile.ts
-import * as path23 from "node:path";
+import * as path24 from "node:path";
 import { atomicWrite as atomicWrite8, color as color39 } from "@wrongstack/core/utils";
 import { readJsonObjectFile as readJsonObjectFile2 } from "@wrongstack/core/utils";
 var INVALID_NAME_PATTERN = /[/\\:._]/g;
@@ -20184,8 +20850,8 @@ async function copyProfile(wpaths, nameArg, activeProfile, renderer) {
     return { message: msg2 };
   }
   const destPath = wpaths.profileConfig(safe);
-  const srcDir = path23.dirname(srcPath);
-  const destDir = path23.dirname(destPath);
+  const srcDir = path24.dirname(srcPath);
+  const destDir = path24.dirname(destPath);
   const { access: access8, cp } = await import("node:fs/promises");
   try {
     await access8(destDir);
@@ -22230,7 +22896,7 @@ async function killSession(sessionId, confirm) {
 }
 
 // src/slash-commands/setmodel.ts
-import * as fs15 from "node:fs/promises";
+import * as fs16 from "node:fs/promises";
 import { toErrorMessage as toErrorMessage21 } from "@wrongstack/core/utils";
 import { AGENT_CATALOG as AGENT_CATALOG2, AGENTS_BY_PHASE as AGENTS_BY_PHASE3 } from "@wrongstack/core/agent-catalog";
 import { atomicWrite as atomicWrite9, color as color44, expectDefined as expectDefined8 } from "@wrongstack/core/utils";
@@ -22312,7 +22978,7 @@ async function patchProfileConfig2(mutate, profileConfigPath) {
   let raw = "{}";
   let fileExists2 = true;
   try {
-    raw = await fs15.readFile(targetPath, "utf8");
+    raw = await fs16.readFile(targetPath, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
     fileExists2 = false;
@@ -22774,14 +23440,14 @@ function buildSetModelCommand(opts) {
 // src/slash-commands/suggest.ts
 import { execFile as execFile3 } from "node:child_process";
 import { access as access4 } from "node:fs/promises";
-import * as path24 from "node:path";
+import * as path25 from "node:path";
 import { color as color45 } from "@wrongstack/core/utils";
 import { parseNextSteps } from "@wrongstack/tools/next-steps";
 import { toErrorMessage as toErrorMessage22 } from "@wrongstack/core/utils";
 function readGitStatus(projectRoot, includeBranch) {
   const args = ["status", "--short"];
   if (includeBranch) args.push("--branch");
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     execFile3(
       "git",
       args,
@@ -22792,7 +23458,7 @@ function readGitStatus(projectRoot, includeBranch) {
         windowsHide: true,
         maxBuffer: 1024 * 1024
       },
-      (error, stdout) => resolve7(error ? "" : stdout.trim())
+      (error, stdout) => resolve8(error ? "" : stdout.trim())
     );
   });
 }
@@ -22947,7 +23613,7 @@ async function generateHeuristicSuggestions(opts) {
     }
   }
   const root = opts.projectRoot;
-  const has = async (...rel) => (await Promise.all(rel.map((item) => pathExists2(path24.join(root, item))))).some(Boolean);
+  const has = async (...rel) => (await Promise.all(rel.map((item) => pathExists2(path25.join(root, item))))).some(Boolean);
   const [hasNode, hasDocker, hasMake, hasPython, hasCi] = await Promise.all([
     has("package.json"),
     has("Dockerfile", "docker-compose.yml", "compose.yaml"),
@@ -23482,9 +24148,9 @@ function buildMouseCommand(_opts) {
 
 // src/slash-commands/project.ts
 import { spawn as spawn7 } from "node:child_process";
-import * as fs16 from "node:fs/promises";
+import * as fs17 from "node:fs/promises";
 import { createRequire } from "node:module";
-import * as path25 from "node:path";
+import * as path26 from "node:path";
 import {
   color as color47,
   ensureProjectGitignore,
@@ -23692,13 +24358,13 @@ async function listProjectsCommand(opts, ctx) {
   return { message: lines.join("\n") };
 }
 async function addProjectCommand(opts, ctx, targetPath, displayName) {
-  const resolved = path25.resolve(ctx?.projectRoot ?? ctx?.cwd ?? process.cwd(), targetPath);
+  const resolved = path26.resolve(ctx?.projectRoot ?? ctx?.cwd ?? process.cwd(), targetPath);
   try {
-    await fs16.access(resolved);
+    await fs17.access(resolved);
   } catch {
     return { message: color47.red(`Directory not found: ${resolved}`) };
   }
-  const stat5 = await fs16.stat(resolved);
+  const stat5 = await fs17.stat(resolved);
   if (!stat5.isDirectory()) {
     return { message: color47.red(`Not a directory: ${resolved}`) };
   }
@@ -23709,7 +24375,7 @@ async function addProjectCommand(opts, ctx, targetPath, displayName) {
       message: color47.yellow(`Project already registered: "${existing.name}" (${existing.slug})`)
     };
   }
-  const name = displayName?.trim() || path25.basename(resolved);
+  const name = displayName?.trim() || path26.basename(resolved);
   const slug = generateSlug(resolved);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   await ensureProjectDataDir(slug, opts.paths?.globalConfig);
@@ -23762,13 +24428,13 @@ async function removeProjectCommand(opts, _ctx, slugOrName) {
   };
 }
 async function switchProjectCommand(opts, ctx, target, displayName) {
-  const resolved = path25.resolve(ctx?.projectRoot ?? ctx?.cwd ?? process.cwd(), target);
+  const resolved = path26.resolve(ctx?.projectRoot ?? ctx?.cwd ?? process.cwd(), target);
   try {
-    await fs16.access(resolved);
+    await fs17.access(resolved);
   } catch {
     return { message: color47.red(`Directory not found: ${resolved}`) };
   }
-  const stat5 = await fs16.stat(resolved);
+  const stat5 = await fs17.stat(resolved);
   if (!stat5.isDirectory()) {
     return { message: color47.red(`Not a directory: ${resolved}`) };
   }
@@ -23776,9 +24442,9 @@ async function switchProjectCommand(opts, ctx, target, displayName) {
   try {
     const req = createRequire(import.meta.url);
     const pkgPath = req.resolve("@wrongstack/cli/package.json");
-    const pkgDir = path25.dirname(pkgPath);
-    cliPath = path25.join(pkgDir, "dist", "index.js");
-    await fs16.access(cliPath);
+    const pkgDir = path26.dirname(pkgPath);
+    cliPath = path26.join(pkgDir, "dist", "index.js");
+    await fs17.access(cliPath);
   } catch {
     cliPath = process.argv[1] ?? "";
     if (!cliPath) {
@@ -23794,13 +24460,13 @@ async function switchProjectCommand(opts, ctx, target, displayName) {
   if (existing) {
     existing.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
   } else {
-    const name = displayName?.trim() || path25.basename(resolved);
+    const name = displayName?.trim() || path26.basename(resolved);
     const slug = generateSlug(resolved);
     manifest.projects.push({ name, root: resolved, slug, lastSeen: (/* @__PURE__ */ new Date()).toISOString() });
     await ensureProjectDataDir(slug, opts.paths?.globalConfig);
   }
   await saveManifest(manifest, opts.paths?.globalConfig);
-  const targetName = displayName?.trim() || path25.basename(resolved);
+  const targetName = displayName?.trim() || path26.basename(resolved);
   const canSwitch = await confirmProjectSwitch(opts, targetName);
   if (!canSwitch) return { message: "" };
   const nodeExe = process.execPath;
@@ -23916,9 +24582,9 @@ async function spawnInProject(opts, _ctx, root, projectName) {
   try {
     const req = createRequire(import.meta.url);
     const pkgPath = req.resolve("@wrongstack/cli/package.json");
-    const pkgDir = path25.dirname(pkgPath);
-    cliPath = path25.join(pkgDir, "dist", "index.js");
-    await fs16.access(cliPath);
+    const pkgDir = path26.dirname(pkgPath);
+    cliPath = path26.join(pkgDir, "dist", "index.js");
+    await fs17.access(cliPath);
   } catch {
     cliPath = process.argv[1] ?? "";
     if (!cliPath) {
@@ -23934,7 +24600,7 @@ async function spawnInProject(opts, _ctx, root, projectName) {
   if (existing) {
     existing.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
   } else {
-    const name = projectName || path25.basename(root);
+    const name = projectName || path26.basename(root);
     const slug = generateSlug(root);
     manifest.projects.push({ name, root, slug, lastSeen: (/* @__PURE__ */ new Date()).toISOString() });
     await ensureProjectDataDir(slug, opts.paths?.globalConfig);
@@ -23966,9 +24632,9 @@ async function handleNewSession(_opts, _ctx) {
   try {
     const req = createRequire(import.meta.url);
     const pkgPath = req.resolve("@wrongstack/cli/package.json");
-    const pkgDir = path25.dirname(pkgPath);
-    cliPath = path25.join(pkgDir, "dist", "index.js");
-    await fs16.access(cliPath);
+    const pkgDir = path26.dirname(pkgPath);
+    cliPath = path26.join(pkgDir, "dist", "index.js");
+    await fs17.access(cliPath);
   } catch {
     cliPath = process.argv[1] ?? "";
     if (!cliPath) {
@@ -24028,9 +24694,9 @@ async function handlePrevSessions(opts, _ctx) {
 // src/slash-commands/review.ts
 import { spawn as spawn8 } from "node:child_process";
 import * as fsp3 from "node:fs/promises";
-import * as path26 from "node:path";
+import * as path27 from "node:path";
 async function runGit2(args, cwd) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const child = spawn8("git", args, {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
@@ -24041,8 +24707,8 @@ async function runGit2(args, cwd) {
     child.stdout?.on("data", (d) => {
       stdout += d;
     });
-    child.on("error", () => resolve7({ stdout, code: 1 }));
-    child.on("close", (code) => resolve7({ stdout, code: code ?? 0 }));
+    child.on("error", () => resolve8({ stdout, code: 1 }));
+    child.on("close", (code) => resolve8({ stdout, code: code ?? 0 }));
   });
 }
 async function getChangedFiles(cwd) {
@@ -24098,7 +24764,7 @@ function buildReviewCommand(opts) {
         if (f.path.startsWith(".wrongstack/")) continue;
         if (fileFilter && !f.path.toLowerCase().includes(fileFilter)) continue;
         try {
-          await fsp3.access(path26.join(cwd, f.path));
+          await fsp3.access(path27.join(cwd, f.path));
           existing.push(f);
         } catch {
         }
@@ -24112,7 +24778,7 @@ function buildReviewCommand(opts) {
       const filesWithContent = [];
       for (const f of existing.slice(0, limit)) {
         try {
-          const content = await fsp3.readFile(path26.join(cwd, f.path), "utf8");
+          const content = await fsp3.readFile(path27.join(cwd, f.path), "utf8");
           filesWithContent.push({ ...f, content });
         } catch {
         }
@@ -24354,7 +25020,7 @@ function buildSettingsCommand(opts) {
       `  auto-proceed max iters:     ${color48.cyan(String(au?.autoProceedMaxIterations ?? "unlimited"))}   ${color48.dim("change: /settings auto-proceed-max-iterations <n>")}`,
       `  title animation:            ${titleAnimation ? color48.cyan("on") : color48.dim("off")}   ${color48.dim("change: /settings title-animation on|off")}`,
       `  thinking word:              ${color48.cyan(au?.thinkingWord ?? "thinking")}   ${color48.dim("change: /settings thinking-word <word>")}`,
-      `  statusline mode:            ${color48.cyan(au?.statuslineMode ?? "detailed")}   ${color48.dim("change: /settings statusline minimum|detailed|no-color")}`,
+      `  statusline mode:            ${color48.cyan(au?.statuslineMode ?? "minimum")}   ${color48.dim("change: /settings statusline minimum|detailed|no-color")}`,
       `  animation style:            ${color48.cyan(au?.animationStyle ?? "rainbow")}   ${color48.dim("change: /settings animation rainbow|wave|pulse|dots|breathe|cycle")}`,
       `  read symbols:               ${au?.readAdvancedMode === true ? color48.cyan("on") : color48.dim("off")}   ${color48.dim("change: /settings read-symbols on|off")}`,
       `  reasoning mode:             ${color48.cyan(reasoningMode)}   ${color48.dim("change: /settings reasoning auto|on|off")}`,
@@ -25548,6 +26214,9 @@ function buildStatuslineCommand(deps) {
       "Available items:",
       ...ALL_CONFIG_KEYS.map((k) => `  ${k.padEnd(12)} ${ITEM_DESCRIPTIONS[k]}`),
       "",
+      "Density mode (minimum/detailed/no-color) is a separate setting \u2014 see /settings.",
+      "These toggles set chip eligibility in any mode; some chips only render in detailed mode.",
+      "",
       "Persistent across sessions (saved to ~/.wrongstack/profiles/<active>/statusline.json)."
     ].join("\n"),
     async run(args) {
@@ -26059,36 +26728,36 @@ ${formatTaskProgress(file.tasks)}`;
 }
 
 // src/slash-commands/techstack.ts
-import * as fs17 from "node:fs/promises";
-import * as path27 from "node:path";
+import * as fs18 from "node:fs/promises";
+import * as path28 from "node:path";
 import { color as color51 } from "@wrongstack/core/utils";
 import { toErrorMessage as toErrorMessage25 } from "@wrongstack/core/utils";
 async function discoverPackageFiles(projectRoot) {
   const files = [];
-  const rootPkg = path27.join(projectRoot, "package.json");
+  const rootPkg = path28.join(projectRoot, "package.json");
   try {
-    await fs17.access(rootPkg);
+    await fs18.access(rootPkg);
     files.push(rootPkg);
   } catch {
   }
-  const workspaceFile = path27.join(projectRoot, "pnpm-workspace.yaml");
+  const workspaceFile = path28.join(projectRoot, "pnpm-workspace.yaml");
   try {
-    await fs17.access(workspaceFile);
-    const content = await fs17.readFile(workspaceFile, "utf8");
+    await fs18.access(workspaceFile);
+    const content = await fs18.readFile(workspaceFile, "utf8");
     const globMatch = /packages?:\s*\[([^\]]+)\]/s.exec(content);
     const rawGlobs = globMatch?.[1];
     if (!rawGlobs) return files;
     const globs = rawGlobs.split(/[\s,]+/).filter(Boolean).map((g) => g.replace(/['"]/g, ""));
     for (const g of globs) {
       const dirPrefix = g.replace(/\/?\*$/, "").replace(/\/\*$/, "");
-      const dir = path27.join(projectRoot, dirPrefix);
+      const dir = path28.join(projectRoot, dirPrefix);
       try {
-        const entries = await fs17.readdir(dir, { withFileTypes: true });
+        const entries = await fs18.readdir(dir, { withFileTypes: true });
         for (const e of entries) {
           if (!e.isDirectory()) continue;
-          const subPkg = path27.join(dir, e.name, "package.json");
+          const subPkg = path28.join(dir, e.name, "package.json");
           try {
-            await fs17.access(subPkg);
+            await fs18.access(subPkg);
             files.push(subPkg);
           } catch {
           }
@@ -26101,7 +26770,7 @@ async function discoverPackageFiles(projectRoot) {
   return files;
 }
 function buildTechStackTask(opts) {
-  const pkgList = opts.packageFiles.map((f) => `  - ${path27.relative(opts.projectRoot, f)}`).join("\n");
+  const pkgList = opts.packageFiles.map((f) => `  - ${path28.relative(opts.projectRoot, f)}`).join("\n");
   const header = opts.isInit ? [
     "## Tech Stack Audit \u2014 First-Time Project Init",
     "",
@@ -27355,9 +28024,9 @@ ${lines.join("\n")}${extra}
 }
 
 // src/slash-commands/tuneup.ts
-import * as fs18 from "node:fs/promises";
+import * as fs19 from "node:fs/promises";
 import * as os3 from "node:os";
-import * as path28 from "node:path";
+import * as path29 from "node:path";
 import { atomicWrite as atomicWrite10, color as color56 } from "@wrongstack/core/utils";
 
 // src/tuneup.ts
@@ -27959,13 +28628,13 @@ async function gatherMemoryFiles(opts) {
   const candidates = [
     { label: "user memory", file: paths.globalMemory, committed: false },
     { label: "project AGENTS.md", file: paths.inProjectAgentsFile, committed: true },
-    { label: "root CLAUDE.md", file: path28.join(opts.projectRoot, "CLAUDE.md"), committed: true },
-    { label: "root AGENTS.md", file: path28.join(opts.projectRoot, "AGENTS.md"), committed: true }
+    { label: "root CLAUDE.md", file: path29.join(opts.projectRoot, "CLAUDE.md"), committed: true },
+    { label: "root AGENTS.md", file: path29.join(opts.projectRoot, "AGENTS.md"), committed: true }
   ];
   const out = [];
   for (const c of candidates) {
     try {
-      const content = await fs18.readFile(c.file, "utf8");
+      const content = await fs19.readFile(c.file, "utf8");
       out.push({ label: c.label, path: c.file, content, committed: c.committed });
     } catch {
     }
@@ -27983,7 +28652,7 @@ async function gatherTrust(opts) {
   const file = opts.paths?.projectTrust;
   if (!file) return void 0;
   try {
-    const raw = await fs18.readFile(file, "utf8");
+    const raw = await fs19.readFile(file, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object") return parsed;
   } catch {
@@ -27994,7 +28663,7 @@ async function gatherConfigIssues(opts) {
   if (!opts.paths) return 0;
   const file = activeProfileConfigPath(opts.paths, opts.configStore.get());
   try {
-    const raw = await fs18.readFile(file, "utf8");
+    const raw = await fs19.readFile(file, "utf8");
     const parsed = JSON.parse(raw);
     return diagnoseConfig(parsed).findings.length;
   } catch {
@@ -28012,14 +28681,14 @@ async function gatherSessionBytes(opts) {
 }
 async function dirSize(dir) {
   let total = 0;
-  const entries = await fs18.readdir(dir, { withFileTypes: true });
+  const entries = await fs19.readdir(dir, { withFileTypes: true });
   for (const e of entries) {
-    const full = path28.join(dir, e.name);
+    const full = path29.join(dir, e.name);
     if (e.isDirectory()) {
       total += await dirSize(full);
     } else if (e.isFile()) {
       try {
-        total += (await fs18.stat(full)).size;
+        total += (await fs19.stat(full)).size;
       } catch {
       }
     }
@@ -28032,7 +28701,7 @@ async function applyActions(actions, opts) {
   const file = activeProfileConfigPath(opts.paths, opts.configStore.get());
   let raw = "{}";
   try {
-    raw = await fs18.readFile(file, "utf8");
+    raw = await fs19.readFile(file, "utf8");
   } catch {
   }
   let parsed;
@@ -28084,7 +28753,7 @@ async function applyActions(actions, opts) {
   }
   await atomicWrite10(file, JSON.stringify(parsed, null, 2));
   try {
-    const homeFn = () => path28.dirname(path28.dirname(file));
+    const homeFn = () => path29.dirname(path29.dirname(file));
     await appendHistory(JSON.parse(raw), parsed, "tuneup auto-fix", homeFn, file);
   } catch {
   }
@@ -28188,8 +28857,8 @@ function summaryLine(findings, fixable, handoffs, power) {
 }
 
 // src/slash-commands/working-dir.ts
-import * as fs19 from "node:fs/promises";
-import * as path29 from "node:path";
+import * as fs20 from "node:fs/promises";
+import * as path30 from "node:path";
 import { color as color57 } from "@wrongstack/core/utils";
 import { toErrorMessage as toErrorMessage28 } from "@wrongstack/core/utils";
 function buildWorkingDirCommand(_opts) {
@@ -28214,7 +28883,7 @@ function buildWorkingDirCommand(_opts) {
       }
       const trimmed = args.trim();
       if (!trimmed) {
-        const rel2 = path29.relative(ctx.projectRoot, ctx.workingDir) || ".";
+        const rel2 = path30.relative(ctx.projectRoot, ctx.workingDir) || ".";
         return {
           message: [
             `Working directory: ${color57.bold(ctx.workingDir)}`,
@@ -28223,10 +28892,10 @@ function buildWorkingDirCommand(_opts) {
           ].join("\n")
         };
       }
-      const resolved = path29.isAbsolute(trimmed) ? path29.resolve(trimmed) : path29.resolve(ctx.projectRoot, trimmed);
-      const root = path29.resolve(ctx.projectRoot);
-      const rel = path29.relative(root, resolved);
-      if (rel.startsWith("..") || path29.isAbsolute(rel)) {
+      const resolved = path30.isAbsolute(trimmed) ? path30.resolve(trimmed) : path30.resolve(ctx.projectRoot, trimmed);
+      const root = path30.resolve(ctx.projectRoot);
+      const rel = path30.relative(root, resolved);
+      if (rel.startsWith("..") || path30.isAbsolute(rel)) {
         return {
           message: color57.red(
             `Directory "${trimmed}" is outside the project root.
@@ -28236,7 +28905,7 @@ function buildWorkingDirCommand(_opts) {
         };
       }
       try {
-        const stat5 = await fs19.stat(resolved);
+        const stat5 = await fs20.stat(resolved);
         if (!stat5.isDirectory()) {
           return { message: color57.red(`Not a directory: ${resolved}`) };
         }
@@ -28251,8 +28920,8 @@ function buildWorkingDirCommand(_opts) {
           message: color57.red(toErrorMessage28(err))
         };
       }
-      const prevRel = path29.relative(ctx.projectRoot, previous) || ".";
-      const newRel = path29.relative(ctx.projectRoot, resolved) || ".";
+      const prevRel = path30.relative(ctx.projectRoot, previous) || ".";
+      const newRel = path30.relative(ctx.projectRoot, resolved) || ".";
       return {
         message: [
           color57.green(`  \u2713 ${prevRel} \u2192 ${color57.bold(newRel)}`),
@@ -28566,7 +29235,7 @@ async function runInteractive(cliCtx) {
       globalInstructions: wpaths.globalInstructions,
       inProjectInstructions: wpaths.inProjectInstructions
     },
-    pathJoiner: { join: (a, b) => path30.join(a, b) },
+    pathJoiner: { join: (a, b) => path31.join(a, b) },
     systemPromptBuilderToken: TOKENS9.SystemPromptBuilder
   });
   const toolRegistry = new ToolRegistry2();
@@ -28644,7 +29313,7 @@ async function runInteractive(cliCtx) {
         sessionId,
         projectSlug: wpaths.projectSlug,
         projectRoot,
-        projectName: path30.basename(projectRoot),
+        projectName: path31.basename(projectRoot),
         workingDir: cwd,
         clientType: flags.webui || flags.simpleui ? "webui" : tuiOwnsScreen ? "tui" : "cli",
         pid: process.pid,
@@ -28653,13 +29322,20 @@ async function runInteractive(cliCtx) {
       return async () => sessionRegistry.unregister();
     }
   });
-  const session = sessResult.session;
+  const { context, planPath, session } = sessResult;
   sessionRef.current = session;
-  const context = sessResult.context;
+  const governanceHandle = await setupCliGovernance({
+    projectRoot,
+    projectId: wpaths.projectSlug,
+    sessionId: session.id,
+    contextMeta: context.meta,
+    logger,
+    events,
+    planPath,
+    captureWorkspaceCheckpoint: async () => sessionStore.captureWorkspaceCheckpoint?.(session.id, 0)
+  });
   configureSimpleUiRuntimeContext(context.meta, flags);
-  const attachments = sessResult.attachments;
-  const queueStore = sessResult.queueStore;
-  const planPath = sessResult.planPath;
+  const { attachments, queueStore } = sessResult;
   const detachTodosCheckpoint = sessResult.detachTodosCheckpoint;
   const priorFleetState = sessResult.priorFleetState;
   memoryStore.withTraceId(sessResult.traceId);
@@ -28713,6 +29389,7 @@ async function runInteractive(cliCtx) {
       }
     }
   });
+  governanceHandle?.installToolBoundary(pipelines);
   const {
     autoCompactor,
     effectiveMaxContextRef,
@@ -28865,7 +29542,8 @@ async function runInteractive(cliCtx) {
     mcpRegistry,
     sessResult,
     modeId,
-    statusTracker
+    statusTracker,
+    ...governanceHandle ? { installToolBoundary: governanceHandle.installToolBoundary } : {}
   });
   const { hqCommandController } = setupHqTelemetry({
     events,
@@ -29128,7 +29806,7 @@ async function runInteractive(cliCtx) {
     onEvent: evOn
   });
   const savedProviderCfg = config.providers?.[config.provider];
-  const { execute } = await import("./execution-A4PGK4XV.js");
+  const { execute } = await import("./execution-HJ643JGZ.js");
   const stopHeapWatchdog = startSharedHeapWatchdog({
     collectStats: () => {
       const hqQueue = hqPublisherRef.current?.getQueueStats();
@@ -29346,10 +30024,18 @@ async function runInteractive(cliCtx) {
         logger
       })
     })
-  ).finally(() => memoryStore.dispose());
+  ).finally(async () => {
+    const governanceCleanup = await governanceHandle?.close();
+    if (governanceCleanup && !governanceCleanup.ok) {
+      logger.warn(`governance: ${governanceCleanup.action} cleanup failed`, {
+        message: governanceCleanup.message
+      });
+    }
+    memoryStore.dispose();
+  });
 }
 export {
   CLI_VERSION,
   runInteractive
 };
-//# sourceMappingURL=cli-main-GOY5YGVL.js.map
+//# sourceMappingURL=cli-main-7QLL2PY6.js.map