@botbotgo/agent-harness 0.0.308 → 0.0.310

package/dist/cli/chat-stream.js

@@ -0,0 +1,330 @@
+import { countRenderedLines, renderChatRequestRunning, renderChatTextChunk, summarizeChatToolResult } from "./chat-rendering.js";
+import { buildTerminalRequestSnapshot, buildTodoContinuationSignature, flattenRequestExecutionSteps, renderRequestEventContinuation, renderRequestSnapshotTree, renderRequestTodoContinuation, } from "./request-tree.js";
+export async function streamChatMessage(input) {
+    const requestStartedAt = Date.now();
+    let firstSnapshotAt;
+    let firstDataAt;
+    let latestSnapshot;
+    let latestSessionId = input.sessionId;
+    let latestRequestId;
+    let latestAgentId = input.agentId;
+    let wroteContent = false;
+    let wroteRenderableBlocks = false;
+    let lastRenderedRequestTreeKey;
+    let lastRenderedRequestTree = "";
+    let lastRenderedRequestTreeLineCount = 0;
+    let lastRenderedRequestTreeAt = 0;
+    let announcedRunningState = false;
+    let requestTreeVisible = false;
+    let requestTreePersisted = false;
+    let liveRequestAnnotations = [];
+    let persistedRequestTreeEventCount = 0;
+    let persistedRequestTreeTodoSignature = "";
+    const requestTreeRenderThrottleMs = 75;
+    let suppressRequestTreeRendering = false;
+    let lastStableRequestTreeKey;
+    let stdoutWriteChain = Promise.resolve();
+    let stderrWriteChain = Promise.resolve();
+    const enqueueChatWrite = (sink, _stream, chain, message) => chain.then(async () => {
+        sink(message);
+    });
+    const summarizeRequestTreeSteps = (steps) => steps
+        .map((step) => [
+        step.id ?? "",
+        step.kind,
+        step.name,
+        step.status,
+        step.startedAt ?? "",
+        step.endedAt ?? "",
+    ].join("|"))
+        .join(";");
+    const buildRequestSnapshotRenderKey = (snapshot) => {
+        const todoSignatures = snapshot.plan.items
+            .map((item) => [
+            item.id ?? "",
+            item.content,
+            item.status,
+            item.ownerAgentId ?? "",
+            item.startedAt ?? "",
+            item.endedAt ?? "",
+            item.result === undefined ? "" : String(item.result),
+            summarizeRequestTreeSteps(item.events),
+        ].join("|"))
+            .join(";");
+        const approvalSignature = snapshot.approval
+            ? [
+                snapshot.approval.approvalId,
+                snapshot.approval.status,
+                snapshot.approval.toolName ?? "",
+            ].join("|")
+            : "";
+        return [
+            snapshot.sessionId,
+            snapshot.requestId,
+            snapshot.state,
+            snapshot.agentId ?? "",
+            snapshot.plan.version,
+            snapshot.plan.updatedAt,
+            snapshot.plan.summary.total,
+            snapshot.plan.summary.inProgress,
+            snapshot.plan.summary.completed,
+            snapshot.plan.summary.failed,
+            approvalSignature,
+            summarizeRequestTreeSteps(snapshot.events),
+            todoSignatures,
+        ].join("||");
+    };
+    const formatPerfClock = (timestamp) => {
+        const value = new Date(timestamp);
+        return value.toLocaleTimeString("en-US", {
+            hour12: false,
+            hour: "2-digit",
+            minute: "2-digit",
+            second: "2-digit",
+            fractionalSecondDigits: 3,
+        });
+    };
+    const formatElapsed = (timestamp) => `${((timestamp - requestStartedAt) / 1000).toFixed(3)}s`;
+    const buildTimingSummary = (completedAt) => {
+        const parts = [`start ${formatPerfClock(requestStartedAt)}`];
+        if (firstSnapshotAt) {
+            parts.push(`first event +${formatElapsed(firstSnapshotAt)}`);
+        }
+        if (firstDataAt) {
+            parts.push(`first data +${formatElapsed(firstDataAt)}`);
+        }
+        if (completedAt) {
+            parts.push(`done +${formatElapsed(completedAt)}`);
+        }
+        else {
+            parts.push(`live +${formatElapsed(Date.now())}`);
+        }
+        return parts.join(" · ");
+    };
+    const buildLiveRequestTreeBlock = () => {
+        if (!lastRenderedRequestTree) {
+            return "";
+        }
+        const annotationBlock = liveRequestAnnotations.length > 0
+            ? `\n${liveRequestAnnotations.join("")}`
+            : "";
+        return `${lastRenderedRequestTree}${annotationBlock}`;
+    };
+    const clearLiveRequestTree = () => {
+        if (!input.requestEvents || !input.liveRequestTree || !requestTreeVisible || lastRenderedRequestTreeLineCount <= 0) {
+            return;
+        }
+        stderrWriteChain = enqueueChatWrite(input.stderr, input.stderrStream, stderrWriteChain, `\x1b[${lastRenderedRequestTreeLineCount}F\x1b[0J`);
+        requestTreeVisible = false;
+    };
+    const drawLiveRequestTree = () => {
+        if (!input.requestEvents || !input.liveRequestTree || !lastRenderedRequestTree) {
+            return;
+        }
+        const block = buildLiveRequestTreeBlock();
+        stderrWriteChain = enqueueChatWrite(input.stderr, input.stderrStream, stderrWriteChain, block);
+        lastRenderedRequestTreeLineCount = countRenderedLines(block);
+        requestTreeVisible = true;
+    };
+    const persistLiveRequestTree = () => {
+        if (!input.requestEvents || !input.liveRequestTree || requestTreePersisted || !lastRenderedRequestTree) {
+            return;
+        }
+        if (requestTreeVisible && lastRenderedRequestTreeLineCount > 0) {
+            stderrWriteChain = enqueueChatWrite(input.stderr, input.stderrStream, stderrWriteChain, `\x1b[${lastRenderedRequestTreeLineCount}F\x1b[0J`);
+            requestTreeVisible = false;
+        }
+        const combinedBlock = buildLiveRequestTreeBlock();
+        const treeBlock = combinedBlock.endsWith("\n")
+            ? combinedBlock
+            : `${combinedBlock}\n`;
+        stderrWriteChain = enqueueChatWrite(input.stderr, input.stderrStream, stderrWriteChain, treeBlock);
+        persistedRequestTreeEventCount = latestSnapshot ? flattenRequestExecutionSteps(latestSnapshot).length : 0;
+        persistedRequestTreeTodoSignature = latestSnapshot ? buildTodoContinuationSignature(latestSnapshot) : "";
+        requestTreePersisted = true;
+    };
+    const enqueueOrderedStdout = (message) => {
+        const barrier = Promise.allSettled([stdoutWriteChain, stderrWriteChain]).then(() => undefined);
+        stdoutWriteChain = enqueueChatWrite(input.stdout, input.stdoutStream, barrier, message);
+    };
+    const writeChatStdout = (message) => {
+        if (input.requestEvents && input.liveRequestTree && !suppressRequestTreeRendering) {
+            clearLiveRequestTree();
+            enqueueOrderedStdout(message);
+            drawLiveRequestTree();
+            return;
+        }
+        if (input.requestEvents && input.liveRequestTree) {
+            enqueueOrderedStdout(message);
+            return;
+        }
+        stdoutWriteChain = enqueueChatWrite(input.stdout, input.stdoutStream, stdoutWriteChain, message);
+    };
+    const writeChatStderr = (message) => {
+        if (input.requestEvents && input.liveRequestTree && !suppressRequestTreeRendering) {
+            clearLiveRequestTree();
+            stderrWriteChain = enqueueChatWrite(input.stderr, input.stderrStream, stderrWriteChain, message);
+            drawLiveRequestTree();
+            return;
+        }
+        stderrWriteChain = enqueueChatWrite(input.stderr, input.stderrStream, stderrWriteChain, message);
+    };
+    const suspendRequestTreeRendering = () => {
+        if (!input.requestEvents || !input.liveRequestTree) {
+            return;
+        }
+        persistLiveRequestTree();
+        suppressRequestTreeRendering = true;
+        clearLiveRequestTree();
+    };
+    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;
+            }
+        }
+    };
+    const 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;
+            }
+        },
+        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(progressLine);
+            }
+        },
+    });
+    if (!result) {
+        throw new Error("chat request completed without a terminal result");
+    }
+    latestSessionId = result.sessionId;
+    latestRequestId = result.requestId;
+    latestAgentId = result.agentId ?? latestAgentId;
+    const completedAt = Date.now();
+    if (input.requestEvents && latestSnapshot) {
+        const terminalSnapshot = buildTerminalRequestSnapshot(latestSnapshot, { state: result.state, output: result.output });
+        lastRenderedRequestTree = renderRequestSnapshotTree(terminalSnapshot, input.colorRequestTree === true, buildTimingSummary(completedAt));
+        if (input.liveRequestTree && !requestTreePersisted) {
+            clearLiveRequestTree();
+            drawLiveRequestTree();
+        }
+        else if (input.liveRequestTree && requestTreePersisted) {
+            const todoContinuation = renderRequestTodoContinuation(terminalSnapshot, persistedRequestTreeTodoSignature, input.colorRequestTree === true);
+            const continuation = renderRequestEventContinuation(terminalSnapshot, persistedRequestTreeEventCount, input.colorRequestTree === true);
+            if (todoContinuation) {
+                stderrWriteChain = enqueueChatWrite(input.stderr, input.stderrStream, stderrWriteChain, `\n${todoContinuation}`);
+            }
+            if (continuation) {
+                stderrWriteChain = enqueueChatWrite(input.stderr, input.stderrStream, stderrWriteChain, `\n${continuation}`);
+            }
+        }
+        else if (!input.liveRequestTree) {
+            input.stderr(`\n${lastRenderedRequestTree}`);
+        }
+    }
+    if (!wroteContent && !wroteRenderableBlocks && result.output.trim().length > 0) {
+        writeChatStdout(renderChatTextChunk(result.output, input.modelInfo));
+    }
+    if (result.state === "waiting_for_approval") {
+        writeChatStderr(`\nRequest is waiting for approval${result.approvalId ? ` (${result.approvalId})` : ""}.\n`);
+    }
+    else if (wroteContent || wroteRenderableBlocks || result.output.trim().length > 0) {
+        writeChatStdout("\n");
+    }
+    await Promise.allSettled([stdoutWriteChain, stderrWriteChain]);
+    return { sessionId: latestSessionId, requestId: latestRequestId, agentId: latestAgentId };
+}

