@astrosheep/keiyaku 0.1.0

package/build/response-builders.js

@@ -0,0 +1,289 @@
+import { resolveTermPreset } from "./term-presets.js";
+function formatSubagentFailure(failure) {
+    const { identity } = resolveTermPreset();
+    const base = `${identity} error: code=${failure.errorCode}, name=${failure.subagentName}, round=${failure.round}, timeoutMs=${failure.timeoutMs ?? "unknown"}, exitCode=${failure.exitCode ?? "none"}`;
+    if (failure.errorCode === "SUBAGENT_TIMEOUT") {
+        return `${base}. Suggestion: task likely too large; break it into smaller pieces and start another round.`;
+    }
+    return base;
+}
+function truncateForDisplay(raw, maxChars = 1500) {
+    const text = raw.trim();
+    if (text.length <= maxChars)
+        return text;
+    return `${text.slice(0, maxChars)}\n...[truncated ${text.length - maxChars} chars]...`;
+}
+function formatMaybe(label, value, maxChars = 400) {
+    if (!value)
+        return [];
+    const trimmed = value.trim();
+    if (!trimmed)
+        return [];
+    return [`${label}: ${truncateForDisplay(trimmed, maxChars)}`];
+}
+function formatList(label, items, opts) {
+    const maxItems = opts?.maxItems ?? 8;
+    const maxItemChars = opts?.maxItemChars ?? 180;
+    if (items.length === 0)
+        return [];
+    const head = [`${label} (${items.length}):`];
+    const shown = items.slice(0, maxItems).map((item) => `- ${truncateForDisplay(item, maxItemChars)}`);
+    const tail = items.length > maxItems ? [`...(+${items.length - maxItems} more)`] : [];
+    return [...head, ...shown, ...tail];
+}
+function formatSubagentFailureDetails(failure) {
+    const lines = [formatSubagentFailure(failure), `Subagent message: ${failure.message}`];
+    if (failure.stderrSnippet) {
+        lines.push("Subagent stderr (snippet):");
+        lines.push(truncateForDisplay(failure.stderrSnippet));
+    }
+    return lines;
+}
+export function buildKeiyakuSuccessResponse(result, input) {
+    const failureLine = result.subagentFailure ? formatSubagentFailureDetails(result.subagentFailure) : [];
+    const diffPreviewLines = [
+        `Diff Preview: showing ${result.diff.files.length} of ${result.diff.stats.filesChanged} file(s); omitted=${result.diff.omittedFileCount}`,
+        ...result.diff.files.flatMap((f) => {
+            const status = f.status === "R" && f.oldPath ? `R (${f.oldPath} -> ${f.path})` : f.status;
+            const flags = [f.binary ? "binary" : null, f.truncated ? "truncated" : null].filter(Boolean).join(", ");
+            const suffix = flags ? ` (${flags})` : "";
+            const header = `- ${status} ${f.path} | +${f.additions} -${f.deletions}${suffix}`;
+            if (!f.patch)
+                return [header];
+            return [header, "```diff", f.patch, "```", ""];
+        }),
+    ];
+    const inputEcho = [
+        "Inputs:",
+        `Title: ${truncateForDisplay(input.title, 200)}`,
+        `Goal: ${truncateForDisplay(input.goal, 500)}`,
+        ...formatMaybe("Directive", input.directive, 300),
+        ...formatList("Criteria", input.criteria, { maxItems: 10, maxItemChars: 200 }),
+        ...formatMaybe("Context", input.context, 600),
+        ...formatMaybe("Constraints", input.constraints, 600),
+        ...formatMaybe(resolveTermPreset().identity, input.subagentName, 120),
+        ...formatMaybe("CWD", input.cwd, 300),
+    ];
+    const nextHint = [
+        "Next: CRITICALLY review the diff and trace. Don't blindly trust the output—ensure these changes align with your actual intent.",
+        "Decide whether to start another round to refine, or finalize (invoke_judgment DONE) if it meets your standards.",
+        "Suggested commands:",
+        `  git diff --stat ${result.baseBranch}...HEAD`,
+        `  git diff ${result.baseBranch}...HEAD -- path/to/file`,
+    ].join("\n");
+    return {
+        content: [
+            {
+                type: "text",
+                text: [
+                    "Keiyaku started successfully.",
+                    `Round: ${result.round}`,
+                    `Branch: ${result.branch} (base: ${result.baseBranch})`,
+                    `Repo state: currently on ${result.branch}; round changes are already committed.`,
+                    `Diff Stats: files=${result.diff.stats.filesChanged}, +${result.diff.stats.insertions}, -${result.diff.stats.deletions}`,
+                    ...diffPreviewLines,
+                    ...failureLine,
+                    `Summary: ${result.summary}`,
+                    ...inputEcho,
+                    "",
+                    nextHint,
+                ].join("\n"),
+            },
+        ],
+        structuredContent: {
+            ok: true,
+            tool: "summon",
+            status: "started",
+            nextAction: "review_round_output",
+            nextHint,
+            inputEcho,
+            ...result,
+        },
+    };
+}
+export function buildDriveResponse(result, input) {
+    const failureLine = result.subagentFailure ? formatSubagentFailureDetails(result.subagentFailure) : [];
+    const diffPreviewLines = [
+        `Diff Preview: showing ${result.diff.files.length} of ${result.diff.stats.filesChanged} file(s); omitted=${result.diff.omittedFileCount}`,
+        ...result.diff.files.flatMap((f) => {
+            const status = f.status === "R" && f.oldPath ? `R (${f.oldPath} -> ${f.path})` : f.status;
+            const flags = [f.binary ? "binary" : null, f.truncated ? "truncated" : null].filter(Boolean).join(", ");
+            const suffix = flags ? ` (${flags})` : "";
+            const header = `- ${status} ${f.path} | +${f.additions} -${f.deletions}${suffix}`;
+            if (!f.patch)
+                return [header];
+            return [header, "```diff", f.patch, "```", ""];
+        }),
+    ];
+    const inputEcho = [
+        "Inputs:",
+        `Directive: ${truncateForDisplay(input.directive, 600)}`,
+        ...formatMaybe("Context", input.context, 600),
+        ...formatMaybe(resolveTermPreset().identity, input.subagentName, 120),
+        ...formatMaybe("CWD", input.cwd, 300),
+    ];
+    const nextHint = [
+        "Next: CRITICALLY review the diff and trace. Don't blindly trust the output—ensure these changes align with your actual intent.",
+        "Decide whether to start another round to refine, or finalize (invoke_judgment DONE) if it meets your standards.",
+        "Suggested commands:",
+        `  git diff --stat ${result.baseBranch}...HEAD`,
+        `  git diff ${result.baseBranch}...HEAD -- path/to/file`,
+    ].join("\n");
+    return {
+        content: [
+            {
+                type: "text",
+                text: [
+                    "Drive accepted.",
+                    `Round: ${result.round}`,
+                    `Branch: ${result.branch} (base: ${result.baseBranch})`,
+                    `Repo state: currently on ${result.branch}; this round is already committed.`,
+                    `Diff Stats: files=${result.diff.stats.filesChanged}, +${result.diff.stats.insertions}, -${result.diff.stats.deletions}`,
+                    ...diffPreviewLines,
+                    `Summary: ${result.summary}`,
+                    ...failureLine,
+                    ...inputEcho,
+                    "",
+                    nextHint,
+                ].join("\n"),
+            },
+        ],
+        structuredContent: {
+            ok: true,
+            tool: "drive",
+            status: "iterating",
+            nextAction: "review_round_output",
+            nextHint,
+            inputEcho,
+            ...result,
+        },
+    };
+}
+export function buildAskResponse(result, input) {
+    const inputEcho = [
+        "Inputs:",
+        `Request: ${truncateForDisplay(input.request, 600)}`,
+        `Context: ${truncateForDisplay(input.context, 800)}`,
+        ...formatMaybe(resolveTermPreset().identity, input.subagentName, 120),
+        ...formatMaybe("CWD", input.cwd, 300),
+    ];
+    const nextHint = "Next: decide whether you need another round, a new keiyaku, or no further action.";
+    return {
+        content: [
+            {
+                type: "text",
+                text: [
+                    "Ask completed.",
+                    `Summary: ${result.summary}`,
+                    ...inputEcho,
+                    "",
+                    nextHint,
+                ].join("\n"),
+            },
+        ],
+        structuredContent: {
+            ok: true,
+            tool: "ask",
+            status: "completed",
+            nextAction: "continue_normal_development",
+            nextHint,
+            inputEcho,
+            ...result,
+        },
+    };
+}
+export function buildJudgmentDoneResponse(result, input) {
+    const inputEcho = [
+        "Inputs:",
+        `Result: DONE`,
+        ...formatList("Criteria checks", input.criteriaChecks, { maxItems: 10, maxItemChars: 220 }),
+        `Quality flags: metPrecise=${input.metPrecise} metMinimal=${input.metMinimal} metIsolated=${input.metIsolated} metIdiomatic=${input.metIdiomatic} metCohesive=${input.metCohesive}`,
+        ...formatMaybe("Oath", input.oath, 220),
+        ...formatMaybe("CWD", input.cwd, 300),
+    ];
+    const nextHint = "Next: decide whether you need another keiyaku; if yes, start one. Otherwise continue normal development.";
+    return {
+        content: [
+            {
+                type: "text",
+                text: [
+                    "Invoke judgment accepted: DONE.",
+                    `Branch: ${result.branch} -> ${result.baseBranch}`,
+                    `Diff Stats: files=${result.diffStats?.filesChanged ?? 0}, +${result.diffStats?.insertions ?? 0}, -${result.diffStats?.deletions ?? 0}`,
+                    "Merged to base branch and cleaned keiyaku branch.",
+                    ...inputEcho,
+                    "",
+                    nextHint,
+                ].join("\n"),
+            },
+        ],
+        structuredContent: {
+            ok: true,
+            tool: "invoke_judgment",
+            nextAction: "continue_normal_development",
+            nextHint,
+            inputEcho,
+            ...result,
+        },
+    };
+}
+export function buildJudgmentDropResponse(result, input) {
+    const inputEcho = [
+        "Inputs:",
+        `Result: DROP`,
+        ...formatList("Criteria checks", input.criteriaChecks, { maxItems: 10, maxItemChars: 220 }),
+        `Quality flags: metPrecise=${input.metPrecise} metMinimal=${input.metMinimal} metIsolated=${input.metIsolated} metIdiomatic=${input.metIdiomatic} metCohesive=${input.metCohesive}`,
+        ...formatMaybe("Oath", input.oath, 220),
+        ...formatMaybe("CWD", input.cwd, 300),
+    ];
+    const nextHint = "Next: decide whether the task still needs doing; if yes, start a new keiyaku with clarified inputs.";
+    return {
+        content: [
+            {
+                type: "text",
+                text: [
+                    "Invoke judgment accepted: DROP.",
+                    "Discarded keiyaku branch and returned to base branch.",
+                    ...inputEcho,
+                    "",
+                    nextHint,
+                ].join("\n"),
+            },
+        ],
+        structuredContent: {
+            ok: true,
+            tool: "invoke_judgment",
+            nextAction: "start_new_keiyaku_if_needed",
+            nextHint,
+            inputEcho,
+            ...result,
+        },
+    };
+}
+export function buildToolErrorResponse(input) {
+    const inputEcho = (input.inputEcho ?? []).map((line) => truncateForDisplay(line, 800));
+    return {
+        content: [
+            {
+                type: "text",
+                text: [
+                    `${input.title} failed.`,
+                    `Reason: ${input.message}`,
+                    `Hint: ${input.hint}`,
+                    ...inputEcho,
+                ].join("\n"),
+            },
+        ],
+        structuredContent: {
+            ok: false,
+            tool: input.tool,
+            status: "error",
+            errorType: input.errorType,
+            errorCode: input.errorCode,
+            error: input.message,
+            hint: input.hint,
+            inputEcho,
+        },
+        isError: true,
+    };
+}

