@testchimp/cli 0.1.68 → 0.1.70

package/dist/chimphands/agentBranch.d.ts

@@ -0,0 +1,42 @@
+/**
+ * ChimpHands CI git: base branch (parent) vs agent branch (testchimp-* only).
+ */
+export declare const BASE_BRANCH_PREFIX = "Base branch: ";
+/** @deprecated Legacy platform line; still parsed for in-flight sessions. */
+export declare const LEGACY_WORKING_BRANCH_PREFIX = "Working branch: ";
+export declare function isAgentBranchName(branch: string): boolean;
+export declare function parseBaseBranchFromPrompt(prompt: string): string | undefined;
+export declare function resolveSessionBaseBranch(prompt: string | undefined, envBaseBranch?: string): string | undefined;
+export declare function buildAgentBranchName(sessionId: string): string;
+type GitRunResult = {
+    code: number;
+    out: string;
+    err: string;
+};
+export declare function runGit(args: string[], env?: NodeJS.ProcessEnv): Promise<GitRunResult>;
+export type EnsureAgentBranchOptions = {
+    sessionId: string;
+    baseBranch?: string;
+    /** Agent branch already reported for this session (bootstrap). */
+    existingAgentBranch?: string;
+};
+export type EnsureAgentBranchResult = {
+    agentBranch: string;
+    baseBranch?: string;
+    created: boolean;
+};
+/**
+ * Ensures the runner is on a published testchimp-* agent branch.
+ * When checked out on the user's base branch, creates testchimp-chimphands-<session> from it.
+ */
+export declare function ensureAgentSessionBranch(opts: EnsureAgentBranchOptions): Promise<EnsureAgentBranchResult>;
+export type EnsurePullRequestOptions = {
+    agentBranch: string;
+    baseBranch: string;
+    title?: string;
+    body?: string;
+};
+/** Opens a PR from agent branch → base branch when none exists. Returns PR URL if created/found. */
+export declare function ensurePullRequest(opts: EnsurePullRequestOptions): Promise<string | undefined>;
+export declare function isPrOnlyMode(): boolean;
+export {};

package/dist/chimphands/agentBranch.js

