@botbotgo/agent-harness 0.0.298 → 0.0.300

package/dist/cli.js

@@ -1,23 +1,27 @@
 #!/usr/bin/env node
-import { spawn } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
+import { EventEmitter } from "node:events";
+import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
 import { createInterface as createReadlineInterface } from "node:readline";
 import { Writable } from "node:stream";
 import path from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import { fileURLToPath } from "node:url";
+import { pathToFileURL } from "node:url";
 import YAML from "yaml";
 import { createAgentHarness } from "./api.js";
-import { createAcpHttpHarnessClient, createAcpStdioHarnessClient } from "./client.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 } 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 [--workspace <path>] [--transport stdio|http] [--host <hostname>] [--port <port>] [--agent <agentId>] [--session <sessionId>] [--message <text>]
+  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 a2a serve [--workspace <path>] [--host <hostname>] [--port <port>]
   agent-harness ag-ui serve [--workspace <path>] [--host <hostname>] [--port <port>]
@@ -27,9 +31,14 @@ function renderUsage() {
   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>]
+
+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) {
@@ -171,17 +180,26 @@ function parseChatOptions(args) {
     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 === "--agent" || arg === "--session" || arg === "--message" || arg === "--transport" || arg === "--host" || arg === "--port") {
+        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, transport, hostname, port, error: `Missing value for ${arg}` };
+                return { workspaceRoot, agentId, sessionId, message, requestEvents, transport, hostname, port, error: `Missing value for ${arg}` };
             }
-            if (arg === "--workspace") {
+            if (arg === "--workspace" || arg === "-w") {
                 workspaceRoot = value;
             }
             else if (arg === "--agent") {
@@ -195,7 +213,7 @@ function parseChatOptions(args) {
             }
             else if (arg === "--transport") {
                 if (value !== "stdio" && value !== "http") {
-                    return { workspaceRoot, agentId, sessionId, message, transport, hostname, port, error: `Unsupported chat transport: ${value}` };
+                    return { workspaceRoot, agentId, sessionId, message, requestEvents, transport, hostname, port, error: `Unsupported chat transport: ${value}` };
                 }
                 transport = value;
             }
@@ -205,16 +223,35 @@ function parseChatOptions(args) {
             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}` };
+                    return { workspaceRoot, agentId, sessionId, message, requestEvents, 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}` };
+        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);
     }
-    return { workspaceRoot, agentId, sessionId, message, transport, hostname, port };
+    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 === "runtime"
+        || value === "runtime-mcp";
 }
 function parseRuntimeInspectOptions(args) {
     let workspaceRoot;
@@ -351,28 +388,390 @@ function parseRuntimeExportOptions(args) {
         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 ?? ".");
-    const configRuntimePath = path.join(resolved, "config", "runtime", "workspace.yaml");
-    if (existsSync(configRuntimePath)) {
+    if (existsSync(path.join(resolved, "config", "runtime", "workspace.yaml"))) {
         return resolved;
     }
-    const directRuntimePath = path.join(resolved, "runtime", "workspace.yaml");
-    if (existsSync(directRuntimePath) && path.basename(resolved) === "config") {
+    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) {
-    const nested = path.join(workspaceRoot, "config");
-    if (existsSync(path.join(nested, "runtime", "workspace.yaml"))) {
-        return nested;
+    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;
     }
-    return workspaceRoot;
 }
 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);
 }
@@ -445,6 +844,39 @@ function renderApprovalList(approvals) {
         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";
@@ -500,41 +932,64 @@ 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 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 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");
+    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
@@ -558,8 +1013,31 @@ const CHAT_ASCII_AGENT_HARNESS = trimAsciiBlock("     _    ____ _____ _   _ ____
  * 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];
+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);
@@ -583,15 +1061,23 @@ function ellipsizeChatId(value, maxChars) {
     }
     return `${value.slice(0, maxChars - 1)}…`;
 }