package/build/subagent-exec/codex-exec.js

@@ -0,0 +1,33 @@
+import { runSubagentProcess, resolvePositiveIntFromEnv, resolvePrefixedCommand } from "./process-runner.js";
+const DEFAULT_CODEX_EXEC_TIMEOUT_MS = 20 * 60 * 1000;
+const DEFAULT_CODEX_EXEC_MAX_CAPTURE_CHARS = 200_000;
+export async function runCodexExec(prompt, cwd, options = {}) {
+    const timeoutMs = resolvePositiveIntFromEnv("KEIYAKU_CODEX_EXEC_TIMEOUT_MS", DEFAULT_CODEX_EXEC_TIMEOUT_MS);
+    const maxCaptureChars = resolvePositiveIntFromEnv("KEIYAKU_CODEX_EXEC_MAX_CAPTURE_CHARS", DEFAULT_CODEX_EXEC_MAX_CAPTURE_CHARS);
+    const codexArgs = ["exec", "--full-auto", "-C", cwd];
+    if (options.model) {
+        codexArgs.push("-m", options.model);
+    }
+    if (options.effort) {
+        codexArgs.push("-c", `model_reasoning_effort=${options.effort}`);
+    }
+    codexArgs.push("-");
+    const { command, args } = resolvePrefixedCommand("codex", codexArgs, process.env.KEIYAKU_CODEX_EXEC_PREFIX);
+    const { stdout, stderr } = await runSubagentProcess({
+        runnerName: "runCodexExec",
+        provider: "codex",
+        command,
+        args,
+        cwd,
+        prompt,
+        timeoutMs,
+        maxCaptureChars,
+        signal: options.signal,
+        startDetails: `model=${options.model ?? "default"} effort=${options.effort ?? "default"}`,
+    });
+    return {
+        finalMessage: stdout.trim(),
+        stdout,
+        stderr,
+    };
+}

