@wrongstack/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,2464 @@
+#!/usr/bin/env node
+import { color, DefaultPathResolver, resolveWstackPaths, DefaultSecretVault, migratePlaintextSecrets, DefaultConfigLoader, DefaultLogger, DefaultModelsRegistry, Container, TOKENS, DefaultSecretScrubber, DefaultRetryPolicy, DefaultErrorHandler, DefaultTokenCounter, DefaultSessionStore, DefaultMemoryStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultPermissionPolicy, HybridCompactor, ProviderRegistry, ToolRegistry, createContextManagerTool, EventBus, RecoveryLock, DefaultAttachmentStore, QueueStore, Context, createDefaultPipelines, AutoCompactionMiddleware, Agent, SlashCommandRegistry, loadPlugins, InputBuilder, DefaultPluginAPI, rewriteConfigEncrypted, atomicWrite } from '@wrongstack/core';
+import * as fs2 from 'fs/promises';
+import { createRequire } from 'module';
+import * as os2 from 'os';
+import * as path2 from 'path';
+import { MCPRegistry } from '@wrongstack/mcp';
+import { buildProviderFactoriesFromRegistry, makeProviderFromConfig, capabilitiesFor } from '@wrongstack/providers';
+import { builtinTools, rememberTool, forgetTool } from '@wrongstack/tools';
+import * as readline from 'readline';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/plugin-api-factory.ts
+var plugin_api_factory_exports = {};
+__export(plugin_api_factory_exports, {
+  default: () => createApi
+});
+function createApi(ownerName, base) {
+  return new DefaultPluginAPI({ ownerName, ...base });
+}
+var init_plugin_api_factory = __esm({
+  "src/plugin-api-factory.ts"() {
+  }
+});
+var ReadlineInputReader = class {
+  rl;
+  historyFile;
+  history = [];
+  pending = false;
+  constructor(opts = {}) {
+    this.historyFile = opts.historyFile ?? path2.join(os2.homedir(), ".wrongstack", "history");
+  }
+  async loadHistory() {
+    try {
+      const raw = await fs2.readFile(this.historyFile, "utf8");
+      this.history = raw.split("\n").filter(Boolean).slice(-1e3);
+    } catch {
+      this.history = [];
+    }
+  }
+  async saveHistory() {
+    try {
+      await fs2.mkdir(path2.dirname(this.historyFile), { recursive: true });
+      await fs2.writeFile(this.historyFile, this.history.slice(-1e3).join("\n"));
+    } catch {
+    }
+  }
+  ensure() {
+    if (!this.rl) {
+      this.rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        history: this.history,
+        terminal: process.stdin.isTTY
+      });
+    }
+    return this.rl;
+  }
+  async readLine(prompt) {
+    if (this.history.length === 0) await this.loadHistory();
+    while (this.pending) {
+      await new Promise((resolve2) => setTimeout(resolve2, 50));
+    }
+    this.pending = true;
+    try {
+      const rl = this.ensure();
+      if (rl._flushed) {
+        rl.close();
+        this.rl = void 0;
+      }
+      const fresh = this.ensure();
+      return new Promise((resolve2, reject) => {
+        fresh.question(prompt ?? "> ", (line) => {
+          if (line.trim()) {
+            this.history.push(line);
+            void this.saveHistory();
+          }
+          resolve2(line);
+        });
+        fresh.once("close", () => reject(new Error("EOF")));
+      });
+    } finally {
+      this.pending = false;
+    }
+  }
+  async readKey(prompt, options) {
+    process.stdout.write(prompt);
+    return new Promise((resolve2) => {
+      const stdin = process.stdin;
+      const wasRaw = stdin.isRaw;
+      const wasPaused = stdin.isPaused();
+      if (stdin.isTTY) stdin.setRawMode(true);
+      stdin.resume();
+      const onData = (buf) => {
+        const key = buf.toString();
+        const opt = options.find(
+          (o) => o.key.toLowerCase() === key.toLowerCase() || o.value === key
+        );
+        if (opt) {
+          cleanup();
+          process.stdout.write(`${opt.key}
+`);
+          resolve2(opt.value);
+        }
+      };
+      const cleanup = () => {
+        stdin.off("data", onData);
+        if (stdin.isTTY) stdin.setRawMode(wasRaw);
+        if (wasPaused) stdin.pause();
+      };
+      stdin.on("data", onData);
+    });
+  }
+  /**
+   * Read a single line of input without echoing it to the terminal. Used
+   * for API keys / passwords. Non-TTY input is read normally — there's
+   * nothing to hide when piped.
+   */
+  async readSecret(prompt) {
+    const stdin = process.stdin;
+    if (!stdin.isTTY) return this.readLine(prompt);
+    this.rl?.close();
+    this.rl = void 0;
+    process.stdout.write(prompt);
+    return new Promise((resolve2) => {
+      let buf = "";
+      const wasRaw = stdin.isRaw;
+      stdin.setRawMode(true);
+      stdin.resume();
+      stdin.setEncoding("utf8");
+      const onData = (chunk) => {
+        for (const ch of chunk) {
+          if (ch === "\r" || ch === "\n") {
+            cleanup();
+            process.stdout.write("\n");
+            resolve2(buf);
+            return;
+          }
+          if (ch === "") {
+            cleanup();
+            process.stdout.write("\n");
+            process.exit(130);
+          }
+          if (ch === "\x7F" || ch === "\b") {
+            buf = buf.slice(0, -1);
+            continue;
+          }
+          buf += ch;
+        }
+      };
+      const cleanup = () => {
+        stdin.off("data", onData);
+        stdin.setRawMode(wasRaw);
+        stdin.pause();
+      };
+      stdin.on("data", onData);
+    });
+  }
+  async close() {
+    await this.saveHistory();
+    this.rl?.close();
+    this.rl = void 0;
+  }
+};
+function renderDiff(diff) {
+  if (!diff) return "";
+  const lines = diff.split("\n");
+  return lines.map((line) => {
+    if (line.startsWith("+++") || line.startsWith("---")) return color.bold(line);
+    if (line.startsWith("@@")) return color.cyan(line);
+    if (line.startsWith("+")) return color.green(line);
+    if (line.startsWith("-")) return color.red(line);
+    return color.dim(line);
+  }).join("\n");
+}
+var theme = {
+  primary: color.amber,
+  accent: color.pink,
+  muted: color.dim,
+  success: color.green,
+  warn: color.yellow,
+  error: color.red,
+  info: color.cyan,
+  bold: color.bold,
+  underline: color.underline
+};
+
+// src/permission-prompt.ts
+function makePromptDelegate(reader) {
+  return async (tool, input, suggestedPattern) => {
+    process.stdout.write(`
+${theme.primary("\u258D")} ${theme.bold(tool.name)}
+`);
+    process.stdout.write(`${color.dim(stringifyInput(input))}
+`);
+    if (tool.name === "edit" && hasDiff(input)) {
+      const inp = input;
+      const diff = typeof inp.diff === "string" ? inp.diff : "";
+      if (diff) process.stdout.write(`${renderDiff(diff)}
+`);
+    }
+    process.stdout.write(color.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n"));
+    const answer = await reader.readKey(
+      `${theme.bold("[y]")}es  ${theme.bold("[n]")}o  ${theme.bold("[a]")}lways allow (${suggestedPattern})  ${theme.bold("[d]")}eny: `,
+      [
+        { key: "y", label: "yes", value: "yes" },
+        { key: "n", label: "no", value: "no" },
+        { key: "a", label: "always", value: "always" },
+        { key: "d", label: "deny", value: "deny" }
+      ]
+    );
+    return answer;
+  };
+}
+function stringifyInput(input) {
+  if (!input || typeof input !== "object") return "";
+  const obj = input;
+  return Object.entries(obj).filter(([k]) => k !== "content" && k !== "new_string").map(([k, v]) => `${k}: ${truncate(JSON.stringify(v), 80)}`).join("  ");
+}
+function truncate(s, max) {
+  return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
+}
+function hasDiff(input) {
+  return Boolean(
+    input && typeof input === "object" && "diff" in input
+  );
+}
+var TerminalRenderer = class {
+  out;
+  err;
+  lineStart = true;
+  /**
+   * When true, every stdout-bound method is a no-op. This is the only
+   * safe state to be in while Ink owns the terminal (TUI mode):
+   * raw writes to stdout interleave with Ink's cursor math and cause
+   * the input + status bar to be reprinted as scrollback junk.
+   * Stderr-bound methods (writeInfo/Warning/Error) still flow — they
+   * go to a different stream Ink does not manage.
+   */
+  silent = false;
+  constructor(opts = {}) {
+    this.out = opts.out ?? process.stdout;
+    this.err = opts.err ?? process.stderr;
+  }
+  /**
+   * Toggle stdout suppression. Call `setSilent(true)` right before
+   * handing the terminal to Ink, and `setSilent(false)` after Ink
+   * exits. Idempotent.
+   */
+  setSilent(silent) {
+    this.silent = silent;
+  }
+  isSilent() {
+    return this.silent;
+  }
+  write(input) {
+    if (this.silent) return;
+    const text = typeof input === "string" ? input : input.text;
+    if (!text) return;
+    const rendered = renderMarkdown(text);
+    this.out.write(rendered);
+    this.lineStart = rendered.endsWith("\n");
+  }
+  writeLine(text = "") {
+    if (this.silent) return;
+    if (!this.lineStart) this.out.write("\n");
+    if (text) this.out.write(`${text}
+`);
+    else this.out.write("\n");
+    this.lineStart = true;
+  }
+  writeBlock(block) {
+    if (this.silent) return;
+    if (block.type === "text") {
+      this.write(block);
+    } else if (block.type === "tool_use") {
+      this.writeToolCall(block.name, block.input);
+    } else if (block.type === "tool_result") {
+      const text = typeof block.content === "string" ? block.content : JSON.stringify(block.content);
+      this.writeToolResult("result", text, !!block.is_error);
+    }
+  }
+  writeToolCall(name, input) {
+    if (this.silent) return;
+    if (!this.lineStart) this.out.write("\n");
+    const arrow = theme.primary("\u2192");
+    const display = formatInputSummary(input);
+    this.out.write(`${arrow} ${theme.bold(name)}${display ? color.dim(` ${display}`) : ""}
+`);
+    this.lineStart = true;
+  }
+  writeToolResult(name, content, isError) {
+    if (this.silent) return;
+    const txt = typeof content === "string" ? content : safeStringify(content);
+    const prefix = isError ? theme.error("\u2718") : theme.success("\u2713");
+    if (isError) {
+      const firstLine = txt.split("\n")[0] ?? "";
+      const truncated = firstLine.length > 200 ? `${firstLine.slice(0, 197)}\u2026` : firstLine;
+      this.out.write(`  ${prefix} ${color.dim(truncated)}
+`);
+      this.lineStart = true;
+      return;
+    }
+    const isEditLike = name === "edit" || name === "write";
+    const isReadLike = name === "read" || name === "grep" || name === "glob" || name === "bash";
+    const previewLines = isEditLike ? 0 : isReadLike ? 6 : 2;
+    const diff = extractDiff(content);
+    if (isEditLike && diff) {
+      this.out.write(`  ${prefix} ${color.dim(summarize(content, name))}
+`);
+      const rendered = renderDiff(diff).split("\n").map((l) => `      ${l}`).join("\n");
+      this.out.write(`${rendered}
+`);
+      this.lineStart = true;
+      return;
+    }
+    const lines = txt.split("\n");
+    const head = lines.slice(0, previewLines).map((l) => l.replace(/\s+$/, ""));
+    const moreCount = Math.max(0, lines.length - head.length);
+    this.out.write(`  ${prefix} ${color.dim(summarize(content, name))}
+`);
+    for (const l of head) {
+      const capped = l.length > 200 ? `${l.slice(0, 197)}\u2026` : l;
+      this.out.write(`      ${color.dim(capped)}
+`);
+    }
+    if (moreCount > 0) {
+      this.out.write(`      ${color.dim(`+${moreCount} more line${moreCount === 1 ? "" : "s"}`)}
+`);
+    }
+    this.lineStart = true;
+  }
+  writeDiff(diff) {
+    if (this.silent) return;
+    if (!this.lineStart) this.out.write("\n");
+    this.out.write(`${renderDiff(diff)}
+`);
+    this.lineStart = true;
+  }
+  writeWarning(text) {
+    this.err.write(`${theme.warn("\u26A0")} ${text}
+`);
+  }
+  writeError(text) {
+    this.err.write(`${theme.error("\u2718")} ${text}
+`);
+  }
+  writeInfo(text) {
+    this.err.write(`${theme.info("\u2139")} ${text}
+`);
+  }
+  clear() {
+    if (this.silent) return;
+    this.out.write("\x1B[2J\x1B[H");
+    this.lineStart = true;
+  }
+};
+function renderMarkdown(s) {
+  let out = s;
+  out = out.replace(/^(#{1,6}) (.+)$/gm, (_m, hashes, text) => {
+    return theme.primary(theme.bold(`${hashes} ${text}`));
+  });
+  out = out.replace(/```([a-zA-Z0-9_+-]*)\n([\s\S]*?)```/g, (_m, _lang, code) => {
+    return color.gray(`
+\u250C\u2500
+${code.replace(/^/gm, "\u2502 ")}\u2514\u2500`);
+  });
+  out = out.replace(/`([^`\n]+)`/g, (_m, code) => theme.accent(code));
+  out = out.replace(/\*\*([^*]+)\*\*/g, (_m, text) => theme.bold(text));
+  out = out.replace(/(^|[^*])\*([^*\n]+)\*([^*]|$)/g, (_m, l, t, r) => `${l}${color.italic(t)}${r}`);
+  return out;
+}
+function formatInputSummary(input) {
+  if (!input || typeof input !== "object") return "";
+  const obj = input;
+  if (typeof obj["path"] === "string") return obj["path"];
+  if (typeof obj["url"] === "string") return obj["url"];
+  if (typeof obj["command"] === "string") {
+    const cmd = obj["command"];
+    return cmd.length > 60 ? cmd.slice(0, 57) + "..." : cmd;
+  }
+  if (typeof obj["pattern"] === "string") return obj["pattern"];
+  return "";
+}
+function safeStringify(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function extractDiff(value) {
+  if (typeof value === "object" && value !== null) {
+    const d = value.diff;
+    if (typeof d === "string" && d.length > 0) return d;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trimStart();
+    if (trimmed.startsWith("{")) {
+      try {
+        const parsed = JSON.parse(value);
+        if (typeof parsed.diff === "string" && parsed.diff.length > 0) {
+          return parsed.diff;
+        }
+      } catch {
+      }
+    }
+    if (/^---[^\n]*\n\+\+\+/m.test(value)) return value;
+  }
+  return null;
+}
+function summarize(value, name) {
+  let v = value;
+  if (typeof value === "string") {
+    const trimmed = value.trimStart();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      try {
+        v = JSON.parse(value);
+      } catch {
+      }
+    }
+  }
+  if (typeof v === "object" && v !== null) {
+    const o = v;
+    if (name === "edit") {
+      const path5 = typeof o["path"] === "string" ? o["path"] : "";
+      const reps = typeof o["replacements"] === "number" ? o["replacements"] : 0;
+      return `${path5}  ${reps} replacement${reps === 1 ? "" : "s"}`.trim();
+    }
+    if (name === "write") {
+      const path5 = typeof o["path"] === "string" ? o["path"] : "";
+      const bytes = typeof o["bytes"] === "number" ? o["bytes"] : void 0;
+      return bytes !== void 0 ? `${path5}  ${bytes}B` : path5;
+    }
+    if (typeof o["count"] === "number") {
+      return `${o["count"]} match${o["count"] === 1 ? "" : "es"}`;
+    }
+  }
+  return "";
+}
+async function runRepl(opts) {
+  if (opts.banner !== false) printBanner(opts.renderer);
+  let activeCtrl;
+  let interrupts = 0;
+  const onSigint = () => {
+    interrupts++;
+    if (interrupts >= 2) {
+      opts.renderer.writeWarning("Exiting.");
+      process.exit(130);
+    }
+    if (activeCtrl) {
+      activeCtrl.abort();
+      opts.renderer.writeWarning("Iteration cancelled. Press Ctrl+C again to exit.");
+    } else {
+      opts.renderer.writeWarning("Press Ctrl+C again to exit.");
+    }
+  };
+  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 {
+        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));
+      }
+      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 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") {
+        opts.renderer.writeError(
+          `Failed: ${result.error instanceof Error ? result.error.message : String(result.error)}`
+        );
+      } 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}`
+          )}
+`
+        );
+      }
+    } catch (err) {
+      opts.renderer.writeError(err instanceof Error ? err.message : String(err));
+    } finally {
+      activeCtrl = void 0;
+    }
+  }
+  process.off("SIGINT", onSigint);
+  await opts.reader.close();
+  return 0;
+}
+async function readPossiblyMultiline(opts) {
+  const firstPrompt = theme.primary("\u203A ");
+  const contPrompt = color.dim("\xB7 ");
+  const first = await opts.reader.readLine(firstPrompt);
+  if (first.trim() === '"""') {
+    const parts = [];
+    for (; ; ) {
+      const next = await opts.reader.readLine(contPrompt);
+      if (next.trim() === '"""') break;
+      parts.push(next);
+    }
+    return parts.join("\n");
+  }
+  let buf = first;
+  while (buf.endsWith("\\")) {
+    buf = buf.slice(0, -1);
+    const cont = await opts.reader.readLine(contPrompt);
+    buf += "\n" + cont;
+  }
+  return buf;
+}
+function fmtTok(n) {
+  if (n < 1e3) return String(n);
+  if (n < 1e6) return `${(n / 1e3).toFixed(n < 1e4 ? 1 : 0)}k`;
+  return `${(n / 1e6).toFixed(1)}M`;
+}
+var FILLED = "\u2588";
+var EMPTY = "\u2591";
+function renderContextChip(used, max) {
+  const ratio = Math.max(0, Math.min(1, used / max));
+  const pct = Math.round(ratio * 100);
+  const bar = renderProgress(ratio, 6);
+  return `${bar} ${pct}% (${fmtTok(used)}/${fmtTok(max)})`;
+}
+function renderProgress(ratio, width) {
+  const clamped = Math.max(0, Math.min(1, ratio));
+  const filled = clamped === 0 ? 0 : Math.max(1, Math.round(clamped * width));
+  const capped = Math.min(width, filled);
+  return FILLED.repeat(capped) + EMPTY.repeat(width - capped);
+}
+function printBanner(renderer) {
+  const lines = [
+    theme.primary(theme.bold("WrongStack")) + color.dim(" v0.0.1"),
+    color.dim("Built on the wrong stack. Shipped anyway."),
+    color.dim("Type /help for commands, /exit to quit."),
+    ""
+  ];
+  renderer.write(`${lines.join("\n")}
+`);
+}
+var SessionStats = class {
+  tokenCounter;
+  startedAt = Date.now();
+  apiRequests = 0;
+  iterations = 0;
+  errors = 0;
+  toolStats = /* @__PURE__ */ new Map();
+  readPaths = /* @__PURE__ */ new Set();
+  editedPaths = /* @__PURE__ */ new Set();
+  writtenPaths = /* @__PURE__ */ new Set();
+  bytesWritten = 0;
+  bashCommands = 0;
+  fetches = 0;
+  constructor(events, tokenCounter) {
+    this.tokenCounter = tokenCounter;
+    events.on("provider.response", () => {
+      this.apiRequests++;
+    });
+    events.on("iteration.completed", () => {
+      this.iterations++;
+    });
+    events.on("error", () => {
+      this.errors++;
+    });
+    events.on("tool.executed", (e) => {
+      const slot = this.toolStats.get(e.name) ?? { ok: 0, fail: 0, totalMs: 0 };
+      if (e.ok) slot.ok++;
+      else slot.fail++;
+      slot.totalMs += e.durationMs;
+      this.toolStats.set(e.name, slot);
+      const input = e.input;
+      if (e.name === "bash") this.bashCommands++;
+      else if (e.name === "fetch") this.fetches++;
+      if (!e.ok) return;
+      const path5 = typeof input?.path === "string" ? input.path : void 0;
+      if (e.name === "read" && path5) this.readPaths.add(path5);
+      else if (e.name === "edit" && path5) this.editedPaths.add(path5);
+      else if (e.name === "write" && path5) {
+        this.writtenPaths.add(path5);
+        const content = typeof input?.content === "string" ? input.content : "";
+        this.bytesWritten += Buffer.byteLength(content, "utf8");
+      }
+    });
+  }
+  hasActivity() {
+    return this.apiRequests > 0 || this.iterations > 0 || this.toolStats.size > 0 || this.tokenCounter.total().input > 0;
+  }
+  render(renderer) {
+    if (!this.hasActivity()) return;
+    const u = this.tokenCounter.total();
+    const cost = this.tokenCounter.estimateCost();
+    const elapsedSec = ((Date.now() - this.startedAt) / 1e3).toFixed(1);
+    const lines = [];
+    lines.push("");
+    lines.push(color.bold("Session report"));
+    lines.push(color.dim("\u2500".repeat(40)));
+    lines.push(`  Elapsed:       ${elapsedSec}s`);
+    lines.push(`  Iterations:    ${this.iterations}`);
+    lines.push(`  API requests:  ${this.apiRequests}`);
+    if (this.errors > 0) {
+      lines.push(`  Errors:        ${color.yellow(String(this.errors))}`);
+    }
+    lines.push("");
+    lines.push(`  Tokens:        in ${fmtTok2(u.input)}   out ${fmtTok2(u.output)}${u.cacheRead ? `   cacheR ${fmtTok2(u.cacheRead)}` : ""}${u.cacheWrite ? `   cacheW ${fmtTok2(u.cacheWrite)}` : ""}`);
+    const cache = this.tokenCounter.cacheStats();
+    if (cache.readTokens > 0 || cache.writeTokens > 0) {
+      const pct = (cache.hitRatio * 100).toFixed(1);
+      lines.push(
+        `  Prompt cache:  ${pct}% hit  ${color.dim(`(${fmtTok2(cache.readTokens)} read / ${fmtTok2(cache.writeTokens)} write)`)}`
+      );
+    }
+    if (cost.total > 0) {
+      lines.push(`  Cost:          $${cost.total.toFixed(4)}${color.dim(` (in $${cost.input.toFixed(4)} / out $${cost.output.toFixed(4)})`)}`);
+    } else {
+      lines.push(`  Cost:          ${color.dim("$0 (no pricing on this plan)")}`);
+    }
+    if (this.toolStats.size > 0) {
+      lines.push("");
+      lines.push(`  ${color.bold("Tool calls")}`);
+      const sorted = [...this.toolStats.entries()].sort(
+        (a, b) => b[1].ok + b[1].fail - (a[1].ok + a[1].fail)
+      );
+      for (const [name, s] of sorted) {
+        const total = s.ok + s.fail;
+        const failPart = s.fail > 0 ? color.yellow(` (${s.fail} failed)`) : "";
+        const avgMs = total > 0 ? Math.round(s.totalMs / total) : 0;
+        lines.push(`    ${name.padEnd(12)} ${String(total).padStart(3)}\xD7   ${color.dim(`avg ${avgMs}ms`)}${failPart}`);
+      }
+    }
+    const fileActivity = this.readPaths.size > 0 || this.editedPaths.size > 0 || this.writtenPaths.size > 0 || this.bytesWritten > 0;
+    if (fileActivity) {
+      lines.push("");
+      lines.push(`  ${color.bold("Files")}`);
+      if (this.readPaths.size > 0)
+        lines.push(`    read:    ${this.readPaths.size}  ${color.dim(samplePaths(this.readPaths))}`);
+      if (this.editedPaths.size > 0)
+        lines.push(`    edited:  ${this.editedPaths.size}  ${color.dim(samplePaths(this.editedPaths))}`);
+      if (this.writtenPaths.size > 0) {
+        const bytes = this.bytesWritten;
+        const byteStr = bytes > 1024 ? `${(bytes / 1024).toFixed(1)}KB` : `${bytes}B`;
+        lines.push(`    written: ${this.writtenPaths.size}  (${byteStr})  ${color.dim(samplePaths(this.writtenPaths))}`);
+      }
+    }
+    if (this.bashCommands > 0 || this.fetches > 0) {
+      lines.push("");
+      if (this.bashCommands > 0) lines.push(`  Shell commands:  ${this.bashCommands}`);
+      if (this.fetches > 0) lines.push(`  Web fetches:     ${this.fetches}`);
+    }
+    lines.push("");
+    renderer.write(`${lines.join("\n")}
+`);
+  }
+};
+function fmtTok2(n) {
+  if (n < 1e3) return String(n);
+  if (n < 1e6) return `${(n / 1e3).toFixed(n < 1e4 ? 1 : 0)}k`;
+  return `${(n / 1e6).toFixed(1)}M`;
+}
+function samplePaths(set) {
+  const arr = [...set];
+  if (arr.length <= 2) return arr.join(", ");
+  return `${arr[0]}, \u2026 (+${arr.length - 1} more)`;
+}
+function buildBuiltinSlashCommands(opts) {
+  return [
+    helpCommand(opts),
+    initCommand(opts),
+    clearCommand(opts),
+    compactCommand(opts),
+    contextCommand(opts),
+    usageCommand(opts),
+    toolsCommand(opts),
+    skillCommand(opts),
+    useCommand(opts),
+    modelCommand(opts),
+    diagCommand(opts),
+    statsCommand(opts),
+    saveCommand(opts),
+    loadCommand(opts),
+    exitCommand(opts)
+  ];
+}
+function initCommand(opts) {
+  return {
+    name: "init",
+    description: "Scaffold .wrongstack/AGENTS.md in the current project.",
+    async run(args, ctx) {
+      const force = args.trim() === "--force";
+      const dir = path2.join(ctx.projectRoot, ".wrongstack");
+      const file = path2.join(dir, "AGENTS.md");
+      try {
+        await fs2.access(file);
+        if (!force) {
+          const msg = `AGENTS.md already exists at ${file}. Use "/init --force" to overwrite.`;
+          opts.renderer.writeWarning(msg);
+          return { message: msg };
+        }
+      } catch {
+      }
+      const detected = await detectProjectFacts(ctx.projectRoot);
+      const body = renderAgentsTemplate(detected);
+      await fs2.mkdir(dir, { recursive: true });
+      await fs2.writeFile(file, body, "utf8");
+      if (detected.hints.length > 0) {
+        const msg = `Wrote ${file}
+Pre-filled: ${detected.hints.join(", ")}. Edit the file to add anything else worth remembering.`;
+        opts.renderer.writeInfo(`Wrote ${file}`);
+        opts.renderer.writeInfo(`Pre-filled: ${detected.hints.join(", ")}. Edit the file to add anything else worth remembering.`);
+        return { message: msg };
+      } else {
+        const msg = `Wrote ${file}
+No project type auto-detected. Edit the file to add build/test commands and conventions.`;
+        opts.renderer.writeInfo(`Wrote ${file}`);
+        return { message: msg };
+      }
+    }
+  };
+}
+async function detectProjectFacts(root) {
+  const facts = { hints: [] };
+  try {
+    const pkg = JSON.parse(await fs2.readFile(path2.join(root, "package.json"), "utf8"));
+    const scripts = pkg.scripts ?? {};
+    const pm = (pkg.packageManager ?? "npm").split("@")[0] ?? "npm";
+    if (scripts["build"]) facts.build = `${pm} run build`;
+    if (scripts["test"]) facts.test = `${pm} test`;
+    if (scripts["lint"]) facts.lint = `${pm} run lint`;
+    if (scripts["dev"] ?? scripts["start"]) facts.run = `${pm} run ${scripts["dev"] ? "dev" : "start"}`;
+    facts.hints.push("package.json scripts");
+  } catch {
+  }
+  try {
+    await fs2.access(path2.join(root, "pyproject.toml"));
+    facts.test ??= "pytest";
+    facts.lint ??= "ruff check .";
+    facts.hints.push("pyproject.toml");
+  } catch {
+  }
+  try {
+    await fs2.access(path2.join(root, "go.mod"));
+    facts.build ??= "go build ./...";
+    facts.test ??= "go test ./...";
+    facts.hints.push("go.mod");
+  } catch {
+  }
+  try {
+    await fs2.access(path2.join(root, "Cargo.toml"));
+    facts.build ??= "cargo build";
+    facts.test ??= "cargo test";
+    facts.hints.push("Cargo.toml");
+  } catch {
+  }
+  try {
+    await fs2.access(path2.join(root, "Makefile"));
+    facts.build ??= "make";
+    facts.test ??= "make test";
+    facts.hints.push("Makefile");
+  } catch {
+  }
+  return facts;
+}
+function renderAgentsTemplate(f) {
+  const cmd = (s) => s ? `\`${s}\`` : "_TODO_";
+  return `# AGENTS.md
+
+Project notes for WrongStack. Committed to the repo so every contributor
+(human or agent) starts with the same context. Edit freely.
+
+## What this project is
+
+_One paragraph: what does this codebase do, who runs it, what's the
+deployment target?_
+
+## How to work on it
+
+- **Build:** ${cmd(f.build)}
+- **Test:** ${cmd(f.test)}
+- **Lint:** ${cmd(f.lint)}
+- **Run locally:** ${cmd(f.run)}
+
+## Conventions
+
+_What style choices matter here? Filenames, module layout, naming, error
+handling, log format. Anything a stranger would get wrong._
+
+## Domain knowledge
+
+_Acronyms, business rules, foot-guns, "this looks weird but it's
+intentional because\u2026"._
+
+## Pointers
+
+_Where to look for: routing, database migrations, feature flags,
+on-call runbooks, dashboards._
+`;
+}
+function diagCommand(opts) {
+  return {
+    name: "diag",
+    description: "Show runtime diagnostics (provider, tokens, tools, MCP).",
+    async run() {
+      if (opts.onDiag) {
+        opts.onDiag();
+        return { message: "diag" };
+      } else {
+        return { message: "Diag not available in this context." };
+      }
+    }
+  };
+}
+function statsCommand(opts) {
+  return {
+    name: "stats",
+    description: "Show session report: tokens, requests, tools, files, cost.",
+    async run() {
+      if (opts.onStats) {
+        opts.onStats();
+        return { message: "stats" };
+      } else {
+        return { message: "Stats not available in this context." };
+      }
+    }
+  };
+}
+function helpCommand(opts) {
+  return {
+    name: "help",
+    description: "Show available slash commands.",
+    async run() {
+      const lines = ["Available slash commands:"];
+      for (const { cmd, owner, fullName } of opts.registry.listWithOwner()) {
+        const isBuiltin = owner === "core";
+        const prefix = isBuiltin ? "" : `${owner}:`;
+        const aliases = cmd.aliases ? cmd.aliases.map((a) => `/${prefix}${a}`).join(", ") : "";
+        const aliasStr = aliases ? ` (${aliases})` : "";
+        lines.push(`  /${prefix}${cmd.name}${aliasStr} \u2014 ${cmd.description}`);
+      }
+      return { message: lines.join("\n") };
+    }
+  };
+}
+function clearCommand(opts) {
+  return {
+    name: "clear",
+    description: "Reset the session and start a new one.",
+    async run(_args, ctx) {
+      if (ctx) {
+        ctx.messages = [];
+        ctx.todos = [];
+        ctx.readFiles.clear();
+        ctx.fileMtimes.clear();
+        ctx.meta = {};
+      }
+      await opts.memoryStore?.clear();
+      opts.onClear?.();
+      opts.renderer.clear();
+      const msg = "Session cleared (context, memory, and history reset).";
+      opts.renderer.writeInfo(msg);
+      return { message: msg };
+    }
+  };
+}
+function contextCommand(opts) {
+  return {
+    name: "context",
+    aliases: ["ctx"],
+    description: "Show context window summary.",
+    async run(args, ctx) {
+      const messages = ctx.messages;
+      const detailed = args.trim() === "detail";
+      const pairCount = countTurnPairs(messages);
+      const estimatedTokens = estimateTokens(messages);
+      const toolUseCount = countToolUses(messages);
+      const toolResultCount = countToolResults(messages);
+      const lines = [
+        `${color.bold("Context Window")}`,
+        `  messages:    ${messages.length} total (${pairCount} user+assistant pairs)`,
+        `  tokens (\u2248):  ${estimatedTokens.toLocaleString()} (chars \xF7 4 estimate)`,
+        `  system prompt: ${ctx.systemPrompt.length} block${ctx.systemPrompt.length !== 1 ? "s" : ""}`,
+        `  tools:       ${toolUseCount} calls made, ${toolResultCount} results in history`,
+        `  read files:  ${ctx.readFiles.size} files`,
+        `  todos:       ${ctx.todos.filter((t) => t.status === "in_progress").length} in_progress / ${ctx.todos.filter((t) => t.status === "pending").length} pending / ${ctx.todos.filter((t) => t.status === "completed").length} completed`
+      ];
+      if (detailed) {
+        lines.push(`  model:       ${ctx.model}`);
+        lines.push(`  cwd:         ${ctx.cwd}`);
+        lines.push(`  projectRoot: ${ctx.projectRoot}`);
+        lines.push(`  file mtimes: ${ctx.fileMtimes.size} tracked`);
+        if (ctx.readFiles.size > 0) {
+          lines.push(`  file list:   ${[...ctx.readFiles].join(", ")}`);
+        }
+      }
+      const msg = lines.join("\n");
+      opts.renderer.write(`${msg}
+`);
+      return { message: msg };
+    }
+  };
+}
+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) {
+    const content = m.content;
+    if (Array.isArray(content)) {
+      count += content.filter((b) => b.type === "tool_use").length;
+    }
+  }
+  return count;
+}
+function countToolResults(messages) {
+  let count = 0;
+  for (const m of messages) {
+    const content = m.content;
+    if (Array.isArray(content)) {
+      count += content.filter((b) => b.type === "tool_result").length;
+    }
+  }
+  return count;
+}
+function estimateTokens(messages) {
+  let total = 0;
+  for (const m of messages) {
+    const content = m.content;
+    if (typeof content === "string") {
+      total += Math.ceil(content.length / 4);
+    } else if (Array.isArray(content)) {
+      for (const b of content) {
+        if (b.type === "text") total += Math.ceil(b.text.length / 4);
+        else if (b.type === "tool_use" || b.type === "tool_result") {
+          total += Math.ceil(JSON.stringify(b).length / 4);
+        }
+      }
+    }
+  }
+  return total;
+}
+function compactCommand(opts) {
+  return {
+    name: "compact",
+    description: "Compact the context window.",
+    async run(args, ctx) {
+      if (!opts.compactor) {
+        const msg2 = "No compactor configured.";
+        opts.renderer.writeWarning(msg2);
+        return { message: msg2 };
+      }
+      const aggressive = args.trim() === "aggressive";
+      const report = await opts.compactor.compact(ctx, { aggressive });
+      const msg = `Compaction: ${report.before} \u2192 ${report.after} tokens (${report.reductions.map((r) => `${r.phase}: ${r.saved}`).join(", ")})`;
+      opts.renderer.writeInfo(msg);
+      return { message: msg };
+    }
+  };
+}
+function usageCommand(opts) {
+  return {
+    name: "usage",
+    aliases: ["cost"],
+    description: "Show token usage and estimated cost.",
+    async run() {
+      const total = opts.tokenCounter.total();
+      const cost = opts.tokenCounter.estimateCost();
+      const msg = `${color.bold("Usage")}
+  input:       ${total.input}
+  output:      ${total.output}
+  cache read:  ${total.cacheRead ?? 0}
+  cache write: ${total.cacheWrite ?? 0}
+  cost:        $${cost.total.toFixed(4)} (input $${cost.input.toFixed(4)} / output $${cost.output.toFixed(4)})
+`;
+      opts.renderer.write(msg);
+      return { message: msg };
+    }
+  };
+}
+function toolsCommand(opts) {
+  return {
+    name: "tools",
+    description: "List registered tools.",
+    async run() {
+      const all = opts.toolRegistry.listWithOwner();
+      const lines = all.map(({ tool, owner }) => {
+        return `  ${tool.name.padEnd(28)} ${color.dim(`[${owner}]`)} ${tool.mutating ? color.yellow("mut") : color.cyan("ro")} ${color.dim(tool.permission)}`;
+      });
+      const msg = `${color.bold("Tools")} (${all.length}):
+${lines.join("\n")}
+`;
+      opts.renderer.write(msg);
+      return { message: msg };
+    }
+  };
+}
+function skillCommand(opts) {
+  return {
+    name: "skill",
+    description: "Show a skill manifest or list 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 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")}
+`;
+        return { message: msg };
+      } else {
+        const skill = await opts.skillLoader.find(args.trim());
+        if (!skill) {
+          const msg = `Skill "${args.trim()}" not found.`;
+          return { message: msg };
+        }
+        const body = await opts.skillLoader.readBody(skill.name);
+        return { message: body };
+      }
+    }
+  };
+}
+function useCommand(opts) {
+  return {
+    name: "use",
+    description: "Switch provider mid-session: /use <provider>",
+    async run(args) {
+      const name = args.trim();
+      if (!name) {
+        const msg2 = "Usage: /use <provider-name>";
+        return { message: msg2 };
+      }
+      opts.onSwitchProvider?.(name);
+      const msg = `Switched provider to "${name}".`;
+      return { message: msg };
+    }
+  };
+}
+function modelCommand(opts) {
+  return {
+    name: "model",
+    description: "Switch model mid-session: /model <model>",
+    async run(args) {
+      const name = args.trim();
+      if (!name) {
+        const msg2 = "Usage: /model <model-name>";
+        return { message: msg2 };
+      }
+      opts.onSwitchModel?.(name);
+      const msg = `Switched model to "${name}".`;
+      return { message: msg };
+    }
+  };
+}
+function saveCommand(opts) {
+  return {
+    name: "save",
+    description: "Save current session (auto by default; this forces flush).",
+    async run(_args, ctx) {
+      await ctx.session.append({
+        type: "session_end",
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        usage: opts.tokenCounter.total()
+      });
+      const msg = `Session ${ctx.session.id} flushed.`;
+      return { message: msg };
+    }
+  };
+}
+function loadCommand(opts) {
+  return {
+    name: "resume",
+    aliases: ["load", "sessions"],
+    description: "List recent sessions. To actually resume, exit and run `wstack resume <id>`.",
+    async run() {
+      if (!opts.sessionStore) {
+        const msg2 = "No session store configured.";
+        return { message: msg2 };
+      }
+      const list = await opts.sessionStore.list(10);
+      if (list.length === 0) {
+        const msg2 = "No saved sessions.";
+        return { message: msg2 };
+      }
+      const lines = list.map(
+        (s) => `  ${s.id}  ${color.dim(s.startedAt)}  ${color.dim(`${s.tokenTotal} tok`)}  ${s.title}`
+      );
+      const msg = `Recent sessions:
+${lines.join("\n")}
+
+` + color.dim(`Resume one with: wstack resume ${list[0]?.id ?? "<id>"}
+`);
+      opts.renderer.write(msg);
+      return { message: msg };
+    }
+  };
+}
+function exitCommand(opts) {
+  return {
+    name: "exit",
+    aliases: ["quit", "q"],
+    description: "Exit the REPL.",
+    async run() {
+      opts.onExit?.();
+      return { exit: true };
+    }
+  };
+}
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var FILLED2 = "\u2588";
+var EMPTY2 = "\u2591";
+var Spinner = class {
+  timer;
+  frame = 0;
+  active = false;
+  label = "";
+  startedAt = 0;
+  context;
+  out;
+  enabled;
+  constructor(out = process.stderr) {
+    this.out = out;
+    this.enabled = Boolean(out.isTTY) && !process.env.NO_COLOR;
+  }
+  start(label) {
+    if (!this.enabled || this.active) return;
+    this.label = label;
+    this.frame = 0;
+    this.active = true;
+    this.startedAt = Date.now();
+    this.render();
+    this.timer = setInterval(() => {
+      this.frame = (this.frame + 1) % FRAMES.length;
+      this.render();
+    }, 80);
+    this.timer.unref?.();
+  }
+  stop() {
+    if (!this.active) return;
+    this.active = false;
+    if (this.timer) clearInterval(this.timer);
+    this.timer = void 0;
+    this.clearLine();
+  }
+  /** Stop and persist a one-line note where the spinner was (e.g. "✓ done in 1.4s"). */
+  stopWith(note) {
+    this.stop();
+    this.out.write(`${note}
+`);
+  }
+  /** Update the live context-window chip shown on the spinner line. */
+  setContext(ctx) {
+    this.context = ctx;
+  }
+  render() {
+    const elapsed = ((Date.now() - this.startedAt) / 1e3).toFixed(1);
+    let line = `${color.amber(FRAMES[this.frame] ?? "")} ${this.label} ${color.dim(`${elapsed}s`)}`;
+    if (this.context && this.context.max > 0) {
+      line += "  " + renderContextChip2(this.context);
+    }
+    this.clearLine();
+    this.out.write(line);
+  }
+  clearLine() {
+    if (!this.enabled) return;
+    this.out.write("\r\x1B[2K");
+  }
+};
+function renderContextChip2(ctx) {
+  const ratio = Math.max(0, Math.min(1, ctx.used / ctx.max));
+  const pct = Math.round(ratio * 100);
+  const chipColor = ratio >= 0.85 ? color.red : ratio >= 0.65 ? color.yellow : color.cyan;
+  const bar = renderProgress2(ratio, 8);
+  return color.dim("ctx ") + chipColor(bar) + chipColor(` ${pct}%`) + color.dim(` (${fmtTok3(ctx.used)}/${fmtTok3(ctx.max)})`);
+}
+function renderProgress2(ratio, width) {
+  const clamped = Math.max(0, Math.min(1, ratio));
+  const filled = clamped === 0 ? 0 : Math.max(1, Math.round(clamped * width));
+  const capped = Math.min(width, filled);
+  return FILLED2.repeat(capped) + EMPTY2.repeat(width - capped);
+}
+function fmtTok3(n) {
+  if (n < 1e3) return String(n);
+  if (n < 1e6) return `${(n / 1e3).toFixed(n < 1e4 ? 1 : 0)}k`;
+  return `${(n / 1e6).toFixed(1)}M`;
+}
+var subcommands = {
+  init: initCmd,
+  auth: authCmd,
+  // `resume <id>` is special-cased in src/index.ts: it's lifted into
+  // `--resume <id>` so the normal REPL bootstrap runs with a pre-loaded
+  // session. There is no standalone subcommand handler.
+  sessions: sessionsCmd,
+  config: configCmd,
+  tools: toolsCmd,
+  skills: skillsCmd,
+  providers: providersCmd,
+  models: modelsCmd,
+  mcp: mcpCmd,
+  plugin: pluginCmd,
+  diag: diagCmd,
+  usage: usageCmd,
+  version: versionCmd,
+  help: helpCmd,
+  projects: projectsCmd
+};
+async function authCmd(args, deps) {
+  const flags = parseAuthFlags(args);
+  let providerId = flags.positional[0];
+  if (!providerId) {
+    providerId = (await deps.reader.readLine("Provider id: ")).trim();
+  }
+  if (!providerId) {
+    deps.renderer.writeError("Provider id is required.");
+    return 1;
+  }
+  let family = flags.family;
+  let baseUrl = flags.baseUrl;
+  let envVars = flags.envVars;
+  try {
+    const known = await deps.modelsRegistry.getProvider(providerId);
+    if (known) {
+      if (!family) family = known.family;
+      if (!baseUrl) baseUrl = known.apiBase;
+      if (!envVars) envVars = known.envVars;
+    }
+  } catch {
+  }
+  if (!family) {
+    deps.renderer.writeError(
+      `Provider "${providerId}" not in catalog. Pass --family <anthropic|openai|openai-compatible|google> to register it manually.`
+    );
+    return 1;
+  }
+  const apiKey = (await deps.reader.readSecret(
+    `API key for ${providerId} (hidden, stored encrypted in ${deps.paths.globalConfig}): `
+  )).trim();
+  if (!apiKey) {
+    deps.renderer.writeError("No key entered. Nothing saved.");
+    return 1;
+  }
+  const patch = {
+    providers: {
+      [providerId]: {
+        type: providerId,
+        apiKey,
+        family,
+        ...baseUrl ? { baseUrl } : {},
+        ...envVars && envVars.length > 0 ? { envVars } : {}
+      }
+    }
+  };
+  try {
+    await rewriteConfigEncrypted(deps.paths.globalConfig, deps.vault, patch);
+    deps.renderer.writeInfo(`Stored encrypted key for ${providerId}.`);
+    deps.renderer.writeInfo(`Use: wstack --provider ${providerId} "<task>"`);
+    return 0;
+  } catch (err) {
+    deps.renderer.writeError(`auth: ${err instanceof Error ? err.message : String(err)}`);
+    return 1;
+  }
+}
+function parseAuthFlags(args) {
+  const out = { positional: [] };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--family") {
+      const v = args[++i];
+      if (v) out.family = v;
+    } else if (a === "--base-url") {
+      const v = args[++i];
+      if (v) out.baseUrl = v;
+    } else if (a === "--env") {
+      const v = args[++i];
+      if (v) out.envVars = v.split(",").map((s) => s.trim()).filter(Boolean);
+    } else if (a && !a.startsWith("--")) {
+      out.positional.push(a);
+    }
+  }
+  return out;
+}
+async function initCmd(_args, deps) {
+  deps.renderer.write(color.bold("WrongStack init\n"));
+  deps.renderer.writeInfo("Loading provider catalog from models.dev (cached locally)\u2026");
+  let providers;
+  try {
+    providers = await deps.modelsRegistry.listProviders();
+  } catch (err) {
+    deps.renderer.writeError(
+      `Failed to load provider catalog: ${err instanceof Error ? err.message : err}`
+    );
+    return 1;
+  }
+  const detected = providers.filter((p) => p.family !== "unsupported").filter((p) => p.envVars.some((v) => process.env[v]));
+  const ranked = detected.length > 0 ? detected : providers.filter((p) => ["anthropic", "openai", "google"].includes(p.id));
+  if (detected.length > 0) {
+    deps.renderer.write(`Detected API keys for: ${detected.map((p) => p.name).join(", ")}
+`);
+  }
+  const defaultId = ranked[0]?.id ?? "anthropic";
+  const providerId = (await deps.reader.readLine(`Provider [${defaultId}]: `)).trim() || defaultId;
+  const provider = await deps.modelsRegistry.getProvider(providerId);
+  if (!provider) {
+    deps.renderer.writeError(`Provider "${providerId}" not found in models.dev catalog.`);
+    return 1;
+  }
+  if (provider.family === "unsupported") {
+    deps.renderer.writeError(
+      `Provider "${providerId}" uses ${provider.npm} which has no built-in transport. Install a plugin to enable it.`
+    );
+    return 1;
+  }
+  const suggestedModel = await deps.modelsRegistry.suggestModel(providerId) ?? "";
+  const modelHint = suggestedModel ? ` [${suggestedModel}]` : "";
+  const modelId = (await deps.reader.readLine(`Model${modelHint}: `)).trim() || suggestedModel;
+  if (!modelId) {
+    deps.renderer.writeError("No model selected. Aborting.");
+    return 1;
+  }
+  const envHit = provider.envVars.map((v) => process.env[v]).find(Boolean);
+  let apiKey = "";
+  if (!envHit) {
+    apiKey = (await deps.reader.readLine(
+      `API key (stored in ${deps.paths.globalConfig}; empty = expect ${provider.envVars[0] ?? "env var"}): `
+    )).trim();
+  } else {
+    deps.renderer.writeInfo(`Found API key in env (${provider.envVars.join(" / ")}).`);
+  }
+  await fs2.mkdir(deps.paths.globalRoot, { recursive: true });
+  const config = {
+    version: 1,
+    provider: providerId,
+    model: modelId
+  };
+  if (apiKey) config.apiKey = apiKey;
+  await atomicWrite(deps.paths.globalConfig, JSON.stringify(config, null, 2));
+  await fs2.mkdir(path2.join(deps.projectRoot, ".wrongstack"), { recursive: true });
+  const agentsFile = path2.join(deps.projectRoot, ".wrongstack", "AGENTS.md");
+  try {
+    await fs2.access(agentsFile);
+  } catch {
+    await atomicWrite(
+      agentsFile,
+      "# Project notes for WrongStack\n\nWrite project-specific conventions, build commands,\nand domain knowledge here. This file is committed to git.\n"
+    );
+  }
+  deps.renderer.writeInfo(`Wrote ${deps.paths.globalConfig}`);
+  deps.renderer.writeInfo(`Project state lives in ${deps.paths.projectDir}`);
+  deps.renderer.writeInfo('Try: wstack "<task>"  or  wstack');
+  return 0;
+}
+async function sessionsCmd(_args, deps) {
+  if (!deps.sessionStore) {
+    deps.renderer.writeError("No session store available.");
+    return 1;
+  }
+  const list = await deps.sessionStore.list(20);
+  if (list.length === 0) {
+    deps.renderer.write("No sessions found.\n");
+    return 0;
+  }
+  for (const s of list) {
+    deps.renderer.write(
+      `  ${s.id}  ${color.dim(s.startedAt)}  ${color.dim(`${s.tokenTotal} tok`)}  ${s.title}
+`
+    );
+  }
+  return 0;
+}
+async function configCmd(args, deps) {
+  const sub = args[0];
+  if (!sub || sub === "show") {
+    const redacted = redactKeys(deps.config);
+    deps.renderer.write(JSON.stringify(redacted, null, 2) + "\n");
+    return 0;
+  }
+  if (sub === "edit") {
+    const editor = process.env["EDITOR"] ?? "vi";
+    deps.renderer.write(`Run: ${editor} ${deps.paths.globalConfig}
+`);
+    return 0;
+  }
+  deps.renderer.writeError(`Unknown config subcommand: ${sub}`);
+  return 1;
+}
+async function toolsCmd(_args, deps) {
+  const reg = deps.toolRegistry;
+  if (!reg) return 0;
+  for (const { tool, owner } of reg.listWithOwner()) {
+    deps.renderer.write(
+      `  ${tool.name.padEnd(28)} ${color.dim(`[${owner}]`)} ${tool.permission}
+`
+    );
+  }
+  return 0;
+}
+async function skillsCmd(_args, deps) {
+  if (!deps.skillLoader) return 0;
+  const list = await deps.skillLoader.list();
+  for (const s of list) {
+    deps.renderer.write(
+      `  ${s.name.padEnd(24)} ${color.dim(`[${s.source}]`)} ${s.description.split("\n")[0]}
+`
+    );
+  }
+  return 0;
+}
+async function providersCmd(args, deps) {
+  const showAll = args.includes("--all");
+  const showUnsupported = args.includes("--unsupported");
+  try {
+    const all = await deps.modelsRegistry.listProviders();
+    const byFamily = {
+      anthropic: [],
+      openai: [],
+      "openai-compatible": [],
+      google: [],
+      unsupported: []
+    };
+    for (const p of all) byFamily[p.family].push(p);
+    const families = showUnsupported ? ["unsupported"] : showAll ? ["anthropic", "openai", "google", "openai-compatible", "unsupported"] : ["anthropic", "openai", "google", "openai-compatible"];
+    for (const family of families) {
+      const list = byFamily[family];
+      if (list.length === 0) continue;
+      deps.renderer.write(`
+${color.bold(family)} (${list.length}):
+`);
+      for (const p of list) {
+        const envFound = p.envVars.some((v) => process.env[v]);
+        const marker = envFound ? color.green("\u25CF") : color.dim("\u25CB");
+        const envHint = p.envVars[0] ? color.dim(`[${p.envVars[0]}]`) : "";
+        const note = family === "unsupported" ? color.dim("(needs plugin)") : "";
+        deps.renderer.write(
+          `  ${marker} ${p.id.padEnd(20)} ${p.name.padEnd(28)} ${envHint} ${note}
+`
+        );
+      }
+    }
+    deps.renderer.write(
+      `
+${color.dim(`Current: ${deps.config.provider ?? "<unset>"} / ${deps.config.model ?? "<unset>"}. Use --all to include unsupported families.`)}
+`
+    );
+    return 0;
+  } catch (err) {
+    deps.renderer.writeError(
+      `Failed to list providers: ${err instanceof Error ? err.message : err}`
+    );
+    return 1;
+  }
+}
+async function modelsCmd(args, deps) {
+  const sub = args[0];
+  if (sub === "refresh") {
+    deps.renderer.writeInfo("Refreshing models.dev cache\u2026");
+    try {
+      const payload = await deps.modelsRegistry.refresh();
+      deps.renderer.writeInfo(
+        `Cached ${Object.keys(payload).length} providers to ${deps.paths.modelsCache}`
+      );
+      return 0;
+    } catch (err) {
+      deps.renderer.writeError(`Refresh failed: ${err instanceof Error ? err.message : err}`);
+      return 1;
+    }
+  }
+  const providerId = sub ?? deps.config.provider;
+  if (!providerId) {
+    deps.renderer.writeError("Usage: wstack models <provider> | refresh");
+    return 1;
+  }
+  const provider = await deps.modelsRegistry.getProvider(providerId);
+  if (!provider) {
+    deps.renderer.writeError(`Provider "${providerId}" not in catalog.`);
+    return 1;
+  }
+  deps.renderer.write(`${color.bold(provider.name)} ${color.dim(`(${provider.id})`)}
+`);
+  if (provider.doc) deps.renderer.write(color.dim(`Docs: ${provider.doc}
+`));
+  const sorted = [...provider.models].sort(
+    (a, b) => (b.release_date ?? "").localeCompare(a.release_date ?? "")
+  );
+  for (const m of sorted) {
+    const caps = [];
+    if (m.tool_call) caps.push("tools");
+    if (m.reasoning) caps.push("reasoning");
+    if (m.modalities?.input?.includes("image")) caps.push("vision");
+    const ctx = m.limit?.context ? `${(m.limit.context / 1e3).toFixed(0)}k` : "?";
+    const cost = m.cost?.input !== void 0 ? `$${m.cost.input}/$${m.cost.output ?? "?"}` : "";
+    deps.renderer.write(
+      `  ${m.id.padEnd(40)} ${color.dim(ctx.padStart(6))}  ${color.dim(cost.padEnd(14))} ${color.dim(caps.join(","))}
+`
+    );
+  }
+  const age = await deps.modelsRegistry.ageSeconds();
+  deps.renderer.write(
+    color.dim(
+      `
+Cache age: ${isFinite(age) ? `${Math.round(age / 60)}m` : "never fetched"}. Run \`wstack models refresh\` to update.
+`
+    )
+  );
+  return 0;
+}
+async function mcpCmd(args, deps) {
+  const sub = args[0];
+  if (!sub || sub === "list") {
+    const servers = deps.config.mcpServers ?? {};
+    if (Object.keys(servers).length === 0) {
+      deps.renderer.write("No MCP servers configured.\n");
+      return 0;
+    }
+    for (const [name, cfg] of Object.entries(servers)) {
+      deps.renderer.write(
+        `  ${name.padEnd(20)} ${cfg.transport}  ${cfg.enabled === false ? "disabled" : "enabled"}
+`
+      );
+    }
+    return 0;
+  }
+  if (sub === "restart") {
+    deps.renderer.writeWarning("mcp restart is only available in REPL mode.");
+    return 0;
+  }
+  deps.renderer.writeError(`Unknown mcp subcommand: ${sub}`);
+  return 1;
+}
+async function pluginCmd(args, deps) {
+  const sub = args[0];
+  if (!sub || sub === "list") {
+    const plugins = deps.config.plugins ?? [];
+    if (plugins.length === 0) {
+      deps.renderer.write("No plugins configured.\n");
+      return 0;
+    }
+    for (const p of plugins) {
+      const name = typeof p === "string" ? p : p.name;
+      const enabled = typeof p === "object" && p.enabled === false ? "disabled" : "enabled";
+      deps.renderer.write(`  ${name}  ${enabled}
+`);
+    }
+    return 0;
+  }
+  deps.renderer.writeWarning(`plugin ${sub} not implemented (edit config.plugins manually).`);
+  return 0;
+}
+async function diagCmd(_args, deps) {
+  const cfg = deps.config;
+  const age = await deps.modelsRegistry.ageSeconds();
+  const lines = [
+    color.bold("WrongStack diagnostics"),
+    `  apiVersion:    0.0.1`,
+    `  cwd:           ${deps.cwd}`,
+    `  projectRoot:   ${deps.projectRoot}`,
+    `  projectHash:   ${deps.paths.projectHash}`,
+    `  projectDir:    ${deps.paths.projectDir}`,
+    `  globalRoot:    ${deps.paths.globalRoot}`,
+    `  modelsCache:   ${deps.paths.modelsCache}`,
+    `  cacheAge:      ${isFinite(age) ? `${Math.round(age / 60)}m` : "never"}`,
+    `  node:          ${process.version}`,
+    `  os:            ${os2.platform()} ${os2.release()}`,
+    `  provider:      ${cfg.provider ?? "<unset>"}`,
+    `  model:         ${cfg.model ?? "<unset>"}`,
+    `  tools:         ${deps.toolRegistry?.list().length ?? 0}`,
+    `  plugins:       ${cfg.plugins?.length ?? 0}`,
+    `  mcpServers:    ${Object.keys(cfg.mcpServers ?? {}).length}`
+  ];
+  deps.renderer.write(lines.join("\n") + "\n");
+  return 0;
+}
+async function usageCmd(_args, deps) {
+  if (!deps.sessionStore) return 0;
+  const list = await deps.sessionStore.list(100);
+  let totalIn = 0;
+  for (const s of list) totalIn += s.tokenTotal;
+  deps.renderer.write(`Sessions: ${list.length}  total tokens: ${totalIn}
+`);
+  return 0;
+}
+async function versionCmd(_args, deps) {
+  deps.renderer.write(
+    `WrongStack 0.0.1 (apiVersion 0.0.1, node ${process.version}, ${os2.platform()})
+`
+  );
+  return 0;
+}
+async function helpCmd(_args, deps) {
+  const lines = [
+    color.bold("WrongStack \u2014 usage"),
+    "",
+    "  wstack                       Start REPL",
+    '  wstack "<task>"              Run task and exit',
+    "  wstack resume [<id>]         Resume a session",
+    "  wstack sessions              List recent sessions",
+    "  wstack init                  Pick provider + model from models.dev",
+    "  wstack auth <provider>       Store API key (encrypted at rest)",
+    "  wstack resume <id>           Resume a session (loads transcript + appends)",
+    "  wstack config [show|edit]    Show or edit effective config",
+    "  wstack tools                 List registered tools",
+    "  wstack skills                List discovered skills",
+    "  wstack providers [--all]     List providers from models.dev",
+    "  wstack models [<provider>]   List models for current/specified provider",
+    "  wstack models refresh        Force-refresh models.dev cache",
+    "  wstack mcp [list]            List MCP servers",
+    "  wstack plugin [list]         List plugins",
+    "  wstack projects              List projects tracked in ~/.wrongstack/projects/",
+    "  wstack diag                  Full diagnostics",
+    "  wstack usage                 Token + cost summary",
+    "  wstack version               Print version",
+    "",
+    "Global flags:",
+    "  --provider, --model, --cwd, --log-level, --yolo, --verbose, --trace, --config"
+  ];
+  deps.renderer.write(lines.join("\n") + "\n");
+  return 0;
+}
+async function projectsCmd(_args, deps) {
+  const projectsRoot = path2.join(deps.paths.globalRoot, "projects");
+  try {
+    const entries = await fs2.readdir(projectsRoot);
+    if (entries.length === 0) {
+      deps.renderer.write("No projects tracked.\n");
+      return 0;
+    }
+    for (const hash of entries) {
+      try {
+        const meta = JSON.parse(
+          await fs2.readFile(path2.join(projectsRoot, hash, "meta.json"), "utf8")
+        );
+        deps.renderer.write(
+          `  ${color.dim(hash)}  ${color.dim(meta.lastSeen ?? "")}  ${meta.root ?? "?"}
+`
+        );
+      } catch {
+        deps.renderer.write(`  ${color.dim(hash)}  ${color.dim("(no meta)")}
+`);
+      }
+    }
+    return 0;
+  } catch {
+    deps.renderer.write("No projects directory.\n");
+    return 0;
+  }
+}
+function redactKeys(obj) {
+  if (!obj || typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) return obj.map(redactKeys);
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (/api.?key|secret|token|pass/i.test(k) && typeof v === "string" && v.length > 0) {
+      out[k] = "[REDACTED]";
+    } else {
+      out[k] = redactKeys(v);
+    }
+  }
+  return out;
+}
+
+// src/index.ts
+var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
+  "yolo",
+  "verbose",
+  "trace",
+  "help",
+  "version",
+  "no-banner",
+  "no-features",
+  "tui",
+  "no-tui",
+  "no-recovery",
+  "recover",
+  "no-alt-screen",
+  "alt-screen",
+  "output-json",
+  "prompt"
+]);
+function parseArgs(argv) {
+  const flags = {};
+  const positional = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (!a) continue;
+    if (a === "--") {
+      positional.push(...argv.slice(i + 1));
+      break;
+    }
+    if (a.startsWith("--")) {
+      const eq = a.indexOf("=");
+      if (eq !== -1) {
+        flags[a.slice(2, eq)] = a.slice(eq + 1);
+        continue;
+      }
+      const name = a.slice(2);
+      if (BOOLEAN_FLAGS.has(name)) {
+        flags[name] = true;
+        continue;
+      }
+      if (i + 1 < argv.length && !(argv[i + 1] ?? "").startsWith("-")) {
+        flags[name] = argv[++i] ?? "";
+      } else {
+        flags[name] = true;
+      }
+    } else if (a.startsWith("-") && a.length === 2) {
+      const short = a.slice(1);
+      const expand = { v: "verbose" };
+      flags[expand[short] ?? short] = true;
+    } else {
+      positional.push(a);
+    }
+  }
+  return { flags, positional };
+}
+function flagsToConfigPatch(flags) {
+  const patch = {};
+  if (typeof flags["provider"] === "string") patch.provider = flags["provider"];
+  if (typeof flags["model"] === "string") patch.model = flags["model"];
+  if (typeof flags["cwd"] === "string") patch.cwd = flags["cwd"];
+  if (typeof flags["log-level"] === "string") {
+    patch.log = { level: flags["log-level"] };
+  } else if (flags["verbose"]) {
+    patch.log = { level: "debug" };
+  } else if (flags["trace"]) {
+    patch.log = { level: "trace" };
+  }
+  if (flags["yolo"]) patch.yolo = true;
+  if (flags["no-features"]) {
+    patch.features = {
+      mcp: false,
+      plugins: false,
+      memory: false,
+      modelsRegistry: false,
+      skills: false
+    };
+  }
+  return patch;
+}
+function resolveBundledSkillsDir() {
+  try {
+    const req = createRequire(import.meta.url);
+    const corePkg = req.resolve("@wrongstack/core/package.json");
+    return path2.join(path2.dirname(corePkg), "skills");
+  } catch {
+    return void 0;
+  }
+}
+function readOwnVersion() {
+  const req = createRequire(import.meta.url);
+  const candidates = ["../package.json", "../../package.json"];
+  for (const rel of candidates) {
+    try {
+      const pkg = req(rel);
+      if (typeof pkg.version === "string" && pkg.version.length > 0) return pkg.version;
+    } catch {
+    }
+  }
+  return "dev";
+}
+var CLI_VERSION = readOwnVersion();
+async function ensureProjectMeta(paths, projectRoot) {
+  try {
+    await fs2.mkdir(paths.projectDir, { recursive: true });
+    const meta = {
+      hash: paths.projectHash,
+      root: projectRoot,
+      lastSeen: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await fs2.writeFile(paths.projectMeta, JSON.stringify(meta, null, 2));
+  } catch {
+  }
+}
+async function main(argv) {
+  const { flags, positional } = parseArgs(argv);
+  const cwd = typeof flags["cwd"] === "string" ? path2.resolve(flags["cwd"]) : process.cwd();
+  const pathResolver = new DefaultPathResolver(cwd);
+  const projectRoot = pathResolver.projectRoot;
+  const userHome = os2.homedir();
+  const wpaths = resolveWstackPaths({ projectRoot, userHome });
+  await ensureProjectMeta(wpaths, projectRoot);
+  if (positional[0] === "resume" && positional[1] && !subcommands["__noop_resume_marker"]) {
+    flags["resume"] = positional[1];
+    positional.splice(0, 2);
+  }
+  const vault = new DefaultSecretVault({ keyFile: wpaths.secretsKey });
+  for (const file of [wpaths.globalConfig, wpaths.projectLocalConfig]) {
+    try {
+      const { migrated } = await migratePlaintextSecrets(file, vault);
+      if (migrated > 0) {
+        process.stderr.write(`[wstack] Encrypted ${migrated} plaintext secret(s) in ${file}
+`);
+      }
+    } catch {
+    }
+  }
+  const configLoader = new DefaultConfigLoader({ paths: wpaths, vault });
+  let config;
+  try {
+    config = await configLoader.load({ cliFlags: flagsToConfigPatch(flags) });
+  } catch (err) {
+    process.stderr.write(`Config error: ${err instanceof Error ? err.message : String(err)}
+`);
+    return 2;
+  }
+  const logger = new DefaultLogger({
+    level: config.log.level,
+    file: wpaths.logFile
+  });
+  const renderer = new TerminalRenderer();
+  const reader = new ReadlineInputReader({ historyFile: wpaths.historyFile });
+  const modelsRegistry = new DefaultModelsRegistry({
+    cacheFile: wpaths.modelsCache,
+    ttlSeconds: 24 * 3600
+  });
+  const first = positional[0];
+  if (first && subcommands[first]) {
+    const sessionStore2 = new DefaultSessionStore({ dir: wpaths.projectSessions });
+    const skillLoader2 = new DefaultSkillLoader({
+      paths: wpaths,
+      bundledDir: resolveBundledSkillsDir()
+    });
+    const toolRegistryForSubcmd = new ToolRegistry();
+    for (const t of builtinTools) toolRegistryForSubcmd.register(t);
+    const code2 = await subcommands[first](positional.slice(1), {
+      config,
+      renderer,
+      reader,
+      sessionStore: sessionStore2,
+      skillLoader: skillLoader2,
+      toolRegistry: toolRegistryForSubcmd,
+      modelsRegistry,
+      paths: wpaths,
+      vault,
+      cwd,
+      projectRoot,
+      userHome
+    });
+    await reader.close();
+    return code2;
+  }
+  if (!config.provider || !config.model) {
+    process.stderr.write(
+      "No provider or model configured. Run `wstack init` first, or set WRONGSTACK_PROVIDER + WRONGSTACK_MODEL.\n"
+    );
+    await reader.close();
+    return 2;
+  }
+  const resolvedProvider = await modelsRegistry.getProvider(config.provider).catch(() => void 0);
+  if (!resolvedProvider) {
+    logger.warn(
+      `Provider "${config.provider}" not found in models.dev. Continuing with raw config.`
+    );
+  } else if (resolvedProvider.family === "unsupported") {
+    process.stderr.write(
+      `Provider "${config.provider}" uses an unsupported wire family (${resolvedProvider.npm}). Install a plugin to enable it, or pick a different provider.
+`
+    );
+    await reader.close();
+    return 2;
+  }
+  const container = new Container();
+  container.bind(TOKENS.Logger, () => logger);
+  container.bind(TOKENS.PathResolver, () => pathResolver);
+  container.bind(TOKENS.SecretScrubber, () => new DefaultSecretScrubber());
+  container.bind(TOKENS.RetryPolicy, () => new DefaultRetryPolicy());
+  container.bind(TOKENS.ErrorHandler, () => new DefaultErrorHandler());
+  container.bind(TOKENS.ModelsRegistry, () => modelsRegistry);
+  container.bind(
+    TOKENS.TokenCounter,
+    () => new DefaultTokenCounter({ registry: modelsRegistry, providerId: config.provider })
+  );
+  container.bind(
+    TOKENS.SessionStore,
+    () => new DefaultSessionStore({ dir: wpaths.projectSessions })
+  );
+  const memoryStore = new DefaultMemoryStore({ paths: wpaths });
+  container.bind(TOKENS.MemoryStore, () => memoryStore);
+  const skillLoader = new DefaultSkillLoader({
+    paths: wpaths,
+    bundledDir: config.features.skills ? resolveBundledSkillsDir() : void 0
+  });
+  container.bind(TOKENS.SkillLoader, () => skillLoader);
+  container.bind(
+    TOKENS.SystemPromptBuilder,
+    () => new DefaultSystemPromptBuilder({
+      memoryStore,
+      skillLoader: config.features.skills ? skillLoader : void 0
+    })
+  );
+  container.bind(TOKENS.Renderer, () => renderer);
+  container.bind(TOKENS.InputReader, () => reader);
+  container.bind(
+    TOKENS.PermissionPolicy,
+    () => new DefaultPermissionPolicy({
+      trustFile: wpaths.projectTrust,
+      yolo: config.yolo,
+      promptDelegate: makePromptDelegate(reader)
+    })
+  );
+  container.bind(
+    TOKENS.Compactor,
+    () => new HybridCompactor({
+      preserveK: config.context.preserveK,
+      eliseThreshold: config.context.eliseThreshold
+    })
+  );
+  const providerRegistry = new ProviderRegistry();
+  if (config.features.modelsRegistry) {
+    try {
+      const factories = await buildProviderFactoriesFromRegistry({
+        registry: modelsRegistry,
+        log: logger
+      });
+      for (const f of factories) providerRegistry.register(f);
+    } catch (err) {
+      process.stderr.write(
+        `Failed to load models.dev registry: ${err instanceof Error ? err.message : err}
+Try \`wstack models refresh\` once you have network access, or run with --no-features.
+`
+      );
+      await reader.close();
+      return 2;
+    }
+  }
+  const toolRegistry = new ToolRegistry();
+  for (const t of builtinTools) toolRegistry.register(t);
+  toolRegistry.registerDefault(
+    createContextManagerTool({ compactor: container.resolve(TOKENS.Compactor) })
+  );
+  if (config.features.memory) {
+    toolRegistry.register(rememberTool(memoryStore));
+    toolRegistry.register(forgetTool(memoryStore));
+  }
+  const events = new EventBus();
+  events.setLogger(logger);
+  const spinner = new Spinner();
+  let lastInputTokens = 0;
+  events.on("provider.response", (e) => {
+    lastInputTokens = e.usage?.input ?? 0;
+    updateSpinnerContext();
+  });
+  events.on("iteration.started", () => {
+    updateSpinnerContext();
+    spinner.start(color.dim(`${config.provider}/${config.model} thinking\u2026`));
+  });
+  events.on("provider.response", () => {
+    spinner.stop();
+  });
+  events.on("error", () => {
+    spinner.stop();
+  });
+  let streamingActive = false;
+  events.on("provider.text_delta", (p) => {
+    if (!streamingActive) {
+      spinner.stop();
+      streamingActive = true;
+    }
+    renderer.write(p.text);
+  });
+  events.on("iteration.completed", () => {
+    if (streamingActive) {
+      renderer.write("\n");
+      streamingActive = false;
+    }
+  });
+  events.on("provider.retry", (p) => {
+    spinner.stop();
+    if (streamingActive) {
+      renderer.write("\n");
+      streamingActive = false;
+    }
+    const secs = (p.delayMs / 1e3).toFixed(p.delayMs >= 1e3 ? 1 : 2);
+    process.stderr.write(color.yellow(`  \u27F3 retry ${p.attempt} in ${secs}s \u2014 ${p.description}
+`));
+    spinner.start(color.dim(`${config.provider}/${config.model} thinking\u2026`));
+  });
+  events.on("provider.error", (p) => {
+    spinner.stop();
+    if (streamingActive) {
+      renderer.write("\n");
+      streamingActive = false;
+    }
+    process.stderr.write(color.red(`  \u2717 ${p.description}
+`));
+  });
+  const providerConfig = config.providers?.[config.provider] ?? {
+    type: config.provider,
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl
+  };
+  let provider;
+  try {
+    if (config.features.modelsRegistry) {
+      provider = providerRegistry.create({ ...providerConfig, type: config.provider });
+    } else {
+      provider = makeProviderFromConfig(config.provider, {
+        ...providerConfig,
+        type: config.provider
+      });
+    }
+  } catch (err) {
+    process.stderr.write(
+      `Failed to create provider: ${err instanceof Error ? err.message : err}
+`
+    );
+    await reader.close();
+    return 2;
+  }
+  const promptBuilder = container.resolve(TOKENS.SystemPromptBuilder);
+  const systemPrompt = await promptBuilder.build({
+    cwd,
+    projectRoot,
+    tools: toolRegistry.list(),
+    provider: config.provider,
+    model: config.model
+  });
+  const sessionStore = container.resolve(TOKENS.SessionStore);
+  let resumeId = typeof flags["resume"] === "string" ? flags["resume"] : void 0;
+  const recoveryLock = new RecoveryLock({
+    dir: wpaths.projectSessions,
+    sessionStore
+  });
+  if (!resumeId && !flags["no-recovery"]) {
+    const abandoned = await recoveryLock.checkAbandoned();
+    if (abandoned && abandoned.messageCount > 0) {
+      const choice = await promptRecovery(reader, renderer, abandoned, !!flags["recover"]);
+      if (choice === "resume") {
+        resumeId = abandoned.sessionId;
+      } else if (choice === "delete") {
+        await sessionStore.delete(abandoned.sessionId).catch(() => void 0);
+        await recoveryLock.clear();
+      } else {
+        await recoveryLock.clear();
+      }
+    } else if (abandoned) {
+      await sessionStore.delete(abandoned.sessionId).catch(() => void 0);
+      await recoveryLock.clear();
+    }
+  }
+  let session;
+  let restoredMessages = [];
+  if (resumeId) {
+    try {
+      const resumed = await sessionStore.resume(resumeId);
+      session = resumed.writer;
+      restoredMessages = resumed.data.messages;
+      renderer.writeInfo(
+        `Resumed session ${resumed.data.metadata.id} \u2014 ${restoredMessages.length} messages, ${resumed.data.usage.input + resumed.data.usage.output} tokens used previously.`
+      );
+    } catch (err) {
+      renderer.writeError(`Resume failed: ${err instanceof Error ? err.message : String(err)}`);
+      return 2;
+    }
+  } else {
+    session = await sessionStore.create({
+      id: "",
+      title: "",
+      model: config.model,
+      provider: config.provider
+    });
+  }
+  await recoveryLock.write(session.id).catch(() => void 0);
+  const attachments = new DefaultAttachmentStore({
+    spoolDir: path2.join(wpaths.projectSessions, session.id, "attachments")
+  });
+  const queueStore = new QueueStore({
+    dir: path2.join(wpaths.projectSessions, session.id)
+  });
+  const tokenCounter = container.resolve(TOKENS.TokenCounter);
+  const stats = new SessionStats(events, tokenCounter);
+  const ctxSignal = new AbortController().signal;
+  const context = new Context({
+    systemPrompt,
+    provider,
+    session,
+    signal: ctxSignal,
+    tokenCounter,
+    cwd,
+    projectRoot,
+    model: config.model
+  });
+  if (restoredMessages.length > 0) {
+    context.messages.push(...restoredMessages);
+  }
+  const pipelines = createDefaultPipelines();
+  const compactor = container.resolve(TOKENS.Compactor);
+  const resolvedCaps = await capabilitiesFor(modelsRegistry, config.provider, context.model).catch(
+    () => void 0
+  );
+  const effectiveMaxContext = config.context.effectiveMaxContext ?? resolvedCaps?.maxContext ?? provider.capabilities.maxContext;
+  const updateSpinnerContext = () => {
+    if (effectiveMaxContext > 0 && lastInputTokens > 0) {
+      spinner.setContext({ used: lastInputTokens, max: effectiveMaxContext });
+    } else {
+      spinner.setContext(void 0);
+    }
+  };
+  if (config.context.autoCompact !== false) {
+    const autoCompactor = new AutoCompactionMiddleware(
+      compactor,
+      effectiveMaxContext,
+      (ctx) => {
+        const msgs = ctx.messages;
+        let total = 0;
+        for (const m of msgs) {
+          if (typeof m.content === "string") total += Math.ceil(m.content.length / 4);
+          else if (Array.isArray(m.content)) {
+            for (const b of m.content) {
+              if (b.type === "text") total += Math.ceil(b.text.length / 4);
+              else if (b.type === "tool_use" || b.type === "tool_result") {
+                total += Math.ceil(JSON.stringify(b).length / 4);
+              }
+            }
+          }
+        }
+        return total;
+      },
+      {
+        warn: config.context.warnThreshold,
+        soft: config.context.softThreshold,
+        hard: config.context.hardThreshold
+      },
+      "soft"
+    );
+    pipelines.contextWindow.use({
+      name: "AutoCompaction",
+      handler: autoCompactor.handler()
+    });
+  }
+  const agent = new Agent({
+    container,
+    tools: toolRegistry,
+    providers: providerRegistry,
+    events,
+    pipelines,
+    context,
+    maxIterations: config.tools.maxIterations,
+    iterationTimeoutMs: config.tools.iterationTimeoutMs,
+    executionStrategy: config.tools.defaultExecutionStrategy,
+    perIterationOutputCapBytes: config.tools.perIterationOutputCapBytes
+  });
+  const mcpRegistry = new MCPRegistry({ toolRegistry, events, log: logger });
+  if (config.features.mcp) {
+    for (const cfg of Object.values(config.mcpServers ?? {})) {
+      try {
+        await mcpRegistry.start(cfg);
+      } catch (err) {
+        logger.warn(`MCP server "${cfg.name}" failed to start`, err);
+      }
+    }
+  }
+  const slashRegistry = new SlashCommandRegistry();
+  if (config.features.plugins && config.plugins && config.plugins.length > 0) {
+    const resolvedPlugins = [];
+    for (const p of config.plugins) {
+      const spec = typeof p === "string" ? p : p.name;
+      try {
+        const mod = await import(spec);
+        if (mod.default) resolvedPlugins.push(mod.default);
+      } catch (err) {
+        logger.warn(`Plugin "${spec}" failed to load`, err);
+      }
+    }
+    if (resolvedPlugins.length > 0) {
+      const { default: createApi2 } = await Promise.resolve().then(() => (init_plugin_api_factory(), plugin_api_factory_exports));
+      await loadPlugins(resolvedPlugins, {
+        log: logger,
+        apiFactory: (plugin) => createApi2(plugin.name, {
+          container,
+          events,
+          pipelines,
+          toolRegistry,
+          providerRegistry,
+          slashCommandRegistry: slashRegistry,
+          mcpRegistry,
+          config,
+          log: logger
+        })
+      });
+    }
+  }
+  const slashCmds = buildBuiltinSlashCommands({
+    registry: slashRegistry,
+    toolRegistry,
+    compactor: container.resolve(TOKENS.Compactor),
+    sessionStore,
+    skillLoader,
+    tokenCounter,
+    renderer,
+    memoryStore,
+    context,
+    onExit: () => {
+      void mcpRegistry.stopAll();
+    },
+    onClear: () => {
+      try {
+        process.stdout.write("\x1B[2J\x1B[3J\x1B[H");
+      } catch {
+      }
+    },
+    onSwitchModel: (name) => {
+      context.model = name;
+    },
+    onSwitchProvider: (name) => {
+      try {
+        const newCfg = config.providers?.[name] ?? {
+          type: name,
+          apiKey: config.apiKey,
+          baseUrl: config.baseUrl
+        };
+        const newProvider = providerRegistry.create({ ...newCfg, type: name });
+        context.provider = newProvider;
+        config.provider = name;
+      } catch (err) {
+        renderer.writeError(
+          `Cannot switch to "${name}": ${err instanceof Error ? err.message : err}`
+        );
+      }
+    },
+    onDiag: () => {
+      const u = tokenCounter.total();
+      const cost = tokenCounter.estimateCost();
+      renderer.write(
+        [
+          `${color.bold("WrongStack diag")}`,
+          `  provider:     ${config.provider} / ${context.model}`,
+          `  projectRoot:  ${projectRoot}`,
+          `  tokens:       in ${u.input}  out ${u.output}  cacheR ${u.cacheRead ?? 0}`,
+          `  cost:         $${cost.total.toFixed(4)}`,
+          `  tools:        ${toolRegistry.list().length}`,
+          `  mcpServers:   ${mcpRegistry.list().length}`,
+          ""
+        ].join("\n")
+      );
+    },
+    onStats: () => {
+      stats.render(renderer);
+    }
+  });
+  for (const cmd of slashCmds) slashRegistry.register(cmd);
+  let code = 0;
+  try {
+    const promptFlag = typeof flags["prompt"] === "string" ? flags["prompt"] : void 0;
+    if (promptFlag) {
+      positional.unshift(promptFlag);
+    }
+    if (positional.length > 0 || promptFlag) {
+      const query = positional.join(" ");
+      const ctrl = new AbortController();
+      const onSigint = () => ctrl.abort();
+      process.on("SIGINT", onSigint);
+      const startedAt = Date.now();
+      const before = tokenCounter.total();
+      const costBefore = tokenCounter.estimateCost().total;
+      let result;
+      try {
+        result = await agent.run(query, { signal: ctrl.signal });
+      } finally {
+        process.off("SIGINT", onSigint);
+      }
+      const after = tokenCounter.total();
+      const costAfter = tokenCounter.estimateCost().total;
+      const usage = {
+        input: after.input - before.input,
+        output: after.output - before.output,
+        iterations: result.iterations,
+        cost: costAfter - costBefore,
+        elapsedMs: Date.now() - startedAt
+      };
+      if (flags["output-json"]) {
+        const json = JSON.stringify({
+          status: result.status,
+          finalText: result.finalText ?? null,
+          error: result.error instanceof Error ? result.error.message : result.error ?? null,
+          usage
+        });
+        process.stdout.write(json + "\n");
+      } else {
+        if (result.status === "failed") {
+          code = 1;
+          renderer.writeError(
+            "Failed: " + (result.error instanceof Error ? result.error.message : String(result.error))
+          );
+        } else if (result.status === "aborted") {
+          code = 130;
+          renderer.writeWarning("Aborted.");
+        } else if (result.status === "max_iterations") {
+          code = 1;
+          renderer.writeWarning(`Hit max iterations (${result.iterations}).`);
+        }
+        if (result.finalText) renderer.write("\n" + result.finalText + "\n");
+        renderer.write(
+          "\n" + color.dim(
+            `[in: ${fmtTok4(usage.input)}  out: ${fmtTok4(usage.output)}  iters: ${usage.iterations}  cost: ${usage.cost.toFixed(4)}  ${(usage.elapsedMs / 1e3).toFixed(1)}s]`
+          ) + "\n"
+        );
+      }
+    } else if (flags.tui && !flags["no-tui"]) {
+      const { runTui } = await import('@wrongstack/tui');
+      renderer.setSilent(true);
+      try {
+        code = await runTui({
+          agent,
+          events,
+          slashRegistry,
+          attachments,
+          tokenCounter,
+          model: context.model,
+          banner: !flags["no-banner"],
+          queueStore,
+          yolo: !!config.yolo,
+          appVersion: CLI_VERSION,
+          provider: config.provider,
+          effectiveMaxContext,
+          // Opt-in: alt-screen disables the terminal's native scrollback,
+          // so we default to false. `--no-alt-screen` is kept as a no-op
+          // for backward compatibility with old invocation scripts.
+          altScreen: flags["alt-screen"] === true,
+          // Alt-screen exit erases the TUI view. Print a one-line hint
+          // into the user's normal terminal so they know the session is
+          // preserved and can resume it. Skipped automatically when
+          // alt-screen is off — runTui only fires onAfterExit then.
+          onAfterExit: () => {
+            process.stdout.write(
+              color.dim(`Session saved: ${session.id} \u2014 resume with `) + color.cyan(`wstack resume ${session.id}`) + "\n"
+            );
+          }
+        });
+      } finally {
+        renderer.setSilent(false);
+      }
+    } else {
+      code = await runRepl({
+        agent,
+        renderer,
+        reader,
+        slashRegistry,
+        tokenCounter,
+        attachments,
+        effectiveMaxContext
+      });
+    }
+  } finally {
+    stats.render(renderer);
+    await mcpRegistry.stopAll();
+    await session.append({
+      type: "session_end",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      usage: tokenCounter.total()
+    });
+    await session.close();
+    await recoveryLock.clear().catch(() => void 0);
+    await reader.close();
+  }
+  return code;
+}
+async function promptRecovery(reader, renderer, abandoned, autoRecover) {
+  const minutes = Math.round(abandoned.ageMs / 6e4);
+  const ageLabel = minutes < 1 ? `${Math.round(abandoned.ageMs / 1e3)}s ago` : minutes < 60 ? `${minutes} min ago` : `${Math.round(minutes / 60)}h ago`;
+  const summary = `Previous session was killed mid-run: ${abandoned.sessionId} (${abandoned.messageCount} messages, ${ageLabel}).`;
+  if (autoRecover) {
+    renderer.writeInfo(`${summary} Auto-resuming (--recover).`);
+    return "resume";
+  }
+  if (!process.stdin.isTTY) {
+    renderer.writeInfo(
+      `${summary} Non-interactive \u2014 leaving as-is. Use \`wstack resume ${abandoned.sessionId}\` or pass \`--recover\` to auto-resume.`
+    );
+    return "skip";
+  }
+  renderer.writeInfo(summary);
+  const answer = await reader.readKey(
+    `${color.amber("?")} Recover it? ${color.dim("[")}${color.bold("Y")}es / ${color.bold("n")}o / ${color.bold("d")}elete${color.dim("]")} `,
+    [
+      { key: "y", label: "yes", value: "resume" },
+      { key: "Y", label: "yes", value: "resume" },
+      { key: "\r", label: "yes", value: "resume" },
+      { key: "\n", label: "yes", value: "resume" },
+      { key: "n", label: "no", value: "skip" },
+      { key: "N", label: "no", value: "skip" },
+      { key: "d", label: "delete", value: "delete" },
+      { key: "D", label: "delete", value: "delete" }
+    ]
+  );
+  return answer;
+}
+function fmtTok4(n) {
+  if (n < 1e3) return String(n);
+  if (n < 1e6) return `${(n / 1e3).toFixed(n < 1e4 ? 1 : 0)}k`;
+  return `${(n / 1e6).toFixed(1)}M`;
+}
+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");
+if (isMain) {
+  main(process.argv.slice(2)).then(
+    (c) => {
+      process.exitCode = c;
+      setTimeout(() => process.exit(c), 200).unref();
+    },
+    (err) => {
+      process.stderr.write((err instanceof Error ? err.stack : String(err)) + "\n");
+      process.exitCode = 1;
+      setTimeout(() => process.exit(1), 200).unref();
+    }
+  );
+}
+
+export { main };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map