subagent-cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,1647 @@
+#!/usr/bin/env node
+
+// src/env.ts
+import * as fs from "fs";
+import * as path from "path";
+function loadEnv() {
+  const toLoad = [];
+  let dir = process.cwd();
+  while (true) {
+    const envFile = path.join(dir, ".env");
+    if (fs.existsSync(envFile)) {
+      toLoad.push(envFile);
+      break;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  const home = process.env.HOME || process.env.USERPROFILE;
+  if (home) {
+    const globalEnv = path.join(home, ".sa", ".env");
+    if (fs.existsSync(globalEnv)) {
+      toLoad.push(globalEnv);
+    }
+  }
+  for (const envFile of toLoad) {
+    parseEnvFile(envFile);
+  }
+}
+function parseEnvFile(filePath) {
+  const content = fs.readFileSync(filePath, "utf-8");
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIdx = trimmed.indexOf("=");
+    if (eqIdx === -1) continue;
+    const key = trimmed.slice(0, eqIdx).trim();
+    let value = trimmed.slice(eqIdx + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (!(key in process.env)) {
+      process.env[key] = value;
+    }
+  }
+}
+
+// src/config.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as os from "os";
+var SA_DIR = ".sa";
+var CONFIG_NAME = "config.json";
+var GLOBAL_DIR = path2.join(os.homedir(), SA_DIR);
+var DEFAULT_MODEL = "anthropic:claude-sonnet-4-6";
+var MEMORY_SYSTEM_PROMPT = `
+## Memory
+
+You have persistent memory via write_memory and read_memory tools.
+
+When you learn something useful during a conversation, save it with write_memory so future sessions benefit:
+- User preferences (coding style, tools, workflow)
+- Project conventions (naming, structure, patterns)
+- Solutions to problems (so you don't re-solve them)
+- Corrections the user made (so you don't repeat mistakes)
+
+Use scope "project" for project-specific knowledge, "global" for cross-project preferences.
+Memory auto-loads into your system prompt on startup.
+`;
+function getProjectDir() {
+  return path2.join(process.cwd(), SA_DIR);
+}
+function getGlobalDir() {
+  return GLOBAL_DIR;
+}
+function ensureDir(dir) {
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
+  }
+}
+function loadJsonFile(filePath) {
+  try {
+    if (fs2.existsSync(filePath)) {
+      return JSON.parse(fs2.readFileSync(filePath, "utf-8"));
+    }
+  } catch {
+  }
+  return {};
+}
+function loadConfig() {
+  const global = loadJsonFile(path2.join(GLOBAL_DIR, CONFIG_NAME));
+  const project = loadJsonFile(path2.join(getProjectDir(), CONFIG_NAME));
+  return { ...global, ...project };
+}
+function parseFlags(argv) {
+  const flags = {};
+  const positional = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--help" || arg === "-h") {
+      flags.help = true;
+    } else if (arg === "--version" || arg === "-v") {
+      flags.version = true;
+    } else if (arg === "--print" || arg === "-p") {
+      flags.print = true;
+    } else if (arg === "--debug") {
+      flags.debug = true;
+    } else if (arg === "--resume" || arg === "-r") {
+      const next = argv[i + 1];
+      if (next && !next.startsWith("-")) {
+        flags.resume = next;
+        i++;
+      } else {
+        flags.resume = true;
+      }
+    } else if (arg === "--model" || arg === "-m") {
+      flags.model = argv[++i];
+    } else if (arg === "--thinking") {
+      flags.thinkingLevel = argv[++i];
+    } else if (arg === "--sms") {
+      flags.sms = true;
+    } else if (arg === "sessions") {
+      flags.sessions = true;
+    } else if (!arg.startsWith("-")) {
+      positional.push(arg);
+    }
+  }
+  if (positional.length > 0) {
+    flags.prompt = positional.join(" ");
+    if (flags.print === void 0) {
+      flags.print = true;
+    }
+  }
+  return flags;
+}
+function resolveModelName(config, flags) {
+  return flags.model ?? config.model ?? DEFAULT_MODEL;
+}
+function configToAgentOptions(config, flags) {
+  const memoryPaths = [];
+  const projectMemory = path2.join(getProjectDir(), "memory.md");
+  if (fs2.existsSync(projectMemory)) {
+    memoryPaths.push(projectMemory);
+  }
+  const globalMemory = path2.join(GLOBAL_DIR, "memory.md");
+  if (fs2.existsSync(globalMemory)) {
+    memoryPaths.push(globalMemory);
+  }
+  let systemPrompt = MEMORY_SYSTEM_PROMPT;
+  if (config.systemPrompt) {
+    systemPrompt = config.systemPrompt + "\n" + systemPrompt;
+  }
+  return {
+    model: flags.model ?? config.model,
+    systemPrompt,
+    warpGrep: config.warpGrep ?? true,
+    fastApply: config.fastApply ?? true,
+    compact: config.compact ?? false,
+    githubSearch: config.githubSearch ?? true,
+    thinkingLevel: flags.thinkingLevel ?? config.thinkingLevel ?? "medium",
+    subagents: config.subagents,
+    memory: memoryPaths.length > 0 ? memoryPaths : void 0,
+    debug: flags.debug ?? config.debug
+  };
+}
+
+// src/modes/print.ts
+import { createAgent } from "subagent";
+
+// src/tools/memory.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import { Type } from "@sinclair/typebox";
+var MAX_MEMORY_SIZE = 8 * 1024;
+function textResult(text) {
+  return { content: [{ type: "text", text }], details: {} };
+}
+function getMemoryPath(scope) {
+  const dir = scope === "global" ? getGlobalDir() : getProjectDir();
+  ensureDir(dir);
+  return path3.join(dir, "memory.md");
+}
+function readMemoryFile(filePath) {
+  try {
+    if (fs3.existsSync(filePath)) {
+      return fs3.readFileSync(filePath, "utf-8");
+    }
+  } catch {
+  }
+  return "";
+}
+var writeMemoryTool = {
+  name: "write_memory",
+  label: "Write Memory",
+  description: `Save a learning, pattern, or preference to persistent memory so future sessions benefit.
+
+Use this when you discover:
+- User preferences (coding style, tools, workflow)
+- Project conventions (naming, structure, patterns)
+- Solutions to problems you solved (so you don't re-solve them)
+- Corrections the user made (so you don't repeat mistakes)
+
+Scope "project" saves to .sa/memory.md (this project only).
+Scope "global" saves to ~/.sa/memory.md (all projects).`,
+  parameters: Type.Object({
+    key: Type.String({ description: "Short identifier for this memory entry (e.g., 'test-command', 'prefer-bun')" }),
+    content: Type.String({ description: "The memory content to save. Be concise but complete." }),
+    scope: Type.Union([Type.Literal("project"), Type.Literal("global")], {
+      description: "Where to save: 'project' for project-specific, 'global' for cross-project",
+      default: "project"
+    })
+  }),
+  execute: async (_toolCallId, params) => {
+    const { key, content, scope } = params;
+    const memoryPath = getMemoryPath(scope);
+    let existing = readMemoryFile(memoryPath);
+    const keyHeader = `## ${key}`;
+    const keyRegex = new RegExp(`## ${escapeRegex(key)}\\n[\\s\\S]*?(?=\\n## |$)`, "m");
+    const newEntry = `## ${key}
+${content}
+`;
+    if (existing.match(keyRegex)) {
+      existing = existing.replace(keyRegex, newEntry.trim());
+    } else {
+      existing = existing.trim() + (existing.trim() ? "\n\n" : "") + newEntry;
+    }
+    if (Buffer.byteLength(existing, "utf-8") > MAX_MEMORY_SIZE) {
+      return textResult(`Memory file would exceed ${MAX_MEMORY_SIZE / 1024}KB limit. Remove old entries first with write_memory using a shorter content, or use read_memory to see what's stored.`);
+    }
+    fs3.writeFileSync(memoryPath, existing.trim() + "\n", "utf-8");
+    return textResult(`Saved "${key}" to ${scope} memory (${memoryPath})`);
+  }
+};
+var readMemoryTool = {
+  name: "read_memory",
+  label: "Read Memory",
+  description: "Read your persistent memory files to recall learnings from previous sessions.",
+  parameters: Type.Object({
+    scope: Type.Optional(
+      Type.Union([Type.Literal("project"), Type.Literal("global"), Type.Literal("all")], {
+        description: "Which memory to read. Default: 'all'",
+        default: "all"
+      })
+    )
+  }),
+  execute: async (_toolCallId, params) => {
+    const scope = params.scope ?? "all";
+    const sections = [];
+    if (scope === "project" || scope === "all") {
+      const projectPath = path3.join(getProjectDir(), "memory.md");
+      const content = readMemoryFile(projectPath);
+      if (content.trim()) {
+        sections.push(`# Project Memory (.sa/memory.md)
+
+${content.trim()}`);
+      } else {
+        sections.push("# Project Memory\n\n(empty)");
+      }
+    }
+    if (scope === "global" || scope === "all") {
+      const globalPath = path3.join(getGlobalDir(), "memory.md");
+      const content = readMemoryFile(globalPath);
+      if (content.trim()) {
+        sections.push(`# Global Memory (~/.sa/memory.md)
+
+${content.trim()}`);
+      } else {
+        sections.push("# Global Memory\n\n(empty)");
+      }
+    }
+    return textResult(sections.join("\n\n---\n\n"));
+  }
+};
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/components/theme.ts
+var ESC = "\x1B[";
+var color = {
+  reset: `${ESC}0m`,
+  bold: `${ESC}1m`,
+  dim: `${ESC}2m`,
+  italic: `${ESC}3m`,
+  underline: `${ESC}4m`,
+  // Foreground
+  black: `${ESC}30m`,
+  red: `${ESC}31m`,
+  green: `${ESC}32m`,
+  yellow: `${ESC}33m`,
+  blue: `${ESC}34m`,
+  magenta: `${ESC}35m`,
+  cyan: `${ESC}36m`,
+  white: `${ESC}37m`,
+  // Bright foreground
+  gray: `${ESC}90m`,
+  brightRed: `${ESC}91m`,
+  brightGreen: `${ESC}92m`,
+  brightYellow: `${ESC}93m`,
+  brightBlue: `${ESC}94m`,
+  brightMagenta: `${ESC}95m`,
+  brightCyan: `${ESC}96m`,
+  brightWhite: `${ESC}97m`,
+  // 256-color (for subtle tones)
+  fg256: (n) => `${ESC}38;5;${n}m`,
+  bg256: (n) => `${ESC}48;5;${n}m`
+};
+var theme = {
+  agent: color.brightCyan,
+  user: color.brightWhite,
+  tool: color.yellow,
+  toolResult: color.dim,
+  error: color.red,
+  success: color.green,
+  thinking: color.gray,
+  dim: color.dim,
+  accent: color.blue,
+  label: color.gray,
+  reset: color.reset,
+  bold: color.bold
+};
+function styled(style, text) {
+  return `${style}${text}${color.reset}`;
+}
+var box = {
+  topLeft: "\u256D",
+  topRight: "\u256E",
+  bottomLeft: "\u2570",
+  bottomRight: "\u256F",
+  horizontal: "\u2500",
+  vertical: "\u2502",
+  teeRight: "\u251C",
+  teeLeft: "\u2524",
+  dot: "\u25CF",
+  arrow: "\u2192",
+  spinner: ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"]
+};
+
+// src/components/team-panel.ts
+var TEAMMATE_COLORS = [
+  color.brightCyan,
+  color.brightMagenta,
+  color.brightYellow,
+  color.brightGreen,
+  color.brightBlue,
+  color.brightRed,
+  color.cyan,
+  color.magenta,
+  color.yellow,
+  color.green
+];
+var colorAssignments = /* @__PURE__ */ new Map();
+var nextColorIndex = 0;
+function getTeammateColor(name) {
+  let assigned = colorAssignments.get(name);
+  if (!assigned) {
+    assigned = TEAMMATE_COLORS[nextColorIndex % TEAMMATE_COLORS.length];
+    colorAssignments.set(name, assigned);
+    nextColorIndex++;
+  }
+  return assigned;
+}
+var activeTasks = /* @__PURE__ */ new Map();
+var agentStats = /* @__PURE__ */ new Map();
+function trackTaskStart(toolCallId, agentName, prompt) {
+  activeTasks.set(toolCallId, { toolCallId, agentName, prompt, startTime: Date.now() });
+}
+function trackTaskEnd(toolCallId) {
+  const task = activeTasks.get(toolCallId);
+  if (!task) return null;
+  activeTasks.delete(toolCallId);
+  const elapsed = Date.now() - task.startTime;
+  const existing = agentStats.get(task.agentName);
+  if (existing) {
+    existing.taskCount++;
+    existing.totalTimeMs += elapsed;
+  } else {
+    agentStats.set(task.agentName, { taskCount: 1, totalTimeMs: elapsed });
+  }
+  return { agentName: task.agentName, elapsed };
+}
+function hasActiveTasks() {
+  return activeTasks.size > 0;
+}
+var activeMessages = /* @__PURE__ */ new Map();
+function trackMessageStart(toolCallId, to, text) {
+  activeMessages.set(toolCallId, { toolCallId, to, text, startTime: Date.now() });
+}
+function trackMessageEnd(toolCallId, delivered) {
+  const msg = activeMessages.get(toolCallId);
+  if (!msg) return null;
+  activeMessages.delete(toolCallId);
+  return { to: msg.to, text: msg.text, elapsed: Date.now() - msg.startTime, delivered };
+}
+function renderTaskCompletion(agentName, elapsed, isError) {
+  const c = getTeammateColor(agentName);
+  const timeStr = formatTime(elapsed);
+  const status = isError ? styled(theme.error, "\u2717") : styled(theme.success, "\u2713");
+  return `  ${status} ${styled(c, agentName)}  ${styled(theme.dim, isError ? "failed" : "done")}  ${styled(theme.dim, timeStr)}`;
+}
+function renderMessageFlow(to, text, delivered, elapsed) {
+  const toColor = getTeammateColor(to);
+  const summary = text.length > 50 ? text.slice(0, 47) + "..." : text;
+  const arrow = `${styled(theme.dim, "\u2500\u2500")}${styled(toColor, "\u2192")}`;
+  const status = delivered ? styled(theme.success, "\u2713") : styled(theme.error, "\u2717");
+  const timeStr = formatTime(elapsed);
+  return `  \u2709  ${styled(theme.dim, "agent")} ${arrow} ${styled(toColor, to)}  ${styled(theme.dim, `"${summary}"`)}  ${status}  ${styled(theme.dim, timeStr)}`;
+}
+function renderInboxBadge(to) {
+  const toColor = getTeammateColor(to);
+  return `  \u{1F4EC} ${styled(toColor, to)}  ${styled(theme.dim, "new message received")}`;
+}
+function renderTaskGraph(spinnerFrame2) {
+  if (activeTasks.size === 0) return [];
+  const tasks = Array.from(activeTasks.values());
+  const lines = [];
+  for (let i = 0; i < tasks.length; i++) {
+    const t = tasks[i];
+    const c = getTeammateColor(t.agentName);
+    const elapsed = Date.now() - t.startTime;
+    const timeStr = formatTime(elapsed);
+    const spinnerChar = styled(c, box.spinner[spinnerFrame2 % box.spinner.length]);
+    const prompt = t.prompt.length > 40 ? t.prompt.slice(0, 37) + "..." : t.prompt;
+    const connector = i === tasks.length - 1 ? "\u2514\u2500" : "\u251C\u2500";
+    const name = t.agentName.padEnd(14);
+    lines.push(
+      `  ${styled(theme.dim, connector)} ${spinnerChar} ${styled(c, name)} ${styled(theme.dim, `"${prompt}"`)}  ${styled(theme.dim, timeStr)}`
+    );
+  }
+  return lines;
+}
+function renderAgentSummary() {
+  if (agentStats.size === 0) return "";
+  const entries = Array.from(agentStats.entries()).sort((a, b) => b[1].totalTimeMs - a[1].totalTimeMs);
+  const lines = [];
+  lines.push(`  ${styled(theme.dim, `\u250C agents ${"\u2500".repeat(37)}\u2510`)}`);
+  for (const [name, stats] of entries) {
+    const c = getTeammateColor(name);
+    const taskLabel = stats.taskCount === 1 ? "1 task" : `${stats.taskCount} tasks`;
+    const timeStr = formatTime(stats.totalTimeMs);
+    lines.push(
+      `  ${styled(theme.dim, "\u2502")} ${styled(c, box.dot)} ${styled(c, name.padEnd(14))} ${styled(theme.dim, taskLabel.padEnd(10))} ${styled(theme.dim, timeStr.padStart(7))}  ${styled(theme.dim, "\u2502")}`
+    );
+  }
+  lines.push(`  ${styled(theme.dim, `\u2514${"\u2500".repeat(44)}\u2518`)}`);
+  return lines.join("\n");
+}
+function renderTeamStatus(team) {
+  if (!team) return "";
+  const lines = [];
+  lines.push(styled(theme.label, `  team: ${team.name}`));
+  for (const [name, handle] of team.teammates) {
+    const c = getTeammateColor(name);
+    const status = handle.abortController.signal.aborted ? styled(theme.dim, "done") : styled(color.green, "active");
+    lines.push(`    ${styled(c, box.dot)} ${styled(c, name)} ${status}`);
+  }
+  return lines.join("\n");
+}
+function formatTime(ms) {
+  if (ms >= 6e4) return `${(ms / 6e4).toFixed(1)}m`;
+  if (ms >= 1e3) return `${(ms / 1e3).toFixed(1)}s`;
+  return `${ms}ms`;
+}
+
+// src/components/tool-panel.ts
+var TEAM_TOOLS = /* @__PURE__ */ new Set(["task", "send_message"]);
+var activeTools = /* @__PURE__ */ new Map();
+var spinnerFrame = 0;
+var renderedLineCount = 0;
+function clearLiveRender() {
+  if (renderedLineCount <= 0) return;
+  let seq = "";
+  for (let i = 0; i < renderedLineCount; i++) {
+    seq += "\x1B[2K";
+    if (i < renderedLineCount - 1) {
+      seq += "\x1B[A";
+    }
+  }
+  seq += "\r";
+  process.stderr.write(seq);
+  renderedLineCount = 0;
+}
+function writeLiveLines(lines) {
+  clearLiveRender();
+  if (lines.length === 0) return;
+  process.stderr.write(lines.join("\n") + "\r");
+  renderedLineCount = lines.length;
+}
+function toolStart(toolCallId, name, args) {
+  activeTools.set(toolCallId, { toolCallId, name, args, startTime: Date.now() });
+  if (name === "task" && args?.agent) {
+    trackTaskStart(toolCallId, args.agent, args.prompt ?? "");
+  } else if (name === "send_message" && args?.to) {
+    trackMessageStart(toolCallId, args.to, args.text ?? "");
+  }
+}
+function toolEnd(toolCallId, _result, isError) {
+  const tool = activeTools.get(toolCallId);
+  activeTools.delete(toolCallId);
+  if (!tool) return;
+  clearLiveRender();
+  if (tool.name === "task") {
+    const tracked = trackTaskEnd(toolCallId);
+    if (tracked) {
+      process.stderr.write(renderTaskCompletion(tracked.agentName, tracked.elapsed, isError) + "\n");
+    }
+    return;
+  }
+  if (tool.name === "send_message") {
+    const tracked = trackMessageEnd(toolCallId, !isError);
+    if (tracked) {
+      process.stderr.write(renderMessageFlow(tracked.to, tracked.text, tracked.delivered, tracked.elapsed) + "\n");
+      if (tracked.delivered) {
+        process.stderr.write(renderInboxBadge(tracked.to) + "\n");
+      }
+    }
+    return;
+  }
+  const elapsed = Date.now() - tool.startTime;
+  const timeStr = formatTime2(elapsed);
+  const status = isError ? styled(theme.error, "\u2717") : styled(theme.success, "\u2713");
+  const label = formatToolLabel(tool.name, tool.args);
+  const nameColor = getToolNameColor(tool.name, tool.args);
+  process.stderr.write(`  ${status} ${styled(nameColor, tool.name)} ${styled(theme.dim, label)} ${styled(theme.dim, timeStr)}
+`);
+}
+function updateLivePanel() {
+  spinnerFrame = (spinnerFrame + 1) % box.spinner.length;
+  const lines = [];
+  if (hasActiveTasks()) {
+    lines.push(...renderTaskGraph(spinnerFrame));
+  }
+  const nonTeamTools = Array.from(activeTools.values()).filter((t) => !TEAM_TOOLS.has(t.name));
+  for (const t of nonTeamTools) {
+    const elapsed = Date.now() - t.startTime;
+    const timeStr = formatTime2(elapsed);
+    const label = formatToolLabel(t.name, t.args);
+    const spinnerColor = getToolNameColor(t.name, t.args);
+    const spinner = styled(spinnerColor, box.spinner[spinnerFrame]);
+    lines.push(`  ${spinner} ${styled(spinnerColor, t.name)} ${styled(theme.dim, label)} ${styled(theme.dim, timeStr)}`);
+  }
+  writeLiveLines(lines);
+}
+function hasActiveWork() {
+  return activeTools.size > 0;
+}
+function getToolNameColor(name, args) {
+  if (name === "task" && args?.agent) return getTeammateColor(args.agent);
+  if (name === "send_message" && args?.to) return getTeammateColor(args.to);
+  return theme.tool;
+}
+function formatToolLabel(name, args) {
+  if (!args) return "";
+  switch (name) {
+    case "read_file":
+      return truncate(args.path ?? args.file_path ?? "", 50);
+    case "write_file":
+      return truncate(args.path ?? args.file_path ?? "", 50);
+    case "edit_file":
+      return truncate(args.path ?? args.file_path ?? "", 50);
+    case "execute":
+      return truncate(args.command ?? "", 60);
+    case "glob":
+      return truncate(args.pattern ?? "", 50);
+    case "grep":
+      return truncate(`"${args.pattern ?? ""}" ${args.path ?? ""}`, 60);
+    case "ls":
+      return truncate(args.path ?? "", 50);
+    case "warp_grep":
+      return truncate(`"${args.query ?? ""}"`, 50);
+    case "fast_apply":
+      return truncate(args.file_path ?? args.path ?? "", 50);
+    case "write_memory":
+      return truncate(`${args.scope ?? "project"}:${args.key ?? ""}`, 40);
+    default:
+      for (const v of Object.values(args)) {
+        if (typeof v === "string" && v.length > 0) {
+          return truncate(v, 50);
+        }
+      }
+      return "";
+  }
+}
+function truncate(s, max) {
+  if (s.length <= max) return s;
+  return s.slice(0, max - 1) + "\u2026";
+}
+function formatTime2(ms) {
+  if (ms >= 6e4) return `${(ms / 6e4).toFixed(1)}m`;
+  if (ms >= 1e3) return `${(ms / 1e3).toFixed(1)}s`;
+  return `${ms}ms`;
+}
+
+// src/components/chat.ts
+function writeTextDelta(delta) {
+  process.stdout.write(delta);
+}
+function writeThinkingDelta(delta) {
+  process.stderr.write(styled(theme.thinking, delta));
+}
+function endThinking() {
+  process.stderr.write(color.reset + "\n");
+}
+function endAssistantMessage() {
+  process.stdout.write("\n");
+}
+function writeError(message) {
+  process.stderr.write(`${styled(theme.error, "error")}: ${message}
+`);
+}
+function writeInfo(message) {
+  process.stderr.write(`${styled(theme.dim, message)}
+`);
+}
+function writeBanner(model, sessionId) {
+  process.stderr.write(
+    `${styled(theme.accent, "sa")} ${styled(theme.dim, model)} ${styled(theme.dim, `session:${sessionId}`)}
+${styled(theme.dim, "Type a message to start. Ctrl+C to exit. /help for commands.")}
+
+`
+  );
+}
+
+// src/session.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+function getSessionsDir() {
+  const dir = path4.join(getProjectDir(), "sessions");
+  ensureDir(dir);
+  return dir;
+}
+function generateSessionId() {
+  const now = /* @__PURE__ */ new Date();
+  const date = now.toISOString().slice(0, 10);
+  const time = now.toISOString().slice(11, 19).replace(/:/g, "");
+  const rand = Math.random().toString(36).slice(2, 6);
+  return `${date}_${time}_${rand}`;
+}
+function appendEvent(sessionId, event) {
+  const sessionsDir = getSessionsDir();
+  const filePath = path4.join(sessionsDir, `${sessionId}.jsonl`);
+  fs4.appendFileSync(filePath, JSON.stringify(event) + "\n", "utf-8");
+}
+function loadSession(sessionId) {
+  const filePath = path4.join(getSessionsDir(), `${sessionId}.jsonl`);
+  if (!fs4.existsSync(filePath)) return [];
+  return fs4.readFileSync(filePath, "utf-8").trim().split("\n").filter(Boolean).map((line) => JSON.parse(line));
+}
+function listSessions() {
+  const dir = getSessionsDir();
+  if (!fs4.existsSync(dir)) return [];
+  return fs4.readdirSync(dir).filter((f) => f.endsWith(".jsonl")).map((f) => {
+    const filePath = path4.join(dir, f);
+    const stat = fs4.statSync(filePath);
+    const content = fs4.readFileSync(filePath, "utf-8").trim();
+    const lines = content.split("\n").filter(Boolean);
+    const firstUser = lines.find((l) => {
+      try {
+        return JSON.parse(l).type === "user";
+      } catch {
+        return false;
+      }
+    });
+    let preview = "(empty)";
+    if (firstUser) {
+      try {
+        const parsed = JSON.parse(firstUser);
+        preview = (parsed.content ?? "").slice(0, 80);
+        if ((parsed.content ?? "").length > 80) preview += "...";
+      } catch {
+      }
+    }
+    return {
+      id: f.replace(".jsonl", ""),
+      created: stat.birthtimeMs,
+      lastActive: stat.mtimeMs,
+      lines: lines.length,
+      preview
+    };
+  }).sort((a, b) => b.lastActive - a.lastActive);
+}
+function getLatestSessionId() {
+  const sessions = listSessions();
+  return sessions.length > 0 ? sessions[0].id : null;
+}
+function formatSessionList(sessions) {
+  if (sessions.length === 0) return "No sessions found.";
+  const lines = sessions.map((s) => {
+    const age = formatAge(Date.now() - s.lastActive);
+    return `  ${s.id}  ${age} ago  (${s.lines} events)  ${s.preview}`;
+  });
+  return `Sessions:
+${lines.join("\n")}`;
+}
+function formatAge(ms) {
+  const mins = Math.floor(ms / 6e4);
+  if (mins < 60) return `${mins}m`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) return `${hours}h`;
+  const days = Math.floor(hours / 24);
+  return `${days}d`;
+}
+
+// src/components/status-bar.ts
+function renderStatusBar(state) {
+  const cols = process.stdout.columns || 80;
+  const model = styled(theme.accent, state.model);
+  const tokens = state.totalTokens > 0 ? styled(theme.dim, ` ${formatTokens(state.totalTokens)} tokens`) : "";
+  const cost = state.totalCost > 0 ? styled(theme.dim, ` $${state.totalCost.toFixed(4)}`) : "";
+  const streaming = state.isStreaming ? styled(color.yellow, " \u25CF") : styled(color.green, " \u25CF");
+  return `${streaming} ${model}${tokens}${cost}`;
+}
+function formatTokens(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+  return `${n}`;
+}
+
+// src/modes/print.ts
+async function runPrintMode(prompt, agentOptions, modelName) {
+  const sessionId = generateSessionId();
+  const tools = [...agentOptions.tools ?? [], writeMemoryTool, readMemoryTool];
+  let agent;
+  try {
+    agent = await createAgent({ ...agentOptions, tools });
+  } catch (err) {
+    writeError(err.message ?? String(err));
+    process.exit(1);
+  }
+  let totalTokens = 0;
+  let totalCost = 0;
+  let isInText = false;
+  let isInThinking = false;
+  let assistantText = "";
+  appendEvent(sessionId, { type: "user", content: prompt, timestamp: Date.now() });
+  agent.subscribe((event) => {
+    switch (event.type) {
+      case "message_update": {
+        const e = event.assistantMessageEvent;
+        if (e.type === "text_delta") {
+          if (isInThinking) {
+            isInThinking = false;
+            endThinking();
+          }
+          if (!isInText) {
+            clearLiveRender();
+          }
+          isInText = true;
+          writeTextDelta(e.delta);
+          assistantText += e.delta;
+        } else if (e.type === "thinking_delta") {
+          isInThinking = true;
+          writeThinkingDelta(e.delta);
+        } else if (e.type === "thinking_end") {
+          if (isInThinking) {
+            isInThinking = false;
+            endThinking();
+          }
+        } else if (e.type === "error") {
+          const errMsg = e.error?.errorMessage ?? "Unknown streaming error";
+          writeError(errMsg);
+        }
+        break;
+      }
+      case "message_end": {
+        const msg = event.message;
+        if (msg?.role === "assistant" && msg?.stopReason === "error") {
+          const errMsg = msg.errorMessage ?? "API error (no details)";
+          writeError(errMsg);
+        }
+        break;
+      }
+      case "turn_end": {
+        if (isInText) {
+          endAssistantMessage();
+          isInText = false;
+        }
+        const msg = event.message;
+        if (msg?.usage) {
+          totalTokens += msg.usage.totalTokens ?? 0;
+          totalCost += msg.usage.cost?.total ?? 0;
+        }
+        if (assistantText) {
+          appendEvent(sessionId, { type: "assistant", content: assistantText, timestamp: Date.now() });
+          assistantText = "";
+        }
+        break;
+      }
+      case "tool_execution_start": {
+        toolStart(event.toolCallId, event.toolName, event.args);
+        appendEvent(sessionId, {
+          type: "tool_call",
+          name: event.toolName,
+          args: event.args,
+          timestamp: Date.now()
+        });
+        break;
+      }
+      case "tool_execution_end": {
+        toolEnd(event.toolCallId, event.result, event.isError);
+        const resultText = extractResultText(event.result);
+        appendEvent(sessionId, {
+          type: "tool_result",
+          name: event.toolName,
+          result: resultText.slice(0, 500),
+          isError: event.isError,
+          timestamp: Date.now()
+        });
+        break;
+      }
+      case "agent_end": {
+        const bar = renderStatusBar({
+          model: modelName,
+          totalTokens,
+          totalCost,
+          sessionId,
+          isStreaming: false
+        });
+        process.stderr.write(`
+${bar}
+`);
+        const agentSummary = renderAgentSummary();
+        if (agentSummary) {
+          process.stderr.write(`${agentSummary}
+`);
+        }
+        break;
+      }
+    }
+  });
+  try {
+    await agent.prompt(prompt);
+    await agent.waitForIdle();
+  } catch (err) {
+    if (err.name === "AbortError") {
+      process.stderr.write(`
+${styled(theme.dim, "(aborted)")}
+`);
+    } else {
+      writeError(err.message ?? String(err));
+    }
+  } finally {
+    agent.destroy();
+  }
+}
+function extractResultText(result) {
+  if (!result) return "";
+  if (typeof result === "string") return result;
+  if (result.content && Array.isArray(result.content)) {
+    return result.content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
+  }
+  return JSON.stringify(result).slice(0, 500);
+}
+
+// src/modes/interactive.ts
+import { createAgent as createAgent2 } from "subagent";
+
+// src/components/input.ts
+import * as readline from "readline";
+var HISTORY_MAX = 200;
+var history = [];
+var rl = null;
+function createInput(opts) {
+  rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stderr,
+    prompt: styled(color.brightWhite + color.bold, "> "),
+    historySize: HISTORY_MAX,
+    terminal: true
+  });
+  rl.on("line", (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      rl?.prompt();
+      return;
+    }
+    history.push(trimmed);
+    opts.onSubmit(trimmed);
+  });
+  rl.on("close", () => {
+    opts.onAbort();
+  });
+  rl.on("SIGINT", () => {
+    opts.onAbort();
+  });
+  return {
+    prompt: () => {
+      rl?.prompt();
+    },
+    close: () => {
+      rl?.close();
+      rl = null;
+    }
+  };
+}
+function pauseInput() {
+  if (rl) {
+    process.stderr.write("\r\x1B[K");
+  }
+}
+
+// src/modes/interactive.ts
+async function runInteractiveMode(agentOptions, modelName, resumeSessionId) {
+  const sessionId = resumeSessionId ?? generateSessionId();
+  const model = modelName;
+  const tools = [...agentOptions.tools ?? [], writeMemoryTool, readMemoryTool];
+  let agent;
+  try {
+    agent = await createAgent2({ ...agentOptions, tools });
+  } catch (err) {
+    writeError(err.message ?? String(err));
+    process.exit(1);
+  }
+  let totalTokens = 0;
+  let totalCost = 0;
+  let isInText = false;
+  let isInThinking = false;
+  let isWorking = false;
+  let assistantText = "";
+  let spinnerInterval = null;
+  if (resumeSessionId) {
+    const events = loadSession(resumeSessionId);
+    if (events.length > 0) {
+      writeInfo(`Resuming session ${resumeSessionId} (${events.length} events)`);
+      for (const event of events) {
+        if (event.type === "user" && event.content) {
+          agent.followUp({
+            role: "user",
+            content: [{ type: "text", text: event.content }],
+            timestamp: event.timestamp
+          });
+        }
+      }
+    }
+  }
+  writeBanner(model, sessionId);
+  agent.subscribe((event) => {
+    switch (event.type) {
+      case "message_update": {
+        const e = event.assistantMessageEvent;
+        if (e.type === "text_delta") {
+          if (isInThinking) {
+            isInThinking = false;
+            endThinking();
+          }
+          if (!isInText) {
+            clearLiveRender();
+          }
+          isInText = true;
+          writeTextDelta(e.delta);
+          assistantText += e.delta;
+        } else if (e.type === "thinking_delta") {
+          if (!isInThinking) {
+            clearLiveRender();
+            process.stderr.write(styled(theme.thinking, "thinking... "));
+            isInThinking = true;
+          }
+          writeThinkingDelta(e.delta);
+        } else if (e.type === "thinking_end") {
+          if (isInThinking) {
+            isInThinking = false;
+            endThinking();
+          }
+        }
+        break;
+      }
+      case "turn_end": {
+        if (isInText) {
+          endAssistantMessage();
+          isInText = false;
+        }
+        const msg = event.message;
+        if (msg?.usage) {
+          totalTokens += msg.usage.totalTokens ?? 0;
+          totalCost += msg.usage.cost?.total ?? 0;
+        }
+        if (assistantText) {
+          appendEvent(sessionId, { type: "assistant", content: assistantText, timestamp: Date.now() });
+          assistantText = "";
+        }
+        break;
+      }
+      case "tool_execution_start": {
+        toolStart(event.toolCallId, event.toolName, event.args);
+        appendEvent(sessionId, {
+          type: "tool_call",
+          name: event.toolName,
+          args: event.args,
+          timestamp: Date.now()
+        });
+        break;
+      }
+      case "tool_execution_end": {
+        toolEnd(event.toolCallId, event.result, event.isError);
+        const resultText = extractResultText2(event.result);
+        appendEvent(sessionId, {
+          type: "tool_result",
+          name: event.toolName,
+          result: resultText.slice(0, 500),
+          isError: event.isError,
+          timestamp: Date.now()
+        });
+        break;
+      }
+      case "agent_end": {
+        isWorking = false;
+        stopSpinner();
+        const bar = renderStatusBar({
+          model,
+          totalTokens,
+          totalCost,
+          sessionId,
+          isStreaming: false
+        });
+        process.stderr.write(`${bar}
+`);
+        const agentSummary = renderAgentSummary();
+        if (agentSummary) {
+          process.stderr.write(`${agentSummary}
+`);
+        }
+        const teamStatus = renderTeamStatus(agent.team);
+        if (teamStatus) {
+          process.stderr.write(`${teamStatus}
+`);
+        }
+        process.stderr.write("\n");
+        input.prompt();
+        break;
+      }
+      case "agent_start": {
+        isWorking = true;
+        startSpinner();
+        break;
+      }
+    }
+  });
+  function startSpinner() {
+    if (spinnerInterval) return;
+    spinnerInterval = setInterval(() => {
+      if (hasActiveWork()) {
+        updateLivePanel();
+      }
+    }, 100);
+  }
+  function stopSpinner() {
+    if (spinnerInterval) {
+      clearInterval(spinnerInterval);
+      spinnerInterval = null;
+      clearLiveRender();
+    }
+  }
+  function handleSlashCommand(input2) {
+    const [cmd, ...rest] = input2.slice(1).split(/\s+/);
+    const arg = rest.join(" ");
+    switch (cmd) {
+      case "help":
+        writeInfo(`Commands:
+  /help              Show this help
+  /sessions          List saved sessions
+  /status            Show current status
+  /clear             Clear conversation
+  /compact           Force context compaction
+  /memory            Show loaded memories
+  /quit, /exit       Exit sa`);
+        return true;
+      case "sessions":
+        process.stderr.write(formatSessionList(listSessions()) + "\n");
+        return true;
+      case "status": {
+        const bar = renderStatusBar({
+          model,
+          totalTokens,
+          totalCost,
+          sessionId,
+          isStreaming: isWorking
+        });
+        process.stderr.write(`${bar}
+`);
+        const teamStatus = renderTeamStatus(agent.team);
+        if (teamStatus) process.stderr.write(`${teamStatus}
+`);
+        return true;
+      }
+      case "clear":
+        agent.reset();
+        totalTokens = 0;
+        totalCost = 0;
+        writeInfo("Conversation cleared.");
+        return true;
+      case "memory":
+        writeInfo("Memory is auto-loaded into system prompt from:");
+        writeInfo("  Project: .sa/memory.md");
+        writeInfo("  Global:  ~/.sa/memory.md");
+        writeInfo("The agent can write to memory with write_memory tool.");
+        return true;
+      case "quit":
+      case "exit":
+        cleanup();
+        return true;
+      default:
+        writeError(`Unknown command: /${cmd}. Type /help for available commands.`);
+        return true;
+    }
+  }
+  const input = createInput({
+    onSubmit: async (text) => {
+      if (text.startsWith("/")) {
+        const handled = handleSlashCommand(text);
+        if (handled) {
+          input.prompt();
+          return;
+        }
+      }
+      if (isWorking) {
+        writeInfo("(steering agent...)");
+        agent.steer({
+          role: "user",
+          content: [{ type: "text", text }],
+          timestamp: Date.now()
+        });
+        return;
+      }
+      pauseInput();
+      appendEvent(sessionId, { type: "user", content: text, timestamp: Date.now() });
+      try {
+        await agent.prompt(text);
+        await agent.waitForIdle();
+      } catch (err) {
+        if (err.name === "AbortError") {
+          process.stderr.write(`
+${styled(theme.dim, "(aborted)")}
+`);
+        } else {
+          writeError(err.message ?? String(err));
+        }
+        input.prompt();
+      }
+    },
+    onAbort: () => {
+      if (isWorking) {
+        agent.abort();
+        isWorking = false;
+        stopSpinner();
+        process.stderr.write(`
+${styled(theme.dim, "(aborted)")}
+`);
+        input.prompt();
+      } else {
+        cleanup();
+      }
+    }
+  });
+  function cleanup() {
+    stopSpinner();
+    agent.destroy();
+    input.close();
+    process.stderr.write(`
+${styled(theme.dim, `Session saved: ${sessionId}`)}
+`);
+    process.exit(0);
+  }
+  process.on("SIGTERM", cleanup);
+  input.prompt();
+}
+function extractResultText2(result) {
+  if (!result) return "";
+  if (typeof result === "string") return result;
+  if (result.content && Array.isArray(result.content)) {
+    return result.content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
+  }
+  return JSON.stringify(result).slice(0, 500);
+}
+
+// src/modes/sms.ts
+import { createAgent as createAgent3 } from "subagent";
+
+// src/sms/relay-client.ts
+import WebSocket from "ws";
+function connectRelay(opts) {
+  let ws = null;
+  let closed = false;
+  let reconnectAttempt = 0;
+  let reconnectTimer = null;
+  let pingInterval = null;
+  const MAX_RECONNECT_DELAY = 3e4;
+  const RECONNECT_BUDGET_MS = 10 * 60 * 1e3;
+  let firstConnectTime = Date.now();
+  function connect() {
+    if (closed) return;
+    const wsUrl = `${opts.apiBaseUrl}/v1/sms/ws?session=${encodeURIComponent(opts.sessionId)}&code=${encodeURIComponent(opts.pairingCode)}`;
+    ws = new WebSocket(wsUrl);
+    ws.on("open", () => {
+      reconnectAttempt = 0;
+      firstConnectTime = Date.now();
+      pingInterval = setInterval(() => {
+        if (ws?.readyState === WebSocket.OPEN) {
+          ws.send(JSON.stringify({ type: "ping" }));
+        }
+      }, 3e4);
+    });
+    ws.on("message", (data) => {
+      let msg;
+      try {
+        msg = JSON.parse(data.toString());
+      } catch {
+        return;
+      }
+      switch (msg.type) {
+        case "prompt":
+          opts.onPrompt(msg.body, msg.from);
+          break;
+        case "paired":
+          opts.onPaired(msg.phone);
+          break;
+        case "pong":
+          break;
+        case "error":
+          opts.onError(msg.message);
+          break;
+      }
+    });
+    ws.on("close", (code) => {
+      clearPing();
+      if (closed) return;
+      if (code === 1e3) {
+        opts.onDisconnect();
+        return;
+      }
+      attemptReconnect();
+    });
+    ws.on("error", (err) => {
+      if (!closed) {
+        console.error(`[relay] WebSocket error: ${err.message}`);
+      }
+    });
+  }
+  function attemptReconnect() {
+    if (closed) return;
+    if (Date.now() - firstConnectTime > RECONNECT_BUDGET_MS) {
+      opts.onError("Reconnect budget exhausted");
+      opts.onDisconnect();
+      return;
+    }
+    const delay = Math.min(1e3 * 2 ** reconnectAttempt, MAX_RECONNECT_DELAY);
+    reconnectAttempt++;
+    reconnectTimer = setTimeout(connect, delay);
+  }
+  function clearPing() {
+    if (pingInterval) {
+      clearInterval(pingInterval);
+      pingInterval = null;
+    }
+  }
+  function send(msg) {
+    if (ws?.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify(msg));
+    }
+  }
+  connect();
+  return {
+    sendResponse(to, body) {
+      send({ type: "response", body, to });
+    },
+    sendStatus(status) {
+      send({ type: "status", status });
+    },
+    close() {
+      closed = true;
+      clearPing();
+      if (reconnectTimer) clearTimeout(reconnectTimer);
+      if (ws) {
+        try {
+          ws.close(1e3, "Client closing");
+        } catch {
+        }
+      }
+    }
+  };
+}
+
+// src/modes/sms.ts
+import crypto from "crypto";
+var SMS_API_BASE = "wss://api.subagents.com";
+var TWILIO_PHONE = process.env.TWILIO_PHONE_NUMBER || "+18556242904";
+var MAX_SMS_LEN = 1500;
+function generatePairingCode() {
+  return String(crypto.randomInt(1e3, 9999));
+}
+function truncateForSms(text) {
+  if (text.length <= MAX_SMS_LEN) return text;
+  return text.slice(0, MAX_SMS_LEN - 30) + '\n\n[text "/full" for complete response]';
+}
+async function runSmsMode(agentOptions, modelName) {
+  const sessionId = generateSessionId();
+  const pairingCode = generatePairingCode();
+  const model = modelName;
+  const tools = [...agentOptions.tools ?? [], writeMemoryTool, readMemoryTool];
+  let agent;
+  try {
+    agent = await createAgent3({ ...agentOptions, tools });
+  } catch (err) {
+    writeError(err.message ?? String(err));
+    process.exit(1);
+  }
+  let totalTokens = 0;
+  let totalCost = 0;
+  let isInText = false;
+  let isInThinking = false;
+  let isWorking = false;
+  let assistantText = "";
+  let lastFullResponse = "";
+  let pairedPhone = "";
+  let spinnerInterval = null;
+  let relay;
+  process.stderr.write("\n");
+  process.stderr.write(styled(color.bold, `  sa `) + styled(theme.dim, `SMS Remote Control
+`));
+  process.stderr.write(styled(theme.dim, `  Model: `) + styled(color.brightCyan, model) + "\n");
+  process.stderr.write(styled(theme.dim, `  Session: `) + sessionId + "\n");
+  process.stderr.write("\n");
+  process.stderr.write(styled(color.brightYellow, `  Text "${pairingCode}" to ${TWILIO_PHONE} to connect
+`));
+  process.stderr.write(styled(theme.dim, `  Ctrl+C to stop
+`));
+  process.stderr.write("\n");
+  agent.subscribe((event) => {
+    switch (event.type) {
+      case "message_update": {
+        const e = event.assistantMessageEvent;
+        if (e.type === "text_delta") {
+          if (isInThinking) {
+            isInThinking = false;
+            endThinking();
+          }
+          isInText = true;
+          writeTextDelta(e.delta);
+          assistantText += e.delta;
+        } else if (e.type === "thinking_delta") {
+          if (!isInThinking) {
+            process.stderr.write(styled(theme.thinking, "thinking... "));
+            isInThinking = true;
+          }
+          writeThinkingDelta(e.delta);
+        } else if (e.type === "thinking_end") {
+          if (isInThinking) {
+            isInThinking = false;
+            endThinking();
+          }
+        }
+        break;
+      }
+      case "turn_end": {
+        if (isInText) {
+          endAssistantMessage();
+          isInText = false;
+        }
+        const msg = event.message;
+        if (msg?.usage) {
+          totalTokens += msg.usage.totalTokens ?? 0;
+          totalCost += msg.usage.cost?.total ?? 0;
+        }
+        if (assistantText) {
+          appendEvent(sessionId, { type: "assistant", content: assistantText, timestamp: Date.now() });
+        }
+        break;
+      }
+      case "tool_execution_start": {
+        toolStart(event.toolCallId, event.toolName, event.args);
+        appendEvent(sessionId, {
+          type: "tool_call",
+          name: event.toolName,
+          args: event.args,
+          timestamp: Date.now()
+        });
+        break;
+      }
+      case "tool_execution_end": {
+        toolEnd(event.toolCallId, event.result, event.isError);
+        break;
+      }
+      case "agent_end": {
+        isWorking = false;
+        stopSpinner();
+        lastFullResponse = assistantText;
+        if (pairedPhone && assistantText) {
+          relay.sendResponse(pairedPhone, truncateForSms(assistantText));
+        }
+        assistantText = "";
+        const bar = renderStatusBar({
+          model,
+          totalTokens,
+          totalCost,
+          sessionId,
+          isStreaming: false
+        });
+        process.stderr.write(`${bar}
+
+`);
+        relay.sendStatus("idle");
+        break;
+      }
+      case "agent_start": {
+        isWorking = true;
+        startSpinner();
+        relay.sendStatus("working");
+        break;
+      }
+    }
+  });
+  function startSpinner() {
+    if (spinnerInterval) return;
+    spinnerInterval = setInterval(() => {
+      if (hasActiveWork()) {
+        updateLivePanel();
+      }
+    }, 100);
+  }
+  function stopSpinner() {
+    if (spinnerInterval) {
+      clearInterval(spinnerInterval);
+      spinnerInterval = null;
+      clearLiveRender();
+    }
+  }
+  function handleSmsCommand(text) {
+    const cmd = text.toLowerCase().trim();
+    if (cmd === "/full") {
+      if (lastFullResponse && pairedPhone) {
+        relay.sendResponse(pairedPhone, lastFullResponse);
+      } else if (pairedPhone) {
+        relay.sendResponse(pairedPhone, "No previous response to show.");
+      }
+      return true;
+    }
+    if (cmd === "/status") {
+      if (pairedPhone) {
+        const status = isWorking ? "Working..." : "Idle";
+        relay.sendResponse(pairedPhone, `Status: ${status}
+Tokens: ${totalTokens}
+Cost: $${totalCost.toFixed(4)}`);
+      }
+      return true;
+    }
+    if (cmd === "/clear") {
+      agent.reset();
+      totalTokens = 0;
+      totalCost = 0;
+      lastFullResponse = "";
+      if (pairedPhone) relay.sendResponse(pairedPhone, "Conversation cleared.");
+      writeInfo("Conversation cleared (via SMS).");
+      return true;
+    }
+    if (cmd === "/quit") {
+      if (pairedPhone) relay.sendResponse(pairedPhone, "Session ended.");
+      cleanup();
+      return true;
+    }
+    return false;
+  }
+  relay = connectRelay({
+    sessionId,
+    pairingCode,
+    apiBaseUrl: SMS_API_BASE,
+    onPrompt: async (body, from) => {
+      process.stderr.write(styled(color.brightCyan, `
+  [SMS from ${from}] `) + body + "\n\n");
+      appendEvent(sessionId, { type: "user", content: `[SMS] ${body}`, timestamp: Date.now() });
+      if (body.startsWith("/")) {
+        if (handleSmsCommand(body)) return;
+      }
+      if (isWorking) {
+        writeInfo("(steering agent via SMS...)");
+        agent.steer({
+          role: "user",
+          content: [{ type: "text", text: body }],
+          timestamp: Date.now()
+        });
+        return;
+      }
+      try {
+        await agent.prompt(body);
+        await agent.waitForIdle();
+      } catch (err) {
+        if (err.name === "AbortError") {
+          process.stderr.write(`
+${styled(theme.dim, "(aborted)")}
+`);
+        } else {
+          writeError(err.message ?? String(err));
+          if (pairedPhone) relay.sendResponse(pairedPhone, `Error: ${err.message}`);
+        }
+      }
+    },
+    onPaired: (phone) => {
+      pairedPhone = phone;
+      process.stderr.write(styled(color.brightGreen, `  Paired with ${phone}
+
+`));
+    },
+    onError: (message) => {
+      writeError(`Relay: ${message}`);
+    },
+    onDisconnect: () => {
+      writeInfo("Relay disconnected.");
+      cleanup();
+    }
+  });
+  function cleanup() {
+    stopSpinner();
+    relay.close();
+    agent.destroy();
+    process.stderr.write(`
+${styled(theme.dim, `Session saved: ${sessionId}`)}
+`);
+    process.exit(0);
+  }
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  process.stderr.write(styled(theme.dim, "  Waiting for SMS connection...\n"));
+}
+
+// src/main.ts
+var VERSION = "0.1.0";
+var HELP = `${styled(color.brightCyan, "sa")} \u2014 fluid, subagent-centric coding agent
+
+${styled(color.bold, "Usage:")}
+  sa                         Interactive mode (TUI)
+  sa "fix the login bug"     Run prompt and exit (print mode)
+  sa --sms                   SMS remote control (text prompts from phone)
+  sa --resume                Resume last session
+  sa sessions                List saved sessions
+
+${styled(color.bold, "Options:")}
+  -m, --model <model>       Model (e.g., anthropic:claude-sonnet-4-6)
+  -p, --print               Force print mode (non-interactive)
+  -r, --resume [id]         Resume a session (latest if no id)
+  --sms                     SMS remote control mode
+  --thinking <level>        Thinking level: off, minimal, low, medium, high
+  --debug                   Enable debug logging
+  -h, --help                Show this help
+  -v, --version             Show version
+
+${styled(color.bold, "Interactive commands:")}
+  /help                     Show available commands
+  /sessions                 List sessions
+  /status                   Show tokens, cost, model
+  /clear                    Clear conversation
+  /quit                     Exit
+
+${styled(color.bold, "Memory:")}
+  The agent saves learnings to .sa/memory.md (project) or ~/.sa/memory.md (global).
+  Memory auto-loads on startup so the agent improves across sessions.
+
+${styled(color.bold, "Config:")}
+  ~/.sa/config.json          Global config
+  .sa/config.json            Project config (overrides global)
+
+${styled(color.bold, "Setup:")}
+  Set your API key: echo 'ANTHROPIC_API_KEY=sk-...' >> ~/.sa/.env
+`;
+async function main(argv) {
+  const flags = parseFlags(argv);
+  if (flags.help) {
+    process.stderr.write(HELP);
+    process.exit(0);
+  }
+  if (flags.version) {
+    process.stderr.write(`sa v${VERSION}
+`);
+    process.exit(0);
+  }
+  if (flags.sessions) {
+    process.stderr.write(formatSessionList(listSessions()) + "\n");
+    process.exit(0);
+  }
+  const config = loadConfig();
+  const agentOptions = configToAgentOptions(config, flags);
+  const modelName = resolveModelName(config, flags);
+  if (flags.sms) {
+    await runSmsMode(agentOptions, modelName);
+    return;
+  }
+  if (flags.resume) {
+    let sessionId;
+    if (typeof flags.resume === "string") {
+      sessionId = flags.resume;
+    } else {
+      sessionId = getLatestSessionId() ?? void 0;
+      if (!sessionId) {
+        writeError("No sessions found to resume.");
+        process.exit(1);
+      }
+    }
+    await runInteractiveMode(agentOptions, modelName, sessionId);
+    return;
+  }
+  if (flags.prompt) {
+    await runPrintMode(flags.prompt, agentOptions, modelName);
+    return;
+  }
+  if (!process.stdin.isTTY) {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk);
+    }
+    const input = Buffer.concat(chunks).toString("utf-8").trim();
+    if (input) {
+      await runPrintMode(input, agentOptions, modelName);
+      return;
+    }
+  }
+  await runInteractiveMode(agentOptions, modelName);
+}
+
+// src/cli.ts
+loadEnv();
+process.on("uncaughtException", (err) => {
+  const msg = err.message ?? String(err);
+  if (msg.includes("No API key")) {
+    process.stderr.write(
+      "\x1B[31merror\x1B[0m: No API key found. Set ANTHROPIC_API_KEY in:\n  - Environment variable\n  - .env file in project directory\n  - ~/.sa/.env for global config\n"
+    );
+  } else {
+    process.stderr.write(`\x1B[31merror\x1B[0m: ${msg}
+`);
+  }
+  process.exit(1);
+});
+process.on("unhandledRejection", (err) => {
+  const msg = err?.message ?? String(err);
+  if (msg.includes("No API key")) {
+    process.stderr.write(
+      "\x1B[31merror\x1B[0m: No API key found. Set ANTHROPIC_API_KEY in:\n  - Environment variable\n  - .env file in project directory\n  - ~/.sa/.env for global config\n"
+    );
+  } else {
+    process.stderr.write(`\x1B[31merror\x1B[0m: ${msg}
+`);
+  }
+  process.exit(1);
+});
+main(process.argv.slice(2)).catch((err) => {
+  process.stderr.write(`\x1B[31merror\x1B[0m: ${err.message ?? err}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map