@ouro.bot/cli 0.1.0-alpha.9 → 0.1.0-alpha.90

package/dist/mind/token-estimate.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__internal = void 0;
 exports.estimateTokensForMessage = estimateTokensForMessage;
 exports.estimateTokensForMessages = estimateTokensForMessages;
 const runtime_1 = require("../nerves/runtime");
@@ -53,7 +52,7 @@ function countCharsInContent(content) {
             return c.text.length;
         if (typeof c.content === "string")
             return c.content.length;
-        return safeStringify(content).length;
+        return safeStringify(c).length;
     }
     return 0;
 }
@@ -70,12 +69,13 @@ function countCharsInToolCalls(toolCalls) {
         if (typeof t.type === "string")
             total += t.type.length;
         if (t.function && typeof t.function === "object") {
-            if (typeof t.function.name === "string")
-                total += t.function.name.length;
-            if (typeof t.function.arguments === "string")
-                total += t.function.arguments.length;
-            else if (t.function.arguments != null)
-                total += safeStringify(t.function.arguments).length;
+            const fn = t.function;
+            if (typeof fn.name === "string")
+                total += fn.name.length;
+            if (typeof fn.arguments === "string")
+                total += fn.arguments.length;
+            else if (fn.arguments != null)
+                total += safeStringify(fn.arguments).length;
         }
     }
     return total;
@@ -113,7 +113,3 @@ function estimateTokensForMessages(msgs) {
         total += estimateTokensForMessage(msg);
     return total;
 }
-exports.__internal = {
-    CHARS_PER_TOKEN,
-    PER_MESSAGE_OVERHEAD_TOKENS,
-};

package/dist/nerves/cli-logging.js

@@ -5,20 +5,33 @@ const config_1 = require("../heart/config");
 const nerves_1 = require("../nerves");
 const runtime_1 = require("./runtime");
 const runtime_2 = require("./runtime");
