@wrongstack/cli 0.295.1 → 0.296.3

package/dist/execution-O7I5DYE6.js

@@ -0,0 +1,4682 @@
+import {
+  deriveFsAccessPair,
+  filterSafeForProject,
+  getSuggestions,
+  normalizeTuiThinkingWord,
+  resolveActualTarget,
+  resolvePersistPath,
+  setAutoSuggestions,
+  setSuggestions
+} from "./chunk-Z7YGASQP.js";
+import {
+  startCliHqConnection
+} from "./chunk-WY7KKOUK.js";
+import "./chunk-WHOIR577.js";
+import {
+  advanceToNextTask,
+  autoDetectTaskCompletion,
+  getActiveSDDContext,
+  getActiveSDDPhase,
+  getCurrentExecutingContext,
+  getTaskListText,
+  getTaskProgress,
+  renderTaskListWithProgress,
+  trySaveImplementationPlan,
+  trySaveSpecFromAIOutput,
+  trySaveTasksFromAIOutput
+} from "./chunk-BQCAJ7FI.js";
+import {
+  theme
+} from "./chunk-QD544J2B.js";
+import {
+  fmtTok
+} from "./chunk-TYO2OVAD.js";
+import {
+  CLI_VERSION
+} from "./chunk-XJXDOF63.js";
+import {
+  resolveActiveApiKey
+} from "./chunk-PJHET45A.js";
+import "./chunk-7OCVIDC7.js";
+
+// src/execution.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+import * as path10 from "node:path";
+import { setQueuedMessagesSnapshot as setQueuedMessagesSnapshot2 } from "@wrongstack/core/agent";
+import { isMailboxLeader } from "@wrongstack/core/coordination";
+import {
+  CHIMERA_REVIEW_PROMPT
+} from "@wrongstack/core/plugin";
+import { attachTodosCheckpoint as attachTodosCheckpoint2 } from "@wrongstack/core/storage";
+import {
+  normalizeTokenSavingTier as normalizeTokenSavingTier2
+} from "@wrongstack/core/types";
+import { mergeCustomModelDefs } from "@wrongstack/core/utils";
+import { capabilitiesFor } from "@wrongstack/providers";
+import { createToolVisionAdapters } from "@wrongstack/runtime/vision";
+
+// src/boot/dispatch-singleshot.ts
+import { color, writeOut } from "@wrongstack/core/utils";
+
+// src/context-overflow-diagnostic.ts
+import { ERROR_CODES } from "@wrongstack/core/types";
+var CONTEXT_OVERFLOW_RE = /context window|exceeds the context|too many tokens|context.*tokens/i;
+function contextOverflowHint(err) {
+  const structured = err.code === ERROR_CODES.PROVIDER_CONTEXT_OVERFLOW || err.code === ERROR_CODES.AGENT_CONTEXT_OVERFLOW;
+  const textual = CONTEXT_OVERFLOW_RE.test(`${err.message}
+${err.describe()}`);
+  if (!structured && !textual) return null;
+  return [
+    "Provider rejected the request as over its effective context window.",
+    "If you use a custom baseUrl/proxy, the real limit may be lower than models.dev reports.",
+    "Try: /context limit 220k",
+    "Then, if needed: /context thresholds 50% 70% 85%",
+    "Persistent config: set context.effectiveMaxContext."
+  ].join("\n");
+}
+
+// src/boot/dispatch-singleshot.ts
+async function runSingleShotDispatch(ctx) {
+  const { agent, query, flags, tokenCounter, renderer } = ctx;
+  const ctrl = new AbortController();
+  const onSigint = () => ctrl.abort();
+  process.on("SIGINT", onSigint);
+  const startedAt = Date.now();
+  const before = tokenCounter.total();
+  const costBefore = tokenCounter.estimateCost().total;
+  let result;
+  try {
+    result = await agent.run(query, { signal: ctrl.signal });
+  } finally {
+    process.off("SIGINT", onSigint);
+    const { getProcessRegistry: getProcessRegistry2 } = await import("@wrongstack/tools");
+    getProcessRegistry2().killAll({ preserveBackground: true });
+  }
+  const after = tokenCounter.total();
+  const costAfter = tokenCounter.estimateCost().total;
+  const usage = {
+    input: after.input - before.input,
+    output: after.output - before.output,
+    iterations: result.iterations,
+    cost: costAfter - costBefore,
+    elapsedMs: Date.now() - startedAt
+  };
+  if (flags["output-json"]) {
+    const json = JSON.stringify({
+      status: result.status,
+      finalText: result.finalText ?? null,
+      error: result.error ? {
+        code: result.error.code,
+        subsystem: result.error.subsystem,
+        severity: result.error.severity,
+        recoverable: result.error.recoverable,
+        message: result.error.message,
+        context: result.error.context ?? null
+      } : null,
+      usage
+    });
+    writeOut(json + "\n");
+    return 0;
+  }
+  let code = 0;
+  if (result.status === "failed") {
+    code = 1;
+    const err = result.error;
+    if (err) {
+      const tag = err.recoverable ? " (recoverable)" : "";
+      renderer.writeError(`Failed [${err.severity}]${tag}: ${err.describe()}`);
+      const hint = contextOverflowHint(err);
+      if (hint) renderer.writeWarning(hint);
+    } else {
+      renderer.writeError("Failed.");
+    }
+  } else if (result.status === "aborted") {
+    code = 130;
+    renderer.writeWarning("Aborted.");
+  } else if (result.status === "max_iterations") {
+    code = 1;
+    renderer.writeWarning(`Hit max iterations (${result.iterations}).`);
+  }
+  if (result.finalText) renderer.write("\n" + result.finalText + "\n");
+  const r = result;
+  renderer.writeDelegateSummaries(r);
+  renderer.write(
+    "\n" + color.dim(
+      `[in: ${fmtTok(usage.input)}  out: ${fmtTok(usage.output)}  iters: ${usage.iterations}  cost: ${usage.cost.toFixed(4)}  ${(usage.elapsedMs / 1e3).toFixed(1)}s]`
+    ) + "\n"
+  );
+  return code;
+}
+
+// src/boot/dispatch-tui.ts
+async function runTuiDispatch(options) {
+  const { runTui } = await import("@wrongstack/tui");
+  return runTui(options);
+}
+
+// src/boot/dispatch-webui.ts
+import { color as color2 } from "@wrongstack/core/utils";
+async function runWebUIDispatch(ctx) {
+  const {
+    agent,
+    events,
+    statusTracker,
+    session,
+    config,
+    flags,
+    projectRoot,
+    globalConfigPath,
+    projectSessionsDir,
+    modelsRegistry,
+    mcpRegistry,
+    brain,
+    brainSettings,
+    brainRuntime,
+    getBrainLog,
+    subscribeEternalIteration,
+    sessionStore,
+    memoryStore,
+    skillLoader,
+    promptLoader,
+    modeStore,
+    modeId,
+    needsSetup,
+    renderer,
+    onAutonomy,
+    applyLiveSettings,
+    onModelContextResolved,
+    activateSessionIdentity,
+    rebindTodosCheckpoint,
+    agentTranscripts,
+    sddSubagentFactory,
+    onKanbanDispatch
+  } = ctx;
+  const isSimpleUi = flags["simpleui"] === true;
+  agent.disableInteractiveConfirmation();
+  renderer.setSilent(true);
+  const { runWebUI } = await import("./webui-server-ZF5KVGC5.js");
+  const flagValue = (names) => {
+    for (const name of names) {
+      if (!Object.hasOwn(flags, name)) continue;
+      const value = flags[name];
+      if (typeof value === "string" && value.trim() !== "") return value.trim();
+      throw new Error(`--${name} requires a value`);
+    }
+    return void 0;
+  };
+  const flagBoolean = (names) => {
+    for (const name of names) {
+      if (!Object.hasOwn(flags, name)) continue;
+      const value = flags[name];
+      if (value === void 0) continue;
+      if (typeof value === "boolean") return value;
+      const normalized = value.trim().toLowerCase();
+      if (["1", "true", "yes", "on"].includes(normalized)) return true;
+      if (["0", "false", "no", "off"].includes(normalized)) return false;
+      throw new Error(`--${name} must be a boolean value`);
+    }
+    return void 0;
+  };
+  const envFlag = (name) => {
+    const value = process.env[name]?.trim().toLowerCase();
+    return value === "1" || value === "true" || value === "yes" || value === "on";
+  };
+  const parsePort = (value, fallback, label) => {
+    if (value === void 0) return fallback;
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isInteger(parsed) || parsed <= 0 || parsed > 65535) {
+      throw new Error(`${label} must be a port between 1 and 65535`);
+    }
+    return parsed;
+  };
+  let webuiHost;
+  let webuiPort;
+  let webuiAccessToken;
+  let webuiPublicUrl;
+  let webuiPublicWsUrl;
+  let webuiRequireToken;
+  let frontendDistDir;
+  try {
+    webuiHost = flagValue(["webui-host", "host"]) ?? process.env["WEBUI_HOST"] ?? process.env["WS_HOST"] ?? "127.0.0.1";
+    const defaultPort = isSimpleUi ? 3466 : 3456;
+    webuiPort = parsePort(
+      flagValue(["webui-port", "http-port", "port", "ws-port"]) ?? process.env["WEBUI_PORT"] ?? process.env["PORT"] ?? process.env["WS_PORT"],
+      defaultPort,
+      "--port"
+    );
+    webuiAccessToken = flagValue(["webui-token"]) ?? process.env["WEBUI_TOKEN"] ?? process.env["WEBUI_AUTH_TOKEN"];
+    webuiPublicUrl = flagValue(["webui-public-url", "public-url"]) ?? process.env["WEBUI_PUBLIC_URL"];
+    webuiPublicWsUrl = flagValue(["webui-public-ws-url", "public-ws-url"]) ?? process.env["WEBUI_PUBLIC_WS_URL"];
+    webuiRequireToken = flagBoolean(["webui-require-token", "require-token"]) ?? envFlag("WEBUI_REQUIRE_TOKEN");
+    if (isSimpleUi) {
+      const { ensureSimpleUiDistDir } = await import("./simpleui-dist-JIFGUJO7.js");
+      frontendDistDir = await ensureSimpleUiDistDir();
+    }
+  } catch (err) {
+    renderer.setSilent(false);
+    renderer.writeInfo(color2.red(`  ${err instanceof Error ? err.message : String(err)}`));
+    return 1;
+  }
+  const webuiPromise = runWebUI({
+    agent,
+    events,
+    statusTracker,
+    session,
+    surface: isSimpleUi ? "simpleui" : "webui",
+    host: webuiHost,
+    port: webuiPort,
+    frontendDistDir,
+    accessToken: webuiAccessToken,
+    publicUrl: webuiPublicUrl,
+    publicWsUrl: webuiPublicWsUrl,
+    requireToken: webuiRequireToken,
+    projectRoot,
+    appConfig: config,
+    open: !!flags.open,
+    agentTranscripts,
+    hqAllowExec: flagBoolean(["hq-allow-exec"]) ?? false,
+    modelsRegistry,
+    globalConfigPath,
+    profileConfigPath: ctx.profileConfigPath,
+    mcpRegistry,
+    subscribeEternalIteration,
+    sessionStore,
+    sessionsDir: projectSessionsDir,
+    claimSession: activateSessionIdentity ? async (sessionId) => {
+      const previousSessionId = agent.ctx.session?.id ?? session.id;
+      await activateSessionIdentity(sessionId);
+      return async () => activateSessionIdentity(previousSessionId);
+    } : void 0,
+    brain,
+    brainSettings,
+    brainRuntime,
+    getBrainLog,
+    onBeforeSessionTodosReplaced: (sessionId, sessionsDir) => rebindTodosCheckpoint?.(sessionId, sessionsDir),
+    onSessionSwapped: async (sessionId, target) => {
+      if (target && activateSessionIdentity) {
+        await activateSessionIdentity(sessionId, target);
+      }
+      void import("@wrongstack/tools/session-kanban").then(
+        ({ hydrateSessionKanban }) => hydrateSessionKanban(agent.ctx)
+      );
+    },
+    onModelContextResolved,
+    memoryStore,
+    skillLoader,
+    promptLoader,
+    modeStore,
+    modeId,
+    needsSetup,
+    sddSubagentFactory,
+    onKanbanDispatch,
+    // Print the "open this" banner only once the server is actually
+    // listening, using the RESOLVED port. Requested ports auto-advance past
+    // busy ports inside runWebUI, so a banner printed up-front lies whenever
+    // the default when it is taken (a second instance, leftover socket).
+    onListening: ({ url }) => {
+      const surface = isSimpleUi ? "SimpleUI" : "WebUI";
+      renderer.writeInfo(color2.green(`  \u2726 ${surface} running \u2192 ${color2.bold(url)}`));
+      renderer.writeInfo(
+        color2.dim(`  Press Ctrl+C in this terminal to stop the ${surface} server.
+`)
+      );
+    },
+    // Make autonomy.switch from the browser flip the CLI's real
+    // autonomy mode — context.meta alone never reaches the run loop.
+    onAutonomySwitch: (mode) => {
+      if (mode === "off" || mode === "suggest" || mode === "auto" || mode === "eternal" || mode === "eternal-parallel") {
+        onAutonomy?.(mode);
+      }
+    },
+    onYoloSwitch: (enabled) => {
+      applyLiveSettings?.({ yolo: enabled });
+    }
+  });
+  const webuiExit = new Promise((resolve3) => {
+    webuiPromise.then(() => {
+      renderer.setSilent(false);
+      renderer.write("\n");
+      renderer.writeInfo(
+        color2.yellow(`  Shutting down ${isSimpleUi ? "SimpleUI" : "WebUI"} server\u2026`)
+      );
+      resolve3(0);
+    }).catch((err) => {
+      renderer.setSilent(false);
+      console.debug(`[execution] webui error: ${err}`);
+      resolve3(1);
+    });
+  });
+  return webuiExit;
+}
+
+// src/boot/execution-mode.ts
+function resolveExecutionMode(positional, flags) {
+  const prompt = typeof flags["prompt"] === "string" ? flags["prompt"] : "";
+  if (positional.length > 0 || prompt.length > 0) return "single-shot";
+  if (flags.tui && flags["no-tui"] !== true && !flags.webui) return "tui";
+  if (flags.webui) return "webui";
+  return "repl";
+}
+
+// src/boot/tui-coordinator-callbacks.ts
+function createTuiCoordinatorCallbacks({
+  state,
+  context,
+  coordinatorEvents,
+  ensureAutonomousCoordinator
+}) {
+  return {
+    getAutonomousCoordinator: () => ensureAutonomousCoordinator(),
+    subscribeCoordinatorEvents: (fn) => {
+      coordinatorEvents.add(fn);
+      return () => {
+        coordinatorEvents.delete(fn);
+      };
+    },
+    onCoordinatorStart: (goal) => {
+      const coordinator = ensureAutonomousCoordinator();
+      if (!coordinator) {
+        console.error(
+          JSON.stringify({
+            level: "error",
+            event: "coordinator.not_ready",
+            message: "no director available",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          })
+        );
+        return;
+      }
+      if (state.coordinatorRun) return;
+      state.coordinatorRun = coordinator.run({ goal: goal ?? "Improve the codebase", runUntilComplete: true }).then(() => void 0).catch((err) => {
+        console.error(
+          JSON.stringify({
+            level: "error",
+            event: "coordinator.run_failed",
+            message: err instanceof Error ? err.message : String(err),
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          })
+        );
+      }).finally(() => {
+        state.coordinatorRun = null;
+      });
+    },
+    onCoordinatorStop: () => {
+      state.autonomousCoordinator?.stop();
+    },
+    onCoordinatorTasks: async () => {
+      const coordinator = ensureAutonomousCoordinator();
+      if (!coordinator) return null;
+      await coordinator.graph.load();
+      return coordinator.auction.getPendingTasks().map((task) => ({
+        id: task.id,
+        title: task.title,
+        priority: task.priority,
+        tags: task.tags
+      }));
+    },
+    onCoordinatorClaim: async (taskId) => {
+      const coordinator = ensureAutonomousCoordinator();
+      if (!coordinator) return "No coordinator is active.";
+      await coordinator.graph.load();
+      const goal = coordinator.graph.get(taskId);
+      if (goal?.type !== "goal") {
+        return `Task ${taskId.slice(0, 8)} not found in the coordinator graph.`;
+      }
+      if (goal.status !== "pending") {
+        return `Task ${taskId.slice(0, 8)} is ${goal.status}, not claimable.`;
+      }
+      const ok = await coordinator.auction.claim(
+        taskId,
+        `terminal@${context.session.id ?? "unknown"}`,
+        "Terminal worker"
+      );
+      if (!ok) {
+        return `Task ${taskId.slice(0, 8)} could not be claimed (status changed?).`;
+      }
+      return { description: goal.description };
+    },
+    onCoordinatorComplete: async (taskId, result) => {
+      const coordinator = ensureAutonomousCoordinator();
+      if (!coordinator) return "No coordinator is active.";
+      await coordinator.graph.load();
+      const goal = coordinator.graph.get(taskId);
+      if (goal?.type !== "goal") {
+        return `Task ${taskId.slice(0, 8)} not found in the coordinator graph.`;
+      }
+      if (goal.status !== "in_progress") {
+        return `Task ${taskId.slice(0, 8)} is ${goal.status}, cannot complete.`;
+      }
+      await coordinator.reportTaskCompletion(
+        taskId,
+        result ?? "Terminal worker completed the task"
+      );
+      return null;
+    },
+    onCoordinatorFail: async (taskId, error) => {
+      const coordinator = ensureAutonomousCoordinator();
+      if (!coordinator) return "No coordinator is active.";
+      await coordinator.graph.load();
+      const goal = coordinator.graph.get(taskId);
+      if (goal?.type !== "goal") {
+        return `Task ${taskId.slice(0, 8)} not found in the coordinator graph.`;
+      }
+      if (goal.status !== "in_progress") {
+        return `Task ${taskId.slice(0, 8)} is ${goal.status}, cannot fail.`;
+      }
+      await coordinator.reportTaskFailure(taskId, error);
+      return null;
+    },
+    onCoordinatorStatus: async () => {
+      const coordinator = ensureAutonomousCoordinator();
+      if (!coordinator) return null;
+      await coordinator.syncFromGraph();
+      const stats = coordinator.getStats();
+      return {
+        goals: {
+          total: stats.goals.total,
+          done: stats.goals.done,
+          pending: stats.goals.pending,
+          failed: stats.goals.failed
+        },
+        dag: {
+          running: stats.dag.running,
+          ready: stats.dag.ready,
+          done: stats.dag.done,
+          failed: stats.dag.failed
+        },
+        auction: {
+          pending: stats.auction.pending,
+          inProgress: stats.auction.in_progress
+        }
+      };
+    }
+  };
+}
+
+// src/boot/tui-coordinator-setup.ts
+import * as path from "node:path";
+import { AutonomousCoordinator } from "@wrongstack/core/coordination";
+function setupAutonomousCoordinator(ctx) {
+  const { state, events, context, wpaths, mailbox, director, getDirector, coordinatorController, onCoordinatorStopSetter } = ctx;
+  const ensure = () => {
+    if (state.autonomousCoordinator) return state.autonomousCoordinator;
+    const currentDirector = getDirector?.() ?? director;
+    if (!currentDirector) return null;
+    const transcript = context.session.transcriptPath;
+    const sessionDir = transcript ? path.dirname(transcript) : wpaths.projectDir;
+    const llmProvider = {
+      decide: async (prompt) => {
+        const sysPrompt = [
+          {
+            type: "text",
+            text: 'You are the autonomous brain of a multi-agent coordination system. Pick the best option for the decision described and reply with JSON: {"optionId":"<id>","rationale":"<short why>"}.'
+          }
+        ];
+        const userPrompt = {
+          type: "text",
+          text: `Decision: ${prompt.question}
+
+Context: ${JSON.stringify(prompt.context)}
+
+Options:
+${prompt.options.map((o, i) => `  ${i + 1}. [${o.id}] ${o.label}${o.consequence ? ` \u2014 ${o.consequence}` : ""}`).join("\n")}
+
+Risk: ${prompt.risk}
+
+Reply with ONLY the JSON object.`
+        };
+        const resp = await context.provider.complete(
+          {
+            model: context.model,
+            system: sysPrompt,
+            messages: [
+              {
+                role: "user",
+                content: [userPrompt]
+              }
+            ],
+            maxTokens: 1024,
+            temperature: 0
+          },
+          { signal: context.signal }
+        );
+        const text = resp.content.filter((b) => b.type === "text").map((b) => b.text).join("\n").trim();
+        const cleaned = text.replace(/^```(?:json)?\s*/i, "").replace(/```$/, "").trim();
+        try {
+          const parsed = JSON.parse(cleaned);
+          const optId = parsed.optionId ?? prompt.options[0]?.id ?? "";
+          return { optionId: optId, rationale: parsed.rationale ?? "" };
+        } catch {
+          return { optionId: prompt.options[0]?.id ?? "", rationale: text };
+        }
+      }
+    };
+    state.autonomousCoordinator = new AutonomousCoordinator({
+      sessionDir,
+      fleet: currentDirector.fleet,
+      fleetManager: currentDirector.fleetManager,
+      director: currentDirector,
+      mailbox,
+      selfAgentId: `leader@${context.session.id ?? "unknown"}`,
+      selfAgentName: "Leader",
+      llmProvider,
+      onCoordinatorEvent: (event) => {
+        for (const fn of state.coordinatorEvents) fn(event);
+      }
+    });
+    onCoordinatorStopSetter(() => state.autonomousCoordinator?.dispose());
+    if (coordinatorController) {
+      coordinatorController["onCoordinatorStart"] = (goal) => {
+        const coordinator = state.autonomousCoordinator;
+        if (!coordinator) return;
+        coordinator.run({ goal: goal ?? "Improve the codebase", runUntilComplete: true }).then(() => void 0).catch(
+          (err) => console.error(
+            JSON.stringify({
+              level: "error",
+              event: "coordinator.run_failed",
+              message: err instanceof Error ? err.message : String(err),
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            })
+          )
+        );
+      };
+      coordinatorController["onCoordinatorStop"] = () => state.autonomousCoordinator?.stop();
+      coordinatorController["onCoordinatorTasks"] = async () => {
+        if (!state.autonomousCoordinator) return null;
+        await state.autonomousCoordinator.graph.load();
+        return state.autonomousCoordinator.auction.getPendingTasks().map((task) => ({ id: task.id, title: task.title, priority: task.priority, tags: task.tags }));
+      };
+      coordinatorController["onCoordinatorClaim"] = async (taskId) => {
+        if (!state.autonomousCoordinator) return "No coordinator is active.";
+        await state.autonomousCoordinator.graph.load();
+        const goal = state.autonomousCoordinator.graph.get(taskId);
+        if (goal?.type !== "goal") return `Task ${taskId.slice(0, 8)} not found.`;
+        if (goal.status !== "pending") return `Task ${taskId.slice(0, 8)} is ${goal.status}, not claimable.`;
+        const ok = await state.autonomousCoordinator.auction.claim(
+          taskId,
+          `terminal@${context.session.id ?? "unknown"}`,
+          "Terminal worker"
+        );
+        if (!ok) return `Task ${taskId.slice(0, 8)} could not be claimed.`;
+        return { description: goal.description };
+      };
+      coordinatorController["onCoordinatorComplete"] = async (taskId, result) => {
+        if (!state.autonomousCoordinator) return "No coordinator is active.";
+        await state.autonomousCoordinator.graph.load();
+        const goal = state.autonomousCoordinator.graph.get(taskId);
+        if (goal?.type !== "goal") return `Task ${taskId.slice(0, 8)} not found.`;
+        if (goal.status !== "in_progress") return `Task ${taskId.slice(0, 8)} is ${goal.status}, cannot complete.`;
+        await state.autonomousCoordinator.reportTaskCompletion(taskId, result ?? "Terminal worker completed the task");
+        return null;
+      };
+      coordinatorController["onCoordinatorFail"] = async (taskId, error) => {
+        if (!state.autonomousCoordinator) return "No coordinator is active.";
+        await state.autonomousCoordinator.graph.load();
+        const goal = state.autonomousCoordinator.graph.get(taskId);
+        if (goal?.type !== "goal") return `Task ${taskId.slice(0, 8)} not found.`;
+        if (goal.status !== "in_progress") return `Task ${taskId.slice(0, 8)} is ${goal.status}, cannot fail.`;
+        await state.autonomousCoordinator.reportTaskFailure(taskId, error);
+        return null;
+      };
+      coordinatorController["onCoordinatorStatus"] = async () => {
+        if (!state.autonomousCoordinator) return null;
+        await state.autonomousCoordinator.syncFromGraph();
+        const stats = state.autonomousCoordinator.getStats();
+        return {
+          goals: { total: stats.goals.total, done: stats.goals.done, pending: stats.goals.pending, failed: stats.goals.failed },
+          dag: { running: stats.dag.running, ready: stats.dag.ready, done: stats.dag.done, failed: stats.dag.failed },
+          auction: { pending: stats.auction.pending, inProgress: stats.auction.in_progress }
+        };
+      };
+    }
+    return state.autonomousCoordinator;
+  };
+  if (director) ensure();
+  const offDirectorSpawned = events.onPattern("subagent.spawned", () => {
+    if (ensure()) offDirectorSpawned();
+  });
+  return {
+    ensure,
+    cleanup: () => offDirectorSpawned()
+  };
+}
+
+// src/boot/tui-debug-stream.ts
+async function registerDebugStreamCallback(cb) {
+  try {
+    const { setDebugStreamCallback } = await import("@wrongstack/providers");
+    setDebugStreamCallback(cb);
+  } catch (err) {
+    console.error(
+      JSON.stringify({
+        level: "error",
+        event: "execution.debug_stream_register_failed",
+        message: err instanceof Error ? err.message : String(err),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+  }
+}
+async function restoreDebugStreamCallback() {
+  try {
+    const { setDebugStreamCallback, defaultDebugStreamCallback } = await import("@wrongstack/providers");
+    setDebugStreamCallback(defaultDebugStreamCallback);
+  } catch (err) {
+    console.error(
+      JSON.stringify({
+        level: "error",
+        event: "execution.debug_stream_restore_failed",
+        message: err instanceof Error ? err.message : String(err),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+  }
+}
+
+// src/boot/tui-goal-wiring.ts
+import { PHASE_EVENT_NAMES } from "@wrongstack/core/goal";
+var GOAL_EVENTS = [
+  ...PHASE_EVENT_NAMES,
+  // Extra events not in PhaseEventMap (sourced from other subsystems)
+  "sdd.board.snapshot",
+  "worktree.allocated",
+  "worktree.committed",
+  "worktree.merged",
+  "worktree.conflict",
+  "worktree.released",
+  "worktree.failed",
+  "countdown.tick"
+];
+function wireGoal(events) {
+  const handlers = /* @__PURE__ */ new Map();
+  const onUntyped = events.on.bind(events);
+  const offUntyped = events.off.bind(events);
+  const subscribe = (handler) => {
+    const registrations = [];
+    for (const ev of GOAL_EVENTS) {
+      const h = (p) => handler(ev, p);
+      handlers.set(ev, h);
+      onUntyped(ev, h);
+      registrations.push(() => offUntyped(ev, h));
+    }
+    return () => {
+      for (const unregister of registrations) unregister();
+      handlers.clear();
+    };
+  };
+  const cleanup = () => {
+    for (const [ev, h] of handlers) {
+      offUntyped(ev, h);
+    }
+    handlers.clear();
+  };
+  return { subscribe, cleanup };
+}
+
+// src/boot/tui-live-sessions.ts
+import * as path2 from "node:path";
+async function getLiveSessions(ctx) {
+  const { SessionRegistry } = await import("@wrongstack/core/storage");
+  const globalRoot = path2.dirname(ctx.state.wpaths.globalConfig);
+  const registry = new SessionRegistry(globalRoot);
+  const sessions = await registry.list();
+  return sessions.filter((s) => s.status !== "stale").map((s) => ({
+    sessionId: s.sessionId,
+    projectName: s.projectName,
+    projectSlug: s.projectSlug,
+    projectRoot: s.projectRoot,
+    workingDir: s.workingDir,
+    gitBranch: s.gitBranch,
+    status: s.status,
+    pid: s.pid,
+    startedAt: s.startedAt,
+    agentCount: s.agentCount,
+    agents: s.agents.map((a) => ({
+      id: a.id,
+      name: a.name,
+      status: a.status,
+      currentTool: a.currentTool,
+      iterations: a.iterations,
+      toolCalls: a.toolCalls,
+      lastActivityAt: a.lastActivityAt
+    }))
+  }));
+}
+function onSwitchToSession(ctx, _sessionId, targetRoot, projectName) {
+  ctx.state.pendingProjectSwitch = { root: targetRoot, name: projectName };
+}
+
+// src/boot/tui-project-picker-callback.ts
+import * as path3 from "node:path";
+import { color as color3 } from "@wrongstack/core/utils";
+async function getProjectPickerItems(ctx) {
+  const { buildPickerItems } = await import("./project-picker-BOCWHBXP.js");
+  return buildPickerItems({
+    globalConfigPath: ctx.state.wpaths.globalConfig,
+    currentProjectRoot: ctx.state.projectRoot
+  });
+}
+async function onProjectSelect(ctx, slug, kind) {
+  const { state, renderer, director, getEternalEngine, getParallelEngine, switchProjectInPlace: switchProjectInPlace2 } = ctx;
+  try {
+    if (kind === "action") {
+      if (slug === "new-session") {
+        const name = path3.basename(state.projectRoot) || state.projectRoot;
+        const err2 = await switchProjectInPlace2(state.projectRoot, name);
+        if (err2) renderer.write(color3.red(`Project switch failed: ${err2}
+`));
+      }
+      return;
+    }
+    const { loadManifest, saveManifest } = await import("./project-manifest-GE25PW4S.js");
+    const manifest = await loadManifest(state.wpaths.globalConfig);
+    const project = manifest.projects.find((p) => p.slug === slug);
+    if (!project) return;
+    const targetRoot = path3.resolve(project.root);
+    if (path3.resolve(state.projectRoot) === targetRoot) return;
+    const fleetStatus = director?.status();
+    const fleetRunning = fleetStatus?.subagents.filter((a) => a.status === "running").length ?? 0;
+    const eternalActive = getEternalEngine?.()?.currentState === "running";
+    const parallelActive = getParallelEngine?.()?.currentState === "running";
+    const hasActiveAgents = fleetRunning > 0 || eternalActive || parallelActive;
+    if (hasActiveAgents) {
+      const parts = [
+        color3.yellow("\u26A0  Switching project in place; active background work is still tied to the previous project:")
+      ];
+      if (fleetRunning > 0) parts.push(color3.dim(`  \u2022 ${fleetRunning} subagent(s) currently running`));
+      if (eternalActive) parts.push(color3.dim("  \u2022 Eternal engine is active"));
+      if (parallelActive) parts.push(color3.dim("  \u2022 Parallel engine is active"));
+      parts.push("");
+      parts.push(color3.dim(`  New project: ${project.name}`));
+      renderer.write(`
+${parts.join("\n")}
+`);
+    }
+    project.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
+    await saveManifest(manifest, state.wpaths.globalConfig);
+    const err = await switchProjectInPlace2(targetRoot, project.name);
+    if (err) renderer.write(color3.red(`Project switch failed: ${err}
+`));
+  } catch (err) {
+    renderer.write(
+      color3.red(
+        `Project switch failed: ${err instanceof Error ? err.message : String(err)}
+`
+      )
+    );
+  }
+}
+
+// src/boot/tui-project-spawn.ts
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import * as fs from "node:fs/promises";
+import * as path4 from "node:path";
+import { color as color4 } from "@wrongstack/core/utils";
+async function handleProjectSwitchSpawn(opts) {
+  const PROJECT_SWITCH_EXIT_CODE = 42;
+  if (opts.code !== PROJECT_SWITCH_EXIT_CODE || !opts.pendingProjectSwitch) {
+    return null;
+  }
+  const { root, name, resumeSessionId } = opts.pendingProjectSwitch;
+  process.stdout.write("\x1B[2J\x1B[H");
+  let cliPath;
+  try {
+    const req = createRequire(import.meta.url);
+    const pkgPath = req.resolve("@wrongstack/cli/package.json");
+    const pkgDir = path4.dirname(pkgPath);
+    cliPath = path4.join(pkgDir, "dist", "index.js");
+    await fs.access(cliPath);
+  } catch {
+    cliPath = process.argv[1] ?? "";
+    if (!cliPath) {
+      console.error(color4.red("Could not locate the CLI entry point.\n"));
+      return 1;
+    }
+  }
+  const nodeExe = process.execPath;
+  const spawnArgs = [cliPath, "--no-interactive"];
+  if (resumeSessionId) spawnArgs.push("--resume", resumeSessionId);
+  spawn(nodeExe, spawnArgs, {
+    cwd: root,
+    stdio: "ignore",
+    detached: true
+  }).on("error", (err) => {
+    console.error(color4.red(`Failed to spawn wstack: ${err.message}`));
+  });
+  console.log(
+    [
+      "",
+      color4.green(`  Switched to ${name}`),
+      color4.dim(`  Root: ${root}`),
+      color4.dim("  (current session stays open \u2014 Ctrl+C to return)"),
+      ""
+    ].join("\n")
+  );
+  return 0;
+}
+
+// src/boot/tui-project-switch.ts
+import * as fs2 from "node:fs/promises";
+import * as path5 from "node:path";
+import {
+  DefaultSystemPromptBuilder,
+  setQueuedMessagesSnapshot
+} from "@wrongstack/core/agent";
+import { DefaultSessionStore } from "@wrongstack/core/storage";
+import { resolveWstackPaths, sessionScopedPath } from "@wrongstack/core/utils";
+async function switchProjectInPlace(ctx, targetRoot, displayName) {
+  const {
+    state,
+    context,
+    events,
+    agent,
+    config,
+    tokenCounter,
+    modeId,
+    modeStore,
+    memoryStore,
+    skillLoader,
+    attachTodosCheckpoint: attachTodosCheckpoint3
+  } = ctx;
+  const resolved = path5.resolve(targetRoot);
+  const stat2 = await fs2.stat(resolved).catch(() => null);
+  if (!stat2?.isDirectory()) return `Cannot switch: not a directory: ${resolved}`;
+  const oldWriter = context.session;
+  const oldUsage = tokenCounter.total();
+  const oldProjectRoot = state.projectRoot;
+  const nextWpaths = resolveWstackPaths({
+    projectRoot: resolved,
+    globalRoot: state.wpaths.globalRoot
+  });
+  await fs2.mkdir(nextWpaths.projectSessions, { recursive: true });
+  const nextSessionStore = new DefaultSessionStore({
+    dir: nextWpaths.projectSessions,
+    projectRoot: resolved
+  });
+  const nextWriter = await nextSessionStore.create({
+    id: "",
+    title: "",
+    model: context.model,
+    provider: context.provider.id ?? config.provider
+  });
+  const previousCwd = process.cwd();
+  try {
+    process.chdir(resolved);
+    process.chdir(previousCwd);
+  } catch (err) {
+    await nextWriter.close().catch(() => void 0);
+    await nextSessionStore.delete(nextWriter.id).catch(() => void 0);
+    return `Cannot switch: ${err instanceof Error ? err.message : String(err)}`;
+  }
+  if (!state.activateSessionIdentity) {
+    await nextWriter.close().catch(() => void 0);
+    await nextSessionStore.delete(nextWriter.id).catch(() => void 0);
+    return "Cannot switch: session ownership registry is unavailable.";
+  }
+  try {
+    await state.activateSessionIdentity(nextWriter.id, {
+      projectSlug: nextWpaths.projectSlug,
+      projectRoot: resolved,
+      projectName: displayName || path5.basename(resolved),
+      workingDir: resolved
+    });
+  } catch (err) {
+    await nextWriter.close().catch(() => void 0);
+    await nextSessionStore.delete(nextWriter.id).catch(() => void 0);
+    return `Cannot switch: ${err instanceof Error ? err.message : String(err)}`;
+  }
+  await Promise.resolve(state.detachActiveTodosCheckpoint?.()).catch(() => void 0);
+  process.chdir(resolved);
+  state.projectRoot = resolved;
+  state.wpaths = nextWpaths;
+  state.activeSessionStore = nextSessionStore;
+  context.cwd = resolved;
+  context.projectRoot = resolved;
+  context.workingDir = resolved;
+  context.session = nextWriter;
+  context.state.replaceMessages([]);
+  context.state.replaceTodos([]);
+  context.clearFileTracking();
+  context.tokenCounter.reset();
+  context.meta["packageTrackerOpts"] = { storageDir: nextWpaths.projectDir, projectRoot: resolved };
+  context.state.setMeta(
+    "plan.path",
+    sessionScopedPath(nextWpaths.projectSessions, nextWriter.id, ".plan.json")
+  );
+  context.state.setMeta(
+    "task.path",
+    sessionScopedPath(nextWpaths.projectSessions, nextWriter.id, ".tasks.json")
+  );
+  try {
+    state.detachActiveTodosCheckpoint = attachTodosCheckpoint3(
+      context.state,
+      sessionScopedPath(nextWpaths.projectSessions, nextWriter.id, ".todos.json"),
+      nextWriter.id,
+      events,
+      context.traceId
+    );
+  } catch {
+    state.detachActiveTodosCheckpoint = void 0;
+  }
+  setQueuedMessagesSnapshot(context, []);
+  try {
+    const switchMode = modeId && modeId !== "default" && modeStore ? await modeStore.getMode(modeId) : void 0;
+    const switchBuilder = new DefaultSystemPromptBuilder({
+      memoryStore: memoryStore ?? void 0,
+      // Single injection channel: SAGE turn middleware, not a static section.
+      injectMemory: false,
+      skillLoader,
+      modeStore,
+      modeId: modeId ?? "default",
+      modePrompt: switchMode?.prompt ?? "",
+      instructionPaths: {
+        globalDir: nextWpaths.globalInstructions,
+        projectDir: nextWpaths.inProjectInstructions,
+        systemVariant: config.systemPrompt?.variant
+      }
+    });
+    context.systemPrompt = await switchBuilder.build({
+      cwd: resolved,
+      projectRoot: resolved,
+      tools: agent.tools.list(),
+      provider: context.provider.id,
+      model: context.model
+    });
+  } catch (err) {
+    console.error(
+      JSON.stringify({
+        level: "warn",
+        event: "execution.project_switch_prompt_rebuild_failed",
+        message: err instanceof Error ? err.message : String(err),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+  }
+  try {
+    await oldWriter.append({ type: "session_end", ts: (/* @__PURE__ */ new Date()).toISOString(), usage: oldUsage });
+    await oldWriter.close();
+  } catch (err) {
+    console.error(
+      JSON.stringify({
+        level: "warn",
+        event: "execution.project_switch_old_session_close_failed",
+        message: err instanceof Error ? err.message : String(err),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+  }
+  const emitUntyped = events.emit;
+  emitUntyped("project.switched", { from: oldProjectRoot, to: resolved, name: displayName });
+  return null;
+}
+
+// src/boot/tui-sdd-callback.ts
+async function getSDDContext() {
+  const { getActiveSDDContext: getActiveSDDContext2 } = await import("./sdd-runtime-JG4EEKL6.js");
+  return getActiveSDDContext2();
+}
+async function onSDDOutput(output) {
+  const {
+    trySaveSpecFromAIOutput: trySaveSpecFromAIOutput2,
+    trySaveImplementationPlan: trySaveImplementationPlan2,
+    trySaveTasksFromAIOutput: trySaveTasksFromAIOutput2,
+    autoDetectTaskCompletion: autoDetectTaskCompletion2,
+    getTaskProgress: getTaskProgress2,
+    getActiveSDDPhase: getActiveSDDPhase2
+  } = await import("./sdd-runtime-JG4EEKL6.js");
+  const messages = [];
+  const specSaved = await trySaveSpecFromAIOutput2(output);
+  if (specSaved)
+    messages.push("\u2713 Spec detected and saved! Use /sdd approve to continue.");
+  const planSaved = trySaveImplementationPlan2(output);
+  if (planSaved) messages.push("\u2713 Implementation plan saved!");
+  const tasksSaved = await trySaveTasksFromAIOutput2(output);
+  if (tasksSaved) {
+    const progress = getTaskProgress2();
+    const count = progress?.total ?? 0;
+    messages.push(`\u2713 ${count} tasks detected and saved! Use /sdd approve to execute.`);
+  }
+  const sddPhase = getActiveSDDPhase2();
+  if (sddPhase === "executing") {
+    const autoCompleted = autoDetectTaskCompletion2(output);
+    if (autoCompleted > 0) {
+      const progress = getTaskProgress2();
+      if (progress) {
+        messages.push(
+          `\u2713 ${autoCompleted} task(s) auto-completed! Progress: ${progress.completed}/${progress.total} (${progress.percentComplete}%)`
+        );
+      }
+    }
+  }
+  return messages;
+}
+
+// src/boot/tui-session-resume.ts
+import * as path6 from "node:path";
+import { attachTodosCheckpoint, loadTodosCheckpoint } from "@wrongstack/core/storage";
+import { sessionScopedPath as sessionScopedPath2 } from "@wrongstack/core/utils";
+async function resumeSession(ctx, sessionId) {
+  const { state, agent, tokenCounter, switchProviderAndModel, events } = ctx;
+  if (!state.activeSessionStore) return null;
+  const { replaySessionMessages } = await import("@wrongstack/tui");
+  let canonicalSessionId = sessionId;
+  try {
+    if (state.activeSessionStore.resolveId) {
+      canonicalSessionId = await state.activeSessionStore.resolveId(sessionId);
+    }
+  } catch (err) {
+    console.error(
+      JSON.stringify({
+        level: "error",
+        event: "execution.resume_id_resolve_failed",
+        sessionId,
+        message: err instanceof Error ? err.message : String(err),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+    return null;
+  }
+  try {
+    const { SessionRegistry } = await import("@wrongstack/core/storage");
+    const registry = new SessionRegistry(path6.dirname(state.wpaths.globalConfig));
+    const live = (await registry.list()).find(
+      (s) => s.sessionId === canonicalSessionId && s.status !== "stale" && s.pid !== process.pid
+    );
+    if (live) {
+      throw new Error(
+        `Session is open in another running wstack (pid ${live.pid}) \u2014 it cannot be resumed here while live.`
+      );
+    }
+  } catch (err) {
+    if (err instanceof Error && err.message.startsWith("Session is open")) throw err;
+  }
+  const previousSessionId = agent.ctx.session?.id;
+  let identityClaimed = false;
+  let writerSwapped = false;
+  let openedWriter;
+  try {
+    if (state.activateSessionIdentity) {
+      await state.activateSessionIdentity(canonicalSessionId);
+      identityClaimed = true;
+    }
+    const resumed = await state.activeSessionStore.resume(canonicalSessionId);
+    openedWriter = resumed.writer;
+    const meta = resumed.data.metadata;
+    const entries = replaySessionMessages(
+      resumed.data.messages,
+      resumed.data.events,
+      /* startId */
+      1
+    );
+    const sessionsDir = state.wpaths.projectSessions;
+    const resumedTodosPath = sessionScopedPath2(sessionsDir, resumed.writer.id, ".todos.json");
+    const restoredTodos = await loadTodosCheckpoint(
+      resumedTodosPath,
+      events,
+      agent.ctx.traceId,
+      resumed.writer.id
+    ).catch(() => null);
+    const oldWriter = agent.ctx.session;
+    const oldMessages = [...agent.ctx.messages];
+    agent.ctx.session = resumed.writer;
+    try {
+      agent.ctx.state.replaceMessages(resumed.data.messages);
+    } catch (err) {
+      agent.ctx.session = oldWriter;
+      agent.ctx.state.replaceMessages(oldMessages);
+      throw err;
+    }
+    writerSwapped = true;
+    await agent.ctx.flushConversationJournal().catch((err) => {
+      console.error(
+        JSON.stringify({
+          level: "error",
+          event: "execution.resume_journal_flush_failed",
+          message: err instanceof Error ? err.message : String(err),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
+    });
+    await Promise.resolve(state.detachActiveTodosCheckpoint?.()).catch(() => void 0);
+    agent.ctx.state.setMeta(
+      "plan.path",
+      sessionScopedPath2(sessionsDir, resumed.writer.id, ".plan.json")
+    );
+    agent.ctx.state.setMeta(
+      "task.path",
+      sessionScopedPath2(sessionsDir, resumed.writer.id, ".tasks.json")
+    );
+    agent.ctx.state.replaceTodos(restoredTodos ?? []);
+    try {
+      state.detachActiveTodosCheckpoint = attachTodosCheckpoint(
+        agent.ctx.state,
+        resumedTodosPath,
+        resumed.writer.id,
+        events,
+        agent.ctx.traceId
+      );
+    } catch {
+      state.detachActiveTodosCheckpoint = void 0;
+    }
+    const currentProviderId = agent.ctx.provider.id;
+    const targetProviderId = typeof meta.provider === "string" && meta.provider.length > 0 ? meta.provider : currentProviderId;
+    const targetModel = typeof meta.model === "string" && meta.model.length > 0 ? meta.model : agent.ctx.model;
+    if (switchProviderAndModel && targetProviderId && (targetProviderId !== currentProviderId || targetModel !== agent.ctx.model)) {
+      await Promise.resolve(switchProviderAndModel(targetProviderId, targetModel)).catch(
+        (err) => {
+          console.error(
+            JSON.stringify({
+              level: "error",
+              event: "execution.resume_model_restore_failed",
+              provider: targetProviderId,
+              model: targetModel,
+              message: err instanceof Error ? err.message : String(err),
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            })
+          );
+        }
+      );
+    } else if (targetModel !== agent.ctx.model) {
+      agent.ctx.model = targetModel;
+    }
+    if (oldWriter && oldWriter !== resumed.writer) {
+      const endedUsage = tokenCounter.total();
+      void (async () => {
+        let appendOk = false;
+        try {
+          await oldWriter.append({
+            type: "session_end",
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            usage: endedUsage
+          });
+          appendOk = true;
+        } catch (err) {
+          console.error(
+            JSON.stringify({
+              level: "error",
+              event: "execution.session_end_append_failed",
+              message: err instanceof Error ? err.message : String(err),
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            })
+          );
+        }
+        if (appendOk) {
+          try {
+            await oldWriter.close();
+          } catch (err) {
+            console.error(
+              JSON.stringify({
+                level: "error",
+                event: "execution.session_close_failed",
+                message: err instanceof Error ? err.message : String(err),
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              })
+            );
+          }
+        }
+      })();
+    }
+    tokenCounter.reset();
+    tokenCounter.account(resumed.data.usage, targetModel, targetProviderId);
+    return {
+      entries,
+      nextId: entries.length + 1,
+      sessionId: resumed.writer.id
+    };
+  } catch (err) {
+    if (identityClaimed && !writerSwapped && previousSessionId) {
+      await state.activateSessionIdentity?.(previousSessionId).catch((rollbackErr) => {
+        console.error(
+          JSON.stringify({
+            level: "error",
+            event: "execution.resume_identity_rollback_failed",
+            sessionId: previousSessionId,
+            message: rollbackErr instanceof Error ? rollbackErr.message : String(rollbackErr),
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          })
+        );
+      });
+    }
+    if (!writerSwapped) {
+      await openedWriter?.close().catch(() => void 0);
+    }
+    console.error(
+      JSON.stringify({
+        level: "error",
+        event: "execution.resume_session_failed",
+        message: err instanceof Error ? err.message : String(err),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+    return null;
+  }
+}
+
+// src/boot/tui-settings-adapter.ts
+import * as fs3 from "node:fs/promises";
+import * as path7 from "node:path";
+import { decryptConfigSecrets, encryptConfigSecrets, noOpVault } from "@wrongstack/core/security";
+import { normalizeTokenSavingTier, resolveFleetChatVerbosity } from "@wrongstack/core/types";
+import { atomicWrite } from "@wrongstack/core/utils";
+import { getProcessRegistry } from "@wrongstack/tools";
+var ANIMATION_STYLES = ["rainbow", "wave", "pulse", "dots", "breathe", "cycle"];
+function normalizeAnimationStyle(raw) {
+  return typeof raw === "string" && ANIMATION_STYLES.includes(raw) ? raw : "rainbow";
+}
+function createSettingsAdapter(ctx) {
+  const { configStore, wpaths, fleetStreamController, applyLiveSettings } = ctx;
+  const deriveFsAccess = deriveFsAccessPair;
+  function getSettings() {
+    const cfg = configStore.get();
+    const autonomy = cfg.autonomy;
+    const rawMode = autonomy?.defaultMode;
+    const mode = rawMode === "suggest" || rawMode === "auto" ? rawMode : "off";
+    const modelRuntime = cfg.modelRuntime;
+    const contextModeRaw = cfg.context?.mode;
+    const contextMode = contextModeRaw === "frugal" || contextModeRaw === "deep" ? contextModeRaw : "balanced";
+    const reasoningEffortRaw = modelRuntime?.reasoning?.effort;
+    const reasoningEffort = reasoningEffortRaw === "none" || reasoningEffortRaw === "minimal" || reasoningEffortRaw === "low" || reasoningEffortRaw === "medium" || reasoningEffortRaw === "high" || reasoningEffortRaw === "xhigh" || reasoningEffortRaw === "max" ? reasoningEffortRaw : "high";
+    const featuresAllow = cfg.features?.allowOutsideProjectRoot;
+    const toolsRestrict = cfg.tools?.restrictToProjectRoot;
+    const resolvedAllow = featuresAllow !== void 0 ? featuresAllow : toolsRestrict !== void 0 ? !toolsRestrict : true;
+    const resolvedRestrict = !resolvedAllow;
+    return {
+      mode,
+      delayMs: autonomy?.autoProceedDelayMs ?? 45e3,
+      titleAnimation: autonomy?.terminalTitleAnimation !== false,
+      yolo: cfg.yolo ?? autonomy?.yolo ?? false,
+      fleetChatVerbosity: resolveFleetChatVerbosity(cfg.autonomy),
+      chime: autonomy?.chime ?? false,
+      confirmExit: autonomy?.confirmExit !== false,
+      nextPrediction: cfg.nextPrediction ?? false,
+      featureMcp: cfg.features?.mcp !== false,
+      featurePlugins: cfg.features?.plugins !== false,
+      featureMemory: cfg.features?.memory !== false,
+      featureSkills: cfg.features?.skills !== false,
+      featureModelsRegistry: cfg.features?.modelsRegistry !== false,
+      // Preserve the 'auto' sentinel for the picker DISPLAY (normalize would
+      // collapse it to 'off', which would then overwrite 'auto' on save);
+      // everything else normalizes to a concrete tier.
+      featureTokenSaving: cfg.features?.tokenSavingMode === "auto" ? "auto" : normalizeTokenSavingTier(cfg.features?.tokenSavingMode),
+      allowOutsideProjectRoot: resolvedAllow,
+      contextAutoCompact: cfg.context?.autoCompact !== false,
+      contextStrategy: cfg.context?.strategy ?? "hybrid",
+      contextMode,
+      maxConcurrent: cfg.maxConcurrent ?? 4,
+      logLevel: cfg.log?.level ?? "info",
+      auditLevel: cfg.session?.auditLevel ?? "standard",
+      indexOnStart: cfg.indexing?.onSessionStart !== false,
+      maxIterations: cfg.tools?.maxIterations ?? 500,
+      restrictFsToRoot: resolvedRestrict,
+      autoProceedMaxIterations: cfg.autonomy?.autoProceedMaxIterations ?? 50,
+      debugStream: cfg.debugStream ?? false,
+      shellBangWarningDontShowAgain: autonomy?.shellBangWarningDontShowAgain === true,
+      statuslineMode: autonomy?.statuslineMode === "no-color" ? "no-color" : autonomy?.statuslineMode === "minimum" ? "minimum" : "detailed",
+      thinkingWord: normalizeTuiThinkingWord(autonomy?.thinkingWord),
+      animationStyle: normalizeAnimationStyle(autonomy?.animationStyle),
+      configScope: cfg.configScope ?? "global",
+      enhanceDelayMs: cfg.autonomy?.enhanceDelayMs ?? 6e4,
+      enhanceEnabled: cfg.autonomy?.enhance ?? true,
+      enhanceLanguage: cfg.autonomy?.enhanceLanguage === "english" ? "english" : "original",
+      midRunSendPicker: cfg.autonomy?.midRunSendPicker ?? true,
+      mouseMode: autonomy?.mouseMode ?? false,
+      autonomyNextPrompt: cfg.autonomy?.autonomyNextPrompt ?? "auto {{suggestion}}",
+      reasoningMode: modelRuntime?.reasoning?.mode === "on" || modelRuntime?.reasoning?.mode === "off" ? modelRuntime.reasoning.mode : "auto",
+      reasoningEffort,
+      reasoningPreserve: modelRuntime?.reasoning?.preserve === true,
+      cacheTtl: modelRuntime?.cache?.ttl === "5m" || modelRuntime?.cache?.ttl === "1h" ? modelRuntime.cache.ttl : "default",
+      breakerEnabled: cfg.circuitBreaker?.enabled === true,
+      breakerAutoKillResetMs: cfg.circuitBreaker?.autoKillResetMs ?? 6e4,
+      showModelReasoning: autonomy?.showModelReasoning ?? true,
+      showAgentSwarmPanel: autonomy?.showAgentSwarmPanel ?? true
+    };
+  }
+  async function saveSettings(s) {
+    try {
+      if (s.mode !== void 0 || s.delayMs !== void 0 || s.titleAnimation !== void 0 || s.yolo !== void 0 || s.fleetChatVerbosity !== void 0 || s.chime !== void 0 || s.confirmExit !== void 0 || s.mouseMode !== void 0 || s.featureMcp !== void 0 || s.featurePlugins !== void 0 || s.featureMemory !== void 0 || s.featureSkills !== void 0 || s.featureModelsRegistry !== void 0 || s.featureTokenSaving !== void 0 || s.allowOutsideProjectRoot !== void 0 || s.contextAutoCompact !== void 0 || s.contextStrategy !== void 0 || s.contextMode !== void 0 || s.maxConcurrent !== void 0 || s.logLevel !== void 0 || s.auditLevel !== void 0 || s.indexOnStart !== void 0 || s.maxIterations !== void 0 || s.restrictFsToRoot !== void 0 || s.nextPrediction !== void 0 || s.debugStream !== void 0 || s.shellBangWarningDontShowAgain !== void 0 || s.configScope !== void 0 || s.enhanceDelayMs !== void 0 || s.enhanceEnabled !== void 0 || s.enhanceLanguage !== void 0 || s.midRunSendPicker !== void 0 || s.statuslineMode !== void 0 || s.thinkingWord !== void 0 || s.animationStyle !== void 0 || s.autonomyNextPrompt !== void 0 || s.autoProceedMaxIterations !== void 0 || s.reasoningMode !== void 0 || s.reasoningEffort !== void 0 || s.reasoningPreserve !== void 0 || s.cacheTtl !== void 0 || s.breakerEnabled !== void 0 || s.breakerAutoKillResetMs !== void 0 || s.showModelReasoning !== void 0 || s.showAgentSwarmPanel !== void 0) {
+        const cfg = configStore.get();
+        const activeProfileName = cfg.activeProfile ?? "default";
+        const persistDeps = {
+          configStore,
+          profileConfigPath: wpaths.profileConfig(activeProfileName),
+          inProjectConfigPath: wpaths.inProjectConfig,
+          vault: noOpVault,
+          resolveProfilePath: (name) => wpaths.profileConfig(name)
+        };
+        const targetPath = resolvePersistPath(persistDeps);
+        let raw;
+        try {
+          raw = await fs3.readFile(targetPath, "utf8");
+        } catch (err) {
+          if (err.code !== "ENOENT") {
+            throw new Error(
+              `Failed to read config at ${targetPath}: ${err instanceof Error ? err.message : String(err)}`,
+              { cause: err }
+            );
+          }
+          raw = "{}";
+        }
+        const parsed = JSON.parse(raw);
+        const decrypted = decryptConfigSecrets(parsed, noOpVault);
+        const autonomy = decrypted.autonomy ?? {};
+        if (s.mode !== void 0) autonomy.defaultMode = s.mode;
+        if (s.delayMs !== void 0) autonomy.autoProceedDelayMs = s.delayMs;
+        if (s.titleAnimation !== void 0) autonomy.terminalTitleAnimation = s.titleAnimation;
+        if (s.yolo !== void 0) autonomy.yolo = s.yolo;
+        if (s.fleetChatVerbosity !== void 0) {
+          autonomy.fleetChatVerbosity = s.fleetChatVerbosity;
+        }
+        if (s.chime !== void 0) autonomy.chime = s.chime;
+        if (s.confirmExit !== void 0) autonomy.confirmExit = s.confirmExit;
+        if (s.mouseMode !== void 0) autonomy.mouseMode = s.mouseMode;
+        if (s.enhanceDelayMs !== void 0) autonomy.enhanceDelayMs = s.enhanceDelayMs;
+        if (s.enhanceEnabled !== void 0) autonomy.enhance = s.enhanceEnabled;
+        if (s.enhanceLanguage !== void 0) autonomy.enhanceLanguage = s.enhanceLanguage;
+        if (s.midRunSendPicker !== void 0) autonomy.midRunSendPicker = s.midRunSendPicker;
+        if (s.shellBangWarningDontShowAgain !== void 0)
+          autonomy.shellBangWarningDontShowAgain = s.shellBangWarningDontShowAgain;
+        if (s.statuslineMode !== void 0) autonomy.statuslineMode = s.statuslineMode;
+        if (s.thinkingWord !== void 0)
+          autonomy.thinkingWord = normalizeTuiThinkingWord(s.thinkingWord);
+        if (s.animationStyle !== void 0) autonomy.animationStyle = s.animationStyle;
+        if (s.showModelReasoning !== void 0) autonomy.showModelReasoning = s.showModelReasoning;
+        if (s.showAgentSwarmPanel !== void 0)
+          autonomy.showAgentSwarmPanel = s.showAgentSwarmPanel;
+        if (s.autonomyNextPrompt !== void 0) autonomy.autonomyNextPrompt = s.autonomyNextPrompt;
+        if (s.autoProceedMaxIterations !== void 0)
+          autonomy.autoProceedMaxIterations = s.autoProceedMaxIterations;
+        decrypted.autonomy = autonomy;
+        if (s.nextPrediction !== void 0) decrypted.nextPrediction = s.nextPrediction;
+        if (s.yolo !== void 0) decrypted.yolo = s.yolo;
+        const fsAccess = deriveFsAccess(s);
+        if (s.featureMcp !== void 0 || s.featurePlugins !== void 0 || s.featureMemory !== void 0 || s.featureSkills !== void 0 || s.featureModelsRegistry !== void 0 || s.featureTokenSaving !== void 0 || fsAccess !== void 0) {
+          const feats = decrypted.features ?? {};
+          if (s.featureMcp !== void 0) feats.mcp = s.featureMcp;
+          if (s.featurePlugins !== void 0) feats.plugins = s.featurePlugins;
+          if (s.featureMemory !== void 0) feats.memory = s.featureMemory;
+          if (s.featureSkills !== void 0) feats.skills = s.featureSkills;
+          if (s.featureModelsRegistry !== void 0) feats.modelsRegistry = s.featureModelsRegistry;
+          if (s.featureTokenSaving !== void 0) feats.tokenSavingMode = s.featureTokenSaving;
+          if (fsAccess !== void 0)
+            feats.allowOutsideProjectRoot = fsAccess.allowOutsideProjectRoot;
+          decrypted.features = feats;
+        }
+        if (s.contextAutoCompact !== void 0 || s.contextStrategy !== void 0 || s.contextMode !== void 0) {
+          const c = decrypted.context ?? {};
+          if (s.contextAutoCompact !== void 0) c.autoCompact = s.contextAutoCompact;
+          if (s.contextStrategy !== void 0) c.strategy = s.contextStrategy;
+          if (s.contextMode !== void 0) c.mode = s.contextMode;
+          decrypted.context = c;
+        }
+        if (s.maxConcurrent !== void 0) decrypted.maxConcurrent = s.maxConcurrent;
+        if (s.logLevel !== void 0) {
+          const log = decrypted.log ?? {};
+          log.level = s.logLevel;
+          decrypted.log = log;
+        }
+        if (s.auditLevel !== void 0) {
+          const sess = decrypted.session ?? {};
+          sess.auditLevel = s.auditLevel;
+          decrypted.session = sess;
+        }
+        if (s.indexOnStart !== void 0) {
+          const idx = decrypted.indexing ?? {};
+          idx.onSessionStart = s.indexOnStart;
+          decrypted.indexing = idx;
+        }
+        if (s.maxIterations !== void 0 || fsAccess !== void 0) {
+          const tools = decrypted.tools ?? {};
+          if (s.maxIterations !== void 0) tools.maxIterations = s.maxIterations;
+          if (fsAccess !== void 0) tools.restrictToProjectRoot = fsAccess.restrictToProjectRoot;
+          decrypted.tools = tools;
+        }
+        if (s.debugStream !== void 0) {
+          decrypted.debugStream = s.debugStream;
+          const { setDebugStreamEnabled } = await import("@wrongstack/providers");
+          setDebugStreamEnabled(s.debugStream);
+        }
+        if (s.configScope !== void 0) decrypted.configScope = s.configScope;
+        if (s.reasoningMode !== void 0 || s.reasoningEffort !== void 0 || s.reasoningPreserve !== void 0 || s.cacheTtl !== void 0) {
+          const modelRuntime = decrypted.modelRuntime ?? {};
+          if (s.reasoningMode !== void 0 || s.reasoningEffort !== void 0 || s.reasoningPreserve !== void 0) {
+            const reasoning = modelRuntime.reasoning ?? {};
+            if (s.reasoningMode !== void 0) reasoning.mode = s.reasoningMode;
+            if (s.reasoningEffort !== void 0) reasoning.effort = s.reasoningEffort;
+            if (s.reasoningPreserve !== void 0) reasoning.preserve = s.reasoningPreserve;
+            modelRuntime.reasoning = reasoning;
+          }
+          if (s.cacheTtl !== void 0) {
+            const cache = modelRuntime.cache ?? {};
+            if (s.cacheTtl === "default") {
+              delete cache.ttl;
+            } else {
+              cache.ttl = s.cacheTtl;
+            }
+            if (Object.keys(cache).length > 0) modelRuntime.cache = cache;
+            else delete modelRuntime.cache;
+          }
+          decrypted.modelRuntime = modelRuntime;
+        }
+        if (s.breakerEnabled !== void 0 || s.breakerAutoKillResetMs !== void 0) {
+          const cb = decrypted.circuitBreaker ?? {};
+          if (s.breakerEnabled !== void 0) cb.enabled = s.breakerEnabled;
+          if (s.breakerAutoKillResetMs !== void 0) cb.autoKillResetMs = s.breakerAutoKillResetMs;
+          decrypted.circuitBreaker = cb;
+        }
+        const actualTarget = resolveActualTarget(
+          persistDeps,
+          decrypted,
+          targetPath
+        );
+        const isProjectTarget = actualTarget === wpaths.inProjectConfig;
+        const toWrite = isProjectTarget ? filterSafeForProject(decrypted) : decrypted;
+        const encrypted = encryptConfigSecrets(toWrite, noOpVault);
+        await fs3.mkdir(path7.dirname(actualTarget), { recursive: true });
+        await atomicWrite(actualTarget, JSON.stringify(encrypted, null, 2), { mode: 384 });
+        const currentConfig = configStore.get();
+        const nextModelRuntime = {
+          ...currentConfig.modelRuntime,
+          ...decrypted.modelRuntime ?? {}
+        };
+        if (s.cacheTtl === "default") {
+          delete nextModelRuntime.cache;
+        }
+        configStore.update({
+          ...s.nextPrediction !== void 0 ? { nextPrediction: s.nextPrediction } : {},
+          ...s.yolo !== void 0 ? { yolo: s.yolo } : {},
+          ...s.featureMcp !== void 0 || s.featurePlugins !== void 0 || s.featureMemory !== void 0 || s.featureSkills !== void 0 || s.featureModelsRegistry !== void 0 || s.featureTokenSaving !== void 0 || fsAccess !== void 0 ? {
+            features: {
+              ...currentConfig.features,
+              ...decrypted.features ?? {}
+            }
+          } : {},
+          ...s.contextAutoCompact !== void 0 || s.contextStrategy !== void 0 || s.contextMode !== void 0 ? {
+            context: {
+              ...currentConfig.context,
+              ...decrypted.context ?? {}
+            }
+          } : {},
+          ...s.maxConcurrent !== void 0 ? { maxConcurrent: s.maxConcurrent } : {},
+          ...s.logLevel !== void 0 ? {
+            log: {
+              ...currentConfig.log,
+              ...decrypted.log ?? {}
+            }
+          } : {},
+          ...s.auditLevel !== void 0 ? {
+            session: {
+              ...currentConfig.session,
+              ...decrypted.session ?? {}
+            }
+          } : {},
+          ...s.indexOnStart !== void 0 ? {
+            indexing: {
+              ...currentConfig.indexing,
+              ...decrypted.indexing ?? {}
+            }
+          } : {},
+          ...s.maxIterations !== void 0 || fsAccess !== void 0 ? {
+            tools: {
+              ...currentConfig.tools,
+              ...decrypted.tools ?? {}
+            }
+          } : {},
+          ...s.debugStream !== void 0 ? { debugStream: s.debugStream } : {},
+          ...s.configScope !== void 0 ? { configScope: s.configScope } : {},
+          autonomy: {
+            ...currentConfig.autonomy,
+            ...decrypted.autonomy ?? {}
+          },
+          ...s.reasoningMode !== void 0 || s.reasoningEffort !== void 0 || s.reasoningPreserve !== void 0 || s.cacheTtl !== void 0 ? {
+            modelRuntime: nextModelRuntime
+          } : {},
+          ...s.breakerEnabled !== void 0 || s.breakerAutoKillResetMs !== void 0 ? {
+            circuitBreaker: {
+              ...currentConfig.circuitBreaker,
+              ...decrypted.circuitBreaker ?? {}
+            }
+          } : {}
+        });
+      }
+      if (s.breakerEnabled !== void 0 || s.breakerAutoKillResetMs !== void 0) {
+        getProcessRegistry().setBreakerConfig({
+          ...s.breakerEnabled !== void 0 ? { enabled: s.breakerEnabled } : {},
+          ...s.breakerAutoKillResetMs !== void 0 ? { autoKillResetMs: s.breakerAutoKillResetMs } : {}
+        });
+      }
+      if (s.fleetChatVerbosity !== void 0) {
+        if (fleetStreamController?.setMode) fleetStreamController.setMode(s.fleetChatVerbosity);
+      }
+      applyLiveSettings?.(s);
+      return null;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.debug(
+        JSON.stringify({
+          level: "error",
+          event: "execution.settings_persist_failed",
+          message,
+          errorName: err instanceof Error ? err.name : void 0,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
+      return message;
+    }
+  }
+  return { getSettings, saveSettings };
+}
+
+// src/brain-menu/panel-service.ts
+var PERSONA_CYCLE = ["executor", "skeptic", "auditor"];
+function compactEntry(entry) {
+  return entry.provider ? `${entry.provider}/${entry.model}` : entry.model;
+}
+function createBrainPanelHost(deps) {
+  const { brainRuntime } = deps;
+  const apply = async (patch) => {
+    try {
+      const { persisted } = brainRuntime.apply(patch);
+      const result = await persisted;
+      return result.ok ? null : `Applied live but NOT saved: ${result.error ?? "unknown error"}`;
+    } catch (err) {
+      return err instanceof Error ? err.message : String(err);
+    }
+  };
+  const currentPool = () => brainRuntime.getSnapshot().models.map(compactEntry);
+  const currentVoters = () => brainRuntime.getSnapshot().council.voters.map((v) => ({ ...v }));
+  const applyVoters = (voters) => apply({ council: { voters: voters.length > 0 ? voters : null } });
+  return {
+    getSettings() {
+      const snap = brainRuntime.getSnapshot();
+      return {
+        mode: snap.mode,
+        riskLevel: snap.maxAutoRisk,
+        strategy: snap.strategy,
+        decisionTimeoutMs: snap.decisionTimeoutMs,
+        humanTimeoutMs: snap.humanTimeoutMs,
+        pool: snap.models.map(compactEntry),
+        poolResolved: snap.poolLabels,
+        usingSessionModel: snap.usingSessionModel,
+        councilEnabled: snap.council.enabled,
+        councilMinRisk: snap.council.minRisk,
+        voters: snap.council.voters.map((v) => ({
+          label: compactEntry(v),
+          persona: v.persona,
+          veto: v.veto,
+          weight: v.weight
+        })),
+        councilSeats: snap.councilLabels,
+        // The EFFECTIVE judge, not `council.judge`. The configured one is
+        // usually absent, so the panel used to read "auto" and say nothing
+        // about who actually breaks the panel's ties — including when that is
+        // one of the seats that produced the tie.
+        judgeLabel: snap.judgeLabel,
+        judgeConfigured: snap.council.judge !== void 0,
+        judgeIsVoter: snap.judgeIsVoter,
+        ledgerEnabled: snap.ledger.enabled,
+        autoDenyAfterFailures: snap.ledger.autoDenyAfterFailures,
+        terminalPolicy: snap.terminalPolicy,
+        heuristics: {
+          lowRiskAutoAnswer: snap.heuristics.lowRiskAutoAnswer,
+          blockedResolved: snap.heuristics.blockedResolved,
+          deadlockSkip: snap.heuristics.deadlockSkip,
+          retryExhausted: snap.heuristics.retryExhausted,
+          continuePing: snap.heuristics.continuePing,
+          blockedResolvedMarkers: snap.heuristics.blockedResolvedMarkers
+        },
+        llmMaxTokens: snap.llm.maxTokens,
+        llmRejectUncertain: snap.llm.rejectUncertain,
+        llmMinConfidence: snap.llm.minConfidence,
+        llmDenyIsTerminal: snap.llm.denyIsTerminal,
+        cacheEnabled: snap.cache.enabled,
+        cacheTtlMs: snap.cache.ttlMs,
+        cacheMaxEntries: snap.cache.maxEntries,
+        cacheHits: snap.cache.hits,
+        cacheMisses: snap.cache.misses,
+        cacheSize: snap.cache.size,
+        traceEnabled: snap.trace.enabled,
+        traceContent: snap.trace.content,
+        tracePath: snap.trace.path,
+        circuitState: snap.circuit?.state,
+        circuitFailures: snap.circuit?.consecutiveFailures,
+        ruleCount: snap.rules.length,
+        ruleErrors: [...snap.ruleErrors]
+      };
+    },
+    setMode: (mode) => apply({ mode }),
+    setRisk: (level) => apply({ maxAutoRisk: level }),
+    setStrategy: (strategy) => apply({ strategy }),
+    setDecisionTimeout: (ms) => apply({ decisionTimeoutMs: ms ?? null }),
+    setHumanTimeout: (ms) => apply({ humanTimeoutMs: ms ?? null }),
+    addPoolModel: (providerId, model) => apply({ models: [...currentPool(), `${providerId}/${model}`] }),
+    removePoolModel: (index) => {
+      const next = currentPool().filter((_, i) => i !== index);
+      return apply({ models: next.length > 0 ? next : null });
+    },
+    clearPool: () => apply({ models: null }),
+    setCouncilEnabled: (on) => apply({ council: { enabled: on } }),
+    setCouncilMinRisk: (risk) => apply({ council: { minRisk: risk } }),
+    addVoter: (providerId, model) => {
+      const voters = currentVoters();
+      const persona = PERSONA_CYCLE[voters.length % PERSONA_CYCLE.length];
+      return applyVoters([...voters, { provider: providerId, model, persona }]);
+    },
+    removeVoter: (index) => applyVoters(currentVoters().filter((_, i) => i !== index)),
+    cycleVoterPersona: (index) => {
+      const voters = currentVoters();
+      const voter = voters[index];
+      if (!voter) return Promise.resolve("No such voter.");
+      const at = PERSONA_CYCLE.indexOf(voter.persona);
+      voter.persona = PERSONA_CYCLE[(at + 1) % PERSONA_CYCLE.length];
+      return applyVoters(voters);
+    },
+    toggleVoterVeto: (index) => {
+      const voters = currentVoters();
+      const voter = voters[index];
+      if (!voter) return Promise.resolve("No such voter.");
+      voter.veto = !voter.veto;
+      return applyVoters(voters);
+    },
+    setJudge: (providerId, model) => apply({ council: { judge: `${providerId}/${model}` } }),
+    clearJudge: () => apply({ council: { judge: null } }),
+    setLedgerEnabled: (on) => apply({ ledger: { enabled: on } }),
+    setAutoDeny: (count) => apply({ ledger: { autoDenyAfterFailures: count ?? null } }),
+    setTerminalPolicy: (policy) => apply({ terminalPolicy: policy }),
+    // Every sub-block below is MERGED field-by-field by `mergePatch`, so a
+    // single-key patch leaves the operator's other knobs alone.
+    setHeuristic: (key, on) => apply({ heuristics: { [key]: on } }),
+    setLlmMaxTokens: (tokens) => apply({ llm: { maxTokens: tokens } }),
+    setLlmRejectUncertain: (on) => apply({ llm: { rejectUncertain: on } }),
+    setLlmMinConfidence: (value) => apply({ llm: { minConfidence: value } }),
+    setLlmDenyIsTerminal: (mode) => apply({ llm: { denyIsTerminal: mode } }),
+    setCacheEnabled: (on) => apply({ cache: { enabled: on } }),
+    setCacheTtl: (ms) => apply({ cache: { ttlMs: ms } }),
+    setCacheMaxEntries: (count) => apply({ cache: { maxEntries: count } }),
+    setTraceEnabled: (on) => apply({ trace: { enabled: on } }),
+    setTraceContent: (content) => apply({ trace: { content } })
+  };
+}
+
+// src/chimera-review-task.ts
+import { parseReviewSeverity } from "@wrongstack/core/plugin";
+function truncateAtCodePointBoundary(text, maxCodeUnits) {
+  if (text.length <= maxCodeUnits) return text;
+  let result = "";
+  for (const ch of text) {
+    if (result.length + ch.length > maxCodeUnits) break;
+    result += ch;
+  }
+  return result;
+}
+function isChimeraAllClearReview(text) {
+  const severities = parseReviewSeverity(text);
+  if (severities.critical > 0 || severities.high > 0 || severities.medium > 0) {
+    return false;
+  }
+  const normalized = text.trim().toLowerCase();
+  return normalized.startsWith("## \u{1F982} chimera review \u2014 all clear") || normalized.includes("chimera review: all clear");
+}
+function buildChimeraReviewTaskDescription(p) {
+  const lines = [];
+  lines.push(`Review the following ${p.files.length} file(s) changed in this session at ${p.cwd}.`);
+  lines.push("");
+  for (const f of p.files) {
+    lines.push(`## [${f.status.toUpperCase()}] ${f.path}`);
+    if (f.diff) {
+      lines.push("");
+      lines.push("```diff");
+      lines.push(f.diff);
+      lines.push("```");
+    } else if (f.status === "added") {
+      lines.push("");
+      lines.push("(New file \u2014 full content provided)");
+    }
+    lines.push("");
+  }
+  if (p.allChangedFiles && p.allChangedFiles.length > p.files.length) {
+    const reviewedPaths = new Set(p.files.map((f) => f.path));
+    const siblings = p.allChangedFiles.filter((s) => !reviewedPaths.has(s.path)).map((s) => `  ${s.path} (${s.status})`);
+    if (siblings.length > 0) {
+      lines.push("---");
+      lines.push("");
+      lines.push(
+        `**Also changed this session (${siblings.length} files \u2014 for context, NOT in your review scope):**`
+      );
+      lines.push(siblings.slice(0, 30).join("\n"));
+      lines.push("");
+    }
+  }
+  if (p.recentCommits && p.recentCommits.length > 0) {
+    lines.push("---");
+    lines.push("");
+    lines.push("**Recent commits (newest first):**");
+    for (const c of p.recentCommits) lines.push(`  ${c}`);
+    lines.push("");
+  }
+  if (p.activeTodos && p.activeTodos.length > 0) {
+    lines.push("---");
+    lines.push("");
+    lines.push(`**Active task items (${p.activeTodos.length}):**`);
+    for (const t of p.activeTodos) {
+      lines.push(`  [${t.status}] ${t.content}`);
+    }
+    lines.push("");
+  }
+  if (p.kanbanCard) {
+    lines.push("---");
+    lines.push("");
+    lines.push(`**Kanban card: ${p.kanbanCard.title}**`);
+    if (p.kanbanCard.description) {
+      lines.push(`  ${p.kanbanCard.description.slice(0, 500)}`);
+    }
+    if (p.kanbanCard.successCriteria && p.kanbanCard.successCriteria.length > 0) {
+      lines.push("  **Success criteria:**");
+      for (const sc of p.kanbanCard.successCriteria) lines.push(`    - ${sc}`);
+    }
+    lines.push("");
+  }
+  if (p.fileProvenance && p.fileProvenance.length > 0) {
+    lines.push("---");
+    lines.push("");
+    lines.push("**File provenance (Chronicle):**");
+    for (const fp of p.fileProvenance) {
+      const parts = [];
+      if (fp.agentId) parts.push(`agent: ${fp.agentId}`);
+      if (fp.taskId) parts.push(`task: ${fp.taskId}`);
+      if (fp.eventType) parts.push(fp.eventType);
+      if (fp.observedAt) parts.push(fp.observedAt);
+      lines.push(`  ${fp.path} \u2014 ${parts.join(", ")}`);
+    }
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("Read each file using the read tool. For modified files, focus on the");
+  lines.push("diff above \u2014 do not re-review unchanged pre-existing code.");
+  lines.push("Check for bugs, type issues, security problems, and produce a");
+  lines.push("structured review report.");
+  return lines.join("\n");
+}
+function buildChimeraCascadeTaskDescription(agentKind, p) {
+  const fileList = p.bundle.files.map((f) => `- ${f.path}`).join("\n");
+  const reportSlice = truncateAtCodePointBoundary(p.reviewText, 12e3);
+  const severityLine = `Critical: ${p.severities.critical}, High: ${p.severities.high}, Medium: ${p.severities.medium}`;
+  if (agentKind === "security-scanner") {
+    return [
+      `You are a security cascade agent. A Chimera code review flagged security-relevant findings.`,
+      ``,
+      `Repository: ${p.bundle.cwd}`,
+      `Severity summary: ${severityLine}`,
+      ``,
+      `--- Review report ---`,
+      reportSlice,
+      ``,
+      `--- Changed files ---`,
+      fileList,
+      ``,
+      `Investigate the security findings above. Read the flagged files, confirm or refute`,
+      `each finding, and **apply fixes** for confirmed vulnerabilities using the edit tool.`,
+      `Use severity (Critical/High/Medium), file:line citations, and remediation steps.`,
+      `After fixing, run the project's typecheck and linter to verify. If a finding is a`,
+      `false positive, say so and do not modify the file.`
+    ].join("\n");
+  }
+  return [
+    `You are a bug-hunter cascade agent. A Chimera code review flagged correctness defects.`,
+    ``,
+    `Repository: ${p.bundle.cwd}`,
+    `Severity summary: ${severityLine}`,
+    ``,
+    `--- Review report ---`,
+    reportSlice,
+    ``,
+    `--- Changed files ---`,
+    fileList,
+    ``,
+    `Hunt for the bugs flagged above. Read the affected files, trace each finding to its`,
+    `root cause, and **apply minimal fixes** for confirmed bugs using the edit tool.`,
+    `Use severity (Critical/High/Medium), file:line citations. After fixing, run the`,
+    `project's typecheck and linter to verify. If a finding is a false positive, say so`,
+    `and do not modify the file.`
+  ].join("\n");
+}
+
+// src/chimera-reviewer-policy.ts
+import {
+  buildReviewerModelPool,
+  selectRoundRobinReviewerAssignment
+} from "@wrongstack/core/plugin";
+function resolveReviewerFallbackModels(reviewFallbackModels, sessionRef) {
+  const base = reviewFallbackModels && reviewFallbackModels.length > 0 ? [...reviewFallbackModels] : [];
+  if (sessionRef && !base.includes(sessionRef)) {
+    base.push(sessionRef);
+  }
+  return base;
+}
+var reviewerRoundRobinCursor = 0;
+function __resetReviewerRoundRobinCursor(value = 0) {
+  reviewerRoundRobinCursor = value;
+}
+function assignReviewerModelsRoundRobin(provider, model, fallbackModels) {
+  const pool = buildReviewerModelPool(provider, model, fallbackModels);
+  if (pool.length <= 1) {
+    return {
+      provider,
+      model,
+      fallbackModels: [...fallbackModels]
+    };
+  }
+  const assignment = selectRoundRobinReviewerAssignment(
+    pool,
+    reviewerRoundRobinCursor,
+    provider,
+    model
+  );
+  reviewerRoundRobinCursor = assignment.nextCursor;
+  return {
+    provider: assignment.provider,
+    model: assignment.model,
+    fallbackModels: assignment.fallbackModels
+  };
+}
+var CHIMERA_REVIEW_READ_ONLY_TOOLS = Object.freeze([
+  "read",
+  "grep",
+  "glob",
+  "tree",
+  "codebase-search",
+  "codebase-stats"
+]);
+function applyChimeraReviewerReadOnlyPolicy(config) {
+  return {
+    ...config,
+    // A security boundary, not an additive default: discard any inherited
+    // mutation tools/capabilities so Chimera reviewers cannot repair files.
+    tools: [...CHIMERA_REVIEW_READ_ONLY_TOOLS],
+    allowedCapabilities: ["fs.read"],
+    worktree: "off"
+  };
+}
+
+// src/execution-cleanup.ts
+async function finalizeExecutionCleanup(input) {
+  const {
+    offStorageObservability,
+    fleetStatusLine,
+    onCoordinatorStop,
+    stats,
+    renderer,
+    detachTodosCheckpoint,
+    mcpRegistry,
+    agent,
+    session,
+    tokenCounter,
+    events,
+    getPendingChimeraWork,
+    director,
+    reader
+  } = input;
+  offStorageObservability();
+  fleetStatusLine?.stop();
+  onCoordinatorStop?.();
+  try {
+    stats.render(renderer);
+  } catch (_err) {
+  }
+  await Promise.resolve(detachTodosCheckpoint?.()).catch(() => void 0);
+  await mcpRegistry.stopAll().catch((err) => {
+    console.warn(
+      JSON.stringify({
+        level: "warn",
+        event: "shutdown.mcp_stop_failed",
+        message: `MCP registry stopAll failed: ${err instanceof Error ? err.message : String(err)}`,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+  });
+  const activeSession = agent.ctx.session ?? session;
+  const pending = activeSession.pendingToolUses;
+  await activeSession.append({
+    type: "session_end",
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    usage: tokenCounter.total(),
+    pendingToolUses: pending.length > 0 ? pending : void 0
+  }).catch((err) => {
+    console.warn(
+      JSON.stringify({
+        level: "warn",
+        event: "shutdown.session_end_append_failed",
+        message: `session_end append failed: ${err instanceof Error ? err.message : String(err)}`,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+  });
+  events.emit("session.ended", {
+    id: activeSession.id,
+    sessionId: activeSession.id,
+    usage: tokenCounter.total()
+  });
+  if (getPendingChimeraWork) {
+    const chimeraWork = getPendingChimeraWork();
+    if (chimeraWork) {
+      await chimeraWork.catch((err) => {
+        console.warn(
+          JSON.stringify({
+            level: "warn",
+            event: "shutdown.chimera_work_failed",
+            message: `Pending chimera work failed: ${err instanceof Error ? err.message : String(err)}`,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          })
+        );
+      });
+    }
+  }
+  if (director) {
+    try {
+      await director.terminateAll();
+    } catch (termErr) {
+      console.warn(
+        JSON.stringify({
+          level: "warn",
+          event: "shutdown.director_terminate_all_failed",
+          message: termErr instanceof Error ? termErr.message : String(termErr),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
+    }
+  }
+  await activeSession.close().catch((err) => {
+    console.warn(
+      JSON.stringify({
+        level: "warn",
+        event: "shutdown.session_close_failed",
+        message: `Session close failed: ${err instanceof Error ? err.message : String(err)}`,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+  });
+  await reader.close().catch((err) => {
+    console.warn(
+      JSON.stringify({
+        level: "warn",
+        event: "shutdown.reader_close_failed",
+        message: `Input reader close failed: ${err instanceof Error ? err.message : String(err)}`,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+  });
+}
+
+// src/execution-kanban-dispatch.ts
+import { randomUUID } from "node:crypto";
+import { WIDE_SUBAGENT_CAPABILITIES } from "@wrongstack/core/security";
+
+// src/kanban-dispatch-route.ts
+import {
+  fallbackProfileChain,
+  parseModelRef
+} from "@wrongstack/core/agent";
+function resolveKanbanDispatchRoute(config, spawnOpts) {
+  let provider = spawnOpts?.provider;
+  let model = spawnOpts?.model;
+  let fallbackModels = spawnOpts?.fallbackModels;
+  if (spawnOpts?.fallbackProfile) {
+    const chain = fallbackProfileChain(config, spawnOpts.fallbackProfile);
+    const primary = chain[0] ? parseModelRef(chain[0]) : void 0;
+    if (primary?.model) {
+      provider = primary.provider ?? config.provider;
+      model = primary.model;
+      fallbackModels = spawnOpts.fallbackModels ?? chain.slice(1);
+    }
+  }
+  return { provider, model, fallbackModels };
+}
+
+// src/execution-kanban-dispatch.ts
+function createKanbanDispatchHandler({
+  config,
+  events,
+  skillLoader,
+  sddSubagentFactory
+}) {
+  if (!sddSubagentFactory) return {};
+  const onKanbanDispatch = async (description, spawnOpts) => {
+    const subagentId = `kanban-${randomUUID().slice(0, 8)}`;
+    const taskId = randomUUID();
+    const name = spawnOpts?.name ?? "kanban-agent";
+    const {
+      provider: resolvedProvider,
+      model: resolvedModel,
+      fallbackModels: resolvedFallbackModels
+    } = resolveKanbanDispatchRoute(config, spawnOpts);
+    let agentDescription = description;
+    if (spawnOpts?.skills?.length && skillLoader) {
+      const loaded = await Promise.all(
+        spawnOpts.skills.map(async (skillName) => {
+          const manifest = await skillLoader.find(skillName);
+          if (!manifest) throw new Error(`Kanban skill not found: ${skillName}`);
+          const body = await skillLoader.readBody(skillName);
+          return `## Required skill: ${skillName}
+
+${body}`;
+        })
+      );
+      agentDescription = `${description}
+
+# Required agentic skill instructions
+
+${loaded.join("\n\n")}`;
+    }
+    void (async () => {
+      const built = await sddSubagentFactory({
+        id: subagentId,
+        name,
+        role: "kanban-agent",
+        prompt: agentDescription,
+        allowedCapabilities: spawnOpts?.allowedCapabilities ?? WIDE_SUBAGENT_CAPABILITIES,
+        ...resolvedProvider ? { provider: resolvedProvider } : {},
+        ...resolvedModel ? { model: resolvedModel } : {},
+        ...resolvedFallbackModels ? { fallbackModels: resolvedFallbackModels } : {},
+        ...spawnOpts?.tools ? { tools: spawnOpts.tools } : {}
+      });
+      try {
+        const result = await built.agent.run(agentDescription);
+        await spawnOpts?.onDone?.({
+          status: result.status === "done" ? "completed" : "failed",
+          result: result.finalText,
+          ..."error" in result && result.error?.message ? { error: result.error.message } : {}
+        });
+      } catch (err) {
+        await spawnOpts?.onDone?.({
+          status: "failed",
+          error: err instanceof Error ? err.message : String(err)
+        });
+        throw err;
+      } finally {
+        await built.dispose?.();
+      }
+    })().catch((err) => {
+      events.emit("error", {
+        err: err instanceof Error ? err : new Error(String(err)),
+        phase: "kanban.dispatch"
+      });
+    });
+    const tags = [];
+    if (resolvedProvider) tags.push(resolvedProvider);
+    if (resolvedModel) tags.push(resolvedModel);
+    if (resolvedFallbackModels?.length) {
+      tags.push(`fallback=${resolvedFallbackModels.join(",")}`);
+    }
+    if (spawnOpts?.fallbackProfile) tags.push(`profile=${spawnOpts.fallbackProfile}`);
+    if (spawnOpts?.skills?.length) tags.push(`skills=${spawnOpts.skills.join(",")}`);
+    if (spawnOpts?.name) tags.push(`"${spawnOpts.name}"`);
+    const tag = tags.length > 0 ? ` (${tags.join(" / ")})` : "";
+    return `Spawned subagent ${subagentId}${tag} for task ${taskId}.`;
+  };
+  return { onKanbanDispatch };
+}
+
+// src/execution-repl-fleet-callbacks.ts
+function createReplFleetCallbacks({
+  director,
+  getDirector
+}) {
+  const resolveDirector = () => getDirector?.() ?? director;
+  return {
+    onInterruptFleet: () => {
+      const dir = resolveDirector();
+      if (!dir) return 0;
+      let killed = 0;
+      for (const sa of dir.status().subagents) {
+        if (sa.status === "running" || sa.status === "idle") {
+          try {
+            void dir.remove(sa.id);
+            killed++;
+          } catch {
+          }
+        }
+      }
+      return killed;
+    },
+    onAgentIterationComplete: (tokens) => {
+      const dir = resolveDirector();
+      dir?.setLeaderContextPressure(tokens);
+    }
+  };
+}
+
+// src/fleet-statusline.ts
+import { color as color5 } from "@wrongstack/core/utils";
+import { onResize } from "@wrongstack/core/utils";
+function fmtElapsed(ms) {
+  const s = Math.floor(ms / 1e3);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  const rem = s % 60;
+  if (m < 60) return `${m}m${rem.toString().padStart(2, "0")}s`;
+  const h = Math.floor(m / 60);
+  return `${h}h${(m % 60).toString().padStart(2, "0")}m`;
+}
+function renderFleetLine(states, now, columns, version) {
+  const all = [...states.values()];
+  if (all.length === 0) return "";
+  const running = all.filter((a) => a.status === "running");
+  const done = all.filter((a) => a.status === "done").length;
+  const failed = all.filter((a) => a.status === "failed").length;
+  const versionChip = version ? `${color5.bold("WS")}${color5.dim(` v${version}`)} ${color5.dim("\u2502")} ` : "";
+  const counts = versionChip + `${color5.cyan("\u27F3 fleet")} ${color5.yellow(`\u25B6${running.length}`)} ${color5.green(`\u2713${done}`)}` + (failed > 0 ? ` ${color5.red(`\u2717${failed}`)}` : "");
+  const shown = running.sort((a, b) => a.startedAt - b.startedAt).slice(0, 4).map((a) => {
+    const elapsed = fmtElapsed(Math.max(0, now - a.startedAt));
+    const tool = a.lastTool ? ` ${color5.dim(a.lastTool)}` : "";
+    const ext = a.extensions && a.extensions > 0 ? ` ${color5.yellow(`\u26A1${a.extensions}`)}` : "";
+    return `${color5.bold(a.name)} ${color5.yellow("\u25B6")} ${color5.dim(elapsed)} ${color5.dim(`L${a.iterations}`)} ${color5.dim(`${a.toolCalls}t`)}${tool}${ext}`;
+  });
+  let line = shown.length > 0 ? `${counts} ${color5.dim("\u2502")} ${shown.join(color5.dim("  \xB7  "))}` : counts;
+  const max = Math.max(20, columns - 1);
+  const visible = line.replace(/\x1b\[[0-9;]*m/g, "");
+  if (visible.length > max) {
+    let count = 0;
+    const out = [];
+    let i = 0;
+    while (i < line.length && count < max - 1) {
+      if (line[i] === "\x1B") {
+        const end = line.indexOf("m", i);
+        if (end !== -1) {
+          out.push(line.slice(i, end + 1));
+          i = end + 1;
+          continue;
+        }
+      }
+      if (line[i] !== void 0) out.push(line[i]);
+      count++;
+      i++;
+    }
+    line = out.join("") + "\u2026";
+  }
+  return line;
+}
+var FleetStatusLine = class {
+  events;
+  out;
+  throttleMs;
+  now;
+  version;
+  states = /* @__PURE__ */ new Map();
+  unsubs = [];
+  active = false;
+  rows = 0;
+  repaintTimer = null;
+  tickTimer = null;
+  resizeCleanup = null;
+  lastPaint = 0;
+  onResize = () => {
+    if (this.active) {
+      this.rows = this.out.rows ?? 24;
+      this.out.write(`\x1B[1;${this.rows - 1}r`);
+      this.paint(true);
+    }
+  };
+  constructor(opts) {
+    this.events = opts.events;
+    this.out = opts.out ?? process.stdout;
+    this.throttleMs = opts.throttleMs ?? 150;
+    this.now = opts.now ?? Date.now;
+    this.version = opts.version;
+  }
+  /** Subscribe to host fleet events. No terminal output until a subagent spawns. */
+  start() {
+    const ensure = (id, name) => {
+      let s = this.states.get(id);
+      if (!s) {
+        s = {
+          id,
+          name: name ?? id,
+          status: "running",
+          iterations: 0,
+          toolCalls: 0,
+          startedAt: this.now()
+        };
+        this.states.set(id, s);
+      } else if (name && s.name === s.id) {
+        s.name = name;
+      }
+      return s;
+    };
+    this.unsubs.push(
+      this.events.on("subagent.spawned", (e) => {
+        ensure(e.subagentId, e.name);
+        this.activate();
+        this.schedulePaint();
+      }),
+      this.events.on("subagent.task_started", (e) => {
+        const s = ensure(e.subagentId);
+        s.status = "running";
+        this.activate();
+        this.schedulePaint();
+      }),
+      this.events.on("subagent.tool_executed", (e) => {
+        const s = ensure(e.subagentId);
+        s.toolCalls++;
+        s.lastTool = e.name;
+        this.activate();
+        this.schedulePaint();
+      }),
+      this.events.on("subagent.iteration_summary", (e) => {
+        const s = ensure(e.subagentId);
+        s.iterations = e.iteration;
+        if (typeof e.toolCalls === "number") s.toolCalls = e.toolCalls;
+        if (e.currentTool) s.lastTool = e.currentTool;
+        this.schedulePaint();
+      }),
+      this.events.on("subagent.budget_extended", (e) => {
+        const s = ensure(e.subagentId);
+        s.extensions = e.totalExtensions;
+        this.activate();
+        this.schedulePaint();
+      }),
+      this.events.on("subagent.task_completed", (e) => {
+        const s = ensure(e.subagentId);
+        s.status = e.status === "success" ? "done" : "failed";
+        s.iterations = e.iterations;
+        s.toolCalls = e.toolCalls;
+        s.endedAt = this.now();
+        this.schedulePaint();
+        if (![...this.states.values()].some((a) => a.status === "running")) {
+          setTimeout(() => {
+            if (![...this.states.values()].some((a) => a.status === "running")) {
+              this.deactivate();
+            }
+          }, 800);
+        }
+      })
+    );
+  }
+  /** Unsubscribe and restore the terminal. Idempotent. */
+  stop() {
+    for (const u of this.unsubs.splice(0)) u();
+    this.deactivate();
+  }
+  isTty() {
+    return !!this.out.isTTY;
+  }
+  activate() {
+    if (this.active || !this.isTty()) return;
+    this.active = true;
+    this.rows = this.out.rows ?? 24;
+    this.out.write("\n");
+    this.out.write(`\x1B[1;${this.rows - 1}r`);
+    this.out.write(`\x1B[${this.rows - 1};1H`);
+    this.resizeCleanup = onResize(() => this.onResize(), this.out);
+    this.tickTimer = setInterval(() => this.paint(true), 1e3);
+    if (this.tickTimer.unref) this.tickTimer.unref();
+    this.paint(true);
+  }
+  deactivate() {
+    if (!this.active) return;
+    this.active = false;
+    if (this.tickTimer) {
+      clearInterval(this.tickTimer);
+      this.tickTimer = null;
+    }
+    if (this.repaintTimer) {
+      clearTimeout(this.repaintTimer);
+      this.repaintTimer = null;
+    }
+    this.resizeCleanup?.();
+    this.resizeCleanup = null;
+    if (this.isTty()) {
+      this.out.write("\x1B7");
+      this.out.write(`\x1B[${this.rows};1H`);
+      this.out.write("\x1B[2K");
+      this.out.write("\x1B8");
+      this.out.write("\x1B[r");
+    }
+  }
+  schedulePaint() {
+    if (!this.active) return;
+    const since = this.now() - this.lastPaint;
+    if (since >= this.throttleMs) {
+      this.paint(false);
+      return;
+    }
+    if (this.repaintTimer) return;
+    this.repaintTimer = setTimeout(() => {
+      this.repaintTimer = null;
+      this.paint(false);
+    }, this.throttleMs - since);
+    if (this.repaintTimer.unref) this.repaintTimer.unref();
+  }
+  paint(force) {
+    if (!this.active || !this.isTty()) return;
+    if (!force) this.lastPaint = this.now();
+    else this.lastPaint = this.now();
+    const line = renderFleetLine(this.states, this.now(), this.out.columns ?? 80, this.version);
+    this.out.write("\x1B7");
+    this.out.write(`\x1B[${this.rows};1H`);
+    this.out.write("\x1B[2K");
+    this.out.write(line);
+    this.out.write("\x1B8");
+  }
+};
+
+// src/execution-chimera-ask.ts
+import { createHash } from "node:crypto";
+async function waitForChimeraAskApproval(opts) {
+  const rawPoll = opts.meta["chimeraPollIntervalMs"] ?? 2e3;
+  const pollIntervalMs = Number.isFinite(rawPoll) ? Math.max(0, rawPoll) : 2e3;
+  const abortSignal = opts.meta["chimeraAbortSignal"];
+  const askStartTime = Date.now();
+  let leaderApproved = false;
+  let repliesFound = false;
+  let nonLeaderReplyCount = 0;
+  let pollDone = false;
+  const pollNext = () => {
+    if (pollDone) return Promise.resolve();
+    const elapsed = Date.now() - askStartTime;
+    const remaining = opts.askTimeoutMs - elapsed;
+    if (remaining <= 0 || abortSignal?.aborted) {
+      pollDone = true;
+      return Promise.resolve();
+    }
+    return new Promise((r) => setTimeout(r, Math.min(pollIntervalMs, remaining))).then(
+      () => pollForReply()
+    );
+  };
+  const pollForReply = async () => {
+    if (pollDone) return;
+    const replies = await opts.mailbox.query({ replyTo: opts.messageId, limit: 5 });
+    if (replies.length > 0) {
+      repliesFound = true;
+      const firstReply = replies[0];
+      if (!firstReply) return pollNext();
+      const replyFromBase = (firstReply.from ?? "").split("@")[0];
+      if (replyFromBase !== "leader" || firstReply.audience === "leaders") {
+        nonLeaderReplyCount++;
+        if (nonLeaderReplyCount >= 5) {
+          console.warn(
+            JSON.stringify({
+              level: "warn",
+              event: "execution.chimera_ask_non_leader_threshold",
+              message: `${nonLeaderReplyCount} non-leader replies seen on chimera ask \u2014 stopping poll`,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            })
+          );
+          pollDone = true;
+          return;
+        }
+        console.warn(
+          JSON.stringify({
+            level: nonLeaderReplyCount <= 1 ? "warn" : "debug",
+            event: "execution.chimera_ask_non_leader_reply",
+            message: `Ignoring non-leader reply #${nonLeaderReplyCount} from ${firstReply.from}`,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          })
+        );
+        return pollNext();
+      }
+      await opts.mailbox.ack({
+        messageId: firstReply.id,
+        readerId: "chimera-review",
+        read: true,
+        completed: true
+      }).catch((_ackErr) => {
+        console.warn(
+          JSON.stringify({
+            level: "warn",
+            event: "execution.chimera_ask_ack_failed",
+            message: _ackErr instanceof Error ? _ackErr.message : String(_ackErr),
+            replyMessageId: firstReply.id,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          })
+        );
+      });
+      const body = firstReply.body.toLowerCase();
+      if (body.trim().length === 0) {
+        pollDone = true;
+        return;
+      }
+      leaderApproved = /^\s*(?:y(?:es)?|sure|ok(?:ay)?|go ahead|proceed|approve|fix it|please do|do it|yep|yeah)\b/.test(
+        body
+      ) || /^\s*👍/.test(body);
+      if (leaderApproved) {
+        pollDone = true;
+        return;
+      }
+      if (/^\s*(no|don'?t|stop|skip|ignore|cancel|reject|decline)\b/.test(body)) {
+        pollDone = true;
+        return;
+      }
+      leaderApproved = /\b(?:y(?:es)?|sure|approve|proceed|go ahead)\b/i.test(body);
+      if (leaderApproved) {
+        pollDone = true;
+        return;
+      }
+      const hash = createHash("sha256").update(body).digest("hex").slice(0, 12);
+      console.warn(
+        JSON.stringify({
+          level: "debug",
+          event: "execution.chimera_ask_reply_unmatched",
+          replyBodyHash: hash,
+          replyBodyLength: body.length,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
+    }
+    return pollNext();
+  };
+  await pollForReply();
+  if (!leaderApproved) {
+    await recordChimeraAskFallback(opts.session, opts.askTimeoutMs, repliesFound);
+  }
+  return leaderApproved;
+}
+async function recordChimeraAskFallback(session, askTimeoutMs, repliesFound) {
+  console.warn(
+    JSON.stringify({
+      level: "warn",
+      event: repliesFound ? "execution.chimera_ask_rejected" : "execution.chimera_ask_timeout",
+      message: repliesFound ? "Leader replied to ask but did not approve" : "Ask timeout expired, falling back to off mode (no auto-fix)",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    })
+  );
+  await session.append({
+    type: "llm_response",
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    content: [
+      {
+        type: "text",
+        text: `\u{1F982} Chimera auto-fix request sent to leader \u2014 no approval received within ${askTimeoutMs / 1e3}s timeout. Falling back to manual review mode. Set autoFix via \`/chimera autoFix auto\` to auto-approve future reviews.`
+      }
+    ],
+    stopReason: "end_turn",
+    usage: { input: 0, output: 0 }
+  }).catch((_appendErr) => {
+    console.warn(
+      JSON.stringify({
+        level: "warn",
+        event: "execution.chimera_timeout_append_failed",
+        message: _appendErr instanceof Error ? _appendErr.message : String(_appendErr),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+  });
+}
+
+// src/execution-chimera-cascade.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import * as fsp from "node:fs/promises";
+import * as path8 from "node:path";
+import { emitReviewIfChanged } from "@wrongstack/core/plugin";
+function installChimeraCascadeHandler({
+  events,
+  director,
+  session,
+  getPendingWork,
+  setPendingWork
+}) {
+  events.onPattern("chimera.cascade_needed", (_event, payload) => {
+    const p = payload;
+    const dir = director;
+    if (!dir) return;
+    if (p.agents.length === 0) return;
+    const previousWork = getPendingWork();
+    const pendingWork = (async () => {
+      try {
+        await previousWork;
+      } catch {
+      }
+      for (const agentKind of p.agents) {
+        try {
+          const taskDesc = buildChimeraCascadeTaskDescription(agentKind, p);
+          const role = agentKind === "security-scanner" ? "security-scanner" : "bug-hunter";
+          const cfg = {
+            name: `chimera-cascade-${agentKind}`,
+            role,
+            maxIterations: 40,
+            maxToolCalls: 200,
+            timeoutMs: 6e5
+          };
+          const subagentId = await dir.spawn(cfg);
+          try {
+            const taskId = randomUUID2();
+            await dir.assign({ id: taskId, description: taskDesc, subagentId });
+            const results = await dir.awaitTasks([taskId]);
+            const result = results[0];
+            if (result?.status === "success") {
+              const resultText = typeof result.result === "string" ? result.result : JSON.stringify(result.result);
+              await session.append({
+                type: "llm_response",
+                ts: (/* @__PURE__ */ new Date()).toISOString(),
+                content: [
+                  {
+                    type: "text",
+                    text: `\u{1F982} Chimera cascade (${agentKind}) \u2014 ${resultText}`
+                  }
+                ],
+                stopReason: "end_turn",
+                usage: { input: 0, output: 0 }
+              });
+            } else {
+              await session.append({
+                type: "error",
+                ts: (/* @__PURE__ */ new Date()).toISOString(),
+                message: `\u{1F982} Chimera cascade (${agentKind}) ${result?.status ?? "unknown"}: ${result?.error?.message ?? "no result"}`,
+                phase: "agent"
+              });
+            }
+          } finally {
+            try {
+              await dir.terminate(subagentId);
+            } catch {
+            }
+          }
+        } catch (err) {
+          await session.append({
+            type: "error",
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            message: `\u{1F982} Chimera cascade (${agentKind}) failed: ${err instanceof Error ? err.message : String(err)}`,
+            phase: "agent"
+          });
+        }
+      }
+      await maybeReReviewCascade({ events, session, bundle: p.bundle });
+    })();
+    setPendingWork(pendingWork);
+  });
+}
+async function maybeReReviewCascade({
+  events,
+  session,
+  bundle
+}) {
+  const maxDepth = bundle.maxCascadeDepth ?? 0;
+  const currentDepth = bundle.cascadeDepth ?? 0;
+  if (maxDepth > 0 && currentDepth < maxDepth) {
+    try {
+      const reReadFiles = [];
+      for (const f of bundle.files) {
+        try {
+          const absPath = path8.join(bundle.cwd, f.path);
+          const content = await fsp.readFile(absPath, "utf8");
+          reReadFiles.push({ path: f.path, status: "modified", content });
+        } catch {
+        }
+      }
+      if (reReadFiles.length > 0) {
+        const reReviewBundle = {
+          ...bundle,
+          files: reReadFiles,
+          cascadeDepth: currentDepth + 1
+        };
+        await session.append({
+          type: "llm_response",
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          content: [
+            {
+              type: "text",
+              text: `\u{1F982} Chimera cascade re-review (depth ${currentDepth + 1}/${maxDepth}) \u2014 re-reviewing ${reReadFiles.length} file(s) after fixes`
+            }
+          ],
+          stopReason: "end_turn",
+          usage: { input: 0, output: 0 }
+        });
+        const emitted = emitReviewIfChanged(
+          { events, emitCustom: events.emitCustom.bind(events) },
+          reReviewBundle
+        );
+        if (!emitted) {
+          await session.append({
+            type: "llm_response",
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            content: [
+              {
+                type: "text",
+                text: `\u{1F982} Chimera cascade re-review skipped \u2014 content unchanged since previous review (depth ${currentDepth + 1}/${maxDepth})`
+              }
+            ],
+            stopReason: "end_turn",
+            usage: { input: 0, output: 0 }
+          });
+        }
+      }
+    } catch (err) {
+      await session.append({
+        type: "error",
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        message: `\u{1F982} Chimera cascade re-review failed: ${err instanceof Error ? err.message : String(err)}`,
+        phase: "agent"
+      });
+    }
+  } else if (maxDepth > 0 && currentDepth >= maxDepth) {
+    await session.append({
+      type: "llm_response",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      content: [
+        {
+          type: "text",
+          text: `\u{1F982} Chimera cascade stopped at depth limit (${currentDepth}/${maxDepth}) \u2014 manual review recommended if issues persist`
+        }
+      ],
+      stopReason: "end_turn",
+      usage: { input: 0, output: 0 }
+    });
+  }
+}
+
+// src/execution-storage-observability.ts
+function installStorageObservability(events, rootTraceId) {
+  const isStorageNamespace = (event) => event === "storage.read" || event === "storage.write" || event === "storage.error" || event.startsWith("storage.");
+  const storageLog = (event, payload) => {
+    if (isStorageNamespace(event)) {
+      const outcome = payload.outcome;
+      const isErrorEvent = event === "storage.error";
+      const reportsFailure = outcome === "failure" || outcome === "error";
+      const isFailure = isErrorEvent || reportsFailure;
+      if (!isFailure) {
+        return;
+      }
+      const traceId2 = payload.traceId ?? rootTraceId;
+      console.warn(
+        JSON.stringify({
+          ...payload,
+          level: "warning",
+          event,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          traceId: traceId2
+        })
+      );
+      return;
+    }
+    const traceId = payload.traceId ?? rootTraceId;
+    console.warn(
+      JSON.stringify({
+        ...payload,
+        level: "info",
+        event,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        traceId
+      })
+    );
+  };
+  const onStorageRead = (...args) => storageLog("storage.read", args[0]);
+  const onStorageWrite = (...args) => storageLog("storage.write", args[0]);
+  const onStorageError = (...args) => storageLog("storage.error", args[0]);
+  const offStorageRead = events.on("storage.read", onStorageRead);
+  const offStorageWrite = events.on("storage.write", onStorageWrite);
+  const offStorageError = events.on("storage.error", onStorageError);
+  return () => {
+    offStorageRead();
+    offStorageWrite();
+    offStorageError();
+  };
+}
+
+// src/next-task-predictor.ts
+import { readBundledInstructionText } from "@wrongstack/core/utils";
+var SYSTEM_PROMPT = readBundledInstructionText("cli/next-task-predictor.md");
+var MAX_REQUEST_CHARS = 1200;
+var MAX_SUMMARY_CHARS = 1200;
+function clamp(text, n) {
+  const t = text.trim();
+  return t.length <= n ? t : `${t.slice(0, n)}\u2026`;
+}
+function buildPredictionPrompt(input) {
+  const parts = [];
+  parts.push(`The user asked:
+${clamp(input.userRequest, MAX_REQUEST_CHARS) || "(no text)"}`);
+  if (input.assistantSummary.trim()) {
+    parts.push(
+      `The assistant just finished and reported:
+${clamp(input.assistantSummary, MAX_SUMMARY_CHARS)}`
+    );
+  }
+  const pending = input.todos.filter((t) => t.status !== "completed");
+  if (pending.length > 0) {
+    const list = pending.slice(0, 8).map((t) => `- [${t.status}] ${t.content}`).join("\n");
+    parts.push(`Open todo items:
+${list}`);
+  }
+  parts.push(
+    "Predict the 1-3 most likely exact prompt messages the user could submit back to the agent through the TUI or WebUI. Each must ask the agent to perform the work, never assign a manual chore to the user."
+  );
+  return parts.join("\n\n");
+}
+function parsePredictions(raw, max = 3) {
+  const text = raw.trim();
+  if (!text) return [];
+  if (/^none\b/i.test(text) || /no further steps/i.test(text)) return [];
+  const out = [];
+  for (const lineRaw of text.split("\n")) {
+    const line = lineRaw.trim();
+    if (!line) continue;
+    const stripped = line.replace(/^\s*(?:\d+[.)]|[-*•])\s+/, "").trim();
+    const candidate = stripped || line;
+    if (/^none$/i.test(candidate)) continue;
+    if (candidate) out.push(candidate);
+    if (out.length >= max) break;
+  }
+  return out;
+}
+function extractText(content) {
+  if (Array.isArray(content)) {
+    return content[0]?.text ?? "";
+  }
+  if (content && typeof content === "object") {
+    return content.text ?? "";
+  }
+  return typeof content === "string" ? content : "";
+}
+async function predictNextTasks(input, opts) {
+  const max = opts.maxPredictions ?? 3;
+  const internal = new AbortController();
+  const timeout = setTimeout(() => internal.abort(), 12e3);
+  const onParentAbort = () => internal.abort();
+  if (opts.signal) {
+    if (opts.signal.aborted) internal.abort();
+    else opts.signal.addEventListener("abort", onParentAbort, { once: true });
+  }
+  try {
+    const resp = await opts.provider.complete(
+      {
+        model: opts.model,
+        system: [{ type: "text", text: SYSTEM_PROMPT }],
+        messages: [
+          { role: "user", content: [{ type: "text", text: buildPredictionPrompt(input) }] }
+        ],
+        maxTokens: 160,
+        temperature: 0.3
+      },
+      { signal: internal.signal }
+    );
+    return parsePredictions(extractText(resp.content), max);
+  } catch {
+    return [];
+  } finally {
+    clearTimeout(timeout);
+    if (opts.signal) opts.signal.removeEventListener("abort", onParentAbort);
+  }
+}
+
+// src/repl.ts
+import { toErrorMessage } from "@wrongstack/core/utils";
+import { color as color9, estimateRequestTokensCalibrated as estimateRequestTokensCalibrated2, expectDefined, hasOpenTodos as hasOpenTodos2 } from "@wrongstack/core/utils";
+import { detectContinueIntent, InputBuilder, resolveContinuation } from "@wrongstack/core/agent";
+import { goalFilePath, loadGoal, summarizeUsage } from "@wrongstack/core/goal";
+import { readClipboardImage, routeImagesForModel } from "@wrongstack/runtime";
+
+// src/repl-suggestions.ts
+import { hasOpenTodos } from "@wrongstack/core/utils";
+import { parseNextSteps } from "@wrongstack/tools/next-steps";
+function parseSuggestionsFromOutput(finalText, todos) {
+  if (hasOpenTodos(todos)) {
+    setAutoSuggestions([]);
+    return null;
+  }
+  const { texts, autoTexts } = parseNextSteps(finalText, false);
+  if (autoTexts.length > 0) {
+    setAutoSuggestions(autoTexts);
+  }
+  return texts.length > 0 ? texts : null;
+}
+
+// src/repl-auto-proceed.ts
+import { color as color6, estimateRequestTokensCalibrated } from "@wrongstack/core/utils";
+import { GROUNDED_NO_PROGRESS_STEER } from "@wrongstack/tools/auto-proceed-loop-guard";
+async function runAutoProceed(opts, suggestion, delayMs, ctrl, loopGuard, grounded = false) {
+  const truncated = suggestion.length > 80 ? `${suggestion.slice(0, 77)}\u2026` : suggestion;
+  console.log(
+    JSON.stringify({
+      level: "info",
+      event: "auto_proceed_started",
+      suggestion: truncated,
+      delayMs
+    })
+  );
+  try {
+    const proceed = await autoProceedCooldown(opts, delayMs, suggestion, ctrl.signal);
+    if (!proceed) {
+      console.log(
+        JSON.stringify({
+          level: "info",
+          event: "auto_proceed_cancelled",
+          suggestion: truncated
+        })
+      );
+      return false;
+    }
+    if ((opts.getAutonomy?.() ?? "off") !== "auto") {
+      console.log(
+        JSON.stringify({
+          level: "info",
+          event: "auto_proceed_cancelled",
+          suggestion: truncated,
+          reason: "autonomy_not_auto"
+        })
+      );
+      return false;
+    }
+    const repetition = grounded ? loopGuard.recordGrounded(suggestion) : loopGuard.record(suggestion);
+    if (repetition.shouldHalt) {
+      setSuggestions([]);
+      setAutoSuggestions([]);
+      opts.onSuggestionsParsed?.(null);
+      opts.renderer.writeWarning(
+        `Auto-proceed halted: the same prompt was fed ${repetition.runLength} times in a row. Autonomy mode is still on, but no automatic next step will run until you provide input. Type anything to continue (resets the guard). Last seen prompt: "${suggestion.length > 100 ? `${suggestion.slice(0, 97)}\u2026` : suggestion}"`
+      );
+      return false;
+    }
+    const steered = "action" in repetition && repetition.action === "steer";
+    if (steered) {
+      opts.renderer.writeWarning(
+        "Todo board unchanged since the last automatic turn \u2014 steering the agent to update the board before continuing."
+      );
+    }
+    const runBlocks = [
+      {
+        type: "text",
+        text: steered ? `${suggestion}
+
+${GROUNDED_NO_PROGRESS_STEER}` : suggestion
+      }
+    ];
+    const runResult = await opts.agent.run(runBlocks, { signal: ctrl.signal });
+    console.log(
+      JSON.stringify({
+        level: "info",
+        event: "auto_proceed_completed",
+        suggestion: truncated,
+        status: runResult.status,
+        iterations: runResult.iterations
+      })
+    );
+    opts.onAgentIterationComplete?.(
+      estimateRequestTokensCalibrated(
+        opts.agent.ctx.messages,
+        opts.agent.ctx.systemPrompt,
+        opts.agent.ctx.tools ?? []
+      ).total
+    );
+    if (runResult.status === "done" && opts.onSuggestionsParsed) {
+      const parsed = runResult.finalText ? parseSuggestionsFromOutput(runResult.finalText, opts.agent.ctx.todos) : null;
+      opts.onSuggestionsParsed(parsed);
+    }
+    return true;
+  } finally {
+  }
+}
+async function autoProceedCooldown(opts, delayMs, suggestion, signal) {
+  if (delayMs <= 0) return true;
+  const truncated = suggestion.length > 100 ? `${suggestion.slice(0, 97)}\u2026` : suggestion;
+  const sec = Math.ceil(delayMs / 1e3);
+  opts.renderer.write(`
+${color6.cyan("\u23F3 Auto")}  ${color6.dim("(Ctrl+C to cancel)")}
+`);
+  opts.renderer.write(`${color6.dim("  \u25B8")} ${color6.dim(truncated)}
+`);
+  void runContextCompaction(opts, signal);
+  const start = Date.now();
+  let interval;
+  let lastTickedSecond = sec + 1;
+  let onAbort;
+  return new Promise((resolve3) => {
+    onAbort = () => resolve3(false);
+    signal.addEventListener("abort", onAbort, { once: true });
+    interval = setInterval(() => {
+      if (signal.aborted) {
+        resolve3(false);
+        return;
+      }
+      const elapsed = Date.now() - start;
+      const remaining = Math.max(0, Math.ceil((delayMs - elapsed) / 1e3));
+      if (remaining <= 0) {
+        opts.renderer.write(color6.dim(`  \u21B3 ${truncated}
+`));
+        resolve3(true);
+        return;
+      }
+      if (opts.onCountdownTick && remaining !== lastTickedSecond) {
+        lastTickedSecond = remaining;
+        try {
+          const shouldAbort = opts.onCountdownTick(remaining);
+          if (shouldAbort === true) {
+            opts.renderer.write(
+              color6.yellow("  \u21B3 Countdown cancelled \u2014 switching to manual mode\n")
+            );
+            resolve3(false);
+            return;
+          }
+        } catch {
+        }
+      }
+      if (remaining % 5 === 0 || remaining === sec) {
+        opts.renderer.write(color6.dim(`  \u23F3 ${remaining}s\u2026
+`));
+      }
+    }, 1e3);
+  }).finally(() => {
+    if (interval) clearInterval(interval);
+    if (onAbort) signal.removeEventListener("abort", onAbort);
+    try {
+      opts.onCountdownTick?.(0);
+    } catch {
+    }
+  });
+}
+async function runContextCompaction(opts, _signal) {
+  try {
+    const ctx = opts.agent.ctx;
+    if (!ctx?.compactor) return;
+    if ((ctx.messages?.length ?? 0) < 50) return;
+    await ctx.compactor.compact(ctx, { aggressive: false });
+  } catch {
+  }
+}
+
+// src/repl-input.ts
+import { color as color7 } from "@wrongstack/core/utils";
+async function readPossiblyMultiline(opts) {
+  const firstPrompt = theme.primary("\u203A ");
+  const contPrompt = color7.dim("\xB7 ");
+  const first = await opts.reader.readLine(firstPrompt);
+  if (first.trim() === '"""') {
+    const parts = [];
+    try {
+      for (; ; ) {
+        const next = await opts.reader.readLine(contPrompt);
+        if (next.trim() === '"""') break;
+        parts.push(next);
+      }
+    } catch {
+      return parts.join("\n");
+    }
+    return parts.join("\n");
+  }
+  let buf = first;
+  while (buf.endsWith("\\")) {
+    buf = buf.slice(0, -1);
+    const cont = await opts.reader.readLine(contPrompt);
+    buf += "\n" + cont;
+  }
+  return buf;
+}
+
+// src/repl-rendering.ts
+import { color as color8 } from "@wrongstack/core/utils";
+var FILLED = "\u2588";
+var EMPTY = "\u2591";
+function renderContextChip(used, max) {
+  const ratio = Math.max(0, Math.min(1, used / max));
+  const pct = Math.round(ratio * 100);
+  const bar = renderProgress(ratio, 6);
+  return `${bar} ${pct}% (${fmtTok(used)}/${fmtTok(max)})`;
+}
+function renderProgress(ratio, width) {
+  const clamped = Math.max(0, Math.min(1, ratio));
+  const filled = clamped === 0 ? 0 : Math.max(1, Math.round(clamped * width));
+  const capped = Math.min(width, filled);
+  return FILLED.repeat(capped) + EMPTY.repeat(width - capped);
+}
+function printBanner(renderer, projectName) {
+  const lines = [
+    theme.primary(theme.bold("WrongStack")) + color8.dim(` v${CLI_VERSION}`),
+    color8.dim("Built on the wrong stack. Shipped anyway.")
+  ];
+  if (projectName && projectName.length > 0) {
+    lines.push(color8.dim("Project: ") + theme.bold(projectName));
+  }
+  lines.push(color8.dim("Type /help for commands, /exit or q to quit."), "");
+  renderer.write(`${lines.join("\n")}
+`);
+}
+
+// src/repl-client-registration.ts
+import * as crypto from "node:crypto";
+import * as path9 from "node:path";
+import {
+  getSharedProjectMailbox,
+  resolveProjectDir
+} from "@wrongstack/core/coordination";
+import { wstackGlobalRoot } from "@wrongstack/core/utils";
+function registerReplClient(opts) {
+  const replProjectRoot = opts.projectRoot ?? process.cwd();
+  const projectDir = resolveProjectDir(replProjectRoot, wstackGlobalRoot());
+  const clientId = `repl@${crypto.randomUUID().slice(0, 8)}`;
+  const hqConnection = startCliHqConnection({
+    clientKind: "repl",
+    projectRoot: replProjectRoot,
+    projectName: path9.basename(replProjectRoot),
+    appConfig: opts.appConfig,
+    capabilities: ["telemetry.publish", "mailbox.summary"]
+  });
+  const clientMailbox = getSharedProjectMailbox(
+    projectDir,
+    void 0,
+    () => hqConnection.getPublisher()
+  );
+  let clientHeartbeat;
+  clientMailbox.registerClient({
+    clientId,
+    sessionId: opts.getSessionId?.() ?? replProjectRoot,
+    name: `REPL [${path9.basename(replProjectRoot)}]`,
+    source: "repl",
+    pid: process.pid
+  }).then(() => {
+    clientHeartbeat = setInterval(() => {
+      clientMailbox.clientHeartbeat({ clientId, sessionId: opts.getSessionId?.() ?? replProjectRoot }).catch(() => {
+      });
+    }, 15e3);
+  }).catch(() => {
+  });
+  return {
+    clientId,
+    close() {
+      if (clientHeartbeat) clearInterval(clientHeartbeat);
+      clientMailbox.deregisterClient(clientId).catch(() => void 0);
+      hqConnection.stop();
+    }
+  };
+}
+
+// src/repl.ts
+import { createAutoProceedLoopGuard } from "@wrongstack/tools/auto-proceed-loop-guard";
+var DEFAULT_MAX_CONSECUTIVE_AUTO_PROCEED = 50;
+async function runRepl(opts) {
+  if (opts.banner !== false) printBanner(opts.renderer, opts.projectName);
+  await renderGoalBanner(opts);
+  let activeCtrl;
+  let interrupts = 0;
+  if (opts.interruptController) {
+    opts.interruptController.abortLeader = () => {
+      if (activeCtrl) {
+        activeCtrl.abort();
+        return true;
+      }
+      return false;
+    };
+  }
+  let autoIterCount = 0;
+  let autoCapWarned = false;
+  const autoProceedLoopGuard = createAutoProceedLoopGuard();
+  let exiting = false;
+  const onSigint = () => {
+    interrupts++;
+    if (interrupts >= 3) {
+      process.exit(130);
+    }
+    if (interrupts >= 2) {
+      opts.renderer.writeWarning("Exiting.");
+      exiting = true;
+      activeCtrl?.abort();
+      const hardExit = setTimeout(() => process.exit(130), 2e3);
+      hardExit.unref?.();
+      return;
+    }
+    if (opts.getAutonomy?.() === "eternal" || opts.getAutonomy?.() === "eternal-parallel") {
+      opts.getEternalEngine?.()?.stop();
+      opts.getParallelEngine?.()?.stop();
+      opts.onAutonomy?.("off");
+      opts.renderer.writeWarning("Engine stop requested. Press Ctrl+C again to exit.");
+      interrupts = 0;
+      return;
+    }
+    const sddRun = opts.getSddRun?.();
+    if (sddRun?.isRunning()) {
+      sddRun.stop();
+      opts.renderer.writeWarning("SDD run stop requested. Press Ctrl+C again to exit.");
+      interrupts = 0;
+      return;
+    }
+    if (activeCtrl) {
+      activeCtrl.abort();
+      const killed = opts.onInterruptFleet?.() ?? 0;
+      opts.renderer.writeWarning(
+        killed > 0 ? `Iteration cancelled \xB7 stopped ${killed} subagent${killed === 1 ? "" : "s"}. Press Ctrl+C again to exit.` : "Iteration cancelled. Press Ctrl+C again to exit."
+      );
+    } else {
+      opts.renderer.writeWarning("Press Ctrl+C again to exit.");
+    }
+  };
+  process.on("SIGINT", onSigint);
+  const replClientRegistration = registerReplClient(opts);
+  const builder = new InputBuilder({ store: opts.attachments });
+  try {
+    for (; ; ) {
+      if (exiting) break;
+      if (opts.getAutonomy?.() === "eternal") {
+        const engine = opts.getEternalEngine?.();
+        if (!engine) {
+          opts.renderer.writeWarning("Eternal mode set but no engine wired \u2014 falling back to off.");
+        } else {
+          const beforeGoal = await loadGoalSafe(opts);
+          const beforeIter = beforeGoal?.iterations ?? 0;
+          opts.renderer.write(color9.dim(`
+  \u21B3 [eternal #${beforeIter + 1}] running iteration\u2026
+`));
+          interrupts = 0;
+          try {
+            const ok = await engine.runOneIteration();
+            const afterGoal = await loadGoalSafe(opts);
+            const last = afterGoal?.journal[afterGoal.journal.length - 1];
+            if (!ok && !last) {
+              opts.renderer.write(color9.dim("  \u21B3 [eternal] iteration produced no progress.\n"));
+            } else if (last) {
+              const mark = last.status === "success" ? color9.green("\u2713") : last.status === "failure" ? color9.red("\u2717") : color9.amber("\u2298");
+              const tail = last.note ? color9.dim(` \u2014 ${last.note.slice(0, 80)}`) : "";
+              opts.renderer.write(
+                `  ${mark} ${color9.dim(`#${last.iteration}`)} ${color9.dim(`[${last.source}]`)} ${last.task}${tail}
+`
+              );
+            }
+            if (engine.currentState === "stopped") {
+              const goal = await loadGoalSafe(opts);
+              if (goal?.goalState === "completed") {
+                const u = goal.journal.length > 0 ? summarizeUsage(goal) : null;
+                const costLine = u && u.iterationsWithUsage > 0 ? color9.dim(
+                  ` \u2014 ${u.totalCostUsd.toFixed(4)} \xB7 ${u.totalInputTokens} in / ${u.totalOutputTokens} out \xB7 ${goal.iterations} iterations`
+                ) : goal.iterations > 0 ? color9.dim(` \u2014 ${goal.iterations} iterations`) : "";
+                opts.renderer.write(
+                  color9.green(`
+  \u{1F3AF} Goal completed!${costLine}
+
+`) + color9.dim("  Goal cleared. Use /goal set <mission> to create a new goal.\n")
+                );
+                if (opts.projectRoot) {
+                  try {
+                    const { unlink } = await import("node:fs/promises");
+                    await unlink(goalFilePath(opts.projectRoot));
+                  } catch {
+                  }
+                }
+              }
+              opts.onAutonomy?.("auto");
+              continue;
+            }
+          } catch (err) {
+            opts.renderer.writeError(
+              `[eternal] ${toErrorMessage(err)}`
+            );
+          }
+          await new Promise((resolve3) => setTimeout(resolve3, 250));
+          continue;
+        }
+      } else if (opts.getAutonomy?.() === "eternal-parallel") {
+        const engine = opts.getParallelEngine?.();
+        if (!engine) {
+          opts.renderer.writeWarning(
+            "Parallel mode set but no engine wired \u2014 falling back to off."
+          );
+        } else {
+          const beforeGoal = await loadGoalSafe(opts);
+          const beforeIter = beforeGoal?.iterations ?? 0;
+          const coord = engine.getCoordinator();
+          if (coord) {
+            const stats = coord.getStats();
+            opts.renderer.write(
+              color9.dim(
+                `  \u250C\u2500 Fleet: ${stats.running} running, ${stats.idle} idle, ${stats.pending} pending, ${stats.completed} done`
+              ) + "\n"
+            );
+          }
+          opts.renderer.write(
+            color9.magenta(`  \u21B3 [parallel #${beforeIter + 1}] launching fan-out\u2026
+`)
+          );
+          interrupts = 0;
+          try {
+            await engine.runOneIteration();
+            const afterGoal = await loadGoalSafe(opts);
+            const last = afterGoal?.journal[afterGoal.journal.length - 1];
+            if (coord) {
+              const stats = coord.getStats();
+              opts.renderer.write(
+                color9.dim(
+                  `  \u2514\u2500 Fleet: ${stats.running} running, ${stats.idle} idle, ${stats.completed} done
+`
+                )
+              );
+            }
+            if (last) {
+              const mark = last.status === "success" ? color9.green("\u2713") : last.status === "failure" ? color9.red("\u2717") : color9.amber("\u2298");
+              const tail = last.note ? color9.dim(` \u2014 ${last.note.slice(0, 80)}`) : "";
+              opts.renderer.write(
+                `  ${mark} ${color9.dim(`#${last.iteration}`)} ${color9.dim(`[${last.source}]`)} ${last.task}${tail}
+`
+              );
+            }
+            if (engine.currentState === "stopped") {
+              const goal = await loadGoalSafe(opts);
+              if (goal?.goalState === "completed") {
+                const u = goal.journal.length > 0 ? summarizeUsage(goal) : null;
+                const costLine = u && u.iterationsWithUsage > 0 ? color9.dim(
+                  ` \u2014 ${u.totalCostUsd.toFixed(4)} \xB7 ${u.totalInputTokens} in / ${u.totalOutputTokens} out \xB7 ${goal.iterations} iterations`
+                ) : goal.iterations > 0 ? color9.dim(` \u2014 ${goal.iterations} iterations`) : "";
+                opts.renderer.write(
+                  color9.green(`
+  \u{1F3AF} Goal completed!${costLine}
+
+`) + color9.dim("  Goal cleared. Use /goal set <mission> to create a new goal.\n")
+                );
+                if (opts.projectRoot) {
+                  try {
+                    const { unlink } = await import("node:fs/promises");
+                    await unlink(goalFilePath(opts.projectRoot));
+                  } catch {
+                  }
+                }
+              }
+              opts.onAutonomy?.("auto");
+              continue;
+            }
+          } catch (err) {
+            opts.renderer.writeError(
+              `[parallel] ${toErrorMessage(err)}`
+            );
+          }
+          await new Promise((resolve3) => setTimeout(resolve3, 250));
+          continue;
+        }
+      }
+      {
+        const mode = opts.getAutonomy?.() ?? "off";
+        const suggestions = opts.getSuggestions?.() ?? [];
+        if (mode === "suggest" && suggestions.length > 0) {
+          const lines = suggestions.map((s, i) => `  ${color9.bold(`${i + 1}.`)} ${color9.dim(s)}`);
+          opts.renderer.write(
+            `
+${color9.cyan("  \u{1F4A1} Suggested next steps")}  ${color9.dim("(use /next 1, /next 2, or /next 1 2 3)")}
+${lines.join("\n")}
+
+`
+          );
+        }
+        if (mode === "auto") {
+          let top;
+          let groundedTodo = false;
+          if (suggestions.length > 0) {
+            const isYolo = opts.getYolo?.() ?? false;
+            const autoSuggestions = opts.getAutoSuggestions?.() ?? [];
+            const useAutoSuggestions = isYolo && autoSuggestions.length > 0;
+            top = useAutoSuggestions ? autoSuggestions[0] ?? "" : suggestions[0] ?? "";
+          } else {
+            const todos = opts.agent.ctx.todos ?? [];
+            const resolved = resolveContinuation({ todos, suggestions: [] });
+            top = resolved.source === "todo" ? resolved.text : "";
+            groundedTodo = top !== "";
+          }
+          if (!top) {
+          } else {
+            const maxAuto = opts.autoProceedMaxIterations ?? DEFAULT_MAX_CONSECUTIVE_AUTO_PROCEED;
+            if (maxAuto > 0 && autoIterCount >= maxAuto) {
+              if (!autoCapWarned) {
+                autoCapWarned = true;
+                opts.renderer.writeWarning(
+                  `Auto-proceed paused after ${maxAuto} consecutive automatic turns \u2014 enter input to continue (resets the counter). Autonomy stays on.`
+                );
+              }
+            } else {
+              const delay = opts.autoProceedDelayMs ?? 1e3;
+              const ctrl = new AbortController();
+              activeCtrl = ctrl;
+              try {
+                const isYolo = opts.getYolo?.() ?? false;
+                const autoSuggestions = opts.getAutoSuggestions?.() ?? [];
+                const useAutoSuggestions = isYolo && autoSuggestions.length > 0;
+                const promptToFeed = useAutoSuggestions && opts.autonomyNextPrompt ? opts.autonomyNextPrompt.replace("{{suggestion}}", top) : top;
+                const submitted = await runAutoProceed(
+                  opts,
+                  promptToFeed,
+                  delay,
+                  ctrl,
+                  autoProceedLoopGuard,
+                  groundedTodo
+                );
+                if (submitted) {
+                  autoIterCount++;
+                  continue;
+                }
+              } finally {
+                activeCtrl = void 0;
+              }
+            }
+          }
+        }
+      }
+      let raw;
+      try {
+        raw = await readPossiblyMultiline(opts);
+      } catch {
+        break;
+      }
+      const trimmed = raw.trim();
+      if (!trimmed) {
+        interrupts = 0;
+        continue;
+      }
+      interrupts = 0;
+      autoIterCount = 0;
+      autoCapWarned = false;
+      autoProceedLoopGuard.reset();
+      if (trimmed === "q") {
+        opts.renderer.write(color9.dim("  Goodbye!\n"));
+        break;
+      }
+      if (trimmed === "wd" || trimmed.startsWith("cd ")) {
+        const args = trimmed.startsWith("cd ") ? trimmed.slice(3).trim() : "";
+        try {
+          const res = await opts.slashRegistry.dispatch(`/working_dir ${args}`, opts.agent.ctx);
+          if (res?.message) opts.renderer.write(`${res.message}
+`);
+        } catch (err) {
+          opts.renderer.writeError(toErrorMessage(err));
+        }
+        continue;
+      }
+      if (trimmed === "/image" || trimmed === "/paste-image" || raw === "\x1Bv") {
+        await pasteClipboardImage(builder, opts);
+        continue;
+      }
+      if (trimmed.startsWith("/")) {
+        try {
+          const res = await opts.slashRegistry.dispatch(trimmed, opts.agent.ctx);
+          if (res?.message) opts.renderer.write(`${res.message}
+`);
+          if (res?.exit) break;
+          if (res?.runText) {
+            const runBlocks = [{ type: "text", text: res.runText }];
+            const runCtrl2 = new AbortController();
+            activeCtrl = runCtrl2;
+            try {
+              const runResult = await opts.agent.run(runBlocks, { signal: runCtrl2.signal });
+              opts.onAgentIterationComplete?.(
+                estimateRequestTokensCalibrated2(
+                  opts.agent.ctx.messages,
+                  opts.agent.ctx.systemPrompt,
+                  opts.agent.ctx.tools ?? []
+                ).total
+              );
+              if (runResult.status === "done" && runResult.finalText) {
+                const specSaved = await trySaveSpecFromAIOutput(runResult.finalText);
+                if (specSaved) {
+                  opts.renderer.write(
+                    `
+${color9.cyan("  \u2713 Spec detected and saved! Use /sdd approve to continue.")}
+`
+                  );
+                }
+                const planSaved = trySaveImplementationPlan(runResult.finalText);
+                if (planSaved) {
+                  opts.renderer.write(`
+${color9.cyan("  \u2713 Implementation plan saved!")}
+`);
+                }
+                const tasksSaved = await trySaveTasksFromAIOutput(runResult.finalText);
+                if (tasksSaved) {
+                  const progress = getTaskProgress();
+                  const count = progress?.total ?? 0;
+                  opts.renderer.write(
+                    `
+${color9.cyan(`  \u2713 ${count} tasks detected and saved! Use /sdd approve to execute.`)}
+`
+                  );
+                }
+                const sddPhase2 = getActiveSDDPhase();
+                if (sddPhase2 === "executing") {
+                  const autoCompleted = autoDetectTaskCompletion(runResult.finalText);
+                  if (autoCompleted > 0) {
+                    const progress = getTaskProgress();
+                    if (progress) {
+                      opts.renderer.write(
+                        `
+${color9.cyan(`  \u2713 ${autoCompleted} task(s) auto-completed! Progress: ${progress.completed}/${progress.total} (${progress.percentComplete}%)`)}
+`
+                      );
+                      const taskList2 = renderTaskListWithProgress();
+                      if (taskList2) {
+                        opts.renderer.write(`
+${color9.dim(taskList2)}
+`);
+                      }
+                    }
+                  } else {
+                    const taskList2 = renderTaskListWithProgress();
+                    if (taskList2) {
+                      opts.renderer.write(`
+${color9.dim(taskList2)}
+`);
+                    }
+                  }
+                }
+                if (opts.onSuggestionsParsed) {
+                  const parsed = parseSuggestionsFromOutput(
+                    runResult.finalText,
+                    opts.agent.ctx.todos
+                  );
+                  opts.onSuggestionsParsed(parsed);
+                }
+              }
+            } catch (_runErr) {
+              opts.renderer.writeWarning("AI auto-trigger failed. You can continue manually.");
+            }
+          }
+        } catch (err) {
+          opts.renderer.writeError(toErrorMessage(err));
+        }
+        continue;
+      }
+      if (detectContinueIntent(trimmed)) {
+        const resolved = resolveContinuation({
+          todos: opts.agent.ctx.todos,
+          suggestions: getSuggestions()
+        });
+        if (resolved.source === "open") {
+          opts.renderer.write(
+            `  ${color9.amber("\u26A0")} ${color9.bold("'continue' has no anchor")} ${color9.dim("\u2014 no pending todo or suggestion.")}
+` + color9.dim("     If you proceed, I'll choose the next step from context; that can drift.\n")
+          );
+          const ans = (await opts.reader.readLine(color9.dim("  Proceed anyway? [Y/n \xB7 e = type your own] "))).trim().toLowerCase();
+          if (ans === "n" || ans === "no") {
+            opts.renderer.write(color9.dim("  Cancelled \u2014 nothing sent.\n"));
+            continue;
+          }
+          if (ans === "e" || ans === "edit") {
+            opts.renderer.write(color9.dim("  Okay \u2014 type what to continue with.\n"));
+            continue;
+          }
+        } else {
+          opts.renderer.write(color9.dim(`  ${resolved.label}
+`));
+        }
+        builder.appendText(resolved.text);
+      } else {
+        const ph = await builder.appendPaste(raw);
+        if (ph) {
+          const lineCount = raw.split("\n").length;
+          opts.renderer.write(color9.dim(`  \u21B3 ${ph} (${lineCount} lines)
+`));
+        }
+      }
+      const blocks = await builder.submit();
+      const sddContext = getActiveSDDContext();
+      const taskList = getTaskListText();
+      const taskProgress = getTaskProgress();
+      const sddPhase = getActiveSDDPhase();
+      let sddPrefix = "";
+      if (sddContext) {
+        sddPrefix = `[SDD SESSION ACTIVE]
+${sddContext}`;
+        if (sddPhase === "executing") {
+          const currentCtx = getCurrentExecutingContext();
+          if (currentCtx) {
+            sddPrefix += `
+
+${currentCtx}`;
+          }
+        }
+        if (taskList) {
+          sddPrefix += `
+
+**Current Task List:**
+${taskList}`;
+        }
+        if (taskProgress && taskProgress.total > 0) {
+          sddPrefix += `
+**Progress:** ${taskProgress.completed}/${taskProgress.total} (${taskProgress.percentComplete}%)`;
+        }
+        if (sddPhase === "executing" && taskProgress && taskProgress.percentComplete === 100) {
+          sddPrefix += "\n\n**All tasks completed! Provide a summary of everything implemented.**";
+        }
+        sddPrefix += "\n\n---\nUser message:\n";
+      }
+      const effectiveBlocks = sddPrefix ? [{ type: "text", text: sddPrefix }, ...blocks] : blocks;
+      const runCtrl = new AbortController();
+      activeCtrl = runCtrl;
+      try {
+        const startedAt = Date.now();
+        const before = opts.tokenCounter?.total();
+        const costBefore = opts.tokenCounter?.estimateCost().total ?? 0;
+        const routed = effectiveBlocks.some((block) => block.type === "image") ? await routeImagesForModel(effectiveBlocks, {
+          supportsVision: opts.supportsVision ? await opts.supportsVision() : opts.agent.ctx.provider.capabilities.vision,
+          adapters: opts.visionAdapters ?? [],
+          ctx: opts.agent.ctx,
+          signal: runCtrl.signal,
+          providerId: opts.agent.ctx.provider.id,
+          model: opts.agent.ctx.model
+        }) : { blocks: effectiveBlocks, route: "none", convertedImages: 0 };
+        if (routed.route === "adapter") {
+          opts.renderer.write(
+            color9.dim(
+              `  \u21B3 image analyzed via ${routed.adapterName ?? "vision adapter"} (${routed.convertedImages} image${routed.convertedImages === 1 ? "" : "s"})
+`
+            )
+          );
+        }
+        const result = await opts.agent.run(routed.blocks, { signal: runCtrl.signal });
+        opts.onAgentIterationComplete?.(
+          estimateRequestTokensCalibrated2(
+            opts.agent.ctx.messages,
+            opts.agent.ctx.systemPrompt,
+            opts.agent.ctx.tools ?? []
+          ).total
+        );
+        if (result.status === "aborted") {
+          opts.renderer.writeWarning("Aborted.");
+        } else if (result.status === "failed") {
+          const err = result.error;
+          if (err) {
+            const tag = err.recoverable ? " (recoverable)" : "";
+            opts.renderer.writeError(`Failed [${err.severity}]${tag}: ${err.describe()}`);
+            const hint = contextOverflowHint(err);
+            if (hint) opts.renderer.writeWarning(hint);
+          } else {
+            opts.renderer.writeError("Failed.");
+          }
+        } else if (result.status === "max_iterations") {
+          opts.renderer.writeWarning(`Hit max iterations (${result.iterations}).`);
+        }
+        if (result.status === "done" && result.finalText && sddContext) {
+          const specSaved = await trySaveSpecFromAIOutput(result.finalText);
+          if (specSaved) {
+            opts.renderer.write(
+              `
+${color9.cyan("  \u2713 Spec detected and saved! Use /sdd approve to continue.")}
+`
+            );
+          }
+          const planSaved = trySaveImplementationPlan(result.finalText);
+          if (planSaved) {
+            opts.renderer.write(`
+${color9.cyan("  \u2713 Implementation plan saved!")}
+`);
+          }
+          const tasksSaved = await trySaveTasksFromAIOutput(result.finalText);
+          if (tasksSaved) {
+            const progress = getTaskProgress();
+            const count = progress?.total ?? 0;
+            opts.renderer.write(
+              `
+${color9.cyan(`  \u2713 ${count} tasks detected and saved! Use /sdd approve to execute.`)}
+`
+            );
+          }
+          const phase = getActiveSDDPhase();
+          if (phase === "executing") {
+            const autoCompleted = autoDetectTaskCompletion(result.finalText);
+            if (autoCompleted > 0) {
+              const progress = getTaskProgress();
+              if (progress) {
+                opts.renderer.write(
+                  `
+${color9.cyan(`  \u2713 ${autoCompleted} task(s) auto-completed! Progress: ${progress.completed}/${progress.total} (${progress.percentComplete}%)`)}
+`
+                );
+                if (progress.percentComplete === 100) {
+                  opts.renderer.write(
+                    `
+${color9.green("  \u{1F389} All tasks completed! Use /sdd cancel to end the session.")}
+`
+                  );
+                }
+              }
+              advanceToNextTask();
+              const taskList2 = renderTaskListWithProgress();
+              if (taskList2) {
+                opts.renderer.write(`
+${color9.dim(taskList2)}
+`);
+              }
+            } else {
+              const taskList2 = renderTaskListWithProgress();
+              if (taskList2) {
+                opts.renderer.write(`
+${color9.dim(taskList2)}
+`);
+              }
+            }
+          }
+        }
+        if (result.status === "done" && result.finalText && opts.onSuggestionsParsed) {
+          const parsed = parseSuggestionsFromOutput(result.finalText, opts.agent.ctx.todos);
+          opts.onSuggestionsParsed(parsed);
+        }
+        if (opts.tokenCounter && before) {
+          const after = opts.tokenCounter.total();
+          const costAfter = opts.tokenCounter.estimateCost().total;
+          const effectiveMaxContext = opts.getEffectiveMaxContext?.() ?? opts.effectiveMaxContext;
+          const ctxChip = effectiveMaxContext && effectiveMaxContext > 0 ? `  ctx: ${renderContextChip(after.input, effectiveMaxContext)}` : "";
+          opts.renderer.write(
+            `
+${color9.dim(
+              `[in: ${fmtTok(after.input - before.input)}  out: ${fmtTok(after.output - before.output)}  iters: ${result.iterations}  cost: ${(costAfter - costBefore).toFixed(4)}  ${((Date.now() - startedAt) / 1e3).toFixed(1)}s]${ctxChip}`
+            )}
+`
+          );
+        }
+        if (result.status === "done" && opts.getAutonomy) {
+          const autonomy = opts.getAutonomy();
+          if (autonomy === "suggest" && !hasOpenTodos2(opts.agent.ctx.todos)) {
+            const suggestPrompt = 'Based on what you just did, suggest 3 exact prompt messages that can be submitted back to you through the TUI or WebUI. Each prompt must ask the agent to perform work; never assign a manual chore to the user. If you include suggestions, wrap them in a balanced <nextsteps>...</nextsteps> block, with one numbered prompt per line and no explanation. If there is nothing meaningful left, say "No further steps needed."';
+            const suggestBlocks = [{ type: "text", text: suggestPrompt }];
+            const suggestCtrl = new AbortController();
+            activeCtrl = suggestCtrl;
+            try {
+              const suggestResult = await opts.agent.run(suggestBlocks, {
+                signal: suggestCtrl.signal
+              });
+              opts.onAgentIterationComplete?.(
+                estimateRequestTokensCalibrated2(
+                  opts.agent.ctx.messages,
+                  opts.agent.ctx.systemPrompt,
+                  opts.agent.ctx.tools ?? []
+                ).total
+              );
+              if (suggestResult.status === "done" && suggestResult.finalText) {
+                opts.renderer.write(
+                  `
+${color9.cyan("  Suggested next steps:")}
+${suggestResult.finalText}
+`
+                );
+                if (opts.onSuggestionsParsed) {
+                  const parsed = parseSuggestionsFromOutput(
+                    suggestResult.finalText,
+                    opts.agent.ctx.todos
+                  );
+                  opts.onSuggestionsParsed(parsed);
+                }
+              }
+            } catch {
+            } finally {
+              activeCtrl = void 0;
+            }
+          }
+        }
+        if (result.status === "done" && opts.getNextPredict?.() && !hasOpenTodos2(opts.agent.ctx.todos)) {
+          const autonomy = opts.getAutonomy?.() ?? "off";
+          if (autonomy === "off") {
+            const predictCtrl = new AbortController();
+            activeCtrl = predictCtrl;
+            try {
+              const predictions = await predictNextTasks(
+                {
+                  userRequest: trimmed,
+                  assistantSummary: result.finalText ?? "",
+                  todos: opts.agent.ctx.todos
+                },
+                {
+                  provider: opts.agent.ctx.provider,
+                  model: opts.agent.ctx.model,
+                  signal: predictCtrl.signal
+                }
+              );
+              if (predictions.length > 0) {
+                const lines = predictions.map((p, i) => `    ${i + 1}. ${p}`).join("\n");
+                opts.renderer.write(`
+${color9.dim("  \u21B3 likely next:")}
+${color9.dim(lines)}
+`);
+              }
+            } catch {
+            } finally {
+              activeCtrl = void 0;
+            }
+          }
+        }
+      } catch (err) {
+        opts.renderer.writeError(toErrorMessage(err));
+      } finally {
+        activeCtrl = void 0;
+      }
+    }
+    return 0;
+  } finally {
+    process.off("SIGINT", onSigint);
+    await opts.reader.close().catch(() => {
+    });
+    replClientRegistration.close();
+    opts.onDestroy?.();
+  }
+}
+async function pasteClipboardImage(builder, opts) {
+  try {
+    const img = await readClipboardImage();
+    if (!img) {
+      opts.renderer.write(color9.dim("  no image on clipboard\n"));
+      return;
+    }
+    const placeholder = await builder.appendImage(img.base64, img.mediaType);
+    const kb = (img.bytes / 1024).toFixed(0);
+    opts.renderer.write(color9.dim(`  \u21B3 ${placeholder} (PNG ${kb}KB)
+`));
+  } catch (err) {
+    opts.renderer.writeError(
+      `Clipboard image error: ${toErrorMessage(err)}`
+    );
+  }
+}
+async function loadGoalSafe(opts) {
+  if (!opts.projectRoot) return null;
+  try {
+    return await loadGoal(goalFilePath(opts.projectRoot));
+  } catch {
+    return null;
+  }
+}
+async function renderGoalBanner(opts) {
+  const goal = await loadGoalSafe(opts);
+  if (!goal) return;
+  const summary = goal.goal.length > 80 ? `${goal.goal.slice(0, 77)}\u2026` : goal.goal;
+  const stateColor = goal.goalState === "active" ? color9.green : goal.goalState === "paused" ? color9.amber : goal.goalState === "completed" ? color9.green : goal.goalState === "abandoned" ? color9.dim : color9.dim;
+  opts.renderer.write(
+    color9.dim("Goal: ") + stateColor(summary) + color9.dim(` [${goal.goalState}]  (iter ${goal.iterations})`) + "\n"
+  );
+  if (goal.journal.length > 0) {
+    const lastEntry = expectDefined(goal.journal[goal.journal.length - 1]);
+    const statusIcon = lastEntry.status === "success" ? "\u2713" : lastEntry.status === "failure" ? "\u2717" : lastEntry.status === "aborted" ? "\u2298" : lastEntry.status === "skipped" ? "\u229D" : "\xB7";
+    opts.renderer.write(
+      color9.dim(`  Last: ${statusIcon} ${lastEntry.task} (${lastEntry.status})`) + "\n"
+    );
+  }
+  if (goal.engineState === "running") {
+    opts.renderer.write(
+      color9.amber("  \u21BA Eternal engine was running when last session ended.") + "\n"
+    );
+    try {
+      const answer = (await opts.reader.readLine(color9.dim("  Resume eternal mode? [y/N] "))).trim().toLowerCase();
+      if (answer === "y" || answer === "yes") {
+        try {
+          await opts.slashRegistry.dispatch("/autonomy eternal", opts.agent.ctx);
+        } catch (err) {
+          opts.renderer.writeError(
+            `Auto-resume failed: ${toErrorMessage(err)}`
+          );
+        }
+      } else {
+        opts.renderer.write(
+          color9.dim("  Not resuming. Use `/autonomy eternal` later to continue.") + "\n"
+        );
+      }
+    } catch {
+      opts.renderer.write(color9.dim("  Use `/autonomy eternal` to resume.") + "\n");
+    }
+  } else if (goal.goalState === "paused") {
+    opts.renderer.write(color9.amber("  \u23F8 Goal is paused. Use `/goal resume` to continue.") + "\n");
+  } else if (goal.goalState === "completed") {
+    opts.renderer.write(
+      color9.green("  \u2713 Goal completed! Use `/goal clear` to set a new goal.") + "\n"
+    );
+  } else if (goal.goalState === "abandoned") {
+    opts.renderer.write(color9.dim("  Use `/goal clear` to set a new goal.") + "\n");
+  }
+  opts.renderer.write("\n");
+}
+
+// src/execution-tui-next-step-callbacks.ts
+function createTuiNextStepCallbacks(input) {
+  const { context, getNextPredict, getAutonomy, getSuggestions: getSuggestions2 } = input;
+  return {
+    async predictNext(request) {
+      if (!getNextPredict?.()) return [];
+      if ((getAutonomy?.() ?? "off") !== "off") return [];
+      return predictNextTasks(
+        { ...request, todos: context.todos ?? [] },
+        {
+          provider: context.provider,
+          model: context.model
+        }
+      );
+    },
+    onSuggestionsParsed(finalText) {
+      const parsed = parseSuggestionsFromOutput(finalText, context.todos);
+      setSuggestions(parsed ?? []);
+    },
+    getSuggestions: () => getSuggestions2?.() ?? [],
+    setSuggestions
+  };
+}
+
+// src/execution.ts
+async function execute(deps) {
+  const {
+    core: {
+      agent,
+      events,
+      config,
+      configStore,
+      wpaths: initialWpaths,
+      projectRoot: initialProjectRoot,
+      flags,
+      positional,
+      slashRegistry,
+      tokenCounter,
+      activateSessionIdentity,
+      updateInfo: initialUpdateInfo
+    },
+    session: {
+      session,
+      context,
+      attachments,
+      queueStore,
+      mcpRegistry,
+      mailbox,
+      sessionStore,
+      memoryStore,
+      modeStore,
+      detachTodosCheckpoint,
+      rebindTodosCheckpoint,
+      restoredMessages,
+      restoredToolCalls,
+      restoredEvents,
+      needsSetup
+    },
+    provider: {
+      modelsRegistry,
+      savedProviderCfg,
+      resolvedProvider,
+      statusTracker,
+      getPickableProviders,
+      switchProviderAndModel,
+      onModelContextResolved,
+      sddSubagentFactory
+    },
+    ui: {
+      renderer,
+      reader,
+      secretInputController,
+      stats,
+      effectiveMaxContext,
+      getEffectiveMaxContext,
+      skillLoader,
+      promptLoader,
+      modeId
+    },
+    fleet: {
+      director,
+      getDirector,
+      coordinatorController,
+      fleetRoster,
+      fleetStreamController,
+      agentsMonitorController,
+      agentTranscripts,
+      authHost,
+      onPanelOpen
+    },
+    controllers: {
+      interruptController,
+      enhanceController,
+      getEnhancerReasoning,
+      buildEnhancerProvider,
+      getEnhanceFallbackRef,
+      getConfiguredRefinerRef,
+      statuslineHiddenItems,
+      setStatuslineHiddenItems,
+      saveStatuslineHiddenItems,
+      getYolo,
+      onYolo,
+      getAutonomy,
+      onAutonomy,
+      getNextPredict,
+      applyLiveSettings,
+      onCountdownTick
+    },
+    picker: {
+      getPluginItems,
+      onPluginToggle,
+      getMcpServers,
+      onMcpToggle,
+      onMcpRestart,
+      getToolsItems,
+      onToolToggle,
+      getBrainData,
+      onBrainRiskLevel,
+      getBrainLog,
+      brain,
+      brainSettings,
+      brainRuntime,
+      getShadowData,
+      onShadowStart,
+      onShadowStop
+    } = {},
+    lifecycles: {
+      getSuggestions: getSuggestions2,
+      getAutoSuggestions,
+      onSuggestionsParsed,
+      autonomyNextPrompt,
+      autoProceedDelayMs,
+      autoProceedMaxIterations,
+      onValidateAutoProceed,
+      getEternalEngine,
+      getParallelEngine,
+      getSddRun,
+      onSddLifecycle,
+      subscribeEternalIteration,
+      subscribeEternalStage,
+      onDestroy,
+      onCoordinatorStop
+    } = {}
+  } = deps;
+  let onCoordinatorStopImpl = onCoordinatorStop;
+  const wpaths = initialWpaths;
+  const projectRoot = initialProjectRoot;
+  const activeSessionStore = sessionStore;
+  const detachActiveTodosCheckpoint = detachTodosCheckpoint;
+  const profileName = config.activeProfile ?? "default";
+  const bootUpdateInfo = initialUpdateInfo;
+  const offStorageObservability = installStorageObservability(events, context.traceId);
+  let pendingChimeraWork;
+  events.onPattern("chimera.review_needed", (_event, payload) => {
+    const p = payload;
+    const dir = director;
+    if (!dir) {
+      return;
+    }
+    if (p.files.length === 0) return;
+    pendingChimeraWork = (async () => {
+      let subagentId;
+      try {
+        const taskDesc = buildChimeraReviewTaskDescription(p);
+        const tProvider = config.provider?.trim() || void 0;
+        const tModel = config.model?.trim() || void 0;
+        const rawProvider = p.reviewFallbackModels ? p.config.provider?.trim() || void 0 : tProvider;
+        const rawModel = p.reviewFallbackModels ? p.config.model?.trim() || void 0 : tModel;
+        const baseProvider = rawProvider || tProvider || config.provider;
+        const baseModel = rawModel || tModel || config.model;
+        const baseFallbacks = p.reviewFallbackModels ? [...p.reviewFallbackModels] : resolveReviewerFallbackModels(void 0);
+        const assigned = assignReviewerModelsRoundRobin(baseProvider, baseModel, baseFallbacks);
+        const cfg = applyChimeraReviewerReadOnlyPolicy({
+          name: "chimera-review",
+          role: "reviewer",
+          systemPromptOverride: CHIMERA_REVIEW_PROMPT,
+          maxIterations: 50,
+          maxToolCalls: 250,
+          timeoutMs: 9e5,
+          provider: assigned.provider,
+          model: assigned.model,
+          fallbackModels: assigned.fallbackModels
+        });
+        subagentId = await dir.spawn(cfg);
+        const taskId = randomUUID4();
+        await dir.assign({
+          id: taskId,
+          description: taskDesc,
+          subagentId
+        });
+        const results = await dir.awaitTasks([taskId]);
+        const result = results[0];
+        if (result?.status !== "success") {
+          try {
+            await session.append({
+              type: "error",
+              ts: (/* @__PURE__ */ new Date()).toISOString(),
+              message: `\u{1F982} Chimera review subagent ${result?.status ?? "unknown"}: ${result?.error?.message ?? "no result"}`,
+              phase: "agent"
+            });
+          } catch (err) {
+            console.error(
+              JSON.stringify({
+                level: "error",
+                event: "execution.chimera_append_failed",
+                message: err instanceof Error ? err.message : String(err),
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              })
+            );
+          }
+          events.emitCustom("chimera.review_complete", {
+            bundle: p,
+            reviewText: "",
+            status: result?.status ?? "unknown",
+            cwd: p.cwd,
+            sessionId: session.id
+          });
+          return;
+        }
+        const reviewText = typeof result.result === "string" ? result.result.trim() : JSON.stringify(result.result);
+        events.emitCustom("chimera.review_complete", {
+          bundle: p,
+          reviewText,
+          status: "success",
+          cwd: p.cwd,
+          sessionId: session.id
+        });
+        if (reviewText) {
+          await session.append({
+            type: "llm_response",
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            content: [{ type: "text", text: reviewText }],
+            stopReason: "end_turn",
+            usage: { input: 0, output: 0 }
+          });
+          const autoFix = agent.ctx.meta["chimeraAutoFix"] ?? p.config.autoFix ?? "off";
+          const reviewHasFindings = !isChimeraAllClearReview(reviewText);
+          const isAskMode = autoFix === "ask" && reviewHasFindings;
+          const mailboxType = isAskMode ? "ask" : "result";
+          const subject = isAskMode ? `\u{1F982} Chimera review \u2014 ${p.files.length} file(s) changed. Shall I fix the findings?` : `\u{1F982} Chimera review \u2014 ${p.files.length} file(s) changed`;
+          let leaderApproved = false;
+          let spawnedFix = false;
+          let askMailMsgId;
+          let leaderOnline = false;
+          if (isAskMode) {
+            try {
+              const onlineAgents = await mailbox.getOnlineAgents();
+              leaderOnline = onlineAgents.some(
+                (a) => a.online && isMailboxLeader(a.agentId, a.role)
+              );
+            } catch (leaderCheckErr) {
+              console.warn(
+                JSON.stringify({
+                  level: "warn",
+                  event: "execution.chimera_leader_check_failed",
+                  message: leaderCheckErr instanceof Error ? leaderCheckErr.message : String(leaderCheckErr),
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                })
+              );
+            }
+            if (!leaderOnline) {
+              console.warn(
+                JSON.stringify({
+                  level: "warn",
+                  event: "execution.chimera_mailbox_leader_offline",
+                  message: `Leader not online \u2014 mailbox ${mailboxType} from chimera-review to leader will be delivered when leader reconnects`,
+                  fileCount: p.files.length,
+                  autoFix,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                })
+              );
+            }
+          } else {
+            leaderOnline = true;
+            console.debug(
+              JSON.stringify({
+                level: "debug",
+                event: "execution.chimera_auto_no_presence_check",
+                message: "Result mode: leader presence not checked \u2014 mailbox message delivered regardless",
+                fileCount: p.files.length,
+                autoFix,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              })
+            );
+          }
+          try {
+            const askTimeoutRaw = agent.ctx.meta["chimeraAskTimeoutMs"] ?? 3e4;
+            const ASK_TIMEOUT_MS = Number.isFinite(askTimeoutRaw) ? Math.max(0, askTimeoutRaw) : 3e4;
+            const directive = isAskMode ? `LEADER ACTION REQUIRED: The Chimera review below found issues. Reply with "yes" to auto-fix, or "no" to skip (${ASK_TIMEOUT_MS / 1e3}s timeout).` : reviewHasFindings ? "LEADER ACTION REQUIRED: The Chimera review below found issues. Read the report and fix any Critical or High findings automatically using the edit tool. Verify with typecheck and linter." : "Chimera review completed with no findings. Read the report summary below; no fix action is requested.";
+            const reviewBody = reviewText.length > 7500 ? truncateAtCodePointBoundary(reviewText, 7500) + "\n\n\u2026(truncated, full report in session transcript)" : reviewText;
+            const body = `${directive}
+
+${reviewBody}`;
+            const mailMsg = await mailbox.send({
+              from: "chimera-review",
+              to: "leader",
+              type: mailboxType,
+              audience: "leaders",
+              subject,
+              body,
+              priority: "normal"
+            });
+            if (!mailMsg?.id) throw new Error("mailbox.send returned no message id");
+            askMailMsgId = mailMsg.id;
+            if (isAskMode) {
+              leaderApproved = await waitForChimeraAskApproval({
+                mailbox,
+                messageId: askMailMsgId,
+                meta: agent.ctx.meta,
+                session: agent.ctx.session ?? session,
+                askTimeoutMs: ASK_TIMEOUT_MS
+              });
+            }
+          } catch (mailErr) {
+            const errMsg = mailErr instanceof Error ? mailErr.message : String(mailErr);
+            console.error(
+              JSON.stringify({
+                level: "error",
+                event: "execution.chimera_mailbox_failed",
+                message: errMsg,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              })
+            );
+            await session.append({
+              type: "error",
+              ts: (/* @__PURE__ */ new Date()).toISOString(),
+              message: `\u{1F982} Chimera auto-fix skipped \u2014 mailbox unreachable: ${errMsg}. Falling back to manual review mode.`,
+              phase: "agent"
+            });
+          }
+          events.emitCustom("chimera.mailbox_delivered", {
+            subject,
+            autoFixMode: autoFix,
+            fileCount: p.files.length,
+            reviewLength: reviewText.length
+          });
+          if (!leaderOnline) {
+            try {
+              await mailbox.send({
+                from: "chimera-review",
+                to: "leader",
+                type: "note",
+                audience: "leaders",
+                subject: `\u23F0 Chimera review pending \u2014 ${p.files.length} file(s) checked`,
+                body: `The leader was offline when a chimera review completed. A full review result with "LEADER ACTION REQUIRED" directive is waiting in this mailbox from chimera-review. Open it, read the findings, and fix any Critical or High issues.`,
+                priority: "high"
+              });
+            } catch (wakeErr) {
+              console.warn(
+                JSON.stringify({
+                  level: "warn",
+                  event: "execution.chimera_wakeup_companion_failed",
+                  message: wakeErr instanceof Error ? wakeErr.message : String(wakeErr),
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                })
+              );
+            }
+          }
+          const shouldSpawnFix = !spawnedFix && reviewHasFindings && (autoFix === "auto" || isAskMode && leaderApproved) && reviewText.length > 0;
+          if (shouldSpawnFix) {
+            spawnedFix = true;
+            const fixTaskDesc = [
+              `You are a fix agent. Apply the fixes requested in this review report.`,
+              ``,
+              `Repository: ${p.cwd}`,
+              ``,
+              `--- Review report ---`,
+              truncateAtCodePointBoundary(reviewText, 12e3),
+              ``,
+              `--- Changed files ---`,
+              p.files.map((f) => `- ${f.path}`).join("\n"),
+              ``,
+              `Read each file, understand the issue, apply fixes using the edit tool.`,
+              `After fixing, run the project's typecheck and linter to verify.`,
+              `Do NOT remove or reorder existing code unless the bug requires it.`
+            ].join("\n");
+            try {
+              const fixCfg = {
+                name: "chimera-fix",
+                role: "fixer",
+                maxIterations: 60,
+                maxToolCalls: 350,
+                timeoutMs: 12e5
+              };
+              const fixSubagentId = await dir.spawn(fixCfg);
+              try {
+                const fixTaskId = randomUUID4();
+                await dir.assign({
+                  id: fixTaskId,
+                  description: fixTaskDesc,
+                  subagentId: fixSubagentId
+                });
+                const fixResults = await dir.awaitTasks([fixTaskId]);
+                const fixResult = fixResults[0];
+                if (fixResult?.status === "success") {
+                  await session.append({
+                    type: "llm_response",
+                    ts: (/* @__PURE__ */ new Date()).toISOString(),
+                    content: [
+                      { type: "text", text: `Chimera fix subagent completed: ${fixResult.result}` }
+                    ],
+                    stopReason: "end_turn",
+                    usage: { input: 0, output: 0 }
+                  });
+                } else {
+                  await session.append({
+                    type: "error",
+                    ts: (/* @__PURE__ */ new Date()).toISOString(),
+                    message: `Chimera fix subagent ${fixResult?.status ?? "unknown"}: ${fixResult?.error?.message ?? "no result"}`,
+                    phase: "agent"
+                  });
+                }
+              } finally {
+                try {
+                  await dir.terminate(fixSubagentId);
+                } catch {
+                }
+              }
+            } catch (fixErr) {
+              await session.append({
+                type: "error",
+                ts: (/* @__PURE__ */ new Date()).toISOString(),
+                message: `\u{1F982} Chimera auto-fix failed: ${fixErr instanceof Error ? fixErr.message : String(fixErr)}`,
+                phase: "agent"
+              });
+            }
+          }
+        }
+      } catch (err) {
+        try {
+          await session.append({
+            type: "error",
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            message: `\u{1F982} Chimera review failed: ${err instanceof Error ? err.message : String(err)}`,
+            phase: "agent"
+          });
+        } catch (appendErr) {
+          console.error(
+            JSON.stringify({
+              level: "error",
+              event: "execution.chimera_review_append_failed",
+              message: appendErr instanceof Error ? appendErr.message : String(appendErr),
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            })
+          );
+        }
+      } finally {
+        if (subagentId) {
+          try {
+            await dir.terminate(subagentId);
+          } catch {
+          }
+        }
+      }
+    })();
+  });
+  installChimeraCascadeHandler({
+    events,
+    director,
+    session,
+    getPendingWork: () => pendingChimeraWork,
+    setPendingWork: (work) => {
+      pendingChimeraWork = work;
+    }
+  });
+  let code = 0;
+  let fleetStatusLine = null;
+  try {
+    const visionAdapters = () => createToolVisionAdapters(agent.tools);
+    const supportsVision = async () => {
+      try {
+        const providerConfig = config.providers?.[context.provider.id];
+        const mergedModels = mergeCustomModelDefs(providerConfig?.customModels, config.models);
+        const caps = await capabilitiesFor(
+          modelsRegistry,
+          context.provider.id,
+          context.model,
+          mergedModels
+        );
+        return caps.vision;
+      } catch {
+        return context.provider.capabilities.vision;
+      }
+    };
+    const promptFlag = typeof flags["prompt"] === "string" ? flags["prompt"] : void 0;
+    if (promptFlag) {
+      positional.unshift(promptFlag);
+    }
+    const goalFlag = typeof flags["goal"] === "string" ? flags["goal"] : void 0;
+    const askFlag = typeof flags["ask"] === "string" ? flags["ask"] : void 0;
+    if ((goalFlag || askFlag) && positional.length === 0 && !promptFlag) {
+      flags.tui = true;
+    }
+    const executionMode = resolveExecutionMode(positional, flags);
+    const enteringTui = executionMode === "tui";
+    if (!enteringTui) {
+      fleetStatusLine = new FleetStatusLine({ events, version: CLI_VERSION });
+      fleetStatusLine.start();
+    }
+    if (executionMode === "single-shot") {
+      code = await runSingleShotDispatch({
+        agent,
+        query: positional.join(" "),
+        flags,
+        tokenCounter,
+        renderer
+      });
+    } else if (executionMode === "tui") {
+      agent.disableInteractiveConfirmation();
+      const state = {
+        projectRoot,
+        wpaths,
+        activeSessionStore,
+        activateSessionIdentity,
+        detachActiveTodosCheckpoint,
+        pendingProjectSwitch: null,
+        autonomousCoordinator: null,
+        coordinatorRun: null,
+        coordinatorEvents: /* @__PURE__ */ new Set()
+      };
+      const banneredFamily = savedProviderCfg?.family ?? resolvedProvider?.family;
+      const banneredKey = (savedProviderCfg ? resolveActiveApiKey(savedProviderCfg) : void 0) ?? config.apiKey ?? (resolvedProvider?.envVars ?? savedProviderCfg?.envVars ?? []).map((v) => process.env[v]).find((v) => !!v);
+      const banneredKeyTail = banneredKey && banneredKey.length >= 3 ? banneredKey.slice(-3) : void 0;
+      const goalWiring = wireGoal(events);
+      const subscribeGoal = goalWiring.subscribe;
+      const coordinatorEvents = /* @__PURE__ */ new Set();
+      state.coordinatorEvents = coordinatorEvents;
+      const autonomousCoordinationEnabled = config.features.autonomousCoordination !== false;
+      const coordinatorSetup = autonomousCoordinationEnabled ? setupAutonomousCoordinator({
+        state,
+        events,
+        context,
+        wpaths,
+        mailbox,
+        director,
+        getDirector,
+        coordinatorController,
+        onCoordinatorStopSetter: (fn) => {
+          onCoordinatorStopImpl = fn ?? void 0;
+        }
+      }) : {
+        ensure: () => null,
+        cleanup: () => void 0
+      };
+      const ensureAutonomousCoordinator = coordinatorSetup.ensure;
+      const offDirectorSpawned = coordinatorSetup.cleanup;
+      const switchCtx = {
+        state,
+        context,
+        events,
+        agent,
+        config,
+        tokenCounter,
+        modeId,
+        modeStore,
+        memoryStore,
+        skillLoader,
+        attachTodosCheckpoint: attachTodosCheckpoint2
+      };
+      const switchProjectInPlace2 = async (targetRoot, displayName) => {
+        return switchProjectInPlace(switchCtx, targetRoot, displayName);
+      };
+      const pickerCtx = {
+        state,
+        renderer,
+        director,
+        getEternalEngine,
+        getParallelEngine,
+        switchCtx,
+        switchProjectInPlace: switchProjectInPlace2
+      };
+      renderer.setTuiActive(true);
+      try {
+        code = await runTuiDispatch({
+          agent,
+          events,
+          slashRegistry,
+          secretInputController,
+          attachments,
+          tokenCounter,
+          visionAdapters,
+          supportsVision,
+          model: context.model,
+          banner: !flags["no-banner"],
+          queueStore,
+          onQueueChange: (items) => {
+            setQueuedMessagesSnapshot2(context, items);
+          },
+          mouse: flags.mouse ? true : void 0,
+          yolo: !!config.yolo,
+          getYolo,
+          onYolo,
+          getAutonomy,
+          ...createTuiNextStepCallbacks({
+            context,
+            getNextPredict,
+            getAutonomy,
+            getSuggestions: getSuggestions2
+          }),
+          getEternalEngine,
+          getSddRun,
+          onSddLifecycle,
+          subscribeEternalIteration,
+          subscribeEternalStage,
+          subscribeGoal,
+          appVersion: CLI_VERSION,
+          latestVersion: bootUpdateInfo?.latest,
+          updateAvailable: bootUpdateInfo?.outdated,
+          provider: config.provider,
+          family: banneredFamily,
+          keyTail: banneredKeyTail,
+          profile: profileName,
+          profileConfigPath: (() => {
+            const abs = wpaths.profileConfig(profileName);
+            const home = wpaths.homeDir;
+            return home && abs.startsWith(home) ? `~${abs.slice(home.length)}` : abs;
+          })(),
+          getPickableProviders,
+          switchProviderAndModel,
+          switchAutonomy: (mode) => {
+            onAutonomy?.(mode);
+            return null;
+          },
+          ...createSettingsAdapter({
+            configStore,
+            wpaths,
+            fleetStreamController,
+            applyLiveSettings
+          }),
+          effectiveMaxContext,
+          titleAnimation: config.autonomy?.["terminalTitleAnimation"] ?? true,
+          chime: config.autonomy?.["chime"] ?? false,
+          confirmExit: config.autonomy?.["confirmExit"] ?? true,
+          director,
+          getDirector,
+          fleetRoster,
+          ...createTuiCoordinatorCallbacks({
+            state,
+            context,
+            coordinatorEvents,
+            ensureAutonomousCoordinator
+          }),
+          onClearHistory: (dispatch) => {
+            dispatch({ type: "clearHistory", model: context.model, provider: context.provider.id });
+            dispatch({ type: "resetContextChip" });
+            dispatch({ type: "streamReset" });
+            dispatch({ type: "toolStreamClear" });
+          },
+          fleetStreamController,
+          interruptController,
+          enhanceController,
+          getEnhancerReasoning,
+          buildEnhancerProvider,
+          getEnhanceFallbackRef,
+          getConfiguredRefinerRef,
+          statuslineHiddenItems,
+          setStatuslineHiddenItems,
+          saveStatuslineHiddenItems,
+          getPluginItems,
+          onPluginToggle,
+          getMcpServers,
+          onMcpToggle,
+          onMcpRestart,
+          getToolsItems,
+          onToolToggle,
+          getBrainData,
+          onBrainRiskLevel,
+          brainPanelHost: brainRuntime ? createBrainPanelHost({ brainRuntime }) : void 0,
+          getShadowData,
+          onShadowStart,
+          onShadowStop,
+          authHost,
+          agentsMonitorController,
+          agentTranscripts,
+          getLiveSessions: () => getLiveSessions({ state }),
+          onSwitchToSession: (_sessionId, targetRoot, projectName) => onSwitchToSession({ state }, _sessionId, targetRoot, projectName),
+          initialGoal: goalFlag,
+          initialAsk: askFlag,
+          projectRoot,
+          appConfig: config,
+          hqTelemetryOwnedExternally: true,
+          getSessionId: () => agent.ctx.session?.id ?? session.id,
+          getSDDContext: () => getSDDContext(),
+          onSDDOutput: (output) => onSDDOutput(output),
+          modeLabel: modeId,
+          getModeLabel: () => {
+            const metaMode = context.meta?.["mode"];
+            return typeof metaMode === "string" ? metaMode : modeId ?? "default";
+          },
+          getModes: modeStore ? async () => {
+            const [modes, active] = await Promise.all([
+              modeStore.listModes(),
+              modeStore.getActiveMode()
+            ]);
+            return { modes, activeId: active?.id ?? null };
+          } : void 0,
+          switchMode: modeStore ? async (id) => {
+            const prev = await modeStore.getActiveMode();
+            await modeStore.setActiveMode(id);
+            const active = await modeStore.getActiveMode();
+            const from = prev?.id ?? "default";
+            if (agent.ctx.session && from !== id) {
+              void agent.ctx.session.append({ type: "mode_changed", ts: (/* @__PURE__ */ new Date()).toISOString(), from, to: id }).catch(() => {
+              });
+            }
+            return active?.name ?? null;
+          } : void 0,
+          registerDebugStreamCallback,
+          restoreDebugStreamCallback,
+          restoredMessages,
+          restoredToolCalls,
+          restoredEvents,
+          listSessions: async (limit = 20) => {
+            if (!activeSessionStore) return [];
+            const summaries = await activeSessionStore.list(limit);
+            const currentId = agent.ctx.session?.id ?? session.id;
+            return summaries.map((s) => ({
+              id: s.id,
+              title: s.title ?? "",
+              name: s.name,
+              lastUserMessage: s.lastUserMessage,
+              messageCount: s.messageCount,
+              lastActivityAt: s.lastActivityAt,
+              startedAt: s.startedAt ?? "",
+              endedAt: s.endedAt,
+              tokenTotal: s.tokenTotal ?? 0,
+              iterationCount: s.iterationCount ?? 0,
+              toolCallCount: s.toolCallCount ?? 0,
+              toolErrorCount: s.toolErrorCount ?? 0,
+              outcome: s.outcome,
+              isCurrent: s.id === currentId
+            }));
+          },
+          onResumeSession: (sessionId) => resumeSession(
+            { state, agent, tokenCounter, switchProviderAndModel, events },
+            sessionId
+          ),
+          getProjectPickerItems: () => getProjectPickerItems(pickerCtx),
+          onProjectSelect: (slug, kind) => onProjectSelect(pickerCtx, slug, kind),
+          initialAgentsMonitorOpen: !!flags.quick,
+          tokenSavingMode: normalizeTokenSavingTier2(config.features.tokenSavingMode),
+          toolCount: agent.tools.list().length,
+          onPanelOpen,
+          memoryStore
+        });
+        const spawnResult = await handleProjectSwitchSpawn({
+          code,
+          pendingProjectSwitch: state.pendingProjectSwitch
+        });
+        if (spawnResult !== null) return spawnResult;
+      } finally {
+        renderer.setTuiActive(false);
+        offDirectorSpawned();
+      }
+    } else if (executionMode === "webui") {
+      code = await runWebUIDispatch({
+        agent,
+        events,
+        session,
+        config,
+        flags,
+        projectRoot,
+        globalConfigPath: wpaths.globalConfig,
+        profileConfigPath: wpaths.profileConfig(profileName),
+        projectSessionsDir: wpaths.projectSessions,
+        modelsRegistry,
+        mcpRegistry,
+        brain,
+        brainSettings,
+        brainRuntime,
+        getBrainLog,
+        subscribeEternalIteration,
+        sessionStore: activeSessionStore,
+        memoryStore,
+        skillLoader,
+        promptLoader,
+        modeStore,
+        modeId,
+        needsSetup,
+        renderer,
+        onAutonomy,
+        applyLiveSettings,
+        activateSessionIdentity,
+        rebindTodosCheckpoint,
+        agentTranscripts,
+        onModelContextResolved,
+        sddSubagentFactory,
+        statusTracker,
+        ...createKanbanDispatchHandler({ config, events, skillLoader, sddSubagentFactory })
+      });
+    } else {
+      const headlessKanbanMirror = projectRoot ? (await import("./kanban-run-mirror-EKVNGXWW.js")).createKanbanRunMirror({
+        projectRoot,
+        events,
+        broadcast: () => {
+        },
+        log: (m) => console.log(m)
+      }) : null;
+      try {
+        code = await runRepl({
+          agent,
+          renderer,
+          reader,
+          slashRegistry,
+          tokenCounter,
+          visionAdapters,
+          supportsVision,
+          attachments,
+          effectiveMaxContext,
+          getEffectiveMaxContext,
+          projectName: path10.basename(projectRoot) || void 0,
+          projectRoot,
+          appConfig: config,
+          getSessionId: () => agent.ctx.session?.id ?? session.id,
+          getAutonomy,
+          onAutonomy,
+          getNextPredict,
+          onSuggestionsParsed,
+          getSuggestions: getSuggestions2,
+          getAutoSuggestions,
+          getYolo,
+          autonomyNextPrompt,
+          autoProceedDelayMs,
+          onValidateAutoProceed,
+          autoProceedMaxIterations,
+          getEternalEngine,
+          getParallelEngine,
+          getSddRun,
+          skillLoader,
+          agentsMonitorController,
+          fleetStreamController,
+          interruptController,
+          ...createReplFleetCallbacks({ director, getDirector }),
+          onCountdownTick,
+          onDestroy
+        });
+      } finally {
+        headlessKanbanMirror?.dispose();
+      }
+    }
+  } finally {
+    await finalizeExecutionCleanup({
+      offStorageObservability,
+      fleetStatusLine,
+      onCoordinatorStop: onCoordinatorStopImpl,
+      stats,
+      renderer,
+      detachTodosCheckpoint,
+      mcpRegistry,
+      agent,
+      session,
+      tokenCounter,
+      events,
+      getPendingChimeraWork: () => pendingChimeraWork,
+      director,
+      reader
+    });
+  }
+  return code;
+}
+export {
+  CHIMERA_REVIEW_READ_ONLY_TOOLS,
+  __resetReviewerRoundRobinCursor,
+  applyChimeraReviewerReadOnlyPolicy,
+  assignReviewerModelsRoundRobin,
+  execute,
+  resolveReviewerFallbackModels
+};
+//# sourceMappingURL=execution-O7I5DYE6.js.map