@ouro.bot/cli 0.1.0-alpha.83 → 0.1.0-alpha.831

package/dist/repertoire/coding/feedback.js

@@ -3,9 +3,19 @@ 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 socket_client_1 = require("../../heart/daemon/socket-client");
+const obligations_1 = require("../../arc/obligations");
 const runtime_1 = require("../../nerves/runtime");
 const TERMINAL_UPDATE_KINDS = new Set(["completed", "failed", "killed"]);
+const OBLIGATION_WAKE_UPDATE_KINDS = new Set([
+    "waiting_input",
+    "stalled",
+    "completed",
+    "failed",
+    "killed",
+]);
+const PULL_REQUEST_NUMBER_PATTERN = /\bPR\s*#(\d+)\b/i;
+const PULL_REQUEST_URL_PATTERN = /\/pull\/(\d+)(?:\b|\/)?/i;
 function clip(text, maxLength = 280) {
     const trimmed = text.trim();
     if (trimmed.length <= maxLength)
@@ -49,23 +59,128 @@ function formatSessionLabel(session) {
         : "";
     return `${session.runner} ${session.id}${origin}`;
 }
+function codingFeedbackOriginSessionId(session) {
+    return session.originSession
+        ? `${session.originSession.friendId}/${session.originSession.channel}/${session.originSession.key}`
+        : "detached";
+}
+function buildCodingFeedbackPrivateWakeOptions(input) {
+    return {
+        reason: "coding feedback private attention",
+        triggerSource: "coding-feedback",
+        budgetClass: "interactive",
+        idempotencyKey: `coding-feedback:${input.agentName}:${input.obligationId}:${input.update.session.id}:${input.update.kind}`,
+        originRefs: [
+            { kind: "coding-session", id: input.update.session.id },
+            { kind: "coding-update", id: input.update.kind },
+            { kind: "obligation", id: input.obligationId },
+            { kind: "session", id: codingFeedbackOriginSessionId(input.update.session) },
+        ],
+    };
+}
+function extractPullRequestLabel(snippet) {
+    if (!snippet)
+        return null;
+    const numberMatch = snippet.match(PULL_REQUEST_NUMBER_PATTERN);
+    if (numberMatch)
+        return `PR #${numberMatch[1]}`;
+    const urlMatch = snippet.match(PULL_REQUEST_URL_PATTERN);
+    if (urlMatch)
+        return `PR #${urlMatch[1]}`;
+    return null;
+}
+function isMergedPullRequestSnippet(snippet) {
+    return /\bmerged\b/i.test(snippet) || /\blanded\b/i.test(snippet);
+}
+function deriveObligationMilestone(update) {
+    const snippet = pickUpdateSnippet(update);
+    const pullRequest = extractPullRequestLabel(snippet);
+    if (update.kind === "completed" && snippet && pullRequest && isMergedPullRequestSnippet(snippet)) {
+        return {
+            status: "updating_runtime",
+            currentSurface: { kind: "runtime", label: "ouro up" },
+            currentArtifact: pullRequest,
+            nextAction: "update runtime, verify version/changelog, then re-observe",
+        };
+    }
+    if (update.kind === "completed" && pullRequest) {
+        return {
+            status: "waiting_for_merge",
+            currentSurface: { kind: "merge", label: pullRequest },
+            currentArtifact: pullRequest,
+            nextAction: `wait for checks, merge ${pullRequest}, then update runtime`,
+        };
+    }
+    if (update.kind === "waiting_input") {
+        return {
+            status: "investigating",
+            currentSurface: { kind: "coding", label: `${update.session.runner} ${update.session.id}` },
+            nextAction: `answer ${update.session.runner} ${update.session.id} and continue`,
+        };
+    }
+    if (update.kind === "stalled") {
+        return {
+            status: "investigating",
+            currentSurface: { kind: "coding", label: `${update.session.runner} ${update.session.id}` },
+            nextAction: `unstick ${update.session.runner} ${update.session.id} and continue`,
+        };
+    }
+    if (update.kind === "progress" || update.kind === "spawned" || update.kind === "failed" || update.kind === "killed" || update.kind === "completed") {
+        return {
+            status: "investigating",
+            currentSurface: { kind: "coding", label: `${update.session.runner} ${update.session.id}` },
+        };
+    }
+    return null;
+}
 function isSafeProgressSnippet(snippet) {
+    const normalized = snippet.trim();
     const wordCount = snippet.split(/\s+/).filter(Boolean).length;
-    return (snippet.length <= 80
+    return (normalized.length <= 80
+        && wordCount >= 2
         && 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));
+        && /[A-Za-z]{3,}/.test(normalized)
+        && !normalized.includes(":")
+        && !/[{}\[\]();]/.test(normalized)
+        && !normalized.startsWith("**")
+        && !/^Respond with\b/i.test(normalized)
+        && !/^Coding session metadata\b/i.test(normalized)
+        && !/^sessionId\b/i.test(normalized)
+        && !/^taskRef\b/i.test(normalized)
+        && !/^parentAgent\b/i.test(normalized));
 }
 function pickUpdateSnippet(update) {
-    return (lastMeaningfulLine(update.text)
+    const checkpoint = update.session.checkpoint?.trim() || null;
+    return (checkpoint
+        ?? lastMeaningfulLine(update.text)
         ?? lastMeaningfulLine(update.session.stderrTail)
         ?? lastMeaningfulLine(update.session.stdoutTail));
 }
+function renderValue(text) {
+    const trimmed = text?.trim();
+    return trimmed && trimmed.length > 0 ? trimmed : "(empty)";
+}
+function renderPath(text) {
+    return text && text.trim().length > 0 ? text : "(none)";
+}
+function formatCodingTail(session) {
+    const stdout = renderValue(session.stdoutTail);
+    const stderr = renderValue(session.stderrTail);
+    return [
+        `sessionId: ${session.id}`,
+        `runner: ${session.runner}`,
+        `status: ${session.status}`,
+        `checkpoint: ${renderValue(session.checkpoint ?? undefined)}`,
+        `artifactPath: ${renderPath(session.artifactPath)}`,
+        `workdir: ${session.workdir}`,
+        "",
+        "[stdout]",
+        stdout,
+        "",
+        "[stderr]",
+        stderr,
+    ].join("\n");
+}
 function formatUpdateMessage(update) {
     const label = formatSessionLabel(update.session);
     const snippet = pickUpdateSnippet(update);
@@ -86,6 +201,22 @@ function formatUpdateMessage(update) {
             return `${label} started`;
     }
 }
+function formatReportBackMessage(update, baseMessage) {
+    if (!baseMessage)
+        return null;
+    if (!update.session.obligationId || !update.session.originSession) {
+        return baseMessage;
+    }
+    const milestone = deriveObligationMilestone(update);
+    const extraLines = [];
+    if (milestone?.currentArtifact) {
+        extraLines.push(`current artifact: ${milestone.currentArtifact}`);
+    }
+    if (milestone?.nextAction) {
+        extraLines.push(`next: ${milestone.nextAction}`);
+    }
+    return extraLines.length > 0 ? `${baseMessage}\n${extraLines.join("\n")}` : baseMessage;
+}
 function obligationNoteFromUpdate(update) {
     const snippet = pickUpdateSnippet(update);
     switch (update.kind) {
@@ -113,10 +244,13 @@ function syncObligationFromUpdate(update) {
     const obligationId = update.session.obligationId;
     if (!obligationId)
         return;
+    const milestone = deriveObligationMilestone(update);
     try {
         (0, obligations_1.advanceObligation)((0, identity_1.getAgentRoot)(), obligationId, {
-            status: "investigating",
-            currentSurface: { kind: "coding", label: `${update.session.runner} ${update.session.id}` },
+            status: milestone?.status ?? "investigating",
+            currentSurface: milestone?.currentSurface ?? { kind: "coding", label: `${update.session.runner} ${update.session.id}` },
+            currentArtifact: milestone?.currentArtifact,
+            nextAction: milestone?.nextAction,
             latestNote: obligationNoteFromUpdate(update) ?? undefined,
         });
     }
@@ -124,26 +258,33 @@ function syncObligationFromUpdate(update) {
         // 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");
+async function requestPrivateWakeForObligation(update) {
+    const obligationId = update.session.obligationId;
+    if (!obligationId || !OBLIGATION_WAKE_UPDATE_KINDS.has(update.kind)) {
+        return;
+    }
+    try {
+        const agentName = (0, identity_1.getAgentName)();
+        await (0, socket_client_1.requestPrivateWake)(agentName, undefined, buildCodingFeedbackPrivateWakeOptions({ agentName, obligationId, update }));
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "repertoire",
+            event: "repertoire.coding_feedback_wake_error",
+            message: "coding feedback wake request failed",
+            meta: {
+                sessionId: update.session.id,
+                kind: update.kind,
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+    }
 }
 function attachCodingSessionFeedback(manager, session, target) {
     let lastMessage = "";
     let closed = false;
-    let unsubscribe = () => { };
+    let unsubscribe = null;
     const sendMessage = (message) => {
         if (closed || !message || message === lastMessage) {
             return;
@@ -164,17 +305,18 @@ function attachCodingSessionFeedback(manager, session, target) {
     };
     const spawnedUpdate = { kind: "spawned", session };
     syncObligationFromUpdate(spawnedUpdate);
-    sendMessage(formatUpdateMessage(spawnedUpdate));
+    sendMessage(formatReportBackMessage(spawnedUpdate, formatUpdateMessage(spawnedUpdate)));
     unsubscribe = manager.subscribe(session.id, async (update) => {
         syncObligationFromUpdate(update);
-        sendMessage(formatUpdateMessage(update));
+        sendMessage(formatReportBackMessage(update, formatUpdateMessage(update)));
+        await requestPrivateWakeForObligation(update);
         if (TERMINAL_UPDATE_KINDS.has(update.kind)) {
             closed = true;
-            unsubscribe();
+            unsubscribe?.();
         }
     });
     return () => {
         closed = true;
-        unsubscribe();
+        unsubscribe?.();
     };
 }

package/dist/repertoire/coding/index.js

@@ -1,19 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatCodingTail = exports.attachCodingSessionFeedback = exports.formatCodingMonitorReport = exports.CodingSessionMonitor = exports.CodingSessionManager = void 0;
+exports.formatCodingTail = exports.attachCodingSessionFeedback = exports.formatCodingMonitorReport = exports.CodingSessionMonitor = exports.WorkbenchMcpClient = exports.WorkbenchCodingSessionManager = exports.CodingSessionManager = void 0;
 exports.getCodingSessionManager = getCodingSessionManager;
 exports.resetCodingSessionManager = resetCodingSessionManager;
 const runtime_1 = require("../../nerves/runtime");
+const config_1 = require("../../heart/config");
+const identity_1 = require("../../heart/identity");
 const manager_1 = require("./manager");
+const workbench_manager_1 = require("./workbench-manager");
+const workbench_client_1 = require("./workbench-client");
 let manager = null;
 function getCodingSessionManager() {
     if (!manager) {
-        manager = new manager_1.CodingSessionManager({});
+        const config = (0, config_1.loadConfig)();
+        const backend = config.features.workbenchCoding ? "workbench" : "process";
+        manager = config.features.workbenchCoding
+            ? new workbench_manager_1.WorkbenchCodingSessionManager({ agentName: (0, identity_1.getAgentName)(), client: new workbench_client_1.WorkbenchMcpClient() })
+            : new manager_1.CodingSessionManager({});
         (0, runtime_1.emitNervesEvent)({
             component: "repertoire",
             event: "repertoire.coding_manager_init",
             message: "initialized coding session manager singleton",
-            meta: {},
+            meta: { backend },
         });
     }
     return manager;
@@ -30,6 +38,10 @@ function resetCodingSessionManager() {
 }
 var manager_2 = require("./manager");
 Object.defineProperty(exports, "CodingSessionManager", { enumerable: true, get: function () { return manager_2.CodingSessionManager; } });
+var workbench_manager_2 = require("./workbench-manager");
+Object.defineProperty(exports, "WorkbenchCodingSessionManager", { enumerable: true, get: function () { return workbench_manager_2.WorkbenchCodingSessionManager; } });
+var workbench_client_2 = require("./workbench-client");
+Object.defineProperty(exports, "WorkbenchMcpClient", { enumerable: true, get: function () { return workbench_client_2.WorkbenchMcpClient; } });
 var monitor_1 = require("./monitor");
 Object.defineProperty(exports, "CodingSessionMonitor", { enumerable: true, get: function () { return monitor_1.CodingSessionMonitor; } });
 var reporter_1 = require("./reporter");

package/dist/repertoire/coding/manager.js

@@ -37,19 +37,15 @@ exports.CodingSessionManager = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const identity_1 = require("../../heart/identity");
+const session_events_1 = require("../../heart/session-events");
 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((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 {
         process.kill(pid, 0);
@@ -63,6 +59,8 @@ 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
@@ -86,6 +84,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;
 }
@@ -123,6 +161,7 @@ class CodingSessionManager {
     maxRestarts;
     defaultStallThresholdMs;
     stateFilePath;
+    artifactDirPath;
     existsSync;
     readFileSync;
     writeFileSync;
@@ -140,8 +179,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) {
@@ -160,8 +210,11 @@ class CodingSessionManager {
             taskRef: normalizedRequest.taskRef,
             originSession: normalizedRequest.originSession ? { ...normalizedRequest.originSession } : undefined,
             obligationId: normalizedRequest.obligationId,
+            evolutionCaseId: normalizedRequest.evolutionCaseId,
             scopeFile: normalizedRequest.scopeFile,
             stateFile: normalizedRequest.stateFile,
+            checkpoint: null,
+            artifactPath: this.artifactPathFor(id),
             status: "spawning",
             stdoutTail: "",
             stderrTail: "",
@@ -248,6 +301,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",
@@ -270,6 +324,7 @@ class CodingSessionManager {
                 continue;
             stalled += 1;
             record.session.status = "stalled";
+            record.session.checkpoint = deriveCheckpoint(record.session);
             (0, runtime_1.emitNervesEvent)({
                 level: "warn",
                 component: "repertoire",
@@ -295,6 +350,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();
             }
         }
@@ -339,6 +395,13 @@ class CodingSessionManager {
             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",
             event: "repertoire.coding_session_output",
@@ -362,12 +425,14 @@ 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;
@@ -379,6 +444,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",
@@ -404,6 +470,7 @@ class CodingSessionManager {
         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",
@@ -495,9 +562,12 @@ class CodingSessionManager {
                 taskRef: session.taskRef ?? normalizedRequest.taskRef,
                 originSession: session.originSession ?? normalizedRequest.originSession,
                 obligationId: session.obligationId ?? normalizedRequest.obligationId,
+                evolutionCaseId: session.evolutionCaseId ?? normalizedRequest.evolutionCaseId,
                 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);
@@ -510,6 +580,7 @@ class CodingSessionManager {
                     normalizedSession.pid = null;
                 }
             }
+            normalizedSession.checkpoint = normalizedSession.checkpoint ?? deriveCheckpoint(normalizedSession);
             this.records.set(normalizedSession.id, {
                 request: normalizedRequest,
                 session: normalizedSession,
@@ -532,7 +603,10 @@ class CodingSessionManager {
         const payload = {
             sequence: this.sequence,
             records: [...this.records.values()].map((record) => ({
-                request: record.request,
+                request: {
+                    ...record.request,
+                    prompt: (0, session_events_1.capStructuredRecordString)(record.request.prompt),
+                },
                 session: record.session,
             })),
         };
@@ -549,6 +623,81 @@ 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"}`,
+            `evolutionCaseId: ${session.evolutionCaseId ?? "none"}`,
+            `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",
+            (0, session_events_1.capStructuredRecordString)(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;