@testchimp/cli 0.1.39 → 0.1.41

package/dist/chimphands/run.d.ts

@@ -3,6 +3,13 @@
  * Relies on TESTCHIMP_API_KEY (+ optional TESTCHIMP_BACKEND_URL; defaults to prod).
  * Does not write mcp.json — TestChimp MCP is wired via opencode.json for OpenCode.
  */
+export type ReportWorkingBranchOptions = {
+    sessionId: string;
+    branch: string;
+    pullRequestUrl?: string;
+};
+/** Agent/CLI hook: persist the conversation working branch (+ optional PR) for UI + later turns. */
+export declare function reportWorkingBranch(opts: ReportWorkingBranchOptions): Promise<void>;
 type RunOptions = {
     sessionId: string;
     prompt?: string;

package/dist/chimphands/run.js

@@ -3,7 +3,7 @@
  * Relies on TESTCHIMP_API_KEY (+ optional TESTCHIMP_BACKEND_URL; defaults to prod).
  * Does not write mcp.json — TestChimp MCP is wired via opencode.json for OpenCode.
  */
-import { spawn, execFileSync } from "node:child_process";
+import { spawn } from "node:child_process";
 import { mkdirSync, writeFileSync } from "node:fs";
 import http from "node:http";
 import https from "node:https";
@@ -11,14 +11,57 @@ import { URL } from "node:url";
 import { getBackendUrl, requireApiKey } from "../core/client.js";
 const ROLE_ASSISTANT = "CHIMPHANDS_MESSAGE_ROLE_ASSISTANT";
 const ROLE_TOOL = "CHIMPHANDS_MESSAGE_ROLE_TOOL";
+const ROLE_REASONING = "CHIMPHANDS_MESSAGE_ROLE_REASONING";
 const ROLE_STATUS = "CHIMPHANDS_MESSAGE_ROLE_STATUS";
 const STATUS_RUNNING = "CHIMPHANDS_SESSION_STATUS_RUNNING";
 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;
+const CHIMPHANDS_AGENT_PROMPT = `You are ChimpHands, TestChimp's cloud coding agent running in GitHub Actions.
+
+## Repo changes (mandatory)
+- NEVER commit or push directly to the default branch (main/master).
+- This conversation uses ONE working branch and ONE pull request. Reuse them for all follow-up work in this chat.
+- If bootstrap lists a working branch, checkout that branch and push additional commits there — update the same PR.
+- Only create a NEW branch/PR when (a) no working branch exists yet for this conversation, or (b) the prior PR was merged/closed (verify with \`gh pr view\`).
+- Branch names MUST start with \`testchimp-\` or \`chimphands-\`.
+- After creating a branch or opening a PR, IMMEDIATELY run:
+  \`testchimp chimphands report-branch --branch <name> [--pr-url <url>]\`
+- Tell the user which branch you are on and include the PR URL when available.
+
+## TestChimp workflows (/testchimp …)
+- Load and follow the \`testchimp\` skill under \`.agents/skills/testchimp/SKILL.md\`.
+- For any /testchimp command: use TestChimp MCP tools (preferred) or \`testchimp\` CLI — never invent API results.
+- Follow plan → explicit user approval → execute. Do not skip MCP calls or claim done without tool evidence.
+- Export \`TESTCHIMP_EXECUTION_SOURCE=CLOUD_AGENT\` before Playwright/Mobilewright runs.
+
+## Honesty
+- If MCP/tools fail, report the error. Never narrate success without tool output or a PR link when repo changes were needed.`;
 function normalizeUserMessage(content) {
     return content.trim();
 }
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/** Agent/CLI hook: persist the conversation working branch (+ optional PR) for UI + later turns. */
+export async function reportWorkingBranch(opts) {
+    const apiKey = requireApiKey();
+    const backend = getBackendUrl();
+    const branch = opts.branch.trim();
+    if (!branch) {
+        throw new Error("branch is required");
+    }
+    const body = {
+        sessionId: opts.sessionId.trim(),
+        workingBranch: branch,
+    };
+    const pr = opts.pullRequestUrl?.trim();
+    if (pr)
+        body.pullRequestUrl = pr;
+    await postJson(backend, apiKey, "/api/chimphands/post_agent_event", body);
+}
 function apiHeaders(apiKey) {
     return {
         "Content-Type": "application/json",
@@ -37,11 +80,70 @@ async function postJson(backend, apiKey, path, body) {
     }
     return text;
 }
-function postJsonFireAndForget(backend, apiKey, path, body) {
-    void postJson(backend, apiKey, path, body).catch((err) => {
-        const detail = err instanceof Error ? err.message : String(err);
-        console.error(`ChimpHands API telemetry failed ${path}: ${detail}`);
-    });
+/** Serializes post_agent_event calls so streaming chunks commit and fan out in order. */
+class AgentEventPoster {
+    backend;
+    apiKey;
+    sessionId;
+    chain = Promise.resolve();
+    lastStreamPostAt = 0;
+    constructor(backend, apiKey, sessionId) {
+        this.backend = backend;
+        this.apiKey = apiKey;
+        this.sessionId = sessionId;
+    }
+    enqueue(role, content, opts) {
+        const body = {
+            sessionId: this.sessionId,
+            role,
+            content: String(content || "").slice(0, 20000),
+        };
+        if (opts?.messageId)
+            body.messageId = opts.messageId;
+        if (opts?.status != null)
+            body.status = opts.status;
+        if (opts?.opencodeSessionId)
+            body.opencodeSessionId = opts.opencodeSessionId;
+        if (opts?.workingBranch)
+            body.workingBranch = opts.workingBranch;
+        if (opts?.pullRequestUrl)
+            body.pullRequestUrl = opts.pullRequestUrl;
+        this.chain = this.chain.then(async () => {
+            if (opts?.throttle) {
+                const now = Date.now();
+                const wait = STREAM_POST_MIN_INTERVAL_MS - (now - this.lastStreamPostAt);
+                if (wait > 0)
+                    await sleep(wait);
+                this.lastStreamPostAt = Date.now();
+            }
+            await postJson(this.backend, this.apiKey, "/api/chimphands/post_agent_event", body);
+        });
+        return this.chain;
+    }
+    fireAndForget(role, content, opts) {
+        void this.enqueue(role, content, opts).catch((err) => {
+            const detail = err instanceof Error ? err.message : String(err);
+            console.error(`ChimpHands API telemetry failed: ${detail}`);
+        });
+    }
+    flush() {
+        return this.chain;
+    }
+    reportWorkingBranch(branch, pullRequestUrl) {
+        this.chain = this.chain.then(async () => {
+            const body = {
+                sessionId: this.sessionId,
+                workingBranch: branch,
+            };
+            if (pullRequestUrl?.trim())
+                body.pullRequestUrl = pullRequestUrl.trim();
+            await postJson(this.backend, this.apiKey, "/api/chimphands/post_agent_event", body);
+        });
+        void this.chain.catch((err) => {
+            const detail = err instanceof Error ? err.message : String(err);
+            console.error(`ChimpHands report-branch failed: ${detail}`);
+        });
+    }
 }
 const TESTCHIMP_PROVIDER_ID = "testchimp";
 function resolveOpencodeModelId(boot) {
@@ -93,10 +195,18 @@ function parseOpencodeEvent(line) {
 }
 function formatToolUseContent(part) {
     const title = part.state?.title || part.tool || "tool";
+    const status = part.state?.status?.trim();
+    const input = part.state?.input;
+    const inputText = input && Object.keys(input).length
+        ? `\nInput: ${JSON.stringify(input).slice(0, 4000)}`
+        : "";
     const output = part.state?.output?.trim();
+    const statusLine = status ? `[${title}] (${status})` : `[${title}]`;
     if (output)
-        return `[${title}]\n${output}`;
-    return `[${title}]`;
+        return `${statusLine}\n${output}`;
+    if (inputText)
+        return `${statusLine}${inputText}`;
+    return statusLine;
 }
 function opencodeMessageId(prefix, part) {
     const raw = part?.id || part?.messageID;
@@ -124,6 +234,42 @@ function summarizeOpencodeFailure(stderr, stdout, exitCode) {
     }
     return exitCode ? `opencode exited with code ${exitCode}` : "opencode failed";
 }
+function isMissingOpencodeSessionError(message) {
+    const m = message.toLowerCase();
+    return ((m.includes("session") && m.includes("not found")) ||
+        m.includes("unknown session") ||
+        m.includes("invalid session"));
+}
+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 (isNewOpencodeSession && conversationSummary.trim()) {
+        parts.push(`Conversation so far:\n${conversationSummary.trim()}`, "", `Current task:\n${task}`);
+        return parts.filter(Boolean).join("\n");
+    }
+    if (parts.length) {
+        parts.push(`Current task:\n${task}`);
+        return parts.filter(Boolean).join("\n");
+    }
+    return task;
+}
+function detectWorkingBranchFromToolOutput(output) {
+    const text = output.trim();
+    if (!text)
+        return {};
+    const prMatch = text.match(/https:\/\/github\.com\/[^\s)\]]+\/pull\/\d+/);
+    const checkoutMatch = text.match(/checkout\s+-b\s+((?:testchimp-|chimphands-)[^\s'"]+)/i);
+    const pushMatch = text.match(/push\s+(?:--set-upstream\s+|-u\s+)?origin\s+((?:testchimp-|chimphands-)[^\s'"]+)/i);
+    const branchMatch = text.match(/branch['":\s]+((?:testchimp-|chimphands-)[^\s'"]+)/i);
+    const branch = (checkoutMatch?.[1] || pushMatch?.[1] || branchMatch?.[1])?.replace(/[`'"]/g, "");
+    return {
+        branch,
+        pullRequestUrl: prMatch?.[0],
+    };
+}
 function writeOpencodeConfig(backend, apiKey, boot) {
     const llmBase = (boot.llm_base_url || `${backend}/v1`).replace(/\/$/, "");
     const llmKey = apiKey || boot.llm_api_key || "";
@@ -132,6 +278,7 @@ function writeOpencodeConfig(backend, apiKey, boot) {
     const mcpEnv = {
         TESTCHIMP_API_KEY: apiKey,
         TESTCHIMP_BACKEND_URL: backend,
+        TESTCHIMP_EXECUTION_SOURCE: "CLOUD_AGENT",
     };
     const serviceUserId = boot.chimphands_service_account_user_id?.trim();
     if (serviceUserId) {
@@ -140,6 +287,7 @@ function writeOpencodeConfig(backend, apiKey, boot) {
     writeFileSync("opencode.json", JSON.stringify({
         $schema: "https://opencode.ai/config.json",
         model,
+        default_agent: OPENCODE_AGENT_ID,
         autoupdate: false,
         provider: {
             [TESTCHIMP_PROVIDER_ID]: {
@@ -156,6 +304,23 @@ function writeOpencodeConfig(backend, apiKey, boot) {
                 },
             },
         },
+        agent: {
+            [OPENCODE_AGENT_ID]: {
+                mode: "primary",
+                description: "TestChimp ChimpHands cloud agent (PR-only repo writes)",
+                prompt: CHIMPHANDS_AGENT_PROMPT,
+                steps: 80,
+                permission: {
+                    skill: "allow",
+                    bash: "allow",
+                    edit: "allow",
+                    read: "allow",
+                },
+            },
+        },
+        skills: {
+            paths: [".agents/skills/testchimp"],
+        },
         mcp: {
             testchimp: {
                 type: "local",
@@ -167,125 +332,144 @@ function writeOpencodeConfig(backend, apiKey, boot) {
     }, null, 2));
     return model;
 }
-function runOpencode(prompt, model, childEnv, postEvent) {
-    const help = (() => {
-        try {
-            return execFileSync("opencode", ["run", "--help"], { encoding: "utf8", env: childEnv });
-        }
-        catch {
-            return "";
-        }
-    })();
-    const useJson = help.includes("--format");
-    const baseArgs = ["run", prompt, "--model", model];
-    if (useJson) {
-        const child = spawn("opencode", [...baseArgs, "--format", "json"], {
-            stdio: ["ignore", "pipe", "pipe"],
-            env: childEnv,
-        });
-        let err = "";
-        child.stderr.on("data", (d) => {
-            err += d.toString();
-        });
-        return new Promise((resolve) => {
-            let buf = "";
-            let fatalError = null;
-            const textByPartId = new Map();
-            const handleOpencodeLine = (line) => {
-                if (!line.trim())
-                    return;
-                const fatal = extractOpencodeFatalError(line);
-                if (fatal) {
-                    fatalError = fatal;
+function buildOpencodeArgs(prompt, model, opencodeSessionId) {
+    const args = ["run", prompt, "--model", model, "--format", "json", "--agent", OPENCODE_AGENT_ID];
+    if (opencodeSessionId?.trim()) {
+        args.push("--session", opencodeSessionId.trim());
+    }
+    return args;
+}
+function runOpencode(prompt, model, childEnv, opencodeSessionId, callbacks) {
+    let activeSessionId = opencodeSessionId?.trim() || undefined;
+    const baseArgs = buildOpencodeArgs(prompt, model, activeSessionId);
+    const child = spawn("opencode", baseArgs, {
+        stdio: ["ignore", "pipe", "pipe"],
+        env: childEnv,
+    });
+    let err = "";
+    child.stderr.on("data", (d) => {
+        err += d.toString();
+    });
+    return new Promise((resolve) => {
+        let buf = "";
+        let fatalError = null;
+        const textByPartId = new Map();
+        const noteSessionId = (sessionId) => {
+            const id = sessionId?.trim();
+            if (!id || id === activeSessionId)
+                return;
+            activeSessionId = id;
+            callbacks.onSessionId?.(id);
+        };
+        const handleOpencodeLine = (line) => {
+            if (!line.trim())
+                return;
+            const fatal = extractOpencodeFatalError(line);
+            if (fatal) {
+                fatalError = fatal;
+                return;
+            }
+            const ev = parseOpencodeEvent(line);
+            if (!ev?.type)
+                return;
+            noteSessionId(ev.sessionID);
+            switch (ev.type) {
+                case "text": {
+                    const chunk = ev.part?.text;
+                    if (!chunk)
+                        return;
+                    const partId = ev.part?.id || ev.part?.messageID;
+                    if (!partId) {
+                        callbacks.postEvent(ROLE_ASSISTANT, chunk, { throttle: true });
+                        return;
+                    }
+                    const next = (textByPartId.get(partId) || "") + chunk;
+                    textByPartId.set(partId, next);
+                    callbacks.postEvent(ROLE_ASSISTANT, next, {
+                        throttle: true,
+                        messageId: opencodeMessageId("oc_text_", ev.part),
+                    });
                     return;
                 }
-                const ev = parseOpencodeEvent(line);
-                if (!ev?.type)
-                    return;
-                switch (ev.type) {
-                    case "text": {
-                        const chunk = ev.part?.text;
-                        if (!chunk)
-                            return;
-                        const partId = ev.part?.id || ev.part?.messageID;
-                        if (!partId) {
-                            postEvent(ROLE_ASSISTANT, chunk);
-                            return;
-                        }
-                        const next = (textByPartId.get(partId) || "") + chunk;
-                        textByPartId.set(partId, next);
-                        postEvent(ROLE_ASSISTANT, next, undefined, opencodeMessageId("oc_text_", ev.part));
+                case "reasoning": {
+                    const chunk = ev.part?.text;
+                    if (!chunk)
                         return;
-                    }
-                    case "tool_use": {
-                        if (ev.part?.state?.status !== "completed")
-                            return;
-                        postEvent(ROLE_TOOL, formatToolUseContent(ev.part), undefined, opencodeMessageId("oc_tool_", ev.part));
+                    const partId = ev.part?.id || ev.part?.messageID;
+                    if (!partId) {
+                        callbacks.postEvent(ROLE_REASONING, chunk, { throttle: true });
                         return;
                     }
-                    case "error": {
-                        const msg = ev.error?.data?.message ||
-                            ev.error?.message ||
-                            line.trim();
-                        if (msg)
-                            fatalError = msg;
+                    const reasoningKey = `reasoning:${partId}`;
+                    const next = (textByPartId.get(reasoningKey) || "") + chunk;
+                    textByPartId.set(reasoningKey, next);
+                    callbacks.postEvent(ROLE_REASONING, next, {
+                        throttle: true,
+                        messageId: opencodeMessageId("oc_reasoning_", ev.part),
+                    });
+                    return;
+                }
+                case "tool_use": {
+                    const status = ev.part?.state?.status;
+                    if (!status || status === "pending")
                         return;
+                    const toolContent = formatToolUseContent(ev.part);
+                    callbacks.postEvent(ROLE_TOOL, toolContent, {
+                        messageId: opencodeMessageId("oc_tool_", ev.part),
+                    });
+                    if (status === "completed") {
+                        const detected = detectWorkingBranchFromToolOutput(toolContent);
+                        if (detected.branch) {
+                            callbacks.onWorkingBranch?.(detected.branch, detected.pullRequestUrl);
+                        }
                     }
-                    case "step_start":
-                    case "step_finish":
-                        return;
-                    default:
-                        return;
-                }
-            };
-            child.stdout.on("data", (chunk) => {
-                buf += chunk.toString();
-                const lines = buf.split("\n");
-                buf = lines.pop() || "";
-                for (const line of lines) {
-                    handleOpencodeLine(line);
-                }
-            });
-            child.on("close", (code) => {
-                if (buf.trim()) {
-                    handleOpencodeLine(buf.trim());
-                }
-                const stderrFatal = extractOpencodeFatalError(err);
-                if (stderrFatal)
-                    fatalError = stderrFatal;
-                if (fatalError) {
-                    resolve({ code: 1, err: fatalError });
                     return;
                 }
-                if (code != null && code !== 0) {
-                    resolve({ code, err: summarizeOpencodeFailure(err, buf, code) });
+                case "error": {
+                    const msg = ev.error?.data?.message ||
+                        ev.error?.message ||
+                        line.trim();
+                    if (msg)
+                        fatalError = msg;
                     return;
                 }
-                resolve({ code: code == null ? 1 : code, err });
-            });
+                case "step_start":
+                case "step_finish":
+                    return;
+                default:
+                    return;
+            }
+        };
+        child.stdout.on("data", (chunk) => {
+            buf += chunk.toString();
+            const lines = buf.split("\n");
+            buf = lines.pop() || "";
+            for (const line of lines) {
+                handleOpencodeLine(line);
+            }
         });
-    }
-    try {
-        const out = execFileSync("opencode", baseArgs, {
-            encoding: "utf8",
-            maxBuffer: 20 * 1024 * 1024,
-            stdio: ["ignore", "pipe", "pipe"],
-            env: childEnv,
+        child.on("close", (code) => {
+            if (buf.trim()) {
+                handleOpencodeLine(buf.trim());
+            }
+            const stderrFatal = extractOpencodeFatalError(err);
+            if (stderrFatal)
+                fatalError = stderrFatal;
+            if (fatalError) {
+                resolve({ code: 1, err: fatalError, opencodeSessionId: activeSessionId });
+                return;
+            }
+            if (code != null && code !== 0) {
+                resolve({
+                    code,
+                    err: summarizeOpencodeFailure(err, buf, code),
+                    opencodeSessionId: activeSessionId,
+                });
+                return;
+            }
+            resolve({ code: code == null ? 1 : code, err, opencodeSessionId: activeSessionId });
         });
-        const fatal = extractOpencodeFatalError(out);
-        if (fatal)
-            return Promise.resolve({ code: 1, err: fatal });
-        if (out)
-            postEvent(ROLE_ASSISTANT, out);
-        return Promise.resolve({ code: 0, err: "" });
-    }
-    catch (e) {
-        const errObj = e;
-        const stderr = errObj.stderr?.toString() || "";
-        const stdout = errObj.stdout?.toString() || "";
-        const fatal = summarizeOpencodeFailure(stderr, stdout, errObj.status ?? 1);
-        return Promise.resolve({ code: errObj.status || 1, err: fatal });
-    }
+    });
 }
 function connectInboundStream(backend, apiKey, sessionId, handlers) {
     const url = new URL(`${backend}/api/chimphands/sessions/${encodeURIComponent(sessionId)}/inbound`);
@@ -368,7 +552,6 @@ function connectInboundStream(backend, apiKey, sessionId, handlers) {
 export async function runChimphands(opts) {
     const apiKey = requireApiKey();
     const backend = getBackendUrl();
-    // Ensure child processes see the resolved backend (prod default when unset).
     process.env.TESTCHIMP_BACKEND_URL = backend;
     const sessionId = (opts.sessionId || process.env.SESSION_ID || "").trim();
     if (!sessionId) {
@@ -380,10 +563,13 @@ 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);
     if (githubRunId) {
-        postJsonFireAndForget(backend, apiKey, "/api/chimphands/post_agent_event", {
+        await postJson(backend, apiKey, "/api/chimphands/post_agent_event", {
             sessionId,
             githubRunId,
+        }).catch((err) => {
+            console.error(`ChimpHands link run failed: ${err instanceof Error ? err.message : String(err)}`);
         });
     }
     const userId = boot.chimphands_service_account_user_id || "";
@@ -393,6 +579,26 @@ export async function runChimphands(opts) {
     mkdirSync(".opencode", { recursive: true });
     const opencodeModel = writeOpencodeConfig(backend, apiKey, boot);
     console.error(`ChimpHands OpenCode model: ${opencodeModel}`);
+    let opencodeSessionId = boot.opencode_session_id?.trim() || undefined;
+    const conversationSummary = boot.conversation_summary || "";
+    let workingBranch = boot.working_branch?.trim() || undefined;
+    let pullRequestUrl = boot.pull_request_url?.trim() || undefined;
+    const noteWorkingBranch = (branch, prUrl) => {
+        const normalizedBranch = branch.trim();
+        if (!normalizedBranch)
+            return;
+        const branchIsNew = !workingBranch;
+        const nextPr = prUrl?.trim() || pullRequestUrl;
+        const prIsNew = !!prUrl?.trim() && prUrl.trim() !== pullRequestUrl;
+        if (workingBranch === normalizedBranch && !prIsNew)
+            return;
+        workingBranch = normalizedBranch;
+        if (prUrl?.trim())
+            pullRequestUrl = prUrl.trim();
+        if (branchIsNew || prIsNew) {
+            poster.reportWorkingBranch(normalizedBranch, nextPr);
+        }
+    };
     const idleMs = (Number(boot.idle_timeout_seconds) || 600) * 1000;
     const queue = [];
     const seenUserMessageIds = new Set();
@@ -430,17 +636,12 @@ export async function runChimphands(opts) {
             // Polling is best-effort when inbound SSE misses an event.
         }
     };
-    const postEvent = (role, content, status, messageId) => {
-        const body = {
-            sessionId,
-            role,
-            content: String(content || "").slice(0, 20000),
-        };
-        if (messageId)
-            body.messageId = messageId;
-        if (status != null)
-            body.status = status;
-        postJsonFireAndForget(backend, apiKey, "/api/chimphands/post_agent_event", body);
+    const postEvent = (role, content, opts) => {
+        const bodyOpts = { ...opts };
+        if (opencodeSessionId && !bodyOpts.opencodeSessionId) {
+            bodyOpts.opencodeSessionId = opencodeSessionId;
+        }
+        poster.fireAndForget(role, content, bodyOpts);
     };
     const complete = (status, errorMessage) => {
         const body = { sessionId, status };
@@ -448,12 +649,15 @@ export async function runChimphands(opts) {
             body.errorMessage = String(errorMessage).slice(0, 4000);
         if (githubRunId)
             body.githubRunId = githubRunId;
-        postJsonFireAndForget(backend, apiKey, "/api/chimphands/complete_session", body);
+        void postJson(backend, apiKey, "/api/chimphands/complete_session", body).catch((err) => {
+            console.error(`ChimpHands complete_session failed: ${err instanceof Error ? err.message : String(err)}`);
+        });
     };
     const childEnv = {
         ...process.env,
         TESTCHIMP_API_KEY: apiKey,
         TESTCHIMP_BACKEND_URL: backend,
+        TESTCHIMP_EXECUTION_SOURCE: "CLOUD_AGENT",
     };
     if (userId)
         childEnv.TESTCHIMP_USER_ID = userId;
@@ -464,11 +668,8 @@ export async function runChimphands(opts) {
         },
         shouldRun: () => sessionActive,
     });
-    postEvent(ROLE_STATUS, "Agent ready", STATUS_RUNNING);
+    poster.fireAndForget(ROLE_STATUS, "Agent ready", { status: STATUS_RUNNING });
     let prompt = normalizeUserMessage(promptInput || boot.initial_prompt || "");
-    if (boot.conversation_summary) {
-        prompt = `Conversation so far:\n${boot.conversation_summary}\n\nCurrent task:\n${prompt}`;
-    }
     for (const m of boot.pending_user_messages || []) {
         if (m?.content)
             enqueueUserMessage({ content: m.content });
@@ -505,17 +706,50 @@ export async function runChimphands(opts) {
         tick();
     });
     while (prompt) {
-        const result = await runOpencode(prompt, opencodeModel, childEnv, postEvent);
+        let useOpencodeSessionId = opencodeSessionId;
+        let isNewOpencodeSession = !useOpencodeSessionId;
+        let effectivePrompt = wrapPromptWithContext(conversationSummary, prompt, isNewOpencodeSession, workingBranch, pullRequestUrl);
+        let result = await runOpencode(effectivePrompt, opencodeModel, childEnv, useOpencodeSessionId, {
+            onSessionId: (id) => {
+                opencodeSessionId = id;
+                void postJson(backend, apiKey, "/api/chimphands/post_agent_event", {
+                    sessionId,
+                    opencodeSessionId: id,
+                }).catch(() => { });
+            },
+            onWorkingBranch: noteWorkingBranch,
+            postEvent,
+        });
+        if (result.code !== 0 &&
+            useOpencodeSessionId &&
+            isMissingOpencodeSessionError(result.err || "")) {
+            console.error(`ChimpHands OpenCode session ${useOpencodeSessionId} missing on runner; starting fresh thread.`);
+            opencodeSessionId = undefined;
+            isNewOpencodeSession = true;
+            effectivePrompt = wrapPromptWithContext(conversationSummary, prompt, true, workingBranch, pullRequestUrl);
+            result = await runOpencode(effectivePrompt, opencodeModel, childEnv, undefined, {
+                onSessionId: (id) => {
+                    opencodeSessionId = id;
+                    void postJson(backend, apiKey, "/api/chimphands/post_agent_event", {
+                        sessionId,
+                        opencodeSessionId: id,
+                    }).catch(() => { });
+                },
+                onWorkingBranch: noteWorkingBranch,
+                postEvent,
+            });
+        }
+        await poster.flush();
+        if (result.opencodeSessionId) {
+            opencodeSessionId = result.opencodeSessionId;
+        }
         if (result.code !== 0) {
             const errMsg = (result.err || "opencode failed").trim() || "opencode failed";
             console.error(`ChimpHands OpenCode failed: ${errMsg}`);
             try {
-                await postJson(backend, apiKey, "/api/chimphands/post_agent_event", {
-                    sessionId,
-                    role: ROLE_STATUS,
-                    content: errMsg,
+                await poster.enqueue(ROLE_STATUS, errMsg, {
                     status: STATUS_FAILED,
-                    githubRunId: githubRunId || undefined,
+                    opencodeSessionId,
                 });
                 await postJson(backend, apiKey, "/api/chimphands/complete_session", {
                     sessionId,
@@ -527,19 +761,19 @@ export async function runChimphands(opts) {
             catch (reportErr) {
                 const detail = reportErr instanceof Error ? reportErr.message : String(reportErr);
                 console.error(`ChimpHands failed to report OpenCode error to backend: ${detail}`);
-                postEvent(ROLE_STATUS, errMsg, STATUS_FAILED);
+                postEvent(ROLE_STATUS, errMsg, { status: STATUS_FAILED });
                 complete(STATUS_FAILED, errMsg);
             }
             process.exit(result.code || 1);
         }
-        postEvent(ROLE_STATUS, "Waiting for user input", STATUS_WAITING_USER);
-        // Idle countdown starts when the agent finishes a turn, not at job bootstrap.
+        postEvent(ROLE_STATUS, "Waiting for user input", { status: STATUS_WAITING_USER });
         lastUserActivity = Date.now();
         idle = false;
         prompt = (await waitForNextPrompt()) || "";
     }
     sessionActive = false;
     stopInbound();
+    await poster.flush();
     console.error("ChimpHands session idle — no user input before timeout; completing.");
     complete(STATUS_IDLE);
 }

package/dist/cli/program.js

@@ -1562,6 +1562,28 @@ export function buildCliProgram() {
         console.log(await runTool("list-api-operation-interactions", mergeBodies(body, opts.jsonInput), { postMcp }));
     });
     const chimphands = program.command("chimphands").description("ChimpHands GitHub Actions agent bridge");
+    chimphands
+        .command("report-branch")
+        .description("Report the conversation working branch (and optional PR URL) to TestChimp")
+        .requiredOption("--branch <name>", "Feature branch name (testchimp-* or chimphands-*)")
+        .option("--pr-url <url>", "Open pull request URL")
+        .option("--session-id <id>", "ChimpHands session id (or SESSION_ID env)")
+        .action(async (opts) => {
+        const { reportWorkingBranch } = await import("../chimphands/run.js");
+        try {
+            await reportWorkingBranch({
+                sessionId: String(opts.sessionId || process.env.SESSION_ID || "").trim(),
+                branch: String(opts.branch || "").trim(),
+                pullRequestUrl: opts.prUrl != null ? String(opts.prUrl).trim() : undefined,
+            });
+            console.log(JSON.stringify({ ok: true }));
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            console.error(`[testchimp chimphands report-branch] ${msg}`);
+            process.exit(1);
+        }
+    });
     chimphands
         .command("run")
         .description("Bootstrap session, configure OpenCode, and run the interactive bridge")

package/package.json

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