@testchimp/cli 0.1.70 → 0.1.72

package/dist/chimphands/run.js

@@ -25,8 +25,8 @@ const STATUS_IDLE = "CHIMPHANDS_SESSION_STATUS_IDLE";
 const STATUS_FAILED = "CHIMPHANDS_SESSION_STATUS_FAILED";
 const OPENCODE_AGENT_ID = "chimphands";
 const MID_TURN_DELIVERED_STATUS = "Answering your question while the current step continues…";
-/** Coalesce live token fanout (~6–10 posts/s/session) while UI is attached. */
-const STREAM_POST_MIN_INTERVAL_MS = 150;
+/** Coalesce live token fanout (~30fps) on tunnel WS / HTTP fallback while UI is attached. */
+const STREAM_FANOUT_MIN_INTERVAL_MS = 33;
 /** Set for the active ChimpHands session (PR base branch + callbacks). */
 let activeSessionGitContext = null;
 function isStreamFanoutRole(role) {
@@ -69,6 +69,11 @@ const CHIMPHANDS_AGENT_PROMPT = `You are ChimpHands, TestChimp's coding agent. Y
 - When you need clarification (e.g. import plans/tests, env strategy, CI choices) or plan approval: write the questions / plan summary as assistant text, then **stop this turn**. Do not invent answers or continue into Execute. The host will wait for the next chat message and revive you.
 - Prefer a short numbered list of concrete questions over a long monologue. One decision gate at a time when possible (especially \`/testchimp project init\` Phase 1).
 
+## Paths (mandatory)
+- Process cwd **is** the git worktree root. On GitHub Actions that is \`$GITHUB_WORKSPACE\`, which looks like \`/home/runner/work/<repo>/<repo>\` — the repeated folder name is the normal Actions layout, **not** a nested second checkout.
+- User \`ref:\` paths are **repo-relative to cwd** (e.g. \`ref: ui/plans/foo.md\` → open \`ui/plans/foo.md\` from cwd). Never prepend the repository name. Never open or create \`<repo>/<repo>/…\` under cwd. Never treat \`/home/runner/work\` (the parent of the twin) as the worktree root.
+- If a tool returns an absolute path under cwd, relativize with the worktree root before reusing it. Do **not** strip a leading \`/\` and re-join under cwd — that nests the workspace path inside itself.
+
 ## Repo changes (mandatory)
 - NEVER commit or push directly to the default branch (main/master) or to a user **base branch** (the \`Base branch:\` line in the prompt is the parent to branch *from*, not where you commit).
 - This conversation uses ONE **agent branch** (\`testchimp-*\` only) and ONE pull request targeting the base branch. Reuse them for all follow-up work in this chat.
@@ -162,23 +167,42 @@ async function postJson(backend, apiKey, path, body) {
         clearTimeout(timer);
     }
 }
-/** Serializes agent event posts so streaming chunks fan out in order. */
+/** Serializes durable agent event posts; live mid-turn tokens prefer the agent tunnel WS. */
 class AgentEventPoster {
     backend;
     apiKey;
     sessionId;
     chain = Promise.resolve();
-    lastStreamPostAt = 0;
+    lastLiveFanoutAt = 0;
     /** When false, liveStream tokens are dropped; completed events still persist. */
     uiAttached = false;
+    /**
+     * Prefer agent tunnel WS for live tokens. Returns true when the frame was queued on an open socket.
+     * Set by {@link startTunnelWorker} once the runtime tunnel is connected.
+     */
+    sendUiMessage = null;
     ephemeralFailLogAt = 0;
     ephemeralFailCount = 0;
+    /** Latest pending live snapshot per messageId (coalesce-to-latest). */
+    pendingLive = new Map();
+    liveFlushTimer = null;
+    liveFlushInFlight = false;
     constructor(backend, apiKey, sessionId) {
         this.backend = backend;
         this.apiKey = apiKey;
         this.sessionId = sessionId;
     }
     enqueue(role, content, opts) {
+        const streamRole = isStreamFanoutRole(role);
+        const live = !!opts?.liveStream && !opts?.durable;
+        // Mid-turn tokens: coalesce + WS (HTTP fallback). Never hit the durable chain.
+        if (live && streamRole) {
+            if (!this.uiAttached) {
+                return Promise.resolve();
+            }
+            this.enqueueLive(role, content, opts);
+            return Promise.resolve();
+        }
         const body = {
             sessionId: this.sessionId,
             role,
@@ -196,48 +220,95 @@ class AgentEventPoster {
             body.pullRequestUrl = opts.pullRequestUrl;
         if (opts?.toolExecution)
             body.toolExecution = protoJsonToolExecution(opts.toolExecution);
-        const streamRole = isStreamFanoutRole(role);
         this.chain = this.chain.then(async () => {
-            const live = !!opts?.liveStream && !opts?.durable;
-            // Mid-turn tokens never hit PG. Async / detached: drop. Attached: ephemeral only.
-            if (live && !this.uiAttached) {
-                return;
+            await postJson(this.backend, this.apiKey, "/api/chimphands/post_agent_event", body);
+        });
+        return this.chain;
+    }
+    enqueueLive(role, content, opts) {
+        const key = (opts?.messageId || "").trim() || `${role}:default`;
+        this.pendingLive.set(key, { role, content: String(content || "").slice(0, 20000), opts });
+        this.scheduleLiveFlush();
+    }
+    scheduleLiveFlush() {
+        if (this.liveFlushInFlight || this.liveFlushTimer)
+            return;
+        const wait = Math.max(0, STREAM_FANOUT_MIN_INTERVAL_MS - (Date.now() - this.lastLiveFanoutAt));
+        this.liveFlushTimer = setTimeout(() => {
+            this.liveFlushTimer = null;
+            void this.flushLivePending();
+        }, wait);
+    }
+    async flushLivePending() {
+        if (this.liveFlushInFlight)
+            return;
+        if (this.pendingLive.size === 0)
+            return;
+        if (!this.uiAttached) {
+            this.pendingLive.clear();
+            return;
+        }
+        this.liveFlushInFlight = true;
+        try {
+            const batch = [...this.pendingLive.values()];
+            this.pendingLive.clear();
+            this.lastLiveFanoutAt = Date.now();
+            for (const item of batch) {
+                await this.deliverLive(item.role, item.content, item.opts);
             }
-            if (opts?.throttle || (streamRole && live)) {
-                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 = live && 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;
-                if (opts?.toolExecution)
-                    eph.toolExecution = protoJsonToolExecution(opts.toolExecution);
-                try {
-                    await postJson(this.backend, this.apiKey, "/api/chimphands/post_ephemeral_agent_event", eph);
+        }
+        finally {
+            this.liveFlushInFlight = false;
+            if (this.pendingLive.size > 0 && this.uiAttached) {
+                this.scheduleLiveFlush();
+            }
+        }
+    }
+    async deliverLive(role, content, opts) {
+        const frame = {
+            type: "ui_message",
+            sessionId: this.sessionId,
+            role,
+            content,
+        };
+        if (opts?.messageId)
+            frame.messageId = opts.messageId;
+        if (opts?.toolExecution)
+            frame.toolExecution = protoJsonToolExecution(opts.toolExecution);
+        if (this.sendUiMessage) {
+            try {
+                if (this.sendUiMessage(frame)) {
                     this.ephemeralFailCount = 0;
+                    return;
                 }
-                catch (err) {
-                    const detail = err instanceof Error ? err.message : String(err);
-                    this.logEphemeralIssue(`ephemeral post failed — not persisting liveStream: ${detail}`);
-                }
-                return;
             }
-            await postJson(this.backend, this.apiKey, "/api/chimphands/post_agent_event", body);
-        });
-        return this.chain;
+            catch (err) {
+                const detail = err instanceof Error ? err.message : String(err);
+                this.logEphemeralIssue(`tunnel ui_message send failed — falling back to HTTP: ${detail}`);
+            }
+        }
+        // HTTP ephemeral fallback when tunnel is down / unavailable.
+        const eph = {
+            sessionId: this.sessionId,
+            role,
+            content,
+        };
+        if (opts?.messageId)
+            eph.messageId = opts.messageId;
+        if (opts?.opencodeSessionId)
+            eph.opencodeSessionId = opts.opencodeSessionId;
+        if (opts?.toolExecution)
+            eph.toolExecution = protoJsonToolExecution(opts.toolExecution);
+        try {
+            await postJson(this.backend, this.apiKey, "/api/chimphands/post_ephemeral_agent_event", eph);
+            this.ephemeralFailCount = 0;
+        }
+        catch (err) {
+            const detail = err instanceof Error ? err.message : String(err);
+            this.logEphemeralIssue(`ephemeral post failed — not persisting liveStream: ${detail}`);
+        }
     }
-    /** Avoid flooding GHA logs when ephemeral 500s every ~150ms. */
+    /** Avoid flooding GHA logs when live fanout fails repeatedly. */
     logEphemeralIssue(message) {
         this.ephemeralFailCount += 1;
         const now = Date.now();
@@ -254,7 +325,11 @@ class AgentEventPoster {
         });
     }
     flush() {
-        return this.chain;
+        if (this.liveFlushTimer) {
+            clearTimeout(this.liveFlushTimer);
+            this.liveFlushTimer = null;
+        }
+        return this.flushLivePending().then(() => this.chain);
     }
     reportWorkingBranch(branch, pullRequestUrl) {
         this.chain = this.chain.then(async () => {
@@ -1497,12 +1572,36 @@ function runOpencode(prompt, model, childEnv, opencodeSessionId, callbacks, atta
         });
     });
 }
-function normalizeWorktreeRelativePath(filePath) {
-    let p = String(filePath || "").trim().replace(/\\/g, "/");
+function normalizeWorktreeRelativePath(filePath, worktreeRoot = process.cwd()) {
+    const rootResolved = path.resolve(worktreeRoot);
+    const rawInput = String(filePath || "").trim();
+    if (!rawInput || rawInput.includes("\0")) {
+        throw new Error("invalid path");
+    }
+    // Absolute path under the worktree → repo-relative (never strip "/" then re-join).
+    if (path.isAbsolute(rawInput)) {
+        const abs = path.resolve(rawInput);
+        if (abs === rootResolved) {
+            throw new Error("invalid path");
+        }
+        if (abs.startsWith(rootResolved + path.sep)) {
+            return path.relative(rootResolved, abs).split(path.sep).join("/");
+        }
+    }
+    let p = rawInput.replace(/\\/g, "/");
     while (p.startsWith("/"))
         p = p.slice(1);
-    if (!p || p.includes("\0")) {
-        throw new Error("invalid path");
+    // GHA workspace is /home/runner/work/<repo>/<repo>. Strip twin prefixes that agents/OpenCode
+    // sometimes emit as if relative to /home/runner/work.
+    const base = path.basename(rootResolved);
+    const parentBase = path.basename(path.dirname(rootResolved));
+    if (base && base === parentBase) {
+        const twin = `${base}/${base}/`;
+        const gha = `home/runner/work/${base}/${base}/`;
+        if (p.startsWith(gha))
+            p = p.slice(gha.length);
+        else if (p.startsWith(twin))
+            p = p.slice(twin.length);
     }
     const segments = [];
     for (const part of p.split("/")) {
@@ -1533,10 +1632,8 @@ async function ackWorktreeFileWrite(backend, apiKey, sessionId, requestId, ok, e
     });
 }
 async function applyUserFileEdit(backend, apiKey, sessionId, edit, turnActive) {
-    if (turnActive()) {
-        await ackWorktreeFileWrite(backend, apiKey, sessionId, edit.requestId, false, "agent turn in progress");
-        return;
-    }
+    // Never hard-nack mid-turn: write to disk immediately so the next agent prompt
+    // sees the edit. Defer commit/push while a turn is active — post-turn always commits.
     try {
         const relative = normalizeWorktreeRelativePath(edit.path);
         const root = process.cwd();
@@ -1547,6 +1644,11 @@ async function applyUserFileEdit(backend, apiKey, sessionId, edit, turnActive) {
         }
         await fs.mkdir(path.dirname(full), { recursive: true });
         await fs.writeFile(full, edit.content, "utf8");
+        if (turnActive()) {
+            console.error(`ChimpHands applied user_file_edit mid-turn (deferred commit): ${relative}`);
+            await ackWorktreeFileWrite(backend, apiKey, sessionId, edit.requestId, true);
+            return;
+        }
         const pushed = await commitAndPushDirtyWorktree("User Update");
         if (!pushed.ok) {
             await ackWorktreeFileWrite(backend, apiKey, sessionId, edit.requestId, false, pushed.error || "commit/push failed");
@@ -2099,11 +2201,16 @@ export async function runChimphands(opts) {
         void pollPendingUserMessages();
     }, 1500);
     if (runtimeId && attachUrl) {
-        stopTunnel = startTunnelWorker(backend, apiKey, runtimeId, attachUrl, sessionId, {
+        const tunnel = startTunnelWorker(backend, apiKey, runtimeId, attachUrl, sessionId, {
             onUserFileEdit: handleUserFileEdit,
             onCancelTurn: handleCancelTurn,
             onUserMessage: enqueueUserMessage,
         });
+        poster.sendUiMessage = (frame) => tunnel.sendUiMessage(frame);
+        stopTunnel = () => {
+            poster.sendUiMessage = null;
+            tunnel.stop();
+        };
     }
     const shutdownRuntime = async () => {
         sessionActive = false;
@@ -2298,11 +2405,9 @@ export async function runChimphands(opts) {
                     console.error(`ChimpHands turn-end reconcile failed: ${err instanceof Error ? err.message : String(err)}`);
                 }
             }
-            // Async / no UI: checkpoint dirty worktree after each turn so PR + Files changed
-            // are reviewable when the user opens the session later (live VCS tunnel may be idle).
-            if (!poster.uiAttached) {
-                await commitAndPushDirtyWorktree("chimphands: commit after turn (async / no UI attached)");
-            }
+            // 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);
@@ -2531,6 +2636,18 @@ function startTunnelWorker(backend, apiKey, runtimeId, attachUrl, sessionId, han
             reconnectTimer = null;
         }
     };
+    const sendUiMessage = (frame) => {
+        const socket = ws;
+        if (!socket || socket.readyState !== 1)
+            return false;
+        try {
+            socket.send(JSON.stringify(frame));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
     const handleHttpRequest = async (socket, req) => {
         if (!req.requestId || socket.readyState !== 1)
             return;
@@ -2710,18 +2827,21 @@ function startTunnelWorker(backend, apiKey, runtimeId, attachUrl, sessionId, han
         });
     };
     void connect();
-    return () => {
-        stopped = true;
-        clearReconnect();
-        if (ws) {
-            try {
-                ws.close();
-            }
-            catch {
-                // ignore
+    return {
+        sendUiMessage,
+        stop: () => {
+            stopped = true;
+            clearReconnect();
+            if (ws) {
+                try {
+                    ws.close();
+                }
+                catch {
+                    // ignore
+                }
+                ws = null;
             }
-            ws = null;
-        }
+        },
     };
 }
 /** Runtime-aware entry: register + attach to local OpenCode server (Phase 1+). */

package/package.json

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