@botbotgo/agent-harness 0.0.294 → 0.0.296

package/dist/cli.js

@@ -1,7 +1,13 @@
 #!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { createInterface as createReadlineInterface } from "node:readline";
+import { Writable } from "node:stream";
 import path from "node:path";
-import { pathToFileURL } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import YAML from "yaml";
 import { createAgentHarness } from "./api.js";
+import { createAcpHttpHarnessClient, createAcpStdioHarnessClient } from "./client.js";
 import { initProject } from "./init-project.js";
 import { serveA2aOverHttp } from "./protocol/a2a/http.js";
 import { serveAgUiOverHttp } from "./protocol/ag-ui/http.js";
@@ -11,6 +17,7 @@ import { serveRuntimeMcpOverStdio } from "./mcp.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 [--workspace <path>] [--transport stdio|http] [--host <hostname>] [--port <port>] [--agent <agentId>] [--session <sessionId>] [--message <text>]
   agent-harness acp serve [--workspace <path>] [--transport stdio|http] [--host <hostname>] [--port <port>]
   agent-harness a2a serve [--workspace <path>] [--host <hostname>] [--port <port>]
   agent-harness ag-ui serve [--workspace <path>] [--host <hostname>] [--port <port>]
@@ -159,6 +166,56 @@ function parseHttpServeOptions(args, serviceLabel = "HTTP") {
     }
     return { workspaceRoot, hostname, port };
 }
+function parseChatOptions(args) {
+    let workspaceRoot;
+    let agentId;
+    let sessionId;
+    let message;
+    let transport = "stdio";
+    let hostname;
+    let port;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--workspace" || arg === "--agent" || arg === "--session" || arg === "--message" || arg === "--transport" || arg === "--host" || arg === "--port") {
+            const value = args[index + 1];
+            if (!value) {
+                return { workspaceRoot, agentId, sessionId, message, transport, hostname, port, error: `Missing value for ${arg}` };
+            }
+            if (arg === "--workspace") {
+                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, 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, transport, hostname, port, error: `Invalid chat port: ${value}` };
+                }
+                port = parsedPort;
+            }
+            index += 1;
+            continue;
+        }
+        return { workspaceRoot, agentId, sessionId, message, transport, hostname, port, error: `Unknown option: ${arg}` };
+    }
+    return { workspaceRoot, agentId, sessionId, message, transport, hostname, port };
+}
 function parseRuntimeInspectOptions(args) {
     let workspaceRoot;
     let json = false;
@@ -294,6 +351,25 @@ function parseRuntimeExportOptions(args) {
         json,
     };
 }
+function resolveCliWorkspaceRoot(cwd, inputPath) {
+    const resolved = path.resolve(cwd, inputPath ?? ".");
+    const configRuntimePath = path.join(resolved, "config", "runtime", "workspace.yaml");
+    if (existsSync(configRuntimePath)) {
+        return resolved;
+    }
+    const directRuntimePath = path.join(resolved, "runtime", "workspace.yaml");
+    if (existsSync(directRuntimePath) && path.basename(resolved) === "config") {
+        return path.dirname(resolved);
+    }
+    return resolved;
+}
+function resolveCliConfigRoot(workspaceRoot) {
+    const nested = path.join(workspaceRoot, "config");
+    if (existsSync(path.join(nested, "runtime", "workspace.yaml"))) {
+        return nested;
+    }
+    return workspaceRoot;
+}
 function renderJson(value) {
     return `${JSON.stringify(value, null, 2)}\n`;
 }
@@ -423,11 +499,584 @@ function renderOperatorOverview(overview, workspacePath) {
     }
     return `${lines.join("\n")}\n`;
 }
