@wrongstack/cli 0.1.4 → 0.1.8

package/dist/index.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-import { color, DefaultLogger, DefaultModelsRegistry, Container, DefaultConfigStore, TOKENS, DefaultSecretScrubber, DefaultRetryPolicy, DefaultErrorHandler, DefaultTokenCounter, DefaultSessionStore, DefaultMemoryStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultPermissionPolicy, HybridCompactor, ProviderRegistry, ToolRegistry, createContextManagerTool, EventBus, InMemoryMetricsSink, wireMetricsToEvents, DefaultHealthRegistry, startMetricsServer, RecoveryLock, DefaultAttachmentStore, QueueStore, Context, createDefaultPipelines, AutoCompactionMiddleware, Agent, SlashCommandRegistry, loadPlugins, DefaultPathResolver, resolveWstackPaths, DefaultSecretVault, migratePlaintextSecrets, DefaultConfigLoader, InputBuilder, DefaultPluginAPI, DefaultSessionReader, atomicWrite, makeAgentSubagentRunner, DefaultMultiAgentCoordinator, decryptConfigSecrets, encryptConfigSecrets } from '@wrongstack/core';
+import { color, DefaultLogger, DefaultModelsRegistry, Container, DefaultConfigStore, TOKENS, DefaultSecretScrubber, DefaultRetryPolicy, DefaultErrorHandler, DefaultTokenCounter, DefaultModeStore, DefaultSessionStore, DefaultMemoryStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultPermissionPolicy, HybridCompactor, ProviderRegistry, ToolRegistry, createContextManagerTool, EventBus, InMemoryMetricsSink, wireMetricsToEvents, DefaultHealthRegistry, startMetricsServer, RecoveryLock, DefaultAttachmentStore, QueueStore, Context, createDefaultPipelines, AutoCompactionMiddleware, Agent, SlashCommandRegistry, loadPlugins, DefaultPathResolver, resolveWstackPaths, DefaultSecretVault, migratePlaintextSecrets, DefaultConfigLoader, InputBuilder, DefaultPluginAPI, atomicWrite, DefaultSessionReader, makeAgentSubagentRunner, Director, DefaultMultiAgentCoordinator, decryptConfigSecrets, encryptConfigSecrets } from '@wrongstack/core';
+import { WebSocketServer, WebSocket } from 'ws';
 import * as fs6 from 'fs/promises';
 import { writeFileSync } from 'fs';
 import { createRequire } from 'module';
@@ -34,6 +35,506 @@ var init_plugin_api_factory = __esm({
   "src/plugin-api-factory.ts"() {
   }
 });
