@testchimp/cli 0.1.73 → 0.1.77

package/dist/chimphands/run.js

@@ -6,6 +6,7 @@
 import { execSync, spawn } from "node:child_process";
 import { mkdirSync, openSync, writeFileSync } from "node:fs";
 import fs from "node:fs/promises";
+import { tmpdir } from "node:os";
 import path from "node:path";
 import http from "node:http";
 import https from "node:https";
@@ -15,6 +16,9 @@ import { isChimphandsLlmRetryEnabled, startLlmRetryProxy } from "./llmRetryProxy
 import { midTurnSteeringKey, releaseUnansweredMidTurnMessages, } from "./midTurnSteering.js";
 import { runSteeringSidecarReply } from "./steeringSidecar.js";
 import { ensureAgentSessionBranch, ensurePullRequest, isAgentBranchName, isPrOnlyMode, resolveSessionBaseBranch, runGit, } from "./agentBranch.js";
+import { isChimpHandsInternalCommitPath, resolveCommitPaths, } from "./worktreeCommitPaths.js";
+/** Runner logs live outside the git worktree so they never enter commit status. */
+const OPENCODE_SERVER_LOG_PATH = path.join(tmpdir(), "chimphands-opencode-server.log");
 const ROLE_ASSISTANT = "CHIMPHANDS_MESSAGE_ROLE_ASSISTANT";
 const ROLE_TOOL = "CHIMPHANDS_MESSAGE_ROLE_TOOL";
 const ROLE_REASONING = "CHIMPHANDS_MESSAGE_ROLE_REASONING";
