@buildaharness/aielia 0.3.1 → 0.3.2

package/dist/bin-CqkqT6KK.js

@@ -0,0 +1,2107 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { createInterface } from "node:readline";
+import { rename, stat, realpath, readdir, mkdir, unlink, writeFile, readFile } from "node:fs/promises";
+import { existsSync, mkdirSync, writeFileSync, renameSync, rmSync, createWriteStream, chmodSync, readFileSync, realpathSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join, dirname, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { OPENROUTER_DEFAULT_MODEL, OPENAI_DEFAULT_MODEL, ANTHROPIC_DEFAULT_MODEL, InMemoryReminderStore, FileSystemAdapter, FileSystemExperienceStore, LLMClient, OpenAICompatibleLLMClient, OPENROUTER_EXTRA_HEADERS, OPENROUTER_BASE_URL, OPENAI_BASE_URL, AnthropicLLMClient } from "@buildaharness/runtime";
+import { x as buildClaudePrompt, aE as stripJsonCodeFence, a as ALREADY_STAGED_ACTION_TOOL, aD as stagedActionInput, ar as parseClaudeCliOutput, aF as stripMcpToolPrefix, V as envOverridesFromProcessEnv, aw as resolveConfig, aB as shouldLaunchTuiApp, aI as validateConfig, c as ConfigValidationError, aa as formatSpendCapStatus, n as PersonalAssistant, w as braveSearch, N as createSmtpSender, M as createResendSender, z as classifyError, an as nodeToLayer, L as LAYER_DISPLAY_NAME, am as nodeDisplayName, X as estimateCostUsd, a0 as formatConfigListing, ae as isConfigKey, C as CONFIG_KEYS, E as ENV_VAR_FOR_CONFIG_KEY, as as parseConfigValue, d as ConfigValueParseError, a2 as formatDoctorReport, a1 as formatCostSummary, a9 as formatSearchResults, ad as formatUndoLogListing, O as defaultExportFilename, ac as formatTranscriptMarkdown, ab as formatStatus, a4 as formatHelp, k as LAYER_ORDER, y as buildWhyChain, l as LAYER_SHORT_CODE, Q as defaultMemoryExportFilename, a5 as formatMemoryExport, a6 as formatMemoryPendingOutcome, a7 as formatMemorySummary } from "./cli-session-BiX2DOni.js";
+import { spawn } from "node:child_process";
+import { createServer, connect } from "node:net";
+import { createRequire } from "node:module";
+import { randomBytes, createHash } from "node:crypto";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+function isEnoent$1(err) {
+  return (err == null ? void 0 : err.code) === "ENOENT";
+}
+function createNodeFsBackend() {
+  return {
+    async readTextFile(path) {
+      try {
+        return await readFile(path, "utf-8");
+      } catch (err) {
+        if (isEnoent$1(err)) return void 0;
+        throw err;
+      }
+    },
+    async writeTextFile(path, contents) {
+      await writeFile(path, contents, "utf-8");
+    },
+    async removeFile(path) {
+      try {
+        await unlink(path);
+      } catch (err) {
+        if (!isEnoent$1(err)) throw err;
+      }
+    },
+    async mkdir(path) {
+      await mkdir(path, { recursive: true });
+    },
+    async readDir(path) {
+      try {
+        return await readdir(path);
+      } catch (err) {
+        if (isEnoent$1(err)) return [];
+        throw err;
+      }
+    },
+    async realpath(path) {
+      return realpath(path);
+    },
+    async stat(path) {
+      try {
+        const info = await stat(path);
+        return { isDirectory: info.isDirectory(), size: info.size };
+      } catch (err) {
+        if (isEnoent$1(err)) return void 0;
+        throw err;
+      }
+    },
+    async rename(from, to) {
+      await rename(from, to);
+    }
+  };
+}
+const CLI_VERSION = "0.3.2";
+function seaCacheDir(version, home = homedir()) {
+  return join(home, ".buildaharness", "personal-assistant", "sea-cache", version);
+}
+function extractAssetOnce(dir, fileName, read) {
+  const target = join(dir, fileName);
+  if (existsSync(target)) return target;
+  mkdirSync(dir, { recursive: true });
+  const tmp = `${target}.${process.pid}.tmp`;
+  const data = read();
+  writeFileSync(tmp, typeof data === "string" ? data : new Uint8Array(data));
+  renameSync(tmp, target);
+  return target;
+}
+const MCP_SERVER_FILE_NAME = "file-tools-mcp-server.mjs";
+const MCP_SERVER_PATTERN_FILES = ["injection-patterns.json", "fact-markers.json", "risk-patterns.json"];
+function loadSea() {
+  try {
+    const sea = createRequire(import.meta.url)("node:sea");
+    return sea.isSea() ? sea : null;
+  } catch {
+    return null;
+  }
+}
+function resolveMcpServerPath(seaOverride, home) {
+  const sea = loadSea();
+  if (sea) {
+    const dir = seaCacheDir(CLI_VERSION, home);
+    for (const name of MCP_SERVER_PATTERN_FILES) {
+      const key = `lexical/patterns/${name}`;
+      extractAssetOnce(join(dir, "lexical", "patterns"), name, () => sea.getRawAsset(key));
+    }
+    return extractAssetOnce(dir, MCP_SERVER_FILE_NAME, () => sea.getRawAsset(MCP_SERVER_FILE_NAME));
+  }
+  return fileURLToPath(new URL(MCP_SERVER_FILE_NAME, import.meta.url));
+}
+const EMPTY_MCP_CONFIG = JSON.stringify({ mcpServers: {} });
+function invokeClaude(claudePath, args) {
+  return new Promise((resolvePromise, reject) => {
+    const proc = spawn(claudePath, args, { cwd: tmpdir(), stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    proc.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    proc.on("error", reject);
+    proc.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(stderr.trim() || `claude exited with code ${code}`));
+        return;
+      }
+      resolvePromise(parseClaudeCliOutput(stdout));
+    });
+  });
+}
+function invokeClaudeStreaming(claudePath, args, onToolStep) {
+  return new Promise((resolvePromise, reject) => {
+    const proc = spawn(claudePath, args, { cwd: tmpdir(), stdio: ["ignore", "pipe", "pipe"] });
+    let buffer = "";
+    let stderr = "";
+    let finalResultLine;
+    proc.stdout.on("data", (chunk) => {
+      var _a;
+      buffer += chunk.toString("utf-8");
+      let newlineIndex;
+      while ((newlineIndex = buffer.indexOf("\n")) !== -1) {
+        const line = buffer.slice(0, newlineIndex);
+        buffer = buffer.slice(newlineIndex + 1);
+        if (!line.trim()) continue;
+        let event;
+        try {
+          event = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (event.type === "assistant" && onToolStep) {
+          for (const block of ((_a = event.message) == null ? void 0 : _a.content) ?? []) {
+            if (block.type !== "tool_use") continue;
+            const toolUse = block;
+            onToolStep({ tool: stripMcpToolPrefix(toolUse.name), input: toolUse.input ?? {} });
+          }
+        } else if (event.type === "result") {
+          finalResultLine = line;
+        }
+      }
+    });
+    proc.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    proc.on("error", reject);
+    proc.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(stderr.trim() || `claude exited with code ${code}`));
+        return;
+      }
+      resolvePromise(parseClaudeCliOutput(finalResultLine ?? ""));
+    });
+  });
+}
+function startToolGateServer(onToolProposal) {
+  return new Promise((resolvePromise, reject) => {
+    const server = createServer((socket) => {
+      let buffer = "";
+      socket.on("data", (chunk) => {
+        buffer += chunk.toString("utf-8");
+        let newlineIndex;
+        while ((newlineIndex = buffer.indexOf("\n")) !== -1) {
+          const line = buffer.slice(0, newlineIndex);
+          buffer = buffer.slice(newlineIndex + 1);
+          if (!line.trim()) continue;
+          void (async (requestLine) => {
+            let request;
+            try {
+              request = JSON.parse(requestLine);
+            } catch {
+              socket.write(`${JSON.stringify({ decision: "allow" })}
+`);
+              return;
+            }
+            let decision;
+            try {
+              decision = onToolProposal && typeof request.tool === "string" ? await onToolProposal(request.tool, request.input ?? {}) : { decision: "allow" };
+            } catch (err) {
+              console.error("claude-cli tool gate: onToolProposal threw — failing open:", err);
+              decision = { decision: "allow" };
+            }
+            socket.write(`${JSON.stringify(decision)}
+`);
+          })(line);
+        }
+      });
+    });
+    server.on("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (address === null || typeof address === "string") {
+        reject(new Error("tool gate server failed to bind to a loopback TCP port"));
+        return;
+      }
+      resolvePromise({ server, port: address.port });
+    });
+  });
+}
+class ClaudeCliLLMClient {
+  constructor(options = {}) {
+    __publicField(this, "claudePath");
+    __publicField(this, "fileTools");
+    __publicField(this, "remindersFile");
+    __publicField(this, "shellTools");
+    __publicField(this, "webTools");
+    __publicField(this, "actionTools");
+    __publicField(this, "model");
+    /**
+     * The concrete model id the last `claude -p` call actually reported running against (read from
+     * the response's own `model` field, not the CLI alias). `undefined` until a call resolves one.
+     * Plan A1 records this into the benchmark report so a published table can name the model.
+     */
+    __publicField(this, "resolvedModelId");
+    this.claudePath = options.claudePath ?? process.env.CLAUDE_PATH ?? "claude";
+    this.fileTools = options.fileTools;
+    this.remindersFile = options.remindersFile;
+    this.shellTools = options.shellTools;
+    this.webTools = options.webTools;
+    this.actionTools = options.actionTools;
+    this.model = options.model;
+  }
+  async *callChat(messages, options = {}) {
+    yield await this.callChatSync(messages, options);
+  }
+  async callChatSync(messages, options = {}) {
+    var _a;
+    const { systemPrompt, prompt } = buildClaudePrompt(messages);
+    const args = [
+      "--print",
+      "--output-format",
+      "json",
+      "--tools",
+      "",
+      "--no-session-persistence",
+      "--system-prompt",
+      systemPrompt,
+      "--mcp-config",
+      EMPTY_MCP_CONFIG,
+      "--strict-mcp-config"
+      // ignore any ambient project/user MCP config — see EMPTY_MCP_CONFIG's doc comment
+    ];
+    const model = options.model ?? this.model;
+    if (model) args.push("--model", model);
+    args.push(prompt);
+    const { reply, usage, model: resolved } = await invokeClaude(this.claudePath, args);
+    if (resolved) this.resolvedModelId = resolved;
+    if (usage) (_a = options.onUsage) == null ? void 0 : _a.call(options, usage);
+    return reply;
+  }
+  /**
+   * When `tools` is non-empty and `fileTools`/`shellTools` was configured, wires the
+   * file-tools MCP server into a single `claude -p` call and lets Claude Code's own
+   * agentic loop call read_file/list_directory/write_file/fetch_url/create_reminder/
+   * list_reminders/run_shell_command autonomously — we don't get to intercept each
+   * call the way the proxy backend's manual tool loop does (see
+   * the internal plan, T6). fetch_url is always
+   * registered on that server; create_reminder/list_reminders only when
+   * `remindersFile` is set; run_shell_command only when `shellTools` is set;
+   * web_search only when `webTools` is set (Brave Search — see the `webTools`
+   * option). Three
+   * possible outcomes: a final text reply (no tool call this backend needs to
+   * surface), a write or shell command staged by the MCP server mid-call (surfaced
+   * as a synthetic `__staged_action` tool call so assistant.ts's tool loop treats it
+   * the same as a manually staged action without staging it a second time), or —
+   * for fetch_url/create_reminder/list_reminders — the tool's result text folded
+   * directly into Claude Code's own reply, since (unlike the proxy backend's
+   * `executeToolCall`) there's no outer loop here to intercept each call and
+   * re-apply trust-tagging itself; the MCP server tags fetch_url's result before
+   * Claude Code ever sees it instead (see file-tools-mcp-server.mjs).
+   */
+  async callChatStructured(messages, tools, options = {}) {
+    var _a, _b, _c, _d, _e, _f;
+    if (!tools || tools.length === 0) {
+      const content = await this.callChatSync(messages, options);
+      return { content: options.structuredOutput ? stripJsonCodeFence(content) : content };
+    }
+    if (!this.fileTools && !this.shellTools && !this.webTools && !this.actionTools) {
+      throw new Error(
+        "ClaudeCliLLMClient does not support tool calls unless constructed with fileTools, shellTools, webTools, or actionTools configured"
+      );
+    }
+    const { systemPrompt, prompt } = buildClaudePrompt(messages);
+    const workspaceRoot = ((_a = this.fileTools) == null ? void 0 : _a.workspaceRoot) ?? ((_b = this.shellTools) == null ? void 0 : _b.workspaceRoot) ?? ((_c = this.actionTools) == null ? void 0 : _c.workspaceRoot) ?? tmpdir();
+    const lastUserMessage = ((_d = [...messages].reverse().find((m) => m.role === "user")) == null ? void 0 : _d.content) ?? "";
+    const mcpServerPath = resolveMcpServerPath();
+    const gate = await startToolGateServer(options.onToolProposal);
+    try {
+      const mcpConfig = JSON.stringify({
+        mcpServers: {
+          "file-tools": {
+            command: "node",
+            args: [mcpServerPath],
+            env: {
+              WORKSPACE_ROOT: workspaceRoot,
+              TOOL_GATE_PORT: String(gate.port),
+              ...this.remindersFile ? { REMINDERS_FILE: this.remindersFile, CURRENT_USER_MESSAGE: lastUserMessage } : {},
+              ...this.shellTools ? { ENABLE_SHELL_TOOLS: "1" } : {},
+              ...((_e = this.webTools) == null ? void 0 : _e.braveApiKey) ? { BRAVE_SEARCH_API_KEY: this.webTools.braveApiKey } : {},
+              ...this.actionTools ? { ENABLE_EMAIL_TOOL: "1" } : {}
+            }
+          }
+        }
+      });
+      const args = [
+        "--print",
+        "--output-format",
+        "stream-json",
+        // streamed (not the single-object 'json') so tool_use events can be reported live via onToolStep — see invokeClaudeStreaming
+        "--verbose",
+        // required by --print when --output-format is stream-json
+        "--tools",
+        "",
+        // still disable Claude Code's own built-in Read/Write/Bash tools — Bash is never added, regardless of shellTools
+        "--no-session-persistence",
+        "--system-prompt",
+        systemPrompt,
+        "--mcp-config",
+        mcpConfig,
+        "--strict-mcp-config",
+        // ignore any ambient project .mcp.json — the tool surface must be exactly this plan's tools
+        "--dangerously-skip-permissions"
+        // headless -p mode has no way to answer an interactive tool-permission prompt
+      ];
+      const model = options.model ?? this.model;
+      if (model) args.push("--model", model);
+      args.push(prompt);
+      const callStartedAt = Date.now();
+      const { reply, usage, model: resolved } = await invokeClaudeStreaming(this.claudePath, args, options.onToolStep);
+      if (resolved) this.resolvedModelId = resolved;
+      if (usage) (_f = options.onUsage) == null ? void 0 : _f.call(options, usage);
+      const staged = await this.findPendingActionStagedSince(workspaceRoot, callStartedAt);
+      if (staged) {
+        return {
+          content: "",
+          toolCalls: [{ id: `cli-staged-${staged.id}`, name: ALREADY_STAGED_ACTION_TOOL, input: stagedActionInput(staged) }]
+        };
+      }
+      return { content: reply };
+    } finally {
+      gate.server.close();
+    }
+  }
+  /** Diffs .pending-actions/ against the call's start time to detect a write or shell command the MCP server staged during this subprocess call. */
+  /**
+   * When the MCP server staged more than one action this call (e.g. "run X AND write Y" —
+   * see file-tools-mcp-server.mjs's stagePendingAction doc comment), every one of them lands
+   * in `.pending-actions/` with an mtime after `startTimeMs`, in `readdir`-arbitrary order —
+   * not necessarily staging order. Must return the *chain head* (earliest `stagedAt`)
+   * specifically, since resolvePendingAction (assistant.ts) walks `nextPendingActionId`
+   * forward from whichever record it's handed; returning a later link here would surface the
+   * chain out of order and orphan the earlier, still-unresolved action.
+   */
+  async findPendingActionStagedSince(workspaceRoot, startTimeMs) {
+    const dir = `${workspaceRoot}/.pending-actions`;
+    let names;
+    try {
+      names = await readdir(dir);
+    } catch {
+      return void 0;
+    }
+    let earliest;
+    for (const name of names) {
+      if (!name.endsWith(".json")) continue;
+      const filePath = `${dir}/${name}`;
+      const stats = await stat(filePath);
+      if (stats.mtimeMs < startTimeMs - 1e3) continue;
+      const record = JSON.parse(await readFile(filePath, "utf-8"));
+      if (!earliest || record.stagedAt < earliest.stagedAt) earliest = record;
+    }
+    return earliest;
+  }
+}
+const MAX_HEADER_BYTES = 16384;
+function hostAllowed(host, allowlist) {
+  const normalized = host.toLowerCase();
+  return allowlist.some((entry) => {
+    const allowed = entry.toLowerCase();
+    return normalized === allowed || normalized.endsWith(`.${allowed}`);
+  });
+}
+function parseConnectTarget(requestLine) {
+  const match = /^CONNECT\s+([^:\s]+):(\d+)\s+HTTP/i.exec(requestLine);
+  return match ? { host: match[1], port: Number(match[2]) } : null;
+}
+function parsePlainHttpTarget(requestLine, headerText) {
+  const absoluteUri = /^[A-Z]+\s+https?:\/\/([^/:\s]+)(?::(\d+))?/i.exec(requestLine);
+  if (absoluteUri) return { host: absoluteUri[1], port: Number(absoluteUri[2] ?? 80) };
+  const hostHeader = /^host:\s*([^\s:]+)(?::(\d+))?/im.exec(headerText);
+  return hostHeader ? { host: hostHeader[1], port: Number(hostHeader[2] ?? 80) } : null;
+}
+function handleConnection(clientSocket, allowlist) {
+  let buffered = Buffer.alloc(0);
+  const onData = (chunk) => {
+    buffered = Buffer.concat([buffered, chunk]);
+    const headerEnd = buffered.indexOf("\r\n\r\n");
+    if (headerEnd === -1) {
+      if (buffered.length > MAX_HEADER_BYTES) clientSocket.destroy();
+      return;
+    }
+    clientSocket.removeListener("data", onData);
+    const headerText = buffered.slice(0, headerEnd).toString("utf-8");
+    const requestLine = headerText.split("\r\n")[0] ?? "";
+    const isConnect = /^CONNECT\s/i.test(requestLine);
+    const target = isConnect ? parseConnectTarget(requestLine) : parsePlainHttpTarget(requestLine, headerText);
+    if (!target || !hostAllowed(target.host, allowlist)) {
+      clientSocket.end("HTTP/1.1 403 Forbidden\r\nContent-Length: 0\r\n\r\n");
+      return;
+    }
+    const upstream = connect(target.port, target.host, () => {
+      if (isConnect) {
+        clientSocket.write("HTTP/1.1 200 Connection Established\r\n\r\n");
+        const tunnelBytes = buffered.slice(headerEnd + 4);
+        if (tunnelBytes.length > 0) upstream.write(tunnelBytes);
+      } else {
+        upstream.write(buffered);
+      }
+      clientSocket.pipe(upstream);
+      upstream.pipe(clientSocket);
+    });
+    upstream.on("error", () => clientSocket.destroy());
+  };
+  clientSocket.on("data", onData);
+  clientSocket.on("error", () => clientSocket.destroy());
+}
+function startProxyServer(allowlist) {
+  return new Promise((resolveStart, rejectStart) => {
+    const server = createServer((socket) => handleConnection(socket, allowlist));
+    server.on("error", rejectStart);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (address === null || typeof address === "string") {
+        rejectStart(new Error("Failed to bind network containment proxy to a loopback port"));
+        return;
+      }
+      resolveStart({
+        port: address.port,
+        close: () => new Promise((resolveClose) => server.close(() => resolveClose()))
+      });
+    });
+  });
+}
+const proxyCache = /* @__PURE__ */ new Map();
+function getNetworkContainmentProxy(allowlist) {
+  const key = JSON.stringify([...allowlist].map((host) => host.toLowerCase()).sort());
+  let proxy = proxyCache.get(key);
+  if (!proxy) {
+    proxy = startProxyServer(allowlist);
+    proxyCache.set(key, proxy);
+  }
+  return proxy;
+}
+const DEFAULT_TIMEOUT_MS = 3e4;
+const DEFAULT_MAX_OUTPUT_BYTES = 2e4;
+const ALLOWED_ENV_VARS = ["PATH", "HOME", "LANG"];
+function allowlistedEnv() {
+  const env = {};
+  for (const key of ALLOWED_ENV_VARS) {
+    const value = process.env[key];
+    if (value !== void 0) env[key] = value;
+  }
+  return env;
+}
+async function networkContainmentEnv(networkAllowlist) {
+  const proxy = await getNetworkContainmentProxy(networkAllowlist);
+  const proxyUrl = `http://127.0.0.1:${proxy.port}`;
+  return {
+    HTTP_PROXY: proxyUrl,
+    http_proxy: proxyUrl,
+    HTTPS_PROXY: proxyUrl,
+    https_proxy: proxyUrl
+  };
+}
+function truncateOutput(text, maxBytes) {
+  const encoded = new TextEncoder().encode(text);
+  if (encoded.length <= maxBytes) return text;
+  const truncated = new TextDecoder("utf-8", { fatal: false }).decode(encoded.slice(0, maxBytes));
+  return `${truncated}
+… (truncated)`;
+}
+const runApprovedShellCommand = async (command, cwd, options = {}) => {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const maxOutputBytes = options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
+  const containmentEnv = await networkContainmentEnv(options.networkAllowlist ?? []);
+  return new Promise((resolvePromise, reject) => {
+    var _a, _b;
+    const proc = spawn(command, {
+      shell: true,
+      cwd,
+      env: { ...allowlistedEnv(), ...containmentEnv },
+      detached: true,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let output = "";
+    let timedOut = false;
+    let settled = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      try {
+        if (proc.pid) process.kill(-proc.pid, "SIGKILL");
+        else proc.kill("SIGKILL");
+      } catch {
+        proc.kill("SIGKILL");
+      }
+    }, timeoutMs);
+    (_a = proc.stdout) == null ? void 0 : _a.on("data", (chunk) => {
+      output += chunk.toString("utf-8");
+    });
+    (_b = proc.stderr) == null ? void 0 : _b.on("data", (chunk) => {
+      output += chunk.toString("utf-8");
+    });
+    proc.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(err);
+    });
+    proc.on("close", (exitCode) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolvePromise({
+        output: truncateOutput(output, maxOutputBytes),
+        exitCode: timedOut ? null : exitCode,
+        timedOut
+      });
+    });
+  });
+};
+function isEnoent(err) {
+  return (err == null ? void 0 : err.code) === "ENOENT";
+}
+class NodeConfigStore {
+  constructor(path) {
+    __publicField(this, "queue", Promise.resolve());
+    this.path = path;
+  }
+  async load() {
+    let raw;
+    try {
+      raw = await readFile(this.path, "utf-8");
+    } catch (err) {
+      if (isEnoent(err)) return {};
+      throw err;
+    }
+    try {
+      return JSON.parse(raw);
+    } catch {
+      console.error(`Warning: ${this.path} is not valid JSON — ignoring it and falling back to defaults.`);
+      return {};
+    }
+  }
+  save(patch) {
+    const task = this.queue.then(() => this.writePatch(patch));
+    this.queue = task.catch(() => {
+    });
+    return task;
+  }
+  async writePatch(patch) {
+    const existing = await this.load();
+    const merged = { ...existing, ...patch };
+    await mkdir(dirname(this.path), { recursive: true });
+    const tempPath = `${this.path}.tmp-${process.pid}-${randomBytes(6).toString("hex")}`;
+    await writeFile(tempPath, JSON.stringify(merged, null, 2), "utf-8");
+    await rename(tempPath, this.path);
+  }
+}
+const DOCTOR_CHECK_TIMEOUT_MS = 3e3;
+async function checkProxyHealth(proxyUrl) {
+  const label = `proxy reachable (${proxyUrl}/health)`;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), DOCTOR_CHECK_TIMEOUT_MS);
+  try {
+    const res = await fetch(`${proxyUrl}/health`, { signal: controller.signal });
+    if (!res.ok) return { label, ok: false, detail: `HTTP ${res.status}` };
+    const body = await res.json().catch(() => void 0);
+    return (body == null ? void 0 : body.status) === "ok" ? { label, ok: true } : { label, ok: false, detail: "unexpected response body" };
+  } catch (err) {
+    const timedOut = err instanceof Error && err.name === "AbortError";
+    return { label, ok: false, detail: timedOut ? "timed out" : err instanceof Error ? err.message : String(err) };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function checkClaudeCli(claudePath) {
+  const label = `claude binary (${claudePath})`;
+  return new Promise((resolvePromise) => {
+    let settled = false;
+    const proc = spawn(claudePath, ["--version"], { stdio: ["ignore", "ignore", "ignore"] });
+    const timeout = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      proc.kill();
+      resolvePromise({ label, ok: false, detail: "timed out" });
+    }, DOCTOR_CHECK_TIMEOUT_MS);
+    proc.on("error", () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      resolvePromise({ label, ok: false, detail: "not found" });
+    });
+    proc.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      resolvePromise({ label, ok: code === 0, detail: code === 0 ? void 0 : `exited with code ${code}` });
+    });
+  });
+}
+async function checkWorkspaceRoot(workspaceRoot) {
+  const label = `workspace root exists (${workspaceRoot})`;
+  try {
+    const info = await stat(workspaceRoot);
+    return info.isDirectory() ? { label, ok: true } : { label, ok: false, detail: "not a directory" };
+  } catch {
+    return { label, ok: false, detail: "not found" };
+  }
+}
+async function checkDataDirWritable(backend, dataDir) {
+  const label = `data dir writable (${dataDir})`;
+  const probePath = join(dataDir, ".doctor-check");
+  try {
+    await backend.mkdir(dataDir);
+    await backend.writeTextFile(probePath, "ok");
+    await backend.removeFile(probePath);
+    return { label, ok: true };
+  } catch (err) {
+    return { label, ok: false, detail: err instanceof Error ? err.message : String(err) };
+  }
+}
+function resolveNonInteractiveApprovalMode(env) {
+  const raw = env.ASSISTANT_NON_INTERACTIVE_APPROVAL;
+  if (raw === void 0) return void 0;
+  if (raw === "decline" || raw === "require-tty") return raw;
+  console.error(`[warning] ASSISTANT_NON_INTERACTIVE_APPROVAL="${raw}" is not "decline" or "require-tty" — ignoring.`);
+  return void 0;
+}
+function alreadyConfigured(deps) {
+  const { persisted, overriddenKeys } = deps;
+  if (persisted.llmBackend !== void 0) return true;
+  if (persisted.apiKey !== void 0 || persisted.authToken !== void 0) return true;
+  for (const key of ["llmBackend", "apiKey", "authToken", "proxyUrl"]) {
+    if (overriddenKeys.has(key)) return true;
+  }
+  return false;
+}
+const PROVIDER_CHOICES = {
+  "1": { backend: "anthropic", label: "Anthropic (Claude) — needs an sk-ant-… key" },
+  "2": { backend: "openai", label: "OpenAI — needs an sk-… key" },
+  "3": { backend: "openrouter", label: "OpenRouter — needs an sk-or-… key" }
+};
+async function maybeRunFirstRunSetup(deps) {
+  const { configStore, persisted, isInteractive, ask, detectClaudeCli, log } = deps;
+  if (alreadyConfigured(deps)) return persisted;
+  if (!isInteractive) return persisted;
+  log("");
+  log("Welcome to Aielia — this looks like your first run. Let's pick how to reach a model.");
+  log("(You can change any of this later with /config, or skip with Ctrl+C.)");
+  log("");
+  const patch = {};
+  if (await detectClaudeCli()) {
+    const useClaude = await ask(
+      "Found an authenticated `claude` CLI on your PATH. Use it? No API key needed. (Y/n) "
+    );
+    if (useClaude === "" || useClaude.toLowerCase().startsWith("y")) {
+      patch.llmBackend = "claude-cli";
+      await configStore.save(patch);
+      log("");
+      log('✓ Using the claude-cli backend. Try "what time zone is Tokyo in?", then');
+      log('  "send an email to my boss saying I quit" to see the approval gate.');
+      log("");
+      return { ...persisted, ...patch };
+    }
+  }
+  log("Pick a provider to use with your own API key:");
+  for (const [key2, { label }] of Object.entries(PROVIDER_CHOICES)) log(`  ${key2}) ${label}`);
+  const choice = (await ask("Provider [1-3, or Enter to skip]: ")).trim();
+  const picked = PROVIDER_CHOICES[choice];
+  if (!picked) {
+    log("");
+    log('Skipped. The assistant will start on the "proxy" backend (needs @buildaharness/proxy');
+    log("on :8787). Run /config set llmBackend <anthropic|openai|openrouter> and");
+    log("/config set apiKey <key> when you are ready, or set ASSISTANT_LLM_BACKEND + ASSISTANT_API_KEY.");
+    log("");
+    return persisted;
+  }
+  const key = (await ask(`Paste your ${picked.backend} API key: `)).trim();
+  if (!key) {
+    log("");
+    log("No key entered — skipping. Set it later with /config set apiKey <key>.");
+    log("");
+    return persisted;
+  }
+  patch.llmBackend = picked.backend;
+  patch.apiKey = key;
+  await configStore.save(patch);
+  log("");
+  log(`✓ Saved. Using ${picked.backend}. The key is stored in plain text in your config file`);
+  log("  (~/.buildaharness/personal-assistant/config.json) — the same trust boundary as a .env.");
+  log("");
+  return { ...persisted, ...patch };
+}
+const ICONS = {
+  /** A routine, no-approval-needed tool step (read_file, fetch_url, web_search, list_reminders, …). */
+  toolStep: "⚙",
+  /** A tool step that is itself the proposal of a state-changing action (write_file, run_shell_command) — printed on the same in-flight step line, before the separate "[needs approval — …]" prompt appears. */
+  proposalStep: "⚠",
+  /** A read-only tool call `tool-policy.ts` denied before it executed — deliberately not `✗` (cli.ts already uses that, unprefixed, as the leading character of several unrelated config/undo-action error lines; reusing it here would misclassify those as `'tool'`-kind in tui-app.tsx's `TOOL_STEP_PREFIXES` match). */
+  deniedStep: "⛔"
+};
+const PLAN_LINE_PREFIX = "▤PLAN▤";
+const PROPOSAL_TOOLS = /* @__PURE__ */ new Set(["write_file", "run_shell_command"]);
+function toolStepIcon(tool) {
+  return PROPOSAL_TOOLS.has(tool) ? ICONS.proposalStep : ICONS.toolStep;
+}
+function parseCliArgs(argv) {
+  const first = argv[0];
+  if (first === "--version" || first === "-v" || first === "version") return { command: "version" };
+  if (first === "--help" || first === "-h" || first === "help") return { command: "help" };
+  if (first === "update") return { command: "update", dryRun: argv.slice(1).includes("--dry-run") };
+  return { command: "repl" };
+}
+function cliHelpText(version) {
+  return [
+    `aielia ${version} — an agent you can hand real work to, held in bounds by a harness.`,
+    "",
+    "Usage:",
+    "  aielia                 start the interactive assistant",
+    "  aielia update          update to the latest release (standalone binary installs)",
+    "  aielia update --dry-run  check for an update without installing it",
+    "  aielia --version       print the version",
+    "  aielia --help          show this help",
+    "",
+    "https://myaielia.com"
+  ].join("\n");
+}
+const MANIFEST_URL = "https://myaielia.com/aielia-latest.json";
+const RELEASES_API_URL = "https://api.github.com/repos/3IVIS/buildaharness/releases?per_page=50";
+const RELEASE_TAG_PREFIX = "aielia-v";
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+const REQUEST_TIMEOUT_MS = 5e3;
+const DOWNLOAD_TIMEOUT_MS = 10 * 60 * 1e3;
+const NPM_UPDATE_HINT = "npm update -g @buildaharness/aielia";
+const defaultDataDir$1 = () => join(homedir(), ".buildaharness", "personal-assistant");
+const cachePath = (dataDir) => join(dataDir, "update-check.json");
+function compareVersions(a, b) {
+  const parse = (v) => {
+    const [core, pre] = v.replace(/^v/, "").split("-", 2);
+    const nums = core.split(".").map((n) => Number.parseInt(n, 10) || 0);
+    while (nums.length < 3) nums.push(0);
+    return { nums, pre: pre !== void 0 };
+  };
+  const pa = parse(a);
+  const pb = parse(b);
+  for (let i = 0; i < 3; i++) if (pa.nums[i] !== pb.nums[i]) return pa.nums[i] - pb.nums[i];
+  if (pa.pre !== pb.pre) return pa.pre ? -1 : 1;
+  return 0;
+}
+function assertHttps(url, allowInsecureHttp = false) {
+  let protocol;
+  try {
+    protocol = new URL(url).protocol;
+  } catch {
+    throw new Error(`Refusing malformed URL: ${url}`);
+  }
+  if (protocol === "https:") return;
+  if (protocol === "http:" && allowInsecureHttp) return;
+  throw new Error(`Refusing non-HTTPS URL: ${url}`);
+}
+function shouldRunPassiveUpdateCheck(input) {
+  if (input.updateCheck === "disabled") return false;
+  if (!input.stdinIsTty) return false;
+  if (input.env.ASSISTANT_NON_INTERACTIVE_APPROVAL !== void 0) return false;
+  return true;
+}
+function platformKey(o) {
+  return `${o.platform ?? process.platform}-${o.arch ?? process.arch}`;
+}
+function readCache(dataDir) {
+  try {
+    const parsed = JSON.parse(readFileSync(cachePath(dataDir), "utf8"));
+    if (typeof parsed.checkedAt !== "number") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function writeCache(dataDir, cache) {
+  try {
+    mkdirSync(dataDir, { recursive: true });
+    writeFileSync(cachePath(dataDir), JSON.stringify(cache));
+  } catch {
+  }
+}
+function parseManifest(json, allowInsecureHttp) {
+  const m = json;
+  if (typeof (m == null ? void 0 : m.tag) !== "string" || typeof m.version !== "string" || typeof m.assets !== "object" || m.assets === null) {
+    throw new Error("Malformed update manifest");
+  }
+  const assets = {};
+  for (const [key, raw] of Object.entries(m.assets)) {
+    if (typeof (raw == null ? void 0 : raw.url) !== "string") continue;
+    assertHttps(raw.url, allowInsecureHttp);
+    assets[key] = {
+      url: raw.url,
+      sha256: typeof raw.sha256 === "string" ? raw.sha256.toLowerCase() : void 0,
+      size: typeof raw.size === "number" ? raw.size : void 0
+    };
+  }
+  return { tag: m.tag, version: m.version, assets, source: "manifest" };
+}
+function assetKeyFromName(name) {
+  const m = /^aielia-([a-z0-9]+-[a-z0-9]+?)(?:\.exe)?$/.exec(name);
+  return m ? m[1] : null;
+}
+function parseGithubReleases(releases, allowInsecureHttp) {
+  let best = null;
+  for (const r of releases) {
+    if (r.draft || r.prerelease || !r.tag_name.startsWith(RELEASE_TAG_PREFIX)) continue;
+    const version = r.tag_name.slice(RELEASE_TAG_PREFIX.length);
+    if (best && compareVersions(version, best.version) <= 0) continue;
+    const assets = {};
+    for (const a of r.assets ?? []) {
+      const key = assetKeyFromName(a.name);
+      if (!key) continue;
+      assertHttps(a.browser_download_url, allowInsecureHttp);
+      assets[key] = { url: a.browser_download_url, size: a.size };
+    }
+    best = { tag: r.tag_name, version, assets, source: "github" };
+  }
+  return best;
+}
+async function getJson(fetchFn, url, headers = {}) {
+  return fetchFn(url, { headers, signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS), redirect: "follow" });
+}
+async function fetchLatestRelease(options, etag) {
+  const fetchFn = options.fetchFn ?? fetch;
+  const insecure = options.allowInsecureHttp ?? false;
+  const manifestUrl = options.manifestUrl ?? MANIFEST_URL;
+  const apiUrl = options.releasesApiUrl ?? RELEASES_API_URL;
+  assertHttps(manifestUrl, insecure);
+  assertHttps(apiUrl, insecure);
+  let manifestError;
+  try {
+    const res2 = await getJson(fetchFn, manifestUrl);
+    if (res2.ok) return { release: parseManifest(await res2.json(), insecure) };
+    manifestError = new Error(`manifest HTTP ${res2.status}`);
+  } catch (err) {
+    manifestError = err;
+  }
+  const headers = { Accept: "application/vnd.github+json" };
+  if (etag) headers["If-None-Match"] = etag;
+  const res = await getJson(fetchFn, apiUrl, headers);
+  if (res.status === 304 && etag) return { notModified: true };
+  if (!res.ok) {
+    throw new Error(`Could not check for updates (manifest: ${(manifestError == null ? void 0 : manifestError.message) ?? manifestError}; GitHub: HTTP ${res.status})`);
+  }
+  const release = parseGithubReleases(await res.json(), insecure);
+  if (!release) throw new Error(`No ${RELEASE_TAG_PREFIX}* release found`);
+  return { release, etag: res.headers.get("etag") ?? void 0 };
+}
+async function checkForUpdate(options = {}) {
+  const now = (options.now ?? Date.now)();
+  const dataDir = options.dataDir ?? defaultDataDir$1();
+  const current = options.currentVersion ?? CLI_VERSION;
+  const cached = readCache(dataDir);
+  try {
+    if ((cached == null ? void 0 : cached.latestVersion) && now - cached.checkedAt < CHECK_INTERVAL_MS) {
+      return { latestVersion: cached.latestVersion, latestTag: cached.latestTag, updateAvailable: compareVersions(cached.latestVersion, current) > 0 };
+    }
+    const result = await fetchLatestRelease(options, cached == null ? void 0 : cached.etag);
+    if ("notModified" in result) {
+      writeCache(dataDir, { ...cached, checkedAt: now });
+      const v = cached.latestVersion;
+      return { latestVersion: v, latestTag: cached.latestTag, updateAvailable: compareVersions(v, current) > 0 };
+    }
+    writeCache(dataDir, { checkedAt: now, latestVersion: result.release.version, latestTag: result.release.tag, etag: result.etag });
+    return { latestVersion: result.release.version, latestTag: result.release.tag, updateAvailable: compareVersions(result.release.version, current) > 0 };
+  } catch {
+    return null;
+  }
+}
+function updateAvailableNotice(latestVersion, currentVersion, isSea) {
+  const how = isSea ? "run `aielia update`" : `run \`${NPM_UPDATE_HINT}\``;
+  return `A newer aielia is available (${currentVersion} → ${latestVersion}) — ${how}.`;
+}
+function isRunningAsSea() {
+  return loadSea() !== null;
+}
+function cleanupStaleUpdateFiles(execPath = process.execPath) {
+  for (const stale of [`${execPath}.old`, `${execPath}.update.tmp`]) {
+    try {
+      if (existsSync(stale)) rmSync(stale, { force: true });
+    } catch {
+    }
+  }
+}
+function replaceBinary(execPath, newFile, platform = process.platform) {
+  if (platform === "win32") {
+    const aside = `${execPath}.old`;
+    rmSync(aside, { force: true });
+    renameSync(execPath, aside);
+    try {
+      renameSync(newFile, execPath);
+    } catch (err) {
+      renameSync(aside, execPath);
+      throw err;
+    }
+    return;
+  }
+  chmodSync(newFile, 493);
+  renameSync(newFile, execPath);
+}
+async function downloadTo(fetchFn, url, dest) {
+  const res = await fetchFn(url, { signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS), redirect: "follow" });
+  if (!res.ok || !res.body) throw new Error(`Download failed: HTTP ${res.status} for ${url}`);
+  const hash = createHash("sha256");
+  await pipeline(
+    Readable.fromWeb(res.body),
+    async function* (source) {
+      for await (const chunk of source) {
+        hash.update(chunk);
+        yield chunk;
+      }
+    },
+    createWriteStream(dest)
+  );
+  return hash.digest("hex");
+}
+async function fetchSidecarHash(fetchFn, assetUrl) {
+  try {
+    const res = await getJson(fetchFn, `${assetUrl}.sha256`);
+    if (!res.ok) return null;
+    const m = /[0-9a-fA-F]{64}/.exec(await res.text());
+    return m ? m[0].toLowerCase() : null;
+  } catch {
+    return null;
+  }
+}
+async function runUpdateCommand(input = {}) {
+  const log = input.log ?? ((line) => console.log(line));
+  const isSea = input.isSea ?? isRunningAsSea();
+  const current = input.currentVersion ?? CLI_VERSION;
+  const dataDir = input.dataDir ?? defaultDataDir$1();
+  const fetchFn = input.fetchFn ?? fetch;
+  const insecure = input.allowInsecureHttp ?? false;
+  if (!isSea) {
+    log(`aielia update only replaces the standalone binary. This copy was installed with npm — run: ${NPM_UPDATE_HINT}`);
+    return 1;
+  }
+  let release;
+  try {
+    const result = await fetchLatestRelease(input);
+    if ("notModified" in result) throw new Error("unexpected 304");
+    release = result.release;
+    writeCache(dataDir, { checkedAt: (input.now ?? Date.now)(), latestVersion: release.version, latestTag: release.tag, etag: result.etag });
+  } catch (err) {
+    log(`Could not check for updates: ${err.message}`);
+    return 1;
+  }
+  if (compareVersions(release.version, current) <= 0) {
+    log(`aielia ${current} is up to date.`);
+    return 0;
+  }
+  const key = platformKey(input);
+  const asset = release.assets[key];
+  if (!asset) {
+    log(`Release ${release.tag} has no build for ${key}.`);
+    return 1;
+  }
+  if (input.dryRun) {
+    log(`Update available: ${current} → ${release.version} (${release.tag}). Would download ${asset.url}`);
+    return 0;
+  }
+  const execPath = input.execPath ?? process.execPath;
+  const tmp = `${execPath}.update.tmp`;
+  try {
+    assertHttps(asset.url, insecure);
+    log(`Downloading aielia ${release.version} (${key})…`);
+    const actual = await downloadTo(fetchFn, asset.url, tmp);
+    const sidecar = await fetchSidecarHash(fetchFn, asset.url);
+    const expected = asset.sha256 ?? sidecar;
+    if (!expected) throw new Error("No checksum available for this release — refusing to install an unverified binary");
+    if (actual !== expected) throw new Error(`Checksum mismatch (expected ${expected}, got ${actual}) — download discarded`);
+    if (asset.sha256 && sidecar && sidecar !== asset.sha256) {
+      throw new Error("Checksum sidecar disagrees with the release manifest — download discarded");
+    }
+    mkdirSync(dirname(execPath), { recursive: true });
+    replaceBinary(execPath, tmp, input.platform);
+    log(`Updated aielia ${current} → ${release.version}. Restart to use the new version.`);
+    return 0;
+  } catch (err) {
+    rmSync(tmp, { force: true });
+    log(`Update failed: ${err.message}`);
+    return 1;
+  }
+}
+const defaultDataDir = join(homedir(), ".buildaharness", "personal-assistant");
+const defaultConfigStore = new NodeConfigStore(join(defaultDataDir, "config.json"));
+const defaultRemindersFile = join(defaultDataDir, "reminders", "reminders.json");
+const defaultEnvOverrides = envOverridesFromProcessEnv(process.env);
+const defaultNonInteractiveApprovalMode = resolveNonInteractiveApprovalMode(process.env);
+const defaultBackend = createNodeFsBackend();
+function buildEmailSender(config) {
+  if (!config.enableEmail || !config.emailFrom) return void 0;
+  if (config.emailProvider === "smtp" && config.smtpHost && config.smtpPort) {
+    return createSmtpSender({
+      host: config.smtpHost,
+      port: config.smtpPort,
+      auth: config.smtpUser && config.smtpPass ? { user: config.smtpUser, pass: config.smtpPass } : void 0,
+      from: config.emailFrom
+    });
+  }
+  if (config.emailProvider === "resend" && config.resendApiKey) {
+    return createResendSender({ apiKey: config.resendApiKey, from: config.emailFrom });
+  }
+  return void 0;
+}
+function buildLlmClient(config, workspaceRoot, remindersFile) {
+  switch (config.llmBackend) {
+    case "claude-cli":
+      return new ClaudeCliLLMClient({
+        fileTools: { workspaceRoot },
+        remindersFile,
+        shellTools: config.enableShell ? { workspaceRoot } : void 0,
+        webTools: config.enableWeb ? { braveApiKey: config.braveApiKey } : void 0,
+        actionTools: config.enableEmail ? { workspaceRoot } : void 0
+      });
+    case "anthropic":
+      return new AnthropicLLMClient({ apiKey: config.apiKey ?? "" });
+    case "openai":
+      return new OpenAICompatibleLLMClient({ apiKey: config.apiKey ?? "", baseUrl: OPENAI_BASE_URL, defaultModel: OPENAI_DEFAULT_MODEL });
+    case "openrouter":
+      return new OpenAICompatibleLLMClient({
+        apiKey: config.apiKey ?? "",
+        baseUrl: OPENROUTER_BASE_URL,
+        defaultModel: OPENROUTER_DEFAULT_MODEL,
+        extraHeaders: OPENROUTER_EXTRA_HEADERS
+      });
+    case "proxy":
+      return new LLMClient({ proxyUrl: config.proxyUrl, authToken: config.authToken });
+  }
+}
+async function buildAssistant(config, { backend, dataDir, remindersFile }) {
+  const workspaceRoot = config.workspaceRoot ?? process.cwd();
+  const search = (query) => braveSearch(query, config.braveApiKey);
+  const llmClient = buildLlmClient(config, workspaceRoot, remindersFile);
+  return PersonalAssistant.create({
+    llmClient,
+    model: config.model,
+    // config.activeProject (set via /project <name>) overrides the default of "the workspace
+    // I'm running in" — see PersonalAssistantOptions.activeProject's doc comment.
+    activeProject: config.activeProject || workspaceRoot,
+    memory: new FileSystemAdapter({ backend, baseDir: dataDir, namespace: "transcripts" }),
+    experienceStore: await FileSystemExperienceStore.create({ backend, baseDir: dataDir, namespace: "experience" }),
+    checkpointStore: new FileSystemAdapter({ backend, baseDir: dataDir, namespace: "checkpoints" }),
+    reminderStore: new InMemoryReminderStore(new FileSystemAdapter({ backend, baseDir: dataDir, namespace: "reminders" })),
+    fileTools: { backend, workspaceRoot },
+    webTools: config.enableWeb ? { search } : void 0,
+    // executeCommand is the real child_process.spawn-based implementation (shell-executor.ts) —
+    // wired in here, not inside assistant.ts, so the browser build never needs node:child_process.
+    shellTools: config.enableShell ? { backend, workspaceRoot, timeoutMs: config.shellTimeoutMs, networkAllowlist: config.shellNetworkAllowlist, executeCommand: runApprovedShellCommand } : void 0,
+    // The Resend/SMTP transport is wired in here, not inside assistant.ts, so the browser build
+    // never needs nodemailer or a mail server — same split as shellTools' executeCommand.
+    actionTools: (() => {
+      const sendEmail = buildEmailSender(config);
+      return sendEmail ? { backend, workspaceRoot, sendEmail } : void 0;
+    })(),
+    dangerouslySkipPermissions: config.dangerouslySkipPermissions,
+    spendCap: config.sessionCostLimitUsd !== void 0 || config.sessionCallLimit !== void 0 ? { sessionCostLimitUsd: config.sessionCostLimitUsd, sessionCallLimit: config.sessionCallLimit } : void 0,
+    // Resolved through the shared config seam (cli-config.ts's envOverridesFromProcessEnv reads
+    // ASSISTANT_ONE_LOOP into config.oneLoopMode; /config set oneLoopMode persists it) so the CLI,
+    // chat-ui, and the Tauri desktop build all decide this the same way. Undefined here means
+    // PersonalAssistant falls back to DEFAULT_ONE_LOOP_MODE.
+    oneLoopMode: config.oneLoopMode,
+    // P11 of the internal plan — resolved through the same shared config
+    // seam as oneLoopMode above (ASSISTANT_PLAN_MODE / `/config set planMode`). Undefined here
+    // means PersonalAssistant falls back to DEFAULT_PLAN_MODE ('legacy').
+    planMode: config.planMode
+  });
+}
+async function runCli(options = {}) {
+  const dataDir = options.dataDir ?? defaultDataDir;
+  const configStore = options.configStore ?? defaultConfigStore;
+  const backend = options.backend ?? defaultBackend;
+  const remindersFile = options.remindersFile ?? defaultRemindersFile;
+  const envOverrides = options.envOverrides ?? defaultEnvOverrides;
+  const nonInteractiveApprovalMode = options.nonInteractiveApprovalMode ?? defaultNonInteractiveApprovalMode;
+  const inputStream = options.input ?? process.stdin;
+  const outputStream = options.output ?? process.stdout;
+  let persisted = await configStore.load();
+  let { config, overriddenKeys } = resolveConfig(persisted, envOverrides);
+  if (!options.skipFirstRunSetup && !options.assistant) {
+    const isInteractive = inputStream.isTTY === true;
+    let setupRl;
+    const firstRunAsk = options.firstRunAsk ?? ((question) => {
+      setupRl ?? (setupRl = createInterface({ input: inputStream, output: outputStream }));
+      return new Promise((resolvePrompt) => {
+        setupRl.question(question, (answer) => resolvePrompt(answer.trim()));
+      });
+    });
+    try {
+      persisted = await maybeRunFirstRunSetup({
+        configStore,
+        persisted,
+        overriddenKeys,
+        isInteractive,
+        ask: firstRunAsk,
+        detectClaudeCli: options.detectClaudeCli ?? (async () => (await checkClaudeCli(process.env.CLAUDE_PATH ?? "claude")).ok),
+        log: (line) => outputStream.write(`${line}
+`)
+      });
+    } finally {
+      setupRl == null ? void 0 : setupRl.close();
+    }
+    ({ config, overriddenKeys } = resolveConfig(persisted, envOverrides));
+  }
+  try {
+    validateConfig({}, config);
+  } catch (err) {
+    if (!(err instanceof ConfigValidationError)) throw err;
+    console.error(err.message);
+    process.exit(1);
+  }
+  if (nonInteractiveApprovalMode === "require-tty" && !process.stdin.isTTY) {
+    console.error(
+      `ASSISTANT_NON_INTERACTIVE_APPROVAL=require-tty is set, but stdin is not a real TTY (piped/scripted input). Refusing to start rather than fail confusingly at the first approval prompt — see README.md's "Non-interactive / scripted use" section for the alternative (ASSISTANT_NON_INTERACTIVE_APPROVAL=decline).`
+    );
+    process.exit(1);
+  }
+  let assistant = options.assistant ?? await buildAssistant(config, { dataDir, backend, remindersFile });
+  const rl = createInterface({ input: options.input ?? process.stdin, output: options.output ?? process.stdout, prompt: "you> " });
+  rl.pause();
+  rl.on("SIGINT", () => {
+    console.log("\nExiting.");
+    process.exit(0);
+  });
+  const backendDisplayModel = {
+    proxy: ANTHROPIC_DEFAULT_MODEL,
+    "claude-cli": "(your Claude Code default)",
+    anthropic: ANTHROPIC_DEFAULT_MODEL,
+    openai: OPENAI_DEFAULT_MODEL,
+    openrouter: OPENROUTER_DEFAULT_MODEL
+  };
+  console.log(`backend: ${config.llmBackend} (${config.model ?? backendDisplayModel[config.llmBackend]})`);
+  const enabledCapabilities = [];
+  if (config.enableWeb) enabledCapabilities.push("web search/fetch (brave)");
+  if (config.enableShell) enabledCapabilities.push(`shell commands (${config.dangerouslySkipPermissions ? "NOT approval-gated" : "approval-gated"})`);
+  const capabilitySuffix = enabledCapabilities.length > 0 ? ` — enabled: ${enabledCapabilities.join(", ")}` : "";
+  const dangerBanner = config.dangerouslySkipPermissions ? "\n⚠ dangerouslySkipPermissions is ON — every approval prompt (risky messages, file writes, shell commands) is skipped automatically.\n" : "";
+  const nonInteractiveBanner = nonInteractiveApprovalMode === "decline" ? "\nASSISTANT_NON_INTERACTIVE_APPROVAL=decline is set — every approval prompt auto-declines.\n" : "";
+  const startupUndoLogEntries = await assistant.listUndoLogEntries();
+  const undoableFromBefore = startupUndoLogEntries.filter((e) => e.undoable).length;
+  const undoBanner = undoableFromBefore > 0 ? `
+${undoableFromBefore} action${undoableFromBefore === 1 ? "" : "s"} from earlier sessions ${undoableFromBefore === 1 ? "is" : "are"} still revertible — see /undo-action.
+` : "";
+  console.log(`Aielia — your personal assistant on the 11-layer harness, one turn at a time. Ctrl+C to exit.${capabilitySuffix}
+${dangerBanner}${nonInteractiveBanner}${undoBanner}`);
+  console.log("Type /help to see all commands, /config to view settings.\n");
+  rl.prompt();
+  let lastTrace;
+  let lastSources;
+  let lastPlanStatus;
+  let lastTurnUsage;
+  let lastTurnToolSteps = [];
+  let lastNoTraceReason;
+  const rememberedActionKinds = /* @__PURE__ */ new Set();
+  const rememberedRiskLevels = /* @__PURE__ */ new Set();
+  const APPROVAL_OPTIONS = [
+    { key: "y", label: "Yes" },
+    { key: "a", label: "Yes, don't ask again this session" },
+    { key: "n", label: "No" }
+  ];
+  function withCostEstimate(usage) {
+    if (config.llmBackend === "claude-cli" || usage.costUsd !== void 0) return usage;
+    const estimated = estimateCostUsd(config.model ?? ANTHROPIC_DEFAULT_MODEL, usage);
+    return estimated !== void 0 ? { ...usage, costUsd: estimated } : usage;
+  }
+  const PLAN_TASK_STATUS_ICON = {
+    PENDING: "○",
+    RUNNING: "▶",
+    COMPLETE: "✓",
+    FAILED: "✗",
+    BLOCKED: "✗",
+    HUMAN_REQUIRED: "~"
+  };
+  function printPlan() {
+    if (!lastPlanStatus) {
+      console.log("\nNo active plan for this session.\n");
+      return;
+    }
+    const lines = [
+      PLAN_LINE_PREFIX,
+      `Plan: ${lastPlanStatus.templateName ?? "custom plan"} (${lastPlanStatus.completionPct.toFixed(1)}% complete)`,
+      ...lastPlanStatus.tasks.map((task) => `  ${PLAN_TASK_STATUS_ICON[task.status] ?? "?"} [${task.status}] ${task.id} — ${task.description}`),
+      `Success criteria: ${lastPlanStatus.successCriteria}`
+    ];
+    console.log(`
+${lines.join("\n")}
+`);
+  }
+  async function handlePlanSketch(args) {
+    const request = args.join(" ").trim();
+    if (!request) {
+      console.log("\nUsage: /plan sketch <request>\n");
+      return;
+    }
+    console.log("\nSketching a plan (read-only grounding only, nothing staged)...\n");
+    const result = await assistant.sketchPlan("cli", request);
+    console.log(`Aielia> ${result.reply ?? "(no reply)"}
+`);
+    if (result.usage) lastTurnUsage = withCostEstimate(result.usage);
+  }
+  async function handlePlan(args) {
+    if (args[0] === "sketch") {
+      await handlePlanSketch(args.slice(1));
+      return;
+    }
+    printPlan();
+  }
+  function verificationHealthLabel({ strength, feasibility }) {
+    const confidence = Math.min(strength, feasibility);
+    if (confidence >= 0.7) return "High confidence";
+    if (confidence >= 0.4) return "Reasonably confident";
+    return "Worth double-checking";
+  }
+  function batchBudgetSummaryLine(batchBudget) {
+    const found = batchBudget.perItemOutcomes.filter((o) => o.status === "found").length;
+    const notFound = batchBudget.perItemOutcomes.filter((o) => o.status === "not_found").length;
+    const truncated = batchBudget.perItemOutcomes.filter((o) => o.status === "truncated_while_productive").length;
+    return `Batch: ${batchBudget.itemCount} items — ${found} found, ${notFound} not found, ${truncated} truncated (${batchBudget.totalCallsUsed} calls used, projected ~${Math.ceil(batchBudget.projectedTotal)})`;
+  }
+  function printWhy() {
+    if (!lastTrace) {
+      console.log(`
+${lastNoTraceReason ?? "No harness trace for the last turn (nothing to explain yet, or it took the fast path)."}
+`);
+      return;
+    }
+    console.log(`
+${verificationHealthLabel(lastTrace.verificationHealth)}`);
+    const chain = buildWhyChain(lastTrace.layerActivity);
+    if (chain.length > 0) {
+      console.log("  " + chain.map((item) => `${LAYER_SHORT_CODE[item.layer]} (${item.reason})`).join(" > "));
+    }
+    if (lastTrace.batchBudget) {
+      console.log("  " + batchBudgetSummaryLine(lastTrace.batchBudget));
+    }
+    console.log("");
+  }
+  function printLayers() {
+    if (!lastTrace) {
+      console.log(`
+${lastNoTraceReason ?? "No harness trace for the last turn (nothing to explain yet, or it took the fast path)."}
+`);
+      return;
+    }
+    console.log("");
+    const byLayer = new Map(lastTrace.layerActivity.map((e) => [e.layer, e]));
+    for (const layer of LAYER_ORDER) {
+      const e = byLayer.get(layer);
+      const mark = (e == null ? void 0 : e.fired) ? "✓" : "·";
+      const reason = (e == null ? void 0 : e.reason) ?? "not evaluated this turn";
+      console.log(`  [${mark}] ${LAYER_DISPLAY_NAME[layer].padEnd(22)} ${reason}`);
+    }
+    if (lastTrace.batchBudget) {
+      console.log("");
+      console.log(`  ${batchBudgetSummaryLine(lastTrace.batchBudget)}`);
+      const STATUS_MARK = {
+        found: "✓",
+        not_found: "✗",
+        truncated_while_productive: "~"
+      };
+      for (const outcome of lastTrace.batchBudget.perItemOutcomes) {
+        console.log(`    [${STATUS_MARK[outcome.status]}] ${outcome.item.padEnd(30)} ${outcome.status} (${outcome.callsUsed} calls)`);
+      }
+    }
+    console.log("");
+  }
+  const SOURCE_TOOL_LABEL = {
+    read_file: "Read",
+    list_directory: "Listed",
+    web_search: "Searched",
+    fetch_url: "Fetched"
+  };
+  function printSources() {
+    if (!lastSources || lastSources.length === 0) {
+      console.log("\nNo sources for the last turn (it used no file/web tool calls).\n");
+      return;
+    }
+    console.log("");
+    for (const source of lastSources) {
+      console.log(`  - ${SOURCE_TOOL_LABEL[source.tool]} ${source.path}`);
+    }
+    console.log("");
+  }
+  function printHelp() {
+    console.log(`
+${formatHelp()}
+`);
+  }
+  async function handleClear() {
+    await assistant.clearSession("cli");
+    lastTrace = void 0;
+    lastSources = void 0;
+    lastPlanStatus = void 0;
+    lastTurnUsage = void 0;
+    lastNoTraceReason = void 0;
+    console.log("\n✓ Started a fresh conversation.\n");
+  }
+  async function handleCheckpoint(args) {
+    if (args[0] === "clear") {
+      const result = await assistant.clearCheckpoint("cli");
+      console.log(
+        result.cleared ? `
+✓ Cleared the stuck checkpoint (was at step ${result.stepsUsed}, node "${result.currentNode}"). Conversation history is untouched — your next message starts a fresh harness run.
+` : "\nNo checkpoint to clear — the last turn either completed normally or there was nothing in progress.\n"
+      );
+      return;
+    }
+    const status = await assistant.getCheckpointStatus("cli");
+    if (!status.present) {
+      console.log("\nNo checkpoint present — the last turn completed normally or there was nothing in progress.\n");
+      return;
+    }
+    const attemptsNote = status.failedResumeAttempts > 0 ? ` — failed to resume ${status.failedResumeAttempts} time${status.failedResumeAttempts === 1 ? "" : "s"} in a row so far` : "";
+    console.log(
+      `
+A checkpoint is present: step ${status.stepsUsed}, last node "${status.currentNode}"${attemptsNote}.
+Your next message will try to resume it automatically. Run /checkpoint clear to discard it and start fresh instead.
+`
+    );
+  }
+  async function printStatus() {
+    const transcript = await assistant.getTranscript("cli");
+    const undoLogEntries = await assistant.listUndoLogEntries();
+    const spendCapLine = await spendCapStatusLine();
+    console.log(
+      `
+${formatStatus({ config, overriddenKeys, transcriptLength: transcript.length, planActive: lastPlanStatus !== void 0, undoLogEntries, spendCapLine })}
+`
+    );
+  }
+  async function spendCapStatusLine() {
+    if (config.sessionCostLimitUsd === void 0 && config.sessionCallLimit === void 0) return void 0;
+    const state = await assistant.getSpendState("cli");
+    return formatSpendCapStatus(state, { sessionCostLimitUsd: config.sessionCostLimitUsd, sessionCallLimit: config.sessionCallLimit });
+  }
+  async function handleExport(args) {
+    const transcript = await assistant.getTranscript("cli");
+    if (transcript.length === 0) {
+      console.log("\nNothing to export yet.\n");
+      return;
+    }
+    const filename = resolve(process.cwd(), args[0] ?? defaultExportFilename());
+    try {
+      await writeFile(filename, formatTranscriptMarkdown(transcript), "utf-8");
+      console.log(`
+✓ Exported ${transcript.length} message${transcript.length === 1 ? "" : "s"} to ${filename}
+`);
+    } catch (err) {
+      const { message } = classifyError(err);
+      console.log(`
+[error] ${message}
+`);
+    }
+  }
+  async function handleUndo() {
+    const transcriptBefore = await assistant.getTranscript("cli");
+    if (transcriptBefore.length === 0) {
+      console.log("\nNothing to undo.\n");
+      return;
+    }
+    const wasPendingApproval = transcriptBefore[transcriptBefore.length - 1].role !== "assistant";
+    const undoneReminders = lastTurnToolSteps.filter((s) => s.tool === "create_reminder");
+    const result = await assistant.undoLastTurn("cli");
+    if (!result.undone) {
+      console.log("\nNothing to undo.\n");
+      return;
+    }
+    lastTrace = void 0;
+    lastSources = void 0;
+    lastPlanStatus = void 0;
+    lastTurnToolSteps = [];
+    const caveat = undoneReminders.length > 0 ? ` Note: ${undoneReminders.length === 1 ? "a reminder" : `${undoneReminders.length} reminders`} created in that exchange (${undoneReminders.map((s) => `"${s.input.text}"`).join(", ")}) ${undoneReminders.length === 1 ? "is" : "are"} still active — /undo only removes chat history, not that side effect.` : "";
+    console.log(
+      `
+✓ Removed ${wasPendingApproval ? "the pending message awaiting approval" : "the last exchange (1 user message, 1 assistant reply)"}.${caveat}
+`
+    );
+  }
+  async function handleUndoAction(args) {
+    if (args.length === 0) {
+      const entries = await assistant.listUndoLogEntries();
+      console.log(`
+${formatUndoLogListing(entries)}
+`);
+      return;
+    }
+    const staged = await assistant.stageUndoAction(args[0]);
+    if (staged.status === "error") {
+      console.log(`
+✗ ${staged.message}
+`);
+      return;
+    }
+    console.log(`
+[needs approval — revert] ${staged.reason}`);
+    const confirmed = await askYesNo("Apply this revert? (y/N) ");
+    lastTrace = void 0;
+    lastNoTraceReason = `No harness trace — the last turn was a staged revert that was ${confirmed ? "approved" : "declined"} before the harness ran.`;
+    await handleTurn("", confirmed, staged.pendingActionId);
+  }
+  async function printMemory() {
+    const summary = await assistant.getMemorySummary("cli");
+    console.log(`
+${formatMemorySummary(summary)}
+`);
+  }
+  async function handleMemoryExport(args) {
+    const data = await assistant.exportMemory("cli");
+    const filename = resolve(process.cwd(), args[0] ?? defaultMemoryExportFilename());
+    try {
+      await writeFile(filename, formatMemoryExport(data), "utf-8");
+      console.log(`
+✓ Exported learned memory to ${filename}
+`);
+    } catch (err) {
+      const { message } = classifyError(err);
+      console.log(`
+[error] ${message}
+`);
+    }
+  }
+  async function handleMemoryPending(action, args) {
+    const selector = args[0];
+    if (!selector) {
+      console.log(`
+Usage: /memory ${action} <n> or /memory ${action} <category>
+`);
+      return;
+    }
+    const outcome = action === "confirm" ? await assistant.confirmPendingFact(selector) : await assistant.rejectPendingFact(selector);
+    console.log(`
+${formatMemoryPendingOutcome(action === "confirm" ? "confirmed" : "rejected", outcome)}
+`);
+  }
+  async function handleMemoryForget(args) {
+    const selector = args[0];
+    if (!selector) {
+      console.log("\nUsage: /memory forget <n>\n");
+      return;
+    }
+    const outcome = await assistant.forgetFact(selector, "cli");
+    console.log(`
+${formatMemoryPendingOutcome("forgotten", outcome)}
+`);
+  }
+  async function handleMemory(args) {
+    if (args[0] === "export") {
+      await handleMemoryExport(args.slice(1));
+      return;
+    }
+    if (args[0] === "confirm" || args[0] === "reject") {
+      await handleMemoryPending(args[0], args.slice(1));
+      return;
+    }
+    if (args[0] === "forget") {
+      await handleMemoryForget(args.slice(1));
+      return;
+    }
+    await printMemory();
+  }
+  async function handleSearch(args) {
+    const query = args.join(" ");
+    if (!query.trim()) {
+      console.log("\nUsage: /search <query>\n");
+      return;
+    }
+    const hits = await assistant.searchTranscript(query);
+    console.log(`
+${formatSearchResults(hits, query)}
+`);
+  }
+  async function printCost() {
+    const spendCapLine = await spendCapStatusLine();
+    const spendState = await assistant.getSpendState("cli");
+    const session = { inputTokens: spendState.cumulativeInputTokens, outputTokens: spendState.cumulativeOutputTokens, costUsd: spendState.cumulativeCostUsd };
+    console.log(`
+${formatCostSummary({ lastTurn: lastTurnUsage, session, backend: config.llmBackend, spendCapLine })}
+`);
+  }
+  async function handleDoctor() {
+    const workspaceRoot = config.workspaceRoot ?? process.cwd();
+    const checks = await Promise.all([
+      // Backend-specific checks only run for the backend actually in use — skipped, not
+      // reported as failing, for the one that's inactive.
+      ...config.llmBackend === "proxy" ? [checkProxyHealth(config.proxyUrl)] : [],
+      ...config.llmBackend === "claude-cli" ? [checkClaudeCli(process.env.CLAUDE_PATH ?? "claude")] : [],
+      checkWorkspaceRoot(workspaceRoot),
+      checkDataDirWritable(backend, dataDir),
+      // Informational only (always ok:true) — surfaces the active backend/flags so a user has
+      // one command to confirm config, rather than none (see file's own config summary gap).
+      { label: `llmBackend: ${config.llmBackend}`, ok: true },
+      { label: `enableShell: ${config.enableShell ?? false}, enableWeb: ${config.enableWeb ?? false}`, ok: true },
+      // Provider API keys are stored plaintext in config.json, not an OS keychain — confirming
+      // that explicitly here rather than leaving it unstated (no keychain integration exists).
+      { label: "provider keys stored: plaintext in config.json (no OS keychain integration)", ok: true }
+    ]);
+    console.log(`
+${formatDoctorReport(checks)}
+`);
+  }
+  let lastProgressLineLength = 0;
+  function writeProgress(progress) {
+    const layer = nodeToLayer(progress.currentNode);
+    const label = layer ? LAYER_DISPLAY_NAME[layer] : nodeDisplayName(progress.currentNode);
+    const prefix = progress.planPosition ? `[${progress.planPosition.templateName ?? "custom plan"} — step ${progress.planPosition.stepIndex}/${progress.planPosition.stepCount} (${progress.planPosition.completionPct.toFixed(0)}%)]` : `[step ${progress.stepsUsed}/${progress.maxSteps}]`;
+    const line = `${prefix}${label ? ` ${label}…` : ""}`;
+    process.stdout.write(`\r${line.padEnd(lastProgressLineLength)}`);
+    lastProgressLineLength = line.length;
+  }
+  function clearProgress() {
+    if (lastProgressLineLength === 0) return;
+    process.stdout.write(`\r${" ".repeat(lastProgressLineLength)}\r`);
+    lastProgressLineLength = 0;
+  }
+  function writeToolStep(step) {
+    clearProgress();
+    if (step.deniedReason) {
+      console.log(`  ${ICONS.deniedStep} Denied: ${step.summary} — ${step.deniedReason}`);
+    } else {
+      console.log(`  ${toolStepIcon(step.tool)} ${step.summary}`);
+    }
+    lastTurnToolSteps.push(step);
+  }
+  function emptyClarificationDraft() {
+    return { selectedLabels: [], editText: "", freeText: "" };
+  }
+  function orderedAskOptions(question) {
+    const options2 = question.options ?? [];
+    return options2.map((option, index) => ({ option, index })).sort((a, b) => Number(b.option.recommended ?? false) - Number(a.option.recommended ?? false) || a.index - b.index).map(({ option }) => option);
+  }
+  function clarificationDraftToAnswer(questionId, draft) {
+    if (draft.selectedLabels.length > 0) {
+      return draft.editText.trim() ? { questionId, kind: "selected_with_edit", selectedLabels: draft.selectedLabels, editText: draft.editText.trim() } : { questionId, kind: "selected", selectedLabels: draft.selectedLabels };
+    }
+    if (draft.freeText.trim()) {
+      return { questionId, kind: "free_text", freeText: draft.freeText.trim() };
+    }
+    return null;
+  }
+  function printClarificationQuestion(question, draft, index, total) {
+    const options2 = orderedAskOptions(question);
+    const allowFreeText = question.allowFreeText !== false;
+    console.log("");
+    if (question.header) console.log(`[${question.header}]`);
+    if (total > 1) console.log(`Question ${index + 1} of ${total}`);
+    console.log(question.question);
+    options2.forEach((option, i) => {
+      const n = i + 1;
+      const picked = draft.selectedLabels.includes(option.label) ? "✓" : " ";
+      const recommended = option.recommended ? " (recommended)" : "";
+      console.log(`  [${picked}] ${n}) ${option.label}${recommended}`);
+      if (option.description) console.log(`        ${option.description}`);
+      if (option.preview) console.log(`        preview: ${option.preview}`);
+    });
+    if (draft.editText) console.log(`  note: ${draft.editText}`);
+    if (draft.freeText) console.log(`  other: ${draft.freeText}`);
+    const commands2 = [
+      options2.length > 0 ? question.allowMultiple ? "<n>/t<n> toggle option" : "<n> select option" : void 0,
+      options2.length > 0 ? "e<n> add a note to a selected option" : void 0,
+      allowFreeText ? "o other (free text)" : void 0,
+      total > 1 ? "b back, n next" : void 0,
+      "s submit"
+    ].filter((c) => c !== void 0);
+    console.log(`  (${commands2.join(" | ")})`);
+  }
+  async function handleClarification(result) {
+    const questions = result.questions ?? [];
+    const pendingClarificationId = result.pendingClarificationId;
+    if (questions.length === 0 || !pendingClarificationId) {
+      lastTrace = void 0;
+      lastNoTraceReason = `No harness trace — the last turn needed clarification (${result.reason ?? "no further detail"}) but had no answerable questions.`;
+      console.log(`
+[needs clarification] ${result.reason ?? "This request needs clarification."}
+`);
+      return;
+    }
+    if (nonInteractiveApprovalMode === "decline") {
+      console.log(`
+[non-interactive mode: auto-declining — ASSISTANT_NON_INTERACTIVE_APPROVAL=decline]`);
+      console.log(`
+[needs clarification] ${result.reason ?? "This request needs clarification."}`);
+      for (const q of questions) console.log(`  - ${q.question}`);
+      console.log("");
+      lastTrace = void 0;
+      lastNoTraceReason = "No harness trace — the last turn needed clarification and was auto-declined (non-interactive mode) before the harness resumed.";
+      return;
+    }
+    console.log(`
+[needs clarification] ${questions.length} question${questions.length === 1 ? "" : "s"} to answer.`);
+    const drafts = new Map(questions.map((q) => [q.id, emptyClarificationDraft()]));
+    let index = 0;
+    while (true) {
+      const question = questions[index];
+      const draft = drafts.get(question.id);
+      printClarificationQuestion(question, draft, index, questions.length);
+      const token = (await askLine("clarify> ")).trim();
+      const lower = token.toLowerCase();
+      if (lower === "s" || lower === "submit") {
+        const answers = questions.map((q) => clarificationDraftToAnswer(q.id, drafts.get(q.id)));
+        const missing = questions.filter((q, i) => answers[i] === null);
+        if (missing.length > 0) {
+          console.log(`
+Still need an answer for: ${missing.map((q) => q.question).join("; ")}
+`);
+          continue;
+        }
+        const response = { answers };
+        await handleTurn("", false, void 0, pendingClarificationId, response);
+        return;
+      }
+      if (lower === "b" && questions.length > 1) {
+        index = Math.max(0, index - 1);
+        continue;
+      }
+      if (lower === "n" && questions.length > 1) {
+        index = Math.min(questions.length - 1, index + 1);
+        continue;
+      }
+      if (lower === "o") {
+        if (question.allowFreeText === false) {
+          console.log("\nThis question does not accept a free-text answer.\n");
+          continue;
+        }
+        const text = await askLine("Other — type your own answer: ");
+        if (!text.trim()) {
+          console.log("\nEmpty answer ignored.\n");
+          continue;
+        }
+        drafts.set(question.id, { selectedLabels: [], editText: "", freeText: text.trim() });
+        continue;
+      }
+      const editMatch = /^e(\d+)$/i.exec(token);
+      if (editMatch) {
+        const options2 = orderedAskOptions(question);
+        const option = options2[Number(editMatch[1]) - 1];
+        if (!option) {
+          console.log(`
+No option ${editMatch[1]}.
+`);
+          continue;
+        }
+        if (!draft.selectedLabels.includes(option.label)) {
+          console.log(`
+Select option ${editMatch[1]} first, then add a note with e${editMatch[1]}.
+`);
+          continue;
+        }
+        const note = await askLine("Note: ");
+        drafts.set(question.id, { ...draft, editText: note.trim() });
+        continue;
+      }
+      const toggleMatch = /^t(\d+)$/i.exec(token) ?? /^(\d+)$/.exec(token);
+      if (toggleMatch) {
+        const options2 = orderedAskOptions(question);
+        const option = options2[Number(toggleMatch[1]) - 1];
+        if (!option) {
+          console.log(`
+No option ${toggleMatch[1]}.
+`);
+          continue;
+        }
+        if (question.allowMultiple) {
+          const already = draft.selectedLabels.includes(option.label);
+          drafts.set(question.id, {
+            ...draft,
+            selectedLabels: already ? draft.selectedLabels.filter((l) => l !== option.label) : [...draft.selectedLabels, option.label],
+            freeText: ""
+          });
+        } else {
+          drafts.set(question.id, { ...draft, selectedLabels: [option.label], freeText: "" });
+        }
+        continue;
+      }
+      console.log(`
+Unrecognized input "${token}".
+`);
+    }
+  }
+  async function handleTurn(message, approved = false, pendingActionId, pendingClarificationId, clarificationAnswer) {
+    lastTurnToolSteps = [];
+    let streamedAnyTokens = false;
+    function writeToken(token) {
+      if (!streamedAnyTokens) {
+        process.stdout.write("\nAielia> ");
+        streamedAnyTokens = true;
+      }
+      process.stdout.write(token);
+    }
+    try {
+      const result = await assistant.turn(message, {
+        sessionId: "cli",
+        approved,
+        pendingActionId,
+        pendingClarificationId,
+        clarificationAnswer,
+        // Gated on streamedAnyTokens: onProgress keeps firing for layers (Memory,
+        // Verification) that run after the LLM call, i.e. after writeToken has already put
+        // the reply on the current line with no trailing newline. writeProgress's \r-based
+        // overwrite doesn't know that — on a real TTY it wrote the "[step N/5] ..." text
+        // over the tail of the just-streamed reply, and the following clearProgress() then
+        // blanked that same line, so the end of the assistant's answer visibly vanished
+        // right after it finished streaming. Once streaming has started this turn, further
+        // progress has nothing safe to overwrite, so it's dropped instead.
+        onProgress: (progress) => {
+          if (!streamedAnyTokens) writeProgress(progress);
+        },
+        onToken: writeToken,
+        onToolStep: writeToolStep
+      });
+      if (!streamedAnyTokens) clearProgress();
+      if (result.status === "needs_approval" && result.pendingActionId) {
+        const kindLabel = result.pendingActionKind === "shell" ? "shell command" : result.pendingActionKind === "email" ? "send email" : result.pendingActionKind === "batch" ? "batch research" : "write";
+        const promptText = result.pendingActionKind === "shell" ? "Run this command?" : result.pendingActionKind === "email" ? "Send this email?" : result.pendingActionKind === "batch" ? "Continue?" : "Apply this write?";
+        console.log(`
+[needs approval — ${kindLabel}] ${result.reason}`);
+        let confirmed;
+        if (result.pendingActionKind && rememberedActionKinds.has(result.pendingActionKind)) {
+          console.log(`["don't ask again" active this session for ${kindLabel} — auto-approved]`);
+          confirmed = true;
+        } else {
+          const decision = await askSelect(promptText, APPROVAL_OPTIONS);
+          confirmed = decision !== "n";
+          if (decision === "a" && result.pendingActionKind) rememberedActionKinds.add(result.pendingActionKind);
+        }
+        lastTrace = void 0;
+        lastNoTraceReason = `No harness trace — the last turn was a staged ${kindLabel} that was ${confirmed ? "approved" : "declined"} before the harness ran.`;
+        await handleTurn(message, confirmed, result.pendingActionId);
+        return;
+      }
+      if (result.status === "needs_approval") {
+        console.log(`
+[needs approval — ${result.riskLevel}] ${result.reason}`);
+        console.log(`  "${message}"`);
+        let confirmed;
+        if (result.riskLevel && rememberedRiskLevels.has(result.riskLevel)) {
+          console.log(`["don't ask again" active this session for risk level ${result.riskLevel} — auto-approved]`);
+          confirmed = true;
+        } else {
+          const decision = await askSelect("Proceed?", APPROVAL_OPTIONS);
+          confirmed = decision !== "n";
+          if (decision === "a" && result.riskLevel) rememberedRiskLevels.add(result.riskLevel);
+        }
+        if (confirmed) {
+          await handleTurn(message, true);
+        } else {
+          lastTrace = void 0;
+          lastNoTraceReason = "No harness trace — the last turn was blocked on an approval gate and declined before the harness ran.";
+          await assistant.recordDeclinedRequest("cli", message, result.reason ?? "This request needed approval.");
+          console.log("Cancelled.\n");
+        }
+        return;
+      }
+      if (result.status === "needs_clarification") {
+        await handleClarification(result);
+        return;
+      }
+      if (result.status === "escalated") {
+        lastTrace = void 0;
+        lastNoTraceReason = `No harness trace — the last turn escalated (${result.reason}) before completing.`;
+        console.log(`
+[escalated] ${result.reason}
+`);
+        return;
+      }
+      if (!pendingActionId) {
+        lastTrace = result.harnessSkipped ? void 0 : result.trace;
+        lastNoTraceReason = result.harnessSkipped ? "No harness trace — the last turn was a simple, self-contained question answered directly without activating the harness (fast path)." : void 0;
+      }
+      lastSources = result.sources;
+      if (!pendingActionId && !result.harnessSkipped) lastPlanStatus = result.planStatus;
+      lastTurnUsage = result.usage ? withCostEstimate(result.usage) : void 0;
+      const riskSuffix = result.riskLevel && result.riskLevel !== "LOW" ? ` [risk: ${result.riskLevel}]` : "";
+      const sourcesHint = result.sources && result.sources.length > 0 ? ` (${result.sources.length} source${result.sources.length > 1 ? "s" : ""} — /sources)` : "";
+      const planHint = result.planStatus ? ` (plan: ${result.planStatus.completionPct.toFixed(0)}% — /plan)` : "";
+      const contradictionNotice = result.contradictionNotice ? `
+
+${result.contradictionNotice}` : "";
+      if (streamedAnyTokens) {
+        const pausedNoteText = result.pausedNote ? `
+
+${result.pausedNote}` : "";
+        process.stdout.write(`${pausedNoteText}${riskSuffix}${sourcesHint}${planHint}${contradictionNotice}
+
+`);
+      } else {
+        console.log(`
+Aielia>${riskSuffix} ${result.reply}${sourcesHint}${planHint}${contradictionNotice}
+`);
+      }
+    } catch (err) {
+      clearProgress();
+      const { message: errorMessage, retryable } = classifyError(err, config.llmBackend);
+      console.log(`
+[error] ${errorMessage}${retryable ? " Type the message again to retry." : ""}
+`);
+    }
+  }
+  function askYesNo(question) {
+    if (options.askYesNo) return options.askYesNo(question);
+    if (nonInteractiveApprovalMode === "decline") {
+      console.log(`
+[non-interactive mode: auto-declining — ASSISTANT_NON_INTERACTIVE_APPROVAL=decline]`);
+      return Promise.resolve(false);
+    }
+    return new Promise((resolve2) => {
+      try {
+        rl.question(question, (answer) => resolve2(answer.trim().toLowerCase().startsWith("y")));
+      } catch {
+        console.log(`
+[could not read a response — treating as declined]`);
+        resolve2(false);
+      }
+    });
+  }
+  function askLine(question) {
+    if (options.askLine) return options.askLine(question);
+    return new Promise((resolve2) => {
+      try {
+        rl.question(question, (answer) => resolve2(answer.trim()));
+      } catch {
+        console.log(`
+[could not read a response — treating as blank]`);
+        resolve2("");
+      }
+    });
+  }
+  function askSelect(question, selectOptions) {
+    if (options.askSelect) return options.askSelect(question, selectOptions);
+    const fallbackKey = selectOptions[selectOptions.length - 1].key;
+    if (nonInteractiveApprovalMode === "decline") {
+      console.log(`
+[non-interactive mode: auto-declining — ASSISTANT_NON_INTERACTIVE_APPROVAL=decline]`);
+      return Promise.resolve(fallbackKey);
+    }
+    const optionLines = selectOptions.map((option, i) => `  ${i + 1}) [${option.key}] ${option.label}`).join("\n");
+    return new Promise((resolve2) => {
+      try {
+        rl.question(`${question}
+${optionLines}
+> `, (answer) => {
+          var _a;
+          const trimmed = answer.trim().toLowerCase();
+          const byKey = selectOptions.find((option) => option.key.toLowerCase() === trimmed);
+          const byIndex = /^\d+$/.test(trimmed) ? selectOptions[Number(trimmed) - 1] : void 0;
+          resolve2(((_a = byKey ?? byIndex) == null ? void 0 : _a.key) ?? fallbackKey);
+        });
+      } catch {
+        console.log(`
+[could not read a response — treating as declined]`);
+        resolve2(fallbackKey);
+      }
+    });
+  }
+  async function reloadAssistant() {
+    const nextPersisted = await configStore.load();
+    ({ config, overriddenKeys } = resolveConfig(nextPersisted, envOverrides));
+    assistant = options.assistant ?? await buildAssistant(config, { dataDir, backend, remindersFile });
+  }
+  async function handleConfigCommand(args) {
+    if (args.length === 0) {
+      console.log(`
+${formatConfigListing(config, overriddenKeys)}
+`);
+      return;
+    }
+    if (args[0] === "set") {
+      const key = args[1];
+      const raw = args.slice(2).join(" ");
+      if (!key || !isConfigKey(key)) {
+        console.log(`
+✗ Unknown config key "${key ?? ""}". Known keys: ${CONFIG_KEYS.join(", ")}
+`);
+        return;
+      }
+      if (!raw) {
+        console.log(`
+Usage: /config set ${key} <value>
+`);
+        return;
+      }
+      if (overriddenKeys.has(key)) {
+        console.log(`
+✗ "${key}" is pinned by ${ENV_VAR_FOR_CONFIG_KEY[key]} — unset that env var to change it here.
+`);
+        return;
+      }
+      let value;
+      try {
+        value = parseConfigValue(key, raw);
+      } catch (err) {
+        if (!(err instanceof ConfigValueParseError)) throw err;
+        console.log(`
+✗ ${err.message}
+`);
+        return;
+      }
+      const patch = { [key]: value };
+      try {
+        validateConfig(patch, config);
+      } catch (err) {
+        if (!(err instanceof ConfigValidationError)) throw err;
+        console.log(`
+✗ ${err.message}
+`);
+        return;
+      }
+      await configStore.save(patch);
+      await reloadAssistant();
+      console.log(`
+✓ ${key} updated (took effect immediately, no restart needed)
+`);
+      return;
+    }
+    if (args[0] === "reset") {
+      const key = args[1];
+      if (key && !isConfigKey(key)) {
+        console.log(`
+✗ Unknown config key "${key}". Known keys: ${CONFIG_KEYS.join(", ")}
+`);
+        return;
+      }
+      const target = key ? `"${key}"` : "ALL settings";
+      const confirmed = await askYesNo(`
+Reset ${target} to default? This takes effect immediately. (y/N) `);
+      if (!confirmed) {
+        console.log("\nCancelled — nothing was reset.\n");
+        return;
+      }
+      const clearPatch = key ? { [key]: void 0 } : Object.fromEntries(CONFIG_KEYS.map((k) => [k, void 0]));
+      await configStore.save(clearPatch);
+      await reloadAssistant();
+      console.log(`
+✓ Reset ${key ?? "all settings"} to default
+`);
+      return;
+    }
+    console.log("\nUsage: /config | /config set <key> <value> | /config reset [key]\n");
+  }
+  async function handleModel(args) {
+    if (args.length === 0) {
+      console.log(`
+${config.model ?? "(using each backend's default)"}
+`);
+      return;
+    }
+    await handleConfigCommand(["set", "model", args.join(" ")]);
+  }
+  async function handleProject(args) {
+    if (args.length === 0) {
+      console.log(`
+${assistant.getActiveProject() || "(none)"}
+`);
+      return;
+    }
+    if (args[0] === "clear") {
+      await handleConfigCommand(["reset", "activeProject"]);
+      return;
+    }
+    await handleConfigCommand(["set", "activeProject", args.join(" ")]);
+  }
+  const commands = {
+    "/why": () => printWhy(),
+    "/layers": () => printLayers(),
+    "/sources": () => printSources(),
+    "/plan": (args) => handlePlan(args),
+    "/help": () => printHelp(),
+    "/clear": () => handleClear(),
+    "/new": () => handleClear(),
+    "/status": () => printStatus(),
+    "/export": (args) => handleExport(args),
+    "/undo": () => handleUndo(),
+    "/undo-action": (args) => handleUndoAction(args),
+    "/memory": (args) => handleMemory(args),
+    "/search": (args) => handleSearch(args),
+    "/model": (args) => handleModel(args),
+    "/project": (args) => handleProject(args),
+    "/cost": () => printCost(),
+    "/doctor": () => handleDoctor(),
+    "/config": (args) => handleConfigCommand(args),
+    "/checkpoint": (args) => handleCheckpoint(args)
+  };
+  async function dispatchOne(message) {
+    const [token, ...args] = message.split(/\s+/);
+    const handler = commands[token];
+    if (handler) {
+      await handler(args);
+      return;
+    }
+    await handleTurn(message);
+  }
+  let dispatchQueue = Promise.resolve();
+  function enqueue(message) {
+    const result = dispatchQueue.then(() => dispatchOne(message)).catch((err) => {
+      console.error("[unexpected error]", err);
+    });
+    dispatchQueue = result;
+    return result;
+  }
+  rl.on("line", (line) => {
+    const message = line.trim();
+    if (!message) {
+      rl.prompt();
+      return;
+    }
+    void enqueue(message).finally(() => rl.prompt());
+  });
+  rl.resume();
+  return {
+    dispatchLine: async (line) => {
+      const message = line.trim();
+      if (!message) return;
+      await enqueue(message);
+    },
+    close: () => rl.close(),
+    getStatusIndicators: async () => {
+      const indicators = [];
+      indicators.push(`Workspace: ${config.workspaceRoot ?? process.cwd()}`);
+      if (config.dangerouslySkipPermissions) indicators.push("⚠ Permissions: auto-approved (dangerouslySkipPermissions)");
+      if (lastPlanStatus !== void 0) indicators.push("Plan mode: active");
+      indicators.push(`Model: ${config.model ?? backendDisplayModel[config.llmBackend]}`);
+      const spendState = await assistant.getSpendState("cli");
+      indicators.push(
+        `↑${spendState.cumulativeInputTokens.toLocaleString()} ↓${spendState.cumulativeOutputTokens.toLocaleString()} tokens (~$${spendState.cumulativeCostUsd.toFixed(4)})`
+      );
+      const spendCapLine = formatSpendCapStatus(spendState, { sessionCostLimitUsd: config.sessionCostLimitUsd, sessionCallLimit: config.sessionCallLimit });
+      if (spendCapLine) indicators.push(spendCapLine);
+      return indicators;
+    }
+  };
+}
+async function main(argv = process.argv.slice(2)) {
+  const parsed = parseCliArgs(argv);
+  if (parsed.command === "version") {
+    console.log(CLI_VERSION);
+    return;
+  }
+  if (parsed.command === "help") {
+    console.log(cliHelpText(CLI_VERSION));
+    return;
+  }
+  if (parsed.command === "update") {
+    process.exitCode = await runUpdateCommand({ dryRun: parsed.dryRun });
+    return;
+  }
+  const persisted = await defaultConfigStore.load();
+  const { config } = resolveConfig(persisted, defaultEnvOverrides);
+  const isSea = isRunningAsSea();
+  if (isSea) cleanupStaleUpdateFiles();
+  if (shouldRunPassiveUpdateCheck({ updateCheck: config.updateCheck, env: process.env, stdinIsTty: Boolean(process.stdin.isTTY) })) {
+    void checkForUpdate().then((result) => {
+      if (result == null ? void 0 : result.updateAvailable) console.log(updateAvailableNotice(result.latestVersion, CLI_VERSION, isSea));
+    });
+  }
+  if (shouldLaunchTuiApp(config.tuiMode ?? "disabled", Boolean(process.stdout.isTTY), Boolean(process.stdin.isTTY))) {
+    const { runTuiApp } = await import("./tui-app-4_TrzESz.js");
+    await runTuiApp();
+    return;
+  }
+  await runCli();
+}
+function entryArgMatchesModule(entryArg, moduleHref, resolveReal = realpathSync) {
+  if (entryArg === void 0) return false;
+  try {
+    return moduleHref === pathToFileURL(resolveReal(entryArg)).href;
+  } catch {
+    return false;
+  }
+}
+function isEntryModule() {
+  return entryArgMatchesModule(process.argv[1], import.meta.url);
+}
+if (isEntryModule()) void main();
+void main();
+export {
+  ICONS as I,
+  PLAN_LINE_PREFIX as P,
+  runCli as r
+};
+//# sourceMappingURL=bin-CqkqT6KK.js.map