@wrongstack/cli 0.1.4 → 0.1.7

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, 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;
@@ -548,6 +1049,7 @@ function buildBuiltinSlashCommands(opts) {
     metricsCommand(opts),
     healthCommand(opts),
     memoryCommand(opts),
+    todosCommand(opts),
     saveCommand(opts),
     loadCommand(opts),
     exitCommand(opts)
@@ -597,6 +1099,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 +1374,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 +1524,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 };
       }
@@ -1498,7 +2066,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 +2084,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 +2196,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")}
 `);
 }
@@ -1929,6 +2503,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,
@@ -3418,7 +3997,8 @@ var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "alt-screen",
   "output-json",
   "prompt",
-  "metrics"
+  "metrics",
+  "webui"
 ]);
 function parseArgs(argv) {
   const flags = {};
@@ -3618,6 +4198,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 +4211,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 +4493,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 +4553,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",
@@ -4255,11 +4855,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 +4893,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 {