@testchimp/cli 0.1.47 → 0.1.49

package/dist/chimphands/run.js

@@ -18,7 +18,11 @@ const STATUS_WAITING_USER = "CHIMPHANDS_SESSION_STATUS_WAITING_USER";
 const STATUS_IDLE = "CHIMPHANDS_SESSION_STATUS_IDLE";
 const STATUS_FAILED = "CHIMPHANDS_SESSION_STATUS_FAILED";
 const OPENCODE_AGENT_ID = "chimphands";
-const STREAM_POST_MIN_INTERVAL_MS = 60;
+/** Coalesce live token fanout (~6–10 posts/s/session) while UI is attached. */
+const STREAM_POST_MIN_INTERVAL_MS = 150;
+function isStreamFanoutRole(role) {
+    return role === ROLE_ASSISTANT || role === ROLE_TOOL || role === ROLE_REASONING;
+}
 const CHIMPHANDS_AGENT_PROMPT = `You are ChimpHands, TestChimp's coding agent. You run on GitHub Actions, but this chat is an **interactive** conversation with the user in the TestChimp UI — same expectations as Cursor/Claude Code locally.
 
 ## Interactive session (mandatory — default)
@@ -102,13 +106,15 @@ async function postJson(backend, apiKey, path, body) {
     }
     return text;
 }
-/** Serializes post_agent_event calls so streaming chunks commit and fan out in order. */
+/** Serializes agent event posts so streaming chunks fan out in order. */
 class AgentEventPoster {
     backend;
     apiKey;
     sessionId;
     chain = Promise.resolve();
     lastStreamPostAt = 0;
+    /** When false, liveStream tokens are dropped; completed events still persist. */
+    uiAttached = false;
     constructor(backend, apiKey, sessionId) {
         this.backend = backend;
         this.apiKey = apiKey;
@@ -130,14 +136,50 @@ class AgentEventPoster {
             body.workingBranch = opts.workingBranch;
         if (opts?.pullRequestUrl)
             body.pullRequestUrl = opts.pullRequestUrl;
+        const streamRole = isStreamFanoutRole(role);
+        // Live token fanout only while UI watching; completed json events always go durable.
+        if (streamRole && opts?.liveStream && !this.uiAttached) {
+            return this.chain;
+        }
         this.chain = this.chain.then(async () => {
-            if (opts?.throttle) {
+            if (opts?.throttle || (streamRole && opts?.liveStream)) {
                 const now = Date.now();
                 const wait = STREAM_POST_MIN_INTERVAL_MS - (now - this.lastStreamPostAt);
                 if (wait > 0)
                     await sleep(wait);
                 this.lastStreamPostAt = Date.now();
             }
+            const tryEphemeral = streamRole && this.uiAttached;
+            if (tryEphemeral) {
+                const eph = {
+                    sessionId: this.sessionId,
+                    role,
+                    content: body.content,
+                };
+                if (opts?.messageId)
+                    eph.messageId = opts.messageId;
+                if (opts?.opencodeSessionId)
+                    eph.opencodeSessionId = opts.opencodeSessionId;
+                try {
+                    const text = await postJson(this.backend, this.apiKey, "/api/chimphands/post_ephemeral_agent_event", eph);
+                    let delivered = false;
+                    try {
+                        const parsed = JSON.parse(text);
+                        delivered = !!parsed.delivered;
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                    if (delivered)
+                        return;
+                    // Cross-replica: UI SSE not on this FS pod — fall through to durable.
+                    console.error("ChimpHands ephemeral not delivered (replica miss?) — persisting via post_agent_event");
+                }
+                catch (err) {
+                    const detail = err instanceof Error ? err.message : String(err);
+                    console.error(`ChimpHands ephemeral post failed — durable fallback: ${detail}`);
+                }
+            }
             await postJson(this.backend, this.apiKey, "/api/chimphands/post_agent_event", body);
         });
         return this.chain;
@@ -215,6 +257,122 @@ function parseOpencodeEvent(line) {
         return null;
     }
 }
+/**
+ * Newer OpenCode `--format json` lines often use the SSE bus shape
+ * (`message.part.updated` + `properties.part`) instead of legacy `type: "text"`.
+ * Normalize both into the same OpencodeEvent used by the stdout switch.
+ */
+function normalizeStdoutOpencodeEvent(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const o = raw;
+    // Global envelope
+    const inner = o.payload && typeof o.payload === "object"
+        ? o.payload
+        : o.event && typeof o.event === "object"
+            ? o.event
+            : o;
+    const type = String(inner.type || "");
+    const props = (inner.properties && typeof inner.properties === "object"
+        ? inner.properties
+        : {});
+    if (type === "message.part.updated" || type === "message.part.delta") {
+        const part = props.part;
+        if (!part)
+            return null;
+        const partType = part.type || "";
+        let mapped;
+        if (partType === "text")
+            mapped = "text";
+        else if (partType === "reasoning")
+            mapped = "reasoning";
+        else if (partType === "tool")
+            mapped = "tool_use";
+        else
+            return null;
+        // Prefer cumulative text; append delta when that's all we got.
+        if (props.delta && !part.text) {
+            part.text = props.delta;
+        }
+        return {
+            type: mapped,
+            sessionID: part.sessionID || props.sessionID,
+            part,
+        };
+    }
+    if (type === "session.error") {
+        return {
+            type: "error",
+            sessionID: props.sessionID,
+            error: props.error,
+        };
+    }
+    // Legacy flat shape: { type: "text"|"tool_use"|..., part, sessionID }
+    if (type) {
+        return inner;
+    }
+    return null;
+}
+/** Pull assistant/tool parts from OpenCode HTTP after attach exits early. */
+async function reconcileOpencodeSessionMessages(attachUrl, opencodeSessionId, postEvent, onWorkingBranch) {
+    const base = attachUrl.replace(/\/$/, "");
+    const url = `${base}/session/${encodeURIComponent(opencodeSessionId)}/message`;
+    let res;
+    try {
+        res = await fetch(url, {
+            headers: { Accept: "application/json", "x-opencode-directory": process.cwd() },
+        });
+    }
+    catch (err) {
+        console.error(`ChimpHands reconcile messages fetch failed: ${err instanceof Error ? err.message : String(err)}`);
+        return 0;
+    }
+    if (!res.ok) {
+        console.error(`ChimpHands reconcile messages HTTP ${res.status}`);
+        return 0;
+    }
+    const data = (await res.json());
+    if (!Array.isArray(data))
+        return 0;
+    let posted = 0;
+    for (const msg of data) {
+        if ((msg.info?.role || "").toLowerCase() !== "assistant")
+            continue;
+        for (const part of msg.parts || []) {
+            if (part.type === "text" && part.text?.trim()) {
+                postEvent(ROLE_ASSISTANT, part.text.trim(), {
+                    messageId: opencodeMessageId("oc_text_", part),
+                });
+                posted += 1;
+            }
+            else if (part.type === "reasoning" && part.text?.trim()) {
+                postEvent(ROLE_REASONING, part.text.trim(), {
+                    messageId: opencodeMessageId("oc_reasoning_", part),
+                });
+                posted += 1;
+            }
+            else if (part.type === "tool") {
+                const status = part.state?.status;
+                if (!status || status === "pending" || status === "running")
+                    continue;
+                const toolContent = formatToolUseContent(part);
+                postEvent(ROLE_TOOL, toolContent, {
+                    messageId: opencodeMessageId("oc_tool_", part),
+                });
+                posted += 1;
+                if (status === "completed") {
+                    const detected = detectWorkingBranchFromToolOutput(toolContent);
+                    if (detected.branch)
+                        onWorkingBranch?.(detected.branch, detected.pullRequestUrl);
+                }
+            }
+        }
+    }
+    if (posted) {
+        console.error(`ChimpHands reconciled ${posted} part(s) from OpenCode session API`);
+    }
+    return posted;
+}
 function formatToolUseContent(part) {
     const title = part.state?.title || part.tool || "tool";
     const status = part.state?.status?.trim();
@@ -236,6 +394,213 @@ function opencodeMessageId(prefix, part) {
         return undefined;
     return `${prefix}${raw}`;
 }
+/**
+ * OpenCode `run --format json` only emits completed text (`part.time.end`).
+ * Live tokens come from the server SSE bus (`message.part.updated` + optional `delta`).
+ * Subscribe directly when attaching so the platform chat streams.
+ */
+function startOpencodeSseRelay(attachUrl, callbacks) {
+    const base = attachUrl.replace(/\/$/, "");
+    const ac = new AbortController();
+    let stopped = false;
+    const textByPartId = new Map();
+    const directory = process.cwd();
+    const sessionMatches = (sessionId) => {
+        const active = callbacks.getActiveSessionId();
+        if (!sessionId)
+            return !active;
+        if (!active)
+            return true;
+        return sessionId === active;
+    };
+    const liveOpts = (extra) => ({
+        ...extra,
+        throttle: true,
+        liveStream: true,
+    });
+    const unwrapBusPayload = (raw) => {
+        if (!raw || typeof raw !== "object")
+            return raw;
+        const o = raw;
+        // /global/event wraps as { directory, payload } or { directory, event }
+        if (o.payload && typeof o.payload === "object")
+            return o.payload;
+        if (o.event && typeof o.event === "object")
+            return o.event;
+        return raw;
+    };
+    const handleBusEvent = (raw) => {
+        const unwrapped = unwrapBusPayload(raw);
+        if (!unwrapped || typeof unwrapped !== "object")
+            return;
+        const ev = unwrapped;
+        const type = ev.type || "";
+        const props = ev.properties || {};
+        if (type === "message.part.updated" || type === "message.part.delta") {
+            const part = props.part;
+            if (!part)
+                return;
+            const sessionId = part.sessionID || props.sessionID;
+            if (!sessionMatches(sessionId))
+                return;
+            callbacks.noteSessionId(sessionId);
+            if (part.type === "text") {
+                const partId = part.id || part.messageID;
+                if (!partId)
+                    return;
+                let next = part.text || "";
+                if (props.delta) {
+                    next = (textByPartId.get(partId) || "") + props.delta;
+                }
+                else if (!next && props.delta === undefined) {
+                    return;
+                }
+                // Prefer cumulative part.text when present (idempotent); else delta accumulation.
+                if (part.text)
+                    next = part.text;
+                textByPartId.set(partId, next);
+                if (!next)
+                    return;
+                callbacks.postEvent(ROLE_ASSISTANT, next, liveOpts({
+                    messageId: opencodeMessageId("oc_text_", part),
+                }));
+                return;
+            }
+            if (part.type === "reasoning") {
+                const partId = part.id || part.messageID;
+                if (!partId)
+                    return;
+                let next = part.text || "";
+                if (props.delta && !part.text) {
+                    next = (textByPartId.get(`reasoning:${partId}`) || "") + props.delta;
+                }
+                if (part.text)
+                    next = part.text;
+                textByPartId.set(`reasoning:${partId}`, next);
+                if (!next)
+                    return;
+                callbacks.postEvent(ROLE_REASONING, next, liveOpts({
+                    messageId: opencodeMessageId("oc_reasoning_", part),
+                }));
+                return;
+            }
+            if (part.type === "tool") {
+                const status = part.state?.status;
+                if (!status || status === "pending" || status === "running")
+                    return;
+                const toolContent = formatToolUseContent(part);
+                callbacks.postEvent(ROLE_TOOL, toolContent, liveOpts({
+                    messageId: opencodeMessageId("oc_tool_", part),
+                    throttle: false,
+                }));
+                if (status === "completed") {
+                    const detected = detectWorkingBranchFromToolOutput(toolContent);
+                    if (detected.branch) {
+                        callbacks.onWorkingBranch?.(detected.branch, detected.pullRequestUrl);
+                    }
+                }
+            }
+            return;
+        }
+        if (type === "session.error") {
+            const sessionId = props.sessionID;
+            if (!sessionMatches(sessionId))
+                return;
+            const msg = props.error?.data?.message || props.error?.message || props.error?.name || "OpenCode session error";
+            callbacks.postEvent(ROLE_STATUS, String(msg), { status: STATUS_RUNNING });
+        }
+    };
+    const consume = async (body) => {
+        const reader = body.getReader();
+        const decoder = new TextDecoder();
+        let buf = "";
+        while (!stopped) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buf += decoder.decode(value, { stream: true });
+            const chunks = buf.split("\n\n");
+            buf = chunks.pop() || "";
+            for (const chunk of chunks) {
+                const dataLines = chunk
+                    .split("\n")
+                    .filter((l) => l.startsWith("data:"))
+                    .map((l) => l.slice(5).trimStart());
+                if (!dataLines.length)
+                    continue;
+                const data = dataLines.join("\n");
+                if (!data || data === "[DONE]")
+                    continue;
+                try {
+                    handleBusEvent(JSON.parse(data));
+                }
+                catch {
+                    /* ignore malformed */
+                }
+            }
+        }
+    };
+    const candidates = () => {
+        const dirQ = `directory=${encodeURIComponent(directory)}`;
+        return [
+            `/event?${dirQ}`,
+            `/event`,
+            `/global/event?${dirQ}`,
+            `/global/event`,
+        ];
+    };
+    void (async () => {
+        let attempt = 0;
+        while (!stopped) {
+            let connected = false;
+            for (const path of candidates()) {
+                if (stopped)
+                    return;
+                try {
+                    const res = await fetch(`${base}${path}`, {
+                        headers: {
+                            Accept: "text/event-stream",
+                            "x-opencode-directory": directory,
+                        },
+                        signal: ac.signal,
+                    });
+                    if (!res.ok || !res.body) {
+                        console.error(`ChimpHands OpenCode SSE ${path} HTTP ${res.status}`);
+                        continue;
+                    }
+                    console.error(`ChimpHands OpenCode SSE streaming via ${path}`);
+                    connected = true;
+                    await consume(res.body);
+                    // Stream ended — retry if still attached.
+                    break;
+                }
+                catch (err) {
+                    if (stopped || ac.signal.aborted)
+                        return;
+                    const detail = err instanceof Error ? err.message : String(err);
+                    console.error(`ChimpHands OpenCode SSE ${path} failed: ${detail}`);
+                }
+            }
+            if (stopped || ac.signal.aborted)
+                return;
+            if (!connected && attempt === 0) {
+                console.error("ChimpHands OpenCode SSE unavailable — falling back to completed-only --format json events (will keep retrying SSE)");
+            }
+            attempt += 1;
+            const backoff = Math.min(30_000, 2_000 * attempt);
+            await sleep(backoff);
+        }
+    })();
+    return () => {
+        stopped = true;
+        try {
+            ac.abort();
+        }
+        catch {
+            /* ignore */
+        }
+    };
+}
 function summarizeOpencodeFailure(stderr, stdout, exitCode) {
     for (const chunk of [stderr, stdout]) {
         for (const line of chunk.split("\n")) {
@@ -262,21 +627,15 @@ function isMissingOpencodeSessionError(message) {
         m.includes("unknown session") ||
         m.includes("invalid session"));
 }
-function isNonInteractivePrompt(userPrompt) {
-    return /(?:^|\s)--mode\s*=?\s*non-interactive\b|mode\s*=\s*non-interactive\b/i.test(userPrompt);
-}
-function isTestchimpWorkflowPrompt(userPrompt) {
-    return /(?:^|\s)\/?testchimp\b/i.test(userPrompt.trim());
-}
 function wrapPromptWithContext(conversationSummary, userPrompt, isNewOpencodeSession, workingBranch, pullRequestUrl) {
     const parts = [];
     if (workingBranch?.trim()) {
         parts.push("## Conversation working branch (reuse for this thread)", `Branch: \`${workingBranch.trim()}\``, pullRequestUrl?.trim() ? `PR: ${pullRequestUrl.trim()}` : "", "Checkout this branch, commit and push here. Do NOT open a new PR unless the one above was merged/closed.", "");
     }
     const task = normalizeUserMessage(userPrompt);