@@ -0,0 +1,174 @@
+/**
+ * ChimpHands CI git: base branch (parent) vs agent branch (testchimp-* only).
+ */
+import { spawn } from "node:child_process";
+export const BASE_BRANCH_PREFIX = "Base branch: ";
+/** @deprecated Legacy platform line; still parsed for in-flight sessions. */
+export const LEGACY_WORKING_BRANCH_PREFIX = "Working branch: ";
+const BASE_BRANCH_LINE = /^(?:Base branch|Working branch):\s*(.+)$/im;
+const AGENT_BRANCH_PREFIX = /^testchimp-/i;
+export function isAgentBranchName(branch) {
+    return AGENT_BRANCH_PREFIX.test(branch.trim());
+}
+export function parseBaseBranchFromPrompt(prompt) {
+    if (!prompt?.trim())
+        return undefined;
+    let last;
+    for (const line of prompt.split("\n")) {
+        const m = line.match(BASE_BRANCH_LINE);
+        if (!m?.[1])
+            continue;
+        const candidate = m[1].trim();
+        if (candidate)
+            last = candidate;
+    }
+    return last;
+}
+export function resolveSessionBaseBranch(prompt, envBaseBranch) {
+    const fromPrompt = prompt ? parseBaseBranchFromPrompt(prompt) : undefined;
+    if (fromPrompt)
+        return fromPrompt;
+    const fromEnv = envBaseBranch?.trim();
+    return fromEnv || undefined;
+}
+export function buildAgentBranchName(sessionId) {
+    const slug = sessionId.replace(/[^a-zA-Z0-9]/g, "").slice(0, 10).toLowerCase() || "session";
+    return `testchimp-chimphands-${slug}`;
+}
+export function runGit(args, env) {
+    return new Promise((resolve) => {
+        const child = spawn("git", args, {
+            stdio: ["ignore", "pipe", "pipe"],
+            env: env ? { ...process.env, ...env } : process.env,
+        });
+        let out = "";
+        let err = "";
+        child.stdout.on("data", (d) => {
+            out += d.toString();
+        });
+        child.stderr.on("data", (d) => {
+            err += d.toString();
+        });
+        child.on("close", (code) => resolve({ code: code ?? 1, out, err }));
+    });
+}
+async function currentBranch() {
+    const r = await runGit(["rev-parse", "--abbrev-ref", "HEAD"]);
+    if (r.code !== 0)
+        return undefined;
+    const b = r.out.trim();
+    return b && b !== "HEAD" ? b : undefined;
+}
+async function isDirtyWorktree() {
+    const r = await runGit(["status", "--porcelain"]);
+    return r.code === 0 && !!r.out.trim();
+}
+/**
+ * Ensures the runner is on a published testchimp-* agent branch.
+ * When checked out on the user's base branch, creates testchimp-chimphands-<session> from it.
+ */
+export async function ensureAgentSessionBranch(opts) {
+    const baseBranch = opts.baseBranch?.trim() || undefined;
+    const existing = opts.existingAgentBranch?.trim();
+    if (existing && isAgentBranchName(existing)) {
+        await checkoutLocalBranch(existing);
+        return { agentBranch: existing, baseBranch, created: false };
+    }
+    const current = await currentBranch();
+    if (current && isAgentBranchName(current)) {
+        return { agentBranch: current, baseBranch, created: false };
+    }
+    const agentBranch = buildAgentBranchName(opts.sessionId);
+    const create = await runGit(["checkout", "-b", agentBranch]);
+    if (create.code !== 0) {
+        throw new Error(`git checkout -b ${agentBranch} failed: ${create.err || create.out || "unknown"}`);
+    }
+    const push = await runGit(["push", "-u", "origin", "HEAD"]);
+    if (push.code !== 0) {
+        throw new Error(`git push failed for new agent branch: ${push.err || push.out || "unknown"}`);
+    }
+    console.error(`ChimpHands created agent branch ${agentBranch}` +
+        (baseBranch ? ` from base ${baseBranch}` : ""));
+    return { agentBranch, baseBranch, created: true };
+}
+async function checkoutLocalBranch(branch) {
+    const r = await runGit(["checkout", branch]);
+    if (r.code !== 0) {
+        throw new Error(`git checkout ${branch} failed: ${r.err || r.out || "unknown"}`);
+    }
+}
+/** Opens a PR from agent branch → base branch when none exists. Returns PR URL if created/found. */
+export async function ensurePullRequest(opts) {
+    const agentBranch = opts.agentBranch.trim();
+    const baseBranch = opts.baseBranch.trim();
+    if (!agentBranch || !baseBranch || agentBranch === baseBranch)
+        return undefined;
+    const list = await runGh([
+        "pr",
+        "list",
+        "--head",
+        agentBranch,
+        "--base",
+        baseBranch,
+        "--state",
+        "open",
+        "--json",
+        "url",
+        "--jq",
+        ".[0].url",
+    ]);
+    if (list.code === 0 && list.out.trim()) {
+        return list.out.trim();
+    }
+    const dirty = await isDirtyWorktree();
+    if (dirty) {
+        return undefined;
+    }
+    const headAhead = await runGit(["rev-list", "--count", `${baseBranch}..${agentBranch}`]);
+    const aheadCount = Number.parseInt(headAhead.out.trim(), 10);
+    if (headAhead.code !== 0 || !Number.isFinite(aheadCount) || aheadCount <= 0) {
+        return undefined;
+    }
+    const title = opts.title?.trim() || `ChimpHands: ${agentBranch}`;
+    const body = opts.body?.trim() ||
+        `Automated changes from ChimpHands session on branch \`${agentBranch}\`.\n\nMerge target: \`${baseBranch}\`.`;
+    const create = await runGh([
+        "pr",
+        "create",
+        "--base",
+        baseBranch,
+        "--head",
+        agentBranch,
+        "--title",
+        title,
+        "--body",
+        body,
+    ]);
+    if (create.code !== 0) {
+        console.error(`ChimpHands gh pr create failed: ${create.err || create.out}`);
+        return undefined;
+    }
+    const url = (create.out || create.err).trim().match(/https:\/\/github\.com\/[^\s]+\/pull\/\d+/)?.[0];
+    return url;
+}
+function runGh(args) {
+    return new Promise((resolve) => {
+        const child = spawn("gh", args, {
+            stdio: ["ignore", "pipe", "pipe"],
+            env: process.env,
+        });
+        let out = "";
+        let err = "";
+        child.stdout.on("data", (d) => {
+            out += d.toString();
+        });
+        child.stderr.on("data", (d) => {
+            err += d.toString();
+        });
+        child.on("close", (code) => resolve({ code: code ?? 1, out, err }));
+    });
+}
+export function isPrOnlyMode() {
+    const v = (process.env.CHIMPHANDS_PR_ONLY || "").trim().toLowerCase();
+    return v === "1" || v === "true" || v === "yes";
+}

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

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

