@testchimp/cli 0.1.50 → 0.1.52

package/dist/chimphands/run.js

@@ -137,11 +137,12 @@ class AgentEventPoster {
         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 () => {
+            // Mid-turn live tokens only while UI is attached — async runs skip FS fanout
+            // and rely on turn-end reconcile for durable PG.
+            if (opts?.liveStream && !this.uiAttached) {
+                return;
+            }
             if (opts?.throttle || (streamRole && opts?.liveStream)) {
                 const now = Date.now();
                 const wait = STREAM_POST_MIN_INTERVAL_MS - (now - this.lastStreamPostAt);
@@ -172,11 +173,21 @@ class AgentEventPoster {
                     }
                     if (delivered)
                         return;
-                    // Cross-replica: UI SSE not on this FS pod — fall through to durable.
+                    // Mid-turn liveStream must not fall through to durable — that would write
+                    // every token to PG. Turn-end reconcile persists the final transcript.
+                    if (opts?.liveStream) {
+                        console.error("ChimpHands ephemeral not delivered (replica miss?) — skipping durable for liveStream");
+                        return;
+                    }
+                    // Completed/non-live: durable fallback for cross-replica UI.
                     console.error("ChimpHands ephemeral not delivered (replica miss?) — persisting via post_agent_event");
                 }
                 catch (err) {
                     const detail = err instanceof Error ? err.message : String(err);
+                    if (opts?.liveStream) {
+                        console.error(`ChimpHands ephemeral post failed — skipping durable for liveStream: ${detail}`);
+                        return;
+                    }
                     console.error(`ChimpHands ephemeral post failed — durable fallback: ${detail}`);
                 }
             }
@@ -276,7 +287,43 @@ function normalizeStdoutOpencodeEvent(raw) {
     const props = (inner.properties && typeof inner.properties === "object"
         ? inner.properties
         : {});
-    if (type === "message.part.updated" || type === "message.part.delta") {
+    if (type === "message.part.delta") {
+        // OpenCode streams tokens as { partID, field, delta } with no `part`.
+        const deltaProps = props;
+        const part = deltaProps.part;
+        if (part) {
+            const partType = part.type || deltaProps.field || "";
+            let mapped;
+            if (partType === "text")
+                mapped = "text";
+            else if (partType === "reasoning")
+                mapped = "reasoning";
+            else if (partType === "tool")
+                mapped = "tool_use";
+            else
+                return null;
+            if (deltaProps.delta && !part.text)
+                part.text = deltaProps.delta;
+            return {
+                type: mapped,
+                sessionID: part.sessionID || deltaProps.sessionID,
+                part,
+            };
+        }
+        const partID = deltaProps.partID;
+        const field = deltaProps.field || "text";
+        const delta = deltaProps.delta;
+        if (!partID || delta == null || delta === "")
+            return null;
+        if (field !== "text" && field !== "reasoning")
+            return null;
+        return {
+            type: field === "reasoning" ? "reasoning" : "text",
+            sessionID: deltaProps.sessionID,
+            part: { id: partID, type: field, text: delta },
+        };
+    }
+    if (type === "message.part.updated") {
         const part = props.part;
         if (!part)
             return null;
@@ -290,7 +337,6 @@ function normalizeStdoutOpencodeEvent(raw) {
             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;
         }
@@ -313,7 +359,7 @@ function normalizeStdoutOpencodeEvent(raw) {
     }
     return null;
 }
-/** Pull assistant/tool parts from OpenCode HTTP after attach exits early. */
+/** Pull assistant/tool parts from OpenCode HTTP for durable PG (turn-end). */
 async function reconcileOpencodeSessionMessages(attachUrl, opencodeSessionId, postEvent, onWorkingBranch) {
     const base = attachUrl.replace(/\/$/, "");
     const url = `${base}/session/${encodeURIComponent(opencodeSessionId)}/message`;
@@ -334,8 +380,18 @@ async function reconcileOpencodeSessionMessages(attachUrl, opencodeSessionId, po
     const data = (await res.json());
     if (!Array.isArray(data))
         return 0;
+    // Only parts after the latest user message (this turn). Full-history reconcile
+    // every turn would O(n) upsert the entire transcript for no benefit.
+    let lastUserIdx = -1;
+    for (let i = data.length - 1; i >= 0; i--) {
+        if ((data[i]?.info?.role || "").toLowerCase() === "user") {
+            lastUserIdx = i;
+            break;
+        }
+    }
+    const turnSlice = lastUserIdx >= 0 ? data.slice(lastUserIdx + 1) : data;
     let posted = 0;
-    for (const msg of data) {
+    for (const msg of turnSlice) {
         if ((msg.info?.role || "").toLowerCase() !== "assistant")
             continue;
         for (const part of msg.parts || []) {
@@ -369,7 +425,7 @@ async function reconcileOpencodeSessionMessages(attachUrl, opencodeSessionId, po
         }
     }
     if (posted) {
-        console.error(`ChimpHands reconciled ${posted} part(s) from OpenCode session API`);
+        console.error(`ChimpHands reconciled ${posted} part(s) from OpenCode session API (this turn)`);
     }
     return posted;
 }
@@ -436,7 +492,36 @@ function startOpencodeSseRelay(attachUrl, callbacks) {
         const ev = unwrapped;
         const type = ev.type || "";
         const props = ev.properties || {};
-        if (type === "message.part.updated" || type === "message.part.delta") {
+        // Token stream: { partID, field, delta } — often no `part` object.
+        if (type === "message.part.delta") {
+            const part = props.part;
+            const partId = props.partID || part?.id || part?.messageID;
+            const field = props.field || part?.type || "text";
+            const sessionId = part?.sessionID || props.sessionID;
+            if (!sessionMatches(sessionId))
+                return;
+            callbacks.noteSessionId(sessionId);
+            if (!partId || props.delta == null || props.delta === "")
+                return;
+            if (field === "text") {
+                const next = (textByPartId.get(partId) || "") + props.delta;
+                textByPartId.set(partId, next);
+                callbacks.postEvent(ROLE_ASSISTANT, next, liveOpts({
+                    messageId: `oc_text_${partId}`,
+                }));
+                return;
+            }
+            if (field === "reasoning") {
+                const key = `reasoning:${partId}`;
+                const next = (textByPartId.get(key) || "") + props.delta;
+                textByPartId.set(key, next);
+                callbacks.postEvent(ROLE_REASONING, next, liveOpts({
+                    messageId: `oc_reasoning_${partId}`,
+                }));
+            }
+            return;
+        }
+        if (type === "message.part.updated") {
             const part = props.part;
             if (!part)
                 return;
@@ -449,13 +534,12 @@ function startOpencodeSseRelay(attachUrl, callbacks) {
                 if (!partId)
                     return;
                 let next = part.text || "";
-                if (props.delta) {
+                if (props.delta && !part.text) {
                     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);
@@ -486,8 +570,17 @@ function startOpencodeSseRelay(attachUrl, callbacks) {
             }
             if (part.type === "tool") {
                 const status = part.state?.status;
-                if (!status || status === "pending" || status === "running")
+                if (!status || status === "pending")
                     return;
+                // Ephemeral "(running)" bubbles while UI attached (liveStream gated in poster).
+                if (status === "running") {
+                    const toolContent = formatToolUseContent(part);
+                    callbacks.postEvent(ROLE_TOOL, toolContent, liveOpts({
+                        messageId: opencodeMessageId("oc_tool_", part),
+                        throttle: false,
+                    }));
+                    return;
+                }
                 const toolContent = formatToolUseContent(part);
                 callbacks.postEvent(ROLE_TOOL, toolContent, liveOpts({
                     messageId: opencodeMessageId("oc_tool_", part),
@@ -863,7 +956,7 @@ function runOpencode(prompt, model, childEnv, opencodeSessionId, callbacks, atta
             callbacks.postEvent(ROLE_STATUS, "Agent is still working… (waiting for OpenCode output)", {
                 status: STATUS_RUNNING,
             });
-        }, 45_000);
+        }, 15_000);
         const noteSessionId = (sessionId) => {
             const id = sessionId?.trim();
             if (!id || id === activeSessionId)
@@ -887,10 +980,31 @@ function runOpencode(prompt, model, childEnv, opencodeSessionId, callbacks, atta
                 fatalError = fatal;
                 return;
             }
-            const ev = parseOpencodeEvent(line);
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                return;
+            }
+            // Newer OpenCode --format json uses bus shape (message.part.updated); normalize first.
+            const ev = normalizeStdoutOpencodeEvent(parsed) || parseOpencodeEvent(line);
             if (!ev?.type)
                 return;
             noteSessionId(ev.sessionID);
+            switch (ev.type) {
+                case "text":
+                case "reasoning":
+                case "tool_use": {
+                    // Attach mode: live tokens come from OpenCode SSE; durable from turn-end
+                    // reconcile. Avoid double-fanout / double-accumulation with stdout.
+                    if (attachUrl)
+                        return;
+                    break;
+                }
+                default:
+                    break;
+            }
             switch (ev.type) {
                 case "text": {
                     const chunk = ev.part?.text;
@@ -901,7 +1015,14 @@ function runOpencode(prompt, model, childEnv, opencodeSessionId, callbacks, atta
                         callbacks.postEvent(ROLE_ASSISTANT, chunk, { throttle: true });
                         return;
                     }
-                    const next = (textByPartId.get(partId) || "") + chunk;
+                    // Without attach, --format json may emit completed cumulative or deltas.
+                    // Prefer replace when we already have longer text (cumulative); else append.
+                    const prev = textByPartId.get(partId) || "";
+                    const next = !prev
+                        ? chunk
+                        : chunk.startsWith(prev)
+                            ? chunk
+                            : prev + chunk;
                     textByPartId.set(partId, next);
                     callbacks.postEvent(ROLE_ASSISTANT, next, {
                         throttle: true,
@@ -919,7 +1040,12 @@ function runOpencode(prompt, model, childEnv, opencodeSessionId, callbacks, atta
                         return;
                     }
                     const reasoningKey = `reasoning:${partId}`;
-                    const next = (textByPartId.get(reasoningKey) || "") + chunk;
+                    const prev = textByPartId.get(reasoningKey) || "";
+                    const next = !prev
+                        ? chunk
+                        : chunk.startsWith(prev)
+                            ? chunk
+                            : prev + chunk;
                     textByPartId.set(reasoningKey, next);
                     callbacks.postEvent(ROLE_REASONING, next, {
                         throttle: true,
@@ -928,8 +1054,9 @@ function runOpencode(prompt, model, childEnv, opencodeSessionId, callbacks, atta
                     return;
                 }
                 case "tool_use": {
+                    // Durable-only path (no attach). Skip in-progress.
                     const status = ev.part?.state?.status;
-                    if (!status || status === "pending")
+                    if (!status || status === "pending" || status === "running")
                         return;
                     const toolContent = formatToolUseContent(ev.part);
                     callbacks.postEvent(ROLE_TOOL, toolContent, {
@@ -1093,36 +1220,58 @@ export async function runChimphands(opts) {
     /** Do not open localhost OpenCode /event until serve has been (re)started with config. */
     let opencodeHttpReady = !attachUrl;
     let pendingUiAttached = !!(boot.uiAttached ?? boot.ui_attached);
+    /** Consecutive uiAttached=false heartbeats before stopping OpenCode SSE (multi-replica poison). */
+    let consecutiveUiDetached = 0;
+    const UI_DETACHED_STOP_AFTER = 3;
+    const startLiveSseIfNeeded = (reason) => {
+        if (!attachUrl || !opencodeHttpReady || stopLiveSse)
+            return;
+        console.error(`ChimpHands ${reason}`);
+        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,
+        });
+    };
     const syncLiveSse = (attached) => {
-        poster.uiAttached = attached;
         pendingUiAttached = attached;
-        if (!attachUrl)
+        if (!attachUrl) {
+            poster.uiAttached = attached;
             return;
+        }
         if (!opencodeHttpReady) {
+            // Defer SSE; still track intent so first sync after ready is correct.
+            poster.uiAttached = attached;
             if (attached) {
                 console.error("ChimpHands UI attached — deferring OpenCode SSE until serve is ready");
             }
             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,
-            });
+        if (attached) {
+            consecutiveUiDetached = 0;
+            // Allow liveStream immediately when heartbeat says attached.
+            poster.uiAttached = true;
+            startLiveSseIfNeeded("UI attached — starting OpenCode SSE fanout");
+            return;
         }
-        else if (!attached && stopLiveSse) {
-            console.error("ChimpHands UI detached — stopping OpenCode SSE fanout");
+        // Detached / async: hysteresis avoids flap from cross-replica heartbeats.
+        // Keep poster.uiAttached true + SSE up during the window so we don't drop
+        // live tokens while the UI is still actually listening on another replica.
+        consecutiveUiDetached += 1;
+        if (consecutiveUiDetached < UI_DETACHED_STOP_AFTER)
+            return;
+        poster.uiAttached = false;
+        if (stopLiveSse) {
+            console.error(`ChimpHands UI detached for ${consecutiveUiDetached} heartbeats — stopping OpenCode SSE fanout`);
             stopLiveSse();
             stopLiveSse = null;
         }
@@ -1186,30 +1335,6 @@ export async function runChimphands(opts) {
     const conversationSummary = bootStr(boot, "conversation_summary", "conversationSummary");
     let workingBranch = bootStr(boot, "working_branch", "workingBranch") || undefined;
     let pullRequestUrl = bootStr(boot, "pull_request_url", "pullRequestUrl") || undefined;
-    const exportSignedUrl = bootStr(boot, "opencode_export_signed_url", "opencodeExportSignedUrl");
-    if (exportSignedUrl && attachUrl) {
-        try {
-            const importedId = await importOpencodeExportFromUrl(exportSignedUrl);
-            if (importedId) {
-                opencodeSessionId = importedId;
-                console.error(`ChimpHands rehydrated OpenCode session from export: ${importedId}`);
-            }
-        }
-        catch (err) {
-            console.error(`ChimpHands export import failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    const snapshotExport = async () => {
-        const sid = opencodeSessionId?.trim();
-        if (!sid)
-            return;
-        try {
-            await putOpencodeExport(backend, apiKey, sessionId, sid);
-        }
-        catch (err) {
-            console.error(`ChimpHands export snapshot failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    };
     noteWorkingBranch = (branch, prUrl) => {
         const normalizedBranch = branch.trim();
         if (!normalizedBranch)
@@ -1309,7 +1434,6 @@ export async function runChimphands(opts) {
         }
         await commitAndPushDirtyWorktree("chimphands: commit before session idle/shutdown");
         await poster.flush();
-        await snapshotExport();
         if (runtimeId) {
             await postJson(backend, apiKey, "/api/chimphands/complete_runtime", {
                 runtimeId,
@@ -1320,10 +1444,22 @@ export async function runChimphands(opts) {
     try {
         poster.fireAndForget(ROLE_STATUS, "Agent ready", { status: STATUS_RUNNING });
         let prompt = normalizeUserMessage(promptInput || bootStr(boot, "initial_prompt", "initialPrompt"));
+        // Bootstrap sets initialPrompt from the last pending user message AND returns
+        // pendingUserMessages — enqueue only messages that are not the initial prompt
+        // (otherwise the same turn runs twice: session=new then session=ses_…).
         const pending = boot.pending_user_messages || boot.pendingUserMessages || [];
+        const initialNorm = normalizeUserMessage(prompt);
         for (const m of pending) {
-            if (m?.content)
-                enqueueUserMessage({ content: m.content });
+            const content = normalizeUserMessage(m?.content || "");
+            if (!content)
+                continue;
+            if (initialNorm && content === initialNorm)
+                continue;
+            const id = ("id" in m && m.id) ||
+                ("message_id" in m && m.message_id) ||
+                ("messageId" in m && m.messageId) ||
+                undefined;
+            enqueueUserMessage({ id: id || undefined, content });
         }
         const waitForNextPrompt = () => new Promise((resolve) => {
             let lastPollAt = 0;
@@ -1397,6 +1533,24 @@ export async function runChimphands(opts) {
             if (result.opencodeSessionId) {
                 opencodeSessionId = result.opencodeSessionId;
             }
+            // Turn-end durable reconcile into PG (idempotent messageIds). Mid-turn was
+            // ephemeral-only when UI attached; async runs get their transcript here.
+            // Also reconcile on failure so partial assistant/tool output is not lost.
+            if (attachUrl && opencodeSessionId) {
+                try {
+                    await reconcileOpencodeSessionMessages(attachUrl, opencodeSessionId, (role, content, opts) => {
+                        void poster.enqueue(role, content, {
+                            ...opts,
+                            opencodeSessionId,
+                            // Explicitly not liveStream → always durable post_agent_event.
+                        });
+                    }, noteWorkingBranch);
+                    await poster.flush();
+                }
+                catch (err) {
+                    console.error(`ChimpHands turn-end reconcile failed: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
             if (result.code !== 0) {
                 const errMsg = (result.err || "opencode failed").trim() || "opencode failed";
                 console.error(`ChimpHands OpenCode failed: ${errMsg}`);
@@ -1422,7 +1576,6 @@ export async function runChimphands(opts) {
                 break;
             }
             postEvent(ROLE_STATUS, "Waiting for user input", { status: STATUS_WAITING_USER });
-            await snapshotExport();
             lastUserActivity = Date.now();
             idle = false;
             prompt = (await waitForNextPrompt()) || "";
@@ -1453,7 +1606,9 @@ function startRuntimeHeartbeat(backend, apiKey, runtimeId, onUiAttached) {
             try {
                 const data = JSON.parse(text);
                 const attached = !!(data.uiAttached ?? data.ui_attached);
-                if (attached !== lastAttached) {
+                // Always notify on false so syncLiveSse can accumulate detach hysteresis;
+                // still skip duplicate true→true noise.
+                if (attached !== lastAttached || !attached) {
                     lastAttached = attached;
                     onUiAttached?.(attached);
                 }
@@ -1536,61 +1691,6 @@ async function commitAndPushDirtyWorktree(message) {
         console.error(`ChimpHands commit-before-idle failed: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
-async function putOpencodeExport(backend, apiKey, sessionId, opencodeSessionId) {
-    const exported = await new Promise((resolve, reject) => {
-        const child = spawn("opencode", ["export", opencodeSessionId], {
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        let out = "";
-        let err = "";
-        child.stdout.on("data", (d) => {
-            out += d.toString();
-        });
-        child.stderr.on("data", (d) => {
-            err += d.toString();
-        });
-        child.on("close", (code) => {
-            if (code === 0 && out.trim())
-                resolve(out);
-            else
-                reject(new Error(err.trim() || `opencode export exited ${code}`));
-        });
-    });
-    const exportBase64 = Buffer.from(exported, "utf8").toString("base64");
-    await postJson(backend, apiKey, "/api/chimphands/put_opencode_export", {
-        sessionId,
-        exportBase64,
-    });
-}
-async function importOpencodeExportFromUrl(signedUrl) {
-    const res = await fetch(signedUrl);
-    if (!res.ok) {
-        throw new Error(`download export failed: ${res.status}`);
-    }
-    const text = await res.text();
-    writeFileSync("/tmp/chimphands-opencode-export.json", text, "utf8");
-    return await new Promise((resolve, reject) => {
-        const child = spawn("opencode", ["import", "/tmp/chimphands-opencode-export.json"], {
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        let out = "";
-        let err = "";
-        child.stdout.on("data", (d) => {
-            out += d.toString();
-        });
-        child.stderr.on("data", (d) => {
-            err += d.toString();
-        });
-        child.on("close", (code) => {
-            if (code !== 0) {
-                reject(new Error(err.trim() || `opencode import exited ${code}`));
-                return;
-            }
-            const match = (out + "\n" + err).match(/ses_[A-Za-z0-9]+/);
-            resolve(match?.[0]);
-        });
-    });
-}
 function startTunnelWorker(backend, apiKey, runtimeId, attachUrl) {
     let stopped = false;
     const base = attachUrl.replace(/\/$/, "");

package/package.json

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