@testchimp/cli 0.1.67 → 0.1.69

package/dist/chimphands/midTurnSteering.d.ts

@@ -0,0 +1,25 @@
+/** Helpers for mid-turn user steering via OpenCode prompt_async. */
+export type OpencodeSessionMessage = {
+    info?: {
+        id?: string;
+        role?: string;
+    };
+    parts?: Array<{
+        type?: string;
+        text?: string;
+        state?: {
+            status?: string;
+        };
+    }>;
+};
+export declare function normalizeSteeringContent(content: string): string;
+export declare function midTurnSteeringKey(id: string | undefined, content: string): string;
+export declare function extractUserMessageText(msg: OpencodeSessionMessage): string;
+/** True when an assistant message after the matching user text has substantive output. */
+export declare function userMessageHasAssistantReply(messages: OpencodeSessionMessage[], userContent: string): boolean;
+export declare function fetchOpencodeSessionMessages(attachUrl: string, opencodeSessionId: string, cwd?: string): Promise<OpencodeSessionMessage[]>;
+/**
+ * After a turn ends, re-queue mid-turn steering messages that prompt_async accepted
+ * but OpenCode never answered (e.g. blocked on long-running bash).
+ */
+export declare function releaseUnansweredMidTurnMessages(attachUrl: string, opencodeSessionId: string, midTurnInjected: Map<string, string>, queue: string[], wake: () => void, sidecarAnsweredKeys?: Set<string>): Promise<void>;

package/dist/chimphands/midTurnSteering.js

@@ -0,0 +1,93 @@
+/** Helpers for mid-turn user steering via OpenCode prompt_async. */
+export function normalizeSteeringContent(content) {
+    return content.trim();
+}
+export function midTurnSteeringKey(id, content) {
+    const norm = normalizeSteeringContent(content);
+    return id?.trim() || `content:${norm}`;
+}
+export function extractUserMessageText(msg) {
+    return (msg.parts || [])
+        .filter((p) => p.type === "text" && p.text?.trim())
+        .map((p) => p.text.trim())
+        .join("\n");
+}
+/** True when an assistant message after the matching user text has substantive output. */
+export function userMessageHasAssistantReply(messages, userContent) {
+    const normalizedTarget = normalizeSteeringContent(userContent);
+    if (!normalizedTarget)
+        return true;
+    let userIdx = -1;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const role = (messages[i]?.info?.role || "").toLowerCase();
+        if (role !== "user")
+            continue;
+        const text = normalizeSteeringContent(extractUserMessageText(messages[i]));
+        if (text === normalizedTarget) {
+            userIdx = i;
+            break;
+        }
+    }
+    if (userIdx < 0)
+        return false;
+    for (let i = userIdx + 1; i < messages.length; i++) {
+        const role = (messages[i]?.info?.role || "").toLowerCase();
+        if (role !== "assistant")
+            continue;
+        const hasText = (messages[i]?.parts || []).some((p) => (p.type === "text" || p.type === "reasoning") && p.text?.trim());
+        const hasCompletedTool = (messages[i]?.parts || []).some((p) => p.type === "tool" && p.state?.status === "completed");
+        if (hasText || hasCompletedTool)
+            return true;
+    }
+    return false;
+}
+export async function fetchOpencodeSessionMessages(attachUrl, opencodeSessionId, cwd = process.cwd()) {
+    const base = attachUrl.replace(/\/$/, "");
+    const url = `${base}/session/${encodeURIComponent(opencodeSessionId)}/message`;
+    const res = await fetch(url, {
+        headers: { Accept: "application/json", "x-opencode-directory": cwd },
+    });
+    if (!res.ok) {
+        throw new Error(`OpenCode session messages HTTP ${res.status}`);
+    }
+    const data = (await res.json());
+    return Array.isArray(data) ? data : [];
+}
+/**
+ * After a turn ends, re-queue mid-turn steering messages that prompt_async accepted
+ * but OpenCode never answered (e.g. blocked on long-running bash).
+ */
+export async function releaseUnansweredMidTurnMessages(attachUrl, opencodeSessionId, midTurnInjected, queue, wake, sidecarAnsweredKeys = new Set()) {
+    if (!midTurnInjected.size)
+        return;
+    let messages = [];
+    try {
+        messages = await fetchOpencodeSessionMessages(attachUrl, opencodeSessionId);
+    }
+    catch (err) {
+        console.error(`ChimpHands mid-turn steering check failed — queueing unanswered injected messages: ${err instanceof Error ? err.message : String(err)}`);
+        for (const [key, content] of midTurnInjected.entries()) {
+            if (sidecarAnsweredKeys.has(key))
+                continue;
+            queue.push(content);
+        }
+        midTurnInjected.clear();
+        wake();
+        return;
+    }
+    for (const [key, content] of midTurnInjected.entries()) {
+        if (sidecarAnsweredKeys.has(key)) {
+            console.error(`ChimpHands mid-turn steering message ${key} answered by sidecar — no re-queue`);
+            continue;
+        }
+        if (userMessageHasAssistantReply(messages, content)) {
+            console.error(`ChimpHands mid-turn steering message ${key} was answered in-session — no re-queue`);
+            continue;
+        }
+        console.error(`ChimpHands mid-turn steering message ${key} unanswered — queueing for next turn`);
+        queue.push(content);
+    }
+    midTurnInjected.clear();
+    if (queue.length)
+        wake();
+}

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

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