package/dist/chimphands/agentBranch.test.js

@@ -0,0 +1,22 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { buildAgentBranchName, isAgentBranchName, parseBaseBranchFromPrompt, resolveSessionBaseBranch, } from "./agentBranch.js";
+describe("agentBranch", () => {
+    it("isAgentBranchName accepts testchimp- only", () => {
+        assert.equal(isAgentBranchName("testchimp-foo"), true);
+        assert.equal(isAgentBranchName("chimphands-foo"), false);
+        assert.equal(isAgentBranchName("feature/foo"), false);
+    });
+    it("parseBaseBranchFromPrompt reads Base and legacy Working lines", () => {
+        assert.equal(parseBaseBranchFromPrompt("run qa\nBase branch: dashboard"), "dashboard");
+        assert.equal(parseBaseBranchFromPrompt("Working branch: main"), "main");
+        assert.equal(parseBaseBranchFromPrompt("run qa only"), undefined);
+    });
+    it("resolveSessionBaseBranch prefers prompt over env", () => {
+        assert.equal(resolveSessionBaseBranch("Base branch: a", "b"), "a");
+        assert.equal(resolveSessionBaseBranch(undefined, "b"), "b");
+    });
+    it("buildAgentBranchName uses testchimp prefix", () => {
+        assert.match(buildAgentBranchName("01ARZ3NDEKTSV4RRFFQ69G5FAV"), /^testchimp-chimphands-/);
+    });
+});

package/dist/chimphands/run.js

@@ -14,6 +14,7 @@ import { getBackendUrl, requireApiKey } from "../core/client.js";
 import { isChimphandsLlmRetryEnabled, startLlmRetryProxy } from "./llmRetryProxy.js";
 import { midTurnSteeringKey, releaseUnansweredMidTurnMessages, } from "./midTurnSteering.js";
 import { runSteeringSidecarReply } from "./steeringSidecar.js";
+import { ensureAgentSessionBranch, ensurePullRequest, isAgentBranchName, isPrOnlyMode, resolveSessionBaseBranch, runGit, } from "./agentBranch.js";
 const ROLE_ASSISTANT = "CHIMPHANDS_MESSAGE_ROLE_ASSISTANT";
 const ROLE_TOOL = "CHIMPHANDS_MESSAGE_ROLE_TOOL";
 const ROLE_REASONING = "CHIMPHANDS_MESSAGE_ROLE_REASONING";
@@ -26,6 +27,8 @@ 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;
+/** Set for the active ChimpHands session (PR base branch + callbacks). */
+let activeSessionGitContext = null;
 function isStreamFanoutRole(role) {
     return role === ROLE_ASSISTANT || role === ROLE_TOOL || role === ROLE_REASONING;
 }
