@buildaharness/aielia 0.3.1 → 0.3.2

package/dist/cli.js

@@ -1,1693 +1,3 @@
 #!/usr/bin/env node
-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 { realpathSync } from "node:fs";
-import { tmpdir, homedir } from "node:os";
-import { dirname, join, 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 { w as buildClaudePrompt, aD as stripJsonCodeFence, a as ALREADY_STAGED_ACTION_TOOL, aC as stagedActionInput, aq as parseClaudeCliOutput, aE as stripMcpToolPrefix, U as envOverridesFromProcessEnv, av as resolveConfig, aA as shouldLaunchTuiApp, aH as validateConfig, c as ConfigValidationError, m as PersonalAssistant, a9 as formatSpendCapStatus, v as braveSearch, M as createSmtpSender, K as createResendSender, y as classifyError, am as nodeToLayer, L as LAYER_DISPLAY_NAME, al as nodeDisplayName, V as estimateCostUsd, $ as formatConfigListing, ad as isConfigKey, C as CONFIG_KEYS, E as ENV_VAR_FOR_CONFIG_KEY, ar as parseConfigValue, d as ConfigValueParseError, a1 as formatDoctorReport, a0 as formatCostSummary, a8 as formatSearchResults, ac as formatUndoLogListing, N as defaultExportFilename, ab as formatTranscriptMarkdown, aa as formatStatus, a3 as formatHelp, j as LAYER_ORDER, x as buildWhyChain, k as LAYER_SHORT_CODE, O as defaultMemoryExportFilename, a4 as formatMemoryExport, a5 as formatMemoryPendingOutcome, a6 as formatMemorySummary } from "./cli-session-D0uLdT2A.js";
-import { spawn } from "node:child_process";
-import { createServer, connect } from "node:net";
-import { randomBytes } from "node:crypto";
-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 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
-   * plans/personal_assistant_file_tools_plan.html, 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 mcpServerFileName = "file-tools-mcp-server.mjs";
-    const mcpServerPath = fileURLToPath(new URL(mcpServerFileName, import.meta.url));
-    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 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 plans/ask_question_and_plan_mode_plan.html — 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;
-  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;
-    }
-    console.log(`
-Plan: ${lastPlanStatus.templateName ?? "custom plan"} (${lastPlanStatus.completionPct.toFixed(1)}% complete)`);
-    for (const task of lastPlanStatus.tasks) {
-      console.log(`  ${PLAN_TASK_STATUS_ICON[task.status] ?? "?"} [${task.status}] ${task.id} — ${task.description}`);
-    }
-    console.log(`
-Success criteria: ${lastPlanStatus.successCriteria}
-`);
-  }
-  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(`${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();
-    console.log(`  ⚙ ${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? (y/N) " : result.pendingActionKind === "email" ? "Send this email? (y/N) " : result.pendingActionKind === "batch" ? "Continue? (y/N) " : "Apply this write? (y/N) ";
-        console.log(`
-[needs approval — ${kindLabel}] ${result.reason}`);
-        const confirmed = await askYesNo(promptText);
-        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}"`);
-        const confirmed = await askYesNo("Proceed? (y/N) ");
-        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("");
-      }
-    });
-  }
-  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");
-      const spendCapLine = await spendCapStatusLine();
-      if (spendCapLine) indicators.push(spendCapLine);
-      return indicators;
-    }
-  };
-}
-async function main() {
-  const persisted = await defaultConfigStore.load();
-  const { config } = resolveConfig(persisted, defaultEnvOverrides);
-  if (shouldLaunchTuiApp(config.tuiMode ?? "disabled", Boolean(process.stdout.isTTY), Boolean(process.stdin.isTTY))) {
-    const { runTuiApp } = await import("./tui-app-DxLPSGh2.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();
-export {
-  entryArgMatchesModule,
-  runCli
-};
+import "./bin-CqkqT6KK.js";
 //# sourceMappingURL=cli.js.map