package/dist/cli/chat-ui.d.ts

@@ -0,0 +1,20 @@
+export declare function renderChatPromptLine(input: {
+    agentId?: string;
+    sessionId?: string;
+    requestId?: string;
+    color: boolean;
+}): string;
+export declare function renderChatBanner(input: {
+    workspacePath: string;
+    transport: "stdio" | "http";
+    agentId?: string;
+    sessionId?: string;
+    color: boolean;
+}): string;
+export declare function renderRequestEvents(events: Array<Record<string, unknown>>): string;
+export declare function renderChatContext(input: {
+    agentId?: string;
+    sessionId?: string;
+    requestId?: string;
+}): string;
+export declare function renderChatHelp(): string;

package/dist/cli/chat-ui.js

@@ -0,0 +1,198 @@
+function formatTimestamp(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function trimAsciiBlock(block) {
+    return block
+        .split("\n")
+        .map((line) => line.replace(/\s+$/u, ""))
+        .join("\n");
+}
+const CHAT_ASCII_BOTBOTGO = trimAsciiBlock("  ____   ___ _____ ____   ___ _____ ____  ___  \n" +
+    " | __ ) / _ \\_   _| __ ) / _ \\_   _/ ___|/ _ \\ \n" +
+    " |  _ \\| | | || | |  _ \\| | | || || |  _| | | |\n" +
+    " | |_) | |_| || | | |_) | |_| || || |_| | |_| |\n" +
+    " |____/ \\___/ |_| |____/ \\___/ |_| \\____|\\___/");
+const CHAT_ASCII_AGENT_HARNESS = trimAsciiBlock("     _    ____ _____ _   _ _____   _   _    _    ____  _   _ _____ ____ ____  \n" +
+    "    / \\  / ___| ____| \\ | |_   _| | | | |  / \\  |  _ \\| \\ | | ____/ ___/ ___| \n" +
+    "   / _ \\| |  _|  _| |  \\| | | |   | |_| | / _ \\ | |_) |  \\| |  _| \\___ \\___ \\ \n" +
+    "  / ___ \\ |_| | |___| |\\  | | |   |  _  |/ ___ \\|  _ <| |\\  | |___ ___) |__) |\n" +
+    " /_/   \\_\\____|_____|_| \\_| |_|   |_| |_/_/   \\_\\_| \\_\\_| \\_|_____|____/____/");
+const CHAT_LOGO_BRAND_LINE_COLORS = [25, 238, 160, 238, 160];
+const CHAT_LOGO_PRODUCT_LINE_COLORS = [136, 136, 160, 160, 160];
+function colorizeSolidAsciiBlock(block, lineColors, enabled) {
+    const trimmed = trimAsciiBlock(block);
+    const lines = trimmed.split("\n");
+    if (!enabled) {
+        return trimmed;
+    }
+    return lines
+        .map((line, i) => {
+        const code = lineColors[Math.min(i, lineColors.length - 1)] ?? lineColors[lineColors.length - 1];
+        return `\x1b[38;5;${code}m${line}\x1b[0m`;
+    })
+        .join("\n");
+}
+function ellipsizeChatId(value, maxChars) {
+    if (value.length <= maxChars) {
+        return value;
+    }
+    if (maxChars <= 1) {
+        return "…";
+    }
+    return `${value.slice(0, maxChars - 1)}…`;
+}
+export function renderChatPromptLine(input) {
+    const agent = input.agentId ?? "—";
+    const sessionShort = input.sessionId ? ellipsizeChatId(input.sessionId, 8) : null;
+    if (!input.color) {
+        return `❯ agent:${agent}${sessionShort ? ` [${sessionShort}]` : ""} › `;
+    }
+    const labelColor = "\x1b[1;37m";
+    const valueColor = "\x1b[38;5;252m";
+    const mutedColor = "\x1b[38;5;242m";
+    const sigilColor = "\x1b[38;5;246m";
+    const reset = "\x1b[0m";
+    return `${sigilColor}❯${reset} ${labelColor}agent${reset}:${valueColor}${agent}${reset}${sessionShort ? ` ${mutedColor}[${sessionShort}]${reset}` : ""} ${sigilColor}›${reset} `;
+}
+export function renderChatBanner(input) {
+    const { color } = input;
+    const brandArt = colorizeSolidAsciiBlock(CHAT_ASCII_BOTBOTGO, CHAT_LOGO_BRAND_LINE_COLORS, color);
+    const productArt = colorizeSolidAsciiBlock(CHAT_ASCII_AGENT_HARNESS, CHAT_LOGO_PRODUCT_LINE_COLORS, color);
+    const logoWidth = Math.max(...CHAT_ASCII_BOTBOTGO.split("\n").map((l) => l.length), ...CHAT_ASCII_AGENT_HARNESS.split("\n").map((l) => l.length));
+    const ruleLen = Math.min(logoWidth + 4, 96);
+    const dimRule = (ch, len) => color ? `\x1b[38;5;237m${ch.repeat(len)}\x1b[0m` : ch.repeat(len);
+    const labelColor = color ? "\x1b[38;5;242m" : "";
+    const valueColor = color ? "\x1b[38;5;252m" : "";
+    const accentColor = color ? "\x1b[38;5;33m" : "";
+    const resetColor = color ? "\x1b[0m" : "";
+    const mutedColor = color ? "\x1b[38;5;238m" : "";
+    const borderColor = color ? "\x1b[38;5;237m" : "";
+    const kvRow = (label, value, labelW, accent = false) => {
+        const lPad = label.padEnd(labelW);
+        const lFormatted = `${labelColor}${lPad}${resetColor}`;
+        const vFormatted = accent
+            ? `${accentColor}${value}${resetColor}`
+            : `${valueColor}${value}${resetColor}`;
+        return `  ${borderColor}│${resetColor} ${lFormatted} ${mutedColor}·${resetColor} ${vFormatted}`;
+    };
+    const rows = [
+        ["workspace", input.workspacePath, false],
+        ["transport", input.transport, false],
+    ];
+    if (input.agentId)
+        rows.push(["agent", input.agentId, true]);
+    if (input.sessionId)
+        rows.push(["session", input.sessionId, false]);
+    const labelW = Math.max(...rows.map(([l]) => l.length));
+    const panelInner = Math.max(...rows.map(([, v]) => labelW + 4 + v.length), 44);
+    const hLine = (l, m, r) => color
+        ? `  ${borderColor}${l}${resetColor}${borderColor}${m.repeat(panelInner + 2)}${r}${resetColor}`
+        : `  ${l}${m.repeat(panelInner + 2)}${r}`;
+    const versionTagText = "agent-harness";
+    const versionTag = color ? `${mutedColor}agent-harness${resetColor}` : versionTagText;
+    const versionDividerSpan = Math.max(36, ruleLen);
+    const versionGap = 2;
+    const versionRuleBudget = Math.max(24, versionDividerSpan - versionTagText.length - versionGap * 2);
+    const versionRuleLeftLen = Math.floor(versionRuleBudget / 2);
+    const versionRuleRightLen = versionRuleBudget - versionRuleLeftLen;
+    const hint = color
+        ? `  ${mutedColor}Type \x1b[38;5;246m/help\x1b[0m${mutedColor} for commands · \x1b[38;5;246m/exit\x1b[0m${mutedColor} to quit${resetColor}`
+        : `  Type /help for commands · /exit to quit`;
+    return [
+        "",
+        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,
+        "",
+    ].join("\n");
+}
+export function renderRequestEvents(events) {
+    if (events.length === 0) {
+        return "No events recorded.\n";
+    }
+    return events.map((event) => {
+        const timestamp = formatTimestamp(event.timestamp) ?? "unknown-time";
+        const eventType = typeof event.eventType === "string" ? event.eventType : "unknown-event";
+        return `${timestamp} ${eventType}`;
+    }).join("\n") + "\n";
+}
+export function renderChatContext(input) {
+    const rows = [
+        ["agent", input.agentId ?? "—"],
+        ["session", input.sessionId ?? "—"],
+        ["request", input.requestId ?? "—"],
+    ];
+    const labelW = Math.max(...rows.map(([l]) => l.length));
+    const lines = rows.map(([label, value]) => `  ${label.padEnd(labelW)}  ${value}`);
+    return ["", "  Context", "  ───────", ...lines, ""].join("\n");
+}
+export function renderChatHelp() {
+    const sections = [
+        {
+            heading: "Context & navigation",
+            rows: [
+                ["/context", "Show current agent / session / request"],
+                ["/new", "Clear session — start a fresh conversation"],
+                ["/agent <id>", "Switch agent for new requests"],
+                ["/session", "Print current session id"],
+                ["/sessions", "List recent sessions"],
+                ["/resume <id>", "Resume an existing session"],
+                ["/request [id]", "Show or select active request"],
+                ["/requests", "List requests for current session / agent"],
+            ],
+        },
+        {
+            heading: "Approvals",
+            rows: [
+                ["/approvals", "List pending approvals"],
+                ["/approve <id>", "Approve a pending approval"],
+                ["/reject <id>", "Reject a pending approval"],
+                ["/cancel", "Cancel the latest active request"],
+            ],
+        },
+        {
+            heading: "Diagnostics",
+            rows: [
+                ["/events", "Persisted events for the latest request"],
+                ["/trace", "Trace items for the latest request"],
+                ["/health", "Runtime health snapshot"],
+                ["/overview", "Runtime operator overview"],
+            ],
+        },
+        {
+            heading: "Session",
+            rows: [
+                ["/help", "Show this help"],
+                ["/exit", "Quit chat"],
+            ],
+        },
+    ];
+    const allRows = sections.flatMap((s) => s.rows);
+    const cmdW = Math.max(...allRows.map(([cmd]) => cmd.length));
+    const out = [""];
+    for (const section of sections) {
+        out.push(`  ${section.heading}`);
+        out.push(`  ${"─".repeat(section.heading.length)}`);
+        for (const [cmd, desc] of section.rows) {
+            out.push(`    ${cmd.padEnd(cmdW)}  ${desc}`);
+        }
+        out.push("");
+    }
+    out.push("  Starter tasks:");
+    out.push("  ─────────────");
+    out.push("    Inspect this workspace and explain the main entry points.");
+    out.push("    Review this project structure before making any edits.");
+    out.push("    Find the likeliest config issue and propose the smallest fix.");
+    out.push("");
+    return out.join("\n");
+}

package/dist/cli/chat-workspace.d.ts

@@ -0,0 +1,15 @@
+export type ChatWorkspaceModelInfo = {
+    provider?: string;
+    model?: string;
+    baseUrl?: string;
+};
+export declare function normalizeChatCommand(line: string): {
+    name: string;
+    arg?: string;
+} | null;
+export declare function readChatWorkspaceModelInfo(workspaceRoot: string, agentId?: string): ChatWorkspaceModelInfo | undefined;
+export declare function renderChatRuntimeFailure(output: string, modelInfo?: ChatWorkspaceModelInfo): string;
+export declare function probeChatWorkspace(input: {
+    workspaceRoot: string;
+    agentId?: string;
+}): Promise<string | undefined>;