@@ -67,17 +70,18 @@ const CHIMPHANDS_AGENT_PROMPT = `You are ChimpHands, TestChimp's coding agent. Y
 - 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).
 
 ## 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\`).
-- Commit and push on the session working branch after meaningful edit batches. When \`CHIMPHANDS_UI_ATTACHED\` is \`false\` (no browser watching live), **commit and push before ending every turn** so the user can review async via PR / Files changed. The host also commits any remaining dirty worktree after each turn and before idle teardown.
-- Branch names MUST start with \`testchimp-\` or \`chimphands-\`.
-- When creating a NEW working branch: create it, then IMMEDIATELY publish it with
+- 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.
+- If bootstrap lists an agent branch (\`testchimp-*\`), checkout that branch and push additional commits there — update the same PR.
+- Only create a NEW agent branch/PR when (a) no \`testchimp-*\` branch exists yet for this conversation, or (b) the prior PR was merged/closed (verify with \`gh pr view\`).
+- Commit and push on the session agent branch after meaningful edit batches. When \`CHIMPHANDS_UI_ATTACHED\` is \`false\` (no browser watching live), **commit and push before ending every turn** so the user can review async via PR / Files changed. The host also commits any remaining dirty worktree after each turn and before idle teardown.
+- Branch names for commits and PRs MUST start with \`testchimp-\` (never \`chimphands-*\` or the base branch name).
+- When the prompt includes \`Base branch: <name>\`: the workflow may already have that branch checked out (\`CHIMPHANDS_WORK_BRANCH\`). Create \`git checkout -b testchimp-<scope>\` from it, push, then work only on the \`testchimp-*\` branch. Open PRs with \`gh pr create --base <base-branch> --head <testchimp-branch>\`.
+- When creating a NEW agent branch: create it, then IMMEDIATELY publish it with
   \`git push -u origin <branch>\` BEFORE calling report-branch. Users open the branch URL in the UI —
   do not report a branch that only exists locally (that causes GitHub 404).
 - After the branch is on the remote (and after opening a PR), IMMEDIATELY run:
-  \`testchimp chimphands report-branch --branch <name> [--pr-url <url>]\`
+  \`testchimp chimphands report-branch --branch <testchimp-branch> [--pr-url <url>]\`
 - Tell the user which branch you are on and include the PR URL when available.
 - **GitHub auth expiry (self-fix):** Job-start App installation tokens expire after ~1 hour. On \`git push\` / \`gh\` auth failures (401/403 / Authentication failed / write access not granted), run \`testchimp chimphands refresh-git-auth\` then retry — **never** ask the user to paste or reconnect a GitHub token in chat. See skill \`references/chimphands-faq.md\`.
 
@@ -119,6 +123,9 @@ export async function reportWorkingBranch(opts) {
     if (!branch) {
         throw new Error("branch is required");
     }
+    if (!isAgentBranchName(branch)) {
+        throw new Error("branch must start with testchimp- (agent feature branch, not the base branch)");
+    }
     const body = {
         sessionId: opts.sessionId.trim(),
         workingBranch: branch,
@@ -966,10 +973,13 @@ function isAssistantEchoOfSentPrompt(assistant, ...sentPrompts) {
     }
     return false;
 }
-function wrapPromptWithContext(conversationSummary, userPrompt, isNewOpencodeSession, workingBranch, pullRequestUrl) {
+function wrapPromptWithContext(conversationSummary, userPrompt, isNewOpencodeSession, workingBranch, pullRequestUrl, baseBranch) {
     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.", "");
+    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.", "");
+    }
+    if (workingBranch?.trim() && isAgentBranchName(workingBranch)) {
+        parts.push("## Conversation agent branch (reuse for this thread)", `Branch: \`${workingBranch.trim()}\``, pullRequestUrl?.trim() ? `PR: ${pullRequestUrl.trim()}` : "", "Checkout this testchimp-* branch, commit and push here. Do NOT open a new PR unless the one above was merged/closed.", "");
     }
     const task = normalizeUserMessage(userPrompt);
     // Do NOT inject "Interactive turn reminder" into the user prompt — it is already in