+
+// src/webui-server.ts
+var webui_server_exports = {};
+__export(webui_server_exports, {
+  runWebUI: () => runWebUI
+});
+async function runWebUI(opts) {
+  const port = opts.port ?? 3457;
+  const clients = /* @__PURE__ */ new Map();
+  let abortController = null;
+  const wss = new WebSocketServer({ port });
+  console.log(`[WebUI] WebSocket server starting on ws://localhost:${port}`);
+  const eventUnsubscribers = [];
+  function setupEvents() {
+    for (const unsub of eventUnsubscribers) unsub();
+    eventUnsubscribers.length = 0;
+    eventUnsubscribers.push(
+      opts.events.on("iteration.started", (e) => {
+        broadcast({
+          type: "iteration.started",
+          payload: { index: e.index }
+        });
+      })
+    );
+    eventUnsubscribers.push(
+      opts.events.on("provider.text_delta", (e) => {
+        broadcast({
+          type: "provider.text_delta",
+          payload: { text: e.text, messageId: "current" }
+        });
+      })
+    );
+    eventUnsubscribers.push(
+      opts.events.on("tool.started", (e) => {
+        broadcast({
+          type: "tool.started",
+          payload: {
+            id: e.id,
+            name: e.name,
+            input: e.input,
+            messageId: `tool_${e.id}`
+          }
+        });
+      })
+    );
+    eventUnsubscribers.push(
+      opts.events.on("tool.progress", (e) => {
+        broadcast({
+          type: "tool.progress",
+          payload: {
+            name: e.name,
+            id: e.id,
+            event: e.event
+          }
+        });
+      })
+    );
+    eventUnsubscribers.push(
+      opts.events.on("tool.executed", (e) => {
+        broadcast({
+          type: "tool.executed",
+          payload: {
+            // Forward the tool_use id so the WebUI can correlate this with
+            // the matching tool.started bubble for parallel tool calls.
+            id: e.id,
+            name: e.name,
+            durationMs: e.durationMs,
+            ok: e.ok,
+            input: e.input,
+            output: e.output
+          }
+        });
+      })
+    );
+    eventUnsubscribers.push(
+      opts.events.on("provider.response", (e) => {
+        broadcast({
+          type: "provider.response",
+          payload: {
+            usage: e.usage,
+            stopReason: e.stopReason,
+            messageId: "current"
+          }
+        });
+      })
+    );
+    eventUnsubscribers.push(
+      opts.events.on("error", (e) => {
+        broadcast({
+          type: "error",
+          payload: {
+            phase: e.phase,
+            message: e.err instanceof Error ? e.err.message : String(e.err)
+          }
+        });
+      })
+    );
+  }
+  return new Promise((resolve3) => {
+    wss.on("listening", () => {
+      console.log(`[WebUI] WebSocket server running on ws://localhost:${port}`);
+      setupEvents();
+    });
+    wss.on("connection", (ws) => {
+      const client = { ws, sessionId: opts.session.id };
+      clients.set(ws, client);
+      console.log("[WebUI] Client connected");
+      ws.on("message", async (data) => {
+        try {
+          const msg = JSON.parse(data.toString());
+          await handleMessage(ws, client, msg);
+        } catch (err) {
+          console.error("[WebUI] Failed to parse message", err);
+        }
+      });
+      ws.on("close", () => {
+        console.log("[WebUI] Client disconnected");
+        clients.delete(ws);
+      });
+      send(ws, {
+        type: "session.start",
+        payload: {
+          sessionId: opts.session.id,
+          model: opts.agent.ctx.model,
+          provider: opts.agent.ctx.provider.id
+        }
+      });
+    });
+    wss.on("error", (err) => {
+      console.error("[WebUI] Server error:", err);
+    });
+    function shutdown() {
+      console.log("[WebUI] Shutting down...");
+      for (const unsub of eventUnsubscribers) unsub();
+      for (const [ws] of clients) {
+        ws.close();
+      }
+      clients.clear();
+      wss.close(() => {
+        console.log("[WebUI] Server stopped");
+        resolve3();
+      });
+    }
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  });
+  async function handleMessage(ws, client, msg) {
+    switch (msg.type) {
+      case "user_message":
+        await handleUserMessage(ws, client, msg.payload.content);
+        break;
+      case "abort":
+        abortController?.abort();
+        broadcast({
+          type: "error",
+          payload: { phase: "abort", message: "User aborted" }
+        });
+        break;
+      case "ping":
+        send(ws, { type: "pong", payload: {} });
+        break;
+      case "providers.list":
+        await handleProvidersList(ws);
+        break;
+      case "provider.models":
+        await handleProviderModels(ws, msg.payload.providerId);
+        break;
+      case "providers.saved":
+        await handleProvidersSaved(ws);
+        break;
+      case "key.add":
+      case "key.update": {
+        const m = msg;
+        await handleKeyUpsert(ws, m.payload.providerId, m.payload.label, m.payload.apiKey);
+        break;
+      }
+      case "key.delete": {
+        const m = msg;
+        await handleKeyDelete(ws, m.payload.providerId, m.payload.label);
+        break;
+      }
+      case "key.set_active": {
+        const m = msg;
+        await handleKeySetActive(ws, m.payload.providerId, m.payload.label);
+        break;
+      }
+      case "provider.add": {
+        const m = msg;
+        await handleProviderAdd(ws, m.payload);
+        break;
+      }
+      case "provider.remove": {
+        const m = msg;
+        await handleProviderRemove(ws, m.payload.providerId);
+        break;
+      }
+    }
+  }
+  async function handleUserMessage(ws, client, content) {
+    abortController?.abort();
+    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) {
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify(msg));
+    }
+  }
+  function broadcast(msg) {
+    const data = JSON.stringify(msg);
+    for (const [ws] of clients) {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(data);
+      }
+    }
+  }
+  async function handleProvidersList(ws) {
+    if (!opts.modelsRegistry) {
+      sendResult(ws, false, "Models registry not available");
+      return;
+    }
+    try {
+      const providers = await opts.modelsRegistry.listProviders();
+      const savedProviders = await loadSavedProviders();
+      const savedIds = new Set(Object.keys(savedProviders));
+      send(ws, {
+        type: "provider.catalog",
+        payload: {
+          providers: providers.map((p) => ({
+            id: p.id,
+            name: p.name,
+            family: p.family,
+            apiBase: p.apiBase,
+            envVars: p.envVars,
+            modelCount: p.models.length,
+            hasApiKey: savedIds.has(p.id) || p.envVars.some((v) => !!process.env[v])
+          }))
+        }
+      });
+    } catch (err) {
+      sendResult(ws, false, err instanceof Error ? err.message : String(err));
+    }
+  }
+  async function handleProviderModels(ws, providerId) {
+    if (!opts.modelsRegistry) {
+      sendResult(ws, false, "Models registry not available");
+      return;
+    }
+    try {
+      const provider = await opts.modelsRegistry.getProvider(providerId);
+      if (!provider) {
+        sendResult(ws, false, `Provider "${providerId}" not found in catalog`);
+        return;
+      }
+      send(ws, {
+        type: "provider.models",
+        payload: {
+          provider: providerId,
+          models: provider.models.map((m) => ({
+            id: m.id,
+            name: m.name,
+            releaseDate: m.release_date,
+            contextWindow: m.limit?.context,
+            inputCost: m.cost?.input,
+            outputCost: m.cost?.output,
+            capabilities: [
+              ...m.tool_call ? ["tools"] : [],
+              ...m.reasoning ? ["reasoning"] : [],
+              ...m.modalities?.input?.includes("image") ? ["vision"] : [],
+              ...m.open_weights ? ["open_weights"] : []
+            ]
+          }))
+        }
+      });
+    } catch (err) {
+      sendResult(ws, false, err instanceof Error ? err.message : String(err));
+    }
+  }
+  async function handleProvidersSaved(ws) {
+    try {
+      const providers = await loadSavedProviders();
+      send(ws, {
+        type: "providers.saved",
+        payload: {
+          providers: Object.entries(providers).map(([id, cfg]) => ({
+            id,
+            family: cfg.family,
+            baseUrl: cfg.baseUrl,
+            apiKeys: normalizeKeys2(cfg).map((k) => ({
+              label: k.label,
+              maskedKey: maskedKey2(k.apiKey),
+              isActive: k.label === cfg.activeKey,
+              createdAt: k.createdAt
+            }))
+          }))
+        }
+      });
+    } catch (err) {
+      sendResult(ws, false, err instanceof Error ? err.message : String(err));
+    }
+  }
+  async function handleKeyUpsert(ws, providerId, label, apiKey) {
+    try {
+      const providers = await loadSavedProviders();
+      const existing = providers[providerId] ?? { type: providerId };
+      const keys = normalizeKeys2(existing);
+      const existingIdx = keys.findIndex((k) => k.label === label);
+      if (existingIdx >= 0) {
+        keys[existingIdx] = { ...keys[existingIdx], apiKey, createdAt: nowIso2() };
+      } else {
+        keys.push({ label, apiKey, createdAt: nowIso2() });
+      }
+      writeKeysBack2(existing, keys);
+      if (!existing.activeKey) existing.activeKey = label;
+      providers[providerId] = existing;
+      await saveProviders(providers);
+      sendResult(ws, true, `Key "${label}" saved for ${providerId}`);
+    } catch (err) {
+      sendResult(ws, false, err instanceof Error ? err.message : String(err));
+    }
+  }
+  async function handleKeyDelete(ws, providerId, label) {
+    try {
+      const providers = await loadSavedProviders();
+      const existing = providers[providerId];
+      if (!existing) {
+        sendResult(ws, false, `Provider "${providerId}" not found`);
+        return;
+      }
+      const keys = normalizeKeys2(existing).filter((k) => k.label !== label);
+      if (keys.length === 0) {
+        delete providers[providerId];
+      } else {
+        writeKeysBack2(existing, keys);
+        if (existing.activeKey === label) {
+          existing.activeKey = keys[0].label;
+        }
+        providers[providerId] = existing;
+      }
+      await saveProviders(providers);
+      sendResult(ws, true, `Key "${label}" deleted from ${providerId}`);
+    } catch (err) {
+      sendResult(ws, false, err instanceof Error ? err.message : String(err));
+    }
+  }
+  async function handleKeySetActive(ws, providerId, label) {
+    try {
+      const providers = await loadSavedProviders();
+      const existing = providers[providerId];
+      if (!existing) {
+        sendResult(ws, false, `Provider "${providerId}" not found`);
+        return;
+      }
+      existing.activeKey = label;
+      writeKeysBack2(existing, normalizeKeys2(existing));
+      providers[providerId] = existing;
+      await saveProviders(providers);
+      sendResult(ws, true, `Active key for ${providerId} set to "${label}"`);
+    } catch (err) {
+      sendResult(ws, false, err instanceof Error ? err.message : String(err));
+    }
+  }
+  async function handleProviderAdd(ws, payload) {
+    try {
+      const providers = await loadSavedProviders();
+      if (providers[payload.id]) {
+        sendResult(ws, false, `Provider "${payload.id}" already exists. Use key.add to add a key.`);
+        return;
+      }
+      const newProv = {
+        type: payload.id,
+        family: payload.family,
+        baseUrl: payload.baseUrl
+      };
+      if (payload.apiKey) {
+        newProv.apiKeys = [{ label: "default", apiKey: payload.apiKey, createdAt: nowIso2() }];
+        newProv.activeKey = "default";
+      }
+      providers[payload.id] = newProv;
+      await saveProviders(providers);
+      sendResult(ws, true, `Provider "${payload.id}" added`);
+    } catch (err) {
+      sendResult(ws, false, err instanceof Error ? err.message : String(err));
+    }
+  }
+  async function handleProviderRemove(ws, providerId) {
+    try {
+      const providers = await loadSavedProviders();
+      if (!providers[providerId]) {
+        sendResult(ws, false, `Provider "${providerId}" not found`);
+        return;
+      }
+      delete providers[providerId];
+      await saveProviders(providers);
+      sendResult(ws, true, `Provider "${providerId}" removed`);
+    } catch (err) {
+      sendResult(ws, false, err instanceof Error ? err.message : String(err));
+    }
+  }
+  async function loadSavedProviders() {
+    if (!opts.globalConfigPath) return {};
+    let raw;
+    try {
+      raw = await fs6.readFile(opts.globalConfigPath, "utf8");
+    } catch {
+      return {};
+    }
+    let parsed = {};
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return {};
+    }
+    return parsed.providers ?? {};
+  }
+  async function saveProviders(providers) {
+    if (!opts.globalConfigPath) return;
+    let raw;
+    try {
+      raw = await fs6.readFile(opts.globalConfigPath, "utf8");
+    } catch {
+      raw = "{}";
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      parsed = {};
+    }
+    parsed.providers = providers;
+    await atomicWrite(opts.globalConfigPath, JSON.stringify(parsed, null, 2), { mode: 384 });
+  }
+  function normalizeKeys2(cfg) {
+    if (Array.isArray(cfg.apiKeys) && cfg.apiKeys.length > 0) {
+      return cfg.apiKeys.map((k) => ({ ...k }));
+    }
+    if (typeof cfg.apiKey === "string" && cfg.apiKey.length > 0) {
+      return [{ label: "default", apiKey: cfg.apiKey, createdAt: "" }];
+    }
+    return [];
+  }
+  function writeKeysBack2(cfg, keys) {
+    if (keys.length === 0) {
+      delete cfg.apiKeys;
+      delete cfg.apiKey;
+      delete cfg.activeKey;
+      return;
+    }
+    cfg.apiKeys = keys;
+    const active = keys.find((k) => k.label === cfg.activeKey) ?? keys[0];
+    cfg.apiKey = active.apiKey;
+    if (!cfg.activeKey || !keys.some((k) => k.label === cfg.activeKey)) {
+      cfg.activeKey = active.label;
+    }
+  }
+  function maskedKey2(key) {
+    if (!key) return "\u2014";
+    if (key.length <= 8) return "\u2022".repeat(key.length);
+    const head = key.slice(0, 4);
+    const tail = key.slice(-4);
+    return `${head}\u2026${tail}`;
+  }
+  function nowIso2() {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+  function sendResult(ws, success, message) {
+    send(ws, { type: "key.operation_result", payload: { success, message } });
+  }
+}
+var init_webui_server = __esm({
+  "src/webui-server.ts"() {
+  }
+});
 var ReadlineInputReader = class {
   rl;
   historyFile;
@@ -516,17 +1017,17 @@ async function resolveModelSelection(answer, models, provider, _registry, render
 var theme2 = { primary: color.amber };
 async function saveToGlobalConfig(configPath, provider, model) {
   try {
-    const { atomicWrite: atomicWrite3 } = await import('@wrongstack/core');
-    const fs8 = await import('fs/promises');
+    const { atomicWrite: atomicWrite4 } = await import('@wrongstack/core');
+    const fs9 = await import('fs/promises');
     let existing = {};
     try {
-      const raw = await fs8.readFile(configPath, "utf8");
+      const raw = await fs9.readFile(configPath, "utf8");
       existing = JSON.parse(raw);
     } catch {
     }
     existing.provider = provider;
     existing.model = model;
-    await atomicWrite3(configPath, JSON.stringify(existing, null, 2));
+    await atomicWrite4(configPath, JSON.stringify(existing, null, 2));
     return true;
   } catch {
     return false;
@@ -545,9 +1046,11 @@ function buildBuiltinSlashCommands(opts) {
     statsCommand(opts),
     spawnCommand(opts),
     agentsCommand(opts),
+    fleetCommand(opts),
     metricsCommand(opts),
     healthCommand(opts),
     memoryCommand(opts),
+    todosCommand(opts),
     saveCommand(opts),
     loadCommand(opts),
     exitCommand(opts)
@@ -597,6 +1100,68 @@ function memoryCommand(opts) {
     }
   };
 }
+function todosCommand(opts) {
+  return {
+    name: "todos",
+    description: "Inspect or edit the live todo list: /todos [show|clear|add <text>|done <id|index>]",
+    async run(args) {
+      const ctx = opts.context;
+      if (!ctx) return { message: "No active context." };
+      const [verb, ...rest] = args.trim().split(/\s+/);
+      const restJoined = rest.join(" ").trim();
+      switch (verb) {
+        case "":
+        case "show":
+        case "list": {
+          const todos = ctx.todos;
+          if (todos.length === 0) {
+            return { message: "No todos. The agent will add some when it plans work." };
+          }
+          const lines = [];
+          const done = todos.filter((t) => t.status === "completed").length;
+          lines.push(color.dim(`Todos (${done}/${todos.length} done):`));
+          todos.forEach((t, i) => {
+            const mark = t.status === "completed" ? color.green("[x]") : t.status === "in_progress" ? color.yellow("[~]") : color.dim("[ ]");
+            const text = t.status === "in_progress" && t.activeForm ? t.activeForm : t.content;
+            const label = t.status === "completed" ? color.dim(text) : text;
+            lines.push(`  ${color.dim(String(i + 1).padStart(2))}. ${mark} ${label}`);
+          });
+          return { message: lines.join("\n") };
+        }
+        case "clear": {
+          const n = ctx.todos.length;
+          ctx.todos.length = 0;
+          return { message: n === 0 ? "Todos were already empty." : `Cleared ${n} todo${n === 1 ? "" : "s"}.` };
+        }
+        case "add": {
+          if (!restJoined) return { message: "Usage: /todos add <text>" };
+          ctx.todos.push({
+            id: `todo_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`,
+            content: restJoined,
+            status: "pending"
+          });
+          return { message: `Added: ${restJoined}` };
+        }
+        case "done":
+        case "complete": {
+          if (!restJoined) return { message: "Usage: /todos done <id|index>" };
+          const asIndex = Number.parseInt(restJoined, 10);
+          let target = !Number.isNaN(asIndex) ? ctx.todos[asIndex - 1] : ctx.todos.find((t) => t.id === restJoined);
+          if (!target) {
+            target = ctx.todos.find((t) => t.content.toLowerCase().includes(restJoined.toLowerCase()));
+          }
+          if (!target) return { message: `No todo matched "${restJoined}".` };
+          target.status = "completed";
+          return { message: `Marked done: ${target.content}` };
+        }
+        default:
+          return {
+            message: `Unknown subcommand "${verb}". Try: show | clear | add <text> | done <id|index>`
+          };
+      }
+    }
+  };
+}
 function initCommand(opts) {
   return {
     name: "init",
@@ -810,11 +1375,11 @@ function clearCommand(opts) {
     ].join("\n"),
     async run(_args, ctx) {
       if (ctx) {
-        ctx.messages = [];
-        ctx.todos = [];
+        ctx.state.replaceMessages([]);
+        ctx.state.replaceTodos([]);
         ctx.readFiles.clear();
         ctx.fileMtimes.clear();
-        ctx.meta = {};
+        for (const key of Object.keys(ctx.meta)) ctx.state.deleteMeta(key);
       }
       await opts.memoryStore?.clear();
       opts.onClear?.();
@@ -960,21 +1525,25 @@ ${lines.join("\n")}
 function skillCommand(opts) {
   return {
     name: "skill",
-    description: "Show a skill manifest or list skills.",
+    description: "Show skill details or list available skills.",
     async run(args) {
       if (!opts.skillLoader) {
         const msg = "No skill loader configured.";
         return { message: msg };
       }
       if (!args.trim()) {
-        const list = await opts.skillLoader.list();
-        if (list.length === 0) {
+        const entries = await opts.skillLoader.listEntries();
+        if (entries.length === 0) {
           const msg2 = "No skills found.";
           return { message: msg2 };
         }
-        const lines = list.map((s) => `  ${s.name.padEnd(24)} ${color.dim(`[${s.source}]`)} ${s.description.split("\n")[0]}`);
-        const msg = `Skills:
-${lines.join("\n")}
+        const lines = entries.map((e) => {
+          const scopeTag = e.scope.length > 0 ? `  ${color.dim(`(${e.scope.slice(0, 3).join(", ")})`)}` : "";
+          return `  ${color.bold(e.name)}${scopeTag}
+    Use when: ${e.trigger}`;
+        });
+        const msg = `Available skills:
+${lines.join("\n\n")}
 `;
         return { message: msg };
       }
@@ -1105,18 +1674,46 @@ function statusIcon(status) {
   if (status === "degraded") return color.yellow("\u25CF");
   return color.red("\u25CF");
 }
+function parseSpawnFlags(input) {
+  const opts = {};
+  let rest = input;
+  const consume = (re) => {
+    const m = rest.match(re);
+    if (m) {
+      rest = rest.slice(m[0].length).replace(/^\s+/, "");
+      return m;
+    }
+    return null;
+  };
+  while (rest.length > 0) {
+    let m;
+    if (m = consume(/^--provider=(\S+)\s*/)) opts.provider = m[1];
+    else if (m = consume(/^--model=(\S+)\s*/)) opts.model = m[1];
+    else if (m = consume(/^--name=("([^"]+)"|(\S+))\s*/)) opts.name = m[2] ?? m[3];
+    else if (m = consume(/^--tools=(\S+)\s*/)) opts.tools = m[1].split(",").map((t) => t.trim()).filter(Boolean);
+    else if (m = consume(/^-p\s+(\S+)\s*/)) opts.provider = m[1];
+    else if (m = consume(/^-m\s+(\S+)\s*/)) opts.model = m[1];
+    else if (m = consume(/^-n\s+("([^"]+)"|(\S+))\s*/)) opts.name = m[2] ?? m[3];
+    else break;
+  }
+  return { description: rest.trim(), opts };
+}
 function spawnCommand(opts) {
   return {
     name: "spawn",
-    description: "Spawn an isolated subagent to handle a task. Usage: /spawn <task description>",
+    description: "Spawn an isolated subagent to handle a task. Usage: /spawn [--provider=<id>] [--model=<id>] [--name=<label>] [--tools=a,b,c] <task description>",
     async run(args) {
-      const description = args.trim();
-      if (!description) return { message: "Usage: /spawn <task description>" };
+      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>"
+        };
+      }
       if (!opts.onSpawn) {
         return { message: "Multi-agent is not enabled in this session." };
       }
       try {
-        const summary = await opts.onSpawn(description);
+        const summary = Object.keys(parsed).length > 0 ? await opts.onSpawn(description, parsed) : await opts.onSpawn(description);
         return { message: summary };
       } catch (err) {
         return {
@@ -1138,6 +1735,63 @@ function agentsCommand(opts) {
     }
   };
 }
+function fleetCommand(opts) {
+  return {
+    name: "fleet",
+    description: "Inspect or control the subagent fleet: /fleet [status|usage|kill <id>|manifest|help]",
+    help: [
+      "Usage:",
+      "  /fleet                  Show fleet status (alias for /fleet status).",
+      "  /fleet status           Pending + completed subagent task table.",
+      "  /fleet usage            Per-subagent runtime cost \u2014 iterations, tool calls, duration.",
+      "  /fleet kill <id>        Terminate a running subagent by id (or prefix).",
+      "  /fleet manifest         Print the director manifest (only with --director).",
+      "  /fleet help             Show this help.",
+      "",
+      "Subagent ids are returned by /spawn and listed in /fleet status."
+    ].join("\n"),
+    async run(args) {
+      if (!opts.onFleet) {
+        return { message: "Multi-agent is not enabled in this session." };
+      }
+      const trimmed = args.trim();
+      const [verb, ...rest] = trimmed.length === 0 ? ["status"] : trimmed.split(/\s+/);
+      const target = rest.join(" ").trim() || void 0;
+      switch (verb) {
+        case "status":
+        case "usage":
+        case "manifest": {
+          const out = await opts.onFleet(verb, void 0);
+          return { message: out };
+        }
+        case "kill": {
+          if (!target) {
+            return { message: "Usage: /fleet kill <subagent-id>" };
+          }
+          const out = await opts.onFleet("kill", target);
+          return { message: out };
+        }
+        case "help":
+        case "?":
+          return {
+            message: [
+              "/fleet \u2014 inspect or control the subagent fleet",
+              "",
+              "  /fleet                  \u2192 status (default)",
+              "  /fleet status           pending + completed tasks per subagent",
+              "  /fleet usage            iterations, tool calls, duration roll-up",
+              "  /fleet kill <id>        terminate a subagent",
+              "  /fleet manifest         director manifest (requires --director)"
+            ].join("\n")
+          };
+        default:
+          return {
+            message: `Unknown subcommand "${verb}". Try: status | usage | kill <id> | manifest | help`
+          };
+      }
+    }
+  };
+}
 
 // src/pre-launch.ts
 var MANIFESTS = [
@@ -1498,7 +2152,7 @@ function patchConfig(base, patch) {
 
 // src/repl.ts
 async function runRepl(opts) {
-  if (opts.banner !== false) printBanner(opts.renderer);
+  if (opts.banner !== false) printBanner(opts.renderer, opts.projectName);
   let activeCtrl;
   let interrupts = 0;
   const onSigint = () => {
@@ -1516,78 +2170,82 @@ async function runRepl(opts) {
   };
   process.on("SIGINT", onSigint);
   const builder = new InputBuilder({ store: opts.attachments });
-  for (; ; ) {
-    let raw;
-    try {
-      raw = await readPossiblyMultiline(opts);
-    } catch {
-      break;
-    }
-    const trimmed = raw.trim();
-    if (!trimmed) {
-      interrupts = 0;
-      continue;
-    }
-    interrupts = 0;
-    if (trimmed.startsWith("/")) {
+  try {
+    for (; ; ) {
+      let raw;
       try {
-        const res = await opts.slashRegistry.dispatch(trimmed, opts.agent.ctx);
-        if (res?.message) opts.renderer.write(`${res.message}
+        raw = await readPossiblyMultiline(opts);
+      } catch {
+        break;
+      }
+      const trimmed = raw.trim();
+      if (!trimmed) {
+        interrupts = 0;
+        continue;
+      }
+      interrupts = 0;
+      if (trimmed.startsWith("/")) {
+        try {
+          const res = await opts.slashRegistry.dispatch(trimmed, opts.agent.ctx);
+          if (res?.message) opts.renderer.write(`${res.message}
 `);
-        if (res?.exit) break;
-      } catch (err) {
-        opts.renderer.writeError(err instanceof Error ? err.message : String(err));
+          if (res?.exit) break;
+        } catch (err) {
+          opts.renderer.writeError(err instanceof Error ? err.message : String(err));
+        }
+        continue;
       }
-      continue;
-    }
-    const ph = await builder.appendPaste(raw);
-    if (ph) {
-      const lineCount = raw.split("\n").length;
-      opts.renderer.write(color.dim(`  \u21B3 ${ph} (${lineCount} lines)
+      const ph = await builder.appendPaste(raw);
+      if (ph) {
+        const lineCount = raw.split("\n").length;
+        opts.renderer.write(color.dim(`  \u21B3 ${ph} (${lineCount} lines)
 `));
-    }
-    const blocks = await builder.submit();
-    const runCtrl = new AbortController();
-    activeCtrl = runCtrl;
-    try {
-      const startedAt = Date.now();
-      const before = opts.tokenCounter?.total();
-      const costBefore = opts.tokenCounter?.estimateCost().total ?? 0;
-      const result = await opts.agent.run(blocks, { signal: runCtrl.signal });
-      if (result.status === "aborted") {
-        opts.renderer.writeWarning("Aborted.");
-      } else if (result.status === "failed") {
-        const err = result.error;
-        if (err) {
-          const tag = err.recoverable ? " (recoverable)" : "";
-          opts.renderer.writeError(`Failed [${err.severity}]${tag}: ${err.describe()}`);
-        } else {
-          opts.renderer.writeError("Failed.");
-        }
-      } else if (result.status === "max_iterations") {
-        opts.renderer.writeWarning(`Hit max iterations (${result.iterations}).`);
       }
-      if (opts.tokenCounter && before) {
-        const after = opts.tokenCounter.total();
-        const costAfter = opts.tokenCounter.estimateCost().total;
-        const ctxChip = opts.effectiveMaxContext && opts.effectiveMaxContext > 0 ? `  ctx: ${renderContextChip(after.input, opts.effectiveMaxContext)}` : "";
-        opts.renderer.write(
-          `
+      const blocks = await builder.submit();
+      const runCtrl = new AbortController();
+      activeCtrl = runCtrl;
+      try {
+        const startedAt = Date.now();
+        const before = opts.tokenCounter?.total();
+        const costBefore = opts.tokenCounter?.estimateCost().total ?? 0;
+        const result = await opts.agent.run(blocks, { signal: runCtrl.signal });
+        if (result.status === "aborted") {
+          opts.renderer.writeWarning("Aborted.");
+        } else if (result.status === "failed") {
+          const err = result.error;
+          if (err) {
+            const tag = err.recoverable ? " (recoverable)" : "";
+            opts.renderer.writeError(`Failed [${err.severity}]${tag}: ${err.describe()}`);
+          } else {
+            opts.renderer.writeError("Failed.");
+          }
+        } else if (result.status === "max_iterations") {
+          opts.renderer.writeWarning(`Hit max iterations (${result.iterations}).`);
+        }
+        if (opts.tokenCounter && before) {
+          const after = opts.tokenCounter.total();
+          const costAfter = opts.tokenCounter.estimateCost().total;
+          const ctxChip = opts.effectiveMaxContext && opts.effectiveMaxContext > 0 ? `  ctx: ${renderContextChip(after.input, opts.effectiveMaxContext)}` : "";
+          opts.renderer.write(
+            `
 ${color.dim(
-            `[in: ${fmtTok(after.input - before.input)}  out: ${fmtTok(after.output - before.output)}  iters: ${result.iterations}  cost: ${(costAfter - costBefore).toFixed(4)}  ${((Date.now() - startedAt) / 1e3).toFixed(1)}s]${ctxChip}`
-          )}
+              `[in: ${fmtTok(after.input - before.input)}  out: ${fmtTok(after.output - before.output)}  iters: ${result.iterations}  cost: ${(costAfter - costBefore).toFixed(4)}  ${((Date.now() - startedAt) / 1e3).toFixed(1)}s]${ctxChip}`
+            )}
 `
-        );
+          );
+        }
+      } catch (err) {
+        opts.renderer.writeError(err instanceof Error ? err.message : String(err));
+      } finally {
+        activeCtrl = void 0;
       }
-    } catch (err) {
-      opts.renderer.writeError(err instanceof Error ? err.message : String(err));
-    } finally {
-      activeCtrl = void 0;
     }
+    return 0;
+  } finally {
+    process.off("SIGINT", onSigint);
+    await opts.reader.close().catch(() => {
+    });
   }
-  process.off("SIGINT", onSigint);
-  await opts.reader.close();
-  return 0;
 }
 async function readPossiblyMultiline(opts) {
   const firstPrompt = theme.primary("\u203A ");
@@ -1624,13 +2282,15 @@ function renderProgress(ratio, width) {
   const capped = Math.min(width, filled);
   return FILLED.repeat(capped) + EMPTY.repeat(width - capped);
 }
-function printBanner(renderer) {
+function printBanner(renderer, projectName) {
   const lines = [
     theme.primary(theme.bold("WrongStack")) + color.dim(` v${CLI_VERSION}`),
-    color.dim("Built on the wrong stack. Shipped anyway."),
-    color.dim("Type /help for commands, /exit to quit."),
-    ""
+    color.dim("Built on the wrong stack. Shipped anyway.")
   ];
+  if (projectName && projectName.length > 0) {
+    lines.push(color.dim("Project: ") + theme.bold(projectName));
+  }
+  lines.push(color.dim("Type /help for commands, /exit to quit."), "");
   renderer.write(`${lines.join("\n")}
 `);
 }
@@ -1900,25 +2560,31 @@ async function ensureProjectMeta(paths, projectRoot) {
   }
 }
 var MultiAgentHost = class {
-  constructor(deps) {
+  constructor(deps, opts = {}) {
     this.deps = deps;
+    this.opts = opts;
   }
   deps;
   coordinator;
+  /** Lazily built when `opts.directorMode` is set. Owns its own internal
+   *  coordinator; the host's `coordinator` field still points at it so
+   *  the rest of the methods don't need to branch. */
+  director;
   pending = /* @__PURE__ */ new Map();
   results = [];
+  opts;
   async ensureCoordinator() {
     if (this.coordinator) return this.coordinator;
     const config = this.deps.configStore.get();
     const factory = async (subCfg) => {
       const events = new EventBus();
-      const provider = await this.buildSubagentProvider(config);
+      const provider = await this.buildSubagentProvider(config, subCfg.provider);
       const baseSystem = await this.deps.systemPromptBuilder.build({
         cwd: this.deps.cwd,
         projectRoot: this.deps.projectRoot,
         tools: this.filterTools(subCfg.tools),
         model: subCfg.model ?? config.model,
-        provider: config.provider
+        provider: subCfg.provider ?? config.provider
       });
       const parentSession = this.deps.session;
       const subSession = {
@@ -1929,6 +2595,11 @@ var MultiAgentHost = class {
         systemPrompt: baseSystem,
         provider,
         session: subSession,
+        // Placeholder — Agent.run() overwrites ctx.signal with the live
+        // per-run signal (see core/agent.ts run()). Tools/middleware that
+        // read ctx.signal after construction will see the runtime signal,
+        // not this one. Kept as `new AbortController().signal` so the
+        // initial value is non-null/non-aborted.
         signal: new AbortController().signal,
         tokenCounter: this.deps.tokenCounter,
         cwd: this.deps.cwd,
@@ -1947,15 +2618,26 @@ var MultiAgentHost = class {
       return { agent, events };
     };
     const runner = makeAgentSubagentRunner({ factory });
-    this.coordinator = new DefaultMultiAgentCoordinator(
-      {
-        coordinatorId: randomUUID(),
-        doneCondition: { type: "all_tasks_done" },
-        maxConcurrent: 2,
-        defaultBudget: { maxToolCalls: 20, maxIterations: 20, timeoutMs: 12e4 }
-      },
-      { runner }
-    );
+    const coordinatorConfig = {
+      coordinatorId: randomUUID(),
+      doneCondition: { type: "all_tasks_done" },
+      maxConcurrent: 2,
+      defaultBudget: { maxToolCalls: 20, maxIterations: 20, timeoutMs: 12e4 }
+    };
+    if (this.opts.directorMode) {
+      this.director = new Director({
+        config: coordinatorConfig,
+        runner,
+        manifestPath: this.opts.manifestPath
+      });
+      this.director.on("task.completed", ({ task, result }) => {
+        this.results.push(result);
+        this.pending.delete(task.id);
+      });
+      this.coordinator = this.director.coordinator;
+      return this.coordinator;
+    }
+    this.coordinator = new DefaultMultiAgentCoordinator(coordinatorConfig, { runner });
     this.coordinator.on(
       "task.completed",
       ({ task, result }) => {
@@ -1965,15 +2647,24 @@ var MultiAgentHost = class {
     );
     return this.coordinator;
   }
-  async buildSubagentProvider(config) {
-    const newCfg = config.providers?.[config.provider] ?? {
-      type: config.provider,
+  /**
+   * Build a Provider for a subagent. When `overrideId` is supplied (from
+   * `SubagentConfig.provider`), looks that provider up in
+   * `config.providers` and constructs it with its own apiKey/baseUrl.
+   * Falls back to the leader's provider when `overrideId` is absent or
+   * not configured (so a typo doesn't crash the whole run — we just
+   * use the leader and the calling code can decide to error later).
+   */
+  async buildSubagentProvider(config, overrideId) {
+    const providerId = overrideId && config.providers?.[overrideId] ? overrideId : config.provider;
+    const newCfg = config.providers?.[providerId] ?? {
+      type: providerId,
       apiKey: config.apiKey,
       baseUrl: config.baseUrl
     };
-    return makeProviderFromConfig(config.provider, {
+    return makeProviderFromConfig(providerId, {
       ...newCfg,
-      type: config.provider
+      type: providerId
     });
   }
   /** Returns a tool slice for the subagent — full set unless restricted. */
@@ -1990,15 +2681,40 @@ var MultiAgentHost = class {
     for (const t of this.filterTools(allow)) sub.register(t);
     return sub;
   }
-  /** Spawn a fresh subagent and assign a single task. Returns task id. */
-  async spawn(description) {
-    const coord = await this.ensureCoordinator();
-    const spawned = await coord.spawn({
-      name: "adhoc",
+  /**
+   * Spawn a fresh subagent and assign a single task. Returns task id.
+   *
+   * Optional `opts` lets the caller (a `/spawn` slash command or the
+   * future director surface) override the subagent's provider, model,
+   * and tool slice on a per-spawn basis. Without options, the legacy
+   * behavior holds: the subagent uses the leader's provider/model and
+   * the full tool registry.
+   */
+  async spawn(description, opts) {
+    await this.ensureCoordinator();
+    const subagentConfig = {
+      name: opts?.name ?? "adhoc",
       role: "general",
       maxToolCalls: 20,
-      maxIterations: 20
-    });
+      maxIterations: 20,
+      provider: opts?.provider,
+      model: opts?.model,
+      tools: opts?.tools
+    };
+    if (this.director) {
+      const subagentId = await this.director.spawn(subagentConfig);
+      const taskId2 = randomUUID();
+      this.pending.set(taskId2, { description, subagentId });
+      await this.director.assign({
+        id: taskId2,
+        description,
+        subagentId,
+        maxToolCalls: 20
+      });
+      return { subagentId, taskId: taskId2 };
+    }
+    const coord = this.coordinator;
+    const spawned = await coord.spawn(subagentConfig);
     const taskId = randomUUID();
     this.pending.set(taskId, { description, subagentId: spawned.subagentId });
     await coord.assign({
@@ -2018,6 +2734,79 @@ var MultiAgentHost = class {
     const summary = !this.coordinator ? "No subagents have been spawned." : `${pending.length} pending, ${this.results.length} completed.`;
     return { pending, completed: this.results, summary };
   }
+  /**
+   * Roll up per-subagent runtime cost from completed TaskResults. We don't
+   * yet have FleetUsageAggregator wired into the simple MultiAgentHost
+   * path (that lives on `Director`), so this aggregates iterations / tool
+   * calls / duration which we *do* have — enough to spot a thrashing
+   * worker without paying for a heavier orchestrator on every /spawn.
+   *
+   * Returns rows sorted by total duration descending (slowest first) so
+   * the table renders the most interesting subagent at the top.
+   */
+  usage() {
+    const bySubagent = /* @__PURE__ */ new Map();
+    for (const r of this.results) {
+      const cur = bySubagent.get(r.subagentId) ?? { tasks: 0, iterations: 0, toolCalls: 0, durationMs: 0, lastStatus: "unknown" };
+      cur.tasks += 1;
+      cur.iterations += r.iterations;
+      cur.toolCalls += r.toolCalls;
+      cur.durationMs += r.durationMs;
+      cur.lastStatus = r.status;
+      bySubagent.set(r.subagentId, cur);
+    }
+    const rows = Array.from(bySubagent.entries()).map(([subagentId, v]) => ({
+      subagentId,
+      tasks: v.tasks,
+      iterations: v.iterations,
+      toolCalls: v.toolCalls,
+      durationMs: v.durationMs,
+      status: v.lastStatus
+    })).sort((a, b) => b.durationMs - a.durationMs);
+    const totals = rows.reduce(
+      (acc, r) => ({
+        tasks: acc.tasks + r.tasks,
+        iterations: acc.iterations + r.iterations,
+        toolCalls: acc.toolCalls + r.toolCalls,
+        durationMs: acc.durationMs + r.durationMs
+      }),
+      { tasks: 0, iterations: 0, toolCalls: 0, durationMs: 0 }
+    );
+    return { rows, totals };
+  }
+  /**
+   * Force the director to write its manifest to disk and return the path,
+   * or `null` when director mode is off (the simple coordinator path has
+   * no manifest). Callers should fall back to a friendly user message
+   * when `null` is returned — e.g. `/fleet manifest` does this already.
+   *
+   * The returned string is the absolute path of the manifest file. The
+   * file contents are JSON; readers can `JSON.parse(fs.readFileSync(...))`
+   * to consume.
+   */
+  async manifest() {
+    if (!this.director) return null;
+    return this.director.writeManifest();
+  }
+  /**
+   * True when this host is running in director mode. Surfaces the mode
+   * to slash commands and tests without exposing the underlying Director
+   * (which would let callers bypass the host's coordination layer).
+   */
+  isDirectorMode() {
+    return !!this.director;
+  }
+  /**
+   * Terminate a single subagent. Returns true when the subagent existed
+   * (regardless of whether stop() succeeded or it was already idle),
+   * false when no coordinator has been created yet — meaning the user
+   * called /fleet kill before any /spawn, and there's nothing to do.
+   */
+  async kill(subagentId) {
+    if (!this.coordinator) return false;
+    await this.coordinator.stop(subagentId);
+    return true;
+  }
   async stopAll() {
     if (this.coordinator) {
       await this.coordinator.stopAll();
@@ -3354,7 +4143,8 @@ async function helpCmd(_args, deps) {
     "  wstack version               Print version",
     "",
     "Global flags:",
-    "  --provider, --model, --cwd, --log-level, --yolo, --verbose, --trace, --config"
+    "  --provider, --model, --cwd, --log-level, --yolo, --verbose, --trace, --config",
+    "  --director                   Run with Director-backed orchestration (writes fleet manifest)"
   ];
   deps.renderer.write(lines.join("\n") + "\n");
   return 0;
@@ -3418,7 +4208,8 @@ var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "alt-screen",
   "output-json",
   "prompt",
-  "metrics"
+  "metrics",
+  "webui"
 ]);
 function parseArgs(argv) {
   const flags = {};
@@ -3618,6 +4409,8 @@ async function main(argv) {
     TOKENS.TokenCounter,
     () => new DefaultTokenCounter({ registry: modelsRegistry, providerId: config.provider })
   );
+  const modeStore = new DefaultModeStore({ directory: wpaths.configDir });
+  container.bind(TOKENS.ModeStore, () => modeStore);
   container.bind(
     TOKENS.SessionStore,
     () => new DefaultSessionStore({ dir: wpaths.projectSessions })
@@ -3629,11 +4422,25 @@ async function main(argv) {
     bundledDir: config.features.skills ? resolveBundledSkillsDir() : void 0
   });
   container.bind(TOKENS.SkillLoader, () => skillLoader);
+  const activeMode = await modeStore.getActiveMode();
+  const modeId = activeMode?.id ?? "default";
+  const modePrompt = activeMode?.prompt ?? "";
+  const resolvedModel = await modelsRegistry.getModel(config.provider, config.model);
+  const modelCapabilities = resolvedModel?.capabilities ? {
+    maxContextTokens: resolvedModel.capabilities.maxContext,
+    supportsTools: resolvedModel.capabilities.tools,
+    supportsVision: resolvedModel.capabilities.vision,
+    supportsReasoning: resolvedModel.capabilities.reasoning
+  } : void 0;
   container.bind(
     TOKENS.SystemPromptBuilder,
     () => new DefaultSystemPromptBuilder({
       memoryStore,
-      skillLoader: config.features.skills ? skillLoader : void 0
+      skillLoader: config.features.skills ? skillLoader : void 0,
+      modeStore,
+      modeId,
+      modePrompt,
+      modelCapabilities
     })
   );
   container.bind(TOKENS.Renderer, () => renderer);
@@ -3897,7 +4704,7 @@ Try \`wstack models refresh\` once you have network access, or run with --no-fea
     model: config.model
   });
   if (restoredMessages.length > 0) {
-    context.messages.push(...restoredMessages);
+    context.state.replaceMessages(restoredMessages);
   }
   const pipelines = createDefaultPipelines();
   const installBoundary = (p) => {
@@ -3957,7 +4764,11 @@ Try \`wstack models refresh\` once you have network access, or run with --no-fea
         soft: config.context.softThreshold,
         hard: config.context.hardThreshold
       },
-      "soft"
+      {
+        aggressiveOn: "soft",
+        failureMode: "throw_on_hard",
+        events
+      }
     );
     pipelines.contextWindow.use({
       name: "AutoCompaction",
@@ -4077,6 +4888,8 @@ Try \`wstack models refresh\` once you have network access, or run with --no-fea
       return err instanceof Error ? err.message : String(err);
     }
   };
+  const directorMode = flags["director"] === true;
+  const manifestPath = directorMode ? typeof process.env["WRONGSTACK_FLEET_MANIFEST"] === "string" ? process.env["WRONGSTACK_FLEET_MANIFEST"] : path5.join(wpaths.projectSessions, session.id, "fleet.json") : void 0;
   const multiAgentHost = new MultiAgentHost({
     container,
     toolRegistry,
@@ -4088,7 +4901,10 @@ Try \`wstack models refresh\` once you have network access, or run with --no-fea
     tokenCounter,
     projectRoot,
     cwd
-  });
+  }, { directorMode, manifestPath });
+  if (directorMode) {
+    renderer.writeInfo(`Director mode enabled. Fleet manifest \u2192 ${manifestPath}`);
+  }
   const slashCmds = buildBuiltinSlashCommands({
     registry: slashRegistry,
     toolRegistry,
@@ -4101,9 +4917,14 @@ Try \`wstack models refresh\` once you have network access, or run with --no-fea
     context,
     metricsSink,
     healthRegistry,
-    onSpawn: async (description) => {
-      const { subagentId, taskId } = await multiAgentHost.spawn(description);
-      return `Spawned subagent ${subagentId} for task ${taskId}. Use /agents to track progress.`;
+    onSpawn: async (description, spawnOpts) => {
+      const { subagentId, taskId } = await multiAgentHost.spawn(description, spawnOpts);
+      const tags = [];
+      if (spawnOpts?.provider) tags.push(spawnOpts.provider);
+      if (spawnOpts?.model) tags.push(spawnOpts.model);
+      if (spawnOpts?.name) tags.push(`"${spawnOpts.name}"`);
+      const tag = tags.length > 0 ? ` (${tags.join(" / ")})` : "";
+      return `Spawned subagent ${subagentId}${tag} for task ${taskId}. Use /agents to track progress.`;
     },
     onAgents: () => {
       const s = multiAgentHost.status();
@@ -4118,6 +4939,60 @@ Try \`wstack models refresh\` once you have network access, or run with --no-fea
       }
       return lines.join("\n");
     },
+    onFleet: async (action, target) => {
+      if (action === "status") {
+        const s = multiAgentHost.status();
+        const lines = [color.bold("Fleet status"), `  ${s.summary}`];
+        if (s.pending.length > 0) {
+          lines.push("", color.dim("  Pending"));
+          for (const p of s.pending) {
+            lines.push(`    ${p.taskId.slice(0, 8)} \u2192 ${p.subagentId.slice(0, 8)} \xB7 ${p.description.slice(0, 60)}`);
+          }
+        }
+        if (s.completed.length > 0) {
+          lines.push("", color.dim("  Completed"));
+          for (const r of s.completed) {
+            const mark = r.status === "success" ? color.green("\u2713") : color.red("\u2717");
+            lines.push(`    ${mark} ${r.taskId.slice(0, 8)} \u2192 ${r.subagentId.slice(0, 8)} \xB7 ${r.iterations}it ${r.toolCalls}tc ${r.durationMs}ms`);
+          }
+        }
+        return lines.join("\n");
+      }
+      if (action === "usage") {
+        const u = multiAgentHost.usage();
+        if (u.rows.length === 0) return "No completed subagent tasks yet.";
+        const lines = [
+          color.bold("Fleet usage"),
+          color.dim("  subagent          tasks  iter  tools     ms  status")
+        ];
+        for (const r of u.rows) {
+          lines.push(
+            `  ${r.subagentId.slice(0, 14).padEnd(14)}  ${String(r.tasks).padStart(5)}  ${String(r.iterations).padStart(4)}  ${String(r.toolCalls).padStart(5)}  ${String(r.durationMs).padStart(5)}  ${r.status}`
+          );
+        }
+        lines.push(
+          color.dim("  \u2500".repeat(28)),
+          `  ${"TOTAL".padEnd(14)}  ${String(u.totals.tasks).padStart(5)}  ${String(u.totals.iterations).padStart(4)}  ${String(u.totals.toolCalls).padStart(5)}  ${String(u.totals.durationMs).padStart(5)}`
+        );
+        return lines.join("\n");
+      }
+      if (action === "kill") {
+        if (!target) return "Usage: /fleet kill <subagent-id>";
+        const ok = await multiAgentHost.kill(target);
+        return ok ? `Sent stop signal to ${target}.` : "No coordinator is running yet \u2014 nothing to kill.";
+      }
+      if (action === "manifest") {
+        if (!multiAgentHost.isDirectorMode()) {
+          return "Manifest is only available when the run was started with --director.";
+        }
+        const p = await multiAgentHost.manifest();
+        if (!p) {
+          return "Director is active but no subagents have been spawned \u2014 nothing to record yet.";
+        }
+        return `Manifest written \u2192 ${p}`;
+      }
+      return `Unknown fleet action: ${action}`;
+    },
     onExit: () => {
       void mcpRegistry.stopAll();
     },
@@ -4255,11 +5130,36 @@ Try \`wstack models refresh\` once you have network access, or run with --no-fea
             process.stdout.write(
               color.dim(`Session saved: ${session.id} \u2014 resume with `) + color.cyan(`wstack resume ${session.id}`) + "\n"
             );
+          },
+          onClearHistory: (dispatch) => {
+            dispatch({ type: "clearHistory" });
+            dispatch({ type: "resetContextChip" });
           }
         });
       } finally {
         renderer.setSilent(false);
       }
+    } else if (flags.webui) {
+      const { runWebUI: runWebUI2 } = await Promise.resolve().then(() => (init_webui_server(), webui_server_exports));
+      const webuiPromise = runWebUI2({
+        agent,
+        events,
+        session,
+        port: Number.parseInt(String(flags.port ?? "3457"), 10),
+        modelsRegistry,
+        globalConfigPath: wpaths.globalConfig
+      });
+      code = await runRepl({
+        agent,
+        renderer,
+        reader,
+        slashRegistry,
+        tokenCounter,
+        attachments,
+        effectiveMaxContext,
+        projectName: path5.basename(projectRoot) || void 0
+      });
+      await webuiPromise;
     } else {
       code = await runRepl({
         agent,
@@ -4268,7 +5168,8 @@ Try \`wstack models refresh\` once you have network access, or run with --no-fea
         slashRegistry,
         tokenCounter,
         attachments,
-        effectiveMaxContext
+        effectiveMaxContext,
+        projectName: path5.basename(projectRoot) || void 0
       });
     }
   } finally {