-function renderChatPromptLine(input) {
+export function renderChatPromptLine(input) {
+    const c = input.color;
     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 `);
+    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());
@@ -607,49 +1093,72 @@ async function* iterateChatLines(rl, nextPrompt) {
         rl.prompt();
     }
 }
-function renderChatBanner(input) {
+export 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;
+    // — 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 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 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
-        ? `  \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");
+        ? `  ${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) {
@@ -688,11 +1197,14 @@ function renderRequestTraceItems(items) {
     }).join("\n") + "\n";
 }
 function renderChatContext(input) {
-    return [
-        `agent=${input.agentId ?? "none"}`,
-        `session=${input.sessionId ?? "none"}`,
-        `request=${input.requestId ?? "none"}`,
-    ].join(" ") + "\n";
+    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();
@@ -709,40 +1221,100 @@ function asRecord(value) {
     return typeof value === "object" && value !== null ? value : undefined;
 }
 function readYamlFile(filePath) {
-    return YAML.parse(readFileSync(filePath, "utf8"));
+    const parsed = YAML.parse(readFileSync(filePath, "utf8"));
+    return interpolateEnvPlaceholders(parsed, filePath);
 }
-function getWorkspaceDefaultAgentId(workspaceRoot) {
-    const runtimePath = path.join(resolveCliConfigRoot(workspaceRoot), "runtime", "workspace.yaml");
-    if (!existsSync(runtimePath)) {
-        return undefined;
+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);
+            }
+        }
     }
-    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;
+    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 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;
+    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 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);
+    const model = readCliConfigObjects(workspaceRoot).find((item) => item.kind === "Model" && item.id === modelName);
     if (!model) {
         return undefined;
     }
@@ -818,6 +1390,37 @@ export function renderChatRuntimeFailure(output, modelInfo) {
 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;
@@ -876,26 +1479,11 @@ function extractChatToolTextContent(value) {
     }
     return "";
 }
-function summarizeChatToolResult(output) {
-    if (typeof output === "string") {
-        return truncateChatToolPreview(output);
+function summarizeChatToolResult(output, isError) {
+    if (!isError) {
+        return "completed";
     }
-    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));
+    return summarizeChatToolError(output);
 }
 export async function probeChatWorkspace(input) {
     const modelInfo = readChatWorkspaceModelInfo(input.workspaceRoot, input.agentId);
@@ -929,143 +1517,512 @@ export function isChatServerNoiseLine(line) {
         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.");
+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));
     }
-    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`);
+    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);
     });
-    const baseClient = createAcpStdioHarnessClient({
-        input: child.stdin,
-        output: child.stdout,
-        idPrefix: "chat",
-    });
-    return wrapChatClientForLifecycle(baseClient, async () => {
-        if (!child.killed) {
-            child.kill();
+    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;
+    };
 }
-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();
-            }
-        },
+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;
-    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;
+    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 (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;
+        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;
             }
-            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;
+    };
+    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();
         }