package/dist/chimphands/midTurnSteering.test.js

@@ -0,0 +1,46 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { userMessageHasAssistantReply, } from "./midTurnSteering.js";
+function userMsg(text) {
+    return { info: { role: "user" }, parts: [{ type: "text", text }] };
+}
+function assistantText(text) {
+    return { info: { role: "assistant" }, parts: [{ type: "text", text }] };
+}
+function assistantTool(status) {
+    return {
+        info: { role: "assistant" },
+        parts: [{ type: "tool", state: { status } }],
+    };
+}
+describe("userMessageHasAssistantReply", () => {
+    it("returns false when user message has no assistant reply after it", () => {
+        const messages = [userMsg("why gcp_sa_json_path?")];
+        assert.equal(userMessageHasAssistantReply(messages, "why gcp_sa_json_path?"), false);
+    });
+    it("returns true when assistant text follows the matching user message", () => {
+        const messages = [
+            userMsg("first question"),
+            assistantText("first answer"),
+            userMsg("why gcp_sa_json_path?"),
+            assistantText("We should use WIF in CI."),
+        ];
+        assert.equal(userMessageHasAssistantReply(messages, "why gcp_sa_json_path?"), true);
+    });
+    it("matches the latest user message with the same content", () => {
+        const messages = [
+            userMsg("repeat"),
+            assistantText("old answer"),
+            userMsg("repeat"),
+        ];
+        assert.equal(userMessageHasAssistantReply(messages, "repeat"), false);
+    });
+    it("counts completed tool output as a reply", () => {
+        const messages = [userMsg("check auth"), assistantTool("completed")];
+        assert.equal(userMessageHasAssistantReply(messages, "check auth"), true);
+    });
+    it("ignores pending tool parts as a reply", () => {
+        const messages = [userMsg("run tests"), assistantTool("running")];
+        assert.equal(userMessageHasAssistantReply(messages, "run tests"), false);
+    });
+});

package/dist/chimphands/run.js

@@ -12,6 +12,8 @@ import https from "node:https";
 import { URL } from "node:url";
 import { getBackendUrl, requireApiKey } from "../core/client.js";
 import { isChimphandsLlmRetryEnabled, startLlmRetryProxy } from "./llmRetryProxy.js";