-    if (isTestchimpWorkflowPrompt(task) && !isNonInteractivePrompt(task)) {
-        parts.push("## Interactive turn reminder", "This is an interactive ChimpHands chat (not autonomous CI). Ask clarifying questions / seek plan approval, then end the turn and wait — do not invent defaults or Execute until the user replies. Only `--mode=non-interactive` skips that pause.", "");
-    }
+    // Do NOT inject "Interactive turn reminder" into the user prompt — it is already in
+    // CHIMPHANDS_AGENT_PROMPT (system). Putting it here makes OpenCode store it as the
+    // user message and the UI shows host control text in chat.
     if (isNewOpencodeSession && conversationSummary.trim()) {
         parts.push(`Conversation so far:\n${conversationSummary.trim()}`, "", `Current task:\n${task}`);
         return parts.filter(Boolean).join("\n");
@@ -350,10 +709,12 @@ function writeOpencodeConfig(backend, apiKey, boot) {
                 prompt: CHIMPHANDS_AGENT_PROMPT,
                 steps: 80,
                 permission: {
+                    "*": "allow",
                     skill: "allow",
                     bash: "allow",
                     edit: "allow",
                     read: "allow",
+                    question: "allow",
                 },
             },
         },
@@ -364,7 +725,8 @@ function writeOpencodeConfig(backend, apiKey, boot) {
             testchimp: {
                 type: "local",
                 enabled: true,
-                command: ["npx", "-y", "@testchimp/cli@latest", "mcp"],
+                // Prefer the already-installed global binary — `npx -y @latest` can hang in GHA.
+                command: ["testchimp", "mcp"],
                 environment: mcpEnv,
             },
         },
