@wrongstack/cli 0.148.0 → 0.155.0

package/dist/index.js

@@ -1,15 +1,16 @@
 #!/usr/bin/env node
-import { color, writeErr, renderProgress, SpecStore, TaskGraphStore, analyzeCriticalPath, getTemplate, listTemplates, templateToMarkdown, SpecParser, renderSpecAnalysis, AISpecBuilder, expectDefined, DefaultTaskStore, TaskTracker, renderTaskGraph, DefaultSecretScrubber, DefaultPathResolver, EventBus, TOKENS, mergeCustomModelDefs, DefaultSystemPromptBuilder, makeAutonomyPromptContributor, ToolRegistry, createContextManagerTool, resolveSessionLoggingConfig, createSessionEventBridge, HookRegistry, HookRunner, SlashCommandRegistry, SessionMemoryConsolidator, BrainDecisionQueue, ObservableBrainArbiter, HumanEscalatingBrainArbiter, DefaultBrainArbiter, createDelegateTool, FLEET_ROSTER, createMcpControlTool, SpecVersioning, atomicWrite, DefaultLogger, DefaultModelsRegistry, isStdinTTY, writeOut, runProviderWithRetry, ReplayLogStore, ReplayProviderRunner, ProviderRegistry, InMemoryMetricsSink, wireMetricsToEvents, DefaultHealthRegistry, startMetricsServer, DEFAULT_SESSION_PRUNE_DAYS, RecoveryLock, DefaultAttachmentStore, QueueStore, Context, loadTodosCheckpoint, attachTodosCheckpoint, loadDirectorState, loadPlan, createDefaultPipelines, resolveContextWindowPolicy, resolveAuditLevel, AutoCompactionMiddleware, estimateRequestTokensCalibrated, Agent, loadPlugins, FleetManager, makeDirectorSessionFactory, Director, makeFleetEmitTool, makeFleetStatusTool, resolveModelMatrix, DEFAULT_SUBAGENT_BASELINE, AutoApprovePermissionPolicy, PhaseStore, AutoPhasePlanner, PhaseGraphBuilder, WorktreeManager, PhaseOrchestrator, makeLLMClassifier, ParallelEternalEngine, EternalAutonomyEngine, allServers as allServers$1, decryptConfigSecrets as decryptConfigSecrets$1, encryptConfigSecrets as encryptConfigSecrets$1, bootConfig as bootConfig$1, setOutputLineGuard, setRawMode, DefaultSessionReader, resolveWstackPaths, ToolAuditLog, DefaultSessionRewinder, DefaultSessionStore, DefaultPluginAPI, StreamHangError, ProviderError, makeAgentSubagentRunner, NULL_FLEET_BUS, buildChildEnv, formatContextWindowModeList, repairToolUseAdjacency, getContextWindowMode, AGENTS_BY_PHASE, dispatchAgent, formatTodosList, loadTasks, emptyTaskFile, saveTasks, formatTaskProgress, formatTaskList, SessionRecovery, loadGoal, goalFilePath, summarizeUsage, saveGoal, formatGoal, emptyGoal, buildGoalPreamble, pendingBtwCount, setBtwNote, MATRIX_PHASE_KEYS, AGENT_CATALOG, matrixKeyKind, phaseForRole, onResize, ERROR_CODES, InputBuilder, FsError, estimateMessageTokens } from '@wrongstack/core';
 import * as fsp4 from 'fs/promises';
-import { DefaultSecretVault, decryptConfigSecrets, encryptConfigSecrets, isSecretField } from '@wrongstack/core/security';
 import * as path10 from 'path';
 import { join } from 'path';
+import { color, writeErr, expectDefined, atomicWrite, renderProgress, SpecStore, TaskGraphStore, analyzeCriticalPath, getTemplate, listTemplates, templateToMarkdown, SpecParser, renderSpecAnalysis, AISpecBuilder, DefaultTaskStore, TaskTracker, renderTaskGraph, DefaultSecretScrubber, resolveContextWindowPolicy, DEFAULT_CONTEXT_WINDOW_MODE_ID, listContextWindowModes, repairToolUseAdjacency, TOKENS, DefaultPathResolver, EventBus, mergeCustomModelDefs, DefaultSystemPromptBuilder, makeAutonomyPromptContributor, ToolRegistry, createContextManagerTool, resolveSessionLoggingConfig, createSessionEventBridge, HookRegistry, HookRunner, SlashCommandRegistry, SessionMemoryConsolidator, BrainDecisionQueue, ObservableBrainArbiter, HumanEscalatingBrainArbiter, DefaultBrainArbiter, createDelegateTool, FLEET_ROSTER, createMcpControlTool, SpecVersioning, DefaultLogger, DefaultModelsRegistry, isStdinTTY, writeOut, runProviderWithRetry, ReplayLogStore, ReplayProviderRunner, ProviderRegistry, InMemoryMetricsSink, wireMetricsToEvents, DefaultHealthRegistry, startMetricsServer, DEFAULT_SESSION_PRUNE_DAYS, RecoveryLock, DefaultAttachmentStore, QueueStore, Context, loadTodosCheckpoint, attachTodosCheckpoint, loadDirectorState, loadPlan, createDefaultPipelines, resolveAuditLevel, AutoCompactionMiddleware, estimateRequestTokensCalibrated, Agent, loadPlugins, FleetManager, makeDirectorSessionFactory, Director, makeFleetEmitTool, makeFleetStatusTool, resolveModelMatrix, DEFAULT_SUBAGENT_BASELINE, AutoApprovePermissionPolicy, PhaseStore, AutoPhasePlanner, PhaseGraphBuilder, WorktreeManager, PhaseOrchestrator, makeLLMClassifier, ParallelEternalEngine, EternalAutonomyEngine, allServers as allServers$1, noOpVault, decryptConfigSecrets as decryptConfigSecrets$1, encryptConfigSecrets as encryptConfigSecrets$1, bootConfig as bootConfig$1, setOutputLineGuard, setRawMode, DefaultSessionReader, resolveWstackPaths, ToolAuditLog, DefaultSessionRewinder, DefaultSessionStore as DefaultSessionStore$1, DefaultPluginAPI, StreamHangError, ProviderError, makeAgentSubagentRunner, NULL_FLEET_BUS, buildChildEnv, formatContextWindowModeList, getContextWindowMode, AGENT_CATALOG, dispatchAgent, formatTodosList, loadTasks, emptyTaskFile, saveTasks, formatTaskProgress, formatTaskList, SessionRecovery, loadGoal, goalFilePath, summarizeUsage, saveGoal, formatGoal, emptyGoal, buildGoalPreamble, pendingBtwCount, setBtwNote, MATRIX_PHASE_KEYS, matrixKeyKind, phaseForRole, onResize, ERROR_CODES, InputBuilder, FsError, estimateMessageTokens, AGENTS_BY_PHASE } from '@wrongstack/core';
+import { decryptConfigSecrets, encryptConfigSecrets, DefaultSecretVault, isSecretField } from '@wrongstack/core/security';
 import { createRequire } from 'module';
 import * as os2 from 'os';
 import os2__default from 'os';
 import * as crypto2 from 'crypto';
 import { randomUUID } from 'crypto';
 import { findFreePort, createHttpServer, openBrowser, registerInstance, unregisterInstance } from '@wrongstack/webui/server';
+import { DefaultSessionStore } from '@wrongstack/core/storage';
 import { WebSocketServer, WebSocket } from 'ws';
 import { spawn, exec, execFileSync } from 'child_process';
 import { MCPRegistry, MCPServer, serveHttp, serveStdio } from '@wrongstack/mcp';