+import { midTurnSteeringKey, releaseUnansweredMidTurnMessages, } from "./midTurnSteering.js";
+import { runSteeringSidecarReply } from "./steeringSidecar.js";
 const ROLE_ASSISTANT = "CHIMPHANDS_MESSAGE_ROLE_ASSISTANT";
 const ROLE_TOOL = "CHIMPHANDS_MESSAGE_ROLE_TOOL";
 const ROLE_REASONING = "CHIMPHANDS_MESSAGE_ROLE_REASONING";
@@ -21,6 +23,7 @@ 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 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;
 function isStreamFanoutRole(role) {
@@ -84,6 +87,11 @@ const CHIMPHANDS_AGENT_PROMPT = `You are ChimpHands, TestChimp's coding agent. Y
 - Follow plan → explicit user approval → execute (interactive default). Do not skip MCP calls or claim done without tool evidence.
 - Export \`TESTCHIMP_EXECUTION_SOURCE=CLOUD_AGENT\` before Playwright/Mobilewright runs.
 
+## 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\`.
+- 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
 - 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) {
@@ -180,7 +188,7 @@ class AgentEventPoster {
         if (opts?.pullRequestUrl)
             body.pullRequestUrl = opts.pullRequestUrl;
         if (opts?.toolExecution)
-            body.toolExecution = opts.toolExecution;
+            body.toolExecution = protoJsonToolExecution(opts.toolExecution);
         const streamRole = isStreamFanoutRole(role);
         this.chain = this.chain.then(async () => {
             const live = !!opts?.liveStream && !opts?.durable;
@@ -207,7 +215,7 @@ class AgentEventPoster {
                 if (opts?.opencodeSessionId)
                     eph.opencodeSessionId = opts.opencodeSessionId;
                 if (opts?.toolExecution)
-                    eph.toolExecution = opts.toolExecution;
+                    eph.toolExecution = protoJsonToolExecution(opts.toolExecution);
                 try {
                     await postJson(this.backend, this.apiKey, "/api/chimphands/post_ephemeral_agent_event", eph);
                     this.ephemeralFailCount = 0;
@@ -308,14 +316,44 @@ function normalizeEpochMillis(raw) {
     return raw < 1_000_000_000_000 ? Math.round(raw * 1000) : Math.round(raw);
 }
 function coerceTimeoutMillis(input) {
-    if (!input)
+    if (input == null)
+        return undefined;
+    let obj;
+    if (typeof input === "string") {
+        try {
+            const parsed = JSON.parse(input);
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                obj = parsed;
+            }
+        }
+        catch {
+            return undefined;
+        }
+    }
+    else {
+        obj = input;
+    }
+    if (!obj)
         return undefined;
-    const raw = input.timeout ?? input.timeoutMs ?? input.timeout_ms;
+    const raw = obj.timeout ?? obj.timeoutMs ?? obj.timeout_ms;
     const n = typeof raw === "number" ? raw : typeof raw === "string" ? Number(raw) : NaN;
     if (!Number.isFinite(n) || n <= 0)
         return undefined;
     return Math.round(n);
 }
+/** Protobuf JSON encodes int64 as strings; numbers can fail JsonFormat.parse. */
+function protoJsonToolExecution(payload) {
+    const out = { status: payload.status };
+    if (payload.toolName)
+        out.toolName = payload.toolName;
+    if (payload.startedAtMillis != null)
+        out.startedAtMillis = String(payload.startedAtMillis);
+    if (payload.timeoutMillis != null)
+        out.timeoutMillis = String(payload.timeoutMillis);
+    if (payload.endedAtMillis != null)
+        out.endedAtMillis = String(payload.endedAtMillis);
+    return out;
+}
 function mapToolExecutionStatus(status) {
     const s = String(status || "").trim().toLowerCase();
     if (!s)
@@ -1071,6 +1109,8 @@ async function injectOpencodeUserMessage(attachUrl, opencodeSessionId, content)
                 "x-opencode-directory": process.cwd(),
             },
             body: JSON.stringify({
+                agent: OPENCODE_AGENT_ID,
+                noReply: false,
                 parts: [{ type: "text", text: content }],
             }),
         });
@@ -1497,6 +1537,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) {
@@ -1811,6 +1856,10 @@ export async function runChimphands(opts) {
     const idleMs = (bootNum(boot, "idle_timeout_seconds", "idleTimeoutSeconds") || 600) * 1000;
     const queue = [];
     const seenUserMessageIds = new Set();
+    /** Mid-turn prompt_async successes that may need a follow-up turn if OpenCode never answered. */
+    const midTurnInjectedById = new Map();
+    /** Steering keys answered by the parallel child-session sidecar. */
+    const midTurnSidecarAnswered = new Set();
     let idle = false;
     let sessionActive = true;
     let lastUserActivity = Date.now();
@@ -1859,6 +1908,40 @@ export async function runChimphands(opts) {
             }
         }
     };
+    const noteMidTurnInjectSuccess = (steeringKey, content) => {
+        midTurnInjectedById.set(steeringKey, normalizeUserMessage(content));
+    };
+    const deliverMidTurnSteeringSidecar = (steeringKey, content) => {
+        const parentSessionId = opencodeSessionId?.trim();
+        if (!attachUrl || !parentSessionId)
+            return;
+        void runSteeringSidecarReply({
+            attachUrl,
+            parentSessionId,
+            userQuestion: content,
+            conversationSummary,
+            model: opencodeModel,
+            agentId: OPENCODE_AGENT_ID,
+        })
+            .then((replyParts) => {
+            if (!replyParts.length) {
+                console.error(`ChimpHands steering sidecar returned no text for ${steeringKey}`);
+                return;
+            }
+            midTurnSidecarAnswered.add(steeringKey);
+            for (const text of replyParts) {
+                postEvent(ROLE_ASSISTANT, text, {
+                    durable: true,
+                    opencodeSessionId: parentSessionId,
+                    messageId: `ch_steering_${steeringKey}_${Date.now()}`,
+                });
+            }
+            console.error(`ChimpHands steering sidecar answered mid-turn message ${steeringKey} (${replyParts.length} part(s))`);
+        })
+            .catch((err) => {
+            console.error(`ChimpHands steering sidecar failed for ${steeringKey}: ${err instanceof Error ? err.message : String(err)}`);
+        });
+    };
     const flushPendingMidTurnInject = () => {
         if (!attachUrl || !agentTurnInProgress)
             return;
@@ -1867,11 +1950,15 @@ export async function runChimphands(opts) {
             return;
         while (pendingMidTurnInject.length) {
             const content = pendingMidTurnInject.shift();
+            const steeringKey = midTurnSteeringKey(undefined, content);
             void injectOpencodeUserMessage(attachUrl, sessionToInject, content).then((ok) => {
                 if (!ok) {
                     queue.push(content);
                     wakePromptWaiter();
+                    return;
                 }
+                noteMidTurnInjectSuccess(steeringKey, content);
+                deliverMidTurnSteeringSidecar(steeringKey, content);
             });
         }
     };
@@ -1892,13 +1979,16 @@ export async function runChimphands(opts) {
             const sessionToInject = opencodeSessionId?.trim();
             if (sessionToInject) {
                 console.error(`ChimpHands delivering mid-turn user message via OpenCode prompt_async (turnActive=true): ${JSON.stringify(preview)}`);
+                const steeringKey = midTurnSteeringKey(id, content);
                 void injectOpencodeUserMessage(attachUrl, sessionToInject, content).then((ok) => {
                     if (!ok) {
                         queue.push(content);
                         wakePromptWaiter();
                         return;
                     }
-                    postEvent(ROLE_STATUS, "Message sent to agent…", { status: STATUS_RUNNING });
+                    noteMidTurnInjectSuccess(steeringKey, content);
+                    postEvent(ROLE_STATUS, MID_TURN_DELIVERED_STATUS, { status: STATUS_RUNNING });
+                    deliverMidTurnSteeringSidecar(steeringKey, content);
                 });
                 return;
             }
@@ -2169,6 +2259,14 @@ export async function runChimphands(opts) {
             if (!poster.uiAttached) {
                 await commitAndPushDirtyWorktree("chimphands: commit after turn (async / no UI attached)");
             }
+            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}`);
@@ -2272,26 +2370,30 @@ async function commitAndPushDirtyWorktree(message) {
     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;
+            const error = `refusing branch "${current || "(unknown)"}"`;
+            console.error(`ChimpHands skip commit-before-idle: ${error}`);
+            return { ok: false, error };
         }
         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",
