openpond 0.0.30-bootstrap.0

package/dist/chunks/src-3RBI4DNN.js

@@ -0,0 +1,3595 @@
+#!/usr/bin/env node
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  ApprovalSchema,
+  ContextUsageSnapshotSchema,
+  DEFAULT_CHAT_PROVIDER,
+  DEFAULT_CODEX_CHAT_MODEL,
+  DEFAULT_OPENPOND_CHAT_MODEL,
+  DEFAULT_OPENPOND_COMMAND_ACCESS_MODE,
+  OpenPondCommandAccessModeSchema,
+  createReadyLineParser
+} from "./chunk-Q57SVPEH.js";
+import {
+  CONNECTED_APP_CATALOG,
+  buildConnectedAppInstallUrl,
+  connectedAppById
+} from "./chunk-LHYK6QO2.js";
+import "./chunk-WYDVQOBL.js";
+import "./chunk-UACZUFIA.js";
+
+// ../terminal/src/index.ts
+import { spawn as spawn2 } from "node:child_process";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { pathToFileURL } from "node:url";
+
+// ../terminal/src/ui/composer.ts
+function createComposer() {
+  return { text: "", cursor: 0, history: [], historyIndex: null };
+}
+function insertText(state, value) {
+  const before = state.text.slice(0, state.cursor);
+  const after = state.text.slice(state.cursor);
+  return {
+    ...state,
+    text: `${before}${value}${after}`,
+    cursor: state.cursor + value.length,
+    historyIndex: null
+  };
+}
+function replaceComposerText(state, text) {
+  return { ...state, text, cursor: text.length };
+}
+function submitComposer(state) {
+  const text = state.text.trim();
+  if (!text) return { state: { ...state, text: "", cursor: 0, historyIndex: null }, action: { type: "none" } };
+  return {
+    state: {
+      text: "",
+      cursor: 0,
+      history: [...state.history.filter((item) => item !== text), text].slice(-100),
+      historyIndex: null
+    },
+    action: { type: "submit", text }
+  };
+}
+function handleComposerKey(state, key) {
+  if (key === "ctrl+c") return { state, action: { type: "cancel-or-exit" } };
+  if (key === "ctrl+d") return { state, action: state.text ? { type: "none" } : { type: "exit" } };
+  if (key === "ctrl+l") return { state, action: { type: "rerender" } };
+  if (key === "enter") return submitComposer(state);
+  if (key === "alt+enter") return { state: insertText(state, "\n"), action: { type: "none" } };
+  if (key === "backspace") {
+    if (state.cursor <= 0) return { state, action: { type: "none" } };
+    return {
+      state: {
+        ...state,
+        text: `${state.text.slice(0, state.cursor - 1)}${state.text.slice(state.cursor)}`,
+        cursor: state.cursor - 1
+      },
+      action: { type: "none" }
+    };
+  }
+  if (key === "delete") {
+    if (state.cursor >= state.text.length) return { state, action: { type: "none" } };
+    return {
+      state: {
+        ...state,
+        text: `${state.text.slice(0, state.cursor)}${state.text.slice(state.cursor + 1)}`
+      },
+      action: { type: "none" }
+    };
+  }
+  if (key === "left") return { state: { ...state, cursor: Math.max(0, state.cursor - 1) }, action: { type: "none" } };
+  if (key === "right") {
+    return { state: { ...state, cursor: Math.min(state.text.length, state.cursor + 1) }, action: { type: "none" } };
+  }
+  if (key === "home" || key === "ctrl+a") return { state: { ...state, cursor: 0 }, action: { type: "none" } };
+  if (key === "end" || key === "ctrl+e") {
+    return { state: { ...state, cursor: state.text.length }, action: { type: "none" } };
+  }
+  if (key === "ctrl+u") return { state: { ...state, text: state.text.slice(state.cursor), cursor: 0 }, action: { type: "none" } };
+  if (key === "ctrl+k") return { state: { ...state, text: state.text.slice(0, state.cursor) }, action: { type: "none" } };
+  if (key === "up") {
+    if (state.history.length === 0) return { state, action: { type: "none" } };
+    const nextIndex = state.historyIndex === null ? state.history.length - 1 : Math.max(0, state.historyIndex - 1);
+    return { state: replaceComposerText({ ...state, historyIndex: nextIndex }, state.history[nextIndex] ?? ""), action: { type: "none" } };
+  }
+  if (key === "down") {
+    if (state.historyIndex === null) return { state, action: { type: "none" } };
+    const nextIndex = state.historyIndex + 1;
+    if (nextIndex >= state.history.length) {
+      return { state: { ...state, text: "", cursor: 0, historyIndex: null }, action: { type: "none" } };
+    }
+    return { state: replaceComposerText({ ...state, historyIndex: nextIndex }, state.history[nextIndex] ?? ""), action: { type: "none" } };
+  }
+  if (key.length > 0) return { state: insertText(state, key), action: { type: "none" } };
+  return { state, action: { type: "none" } };
+}
+
+// ../terminal/src/line-mode-turn-guard.ts
+var LINE_MODE_TURN_RUNNING_MESSAGE = "A turn is already running. Wait for it to finish before sending another line.";
+function createTerminalTurnSubmissionGuard() {
+  let running = false;
+  return {
+    isRunning() {
+      return running;
+    },
+    tryStartSubmission() {
+      if (running) return false;
+      running = true;
+      return true;
+    },
+    failSubmission() {
+      running = false;
+    },
+    applyRuntimeEvent(event) {
+      if (event.name === "turn.started") running = true;
+      if (event.name === "turn.completed" || event.name === "turn.failed" || event.name === "turn.interrupted") {
+        running = false;
+      }
+    }
+  };
+}
+function createLineModeTurnGuard() {
+  return createTerminalTurnSubmissionGuard();
+}
+
+// ../terminal/src/ui/commands.ts
+var SLASH_COMMANDS = [
+  { name: "help", usage: "/help", description: "show this help" },
+  { name: "providers", usage: "/providers", description: "list providers" },
+  { name: "provider", usage: "/provider [id]", description: "switch provider", requiresArgument: true },
+  { name: "model", usage: "/model [id]", description: "list or switch model" },
+  { name: "apps", usage: "/apps", description: "list connectable apps" },
+  { name: "install", usage: "/install <app>", description: "open app details", requiresArgument: true },
+  { name: "projects", usage: "/projects", description: "list projects" },
+  { name: "project", usage: "/project <id>", description: "switch project", requiresArgument: true },
+  { name: "permissions", usage: "/permissions [ask|full-access]", description: "show or change command access" },
+  { name: "profile", usage: "/profile [status|diff|catalog|check|push]", description: "show or sync profile" },
+  { name: "agents", usage: "/agents", description: "list agents" },
+  { name: "agent", usage: "/agent <id>", description: "select agent", requiresArgument: true },
+  { name: "run", usage: "/run <action> [json]", description: "run profile action", requiresArgument: true },
+  { name: "settings", usage: "/settings [goal-storage global|workspace]", description: "show or update settings" },
+  { name: "logs", usage: "/logs", description: "show recent events" },
+  { name: "compact", usage: "/compact", description: "compact current session" },
+  { name: "clear", usage: "/clear", description: "clear terminal transcript" },
+  { name: "exit", usage: "/exit", description: "exit" },
+  { name: "hooks", usage: "/hooks", description: "show hook status" },
+  { name: "start", usage: "/start", description: "start a new session" }
+];
+function parseSlashCommand(text) {
+  if (!text.startsWith("/")) return null;
+  const [rawCommand = "", ...rest] = text.slice(1).trim().split(/\s+/);
+  const command = rawCommand.toLowerCase();
+  if (!command) return null;
+  if (command === "exit" || command === "quit") return { type: "exit" };
+  if (command === "help") return { type: "help" };
+  if (command === "clear") return { type: "clear" };
+  if (command === "agents") return { type: "agents" };
+  if (command === "apps") return { type: "apps" };
+  if (command === "agent") return { type: "agent", id: rest.join(" ").trim() };
+  if (command === "install") return { type: "install", id: rest.join(" ").trim() };
+  if (command === "projects") return { type: "projects" };
+  if (command === "project") return { type: "project", id: rest.join(" ").trim() };
+  if (command === "model") return { type: "model", id: rest.join(" ").trim() || null };
+  if (command === "permissions") return { type: "permissions", args: rest };
+  if (command === "profile") return { type: "profile", args: rest };
+  if (command === "logs") return { type: "logs" };
+  if (command === "providers") return { type: "providers" };
+  if (command === "provider") return { type: "provider", id: rest.join(" ").trim() || null };
+  if (command === "compact") return { type: "compact" };
+  if (command === "hooks") return { type: "hooks" };
+  if (command === "start") return { type: "start" };
+  if (command === "run") {
+    const action = rest[0] ?? "";
+    const rawInput = rest.slice(1).join(" ").trim();
+    if (!rawInput) return { type: "run", action, input: void 0 };
+    return { type: "run", action, input: JSON.parse(rawInput) };
+  }
+  if (command === "settings") return { type: "settings", args: rest };
+  return { type: "unknown", command };
+}
+function parseDirectCommandPrompt(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("!")) return null;
+  const command = trimmed.slice(1).trim();
+  return command ? { command } : null;
+}
+function helpText() {
+  const usageWidth = Math.max(...SLASH_COMMANDS.map((command) => command.usage.length));
+  return ["Commands:", ...SLASH_COMMANDS.map((command) => `${command.usage.padEnd(usageWidth + 2)}${command.description}`)].join("\n");
+}
+
+// ../terminal/src/ui/input.ts
+var RawInput = class {
+  input;
+  onKey;
+  previousRawMode = false;
+  dataHandler = null;
+  constructor(input2, onKey) {
+    this.input = input2;
+    this.onKey = onKey;
+  }
+  start() {
+    this.previousRawMode = this.input.isRaw ?? false;
+    this.input.setRawMode(true);
+    this.input.resume();
+    this.dataHandler = (chunk) => {
+      for (const key of decodeKeys(chunk)) this.onKey(key);
+    };
+    this.input.on("data", this.dataHandler);
+  }
+  stop() {
+    if (this.dataHandler) this.input.off("data", this.dataHandler);
+    this.dataHandler = null;
+    this.input.setRawMode(this.previousRawMode);
+    this.input.pause();
+  }
+};
+function decodeKeys(chunk) {
+  const text = chunk.toString("utf8");
+  const keys = [];
+  for (let i = 0; i < text.length; i += 1) {
+    const char = text[i];
+    const next = text[i + 1];
+    if (char === "\x1B") {
+      const sequence = readEscapeSequence(text, i);
+      keys.push(sequence.key);
+      i = sequence.end;
+      continue;
+    }
+    if (char === "") keys.push("ctrl+c");
+    else if (char === "") keys.push("ctrl+d");
+    else if (char === "\f") keys.push("ctrl+l");
+    else if (char === "
") keys.push("ctrl+a");
+    else if (char === "") keys.push("ctrl+e");
+    else if (char === "\v") keys.push("ctrl+k");
+    else if (char === "") keys.push("ctrl+u");
+    else if (char === "\x7F" || char === "\b") keys.push("backspace");
+    else if (char === "\r" || char === "\n") keys.push("enter");
+    else if (char >= " " || char && next) keys.push(char);
+  }
+  return keys;
+}
+function readEscapeSequence(text, start) {
+  const rest = text.slice(start);
+  if (rest.startsWith("\x1B\r") || rest.startsWith("\x1B\n")) return { key: "alt+enter", end: start + 1 };
+  if (rest.startsWith("\x1B[A")) return { key: "up", end: start + 2 };
+  if (rest.startsWith("\x1B[B")) return { key: "down", end: start + 2 };
+  if (rest.startsWith("\x1B[C")) return { key: "right", end: start + 2 };
+  if (rest.startsWith("\x1B[D")) return { key: "left", end: start + 2 };
+  if (rest.startsWith("\x1B[H") || rest.startsWith("\x1B[1~") || rest.startsWith("\x1BOH")) {
+    return { key: "home", end: start + (rest.startsWith("\x1B[1~") ? 3 : 2) };
+  }
+  if (rest.startsWith("\x1B[F") || rest.startsWith("\x1B[4~") || rest.startsWith("\x1BOF")) {
+    return { key: "end", end: start + (rest.startsWith("\x1B[4~") ? 3 : 2) };
+  }
+  if (rest.startsWith("\x1B[3~")) return { key: "delete", end: start + 3 };
+  if (rest.startsWith("\x1B[5~")) return { key: "pageup", end: start + 3 };
+  if (rest.startsWith("\x1B[6~")) return { key: "pagedown", end: start + 3 };
+  if (rest.length >= 2 && rest[1] && rest[1] >= " ") return { key: rest[1], end: start + 1 };
+  return { key: "", end: start };
+}
+
+// ../terminal/src/ui/ansi.ts
+var ESC = "\x1B[";
+var COLORS = {
+  reset: "0",
+  muted: "38;5;244",
+  text: "38;5;252",
+  strong: "38;5;255",
+  accent: "38;5;81",
+  success: "38;5;114",
+  warning: "38;5;221",
+  error: "38;5;203",
+  dim: "38;5;240"
+};
+function color(name) {
+  return `${ESC}${COLORS[name]}m`;
+}
+function style(text, name) {
+  if (!text) return "";
+  return `${color(name)}${text}${color("reset")}`;
+}
+function surfaceLine(text, width, foreground = "strong") {
+  const padded = truncatePlain(text, Math.max(0, width)).padEnd(Math.max(0, width));
+  return `${ESC}48;5;236m${color(foreground)}${padded}${color("reset")}`;
+}
+function hideCursor() {
+  return "\x1B[?25l";
+}
+function showCursor() {
+  return "\x1B[?25h";
+}
+function setCursorColor(colorValue) {
+  return `\x1B]12;${colorValue}\x07`;
+}
+function resetCursorColor() {
+  return "\x1B]112\x07";
+}
+function clearLine() {
+  return `${ESC}2K`;
+}
+function truncatePlain(input2, max) {
+  if (max <= 0) return "";
+  const chars = Array.from(input2);
+  if (chars.length <= max) return input2;
+  if (max === 1) return ".";
+  return `${chars.slice(0, max - 1).join("")}.`;
+}
+
+// ../terminal/src/ui/layout.ts
+function buildFrame(input2) {
+  const cols = Math.max(20, input2.cols);
+  const rows = Math.max(4, input2.rows);
+  const composer = renderComposer(input2.composer, cols, Math.min(5, rows - 1));
+  const menuRows = renderSlashMenu(input2.slashMenu, cols, Math.max(0, rows - composer.lines.length - 1));
+  const footer = renderFooter(input2.status, cols);
+  const fixedRows = 1 + composer.lines.length + menuRows.length;
+  const transcriptRows = Math.max(0, rows - fixedRows);
+  const transcriptLines = renderTranscript(input2.transcript, cols, input2.transcriptLayoutCache);
+  const start = Math.max(0, transcriptLines.length - transcriptRows - input2.scrollOffset);
+  const visibleTranscript = transcriptLines.length > 0 ? transcriptLines.slice(start, start + transcriptRows) : input2.status.running ? [style("Working...", "muted")] : [];
+  const spacer = visibleTranscript.length > 0 ? ["", ""] : [];
+  const lines = [...visibleTranscript, ...spacer, ...composer.lines, ...menuRows, footer].slice(0, rows);
+  const composerStartRow = visibleTranscript.length + spacer.length + 1;
+  return {
+    lines,
+    cursorRow: Math.min(lines.length, composerStartRow + composer.cursorLine),
+    cursorCol: Math.min(cols, composer.cursorCol)
+  };
+}
+function renderFooter(status, cols) {
+  const left = `${status.provider || "OpenPond"} / ${status.model || "OpenPond Chat"}  ${compactPath(status.cwd)}`;
+  const right = status.notice ?? (status.running ? "running" : "/help");
+  const gap = Math.max(1, cols - visible(left) - visible(right));
+  return style(truncatePlain(`${left}${" ".repeat(gap)}${right}`, cols), "muted");
+}
+function renderTranscript(items, cols, cache) {
+  cache?.retain(new Set(items.map((item) => item.id)));
+  const lines = [];
+  for (const item of items) {
+    if (lines.length > 0) lines.push("");
+    lines.push(...renderItem(item, cols, cache));
+  }
+  return lines;
+}
+function renderTranscriptItemsForScrollback(items, cols) {
+  return renderTranscript(items, cols);
+}
+function renderWelcome(status, cols) {
+  const profile = status.profile || "none";
+  const agent = status.agent ? `  agent: ${status.agent}` : "";
+  const rows = [
+    "OpenPond",
+    `provider: ${status.provider || "OpenPond"}  /provider`,
+    `model: ${status.model || "OpenPond Chat"}  /model`,
+    `directory: ${compactPath(status.cwd)}`,
+    `profile: ${profile}${agent}`
+  ];
+  const width = Math.min(cols, Math.max(34, ...rows.map((row) => visible(row) + 4)));
+  const horizontal = "\u2500".repeat(Math.max(0, width - 2));
+  return [
+    style(`\u250C${horizontal}\u2510`, "accent"),
+    ...rows.map((row, index) => {
+      const padded = row.padEnd(Math.max(0, width - 4));
+      return `${style("\u2502", "accent")} ${style(padded, index === 0 ? "strong" : "text")} ${style("\u2502", "accent")}`;
+    }),
+    style(`\u2514${horizontal}\u2518`, "accent")
+  ];
+}
+function renderItem(item, cols, cache) {
+  if (item.kind === "user") return renderUserMessage(item.text, cols);
+  if (item.kind === "assistant") {
+    return renderAssistantMessage(
+      item.text || (item.streaming ? "..." : ""),
+      cols,
+      cache ? (text, width) => cache.renderAssistant(item.id, text, width) : void 0
+    );
+  }
+  if (item.kind === "system") return renderBlock("!", item.text, cols, item.tone === "error" ? "error" : item.tone === "warning" ? "warning" : "muted", "muted");
+  if (item.kind === "approval") {
+    const body2 = `${item.title}${item.body ? `
+${item.body}` : ""}`;
+    return renderBlock("?", body2, cols, "warning", "text");
+  }
+  if (item.kind === "command") {
+    const output2 = compactOutput(item.output);
+    const body2 = output2 ? `${item.title}
+${output2}` : item.title;
+    return renderBlock(item.status === "failed" ? "!" : "$", body2, cols, item.status === "failed" ? "error" : "warning", "text");
+  }
+  const summary = compactOutput(item.summary);
+  const body = summary ? `${item.title}
+${summary}` : item.title;
+  const label = item.status === "failed" ? "!" : item.status === "running" ? "*" : "ok";
+  return renderBlock(label, body, cols, item.status === "failed" ? "error" : item.status === "running" ? "warning" : "success", "text");
+}
+function renderUserMessage(body, cols) {
+  const bodyWidth = Math.max(12, cols - 4);
+  const bodyLines = body.split(/\r?\n/).flatMap((line) => wrapPlain(line, bodyWidth));
+  return [
+    surfaceLine("", cols),
+    ...bodyLines.map((line) => surfaceLine(`  ${line}`, cols)),
+    surfaceLine("", cols),
+    "",
+    ""
+  ];
+}
+function renderSlashMenu(menu, cols, maxRows) {
+  if (!menu || menu.items.length === 0 || maxRows <= 0) return [];
+  const visibleRows = Math.min(maxRows, 8, menu.items.length);
+  const selected = clamp(menu.selectedIndex, 0, menu.items.length - 1);
+  const start = Math.min(Math.max(0, selected - Math.floor(visibleRows / 2)), Math.max(0, menu.items.length - visibleRows));
+  const visibleItems = menu.items.slice(start, start + visibleRows);
+  const usageWidth = Math.min(24, Math.max(...visibleItems.map((item) => item.usage.length)));
+  return visibleItems.map((item, offset) => {
+    const index = start + offset;
+    const usage = item.usage.padEnd(usageWidth);
+    return surfaceLine(`   ${usage}  ${item.description}`, cols, index === selected ? "accent" : "text");
+  });
+}
+function renderAssistantMessage(body, cols, wrap) {
+  const lines = (wrap ? wrap(body, Math.max(8, cols)) : body.split(/\r?\n/).flatMap((line) => wrapPlain(line, Math.max(8, cols)))).map((line) => style(line, "text"));
+  return [...lines, ""];
+}
+function renderBlock(label, body, cols, labelColor, bodyColor) {
+  const labelWidth = Math.min(9, Math.max(2, label.length));
+  const bodyWidth = Math.max(8, cols - labelWidth - 2);
+  const bodyLines = body.split(/\r?\n/).flatMap((line) => wrapPlain(line, bodyWidth));
+  const first = bodyLines[0] ?? "";
+  const lines = [`${style(label.padEnd(labelWidth), labelColor)}  ${style(first, bodyColor)}`];
+  for (const line of bodyLines.slice(1)) {
+    lines.push(`${" ".repeat(labelWidth)}  ${style(line, bodyColor)}`);
+  }
+  return lines;
+}
+function compactPath(cwd) {
+  const normalized = cwd.replace(/\\/g, "/");
+  const home = process.env.HOME?.replace(/\\/g, "/");
+  if (home && normalized === home) return "~";
+  if (home && normalized.startsWith(`${home}/`)) return `~/${normalized.slice(home.length + 1)}`;
+  return normalized;
+}
+function compactOutput(output2) {
+  const trimmed = output2.trim();
+  if (!trimmed) return "";
+  const lines = trimmed.split(/\r?\n/);
+  const maxLines = 8;
+  const clipped = lines.length > maxLines ? [...lines.slice(0, maxLines - 1), `... ${lines.length - maxLines + 1} more lines`] : lines;
+  return clipped.map((line) => truncatePlain(line, 160)).join("\n");
+}
+function renderComposer(composer, cols, maxLines) {
+  const width = Math.max(1, cols - 4);
+  const wrapped = wrapComposerText(composer.text, composer.cursor, width);
+  const maxTextLines = Math.max(1, maxLines - 2);
+  const start = Math.max(0, wrapped.cursorLine - maxTextLines + 1);
+  const visibleLines = wrapped.lines.slice(start, start + maxLines);
+  const renderedText = visibleLines.slice(0, maxTextLines).map((line) => {
+    const text = line || (composer.text ? "" : " message OpenPond or /help");
+    return surfaceLine(`  ${text}`, cols, line ? "strong" : "dim");
+  });
+  if (renderedText.length === 0) renderedText.push(surfaceLine("   message OpenPond or /help", cols, "dim"));
+  const cursorLine = Math.max(0, wrapped.cursorLine - start);
+  return {
+    lines: [surfaceLine("", cols), ...renderedText, surfaceLine("", cols)],
+    cursorLine: cursorLine + 1,
+    cursorCol: 3 + wrapped.cursorCol
+  };
+}
+function wrapComposerText(text, cursor, width) {
+  const lines = [""];
+  let line = 0;
+  let col = 0;
+  let cursorLine = 0;
+  let cursorCol = 0;
+  const chars = Array.from(text);
+  for (let i = 0; i <= chars.length; i += 1) {
+    if (i === cursor) {
+      cursorLine = line;
+      cursorCol = col;
+    }
+    if (i === chars.length) break;
+    const char = chars[i];
+    if (char === "\n" || col >= width) {
+      line += 1;
+      col = 0;
+      lines[line] = "";
+      if (char === "\n") continue;
+    }
+    lines[line] += char;
+    col += 1;
+  }
+  return { lines, cursorLine, cursorCol };
+}
+function wrapPlain(input2, width) {
+  if (!input2) return [""];
+  const words = input2.split(/(\s+)/);
+  const lines = [];
+  let current = "";
+  for (const word of words) {
+    if (!word) continue;
+    if (visible(current) + visible(word) <= width) {
+      current += word;
+      continue;
+    }
+    if (current.trimEnd()) lines.push(current.trimEnd());
+    current = "";
+    if (visible(word) > width) {
+      const chars = Array.from(word);
+      while (chars.length > width) lines.push(chars.splice(0, width).join(""));
+      current = chars.join("");
+    } else {
+      current = word.trimStart();
+    }
+  }
+  if (current.trimEnd()) lines.push(current.trimEnd());
+  return lines.length ? lines : [""];
+}
+function visible(input2) {
+  return Array.from(input2).length;
+}
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+
+// ../terminal/src/ui/render-scheduler.ts
+var DEFAULT_MAX_FPS = 30;
+function createTerminalRenderScheduler(render, options = {}) {
+  const maxFps = Number.isFinite(options.maxFps) && options.maxFps > 0 ? options.maxFps : DEFAULT_MAX_FPS;
+  const frameMs = Math.max(1, Math.ceil(1e3 / maxFps));
+  const setTimer = options.setTimer ?? setTimeout;
+  const clearTimer = options.clearTimer ?? clearTimeout;
+  let timer = null;
+  let pending = false;
+  function clearPendingTimer() {
+    if (!timer) return;
+    clearTimer(timer);
+    timer = null;
+  }
+  function paint() {
+    timer = null;
+    if (!pending) return;
+    pending = false;
+    render();
+  }
+  return {
+    request() {
+      pending = true;
+      if (timer) return;
+      timer = setTimer(paint, frameMs);
+    },
+    flush() {
+      if (!pending) {
+        clearPendingTimer();
+        return;
+      }
+      pending = false;
+      clearPendingTimer();
+      render();
+    },
+    cancel() {
+      pending = false;
+      clearPendingTimer();
+    }
+  };
+}
+
+// ../terminal/src/ui/transcript-layout-cache.ts
+var TranscriptLayoutCache = class {
+  #assistant = /* @__PURE__ */ new Map();
+  #processedCharacters = 0;
+  renderAssistant(id, text, width) {
+    const safeWidth = Math.max(1, width);
+    let entry = this.#assistant.get(id);
+    if (!entry || entry.width !== safeWidth || !text.startsWith(entry.lastText)) {
+      entry = {
+        width: safeWidth,
+        lastText: "",
+        stableOffset: 0,
+        stableState: { lines: [], current: "", trailingNewline: false }
+      };
+      this.#assistant.set(id, entry);
+    }
+    const suffix = text.slice(entry.stableOffset);
+    const stableLength = stablePrefixLength(suffix, safeWidth);
+    if (stableLength > 0) {
+      this.#process(entry.stableState, suffix.slice(0, stableLength), safeWidth);
+      entry.stableOffset += stableLength;
+    }
+    const rendered = cloneState(entry.stableState);
+    this.#process(rendered, text.slice(entry.stableOffset), safeWidth);
+    entry.lastText = text;
+    return finishState(rendered);
+  }
+  retain(itemIds) {
+    for (const id of this.#assistant.keys()) {
+      if (!itemIds.has(id)) this.#assistant.delete(id);
+    }
+  }
+  stats() {
+    return { entries: this.#assistant.size, processedCharacters: this.#processedCharacters };
+  }
+  #process(state, input2, width) {
+    this.#processedCharacters += input2.length;
+    for (const token of input2.match(/\r\n|\r|\n|[^\S\r\n]+|\S+/g) ?? []) {
+      if (/^\r?\n$|^\r$/.test(token)) processNewline(state);
+      else processToken(state, token, width);
+    }
+  }
+};
+function stablePrefixLength(input2, width) {
+  const matches = [...input2.matchAll(/\r\n|\r|\n|[^\S\r\n]+|\S+/g)];
+  if (matches.length === 0) return 0;
+  const last = matches.at(-1);
+  const lastStart = last.index ?? 0;
+  const lastToken = last[0];
+  if (/^\r?\n$|^\r$/.test(lastToken)) return input2.length;
+  if (/^\s+$/.test(lastToken)) return lastStart;
+  const stableWordCharacters = Math.max(0, Math.floor((lastToken.length - 1) / width) * width);
+  return lastStart + stableWordCharacters;
+}
+function processToken(state, token, width) {
+  state.trailingNewline = false;
+  if (visible2(state.current) + visible2(token) <= width) {
+    state.current += token;
+    return;
+  }
+  if (state.current.trimEnd()) state.lines.push(state.current.trimEnd());
+  state.current = "";
+  if (visible2(token) > width) {
+    const chars = Array.from(token);
+    while (chars.length > width) state.lines.push(chars.splice(0, width).join(""));
+    state.current = chars.join("");
+  } else {
+    state.current = token.trimStart();
+  }
+}
+function processNewline(state) {
+  state.lines.push(state.current.trimEnd());
+  state.current = "";
+  state.trailingNewline = true;
+}
+function finishState(state) {
+  const lines = [...state.lines];
+  if (state.current.trimEnd()) lines.push(state.current.trimEnd());
+  else if (state.trailingNewline) lines.push("");
+  return lines.length > 0 ? lines : [""];
+}
+function cloneState(state) {
+  return { lines: [...state.lines], current: state.current, trailingNewline: state.trailingNewline };
+}
+function visible2(input2) {
+  return Array.from(input2).length;
+}
+
+// ../terminal/src/ui/renderer.ts
+var CSI = "\x1B[";
+var MAX_FRAME_ROWS = 10;
+var TerminalRenderer = class {
+  output;
+  previousRows = 0;
+  cursorRow = 1;
+  active = false;
+  resizeHandler = null;
+  transcriptLayoutCache = new TranscriptLayoutCache();
+  constructor(output2, onResize) {
+    this.output = output2;
+    this.resizeHandler = onResize;
+  }
+  start() {
+    if (this.active) return;
+    this.active = true;
+    this.output.write(`${setCursorColor("#ffffff")}${hideCursor()}`);
+    if (this.resizeHandler) this.output.on("resize", this.resizeHandler);
+  }
+  stop() {
+    if (!this.active) return;
+    if (this.resizeHandler) this.output.off("resize", this.resizeHandler);
+    this.output.write(`${this.clearPrompt()}${resetCursorColor()}${showCursor()}`);
+    this.active = false;
+  }
+  fullRedraw() {
+  }
+  render(input2) {
+    if (!this.active) return;
+    const cols = this.output.columns || 80;
+    const rows = Math.min(this.output.rows || 24, MAX_FRAME_ROWS);
+    const frame = buildFrame({ ...input2, cols, rows, transcriptLayoutCache: this.transcriptLayoutCache });
+    let buffer = `${hideCursor()}${this.clearPrompt()}`;
+    const physicalRows = frame.lines.length;
+    for (let index = 0; index < physicalRows; index += 1) {
+      buffer += `${clearLine()}${frame.lines[index] ?? ""}`;
+      if (index < physicalRows - 1) buffer += "\n";
+    }
+    const rowsUp = Math.max(0, physicalRows - frame.cursorRow);
+    buffer += rowsUp > 0 ? `${CSI}${rowsUp}F` : "\r";
+    if (frame.cursorCol > 1) buffer += `${CSI}${frame.cursorCol - 1}C`;
+    buffer += showCursor();
+    this.previousRows = physicalRows;
+    this.cursorRow = frame.cursorRow;
+    this.output.write(buffer);
+  }
+  commitLines(lines) {
+    if (!this.active || lines.length === 0) return;
+    let buffer = `${hideCursor()}${this.clearPrompt()}`;
+    buffer += lines.map((line) => `${line}\r
+`).join("");
+    this.output.write(buffer);
+  }
+  clearPrompt() {
+    if (this.previousRows === 0) return "";
+    let buffer = this.cursorRow > 1 ? `${CSI}${this.cursorRow - 1}F` : "\r";
+    for (let index = 0; index < this.previousRows; index += 1) {
+      buffer += clearLine();
+      if (index < this.previousRows - 1) buffer += "\n";
+    }
+    if (this.previousRows > 1) buffer += `${CSI}${this.previousRows - 1}F`;
+    else buffer += "\r";
+    this.previousRows = 0;
+    this.cursorRow = 1;
+    return buffer;
+  }
+};
+
+// ../terminal/src/ui/transcript.ts
+var MAX_ACTIVE_TRANSCRIPT_ITEMS = 200;
+var MAX_ACTIVE_STREAMING_TEXT_BYTES = 128 * 1024;
+var STREAM_TRUNCATION_MARKER = "\n\n[terminal live output truncated; full output remains available from session history]";
+function itemId(prefix) {
+  return `${prefix}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function userItem(text) {
+  return { id: itemId("user"), kind: "user", text, createdAt: nowIso() };
+}
+function systemItem(text, tone = "info") {
+  return { id: itemId("system"), kind: "system", tone, text, createdAt: nowIso() };
+}
+function isTranscriptItemCommitReady(item) {
+  if (item.kind === "assistant") return !item.streaming;
+  if (item.kind === "command" || item.kind === "tool") return item.status !== "running";
+  if (item.kind === "approval") return item.status !== "pending";
+  return true;
+}
+function limitActiveTranscriptItems(items, limit = MAX_ACTIVE_TRANSCRIPT_ITEMS) {
+  if (items.length <= limit) return items;
+  return items.slice(Math.max(0, items.length - limit));
+}
+function appendTranscriptItem(items, item, limit = MAX_ACTIVE_TRANSCRIPT_ITEMS) {
+  return limitActiveTranscriptItems([...items, item], limit);
+}
+function commitReadyTranscriptItems(items, isReady = isTranscriptItemCommitReady) {
+  const readyItems = [];
+  const activeItems = [];
+  for (const item of items) {
+    if (isReady(item)) readyItems.push(item);
+    else activeItems.push(item);
+  }
+  return { readyItems, activeItems: limitActiveTranscriptItems(activeItems) };
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function stringValue(record, keys) {
+  if (!record) return null;
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return null;
+}
+function approvalRequestedId(event) {
+  return stringValue(asRecord(event.data), ["id", "approvalId", "approval_id"]) ?? event.id;
+}
+function approvalResolvedId(event) {
+  return stringValue(asRecord(event.data), ["approvalId", "approval_id", "id"]) ?? event.id;
+}
+function toolEventId(event) {
+  const data = asRecord(event.data);
+  const stableId = stringValue(data, [
+    "toolCallId",
+    "tool_call_id",
+    "workspaceToolCallId",
+    "workspace_tool_call_id",
+    "callId",
+    "call_id",
+    "itemId",
+    "item_id",
+    "id"
+  ]);
+  return stableId ? `${event.name.startsWith("workspace_") ? "workspace" : "tool"}-${stableId}` : event.id;
+}
+function appendRuntimeEvent(items, event) {
+  if (event.name === "assistant.delta") {
+    const delta = event.output ?? "";
+    if (!delta) return items;
+    const last = items[items.length - 1];
+    if (last?.kind === "assistant" && last.streaming) {
+      if (last.truncated) return items;
+      const appended = appendStreamingText(last.text, last.textBytes, delta);
+      return limitActiveTranscriptItems([
+        ...items.slice(0, -1),
+        {
+          ...last,
+          text: appended.text,
+          textBytes: appended.textBytes,
+          truncated: appended.truncated
+        }
+      ]);
+    }
+    const initial = appendStreamingText("", 0, delta);
+    return appendTranscriptItem(
+      items,
+      {
+        id: event.turnId ? `assistant-${event.turnId}` : itemId("assistant"),
+        kind: "assistant",
+        text: initial.text,
+        textBytes: initial.textBytes,
+        truncated: initial.truncated,
+        streaming: true,
+        createdAt: event.timestamp
+      }
+    );
+  }
+  if (event.name === "turn.completed") {
+    return limitActiveTranscriptItems(
+      items.map((item) => item.kind === "assistant" && item.streaming ? { ...item, streaming: false } : item)
+    );
+  }
+  if (event.name === "turn.failed" || event.name === "turn.interrupted") {
+    const tone = event.name === "turn.failed" ? "error" : "warning";
+    const text = event.error || event.output || (event.name === "turn.failed" ? "Turn failed" : "Turn interrupted");
+    return appendTranscriptItem(
+      items.map((item) => item.kind === "assistant" && item.streaming ? { ...item, streaming: false } : item),
+      systemItem(text, tone)
+    );
+  }
+  if (event.name === "approval.requested") {
+    return appendTranscriptItem(
+      items,
+      {
+        id: approvalRequestedId(event),
+        kind: "approval",
+        title: event.action || "Approval requested",
+        body: event.output || "Review the approval request in the app.",
+        status: "pending",
+        createdAt: event.timestamp
+      }
+    );
+  }
+  if (event.name === "approval.resolved") {
+    const approvalId = approvalResolvedId(event);
+    return limitActiveTranscriptItems(
+      items.map(
+        (item) => item.kind === "approval" && item.id === approvalId ? { ...item, status: event.status === "completed" ? "approved" : "denied" } : item
+      )
+    );
+  }
+  if (event.name === "command.output") {
+    return appendTranscriptItem(
+      items,
+      {
+        id: event.id,
+        kind: "command",
+        title: event.action || "command",
+        output: event.output || "",
+        status: event.error ? "failed" : "succeeded",
+        createdAt: event.timestamp
+      }
+    );
+  }
+  if (event.name === "tool.started" || event.name === "workspace_action") {
+    return appendTranscriptItem(
+      items,
+      {
+        id: toolEventId(event),
+        kind: "tool",
+        title: event.action || "tool",
+        summary: event.output || "",
+        status: "running",
+        createdAt: event.timestamp
+      }
+    );
+  }
+  if (event.name === "tool.completed" || event.name === "workspace_action_result") {
+    const nextItem = {
+      id: toolEventId(event),
+      kind: "tool",
+      title: event.action || "tool",
+      summary: event.error || event.output || "",
+      status: event.error || event.status === "failed" ? "failed" : "succeeded",
+      createdAt: event.timestamp
+    };
+    const index = items.findIndex((item) => item.kind === "tool" && item.id === nextItem.id);
+    if (index === -1) return appendTranscriptItem(items, nextItem);
+    return limitActiveTranscriptItems([...items.slice(0, index), nextItem, ...items.slice(index + 1)]);
+  }
+  if (event.name === "session.compaction.started") return appendTranscriptItem(items, systemItem("Compaction started"));
+  if (event.name === "session.compaction.completed") return appendTranscriptItem(items, systemItem("Compaction completed"));
+  if (event.name === "session.compaction.failed") return appendTranscriptItem(items, systemItem(event.error || "Compaction failed", "error"));
+  return items;
+}
+function appendStreamingText(current, knownCurrentBytes, delta) {
+  const currentBytes = knownCurrentBytes ?? utf8Bytes(current);
+  const deltaBytes = utf8Bytes(delta);
+  if (currentBytes + deltaBytes <= MAX_ACTIVE_STREAMING_TEXT_BYTES) {
+    return { text: `${current}${delta}`, textBytes: currentBytes + deltaBytes, truncated: false };
+  }
+  const markerBytes = utf8Bytes(STREAM_TRUNCATION_MARKER);
+  const remainingBytes = Math.max(0, MAX_ACTIVE_STREAMING_TEXT_BYTES - currentBytes - markerBytes);
+  const prefix = utf8Prefix(delta, remainingBytes);
+  const text = `${current}${prefix}${STREAM_TRUNCATION_MARKER}`;
+  return { text, textBytes: utf8Bytes(text), truncated: true };
+}
+function utf8Prefix(value, maxBytes) {
+  if (maxBytes <= 0) return "";
+  let output2 = "";
+  let bytes = 0;
+  for (const char of value) {
+    const size = utf8Bytes(char);
+    if (bytes + size > maxBytes) break;
+    output2 += char;
+    bytes += size;
+  }
+  return output2;
+}
+function utf8Bytes(value) {
+  return new TextEncoder().encode(value).byteLength;
+}
+
+// ../terminal/src/args.ts
+import path from "node:path";
+
+// ../terminal/src/formatting.ts
+var TERMINAL_MODEL_OPTIONS = [
+  {
+    id: DEFAULT_OPENPOND_CHAT_MODEL,
+    label: "OpenPond Chat",
+    description: "default OpenPond hosted chat model"
+  },
+  {
+    id: "deepseek-v4-flash",
+    label: "DeepSeek V4 Flash",
+    description: "fast OpenPond-compatible model"
+  }
+];
+var OPENAI_COMPATIBLE_CHAT_PROVIDER_IDS = [
+  "local-adapter",
+  "openai",
+  "xai",
+  "openrouter",
+  "deepseek",
+  "zai",
+  "moonshot",
+  "together",
+  "groq",
+  "fireworks",
+  "custom-openai-compatible"
+];
+var RUNNABLE_CHAT_PROVIDER_IDS = [
+  "openpond",
+  "codex",
+  ...OPENAI_COMPATIBLE_CHAT_PROVIDER_IDS
+];
+var RUNNABLE_CHAT_PROVIDER_ID_SET = new Set(
+  RUNNABLE_CHAT_PROVIDER_IDS
+);
+function normalizeTerminalProvider(value) {
+  const normalized = value?.trim();
+  if (!normalized) return null;
+  if (RUNNABLE_CHAT_PROVIDER_ID_SET.has(normalized)) {
+    return normalized;
+  }
+  return null;
+}
+function parseProviderModelSelection(value, currentProvider) {
+  const normalized = value?.trim();
+  if (!normalized) return { provider: null, model: null };
+  const slashIndex = normalized.indexOf("/");
+  if (slashIndex > 0) {
+    const provider = normalizeTerminalProvider(normalized.slice(0, slashIndex));
+    if (provider) {
+      return {
+        provider,
+        model: normalizeTerminalModel(normalized.slice(slashIndex + 1))
+      };
+    }
+  }
+  return {
+    provider: currentProvider,
+    model: normalizeTerminalModel(normalized)
+  };
+}
+function normalizeTerminalModel(value) {
+  const normalized = value?.trim();
+  if (!normalized) return null;
+  const lower = normalized.toLowerCase();
+  if (lower === "default" || lower === "openpond chat" || lower === DEFAULT_OPENPOND_CHAT_MODEL) {
+    return null;
+  }
+  return normalized;
+}
+function providerLabel(settings, provider) {
+  if (provider === "openpond") return "OpenPond";
+  return settings?.statuses[provider]?.displayName ?? (provider === "codex" ? "Codex" : provider);
+}
+function modelOptionFromProviderModel(model) {
+  const details = [
+    model.contextWindow ? `${Math.round(model.contextWindow / 1e3)}K context` : "",
+    model.capabilities.reasoning ? "reasoning" : "",
+    model.source
+  ].filter(Boolean);
+  return {
+    id: model.id,
+    label: model.displayName || model.id,
+    description: details.join(", ") || model.providerId
+  };
+}
+function modelOptionsForProvider(settings, provider) {
+  if (provider === "openpond") {
+    return TERMINAL_MODEL_OPTIONS.filter((option) => option.id === DEFAULT_OPENPOND_CHAT_MODEL);
+  }
+  if (provider === "codex") {
+    return [
+      { id: DEFAULT_CODEX_CHAT_MODEL, label: "GPT-5.6 Sol", description: "default Codex model" },
+      { id: "gpt-5.6-terra", label: "GPT-5.6 Terra", description: "Codex model" },
+      { id: "gpt-5.6-luna", label: "GPT-5.6 Luna", description: "Codex model" },
+      { id: "gpt-5.5", label: "GPT-5.5", description: "Codex model" },
+      { id: "gpt-5.4", label: "GPT-5.4", description: "Codex model" },
+      { id: "gpt-5.4-mini", label: "GPT-5.4 Mini", description: "Codex model" },
+      { id: "gpt-5.3-codex", label: "GPT-5.3 Codex", description: "Codex model" },
+      { id: "gpt-5.3-codex-spark", label: "GPT-5.3 Codex Spark", description: "Codex model" },
+      { id: "gpt-5.2", label: "GPT-5.2", description: "Codex model" }
+    ];
+  }
+  const cacheModels = settings?.modelCaches[provider]?.models ?? [];
+  const config = settings?.providers[provider];
+  const manualModels = [...config?.modelOverrides ?? [], config?.defaultModel].filter((value) => Boolean(value?.trim())).map((id) => ({ id, label: id, description: "manual" }));
+  const seen = /* @__PURE__ */ new Set();
+  const options = [];
+  for (const option of [...cacheModels.map(modelOptionFromProviderModel), ...manualModels]) {
+    if (!option.id || seen.has(option.id)) continue;
+    seen.add(option.id);
+    options.push(option);
+  }
+  return options;
+}
+function defaultModelId(settings, provider) {
+  const configDefault = settings?.providers[provider]?.defaultModel?.trim();
+  if (configDefault) return configDefault;
+  const statusDefault = settings?.statuses[provider]?.defaultModel?.trim();
+  if (statusDefault) return statusDefault;
+  const firstOption = modelOptionsForProvider(settings, provider)[0]?.id?.trim();
+  if (firstOption) return firstOption;
+  if (provider === "codex") return DEFAULT_CODEX_CHAT_MODEL;
+  if (provider === "openpond") return DEFAULT_OPENPOND_CHAT_MODEL;
+  return "";
+}
+function activeModelId(options, settings) {
+  const normalized = normalizeTerminalModel(options.model);
+  if (normalized) return normalized;
+  return defaultModelId(settings, options.provider);
+}
+function activeModelRef(options, settings) {
+  const modelId = activeModelId(options, settings);
+  return modelId ? { providerId: options.provider, modelId } : void 0;
+}
+function modelLabel(settings, options) {
+  const id = activeModelId(options, settings);
+  return modelOptionsForProvider(settings, options.provider).find((option) => option.id === id)?.label ?? (id || "No model");
+}
+function terminalSessionHeading(settings, options) {
+  const provider = providerLabel(settings, options.provider);
+  const productAndProvider = options.provider === "openpond" ? "OpenPond" : `OpenPond ${provider}`;
+  return `${productAndProvider} / ${modelLabel(settings, options)} ${options.cwd}`;
+}
+function formatProviderOptions(settings, activeProvider) {
+  const rows = RUNNABLE_CHAT_PROVIDER_IDS.map((provider) => {
+    const status = settings?.statuses[provider];
+    const marker = provider === activeProvider ? "*" : " ";
+    const state = status?.available ? "ready" : status?.credential.connected ? "configured" : status?.routing.localByok ? "needs-key" : "unavailable";
+    return `${marker} ${provider.padEnd(25)}  ${providerLabel(settings, provider)} - ${state}`;
+  });
+  return ["Providers:", ...rows].join("\n");
+}
+function formatModelOptions(settings, provider, model) {
+  const options = modelOptionsForProvider(settings, provider);
+  const active = activeModelId({ provider, model }, settings);
+  const displayOptions = active && !options.some((option) => option.id === active) ? [{ id: active, label: active, description: "manual" }, ...options] : options;
+  if (displayOptions.length === 0) {
+    return `No cached models for ${providerLabel(settings, provider)}. Configure a default model in Desktop settings.`;
+  }
+  const idWidth = Math.min(48, Math.max(...displayOptions.map((option) => option.id.length)));
+  return displayOptions.map((option) => {
+    const marker = option.id === active ? "*" : " ";
+    return `${marker} ${option.id.padEnd(idWidth)}  ${option.label} - ${option.description}`;
+  }).join("\n");
+}
+function resolveModelSelection(settings, provider, inputModel) {
+  const normalized = normalizeTerminalModel(inputModel);
+  if (!normalized) {
+    return {
+      changed: true,
+      model: null,
+      message: `Model reset to ${defaultModelId(settings, provider) || "provider default"}`
+    };
+  }
+  const options = modelOptionsForProvider(settings, provider);
+  const exact = options.find((option) => option.id === normalized);
+  if (exact) return { changed: true, model: exact.id, message: `Model set to ${exact.label}` };
+  const matches = options.filter(
+    (option) => `${option.id} ${option.label}`.toLowerCase().includes(normalized.toLowerCase())
+  );
+  if (matches.length === 1) {
+    return { changed: true, model: matches[0].id, message: `Model set to ${matches[0].label}` };
+  }
+  if (matches.length > 1) {
+    const idWidth = Math.min(48, Math.max(...matches.map((option) => option.id.length)));
+    return {
+      changed: false,
+      model: null,
+      message: [
+        `Model matches for ${normalized}:`,
+        ...matches.slice(0, 20).map((option) => `${option.id.padEnd(idWidth)}  ${option.label}`),
+        matches.length > 20 ? `... ${matches.length - 20} more` : ""
+      ].filter(Boolean).join("\n")
+    };
+  }
+  return { changed: true, model: normalized, message: `Model set to ${normalized}` };
+}
+function formatConnectedApps(payload) {
+  const baseUrl = payload?.account.baseUrl ?? payload?.account.activeProfile?.baseUrl ?? null;
+  const teamId = payload?.preferences.defaultTeamId ?? null;
+  const idWidth = Math.max(...CONNECTED_APP_CATALOG.map((app) => app.id.length));
+  const rows = CONNECTED_APP_CATALOG.map((app) => {
+    const url = buildConnectedAppInstallUrl({ appId: app.id, baseUrl, teamId });
+    return `${app.id.padEnd(idWidth)}  ${app.label} - ${app.description}
+${" ".repeat(idWidth + 2)}  ${url}`;
+  });
+  return ["Apps:", ...rows, "", "Use /install <app> to open setup."].join("\n");
+}
+function installAppOptions(query) {
+  const normalized = query.trim().toLowerCase();
+  return CONNECTED_APP_CATALOG.filter((app) => {
+    if (!normalized) return true;
+    return [app.id, app.label, app.shortLabel, app.category].some(
+      (value) => value.toLowerCase().includes(normalized)
+    );
+  }).map((app) => ({
+    name: `install:${app.id}`,
+    usage: `/install ${app.id}`,
+    description: `${app.label} - ${app.category}`,
+    submitText: `/install ${app.id}`
+  }));
+}
+function installAppQuery(text) {
+  const match = text.match(/^\/install(?:\s+([A-Za-z0-9_-]*))?$/);
+  return match ? match[1] ?? "" : null;
+}
+function shortSha(value) {
+  return value ? value.slice(0, 10) : "none";
+}
+function formatProfileStatus(profile) {
+  if (profile.mode === "none") return "No active OpenPond profile. Run `openpond init`.";
+  const git = profile.git;
+  const lines = [
+    `Profile: ${profile.activeProfile ?? "default"}`,
+    `State: ${profile.summary.state} - ${profile.summary.message}`,
+    `Repo: ${profile.repoPath}`,
+    `Source: ${profile.sourcePath ?? "missing"}`,
+    git ? `Git: ${git.branch ?? "detached"} ${shortSha(git.head)}${git.dirty ? " dirty" : ""}${git.upstream ? ` -> ${git.upstream}` : ""}` : "Git: not initialized",
+    profile.hosted?.sourceCommitSha ? `Hosted: ${profile.hosted.teamId ?? "team"} ${shortSha(profile.hosted.sourceCommitSha)}` : "Hosted: not pushed",
+    `Catalog: ${profile.catalog.actionCount} actions${profile.catalog.stale ? " stale" : ""}${profile.catalog.error ? ` (${profile.catalog.error})` : ""}`,
+    `Setup gate: ${profile.setupGate.status} (${profile.setupGate.blockingCount} blocking, ${profile.setupGate.optionalMissingCount} optional missing)`,
+    profile.summary.defaultAction ? `Default action: ${profile.summary.defaultAction}` : "Default action: none",
+    profile.lastCheck ? `Last check: ${profile.lastCheck.command} ${profile.lastCheck.status} at ${profile.lastCheck.checkedAt}` : "Last check: none",
+    profile.summary.checkStaleReason ? `Check stale: ${profile.summary.checkStaleReason}` : "",
+    profile.setupGate.blockingRequirements.length ? `Blocking setup: ${profile.setupGate.blockingRequirements.map(formatProfileSetupRequirement).join(", ")}` : "",
+    profile.error ? `Error: ${profile.error}` : ""
+  ];
+  return lines.filter(Boolean).join("\n");
+}
+function formatProfileDiff(profile) {
+  if (profile.mode === "none") return "No active OpenPond profile. Run `openpond init`.";
+  const diff = profile.diff;
+  const lines = [
+    diff.newAgents.length ? `New agents: ${diff.newAgents.join(", ")}` : "",
+    diff.changedAgents.length ? `Changed agents: ${diff.changedAgents.join(", ")}` : "",
+    diff.deletedAgents.length ? `Deleted agents: ${diff.deletedAgents.join(", ")}` : "",
+    diff.changedSkills.length ? `Changed skills: ${diff.changedSkills.join(", ")}` : "",
+    diff.changedActions.length ? `Changed actions: ${diff.changedActions.join(", ")}` : "",
+    diff.changedExtensions.length ? `Extensions: ${diff.changedExtensions.join(", ")}` : "",
+    diff.setupChanges.length ? `Setup: ${diff.setupChanges.join(", ")}` : "",
+    diff.envRequirementChanges.length ? `Env requirements: ${diff.envRequirementChanges.join(", ")}` : ""
+  ].filter(Boolean);
+  if (diff.files.length) {
+    lines.push(
+      "Files:",
+      ...diff.files.slice(0, 25).map((file) => `${file.status.padEnd(2)} ${file.path}`)
+    );
+    if (diff.files.length > 25) lines.push(`... ${diff.files.length - 25} more files`);
+  }
+  return lines.length ? lines.join("\n") : "No local profile diff.";
+}
+function formatProfileCatalog(profile) {
+  if (profile.mode === "none") return "No active OpenPond profile. Run `openpond init`.";
+  if (profile.actionCatalog.length === 0) return "No profile actions found. Run `openpond profile check build`.";
+  return profile.actionCatalog.map((action) => {
+    const label = action.label ?? action.name ?? action.id;
+    const description = action.description ? ` - ${action.description}` : "";
+    const setup = blockingSetupRequirementsForAction(profile, action.id);
+    const setupStatus = setup.length ? ` setup_required:${setup.map((requirement) => requirement.label).join(",")}` : "";
+    return `${action.id}  ${label}${description}${setupStatus}`;
+  }).join("\n");
+}
+function formatProfileAgents(profile, activeAgentId) {
+  if (profile.agents.length === 0) return "No profile agents found.";
+  const agentLines = profile.agents.map(
+    (agent) => `${agent.id === activeAgentId ? "*" : " "} ${agent.id}  ${agent.enabled ? "enabled" : "disabled"}  ${agent.path}`
+  );
+  const actionLines = profile.actionCatalog.map((action) => {
+    const setup = blockingSetupRequirementsForAction(profile, action.id);
+    const setupStatus = setup.length ? `  setup_required:${setup.map((requirement) => requirement.label).join(",")}` : "";
+    return `  /run ${action.id}  ${action.label ?? action.name ?? ""}${setupStatus}`.trimEnd();
+  });
+  return [...agentLines, actionLines.length ? "\nActions:" : "", ...actionLines].filter(Boolean).join("\n");
+}
+function blockingSetupRequirementsForAction(profile, actionId) {
+  return profile.setupGate.blockingRequirements.filter(
+    (requirement) => requirement.actionId === null || requirement.actionId === actionId
+  );
+}
+function formatProfileSetupRequirement(requirement) {
+  const prefix = requirement.actionId ? `${requirement.actionId}: ` : "";
+  return `${prefix}${requirement.label} (${requirement.status})`;
+}
+
+// ../terminal/src/args.ts
+var TerminalUsageError = class extends Error {
+  exitCode = 2;
+  constructor(message) {
+    super(message);
+    this.name = "TerminalUsageError";
+  }
+};
+function parseTerminalArgs(argv, defaultCwd = process.cwd()) {
+  const [command = "chat", ...rest] = argv;
+  const options = {
+    server: "http://127.0.0.1:17874",
+    provider: DEFAULT_CHAT_PROVIDER,
+    model: null,
+    cwd: defaultCwd,
+    project: null,
+    resume: null,
+    noServerStart: false,
+    message: null,
+    messageFile: null,
+    stdin: false,
+    nonInteractive: false,
+    json: false,
+    yes: false,
+    approvalPolicy: "on-request",
+    sandbox: "workspace-write",
+    timeoutSec: null,
+    maxOutputBytes: null
+  };
+  for (let i = 0; i < rest.length; i += 1) {
+    const arg = rest[i];
+    if (arg === "--server") options.server = rest[++i] ?? options.server;
+    else if (arg === "--provider") {
+      options.provider = normalizeTerminalProvider(rest[++i] ?? null) ?? options.provider;
+    } else if (arg === "--model") {
+      const selection = parseProviderModelSelection(rest[++i] ?? null, options.provider);
+      if (selection.provider) options.provider = selection.provider;
+      options.model = selection.model;
+    } else if (arg === "--cwd") {
+      options.cwd = path.resolve(rest[++i] ?? options.cwd);
+      options.cwdExplicit = true;
+    } else if (arg === "--project") {
+      options.project = rest[++i] ?? null;
+    } else if (arg === "--resume") {
+      options.resume = rest[++i] ?? null;
+    } else if (arg === "--no-server-start") {
+      options.noServerStart = true;
+    } else if (arg === "--message") {
+      options.message = readStringArg(rest, ++i, "message");
+    } else if (arg === "--message-file") {
+      options.messageFile = path.resolve(readStringArg(rest, ++i, "message-file"));
+    } else if (arg === "--stdin") {
+      const parsed = readOptionalBoolean(rest, i);
+      options.stdin = parsed.value;
+      i = parsed.index;
+    } else if (arg === "--non-interactive") {
+      const parsed = readOptionalBoolean(rest, i);
+      options.nonInteractive = parsed.value;
+      i = parsed.index;
+    } else if (arg === "--json") {
+      const parsed = readOptionalBoolean(rest, i);
+      options.json = parsed.value;
+      i = parsed.index;
+    } else if (arg === "--yes") {
+      const parsed = readOptionalBoolean(rest, i);
+      options.yes = parsed.value;
+      i = parsed.index;
+    } else if (arg === "--approval-policy") {
+      options.approvalPolicy = parseApprovalPolicy(readStringArg(rest, ++i, "approval-policy"));
+    } else if (arg === "--sandbox") {
+      options.sandbox = parseSandboxMode(readStringArg(rest, ++i, "sandbox"));
+    } else if (arg === "--timeout-sec") {
+      options.timeoutSec = parsePositiveInteger(readStringArg(rest, ++i, "timeout-sec"), "timeout-sec");
+    } else if (arg === "--max-output-bytes") {
+      options.maxOutputBytes = parsePositiveInteger(readStringArg(rest, ++i, "max-output-bytes"), "max-output-bytes");
+    } else if (arg.startsWith("-")) {
+      throw new TerminalUsageError(`unknown option ${arg}`);
+    }
+  }
+  return { command, options };
+}
+function shouldRunOneShotChat(options) {
+  return Boolean(options.nonInteractive || options.message || options.messageFile || options.stdin);
+}
+function resolveTerminalChatMode(options, streams) {
+  if (shouldRunOneShotChat(options)) return "one-shot";
+  if (!streams.inputIsTTY || !streams.outputIsTTY) return "line-mode";
+  return "interactive";
+}
+function readStringArg(args, index, label) {
+  const value = args[index];
+  if (!value || value.startsWith("--")) {
+    throw new TerminalUsageError(`${label} requires a value`);
+  }
+  return value;
+}
+function readOptionalBoolean(args, index) {
+  const next = args[index + 1];
+  if (next && isBooleanLiteral(next)) {
+    return { value: parseBooleanLiteral(next), index: index + 1 };
+  }
+  return { value: true, index };
+}
+function isBooleanLiteral(value) {
+  return /^(true|false|1|0|yes|no)$/i.test(value);
+}
+function parseBooleanLiteral(value) {
+  return /^(true|1|yes)$/i.test(value);
+}
+function parseApprovalPolicy(value) {
+  if (value === "on-request" || value === "never" || value === "on-failure" || value === "untrusted") {
+    return value;
+  }
+  throw new TerminalUsageError("approval-policy must be on-request, never, on-failure, or untrusted");
+}
+function parseSandboxMode(value) {
+  if (value === "read-only" || value === "workspace-write" || value === "danger-full-access") {
+    return value;
+  }
+  throw new TerminalUsageError("sandbox must be read-only, workspace-write, or danger-full-access");
+}
+function parsePositiveInteger(value, label) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new TerminalUsageError(`${label} must be a positive integer`);
+  }
+  return parsed;
+}
+
+// ../terminal/src/connection.ts
+import { spawn } from "node:child_process";
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path2 from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+var __dirname = path2.dirname(fileURLToPath(import.meta.url));
+var serverProcess = null;
+var stopServerPromise = null;
+function tokenFilePath() {
+  return path2.join(os.homedir(), ".openpond", "openpond-app", "token");
+}
+async function readToken() {
+  try {
+    return (await fs.readFile(tokenFilePath(), "utf8")).trim() || null;
+  } catch {
+    return null;
+  }
+}
+async function apiFetch(server, token, route, init) {
+  const headers = new Headers(init?.headers);
+  headers.set("Content-Type", "application/json");
+  headers.set("Authorization", `Bearer ${token}`);
+  const response = await fetch(`${server}${route}`, { ...init, headers });
+  if (!response.ok) {
+    const payload = await response.json().catch(() => ({}));
+    const message = payload && typeof payload === "object" && "error" in payload ? String(payload.error) : response.statusText;
+    throw new Error(message);
+  }
+  return await response.json();
+}
+async function health(server) {
+  try {
+    const response = await fetch(`${server}/health`);
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+function repoRoot() {
+  return path2.resolve(__dirname, "../../..");
+}
+async function startServer(onLog) {
+  const root = repoRoot();
+  const configuredRunner = process.env.OPENPOND_SERVER_RUNNER;
+  const configuredArgs = parseConfiguredServerArgs(process.env.OPENPOND_SERVER_ARGS);
+  const sourceMode = !configuredRunner && path2.basename(__dirname) === "src";
+  const serverEntry = path2.join(root, "apps", "server", sourceMode ? "src/index.ts" : "dist/index.js");
+  const command = configuredRunner ?? process.env.OPENPOND_NODE_BINARY ?? process.execPath;
+  const args = configuredRunner ? configuredArgs : sourceMode ? [createRequire(import.meta.url).resolve("tsx/cli"), serverEntry] : [serverEntry];
+  const child = spawn(command, args, {
+    cwd: process.env.OPENPOND_SERVER_CWD || root,
+    env: process.env,
+    detached: process.platform !== "win32"
+  });
+  serverProcess = child;
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const cleanup = () => {
+      clearTimeout(timer);
+      child.stdout.off("data", onStdout);
+      child.stderr.off("data", onStderr);
+      child.off("error", onError);
+      child.off("exit", onExit);
+    };
+    const finish = (url) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve(url);
+    };
+    const fail = (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(error);
+    };
+    const parser = createReadyLineParser("OPENPOND_APP_SERVER_READY ", (payload) => {
+      finish(payload.url || "http://127.0.0.1:17874");
+    });
+    const timer = setTimeout(() => fail(new Error("server start timed out")), 15e3);
+    const onStdout = (chunk) => {
+      try {
+        parser.push(chunk.toString("utf8"));
+      } catch (error) {
+        fail(error instanceof Error ? error : new Error(String(error)));
+      }
+    };
+    const onStderr = (chunk) => {
+      const text = chunk.toString("utf8").trim();
+      if (text) onLog(text);
+    };
+    const onError = (error) => fail(error);
+    const onExit = (code, signal) => {
+      parser.flush();
+      fail(new Error(`server exited with ${signal ? `signal ${signal}` : `code ${code ?? "unknown"}`}`));
+    };
+    child.stdout.on("data", onStdout);
+    child.stderr.on("data", onStderr);
+    child.once("error", onError);
+    child.once("exit", onExit);
+  });
+}
+function parseConfiguredServerArgs(value) {
+  if (!value) return [];
+  try {
+    const parsed = JSON.parse(value);
+    if (Array.isArray(parsed) && parsed.every((item) => typeof item === "string")) return parsed;
+  } catch {
+  }
+  throw new Error("OPENPOND_SERVER_ARGS must be a JSON string array");
+}
+async function ensureServer(options, onLog) {
+  let server = options.server;
+  if (!await health(server)) {
+    if (options.noServerStart) throw new Error(`No server is listening at ${server}`);
+    try {
+      server = await startServer(onLog);
+    } catch (error) {
+      await stopManagedServer();
+      throw error;
+    }
+  }
+  const token = await readToken();
+  if (!token) throw new Error("Missing OpenPond App capability token");
+  return { server, token };
+}
+function stopManagedServer() {
+  if (stopServerPromise) return stopServerPromise;
+  const child = serverProcess;
+  serverProcess = null;
+  if (!child) return Promise.resolve();
+  stopServerPromise = stopTerminalProcessTree(child).finally(() => {
+    stopServerPromise = null;
+  });
+  return stopServerPromise;
+}
+async function stopTerminalProcessTree(child, options = {}) {
+  terminateProcessTree(child, "SIGTERM");
+  if (await waitForExit(child, options.gracefulTimeoutMs ?? 5e3)) return;
+  terminateProcessTree(child, "SIGKILL");
+  if (!await waitForExit(child, options.killTimeoutMs ?? 2e3)) {
+    throw new Error(`terminal-owned server process tree ${child.pid ?? "unknown"} did not exit`);
+  }
+}
+function terminateProcessTree(child, signal) {
+  if (!child.pid || child.exitCode !== null) return;
+  if (process.platform === "win32") {
+    const args = ["/pid", String(child.pid), "/t", ...signal === "SIGKILL" ? ["/f"] : []];
+    spawn("taskkill", args, { stdio: "ignore", windowsHide: true }).unref();
+    return;
+  }
+  try {
+    process.kill(-child.pid, signal);
+  } catch {
+    child.kill(signal);
+  }
+}
+async function waitForExit(child, timeoutMs) {
+  if (child.exitCode !== null || child.signalCode !== null) return true;
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      child.off("exit", onExit);
+      resolve(false);
+    }, timeoutMs);
+    const onExit = () => {
+      clearTimeout(timer);
+      resolve(true);
+    };
+    child.once("exit", onExit);
+  });
+}
+
+// ../terminal/src/projects.ts
+function resolveTerminalProjectTarget(payload, query) {
+  const normalized = normalizeProjectQuery(query);
+  if (!normalized) return null;
+  const localProject = payload.localProjects.find((project) => matchesLocalProject(project, normalized));
+  if (localProject) {
+    return {
+      kind: "local_project",
+      id: localProject.id,
+      label: localProject.name,
+      session: {
+        appId: localProject.linkedOpenPondApp?.appId ?? null,
+        appName: localProject.linkedOpenPondApp?.appName ?? null,
+        workspaceKind: "local_project",
+        workspaceId: localProject.id,
+        workspaceName: localProject.name,
+        localProjectId: localProject.id,
+        cloudProjectId: localProject.linkedSandboxProject?.projectId ?? null,
+        cloudTeamId: localProject.linkedSandboxProject?.teamId ?? null,
+        cwd: localProject.workspacePath
+      }
+    };
+  }
+  const cloudProject = payload.cloudProjects.find((project) => matchesCloudProject(project, normalized));
+  if (cloudProject) {
+    return {
+      kind: "cloud_project",
+      id: cloudProject.id,
+      label: cloudProject.name,
+      provider: "openpond",
+      session: {
+        appId: null,
+        appName: null,
+        workspaceKind: "sandbox",
+        workspaceId: cloudProject.id,
+        workspaceName: cloudProject.name,
+        cloudProjectId: cloudProject.id,
+        cloudTeamId: cloudProject.teamId,
+        cwd: null
+      }
+    };
+  }
+  const app = payload.apps.find((candidate) => matchesApp(candidate, normalized));
+  if (app) {
+    return {
+      kind: "sandbox_app",
+      id: app.id,
+      label: app.name,
+      session: {
+        appId: app.id,
+        appName: app.name,
+        workspaceKind: "sandbox_app",
+        workspaceId: app.id,
+        workspaceName: app.name
+      }
+    };
+  }
+  return null;
+}
+function formatTerminalProjects(payload) {
+  const rows = [
+    ...payload.localProjects.map((project) => `local  ${project.id}  ${project.name}  ${project.workspacePath}`),
+    ...payload.cloudProjects.map((project) => `cloud  ${project.id}  ${project.name}${project.slug ? ` (${project.slug})` : ""}`),
+    ...payload.apps.map((app) => `app    ${app.id}  ${app.name}`)
+  ];
+  return rows.length ? rows.join("\n") : "No local projects, cloud projects, or OpenPond apps returned.";
+}
+function normalizeProjectQuery(value) {
+  return value?.trim().toLowerCase() ?? "";
+}
+function matchesLocalProject(project, query) {
+  return [project.id, project.name, project.path, project.workspacePath, project.repoPath ?? ""].some(
+    (value) => value.trim().toLowerCase() === query
+  );
+}
+function matchesCloudProject(project, query) {
+  return [project.id, project.name, project.slug ?? ""].some((value) => value.trim().toLowerCase() === query);
+}
+function matchesApp(app, query) {
+  return [app.id, app.name].some((value) => value.trim().toLowerCase() === query);
+}
+
+// ../terminal/src/session-state.ts
+import { realpath } from "node:fs/promises";
+import path3 from "node:path";
+function profileLabel(payload) {
+  if (payload.profile.mode !== "local") return "none";
+  const name = payload.profile.activeProfile ?? "local";
+  const state = payload.profile.summary.state === "ready" ? "" : `:${payload.profile.summary.state}`;
+  return `${name}${state}`;
+}
+function findTerminalSession(payload, sessionId) {
+  if (!sessionId) return null;
+  return [...payload.sessions, ...payload.codexHistorySessions ?? []].find(
+    (session) => session.id === sessionId
+  ) ?? null;
+}
+function resolveResumedTerminalSelection(payload, sessionId, selection) {
+  const resumed = findTerminalSession(payload, sessionId);
+  if (resumed?.modelRef) {
+    return {
+      provider: resumed.modelRef.providerId,
+      model: resumed.modelRef.modelId
+    };
+  }
+  if (resumed?.provider) {
+    return {
+      ...selection,
+      provider: resumed.provider
+    };
+  }
+  return selection;
+}
+async function createTerminalChatSession(connection, payload, options) {
+  const target = resolveTerminalProjectTarget(payload, options.project);
+  if (target && options.cwdExplicit) {
+    if (target.kind !== "local_project" || !target.session.cwd) {
+      throw new Error("--cwd can only be combined with a local --project target.");
+    }
+    await assertLocalProjectCwd(target.session.cwd, options.cwd);
+  }
+  const provider = target?.provider ?? options.provider;
+  const sessionOptions = { ...options, provider };
+  const targetSession = target ? {
+    ...target.session,
+    ...options.cwdExplicit ? { cwd: options.cwd } : {}
+  } : {
+    appId: options.project,
+    appName: null,
+    cwd: options.cwd
+  };
+  const metadata = {
+    ...targetSession.metadata ?? {},
+    ...options.headless ? {
+      openpondTerminalMode: "one-shot",
+      openpondTerminal: {
+        mode: "one-shot",
+        sandbox: options.sandbox ?? null
+      }
+    } : {}
+  };
+  const body = {
+    provider,
+    modelRef: activeModelRef(sessionOptions, payload.providers),
+    title: target?.label ? `${target.label} terminal` : "Terminal chat",
+    ...targetSession,
+    ...Object.keys(metadata).length > 0 ? { metadata } : {},
+    ...options.headless && (options.yes || options.approvalPolicy === "never") ? { openPondCommandAccessMode: "full-access" } : {}
+  };
+  if (typeof targetSession.cwd === "string" && targetSession.cwd) {
+    options.cwd = targetSession.cwd;
+  }
+  return apiFetch(connection.server, connection.token, "/v1/sessions", {
+    method: "POST",
+    body: JSON.stringify(body),
+    signal: connection.signal
+  });
+}
+async function ensureTerminalChatSession(connection, payload, options, requestedSessionId) {
+  const selection = resolveResumedTerminalSelection(payload, requestedSessionId, {
+    provider: options.provider,
+    model: options.model
+  });
+  if (requestedSessionId) {
+    if (options.cwdExplicit) {
+      throw new Error("--cwd cannot be combined with --resume; the resumed session workspace is authoritative.");
+    }
+    const resumed = findTerminalSession(payload, requestedSessionId);
+    if (resumed?.cwd) options.cwd = resumed.cwd;
+    return {
+      sessionId: requestedSessionId,
+      session: resumed,
+      ...selection
+    };
+  }
+  const session = await createTerminalChatSession(connection, payload, {
+    ...options,
+    ...selection
+  });
+  return {
+    sessionId: session.id,
+    session,
+    ...selection
+  };
+}
+async function ensureTerminalSessionWorkspaceReady(connection, session) {
+  if (!session || session.workspaceKind !== "sandbox" && session.workspaceKind !== "sandbox_template") {
+    return session;
+  }
+  const result = await apiFetch(
+    connection.server,
+    connection.token,
+    `/v1/sessions/${encodeURIComponent(session.id)}/workspace/ensure-ready`,
+    {
+      method: "POST",
+      body: JSON.stringify({ surface: "terminal" }),
+      signal: connection.signal
+    }
+  );
+  return result.session;
+}
+async function assertLocalProjectCwd(projectCwd, requestedCwd) {
+  const [projectRoot, requested] = await Promise.all([realpath(projectCwd), realpath(requestedCwd)]);
+  const relation = path3.relative(projectRoot, requested);
+  if (relation.startsWith("..") || path3.isAbsolute(relation)) {
+    throw new Error(`--cwd must be the selected local project or one of its subdirectories: ${projectRoot}`);
+  }
+}
+
+// ../terminal/src/permissions.ts
+var TERMINAL_PERMISSION_QUESTION_CHOICES = [
+  { name: "yes", usage: "yes", description: "approve this command", submitText: "yes" },
+  { name: "session", usage: "session", description: "approve this command family", submitText: "session" },
+  { name: "no", usage: "no", description: "deny this command", submitText: "no" },
+  { name: "skip", usage: "skip", description: "cancel this command request", submitText: "skip" }
+];
+function parseTerminalPermissionChoice(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (normalized === "yes" || normalized === "y" || normalized === "approve") return "yes";
+  if (normalized === "session" || normalized === "s") return "session";
+  if (normalized === "no" || normalized === "n" || normalized === "deny") return "no";
+  if (normalized === "skip" || normalized === "cancel") return "skip";
+  return null;
+}
+function terminalPermissionDecision(choice) {
+  if (choice === "yes") return "accept";
+  if (choice === "session") return "acceptForSession";
+  if (choice === "skip") return "cancel";
+  return "decline";
+}
+function parseTerminalPermissionMode(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (!normalized) return null;
+  if (normalized === "full" || normalized === "full-access" || normalized === "full_access") {
+    return "full-access";
+  }
+  const parsed = OpenPondCommandAccessModeSchema.safeParse(normalized);
+  return parsed.success ? parsed.data : null;
+}
+function formatTerminalPermissionMode(mode) {
+  if (mode === "full-access") return "Full access";
+  if (mode === "disabled") return "Disabled";
+  return "Ask";
+}
+function latestPendingCommandApproval(payload, sessionId) {
+  if (!payload || !sessionId) return null;
+  return (payload.approvals ?? []).filter(
+    (approval) => approval.kind === "command" && approval.status === "pending" && approval.sessionId === sessionId
+  ).sort((left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt))[0] ?? null;
+}
+function commandApprovalFromRuntimeEvent(event) {
+  if (event.name !== "approval.requested") return null;
+  const parsed = ApprovalSchema.safeParse(event.data);
+  if (!parsed.success || parsed.data.kind !== "command" || parsed.data.status !== "pending") return null;
+  return parsed.data;
+}
+function commandApprovalIdFromResolvedEvent(event) {
+  if (event.name !== "approval.resolved") return null;
+  const data = event.data && typeof event.data === "object" && !Array.isArray(event.data) ? event.data : null;
+  const value = data?.approvalId ?? data?.approval_id ?? data?.id;
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function commandAccessModeForSession(payload, sessionId) {
+  const session = payload?.sessions.find((candidate) => candidate.id === sessionId) ?? payload?.codexHistorySessions?.find((candidate) => candidate.id === sessionId) ?? null;
+  return session?.openPondCommandAccessMode ?? payload?.preferences?.openPondCommandAccessMode ?? DEFAULT_OPENPOND_COMMAND_ACCESS_MODE;
+}
+function formatTerminalPermissionsSummary(mode) {
+  return [
+    `Command access: ${formatTerminalPermissionMode(mode)}`,
+    "Use /permissions ask or /permissions full-access to update this chat.",
+    "When a command approval is pending, /permissions opens yes/session/no/skip choices."
+  ].join("\n");
+}
+function formatTerminalCommandApprovalQuestion(approval) {
+  const detail = commandApprovalDetail(approval);
+  const rows = [
+    "Command approval",
+    `command: ${detail.command ?? approval.title}`,
+    detail.cwd ? `cwd: ${detail.cwd}` : null,
+    detail.risk ? `risk: ${detail.risk}` : null,
+    detail.timeoutSeconds ? `timeout: ${detail.timeoutSeconds}s` : null,
+    detail.familyLabel ? `session approval family: ${detail.familyLabel}` : null,
+    "Choose: yes, session, no, or skip."
+  ];
+  return rows.filter(Boolean).join("\n");
+}
+function commandApprovalDetail(approval) {
+  try {
+    const parsed = JSON.parse(approval.detail);
+    const family = parsed.sessionApprovalFamily && typeof parsed.sessionApprovalFamily === "object" && !Array.isArray(parsed.sessionApprovalFamily) ? parsed.sessionApprovalFamily : null;
+    return {
+      command: stringValue2(parsed.command),
+      cwd: stringValue2(parsed.cwd),
+      risk: stringValue2(parsed.risk),
+      timeoutSeconds: typeof parsed.timeoutSeconds === "number" ? parsed.timeoutSeconds : null,
+      familyLabel: stringValue2(family?.label)
+    };
+  } catch {
+    return {
+      command: null,
+      cwd: null,
+      risk: null,
+      timeoutSeconds: null,
+      familyLabel: null
+    };
+  }
+}
+function stringValue2(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
+// ../terminal/src/command-handlers.ts
+async function handleTerminalSlashCommand(command, context) {
+  const connection = context.getConnection();
+  if (!connection) return;
+  if (command.type === "exit") {
+    context.requestExit();
+    return;
+  }
+  if (command.type === "clear") {
+    context.clearTranscript();
+    context.render();
+    return;
+  }
+  if (command.type === "help") {
+    context.addItem(systemItem(helpText()));
+    return;
+  }
+  if (command.type === "projects") {
+    const latest = await context.refreshBootstrap();
+    context.addItem(systemItem(formatTerminalProjects(latest)));
+    return;
+  }
+  if (command.type === "providers") {
+    const latest = context.getPayload() ?? await context.refreshBootstrap();
+    context.addItem(systemItem(formatProviderOptions(latest.providers, context.options.provider)));
+    return;
+  }
+  if (command.type === "provider") {
+    const latest = context.getPayload() ?? await context.refreshBootstrap();
+    if (!command.id) {
+      context.addItem(systemItem(formatProviderOptions(latest.providers, context.options.provider)));
+      return;
+    }
+    const provider = normalizeTerminalProvider(command.id);
+    if (!provider) {
+      context.addItem(systemItem(`Unknown provider: ${command.id}
+
+${formatProviderOptions(latest.providers, context.options.provider)}`, "warning"));
+      return;
+    }
+    context.options.provider = provider;
+    context.options.model = null;
+    context.addItem(systemItem(`Provider set to ${providerLabel(latest.providers, provider)} / ${modelLabel(latest.providers, context.options)}`));
+    context.render();
+    return;
+  }
+  if (command.type === "apps") {
+    const latest = context.getPayload() ?? await context.refreshBootstrap();
+    context.addItem(systemItem(formatConnectedApps(latest)));
+    return;
+  }
+  if (command.type === "install") {
+    const app = connectedAppById(command.id);
+    if (!app) {
+      context.addItem(systemItem(`Unknown app: ${command.id}
+
+${formatConnectedApps(context.getPayload())}`, "warning"));
+      return;
+    }
+    const latest = context.getPayload() ?? await context.refreshBootstrap();
+    const url = buildConnectedAppInstallUrl({
+      appId: app.id,
+      baseUrl: latest.account.baseUrl ?? latest.account.activeProfile?.baseUrl ?? null,
+      teamId: latest.preferences.defaultTeamId ?? null
+    });
+    context.openUrl(url);
+    context.addItem(systemItem(`Opened ${app.label} setup:
+${url}`));
+    return;
+  }
+  if (command.type === "project") {
+    if (!command.id) {
+      context.addItem(systemItem("Usage: /project <id>", "warning"));
+      return;
+    }
+    const latest = context.getPayload() ?? await context.refreshBootstrap();
+    const target = resolveTerminalProjectTarget(latest, command.id);
+    if (!target) {
+      context.addItem(systemItem(`Project not found: ${command.id}
+
+${formatTerminalProjects(latest)}`, "warning"));
+      return;
+    }
+    const nextOptions = {
+      ...context.options,
+      project: target.id,
+      provider: target.provider ?? context.options.provider,
+      model: target.provider ? null : context.options.model
+    };
+    await createAndActivateSession(
+      context,
+      () => createTerminalChatSession(connection, latest, nextOptions)
+    );
+    context.options.project = nextOptions.project;
+    context.options.provider = nextOptions.provider;
+    context.options.model = nextOptions.model;
+    context.options.cwd = nextOptions.cwd;
+    context.addItem(systemItem(`Project set to ${target.kind}: ${target.label}`));
+    context.render();
+    return;
+  }
+  if (command.type === "model") {
+    const latest = context.getPayload() ?? await context.refreshBootstrap();
+    if (!command.id) {
+      context.addItem(systemItem(formatModelOptions(latest.providers, context.options.provider, context.options.model)));
+      return;
+    }
+    const selection = parseProviderModelSelection(command.id, context.options.provider);
+    if (selection.provider) {
+      context.options.provider = selection.provider;
+    }
+    const resolved = resolveModelSelection(
+      latest.providers,
+      context.options.provider,
+      selection.model ?? "default"
+    );
+    if (resolved.changed) context.options.model = resolved.model;
+    context.addItem(systemItem(`${providerLabel(latest.providers, context.options.provider)} / ${resolved.message}`));
+    context.render();
+    return;
+  }
+  if (command.type === "permissions") {
+    await handlePermissionsCommand(command.args, context, connection);
+    return;
+  }
+  if (command.type === "agents") {
+    const latest = await context.refreshBootstrap();
+    context.addItem(systemItem(formatProfileAgents(latest.profile, context.getActiveAgentId())));
+    return;
+  }
+  if (command.type === "agent") {
+    const latest = await context.refreshBootstrap();
+    const agent = latest.profile.agents.find((candidate) => candidate.id === command.id);
+    if (!agent) {
+      context.addItem(systemItem(`Profile agent not found: ${command.id}`, "warning"));
+      return;
+    }
+    context.setActiveAgentId(agent.id);
+    context.addItem(systemItem(`Agent set to ${agent.id}`));
+    context.render();
+    return;
+  }
+  if (command.type === "profile") {
+    await handleProfileCommand(command.args, context, connection);
+    return;
+  }
+  if (command.type === "run") {
+    if (!command.action) {
+      context.addItem(systemItem("Usage: /run <action> [json]", "warning"));
+      return;
+    }
+    const latest = await context.refreshBootstrap();
+    const catalogAction = latest.profile.actionCatalog.find((action) => action.id === command.action);
+    if (!catalogAction) {
+      context.addItem(systemItem(`Profile action not found: ${command.action}. Run /profile catalog.`, "warning"));
+      return;
+    }
+    const blockingSetup = blockingSetupRequirementsForAction(latest.profile, command.action);
+    if (blockingSetup.length > 0) {
+      context.addItem(
+        systemItem(
+          [
+            "agent_source_setup_required",
+            `Profile action ${command.action} has unresolved required setup.`,
+            `Missing setup: ${blockingSetup.map((requirement) => requirement.label).join(", ")}`
+          ].join("\n"),
+          "warning"
+        )
+      );
+      return;
+    }
+    const result = await apiFetch(connection.server, connection.token, "/v1/profile/run", {
+      method: "POST",
+      body: JSON.stringify({ action: command.action, input: command.input })
+    });
+    context.addItem(systemItem([result.stdout.trim(), result.stderr.trim()].filter(Boolean).join("\n") || `${result.action} completed`));
+    return;
+  }
+  if (command.type === "settings") {
+    await handleSettingsCommand(command.args, context, connection);
+    return;
+  }
+  if (command.type === "logs") {
+    const latest = await context.refreshBootstrap();
+    const lines = latest.events.slice(-20).map((event) => `${event.timestamp} ${event.name} ${event.output ?? event.error ?? ""}`.trim());
+    context.addItem(systemItem(lines.join("\n") || "No recent events."));
+    return;
+  }
+  if (command.type === "compact") {
+    const activeSessionId = context.getActiveSessionId();
+    if (!activeSessionId) return;
+    await apiFetch(connection.server, connection.token, `/v1/sessions/${activeSessionId}/compact`, {
+      method: "POST",
+      body: JSON.stringify({
+        reason: "manual",
+        model: activeModelId(context.options, context.getPayload()?.providers),
+        modelRef: activeModelRef(context.options, context.getPayload()?.providers)
+      })
+    });
+    context.addItem(systemItem("Compaction started."));
+    return;
+  }
+  if (command.type === "hooks") {
+    context.addItem(systemItem("Hooks are registered in the shared local runtime; destructive hooks are disabled by default."));
+    return;
+  }
+  if (command.type === "start") {
+    const latest = context.getPayload() ?? await context.refreshBootstrap();
+    const session = await createAndActivateSession(
+      context,
+      () => createTerminalChatSession(connection, latest, context.options)
+    );
+    context.addItem(systemItem(`Started ${session.id}`));
+    context.render();
+    return;
+  }
+  context.addItem(systemItem(`Unknown command: ${command.command}`, "warning"));
+}
+async function createAndActivateSession(context, create) {
+  if (context.switchSession) return context.switchSession(create);
+  const session = await create();
+  context.setActiveSessionId(session.id);
+  return session;
+}
+async function handlePermissionsCommand(args, context, connection) {
+  const latest = await context.refreshBootstrap();
+  const activeSessionId = context.getActiveSessionId();
+  const pendingApproval = context.getPendingCommandApproval?.() ?? latestPendingCommandApproval(latest, activeSessionId);
+  const first = args[0] ?? null;
+  const choice = parseTerminalPermissionChoice(first);
+  if (choice) {
+    if (!pendingApproval) {
+      context.addItem(systemItem("No command approval is pending.", "warning"));
+      return;
+    }
+    await resolveTerminalCommandApproval(connection, pendingApproval.id, choice);
+    context.addItem(systemItem(`Command approval resolved: ${choice}.`));
+    return;
+  }
+  if (pendingApproval && !first) {
+    if (context.openCommandApprovalQuestion) {
+      context.openCommandApprovalQuestion(pendingApproval);
+    } else {
+      context.addItem(systemItem(formatTerminalCommandApprovalQuestion(pendingApproval), "warning"));
+    }
+    return;
+  }
+  const mode = parseTerminalPermissionMode(first);
+  if (mode) {
+    if (!activeSessionId) {
+      context.addItem(systemItem("No active session.", "warning"));
+      return;
+    }
+    await patchTerminalSessionCommandAccess(connection, activeSessionId, mode);
+    await context.refreshBootstrap();
+    context.addItem(systemItem(`Command access set to ${formatTerminalPermissionMode(mode)}.`));
+    return;
+  }
+  if (first) {
+    context.addItem(
+      systemItem("Usage: /permissions [ask|full-access|yes|session|no|skip]", "warning")
+    );
+    return;
+  }
+  context.addItem(systemItem(formatTerminalPermissionsSummary(commandAccessModeForSession(latest, activeSessionId))));
+}
+async function resolveTerminalCommandApproval(connection, approvalId, choice) {
+  return apiFetch(
+    connection.server,
+    connection.token,
+    `/v1/approvals/${encodeURIComponent(approvalId)}`,
+    {
+      method: "POST",
+      body: JSON.stringify({ decision: terminalPermissionDecision(choice) })
+    }
+  );
+}
+async function patchTerminalSessionCommandAccess(connection, sessionId, mode) {
+  await apiFetch(connection.server, connection.token, `/v1/sessions/${encodeURIComponent(sessionId)}`, {
+    method: "PATCH",
+    body: JSON.stringify({ openPondCommandAccessMode: mode })
+  });
+}
+async function handleSettingsCommand(args, context, connection) {
+  const latest = context.getPayload() ?? await context.refreshBootstrap();
+  const subcommand = args[0] ?? "show";
+  if (subcommand === "show") {
+    context.addItem(systemItem(formatTerminalSettings(latest)));
+    return;
+  }
+  if (subcommand !== "goal-storage") {
+    context.addItem(systemItem("Usage: /settings [goal-storage global|workspace]", "warning"));
+    return;
+  }
+  const location = args[1];
+  if (location !== "global" && location !== "workspace") {
+    context.addItem(systemItem("Usage: /settings goal-storage global|workspace", "warning"));
+    return;
+  }
+  const updated = await apiFetch(connection.server, connection.token, "/v1/preferences", {
+    method: "PATCH",
+    body: JSON.stringify({ goalStorageLocation: location })
+  });
+  context.setPayload(updated);
+  context.addItem(systemItem(`Goal storage set to ${goalStorageLabel(updated.preferences.goalStorageLocation)}.`));
+}
+function formatTerminalSettings(payload) {
+  return [
+    "Settings:",
+    `Goal storage: ${goalStorageLabel(payload.preferences.goalStorageLocation)}`,
+    "",
+    "Change it with /settings goal-storage global or /settings goal-storage workspace."
+  ].join("\n");
+}
+function goalStorageLabel(location) {
+  return location === "workspace" ? ".openpond/goals in the working directory" : "~/.openpond/goals";
+}
+async function handleProfileCommand(args, context, connection) {
+  const subcommand = args[0] ?? "current";
+  if (subcommand === "init") {
+    const profileState = await apiFetch(connection.server, connection.token, "/v1/profile/init", {
+      method: "POST",
+      body: JSON.stringify({ path: args[1] })
+    });
+    await context.refreshBootstrap();
+    context.addItem(systemItem(JSON.stringify(profileState, null, 2)));
+    return;
+  }
+  if (subcommand === "load") {
+    if (!args[1]) {
+      context.addItem(systemItem("Usage: /profile load <path> [profile]", "warning"));
+      return;
+    }
+    const profileState = await apiFetch(connection.server, connection.token, "/v1/profile/load", {
+      method: "POST",
+      body: JSON.stringify({ path: args[1], profile: args[2] })
+    });
+    await context.refreshBootstrap();
+    context.addItem(systemItem(JSON.stringify(profileState, null, 2)));
+    return;
+  }
+  if (subcommand === "check") {
+    const profileState = await apiFetch(connection.server, connection.token, "/v1/profile/check", {
+      method: "POST",
+      body: JSON.stringify({ kind: args[1] ?? "all" })
+    });
+    await context.refreshBootstrap();
+    context.addItem(systemItem(formatProfileStatus(profileState)));
+    return;
+  }
+  if (subcommand === "commit") {
+    const message = args.slice(1).join(" ").trim() || void 0;
+    const result = await apiFetch(connection.server, connection.token, "/v1/profile/commit", {
+      method: "POST",
+      body: JSON.stringify({ message })
+    });
+    await context.refreshBootstrap();
+    context.addItem(systemItem(JSON.stringify(result, null, 2)));
+    return;
+  }
+  if (subcommand === "push") {
+    const teamId = args[1];
+    if (!teamId) {
+      context.addItem(systemItem("Usage: /profile push <teamId>", "warning"));
+      return;
+    }
+    const result = await apiFetch(connection.server, connection.token, "/v1/profile/push", {
+      method: "POST",
+      body: JSON.stringify({ teamId, ensureHosted: true })
+    });
+    const latest2 = await context.refreshBootstrap();
+    context.addItem(systemItem([`Pushed profile to ${teamId}.`, formatProfileStatus(latest2.profile), JSON.stringify(result, null, 2)].join("\n\n")));
+    return;
+  }
+  const latest = await context.refreshBootstrap();
+  if (latest.profile.mode === "none") {
+    context.addItem(systemItem("No active OpenPond profile. Run `openpond init`.", "warning"));
+    return;
+  }
+  if (subcommand === "diff") {
+    context.addItem(systemItem(formatProfileDiff(latest.profile)));
+    return;
+  }
+  if (subcommand === "catalog" || subcommand === "actions") {
+    context.addItem(systemItem(formatProfileCatalog(latest.profile)));
+    return;
+  }
+  context.addItem(systemItem(formatProfileStatus(latest.profile)));
+}
+
+// ../terminal/src/direct-command.ts
+var TERMINAL_SELECT_PROJECT_MESSAGE = "Select a project to use this.";
+function isTerminalDirectCommandSession(session) {
+  if (!session || session.provider === "codex") return false;
+  if (session.workspaceKind === "local_project") return Boolean(session.cwd?.trim());
+  if (session.workspaceKind === "sandbox" || session.workspaceKind === "sandbox_template" || session.workspaceKind === "sandbox_app") {
+    return Boolean(session.workspaceId);
+  }
+  return false;
+}
+function terminalDirectCommandBlockedReason(session) {
+  return isTerminalDirectCommandSession(session) ? null : TERMINAL_SELECT_PROJECT_MESSAGE;
+}
+async function runTerminalDirectCommand(connection, session, command) {
+  return apiFetch(
+    connection.server,
+    connection.token,
+    `/v1/sessions/${encodeURIComponent(session.id)}/commands`,
+    {
+      method: "POST",
+      body: JSON.stringify({
+        command,
+        cwd: session.cwd
+      })
+    }
+  );
+}
+
+// ../terminal/src/events.ts
+function terminalEventStreamRequest(server, token, signal, options = {}) {
+  const headers = new Headers();
+  headers.set("Accept", "text/event-stream");
+  headers.set("Authorization", `Bearer ${token}`);
+  const url = new URL(`${server.replace(/\/$/, "")}/v1/events`);
+  if ((options.afterSequence ?? 0) > 0) url.searchParams.set("afterSequence", String(options.afterSequence));
+  if (options.sessionId) url.searchParams.set("sessionId", options.sessionId);
+  return {
+    url: url.toString(),
+    init: { headers, signal }
+  };
+}
+function terminalEventReconnectDelayMs(attempt) {
+  return Math.min(500 * 2 ** Math.max(0, attempt), 1e4);
+}
+async function readTerminalEventStream(response, activeSessionId, onEvent, signal, onReady) {
+  validateTerminalEventResponse(response);
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  while (!signal?.aborted) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    let boundary = buffer.indexOf("\n\n");
+    while (boundary >= 0) {
+      const raw = buffer.slice(0, boundary);
+      buffer = buffer.slice(boundary + 2);
+      handleTerminalEventFrame(raw, activeSessionId, onEvent, onReady);
+      boundary = buffer.indexOf("\n\n");
+    }
+  }
+}
+function validateTerminalEventResponse(response) {
+  if (!response.ok) {
+    throw new Error(`event stream failed: ${response.status} ${response.statusText || "HTTP error"}`);
+  }
+  if (!response.body) {
+    throw new Error("event stream did not return a response body");
+  }
+}
+async function openTerminalEvents(input2) {
+  const controller = new AbortController();
+  const fetchImpl = input2.fetchImpl ?? fetch;
+  const reconnectDelayMs = input2.reconnectDelayMs ?? terminalEventReconnectDelayMs;
+  const initialReady = createDeferred();
+  let sessionReady = initialReady;
+  let requestedSessionId = input2.activeSessionId();
+  let generation = 0;
+  let readyGeneration = -1;
+  let activeRequest = null;
+  controller.ready = initialReady.promise;
+  controller.switchSession = (sessionId) => {
+    if (controller.signal.aborted) return Promise.reject(new Error("event stream is closed"));
+    if (sessionId === requestedSessionId && readyGeneration === generation) return Promise.resolve();
+    requestedSessionId = sessionId;
+    generation += 1;
+    sessionReady.reject(new Error("event stream session changed before becoming ready"));
+    sessionReady = createDeferred();
+    activeRequest?.abort();
+    return sessionReady.promise;
+  };
+  controller.signal.addEventListener(
+    "abort",
+    () => {
+      activeRequest?.abort();
+      const error = new Error("event stream aborted before connecting");
+      initialReady.reject(error);
+      sessionReady.reject(error);
+    },
+    { once: true }
+  );
+  controller.ready.catch(() => void 0);
+  let lastAppliedSequence = 0;
+  void (async () => {
+    let attempt = 0;
+    while (!controller.signal.aborted) {
+      const requestGeneration = generation;
+      const requestSessionId = requestedSessionId;
+      const requestController = new AbortController();
+      activeRequest = requestController;
+      input2.onStatus?.({ state: "connecting", attempt });
+      try {
+        const request = terminalEventStreamRequest(input2.server, input2.token, requestController.signal, {
+          afterSequence: lastAppliedSequence,
+          sessionId: requestSessionId
+        });
+        const response = await fetchImpl(request.url, request.init);
+        validateTerminalEventResponse(response);
+        input2.onStatus?.({ state: "connected", attempt });
+        await readTerminalEventStream(
+          response,
+          () => requestSessionId,
+          (event) => {
+            const sequence = event.sequence ?? 0;
+            if (sequence > 0 && sequence <= lastAppliedSequence) return;
+            if (sequence > 0) lastAppliedSequence = sequence;
+            input2.onEvent(event);
+          },
+          requestController.signal,
+          () => {
+            if (requestGeneration !== generation) return;
+            readyGeneration = requestGeneration;
+            initialReady.resolve();
+            sessionReady.resolve();
+          }
+        );
+        if (controller.signal.aborted) break;
+        if (requestGeneration !== generation) {
+          attempt = 0;
+          continue;
+        }
+        throw new Error("event stream ended");
+      } catch (error) {
+        if (controller.signal.aborted) break;
+        if (requestGeneration !== generation) {
+          attempt = 0;
+          continue;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        const nextDelayMs = reconnectDelayMs(attempt);
+        input2.onStatus?.({ state: "disconnected", attempt, message, nextDelayMs });
+        await abortableDelay(nextDelayMs, requestController.signal);
+        if (requestGeneration !== generation) {
+          attempt = 0;
+          continue;
+        }
+        attempt += 1;
+      } finally {
+        if (activeRequest === requestController) activeRequest = null;
+      }
+    }
+  })().catch(() => void 0);
+  return controller;
+}
+function createDeferred() {
+  let settled = false;
+  let resolvePromise;
+  let rejectPromise;
+  const promise = new Promise((resolve, reject) => {
+    resolvePromise = resolve;
+    rejectPromise = reject;
+  });
+  promise.catch(() => void 0);
+  return {
+    promise,
+    resolve() {
+      if (settled) return;
+      settled = true;
+      resolvePromise();
+    },
+    reject(error) {
+      if (settled) return;
+      settled = true;
+      rejectPromise(error);
+    }
+  };
+}
+function handleTerminalEventFrame(raw, activeSessionId, onEvent, onReady) {
+  const eventName = raw.split("\n").find((line) => line.startsWith("event: "))?.slice(7);
+  if (eventName === "ready") {
+    onReady?.();
+    return;
+  }
+  const dataLine = raw.split("\n").find((line) => line.startsWith("data: "));
+  if (!dataLine) return;
+  try {
+    const event = JSON.parse(dataLine.slice(6));
+    if (typeof event.name !== "string") return;
+    if (!event.sessionId || event.sessionId === activeSessionId()) onEvent(event);
+  } catch {
+  }
+}
+async function abortableDelay(ms, signal) {
+  if (ms <= 0 || signal.aborted) return;
+  await new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    signal.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        resolve();
+      },
+      { once: true }
+    );
+  });
+}
+
+// ../terminal/src/interactive-state.ts
+var PENDING_TURN = "<submitting>";
+function createTerminalInteractiveState(initialSessionId = null) {
+  const activeTurns = /* @__PURE__ */ new Map();
+  let activeSessionId = initialSessionId;
+  let ready = false;
+  let switching = false;
+  let stopping = false;
+  function snapshot() {
+    const activeTurnId = activeSessionId ? activeTurns.get(activeSessionId) ?? null : null;
+    const phase = stopping ? "stopping" : switching ? "switching" : !ready ? "starting" : activeTurnId ? "running" : "ready";
+    return {
+      phase,
+      activeSessionId,
+      activeTurnId: activeTurnId === PENDING_TURN ? null : activeTurnId
+    };
+  }
+  function blocked(action) {
+    const state = snapshot();
+    if (state.phase === "ready") return { ok: true };
+    const message = state.phase === "starting" ? `Wait for terminal startup and event recovery before ${action}.` : state.phase === "running" ? `A turn is already running. Interrupt or wait for it before ${action}.` : state.phase === "switching" ? `Wait for the session switch to finish before ${action}.` : `The terminal is stopping and cannot ${action}.`;
+    return { ok: false, message };
+  }
+  function completeStartup(sessionId) {
+    if (stopping) return;
+    activeSessionId = sessionId;
+    ready = true;
+  }
+  function beginTurn(sessionId) {
+    const allowed = blocked("starting another turn");
+    if (!allowed.ok) return allowed;
+    if (sessionId !== activeSessionId) return { ok: false, message: "The active session changed; retry the turn." };
+    activeTurns.set(sessionId, PENDING_TURN);
+    return { ok: true };
+  }
+  function failTurnSubmission(sessionId) {
+    if (activeTurns.get(sessionId) === PENDING_TURN) activeTurns.delete(sessionId);
+  }
+  function applyRuntimeEvent(event) {
+    const sessionId = event.sessionId ?? activeSessionId;
+    if (!sessionId) return;
+    if (event.name === "turn.started") {
+      activeTurns.set(sessionId, event.turnId ?? PENDING_TURN);
+      return;
+    }
+    if (event.name !== "turn.completed" && event.name !== "turn.failed" && event.name !== "turn.interrupted") return;
+    const activeTurnId = activeTurns.get(sessionId);
+    if (!activeTurnId) return;
+    if (activeTurnId !== PENDING_TURN && event.turnId && event.turnId !== activeTurnId) return;
+    activeTurns.delete(sessionId);
+  }
+  function beginSessionSwitch() {
+    const allowed = blocked("switching sessions");
+    if (!allowed.ok) return allowed;
+    switching = true;
+    return { ok: true };
+  }
+  function completeSessionSwitch(sessionId) {
+    activeSessionId = sessionId;
+    switching = false;
+  }
+  function failSessionSwitch() {
+    switching = false;
+  }
+  function beginStopping() {
+    stopping = true;
+  }
+  return {
+    applyRuntimeEvent,
+    beginSessionSwitch,
+    beginStopping,
+    beginTurn,
+    blocked,
+    completeSessionSwitch,
+    completeStartup,
+    failSessionSwitch,
+    failTurnSubmission,
+    snapshot
+  };
+}
+
+// ../terminal/src/task-scheduler.ts
+function createSerialTaskScheduler() {
+  let tail = Promise.resolve();
+  return {
+    run(task) {
+      const runTask = () => Promise.resolve().then(task);
+      const next = tail.then(runTask, runTask);
+      tail = next.catch(() => void 0);
+      return next;
+    }
+  };
+}
+function createLatestWinsTaskScheduler(options = {}) {
+  const delayMs = Math.max(0, options.delayMs ?? 16);
+  const setTimer = options.setTimer ?? setTimeout;
+  const clearTimer = options.clearTimer ?? clearTimeout;
+  let latestTask = null;
+  let timer = null;
+  function clearPendingTimer() {
+    if (!timer) return;
+    clearTimer(timer);
+    timer = null;
+  }
+  function runLatest() {
+    timer = null;
+    const task = latestTask;
+    latestTask = null;
+    task?.();
+  }
+  return {
+    request(task) {
+      latestTask = task;
+      if (timer) return;
+      timer = setTimer(runLatest, delayMs);
+    },
+    flush() {
+      clearPendingTimer();
+      runLatest();
+    },
+    cancel() {
+      latestTask = null;
+      clearPendingTimer();
+    }
+  };
+}
+
+// ../terminal/src/exit-latch.ts
+function createTerminalExitLatch() {
+  let requested = false;
+  let resolveWait = null;
+  return {
+    get requested() {
+      return requested;
+    },
+    request() {
+      if (requested) return;
+      requested = true;
+      resolveWait?.();
+    },
+    wait() {
+      if (requested) return Promise.resolve();
+      return new Promise((resolve) => {
+        resolveWait = resolve;
+        if (requested) resolve();
+      });
+    }
+  };
+}
+
+// ../terminal/src/one-shot-chat.ts
+import { readFile } from "node:fs/promises";
+import { stdin as defaultInput, stdout as defaultOutput } from "node:process";
+var TerminalOneShotExitError = class extends Error {
+  constructor(message, exitCode) {
+    super(message);
+    this.exitCode = exitCode;
+    this.name = "TerminalOneShotExitError";
+  }
+  exitCode;
+};
+var OneShotDeadlineError = class extends Error {
+  constructor(phase, timeoutSec) {
+    super(`Timed out after ${timeoutSec}s during ${phase}.`);
+    this.phase = phase;
+    this.timeoutSec = timeoutSec;
+    this.name = "OneShotDeadlineError";
+  }
+  phase;
+  timeoutSec;
+};
+async function runOneShotChat(options, io = {}) {
+  const output2 = io.output ?? defaultOutput;
+  const startedAtMs = Date.now();
+  const startedAt = new Date(startedAtMs).toISOString();
+  const deadline = createOneShotDeadline(options.timeoutSec);
+  const startupWarnings = [];
+  let connection = null;
+  let eventStream = null;
+  let timedOut = false;
+  let activeSessionId = null;
+  let selectedModel = options.model;
+  let accumulator = null;
+  let turnSubmitted = false;
+  try {
+    const prompt = await deadline.run("input loading", resolveOneShotPrompt(options, io.input ?? defaultInput));
+    if (!prompt.trim()) {
+      throw new TerminalOneShotExitError("openpond chat --non-interactive requires --message, --message-file, or --stdin input.", 2);
+    }
+    connection = io.connection ?? await deadline.run(
+      "server startup",
+      ensureServer(options, (line) => startupWarnings.push(line))
+    );
+    const payload = await deadline.run(
+      "bootstrap",
+      apiFetch(connection.server, connection.token, "/v1/bootstrap?refreshCodex=1", {
+        signal: deadline.signal
+      })
+    );
+    const sessionState = await deadline.run("session setup", ensureTerminalChatSession(
+      { ...connection, signal: deadline.signal },
+      payload,
+      { ...options, headless: true },
+      options.resume
+    ));
+    const readySession = await deadline.run(
+      "workspace readiness",
+      ensureTerminalSessionWorkspaceReady({ ...connection, signal: deadline.signal }, sessionState.session)
+    );
+    activeSessionId = sessionState.sessionId;
+    if (readySession?.cwd) options.cwd = readySession.cwd;
+    options.provider = sessionState.provider;
+    options.model = sessionState.model;
+    selectedModel = sessionState.model;
+    const modelId = activeModelId(options, payload.providers);
+    if (!modelId) {
+      throw new Error(`No model selected for ${providerLabel(payload.providers, options.provider)}.`);
+    }
+    selectedModel = modelId;
+    if (!options.json) {
+      for (const line of startupWarnings) output2.write(`${line}
+`);
+      output2.write(`${terminalSessionHeading(payload.providers, options)}
+`);
+    }
+    const activeAccumulator = createOneShotAccumulator({ maxOutputBytes: options.maxOutputBytes });
+    accumulator = activeAccumulator;
+    let resolveTerminalEvent = (_event) => void 0;
+    const terminalEventPromise = new Promise((resolve) => {
+      resolveTerminalEvent = resolve;
+    });
+    eventStream = openOneShotTerminalEvents({
+      server: connection.server,
+      token: connection.token,
+      activeSessionId,
+      onEvent: (event) => {
+        activeAccumulator.apply(event);
+        if (!options.json) output2.write(humanOneShotEventText(event));
+        if (isTerminalTurnEvent(event)) resolveTerminalEvent(event);
+      },
+      onStatus: (message) => {
+        if (!options.json) output2.write(message);
+      }
+    });
+    await deadline.run("event stream readiness", eventStream.ready);
+    await deadline.run("turn submission", apiFetch(connection.server, connection.token, `/v1/sessions/${activeSessionId}/turns`, {
+      method: "POST",
+      body: JSON.stringify({
+        prompt,
+        ...options.cwdExplicit || !options.project && !options.resume ? { cwd: options.cwd } : {},
+        model: modelId,
+        modelRef: activeModelRef(options, payload.providers),
+        approvalPolicy: options.yes ? "never" : options.approvalPolicy,
+        sandbox: options.sandbox,
+        metadata: {
+          openpondTerminalMode: "one-shot",
+          openpondTerminal: {
+            mode: "one-shot",
+            nonInteractive: true,
+            sandbox: options.sandbox
+          }
+        }
+      }),
+      signal: deadline.signal
+    }));
+    turnSubmitted = true;
+    const terminal = await deadline.run("turn completion", terminalEventPromise);
+    const result = activeAccumulator.result({
+      terminal: terminal.name,
+      sessionId: activeSessionId,
+      provider: options.provider,
+      model: modelId,
+      cwd: options.cwd,
+      startedAt,
+      startedAtMs,
+      error: terminal.error ?? (terminal.name === "turn.failed" ? terminal.output ?? "Turn failed." : null)
+    });
+    writeOneShotResult(output2, options, result);
+    if (result.status !== "completed") process.exitCode = 1;
+    return result;
+  } catch (error) {
+    if (error instanceof TerminalOneShotExitError) throw error;
+    if (error instanceof OneShotDeadlineError) {
+      timedOut = true;
+      if (connection && activeSessionId && turnSubmitted) {
+        await interruptOneShotTurn(connection.server, connection.token, activeSessionId);
+      }
+      const result2 = (accumulator ?? createOneShotAccumulator({ maxOutputBytes: options.maxOutputBytes })).result({
+        terminal: "timeout",
+        sessionId: activeSessionId,
+        provider: options.provider,
+        model: selectedModel,
+        cwd: options.cwd,
+        startedAt,
+        startedAtMs,
+        error: error.message
+      });
+      writeOneShotResult(output2, options, result2);
+      process.exitCode = 124;
+      return result2;
+    }
+    const result = (accumulator ?? createOneShotAccumulator({ maxOutputBytes: options.maxOutputBytes })).result({
+      terminal: "error",
+      sessionId: activeSessionId,
+      provider: options.provider,
+      model: selectedModel,
+      cwd: options.cwd,
+      startedAt,
+      startedAtMs,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    writeOneShotResult(output2, options, result);
+    process.exitCode = 1;
+    return result;
+  } finally {
+    deadline.dispose();
+    const activeEventStream = eventStream;
+    activeEventStream?.abort();
+    if (!io.connection) await stopManagedServer();
+    if (timedOut && !options.json) output2.write("\n[turn timeout]\n");
+  }
+}
+function createOneShotDeadline(timeoutSec) {
+  const controller = new AbortController();
+  let phase = "startup";
+  let timer = null;
+  let rejectTimeout = (_error) => void 0;
+  const timeout = new Promise((_resolve, reject) => {
+    rejectTimeout = reject;
+  });
+  timeout.catch(() => void 0);
+  if (timeoutSec) {
+    timer = setTimeout(() => {
+      controller.abort();
+      rejectTimeout(new OneShotDeadlineError(phase, timeoutSec));
+    }, timeoutSec * 1e3);
+  }
+  return {
+    signal: controller.signal,
+    async run(nextPhase, operation) {
+      phase = nextPhase;
+      return timeoutSec ? Promise.race([operation, timeout]) : operation;
+    },
+    dispose() {
+      if (timer) clearTimeout(timer);
+    }
+  };
+}
+function createOneShotAccumulator(options = {}) {
+  let total = 0;
+  let commands = 0;
+  let workspaceActions = 0;
+  let finalMessage = "";
+  let finalMessageBytes = 0;
+  let finalMessageTruncated = false;
+  let turnId = null;
+  let usage = null;
+  const maxOutputBytes = options.maxOutputBytes ?? null;
+  return {
+    apply(event) {
+      total += 1;
+      if (event.turnId) turnId = event.turnId;
+      if (event.name === "assistant.delta" && event.output && !finalMessageTruncated) {
+        const next = appendWithinByteLimit(finalMessage, finalMessageBytes, event.output, maxOutputBytes);
+        finalMessage = next.text;
+        finalMessageBytes = next.bytes;
+        finalMessageTruncated = next.truncated;
+      }
+      if (event.name === "command.output" || event.name === "tool.completed" && event.action === "exec_command") {
+        commands += 1;
+      }
+      if (event.name === "workspace_action" || event.name === "workspace_action_result") workspaceActions += 1;
+      const usageSnapshot = contextUsageFromEvent(event);
+      if (usageSnapshot) usage = usageSnapshot;
+    },
+    result(input2) {
+      const finishedAtMs = Date.now();
+      const terminal = input2.terminal;
+      return {
+        status: terminalStatus(terminal),
+        sessionId: input2.sessionId,
+        turnId,
+        provider: input2.provider,
+        model: input2.model,
+        cwd: input2.cwd,
+        startedAt: input2.startedAt,
+        finishedAt: new Date(finishedAtMs).toISOString(),
+        durationMs: Math.max(0, finishedAtMs - input2.startedAtMs),
+        finalMessage,
+        output: {
+          finalMessageBytes,
+          truncated: finalMessageTruncated,
+          maxOutputBytes
+        },
+        events: {
+          terminal,
+          total,
+          commands,
+          workspaceActions
+        },
+        usage,
+        error: input2.error
+      };
+    }
+  };
+}
+function contextUsageFromEvent(event) {
+  if (event.name !== "session.context.updated") return null;
+  const parsed = ContextUsageSnapshotSchema.safeParse(event.data);
+  if (!parsed.success) return null;
+  if (parsed.data.source === "heuristic") return null;
+  return parsed.data;
+}
+function appendWithinByteLimit(current, currentBytes, chunk, maxBytes) {
+  if (maxBytes === null) {
+    return {
+      text: current + chunk,
+      bytes: currentBytes + utf8Bytes2(chunk),
+      truncated: false
+    };
+  }
+  let text = current;
+  let bytes = currentBytes;
+  for (const char of chunk) {
+    const charBytes = utf8Bytes2(char);
+    if (bytes + charBytes > maxBytes) {
+      return { text, bytes, truncated: true };
+    }
+    text += char;
+    bytes += charBytes;
+  }
+  return { text, bytes, truncated: false };
+}
+function utf8Bytes2(value) {
+  return new TextEncoder().encode(value).byteLength;
+}
+async function resolveOneShotPrompt(options, input2) {
+  const parts = [];
+  const inputIsTty = Boolean(input2.isTTY);
+  const explicitSources = [
+    options.message !== null ? "--message" : null,
+    options.messageFile !== null ? "--message-file" : null,
+    options.stdin ? "--stdin" : null
+  ].filter((source) => source !== null);
+  if (explicitSources.length > 1) {
+    throw new TerminalOneShotExitError(
+      `openpond chat --non-interactive accepts exactly one instruction source; received ${explicitSources.join(", ")}.`,
+      2
+    );
+  }
+  if (options.message !== null) parts.push(options.message);
+  if (options.messageFile) parts.push(await readOneShotMessageFile(options.messageFile));
+  if (options.stdin || options.nonInteractive && !inputIsTty && !options.message && !options.messageFile) {
+    parts.push(await readAll(input2));
+  }
+  return parts.join("\n\n").trimEnd();
+}
+async function readOneShotMessageFile(filePath) {
+  try {
+    return await readFile(filePath, "utf8");
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new TerminalOneShotExitError(`openpond chat --message-file could not read ${filePath}: ${detail}`, 2);
+  }
+}
+async function readAll(input2) {
+  let text = "";
+  input2.setEncoding("utf8");
+  for await (const chunk of input2) text += String(chunk);
+  return text;
+}
+function openOneShotTerminalEvents(input2) {
+  const pending = openTerminalEvents({
+    server: input2.server,
+    token: input2.token,
+    activeSessionId: () => input2.activeSessionId,
+    onEvent: input2.onEvent,
+    onStatus: (status) => {
+      if (status.state === "disconnected") {
+        input2.onStatus(`
+[event stream] reconnecting in ${Math.ceil(status.nextDelayMs / 1e3)}s: ${status.message}
+`);
+      }
+    }
+  });
+  const fallback = new AbortController();
+  fallback.ready = pending.then((controller) => controller.ready);
+  fallback.switchSession = (sessionId) => pending.then((controller) => controller.switchSession(sessionId));
+  pending.then((controller) => {
+    if (fallback.signal.aborted) controller.abort();
+    else {
+      fallback.signal.addEventListener("abort", () => controller.abort(), { once: true });
+    }
+  }).catch(() => void 0);
+  return fallback;
+}
+async function interruptOneShotTurn(server, token, sessionId) {
+  await apiFetch(server, token, `/v1/sessions/${sessionId}/turns/interrupt`, { method: "POST" }).catch(() => void 0);
+}
+function writeOneShotResult(output2, options, result) {
+  if (options.json) {
+    output2.write(`${JSON.stringify(result, null, 2)}
+`);
+    return;
+  }
+  output2.write(`
+[turn ${result.status}]
+`);
+}
+function humanOneShotEventText(event) {
+  if (event.name === "assistant.delta") return event.output ?? "";
+  if (event.name === "approval.requested") return `
+[approval] ${event.output ?? event.action ?? "request"}
+`;
+  if (event.name === "command.output" && event.output) return `
+[command] ${event.output}
+`;
+  if (event.name.startsWith("workspace_")) return `
+[openpond] ${event.output ?? event.action ?? event.name}
+`;
+  return "";
+}
+function isTerminalTurnEvent(event) {
+  return event.name === "turn.completed" || event.name === "turn.failed" || event.name === "turn.interrupted";
+}
+function terminalStatus(terminal) {
+  if (terminal === "turn.completed") return "completed";
+  if (terminal === "turn.interrupted") return "interrupted";
+  if (terminal === "timeout") return "timeout";
+  return "failed";
+}
+
+// ../terminal/src/index.ts
+async function interruptTurn(server, token, sessionId) {
+  await apiFetch(server, token, `/v1/sessions/${sessionId}/turns/interrupt`, { method: "POST" });
+}
+function openUrlCommand(url) {
+  if (process.platform === "darwin") return { command: "open", args: [url] };
+  if (process.platform === "win32") return { command: "cmd", args: ["/c", "start", "", url] };
+  return { command: "xdg-open", args: [url] };
+}
+function openUrlDetached(url) {
+  const { command, args } = openUrlCommand(url);
+  const child = spawn2(command, args, {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+}
+async function chat(options) {
+  const mode = resolveTerminalChatMode(options, {
+    inputIsTTY: Boolean(input.isTTY),
+    outputIsTTY: Boolean(output.isTTY)
+  });
+  if (mode === "one-shot") {
+    await runOneShotChat(options, { input, output });
+    return;
+  }
+  if (mode === "line-mode") {
+    await lineModeChat(options);
+    return;
+  }
+  let transcript = [];
+  let composer = createComposer();
+  let slashSelectedIndex = 0;
+  let slashLastQuery = null;
+  let scrollOffset = 0;
+  let activeSessionId = options.resume;
+  let activeAgentId = null;
+  let payload = null;
+  let eventStream = null;
+  const exitLatch = createTerminalExitLatch();
+  let connection = null;
+  let pendingCommandApproval = null;
+  let permissionQuestion = null;
+  let permissionQuestionSelectedIndex = 0;
+  let notice = null;
+  let eventStreamNotice = null;
+  const commandScheduler = createSerialTaskScheduler();
+  const resizeRenderScheduler = createLatestWinsTaskScheduler();
+  const interaction = createTerminalInteractiveState(activeSessionId);
+  const renderer = new TerminalRenderer(output, () => {
+    resizeRenderScheduler.request(() => {
+      renderer.fullRedraw();
+      render();
+    });
+  });
+  function status() {
+    return {
+      provider: providerLabel(payload?.providers, options.provider),
+      model: modelLabel(payload?.providers, options),
+      cwd: options.cwd,
+      profile: payload ? profileLabel(payload) : "loading",
+      agent: activeAgentId,
+      running: interaction.snapshot().phase === "running",
+      sessionId: activeSessionId,
+      notice: notice ?? eventStreamNotice
+    };
+  }
+  function render() {
+    flushCommittedItems();
+    renderer.render({
+      transcript,
+      composer,
+      slashMenu: activeSlashMenu(),
+      status: status(),
+      scrollOffset
+    });
+  }
+  const eventRenderScheduler = createTerminalRenderScheduler(render);
+  function activeSlashMenu() {
+    if (permissionQuestion) {
+      permissionQuestionSelectedIndex = Math.min(
+        Math.max(0, permissionQuestionSelectedIndex),
+        TERMINAL_PERMISSION_QUESTION_CHOICES.length - 1
+      );
+      return {
+        items: TERMINAL_PERMISSION_QUESTION_CHOICES,
+        selectedIndex: permissionQuestionSelectedIndex
+      };
+    }
+    const appQuery = installAppQuery(composer.text);
+    if (appQuery !== null) {
+      const queryKey = `install:${appQuery}`;
+      if (queryKey !== slashLastQuery) {
+        slashSelectedIndex = 0;
+        slashLastQuery = queryKey;
+      }
+      const items2 = installAppOptions(appQuery);
+      if (items2.length === 0) return null;
+      slashSelectedIndex = Math.min(Math.max(0, slashSelectedIndex), items2.length - 1);
+      return { items: items2, selectedIndex: slashSelectedIndex };
+    }
+    const query = slashCommandQuery(composer.text);
+    if (query === null) {
+      slashLastQuery = null;
+      return null;
+    }
+    if (query !== slashLastQuery) {
+      slashSelectedIndex = 0;
+      slashLastQuery = query;
+    }
+    const items = SLASH_COMMANDS.filter((command) => command.name.startsWith(query) || command.usage.slice(1).startsWith(query));
+    if (items.length === 0) return null;
+    slashSelectedIndex = Math.min(Math.max(0, slashSelectedIndex), items.length - 1);
+    return { items, selectedIndex: slashSelectedIndex };
+  }
+  function slashCommandQuery(text) {
+    if (!text.startsWith("/") || text.includes("\n")) return null;
+    const body = text.slice(1);
+    if (body.includes(" ")) return null;
+    return body.toLowerCase();
+  }
+  function flushCommittedItems() {
+    const { readyItems, activeItems } = commitReadyTranscriptItems(transcript);
+    if (readyItems.length === 0) return;
+    renderer.commitLines(renderTranscriptItemsForScrollback(readyItems, output.columns || 80));
+    transcript = activeItems;
+  }
+  function addItem(item) {
+    transcript = appendTranscriptItem(transcript, item);
+    scrollOffset = 0;
+    render();
+  }
+  function setNotice(text) {
+    notice = text;
+    render();
+  }
+  function activePendingCommandApproval() {
+    if (pendingCommandApproval?.status === "pending" && pendingCommandApproval.sessionId === activeSessionId) {
+      return pendingCommandApproval;
+    }
+    return latestPendingCommandApproval(payload, activeSessionId);
+  }
+  function openCommandApprovalQuestion(approval) {
+    pendingCommandApproval = approval;
+    permissionQuestion = { approval };
+    permissionQuestionSelectedIndex = 0;
+    setNotice("approval question");
+    addItem(systemItem(formatTerminalCommandApprovalQuestion(approval), "warning"));
+  }
+  async function resolvePermissionQuestion(choice) {
+    if (!connection || !permissionQuestion) return;
+    const approval = permissionQuestion.approval;
+    setNotice("resolving approval");
+    try {
+      await apiFetch(connection.server, connection.token, `/v1/approvals/${encodeURIComponent(approval.id)}`, {
+        method: "POST",
+        body: JSON.stringify({
+          decision: choice === "yes" ? "accept" : choice === "session" ? "acceptForSession" : choice === "skip" ? "cancel" : "decline"
+        })
+      });
+      permissionQuestion = null;
+      if (pendingCommandApproval?.id === approval.id) pendingCommandApproval = null;
+      notice = null;
+      render();
+    } catch (error) {
+      setNotice(null);
+      addItem(systemItem(error instanceof Error ? error.message : String(error), "error"));
+    }
+  }
+  async function refreshBootstrap(refreshCodex = false) {
+    if (!connection) throw new Error("Not connected");
+    payload = await apiFetch(connection.server, connection.token, `/v1/bootstrap${refreshCodex ? "?refreshCodex=1" : ""}`);
+    activeAgentId = activeAgentId ?? payload.profile.agents[0]?.id ?? null;
+    return payload;
+  }
+  async function submitPrompt(text) {
+    if (!activeSessionId) {
+      addItem(systemItem("Wait for terminal startup before sending a turn.", "warning"));
+      return;
+    }
+    const started = interaction.beginTurn(activeSessionId);
+    if (!started.ok) {
+      addItem(systemItem(started.message, "warning"));
+      return;
+    }
+    if (!connection) {
+      interaction.failTurnSubmission(activeSessionId);
+      addItem(systemItem("Wait for the server connection before sending a turn.", "warning"));
+      return;
+    }
+    transcript = appendTranscriptItem(transcript, userItem(text));
+    setNotice("running");
+    render();
+    const prompt = activeAgentId ? `@${activeAgentId} ${text}` : text;
+    const modelId = activeModelId(options, payload?.providers);
+    if (!modelId) {
+      interaction.failTurnSubmission(activeSessionId);
+      setNotice(null);
+      addItem(systemItem(`No model selected for ${providerLabel(payload?.providers, options.provider)}. Use /model <id> or configure a default model in Desktop settings.`, "warning"));
+      return;
+    }
+    try {
+      await apiFetch(connection.server, connection.token, `/v1/sessions/${activeSessionId}/turns`, {
+        method: "POST",
+        body: JSON.stringify({
+          prompt,
+          ...options.cwdExplicit || !options.project && !options.resume ? { cwd: options.cwd } : {},
+          model: modelId,
+          modelRef: activeModelRef(options, payload?.providers),
+          approvalPolicy: "on-request",
+          sandbox: "workspace-write"
+        })
+      });
+    } catch (error) {
+      interaction.failTurnSubmission(activeSessionId);
+      setNotice(null);
+      addItem(systemItem(error instanceof Error ? error.message : String(error), "error"));
+    }
+  }
+  async function submitDirectCommand(command) {
+    if (!connection || !activeSessionId) return;
+    const latest = payload ?? await refreshBootstrap();
+    const session = findTerminalSession(latest, activeSessionId);
+    const blockedReason = terminalDirectCommandBlockedReason(session);
+    if (blockedReason || !session) {
+      addItem(systemItem(blockedReason ?? "Select a project to use this.", "warning"));
+      return;
+    }
+    setNotice("running command");
+    try {
+      const result = await runTerminalDirectCommand(connection, session, command);
+      for (const event of result.events) {
+        transcript = appendRuntimeEvent(transcript, event);
+      }
+      payload = await refreshBootstrap().catch(() => payload);
+    } catch (error) {
+      addItem(systemItem(error instanceof Error ? error.message : String(error), "error"));
+    } finally {
+      setNotice(null);
+      render();
+    }
+  }
+  async function handleSubmit(text) {
+    try {
+      const phase = interaction.snapshot().phase;
+      if (phase === "starting" || phase === "switching" || phase === "stopping") {
+        const command2 = parseSlashCommand(text);
+        if (command2?.type === "exit") requestExit();
+        else {
+          const blocked = interaction.blocked("accepting input");
+          if (!blocked.ok) addItem(systemItem(blocked.message, "warning"));
+        }
+        return;
+      }
+      if (permissionQuestion) {
+        const choice = parseTerminalPermissionChoice(text);
+        if (!choice) {
+          addItem(systemItem("Choose yes, session, no, or skip.", "warning"));
+          return;
+        }
+        transcript = appendTranscriptItem(transcript, userItem(text));
+        render();
+        await resolvePermissionQuestion(choice);
+        return;
+      }
+      const directCommand = parseDirectCommandPrompt(text);
+      if (directCommand) {
+        const allowed = interaction.blocked("running a direct command");
+        if (!allowed.ok) {
+          addItem(systemItem(allowed.message, "warning"));
+          return;
+        }
+        await commandScheduler.run(() => submitDirectCommand(directCommand.command));
+        return;
+      }
+      const command = parseSlashCommand(text);
+      if (command) {
+        transcript = appendTranscriptItem(transcript, userItem(text));
+        render();
+        await commandScheduler.run(
+          () => handleTerminalSlashCommand(command, {
+            options,
+            getConnection: () => connection,
+            getPayload: () => payload,
+            setPayload: (nextPayload) => {
+              payload = nextPayload;
+            },
+            getActiveSessionId: () => activeSessionId,
+            setActiveSessionId: (sessionId) => {
+              activeSessionId = sessionId;
+            },
+            switchSession: async (create) => {
+              const started = interaction.beginSessionSwitch();
+              if (!started.ok) throw new Error(started.message);
+              try {
+                const created = await create();
+                const session = await ensureTerminalSessionWorkspaceReady(connection, created) ?? created;
+                activeSessionId = session.id;
+                await eventStream?.switchSession(session.id);
+                interaction.completeSessionSwitch(session.id);
+                transcript = [];
+                pendingCommandApproval = null;
+                permissionQuestion = null;
+                return session;
+              } catch (error) {
+                interaction.failSessionSwitch();
+                throw error;
+              }
+            },
+            getActiveAgentId: () => activeAgentId,
+            setActiveAgentId: (agentId) => {
+              activeAgentId = agentId;
+            },
+            getPendingCommandApproval: activePendingCommandApproval,
+            openCommandApprovalQuestion,
+            refreshBootstrap,
+            addItem,
+            clearTranscript: () => {
+              transcript = [];
+            },
+            requestExit,
+            render,
+            openUrl: openUrlDetached
+          })
+        );
+        return;
+      }
+      await submitPrompt(text);
+    } catch (error) {
+      addItem(systemItem(error instanceof Error ? error.message : String(error), "error"));
+    }
+  }
+  function submitMenuCommand(command) {
+    if (permissionQuestion) {
+      const choice = parseTerminalPermissionChoice(composer.text) ?? parseTerminalPermissionChoice(command.submitText ?? command.name);
+      composer = createComposer();
+      render();
+      if (choice) void resolvePermissionQuestion(choice);
+      return;
+    }
+    const commandText = command.submitText ?? `/${command.name}`;
+    if (command.requiresArgument) {
+      composer = replaceComposerText(composer, `${commandText} `);
+      slashSelectedIndex = 0;
+      render();
+      return;
+    }
+    composer = {
+      text: "",
+      cursor: 0,
+      history: [...composer.history.filter((item) => item !== commandText), commandText].slice(-100),
+      historyIndex: null
+    };
+    slashSelectedIndex = 0;
+    render();
+    void handleSubmit(commandText);
+  }
+  async function handleKey(key) {
+    if (key === "pageup") {
+      scrollOffset += Math.max(4, Math.floor((output.rows || 24) / 2));
+      render();
+      return;
+    }
+    if (key === "pagedown") {
+      scrollOffset = Math.max(0, scrollOffset - Math.max(4, Math.floor((output.rows || 24) / 2)));
+      render();
+      return;
+    }
+    const menu = activeSlashMenu();
+    if (menu && key === "up") {
+      if (permissionQuestion) permissionQuestionSelectedIndex = Math.max(0, permissionQuestionSelectedIndex - 1);
+      else slashSelectedIndex = Math.max(0, slashSelectedIndex - 1);
+      render();
+      return;
+    }
+    if (menu && key === "down") {
+      if (permissionQuestion) {
+        permissionQuestionSelectedIndex = Math.min(menu.items.length - 1, permissionQuestionSelectedIndex + 1);
+      } else {
+        slashSelectedIndex = Math.min(menu.items.length - 1, slashSelectedIndex + 1);
+      }
+      render();
+      return;
+    }
+    if (menu && key === "enter") {
+      submitMenuCommand(menu.items[slashSelectedIndex] ?? menu.items[0]);
+      return;
+    }
+    const before = composer;
+    const result = handleComposerKey(composer, key);
+    composer = result.state;
+    if (!activeSlashMenu()) slashSelectedIndex = 0;
+    if (result.action.type === "submit") {
+      render();
+      void handleSubmit(result.action.text);
+      return;
+    }
+    if (result.action.type === "cancel-or-exit") {
+      if (permissionQuestion) {
+        void resolvePermissionQuestion("skip");
+      } else if (interaction.snapshot().phase === "running" && connection && activeSessionId) {
+        setNotice("interrupting");
+        void interruptTurn(connection.server, connection.token, activeSessionId).catch((error) => {
+          addItem(systemItem(error instanceof Error ? error.message : String(error), "error"));
+        });
+      } else if (before.text) {
+        composer = createComposer();
+        render();
+      } else {
+        requestExit();
+      }
+      return;
+    }
+    if (result.action.type === "exit") {
+      requestExit();
+      return;
+    }
+    if (result.action.type === "rerender") renderer.fullRedraw();
+    render();
+  }
+  function requestExit() {
+    if (exitLatch.requested) return;
+    interaction.beginStopping();
+    exitLatch.request();
+  }
+  const rawInput = new RawInput(input, (key) => {
+    void handleKey(key);
+  });
+  renderer.start();
+  rawInput.start();
+  try {
+    const startupWarnings = [];
+    connection = await ensureServer(options, (line) => startupWarnings.push(line));
+    payload = await apiFetch(connection.server, connection.token, "/v1/bootstrap?refreshCodex=1");
+    activeAgentId = payload.profile.agents[0]?.id ?? null;
+    const sessionState = await ensureTerminalChatSession(connection, payload, options, activeSessionId);
+    const readySession = await ensureTerminalSessionWorkspaceReady(connection, sessionState.session);
+    activeSessionId = sessionState.sessionId;
+    if (readySession?.cwd) options.cwd = readySession.cwd;
+    options.provider = sessionState.provider;
+    options.model = sessionState.model;
+    notice = null;
+    renderer.commitLines([...renderWelcome(status(), output.columns || 80), ""]);
+    for (const line of startupWarnings) addItem(systemItem(line, "warning"));
+    eventStream = await openTerminalEvents({
+      server: connection.server,
+      token: connection.token,
+      activeSessionId: () => activeSessionId,
+      onEvent: (event) => {
+        interaction.applyRuntimeEvent(event);
+        const requestedApproval = commandApprovalFromRuntimeEvent(event);
+        if (requestedApproval) pendingCommandApproval = requestedApproval;
+        const resolvedApprovalId = commandApprovalIdFromResolvedEvent(event);
+        if (resolvedApprovalId && pendingCommandApproval?.id === resolvedApprovalId) {
+          pendingCommandApproval = null;
+        }
+        if (resolvedApprovalId && permissionQuestion?.approval.id === resolvedApprovalId) {
+          permissionQuestion = null;
+          notice = null;
+        }
+        transcript = appendRuntimeEvent(transcript, event);
+        if (event.name === "turn.completed" || event.name === "turn.failed" || event.name === "turn.interrupted") {
+          notice = null;
+        }
+        eventRenderScheduler.request();
+      },
+      onStatus: (status2) => {
+        if (status2.state === "disconnected") {
+          eventStreamNotice = `event stream reconnecting in ${Math.ceil(status2.nextDelayMs / 1e3)}s`;
+          eventRenderScheduler.request();
+        } else if (status2.state === "connected" && eventStreamNotice) {
+          eventStreamNotice = null;
+          eventRenderScheduler.request();
+        }
+      }
+    });
+    await eventStream.ready;
+    interaction.completeStartup(activeSessionId);
+    render();
+    await exitLatch.wait();
+  } finally {
+    eventStream?.abort();
+    eventRenderScheduler.cancel();
+    resizeRenderScheduler.cancel();
+    rawInput.stop();
+    renderer.stop();
+    await stopManagedServer();
+  }
+}
+function printEvent(event) {
+  if (event.name === "assistant.delta") output.write(event.output ?? "");
+  else if (event.name === "turn.completed") output.write("\n[turn completed]\n");
+  else if (event.name === "approval.requested") output.write(`
+[approval] ${event.output ?? event.action ?? "request"}
+`);
+  else if (event.name === "command.output" && event.output) output.write(`
+[command] ${event.output}
+`);
+  else if (event.name.startsWith("workspace_")) output.write(`
+[openpond] ${event.output ?? event.action ?? event.name}
+`);
+}
+async function lineModeChat(options) {
+  const connection = await ensureServer(options, (line) => output.write(`${line}
+`));
+  const payload = await apiFetch(connection.server, connection.token, "/v1/bootstrap?refreshCodex=1");
+  const sessionState = await ensureTerminalChatSession(connection, payload, options, options.resume);
+  const readySession = await ensureTerminalSessionWorkspaceReady(connection, sessionState.session);
+  const activeSessionId = sessionState.sessionId;
+  if (readySession?.cwd) options.cwd = readySession.cwd;
+  options.provider = sessionState.provider;
+  options.model = sessionState.model;
+  const turnGuard = createLineModeTurnGuard();
+  const eventStream = await openTerminalEvents({
+    server: connection.server,
+    token: connection.token,
+    activeSessionId: () => activeSessionId,
+    onEvent: (event) => {
+      turnGuard.applyRuntimeEvent(event);
+      printEvent(event);
+    },
+    onStatus: (status) => {
+      if (status.state === "disconnected") {
+        output.write(`
+[event stream] reconnecting in ${Math.ceil(status.nextDelayMs / 1e3)}s: ${status.message}
+`);
+      }
+    }
+  });
+  await eventStream.ready;
+  const rl = createInterface({ input, output });
+  output.write(`${terminalSessionHeading(payload.providers, options)}
+`);
+  try {
+    for await (const rawLine of rl) {
+      const line = rawLine.trim();
+      if (!line) continue;
+      if (line === "/exit" || line === "/quit") break;
+      if (!turnGuard.tryStartSubmission()) {
+        output.write(`${LINE_MODE_TURN_RUNNING_MESSAGE}
+`);
+        continue;
+      }
+      const modelId = activeModelId(options, payload.providers);
+      if (!modelId) {
+        turnGuard.failSubmission();
+        throw new Error(`No model selected for ${providerLabel(payload.providers, options.provider)}.`);
+      }
+      try {
+        await apiFetch(connection.server, connection.token, `/v1/sessions/${activeSessionId}/turns`, {
+          method: "POST",
+          body: JSON.stringify({
+            prompt: line,
+            ...options.cwdExplicit || !options.project && !options.resume ? { cwd: options.cwd } : {},
+            model: modelId,
+            modelRef: activeModelRef(options, payload.providers),
+            approvalPolicy: "on-request",
+            sandbox: "workspace-write"
+          })
+        });
+      } catch (error) {
+        turnGuard.failSubmission();
+        throw error;
+      }
+    }
+  } finally {
+    rl.close();
+    eventStream.abort();
+    await stopManagedServer();
+  }
+}
+async function runOpenPondTerminalCli(argv = process.argv.slice(2)) {
+  const { command, options } = parseTerminalArgs(argv);
+  if (command !== "chat") {
+    output.write(
+      "Usage: openpond-app chat [--server URL] [--provider PROVIDER] [--model MODEL] [--cwd DIR] [--project APP_ID] [--resume SESSION_ID] (--message TEXT|--message-file PATH|--stdin) --non-interactive [--yes] [--approval-policy POLICY] [--json] [--timeout-sec SEC] [--max-output-bytes BYTES] [--sandbox MODE]\n"
+    );
+    return;
+  }
+  await chat(options);
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  void runOpenPondTerminalCli().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    const exitCode = typeof error.exitCode === "number" ? error.exitCode : 1;
+    process.exit(exitCode);
+  });
+}
+export {
+  runOpenPondTerminalCli
+};