@botbotgo/agent-harness 0.0.309 → 0.0.311

package/dist/cli.js

@@ -1,3027 +1,6 @@
 #!/usr/bin/env node
-import { spawn } from "node:child_process";
-import { EventEmitter } from "node:events";
-import { existsSync, openSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { createInterface as createReadlineInterface } from "node:readline";
-import { Writable } from "node:stream";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { pathToFileURL } from "node:url";
-import YAML from "yaml";
-import { createAgentHarness } from "./api.js";
-import { createAcpHttpHarnessClient, createInProcessHarnessClient, } from "./client.js";
-import { initProject } from "./init-project.js";
-import { serveA2aOverHttp } from "./protocol/a2a/http.js";
-import { serveAgUiOverHttp } from "./protocol/ag-ui/http.js";
-import { serveAcpOverHttp } from "./protocol/acp/http.js";
-import { serveAcpOverStdio } from "./protocol/acp/stdio.js";
-import { serveRuntimeMcpOverStdio, serveRuntimeMcpOverStreamableHttp } from "./mcp.js";
-import { interpolateEnvPlaceholders } from "./workspace/yaml-object-reader.js";
-function renderUsage() {
-    return `Usage:
-  agent-harness init <project-name> [--template deep-research|single-agent] [--provider <provider>] [--model <model>] [--with-web-search|--no-web-search]
-  agent-harness chat [-w <path>] [--transport stdio|http] [--host <hostname>] [--port <port>] [--agent <agentId>] [--session <sessionId>] [--message <text>]
-  agent-harness [-w <path>] [prompt]
-  botbotgo [-w <path>] [prompt]
-  agent-harness acp serve [--workspace <path>] [--transport stdio|http] [--host <hostname>] [--port <port>]
-  agent-harness acp start [--workspace <path>] [--host <hostname>] [--port <port>]
-  agent-harness acp stop [--workspace <path>]
-  agent-harness a2a serve [--workspace <path>] [--host <hostname>] [--port <port>]
-  agent-harness a2a start [--workspace <path>] [--host <hostname>] [--port <port>]
-  agent-harness a2a stop [--workspace <path>]
-  agent-harness ag-ui serve [--workspace <path>] [--host <hostname>] [--port <port>]
-  agent-harness runtime overview [--workspace <path>] [--limit <n>] [--json]
-  agent-harness runtime health [--workspace <path>] [--json]
-  agent-harness runtime approvals list [--workspace <path>] [--status <pending|approved|edited|rejected|expired>] [--json]
-  agent-harness runtime approvals watch [--workspace <path>] [--status <pending|approved|edited|rejected|expired>] [--poll-ms <ms>] [--once] [--json]
-  agent-harness runtime requests list [--workspace <path>] [--agent <agentId>] [--session <sessionId>] [--state <state>] [--json]
-  agent-harness runtime requests tail [--workspace <path>] [--agent <agentId>] [--session <sessionId>] [--state <state>] [--poll-ms <ms>] [--once] [--json]
-  agent-harness runtime scheduled-run --workspace <path> --schedule <scheduleId>
-  agent-harness runtime export request --workspace <path> --session <sessionId> --request <requestId> [--artifacts] [--artifact-contents] [--health] [--json]
-  agent-harness runtime export session --workspace <path> --session <sessionId> [--artifacts] [--artifact-contents] [--health] [--json]
-  agent-harness runtime-mcp serve [--workspace <path>] [--transport stdio|streamable-http] [--host <hostname>] [--port <port>]
-  agent-harness runtime-mcp start [--workspace <path>] [--host <hostname>] [--port <port>]
-  agent-harness runtime-mcp stop [--workspace <path>]
-  agent-harness mcp serve [--workspace <path>] [--transport stdio|streamable-http] [--host <hostname>] [--port <port>]
-  agent-harness mcp start [--workspace <path>] [--host <hostname>] [--port <port>]
-  agent-harness mcp stop [--workspace <path>]
-
-Run botbotgo or agent-harness from any folder.
-If ./config/ is absent, the runtime falls back to the bundled system defaults and bundled resources.
-Chat defaults to the current directory as the workspace. Use -w to point at another workspace.
-`;
-}
-function isTemplate(value) {
-    return value === "deep-research" || value === "single-agent";
-}
-function parseInitOptions(args) {
-    const options = {};
-    for (let index = 0; index < args.length; index += 1) {
-        const arg = args[index];
-        if (arg === "--with-web-search") {
-            options.withWebSearch = true;
-            continue;
-        }
-        if (arg === "--no-web-search") {
-            options.withWebSearch = false;
-            continue;
-        }
-        if (arg === "--template" || arg === "--provider" || arg === "--model") {
-            const value = args[index + 1];
-            if (!value) {
-                return { error: `Missing value for ${arg}` };
-            }
-            if (arg === "--template") {
-                if (!isTemplate(value)) {
-                    return { error: `Unsupported template: ${value}` };
-                }
-                options.template = value;
-            }
-            else if (arg === "--provider") {
-                options.provider = value;
-            }
-            else {
-                options.model = value;
-            }
-            index += 1;
-            continue;
-        }
-        return { error: `Unknown option: ${arg}` };
-    }
-    return { options };
-}
-function parseAcpServeOptions(args, defaultTransport = "stdio") {
-    let workspaceRoot;
-    let transport = defaultTransport;
-    let hostname;
-    let port;
-    for (let index = 0; index < args.length; index += 1) {
-        const arg = args[index];
-        if (arg === "--workspace") {
-            const value = args[index + 1];
-            if (!value) {
-                return { transport, error: "Missing value for --workspace" };
-            }
-            workspaceRoot = value;
-            index += 1;
-            continue;
-        }
-        if (arg === "--transport") {
-            const value = args[index + 1];
-            if (!value) {
-                return { transport, hostname, port, error: "Missing value for --transport" };
-            }
-            if (value !== "stdio" && value !== "http") {
-                return { transport, hostname, port, error: `Unsupported ACP transport: ${value}` };
-            }
-            transport = value;
-            index += 1;
-            continue;
-        }
-        if (arg === "--host") {
-            const value = args[index + 1];
-            if (!value) {
-                return { transport, hostname, port, error: "Missing value for --host" };
-            }
-            hostname = value;
-            index += 1;
-            continue;
-        }
-        if (arg === "--port") {
-            const value = args[index + 1];
-            if (!value) {
-                return { transport, hostname, port, error: "Missing value for --port" };
-            }
-            const parsedPort = Number.parseInt(value, 10);
-            if (!Number.isFinite(parsedPort) || parsedPort < 0) {
-                return { transport, hostname, port, error: `Invalid ACP port: ${value}` };
-            }
-            port = parsedPort;
-            index += 1;
-            continue;
-        }
-        return { transport, hostname, port, error: `Unknown option: ${arg}` };
-    }
-    return { workspaceRoot, transport, hostname, port };
-}
-function parseWorkspaceOnlyOptions(args) {
-    let workspaceRoot;
-    for (let index = 0; index < args.length; index += 1) {
-        const arg = args[index];
-        if (arg === "--workspace") {
-            const value = args[index + 1];
-            if (!value) {
-                return { error: "Missing value for --workspace" };
-            }
-            workspaceRoot = value;
-            index += 1;
-            continue;
-        }
-        return { error: `Unknown option: ${arg}` };
-    }
-    return { workspaceRoot };
-}
-function parseHttpServeOptions(args, serviceLabel = "HTTP") {
-    let workspaceRoot;
-    let hostname;
-    let port;
-    for (let index = 0; index < args.length; index += 1) {
-        const arg = args[index];
-        if (arg === "--workspace") {
-            const value = args[index + 1];
-            if (!value) {
-                return { hostname, port, error: "Missing value for --workspace" };
-            }
-            workspaceRoot = value;
-            index += 1;
-            continue;
-        }
-        if (arg === "--host") {
-            const value = args[index + 1];
-            if (!value) {
-                return { workspaceRoot, port, error: "Missing value for --host" };
-            }
-            hostname = value;
-            index += 1;
-            continue;
-        }
-        if (arg === "--port") {
-            const value = args[index + 1];
-            if (!value) {
-                return { workspaceRoot, hostname, error: "Missing value for --port" };
-            }
-            const parsedPort = Number.parseInt(value, 10);
-            if (!Number.isFinite(parsedPort) || parsedPort < 0) {
-                return { workspaceRoot, hostname, error: `Invalid ${serviceLabel} port: ${value}` };
-            }
-            port = parsedPort;
-            index += 1;
-            continue;
-        }
-        return { workspaceRoot, hostname, port, error: `Unknown option: ${arg}` };
-    }
-    return { workspaceRoot, hostname, port };
-}
-function parseRuntimeMcpServeOptions(args, defaultTransport = "stdio") {
-    let workspaceRoot;
-    let transport = defaultTransport;
-    let hostname;
-    let port;
-    for (let index = 0; index < args.length; index += 1) {
-        const arg = args[index];
-        if (arg === "--workspace") {
-            const value = args[index + 1];
-            if (!value) {
-                return { transport, hostname, port, error: "Missing value for --workspace" };
-            }
-            workspaceRoot = value;
-            index += 1;
-            continue;
-        }
-        if (arg === "--transport") {
-            const value = args[index + 1];
-            if (!value) {
-                return { transport, hostname, port, error: "Missing value for --transport" };
-            }
-            if (value !== "stdio" && value !== "streamable-http") {
-                return { transport, hostname, port, error: `Unsupported runtime MCP transport: ${value}` };
-            }
-            transport = value;
-            index += 1;
-            continue;
-        }
-        if (arg === "--host") {
-            const value = args[index + 1];
-            if (!value) {
-                return { transport, hostname, port, error: "Missing value for --host" };
-            }
-            hostname = value;
-            index += 1;
-            continue;
-        }
-        if (arg === "--port") {
-            const value = args[index + 1];
-            if (!value) {
-                return { transport, hostname, port, error: "Missing value for --port" };
-            }
-            const parsedPort = Number.parseInt(value, 10);
-            if (!Number.isFinite(parsedPort) || parsedPort < 0) {
-                return { transport, hostname, port, error: `Invalid runtime MCP port: ${value}` };
-            }
-            port = parsedPort;
-            index += 1;
-            continue;
-        }
-        return { transport, hostname, port, error: `Unknown option: ${arg}` };
-    }
-    return { workspaceRoot, transport, hostname, port };
-}
-function parseChatOptions(args) {
-    let workspaceRoot;
-    let agentId;
-    let sessionId;
-    let message;
-    let requestEvents = false;
-    let transport = "stdio";
-    let hostname;
-    let port;
-    const positional = [];
-    for (let index = 0; index < args.length; index += 1) {
-        const arg = args[index];
-        if (arg === "--workspace"
-            || arg === "-w"
-            || arg === "--agent"
-            || arg === "--session"
-            || arg === "--message"
-            || arg === "--transport"
-            || arg === "--host"
-            || arg === "--port") {
-            const value = args[index + 1];
-            if (!value) {
-                return { workspaceRoot, agentId, sessionId, message, requestEvents, transport, hostname, port, error: `Missing value for ${arg}` };
-            }
-            if (arg === "--workspace" || arg === "-w") {
-                workspaceRoot = value;
-            }
-            else if (arg === "--agent") {
-                agentId = value;
-            }
-            else if (arg === "--session") {
-                sessionId = value;
-            }
-            else if (arg === "--message") {
-                message = value;
-            }
-            else if (arg === "--transport") {
-                if (value !== "stdio" && value !== "http") {
-                    return { workspaceRoot, agentId, sessionId, message, requestEvents, transport, hostname, port, error: `Unsupported chat transport: ${value}` };
-                }
-                transport = value;
-            }
-            else if (arg === "--host") {
-                hostname = value;
-            }
-            else {
-                const parsedPort = Number.parseInt(value, 10);
-                if (!Number.isFinite(parsedPort) || parsedPort <= 0) {
-                    return { workspaceRoot, agentId, sessionId, message, requestEvents, transport, hostname, port, error: `Invalid chat port: ${value}` };
-                }
-                port = parsedPort;
-            }
-            index += 1;
-            continue;
-        }
-        if (arg === "--request-events") {
-            requestEvents = true;
-            continue;
-        }
-        if (arg.startsWith("-")) {
-            return { workspaceRoot, agentId, sessionId, message, requestEvents, transport, hostname, port, error: `Unknown option: ${arg}` };
-        }
-        positional.push(arg);
-    }
-    if (!message && positional.length > 0) {
-        message = positional.join(" ");
-    }
-    return { workspaceRoot, agentId, sessionId, message, requestEvents, transport, hostname, port };
-}
-function isTopLevelCliCommand(value) {
-    return value === "init"
-        || value === "chat"
-        || value === "acp"
-        || value === "a2a"
-        || value === "ag-ui"
-        || value === "mcp"
-        || value === "runtime"
-        || value === "runtime-mcp";
-}
-function resolveManagedServiceRoot(workspaceRoot) {
-    return path.join(workspaceRoot, ".botbotgo", "services");
-}
-function managedServiceStatePath(workspaceRoot, service) {
-    return path.join(resolveManagedServiceRoot(workspaceRoot), `${service}.json`);
-}
-function managedServiceLogPath(workspaceRoot, service, stream) {
-    return path.join(resolveManagedServiceRoot(workspaceRoot), `${service}.${stream}.log`);
-}
-async function readManagedServiceState(workspaceRoot, service) {
-    const statePath = managedServiceStatePath(workspaceRoot, service);
-    if (!existsSync(statePath)) {
-        return null;
-    }
-    try {
-        return JSON.parse(await readFile(statePath, "utf8"));
-    }
-    catch {
-        return null;
-    }
-}
-async function writeManagedServiceState(state) {
-    const statePath = managedServiceStatePath(state.workspaceRoot, state.service);
-    await mkdir(path.dirname(statePath), { recursive: true });
-    await writeFile(statePath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
-}
-async function clearManagedServiceState(workspaceRoot, service) {
-    await rm(managedServiceStatePath(workspaceRoot, service), { force: true });
-}
-function defaultIsManagedProcessRunning(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function defaultSignalManagedProcess(pid, signal) {
-    process.kill(pid, signal);
-}
-async function defaultSpawnManagedCliProcess(input) {
-    await mkdir(path.dirname(input.stdoutPath), { recursive: true });
-    const stdoutFd = openSync(input.stdoutPath, "a");
-    const stderrFd = openSync(input.stderrPath, "a");
-    const child = spawn(process.execPath, [fileURLToPath(import.meta.url), ...input.args], {
-        cwd: input.cwd,
-        detached: true,
-        stdio: ["ignore", stdoutFd, stderrFd],
-    });
-    child.unref();
-    return { pid: child.pid };
-}
-async function sleep(ms) {
-    await new Promise((resolve) => setTimeout(resolve, ms));
-}
-function parseRuntimeInspectOptions(args) {
-    let workspaceRoot;
-    let json = false;
-    let once = false;
-    let pollMs = 1000;
-    let limit = 5;
-    let status;
-    let state;
-    let agentId;
-    let sessionId;
-    for (let index = 0; index < args.length; index += 1) {
-        const arg = args[index];
-        if (arg === "--workspace" || arg === "--status" || arg === "--state" || arg === "--agent" || arg === "--session" || arg === "--poll-ms" || arg === "--limit") {
-            const value = args[index + 1];
-            if (!value) {
-                return { json, once, pollMs, limit, status, state, agentId, sessionId, error: `Missing value for ${arg}` };
-            }
-            if (arg === "--workspace") {
-                workspaceRoot = value;
-            }
-            else if (arg === "--status") {
-                status = value;
-            }
-            else if (arg === "--state") {
-                state = value;
-            }
-            else if (arg === "--agent") {
-                agentId = value;
-            }
-            else if (arg === "--session") {
-                sessionId = value;
-            }
-            else if (arg === "--limit") {
-                const parsedLimit = Number.parseInt(value, 10);
-                if (!Number.isFinite(parsedLimit) || parsedLimit <= 0) {
-                    return { json, once, pollMs, limit, status, state, agentId, sessionId, error: `Invalid limit: ${value}` };
-                }
-                limit = parsedLimit;
-            }
-            else {
-                const parsedPoll = Number.parseInt(value, 10);
-                if (!Number.isFinite(parsedPoll) || parsedPoll <= 0) {
-                    return { json, once, pollMs, limit, status, state, agentId, sessionId, error: `Invalid poll interval: ${value}` };
-                }
-                pollMs = parsedPoll;
-            }
-            index += 1;
-            continue;
-        }
-        if (arg === "--json") {
-            json = true;
-            continue;
-        }
-        if (arg === "--once") {
-            once = true;
-            continue;
-        }
-        return { workspaceRoot, json, once, pollMs, limit, status, state, agentId, sessionId, error: `Unknown option: ${arg}` };
-    }
-    return { workspaceRoot, json, once, pollMs, limit, status, state, agentId, sessionId };
-}
-function parseRuntimeExportOptions(args) {
-    let workspaceRoot;
-    let sessionId;
-    let requestId;
-    let includeArtifacts = false;
-    let includeArtifactContents = false;
-    let includeRuntimeHealth = false;
-    let json = false;
-    for (let index = 0; index < args.length; index += 1) {
-        const arg = args[index];
-        if (arg === "--artifacts") {
-            includeArtifacts = true;
-            continue;
-        }
-        if (arg === "--artifact-contents") {
-            includeArtifacts = true;
-            includeArtifactContents = true;
-            continue;
-        }
-        if (arg === "--health") {
-            includeRuntimeHealth = true;
-            continue;
-        }
-        if (arg === "--json") {
-            json = true;
-            continue;
-        }
-        if (arg === "--workspace" || arg === "--session" || arg === "--request") {
-            const value = args[index + 1];
-            if (!value) {
-                return {
-                    workspaceRoot,
-                    sessionId,
-                    requestId,
-                    includeArtifacts,
-                    includeArtifactContents,
-                    includeRuntimeHealth,
-                    json,
-                    error: `Missing value for ${arg}`,
-                };
-            }
-            if (arg === "--workspace") {
-                workspaceRoot = value;
-            }
-            else if (arg === "--session") {
-                sessionId = value;
-            }
-            else {
-                requestId = value;
-            }
-            index += 1;
-            continue;
-        }
-        return {
-            workspaceRoot,
-            sessionId,
-            requestId,
-            includeArtifacts,
-            includeArtifactContents,
-            includeRuntimeHealth,
-            json,
-            error: `Unknown option: ${arg}`,
-        };
-    }
-    return {
-        workspaceRoot,
-        sessionId,
-        requestId,
-        includeArtifacts,
-        includeArtifactContents,
-        includeRuntimeHealth,
-        json,
-    };
-}
-function parseScheduledRunOptions(args) {
-    let workspaceRoot;
-    let scheduleId;
-    for (let index = 0; index < args.length; index += 1) {
-        const arg = args[index];
-        if (arg === "--workspace" || arg === "--schedule") {
-            const value = args[index + 1];
-            if (!value) {
-                return { workspaceRoot, scheduleId, error: `Missing value for ${arg}` };
-            }
-            if (arg === "--workspace") {
-                workspaceRoot = value;
-            }
-            else {
-                scheduleId = value;
-            }
-            index += 1;
-            continue;
-        }
-        return { workspaceRoot, scheduleId, error: `Unknown option: ${arg}` };
-    }
-    return { workspaceRoot, scheduleId };
-}
-function resolveCliWorkspaceRoot(cwd, inputPath) {
-    const resolved = path.resolve(cwd, inputPath ?? ".");
-    if (existsSync(path.join(resolved, "config", "runtime", "workspace.yaml"))) {
-        return resolved;
-    }
-    if (path.basename(resolved) === "config" && hasCliConfigYaml(resolved)) {
-        return path.dirname(resolved);
-    }
-    return resolved;
-}
-function getWorkspaceConfigPath(workspaceRoot) {
-    return path.join(workspaceRoot, "config", "runtime", "workspace.yaml");
-}
-function hasCliConfigYaml(configRoot) {
-    if (!existsSync(configRoot) || !statSync(configRoot).isDirectory()) {
-        return false;
-    }
-    const pending = [configRoot];
-    while (pending.length > 0) {
-        const current = pending.pop();
-        for (const entry of readdirSync(current, { withFileTypes: true })) {
-            if (entry.isDirectory()) {
-                if (entry.name === "node_modules") {
-                    continue;
-                }
-                pending.push(path.join(current, entry.name));
-                continue;
-            }
-            if (entry.isFile() && /\.ya?ml$/i.test(entry.name)) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-function validateCliWorkspaceRoot(workspaceRoot, inputPath) {
-    if (!existsSync(workspaceRoot)) {
-        return undefined;
-    }
-    if (!statSync(workspaceRoot).isDirectory()) {
-        const workspaceLabel = inputPath ? "Workspace path" : "Current directory";
-        return `${workspaceLabel} is not a directory: ${workspaceRoot}`;
-    }
-    return undefined;
-}
-function resolveCliConfigRoot(workspaceRoot) {
-    if (path.basename(workspaceRoot) === "config") {
-        return workspaceRoot;
-    }
-    return path.join(workspaceRoot, "config");
-}
-function frameworkCliWorkspaceRoot() {
-    const resolved = fileURLToPath(new URL("..", import.meta.url));
-    const distSegment = `${path.sep}dist`;
-    if (!resolved.endsWith(distSegment)) {
-        return resolved;
-    }
-    const sourceRoot = resolved.slice(0, -distSegment.length);
-    if (!existsSync(sourceRoot)) {
-        return resolved;
-    }
-    try {
-        return statSync(sourceRoot).mtimeMs >= statSync(resolved).mtimeMs ? sourceRoot : resolved;
-    }
-    catch {
-        return sourceRoot;
-    }
-}
-function renderJson(value) {
-    return `${JSON.stringify(value, null, 2)}\n`;
-}
-function formatTreeBranch(isLast) {
-    return isLast ? "└─" : "├─";
-}
-function formatTreeIndent(ancestorLast) {
-    return ancestorLast ? "   " : "│  ";
-}
-function applyAnsi(text, code, enabled) {
-    if (!enabled) {
-        return text;
-    }
-    return `\x1b[${code}m${text}\x1b[0m`;
-}
-function renderRequestStateBadge(state, color) {
-    if (state === "completed") {
-        return color ? `\x1b[32;1m✔ DONE\x1b[0m` : "✔ DONE";
-    }
-    if (state === "running") {
-        return color ? `\x1b[36;1m▶ RUNNING\x1b[0m` : "▶ RUNNING";
-    }
-    if (state === "waiting" || state === "waiting_for_approval") {
-        return color ? `\x1b[33;1m⚠ WAITING\x1b[0m` : "⚠ WAITING";
-    }
-    if (state === "failed") {
-        return color ? `\x1b[31;1m✘ FAILED\x1b[0m` : "✘ FAILED";
-    }
-    if (state === "cancelled") {
-        return color ? `\x1b[31m○ CANCELLED\x1b[0m` : "○ CANCELLED";
-    }
-    if (state === "queued") {
-        return color ? `\x1b[38;5;242m· QUEUED\x1b[0m` : "· QUEUED";
-    }
-    return color ? `\x1b[37m${state.toUpperCase()}\x1b[0m` : state.toUpperCase();
-}
-function summarizeRequestPlan(snapshot) {
-    const summary = snapshot.plan.summary;
-    const eventCount = flattenRequestExecutionSteps(snapshot).length;
-    const parts = [
-        `${summary.total} todo${summary.total === 1 ? "" : "s"}`,
-        summary.inProgress > 0 ? `${summary.inProgress} active` : undefined,
-        summary.completed > 0 ? `${summary.completed} done` : undefined,
-        summary.failed > 0 ? `${summary.failed} failed` : undefined,
-        eventCount > 0 ? `${eventCount} event${eventCount === 1 ? "" : "s"}` : undefined,
-    ].filter((part) => typeof part === "string");
-    return parts.join(" · ");
-}
-function summarizeRequestOutput(output, color) {
-    const trimmed = output.trim();
-    if (!trimmed) {
-        return applyAnsi("empty", "2", color);
-    }
-    const normalized = trimmed.replace(/\s+/g, " ");
-    const preview = normalized.length > 72 ? `${normalized.slice(0, 69)}...` : normalized;
-    return applyAnsi(preview, "2", color);
-}
-function formatCompactClockTime(value) {
-    const date = new Date(value);
-    if (Number.isNaN(date.getTime())) {
-        return value;
-    }
-    return new Intl.DateTimeFormat("en-US", {
-        hour12: false,
-        hour: "2-digit",
-        minute: "2-digit",
-        second: "2-digit",
-    }).format(date);
-}
-function renderTimeRange(startedAt, endedAt, detail, color) {
-    if (!startedAt && !endedAt) {
-        return "";
-    }
-    const from = startedAt ? formatCompactClockTime(startedAt) : "?";
-    const to = endedAt ? formatCompactClockTime(endedAt) : "now";
-    const durationMs = typeof detail?.durationMs === "number" ? detail.durationMs : undefined;
-    const durationLabel = durationMs !== undefined
-        ? ` · ${(durationMs / 1000).toFixed(durationMs >= 10_000 ? 0 : durationMs >= 1_000 ? 1 : 3)}s`
-        : "";
-    return ` ${applyAnsi(`[${from} -> ${to}${durationLabel}]`, "2", color)}`;
-}
-function readStepSkillNames(step) {
-    const value = step.detail?.skillNames;
-    return Array.isArray(value) ? value.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
-}
-function buildRequestStepEventKey(step) {
-    return `${step.kind}:${step.id}`;
-}
-function resolveEventTimestamp(step) {
-    return step.occurredAt ?? step.endedAt ?? step.startedAt;
-}
-function summarizeRequestStepDetail(step, displayName, color) {
-    if (step.kind === "memory" && step.detail?.source === "runtime-durable-memory") {
-        const count = typeof step.detail.count === "number" ? step.detail.count : undefined;
-        const scopes = Array.isArray(step.detail.scopes)
-            ? step.detail.scopes.filter((item) => typeof item === "string" && item.trim().length > 0)
-            : [];
-        const countLabel = count !== undefined ? `${count} record${count === 1 ? "" : "s"}` : undefined;
-        const scopeLabel = scopes.length > 0 ? scopes.join(", ") : undefined;
-        const summary = typeof step.detail.summary === "string" ? step.detail.summary.trim() : "";
-        const detailLabel = [countLabel, scopeLabel].filter((value) => Boolean(value)).join(" · ");
-        if (detailLabel) {
-            return ` ${applyAnsi(`(${detailLabel})`, "2", color)}`;
-        }
-        if (summary && !summary.toLowerCase().includes(displayName.toLowerCase())) {
-            const preview = summary.length > 48 ? `${summary.slice(0, 45)}...` : summary;
-            return ` ${applyAnsi(`(${preview})`, "2", color)}`;
-        }
-        return "";
-    }
-    if (step.ownerAgentId && step.ownerAgentId !== step.agentId) {
-        return ` ${applyAnsi(`(from ${step.ownerAgentId})`, "2", color)}`;
-    }
-    return "";
-}
-function renderRequestStepLine(step, prefix, isLast, _activeEventId, color = false) {
-    const skillNames = step.kind === "skill" ? readStepSkillNames(step) : [];
-    const profileDisplayName = step.id.startsWith("profile:") && step.kind === "agent"
-        ? `${step.name} ${step.action ?? ""}`.trim()
-        : undefined;
-    const displayName = profileDisplayName
-        ? profileDisplayName
-        : step.kind === "skill" && skillNames.length === 1
-            ? skillNames[0]
-            : step.kind === "skill" && skillNames.length > 1
-                ? skillNames.join(", ")
-                : step.name;
-    const icon = STEP_KIND_ICON[step.kind] ?? "·";
-    const kindLabel = color
-        ? `\x1b[38;5;242m${icon} ${step.kind}\x1b[0m`
-        : `${icon} ${step.kind}`;
-    const stIcon = statusIcon(step.status === "started" ? "in_progress" : step.status, color);
-    const nameFormatted = color ? `\x1b[38;5;252m${displayName}\x1b[0m` : displayName;
-    const eventTime = resolveEventTimestamp(step);
-    const timeLabel = eventTime ? applyAnsi(`[${formatCompactClockTime(eventTime)}]`, "2", color) : applyAnsi("[time?]", "2", color);
-    const detailSuffix = summarizeRequestStepDetail(step, displayName, color);
-    return `${prefix}${formatTreeBranch(isLast)} ${timeLabel} ${stIcon} ${kindLabel} ${nameFormatted}${detailSuffix}`;
-}
-function resolveRequestStepDisplayName(step) {
-    const skillNames = step.kind === "skill" ? readStepSkillNames(step) : [];
-    if (step.id.startsWith("profile:") && step.kind === "agent") {
-        return `${step.name} ${step.action}`.trim();
-    }
-    if (step.kind === "skill" && skillNames.length === 1) {
-        return skillNames[0];
-    }
-    if (step.kind === "skill" && skillNames.length > 1) {
-        return skillNames.join(", ");
-    }
-    return step.name;
-}
-function isInternalAgentLifecycleStep(step) {
-    return step.kind === "agent" && step.id.startsWith("profile:agent:");
-}
-function isVisibleRequestTreeStep(step) {
-    if (step.kind === "skill") {
-        return false;
-    }
-    return !isInternalAgentLifecycleStep(step);
-}
-function getVisibleTodoEvents(todo) {
-    return todo.events.filter(isVisibleRequestTreeStep);
-}
-function getVisibleRootEvents(snapshot) {
-    return snapshot.events.filter(isVisibleRequestTreeStep);
-}
-function flattenRequestExecutionSteps(snapshot) {
-    return [
-        ...snapshot.plan.items.flatMap((item) => getVisibleTodoEvents(item)),
-        ...getVisibleRootEvents(snapshot),
-    ];
-}
-function buildExecutionStepEventKey(step) {
-    return [
-        buildRequestStepEventKey(step),
-        step.status,
-        step.startedAt ?? "",
-        step.endedAt ?? "",
-    ].join("|");
-}
-function renderRequestSnapshotTree(snapshot, color = false, timingSummary) {
-    const lines = [];
-    const eventSteps = flattenRequestExecutionSteps(snapshot);
-    const rootEvents = getVisibleRootEvents(snapshot);
-    // Header row: status badge + agent
-    const badge = renderRequestStateBadge(snapshot.state, color);
-    const agentLabel = snapshot.agentId
-        ? (color ? `\x1b[38;5;33m${snapshot.agentId}\x1b[0m` : snapshot.agentId)
-        : applyAnsi("unknown", "2", color);
-    const headerLabel = color ? `\x1b[1;37mREQUEST\x1b[0m` : "REQUEST";
-    lines.push(`${headerLabel}  ${badge}  ${applyAnsi("agent:", "2", color)}${agentLabel}`);
-    // IDs (compact, muted)
-    const muted = (s) => applyAnsi(s, "2", color);
-    lines.push(`├─ ${muted("session")} ${applyAnsi(ellipsizeChatId(snapshot.sessionId, 24), "2", color)}`);
-    lines.push(`├─ ${muted("request")} ${applyAnsi(ellipsizeChatId(snapshot.requestId, 24), "2", color)}`);
-    // Summary + timing on one line
-    const planSummary = summarizeRequestPlan(snapshot);
-    const timing = timingSummary ?? "collecting";
-    lines.push(`├─ ${muted("plan")} ${applyAnsi(`v${snapshot.plan.version}`, "2", color)}  ${muted("·")}  ${planSummary ? applyAnsi(planSummary, "2", color) : muted("no tracked work yet")}`);
-    lines.push(`├─ ${muted("timing")} ${applyAnsi(timing, "2", color)}`);
-    // Todo items
-    lines.push(`├─ ${muted("todos")}`);
-    const planPrefix = `${formatTreeIndent(false)}`;
-    if (snapshot.plan.items.length === 0) {
-        lines.push(`${planPrefix}└─ ${muted("none yet")}`);
-    }
-    else {
-        snapshot.plan.items.forEach((todo, todoIndex) => {
-            const todoEvents = getVisibleTodoEvents(todo);
-            const todoIsLast = todoIndex === snapshot.plan.items.length - 1
-                && rootEvents.length === 0
-                && !snapshot.approval;
-            const todoActive = todo.key === snapshot.activeTodoKey
-                ? (color ? ` \x1b[36m●\x1b[0m` : " ●")
-                : "";
-            const tIcon = statusIcon(todo.status, color);
-            const todoTimeRange = renderTimeRange(todo.startedAt, todo.endedAt, undefined, color);
-            const todoContent = color ? `\x1b[38;5;253m${todo.content}\x1b[0m` : todo.content;
-            lines.push(`${planPrefix}${formatTreeBranch(todoIsLast)} ${tIcon} ${todoContent}${todoTimeRange}${todoActive}`);
-            if (todoEvents.length > 0) {
-                const todoEventPrefix = `${planPrefix}${formatTreeIndent(todoIsLast)}`;
-                todoEvents.forEach((step, eventIndex) => {
-                    lines.push(renderRequestStepLine(step, todoEventPrefix, eventIndex === todoEvents.length - 1, snapshot.activeEventId, color));
-                });
-            }
-        });
-    }
-    // Root-level execution events only: keep streamed data outside the tree.
-    if (rootEvents.length > 0) {
-        lines.push(`├─ ${muted("events")}`);
-        rootEvents.forEach((step, index) => {
-            lines.push(renderRequestStepLine(step, `${formatTreeIndent(false)}`, index === rootEvents.length - 1 && !snapshot.approval, snapshot.activeEventId, color));
-        });
-    }
-    // Approval
-    if (snapshot.approval) {
-        const approvalStatus = snapshot.approval.status ?? "pending";
-        const approvalColor = approvalStatus === "approved" ? "32" : approvalStatus === "rejected" ? "31" : "33";
-        lines.push(`└─ ${color ? `\x1b[33m⚠ approval\x1b[0m` : "⚠ approval"} ${muted("·")} ${snapshot.approval.toolName ?? "unknown-tool"} ${applyAnsi(`(${approvalStatus})`, approvalColor, color)}`);
-    }
-    return `${lines.join("\n")}\n`;
-}
-function renderRequestEventContinuation(snapshot, fromIndex, color = false) {
-    const eventSteps = flattenRequestExecutionSteps(snapshot).slice(fromIndex);
-    if (eventSteps.length === 0) {
-        return "";
-    }
-    const muted = (s) => applyAnsi(s, "2", color);
-    const lines = [`${muted("events (continued)")}`];
-    eventSteps.forEach((step, index) => {
-        lines.push(renderRequestStepLine(step, "", index === eventSteps.length - 1, snapshot.activeEventId, color));
-    });
-    return `${lines.join("\n")}\n`;
-}
-function buildTodoContinuationSignature(snapshot) {
-    return snapshot.plan.items
-        .map((item) => [
-        item.id ?? "",
-        item.content,
-        item.status,
-        item.ownerAgentId ?? "",
-        item.startedAt ?? "",
-        item.endedAt ?? "",
-    ].join("|"))
-        .join(";");
-}
-function renderRequestTodoContinuation(snapshot, previousSignature, color = false) {
-    const nextSignature = buildTodoContinuationSignature(snapshot);
-    if (!nextSignature || nextSignature === previousSignature || snapshot.plan.items.length === 0) {
-        return "";
-    }
-    const muted = (s) => applyAnsi(s, "2", color);
-    const lines = [`${muted("todos (continued)")}`];
-    snapshot.plan.items.forEach((todo, index) => {
-        const tIcon = statusIcon(todo.status, color);
-        const todoTimeRange = renderTimeRange(todo.startedAt, todo.endedAt, undefined, color);
-        const todoContent = color ? `\x1b[38;5;253m${todo.content}\x1b[0m` : todo.content;
-        lines.push(`${formatTreeBranch(index === snapshot.plan.items.length - 1)} ${tIcon} ${todoContent}${todoTimeRange}`);
-    });
-    return `${lines.join("\n")}\n`;
-}
-function buildTerminalRequestSnapshot(snapshot, result) {
-    return {
-        ...snapshot,
-        state: result.state,
-        updatedAt: new Date().toISOString(),
-        output: result.output,
-        activeEventId: undefined,
-    };
-}
-function countRenderedLines(text) {
-    return text.replace(/\n$/, "").split("\n").length;
-}
-function isObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function formatTimestamp(value) {
-    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
-}
-function renderHealthSnapshot(snapshot, workspacePath) {
-    const lines = [];
-    const status = typeof snapshot.status === "string" ? snapshot.status : "unknown";
-    lines.push(`Runtime health ${workspacePath}: ${status}`);
-    const checks = isObject(snapshot.checks) ? snapshot.checks : {};
-    const checkEntries = Object.entries(checks)
-        .filter(([, value]) => isObject(value))
-        .map(([name, value]) => {
-        const check = value;
-        const reason = typeof check.reason === "string" && check.reason.trim().length > 0 ? ` (${check.reason})` : "";
-        return `  - ${name}: ${typeof check.status === "string" ? check.status : "unknown"}${reason}`;
-    });
-    if (checkEntries.length > 0) {
-        lines.push("Checks:");
-        lines.push(...checkEntries);
-    }
-    const stats = isObject(snapshot.stats) ? snapshot.stats : {};
-    const statEntries = [
-        ["activeRequestSlots", stats.activeRequestSlots],
-        ["pendingRequestSlots", stats.pendingRequestSlots],
-        ["pendingApprovals", stats.pendingApprovals],
-        ["stuckRequests", stats.stuckRequests],
-        ["llmSuccessRate1m", stats.llmSuccessRate1m],
-        ["llmP95LatencyMs1m", stats.llmP95LatencyMs1m],
-    ]
-        .filter(([, value]) => typeof value === "number")
-        .map(([name, value]) => `  - ${name}: ${value}`);
-    if (statEntries.length > 0) {
-        lines.push("Stats:");
-        lines.push(...statEntries);
-    }
-    const symptoms = Array.isArray(snapshot.symptoms) ? snapshot.symptoms.filter(isObject) : [];
-    if (symptoms.length > 0) {
-        lines.push("Symptoms:");
-        lines.push(...symptoms.map((symptom) => {
-            const code = typeof symptom.code === "string" ? symptom.code : "unknown";
-            const severity = typeof symptom.severity === "string" ? symptom.severity : "unknown";
-            const message = typeof symptom.message === "string" ? symptom.message : "";
-            return `  - ${code}: ${severity}${message ? ` (${message})` : ""}`;
-        }));
-    }
-    return `${lines.join("\n")}\n`;
-}
-function renderApprovalList(approvals) {
-    if (approvals.length === 0) {
-        return "No approvals matched.\n";
-    }
-    return approvals.map((approval) => {
-        const status = typeof approval.status === "string" ? approval.status : "unknown";
-        const toolName = typeof approval.toolName === "string" ? approval.toolName : "unknown_tool";
-        const approvalId = typeof approval.approvalId === "string" ? approval.approvalId : "unknown";
-        const sessionId = typeof approval.sessionId === "string" ? ` session=${approval.sessionId}` : "";
-        const requestId = typeof approval.requestId === "string" ? ` request=${approval.requestId}` : "";
-        const reason = typeof approval.approvalReason === "string" ? ` reason=${approval.approvalReason}` : "";
-        const requestedAt = formatTimestamp(approval.requestedAt);
-        const resolvedAt = formatTimestamp(approval.resolvedAt);
-        const requested = requestedAt ? ` requested=${requestedAt}` : "";
-        const resolved = resolvedAt ? ` resolved=${resolvedAt}` : "";
-        return `${approvalId} status=${status} tool=${toolName}${sessionId}${requestId}${reason}${requested}${resolved}`;
-    }).join("\n") + "\n";
-}
-function renderPlanResultSummary(result) {
-    if (typeof result === "string" && result.trim().length > 0) {
-        return result.trim();
-    }
-    if (!isObject(result)) {
-        return undefined;
-    }
-    const summary = typeof result.summary === "string" && result.summary.trim().length > 0
-        ? result.summary.trim()
-        : typeof result.message === "string" && result.message.trim().length > 0
-            ? result.message.trim()
-            : undefined;
-    if (summary) {
-        return summary;
-    }
-    const serialized = JSON.stringify(result);
-    return serialized && serialized !== "{}" ? serialized : undefined;
-}
-function renderChatPlanState(planState) {
-    const lines = [`[plan v${planState.version}] ${planState.summary.total} todo(s)`];
-    if (planState.summary.total === 0) {
-        lines.push("No todos tracked yet.");
-        return `${lines.join("\n")}\n`;
-    }
-    for (const [index, item] of planState.items.entries()) {
-        lines.push(`${index + 1}. [${item.status}] ${item.content}`);
-        const resultSummary = renderPlanResultSummary(item.result);
-        if (resultSummary) {
-            lines.push(`   result: ${resultSummary}`);
-        }
-    }
-    return `${lines.join("\n")}\n`;
-}
-function renderRequestList(requests) {
-    if (requests.length === 0) {
-        return "No requests matched.\n";
-    }
-    return requests.map((request) => {
-        const requestId = typeof request.requestId === "string" ? request.requestId : "unknown";
-        const sessionId = typeof request.sessionId === "string" ? request.sessionId : "unknown";
-        const agentId = typeof request.agentId === "string" ? request.agentId : "unknown";
-        const state = typeof request.state === "string" ? request.state : "unknown";
-        const currentAgent = typeof request.currentAgentId === "string" ? ` current=${request.currentAgentId}` : "";
-        const resumable = typeof request.resumable === "boolean" ? ` resumable=${request.resumable}` : "";
-        const updatedAt = formatTimestamp(request.updatedAt);
-        const lastActivityAt = formatTimestamp(request.lastActivityAt);
-        const updated = updatedAt ? ` updated=${updatedAt}` : "";
-        const lastActivity = lastActivityAt ? ` activity=${lastActivityAt}` : "";
-        return `${requestId} session=${sessionId} agent=${agentId}${currentAgent} state=${state}${resumable}${updated}${lastActivity}`;
-    }).join("\n") + "\n";
-}
-function renderOperatorOverview(overview, workspacePath) {
-    const lines = [];
-    const summary = typeof overview.summary === "string" ? overview.summary : "";
-    lines.push(`Runtime overview ${workspacePath}`);
-    if (summary) {
-        lines.push(`Summary: ${summary}`);
-    }
-    const health = isObject(overview.health) ? overview.health : {};
-    if (Object.keys(health).length > 0) {
-        lines.push("");
-        lines.push(renderHealthSnapshot(health, workspacePath).trimEnd());
-    }
-    const queue = isObject(overview.queue) ? overview.queue : {};
-    if (Object.keys(queue).length > 0) {
-        lines.push("");
-        lines.push(`Queue: ${typeof queue.summary === "string" ? queue.summary : "unavailable"}`);
-    }
-    const governance = isObject(overview.governance) ? overview.governance : {};
-    if (Object.keys(governance).length > 0) {
-        lines.push("Governance:");
-        lines.push(`  - ${typeof governance.summary === "string" ? governance.summary : "unavailable"}`);
-    }
-    const approvals = isObject(overview.approvals) ? overview.approvals : {};
-    const approvalItems = Array.isArray(approvals.items) ? approvals.items.filter(isObject) : [];
-    lines.push(`Pending approvals: ${typeof approvals.total === "number" ? approvals.total : approvalItems.length}`);
-    if (approvalItems.length > 0) {
-        lines.push(renderApprovalList(approvalItems).trimEnd());
-    }
-    const requests = isObject(overview.requests) ? overview.requests : {};
-    const requestItems = Array.isArray(requests.items) ? requests.items.filter(isObject) : [];
-    lines.push(`Active requests: ${typeof requests.total === "number" ? requests.total : requestItems.length}`);
-    if (requestItems.length > 0) {
-        lines.push(renderRequestList(requestItems).trimEnd());
-    }
-    return `${lines.join("\n")}\n`;
-}
-function renderChatHelp() {
-    const sections = [
-        {
-            heading: "Context & navigation",
-            rows: [
-                ["/context", "Show current agent / session / request"],
-                ["/new", "Clear session — start a fresh conversation"],
-                ["/agent <id>", "Switch agent for new requests"],
-                ["/session", "Print current session id"],
-                ["/sessions", "List recent sessions"],
-                ["/resume <id>", "Resume an existing session"],
-                ["/request [id]", "Show or select active request"],
-                ["/requests", "List requests for current session / agent"],
-            ],
-        },
-        {
-            heading: "Approvals",
-            rows: [
-                ["/approvals", "List pending approvals"],
-                ["/approve <id>", "Approve a pending approval"],
-                ["/reject <id>", "Reject a pending approval"],
-                ["/cancel", "Cancel the latest active request"],
-            ],
-        },
-        {
-            heading: "Diagnostics",
-            rows: [
-                ["/events", "Persisted events for the latest request"],
-                ["/trace", "Trace items for the latest request"],
-                ["/health", "Runtime health snapshot"],
-                ["/overview", "Runtime operator overview"],
-            ],
-        },
-        {
-            heading: "Session",
-            rows: [
-                ["/help", "Show this help"],
-                ["/exit", "Quit chat"],
-            ],
-        },
-    ];
-    const allRows = sections.flatMap((s) => s.rows);
-    const cmdW = Math.max(...allRows.map(([cmd]) => cmd.length));
-    const out = [""];
-    for (const section of sections) {
-        out.push(`  ${section.heading}`);
-        out.push(`  ${"─".repeat(section.heading.length)}`);
-        for (const [cmd, desc] of section.rows) {
-            out.push(`    ${cmd.padEnd(cmdW)}  ${desc}`);
-        }
-        out.push("");
-    }
-    out.push("  Starter tasks:");
-    out.push("  ─────────────");
-    out.push("    Inspect this workspace and explain the main entry points.");
-    out.push("    Review this project structure before making any edits.");
-    out.push("    Find the likeliest config issue and propose the smallest fix.");
-    out.push("");
-    return out.join("\n");
-}
-function trimAsciiBlock(block) {
-    return block
-        .split("\n")
-        .map((line) => line.replace(/\s+$/u, ""))
-        .join("\n");
-}
-/** Figlet Small font — trimmed for clean right edge */
-const CHAT_ASCII_BOTBOTGO = trimAsciiBlock("  ____   ___ _____ ____   ___ _____ ____  ___  \n" +
-    " | __ ) / _ \\_   _| __ ) / _ \\_   _/ ___|/ _ \\ \n" +
-    " |  _ \\| | | || | |  _ \\| | | || || |  _| | | |\n" +
-    " | |_) | |_| || | | |_) | |_| || || |_| | |_| |\n" +
-    " |____/ \\___/ |_| |____/ \\___/ |_| \\____|\\___/");
-const CHAT_ASCII_AGENT_HARNESS = trimAsciiBlock("     _    ____ _____ _   _ _____   _   _    _    ____  _   _ _____ ____ ____  \n" +
-    "    / \\  / ___| ____| \\ | |_   _| | | | |  / \\  |  _ \\| \\ | | ____/ ___/ ___| \n" +
-    "   / _ \\| |  _|  _| |  \\| | | |   | |_| | / _ \\ | |_) |  \\| |  _| \\___ \\___ \\ \n" +
-    "  / ___ \\ |_| | |___| |\\  | | |   |  _  |/ ___ \\|  _ <| |\\  | |___ ___) |__) |\n" +
-    " /_/   \\_\\____|_____|_| \\_| |_|   |_| |_/_/   \\_\\_| \\_\\_| \\_|_____|____/____/");
-/**
- * Solid fills (one 256-color per Figlet row, no gradient):
- * BOTBOTGO ≈ US flag: blue / white / red / white / red stripes top→bottom.
- * AGENT HARNESS ≈ 中国国旗: upper rows gold (星区黄), lower rows field red.
- */
-const CHAT_LOGO_BRAND_LINE_COLORS = [25, 238, 160, 238, 160];
-const CHAT_LOGO_PRODUCT_LINE_COLORS = [136, 136, 160, 160, 160];
-/** Step-kind icons for the request tree */
-const STEP_KIND_ICON = {
-    llm: "◆",
-    tool: "⚙",
-    skill: "★",
-    agent: "◉",
-    memory: "◈",
-    approval: "⚠",
-};
-/** Status icons for todos and steps */
-function statusIcon(status, color) {
-    if (status === "completed" || status === "done")
-        return applyAnsi("✔", "32", color);
-    if (status === "in_progress" || status === "started")
-        return applyAnsi("▶", "36", color);
-    if (status === "failed")
-        return applyAnsi("✘", "31", color);
-    if (status === "cancelled")
-        return applyAnsi("○", "31", color);
-    if (status === "pending" || status === "queued")
-        return applyAnsi("·", "238", color);
-    return applyAnsi("?", "37", color);
-}
-/** One foreground color per entire line — flat, no relief shading */
-function colorizeSolidAsciiBlock(block, lineColors, enabled) {
-    const trimmed = trimAsciiBlock(block);
-    const lines = trimmed.split("\n");
-    if (!enabled) {
-        return trimmed;
-    }
-    return lines
-        .map((line, i) => {
-        const code = lineColors[Math.min(i, lineColors.length - 1)] ?? lineColors[lineColors.length - 1];
-        return `\x1b[38;5;${code}m${line}\x1b[0m`;
-    })
-        .join("\n");
-}
-function ellipsizeChatId(value, maxChars) {
-    if (value.length <= maxChars) {
-        return value;
-    }
-    if (maxChars <= 1) {
-        return "…";
-    }
-    return `${value.slice(0, maxChars - 1)}…`;
-}
-export function renderChatPromptLine(input) {
-    const c = input.color;
-    const agent = input.agentId ?? "—";
-    const sessionShort = input.sessionId ? ellipsizeChatId(input.sessionId, 8) : null;
-    if (!c) {
-        const ctx = sessionShort ? ` [${sessionShort}]` : "";
-        return `\n  ─────────────────────────────────────────────\n  ❯ agent:${agent}${ctx} › `;
-    }
-    const sep = `  \x1b[38;5;236m${"─".repeat(45)}\x1b[0m`;
-    // left: brand tag + agent
-    const brand = `\x1b[38;5;33m◆\x1b[0m \x1b[1;37magent\x1b[0m\x1b[38;5;242m:\x1b[0m\x1b[38;5;252m${agent}\x1b[0m`;
-    // right: session pill (muted)
-    const sessionTag = sessionShort
-        ? ` \x1b[38;5;238m[\x1b[0m\x1b[38;5;244m${sessionShort}\x1b[0m\x1b[38;5;238m]\x1b[0m`
-        : "";
-    const arrow = `\x1b[38;5;33m›\x1b[0m`;
-    return `\n${sep}\n  ${brand}${sessionTag} ${arrow} `;
-}
-async function* iterateChatLines(rl, nextPrompt) {
-    rl.setPrompt(nextPrompt());
-    rl.prompt();
-    const asyncIterator = rl[Symbol.asyncIterator]();
-    while (true) {
-        const step = await asyncIterator.next();
-        if (step.done) {
-            break;
-        }
-        yield step.value;
-        rl.setPrompt(nextPrompt());
-        rl.prompt();
-    }
-}
-export function renderChatBanner(input) {
-    const color = input.color === true;
-    // — Logo block (single ASCII art) —
-    const brandArt = colorizeSolidAsciiBlock(CHAT_ASCII_BOTBOTGO, CHAT_LOGO_BRAND_LINE_COLORS, color);
-    const productArt = colorizeSolidAsciiBlock(CHAT_ASCII_AGENT_HARNESS, CHAT_LOGO_PRODUCT_LINE_COLORS, color);
-    const logoWidth = Math.max(...CHAT_ASCII_BOTBOTGO.split("\n").map((l) => l.length), ...CHAT_ASCII_AGENT_HARNESS.split("\n").map((l) => l.length));
-    const ruleLen = Math.min(logoWidth + 4, 96);
-    const dimRule = (ch, len) => color ? `\x1b[38;5;237m${ch.repeat(len)}\x1b[0m` : ch.repeat(len);
-    // — Info panel —
-    const labelColor = color ? "\x1b[38;5;242m" : "";
-    const valueColor = color ? "\x1b[38;5;252m" : "";
-    const accentColor = color ? "\x1b[38;5;33m" : ""; // bright cyan-blue
-    const resetColor = color ? "\x1b[0m" : "";
-    const mutedColor = color ? "\x1b[38;5;238m" : "";
-    const borderColor = color ? "\x1b[38;5;237m" : "";
-    const kvRow = (label, value, labelW, accent = false) => {
-        const lPad = label.padEnd(labelW);
-        const lFormatted = `${labelColor}${lPad}${resetColor}`;
-        const vFormatted = accent
-            ? `${accentColor}${value}${resetColor}`
-            : `${valueColor}${value}${resetColor}`;
-        return `  ${borderColor}│${resetColor} ${lFormatted} ${mutedColor}·${resetColor} ${vFormatted}`;
-    };
-    const rows = [
-        ["workspace", input.workspacePath, false],
-        ["transport", input.transport, false],
-    ];
-    if (input.agentId)
-        rows.push(["agent", input.agentId, true]);
-    if (input.sessionId)
-        rows.push(["session", input.sessionId, false]);
-    const labelW = Math.max(...rows.map(([l]) => l.length));
-    const panelInner = Math.max(...rows.map(([, v]) => labelW + 4 + v.length), 44);
-    const hLine = (l, m, r) => color
-        ? `  ${borderColor}${l}${resetColor}${borderColor}${m.repeat(panelInner + 2)}${r}${resetColor}`
-        : `  ${l}${m.repeat(panelInner + 2)}${r}`;
-    const versionTagText = "agent-harness";
-    const versionTag = color
-        ? `${mutedColor}agent-harness${resetColor}`
-        : versionTagText;
-    const versionDividerSpan = Math.max(36, ruleLen);
-    const versionGap = 2;
-    const versionRuleBudget = Math.max(24, versionDividerSpan - versionTagText.length - versionGap * 2);
-    const versionRuleLeftLen = Math.floor(versionRuleBudget / 2);
-    const versionRuleRightLen = versionRuleBudget - versionRuleLeftLen;
-    const hint = color
-        ? `  ${mutedColor}Type \x1b[38;5;246m/help\x1b[0m${mutedColor} for commands · \x1b[38;5;246m/exit\x1b[0m${mutedColor} to quit${resetColor}`
-        : `  Type /help for commands · /exit to quit`;
-    const lines = [
-        "",
-        brandArt,
-        "",
-        `  ${dimRule("─", Math.max(36, ruleLen - 4))}`,
-        "",
-        productArt,
-        "",
-        `  ${dimRule("─", versionRuleLeftLen)}${" ".repeat(versionGap)}${versionTag}${" ".repeat(versionGap)}${dimRule("─", versionRuleRightLen)}`,
-        "",
-        hLine("╭", "─", "╮"),
-        ...rows.map(([l, v, accent]) => kvRow(l, v, labelW, accent)),
-        hLine("╰", "─", "╯"),
-        "",
-        hint,
-        "",
-    ];
-    return lines.join("\n");
-}
-function renderRequestEvents(events) {
-    if (events.length === 0) {
-        return "No events recorded.\n";
-    }
-    return events.map((event) => {
-        const timestamp = formatTimestamp(event.timestamp) ?? "unknown-time";
-        const eventType = typeof event.eventType === "string" ? event.eventType : "unknown-event";
-        return `${timestamp} ${eventType}`;
-    }).join("\n") + "\n";
-}
-function renderSessionSummaries(summaries) {
-    if (summaries.length === 0) {
-        return "No sessions recorded.\n";
-    }
-    return summaries.map((summary) => {
-        const sessionId = typeof summary.sessionId === "string" ? summary.sessionId : "unknown";
-        const entryAgentId = typeof summary.entryAgentId === "string" ? ` agent=${summary.entryAgentId}` : "";
-        const state = typeof summary.currentState === "string" ? ` state=${summary.currentState}` : "";
-        const messageCount = typeof summary.messageCount === "number" ? ` messages=${summary.messageCount}` : "";
-        const title = typeof summary.title === "string" && summary.title.trim().length > 0 ? ` title=${summary.title}` : "";
-        const snippet = typeof summary.snippet === "string" && summary.snippet.trim().length > 0 ? ` snippet=${summary.snippet}` : "";
-        return `${sessionId}${entryAgentId}${state}${messageCount}${title}${snippet}`;
-    }).join("\n") + "\n";
-}
-function renderRequestTraceItems(items) {
-    if (items.length === 0) {
-        return "No trace items recorded.\n";
-    }
-    return items.map((item) => {
-        const surfaceItem = isObject(item.surfaceItem) ? item.surfaceItem : {};
-        const kind = typeof surfaceItem.kind === "string" ? surfaceItem.kind : "unknown";
-        const id = typeof surfaceItem.id === "string" ? surfaceItem.id : typeof surfaceItem.name === "string" ? surfaceItem.name : "unknown";
-        const agentId = typeof surfaceItem.agentId === "string" ? ` agent=${surfaceItem.agentId}` : "";
-        return `${kind}:${id}${agentId}`;
-    }).join("\n") + "\n";
-}
-function renderChatContext(input) {
-    const rows = [
-        ["agent", input.agentId ?? "—"],
-        ["session", input.sessionId ?? "—"],
-        ["request", input.requestId ?? "—"],
-    ];
-    const labelW = Math.max(...rows.map(([l]) => l.length));
-    const lines = rows.map(([label, value]) => `  ${label.padEnd(labelW)}  ${value}`);
-    return ["", "  Context", "  ───────", ...lines, ""].join("\n");
-}
-function normalizeChatCommand(line) {
-    const trimmed = line.trim();
-    if (!trimmed.startsWith("/")) {
-        return null;
-    }
-    const [name, ...rest] = trimmed.slice(1).split(/\s+/);
-    return {
-        name,
-        arg: rest.length > 0 ? rest.join(" ") : undefined,
-    };
-}
-function asRecord(value) {
-    return typeof value === "object" && value !== null ? value : undefined;
-}
-function readYamlFile(filePath) {
-    const parsed = YAML.parse(readFileSync(filePath, "utf8"));
-    return interpolateEnvPlaceholders(parsed, filePath);
-}
-function readCliConfigObjects(workspaceRoot) {
-    const roots = [
-        resolveCliConfigRoot(frameworkCliWorkspaceRoot()),
-        resolveCliConfigRoot(workspaceRoot),
-    ];
-    const merged = new Map();
-    for (const configRoot of roots) {
-        if (!hasCliConfigYaml(configRoot)) {
-            continue;
-        }
-        const files = [];
-        const pending = [configRoot];
-        while (pending.length > 0) {
-            const current = pending.pop();
-            for (const entry of readdirSync(current, { withFileTypes: true })) {
-                const entryPath = path.join(current, entry.name);
-                if (entry.isDirectory()) {
-                    if (entry.name === "node_modules") {
-                        continue;
-                    }
-                    pending.push(entryPath);
-                    continue;
-                }
-                if (entry.isFile() && /\.ya?ml$/i.test(entry.name)) {
-                    files.push(entryPath);
-                }
-            }
-        }
-        for (const filePath of files.sort()) {
-            const content = readFileSync(filePath, "utf8");
-            for (const document of YAML.parseAllDocuments(content)) {
-                const resolved = interpolateEnvPlaceholders(document.toJSON(), filePath);
-                const typed = asRecord(resolved);
-                if (!typed) {
-                    continue;
-                }
-                if (typed.kind === "Models" && Array.isArray(typed.spec)) {
-                    for (const item of typed.spec) {
-                        const record = asRecord(item);
-                        if (!record) {
-                            continue;
-                        }
-                        const id = typeof record.name === "string" ? record.name : record.id;
-                        if (typeof id !== "string" || !id) {
-                            continue;
-                        }
-                        merged.set(`Model/${id}`, {
-                            ...record,
-                            kind: "Model",
-                            id,
-                        });
-                    }
-                    continue;
-                }
-                const metadata = asRecord(typed.metadata);
-                const spec = asRecord(typed.spec);
-                if (typeof typed.kind === "string" && spec) {
-                    const id = typeof metadata?.name === "string" ? metadata.name : typed.id;
-                    if (typeof id !== "string" || !id) {
-                        continue;
-                    }
-                    merged.set(`${typed.kind}/${id}`, {
-                        ...spec,
-                        kind: typed.kind,
-                        id,
-                    });
-                    continue;
-                }
-                const kind = typeof typed.kind === "string" ? typed.kind : undefined;
-                const id = typeof typed.id === "string" ? typed.id : undefined;
-                if (!kind || !id) {
-                    continue;
-                }
-                merged.set(`${kind}/${id}`, typed);
-            }
-        }
-    }
-    return Array.from(merged.values());
-}
-function getWorkspaceDefaultAgentId(workspaceRoot) {
-    const runtime = readCliConfigObjects(workspaceRoot).find((item) => item.kind === "Runtime" && item.id === "default");
-    const routing = asRecord(runtime?.routing);
-    return typeof routing?.defaultAgentId === "string" && routing.defaultAgentId.trim().length > 0 ? routing.defaultAgentId.trim() : undefined;
-}
-function getAgentModelRef(workspaceRoot, agentId) {
-    const agent = readCliConfigObjects(workspaceRoot).find((item) => item.kind === "Agent" && item.id === agentId);
-    return typeof agent?.modelRef === "string" && agent.modelRef.trim().length > 0 ? agent.modelRef.trim() : undefined;
-}
-function getModelInfo(workspaceRoot, modelRef) {
-    const modelName = modelRef.startsWith("model/") ? modelRef.slice("model/".length) : modelRef;
-    const model = readCliConfigObjects(workspaceRoot).find((item) => item.kind === "Model" && item.id === modelName);
-    if (!model) {
-        return undefined;
-    }
-    return {
-        provider: typeof model.provider === "string" ? model.provider : undefined,
-        model: typeof model.model === "string" ? model.model : undefined,
-        baseUrl: typeof model.baseUrl === "string" ? model.baseUrl : undefined,
-    };
-}
-function readChatWorkspaceModelInfo(workspaceRoot, agentId) {
-    try {
-        const resolvedAgentId = agentId ?? getWorkspaceDefaultAgentId(workspaceRoot);
-        if (!resolvedAgentId) {
-            return getModelInfo(workspaceRoot, "model/default");
-        }
-        const modelRef = getAgentModelRef(workspaceRoot, resolvedAgentId) ?? "model/default";
-        return getModelInfo(workspaceRoot, modelRef);
-    }
-    catch {
-        return undefined;
-    }
-}
-function renderProviderFailureHint(modelInfo) {
-    if (!modelInfo?.provider) {
-        return undefined;
-    }
-    if (modelInfo.provider === "ollama") {
-        const modelText = modelInfo.model ? ` and ensure \`${modelInfo.model}\` is available` : "";
-        return `Hint: start Ollama${modelInfo.baseUrl ? ` at ${modelInfo.baseUrl}` : ""}${modelText}. Example: \`ollama serve\`${modelInfo.model ? ` and \`ollama pull ${modelInfo.model}\`` : ""}.`;
-    }
-    if (modelInfo.provider === "openai") {
-        return "Hint: verify network access and that `OPENAI_API_KEY` is set for this shell.";
-    }
-    if (modelInfo.provider === "anthropic") {
-        return "Hint: verify network access and that `ANTHROPIC_API_KEY` is set for this shell.";
-    }
-    if (modelInfo.provider === "google" || modelInfo.provider === "google-genai" || modelInfo.provider === "gemini") {
-        return "Hint: verify network access and that the configured Google API key is available in this shell.";
-    }
-    if (modelInfo.provider === "openai-compatible") {
-        return `Hint: verify the configured endpoint${modelInfo.baseUrl ? ` (${modelInfo.baseUrl})` : ""} and the required API key for that provider.`;
-    }
-    return undefined;
-}
-export function renderChatRuntimeFailure(output, modelInfo) {
-    const trimmed = output.trim();
-    if (!trimmed.startsWith("runtime_error=")) {
-        return output;
-    }
-    const normalized = trimmed.toLowerCase();
-    if (!normalized.includes("fetch failed") &&
-        !normalized.includes("connection error") &&
-        !normalized.includes("timed out") &&
-        !normalized.includes("404 page not found")) {
-        return output;
-    }
-    const lines = [trimmed];
-    if (modelInfo?.provider || modelInfo?.model) {
-        lines.push(`provider=${modelInfo?.provider ?? "unknown"}${modelInfo?.model ? ` model=${modelInfo.model}` : ""}`);
-    }
-    if (modelInfo?.baseUrl) {
-        lines.push(`endpoint=${modelInfo.baseUrl}`);
-    }
-    if (normalized.includes("404 page not found") && modelInfo?.provider === "ollama") {
-        lines.push("Hint: the configured endpoint responded, but it does not look like an Ollama API route. Check that `baseUrl` points at the Ollama server root and that no other service is bound to this port.");
-    }
-    const hint = renderProviderFailureHint(modelInfo);
-    if (hint) {
-        lines.push(hint);
-    }
-    return lines.join("\n");
-}
-function renderChatTextChunk(text, modelInfo) {
-    return renderChatRuntimeFailure(text, modelInfo);
-}
-function renderChatRequestRunning(input) {
-    const parts = [
-        input.sessionId ? `session=${input.sessionId}` : undefined,
-        input.requestId ? `request=${input.requestId}` : undefined,
-        input.agentId ? `agent=${input.agentId}` : undefined,
-        "running: waiting for model output",
-    ].filter((part) => typeof part === "string" && part.length > 0);
-    return `\n${parts.join(" ")}\n`;
-}
-function summarizeChatToolError(output) {
-    if (typeof output === "string") {
-        const trimmed = output.trim();
-        return trimmed.length > 0 ? truncateChatToolPreview(trimmed, 240) : "failed";
-    }
-    if (typeof output === "number" || typeof output === "boolean") {
-        return String(output);
-    }
-    if (!output || typeof output !== "object") {
-        return "failed";
-    }
-    const typed = output;
-    const content = extractChatToolTextContent(output);
-    if (content && content.trim().length > 0) {
-        return truncateChatToolPreview(content.trim(), 240);
-    }
-    const summary = typeof typed.summary === "object" && typed.summary !== null ? typed.summary : undefined;
-    if (summary) {
-        return truncateChatToolPreview(JSON.stringify(summary, null, 2), 240);
-    }
-    return truncateChatToolPreview(JSON.stringify(output, null, 2), 240);
-}
-function truncateChatToolPreview(value, maxChars = 800) {
-    if (value.length <= maxChars) {
-        return value;
-    }
-    return `${value.slice(0, maxChars - 15)}\n...[truncated]`;
-}
-function extractChatToolTextContent(value) {
-    if (typeof value === "string") {
-        return value;
-    }
-    if (Array.isArray(value)) {
-        return value
-            .map((item) => extractChatToolTextContent(item))
-            .filter((item) => item.trim().length > 0)
-            .join("\n");
-    }
-    if (!value || typeof value !== "object") {
-        return "";
-    }
-    const typed = value;
-    if (typeof typed.text === "string") {
-        return typed.text;
-    }
-    if (typeof typed.content === "string") {
-        return typed.content;
-    }
-    if (typed.content !== undefined) {
-        const nestedContent = extractChatToolTextContent(typed.content);
-        if (nestedContent.trim().length > 0) {
-            return nestedContent;
-        }
-    }
-    if (typed.kwargs !== undefined) {
-        const nestedKwargs = extractChatToolTextContent(typed.kwargs);
-        if (nestedKwargs.trim().length > 0) {
-            return nestedKwargs;
-        }
-    }
-    if (typed.message !== undefined) {
-        const nestedMessage = extractChatToolTextContent(typed.message);
-        if (nestedMessage.trim().length > 0) {
-            return nestedMessage;
-        }
-    }
-    if (typed.body !== undefined) {
-        const nestedBody = extractChatToolTextContent(typed.body);
-        if (nestedBody.trim().length > 0) {
-            return nestedBody;
-        }
-    }
-    if (typed.answer !== undefined) {
-        const nestedAnswer = extractChatToolTextContent(typed.answer);
-        if (nestedAnswer.trim().length > 0) {
-            return nestedAnswer;
-        }
-    }
-    return "";
-}
-function summarizeChatToolResult(output, isError) {
-    if (!isError) {
-        return "completed";
-    }
-    return summarizeChatToolError(output);
-}
-export async function probeChatWorkspace(input) {
-    const modelInfo = readChatWorkspaceModelInfo(input.workspaceRoot, input.agentId);
-    if (!modelInfo?.provider || modelInfo.provider !== "ollama" || !modelInfo.baseUrl) {
-        return undefined;
-    }
-    try {
-        const response = await fetch(new URL("/api/tags", modelInfo.baseUrl), {
-            method: "GET",
-            headers: { accept: "application/json" },
-        });
-        if (response.ok) {
-            return undefined;
-        }
-        if (response.status === 404) {
-            return renderChatRuntimeFailure("runtime_error=404 page not found", modelInfo);
-        }
-        return renderChatRuntimeFailure(`runtime_error=HTTP ${response.status} ${response.statusText}`.trim(), modelInfo);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return renderChatRuntimeFailure(`runtime_error=${message}`, modelInfo);
-    }
-}
-export function isChatServerNoiseLine(line) {
-    const trimmed = line.trim();
-    if (!trimmed) {
-        return true;
-    }
-    return (trimmed.startsWith("Serving ACP over stdio from ") ||
-        trimmed === "langsmith/experimental/sandbox is in alpha. This feature is experimental, and breaking changes are expected." ||
-        trimmed === "llamaindex was already imported. This breaks constructor checks and will lead to issues!");
-}
-const CLI_IGNORED_STDERR_WARNING_SNIPPETS = [
-    "llamaindex was already imported. This breaks constructor checks and will lead to issues!",
-    "MaxListenersExceededWarning: Possible EventEmitter memory leak detected.",
-    "(Use `node --trace-warnings ...` to show where the warning was created)",
-];
-function installCliWriteListenerGuard(streams, minimum = 64) {
-    const restore = [];
-    for (const stream of streams) {
-        if (!stream?.getMaxListeners || !stream?.setMaxListeners) {
-            continue;
-        }
-        const previous = stream.getMaxListeners();
-        if (previous === 0 || previous >= minimum) {
-            continue;
-        }
-        stream.setMaxListeners(minimum);
-        restore.push(() => stream.setMaxListeners?.(previous));
-    }
-    return () => {
-        for (const reset of restore.reverse()) {
-            reset();
-        }
-    };
-}
-function installCliEmitterListenerGuard(minimum = 64) {
-    const previous = EventEmitter.defaultMaxListeners;
-    const hadPrototypeMaxListeners = Object.prototype.hasOwnProperty.call(EventEmitter.prototype, "_maxListeners");
-    const previousPrototypeMaxListeners = EventEmitter.prototype._maxListeners;
-    if (previous === 0 || previous >= minimum) {
-        return () => undefined;
-    }
-    EventEmitter.defaultMaxListeners = minimum;
-    EventEmitter.prototype._maxListeners = minimum;
-    return () => {
-        EventEmitter.defaultMaxListeners = previous;
-        if (hadPrototypeMaxListeners) {
-            EventEmitter.prototype._maxListeners = previousPrototypeMaxListeners;
-            return;
-        }
-        delete EventEmitter.prototype._maxListeners;
-    };
-}
-function installCliStderrNoiseFilter(enabled) {
-    if (!enabled) {
-        return () => undefined;
-    }
-    const originalStderrWrite = process.stderr.write.bind(process.stderr);
-    process.stderr.write = ((chunk, encoding, callback) => {
-        const text = typeof chunk === "string"
-            ? chunk
-            : chunk instanceof Uint8Array
-                ? Buffer.from(chunk).toString(typeof encoding === "string" ? encoding : undefined)
-                : "";
-        if (CLI_IGNORED_STDERR_WARNING_SNIPPETS.some((snippet) => text.includes(snippet))) {
-            if (typeof encoding === "function") {
-                encoding();
-            }
-            else if (typeof callback === "function") {
-                callback();
-            }
-            return true;
-        }
-        if (typeof encoding === "function") {
-            return originalStderrWrite(chunk, encoding);
-        }
-        return originalStderrWrite(chunk, encoding, callback);
-    });
-    return () => {
-        process.stderr.write = originalStderrWrite;
-    };
-}
-function installCliWarningFilter() {
-    const originalEmitWarning = process.emitWarning.bind(process);
-    process.emitWarning = ((warning, ...args) => {
-        const text = typeof warning === "string" ? warning : warning?.message ?? "";
-        const name = typeof warning === "string" ? String(args[1] ?? args[0] ?? "") : warning?.name ?? "";
-        if (CLI_IGNORED_STDERR_WARNING_SNIPPETS.some((snippet) => text.includes(snippet))
-            || name === "MaxListenersExceededWarning") {
-            return;
-        }
-        return originalEmitWarning(warning, ...args);
-    });
-    return () => {
-        process.emitWarning = originalEmitWarning;
-    };
-}
-function terminateChatSubprocess(child, signal = "SIGTERM") {
-    if (child.killed || child.exitCode !== null || child.signalCode !== null) {
-        return;
-    }
-    try {
-        child.kill(signal);
-    }
-    catch {
-        // Ignore termination races during shutdown.
-    }
-}
-export function installChatSubprocessExitGuard(child, host = process) {
-    let cleanedUp = false;
-    let forceKillTimer;
-    const handleParentExit = () => {
-        terminateChatSubprocess(child, "SIGTERM");
-        if (!forceKillTimer && child.exitCode === null && child.signalCode === null) {
-            forceKillTimer = setTimeout(() => {
-                terminateChatSubprocess(child, "SIGKILL");
-            }, 2_000);
-            forceKillTimer.unref?.();
-        }
-    };
-    const cleanup = () => {
-        if (cleanedUp) {
-            return;
-        }
-        cleanedUp = true;
-        if (forceKillTimer) {
-            clearTimeout(forceKillTimer);
-            forceKillTimer = undefined;
-        }
-        host.off("beforeExit", handleParentExit);
-        host.off("exit", handleParentExit);
-        child.off("close", cleanup);
-        child.off("exit", cleanup);
-    };
-    host.on("beforeExit", handleParentExit);
-    host.on("exit", handleParentExit);
-    child.on("close", cleanup);
-    child.on("exit", cleanup);
-    return cleanup;
-}
-async function streamChatMessage(input) {
-    const requestStartedAt = Date.now();
-    let firstSnapshotAt;
-    let firstDataAt;
-    let latestSnapshot;
-    let latestSessionId = input.sessionId;
-    let latestRequestId;
-    let latestAgentId = input.agentId;
-    let wroteContent = false;
-    let wroteRenderableBlocks = false;
-    let lastRenderedRequestTreeKey;
-    let lastRenderedRequestTree = "";
-    let lastRenderedRequestTreeLineCount = 0;
-    let lastRenderedRequestTreeAt = 0;
-    let announcedRunningState = false;
-    let requestTreeVisible = false;
-    let requestTreePersisted = false;
-    let liveRequestAnnotations = [];
-    let persistedRequestTreeEventCount = 0;
-    let persistedRequestTreeTodoSignature = "";
-    const requestTreeRenderThrottleMs = 75;
-    let suppressRequestTreeRendering = false;
-    let lastStableRequestTreeKey;
-    let stdoutWriteChain = Promise.resolve();
-    let stderrWriteChain = Promise.resolve();
-    const enqueueChatWrite = (sink, _stream, chain, message) => chain.then(async () => {
-        sink(message);
-    });
-    const summarizeRequestTreeSteps = (steps) => steps
-        .map((step) => [
-        step.id ?? "",
-        step.kind,
-        step.name,
-        step.status,
-        step.startedAt ?? "",
-        step.endedAt ?? "",
-    ].join("|"))
-        .join(";");
-    const buildRequestSnapshotRenderKey = (snapshot) => {
-        const todoSignatures = snapshot.plan.items
-            .map((item) => [
-            item.id ?? "",
-            item.content,
-            item.status,
-            item.ownerAgentId ?? "",
-            item.startedAt ?? "",
-            item.endedAt ?? "",
-            item.result === undefined ? "" : String(item.result),
-            summarizeRequestTreeSteps(item.events),
-        ].join("|"))
-            .join(";");
-        const approvalSignature = snapshot.approval
-            ? [
-                snapshot.approval.approvalId,
-                snapshot.approval.status,
-                snapshot.approval.toolName ?? "",
-            ].join("|")
-            : "";
-        return [
-            snapshot.sessionId,
-            snapshot.requestId,
-            snapshot.state,
-            snapshot.agentId ?? "",
-            snapshot.plan.version,
-            snapshot.plan.updatedAt,
-            snapshot.plan.summary.total,
-            snapshot.plan.summary.inProgress,
-            snapshot.plan.summary.completed,
-            snapshot.plan.summary.failed,
-            approvalSignature,
-            summarizeRequestTreeSteps(snapshot.events),
-            todoSignatures,
-        ].join("||");
-    };
-    const buildPlanSnapshotRenderKey = (snapshot) => [
-        snapshot.plan.version,
-        snapshot.plan.updatedAt,
-        snapshot.plan.summary.total,
-        snapshot.plan.summary.inProgress,
-        snapshot.plan.summary.completed,
-        snapshot.plan.summary.failed,
-        snapshot.plan.items
-            .map((item) => [
-            item.id ?? "",
-            item.content,
-            item.status,
-            item.ownerAgentId ?? "",
-            item.startedAt ?? "",
-            item.endedAt ?? "",
-            item.result === undefined ? "" : String(item.result),
-        ].join("|"))
-            .join(";"),
-    ].join("||");
-    const formatPerfClock = (timestamp) => {
-        const value = new Date(timestamp);
-        return value.toLocaleTimeString("en-US", {
-            hour12: false,
-            hour: "2-digit",
-            minute: "2-digit",
-            second: "2-digit",
-            fractionalSecondDigits: 3,
-        });
-    };
-    const formatElapsed = (timestamp) => `${((timestamp - requestStartedAt) / 1000).toFixed(3)}s`;
-    const buildTimingSummary = (completedAt) => {
-        const parts = [`start ${formatPerfClock(requestStartedAt)}`];
-        if (firstSnapshotAt) {
-            parts.push(`first event +${formatElapsed(firstSnapshotAt)}`);
-        }
-        if (firstDataAt) {
-            parts.push(`first data +${formatElapsed(firstDataAt)}`);
-        }
-        if (completedAt) {
-            parts.push(`done +${formatElapsed(completedAt)}`);
-        }
-        else {
-            parts.push(`live +${formatElapsed(Date.now())}`);
-        }
-        return parts.join(" · ");
-    };
-    const buildLiveRequestTreeBlock = () => {
-        if (!lastRenderedRequestTree) {
-            return "";
-        }
-        const annotationBlock = liveRequestAnnotations.length > 0
-            ? `\n${liveRequestAnnotations.join("")}`
-            : "";
-        return `${lastRenderedRequestTree}${annotationBlock}`;
-    };
-    const clearLiveRequestTree = () => {
-        if (!input.requestEvents || !input.liveRequestTree || !requestTreeVisible || lastRenderedRequestTreeLineCount <= 0) {
-            return;
-        }
-        stderrWriteChain = enqueueChatWrite(input.stderr, input.stderrStream, stderrWriteChain, `\x1b[${lastRenderedRequestTreeLineCount}F\x1b[0J`);
-        requestTreeVisible = false;
-    };
-    const drawLiveRequestTree = () => {
-        if (!input.requestEvents || !input.liveRequestTree || !lastRenderedRequestTree) {
-            return;
-        }
-        const block = buildLiveRequestTreeBlock();
-        stderrWriteChain = enqueueChatWrite(input.stderr, input.stderrStream, stderrWriteChain, block);
-        lastRenderedRequestTreeLineCount = countRenderedLines(block);
-        requestTreeVisible = true;
-    };
-    const persistLiveRequestTree = () => {
-        if (!input.requestEvents || !input.liveRequestTree || requestTreePersisted || !lastRenderedRequestTree) {
-            return;
-        }
-        if (requestTreeVisible && lastRenderedRequestTreeLineCount > 0) {
-            stderrWriteChain = enqueueChatWrite(input.stderr, input.stderrStream, stderrWriteChain, `\x1b[${lastRenderedRequestTreeLineCount}F\x1b[0J`);
-            requestTreeVisible = false;
-        }
-        const combinedBlock = buildLiveRequestTreeBlock();
-        const treeBlock = combinedBlock.endsWith("\n")
-            ? combinedBlock
-            : `${combinedBlock}\n`;
-        stderrWriteChain = enqueueChatWrite(input.stderr, input.stderrStream, stderrWriteChain, treeBlock);
-        persistedRequestTreeEventCount = latestSnapshot ? flattenRequestExecutionSteps(latestSnapshot).length : 0;
-        persistedRequestTreeTodoSignature = latestSnapshot ? buildTodoContinuationSignature(latestSnapshot) : "";
-        requestTreePersisted = true;
-    };
-    const enqueueOrderedStdout = (message) => {
-        const barrier = Promise.allSettled([stdoutWriteChain, stderrWriteChain]).then(() => undefined);
-        stdoutWriteChain = enqueueChatWrite(input.stdout, input.stdoutStream, barrier, message);
-    };
-    const writeChatStdout = (message) => {
-        if (input.requestEvents && input.liveRequestTree && !suppressRequestTreeRendering) {
-            clearLiveRequestTree();
-            enqueueOrderedStdout(message);
-            drawLiveRequestTree();
-            return;
-        }
-        if (input.requestEvents && input.liveRequestTree) {
-            enqueueOrderedStdout(message);
-            return;
-        }
-        stdoutWriteChain = enqueueChatWrite(input.stdout, input.stdoutStream, stdoutWriteChain, message);
-    };
-    const writeChatStderr = (message) => {
-        if (input.requestEvents && input.liveRequestTree && !suppressRequestTreeRendering) {
-            clearLiveRequestTree();
-            stderrWriteChain = enqueueChatWrite(input.stderr, input.stderrStream, stderrWriteChain, message);
-            drawLiveRequestTree();
-            return;
-        }
-        stderrWriteChain = enqueueChatWrite(input.stderr, input.stderrStream, stderrWriteChain, message);
-    };
-    const renderPlanSnapshot = (snapshot) => {
-        return;
-    };
-    const suspendRequestTreeRendering = () => {
-        if (!input.requestEvents || !input.liveRequestTree) {
-            return;
-        }
-        persistLiveRequestTree();
-        suppressRequestTreeRendering = true;
-        clearLiveRequestTree();
-    };
-    const renderExecutionStepEvents = (snapshot) => {
-        return;
-    };
-    const renderContentBlocks = (contentBlocks, agentId) => {
-        latestAgentId = agentId || latestAgentId;
-        if (!wroteContent) {
-            const rendered = contentBlocks
-                .map((block) => {
-                if (typeof block === "string") {
-                    return block;
-                }
-                if (block && typeof block === "object" && "text" in block && typeof block.text === "string") {
-                    return block.text;
-                }
-                return "";
-            })
-                .filter((block) => block.trim().length > 0)
-                .join("");
-            if (rendered) {
-                if (input.requestEvents) {
-                    suspendRequestTreeRendering();
-                }
-                writeChatStdout(renderChatTextChunk(rendered, input.modelInfo));
-                wroteRenderableBlocks = true;
-            }
-        }
-    };
-    let result;
-    try {
-        result = await input.client.request({
-            ...(input.agentId ? { agentId: input.agentId } : {}),
-            ...(input.sessionId ? { sessionId: input.sessionId } : {}),
-            input: input.message,
-            eventListener(snapshot) {
-                latestSessionId = snapshot.sessionId || latestSessionId;
-                latestRequestId = snapshot.requestId || latestRequestId;
-                latestAgentId = snapshot.agentId || latestAgentId;
-                latestSnapshot = snapshot;
-                firstSnapshotAt ??= Date.now();
-                if (input.requestEvents && !suppressRequestTreeRendering) {
-                    const now = Date.now();
-                    const nextTreeKey = buildRequestSnapshotRenderKey(snapshot);
-                    const terminalSnapshot = snapshot.state !== "queued" && snapshot.state !== "claimed" && snapshot.state !== "running";
-                    const snapshotCarriesRenderableOutput = snapshot.output.trim().length > 0;
-                    const shouldRenderSnapshot = !snapshotCarriesRenderableOutput
-                        && nextTreeKey !== lastRenderedRequestTreeKey
-                        && nextTreeKey !== lastStableRequestTreeKey
-                        && ((terminalSnapshot && !input.liveRequestTree)
-                            || !input.liveRequestTree
-                            || now - lastRenderedRequestTreeAt >= requestTreeRenderThrottleMs);
-                    if (shouldRenderSnapshot) {
-                        lastRenderedRequestTree = renderRequestSnapshotTree(snapshot, input.colorRequestTree === true, buildTimingSummary());
-                        if (input.liveRequestTree) {
-                            clearLiveRequestTree();
-                            drawLiveRequestTree();
-                        }
-                        else {
-                            input.stderr(`\n${lastRenderedRequestTree}`);
-                        }
-                        lastRenderedRequestTreeKey = nextTreeKey;
-                        if (!snapshot.activeEventId && snapshot.state !== "running") {
-                            lastStableRequestTreeKey = nextTreeKey;
-                        }
-                        lastRenderedRequestTreeAt = now;
-                    }
-                }
-                if ((input.showRunningState ?? true) && !input.requestEvents && !announcedRunningState && !wroteContent && !wroteRenderableBlocks) {
-                    input.stderr(renderChatRequestRunning({
-                        sessionId: snapshot.sessionId,
-                        requestId: snapshot.requestId,
-                        agentId: snapshot.agentId,
-                    }));
-                    announcedRunningState = true;
-                }
-                renderExecutionStepEvents(snapshot);
-                renderPlanSnapshot({
-                    sessionId: snapshot.sessionId,
-                    requestId: snapshot.requestId,
-                    plan: {
-                        version: snapshot.plan.version,
-                        updatedAt: snapshot.plan.updatedAt,
-                        items: snapshot.plan.items.map((item) => ({
-                            id: item.id,
-                            content: item.content,
-                            status: item.status,
-                            ownerAgentId: item.ownerAgentId,
-                            startedAt: item.startedAt,
-                            endedAt: item.endedAt,
-                            result: item.result,
-                            metadata: item.metadata,
-                        })),
-                        summary: snapshot.plan.summary,
-                    },
-                });
-            },
-            dataListener(delta) {
-                latestSessionId = delta.sessionId || latestSessionId;
-                latestRequestId = delta.requestId || latestRequestId;
-                firstDataAt ??= Date.now();
-                if (delta.type === "output.text.delta") {
-                    latestAgentId = delta.agentId || latestAgentId;
-                    if (input.requestEvents) {
-                        suspendRequestTreeRendering();
-                    }
-                    writeChatStdout(renderChatTextChunk(delta.text, input.modelInfo));
-                    wroteContent = true;
-                    return;
-                }
-                if (delta.type === "output.content-blocks") {
-                    suspendRequestTreeRendering();
-                    renderContentBlocks(delta.contentBlocks, delta.agentId);
-                    return;
-                }
-                if (delta.type === "tool.result") {
-                    latestAgentId = delta.agentId || latestAgentId;
-                    if ((input.showToolResults ?? true) && !input.requestEvents) {
-                        writeChatStderr(`\n[${formatPerfClock(Date.now())} +${formatElapsed(Date.now())}] [tool:${delta.toolName}] ${summarizeChatToolResult(delta.output, delta.isError === true)}${delta.isError ? " (error)" : ""}\n`);
-                    }
-                    return;
-                }
-                if (delta.type === "progress.commentary") {
-                    latestAgentId = delta.agentId || latestAgentId;
-                    if (wroteContent || wroteRenderableBlocks) {
-                        return;
-                    }
-                    const progressLine = `[${formatPerfClock(Date.now())} +${formatElapsed(Date.now())}] ${delta.text}\n`;
-                    if (input.requestEvents && input.liveRequestTree && !suppressRequestTreeRendering && lastRenderedRequestTree) {
-                        liveRequestAnnotations.push(progressLine);
-                        clearLiveRequestTree();
-                        drawLiveRequestTree();
-                        return;
-                    }
-                    writeChatStderr(`[${formatPerfClock(Date.now())} +${formatElapsed(Date.now())}] ${delta.text}\n`);
-                }
-            },
-        });
-    }
-    catch (error) {
-        throw error;
-    }
-    if (!result) {
-        throw new Error("chat request completed without a terminal result");
-    }
-    latestSessionId = result.sessionId;
-    latestRequestId = result.requestId;
-    latestAgentId = result.agentId ?? latestAgentId;
-    const completedAt = Date.now();
-    if (input.requestEvents && latestSnapshot) {
-        const terminalSnapshot = buildTerminalRequestSnapshot(latestSnapshot, { state: result.state, output: result.output });
-        lastRenderedRequestTree = renderRequestSnapshotTree(terminalSnapshot, input.colorRequestTree === true, buildTimingSummary(completedAt));
-        if (input.liveRequestTree && !requestTreePersisted) {
-            clearLiveRequestTree();
-            drawLiveRequestTree();
-        }
-        else if (input.liveRequestTree && requestTreePersisted) {
-            const todoContinuation = renderRequestTodoContinuation(terminalSnapshot, persistedRequestTreeTodoSignature, input.colorRequestTree === true);
-            const continuation = renderRequestEventContinuation(terminalSnapshot, persistedRequestTreeEventCount, input.colorRequestTree === true);
-            if (todoContinuation) {
-                stderrWriteChain = enqueueChatWrite(input.stderr, input.stderrStream, stderrWriteChain, `\n${todoContinuation}`);
-            }
-            if (continuation) {
-                stderrWriteChain = enqueueChatWrite(input.stderr, input.stderrStream, stderrWriteChain, `\n${continuation}`);
-            }
-        }
-        else if (!input.liveRequestTree) {
-            input.stderr(`\n${lastRenderedRequestTree}`);
-        }
-    }
-    if (!wroteContent && !wroteRenderableBlocks && result.output.trim().length > 0) {
-        writeChatStdout(renderChatTextChunk(result.output, input.modelInfo));
-    }
-    if (result.state === "waiting_for_approval") {
-        writeChatStderr(`\nRequest is waiting for approval${result.approvalId ? ` (${result.approvalId})` : ""}.\n`);
-    }
-    else if ((wroteContent || wroteRenderableBlocks || result.output.trim().length > 0)) {
-        writeChatStdout("\n");
-    }
-    await Promise.allSettled([stdoutWriteChain, stderrWriteChain]);
-    return { sessionId: latestSessionId, requestId: latestRequestId, agentId: latestAgentId };
-}
-export async function runCli(argv, io = {}, deps = {}) {
-    const cwd = io.cwd ?? process.cwd();
-    const stdin = io.stdin ?? process.stdin;
-    const stdout = io.stdout ?? ((message) => process.stdout.write(message));
-    const stderr = io.stderr ?? ((message) => process.stderr.write(message));
-    const stdoutStream = io.stdout === undefined ? process.stdout : undefined;
-    const stderrStream = io.stderr === undefined ? process.stderr : undefined;
-    const [command, projectName, ...rest] = argv;
-    const probeWorkspace = deps.probeChatWorkspace ?? probeChatWorkspace;
-    const createChatLineReader = deps.createReadlineInterface ?? createReadlineInterface;
-    const createHarness = deps.createAgentHarness ?? createAgentHarness;
-    const serveA2a = deps.serveA2aOverHttp ?? serveA2aOverHttp;
-    const serveAgUi = deps.serveAgUiOverHttp ?? serveAgUiOverHttp;
-    const serveAcpHttp = deps.serveAcpOverHttp ?? serveAcpOverHttp;
-    const serveAcp = deps.serveAcpOverStdio ?? serveAcpOverStdio;
-    const serveRuntimeMcp = deps.serveRuntimeMcpOverStdio ?? serveRuntimeMcpOverStdio;
-    const serveRuntimeMcpStreamableHttp = deps.serveRuntimeMcpOverStreamableHttp ?? serveRuntimeMcpOverStreamableHttp;
-    const spawnManagedCliProcess = deps.spawnManagedCliProcess ?? defaultSpawnManagedCliProcess;
-    const isManagedProcessRunning = deps.isManagedProcessRunning ?? defaultIsManagedProcessRunning;
-    const signalManagedProcess = deps.signalManagedProcess ?? defaultSignalManagedProcess;
-    const createChatClient = deps.createChatClient ?? (async (input) => {
-        if (input.transport === "http") {
-            return createAcpHttpHarnessClient({
-                rpcUrl: `http://${input.hostname ?? "127.0.0.1"}:${input.port ?? 8787}/rpc`,
-                eventsUrl: `http://${input.hostname ?? "127.0.0.1"}:${input.port ?? 8787}/events`,
-            });
-        }
-        const runtime = await createHarness(input.workspaceRoot);
-        return createInProcessHarnessClient(runtime);
-    });
-    const executeChat = async (parsed) => {
-        const workspacePath = resolveCliWorkspaceRoot(cwd, parsed.workspaceRoot);
-        const workspaceError = validateCliWorkspaceRoot(workspacePath, parsed.workspaceRoot);
-        if (workspaceError) {
-            stderr(`${workspaceError}\n`);
-            return 1;
-        }
-        const workspaceModelInfo = readChatWorkspaceModelInfo(workspacePath, parsed.agentId);
-        const chatStdinStream = stdin;
-        let client;
-        let restoreWriteListenerGuard;
-        let restoreEmitterListenerGuard;
-        let restoreStderrNoiseFilter;
-        let restoreWarningFilter;
-        try {
-            restoreEmitterListenerGuard = installCliEmitterListenerGuard();
-            restoreStderrNoiseFilter = installCliStderrNoiseFilter(io.stderr === undefined);
-            restoreWarningFilter = installCliWarningFilter();
-            client = await createChatClient({
-                workspaceRoot: workspacePath,
-                transport: parsed.transport,
-                hostname: parsed.hostname,
-                port: parsed.port,
-                stderr,
-            });
-            restoreWriteListenerGuard = installCliWriteListenerGuard([stdoutStream, stderrStream]);
-            let activeAgentId = parsed.agentId;
-            let activeSessionId = parsed.sessionId;
-            let latestRequestId;
-            const useColor = false;
-            const preflightWarning = parsed.message
-                ? undefined
-                : await probeWorkspace({
-                    workspaceRoot: workspacePath,
-                    agentId: activeAgentId,
-                });
-            if (parsed.message) {
-                await streamChatMessage({
-                    client,
-                    stdout,
-                    stdoutStream,
-                    stderr,
-                    stderrStream,
-                    agentId: activeAgentId,
-                    sessionId: activeSessionId,
-                    message: parsed.message,
-                    modelInfo: workspaceModelInfo,
-                    requestEvents: parsed.requestEvents,
-                    liveRequestTree: parsed.requestEvents && chatStdinStream.isTTY === true,
-                    colorRequestTree: useColor,
-                    showToolResults: parsed.requestEvents,
-                    showRunningState: false,
-                });
-                await client.stop();
-                restoreWriteListenerGuard?.();
-                restoreEmitterListenerGuard?.();
-                restoreStderrNoiseFilter?.();
-                restoreWarningFilter?.();
-                return 0;
-            }
-            stdout(renderChatBanner({
-                workspacePath,
-                transport: parsed.transport,
-                agentId: activeAgentId,
-                sessionId: activeSessionId,
-                color: useColor,
-            }));
-            if (preflightWarning) {
-                stdout(`${preflightWarning}\n\n`);
-            }
-            const stdoutSink = new Writable({
-                decodeStrings: false,
-                write(chunk, _encoding, callback) {
-                    stdout(typeof chunk === "string" ? chunk : String(chunk));
-                    callback();
-                },
-            });
-            const lineReader = createChatLineReader({
-                input: stdin,
-                output: stdoutSink,
-                crlfDelay: Infinity,
-                terminal: chatStdinStream.isTTY === true,
-            });
-            try {
-                for await (const raw of iterateChatLines(lineReader, () => renderChatPromptLine({
-                    agentId: activeAgentId,
-                    sessionId: activeSessionId,
-                    requestId: latestRequestId,
-                    color: useColor,
-                }))) {
-                    const trimmed = raw.trim();
-                    if (!trimmed) {
-                        continue;
-                    }
-                    const chatCommand = normalizeChatCommand(trimmed);
-                    if (!chatCommand) {
-                        const streamed = await streamChatMessage({
-                            client,
-                            stdout,
-                            stdoutStream,
-                            stderr,
-                            stderrStream,
-                            agentId: activeAgentId,
-                            sessionId: activeSessionId,
-                            message: trimmed,
-                            modelInfo: workspaceModelInfo,
-                            requestEvents: parsed.requestEvents,
-                            liveRequestTree: parsed.requestEvents && chatStdinStream.isTTY === true,
-                            colorRequestTree: useColor,
-                            showToolResults: parsed.requestEvents,
-                            showRunningState: false,
-                        });
-                        activeSessionId = streamed.sessionId;
-                        latestRequestId = streamed.requestId;
-                        activeAgentId = streamed.agentId ?? activeAgentId;
-                        continue;
-                    }
-                    if (chatCommand.name === "exit" || chatCommand.name === "quit") {
-                        break;
-                    }
-                    if (chatCommand.name === "help") {
-                        stdout(renderChatHelp());
-                        continue;
-                    }
-                    if (chatCommand.name === "context") {
-                        stdout(renderChatContext({
-                            agentId: activeAgentId,
-                            sessionId: activeSessionId,
-                            requestId: latestRequestId,
-                        }));
-                        continue;
-                    }
-                    if (chatCommand.name === "new") {
-                        activeSessionId = undefined;
-                        latestRequestId = undefined;
-                        stdout(renderChatContext({
-                            agentId: activeAgentId,
-                            sessionId: activeSessionId,
-                            requestId: latestRequestId,
-                        }));
-                        continue;
-                    }
-                    if (chatCommand.name === "agent") {
-                        if (!chatCommand.arg) {
-                            stdout(activeAgentId ? `${activeAgentId}\n` : "No active agent override.\n");
-                            continue;
-                        }
-                        activeAgentId = chatCommand.arg;
-                        stdout(`agent=${activeAgentId}\n`);
-                        continue;
-                    }
-                    if (chatCommand.name === "session") {
-                        stdout(activeSessionId ? `${activeSessionId}\n` : "No active session.\n");
-                        continue;
-                    }
-                    if (chatCommand.name === "request") {
-                        if (!chatCommand.arg) {
-                            stdout(latestRequestId ? `${latestRequestId}\n` : "No active request.\n");
-                            continue;
-                        }
-                        const selected = await client.getRequest(chatCommand.arg);
-                        if (!selected) {
-                            stdout(`Request not found: ${chatCommand.arg}\n`);
-                            continue;
-                        }
-                        latestRequestId = selected.requestId;
-                        activeSessionId = selected.sessionId;
-                        activeAgentId = selected.agentId;
-                        stdout(`request=${latestRequestId} session=${activeSessionId}\n`);
-                        continue;
-                    }
-                    if (chatCommand.name === "sessions") {
-                        const summaries = await client.listSessionSummaries(parsed.agentId ? { agentId: parsed.agentId } : undefined);
-                        stdout(renderSessionSummaries(summaries));
-                        continue;
-                    }
-                    if (chatCommand.name === "requests") {
-                        const requests = await client.listRequests(activeSessionId
-                            ? { sessionId: activeSessionId }
-                            : activeAgentId
-                                ? { agentId: activeAgentId }
-                                : undefined);
-                        stdout(renderRequestList(requests));
-                        continue;
-                    }
-                    if (chatCommand.name === "resume") {
-                        if (!chatCommand.arg) {
-                            stdout("Usage: /resume <sessionId>\n");
-                            continue;
-                        }
-                        const session = await client.getSession(chatCommand.arg);
-                        if (!session) {
-                            stdout(`Session not found: ${chatCommand.arg}\n`);
-                            continue;
-                        }
-                        activeSessionId = chatCommand.arg;
-                        latestRequestId = session.latestRequestId;
-                        activeAgentId = session.currentAgentId ?? session.entryAgentId ?? activeAgentId;
-                        stdout(`session=${activeSessionId}\n`);
-                        continue;
-                    }
-                    if (chatCommand.name === "cancel") {
-                        if (!latestRequestId) {
-                            stdout("No active request.\n");
-                            continue;
-                        }
-                        const result = await client.cancelRequest({
-                            requestId: latestRequestId,
-                            reason: "Cancelled from chat CLI",
-                        });
-                        activeSessionId = result.sessionId;
-                        latestRequestId = result.requestId;
-                        stdout(`${result.state}: ${result.output}\n`);
-                        continue;
-                    }
-                    if (chatCommand.name === "approvals") {
-                        const approvals = await client.listApprovals(activeSessionId ? { sessionId: activeSessionId, status: "pending" } : { status: "pending" });
-                        stdout(renderApprovalList(approvals));
-                        continue;
-                    }
-                    if ((chatCommand.name === "approve" || chatCommand.name === "reject") && chatCommand.arg) {
-                        const result = await client.resolveApproval({
-                            approvalId: chatCommand.arg,
-                            decision: chatCommand.name === "approve" ? "approve" : "reject",
-                            ...(activeSessionId ? { sessionId: activeSessionId } : {}),
-                        });
-                        activeSessionId = result.sessionId;
-                        latestRequestId = result.requestId;
-                        stdout(`${result.state}: ${result.output}\n`);
-                        continue;
-                    }
-                    if (chatCommand.name === "events") {
-                        if (!activeSessionId || !latestRequestId) {
-                            stdout("No active request.\n");
-                            continue;
-                        }
-                        const events = await client.listRequestEvents({
-                            sessionId: activeSessionId,
-                            requestId: latestRequestId,
-                        });
-                        stdout(renderRequestEvents(events));
-                        continue;
-                    }
-                    if (chatCommand.name === "trace") {
-                        if (!activeSessionId || !latestRequestId) {
-                            stdout("No active request.\n");
-                            continue;
-                        }
-                        const traceItems = await client.listRequestTraceItems({
-                            sessionId: activeSessionId,
-                            requestId: latestRequestId,
-                        });
-                        stdout(renderRequestTraceItems(traceItems));
-                        continue;
-                    }
-                    if (chatCommand.name === "health") {
-                        const health = await client.getHealth();
-                        stdout(renderHealthSnapshot(health, workspacePath));
-                        continue;
-                    }
-                    if (chatCommand.name === "overview") {
-                        const overview = await client.getOperatorOverview({ limit: 5 });
-                        stdout(renderOperatorOverview(overview, workspacePath));
-                        continue;
-                    }
-                    stdout("Unknown chat command. Use /help.\n");
-                }
-            }
-            finally {
-                lineReader.close();
-            }
-            await client.stop();
-            restoreWriteListenerGuard?.();
-            restoreEmitterListenerGuard?.();
-            restoreStderrNoiseFilter?.();
-            restoreWarningFilter?.();
-            return 0;
-        }
-        catch (error) {
-            restoreWriteListenerGuard?.();
-            restoreEmitterListenerGuard?.();
-            restoreStderrNoiseFilter?.();
-            restoreWarningFilter?.();
-            const message = error instanceof Error ? error.message : String(error);
-            stderr(`${message}\n`);
-            if (client) {
-                await client.stop().catch(() => undefined);
-            }
-            return 1;
-        }
-    };
-    const startManagedHttpService = async (service, workspacePath, args) => {
-        const existing = await readManagedServiceState(workspacePath, service);
-        if (existing && isManagedProcessRunning(existing.pid)) {
-            stderr(`${service.toUpperCase()} service is already running for ${workspacePath} (pid ${existing.pid}).\n`);
-            return 0;
-        }
-        if (existing) {
-            await clearManagedServiceState(workspacePath, service);
-        }
-        const stdoutPath = managedServiceLogPath(workspacePath, service, "stdout");
-        const stderrPath = managedServiceLogPath(workspacePath, service, "stderr");
-        const spawned = await spawnManagedCliProcess({
-            args,
-            cwd: workspacePath,
-            stdoutPath,
-            stderrPath,
-        });
-        if (!spawned.pid || spawned.pid <= 0) {
-            stderr(`Failed to start ${service.toUpperCase()} service for ${workspacePath}.\n`);
-            return 1;
-        }
-        await writeManagedServiceState({
-            pid: spawned.pid,
-            service,
-            workspaceRoot: workspacePath,
-            transport: service === "mcp" ? "streamable-http" : "http",
-            startedAt: new Date().toISOString(),
-            stdoutPath,
-            stderrPath,
-        });
-        await sleep(250);
-        if (!isManagedProcessRunning(spawned.pid)) {
-            await clearManagedServiceState(workspacePath, service);
-            stderr(`Failed to keep ${service.toUpperCase()} service running for ${workspacePath}. Check ${stderrPath}.\n`);
-            return 1;
-        }
-        stderr(`Started ${service.toUpperCase()} service for ${workspacePath} (pid ${spawned.pid}). Logs: ${stdoutPath}, ${stderrPath}\n`);
-        return 0;
-    };
-    const stopManagedHttpService = async (service, workspacePath) => {
-        const existing = await readManagedServiceState(workspacePath, service);
-        if (!existing) {
-            stderr(`No managed ${service.toUpperCase()} service is recorded for ${workspacePath}.\n`);
-            return 0;
-        }
-        if (!isManagedProcessRunning(existing.pid)) {
-            await clearManagedServiceState(workspacePath, service);
-            stderr(`Managed ${service.toUpperCase()} service for ${workspacePath} is already stopped.\n`);
-            return 0;
-        }
-        signalManagedProcess(existing.pid, "SIGTERM");
-        for (let attempt = 0; attempt < 20; attempt += 1) {
-            await sleep(100);
-            if (!isManagedProcessRunning(existing.pid)) {
-                await clearManagedServiceState(workspacePath, service);
-                stderr(`Stopped ${service.toUpperCase()} service for ${workspacePath}.\n`);
-                return 0;
-            }
-        }
-        stderr(`Timed out while stopping ${service.toUpperCase()} service for ${workspacePath} (pid ${existing.pid}).\n`);
-        return 1;
-    };
-    if (command === "init") {
-        if (!projectName?.trim()) {
-            stderr(renderUsage());
-            return 1;
-        }
-        const parsed = parseInitOptions(rest);
-        if (parsed.error) {
-            stderr(`${parsed.error}\n`);
-            stderr(renderUsage());
-            return 1;
-        }
-        try {
-            const projectRoot = path.resolve(cwd, projectName);
-            const result = await initProject(projectRoot, projectName, parsed.options);
-            stdout(`Created ${result.projectSlug} at ${result.projectRoot}\n`);
-            stdout("Next steps:\n");
-            stdout(`  cd ${projectName}\n`);
-            stdout("  npm install\n");
-            if ((parsed.options?.provider ?? "openai") === "openai") {
-                stdout("  export OPENAI_API_KEY=your_key_here\n");
-            }
-            stdout('  npm run start -- "Research a topic"\n');
-            return 0;
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            stderr(`${message}\n`);
-            return 1;
-        }
-    }
-    if (command === "chat") {
-        const parsed = parseChatOptions([projectName, ...rest].filter((item) => typeof item === "string"));
-        if (parsed.error) {
-            stderr(`${parsed.error}\n`);
-            stderr(renderUsage());
-            return 1;
-        }
-        return executeChat(parsed);
-    }
-    if (!isTopLevelCliCommand(command)) {
-        const parsed = parseChatOptions(argv);
-        if (parsed.error) {
-            stderr(`${parsed.error}\n`);
-            stderr(renderUsage());
-            return 1;
-        }
-        return executeChat(parsed);
-    }
-    if (command === "acp") {
-        const [subcommand, ...subcommandArgs] = [projectName, ...rest];
-        if (subcommand !== "serve" && subcommand !== "start" && subcommand !== "stop") {
-            stderr(renderUsage());
-            return 1;
-        }
-        const parsedStop = subcommand === "stop" ? parseWorkspaceOnlyOptions(subcommandArgs) : undefined;
-        const parsedServe = subcommand !== "stop"
-            ? parseAcpServeOptions(subcommandArgs, subcommand === "start" ? "http" : "stdio")
-            : undefined;
-        const parseError = parsedStop?.error ?? parsedServe?.error;
-        if (parseError) {
-            stderr(`${parseError}\n`);
-            stderr(renderUsage());
-            return 1;
-        }
-        try {
-            const workspaceRoot = parsedStop?.workspaceRoot ?? parsedServe?.workspaceRoot;
-            const workspacePath = resolveCliWorkspaceRoot(cwd, workspaceRoot);
-            const workspaceError = validateCliWorkspaceRoot(workspacePath, workspaceRoot);
-            if (workspaceError) {
-                stderr(`${workspaceError}\n`);
-                return 1;
-            }
-            if (subcommand === "start") {
-                if (!parsedServe) {
-                    stderr(renderUsage());
-                    return 1;
-                }
-                if (parsedServe.transport !== "http") {
-                    stderr("ACP start only supports --transport http. Use `acp serve --transport stdio` for stdio clients.\n");
-                    return 1;
-                }
-                const args = ["acp", "serve", "--workspace", workspacePath, "--transport", "http"];
-                if (parsedServe.hostname) {
-                    args.push("--host", parsedServe.hostname);
-                }
-                if (typeof parsedServe.port === "number") {
-                    args.push("--port", String(parsedServe.port));
-                }
-                return startManagedHttpService("acp", workspacePath, args);
-            }
-            if (subcommand === "stop") {
-                return stopManagedHttpService("acp", workspacePath);
-            }
-            if (!parsedServe) {
-                stderr(renderUsage());
-                return 1;
-            }
-            const runtime = await createHarness(workspacePath);
-            if (parsedServe.transport === "http") {
-                const server = await serveAcpHttp(runtime, {
-                    hostname: parsedServe.hostname,
-                    port: parsedServe.port,
-                });
-                stderr(`Serving ACP over http from ${workspacePath} at ${server.rpcUrl} (events ${server.eventsUrl})\n`);
-                await server.completed;
-            }
-            else {
-                stderr(`Serving ACP over stdio from ${workspacePath}\n`);
-                const server = serveAcp(runtime);
-                await server.completed;
-            }
-            await runtime.stop();
-            return 0;
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            stderr(`${message}\n`);
-            return 1;
-        }
-    }
-    if (command === "ag-ui") {
-        const [subcommand, ...subcommandArgs] = [projectName, ...rest];
-        if (subcommand !== "serve") {
-            stderr(renderUsage());
-            return 1;
-        }
-        const parsed = parseHttpServeOptions(subcommandArgs, "AG-UI");
-        if (parsed.error) {
-            stderr(`${parsed.error}\n`);
-            stderr(renderUsage());
-            return 1;
-        }
-        try {
-            const workspacePath = resolveCliWorkspaceRoot(cwd, parsed.workspaceRoot);
-            const workspaceError = validateCliWorkspaceRoot(workspacePath, parsed.workspaceRoot);
-            if (workspaceError) {
-                stderr(`${workspaceError}\n`);
-                return 1;
-            }
-            const runtime = await createHarness(workspacePath);
-            const server = await serveAgUi(runtime, {
-                hostname: parsed.hostname,
-                port: parsed.port,
-            });
-            stderr(`Serving AG-UI over http from ${workspacePath} at ${server.runUrl}\n`);
-            await server.completed;
-            await runtime.stop();
-            return 0;
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            stderr(`${message}\n`);
-            return 1;
-        }
-    }
-    if (command === "a2a") {
-        const [subcommand, ...subcommandArgs] = [projectName, ...rest];
-        if (subcommand !== "serve" && subcommand !== "start" && subcommand !== "stop") {
-            stderr(renderUsage());
-            return 1;
-        }
-        const parsedStop = subcommand === "stop" ? parseWorkspaceOnlyOptions(subcommandArgs) : undefined;
-        const parsedServe = subcommand !== "stop" ? parseHttpServeOptions(subcommandArgs, "A2A") : undefined;
-        const parseError = parsedStop?.error ?? parsedServe?.error;
-        if (parseError) {
-            stderr(`${parseError}\n`);
-            stderr(renderUsage());
-            return 1;
-        }
-        try {
-            const workspaceRoot = parsedStop?.workspaceRoot ?? parsedServe?.workspaceRoot;
-            const workspacePath = resolveCliWorkspaceRoot(cwd, workspaceRoot);
-            const workspaceError = validateCliWorkspaceRoot(workspacePath, workspaceRoot);
-            if (workspaceError) {
-                stderr(`${workspaceError}\n`);
-                return 1;
-            }
-            if (subcommand === "start") {
-                const args = ["a2a", "serve", "--workspace", workspacePath];
-                if (parsedServe?.hostname) {
-                    args.push("--host", parsedServe.hostname);
-                }
-                if (typeof parsedServe?.port === "number") {
-                    args.push("--port", String(parsedServe.port));
-                }
-                return startManagedHttpService("a2a", workspacePath, args);
-            }
-            if (subcommand === "stop") {
-                return stopManagedHttpService("a2a", workspacePath);
-            }
-            if (!parsedServe) {
-                stderr(renderUsage());
-                return 1;
-            }
-            const runtime = await createHarness(workspacePath);
-            const server = await serveA2a(runtime, {
-                hostname: parsedServe.hostname,
-                port: parsedServe.port,
-            });
-            stderr(`Serving A2A over http from ${workspacePath} at ${server.rpcUrl} (card ${server.agentCardUrl})\n`);
-            await server.completed;
-            await runtime.stop();
-            return 0;
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            stderr(`${message}\n`);
-            return 1;
-        }
-    }
-    if (command === "mcp" || command === "runtime-mcp") {
-        const [subcommand, ...subcommandArgs] = [projectName, ...rest];
-        if (subcommand !== "serve" && subcommand !== "start" && subcommand !== "stop") {
-            stderr(renderUsage());
-            return 1;
-        }
-        const parsedStop = subcommand === "stop" ? parseWorkspaceOnlyOptions(subcommandArgs) : undefined;
-        const parsedServe = subcommand !== "stop"
-            ? parseRuntimeMcpServeOptions(subcommandArgs, subcommand === "start" ? "streamable-http" : "stdio")
-            : undefined;
-        const parseError = parsedStop?.error ?? parsedServe?.error;
-        if (parseError) {
-            stderr(`${parseError}\n`);
-            stderr(renderUsage());
-            return 1;
-        }
-        try {
-            const workspaceRoot = parsedStop?.workspaceRoot ?? parsedServe?.workspaceRoot;
-            const workspacePath = resolveCliWorkspaceRoot(cwd, workspaceRoot);
-            const workspaceError = validateCliWorkspaceRoot(workspacePath, workspaceRoot);
-            if (workspaceError) {
-                stderr(`${workspaceError}\n`);
-                return 1;
-            }
-            if (subcommand === "start") {
-                if (!parsedServe) {
-                    stderr(renderUsage());
-                    return 1;
-                }
-                if (parsedServe.transport !== "streamable-http") {
-                    stderr("MCP start only supports --transport streamable-http. Use `mcp serve --transport stdio` for stdio clients.\n");
-                    return 1;
-                }
-                const args = ["mcp", "serve", "--workspace", workspacePath, "--transport", "streamable-http"];
-                if (parsedServe.hostname) {
-                    args.push("--host", parsedServe.hostname);
-                }
-                if (typeof parsedServe.port === "number") {
-                    args.push("--port", String(parsedServe.port));
-                }
-                return startManagedHttpService("mcp", workspacePath, args);
-            }
-            if (subcommand === "stop") {
-                return stopManagedHttpService("mcp", workspacePath);
-            }
-            if (!parsedServe) {
-                stderr(renderUsage());
-                return 1;
-            }
-            const runtime = await createHarness(workspacePath);
-            if (parsedServe.transport === "streamable-http") {
-                const server = await serveRuntimeMcpStreamableHttp(runtime, {
-                    hostname: parsedServe.hostname,
-                    port: parsedServe.port,
-                });
-                stderr(`Serving runtime MCP over streamable HTTP from ${workspacePath} at ${server.url}\n`);
-                await server.completed;
-            }
-            else {
-                stderr(`Serving runtime MCP over stdio from ${workspacePath}\n`);
-                const server = await serveRuntimeMcp(runtime);
-                await new Promise((resolve, reject) => {
-                    process.stdin.on("end", resolve);
-                    process.stdin.on("error", reject);
-                });
-                await server.close();
-            }
-            await runtime.stop();
-            return 0;
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            stderr(`${message}\n`);
-            return 1;
-        }
-    }
-    if (command === "runtime") {
-        const [subcommand, possibleNestedCommand, possibleThirdCommand, ...remainingArgs] = [projectName, ...rest];
-        if (!subcommand) {
-            stderr(renderUsage());
-            return 1;
-        }
-        if (subcommand === "scheduled-run") {
-            const parsed = parseScheduledRunOptions([possibleNestedCommand, possibleThirdCommand, ...remainingArgs].filter((item) => typeof item === "string"));
-            if (parsed.error) {
-                stderr(`${parsed.error}\n`);
-                stderr(renderUsage());
-                return 1;
-            }
-            if (!parsed.scheduleId) {
-                stderr("Missing value for --schedule\n");
-                stderr(renderUsage());
-                return 1;
-            }
-            try {
-                const workspacePath = resolveCliWorkspaceRoot(cwd, parsed.workspaceRoot);
-                const workspaceError = validateCliWorkspaceRoot(workspacePath, parsed.workspaceRoot);
-                if (workspaceError) {
-                    stderr(`${workspaceError}\n`);
-                    return 1;
-                }
-                const runtime = await createHarness(workspacePath);
-                try {
-                    const result = await runtime.runScheduledTask(parsed.scheduleId);
-                    stdout(`${String(result.output ?? "").trim()}\n`);
-                }
-                finally {
-                    await runtime.stop();
-                }
-                return 0;
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                stderr(`${message}\n`);
-                return 1;
-            }
-        }
-        if (subcommand === "export") {
-            const exportTarget = possibleNestedCommand;
-            const parsed = parseRuntimeExportOptions([possibleThirdCommand, ...remainingArgs].filter((item) => typeof item === "string"));
-            if (parsed.error) {
-                stderr(`${parsed.error}\n`);
-                stderr(renderUsage());
-                return 1;
-            }
-            if (!parsed.sessionId) {
-                stderr("Missing value for --session\n");
-                stderr(renderUsage());
-                return 1;
-            }
-            if (exportTarget !== "request" && exportTarget !== "session") {
-                stderr(renderUsage());
-                return 1;
-            }
-            if (exportTarget === "request" && !parsed.requestId) {
-                stderr("Missing value for --request\n");
-                stderr(renderUsage());
-                return 1;
-            }
-            try {
-                const workspacePath = resolveCliWorkspaceRoot(cwd, parsed.workspaceRoot);
-                const workspaceError = validateCliWorkspaceRoot(workspacePath, parsed.workspaceRoot);
-                if (workspaceError) {
-                    stderr(`${workspaceError}\n`);
-                    return 1;
-                }
-                const runtime = await createHarness(workspacePath);
-                try {
-                    if (exportTarget === "request") {
-                        const pkg = await runtime.exportRequestPackage({
-                            sessionId: parsed.sessionId,
-                            requestId: parsed.requestId,
-                            includeArtifacts: parsed.includeArtifacts,
-                            includeArtifactContents: parsed.includeArtifactContents,
-                            includeRuntimeHealth: parsed.includeRuntimeHealth,
-                        });
-                        stdout(renderJson(pkg));
-                    }
-                    else {
-                        const pkg = await runtime.exportSessionPackage({
-                            sessionId: parsed.sessionId,
-                            includeArtifacts: parsed.includeArtifacts,
-                            includeArtifactContents: parsed.includeArtifactContents,
-                            includeRuntimeHealth: parsed.includeRuntimeHealth,
-                        });
-                        stdout(renderJson(pkg));
-                    }
-                }
-                finally {
-                    await runtime.stop();
-                }
-                return 0;
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                stderr(`${message}\n`);
-                return 1;
-            }
-        }
-        const nestedCommand = (subcommand === "approvals" || subcommand === "requests") && possibleNestedCommand
-            ? possibleNestedCommand
-            : undefined;
-        const subcommandArgs = nestedCommand
-            ? [possibleThirdCommand, ...remainingArgs].filter((item) => typeof item === "string")
-            : [possibleNestedCommand, possibleThirdCommand, ...remainingArgs].filter((item) => typeof item === "string");
-        const parsed = parseRuntimeInspectOptions(subcommandArgs);
-        if (parsed.error) {
-            stderr(`${parsed.error}\n`);
-            stderr(renderUsage());
-            return 1;
-        }
-        try {
-            const workspacePath = resolveCliWorkspaceRoot(cwd, parsed.workspaceRoot);
-            const workspaceError = validateCliWorkspaceRoot(workspacePath, parsed.workspaceRoot);
-            if (workspaceError) {
-                stderr(`${workspaceError}\n`);
-                return 1;
-            }
-            const runtime = await createHarness(workspacePath);
-            if (subcommand === "health") {
-                const snapshot = await runtime.getHealth();
-                stdout(parsed.json ? renderJson(snapshot) : renderHealthSnapshot(snapshot, workspacePath));
-                await runtime.stop();
-                return 0;
-            }
-            if (subcommand === "overview") {
-                const overview = await runtime.getOperatorOverview({ limit: parsed.limit });
-                stdout(parsed.json ? renderJson(overview) : renderOperatorOverview(overview, workspacePath));
-                await runtime.stop();
-                return 0;
-            }
-            if (subcommand === "approvals" && (nestedCommand === "list" || nestedCommand === "watch")) {
-                const renderApprovals = async () => {
-                    const approvals = await runtime.listApprovals(parsed.status ? { status: parsed.status } : undefined);
-                    stdout(parsed.json ? renderJson(approvals) : renderApprovalList(approvals));
-                };
-                await renderApprovals();
-                if (nestedCommand === "watch" && !parsed.once) {
-                    for (;;) {
-                        await sleep(parsed.pollMs);
-                        await renderApprovals();
-                    }
-                }
-                await runtime.stop();
-                return 0;
-            }
-            if (subcommand === "requests" && (nestedCommand === "list" || nestedCommand === "tail")) {
-                const renderRequests = async () => {
-                    const listRequests = runtime.listRequests?.bind(runtime);
-                    if (!listRequests) {
-                        throw new Error("Runtime does not support request listing");
-                    }
-                    const requests = await listRequests({
-                        ...(parsed.agentId ? { agentId: parsed.agentId } : {}),
-                        ...(parsed.sessionId ? { sessionId: parsed.sessionId } : {}),
-                        ...(parsed.state ? { state: parsed.state } : {}),
-                    });
-                    stdout(parsed.json ? renderJson(requests) : renderRequestList(requests));
-                };
-                await renderRequests();
-                if (nestedCommand === "tail" && !parsed.once) {
-                    for (;;) {
-                        await sleep(parsed.pollMs);
-                        await renderRequests();
-                    }
-                }
-                await runtime.stop();
-                return 0;
-            }
-            await runtime.stop();
-            stderr(renderUsage());
-            return 1;
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            stderr(`${message}\n`);
-            return 1;
-        }
-    }
-    stderr(renderUsage());
-    return 1;
-}
-export function resolveInvokedCliHref(argvPath) {
-    if (!argvPath) {
-        return "";
-    }
-    const resolved = path.resolve(argvPath);
-    const realPath = existsSync(resolved) ? realpathSync(resolved) : resolved;
-    return pathToFileURL(realPath).href;
-}
+export * from "./cli/main.js";
+import { runCli, resolveInvokedCliHref } from "./cli/main.js";
 const invokedPath = resolveInvokedCliHref(process.argv[1]);
 if (import.meta.url === invokedPath) {
     const exitCode = await runCli(process.argv.slice(2));