@testchimp/cli 0.1.72 → 0.1.76

package/dist/chimphands/run.js

@@ -1048,8 +1048,10 @@ function isAssistantEchoOfSentPrompt(assistant, ...sentPrompts) {
     }
     return false;
 }
+/** First line of host-injected OpenCode prompts — UI filters on this marker. */
+const HOST_PROMPT_WRAPPER_MARKER = "[[[chimphands.host_prompt.v1]]]";
 function wrapPromptWithContext(conversationSummary, userPrompt, isNewOpencodeSession, workingBranch, pullRequestUrl, baseBranch) {
-    const parts = [];
+    const parts = [HOST_PROMPT_WRAPPER_MARKER];
     if (baseBranch?.trim()) {
         parts.push("## Base branch (parent — do NOT commit here)", `Base branch: \`${baseBranch.trim()}\``, "Create a `testchimp-*` branch from this parent before any file edits. PRs must target this base branch.", "");
     }
@@ -1062,11 +1064,11 @@ function wrapPromptWithContext(conversationSummary, userPrompt, isNewOpencodeSes
     // 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");
+        return parts.filter((p) => p !== "").join("\n");
     }
-    if (parts.length) {
+    if (parts.length > 1) {
         parts.push(`Current task:\n${task}`);
-        return parts.filter(Boolean).join("\n");
+        return parts.filter((p) => p !== "").join("\n");
     }
     return task;
 }
@@ -2387,10 +2389,20 @@ 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) {
+            // Checkpoint dirty worktree before unlocking the UI so Files (GitHub tip
+            // of workingBranch) matches what the user sees when WAITING_USER lands.
+            await commitAndPushDirtyWorktree("chimphands: commit after turn");
+            if (attachUrl && opencodeSessionId && midTurnInjectedById.size) {
+                try {
+                    await releaseUnansweredMidTurnMessages(attachUrl, opencodeSessionId, midTurnInjectedById, queue, wakePromptWaiter, midTurnSidecarAnswered);
+                }
+                catch (err) {
+                    console.error(`ChimpHands mid-turn steering release failed: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            const reconcileTurn = async () => {
+                if (!attachUrl || !opencodeSessionId)
+                    return;
                 try {
                     await reconcileOpencodeSessionMessages(attachUrl, opencodeSessionId, (role, content, opts) => {
                         turnPostEvent(role, content, {
@@ -2404,18 +2416,7 @@ export async function runChimphands(opts) {
                 catch (err) {
                     console.error(`ChimpHands turn-end reconcile failed: ${err instanceof Error ? err.message : String(err)}`);
                 }
-            }
-            // Always checkpoint dirty worktree after each turn so PR + Files pane
-            // (GitHub compare) stay current whether or not a browser UI is attached.
-            await commitAndPushDirtyWorktree("chimphands: commit after turn");
-            if (attachUrl && opencodeSessionId && midTurnInjectedById.size) {
-                try {
-                    await releaseUnansweredMidTurnMessages(attachUrl, opencodeSessionId, midTurnInjectedById, queue, wakePromptWaiter, midTurnSidecarAnswered);
-                }
-                catch (err) {
-                    console.error(`ChimpHands mid-turn steering release failed: ${err instanceof Error ? err.message : String(err)}`);
-                }
-            }
+            };
             if (result.code !== 0 && !result.cancelled) {
                 const errMsg = (result.err || "opencode failed").trim() || "opencode failed";
                 console.error(`ChimpHands OpenCode failed: ${errMsg}`);
@@ -2437,16 +2438,25 @@ export async function runChimphands(opts) {
                     postEvent(ROLE_STATUS, errMsg, { status: STATUS_FAILED });
                     await complete(STATUS_FAILED, errMsg);
                 }
+                // Persist partial transcript even on failure (after push / status report).
+                await reconcileTurn();
                 exitCode = result.code || 1;
                 break;
             }
+            const waitingOpts = {
+                status: STATUS_WAITING_USER,
+                ...(workingBranch ? { workingBranch } : {}),
+                ...(pullRequestUrl ? { pullRequestUrl } : {}),
+            };
             if (result.cancelled) {
-                postEvent(ROLE_STATUS, "Turn stopped", { status: STATUS_WAITING_USER });
+                postEvent(ROLE_STATUS, "Turn stopped", waitingOpts);
             }
             else {
-                postEvent(ROLE_STATUS, "Waiting for user input", { status: STATUS_WAITING_USER });
+                postEvent(ROLE_STATUS, "Waiting for user input", waitingOpts);
             }
             await poster.flush();
+            // Durable reconcile after unlock so Interrupt→Send is not blocked on PG writes.
+            await reconcileTurn();
             lastUserActivity = Date.now();
             idle = false;
             prompt = (await waitForNextPrompt()) || "";
@@ -2499,6 +2509,39 @@ function startRuntimeHeartbeat(backend, apiKey, runtimeId, onUiAttached) {
         stopped = true;
     };
 }
+/** Paths ChimpHands writes on the runner — never commit into the agent branch. */
+const CHIMPHANDS_COMMIT_EXCLUDE_PATHSPECS = [
+    ":(exclude)opencode.json",
+    ":(exclude)opencode-server.log",
+    ":(exclude)chimphands-run.log",
+    ":(exclude)remote-branches.txt",
+    ":(exclude)remote-branch-names.txt",
+    ":(exclude)gha-creds*",
+    ":(exclude)**/gha-creds*",
+    ":(exclude).chimphands",
+    ":(exclude).chimphands/**",
+    ":(exclude).agents",
+    ":(exclude).agents/**",
+];
+function isChimpHandsInternalCommitPath(filePath) {
+    let normalized = filePath.replace(/\\/g, "/").toLowerCase();
+    while (normalized.startsWith("./"))
+        normalized = normalized.slice(2);
+    const slash = normalized.lastIndexOf("/");
+    const name = slash >= 0 ? normalized.slice(slash + 1) : normalized;
+    if (name === "opencode.json" ||
+        name === "opencode-server.log" ||
+        name === "chimphands-run.log" ||
+        name === "remote-branches.txt" ||
+        name === "remote-branch-names.txt" ||
+        name.startsWith("gha-creds")) {
+        return true;
+    }
+    return (normalized === ".chimphands" ||
+        normalized.startsWith(".chimphands/") ||
+        normalized === ".agents" ||
+        normalized.startsWith(".agents/"));
+}
 /** Commit+push dirty worktree on the session agent branch before idle/teardown. */
 async function commitAndPushDirtyWorktree(message) {
     const run = (args, env) => runGit(args, env);
@@ -2527,12 +2570,50 @@ async function commitAndPushDirtyWorktree(message) {
         if (!status.out.trim()) {
             return { ok: true };
         }
-        const add = await run(["add", "-A"]);
+        const add = await run([
+            "add",
+            "-A",
+            "--",
+            ".",
+            ...CHIMPHANDS_COMMIT_EXCLUDE_PATHSPECS,
+        ]);
         if (add.code !== 0) {
             const error = add.err || add.out || "git add failed";
             console.error(`ChimpHands git add failed: ${error}`);
             return { ok: false, error };
         }
+        // Drop already-tracked scaffolding that may still be staged from older commits.
+        await run([
+            "reset",
+            "-q",
+            "HEAD",
+            "--",
+            "opencode.json",
+            "opencode-server.log",
+            "chimphands-run.log",
+            "remote-branches.txt",
+            "remote-branch-names.txt",
+            ".chimphands",
+            ".agents",
+        ]);
+        const staged = await run(["diff", "--cached", "--name-only"]);
+        if (staged.code !== 0) {
+            const error = staged.err || staged.out || "git diff --cached failed";
+            console.error(`ChimpHands git staged check failed: ${error}`);
+            return { ok: false, error };
+        }
+        const stagedPaths = staged.out
+            .split("\n")
+            .map((line) => line.trim())
+            .filter(Boolean);
+        const internalStaged = stagedPaths.filter(isChimpHandsInternalCommitPath);
+        if (internalStaged.length) {
+            await run(["reset", "-q", "HEAD", "--", ...internalStaged]);
+        }
+        const keepStaged = stagedPaths.filter((p) => !isChimpHandsInternalCommitPath(p));
+        if (!keepStaged.length) {
+            return { ok: true };
+        }
         const commitEnv = {
             GIT_AUTHOR_NAME: process.env.GIT_AUTHOR_NAME || "ChimpHands",
             GIT_AUTHOR_EMAIL: process.env.GIT_AUTHOR_EMAIL || "chimphands@testchimp.io",
@@ -2682,11 +2763,31 @@ function startTunnelWorker(backend, apiKey, runtimeId, attachUrl, sessionId, han
             }
         };
         try {
+            // Prefer JSON for workspace-scoped APIs — OpenCode SPA fallback is text/html.
+            if (opencodeProxyNeedsDirectory(pathPart) && !headers.Accept && !headers.accept) {
+                headers.Accept = "application/json";
+            }
             const upstream = await fetch(target, init);
             const respHeaders = {};
             upstream.headers.forEach((v, k) => {
                 respHeaders[k] = v;
             });
+            const contentType = String(respHeaders["content-type"] || respHeaders["Content-Type"] || "").toLowerCase();
+            // Root-cause: never tunnel OpenCode SPA HTML as a successful VCS/API response.
+            if (opencodeProxyNeedsDirectory(pathPart) &&
+                contentType.includes("text/html")) {
+                const msg = `OpenCode returned HTML SPA shell for ${pathPart} ` +
+                    "(expected JSON API; check directory routing / API path)";
+                console.error(`ChimpHands ${msg}`);
+                send({
+                    type: "http_response",
+                    requestId,
+                    status: 502,
+                    headers: { "Content-Type": "text/plain; charset=utf-8" },
+                    bodyBase64: Buffer.from(msg, "utf8").toString("base64"),
+                });
+                return;
+            }
             send({
                 type: "http_response_start",
                 requestId,

package/package.json

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