package/build/subagent-exec/gemini-exec.js

@@ -0,0 +1,37 @@
+import { runSubagentProcess, resolvePositiveIntFromEnv, resolvePrefixedCommand } from "./process-runner.js";
+const DEFAULT_GEMINI_EXEC_TIMEOUT_MS = 20 * 60 * 1000;
+const DEFAULT_GEMINI_EXEC_MAX_CAPTURE_CHARS = 200_000;
+export async function runGeminiExec(prompt, cwd, options = {}) {
+    const timeoutMs = resolvePositiveIntFromEnv("KEIYAKU_GEMINI_EXEC_TIMEOUT_MS", DEFAULT_GEMINI_EXEC_TIMEOUT_MS);
+    const maxCaptureChars = resolvePositiveIntFromEnv("KEIYAKU_GEMINI_EXEC_MAX_CAPTURE_CHARS", DEFAULT_GEMINI_EXEC_MAX_CAPTURE_CHARS);
+    const geminiArgs = ["--approval-mode", "yolo", "--output-format", "json"];
+    if (options.model) {
+        geminiArgs.push("-m", options.model);
+    }
+    // Prompt is passed via stdin to avoid command-line length limits.
+    geminiArgs.push("--prompt", "-");
+    const { command, args } = resolvePrefixedCommand("gemini", geminiArgs, process.env.KEIYAKU_GEMINI_EXEC_PREFIX);
+    const { stdout, stderr } = await runSubagentProcess({
+        runnerName: "runGeminiExec",
+        provider: "gemini",
+        command,
+        args,
+        cwd,
+        prompt,
+        timeoutMs,
+        maxCaptureChars,
+        signal: options.signal,
+        startDetails: `model=${options.model ?? "default"}`,
+    });
+    let finalMessage = stdout.trim();
+    try {
+        const parsed = JSON.parse(stdout);
+        if (parsed.response && typeof parsed.response === "string") {
+            finalMessage = parsed.response;
+        }
+    }
+    catch {
+        // Fall back to raw stdout when Gemini output is not valid JSON.
+    }
+    return { finalMessage, stdout, stderr };
+}