+const LEVEL_PRIORITY = { debug: 10, info: 20, warn: 30, error: 40 };
+/** Wrap a sink so it only receives events at or above the given level. */
+/* v8 ignore start -- internal filter plumbing, exercised via integration @preserve */
+function filterSink(sink, minLevel) {
+    const minPriority = LEVEL_PRIORITY[minLevel] ?? 0;
+    return (entry) => {
+        if ((LEVEL_PRIORITY[entry.level] ?? 0) >= minPriority)
+            sink(entry);
+    };
+}
 function resolveCliSinks(sinks) {
     const requested = sinks && sinks.length > 0 ? sinks : ["terminal", "ndjson"];
     return [...new Set(requested)];
 }
 function configureCliRuntimeLogger(_friendId, options = {}) {
     const sinkKinds = resolveCliSinks(options.sinks);
+    const level = options.level ?? "info";
     const sinks = sinkKinds.map((sinkKind) => {
         if (sinkKind === "terminal") {
-            return (0, nerves_1.createTerminalSink)();
+            // Terminal only shows warnings and errors — INFO is too noisy
+            // for an interactive session. Full detail goes to the ndjson file.
+            return filterSink((0, nerves_1.createTerminalSink)(), "warn");
         }
         return (0, nerves_1.createNdjsonFileSink)((0, config_1.logPath)("cli", "runtime"));
     });
     const logger = (0, nerves_1.createLogger)({
-        level: options.level ?? "info",
+        level,
         sinks,
     });
     (0, runtime_2.setRuntimeLogger)(logger);

package/dist/nerves/coverage/run-artifacts.js

@@ -14,7 +14,7 @@ const path_1 = require("path");
 const os_1 = require("os");
 exports.REPO_SLUG = "ouroboros-agent-harness";
 function getTestRunsRoot(repoSlug = exports.REPO_SLUG) {
-    return (0, path_1.join)((0, os_1.homedir)(), ".agentstate", "test-runs", repoSlug);
+    return (0, path_1.join)((0, os_1.tmpdir)(), "ouroboros-test-runs", repoSlug);
 }
 function createRunId(now = new Date()) {
     return now.toISOString().replace(/[:.]/g, "-");

package/dist/nerves/index.js

@@ -4,6 +4,7 @@ exports.createTraceId = createTraceId;
 exports.ensureTraceId = ensureTraceId;
 exports.createFanoutSink = createFanoutSink;
 exports.formatTerminalEntry = formatTerminalEntry;
+exports.registerSpinnerHooks = registerSpinnerHooks;
 exports.createTerminalSink = createTerminalSink;
 exports.createStderrSink = createStderrSink;
 exports.createNdjsonFileSink = createNdjsonFileSink;
@@ -73,15 +74,26 @@ function formatTerminalEntry(entry) {
     const level = entry.level.toUpperCase();
     return `${formatTerminalTime(entry.ts)} ${level} [${entry.component}] ${entry.message}${formatTerminalMeta(entry.meta)}`;
 }
+// Spinner coordination: the CLI sense registers these so log output
+// doesn't interleave with the active spinner animation.
+let _pauseSpinner = null;
+let _resumeSpinner = null;
+function registerSpinnerHooks(pause, resume) {
+    _pauseSpinner = pause;
+    _resumeSpinner = resume;
+}
 function createTerminalSink(write = (chunk) => process.stderr.write(chunk), colorize = true) {
     return (entry) => {
+        _pauseSpinner?.();
         const line = formatTerminalEntry(entry);
         if (!colorize) {
             write(`${line}\n`);
+            _resumeSpinner?.();
             return;
         }
         const prefix = LEVEL_COLORS[entry.level];
         write(`${prefix}${line}\x1b[0m\n`);
+        _resumeSpinner?.();
     };
 }
 function createStderrSink(write = (chunk) => process.stderr.write(chunk)) {

package/dist/repertoire/ado-client.js

@@ -28,8 +28,10 @@ function resolveContentType(method, path) {
         : "application/json";
 }
 // Generic ADO API request. Returns response body as pretty-printed JSON string.
-async function adoRequest(token, method, org, path, body) {
+// `host` overrides the base URL for non-standard APIs (e.g. "vsapm.dev.azure.com", "vssps.dev.azure.com").
+async function adoRequest(token, method, org, path, body, host) {
     try {
+        const base = host ? `https://${host}/${org}` : `${ADO_BASE}/${org}`;
         (0, runtime_1.emitNervesEvent)({
             event: "client.request_start",
             component: "clients",
@@ -37,7 +39,7 @@ async function adoRequest(token, method, org, path, body) {
             meta: { client: "ado", method, org, path },
         });
         const fullPath = ensureApiVersion(path);
-        const url = `${ADO_BASE}/${org}${fullPath}`;
+        const url = `${base}${fullPath}`;
         const contentType = resolveContentType(method, path);
         const opts = {
             method,

package/dist/repertoire/coding/feedback.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatCodingTail = formatCodingTail;
+exports.attachCodingSessionFeedback = attachCodingSessionFeedback;
+const identity_1 = require("../../heart/identity");
+const obligations_1 = require("../../heart/obligations");
+const runtime_1 = require("../../nerves/runtime");
+const TERMINAL_UPDATE_KINDS = new Set(["completed", "failed", "killed"]);
+function clip(text, maxLength = 280) {
+    const trimmed = text.trim();
+    if (trimmed.length <= maxLength)
+        return trimmed;
+    return `${trimmed.slice(0, maxLength - 3)}...`;
+}
+function isNoiseLine(line) {
+    return (/^-+$/.test(line)
+        || /^Reading prompt from stdin/i.test(line)
+        || /^OpenAI Codex v/i.test(line)
+        || /^workdir:/i.test(line)
+        || /^model:/i.test(line)
+        || /^provider:/i.test(line)
+        || /^approval:/i.test(line)
+        || /^sandbox:/i.test(line)
+        || /^reasoning effort:/i.test(line)
+        || /^reasoning summaries:/i.test(line)
+        || /^session id:/i.test(line)
+        || /^mcp startup:/i.test(line)
+        || /^tokens used$/i.test(line)
+        || /^\d{1,3}(,\d{3})*$/.test(line)
+        || /^\d{4}-\d{2}-\d{2}T.*\bWARN\b/.test(line)
+        || line === "user"
+        || line === "codex");
+}
+function lastMeaningfulLine(text) {
+    if (!text)
+        return null;
+    const lines = text
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .filter((line) => !isNoiseLine(line));
+    if (lines.length === 0)
+        return null;
+    return clip(lines.at(-1));
+}
+function formatSessionLabel(session) {
+    const origin = session.originSession
+        ? ` for ${session.originSession.channel}/${session.originSession.key}`
+        : "";
+    return `${session.runner} ${session.id}${origin}`;
+}
+function isSafeProgressSnippet(snippet) {
+    const wordCount = snippet.split(/\s+/).filter(Boolean).length;
+    return (snippet.length <= 80
+        && wordCount <= 8
+        && !snippet.includes(":")
+        && !snippet.startsWith("**")
+        && !/^Respond with\b/i.test(snippet)
+        && !/^Coding session metadata\b/i.test(snippet)
+        && !/^sessionId\b/i.test(snippet)
+        && !/^taskRef\b/i.test(snippet)
+        && !/^parentAgent\b/i.test(snippet));
+}
+function pickUpdateSnippet(update) {
+    return (lastMeaningfulLine(update.text)
+        ?? lastMeaningfulLine(update.session.stderrTail)
+        ?? lastMeaningfulLine(update.session.stdoutTail));
+}
+function formatUpdateMessage(update) {
+    const label = formatSessionLabel(update.session);
+    const snippet = pickUpdateSnippet(update);
+    switch (update.kind) {
+        case "progress":
+            return snippet && isSafeProgressSnippet(snippet) ? `${label}: ${snippet}` : null;
+        case "waiting_input":
+            return snippet ? `${label} waiting: ${snippet}` : `${label} waiting`;
+        case "stalled":
+            return snippet ? `${label} stalled: ${snippet}` : `${label} stalled`;
+        case "completed":
+            return snippet ? `${label} completed: ${snippet}` : `${label} completed`;
+        case "failed":
+            return snippet ? `${label} failed: ${snippet}` : `${label} failed`;
+        case "killed":
+            return `${label} killed`;
+        case "spawned":
+            return `${label} started`;
+    }
+}
+function obligationNoteFromUpdate(update) {
+    const snippet = pickUpdateSnippet(update);
+    switch (update.kind) {
+        case "spawned":
+            return update.session.originSession
+                ? `coding session started for ${update.session.originSession.channel}/${update.session.originSession.key}`
+                : "coding session started";
+        case "progress":
+            return snippet ? `coding session progress: ${snippet}` : null;
+        case "waiting_input":
+            return snippet ? `coding session waiting: ${snippet}` : "coding session waiting for input";
+        case "stalled":
+            return snippet ? `coding session stalled: ${snippet}` : "coding session stalled";
+        case "completed":
+            return snippet
+                ? `coding session completed: ${snippet}; merge/update still pending`
+                : "coding session completed; merge/update still pending";
+        case "failed":
+            return snippet ? `coding session failed: ${snippet}` : "coding session failed";
+        case "killed":
+            return "coding session killed";
+    }
+}
+function syncObligationFromUpdate(update) {
+    const obligationId = update.session.obligationId;
+    if (!obligationId)
+        return;
+    try {
+        (0, obligations_1.advanceObligation)((0, identity_1.getAgentRoot)(), obligationId, {
+            status: "investigating",
+            currentSurface: { kind: "coding", label: `${update.session.runner} ${update.session.id}` },
+            latestNote: obligationNoteFromUpdate(update) ?? undefined,
+        });
+    }
+    catch {
+        // Detached feedback should still reach the human even if obligation sync is unavailable.
+    }
+}
+function formatCodingTail(session) {
+    const stdout = session.stdoutTail.trim() || "(empty)";
+    const stderr = session.stderrTail.trim() || "(empty)";
+    return [
+        `sessionId: ${session.id}`,
+        `runner: ${session.runner}`,
+        `status: ${session.status}`,
+        `workdir: ${session.workdir}`,
+        "",
+        "[stdout]",
+        stdout,
+        "",
+        "[stderr]",
+        stderr,
+    ].join("\n");
+}
+function attachCodingSessionFeedback(manager, session, target) {
+    let lastMessage = "";
+    let closed = false;
+    let unsubscribe = () => { };
+    const sendMessage = (message) => {
+        if (closed || !message || message === lastMessage) {
+            return;
+        }
+        lastMessage = message;
+        void Promise.resolve(target.send(message)).catch((error) => {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "repertoire",
+                event: "repertoire.coding_feedback_error",
+                message: "coding feedback transport failed",
+                meta: {
+                    sessionId: session.id,
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+        });
+    };
+    const spawnedUpdate = { kind: "spawned", session };
+    syncObligationFromUpdate(spawnedUpdate);
+    sendMessage(formatUpdateMessage(spawnedUpdate));
+    unsubscribe = manager.subscribe(session.id, async (update) => {
+        syncObligationFromUpdate(update);
+        sendMessage(formatUpdateMessage(update));
+        if (TERMINAL_UPDATE_KINDS.has(update.kind)) {
+            closed = true;
+            unsubscribe();
+        }
+    });
+    return () => {
+        closed = true;
+        unsubscribe();
+    };
+}

package/dist/repertoire/coding/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatCodingMonitorReport = exports.CodingSessionMonitor = exports.CodingSessionManager = void 0;
+exports.formatCodingTail = exports.attachCodingSessionFeedback = exports.formatCodingMonitorReport = exports.CodingSessionMonitor = exports.CodingSessionManager = void 0;
 exports.getCodingSessionManager = getCodingSessionManager;
 exports.resetCodingSessionManager = resetCodingSessionManager;
 const runtime_1 = require("../../nerves/runtime");
@@ -34,3 +34,6 @@ var monitor_1 = require("./monitor");
 Object.defineProperty(exports, "CodingSessionMonitor", { enumerable: true, get: function () { return monitor_1.CodingSessionMonitor; } });
 var reporter_1 = require("./reporter");
 Object.defineProperty(exports, "formatCodingMonitorReport", { enumerable: true, get: function () { return reporter_1.formatCodingMonitorReport; } });
+var feedback_1 = require("./feedback");
+Object.defineProperty(exports, "attachCodingSessionFeedback", { enumerable: true, get: function () { return feedback_1.attachCodingSessionFeedback; } });
+Object.defineProperty(exports, "formatCodingTail", { enumerable: true, get: function () { return feedback_1.formatCodingTail; } });

package/dist/repertoire/coding/manager.js

@@ -35,7 +35,6 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CodingSessionManager = void 0;
 const fs = __importStar(require("fs"));
-const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const identity_1 = require("../../heart/identity");
 const runtime_1 = require("../../nerves/runtime");
@@ -49,7 +48,7 @@ function safeAgentName() {
     }
 }
 function defaultStateFilePath(agentName) {
-    return path.join(os.homedir(), ".agentstate", agentName, "coding", "sessions.json");
+    return path.join((0, identity_1.getAgentRoot)(agentName), "state", "coding", "sessions.json");
 }
 function isPidAlive(pid) {
     try {
@@ -63,6 +62,9 @@ function isPidAlive(pid) {
 function cloneSession(session) {
     return {
         ...session,
+        originSession: session.originSession ? { ...session.originSession } : undefined,
+        stdoutTail: session.stdoutTail,
+        stderrTail: session.stderrTail,
         failure: session.failure
             ? {
                 ...session.failure,
@@ -115,6 +117,7 @@ function defaultFailureDiagnostics(code, signal, command, args, stdoutTail, stde
 }
 class CodingSessionManager {
     records = new Map();
+    listeners = new Map();
     spawnProcess;
     nowIso;
     maxRestarts;
@@ -155,9 +158,13 @@ class CodingSessionManager {
             runner: normalizedRequest.runner,
             workdir: normalizedRequest.workdir,
             taskRef: normalizedRequest.taskRef,
+            originSession: normalizedRequest.originSession ? { ...normalizedRequest.originSession } : undefined,
+            obligationId: normalizedRequest.obligationId,
             scopeFile: normalizedRequest.scopeFile,
             stateFile: normalizedRequest.stateFile,
             status: "spawning",
+            stdoutTail: "",
+            stderrTail: "",
             pid: null,
             startedAt: now,
             lastActivityAt: now,
@@ -188,6 +195,7 @@ class CodingSessionManager {
             meta: { id, runner: normalizedRequest.runner, pid: session.pid },
         });
         this.persistState();
+        this.notifyListeners(id, { kind: "spawned", session: cloneSession(session) });
         return cloneSession(session);
     }
     listSessions() {
@@ -199,6 +207,20 @@ class CodingSessionManager {
         const record = this.records.get(sessionId);
         return record ? cloneSession(record.session) : null;
     }
+    subscribe(sessionId, listener) {
+        const listeners = this.listeners.get(sessionId) ?? new Set();
+        listeners.add(listener);
+        this.listeners.set(sessionId, listeners);
+        return () => {
+            const current = this.listeners.get(sessionId);
+            if (!current)
+                return;
+            current.delete(listener);
+            if (current.size === 0) {
+                this.listeners.delete(sessionId);
+            }
+        };
+    }
     sendInput(sessionId, input) {
         const record = this.records.get(sessionId);
         if (!record || !record.process) {
@@ -234,6 +256,7 @@ class CodingSessionManager {
             meta: { id: sessionId },
         });
         this.persistState();
+        this.notifyListeners(sessionId, { kind: "killed", session: cloneSession(record.session) });
         return { ok: true, message: `killed ${sessionId}` };
     }
     checkStalls(nowMs = Date.now()) {
@@ -254,6 +277,7 @@ class CodingSessionManager {
                 message: "coding session stalled",
                 meta: { id: record.session.id, elapsedMs: elapsed },
             });
+            this.notifyListeners(record.session.id, { kind: "stalled", session: cloneSession(record.session) });
             if (record.request.autoRestartOnStall !== false && record.session.restartCount < this.maxRestarts) {
                 this.restartSession(record, "stalled");
             }
@@ -297,18 +321,23 @@ class CodingSessionManager {
     }
     onOutput(record, text, stream) {
         record.session.lastActivityAt = this.nowIso();
+        let updateKind = "progress";
         if (stream === "stdout") {
             record.stdoutTail = appendTail(record.stdoutTail, text);
+            record.session.stdoutTail = record.stdoutTail;
         }
         else {
             record.stderrTail = appendTail(record.stderrTail, text);
+            record.session.stderrTail = record.stderrTail;
         }
         if (text.includes("status: NEEDS_REVIEW") || text.includes("❌ blocked")) {
             record.session.status = "waiting_input";
+            updateKind = "waiting_input";
         }
         if (text.includes("✅ all units complete")) {
             record.session.status = "completed";
             record.session.endedAt = this.nowIso();
+            updateKind = "completed";
         }
         (0, runtime_1.emitNervesEvent)({
             component: "repertoire",
@@ -317,6 +346,12 @@ class CodingSessionManager {
             meta: { id: record.session.id, status: record.session.status },
         });
         this.persistState();
+        this.notifyListeners(record.session.id, {
+            kind: updateKind,
+            session: cloneSession(record.session),
+            stream,
+            text,
+        });
     }
     onExit(record, code, signal) {
         if (!record.process)
@@ -334,6 +369,7 @@ class CodingSessionManager {
             record.session.status = "completed";
             record.session.endedAt = this.nowIso();
             this.persistState();
+            this.notifyListeners(record.session.id, { kind: "completed", session: cloneSession(record.session) });
             return;
         }
         if (record.request.autoRestartOnCrash !== false && record.session.restartCount < this.maxRestarts) {
@@ -351,6 +387,7 @@ class CodingSessionManager {
             meta: { id: record.session.id, code, signal, command: record.command },
         });
         this.persistState();
+        this.notifyListeners(record.session.id, { kind: "failed", session: cloneSession(record.session) });
     }
     restartSession(record, reason) {
         const replacement = normalizeSpawnResult(this.spawnProcess(record.request));
@@ -359,6 +396,8 @@ class CodingSessionManager {
         record.args = [...replacement.args];
         record.stdoutTail = "";
         record.stderrTail = "";
+        record.session.stdoutTail = "";
+        record.session.stderrTail = "";
         record.session.pid = replacement.process.pid ?? null;
         record.session.restartCount += 1;
         record.session.status = "running";
@@ -375,6 +414,26 @@ class CodingSessionManager {
         });
         this.persistState();
     }
+    notifyListeners(sessionId, update) {
+        const listeners = this.listeners.get(sessionId);
+        if (!listeners || listeners.size === 0)
+            return;
+        for (const listener of listeners) {
+            void Promise.resolve(listener(update)).catch((error) => {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "repertoire",
+                    event: "repertoire.coding_feedback_listener_error",
+                    message: "coding session listener failed",
+                    meta: {
+                        sessionId,
+                        kind: update.kind,
+                        reason: error instanceof Error ? error.message : String(error),
+                    },
+                });
+            });
+        }
+    }
     loadPersistedState() {
         if (!this.existsSync(this.stateFilePath)) {
             return;
@@ -426,13 +485,19 @@ class CodingSessionManager {
             }
             const normalizedRequest = {
                 ...request,
+                originSession: request.originSession ? { ...request.originSession } : undefined,
                 sessionId: request.sessionId ?? session.id,
+                obligationId: request.obligationId,
                 parentAgent: request.parentAgent ?? this.agentName,
             };
             const normalizedSession = {
                 ...session,
                 taskRef: session.taskRef ?? normalizedRequest.taskRef,
+                originSession: session.originSession ?? normalizedRequest.originSession,
+                obligationId: session.obligationId ?? normalizedRequest.obligationId,
                 failure: session.failure ?? null,
+                stdoutTail: session.stdoutTail ?? session.failure?.stdoutTail ?? "",
+                stderrTail: session.stderrTail ?? session.failure?.stderrTail ?? "",
             };
             if (typeof normalizedSession.pid === "number") {
                 const alive = this.pidAlive(normalizedSession.pid);
@@ -451,8 +516,8 @@ class CodingSessionManager {
                 process: null,
                 command: normalizedSession.failure?.command ?? "restored",
                 args: normalizedSession.failure ? [...normalizedSession.failure.args] : [],
-                stdoutTail: normalizedSession.failure?.stdoutTail ?? "",
-                stderrTail: normalizedSession.failure?.stderrTail ?? "",
+                stdoutTail: normalizedSession.stdoutTail,
+                stderrTail: normalizedSession.stderrTail,
             });
             this.sequence = Math.max(this.sequence, extractSequence(normalizedSession.id));
         }

package/dist/repertoire/coding/spawner.js

@@ -36,6 +36,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.spawnCodingProcess = spawnCodingProcess;
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
 const runtime_1 = require("../../nerves/runtime");
 function buildCommandArgs(runner, workdir) {
     if (runner === "claude") {
@@ -43,11 +45,11 @@ function buildCommandArgs(runner, workdir) {
             command: "claude",
             args: [
                 "-p",
+                "--verbose",
+                "--no-session-persistence",
                 "--dangerously-skip-permissions",
                 "--add-dir",
                 workdir,
-                "--input-format",
-                "stream-json",
                 "--output-format",
                 "stream-json",
             ],
@@ -58,6 +60,18 @@ function buildCommandArgs(runner, workdir) {
         args: ["exec", "--skip-git-repo-check", "--cd", workdir],
     };
 }
+function buildSpawnEnv(baseEnv, homeDir) {
+    const binDir = path.join(homeDir, ".ouro-cli", "bin");
+    const existingPath = baseEnv.PATH ?? "";
+    const pathEntries = existingPath.split(path.delimiter).filter((entry) => entry.length > 0);
+    if (!pathEntries.includes(binDir)) {
+        pathEntries.unshift(binDir);
+    }
+    return {
+        ...baseEnv,
+        PATH: pathEntries.join(path.delimiter),
+    };
+}
 function buildPrompt(request, deps) {
     const sections = [];
     sections.push([
@@ -79,8 +93,11 @@ function spawnCodingProcess(request, deps = {}) {
     const spawnFn = deps.spawnFn ?? ((command, args, options) => (0, child_process_1.spawn)(command, args, options));
     const existsSync = deps.existsSync ?? fs.existsSync;
     const readFileSync = deps.readFileSync ?? fs.readFileSync;
+    const homeDir = deps.homeDir ?? os.homedir();
+    const baseEnv = deps.baseEnv ?? process.env;
     const prompt = buildPrompt(request, { existsSync, readFileSync });
     const { command, args } = buildCommandArgs(request.runner, request.workdir);
+    const env = buildSpawnEnv(baseEnv, homeDir);
     (0, runtime_1.emitNervesEvent)({
         component: "repertoire",
         event: "repertoire.coding_spawn_start",
@@ -89,9 +106,10 @@ function spawnCodingProcess(request, deps = {}) {
     });
     const proc = spawnFn(command, args, {
         cwd: request.workdir,
+        env,
         stdio: ["pipe", "pipe", "pipe"],
     });
-    proc.stdin.write(`${prompt}\n`);
+    proc.stdin.end(`${prompt}\n`);
     (0, runtime_1.emitNervesEvent)({
         component: "repertoire",
         event: "repertoire.coding_spawn_end",