@@ -98,7 +102,7 @@ const CHIMPHANDS_AGENT_PROMPT = `You are ChimpHands, TestChimp's coding agent. Y
 
 ## CI runner hygiene (GitHub Actions)
 - On hosted runners: load skill \`references/chimphands-ci-runner.md\` before compile, Docker builds, or large installs.
-- Never \`git fetch origin\` (full fetch) — shallow single-branch fetch only; branch names are in \`.chimphands/remote-branch-names.txt\`.
+- Never \`git fetch origin\` (full fetch) — shallow single-branch fetch only; branch names are in \`/tmp/chimphands/remote-branch-names.txt\` (or \`$CHIMPHANDS_REMOTE_BRANCH_NAMES\`).
 - Reclaim disk between heavy phases (\`docker builder prune -af\` after image builds, stop compile daemons, delete temp/test artifacts). One reclaim+retry on ENOSPC — no blind loops.
 
 ## Honesty
@@ -1048,8 +1052,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 +1068,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;
 }
@@ -1310,7 +1316,7 @@ async function restartLocalOpencodeServer(attachUrl) {
     const port = u.port || (u.protocol === "https:" ? "443" : "80");
     killListenersOnPort(port);
     await sleep(300);
-    const logFd = openSync("opencode-server.log", "a");
+    const logFd = openSync(OPENCODE_SERVER_LOG_PATH, "a");
     const child = spawn("opencode", ["serve", "--port", port, "--hostname", hostname], {
         detached: true,
         stdio: ["ignore", logFd, logFd],
@@ -1325,6 +1331,7 @@ async function restartLocalOpencodeServer(attachUrl) {
             /* best effort */
         }
     }
+    console.error(`ChimpHands opencode serve log: ${OPENCODE_SERVER_LOG_PATH}`);
     console.error(`ChimpHands restarted OpenCode serve on ${hostname}:${port} (pid ${child.pid ?? "?"})`);
     await waitForOpencodeHttp(attachUrl, 60_000);
 }
@@ -1625,8 +1632,13 @@ async function ackWorktreeFileWrite(backend, apiKey, sessionId, requestId, ok, e
         requestId,
         ok,
     };
-    if (errorMessage)
-        body.errorMessage = errorMessage.slice(0, 2000);
+    if (errorMessage) {
+        body.errorMessage = errorMessage
+            .replace(/[\r\n\t]+/g, " ")
+            .replace(/ +/g, " ")
+            .trim()
+            .slice(0, 2000);
+    }
     await postJson(backend, apiKey, "/api/chimphands/ack_worktree_file_write", body).catch((err) => {
         console.error(`ChimpHands ack_worktree_file_write failed: ${err instanceof Error ? err.message : String(err)}`);
     });
@@ -1649,7 +1661,9 @@ async function applyUserFileEdit(backend, apiKey, sessionId, edit, turnActive) {
             await ackWorktreeFileWrite(backend, apiKey, sessionId, edit.requestId, true);
             return;
         }
-        const pushed = await commitAndPushDirtyWorktree("User Update");
+        const pushed = await commitAndPushDirtyWorktree("User Update", {
+            paths: [relative],
+        });
         if (!pushed.ok) {
             await ackWorktreeFileWrite(backend, apiKey, sessionId, edit.requestId, false, pushed.error || "commit/push failed");
             return;
@@ -2387,10 +2401,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 +2428,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 +2450,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,8 +2521,15 @@ function startRuntimeHeartbeat(backend, apiKey, runtimeId, onUiAttached) {
         stopped = true;
     };
 }
-/** Commit+push dirty worktree on the session agent branch before idle/teardown. */
-async function commitAndPushDirtyWorktree(message) {
+/**
+ * Commit+push product changes on the session agent branch.
+ *
+ * Policy: allowlist staging from `git status` (never `git add -A` / exclude pathspecs).
+ * Runner scaffolding is filtered out; anything already staged by the agent that is
+ * scaffolding is unstaged before commit. Session logs are written under os.tmpdir(),
+ * not the worktree.
+ */
+async function commitAndPushDirtyWorktree(message, opts) {
     const run = (args, env) => runGit(args, env);
     try {
         const branch = await run(["rev-parse", "--abbrev-ref", "HEAD"]);
@@ -2524,22 +2553,70 @@ async function commitAndPushDirtyWorktree(message) {
             console.error(`ChimpHands git status failed: ${error}`);
             return { ok: false, error };
         }
-        if (!status.out.trim()) {
-            return { ok: true };
+        const toStage = resolveCommitPaths(status.out, opts?.paths);
+        if (toStage.length) {
+            const add = await run(["add", "--", ...toStage]);
+            if (add.code !== 0) {
+                const error = add.err || add.out || "git add failed";
+                console.error(`ChimpHands git add failed: ${error}`);
+                return { ok: false, error };
+            }
         }
-        const add = await run(["add", "-A"]);
-        if (add.code !== 0) {
-            const error = add.err || add.out || "git add failed";
-            console.error(`ChimpHands git add failed: ${error}`);
+        // Drop scaffolding the agent may have staged (git add -A, etc.).
+        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));
+        const pathScoped = !!opts?.paths?.length;
+        if (pathScoped) {
+            if (!toStage.length) {
+                return { ok: true };
+            }
+        }
+        else 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",
             GIT_COMMITTER_NAME: process.env.GIT_COMMITTER_NAME || "ChimpHands",
             GIT_COMMITTER_EMAIL: process.env.GIT_COMMITTER_EMAIL || "chimphands@testchimp.io",
         };
-        const commit = await run(["-c", "user.name=ChimpHands", "-c", "user.email=chimphands@testchimp.io", "commit", "-m", message], commitEnv);
+        // Pathspec form is `git commit --only` — commits just those paths even if
+        // the index has other staged product files.
+        const commitArgs = pathScoped
+            ? [
+                "-c",
+                "user.name=ChimpHands",
+                "-c",
+                "user.email=chimphands@testchimp.io",
+                "commit",
+                "-m",
+                message,
+                "--",
+                ...toStage,
+            ]
+            : [
+                "-c",
+                "user.name=ChimpHands",
+                "-c",
+                "user.email=chimphands@testchimp.io",
+                "commit",
+                "-m",
+                message,
+            ];
+        const commit = await run(commitArgs, commitEnv);
         if (commit.code !== 0) {
             const error = commit.err || commit.out || "git commit failed";
             console.error(`ChimpHands git commit: ${error}`);

package/dist/chimphands/worktreeCommitPaths.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Paths that must not be committed on the agent branch.
+ *
+ * Worktree-resident (needed at runtime, never product):
+ * - opencode.json, .agents/**
+ *
+ * Legacy / accidental worktree pollution (now written under /tmp when possible):
+ * - *.log runner logs, .chimphands/**, remote-branch*.txt, gha-creds*
+ */
+export declare function isChimpHandsInternalCommitPath(filePath: string): boolean;
+/** Parse paths from `git status --porcelain` (newline form, not -z). */
+export declare function pathsFromGitPorcelain(porcelain: string): string[];
+/** Dirty worktree paths that are eligible to commit on the agent branch. */
+export declare function commitCandidatePathsFromPorcelain(porcelain: string): string[];
+export declare function normalizeWorktreePath(filePath: string): string;
+/** Intersect status candidates with an optional path allowlist (e.g. a single UI save). */
+export declare function resolveCommitPaths(porcelain: string, onlyPaths?: string[]): string[];

package/dist/chimphands/worktreeCommitPaths.js

@@ -0,0 +1,72 @@
+/**
+ * Paths that must not be committed on the agent branch.
+ *
+ * Worktree-resident (needed at runtime, never product):
+ * - opencode.json, .agents/**
+ *
+ * Legacy / accidental worktree pollution (now written under /tmp when possible):
+ * - *.log runner logs, .chimphands/**, remote-branch*.txt, gha-creds*
+ */
+export 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/"));
+}
+/** Parse paths from `git status --porcelain` (newline form, not -z). */
+export function pathsFromGitPorcelain(porcelain) {
+    const paths = [];
+    for (const raw of porcelain.split("\n")) {
+        if (!raw || raw.length < 4)
+            continue;
+        let body = raw.slice(3);
+        if (body.includes(" -> ")) {
+            body = body.slice(body.lastIndexOf(" -> ") + 4);
+        }
+        if (body.startsWith('"') && body.endsWith('"')) {
+            body = body
+                .slice(1, -1)
+                .replace(/\\([\\"nt])/g, (_m, c) => {
+                if (c === "n")
+                    return "\n";
+                if (c === "t")
+                    return "\t";
+                return c;
+            });
+        }
+        if (body)
+            paths.push(body);
+    }
+    return paths;
+}
+/** Dirty worktree paths that are eligible to commit on the agent branch. */
+export function commitCandidatePathsFromPorcelain(porcelain) {
+    return pathsFromGitPorcelain(porcelain).filter((p) => !isChimpHandsInternalCommitPath(p));
+}
+export function normalizeWorktreePath(filePath) {
+    let normalized = filePath.replace(/\\/g, "/");
+    while (normalized.startsWith("./"))
+        normalized = normalized.slice(2);
+    return normalized;
+}
+/** Intersect status candidates with an optional path allowlist (e.g. a single UI save). */
+export function resolveCommitPaths(porcelain, onlyPaths) {
+    const candidates = commitCandidatePathsFromPorcelain(porcelain);
+    if (!onlyPaths?.length)
+        return candidates;
+    const want = new Set(onlyPaths.map(normalizeWorktreePath));
+    return candidates.filter((p) => want.has(normalizeWorktreePath(p)));
+}

package/dist/chimphands/worktreeCommitPaths.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/chimphands/worktreeCommitPaths.test.js

@@ -0,0 +1,28 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { commitCandidatePathsFromPorcelain, isChimpHandsInternalCommitPath, pathsFromGitPorcelain, resolveCommitPaths, } from "./worktreeCommitPaths.js";
+describe("worktreeCommitPaths", () => {
+    it("parses porcelain paths and rename destinations", () => {
+        assert.deepEqual(pathsFromGitPorcelain([" M ui/plans/foo.md", "?? chimphands-run.log", "R  old.md -> new.md"].join("\n")), ["ui/plans/foo.md", "chimphands-run.log", "new.md"]);
+    });
+    it("allowlists only product paths for commit", () => {
+        assert.deepEqual(commitCandidatePathsFromPorcelain([
+            " M ui/plans/stories/x.md",
+            "?? chimphands-run.log",
+            "?? opencode-server.log",
+            "?? opencode.json",
+            " M src/app.ts",
+            "?? .agents/skills/testchimp/SKILL.md",
+        ].join("\n")), ["ui/plans/stories/x.md", "src/app.ts"]);
+    });
+    it("can narrow commit to an explicit path set", () => {
+        const porcelain = [" M ui/plans/a.md", " M src/app.ts"].join("\n");
+        assert.deepEqual(resolveCommitPaths(porcelain, ["ui/plans/a.md"]), ["ui/plans/a.md"]);
+        assert.deepEqual(resolveCommitPaths(porcelain), ["ui/plans/a.md", "src/app.ts"]);
+    });
+    it("recognizes internal commit paths", () => {
+        assert.equal(isChimpHandsInternalCommitPath("chimphands-run.log"), true);
+        assert.equal(isChimpHandsInternalCommitPath(".chimphands/tmp"), true);
+        assert.equal(isChimpHandsInternalCommitPath("ui/plans/x.md"), false);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testchimp/cli",
-  "version": "0.1.73",
+  "version": "0.1.77",
   "description": "TestChimp CLI and MCP server — coverage, plans, EaaS, TrueCoverage, API operations (calls /api/mcp/*)",
   "type": "module",
   "main": "dist/bin/testchimp.js",
@@ -13,7 +13,7 @@
   ],
   "scripts": {
     "build": "tsc",
-    "test": "npm run build && node --test dist/chimphands/llmRetryProxy.test.js dist/chimphands/midTurnSteering.test.js dist/chimphands/steeringSidecar.test.js dist/chimphands/agentBranch.test.js",
+    "test": "npm run build && node --test dist/chimphands/llmRetryProxy.test.js dist/chimphands/midTurnSteering.test.js dist/chimphands/steeringSidecar.test.js dist/chimphands/agentBranch.test.js dist/chimphands/worktreeCommitPaths.test.js",
     "watch": "tsc --watch",
     "start": "node dist/bin/testchimp.js",
     "prepublishOnly": "npm run build"