package/build/subagent-exec/index.js

@@ -0,0 +1,39 @@
+import { FlowError } from "../errors.js";
+import { runCodexExec } from "./codex-exec.js";
+import { runGeminiExec } from "./gemini-exec.js";
+import { isSubagentExecError, SubagentExecError } from "./types.js";
+const CODEX_MODEL = "gpt-5.3-codex";
+const GEMINI_MODEL = "gemini-3-flash-preview";
+const SUBAGENT_PROFILES = {
+    "servant-tier-B": { provider: "codex", model: CODEX_MODEL, effort: "low" },
+    "servant-tier-A": { provider: "codex", model: CODEX_MODEL, effort: "medium" },
+    "servant-tier-S": { provider: "codex", model: CODEX_MODEL, effort: "high" },
+};
+export { SubagentExecError, isSubagentExecError };
+export function getSubagentNames() {
+    return Object.keys(SUBAGENT_PROFILES);
+}
+export function resolveSubagentConfig(name) {
+    const config = SUBAGENT_PROFILES[name];
+    if (!config) {
+        throw new FlowError("UNKNOWN_SUBAGENT", `Unknown subagent '${name}'. Expected one of: ${getSubagentNames().join(", ")}`);
+    }
+    return config;
+}
+export async function runSubagentExec(name, prompt, cwd, options = {}) {
+    const config = resolveSubagentConfig(name);
+    if (config.provider === "codex") {
+        return runCodexExec(prompt, cwd, {
+            model: config.model,
+            effort: config.effort,
+            signal: options.signal,
+        });
+    }
+    if (config.provider === "gemini") {
+        return runGeminiExec(prompt, cwd, {
+            model: config.model,
+            signal: options.signal,
+        });
+    }
+    throw new SubagentExecError("SUBAGENT_EXEC_ERROR", `Unsupported subagent provider '${String(config.provider)}'.`);
+}