@@ -372,6 +734,8 @@ function writeOpencodeConfig(backend, apiKey, boot) {
     return model;
 }
 function buildOpencodeArgs(prompt, model, opencodeSessionId, attachUrl) {
+    // --auto: headless CI must approve tool permissions (1.18+ otherwise auto-rejects).
+    // --print-logs: surface server/client progress on stderr while waiting for first token.
     const args = [
         "run",
         prompt,
@@ -381,6 +745,8 @@ function buildOpencodeArgs(prompt, model, opencodeSessionId, attachUrl) {
         "json",
         "--agent",
         OPENCODE_AGENT_ID,
+        "--auto",
+        "--print-logs",
     ];
     if (opencodeSessionId?.trim()) {
         args.push("--session", opencodeSessionId.trim());
@@ -461,18 +827,43 @@ async function restartLocalOpencodeServer(attachUrl) {
 function runOpencode(prompt, model, childEnv, opencodeSessionId, callbacks, attachUrl) {
     let activeSessionId = opencodeSessionId?.trim() || undefined;
     const baseArgs = buildOpencodeArgs(prompt, model, activeSessionId, attachUrl);
+    const preview = prompt.length > 120 ? `${prompt.slice(0, 117)}...` : prompt;
+    console.error(`ChimpHands invoking OpenCode: model=${model} attach=${attachUrl || "(local)"} session=${activeSessionId || "(new)"} prompt=${JSON.stringify(preview)}`);
+    // pipe+end stdin so OpenCode does not wait on Bun.stdin.text() (non-TTY).
     const child = spawn("opencode", baseArgs, {
-        stdio: ["ignore", "pipe", "pipe"],
+        stdio: ["pipe", "pipe", "pipe"],
         env: childEnv,
     });
+    try {
+        child.stdin?.end();
+    }
+    catch {
+        /* ignore */
+    }
     let err = "";
     child.stderr.on("data", (d) => {
-        err += d.toString();
+        const chunk = d.toString();
+        err += chunk;
+        // Live-forward so GHA shows progress while waiting for first JSON event.
+        process.stderr.write(chunk);
     });
     return new Promise((resolve) => {
         let buf = "";
         let fatalError = null;
         const textByPartId = new Map();
+        let sawStdout = false;
+        let progressTicker = setInterval(() => {
+            if (sawStdout) {
+                if (progressTicker) {
+                    clearInterval(progressTicker);
+                    progressTicker = null;
+                }
+                return;
+            }
+            callbacks.postEvent(ROLE_STATUS, "Agent is still working… (waiting for OpenCode output)", {
+                status: STATUS_RUNNING,
+            });
+        }, 45_000);
         const noteSessionId = (sessionId) => {
             const id = sessionId?.trim();
             if (!id || id === activeSessionId)
@@ -483,6 +874,14 @@ function runOpencode(prompt, model, childEnv, opencodeSessionId, callbacks, atta
         const handleOpencodeLine = (line) => {
             if (!line.trim())
                 return;
+            if (!sawStdout) {
+                sawStdout = true;
+                console.error("ChimpHands OpenCode first stdout event received");
+                if (progressTicker) {
+                    clearInterval(progressTicker);
+                    progressTicker = null;
+                }
+            }
             const fatal = extractOpencodeFatalError(line);
             if (fatal) {
                 fatalError = fatal;
@@ -568,6 +967,10 @@ function runOpencode(prompt, model, childEnv, opencodeSessionId, callbacks, atta
             }
         });
         child.on("close", (code) => {
+            if (progressTicker) {
+                clearInterval(progressTicker);
+                progressTicker = null;
+            }
             if (buf.trim()) {
                 handleOpencodeLine(buf.trim());
             }
@@ -685,6 +1088,40 @@ export async function runChimphands(opts) {
     const boot = JSON.parse(bootText);
     const githubRunId = (process.env.GITHUB_RUN_ID || "").trim();
     const poster = new AgentEventPoster(backend, apiKey, sessionId);
+    poster.uiAttached = !!(boot.uiAttached ?? boot.ui_attached);
+    let stopLiveSse = null;
+    const syncLiveSse = (attached) => {
+        poster.uiAttached = attached;
+        if (!attachUrl)
+            return;
+        if (attached && !stopLiveSse) {
+            console.error("ChimpHands UI attached — starting OpenCode SSE fanout");
+            stopLiveSse = startOpencodeSseRelay(attachUrl, {
+                getActiveSessionId: () => opencodeSessionId,
+                noteSessionId: (id) => {
+                    if (id?.trim())
+                        opencodeSessionId = id.trim();
+                },
+                postEvent: (role, content, opts) => {
+                    poster.fireAndForget(role, content, {
+                        ...opts,
+                        opencodeSessionId: opts?.opencodeSessionId || opencodeSessionId,
+                    });
+                },
+                onWorkingBranch: noteWorkingBranchPlaceholder,
+            });
+        }
+        else if (!attached && stopLiveSse) {
+            console.error("ChimpHands UI detached — stopping OpenCode SSE fanout");
+            stopLiveSse();
+            stopLiveSse = null;
+        }
+    };
+    // noteWorkingBranch is defined later; bind via mutable holder until then.
+    let noteWorkingBranch = () => { };
+    const noteWorkingBranchPlaceholder = (branch, prUrl) => {
+        noteWorkingBranch(branch, prUrl);
+    };
     if (githubRunId) {
         await postJson(backend, apiKey, "/api/chimphands/post_agent_event", {
             sessionId,
@@ -712,7 +1149,9 @@ export async function runChimphands(opts) {
         }
     }
     const stopHeartbeat = runtimeId
-        ? startRuntimeHeartbeat(backend, apiKey, runtimeId)
+        ? startRuntimeHeartbeat(backend, apiKey, runtimeId, (attached) => {
+            syncLiveSse(attached);
+        })
         : () => { };
     const stopTunnel = runtimeId && attachUrl
         ? startTunnelWorker(backend, apiKey, runtimeId, attachUrl)
@@ -758,7 +1197,7 @@ export async function runChimphands(opts) {
             console.error(`ChimpHands export snapshot failed: ${err instanceof Error ? err.message : String(err)}`);
         }
     };
-    const noteWorkingBranch = (branch, prUrl) => {
+    noteWorkingBranch = (branch, prUrl) => {
         const normalizedBranch = branch.trim();
         if (!normalizedBranch)
             return;
@@ -774,6 +1213,8 @@ export async function runChimphands(opts) {
             poster.reportWorkingBranch(normalizedBranch, nextPr);
         }
     };
+    // Apply bootstrap ui_attached now that session id + branch hooks exist.
+    syncLiveSse(poster.uiAttached);
     const idleMs = (bootNum(boot, "idle_timeout_seconds", "idleTimeoutSeconds") || 600) * 1000;
     const queue = [];
     const seenUserMessageIds = new Set();
@@ -849,6 +1290,10 @@ export async function runChimphands(opts) {
         stopInbound();
         stopTunnel();
         stopHeartbeat();
+        if (stopLiveSse) {
+            stopLiveSse();
+            stopLiveSse = null;
+        }
         await commitAndPushDirtyWorktree("chimphands: commit before session idle/shutdown");
         await poster.flush();
         await snapshotExport();
@@ -902,6 +1347,9 @@ export async function runChimphands(opts) {
             let useOpencodeSessionId = opencodeSessionId;
             let isNewOpencodeSession = !useOpencodeSessionId;
             let effectivePrompt = wrapPromptWithContext(conversationSummary, prompt, isNewOpencodeSession, workingBranch, pullRequestUrl);
+            // Visible in chat (not filtered as routine). OpenCode may not emit text until a
+            // part completes — without this the UI looks empty while the turn is running.
+            postEvent(ROLE_STATUS, "Agent is working…", { status: STATUS_RUNNING });
             let result = await runOpencode(effectivePrompt, opencodeModel, childEnv, useOpencodeSessionId, {
                 onSessionId: (id) => {
                     opencodeSessionId = id;
@@ -978,22 +1426,34 @@ export async function runChimphands(opts) {
         process.exit(exitCode);
     }
 }
-function startRuntimeHeartbeat(backend, apiKey, runtimeId) {
+function startRuntimeHeartbeat(backend, apiKey, runtimeId, onUiAttached) {
     let stopped = false;
+    let lastAttached;
     const tick = async () => {
         if (stopped)
             return;
         try {
             // Do not claim tunnel_connected here — only the tunnel poll loop should.
-            await postJson(backend, apiKey, "/api/chimphands/runtime_heartbeat", {
+            const text = await postJson(backend, apiKey, "/api/chimphands/runtime_heartbeat", {
                 runtimeId,
             });
+            try {
+                const data = JSON.parse(text);
+                const attached = !!(data.uiAttached ?? data.ui_attached);
+                if (attached !== lastAttached) {
+                    lastAttached = attached;
+                    onUiAttached?.(attached);
+                }
+            }
+            catch {
+                /* ignore parse */
+            }
         }
         catch (err) {
             console.error(`ChimpHands runtime_heartbeat failed: ${err instanceof Error ? err.message : String(err)}`);
         }
         if (!stopped)
-            setTimeout(tick, 15_000);
+            setTimeout(tick, 5_000);
     };
     void tick();
     return () => {
@@ -1065,7 +1525,7 @@ async function commitAndPushDirtyWorktree(message) {
 }
 async function putOpencodeExport(backend, apiKey, sessionId, opencodeSessionId) {
     const exported = await new Promise((resolve, reject) => {
-        const child = spawn("opencode", ["export", opencodeSessionId, "--sanitize"], {
+        const child = spawn("opencode", ["export", opencodeSessionId], {
             stdio: ["ignore", "pipe", "pipe"],
         });
         let out = "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testchimp/cli",
-  "version": "0.1.47",
+  "version": "0.1.49",
   "description": "TestChimp CLI and MCP server — coverage, plans, EaaS, TrueCoverage, API operations (calls /api/mcp/*)",
   "type": "module",
   "main": "dist/bin/testchimp.js",