@@ -36,6 +37,218 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+function parseSubcommand(args) {
+  const parts = args.trim().split(/\s+/);
+  return { cmd: (parts[0] ?? "").toLowerCase(), rest: parts.slice(1) };
+}
+function unknownSubcommand(cmd, valid, name) {
+  const list = valid.join(", ");
+  return name ? `Unknown subcommand "${cmd}" for /${name}. Valid: ${list}.` : `Unknown subcommand "${cmd}". Valid: ${list}.`;
+}
+async function pathExists(file) {
+  try {
+    await fsp4.access(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function detectPackageManager(root, declared) {
+  if (declared) {
+    const name = declared.split("@")[0];
+    if (name) return name;
+  }
+  if (await pathExists(path10.join(root, "pnpm-lock.yaml"))) return "pnpm";
+  if (await pathExists(path10.join(root, "bun.lockb"))) return "bun";
+  if (await pathExists(path10.join(root, "bun.lock"))) return "bun";
+  if (await pathExists(path10.join(root, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+function hasUsableScript(scripts, name) {
+  const script = scripts[name];
+  if (typeof script !== "string" || script.trim() === "") return false;
+  if (name === "test" && /no test specified/i.test(script)) return false;
+  return true;
+}
+function parseMakeTargets(makefile) {
+  const targets = /* @__PURE__ */ new Set();
+  for (const line of makefile.split(/\r?\n/)) {
+    if (line.startsWith("	") || line.trimStart().startsWith("#")) continue;
+    const match = /^([A-Za-z0-9_.-]+)\s*:(?![=])/.exec(line);
+    if (match?.[1]) targets.add(match[1]);
+  }
+  return targets;
+}
+async function detectProjectFacts(root) {
+  const facts = { hints: [] };
+  try {
+    const pkg = JSON.parse(await fsp4.readFile(path10.join(root, "package.json"), "utf8"));
+    const scripts = pkg.scripts ?? {};
+    const pm = await detectPackageManager(root, pkg.packageManager);
+    if (hasUsableScript(scripts, "build")) facts.build = `${pm} run build`;
+    if (hasUsableScript(scripts, "test")) facts.test = `${pm} test`;
+    if (hasUsableScript(scripts, "lint")) facts.lint = `${pm} run lint`;
+    const runScript = ["dev", "start", "serve", "preview"].find(
+      (name) => hasUsableScript(scripts, name)
+    );
+    if (runScript) facts.run = `${pm} run ${runScript}`;
+    facts.hints.push(Object.keys(scripts).length > 0 ? "package.json scripts" : "package.json");
+  } catch {
+  }
+  try {
+    if (!await pathExists(path10.join(root, "pyproject.toml"))) throw new Error("not python");
+    facts.test ??= "pytest";
+    facts.lint ??= "ruff check .";
+    facts.hints.push("pyproject.toml");
+  } catch {
+  }
+  try {
+    if (!await pathExists(path10.join(root, "go.mod"))) throw new Error("not go");
+    facts.build ??= "go build ./...";
+    facts.test ??= "go test ./...";
+    facts.run ??= "go run .";
+    facts.hints.push("go.mod");
+  } catch {
+  }
+  try {
+    if (!await pathExists(path10.join(root, "Cargo.toml"))) throw new Error("not rust");
+    facts.build ??= "cargo build";
+    facts.test ??= "cargo test";
+    facts.lint ??= "cargo clippy";
+    facts.run ??= "cargo run";
+    facts.hints.push("Cargo.toml");
+  } catch {
+  }
+  try {
+    const makefile = await fsp4.readFile(path10.join(root, "Makefile"), "utf8");
+    const targets = parseMakeTargets(makefile);
+    facts.build ??= targets.has("build") ? "make build" : "make";
+    if (targets.has("test")) facts.test ??= "make test";
+    if (targets.has("lint")) facts.lint ??= "make lint";
+    const runTarget = ["run", "dev", "start", "serve"].find((name) => targets.has(name));
+    if (runTarget) facts.run ??= `make ${runTarget}`;
+    facts.hints.push("Makefile");
+  } catch {
+  }
+  return facts;
+}
+function renderAgentsTemplate(f) {
+  const cmd = (s) => s ? `\`${s}\`` : "_TODO_";
+  const hints = f.hints.length > 0 ? `
+
+> Auto-detected: ${f.hints.join(", ")}` : "";
+  return `# AGENTS.md
+
+> **DO NOT DELETE THIS FILE.** It is loaded into WrongStack's system prompt as
+> persistent project context. Previous content here may contain decisions,
+> architecture notes, domain knowledge, or verification history that should be
+> preserved. Merge additions rather than replacing.
+
+## Project brief
+
+- **Purpose:** _What does this project do and why does it exist?_
+- **Primary users:** _Who uses it: developers, operators, customers, internal systems?_
+- **Runtime / deployment:** _CLI, server, browser, worker, library, package?_${hints}
+
+## How to work safely
+
+- _Project-specific rules the agent should always follow._
+- _Files, generated artifacts, migrations, or config the agent should not edit without asking._
+- _Preferred style or architecture choices not obvious from the code._
+- _Known fragile areas or historical bugs that deserve extra caution._
+
+## Commands
+
+| Command | Script |
+|---------|--------|
+| Build | ${cmd(f.build)} |
+| Test | ${cmd(f.test)} |
+| Lint | ${cmd(f.lint)} |
+| Run locally | ${cmd(f.run)} |
+
+## Key files and entry points
+
+| File / directory | Role |
+|---|---|
+| _src/_ | _Main source entry point(s)_ |
+| _tests/_ | _Test root or convention_ |
+| _docs/_ | _Architecture, runbooks, design notes_ |
+| _scripts/_ | _Automation scripts (CI, release, install, etc.)_ |
+
+## Architecture notes
+
+_Summarize the important modules, data flow, boundaries, and ownership rules.
+Mention anything a newcomer might misread or that looks unusual but is intentional._
+
+### Dependency layers
+
+_Describe the key dependency direction or layered structure, e.g.: "core has no
+runtime deps; cli assembles everything above it."_
+
+### Extension points
+
+_Plugin, MCP, extension hooks, custom tools \u2014 what's wired up and how._
+
+## Domain knowledge
+
+_Business rules, acronyms, invariants, external services, and notes where the
+code looks unusual but is intentional. E.g.: "IDs are ULIDs, not UUIDs", "the
+\`draft\` flag means uncommitted billing metadata", "MCP servers are restarted
+on disconnect with exponential backoff, up to 3 attempts"._
+
+## Verification checklist
+
+- _What should be run after code changes?_
+- _What manual smoke test proves the common path still works?_
+- _What failure modes deserve extra attention?_
+- _Any known flaky tests or environment-dependent behavior?_
+
+## Useful pointers
+
+- _Docs, dashboards, runbooks, issue trackers, design notes, owner contacts._
+- _Related projects or repositories._`;
+}
+function countTurnPairs(messages) {
+  let count = 0;
+  for (const m of messages) {
+    if (m.role === "user" || m.role === "assistant") count++;
+  }
+  return Math.floor(count / 2);
+}
+function countToolUses(messages) {
+  let count = 0;
+  for (const m of messages) {
+    if (Array.isArray(m.content)) count += m.content.filter((b) => b.type === "tool_use").length;
+  }
+  return count;
+}
+function countToolResults(messages) {
+  let count = 0;
+  for (const m of messages) {
+    if (Array.isArray(m.content)) count += m.content.filter((b) => b.type === "tool_result").length;
+  }
+  return count;
+}
+function estimateTokens(messages) {
+  return estimateMessageTokens(messages);
+}
+var init_helpers = __esm({
+  "src/slash-commands/helpers.ts"() {
+  }
+});
+
+// src/provider-config-utils.ts
+var provider_config_utils_exports = {};
+__export(provider_config_utils_exports, {
+  activeLabel: () => activeLabel,
+  expectDefined: () => expectDefined,
+  loadConfigProviders: () => loadConfigProviders,
+  maskedKey: () => maskedKey,
+  mutateConfigProviders: () => mutateConfigProviders,
+  normalizeKeys: () => normalizeKeys,
+  nowIso: () => nowIso,
+  writeKeysBack: () => writeKeysBack
+});
 function normalizeKeys(cfg) {
   if (Array.isArray(cfg.apiKeys) && cfg.apiKeys.length > 0) {
     return cfg.apiKeys.map((k) => ({ ...k }));
@@ -655,17 +868,17 @@ function buildSddCommand(opts) {
       const specsDir = opts.paths.projectSpecs;
       const specStore = new SpecStore({ baseDir: specsDir });
       const versioning = sddState.getVersioning();
-      const [verb, ...rest] = args.trim().split(/\s+/);
-      const restJoined = rest.join(" ").trim();
-      switch (verb) {
+      const { cmd, rest: restArgs } = parseSubcommand(args);
+      const restJoined = restArgs.join(" ").trim();
+      switch (cmd) {
         case "":
         case "help":
           return { message: sddHelp() };
         // ── AI-Driven Spec Session ─────────────────────────────────────────
         case "new":
         case "create": {
-          const forceFlag = rest.includes("--force") || rest.includes("-f");
-          const title = rest.filter((a) => !a.startsWith("-")).join(" ").trim() || "Untitled Feature";
+          const forceFlag = restArgs.includes("--force") || restArgs.includes("-f");
+          const title = restArgs.filter((a) => !a.startsWith("-")).join(" ").trim() || "Untitled Feature";
           if (!sessionState.getBuilder() && !forceFlag) {
             const sessionPath = opts.paths.projectSddSession;
             try {
@@ -1571,7 +1784,7 @@ ${lines.join("\n")}`
         }
         default:
           return {
-            message: `Unknown command "${verb}".
+            message: `${unknownSubcommand(cmd, ["new", "approve", "execute", "cancel", "status", "list", "show", "templates", "resume"], "sdd")}
 
 ${sddHelp()}`
           };
@@ -1581,6 +1794,7 @@ ${sddHelp()}`
 }
 var init_sdd = __esm({
   "src/slash-commands/sdd.ts"() {
+    init_helpers();
     init_state();
     init_task_manager();
     init_project_context();
@@ -1722,6 +1936,91 @@ var webui_server_exports = {};
 __export(webui_server_exports, {
   runWebUI: () => runWebUI
 });
+function isHiddenEntry(name) {
+  return name.startsWith(".") && !KEEP_DOTFILES.has(name);
+}
+function rankFiles(paths, query, limit) {
+  const q = query.toLowerCase();
+  const scored = [];
+  for (const p of paths) {
+    if (!q) {
+      scored.push({ path: p, score: 0 });
+      continue;
+    }
+    const lower = p.toLowerCase();
+    const base = lower.split("/").pop() ?? lower;
+    let score = 0;
+    if (base === q) score = 100;
+    else if (base.startsWith(q)) score = 60;
+    else if (lower.includes(q)) score = 20;
+    else continue;
+    score -= p.split("/").length;
+    scored.push({ path: p, score });
+  }
+  scored.sort((a, b) => b.score - a.score || a.path.localeCompare(b.path));
+  return scored.slice(0, limit).map((s) => s.path);
+}
+function estimateTokens2(s) {
+  return Math.ceil(s.length / 4);
+}
+function stringifyContent(c) {
+  if (typeof c === "string") return c;
+  try {
+    return JSON.stringify(c);
+  } catch {
+    return String(c);
+  }
+}
+function messageTokens(content) {
+  if (typeof content === "string") return estimateTokens2(content);
+  if (!Array.isArray(content)) return 0;
+  let tk = 0;
+  for (const b of content) {
+    if (b.type === "text") tk += estimateTokens2(b.text ?? "");
+    else if (b.type === "tool_use") tk += estimateTokens2(stringifyContent(b.input));
+    else if (b.type === "tool_result") tk += estimateTokens2(stringifyContent(b.content));
+    else tk += estimateTokens2(stringifyContent(b));
+  }
+  return tk;
+}
+function messagePreview(content) {
+  if (typeof content === "string") return content.slice(0, 60);
+  if (!Array.isArray(content)) return "";
+  return content.map((b) => b.type === "text" ? (b.text ?? "").slice(0, 40) : b.type === "tool_use" ? `[tool_use: ${b.name}]` : b.type === "tool_result" ? "[tool_result]" : `[${b.type}]`).join(" ").slice(0, 60);
+}
+function estimateContextBreakdown(input) {
+  const sysTokens = input.systemPrompt.reduce((acc, b) => acc + estimateTokens2(b.text ?? ""), 0);
+  const toolBreakdown = input.tools.map((t) => {
+    const schema = t.inputSchema ?? {};
+    const desc = t.description ?? "";
+    return { name: t.name, tokens: estimateTokens2(t.name) + estimateTokens2(desc) + estimateTokens2(stringifyContent(schema)) };
+  });
+  const toolTokens = toolBreakdown.reduce((a, b) => a + b.tokens, 0);
+  const messageBreakdown = input.messages.map((m, i) => ({
+    index: i,
+    role: m.role,
+    tokens: messageTokens(m.content),
+    preview: messagePreview(m.content)
+  }));
+  const msgTokens = messageBreakdown.reduce((a, b) => a + b.tokens, 0);
+  return {
+    total: sysTokens + toolTokens + msgTokens,
+    systemPrompt: sysTokens,
+    tools: { total: toolTokens, count: input.tools.length, breakdown: toolBreakdown },
+    messages: { total: msgTokens, count: input.messages.length, breakdown: messageBreakdown }
+  };
+}
+function getCostRates(model) {
+  const cost = model?.cost;
+  return {
+    input: cost?.input ?? 0,
+    output: cost?.output ?? 0,
+    cacheRead: cost?.cache_read ?? 0
+  };
+}
+function computeUsageCost(usage, rates) {
+  return (usage.input * rates.input + usage.output * rates.output + (usage.cacheRead ?? 0) * rates.cacheRead) / 1e6;
+}
 async function runWebUI(opts) {
   const host = "127.0.0.1";
   const requestedWsPort = opts.port ?? 3457;
@@ -2069,7 +2368,9 @@ async function runWebUI(opts) {
           sessionId: opts.session.id,
           model: opts.agent.ctx.model,
           provider: opts.agent.ctx.provider.id,
-          wsToken: authToken
+          wsToken: authToken,
+          mode: opts.modeId ?? "default",
+          projectName: opts.projectRoot ? path10.basename(opts.projectRoot) : void 0
         }
       });
     });
@@ -2159,50 +2460,729 @@ async function runWebUI(opts) {
         await handleProviderRemove(ws, m.payload.providerId);
         break;
       }
-      default: {
-        console.debug(
-          `[WebUI] Unhandled message type: ${String(msg.type)}`
-        );
+      case "todos.get": {
+        send(ws, {
+          type: "todos.updated",
+          payload: { todos: [...opts.agent.ctx.todos] }
+        });
         break;
       }
-    }
-  }
-  async function handleUserMessage(ws, _client, content) {
-    if (abortController) {
-      send(ws, {
-        type: "error",
-        payload: { phase: "agent.run", message: "A run is already in progress. Abort it first." }
-      });
-      return;
-    }
-    abortController = new AbortController();
-    try {
-      const result = await opts.agent.run(content, {
-        signal: abortController.signal
-      });
-      send(ws, {
-        type: "run.result",
-        payload: {
-          status: result.status,
-          iterations: result.iterations,
-          finalText: result.finalText,
-          error: result.error ? {
-            code: result.error.code,
-            message: result.error.message,
-            recoverable: result.error.recoverable
-          } : void 0
-        }
-      });
-    } catch (err) {
-      send(ws, {
-        type: "error",
-        payload: {
-          phase: "agent.run",
-          message: err instanceof Error ? err.message : String(err)
+      case "goal.get": {
+        const projectRoot = opts.projectRoot ?? opts.agent.ctx.projectRoot;
+        try {
+          const goalPath = path10.join(projectRoot, ".wrongstack", "goal.json");
+          const raw = await fsp4.readFile(goalPath, "utf8");
+          const goal = JSON.parse(raw);
+          broadcast({ type: "goal.updated", payload: goal });
+        } catch {
+          broadcast({ type: "goal.updated", payload: null });
         }
-      });
-    } finally {
-      abortController = null;
+        break;
+      }
+      case "sessions.list": {
+        const projectRoot = opts.projectRoot ?? opts.agent.ctx.projectRoot;
+        const sessionsDir = path10.join(projectRoot, ".wrongstack", "sessions");
+        const limit = msg.payload?.limit ?? 50;
+        try {
+          const store = new DefaultSessionStore({ dir: sessionsDir });
+          const list = await store.list(limit);
+          send(ws, {
+            type: "sessions.list",
+            payload: {
+              sessions: list.map((s) => ({
+                id: s.id,
+                title: s.title,
+                startedAt: s.startedAt,
+                model: s.model,
+                provider: s.provider,
+                tokenTotal: s.tokenTotal,
+                isCurrent: s.id === opts.session.id
+              }))
+            }
+          });
+        } catch (err) {
+          send(ws, {
+            type: "sessions.list",
+            payload: { sessions: [], error: err instanceof Error ? err.message : String(err) }
+          });
+        }
+        break;
+      }
+      case "session.new": {
+        const ctx = opts.agent.ctx;
+        ctx.state.replaceMessages([]);
+        ctx.state.replaceTodos([]);
+        ctx.readFiles.clear();
+        ctx.fileMtimes.clear();
+        broadcast({
+          type: "session.start",
+          payload: {
+            sessionId: opts.session.id,
+            model: ctx.model,
+            provider: opts.agent.ctx.provider.id,
+            reset: true
+          }
+        });
+        break;
+      }
+      case "todos.clear": {
+        opts.agent.ctx.state.replaceTodos([]);
+        sendResult(ws, true, "Todos cleared");
+        broadcast({ type: "todos.updated", payload: { todos: [] } });
+        break;
+      }
+      case "todos.remove": {
+        const payload = msg.payload;
+        if (!payload) {
+          sendResult(ws, false, "Missing id or index");
+          break;
+        }
+        const { id, index } = payload;
+        const todos = opts.agent.ctx.todos;
+        let targetIdx = -1;
+        if (typeof id === "string") {
+          targetIdx = todos.findIndex((t) => t.id === id);
+        } else if (typeof index === "number" && index > 0) {
+          targetIdx = index - 1;
+        }
+        if (targetIdx < 0 || !todos[targetIdx]) {
+          sendResult(ws, false, "Todo not found");
+          break;
+        }
+        const removed = expectDefined(todos[targetIdx]);
+        const next = [...todos.slice(0, targetIdx), ...todos.slice(targetIdx + 1)];
+        opts.agent.ctx.state.replaceTodos(next);
+        sendResult(ws, true, `Removed: ${removed.content}`);
+        broadcast({ type: "todos.updated", payload: { todos: next } });
+        break;
+      }
+      case "context.clear": {
+        const ctx = opts.agent.ctx;
+        ctx.state.replaceMessages([]);
+        ctx.state.replaceTodos([]);
+        ctx.readFiles.clear();
+        ctx.fileMtimes.clear();
+        sendResult(ws, true, "Context cleared");
+        broadcast({
+          type: "session.start",
+          payload: {
+            sessionId: opts.session.id,
+            model: ctx.model,
+            provider: ctx.provider.id,
+            reset: true
+          }
+        });
+        break;
+      }
+      case "process.list": {
+        try {
+          const { getProcessRegistry } = await import('@wrongstack/tools');
+          const procs = getProcessRegistry().list();
+          send(ws, {
+            type: "process.list",
+            payload: {
+              processes: procs.map((p) => ({
+                pid: p.pid,
+                command: p.command,
+                tool: p.name,
+                startedAt: p.startedAt,
+                status: p.killed ? "killed" : "running",
+                protected: p.protected
+              }))
+            }
+          });
+        } catch {
+          send(ws, { type: "process.list", payload: { processes: [] } });
+        }
+        break;
+      }
+      case "process.kill": {
+        const { pid } = msg.payload;
+        try {
+          const { getProcessRegistry } = await import('@wrongstack/tools');
+          const proc = getProcessRegistry().get(pid);
+          if (proc?.protected) {
+            sendResult(ws, false, `Cannot kill protected process (PID ${pid})`);
+            break;
+          }
+          getProcessRegistry().kill(pid);
+          sendResult(ws, true, `Killed PID ${pid}`);
+        } catch (err) {
+          sendResult(ws, false, err instanceof Error ? err.message : String(err));
+        }
+        break;
+      }
+      case "process.killAll": {
+        try {
+          const { getProcessRegistry } = await import('@wrongstack/tools');
+          getProcessRegistry().killAll();
+          sendResult(ws, true, "All processes killed");
+        } catch (err) {
+          sendResult(ws, false, err instanceof Error ? err.message : String(err));
+        }
+        break;
+      }
+      case "diag.get": {
+        const ctx = opts.agent.ctx;
+        const tools = opts.agent.tools.list();
+        send(ws, {
+          type: "diag.get",
+          payload: {
+            provider: ctx.provider.id,
+            model: ctx.model,
+            cwd: opts.projectRoot ?? ctx.projectRoot,
+            sessionId: opts.session.id,
+            tools: {
+              count: tools.length,
+              names: tools.map((t) => t.name)
+            },
+            features: {},
+            mode: "default",
+            usage: ctx.tokenCounter.total(),
+            messages: ctx.messages.length,
+            todos: ctx.todos.length
+          }
+        });
+        break;
+      }
+      case "stats.get": {
+        const ctx = opts.agent.ctx;
+        const usage = ctx.tokenCounter.total();
+        const cacheStats = ctx.tokenCounter.cacheStats();
+        let cost = null;
+        try {
+          if (opts.modelsRegistry) {
+            const model = await opts.modelsRegistry.getModel(
+              ctx.provider.id,
+              ctx.model
+            );
+            const rates = getCostRates(model);
+            cost = computeUsageCost(
+              { input: usage.input, output: usage.output, cacheRead: cacheStats.readTokens },
+              rates
+            );
+          }
+        } catch {
+        }
+        send(ws, {
+          type: "stats.get",
+          payload: {
+            sessionId: opts.session.id,
+            provider: ctx.provider.id,
+            model: ctx.model,
+            usage,
+            cache: cacheStats,
+            cost,
+            messages: ctx.messages.length,
+            readFiles: ctx.readFiles.size,
+            tools: opts.agent.tools.list().length,
+            elapsedMs: 0
+          }
+        });
+        break;
+      }
+      case "autonomy.switch": {
+        const { mode } = msg.payload;
+        opts.agent.ctx.meta["autonomy"] = mode;
+        sendResult(ws, true, `Autonomy mode set to "${mode}"`);
+        break;
+      }
+      case "tools.list": {
+        const list = opts.agent.tools.list().map((t) => {
+          const schema = t.inputSchema ?? {};
+          const params = schema.properties ? Object.keys(schema.properties) : [];
+          return {
+            name: t.name,
+            description: t.description ?? "",
+            params
+          };
+        });
+        send(ws, { type: "tools.list", payload: { tools: list } });
+        break;
+      }
+      case "session.checkpoints": {
+        const projectRoot = opts.projectRoot ?? opts.agent.ctx.projectRoot;
+        try {
+          const { DefaultSessionRewinder: DefaultSessionRewinder2 } = await import('@wrongstack/core');
+          const rewinder = new DefaultSessionRewinder2(
+            path10.join(projectRoot, ".wrongstack", "sessions"),
+            projectRoot
+          );
+          const checkpoints = await rewinder.listCheckpoints(opts.session.id);
+          send(ws, {
+            type: "session.checkpoints",
+            payload: { checkpoints }
+          });
+        } catch {
+          send(ws, {
+            type: "session.checkpoints",
+            payload: { checkpoints: [] }
+          });
+        }
+        break;
+      }
+      case "files.list": {
+        const projectRoot = opts.projectRoot ?? opts.agent.ctx.projectRoot;
+        const payload = msg.payload ?? {};
+        const limit = payload.limit ?? 50;
+        const results = [];
+        async function walk(dir, rel, depth) {
+          if (depth > 8 || results.length >= 600) return;
+          let entries = [];
+          try {
+            entries = await fsp4.readdir(dir, { withFileTypes: true });
+          } catch {
+            return;
+          }
+          for (const e of entries) {
+            if (results.length >= 600) return;
+            if (isHiddenEntry(e.name)) continue;
+            const childRel = rel ? `${rel}/${e.name}` : e.name;
+            if (e.isDirectory()) {
+              if (SKIP_DIRS.has(e.name)) continue;
+              await walk(path10.join(dir, e.name), childRel, depth + 1);
+            } else if (e.isFile()) {
+              results.push(childRel);
+            }
+          }
+        }
+        await walk(projectRoot, "", 0);
+        send(ws, {
+          type: "files.list",
+          payload: { files: rankFiles(results, payload.query ?? "", limit) }
+        });
+        break;
+      }
+      case "session.delete": {
+        const { id } = msg.payload;
+        if (id === opts.session.id) {
+          sendResult(ws, false, "Cannot delete the active session");
+          break;
+        }
+        const projectRoot = opts.projectRoot ?? opts.agent.ctx.projectRoot;
+        try {
+          const store = new DefaultSessionStore({
+            dir: path10.join(projectRoot, ".wrongstack", "sessions")
+          });
+          await store.delete(id);
+          sendResult(ws, true, `Session ${id} deleted`);
+        } catch (err) {
+          sendResult(ws, false, err instanceof Error ? err.message : String(err));
+        }
+        break;
+      }
+      case "session.save":
+        sendResult(ws, true, `Session ${opts.session.id} is auto-saved`);
+        break;
+      case "plan.get": {
+        const planPath = opts.agent.ctx.meta["plan.path"];
+        if (typeof planPath === "string" && planPath) {
+          try {
+            const { loadPlan: loadPlan2 } = await import('@wrongstack/core');
+            const plan = await loadPlan2(planPath);
+            send(ws, {
+              type: "plan.updated",
+              payload: {
+                plan: plan ?? {
+                  version: 1,
+                  sessionId: opts.session.id,
+                  updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+                  items: []
+                }
+              }
+            });
+          } catch {
+            send(ws, {
+              type: "plan.updated",
+              payload: {
+                plan: {
+                  version: 1,
+                  sessionId: opts.session.id,
+                  updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+                  items: []
+                }
+              }
+            });
+          }
+        } else {
+          send(ws, {
+            type: "plan.updated",
+            payload: { plan: null, error: "Plan storage is not configured for this session." }
+          });
+        }
+        break;
+      }
+      case "memory.list": {
+        if (!opts.memoryStore) {
+          send(ws, { type: "memory.list", payload: { text: "", error: "Memory store not available" } });
+          break;
+        }
+        try {
+          const text = await opts.memoryStore.readAll();
+          send(ws, { type: "memory.list", payload: { text } });
+        } catch (err) {
+          send(ws, {
+            type: "memory.list",
+            payload: { text: "", error: err instanceof Error ? err.message : String(err) }
+          });
+        }
+        break;
+      }
+      case "memory.remember": {
+        if (!opts.memoryStore) {
+          sendResult(ws, false, "Memory store not available");
+          break;
+        }
+        const { text, scope } = msg.payload;
+        try {
+          await opts.memoryStore.remember(text, scope ?? "project-memory");
+          sendResult(ws, true, "Saved to memory");
+        } catch (err) {
+          sendResult(ws, false, err instanceof Error ? err.message : String(err));
+        }
+        break;
+      }
+      case "memory.forget": {
+        if (!opts.memoryStore) {
+          sendResult(ws, false, "Memory store not available");
+          break;
+        }
+        const { text, scope } = msg.payload;
+        try {
+          const removed = await opts.memoryStore.forget(text, scope ?? "project-memory");
+          sendResult(
+            ws,
+            removed > 0,
+            removed > 0 ? `Removed ${removed} entr${removed === 1 ? "y" : "ies"}` : "No matching entries"
+          );
+        } catch (err) {
+          sendResult(ws, false, err instanceof Error ? err.message : String(err));
+        }
+        break;
+      }
+      case "skills.list": {
+        if (!opts.skillLoader) {
+          send(ws, { type: "skills.list", payload: { skills: [], enabled: false } });
+          break;
+        }
+        try {
+          const manifests = await opts.skillLoader.list();
+          const entries = await opts.skillLoader.listEntries();
+          const byName = new Map(entries.map((e) => [e.name, e]));
+          send(ws, {
+            type: "skills.list",
+            payload: {
+              enabled: true,
+              skills: manifests.map((m) => ({
+                name: m.name,
+                description: m.description,
+                version: m.version ?? "",
+                source: m.source,
+                path: m.path,
+                trigger: byName.get(m.name)?.trigger ?? "",
+                scope: byName.get(m.name)?.scope ?? []
+              }))
+            }
+          });
+        } catch (err) {
+          send(ws, {
+            type: "skills.list",
+            payload: { skills: [], enabled: true, error: err instanceof Error ? err.message : String(err) }
+          });
+        }
+        break;
+      }
+      case "modes.list": {
+        if (!opts.modeStore) {
+          send(ws, {
+            type: "modes.list",
+            payload: { modes: [], activeId: "default", error: "Mode store not available" }
+          });
+          break;
+        }
+        try {
+          const modes = await opts.modeStore.listModes();
+          const active = await opts.modeStore.getActiveMode();
+          send(ws, {
+            type: "modes.list",
+            payload: {
+              modes: modes.map((m) => ({
+                id: m.id,
+                name: m.name,
+                description: m.description,
+                isActive: m.id === (active?.id ?? "default")
+              })),
+              activeId: active?.id ?? "default"
+            }
+          });
+        } catch (err) {
+          send(ws, {
+            type: "modes.list",
+            payload: { modes: [], activeId: "default", error: err instanceof Error ? err.message : String(err) }
+          });
+        }
+        break;
+      }
+      case "mode.switch": {
+        if (!opts.modeStore) {
+          sendResult(ws, false, "Mode store not available");
+          break;
+        }
+        const { id } = msg.payload;
+        try {
+          if (id === "default") {
+            await opts.modeStore.setActiveMode(null);
+          } else {
+            const found = await opts.modeStore.getMode(id);
+            if (!found) throw new Error(`Unknown mode "${id}"`);
+            await opts.modeStore.setActiveMode(id);
+          }
+          opts.agent.ctx.meta["mode"] = id;
+          sendResult(ws, true, `Switched to mode "${id}"`);
+          broadcast({
+            type: "session.start",
+            payload: {
+              sessionId: opts.session.id,
+              model: opts.agent.ctx.model,
+              provider: opts.agent.ctx.provider.id,
+              mode: id,
+              reset: true
+            }
+          });
+        } catch (err) {
+          sendResult(ws, false, err instanceof Error ? err.message : String(err));
+        }
+        break;
+      }
+      case "model.switch": {
+        const { provider: newProvider, model: newModel } = msg.payload;
+        try {
+          const ctx = opts.agent.ctx;
+          ctx.model = newModel;
+          const { makeProviderFromConfig: makeProviderFromConfig5 } = await import('@wrongstack/providers');
+          const { loadConfigProviders: loadConfigProviders2 } = await Promise.resolve().then(() => (init_provider_config_utils(), provider_config_utils_exports));
+          const saved = opts.globalConfigPath ? await loadConfigProviders2(opts.globalConfigPath, getVault()) : {};
+          const providerCfg = saved[newProvider] ?? { type: newProvider };
+          const newProv = makeProviderFromConfig5(newProvider, providerCfg);
+          ctx.provider = newProv;
+          send(ws, {
+            type: "key.operation_result",
+            payload: { success: true, message: `Switched to ${newProvider} / ${newModel}` }
+          });
+          broadcast({
+            type: "session.start",
+            payload: {
+              sessionId: opts.session.id,
+              model: newModel,
+              provider: newProvider
+            }
+          });
+        } catch (err) {
+          send(ws, {
+            type: "key.operation_result",
+            payload: {
+              success: false,
+              message: `Switch failed: ${err instanceof Error ? err.message : String(err)}`
+            }
+          });
+        }
+        break;
+      }
+      case "session.resume": {
+        if (!opts.sessionStore) {
+          sendResult(ws, false, "Session store not available");
+          break;
+        }
+        const { id } = msg.payload;
+        try {
+          if (id === opts.session.id) {
+            sendResult(ws, false, "Session is already active");
+            break;
+          }
+          const resumed = await opts.sessionStore.resume(id);
+          const ctx = opts.agent.ctx;
+          ctx.state.replaceMessages(resumed.data.messages);
+          ctx.state.replaceTodos([]);
+          ctx.readFiles.clear();
+          ctx.fileMtimes.clear();
+          ctx.tokenCounter.reset();
+          ctx.tokenCounter.account(resumed.data.usage, ctx.model);
+          broadcast({
+            type: "session.start",
+            payload: {
+              sessionId: opts.session.id,
+              model: ctx.model,
+              provider: ctx.provider.id,
+              reset: true,
+              replayMessages: resumed.data.messages,
+              replayUsage: resumed.data.usage
+            }
+          });
+          sendResult(ws, true, `Resumed session ${id}`);
+        } catch (err) {
+          sendResult(ws, false, err instanceof Error ? err.message : String(err));
+        }
+        break;
+      }
+      case "context.debug": {
+        const ctx = opts.agent.ctx;
+        const breakdown = estimateContextBreakdown({
+          systemPrompt: ctx.systemPrompt,
+          tools: opts.agent.tools.list(),
+          messages: ctx.messages
+        });
+        send(ws, {
+          type: "context.debug",
+          payload: {
+            ...breakdown,
+            mode: ctx.meta["contextWindowMode"] ?? DEFAULT_CONTEXT_WINDOW_MODE_ID,
+            policy: ctx.meta["contextWindowPolicy"] ?? null
+          }
+        });
+        break;
+      }
+      case "context.compact": {
+        const aggressive = !!msg.payload?.aggressive;
+        try {
+          const compactor = opts.agent.container.resolve(TOKENS.Compactor);
+          if (!compactor) {
+            sendResult(ws, false, "Compactor not available");
+            break;
+          }
+          const before = opts.agent.ctx.tokenCounter.total();
+          const report = await compactor.compact(opts.agent.ctx, { aggressive });
+          const after = opts.agent.ctx.tokenCounter.total();
+          send(ws, {
+            type: "context.compacted",
+            payload: {
+              before: before.input + before.output,
+              after: after.input + after.output,
+              saved: Math.max(0, before.input + before.output - after.input - after.output),
+              reductions: report.reductions ?? [],
+              repaired: report.repaired ?? false
+            }
+          });
+          sendResult(
+            ws,
+            true,
+            `Compacted: ${before.input + before.output} \u2192 ${after.input + after.output} tokens`
+          );
+        } catch (err) {
+          sendResult(ws, false, err instanceof Error ? err.message : String(err));
+        }
+        break;
+      }
+      case "context.repair": {
+        const ctx = opts.agent.ctx;
+        const beforeMessages = ctx.messages.length;
+        const repaired = repairToolUseAdjacency(ctx.messages);
+        if (repaired.report.changed) {
+          ctx.state.replaceMessages(repaired.messages);
+        }
+        const payload = {
+          removedToolUses: repaired.report.removedToolUses,
+          removedToolResults: repaired.report.removedToolResults,
+          removedMessages: repaired.report.removedMessages,
+          beforeMessages,
+          afterMessages: ctx.messages.length
+        };
+        broadcast({ type: "context.repaired", payload });
+        const removed = payload.removedToolUses.length + payload.removedToolResults.length + payload.removedMessages;
+        sendResult(
+          ws,
+          true,
+          removed > 0 ? `Context repaired: removed ${removed} orphan protocol item(s)` : "Context repair found no orphan protocol blocks"
+        );
+        break;
+      }
+      case "context.modes.list": {
+        const active = String(
+          opts.agent.ctx.meta["contextWindowMode"] ?? DEFAULT_CONTEXT_WINDOW_MODE_ID
+        );
+        send(ws, {
+          type: "context.modes.list",
+          payload: {
+            activeId: active,
+            modes: listContextWindowModes().map((m) => ({
+              id: m.id,
+              name: m.name,
+              description: m.description,
+              isActive: m.id === active,
+              thresholds: m.thresholds,
+              preserveK: m.preserveK,
+              eliseThreshold: m.eliseThreshold
+            }))
+          }
+        });
+        break;
+      }
+      case "context.mode.switch": {
+        const { id } = msg.payload;
+        const policy = resolveContextWindowPolicy({}, id);
+        if (policy.id !== id) {
+          sendResult(ws, false, `Unknown context mode "${id}"`);
+          break;
+        }
+        opts.agent.ctx.meta["contextWindowMode"] = policy.id;
+        opts.agent.ctx.meta["contextWindowPolicy"] = policy;
+        sendResult(ws, true, `Context mode switched to ${policy.id}`);
+        broadcast({
+          type: "context.mode.changed",
+          payload: { id: policy.id, name: policy.name, policy }
+        });
+        break;
+      }
+      // Collaboration messages — the CLI webui-server doesn't run a
+      // full collab hub; silently acknowledge and ignore.
+      case "collab.join":
+      case "collab.leave":
+      case "collab.annotate":
+      case "collab.resolve":
+        break;
+      default: {
+        console.debug(
+          `[WebUI] Unhandled message type: ${String(msg.type)}`
+        );
+        break;
+      }
+    }
+  }
+  async function handleUserMessage(ws, _client, content) {
+    if (abortController) {
+      send(ws, {
+        type: "error",
+        payload: { phase: "agent.run", message: "A run is already in progress. Abort it first." }
+      });
+      return;
+    }
+    abortController = new AbortController();
+    try {
+      const result = await opts.agent.run(content, {
+        signal: abortController.signal
+      });
+      send(ws, {
+        type: "run.result",
+        payload: {
+          status: result.status,
+          iterations: result.iterations,
+          finalText: result.finalText,
+          error: result.error ? {
+            code: result.error.code,
+            message: result.error.message,
+            recoverable: result.error.recoverable
+          } : void 0
+        }
+      });
+    } catch (err) {
+      send(ws, {
+        type: "error",
+        payload: {
+          phase: "agent.run",
+          message: err instanceof Error ? err.message : String(err)
+        }
+      });
+    } finally {
+      abortController = null;
     }
   }
   function send(ws, msg) {
@@ -2423,9 +3403,32 @@ async function runWebUI(opts) {
     send(ws, { type: "key.operation_result", payload: { success, message } });
   }
 }
+var SKIP_DIRS, KEEP_DOTFILES;
 var init_webui_server = __esm({
   "src/webui-server.ts"() {
     init_provider_config_utils();
+    SKIP_DIRS = /* @__PURE__ */ new Set([
+      ".git",
+      "node_modules",
+      "dist",
+      "build",
+      ".next",
+      ".turbo",
+      ".cache",
+      "target",
+      "coverage",
+      ".nyc_output",
+      "out",
+      ".pnpm-store",
+      ".parcel-cache"
+    ]);
+    KEEP_DOTFILES = /* @__PURE__ */ new Set([
+      ".wrongstack",
+      ".env.example",
+      ".gitignore",
+      ".eslintrc",
+      ".prettierrc"
+    ]);
   }
 });
 var req = createRequire(import.meta.url);
@@ -2693,193 +3696,9 @@ function parseSpawnFlags(input) {
   }
   return { description: rest.trim(), opts };
 }
-async function pathExists(file) {
-  try {
-    await fsp4.access(file);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function detectPackageManager(root, declared) {
-  if (declared) {
-    const name = declared.split("@")[0];
-    if (name) return name;
-  }
-  if (await pathExists(path10.join(root, "pnpm-lock.yaml"))) return "pnpm";
-  if (await pathExists(path10.join(root, "bun.lockb"))) return "bun";
-  if (await pathExists(path10.join(root, "bun.lock"))) return "bun";
-  if (await pathExists(path10.join(root, "yarn.lock"))) return "yarn";
-  return "npm";
-}
-function hasUsableScript(scripts, name) {
-  const script = scripts[name];
-  if (typeof script !== "string" || script.trim() === "") return false;
-  if (name === "test" && /no test specified/i.test(script)) return false;
-  return true;
-}
-function parseMakeTargets(makefile) {
-  const targets = /* @__PURE__ */ new Set();
-  for (const line of makefile.split(/\r?\n/)) {
-    if (line.startsWith("	") || line.trimStart().startsWith("#")) continue;
-    const match = /^([A-Za-z0-9_.-]+)\s*:(?![=])/.exec(line);
-    if (match?.[1]) targets.add(match[1]);
-  }
-  return targets;
-}
-async function detectProjectFacts(root) {
-  const facts = { hints: [] };
-  try {
-    const pkg = JSON.parse(await fsp4.readFile(path10.join(root, "package.json"), "utf8"));
-    const scripts = pkg.scripts ?? {};
-    const pm = await detectPackageManager(root, pkg.packageManager);
-    if (hasUsableScript(scripts, "build")) facts.build = `${pm} run build`;
-    if (hasUsableScript(scripts, "test")) facts.test = `${pm} test`;
-    if (hasUsableScript(scripts, "lint")) facts.lint = `${pm} run lint`;
-    const runScript = ["dev", "start", "serve", "preview"].find(
-      (name) => hasUsableScript(scripts, name)
-    );
-    if (runScript) facts.run = `${pm} run ${runScript}`;
-    facts.hints.push(Object.keys(scripts).length > 0 ? "package.json scripts" : "package.json");
-  } catch {
-  }
-  try {
-    if (!await pathExists(path10.join(root, "pyproject.toml"))) throw new Error("not python");
-    facts.test ??= "pytest";
-    facts.lint ??= "ruff check .";
-    facts.hints.push("pyproject.toml");
-  } catch {
-  }
-  try {
-    if (!await pathExists(path10.join(root, "go.mod"))) throw new Error("not go");
-    facts.build ??= "go build ./...";
-    facts.test ??= "go test ./...";
-    facts.run ??= "go run .";
-    facts.hints.push("go.mod");
-  } catch {
-  }
-  try {
-    if (!await pathExists(path10.join(root, "Cargo.toml"))) throw new Error("not rust");
-    facts.build ??= "cargo build";
-    facts.test ??= "cargo test";
-    facts.lint ??= "cargo clippy";
-    facts.run ??= "cargo run";
-    facts.hints.push("Cargo.toml");
-  } catch {
-  }
-  try {
-    const makefile = await fsp4.readFile(path10.join(root, "Makefile"), "utf8");
-    const targets = parseMakeTargets(makefile);
-    facts.build ??= targets.has("build") ? "make build" : "make";
-    if (targets.has("test")) facts.test ??= "make test";
-    if (targets.has("lint")) facts.lint ??= "make lint";
-    const runTarget = ["run", "dev", "start", "serve"].find((name) => targets.has(name));
-    if (runTarget) facts.run ??= `make ${runTarget}`;
-    facts.hints.push("Makefile");
-  } catch {
-  }
-  return facts;
-}
-function renderAgentsTemplate(f) {
-  const cmd = (s) => s ? `\`${s}\`` : "_TODO_";
-  const hints = f.hints.length > 0 ? `
-
-> Auto-detected: ${f.hints.join(", ")}` : "";
-  return `# AGENTS.md
-
-> **DO NOT DELETE THIS FILE.** It is loaded into WrongStack's system prompt as
-> persistent project context. Previous content here may contain decisions,
-> architecture notes, domain knowledge, or verification history that should be
-> preserved. Merge additions rather than replacing.
-
-## Project brief
-
-- **Purpose:** _What does this project do and why does it exist?_
-- **Primary users:** _Who uses it: developers, operators, customers, internal systems?_
-- **Runtime / deployment:** _CLI, server, browser, worker, library, package?_${hints}
-
-## How to work safely
-
-- _Project-specific rules the agent should always follow._
-- _Files, generated artifacts, migrations, or config the agent should not edit without asking._
-- _Preferred style or architecture choices not obvious from the code._
-- _Known fragile areas or historical bugs that deserve extra caution._
-
-## Commands
-
-| Command | Script |
-|---------|--------|
-| Build | ${cmd(f.build)} |
-| Test | ${cmd(f.test)} |
-| Lint | ${cmd(f.lint)} |
-| Run locally | ${cmd(f.run)} |
-
-## Key files and entry points
-
-| File / directory | Role |
-|---|---|
-| _src/_ | _Main source entry point(s)_ |
-| _tests/_ | _Test root or convention_ |
-| _docs/_ | _Architecture, runbooks, design notes_ |
-| _scripts/_ | _Automation scripts (CI, release, install, etc.)_ |
-
-## Architecture notes
-
-_Summarize the important modules, data flow, boundaries, and ownership rules.
-Mention anything a newcomer might misread or that looks unusual but is intentional._
-
-### Dependency layers
-
-_Describe the key dependency direction or layered structure, e.g.: "core has no
-runtime deps; cli assembles everything above it."_
-
-### Extension points
-
-_Plugin, MCP, extension hooks, custom tools \u2014 what's wired up and how._
-
-## Domain knowledge
-
-_Business rules, acronyms, invariants, external services, and notes where the
-code looks unusual but is intentional. E.g.: "IDs are ULIDs, not UUIDs", "the
-\`draft\` flag means uncommitted billing metadata", "MCP servers are restarted
-on disconnect with exponential backoff, up to 3 attempts"._
-
-## Verification checklist
 
-- _What should be run after code changes?_
-- _What manual smoke test proves the common path still works?_
-- _What failure modes deserve extra attention?_
-- _Any known flaky tests or environment-dependent behavior?_
-
-## Useful pointers
-
-- _Docs, dashboards, runbooks, issue trackers, design notes, owner contacts._
-- _Related projects or repositories._`;
-}
-function countTurnPairs(messages) {
-  let count = 0;
-  for (const m of messages) {
-    if (m.role === "user" || m.role === "assistant") count++;
-  }
-  return Math.floor(count / 2);
-}
-function countToolUses(messages) {
-  let count = 0;
-  for (const m of messages) {
-    if (Array.isArray(m.content)) count += m.content.filter((b) => b.type === "tool_use").length;
-  }
-  return count;
-}
-function countToolResults(messages) {
-  let count = 0;
-  for (const m of messages) {
-    if (Array.isArray(m.content)) count += m.content.filter((b) => b.type === "tool_result").length;
-  }
-  return count;
-}
-function estimateTokens(messages) {
-  return estimateMessageTokens(messages);
-}
+// src/slash-commands/index.ts
+init_helpers();
 
 // src/slash-commands/auth.ts
 init_provider_config_utils();
@@ -3024,6 +3843,9 @@ function buildAuthCommand(opts) {
     }
   };
 }
+
+// src/slash-commands/autophase.ts
+init_helpers();
 function getStore(opts) {
   if (!opts.paths) throw new Error("PhaseStore not available \u2014 paths not configured.");
   return new PhaseStore({ baseDir: opts.paths.projectAutophase });
@@ -3092,12 +3914,12 @@ function buildAutoPhaseCommand(opts) {
       ""
     ].join("\n"),
     async run(args) {
-      const parts = args.trim().split(/\s+/).filter(Boolean);
-      const sub = parts[0] ?? "status";
+      const { cmd, rest } = parseSubcommand(args);
+      const sub = cmd || "status";
       const store = getStore(opts);
       switch (sub) {
         case "start": {
-          const goal = parts.slice(1).join(" ").trim();
+          const goal = rest.join(" ").trim();
           if (!goal) {
             return { message: "Usage: /autophase start <goal>  \u2014 describe what to build." };
           }
@@ -3142,7 +3964,7 @@ function buildAutoPhaseCommand(opts) {
           return { message: `\u{1F4BE} AutoPhase saved: ${view.graph.title}` };
         }
         case "load": {
-          const title = parts.slice(1).join(" ").trim();
+          const title = rest.join(" ").trim();
           const graphs = await store.list();
           if (graphs.length === 0) return { message: "\u274C No saved projects." };
           const entry = title ? graphs.find((g) => g.title.toLowerCase().includes(title.toLowerCase())) : graphs[0];
@@ -3179,10 +4001,24 @@ function buildAutoPhaseCommand(opts) {
           };
         }
       }
-      return { message: `Unknown subcommand "${sub}". Run \`/autophase\` for usage.` };
+      return { message: unknownSubcommand(sub, ["start", "pause", "resume", "stop", "save", "load", "list", "status"], "autophase") };
     }
   };
 }
+var MODE_LABELS = {
+  off: `${color.green("OFF")} ${color.dim("(agent stops after each turn)")}`,
+  suggest: `${color.cyan("SUGGEST")} ${color.dim("(shows next-step suggestions)")}`,
+  auto: `${color.yellow("AUTO")} ${color.dim("(self-driving \u2014 Esc to redirect, Ctrl+C to stop)")}`,
+  eternal: `${color.red("ETERNAL")} ${color.dim("(goal-driven loop \u2014 YOLO, until /autonomy stop)")}`,
+  "eternal-parallel": `${color.magenta("PARALLEL")} ${color.dim("(4-8 subagents per tick \u2014 fan-out, until /autonomy stop)")}`
+};
+var MODE_LABELS_SHORT = {
+  off: `${color.green("OFF")} \u2014 agent stops after each turn`,
+  suggest: `${color.cyan("SUGGEST")} \u2014 shows next-step suggestions after each turn`,
+  auto: `${color.yellow("AUTO")} \u2014 self-driving, agent continues automatically`,
+  eternal: `${color.red("ETERNAL")} \u2014 goal-driven sittin-sene loop`,
+  "eternal-parallel": `${color.magenta("PARALLEL")} \u2014 fan-out 4-8 subagents per tick`
+};
 function buildAutonomyCommand(opts) {
   return {
     name: "autonomy",
@@ -3231,14 +4067,7 @@ function buildAutonomyCommand(opts) {
       }
       if (!arg || arg === "status") {
         const current = opts.onAutonomy();
-        const labels2 = {
-          off: `${color.green("OFF")} ${color.dim("(agent stops after each turn)")}`,
-          suggest: `${color.cyan("SUGGEST")} ${color.dim("(shows next-step suggestions)")}`,
-          auto: `${color.yellow("AUTO")} ${color.dim("(self-driving \u2014 Esc to redirect, Ctrl+C to stop)")}`,
-          eternal: `${color.red("ETERNAL")} ${color.dim("(goal-driven loop \u2014 YOLO, until /autonomy stop)")}`,
-          "eternal-parallel": `${color.magenta("PARALLEL")} ${color.dim("(4-8 subagents per tick \u2014 fan-out, until /autonomy stop)")}`
-        };
-        const lines = [`Autonomy mode: ${labels2[current] ?? current}`];
+        const lines = [`Autonomy mode: ${MODE_LABELS[current] ?? current}`];
         try {
           const goal = await loadGoal(goalFilePath(opts.projectRoot));
           if (goal) {
@@ -3379,14 +4208,7 @@ ${color.dim("Regular YOLO enabled; destructive-gated calls still use the permiss
         opts.onEternalStop();
       }
       opts.onAutonomy(newMode);
-      const labels = {
-        off: `${color.green("OFF")} \u2014 agent stops after each turn`,
-        suggest: `${color.cyan("SUGGEST")} \u2014 shows next-step suggestions after each turn`,
-        auto: `${color.yellow("AUTO")} \u2014 self-driving, agent continues automatically`,
-        eternal: `${color.red("ETERNAL")} \u2014 goal-driven sittin-sene loop`,
-        "eternal-parallel": `${color.magenta("PARALLEL")} \u2014 fan-out 4-8 subagents per tick`
-      };
-      const msg = `Autonomy mode: ${labels[newMode]}`;
+      const msg = `Autonomy mode: ${MODE_LABELS_SHORT[newMode]}`;
       opts.renderer.write(msg);
       return { message: msg };
     }
@@ -3496,21 +4318,24 @@ ${color.yellow(`  ${r.errors.length} file(s) had errors`)}` : "");
     }
   };
 }
+
+// src/slash-commands/collab.ts
+init_helpers();
 function buildCollabCommand(opts) {
   return {
     name: "collab",
     category: "Agent",
     description: "Live collaboration helpers (status / invite / history).",
     async run(args, ctx) {
-      const parts = args.split(/\s+/).filter(Boolean);
-      const sub = (parts[0] ?? "status").toLowerCase();
+      const { cmd, rest } = parseSubcommand(args);
+      const sub = cmd || "status";
       switch (sub) {
         case "status":
           return statusCommand(ctx.session?.id);
         case "invite":
           return inviteCommand(ctx.session?.id);
         case "history":
-          return historyCommand(opts, ctx.session?.id, parts.slice(1));
+          return historyCommand(opts, ctx.session?.id, rest);
         case "annotations":
         case "notes":
           return annotationsCommand(opts, ctx.session?.id);
@@ -3521,7 +4346,7 @@ function buildCollabCommand(opts) {
         default:
           return {
             message: color.yellow(
-              `Unknown subcommand: ${sub}. Try: /collab status | invite | history | annotations`
+              unknownSubcommand(sub, ["status", "invite", "history", "annotations"], "collab")
             )
           };
       }
@@ -3716,6 +4541,9 @@ function buildCompactCommand(opts) {
     }
   };
 }
+
+// src/slash-commands/context.ts
+init_helpers();
 function buildContextCommand(opts) {
   return {
     name: "context",
@@ -3958,8 +4786,173 @@ function parseThreshold(raw) {
 function formatLimit(limit) {
   return limit > 0 ? `${limit.toLocaleString()} tokens` : "unknown";
 }
-function pct(n) {
-  return `${Math.round(n * 100)}%`;
+function pct(n) {
+  return `${Math.round(n * 100)}%`;
+}
+function buildDelegateCommand(opts) {
+  return {
+    name: "delegate",
+    category: "Agent",
+    description: "Hand a task to a specialist subagent. /delegate [--role=<role>] <task>. Auto-dispatches if no role given.",
+    argsHint: "[--role=<role>] [--name=<label>] <task description>",
+    help: [
+      "User-facing counterpart to the AI's `delegate` tool.",
+      "",
+      "Usage:",
+      "  /delegate <task description>                  Auto-dispatch to best agent",
+      "  /delegate --role=<role> <task description>    Spawn a specific role",
+      "  /delegate --role=<role> --name=<label> <task> Spawn with custom name",
+      "  /delegate list                                 List available roles",
+      "",
+      "Examples:",
+      '  /delegate "audit packages/core for null-deref bugs"',
+      '  /delegate --role=bug-hunter "find the race condition in session.ts"',
+      '  /delegate --role=security-scanner --name=sec-audit "scan configs for secrets"',
+      "",
+      "Smart dispatch uses the same engine as /fleet dispatch: heuristic keyword",
+      "matching with LLM fallback when ambiguous. The chosen agent is shown before",
+      "spawning so you can confirm or cancel.",
+      "",
+      "Requires director mode. Run /director first, or start with wstack --director.",
+      "",
+      "Related: /spawn (fire-and-forget), /fleet dispatch (smart routing with fleet status)."
+    ].join("\n"),
+    async run(args) {
+      const trimmed = args.trim();
+      if (trimmed === "list" || trimmed === "roles" || trimmed === "ls") {
+        return listRoles();
+      }
+      if (!trimmed) {
+        return {
+          message: [
+            `${color.bold("/delegate")} \u2014 Hand a task to a specialist subagent`,
+            "",
+            "Usage:",
+            `  ${color.cyan("/delegate <task>")}                    Auto-dispatch to best agent`,
+            `  ${color.cyan("/delegate --role=<role> <task>")}     Spawn a specific role`,
+            `  ${color.cyan("/delegate list")}                     List available roles`,
+            "",
+            "Requires director mode. Run /director first."
+          ].join("\n")
+        };
+      }
+      let role;
+      let name;
+      const taskParts = [];
+      const tokens = trimmed.split(/\s+/);
+      for (let i = 0; i < tokens.length; i++) {
+        const t = tokens[i] ?? "";
+        if (t.startsWith("--role=")) {
+          role = t.slice("--role=".length);
+        } else if (t === "--role" && tokens[i + 1]) {
+          role = tokens[++i];
+        } else if (t.startsWith("--name=")) {
+          name = t.slice("--name=".length);
+        } else if (t === "--name" && tokens[i + 1]) {
+          name = tokens[++i];
+        } else if (!t.startsWith("-")) {
+          taskParts.push(t);
+        }
+      }
+      const task = taskParts.join(" ").trim();
+      if (!task) {
+        return {
+          message: `${color.amber("Usage:")} /delegate [--role=<role>] [--name=<label>] <task description>`
+        };
+      }
+      if (role) {
+        const normalized = role.toLowerCase();
+        const def = AGENT_CATALOG[normalized];
+        if (!def) {
+          const available = Object.keys(AGENT_CATALOG).sort().join(", ");
+          return {
+            message: `${color.red("Unknown role")} "${role}". Available roles:
+  ${color.dim(available)}
+
+Use ${color.cyan("/delegate list")} to browse by phase.`
+          };
+        }
+        return await spawnAgent(
+          opts,
+          normalized,
+          task,
+          name ?? normalized,
+          `${color.green("\u2713")} Delegating to ${color.bold(normalized)}: ${color.dim(task)}`
+        );
+      }
+      const decision = await dispatchAgent(task, {
+        classifier: opts.onDispatchClassify
+      });
+      const pct2 = Math.round(decision.confidence * 100);
+      const decisionMsg = [
+        `${color.bold("\u2192 " + decision.role)} ${color.dim(`(${decision.method}, ${pct2}% confidence)`)}`,
+        `  ${color.dim(decision.definition.capability.summary)}`,
+        `  ${color.dim("why:")} ${decision.reason}`,
+        decision.alternatives.length > 0 ? `  ${color.dim("alternatives:")} ${decision.alternatives.slice(0, 3).map((a) => a.role).join(", ")}` : ""
+      ].filter(Boolean).join("\n");
+      opts.renderer.write(decisionMsg);
+      return await spawnAgent(
+        opts,
+        decision.role,
+        task,
+        name ?? decision.role,
+        decisionMsg
+      );
+    }
+  };
+}
+async function spawnAgent(opts, role, _task, _name, header) {
+  if (!opts.onFleetSpawn) {
+    const msg = `${color.amber("\u26A0 No fleet active.")} Run ${color.bold("/director")} first, or start with ${color.bold("wstack --director")}.`;
+    opts.renderer.writeWarning(msg);
+    return { message: msg };
+  }
+  try {
+    const id = await opts.onFleetSpawn(role);
+    const msg = [
+      header,
+      `  ${color.green("\u2713 spawned")} as ${color.dim(id)}`
+    ].join("\n");
+    opts.renderer.write(msg);
+    return { message: msg };
+  } catch (err) {
+    const msg = `${color.red("\u2717 Spawn failed")}: ${err instanceof Error ? err.message : String(err)}`;
+    opts.renderer.writeWarning(msg);
+    return { message: msg };
+  }
+}
+function listRoles() {
+  const PHASE_ORDER2 = [
+    { phase: "discovery", label: "1 \xB7 Discovery" },
+    { phase: "planning", label: "2 \xB7 Planning" },
+    { phase: "build", label: "3 \xB7 Build" },
+    { phase: "verify", label: "4 \xB7 Verify" },
+    { phase: "review", label: "5 \xB7 Review" },
+    { phase: "domain", label: "6 \xB7 Domain" },
+    { phase: "knowledge", label: "7 \xB7 Knowledge" },
+    { phase: "delivery", label: "8 \xB7 Delivery & Ops" },
+    { phase: "meta", label: "9 \xB7 Meta" }
+  ];
+  const totalRoles = Object.keys(AGENT_CATALOG).length;
+  const lines = [
+    `${color.bold("Available Agent Roles")} ${color.dim(`(${totalRoles} total)`)}`,
+    "",
+    `${color.dim("Use /delegate --role=<role> <task> to pick one,")}`,
+    `${color.dim("or /delegate <task> for smart dispatch.")}`,
+    ""
+  ];
+  for (const { phase, label } of PHASE_ORDER2) {
+    const agents = AGENTS_BY_PHASE[phase];
+    if (!agents || agents.length === 0) continue;
+    lines.push(color.cyan(`  Phase ${label}`));
+    for (const def of agents.sort(
+      (a, b) => (a.config.role ?? "").localeCompare(b.config.role ?? "")
+    )) {
+      const role = (def.config.role ?? "unknown").padEnd(20);
+      lines.push(`    ${color.bold(role)} ${color.dim(def.capability.summary)}`);
+    }
+  }
+  return { message: lines.join("\n") };
 }
 var DEFAULT_TIMEOUT_MS = 6e4;
 var MAX_OUTPUT_LINES = 500;
@@ -4222,11 +5215,6 @@ async function persistTelegramConfig(deps, mutator) {
 }
 
 // src/slash-commands/enhance.ts
-var noOpVault = {
-  encrypt: (v) => v,
-  decrypt: (v) => v,
-  isEncrypted: () => false
-};
 function buildEnhanceCommand(opts) {
   const controller = opts.enhanceController;
   return {
@@ -5055,7 +6043,7 @@ function skillLabel(skillHints) {
   return skillHints.map((s) => `\`${s}\``).join(", ");
 }
 function categoryLabel(cli) {
-  if (cli.language !== "unknown" && cli.language !== "unknown") {
+  if (cli.language !== "unknown") {
     return `${cli.subcategory} (${cli.category}, ${cli.language})`;
   }
   return `${cli.subcategory} (${cli.category})`;
@@ -5257,273 +6245,323 @@ function buildFleetCommand(opts) {
       const parts = args.trim().split(/\s+/);
       const cmd = parts[0]?.toLowerCase() ?? "";
       const subargs = parts.slice(1);
-      if (!cmd || cmd === "status" || cmd === "info" || cmd === "manifest") {
-        if (opts.onFleetStatus) {
-          const status = opts.onFleetStatus();
-          if (!status) {
-            const msg4 = `${color.amber("\u26A0 No fleet active.")} Start /autonomy parallel first, or pass --director to a session.`;
-            opts.renderer.write(msg4);
-            return { message: msg4 };
-          }
-          const lines = [];
-          lines.push(`${color.bold("Fleet Status")}`);
-          lines.push(
-            color.dim(
-              `  coordinator: ${status.coordinatorId}  \xB7  pending: ${status.pendingTasks}  \xB7  done: ${status.completedTasks}`
-            )
-          );
-          if (status.subagents.length === 0) {
-            lines.push(color.dim("  No active subagents."));
-          } else {
-            lines.push("");
-            lines.push(
-              `  ${color.bold("ID").padEnd(36)} ${color.bold("NAME").padEnd(16)} ${color.bold("STATUS").padEnd(10)} ${color.bold("TASK")}`
-            );
-            lines.push(color.dim("  " + "\u2500".repeat(80)));
-            for (const sa of status.subagents) {
-              const id = sa.id?.padEnd(36) ?? "".padEnd(36);
-              const name = (sa.name ?? "worker").padEnd(16);
-              const statusColor = sa.status === "running" ? color.green(sa.status.padEnd(10)) : sa.status === "idle" ? color.dim(sa.status.padEnd(10)) : color.dim(sa.status.padEnd(10));
-              const ext = sa.extensions && sa.extensions > 0 ? `${color.yellow(`\u26A1\xD7${sa.extensions}`)} ` : "";
-              const task = sa.currentTask ?? color.dim("\u2014");
-              lines.push(`  ${id} ${name} ${statusColor} ${ext}${task}`);
-            }
-          }
-          const msg3 = lines.join("\n");
-          opts.renderer.write(msg3);
-          return { message: msg3 };
-        }
-        if (opts.onFleet) {
-          const msg3 = await opts.onFleet(cmd || "status", void 0);
-          return { message: msg3 };
-        }
-        const msg2 = `${color.amber("\u26A0 No fleet active.")} Start /autonomy parallel first, or pass --director to a session.`;
-        opts.renderer.write(msg2);
-        return { message: msg2 };
-      }
-      if (cmd === "usage" || cmd === "cost" || cmd === "tokens") {
-        if (opts.onFleetUsage) {
-          const usage = opts.onFleetUsage();
-          if (!usage) {
-            const msg4 = `${color.amber("\u26A0 No fleet usage data.")} Start /autonomy parallel first.`;
-            opts.renderer.write(msg4);
-            return { message: msg4 };
-          }
-          const totalCost = usage.total?.cost ?? 0;
-          const totalIn = usage.total?.input ?? 0;
-          const totalOut = usage.total?.output ?? 0;
-          const lines = [];
-          lines.push(`${color.bold("Fleet Usage")}`);
-          lines.push(
-            `  ${color.dim("Total:")} ${color.green(`${totalCost.toFixed(4)}`)} \xB7 ${color.cyan(totalIn.toLocaleString())} in \xB7 ${color.cyan(totalOut.toLocaleString())} out`
-          );
-          const subagents = Object.values(usage.perSubagent);
-          if (subagents.length > 0) {
-            lines.push("");
-            for (const sa of subagents) {
-              const name = (sa.subagentId ?? "?").padEnd(20);
-              const cost = `${(sa.cost ?? 0).toFixed(4)}`.padStart(10);
-              const tokens = `${sa.input ?? 0} in / ${sa.output ?? 0} out`.padEnd(30);
-              lines.push(`  ${color.dim(name)} ${color.cyan(cost)} ${color.dim(tokens)}`);
-            }
-          }
-          const msg3 = lines.join("\n");
-          opts.renderer.write(msg3);
-          return { message: msg3 };
-        }
-        if (opts.onFleet) {
-          const msg3 = await opts.onFleet("usage", void 0);
-          return { message: msg3 };
-        }
-        const msg2 = `${color.amber("\u26A0 No fleet usage data.")} Start /autonomy parallel first.`;
-        opts.renderer.write(msg2);
-        return { message: msg2 };
-      }
-      if (cmd === "retry") {
-        if (opts.onFleetRetry) {
-          const targetId = subargs[0];
-          const msg3 = await opts.onFleetRetry(targetId);
-          return { message: msg3 };
-        }
-        if (opts.onFleet) {
-          const msg3 = await opts.onFleet("retry", subargs[0]);
-          return { message: msg3 };
-        }
-        const msg2 = `Retry is only available when director mode is active.`;
-        opts.renderer.writeWarning(msg2);
-        return { message: msg2 };
-      }
-      if (cmd === "journal" || cmd === "log") {
-        if (opts.onFleetLog) {
-          const subagentId = subargs[0];
-          const mode = subargs[1] === "raw" ? "raw" : "summary";
-          const msg3 = await opts.onFleetLog(subagentId, mode);
-          return { message: msg3 };
-        }
-        if (opts.onFleet) {
-          const msg3 = await opts.onFleet("log", subargs[0]);
-          return { message: msg3 };
-        }
-        const msg2 = `${color.dim("No journal entries yet.")}`;
-        opts.renderer.write(msg2);
-        return { message: msg2 };
-      }
-      if (cmd === "kill" || cmd === "stop-all") {
-        const targetId = subargs[0];
-        if (targetId) {
-          if (opts.onFleet) {
-            const msg4 = await opts.onFleet("kill", targetId);
-            return { message: msg4 };
-          }
-          const msg3 = `${color.amber("\u26A0 /fleet kill is not wired in this session.")}`;
-          opts.renderer.writeWarning(msg3);
-          return { message: msg3 };
-        }
-        if (opts.onFleetKill) {
-          const killed = opts.onFleetKill();
-          const msg3 = `${color.red("\u2717 Killed")} ${killed} subagent(s).`;
-          opts.renderer.write(msg3);
-          return { message: msg3 };
-        }
-        const msg2 = `${color.amber("\u26A0 /fleet kill is not wired in this session.")}`;
-        opts.renderer.writeWarning(msg2);
-        return { message: msg2 };
-      }
-      if (cmd === "terminate" || cmd === "stop") {
-        const targetId = subargs[0];
-        if (!targetId) {
-          const msg3 = `${color.amber("\u26A0 /fleet terminate requires a subagentId.")} Use /fleet to see active ids.`;
-          opts.renderer.writeWarning(msg3);
-          return { message: msg3 };
-        }
-        if (!opts.onFleetTerminate) {
-          const msg3 = `${color.amber("\u26A0 /fleet terminate is not wired in this session.")}`;
-          opts.renderer.writeWarning(msg3);
-          return { message: msg3 };
-        }
-        const ok = opts.onFleetTerminate(targetId);
-        if (ok) {
-          const msg3 = `${color.green("\u2713 Terminated")} subagent ${color.bold(targetId)}.`;
-          opts.renderer.write(msg3);
-          return { message: msg3 };
-        }
-        const msg2 = `${color.red("\u2717 Failed")} to terminate ${color.bold(targetId)}. Subagent may already be stopped.`;
-        opts.renderer.writeWarning(msg2);
-        return { message: msg2 };
-      }
-      if (cmd === "spawn" || cmd === "add") {
-        const role = subargs[0] ?? "worker";
-        const count = Math.min(16, Math.max(1, Number.parseInt(subargs[1] ?? "1", 10) || 1));
-        if (!opts.onFleetSpawn) {
-          const msg3 = `${color.amber("\u26A0 /fleet spawn is not wired in this session.")}`;
-          opts.renderer.writeWarning(msg3);
-          return { message: msg3 };
-        }
-        const spawned = [];
-        let msg2;
-        for (let i = 0; i < count; i++) {
-          try {
-            const id = await opts.onFleetSpawn(role);
-            spawned.push(id);
-          } catch (err) {
-            const msg3 = `${color.red("\u2717 Spawn failed")} for slot ${i + 1}: ${err instanceof Error ? err.message : String(err)}`;
-            opts.renderer.writeWarning(msg3);
-          }
-        }
-        if (spawned.length === count) {
-          msg2 = `${color.green("\u2713 Spawned")} ${count} subagent(s) of role ${color.bold(role)}.`;
-          opts.renderer.write(msg2);
-        } else {
-          msg2 = `${color.amber("\u26A0 Spawned")} ${spawned.length}/${count} subagent(s). Check /fleet for details.`;
-          opts.renderer.writeWarning(msg2);
-        }
-        return { message: msg2 };
-      }
-      if (cmd === "list" || cmd === "roster" || cmd === "agents") {
-        const lines = [`${color.bold("Agent Roster")} ${color.dim("(spawn with /fleet spawn <role>)")}`];
-        for (const { phase, label } of PHASE_ORDER) {
-          const defs = AGENTS_BY_PHASE[phase];
-          if (!defs || defs.length === 0) continue;
-          lines.push("");
-          lines.push(color.cyan(`  Phase ${label}`));
-          for (const def of defs) {
-            const role = (def.config.role ?? "").padEnd(18);
-            lines.push(`    ${color.bold(role)} ${color.dim(def.capability.summary)}`);
-          }
-        }
-        const msg2 = lines.join("\n");
-        opts.renderer.write(msg2);
-        return { message: msg2 };
-      }
-      if (cmd === "dispatch" || cmd === "route") {
-        const task = subargs.join(" ").trim();
-        if (!task) {
-          const msg3 = `Usage: /fleet dispatch <task description> \u2014 routes the task to the best agent.`;
-          opts.renderer.writeWarning(msg3);
-          return { message: msg3 };
-        }
-        const decision = await dispatchAgent(task, { classifier: opts.onDispatchClassify });
-        const pct2 = Math.round(decision.confidence * 100);
-        const lines = [];
-        lines.push(
-          `${color.bold("\u2192 " + decision.role)} ${color.dim(`(${decision.method}, ${pct2}% confidence)`)}`
-        );
-        lines.push(`  ${color.dim(decision.definition.capability.summary)}`);
-        lines.push(`  ${color.dim("why:")} ${decision.reason}`);
-        if (decision.alternatives.length > 0) {
-          const alts = decision.alternatives.slice(0, 3).map((a) => a.role).join(", ");
-          lines.push(`  ${color.dim("alternatives:")} ${alts}`);
-        }
-        if (opts.onFleetSpawn) {
-          try {
-            const id = await opts.onFleetSpawn(decision.role);
-            lines.push(`  ${color.green("\u2713 spawned")} ${color.bold(decision.role)} as ${color.dim(id)}`);
-          } catch (err) {
-            lines.push(
-              `  ${color.amber("\u26A0 spawn failed:")} ${err instanceof Error ? err.message : String(err)}`
-            );
-          }
-        } else {
-          lines.push(`  ${color.dim("(no fleet active \u2014 run /autonomy parallel or --director to spawn)")}`);
-        }
-        const msg2 = lines.join("\n");
-        opts.renderer.write(msg2);
-        return { message: msg2 };
-      }
-      if (cmd === "concurrency" || cmd === "slots" || cmd === "parallel") {
-        if (opts.onFleet) {
-          const n = subargs[0];
-          const msg3 = await opts.onFleet("concurrency", n || void 0);
-          return { message: msg3 };
+      switch (cmd) {
+        // ── /fleet (default / status / manifest) ────────────────────────────
+        case "":
+        case "status":
+        case "info":
+        case "manifest":
+          return await handleStatus(opts, cmd);
+        // ── /fleet usage ────────────────────────────────────────────────────
+        case "usage":
+        case "cost":
+        case "tokens":
+          return await handleUsage(opts);
+        // ── /fleet retry ─────────────────────────────────────────────────────
+        case "retry":
+          return await handleRetry(opts, subargs);
+        // ── /fleet journal / log ─────────────────────────────────────────────
+        case "journal":
+        case "log":
+          return await handleJournal(opts, subargs);
+        // ── /fleet kill ──────────────────────────────────────────────────────
+        case "kill":
+        case "stop-all":
+          return await handleKill(opts, subargs);
+        // ── /fleet terminate <subagentId> ────────────────────────────────────
+        case "terminate":
+        case "stop":
+          return handleTerminate(opts, subargs);
+        // ── /fleet spawn <role> [count] ──────────────────────────────────────
+        case "spawn":
+        case "add":
+          return await handleSpawn(opts, subargs);
+        // ── /fleet list ──────────────────────────────────────────────────────
+        case "list":
+        case "roster":
+        case "agents":
+          return handleList();
+        // ── /fleet dispatch <task> ───────────────────────────────────────────
+        case "dispatch":
+        case "route":
+          return await handleDispatch(opts, subargs);
+        // ── /fleet concurrency [n] ───────────────────────────────────────────
+        case "concurrency":
+        case "slots":
+        case "parallel":
+          return await handleConcurrency(opts, subargs);
+        // ── /fleet help ──────────────────────────────────────────────────────
+        case "help":
+        case "?":
+          return handleFleetHelp(opts);
+        // ── Unknown command ──────────────────────────────────────────────────
+        default: {
+          const valid = ["status", "list", "dispatch", "usage", "spawn", "terminate", "kill", "retry", "concurrency", "journal"];
+          const msg = `Unknown subcommand "${cmd}". Valid subcommands: ${valid.join(", ")}. Run /fleet with no args to see status, or /fleet help for usage.`;
+          opts.renderer.writeWarning(msg);
+          return { message: msg };
         }
-        const msg2 = `${color.amber("\u26A0 /fleet concurrency is not wired in this session.")}`;
-        opts.renderer.writeWarning(msg2);
-        return { message: msg2 };
       }
-      if (cmd === "help" || cmd === "?") {
-        const msg2 = [
-          `${color.bold("Fleet Commands")}`,
-          `  ${color.dim("/fleet")}              Show fleet status (default)`,
-          `  ${color.dim("/fleet status")}       Same as /fleet (verbose status)`,
-          `  ${color.dim("/fleet list")}         List the agent roster grouped by phase`,
-          `  ${color.dim("/fleet dispatch <task>")}  Route a task to the best agent and spawn it`,
-          `  ${color.dim("/fleet spawn <role> [count]")}  Spawn N subagents of a role (default 1)`,
-          `  ${color.dim("/fleet terminate <subagentId>")}  Stop a specific subagent by id`,
-          `  ${color.dim("/fleet kill")}         Stop all running subagents`,
-          `  ${color.dim("/fleet usage")}        Token and cost breakdown across the fleet`,
-          `  ${color.dim("/fleet concurrency [n]")}  Show or set the concurrent-subagent ceiling`,
-          `  ${color.dim("/fleet journal")}      Show recent journal entries from /goal journal`
-        ].join("\n");
-        opts.renderer.write(msg2);
-        return { message: msg2 };
-      }
-      const valid = ["status", "list", "dispatch", "usage", "spawn", "terminate", "kill", "retry", "concurrency", "journal"];
-      const msg = `Unknown subcommand "${cmd}". Valid subcommands: ${valid.join(", ")}. Run /fleet with no args to see status, or /fleet help for usage.`;
-      opts.renderer.writeWarning(msg);
-      return { message: msg };
     }
   };
 }
+async function handleStatus(opts, cmd) {
+  if (opts.onFleetStatus) {
+    const status = opts.onFleetStatus();
+    if (!status) {
+      const msg3 = `${color.amber("\u26A0 No fleet active.")} Start /autonomy parallel first, or pass --director to a session.`;
+      opts.renderer.write(msg3);
+      return { message: msg3 };
+    }
+    const lines = [];
+    lines.push(`${color.bold("Fleet Status")}`);
+    lines.push(
+      color.dim(
+        `  coordinator: ${status.coordinatorId}  \xB7  pending: ${status.pendingTasks}  \xB7  done: ${status.completedTasks}`
+      )
+    );
+    if (status.subagents.length === 0) {
+      lines.push(color.dim("  No active subagents."));
+    } else {
+      lines.push("");
+      lines.push(
+        `  ${color.bold("ID").padEnd(36)} ${color.bold("NAME").padEnd(16)} ${color.bold("STATUS").padEnd(10)} ${color.bold("TASK")}`
+      );
+      lines.push(color.dim("  " + "\u2500".repeat(80)));
+      for (const sa of status.subagents) {
+        const id = sa.id?.padEnd(36) ?? "".padEnd(36);
+        const name = (sa.name ?? "worker").padEnd(16);
+        const statusColor = sa.status === "running" ? color.green(sa.status.padEnd(10)) : sa.status === "idle" ? color.dim(sa.status.padEnd(10)) : color.dim(sa.status.padEnd(10));
+        const ext = sa.extensions && sa.extensions > 0 ? `${color.yellow(`\u26A1\xD7${sa.extensions}`)} ` : "";
+        const task = sa.currentTask ?? color.dim("\u2014");
+        lines.push(`  ${id} ${name} ${statusColor} ${ext}${task}`);
+      }
+    }
+    const msg2 = lines.join("\n");
+    opts.renderer.write(msg2);
+    return { message: msg2 };
+  }
+  if (opts.onFleet) {
+    const msg2 = await opts.onFleet(cmd || "status", void 0);
+    return { message: msg2 };
+  }
+  const msg = `${color.amber("\u26A0 No fleet active.")} Start /autonomy parallel first, or pass --director to a session.`;
+  opts.renderer.write(msg);
+  return { message: msg };
+}
+async function handleUsage(opts) {
+  if (opts.onFleetUsage) {
+    const usage = opts.onFleetUsage();
+    if (!usage) {
+      const msg3 = `${color.amber("\u26A0 No fleet usage data.")} Start /autonomy parallel first.`;
+      opts.renderer.write(msg3);
+      return { message: msg3 };
+    }
+    const totalCost = usage.total?.cost ?? 0;
+    const totalIn = usage.total?.input ?? 0;
+    const totalOut = usage.total?.output ?? 0;
+    const lines = [];
+    lines.push(`${color.bold("Fleet Usage")}`);
+    lines.push(
+      `  ${color.dim("Total:")} ${color.green(`${totalCost.toFixed(4)}`)} \xB7 ${color.cyan(totalIn.toLocaleString())} in \xB7 ${color.cyan(totalOut.toLocaleString())} out`
+    );
+    const subagents = Object.values(usage.perSubagent);
+    if (subagents.length > 0) {
+      lines.push("");
+      for (const sa of subagents) {
+        const name = (sa.subagentId ?? "?").padEnd(20);
+        const cost = `${(sa.cost ?? 0).toFixed(4)}`.padStart(10);
+        const tokens = `${sa.input ?? 0} in / ${sa.output ?? 0} out`.padEnd(30);
+        lines.push(`  ${color.dim(name)} ${color.cyan(cost)} ${color.dim(tokens)}`);
+      }
+    }
+    const msg2 = lines.join("\n");
+    opts.renderer.write(msg2);
+    return { message: msg2 };
+  }
+  if (opts.onFleet) {
+    const msg2 = await opts.onFleet("usage", void 0);
+    return { message: msg2 };
+  }
+  const msg = `${color.amber("\u26A0 No fleet usage data.")} Start /autonomy parallel first.`;
+  opts.renderer.write(msg);
+  return { message: msg };
+}
+async function handleRetry(opts, subargs) {
+  if (opts.onFleetRetry) {
+    const targetId = subargs[0];
+    const msg2 = await opts.onFleetRetry(targetId);
+    return { message: msg2 };
+  }
+  if (opts.onFleet) {
+    const msg2 = await opts.onFleet("retry", subargs[0]);
+    return { message: msg2 };
+  }
+  const msg = `Retry is only available when director mode is active.`;
+  opts.renderer.writeWarning(msg);
+  return { message: msg };
+}
+async function handleJournal(opts, subargs) {
+  if (opts.onFleetLog) {
+    const subagentId = subargs[0];
+    const mode = subargs[1] === "raw" ? "raw" : "summary";
+    const msg2 = await opts.onFleetLog(subagentId, mode);
+    return { message: msg2 };
+  }
+  if (opts.onFleet) {
+    const msg2 = await opts.onFleet("log", subargs[0]);
+    return { message: msg2 };
+  }
+  const msg = `${color.dim("No journal entries yet.")}`;
+  opts.renderer.write(msg);
+  return { message: msg };
+}
+async function handleKill(opts, subargs) {
+  const targetId = subargs[0];
+  if (targetId) {
+    if (opts.onFleet) {
+      const msg3 = await opts.onFleet("kill", targetId);
+      return { message: msg3 };
+    }
+    const msg2 = `${color.amber("\u26A0 /fleet kill <id> is not wired in this session.")}`;
+    opts.renderer.writeWarning(msg2);
+    return { message: msg2 };
+  }
+  if (opts.onFleetKill) {
+    const killed = opts.onFleetKill();
+    const msg2 = `${color.red("\u2717 Killed")} ${killed} subagent(s).`;
+    opts.renderer.write(msg2);
+    return { message: msg2 };
+  }
+  const msg = `${color.amber("\u26A0 /fleet kill is not wired in this session.")}`;
+  opts.renderer.writeWarning(msg);
+  return { message: msg };
+}
+function handleTerminate(opts, subargs) {
+  const targetId = subargs[0];
+  if (!targetId) {
+    const msg2 = `${color.amber("\u26A0 /fleet terminate requires a subagentId.")} Use /fleet to see active ids.`;
+    opts.renderer.writeWarning(msg2);
+    return { message: msg2 };
+  }
+  if (!opts.onFleetTerminate) {
+    const msg2 = `${color.amber("\u26A0 /fleet terminate is not wired in this session.")}`;
+    opts.renderer.writeWarning(msg2);
+    return { message: msg2 };
+  }
+  const ok = opts.onFleetTerminate(targetId);
+  if (ok) {
+    const msg2 = `${color.green("\u2713 Terminated")} subagent ${color.bold(targetId)}.`;
+    opts.renderer.write(msg2);
+    return { message: msg2 };
+  }
+  const msg = `${color.red("\u2717 Failed")} to terminate ${color.bold(targetId)}. Subagent may already be stopped.`;
+  opts.renderer.writeWarning(msg);
+  return { message: msg };
+}
+async function handleSpawn(opts, subargs) {
+  const role = subargs[0] ?? "worker";
+  const count = Math.min(16, Math.max(1, Number.parseInt(subargs[1] ?? "1", 10) || 1));
+  if (!opts.onFleetSpawn) {
+    const msg2 = `${color.amber("\u26A0 /fleet spawn is not wired in this session.")}`;
+    opts.renderer.writeWarning(msg2);
+    return { message: msg2 };
+  }
+  const spawned = [];
+  for (let i = 0; i < count; i++) {
+    try {
+      const id = await opts.onFleetSpawn(role);
+      spawned.push(id);
+    } catch (err) {
+      const warnMsg = `${color.red("\u2717 Spawn failed")} for slot ${i + 1}: ${err instanceof Error ? err.message : String(err)}`;
+      opts.renderer.writeWarning(warnMsg);
+    }
+  }
+  if (spawned.length === count) {
+    const msg2 = `${color.green("\u2713 Spawned")} ${count} subagent(s) of role ${color.bold(role)}.`;
+    opts.renderer.write(msg2);
+    return { message: msg2 };
+  }
+  const msg = `${color.amber("\u26A0 Spawned")} ${spawned.length}/${count} subagent(s). Check /fleet for details.`;
+  opts.renderer.writeWarning(msg);
+  return { message: msg };
+}
+function handleList() {
+  const lines = [`${color.bold("Agent Roster")} ${color.dim("(spawn with /fleet spawn <role>)")}`];
+  for (const { phase, label } of PHASE_ORDER) {
+    const defs = AGENTS_BY_PHASE[phase];
+    if (!defs || defs.length === 0) continue;
+    lines.push("");
+    lines.push(color.cyan(`  Phase ${label}`));
+    for (const def of defs) {
+      const role = (def.config.role ?? "").padEnd(18);
+      lines.push(`    ${color.bold(role)} ${color.dim(def.capability.summary)}`);
+    }
+  }
+  return { message: lines.join("\n") };
+}
+async function handleDispatch(opts, subargs) {
+  const task = subargs.join(" ").trim();
+  if (!task) {
+    const msg2 = `Usage: /fleet dispatch <task description> \u2014 routes the task to the best agent.`;
+    opts.renderer.writeWarning(msg2);
+    return { message: msg2 };
+  }
+  const decision = await dispatchAgent(task, { classifier: opts.onDispatchClassify });
+  const pct2 = Math.round(decision.confidence * 100);
+  const lines = [];
+  lines.push(
+    `${color.bold("\u2192 " + decision.role)} ${color.dim(`(${decision.method}, ${pct2}% confidence)`)}`
+  );
+  lines.push(`  ${color.dim(decision.definition.capability.summary)}`);
+  lines.push(`  ${color.dim("why:")} ${decision.reason}`);
+  if (decision.alternatives.length > 0) {
+    const alts = decision.alternatives.slice(0, 3).map((a) => a.role).join(", ");
+    lines.push(`  ${color.dim("alternatives:")} ${alts}`);
+  }
+  if (opts.onFleetSpawn) {
+    try {
+      const id = await opts.onFleetSpawn(decision.role);
+      lines.push(`  ${color.green("\u2713 spawned")} ${color.bold(decision.role)} as ${color.dim(id)}`);
+    } catch (err) {
+      lines.push(
+        `  ${color.amber("\u26A0 spawn failed:")} ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  } else {
+    lines.push(`  ${color.dim("(no fleet active \u2014 run /autonomy parallel or --director to spawn)")}`);
+  }
+  const msg = lines.join("\n");
+  opts.renderer.write(msg);
+  return { message: msg };
+}
+async function handleConcurrency(opts, subargs) {
+  if (opts.onFleet) {
+    const n = subargs[0];
+    const msg2 = await opts.onFleet("concurrency", n || void 0);
+    return { message: msg2 };
+  }
+  const msg = `${color.amber("\u26A0 /fleet concurrency is not wired in this session.")}`;
+  opts.renderer.writeWarning(msg);
+  return { message: msg };
+}
+function handleFleetHelp(opts) {
+  const msg = [
+    `${color.bold("Fleet Commands")}`,
+    `  ${color.dim("/fleet")}              Show fleet status (default)`,
+    `  ${color.dim("/fleet status")}       Same as /fleet (verbose status)`,
+    `  ${color.dim("/fleet list")}         List the agent roster grouped by phase`,
+    `  ${color.dim("/fleet dispatch <task>")}  Route a task to the best agent and spawn it`,
+    `  ${color.dim("/fleet spawn <role> [count]")}  Spawn N subagents of a role (default 1)`,
+    `  ${color.dim("/fleet terminate <subagentId>")}  Stop a specific subagent by id`,
+    `  ${color.dim("/fleet kill")}         Stop all running subagents`,
+    `  ${color.dim("/fleet usage")}        Token and cost breakdown across the fleet`,
+    `  ${color.dim("/fleet concurrency [n]")}  Show or set the concurrent-subagent ceiling`,
+    `  ${color.dim("/fleet journal")}      Show recent journal entries from /goal journal`
+  ].join("\n");
+  opts.renderer.write(msg);
+  return { message: msg };
+}
 
 // src/slash-commands/goal-refiner.ts
 async function refineGoal(rawGoal, provider, model) {
@@ -5934,6 +6972,9 @@ function buildHelpCommand(opts) {
     }
   };
 }
+
+// src/slash-commands/init.ts
+init_helpers();
 function buildInitCommand(opts) {
   return {
     name: "init",
@@ -6233,6 +7274,7 @@ function buildMcpSlashCommand(opts) {
 }
 
 // src/slash-commands/memory.ts
+init_helpers();
 function buildMemoryCommand(opts) {
   return {
     name: "memory",
@@ -6241,9 +7283,9 @@ function buildMemoryCommand(opts) {
     async run(args) {
       const store = opts.memoryStore;
       if (!store) return { message: "No memory store configured." };
-      const [verb, ...rest] = args.trim().split(/\s+/);
+      const { cmd, rest } = parseSubcommand(args);
       const restJoined = rest.join(" ").trim();
-      switch (verb) {
+      switch (cmd) {
         case "":
         case "show":
         case "list": {
@@ -6278,27 +7320,19 @@ function buildMemoryCommand(opts) {
         }
         default:
           return {
-            message: `Unknown subcommand "${verb}". Try: show | remember <text> | forget <query> | clear | compact | stats`
+            message: unknownSubcommand(cmd, ["show", "remember", "forget", "clear", "compact", "stats"], "memory")
           };
       }
     }
   };
 }
-function buildCompactPrompt(entries) {
-  const entriesBlock = entries.map(
-    (e, i) => `${i + 1}. [${e.ts.slice(0, 10)}] ${e.id}
-   ${e.text}${e.tags ? `
-   tags: ${e.tags.join(", ")}` : ""}${e.type ? `
-   type: ${e.type}` : ""}${e.priority ? `
-   priority: ${e.priority}` : ""}`
-  ).join("\n\n");
-  return `You are a memory curator. Your task is to review, deduplicate, and improve a set of long-term memory entries.
+var COMPACT_SYSTEM_PROMPT = `You are a memory curator. Your task is to review, deduplicate, and improve a set of long-term memory entries.
 
 These entries are injected into the context of an AI coding agent. Every token counts. The memory must be concise, accurate, and free of noise.
 
 ## Current Memory Entries
 
-${entriesBlock}
+__ENTRIES__
 
 ## Your Task
 
@@ -6336,6 +7370,15 @@ Return ONLY valid JSON with this structure:
 }
 
 Use the EXACT entry IDs from the list above for "targets". No markdown, no explanation outside the JSON.`;
+function buildCompactPrompt(entries) {
+  const entriesBlock = entries.map(
+    (e, i) => `${i + 1}. [${e.ts.slice(0, 10)}] ${e.id}
+   ${e.text}${e.tags ? `
+   tags: ${e.tags.join(", ")}` : ""}${e.type ? `
+   type: ${e.type}` : ""}${e.priority ? `
+   priority: ${e.priority}` : ""}`
+  ).join("\n\n");
+  return COMPACT_SYSTEM_PROMPT.replace("__ENTRIES__", entriesBlock);
 }
 async function runCompact(opts) {
   const store = opts.memoryStore;
@@ -6717,11 +7760,9 @@ ${targetMode.description}`
     }
   };
 }
-var noOpVault2 = {
-  encrypt: (v) => v,
-  decrypt: (v) => v,
-  isEncrypted: () => false
-};
+
+// src/slash-commands/models.ts
+init_helpers();
 async function patchGlobalConfig(globalConfigPath, mutate) {
   let raw = "{}";
   let fileExists2 = true;
@@ -6740,9 +7781,9 @@ async function patchGlobalConfig(globalConfigPath, mutate) {
     }
     parsed = {};
   }
-  const decrypted = decryptConfigSecrets$1(parsed, noOpVault2);
+  const decrypted = decryptConfigSecrets$1(parsed, noOpVault);
   mutate(decrypted);
-  const encrypted = encryptConfigSecrets$1(decrypted, noOpVault2);
+  const encrypted = encryptConfigSecrets$1(decrypted, noOpVault);
   await atomicWrite(globalConfigPath, JSON.stringify(encrypted, null, 2), { mode: 384 });
   return decrypted;
 }
@@ -6851,8 +7892,8 @@ function buildModelsCommand(opts) {
     description: "Manage custom model definitions.",
     help,
     async run(args) {
-      const parts = args.trim().split(/\s+/).filter(Boolean);
-      const sub = (parts[0] ?? "").toLowerCase();
+      const { cmd, rest } = parseSubcommand(args);
+      const sub = cmd;
       if (sub === "help" || sub === "--help") return { message: help };
       if (!opts.configStore || !opts.paths) {
         return { message: `${color.red("Error")} config store not available.` };
@@ -6883,7 +7924,7 @@ function buildModelsCommand(opts) {
       }
       try {
         if (sub === "add") {
-          const { modelId, def, error } = parseFlags(parts.slice(1));
+          const { modelId, def, error } = parseFlags(rest);
           if (error) {
             return { message: `${color.red("Error")}: ${error}. ${color.dim("/models help")}` };
           }
@@ -6910,7 +7951,7 @@ function buildModelsCommand(opts) {
           return { message: `${color.green("\u2713")} ${color.amber(modelId)} ${existed ? "updated" : "added"}.` };
         }
         if (sub === "remove" || sub === "rm") {
-          const modelId = parts[1];
+          const modelId = rest[0];
           if (!modelId) {
             return { message: `${color.amber("Usage:")} /models remove <id>` };
           }
@@ -6929,7 +7970,7 @@ function buildModelsCommand(opts) {
           return { message: `${color.green("\u2713")} removed ${color.amber(modelId)}` };
         }
         return {
-          message: `${color.red("Unknown subcommand")} "${sub}". Try ${color.dim("/models")}, ${color.dim("/models add")}, or ${color.dim("/models help")}.`
+          message: `${color.red("Unknown subcommand")} "${sub}". ${unknownSubcommand(sub, ["add", "remove"], "models")}`
         };
       } catch (err) {
         return {
@@ -6939,6 +7980,20 @@ function buildModelsCommand(opts) {
     }
   };
 }
+
+// src/slash-commands/suggestion-store.ts
+var sharedSuggestions = [];
+function setSuggestions(suggestions) {
+  sharedSuggestions = suggestions;
+}
+function getSuggestions() {
+  return sharedSuggestions;
+}
+function clearSuggestions() {
+  sharedSuggestions = [];
+}
+
+// src/slash-commands/next.ts
 function buildNextCommand(opts) {
   return {
     name: "next",
@@ -6968,9 +8023,10 @@ function buildNextCommand(opts) {
       }
       const arg = trimmed.toLowerCase();
       if (arg === "list" || arg === "ls" || arg === "show") {
-        return handleList(opts);
+        return handleList2(opts);
       }
       if (arg === "clear" || arg === "reset") {
+        clearSuggestions();
         opts.onSuggestions?.([]);
         return { message: color.dim("Suggestion list cleared.") };
       }
@@ -6982,7 +8038,8 @@ function buildNextCommand(opts) {
       const current = opts.onNextPredict();
       const label = (on) => on ? `${color.cyan("ON")} ${color.dim("(predicted next steps shown after each turn)")}` : `${color.green("OFF")} ${color.dim("(no predictions)")}`;
       if (!arg || arg === "status") {
-        const suggestions = opts.onSuggestions?.() ?? [];
+        const stored = getSuggestions();
+        const suggestions = stored.length > 0 ? stored : opts.onSuggestions?.() ?? [];
         const msg2 = [
           `Next-task prediction: ${label(current)}`,
           suggestions.length > 0 ? color.dim(`  ${suggestions.length} suggestion(s) available \u2014 use /next list to view, /next 1 to execute`) : color.dim("  No suggestions stored \u2014 use /suggest to generate")
@@ -7015,7 +8072,7 @@ function handleSelection(input, opts) {
   if (indices.length === 0) {
     return { message: color.amber("No valid suggestion numbers found. Use /next 1, /next 1 2 3, etc.") };
   }
-  const suggestions = opts.onSuggestions?.() ?? [];
+  const suggestions = getSuggestions().length > 0 ? getSuggestions() : opts.onSuggestions?.() ?? [];
   if (suggestions.length === 0) {
     return {
       message: color.amber("No suggestions available. Run /suggest first, or enable prediction with /next on.")
@@ -7049,8 +8106,8 @@ function handleSelection(input, opts) {
     runText
   };
 }
-function handleList(opts) {
-  const suggestions = opts.onSuggestions?.() ?? [];
+function handleList2(opts) {
+  const suggestions = getSuggestions().length > 0 ? getSuggestions() : opts.onSuggestions?.() ?? [];
   if (suggestions.length === 0) {
     return {
       message: [
@@ -7196,9 +8253,9 @@ function buildSaveCommand(opts) {
 }
 function buildLoadCommand(opts) {
   return {
-    name: "resume",
+    name: "sessions",
     category: "Session",
-    aliases: ["load", "sessions"],
+    aliases: ["resume", "load"],
     description: "List recent sessions, show incomplete ones (--incomplete), or plan a recovery (--recover <id>).",
     async run(args) {
       const parts = args.split(/\s+/).filter(Boolean);
@@ -7370,11 +8427,6 @@ function summariseEvent(ev) {
       return color.dim("\u2026");
   }
 }
-var noOpVault3 = {
-  encrypt: (v) => v,
-  decrypt: (v) => v,
-  isEncrypted: () => false
-};
 function providerHasKey(entry) {
   if (!entry) return false;
   if (typeof entry.apiKey === "string" && entry.apiKey.length > 0) return true;
@@ -7422,9 +8474,9 @@ async function patchGlobalConfig2(globalConfigPath, mutate) {
       throw new Error(`Config at ${globalConfigPath} is not valid JSON: ${err.message}`);
     parsed = {};
   }
-  const decrypted = decryptConfigSecrets$1(parsed, noOpVault3);
+  const decrypted = decryptConfigSecrets$1(parsed, noOpVault);
   mutate(decrypted);
-  const encrypted = encryptConfigSecrets$1(decrypted, noOpVault3);
+  const encrypted = encryptConfigSecrets$1(decrypted, noOpVault);
   await atomicWrite(globalConfigPath, JSON.stringify(encrypted, null, 2), { mode: 384 });
   return decrypted;
 }
@@ -7922,12 +8974,14 @@ function buildSuggestCommand(opts) {
       const fast = /\b(--fast|-f)\b/.test(trimmed);
       if (fast) {
         const suggestions = generateHeuristicSuggestions(opts);
+        setSuggestions(suggestions);
         opts.onSuggestions?.(suggestions);
         const display = formatSuggestions(suggestions);
         return { message: display };
       }
       if (!opts.onSpawnAndWait) {
         const suggestions = generateHeuristicSuggestions(opts);
+        setSuggestions(suggestions);
         opts.onSuggestions?.(suggestions);
         const display = formatSuggestions(suggestions) + "\n" + color.dim("(Heuristic fallback \u2014 multi-agent not enabled)");
         return { message: display };
@@ -7945,9 +8999,11 @@ function buildSuggestCommand(opts) {
         const suggestions = parseSuggestions(raw);
         if (suggestions.length === 0) {
           const fallback = ["No pending actions \u2014 everything is up to date."];
+          setSuggestions(fallback);
           opts.onSuggestions?.(fallback);
           return { message: formatSuggestions(fallback) };
         }
+        setSuggestions(suggestions);
         opts.onSuggestions?.(suggestions);
         return { message: formatSuggestions(suggestions) };
       } catch (err) {
@@ -8013,11 +9069,7 @@ function formatSuggestions(suggestions) {
   }
   return lines.join("\n");
 }
-var noOpVault4 = {
-  encrypt: (v) => v,
-  decrypt: (v) => v,
-  isEncrypted: () => false
-};
+init_helpers();
 function formatDelay(ms) {
   if (ms >= 6e4) return `${Math.round(ms / 6e4)}m`;
   if (ms === 0) return "disabled";
@@ -8061,8 +9113,8 @@ function buildSettingsCommand(opts) {
     description: "View or change settings (auto-proceed delay, default autonomy mode, launch hints).",
     help,
     async run(args) {
-      const parts = args.trim().split(/\s+/).filter(Boolean);
-      const sub = (parts[0] ?? "").toLowerCase();
+      const { cmd, rest } = parseSubcommand(args);
+      const sub = cmd;
       if (sub === "help" || sub === "--help") {
         return { message: this.help ?? "" };
       }
@@ -8090,11 +9142,11 @@ function buildSettingsCommand(opts) {
         configStore: opts.configStore,
         globalConfigPath: opts.paths.globalConfig,
         inProjectConfigPath: opts.paths.inProjectConfig,
-        vault: noOpVault4
+        vault: noOpVault
       };
       try {
         if (sub === "delay") {
-          const raw = parts[1];
+          const raw = rest[0];
           if (raw === void 0) {
             return {
               message: `${color.amber("Usage:")} /settings delay <seconds>   ${color.dim("(0 disables)")}`
@@ -8113,7 +9165,7 @@ function buildSettingsCommand(opts) {
           return { message: `${color.green("\u2713")} auto-proceed delay \u2192 ${formatDelay(ms)}` };
         }
         if (sub === "mode") {
-          const raw = (parts[1] ?? "").toLowerCase();
+          const raw = (rest[0] ?? "").toLowerCase();
           const modes = ["off", "suggest", "auto"];
           if (!modes.includes(raw)) {
             return { message: `${color.amber("Usage:")} /settings mode off|suggest|auto` };
@@ -8124,7 +9176,7 @@ function buildSettingsCommand(opts) {
           return { message: `${color.green("\u2713")} default autonomy \u2192 ${color.bold(raw)}` };
         }
         if (sub === "hints") {
-          const raw = (parts[1] ?? "").toLowerCase();
+          const raw = (rest[0] ?? "").toLowerCase();
           if (!["on", "off"].includes(raw)) {
             return { message: `${color.amber("Usage:")} /settings hints on|off` };
           }
@@ -8135,7 +9187,7 @@ function buildSettingsCommand(opts) {
           return { message: `${color.green("\u2713")} launch hints \u2192 ${on ? color.cyan("on") : color.dim("off")}` };
         }
         if (sub === "debug-stream") {
-          const raw = (parts[1] ?? "").toLowerCase();
+          const raw = (rest[0] ?? "").toLowerCase();
           if (!["on", "off"].includes(raw)) {
             return { message: `${color.amber("Usage:")} /settings debug-stream on|off` };
           }
@@ -8148,7 +9200,7 @@ function buildSettingsCommand(opts) {
           return { message: `${color.green("\u2713")} debug stream \u2192 ${on ? color.cyan("on") : color.dim("off")}   ${color.dim("raw SSE hex-dump to stderr")}` };
         }
         if (sub === "config-scope") {
-          const raw = (parts[1] ?? "").toLowerCase();
+          const raw = (rest[0] ?? "").toLowerCase();
           if (!["global", "project"].includes(raw)) {
             return { message: `${color.amber("Usage:")} /settings config-scope global|project` };
           }
@@ -8159,7 +9211,7 @@ function buildSettingsCommand(opts) {
           return { message: `${color.green("\u2713")} config scope \u2192 ${label}` };
         }
         return {
-          message: `${color.red("Unknown setting")} "${sub}". Try ${color.dim("/settings")}, ${color.dim("/settings delay <s>")}, ${color.dim("/settings mode <m>")}, ${color.dim("/settings hints on|off")}, ${color.dim("/settings debug-stream on|off")}, or ${color.dim("/settings config-scope global|project")}.`
+          message: `${color.red("Unknown setting")} "${sub}". ${unknownSubcommand(sub, ["delay", "mode", "hints", "debug-stream", "config-scope", "defaults"], "settings")}`
         };
       } catch (err) {
         return {
@@ -8169,11 +9221,6 @@ function buildSettingsCommand(opts) {
     }
   };
 }
-var noOpVault5 = {
-  encrypt: (v) => v,
-  decrypt: (v) => v,
-  isEncrypted: () => false
-};
 var HELP = [
   "Usage:",
   "  /telegram-setup                     Show setup instructions",
@@ -8275,7 +9322,7 @@ function buildTelegramSetupCommand(opts) {
       const persistDeps = {
         configStore: opts.configStore,
         globalConfigPath: opts.paths?.globalConfig ?? "",
-        vault: noOpVault5
+        vault: noOpVault
       };
       if (!persistDeps.globalConfigPath) {
         return {
@@ -8328,11 +9375,31 @@ function buildSpawnCommand(opts) {
     name: "spawn",
     category: "Agent",
     description: "Spawn an isolated subagent to handle a task.",
+    argsHint: "[--name=<label>] [--model=<id>] <task description>",
+    help: [
+      "Fire-and-forget subagent spawn. The subagent runs independently; check",
+      "its status with /agents or /fleet.",
+      "",
+      "Usage:",
+      "  /spawn <task description>",
+      "  /spawn --name=<label> --model=<id> <task description>",
+      "",
+      "Flags:",
+      "  --name=<label>   Display name for the subagent",
+      "  --provider=<id>  Override the provider (defaults to leader provider)",
+      "  --model=<id>     Override the model (defaults to leader model)",
+      "  --tools=a,b,c    Comma-separated list of tool names to grant",
+      "",
+      "For smart routing (auto-picking the right agent role), use /fleet dispatch.",
+      "For explicit role assignment, use /fleet spawn <role>.",
+      "",
+      "Requires director mode. Run /director first."
+    ].join("\n"),
     async run(args) {
       const { description, opts: parsed } = parseSpawnFlags(args.trim());
       if (!description)
         return {
-          message: "Usage: /spawn [--provider=<id>] [--model=<id>] [--name=<label>] [--tools=a,b,c] <task description>"
+          message: 'Usage: /spawn [--name=<label>] [--model=<id>] <task description>\n\nExamples:\n  /spawn "fix the auth bug in session.ts"\n  /spawn --name=fixer "audit core for null-deref bugs"\n\nRequires director mode. Run /director first.'
         };
       if (!opts.onSpawn) return { message: "Multi-agent is not enabled in this session." };
       try {
@@ -8387,6 +9454,19 @@ function buildDirectorCommand(opts) {
     name: "director",
     category: "Agent",
     description: "Promote this session to director mode, enabling fleet orchestration tools. Only works before any subagents are spawned.",
+    help: [
+      "Promotes the current session to director mode, which unlocks:",
+      "",
+      "  /fleet             \u2014 fleet status, spawn, dispatch, kill, usage",
+      "  /spawn             \u2014 fire-and-forget subagent spawns",
+      "  /agents            \u2014 subagent status dashboard",
+      "",
+      "Director mode must be activated BEFORE any subagents are spawned.",
+      "Alternatively, start a session with --director:  wstack --director",
+      "",
+      "Director mode is a prerequisite for /fleet dispatch, /fleet spawn,",
+      'and /spawn. Without it, those commands will report "not wired."'
+    ].join("\n"),
     async run() {
       if (!opts.onDirector) return { message: "Director promotion is not available in this session." };
       const result = await opts.onDirector();
@@ -8508,6 +9588,9 @@ function buildStatuslineCommand(deps) {
     }
   };
 }
+
+// src/slash-commands/todos.ts
+init_helpers();
 function findTodo(todos, query) {
   const asIndex = Number.parseInt(query, 10);
   if (!Number.isNaN(asIndex)) {
@@ -8536,9 +9619,9 @@ function buildTodosCommand(opts) {
     async run(args) {
       const ctx = opts.context;
       if (!ctx) return { message: "No active context." };
-      const [verb, ...rest] = args.trim().split(/\s+/);
+      const { cmd, rest } = parseSubcommand(args);
       const restJoined = rest.join(" ").trim();
-      switch (verb) {
+      switch (cmd) {
         case "":
         case "show":
         case "list": {
@@ -8589,12 +9672,15 @@ function buildTodosCommand(opts) {
         }
         default:
           return {
-            message: `Unknown subcommand "${verb}". Try: show | clear | add <text> | done <id|index> | remove <id|index>`
+            message: unknownSubcommand(cmd, ["show", "clear", "add", "done", "remove"], "todos")
           };
       }
     }
   };
 }
+
+// src/slash-commands/tasks.ts
+init_helpers();
 function findTask(tasks, query) {
   const asIndex = Number.parseInt(query, 10);
   if (!Number.isNaN(asIndex)) {
@@ -8656,9 +9742,9 @@ function buildTasksCommand(_opts) {
       }
       const sessionId = ctx.session?.id ?? "unknown";
       const file = await loadTasks(taskPath) ?? emptyTaskFile(sessionId);
-      const [verb, ...rest] = args.trim().split(/\s+/);
+      const { cmd, rest } = parseSubcommand(args);
       const restJoined = rest.join(" ").trim();
-      switch (verb) {
+      switch (cmd) {
         case "":
         case "show":
         case "list":
@@ -8691,7 +9777,7 @@ ${formatTaskProgress(file.tasks)}` };
         case "start":
         case "done":
         case "fail": {
-          if (!restJoined) return { message: `Usage: /tasks ${verb} <id|index>` };
+          if (!restJoined) return { message: `Usage: /tasks ${cmd} <id|index>` };
           const found = findTask(file.tasks, restJoined);
           if (!found) return { message: `No task matched "${restJoined}".` };
           const statusMap = {
@@ -8699,7 +9785,13 @@ ${formatTaskProgress(file.tasks)}` };
             done: "completed",
             fail: "failed"
           };
-          found.item.status = statusMap[verb] ?? "pending";
+          const verbMap = {
+            start: "Started",
+            done: "Completed",
+            fail: "Failed"
+          };
+          const verb = verbMap[cmd] ?? cmd;
+          found.item.status = statusMap[cmd] ?? "pending";
           found.item.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
           await saveTasks(taskPath, file);
           return { message: `Marked ${verb}: ${found.item.title}
@@ -8781,7 +9873,7 @@ ${formatTaskProgress(file.tasks)}`
         }
         default:
           return {
-            message: `Unknown subcommand "${verb}". Try: show | add <title> | start <id> | done <id> | fail <id> | status <id> <s> | depends <id> <deps> | assign <id> <agent> | promote <id> | clear`
+            message: unknownSubcommand(cmd, ["show", "add", "start", "done", "fail", "status", "depends", "assign", "promote", "clear"], "tasks")
           };
       }
     }
@@ -9080,8 +10172,18 @@ function buildYoloCommand(opts) {
         newState = false;
       } else if (arg === "toggle") {
         newState = !opts.onYolo();
+      } else if (arg === "destructive") {
+        const currentMode = opts.onYolo();
+        if (!currentMode) {
+          const msg3 = `${color.amber("YOLO is OFF.")} Enable YOLO first with /yolo on, then /yolo destructive will control the confirmation gate.`;
+          opts.renderer.writeWarning(msg3);
+          return { message: msg3 };
+        }
+        const msg2 = `${color.amber("Destructive gate:")} ${color.dim("YOLO is ON \u2014 destructive operations require confirmation. Use /yolo destructive to toggle this gate.")}`;
+        opts.renderer.writeWarning(msg2);
+        return { message: msg2 };
       } else {
-        const msg2 = `Unknown argument: ${arg}. Use /yolo on, /yolo off, or /yolo toggle.`;
+        const msg2 = `Unknown argument: ${arg}. Use /yolo on, /yolo off, /yolo toggle, or /yolo destructive.`;
         opts.renderer.writeWarning(msg2);
         return { message: msg2 };
       }
@@ -9102,6 +10204,7 @@ function buildBuiltinSlashCommands(opts) {
     buildClearCommand(opts),
     buildCompactCommand(opts),
     buildContextCommand(opts),
+    buildDelegateCommand(opts),
     buildDevCommand(opts),
     buildCodebaseReindexCommand(opts),
     buildTechStackCommand(opts),
@@ -9964,10 +11067,10 @@ var theme = { primary: color.amber };
 async function saveToGlobalConfig(configPath2, provider, model, homeFn = () => process.env.HOME ?? os2__default.homedir()) {
   try {
     const { atomicWrite: atomicWrite14 } = await import('@wrongstack/core');
-    const fs30 = await import('fs/promises');
+    const fs31 = await import('fs/promises');
     let existing = {};
     try {
-      const raw = await fs30.readFile(configPath2, "utf8");
+      const raw = await fs31.readFile(configPath2, "utf8");
       existing = JSON.parse(raw);
     } catch {
     }
@@ -11982,6 +13085,9 @@ var exportCmd = async (args, deps) => {
   }
   return 0;
 };
+
+// src/subcommands/handlers/init.ts
+init_helpers();
 var initCmd = async (_args, deps) => {
   deps.renderer.write(color.bold("WrongStack init\n"));
   deps.renderer.writeInfo("Loading provider catalog from models.dev (cached locally)\u2026");
@@ -13293,7 +14399,7 @@ var rewindCmd = async (args, deps) => {
     if (result.revertedFiles.length === 0) {
       deps.renderer.write("No files to revert.\n");
       if (flags.resume) {
-        const store = new DefaultSessionStore({ dir: sessionsDir });
+        const store = new DefaultSessionStore$1({ dir: sessionsDir });
         const resumed = await store.resume(targetSessionId);
         const toIdx = result.toPromptIndex;
         await resumed.writer.truncateToCheckpoint(toIdx);
@@ -13311,7 +14417,7 @@ Reverted ${result.revertedFiles.length} file(s):
 `);
     }
     if (flags.resume) {
-      const store = new DefaultSessionStore({ dir: sessionsDir });
+      const store = new DefaultSessionStore$1({ dir: sessionsDir });
       const resumed = await store.resume(targetSessionId);
       const toIdx = result.toPromptIndex;
       const removed = await resumed.writer.truncateToCheckpoint(toIdx);
@@ -13461,10 +14567,10 @@ var auditCmd = async (args, deps) => {
   return verify.ok ? 0 : 1;
 };
 async function listAudits(log, dir, deps) {
-  const fs30 = await import('fs/promises');
+  const fs31 = await import('fs/promises');
   let entries;
   try {
-    entries = await fs30.readdir(dir);
+    entries = await fs31.readdir(dir);
   } catch {
     deps.renderer.write(
       color.dim(`No sessions dir found at ${dir}. Run a session first.`) + "\n"
@@ -14364,22 +15470,22 @@ function fmtDuration(ms) {
   const remMin = m - h * 60;
   return `${h}h${remMin}m`;
 }
-function fmtTaskResultLine(r, color62) {
+function fmtTaskResultLine(r, color63) {
   const stats = `${r.iterations}it ${r.toolCalls}tc ${fmtDuration(r.durationMs)}`;
   const errMsg = typeof r.error === "string" ? r.error : r.error?.message;
   const errKind = typeof r.error === "object" ? r.error?.kind : void 0;
   const errTail = errMsg ? ` \u2014 ${errMsg.replace(/\s+/g, " ").slice(0, 80)}${errMsg.length > 80 ? "\u2026" : ""}` : "";
-  const errKindChip = errKind ? color62.dim(` [${errKind}]`) : "";
-  const errSnip = errMsg || errKind ? `${errKindChip}${color62.dim(errTail)}` : "";
+  const errKindChip = errKind ? color63.dim(` [${errKind}]`) : "";
+  const errSnip = errMsg || errKind ? `${errKindChip}${color63.dim(errTail)}` : "";
   switch (r.status) {
     case "success":
-      return { mark: color62.green("\u2713"), stats, tail: "" };
+      return { mark: color63.green("\u2713"), stats, tail: "" };
     case "timeout":
-      return { mark: color62.yellow("\u23F1"), stats: `${color62.yellow("timeout")} ${stats}`, tail: errSnip };
+      return { mark: color63.yellow("\u23F1"), stats: `${color63.yellow("timeout")} ${stats}`, tail: errSnip };
     case "stopped":
-      return { mark: color62.dim("\u2298"), stats: `${color62.dim("stopped")} ${stats}`, tail: errSnip };
+      return { mark: color63.dim("\u2298"), stats: `${color63.dim("stopped")} ${stats}`, tail: errSnip };
     case "failed":
-      return { mark: color62.red("\u2717"), stats: `${color62.red("failed")} ${stats}`, tail: errSnip };
+      return { mark: color63.red("\u2717"), stats: `${color63.red("failed")} ${stats}`, tail: errSnip };
   }
 }
 
@@ -15919,7 +17025,7 @@ async function execute(deps) {
     onAutonomy,
     getNextPredict,
     onSuggestionsParsed,
-    getSuggestions,
+    getSuggestions: getSuggestions2,
     autoProceedDelayMs,
     autoProceedMaxIterations,
     onValidateAutoProceed,
@@ -15928,7 +17034,10 @@ async function execute(deps) {
     subscribeEternalIteration,
     subscribeEternalStage,
     skillLoader,
-    modeId
+    modeId,
+    sessionStore,
+    memoryStore,
+    modeStore
   } = deps;
   let code = 0;
   let fleetStatusLine = null;
@@ -16164,7 +17273,7 @@ async function execute(deps) {
                   configStore,
                   globalConfigPath: wpaths.globalConfig,
                   inProjectConfigPath: wpaths.inProjectConfig,
-                  vault: { encrypt: (v) => v, decrypt: (v) => v, isEncrypted: () => false }
+                  vault: noOpVault
                 },
                 (autonomy) => {
                   autonomy.defaultMode = s.mode;
@@ -16182,8 +17291,7 @@ async function execute(deps) {
                 const targetPath = configScope === "project" && wpaths.inProjectConfig ? wpaths.inProjectConfig : wpaths.globalConfig;
                 const raw = await fsp4.readFile(targetPath, "utf8").catch(() => "{}");
                 const parsed = JSON.parse(raw);
-                const vault = { encrypt: (v) => v, decrypt: (v) => v, isEncrypted: () => false };
-                const decrypted = decryptConfigSecrets$1(parsed, vault);
+                const decrypted = decryptConfigSecrets$1(parsed, noOpVault);
                 if (s.nextPrediction !== void 0) {
                   decrypted.nextPrediction = s.nextPrediction;
                 }
@@ -16241,7 +17349,7 @@ async function execute(deps) {
                   decrypted.autonomy = autonomy;
                 }
                 const toWrite = targetPath === wpaths.globalConfig ? decrypted : filterSafeForProject(decrypted);
-                const encrypted = encryptConfigSecrets$1(toWrite, vault);
+                const encrypted = encryptConfigSecrets$1(toWrite, noOpVault);
                 if (targetPath !== wpaths.globalConfig) {
                   await fsp4.mkdir(path10.dirname(targetPath), { recursive: true }).catch((err) => console.debug(`[execution] mkdir failed: ${err}`));
                 }
@@ -16360,7 +17468,12 @@ async function execute(deps) {
         open: !!flags.open,
         modelsRegistry,
         globalConfigPath: wpaths.globalConfig,
-        subscribeEternalIteration
+        subscribeEternalIteration,
+        sessionStore,
+        memoryStore,
+        skillLoader,
+        modeStore,
+        modeId
       });
       try {
         code = await runRepl({
@@ -16379,7 +17492,7 @@ async function execute(deps) {
           onAutonomy,
           getNextPredict,
           onSuggestionsParsed,
-          getSuggestions,
+          getSuggestions: getSuggestions2,
           autoProceedDelayMs,
           autoProceedMaxIterations,
           onValidateAutoProceed,
@@ -16411,7 +17524,7 @@ async function execute(deps) {
         onAutonomy,
         getNextPredict,
         onSuggestionsParsed,
-        getSuggestions,
+        getSuggestions: getSuggestions2,
         autoProceedDelayMs,
         onValidateAutoProceed,
         autoProceedMaxIterations,
@@ -18090,14 +19203,14 @@ function isIgnored(rel) {
   return rel.split(/[/\\]/).some((seg) => IGNORE_DIRS.has(seg));
 }
 async function setupCodebaseIndexing(deps) {
-  const { config, pipelines, projectRoot, logger } = deps;
+  const { config, context, pipelines, projectRoot, logger } = deps;
   const idx = config.indexing;
   if (!idx) return () => {
   };
   const debounceMs = idx.debounceMs ?? 400;
   const onError = (err) => logger.debug(`codebase auto-index failed: ${err instanceof Error ? err.message : String(err)}`);
   if (idx.onSessionStart) {
-    void runStartupIndex({ projectRoot }).then((r) => {
+    void runStartupIndex({ projectRoot, signal: context.signal }).then((r) => {
       logger.info(
         `codebase index ready: ${r.symbolsIndexed} symbols \xB7 ${r.filesIndexed} files \xB7 ${r.durationMs}ms`
       );
@@ -19754,8 +20867,10 @@ Restart WrongStack to load or unload plugin code in this session.`;
     onSuggestions: (suggestions) => {
       if (suggestions !== void 0) {
         currentSuggestions = suggestions;
+        setSuggestions(suggestions);
       }
-      return currentSuggestions;
+      const shared = getSuggestions();
+      return shared.length > 0 ? shared : currentSuggestions;
     },
     onAutonomy: (setTo) => {
       if (setTo !== void 0) {
@@ -19951,6 +21066,7 @@ Restart WrongStack to load or unload plugin code in this session.`;
   }
   const disposeIndexing = await setupCodebaseIndexing({
     config,
+    context,
     pipelines,
     projectRoot,
     logger
@@ -20005,8 +21121,12 @@ Restart WrongStack to load or unload plugin code in this session.`;
     getNextPredict: () => nextPredictEnabled,
     onSuggestionsParsed: (suggestions) => {
       currentSuggestions = suggestions ?? [];
+      setSuggestions(suggestions ?? []);
+    },
+    getSuggestions: () => {
+      const shared = getSuggestions();
+      return shared.length > 0 ? shared : currentSuggestions;
     },
-    getSuggestions: () => currentSuggestions,
     autoProceedDelayMs: config.autonomy?.autoProceedDelayMs ?? 45e3,
     autoProceedMaxIterations: config.autonomy?.autoProceedMaxIterations ?? 50,
     onValidateAutoProceed: async (suggestion, lastOutput) => {
@@ -20062,7 +21182,10 @@ Reply YES to auto-proceed, NO to wait for human input.`
       return () => stageListeners.delete(fn);
     },
     skillLoader: config.features.skills ? skillLoader : void 0,
-    modeId
+    modeId,
+    sessionStore,
+    memoryStore,
+    modeStore
   });
 }
 var isMain = import.meta.url === `file://${process.argv[1]?.replace(/\\/g, "/")}` || process.argv[1]?.endsWith("/cli/dist/index.js") || process.argv[1]?.endsWith("\\cli\\dist\\index.js");