package/build/subagent-exec/process-runner.js

@@ -0,0 +1,207 @@
+import { spawn } from "node:child_process";
+import { appendDebugLog } from "../debug-log.js";
+import { StringTailBuffer } from "./string-tail-buffer.js";
+import { SubagentExecError } from "./types.js";
+function shellEscape(arg) {
+    return `'${arg.replace(/'/g, `'\\''`)}'`;
+}
+function createAbortError(message) {
+    const error = new Error(message);
+    error.name = "AbortError";
+    return error;
+}
+function createStderrStreamId() {
+    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function renderTruncationSuffix(truncatedChars) {
+    if (truncatedChars <= 0)
+        return "";
+    return `\n...[truncated ${truncatedChars} chars from start]...`;
+}
+function terminateChildTree(pid, detached, signal) {
+    if (!pid)
+        return;
+    if (detached && process.platform !== "win32") {
+        try {
+            process.kill(-pid, signal);
+            return;
+        }
+        catch {
+            // Fall through to direct child kill when process group kill fails.
+        }
+    }
+    try {
+        process.kill(pid, signal);
+    }
+    catch {
+        // Best effort shutdown.
+    }
+}
+function getCapturedOutput(stdoutBuffer, stderrBuffer) {
+    const stdoutSnapshot = stdoutBuffer.snapshot();
+    const stderrSnapshot = stderrBuffer.snapshot();
+    return {
+        stdout: `${stdoutSnapshot.text}${renderTruncationSuffix(stdoutSnapshot.truncatedChars)}`,
+        stderr: `${stderrSnapshot.text}${renderTruncationSuffix(stderrSnapshot.truncatedChars)}`,
+        stdoutSnapshot,
+        stderrSnapshot,
+    };
+}
+export function resolvePositiveIntFromEnv(envName, fallback) {
+    const value = process.env[envName]?.trim();
+    if (!value)
+        return fallback;
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return fallback;
+    return Math.floor(parsed);
+}
+export function resolvePrefixedCommand(binary, binaryArgs, commandPrefix) {
+    const prefix = commandPrefix?.trim();
+    if (!prefix) {
+        return { command: binary, args: binaryArgs };
+    }
+    return {
+        command: "sh",
+        args: ["-lc", `${prefix} ${binary} ${binaryArgs.map(shellEscape).join(" ")}`],
+    };
+}
+export async function runSubagentProcess(options) {
+    const stderrStreamId = createStderrStreamId();
+    let stderrStreamed = false;
+    const stderrSection = `${options.provider}-stderr`;
+    const prefixStderrChunk = (chunk) => {
+        const normalized = chunk.replace(/\r/g, "");
+        const lines = normalized.split("\n");
+        return lines.map((line) => `[stderr:${stderrStreamId}] ${line}`).join("\n");
+    };
+    try {
+        const detailsSuffix = options.startDetails ? ` ${options.startDetails}` : "";
+        appendDebugLog(`${options.runnerName} start: command=${options.command} args=${JSON.stringify(options.args)} timeoutMs=${options.timeoutMs} maxCaptureChars=${options.maxCaptureChars}${detailsSuffix}`, { cwd: options.cwd, section: options.provider });
+        const { stdout, stderr } = await new Promise((resolve, reject) => {
+            const detached = process.platform !== "win32";
+            const child = spawn(options.command, options.args, { cwd: options.cwd, detached });
+            const stdoutBuffer = new StringTailBuffer(options.maxCaptureChars);
+            const stderrBuffer = new StringTailBuffer(options.maxCaptureChars);
+            let stdoutTotalBytes = 0;
+            let stderrTotalBytes = 0;
+            let finished = false;
+            let forceKillTimer;
+            const finishWithError = (error) => {
+                if (finished)
+                    return;
+                finished = true;
+                clearTimeout(timeout);
+                if (forceKillTimer)
+                    clearTimeout(forceKillTimer);
+                if (options.signal && abortHandler) {
+                    options.signal.removeEventListener("abort", abortHandler);
+                }
+                reject(error);
+            };
+            const requestStop = (error) => {
+                if (finished)
+                    return;
+                appendDebugLog(`${options.runnerName} stop requested: ${error.message}`, { cwd: options.cwd, section: options.provider });
+                terminateChildTree(child.pid, detached, "SIGTERM");
+                forceKillTimer = setTimeout(() => {
+                    terminateChildTree(child.pid, detached, "SIGKILL");
+                }, 5000);
+                finishWithError(error);
+            };
+            const timeout = setTimeout(() => {
+                requestStop((() => {
+                    const captured = getCapturedOutput(stdoutBuffer, stderrBuffer);
+                    return new SubagentExecError("SUBAGENT_TIMEOUT", `${options.provider} exec timed out`, {
+                        timeoutMs: options.timeoutMs,
+                        stdout: captured.stdout,
+                        stderr: captured.stderr,
+                    });
+                })());
+            }, options.timeoutMs);
+            const abortHandler = () => {
+                requestStop(createAbortError(`${options.provider} exec cancelled by client`));
+            };
+            if (options.signal) {
+                if (options.signal.aborted) {
+                    requestStop(createAbortError(`${options.provider} exec cancelled by client`));
+                    return;
+                }
+                options.signal.addEventListener("abort", abortHandler, { once: true });
+            }
+            child.stdout.on("data", (chunk) => {
+                const text = String(chunk);
+                stdoutTotalBytes += Buffer.byteLength(text);
+                stdoutBuffer.append(text);
+            });
+            child.stderr.on("data", (chunk) => {
+                const text = String(chunk);
+                stderrTotalBytes += Buffer.byteLength(text);
+                stderrBuffer.append(text);
+                stderrStreamed = true;
+                appendDebugLog(prefixStderrChunk(text), { cwd: options.cwd, section: stderrSection });
+            });
+            child.on("error", (err) => {
+                appendDebugLog(`${options.runnerName} spawn error: ${err.message}`, { cwd: options.cwd, section: options.provider });
+                finishWithError((() => {
+                    const captured = getCapturedOutput(stdoutBuffer, stderrBuffer);
+                    return new SubagentExecError("SUBAGENT_SPAWN_ERROR", `${options.provider} exec spawn error: ${err.message}`, {
+                        timeoutMs: options.timeoutMs,
+                        stdout: captured.stdout,
+                        stderr: captured.stderr,
+                        cause: err,
+                    });
+                })());
+            });
+            child.on("close", (code) => {
+                clearTimeout(timeout);
+                if (forceKillTimer)
+                    clearTimeout(forceKillTimer);
+                if (options.signal) {
+                    options.signal.removeEventListener("abort", abortHandler);
+                }
+                if (finished)
+                    return;
+                finished = true;
+                const captured = getCapturedOutput(stdoutBuffer, stderrBuffer);
+                appendDebugLog(`${options.runnerName} close: code=${code} stdoutBytes=${stdoutTotalBytes} stderrBytes=${stderrTotalBytes} stdoutTruncatedChars=${captured.stdoutSnapshot.truncatedChars} stderrTruncatedChars=${captured.stderrSnapshot.truncatedChars}`, { cwd: options.cwd, section: options.provider });
+                if (code === 0) {
+                    resolve({ stdout: captured.stdout, stderr: captured.stderr });
+                    return;
+                }
+                const errorText = captured.stderr || captured.stdout || `${options.provider} exec exited with code ${code}`;
+                reject(new SubagentExecError("SUBAGENT_NON_ZERO_EXIT", errorText, {
+                    timeoutMs: options.timeoutMs,
+                    stdout: captured.stdout,
+                    stderr: captured.stderr,
+                    exitCode: code,
+                }));
+            });
+            child.stdin.end(options.prompt);
+        });
+        if (!stderrStreamed && stderr.trim()) {
+            appendDebugLog(`[stderr:${stderrStreamId}] ${stderr.trim()}`, { cwd: options.cwd, section: stderrSection });
+        }
+        return { stdout, stderr };
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            appendDebugLog(`${options.runnerName} error: ${error.name}: ${error.message}`, { cwd: options.cwd, section: options.provider });
+            if (error instanceof SubagentExecError) {
+                if (!stderrStreamed && error.stderr.trim()) {
+                    appendDebugLog(`[stderr:${stderrStreamId}] ${error.stderr.trim()}`, { cwd: options.cwd, section: stderrSection });
+                }
+            }
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+            throw error;
+        }
+        if (error instanceof SubagentExecError) {
+            throw error;
+        }
+        const message = error instanceof Error ? error.message : `Unknown ${options.provider} exec error`;
+        throw new SubagentExecError("SUBAGENT_EXEC_ERROR", `${options.provider} exec failed: ${message}`, {
+            timeoutMs: options.timeoutMs,
+        });
+    }
+}

package/build/subagent-exec/string-tail-buffer.js

@@ -0,0 +1,44 @@
+export class StringTailBuffer {
+    maxChars;
+    chunks = [];
+    keptChars = 0;
+    totalChars = 0;
+    constructor(maxChars) {
+        if (!Number.isFinite(maxChars) || maxChars <= 0) {
+            throw new Error(`invalid maxChars: ${maxChars}`);
+        }
+        this.maxChars = Math.floor(maxChars);
+    }
+    append(chunk) {
+        if (!chunk)
+            return;
+        this.totalChars += chunk.length;
+        if (chunk.length >= this.maxChars) {
+            this.chunks.length = 0;
+            this.chunks.push(chunk.slice(-this.maxChars));
+            this.keptChars = this.maxChars;
+            return;
+        }
+        this.chunks.push(chunk);
+        this.keptChars += chunk.length;
+        this.trimOverflow();
+    }
+    snapshot() {
+        const text = this.chunks.join("");
+        const truncatedChars = Math.max(0, this.totalChars - text.length);
+        return { text, totalChars: this.totalChars, truncatedChars };
+    }
+    trimOverflow() {
+        while (this.keptChars > this.maxChars && this.chunks.length > 0) {
+            const overflow = this.keptChars - this.maxChars;
+            const first = this.chunks[0];
+            if (first.length <= overflow) {
+                this.chunks.shift();
+                this.keptChars -= first.length;
+                continue;
+            }
+            this.chunks[0] = first.slice(overflow);
+            this.keptChars -= overflow;
+        }
+    }
+}

package/build/subagent-exec/types.js

@@ -0,0 +1,19 @@
+export class SubagentExecError extends Error {
+    code;
+    timeoutMs;
+    exitCode;
+    stdout;
+    stderr;
+    constructor(code, message, options = {}) {
+        super(message, options.cause === undefined ? undefined : { cause: options.cause });
+        this.name = "SubagentExecError";
+        this.code = code;
+        this.timeoutMs = options.timeoutMs ?? null;
+        this.exitCode = options.exitCode ?? null;
+        this.stdout = options.stdout ?? "";
+        this.stderr = options.stderr ?? "";
+    }
+}
+export function isSubagentExecError(error) {
+    return error instanceof SubagentExecError;
+}