-        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));
+        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 (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");
+            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 = {}) {
@@ -1073,8 +2030,9 @@ export async function runCli(argv, io = {}, deps = {}) {
     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 createChatClient = deps.createChatClient ?? createSubprocessChatClient;
     const probeWorkspace = deps.probeChatWorkspace ?? probeChatWorkspace;
     const createChatLineReader = deps.createReadlineInterface ?? createReadlineInterface;
     const createHarness = deps.createAgentHarness ?? createAgentHarness;
@@ -1083,47 +2041,34 @@ export async function runCli(argv, io = {}, deps = {}) {
     const serveAcpHttp = deps.serveAcpOverHttp ?? serveAcpOverHttp;
     const serveAcp = deps.serveAcpOverStdio ?? serveAcpOverStdio;
     const serveRuntimeMcp = deps.serveRuntimeMcpOverStdio ?? serveRuntimeMcpOverStdio;
-    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;
+    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`,
+            });
         }
-    }
-    if (command === "chat") {
-        const parsed = parseChatOptions([projectName, ...rest].filter((item) => typeof item === "string"));
-        if (parsed.error) {
-            stderr(`${parsed.error}\n`);
-            stderr(renderUsage());
+        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 workspacePath = resolveCliWorkspaceRoot(cwd, parsed.workspaceRoot);
         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,
@@ -1131,34 +2076,41 @@ export async function runCli(argv, io = {}, deps = {}) {
                 port: parsed.port,
                 stderr,
             });
+            restoreWriteListenerGuard = installCliWriteListenerGuard([stdoutStream, stderrStream]);
             let activeAgentId = parsed.agentId;
             let activeSessionId = parsed.sessionId;
             let latestRequestId;
-            const preflightWarning = await probeWorkspace({
-                workspaceRoot: workspacePath,
-                agentId: activeAgentId,
-            });
+            const useColor = false;
+            const preflightWarning = parsed.message
+                ? undefined
+                : await probeWorkspace({
+                    workspaceRoot: workspacePath,
+                    agentId: activeAgentId,
+                });
             if (parsed.message) {
-                const streamed = await streamChatMessage({
+                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,
                 });
-                activeSessionId = streamed.sessionId;
-                latestRequestId = streamed.requestId;
-                activeAgentId = streamed.agentId ?? activeAgentId;
-                if (activeSessionId) {
-                    stderr(`session=${activeSessionId}${latestRequestId ? ` request=${latestRequestId}` : ""}\n`);
-                }
                 await client.stop();
+                restoreWriteListenerGuard?.();
+                restoreEmitterListenerGuard?.();
+                restoreStderrNoiseFilter?.();
+                restoreWarningFilter?.();
                 return 0;
             }
-            const stdinStream = stdin;
-            const useColor = stdinStream.isTTY === true && io.stdout === undefined;
             stdout(renderChatBanner({
                 workspacePath,
                 transport: parsed.transport,
@@ -1180,7 +2132,7 @@ export async function runCli(argv, io = {}, deps = {}) {
                 input: stdin,
                 output: stdoutSink,
                 crlfDelay: Infinity,
-                terminal: stdinStream.isTTY === true,
+                terminal: chatStdinStream.isTTY === true,
             });
             try {
                 for await (const raw of iterateChatLines(lineReader, () => renderChatPromptLine({
@@ -1198,11 +2150,18 @@ export async function runCli(argv, io = {}, deps = {}) {
                         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;
@@ -1364,9 +2323,17 @@ export async function runCli(argv, io = {}, deps = {}) {
                 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) {
@@ -1374,6 +2341,54 @@ export async function runCli(argv, io = {}, deps = {}) {
             }
             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];
@@ -1389,6 +2404,11 @@ export async function runCli(argv, io = {}, deps = {}) {
         }
         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 (parsed.transport === "http") {
                 const server = await serveAcpHttp(runtime, {
@@ -1426,6 +2446,11 @@ export async function runCli(argv, io = {}, deps = {}) {
         }
         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,
@@ -1456,6 +2481,11 @@ export async function runCli(argv, io = {}, deps = {}) {
         }
         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 serveA2a(runtime, {
                 hostname: parsed.hostname,
@@ -1486,6 +2516,11 @@ export async function runCli(argv, io = {}, deps = {}) {
         }
         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);
             stderr(`Serving runtime MCP over stdio from ${workspacePath}\n`);
             const server = await serveRuntimeMcp(runtime);
@@ -1509,6 +2544,41 @@ export async function runCli(argv, io = {}, deps = {}) {
             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"));
@@ -1532,7 +2602,13 @@ export async function runCli(argv, io = {}, deps = {}) {
                 return 1;
             }
             try {
-                const runtime = await createHarness(resolveCliWorkspaceRoot(cwd, parsed.workspaceRoot));
+                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({
@@ -1579,6 +2655,11 @@ export async function runCli(argv, io = {}, deps = {}) {
         }
         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();
@@ -1643,7 +2724,15 @@ export async function runCli(argv, io = {}, deps = {}) {
     stderr(renderUsage());
     return 1;
 }
-const invokedPath = process.argv[1] ? pathToFileURL(path.resolve(process.argv[1])).href : "";
+export function resolveInvokedCliHref(argvPath) {
+    if (!argvPath) {
+        return "";
+    }
+    const resolved = path.resolve(argvPath);
+    const realPath = existsSync(resolved) ? realpathSync(resolved) : resolved;
+    return pathToFileURL(realPath).href;
+}
+const invokedPath = resolveInvokedCliHref(process.argv[1]);
 if (import.meta.url === invokedPath) {
     const exitCode = await runCli(process.argv.slice(2));
     process.exitCode = exitCode;