+function renderChatHelp() {
+    const rows = [
+        ["/context", "Show the current agent/session/request context"],
+        ["/new", "Clear the current session/request context"],
+        ["/help", "Show chat commands"],
+        ["/agent <agentId>", "Switch the active agent for new requests"],
+        ["/session", "Show current session id"],
+        ["/request [requestId]", "Show or switch the active request id"],
+        ["/sessions", "List recent sessions"],
+        ["/requests", "List requests for the current session or agent"],
+        ["/resume <sessionId>", "Switch chat to an existing session"],
+        ["/cancel", "Cancel the latest active request"],
+        ["/approvals", "List pending approvals for the current session"],
+        ["/approve <id>", "Approve a pending approval"],
+        ["/reject <id>", "Reject a pending approval"],
+        ["/events", "Show persisted events for the latest request"],
+        ["/trace", "Show persisted trace items for the latest request"],
+        ["/health", "Show runtime health"],
+        ["/overview", "Show runtime overview"],
+        ["/exit", "Exit chat"],
+    ];
+    const cmdW = Math.max(...rows.map(([cmd]) => cmd.length));
+    const lines = rows.map(([cmd, desc]) => `  ${cmd.padEnd(cmdW)}  ${desc}`);
+    return [
+        "Commands:",
+        "────────",
+        ...lines,
+        "",
+        "Starter tasks:",
+        "─────────────",
+        "  - Inspect this workspace and explain the main entry points.",
+        "  - Review this project structure before making any edits.",
+        "  - Update README.md to make the setup steps clearer.",
+        "  - Find the likeliest config issue in this workspace and propose the smallest fix.",
+        "",
+    ].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 = [27, 255, 196, 255, 196];
+const CHAT_LOGO_PRODUCT_LINE_COLORS = [226, 226, 196, 196, 196];
+/** 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)}…`;
+}
+function renderChatPromptLine(input) {
+    const agent = input.agentId ?? "—";
+    const separator = "  ────────────────────────────────────────";
+    if (!input.color) {
+        return `${separator}\n  botbotgo │ agent ${agent} › `;
+    }
+    return (`  \x1b[38;5;240m${"─".repeat(40)}\x1b[0m\n  ` +
+        `\x1b[1;36mbotbotgo\x1b[0m \x1b[38;5;240m│\x1b[0m ` +
+        `\x1b[90magent\x1b[0m \x1b[97m${agent}\x1b[0m \x1b[32m›\x1b[0m `);
+}
+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();
+    }
+}
+function renderChatBanner(input) {
+    const color = input.color === true;
+    const subtitle = "ACP workspace shell · @botbotgo/agent-harness";
+    const labelW = 12;
+    const rows = [
+        ["Workspace", input.workspacePath],
+        ["Transport", input.transport],
+    ];
+    if (input.agentId) {
+        rows.push(["Agent", input.agentId]);
+    }
+    if (input.sessionId) {
+        rows.push(["Session", input.sessionId]);
+    }
+    const bodyLines = rows.map(([label, value]) => `${label.padEnd(labelW)} ${value}`);
+    const inner = Math.max(subtitle.length, ...bodyLines.map((line) => line.length), 44);
+    const horizontal = (left, mid, right) => `  ${left}${mid.repeat(inner + 2)}${right}`;
+    const boxed = (text) => `  │ ${text.padEnd(inner)} │`;
+    const logoWidth = Math.max(...CHAT_ASCII_BOTBOTGO.split("\n").map((line) => line.length), ...CHAT_ASCII_AGENT_HARNESS.split("\n").map((line) => line.length), inner + 4);
+    const ruleLen = Math.min(logoWidth, 96);
+    const rulePlain = `  ${"·".repeat(ruleLen)}`;
+    const rule = color ? `\x1b[38;5;253m${rulePlain}\x1b[0m` : rulePlain;
+    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 blockSepWidth = Math.max(36, ruleLen - 4);
+    const blockSep = color ? `  \x1b[38;5;255m${"─".repeat(blockSepWidth)}\x1b[0m` : "";
+    const boxBorder = color ? "\x1b[38;5;27m" : "";
+    const boxBorderReset = color ? "\x1b[0m" : "";
+    const horizontalColored = (left, mid, right) => color
+        ? `  ${boxBorder}${left}${boxBorderReset}\x1b[38;5;253m${mid.repeat(inner + 2)}\x1b[0m${boxBorder}${right}${boxBorderReset}`
+        : horizontal(left, mid, right);
+    const boxedColored = (text) => color
+        ? `  ${boxBorder}│${boxBorderReset} \x1b[38;5;255m${text.padEnd(inner)}\x1b[0m ${boxBorder}│${boxBorderReset}`
+        : boxed(text);
+    const hint = color
+        ? `  \x1b[2m\x1b[38;5;253mType /help for commands and starter tasks\x1b[0m`
+        : `  Type /help for commands and starter tasks`;
+    const mid = [brandArt, ""];
+    if (color) {
+        mid.push(blockSep, "");
+    }
+    mid.push(productArt, "", rule, "", horizontalColored("╭", "─", "╮"), boxedColored(subtitle), horizontalColored("├", "─", "┤"), ...bodyLines.map((line) => boxedColored(line)), horizontalColored("╰", "─", "╯"), "", rule, hint, "");
+    return ["", ...mid].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) {
+    return [
+        `agent=${input.agentId ?? "none"}`,
+        `session=${input.sessionId ?? "none"}`,
+        `request=${input.requestId ?? "none"}`,
+    ].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) {
+    return YAML.parse(readFileSync(filePath, "utf8"));
+}
+function getWorkspaceDefaultAgentId(workspaceRoot) {
+    const runtimePath = path.join(resolveCliConfigRoot(workspaceRoot), "runtime", "workspace.yaml");
+    if (!existsSync(runtimePath)) {
+        return undefined;
+    }
+    const parsed = asRecord(readYamlFile(runtimePath));
+    const spec = asRecord(parsed?.spec);
+    const routing = asRecord(spec?.routing);
+    return typeof routing?.defaultAgentId === "string" && routing.defaultAgentId.trim().length > 0
+        ? routing.defaultAgentId.trim()
+        : undefined;
+}
+function getAgentModelRef(workspaceRoot, agentId) {
+    const agentPath = path.join(resolveCliConfigRoot(workspaceRoot), "agents", `${agentId}.yaml`);
+    if (!existsSync(agentPath)) {
+        return undefined;
+    }
+    const parsed = asRecord(readYamlFile(agentPath));
+    const spec = asRecord(parsed?.spec);
+    return typeof spec?.modelRef === "string" && spec.modelRef.trim().length > 0
+        ? spec.modelRef.trim()
+        : undefined;
+}
+function getModelInfo(workspaceRoot, modelRef) {
+    const modelsPath = path.join(resolveCliConfigRoot(workspaceRoot), "catalogs", "models.yaml");
+    if (!existsSync(modelsPath)) {
+        return undefined;
+    }
+    const parsed = asRecord(readYamlFile(modelsPath));
+    const spec = Array.isArray(parsed?.spec) ? parsed.spec.filter(asRecord) : [];
+    const modelName = modelRef.startsWith("model/") ? modelRef.slice("model/".length) : modelRef;
+    const model = spec.find((item) => item.name === 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 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) {
+    if (typeof output === "string") {
+        return truncateChatToolPreview(output);
+    }
+    if (typeof output === "number" || typeof output === "boolean") {
+        return String(output);
+    }
+    if (!output || typeof output !== "object") {
+        return JSON.stringify(output);
+    }
+    const typed = output;
+    const content = extractChatToolTextContent(output);
+    if (content && content.trim().length > 0) {
+        return truncateChatToolPreview(content.trim());
+    }
+    const summary = typeof typed.summary === "object" && typed.summary !== null ? typed.summary : undefined;
+    if (summary) {
+        return truncateChatToolPreview(JSON.stringify(summary, null, 2));
+    }
+    return truncateChatToolPreview(JSON.stringify(output, null, 2));
+}
+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!");
+}
+async function createSubprocessChatClient(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 cliFilePath = fileURLToPath(import.meta.url);
+    const child = spawn(process.execPath, [
+        cliFilePath,
+        "acp",
+        "serve",
+        "--workspace",
+        input.workspaceRoot,
+        "--transport",
+        "stdio",
+    ], {
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    if (!child.stdin || !child.stdout || !child.stderr) {
+        throw new Error("Failed to open ACP stdio pipes for chat client.");
+    }
+    let stderrBuffer = "";
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+        stderrBuffer += chunk;
+        const lines = stderrBuffer.split(/\r?\n/);
+        stderrBuffer = lines.pop() ?? "";
+        for (const line of lines) {
+            if (!isChatServerNoiseLine(line)) {
+                input.stderr?.(`[runtime] ${line}\n`);
+            }
+        }
+    });
+    const baseClient = createAcpStdioHarnessClient({
+        input: child.stdin,
+        output: child.stdout,
+        idPrefix: "chat",
+    });
+    return wrapChatClientForLifecycle(baseClient, async () => {
+        if (!child.killed) {
+            child.kill();
+        }
+    });
+}
+export function wrapChatClientForLifecycle(client, onStop) {
+    return {
+        request: client.request.bind(client),
+        streamRequest: client.streamRequest.bind(client),
+        resolveApproval: client.resolveApproval.bind(client),
+        cancelRequest: client.cancelRequest.bind(client),
+        subscribe: client.subscribe.bind(client),
+        listSessions: client.listSessions.bind(client),
+        listSessionSummaries: client.listSessionSummaries.bind(client),
+        listRequests: client.listRequests.bind(client),
+        getSession: client.getSession.bind(client),
+        getRequest: client.getRequest.bind(client),
+        listApprovals: client.listApprovals.bind(client),
+        getApproval: client.getApproval.bind(client),
+        listRequestEvents: client.listRequestEvents.bind(client),
+        listRequestTraceItems: client.listRequestTraceItems.bind(client),
+        getHealth: client.getHealth.bind(client),
+        getOperatorOverview: client.getOperatorOverview.bind(client),
+        async stop() {
+            try {
+                await client.stop();
+            }
+            finally {
+                await onStop();
+            }
+        },
+    };
+}
+async function streamChatMessage(input) {
+    let latestSessionId = input.sessionId;
+    let latestRequestId;
+    let latestAgentId = input.agentId;
+    let wroteContent = false;
+    let wroteRenderableBlocks = false;
+    for await (const item of input.client.streamRequest({
+        ...(input.agentId ? { agentId: input.agentId } : {}),
+        ...(input.sessionId ? { sessionId: input.sessionId } : {}),
+        input: input.message,
+    })) {
+        if (item.type === "content") {
+            input.stdout(renderChatTextChunk(item.content, input.modelInfo));
+            latestSessionId = item.sessionId;
+            latestRequestId = item.requestId;
+            latestAgentId = item.agentId;
+            wroteContent = true;
+            continue;
+        }
+        if (item.type === "content-blocks") {
+            latestSessionId = item.sessionId;
+            latestRequestId = item.requestId;
+            latestAgentId = item.agentId;
+            if (!wroteContent) {
+                const rendered = item.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) {
+                    input.stdout(renderChatTextChunk(rendered, input.modelInfo));
+                    wroteRenderableBlocks = true;
+                }
+            }
+            continue;
+        }
+        if (item.type === "tool-result") {
+            latestSessionId = item.sessionId;
+            latestRequestId = item.requestId;
+            latestAgentId = item.agentId;
+            input.stderr(`\n[tool:${item.toolName}] ${summarizeChatToolResult(item.output)}${item.isError ? " (error)" : ""}\n`);
+            continue;
+        }
+        if (item.type === "result") {
+            latestSessionId = item.result.sessionId;
+            latestRequestId = item.result.requestId;
+            if (!wroteContent && !wroteRenderableBlocks && item.result.output.trim().length > 0) {
+                input.stdout(renderChatRuntimeFailure(item.result.output, input.modelInfo));
+            }
+            if (item.result.state === "waiting_for_approval") {
+                input.stderr(`\nRequest is waiting for approval${item.result.approvalId ? ` (${item.result.approvalId})` : ""}.\n`);
+            }
+            else if (wroteContent || wroteRenderableBlocks || item.result.output.trim().length > 0) {
+                input.stdout("\n");
+            }
+        }
+    }
+    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 [command, projectName, ...rest] = argv;
+    const createChatClient = deps.createChatClient ?? createSubprocessChatClient;
+    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;
@@ -464,6 +1113,268 @@ export async function runCli(argv, io = {}, deps = {}) {
             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;
+        }
+        const workspacePath = resolveCliWorkspaceRoot(cwd, parsed.workspaceRoot);
+        const workspaceModelInfo = readChatWorkspaceModelInfo(workspacePath, parsed.agentId);
+        let client;
+        try {
+            client = await createChatClient({
+                workspaceRoot: workspacePath,
+                transport: parsed.transport,
+                hostname: parsed.hostname,
+                port: parsed.port,
+                stderr,
+            });
+            let activeAgentId = parsed.agentId;
+            let activeSessionId = parsed.sessionId;
+            let latestRequestId;
+            const preflightWarning = await probeWorkspace({
+                workspaceRoot: workspacePath,
+                agentId: activeAgentId,
+            });
+            if (parsed.message) {
+                const streamed = await streamChatMessage({
+                    client,
+                    stdout,
+                    stderr,
+                    agentId: activeAgentId,
+                    sessionId: activeSessionId,
+                    message: parsed.message,
+                    modelInfo: workspaceModelInfo,
+                });
+                activeSessionId = streamed.sessionId;
+                latestRequestId = streamed.requestId;
+                activeAgentId = streamed.agentId ?? activeAgentId;
+                if (activeSessionId) {
+                    stderr(`session=${activeSessionId}${latestRequestId ? ` request=${latestRequestId}` : ""}\n`);
+                }
+                await client.stop();
+                return 0;
+            }
+            const stdinStream = stdin;
+            const useColor = stdinStream.isTTY === true && io.stdout === undefined;
+            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: stdinStream.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,
+                            stderr,
+                            agentId: activeAgentId,
+                            sessionId: activeSessionId,
+                            message: trimmed,
+                            modelInfo: workspaceModelInfo,
+                        });
+                        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();
+            return 0;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            stderr(`${message}\n`);
+            if (client) {
+                await client.stop().catch(() => undefined);
+            }
+            return 1;
+        }
+    }
     if (command === "acp") {
         const [subcommand, ...subcommandArgs] = [projectName, ...rest];
         if (subcommand !== "serve") {
@@ -477,8 +1388,8 @@ export async function runCli(argv, io = {}, deps = {}) {
             return 1;
         }
         try {
-            const runtime = await createHarness(path.resolve(cwd, parsed.workspaceRoot ?? "."));
-            const workspacePath = path.resolve(cwd, parsed.workspaceRoot ?? ".");
+            const workspacePath = resolveCliWorkspaceRoot(cwd, parsed.workspaceRoot);
+            const runtime = await createHarness(workspacePath);
             if (parsed.transport === "http") {
                 const server = await serveAcpHttp(runtime, {
                     hostname: parsed.hostname,
@@ -514,8 +1425,8 @@ export async function runCli(argv, io = {}, deps = {}) {
             return 1;
         }
         try {
-            const runtime = await createHarness(path.resolve(cwd, parsed.workspaceRoot ?? "."));
-            const workspacePath = path.resolve(cwd, parsed.workspaceRoot ?? ".");
+            const workspacePath = resolveCliWorkspaceRoot(cwd, parsed.workspaceRoot);
+            const runtime = await createHarness(workspacePath);
             const server = await serveAgUi(runtime, {
                 hostname: parsed.hostname,
                 port: parsed.port,
@@ -544,8 +1455,8 @@ export async function runCli(argv, io = {}, deps = {}) {
             return 1;
         }
         try {
-            const runtime = await createHarness(path.resolve(cwd, parsed.workspaceRoot ?? "."));
-            const workspacePath = path.resolve(cwd, parsed.workspaceRoot ?? ".");
+            const workspacePath = resolveCliWorkspaceRoot(cwd, parsed.workspaceRoot);
+            const runtime = await createHarness(workspacePath);
             const server = await serveA2a(runtime, {
                 hostname: parsed.hostname,
                 port: parsed.port,
@@ -574,8 +1485,8 @@ export async function runCli(argv, io = {}, deps = {}) {
             return 1;
         }
         try {
-            const runtime = await createHarness(path.resolve(cwd, parsed.workspaceRoot ?? "."));
-            const workspacePath = path.resolve(cwd, parsed.workspaceRoot ?? ".");
+            const workspacePath = resolveCliWorkspaceRoot(cwd, parsed.workspaceRoot);
+            const runtime = await createHarness(workspacePath);
             stderr(`Serving runtime MCP over stdio from ${workspacePath}\n`);
             const server = await serveRuntimeMcp(runtime);
             await new Promise((resolve, reject) => {
@@ -621,7 +1532,7 @@ export async function runCli(argv, io = {}, deps = {}) {
                 return 1;
             }
             try {
-                const runtime = await createHarness(path.resolve(cwd, parsed.workspaceRoot ?? "."));
+                const runtime = await createHarness(resolveCliWorkspaceRoot(cwd, parsed.workspaceRoot));
                 try {
                     if (exportTarget === "request") {
                         const pkg = await runtime.exportRequestPackage({
@@ -667,8 +1578,8 @@ export async function runCli(argv, io = {}, deps = {}) {
             return 1;
         }
         try {
-            const runtime = await createHarness(path.resolve(cwd, parsed.workspaceRoot ?? "."));
-            const workspacePath = path.resolve(cwd, parsed.workspaceRoot ?? ".");
+            const workspacePath = resolveCliWorkspaceRoot(cwd, parsed.workspaceRoot);
+            const runtime = await createHarness(workspacePath);
             if (subcommand === "health") {
                 const snapshot = await runtime.getHealth();
                 stdout(parsed.json ? renderJson(snapshot) : renderHealthSnapshot(snapshot, workspacePath));