@ouro.bot/cli 0.1.0-alpha.5 → 0.1.0-alpha.500

package/dist/repertoire/coding/manager.js

@@ -35,21 +35,15 @@ 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");
 const spawner_1 = require("./spawner");
-function safeAgentName() {
-    try {
-        return (0, identity_1.getAgentName)();
-    }
-    catch {
-        return "default";
-    }
-}
 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 defaultArtifactDirPath(agentName) {
+    return path.join((0, identity_1.getAgentRoot)(agentName), "state", "coding", "sessions");
 }
 function isPidAlive(pid) {
     try {
@@ -63,6 +57,11 @@ function isPidAlive(pid) {
 function cloneSession(session) {
     return {
         ...session,
+        originSession: session.originSession ? { ...session.originSession } : undefined,
+        checkpoint: session.checkpoint ?? null,
+        artifactPath: session.artifactPath,
+        stdoutTail: session.stdoutTail,
+        stderrTail: session.stderrTail,
         failure: session.failure
             ? {
                 ...session.failure,
@@ -84,6 +83,46 @@ function appendTail(existing, nextChunk, maxLength = 2000) {
     const combined = `${existing}${nextChunk}`;
     return combined.length <= maxLength ? combined : combined.slice(combined.length - maxLength);
 }
+function compactText(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+function clipText(text, maxLength = 240) {
+    return text.length <= maxLength ? text : `${text.slice(0, maxLength - 3)}...`;
+}
+function latestMeaningfulLine(text) {
+    const lines = text
+        .split(/\r?\n/)
+        .map((line) => compactText(line))
+        .filter(Boolean);
+    if (lines.length === 0)
+        return null;
+    return clipText(lines.at(-1));
+}
+function fallbackCheckpoint(status, code, signal) {
+    switch (status) {
+        case "waiting_input":
+            return "needs input";
+        case "stalled":
+            return "no recent output";
+        case "completed":
+            return "completed";
+        case "failed":
+            if (code !== null)
+                return `exit code ${code}`;
+            if (signal)
+                return `terminated by ${signal}`;
+            return "failed";
+        case "killed":
+            return "terminated by parent agent";
+        default:
+            return null;
+    }
+}
+function deriveCheckpoint(session) {
+    return (latestMeaningfulLine(session.stderrTail)
+        ?? latestMeaningfulLine(session.stdoutTail)
+        ?? fallbackCheckpoint(session.status, session.lastExitCode, session.lastSignal));
+}
 function isSpawnCodingResult(value) {
     return typeof value === "object" && value !== null && "process" in value;
 }
@@ -115,11 +154,13 @@ function defaultFailureDiagnostics(code, signal, command, args, stdoutTail, stde
 }
 class CodingSessionManager {
     records = new Map();
+    listeners = new Map();
     spawnProcess;
     nowIso;
     maxRestarts;
     defaultStallThresholdMs;
     stateFilePath;
+    artifactDirPath;
     existsSync;
     readFileSync;
     writeFileSync;
@@ -137,8 +178,19 @@ class CodingSessionManager {
         this.writeFileSync = options.writeFileSync ?? fs.writeFileSync;
         this.mkdirSync = options.mkdirSync ?? fs.mkdirSync;
         this.pidAlive = options.pidAlive ?? isPidAlive;
-        this.agentName = options.agentName ?? safeAgentName();
+        // No silent fallback to "default" — if there's no agentName and no
+        // explicit option, getAgentName() throws. The previous `safeAgentName`
+        // helper fell back to "default" and ended up writing coding session
+        // state to `~/AgentBundles/default.ouro/state/coding/sessions.json` on
+        // every vitest run because the coding manager singleton constructs with
+        // `{}`. That leaked real-fs state into the developer's home directory
+        // on every coverage run. Production callers always pass via argv (see
+        // getAgentName); test callers must either pass `agentName` explicitly
+        // or mock `../../heart/identity`.
+        this.agentName = options.agentName ?? (0, identity_1.getAgentName)();
         this.stateFilePath = options.stateFilePath ?? defaultStateFilePath(this.agentName);
+        this.artifactDirPath = options.artifactDirPath
+            ?? (options.stateFilePath ? path.dirname(options.stateFilePath) : defaultArtifactDirPath(this.agentName));
         this.loadPersistedState();
     }
     async spawnSession(request) {
@@ -155,9 +207,15 @@ 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,
+            checkpoint: null,
+            artifactPath: this.artifactPathFor(id),
             status: "spawning",
+            stdoutTail: "",
+            stderrTail: "",
             pid: null,
             startedAt: now,
             lastActivityAt: now,
@@ -188,6 +246,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 +258,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) {
@@ -226,6 +299,7 @@ class CodingSessionManager {
         record.process.kill("SIGTERM");
         record.process = null;
         record.session.status = "killed";
+        record.session.checkpoint = "terminated by parent agent";
         record.session.endedAt = this.nowIso();
         (0, runtime_1.emitNervesEvent)({
             component: "repertoire",
@@ -234,6 +308,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()) {
@@ -247,6 +322,7 @@ class CodingSessionManager {
                 continue;
             stalled += 1;
             record.session.status = "stalled";
+            record.session.checkpoint = deriveCheckpoint(record.session);
             (0, runtime_1.emitNervesEvent)({
                 level: "warn",
                 component: "repertoire",
@@ -254,6 +330,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");
             }
@@ -271,6 +348,7 @@ class CodingSessionManager {
             record.process = null;
             if (record.session.status === "running" || record.session.status === "spawning") {
                 record.session.status = "killed";
+                record.session.checkpoint = "terminated during manager shutdown";
                 record.session.endedAt = this.nowIso();
             }
         }
@@ -297,18 +375,30 @@ 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";
+        }
+        const checkpoint = latestMeaningfulLine(text);
+        if (checkpoint) {
+            record.session.checkpoint = checkpoint;
+        }
+        else if (!record.session.checkpoint) {
+            record.session.checkpoint = deriveCheckpoint(record.session);
         }
         (0, runtime_1.emitNervesEvent)({
             component: "repertoire",
@@ -317,6 +407,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)
@@ -327,13 +423,16 @@ class CodingSessionManager {
         record.session.lastSignal = signal;
         if (record.session.status === "killed" || record.session.status === "completed") {
             record.session.endedAt = this.nowIso();
+            record.session.checkpoint = deriveCheckpoint(record.session);
             this.persistState();
             return;
         }
         if (code === 0) {
             record.session.status = "completed";
             record.session.endedAt = this.nowIso();
+            record.session.checkpoint = deriveCheckpoint(record.session);
             this.persistState();
+            this.notifyListeners(record.session.id, { kind: "completed", session: cloneSession(record.session) });
             return;
         }
         if (record.request.autoRestartOnCrash !== false && record.session.restartCount < this.maxRestarts) {
@@ -343,6 +442,7 @@ class CodingSessionManager {
         record.session.status = "failed";
         record.session.endedAt = this.nowIso();
         record.session.failure = defaultFailureDiagnostics(code, signal, record.command, record.args, record.stdoutTail, record.stderrTail);
+        record.session.checkpoint = deriveCheckpoint(record.session);
         (0, runtime_1.emitNervesEvent)({
             level: "error",
             component: "repertoire",
@@ -351,6 +451,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,12 +460,15 @@ 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";
         record.session.lastActivityAt = this.nowIso();
         record.session.endedAt = null;
         record.session.failure = null;
+        record.session.checkpoint = `restarted after ${reason}`;
         this.attachProcessListeners(record);
         (0, runtime_1.emitNervesEvent)({
             level: "warn",
@@ -375,6 +479,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 +550,21 @@ 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 ?? "",
+                checkpoint: typeof session.checkpoint === "string" ? session.checkpoint : null,
+                artifactPath: typeof session.artifactPath === "string" ? session.artifactPath : this.artifactPathFor(session.id),
             };
             if (typeof normalizedSession.pid === "number") {
                 const alive = this.pidAlive(normalizedSession.pid);
@@ -445,14 +577,15 @@ class CodingSessionManager {
                     normalizedSession.pid = null;
                 }
             }
+            normalizedSession.checkpoint = normalizedSession.checkpoint ?? deriveCheckpoint(normalizedSession);
             this.records.set(normalizedSession.id, {
                 request: normalizedRequest,
                 session: normalizedSession,
                 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));
         }
@@ -484,6 +617,80 @@ class CodingSessionManager {
                 meta: { path: this.stateFilePath, reason: error instanceof Error ? error.message : String(error) },
             });
         }
+        this.persistArtifacts();
+    }
+    artifactPathFor(sessionId) {
+        return path.join(this.artifactDirPath, `${sessionId}.md`);
+    }
+    renderArtifact(record) {
+        const { request, session } = record;
+        const stdout = session.stdoutTail.trim() || "(empty)";
+        const stderr = session.stderrTail.trim() || "(empty)";
+        const lines = [
+            "# Coding Session Artifact",
+            "",
+            "## Session",
+            `id: ${session.id}`,
+            `runner: ${session.runner}`,
+            `status: ${session.status}`,
+            `taskRef: ${session.taskRef ?? "unassigned"}`,
+            `workdir: ${session.workdir}`,
+            `startedAt: ${session.startedAt}`,
+            `lastActivityAt: ${session.lastActivityAt}`,
+            `endedAt: ${session.endedAt ?? "active"}`,
+            `pid: ${session.pid ?? "none"}`,
+            `restarts: ${session.restartCount}`,
+            `checkpoint: ${session.checkpoint ?? "none"}`,
+            `scopeFile: ${session.scopeFile ?? "none"}`,
+            `stateFile: ${session.stateFile ?? "none"}`,
+            "",
+            "## Request",
+            request.prompt,
+            "",
+            "## Stdout Tail",
+            stdout,
+            "",
+            "## Stderr Tail",
+            stderr,
+        ];
+        if (session.failure) {
+            lines.push("", "## Failure", `command: ${session.failure.command}`, `args: ${session.failure.args.join(" ") || "(none)"}`, `code: ${session.failure.code ?? "null"}`, `signal: ${session.failure.signal ?? "null"}`);
+        }
+        return `${lines.join("\n")}\n`;
+    }
+    persistArtifacts() {
+        try {
+            this.mkdirSync(this.artifactDirPath, { recursive: true });
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "repertoire",
+                event: "repertoire.coding_artifact_persist_error",
+                message: "failed preparing coding artifact directory",
+                meta: { path: this.artifactDirPath, reason: error instanceof Error ? error.message : String(error) },
+            });
+            return;
+        }
+        for (const record of this.records.values()) {
+            try {
+                record.session.artifactPath = record.session.artifactPath ?? this.artifactPathFor(record.session.id);
+                this.writeFileSync(record.session.artifactPath, this.renderArtifact(record), "utf-8");
+            }
+            catch (error) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "repertoire",
+                    event: "repertoire.coding_artifact_persist_error",
+                    message: "failed writing coding session artifact",
+                    meta: {
+                        id: record.session.id,
+                        path: record.session.artifactPath ?? this.artifactPathFor(record.session.id),
+                        reason: error instanceof Error ? error.message : String(error),
+                    },
+                });
+            }
+        }
     }
 }
 exports.CodingSessionManager = CodingSessionManager;

package/dist/repertoire/coding/spawner.js

@@ -36,42 +36,84 @@ 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) {
+function buildCommandArgs(runner, workdir, parentAgent) {
     if (runner === "claude") {
         return {
             command: "claude",
             args: [
                 "-p",
+                "--verbose",
+                "--no-session-persistence",
                 "--dangerously-skip-permissions",
                 "--add-dir",
                 workdir,
-                "--input-format",
-                "stream-json",
                 "--output-format",
                 "stream-json",
             ],
         };
     }
+    const agent = parentAgent ?? "unknown";
+    // Use absolute path to ouro-entry.js so MCP works in both dev and installed mode
+    // __dirname at runtime is dist/repertoire/coding/ — go up 2 levels to dist/
+    const distRoot = path.resolve(__dirname, "..", "..");
+    const ouroEntryPath = path.join(distRoot, "heart", "daemon", "ouro-entry.js");
     return {
         command: "codex",
-        args: ["exec", "--skip-git-repo-check", "--cd", workdir],
+        args: [
+            "exec",
+            "--skip-git-repo-check",
+            "--cd",
+            workdir,
+            "--ephemeral",
+            "--json",
+            "-c",
+            `mcp_servers.ouro.command=node`,
+            "-c",
+            `mcp_servers.ouro.args=["${ouroEntryPath}","mcp-serve","--agent","${agent}"]`,
+        ],
+    };
+}
+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 appendFileSection(sections, label, filePath, deps) {
+    if (!filePath || !deps.existsSync(filePath))
+        return;
+    const content = deps.readFileSync(filePath, "utf-8").trim();
+    if (content.length === 0)
+        return;
+    sections.push(`${label} (${filePath}):\n${content}`);
+}
 function buildPrompt(request, deps) {
     const sections = [];
+    sections.push([
+        "Execution contract:",
+        "- You are a subordinate coding session launched by a parent Ouro agent.",
+        "- Execute the concrete request in the supplied workdir directly.",
+        "- Do not switch into planning/doing workflows, approval gates, or repo-management rituals unless the request explicitly asks for them.",
+        "- Treat the request, scope file, and state file as the authoritative briefing for this session.",
+        "- Prefer direct execution and verification over narration.",
+    ].join("\n"));
     sections.push([
         "Coding session metadata:",
         `sessionId: ${request.sessionId ?? "pending"}`,
         `parentAgent: ${request.parentAgent ?? "unknown"}`,
         `taskRef: ${request.taskRef ?? "unassigned"}`,
     ].join("\n"));
-    if (request.stateFile && deps.existsSync(request.stateFile)) {
-        const stateContent = deps.readFileSync(request.stateFile, "utf-8").trim();
-        if (stateContent.length > 0) {
-            sections.push(`State file (${request.stateFile}):\n${stateContent}`);
-        }
-    }
+    appendFileSection(sections, "Scope file", request.scopeFile, deps);
+    appendFileSection(sections, "State file", request.stateFile, deps);
     sections.push(request.prompt);
     return sections.join("\n\n---\n\n");
 }
@@ -79,8 +121,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 { command, args } = buildCommandArgs(request.runner, request.workdir, request.parentAgent);
+    const env = buildSpawnEnv(baseEnv, homeDir);
     (0, runtime_1.emitNervesEvent)({
         component: "repertoire",
         event: "repertoire.coding_spawn_start",
@@ -89,9 +134,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",