@ouro.bot/cli 0.1.0-alpha.28 → 0.1.0-alpha.280

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,10 @@ 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 defaultArtifactDirPath(agentName) {
+    return path.join((0, identity_1.getAgentRoot)(agentName), "state", "coding", "sessions");
 }
 function isPidAlive(pid) {
     try {
@@ -63,6 +65,9 @@ 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
@@ -86,6 +91,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 +168,7 @@ class CodingSessionManager {
     maxRestarts;
     defaultStallThresholdMs;
     stateFilePath;
+    artifactDirPath;
     existsSync;
     readFileSync;
     writeFileSync;
@@ -142,6 +188,8 @@ class CodingSessionManager {
         this.pidAlive = options.pidAlive ?? isPidAlive;
         this.agentName = options.agentName ?? safeAgentName();
         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) {
@@ -158,8 +206,12 @@ 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: "",
@@ -246,6 +298,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",
@@ -268,6 +321,7 @@ class CodingSessionManager {
                 continue;
             stalled += 1;
             record.session.status = "stalled";
+            record.session.checkpoint = deriveCheckpoint(record.session);
             (0, runtime_1.emitNervesEvent)({
                 level: "warn",
                 component: "repertoire",
@@ -293,6 +347,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();
             }
         }
@@ -337,6 +392,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",
@@ -360,12 +422,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;
@@ -377,6 +441,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",
@@ -402,6 +467,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",
@@ -483,15 +549,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);
@@ -504,6 +576,7 @@ class CodingSessionManager {
                     normalizedSession.pid = null;
                 }
             }
+            normalizedSession.checkpoint = normalizedSession.checkpoint ?? deriveCheckpoint(normalizedSession);
             this.records.set(normalizedSession.id, {
                 request: normalizedRequest,
                 session: normalizedSession,
@@ -543,6 +616,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,8 +36,10 @@ 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",
@@ -53,25 +55,65 @@ function buildCommandArgs(runner, workdir) {
             ],
         };
     }
+    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,6 +134,7 @@ function spawnCodingProcess(request, deps = {}) {
     });
     const proc = spawnFn(command, args, {
         cwd: request.workdir,
+        env,
         stdio: ["pipe", "pipe", "pipe"],
     });
     proc.stdin.end(`${prompt}\n`);

package/dist/repertoire/coding/tools.js

@@ -1,8 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.codingToolDefinitions = void 0;
+exports.countFilesInSessionOutput = countFilesInSessionOutput;
 const index_1 = require("./index");
+const context_pack_1 = require("./context-pack");
+const identity_1 = require("../../heart/identity");
+const obligations_1 = require("../../arc/obligations");
 const runtime_1 = require("../../nerves/runtime");
+const scrutiny_1 = require("../../mind/scrutiny");
 const RUNNERS = ["claude", "codex"];
 function requireArg(args, key) {
     const value = args[key];
@@ -29,11 +34,112 @@ function emitCodingToolEvent(toolName) {
         meta: { toolName },
     });
 }
+/**
+ * Count distinct file paths mentioned in a coding session's stdout output.
+ * Looks for path-like tokens (containing / and a file extension).
+ * Returns the count of unique paths found.
+ */
+function countFilesInSessionOutput(session) {
+    const text = `${session.stdoutTail}\n${session.stderrTail}`;
+    // Match path-like tokens: contain at least one / and a file extension
+    const pathPattern = /(?:^|\s)((?:\/|\.\/|\.\.\/)?(?:[\w.@-]+\/)+[\w.-]+\.[\w]+)/gm;
+    const paths = new Set();
+    let match;
+    while ((match = pathPattern.exec(text)) !== null) {
+        paths.add(match[1]);
+    }
+    return paths.size;
+}
+/**
+ * If a coding session is completed, append scrutiny to the result.
+ * Returns the original result with scrutiny appended, or unchanged if
+ * the session is not completed or has no file changes.
+ */
+function appendCompletionScrutiny(result, session) {
+    if (session.status !== "completed")
+        return result;
+    const fileCount = countFilesInSessionOutput(session);
+    const scrutiny = (0, scrutiny_1.getCodingCompletionScrutiny)(fileCount);
+    return scrutiny ? `${result}\n\n${scrutiny}` : result;
+}
+function sameOriginSession(left, right) {
+    if (!left && !right)
+        return true;
+    if (!left || !right)
+        return false;
+    return left.friendId === right.friendId && left.channel === right.channel && left.key === right.key;
+}
+function matchesReusableCodingSession(session, request) {
+    if (session.status !== "spawning" && session.status !== "running" && session.status !== "waiting_input" && session.status !== "stalled") {
+        return false;
+    }
+    const scopeMatches = request.scopeFile ? session.scopeFile === request.scopeFile : true;
+    const stateMatches = request.stateFile ? session.stateFile === request.stateFile : true;
+    return (session.runner === request.runner &&
+        session.workdir === request.workdir &&
+        session.taskRef === request.taskRef &&
+        scopeMatches &&
+        stateMatches &&
+        session.obligationId === request.obligationId &&
+        sameOriginSession(request.originSession, session.originSession));
+}
+function latestSessionFirst(left, right) {
+    const lastActivityDelta = Date.parse(right.lastActivityAt) - Date.parse(left.lastActivityAt);
+    if (lastActivityDelta !== 0)
+        return lastActivityDelta;
+    return right.id.localeCompare(left.id);
+}
+function findReusableCodingSession(sessions, request) {
+    const matches = sessions.filter((session) => matchesReusableCodingSession(session, request)).sort(latestSessionFirst);
+    return matches[0] ?? null;
+}
+function isLiveCodingStatus(status) {
+    return status === "spawning" || status === "running" || status === "waiting_input" || status === "stalled";
+}
+function rankCodingStatusSession(session, currentSession) {
+    return sameOriginSession({
+        friendId: currentSession.friendId,
+        channel: currentSession.channel,
+        key: currentSession.key,
+    }, session.originSession)
+        ? 0
+        : 1;
+}
+function selectCodingStatusSessions(sessions, currentSession) {
+    if (sessions.length === 0)
+        return [];
+    if (!currentSession) {
+        return sessions;
+    }
+    const activeSessions = sessions.filter((session) => isLiveCodingStatus(session.status)).sort(latestSessionFirst);
+    if (activeSessions.length > 0) {
+        return activeSessions.sort((left, right) => {
+            const rankDelta = rankCodingStatusSession(left, currentSession) - rankCodingStatusSession(right, currentSession);
+            if (rankDelta !== 0)
+                return rankDelta;
+            return latestSessionFirst(left, right);
+        });
+    }
+    const matchingClosedSessions = sessions
+        .filter((session) => sameOriginSession({
+        friendId: currentSession.friendId,
+        channel: currentSession.channel,
+        key: currentSession.key,
+    }, session.originSession))
+        .sort(latestSessionFirst);
+    if (matchingClosedSessions.length > 0) {
+        return matchingClosedSessions;
+    }
+    return [...sessions].sort(latestSessionFirst);
+}
+function buildCodingObligationContent(taskRef) {
+    return `finish ${taskRef} and bring the result back`;
+}
 const codingSpawnTool = {
     type: "function",
     function: {
         name: "coding_spawn",
-        description: "spawn a coding session using claude/codex and explicit task-threaded guidance",
+        description: "Spawn a coding session using claude or codex with task-threaded guidance. The coding session runs as a separate process with its own context. Give it a COMPLETE, SELF-CONTAINED task description -- it cannot see this conversation, doesn't know what you've tried, doesn't understand the broader context. Include: what to do, why, what files are involved, what 'done' looks like. Never delegate understanding -- don't write 'based on the conversation, fix the bug.' Write the specific file paths, line numbers, and what to change. Include any required verification steps or tests in the task description so the coding session knows how to prove the work is done.",
         parameters: {
             type: "object",
             properties: {
@@ -52,7 +158,7 @@ const codingStatusTool = {
     type: "function",
     function: {
         name: "coding_status",
-        description: "inspect coding sessions; omit sessionId to list all active/known sessions",
+        description: "Inspect coding sessions. Omit sessionId to list all active/known sessions with their status. Use this to check progress before asking the human for a status update.",
         parameters: {
             type: "object",
             properties: {
@@ -65,7 +171,7 @@ const codingTailTool = {
     type: "function",
     function: {
         name: "coding_tail",
-        description: "show recent stdout/stderr tail for a coding session in a readable format",
+        description: "Show recent stdout/stderr output from a coding session. Use this to understand what the session is doing or why it might be stuck. Read the actual output before reporting status -- don't guess.",
         parameters: {
             type: "object",
             properties: {
@@ -130,6 +236,17 @@ exports.codingToolDefinitions = [
                 prompt,
                 taskRef,
             };
+            if (ctx?.currentSession && ctx.currentSession.channel !== "inner") {
+                request.originSession = {
+                    friendId: ctx.currentSession.friendId,
+                    channel: ctx.currentSession.channel,
+                    key: ctx.currentSession.key,
+                };
+                const obligation = (0, obligations_1.findPendingObligationForOrigin)((0, identity_1.getAgentRoot)(), request.originSession);
+                if (obligation) {
+                    request.obligationId = obligation.id;
+                }
+            }
             const scopeFile = optionalArg(args, "scopeFile");
             if (scopeFile)
                 request.scopeFile = scopeFile;
@@ -137,7 +254,48 @@ exports.codingToolDefinitions = [
             if (stateFile)
                 request.stateFile = stateFile;
             const manager = (0, index_1.getCodingSessionManager)();
+            const existingSessions = manager.listSessions();
+            const existingSession = findReusableCodingSession(existingSessions, request);
+            if (existingSession) {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "repertoire",
+                    event: "repertoire.coding_session_reused",
+                    message: "reused active coding session",
+                    meta: { id: existingSession.id, runner: existingSession.runner, taskRef: existingSession.taskRef },
+                });
+                if (ctx?.codingFeedback) {
+                    (0, index_1.attachCodingSessionFeedback)(manager, existingSession, ctx.codingFeedback);
+                }
+                return JSON.stringify({ ...existingSession, reused: true });
+            }
+            if (request.originSession && !request.obligationId) {
+                const created = (0, obligations_1.createObligation)((0, identity_1.getAgentRoot)(), {
+                    origin: request.originSession,
+                    content: buildCodingObligationContent(taskRef),
+                });
+                request.obligationId = created.id;
+            }
+            if (!request.scopeFile || !request.stateFile) {
+                const generated = (0, context_pack_1.prepareCodingContextPack)({
+                    request: { ...request },
+                    existingSessions,
+                    activeWorkFrame: ctx?.activeWorkFrame,
+                });
+                if (!request.scopeFile)
+                    request.scopeFile = generated.scopeFile;
+                if (!request.stateFile)
+                    request.stateFile = generated.stateFile;
+            }
             const session = await manager.spawnSession(request);
+            if (session.obligationId) {
+                (0, obligations_1.advanceObligation)((0, identity_1.getAgentRoot)(), session.obligationId, {
+                    status: "investigating",
+                    currentSurface: { kind: "coding", label: `${session.runner} ${session.id}` },
+                    latestNote: session.originSession
+                        ? `coding session started for ${session.originSession.channel}/${session.originSession.key}`
+                        : "coding session started",
+                });
+            }
             if (args.runner === "codex" && args.taskRef) {
                 (0, runtime_1.emitNervesEvent)({
                     component: "repertoire",
@@ -151,21 +309,23 @@ exports.codingToolDefinitions = [
             }
             return JSON.stringify(session);
         },
+        summaryKeys: ["runner", "workdir", "taskRef"],
     },
     {
         tool: codingStatusTool,
-        handler: (args) => {
+        handler: (args, ctx) => {
             emitCodingToolEvent("coding_status");
             const manager = (0, index_1.getCodingSessionManager)();
             const sessionId = requireArg(args, "sessionId");
             if (!sessionId) {
-                return JSON.stringify(manager.listSessions());
+                return JSON.stringify(selectCodingStatusSessions(manager.listSessions(), ctx?.currentSession));
             }
             const session = manager.getSession(sessionId);
             if (!session)
                 return `session not found: ${sessionId}`;
-            return JSON.stringify(session);
+            return appendCompletionScrutiny(JSON.stringify(session), session);
         },
+        summaryKeys: ["sessionId"],
     },
     {
         tool: codingTailTool,
@@ -177,8 +337,9 @@ exports.codingToolDefinitions = [
             const session = (0, index_1.getCodingSessionManager)().getSession(sessionId);
             if (!session)
                 return `session not found: ${sessionId}`;
-            return (0, index_1.formatCodingTail)(session);
+            return appendCompletionScrutiny((0, index_1.formatCodingTail)(session), session);
         },
+        summaryKeys: ["sessionId"],
     },
     {
         tool: codingSendInputTool,
@@ -192,6 +353,7 @@ exports.codingToolDefinitions = [
                 return "input is required";
             return JSON.stringify((0, index_1.getCodingSessionManager)().sendInput(sessionId, input));
         },
+        summaryKeys: ["sessionId", "input"],
     },
     {
         tool: codingKillTool,
@@ -202,5 +364,6 @@ exports.codingToolDefinitions = [
                 return "sessionId is required";
             return JSON.stringify((0, index_1.getCodingSessionManager)().killSession(sessionId));
         },
+        summaryKeys: ["sessionId"],
     },
 ];