@@ -992,7 +1002,7 @@ function detectWorkingBranchFromToolOutput(output) {
     const prMatch = text.match(/https:\/\/github\.com\/[^\s)\]]+\/pull\/\d+/);
     // Only auto-detect after a successful push to origin — local checkout -b alone would
     // report a branch URL that 404s until the remote ref exists.
-    const pushMatch = text.match(/push\s+(?:--set-upstream\s+|-u\s+)?origin\s+((?:testchimp-|chimphands-)[^\s'"\[\]]+)/i);
+    const pushMatch = text.match(/push\s+(?:--set-upstream\s+|-u\s+)?origin\s+((?:testchimp-)[^\s'"\[\]]+)/i);
     const branch = pushMatch?.[1]?.replace(/[`'"\[\]]/g, "");
     return {
         branch,
@@ -1537,6 +1547,11 @@ async function applyUserFileEdit(backend, apiKey, sessionId, edit, turnActive) {
         }
         await fs.mkdir(path.dirname(full), { recursive: true });
         await fs.writeFile(full, edit.content, "utf8");
+        const pushed = await commitAndPushDirtyWorktree("User Update");
+        if (!pushed.ok) {
+            await ackWorktreeFileWrite(backend, apiKey, sessionId, edit.requestId, false, pushed.error || "commit/push failed");
+            return;
+        }
         await ackWorktreeFileWrite(backend, apiKey, sessionId, edit.requestId, true);
     }
     catch (err) {
@@ -1839,9 +1854,16 @@ export async function runChimphands(opts) {
         const prIsNew = !!prUrl?.trim() && prUrl.trim() !== pullRequestUrl;
         if (workingBranch === normalizedBranch && !prIsNew)
             return;
+        if (!isAgentBranchName(normalizedBranch))
+            return;
         workingBranch = normalizedBranch;
         if (prUrl?.trim())
             pullRequestUrl = prUrl.trim();
+        if (activeSessionGitContext) {
+            activeSessionGitContext.agentBranch = normalizedBranch;
+            if (pullRequestUrl)
+                activeSessionGitContext.pullRequestUrl = pullRequestUrl;
+        }
         if (branchIsNew || prIsNew) {
             poster.reportWorkingBranch(normalizedBranch, nextPr);
         }
@@ -2108,6 +2130,7 @@ export async function runChimphands(opts) {
                 status: "CHIMPHANDS_RUNTIME_STATUS_TERMINATED",
             }).catch(() => { });
         }
+        activeSessionGitContext = null;
     };
     try {
         poster.fireAndForget(ROLE_STATUS, "Agent ready", { status: STATUS_RUNNING });
@@ -2129,6 +2152,32 @@ export async function runChimphands(opts) {
                 undefined;
             enqueueUserMessage({ id: id || undefined, content });
         }
+        let sessionBaseBranch = resolveSessionBaseBranch(prompt, process.env.CHIMPHANDS_WORK_BRANCH);
+        activeSessionGitContext = {
+            baseBranch: sessionBaseBranch,
+            agentBranch: workingBranch && isAgentBranchName(workingBranch) ? workingBranch : undefined,
+            pullRequestUrl,
+            onPullRequest: (url) => {
+                if (workingBranch)
+                    noteWorkingBranch(workingBranch, url);
+            },
+        };
+        try {
+            const branchSetup = await ensureAgentSessionBranch({
+                sessionId,
+                baseBranch: sessionBaseBranch,
+                existingAgentBranch: workingBranch && isAgentBranchName(workingBranch) ? workingBranch : undefined,
+            });
+            sessionBaseBranch = branchSetup.baseBranch || sessionBaseBranch;
+            activeSessionGitContext.baseBranch = sessionBaseBranch;
+            activeSessionGitContext.agentBranch = branchSetup.agentBranch;
+            if (!workingBranch || workingBranch !== branchSetup.agentBranch) {
+                noteWorkingBranch(branchSetup.agentBranch);
+            }
+        }
+        catch (err) {
+            console.error(`ChimpHands ensure agent branch failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
         const waitForNextPrompt = () => new Promise((resolve) => {
             let lastPollAt = 0;
             let settled = false;
@@ -2184,7 +2233,7 @@ export async function runChimphands(opts) {
             flushPendingMidTurnInject();
             let useOpencodeSessionId = opencodeSessionId;
             let isNewOpencodeSession = !useOpencodeSessionId;
-            let effectivePrompt = wrapPromptWithContext(conversationSummary, prompt, isNewOpencodeSession, workingBranch, pullRequestUrl);
+            let effectivePrompt = wrapPromptWithContext(conversationSummary, prompt, isNewOpencodeSession, workingBranch, pullRequestUrl, sessionBaseBranch);
             const turnPostEvent = (role, content, opts) => postEventForTurn(prompt, effectivePrompt, role, content, opts);
             // Visible in chat (not filtered as routine). OpenCode may not emit text until a
             // part completes — without this the UI looks empty while the turn is running.
@@ -2208,7 +2257,7 @@ export async function runChimphands(opts) {
                 console.error(`ChimpHands OpenCode session ${useOpencodeSessionId} missing on runner; starting fresh thread.`);
                 opencodeSessionId = undefined;
                 isNewOpencodeSession = true;
-                effectivePrompt = wrapPromptWithContext(conversationSummary, prompt, true, workingBranch, pullRequestUrl);
+                effectivePrompt = wrapPromptWithContext(conversationSummary, prompt, true, workingBranch, pullRequestUrl, sessionBaseBranch);
                 result = await runOpencode(effectivePrompt, opencodeModel, childEnv, undefined, {
                     onSessionId: (id) => {
                         opencodeSessionId = id;
@@ -2345,46 +2394,39 @@ function startRuntimeHeartbeat(backend, apiKey, runtimeId, onUiAttached) {
         stopped = true;
     };
 }
-/** Commit+push dirty worktree on the session branch before idle/teardown (no default-branch writes). */
+/** Commit+push dirty worktree on the session agent branch before idle/teardown. */
 async function commitAndPushDirtyWorktree(message) {
-    const run = (args, env) => new Promise((resolve) => {
-        const child = spawn("git", args, {
-            stdio: ["ignore", "pipe", "pipe"],
-            env: env ? { ...process.env, ...env } : process.env,
-        });
-        let out = "";
-        let err = "";
-        child.stdout.on("data", (d) => {
-            out += d.toString();
-        });
-        child.stderr.on("data", (d) => {
-            err += d.toString();
-        });
-        child.on("close", (code) => resolve({ code: code ?? 1, out, err }));
-    });
+    const run = (args, env) => runGit(args, env);
     try {
         const branch = await run(["rev-parse", "--abbrev-ref", "HEAD"]);
         if (branch.code !== 0) {
-            console.error(`ChimpHands git rev-parse failed: ${branch.err || branch.out}`);
-            return;
+            const error = branch.err || branch.out || "git rev-parse failed";
+            console.error(`ChimpHands git rev-parse failed: ${error}`);
+            return { ok: false, error };
         }
         const current = branch.out.trim();
-        if (!current || current === "HEAD" || /^(main|master)$/i.test(current)) {
-            console.error(`ChimpHands skip commit-before-idle: refusing branch "${current || "(unknown)"}"`);
-            return;
+        if (!current || current === "HEAD" || !isAgentBranchName(current)) {
+            const error = `refusing non-agent branch "${current || "(unknown)"}" (expected testchimp-*)`;
+            console.error(`ChimpHands skip commit-before-idle: ${error}`);
+            return { ok: false, error };
+        }
+        if (activeSessionGitContext) {
+            activeSessionGitContext.agentBranch = current;
         }
         const status = await run(["status", "--porcelain"]);
         if (status.code !== 0) {
-            console.error(`ChimpHands git status failed: ${status.err || status.out}`);
-            return;
+            const error = status.err || status.out || "git status failed";
+            console.error(`ChimpHands git status failed: ${error}`);
+            return { ok: false, error };
         }
         if (!status.out.trim()) {
-            return;
+            return { ok: true };
         }
         const add = await run(["add", "-A"]);
         if (add.code !== 0) {
-            console.error(`ChimpHands git add failed: ${add.err || add.out}`);
-            return;
+            const error = add.err || add.out || "git add failed";
+            console.error(`ChimpHands git add failed: ${error}`);
+            return { ok: false, error };
         }
         const commitEnv = {
             GIT_AUTHOR_NAME: process.env.GIT_AUTHOR_NAME || "ChimpHands",
@@ -2394,8 +2436,9 @@ async function commitAndPushDirtyWorktree(message) {
         };
         const commit = await run(["-c", "user.name=ChimpHands", "-c", "user.email=chimphands@testchimp.io", "commit", "-m", message], commitEnv);
         if (commit.code !== 0) {
-            console.error(`ChimpHands git commit: ${commit.err || commit.out}`);
-            return;
+            const error = commit.err || commit.out || "git commit failed";
+            console.error(`ChimpHands git commit: ${error}`);
+            return { ok: false, error };
         }
         let push = await run(["push", "-u", "origin", "HEAD"]);
         if (push.code !== 0) {
@@ -2408,23 +2451,44 @@ async function commitAndPushDirtyWorktree(message) {
                     await refreshGitAuth();
                     push = await run(["push", "-u", "origin", "HEAD"]);
                     if (push.code !== 0) {
-                        console.error(`ChimpHands git push failed after refresh: ${push.err || push.out}`);
-                        return;
+                        const error = push.err || push.out || "git push failed after refresh";
+                        console.error(`ChimpHands git push failed after refresh: ${error}`);
+                        return { ok: false, error };
                     }
                 }
                 else {
-                    return;
+                    return { ok: false, error: push.err || push.out || "git push failed" };
                 }
             }
             catch (refreshErr) {
-                console.error(`ChimpHands refresh-git-auth after push failure: ${refreshErr instanceof Error ? refreshErr.message : String(refreshErr)}`);
-                return;
+                const error = refreshErr instanceof Error ? refreshErr.message : String(refreshErr);
+                console.error(`ChimpHands refresh-git-auth after push failure: ${error}`);
+                return { ok: false, error };
             }
         }
         console.error(`ChimpHands committed and pushed dirty worktree on ${current} before shutdown`);
+        const ctx = activeSessionGitContext;
+        if (ctx &&
+            isPrOnlyMode() &&
+            !ctx.pullRequestUrl &&
+            ctx.baseBranch &&
+            isAgentBranchName(current)) {
+            const prUrl = await ensurePullRequest({
+                agentBranch: current,
+                baseBranch: ctx.baseBranch,
+            });
+            if (prUrl) {
+                ctx.pullRequestUrl = prUrl;
+                ctx.onPullRequest?.(prUrl);
+                console.error(`ChimpHands opened PR: ${prUrl}`);
+            }
+        }
+        return { ok: true };
     }
     catch (err) {
-        console.error(`ChimpHands commit-before-idle failed: ${err instanceof Error ? err.message : String(err)}`);
+        const error = err instanceof Error ? err.message : String(err);
+        console.error(`ChimpHands commit-before-idle failed: ${error}`);
+        return { ok: false, error };
     }
 }
 function opencodeProxyNeedsDirectory(path) {

package/dist/cli/program.js

@@ -1607,7 +1607,7 @@ export function buildCliProgram() {
     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-*)")
+        .requiredOption("--branch <name>", "Agent feature branch name (testchimp-* only)")
         .option("--pr-url <url>", "Open pull request URL")
         .option("--session-id <id>", "ChimpHands session id (or SESSION_ID env)")
         .action(async (opts) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testchimp/cli",
-  "version": "0.1.68",
+  "version": "0.1.70",
   "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",
+    "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",
     "watch": "tsc --watch",
     "start": "node dist/bin/testchimp.js",
     "prepublishOnly": "npm run build"