@@ -2301,8 +2403,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) {
@@ -2315,23 +2418,28 @@ 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`);
+        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/chimphands/steeringSidecar.d.ts

@@ -0,0 +1,40 @@
+/** Parallel OpenCode child-session turn for mid-turn steering Q&A. */
+export type OpencodeModelRef = {
+    providerID: string;
+    modelID: string;
+};
+export declare function parseOpencodeModelRef(model: string): OpencodeModelRef | undefined;
+export declare function buildSteeringSidecarPrompt(userQuestion: string, conversationSummary: string): string;
+type OpencodeMessagePart = {
+    type?: string;
+    text?: string;
+    state?: {
+        status?: string;
+        output?: string;
+    };
+};
+type OpencodeMessageResponse = {
+    info?: {
+        role?: string;
+        id?: string;
+    };
+    parts?: OpencodeMessagePart[];
+};
+export declare function extractAssistantReplyParts(response: OpencodeMessageResponse): string[];
+export type SteeringSidecarOptions = {
+    attachUrl: string;
+    parentSessionId: string;
+    userQuestion: string;
+    conversationSummary?: string;
+    model: string;
+    agentId: string;
+    cwd?: string;
+    /** Max wait for the child-session /message round-trip. */
+    timeoutMs?: number;
+};
+/**
+ * Run a parallel OpenCode turn on a child session so the user gets an immediate
+ * answer while the main session stays blocked on a long-running tool.
+ */
+export declare function runSteeringSidecarReply(opts: SteeringSidecarOptions): Promise<string[]>;
+export {};

package/dist/chimphands/steeringSidecar.js

@@ -0,0 +1,103 @@
+/** Parallel OpenCode child-session turn for mid-turn steering Q&A. */
+export function parseOpencodeModelRef(model) {
+    const trimmed = model.trim();
+    if (!trimmed)
+        return undefined;
+    const slash = trimmed.indexOf("/");
+    if (slash <= 0 || slash >= trimmed.length - 1)
+        return undefined;
+    return {
+        providerID: trimmed.slice(0, slash),
+        modelID: trimmed.slice(slash + 1),
+    };
+}
+export function buildSteeringSidecarPrompt(userQuestion, conversationSummary) {
+    const summary = conversationSummary.trim();
+    const parts = [
+        "Mid-turn steering reply — the main ChimpHands session is still running a long command in parallel.",
+        "Answer the user's question directly and concisely.",
+        "Do NOT run bash/shell, edit files, or kick off long tools. Read-only lookup is OK if needed.",
+        "Do not repeat the full plan; focus on the question.",
+    ];
+    if (summary) {
+        parts.push("", "Conversation so far:", summary);
+    }
+    parts.push("", "User question:", userQuestion.trim());
+    return parts.join("\n");
+}
+export function extractAssistantReplyParts(response) {
+    const role = (response.info?.role || "").toLowerCase();
+    if (role && role !== "assistant")
+        return [];
+    const out = [];
+    for (const part of response.parts || []) {
+        if (part.type === "text" && part.text?.trim()) {
+            out.push(part.text.trim());
+        }
+    }
+    return out;
+}
+async function opencodeFetch(attachUrl, path, init, cwd) {
+    const base = attachUrl.replace(/\/$/, "");
+    return fetch(`${base}${path}`, {
+        ...init,
+        headers: {
+            Accept: "application/json",
+            "Content-Type": "application/json",
+            "x-opencode-directory": cwd,
+            ...init.headers,
+        },
+    });
+}
+async function createSteeringChildSession(attachUrl, parentSessionId, cwd) {
+    const res = await opencodeFetch(attachUrl, "/session", {
+        method: "POST",
+        body: JSON.stringify({
+            parentID: parentSessionId,
+            title: "ChimpHands steering",
+        }),
+    }, cwd);
+    if (!res.ok) {
+        throw new Error(`OpenCode create steering session HTTP ${res.status}`);
+    }
+    const data = (await res.json());
+    const childId = data.id?.trim();
+    if (!childId)
+        throw new Error("OpenCode create steering session returned no id");
+    return childId;
+}
+/**
+ * Run a parallel OpenCode turn on a child session so the user gets an immediate
+ * answer while the main session stays blocked on a long-running tool.
+ */
+export async function runSteeringSidecarReply(opts) {
+    const cwd = opts.cwd || process.cwd();
+    const childSessionId = await createSteeringChildSession(opts.attachUrl, opts.parentSessionId, cwd);
+    const modelRef = parseOpencodeModelRef(opts.model);
+    const prompt = buildSteeringSidecarPrompt(opts.userQuestion, opts.conversationSummary || "");
+    const timeoutMs = opts.timeoutMs ?? 120_000;
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), timeoutMs);
+    try {
+        const body = {
+            agent: opts.agentId,
+            noReply: false,
+            parts: [{ type: "text", text: prompt }],
+        };
+        if (modelRef)
+            body.model = modelRef;
+        const res = await opencodeFetch(opts.attachUrl, `/session/${encodeURIComponent(childSessionId)}/message`, {
+            method: "POST",
+            body: JSON.stringify(body),
+            signal: ac.signal,
+        }, cwd);
+        if (!res.ok) {
+            throw new Error(`OpenCode steering /message HTTP ${res.status}`);
+        }
+        const data = (await res.json());
+        return extractAssistantReplyParts(data);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

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

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

package/dist/chimphands/steeringSidecar.test.js

@@ -0,0 +1,28 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { buildSteeringSidecarPrompt, extractAssistantReplyParts, parseOpencodeModelRef, } from "./steeringSidecar.js";
+describe("parseOpencodeModelRef", () => {
+    it("splits provider/model", () => {
+        assert.deepEqual(parseOpencodeModelRef("testchimp/gpt-5.6-luna"), {
+            providerID: "testchimp",
+            modelID: "gpt-5.6-luna",
+        });
+    });
+});
+describe("buildSteeringSidecarPrompt", () => {
+    it("includes summary and user question", () => {
+        const prompt = buildSteeringSidecarPrompt("why WIF?", "Prior: discussed CI auth.");
+        assert.match(prompt, /why WIF\?/);
+        assert.match(prompt, /Prior: discussed CI auth\./);
+        assert.match(prompt, /Do NOT run bash/);
+    });
+});
+describe("extractAssistantReplyParts", () => {
+    it("returns text parts from assistant message", () => {
+        const parts = extractAssistantReplyParts({
+            info: { role: "assistant" },
+            parts: [{ type: "text", text: "Use WIF in CI." }],
+        });
+        assert.deepEqual(parts, ["Use WIF in CI."]);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testchimp/cli",
-  "version": "0.1.67",
+  "version": "0.1.69",
   "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",
+    "test": "npm run build && node --test dist/chimphands/llmRetryProxy.test.js dist/chimphands/midTurnSteering.test.js dist/chimphands/steeringSidecar.test.js",
     "watch": "tsc --watch",
     "start": "node dist/bin/testchimp.js",
     "prepublishOnly": "npm run build"