@ouro.bot/cli 0.1.0-alpha.63 → 0.1.0-alpha.638

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,14 @@
 "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 evolution_1 = require("../../arc/evolution");
 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 +35,136 @@ 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;
+    const evolutionCaseMatches = request.evolutionCaseId ? session.evolutionCaseId === request.evolutionCaseId : true;
+    return (session.runner === request.runner &&
+        session.workdir === request.workdir &&
+        session.taskRef === request.taskRef &&
+        scopeMatches &&
+        stateMatches &&
+        evolutionCaseMatches &&
+        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`;
+}
+function blockedEvolutionSpawnResult(evolutionCaseId, decision) {
+    return JSON.stringify({
+        ok: false,
+        blocked: true,
+        action: "spawn_coding",
+        evolutionCaseId,
+        code: decision.code,
+        reason: decision.reason,
+    });
+}
+function recordBlockedEvolutionSpawn(agentRoot, evolutionCaseId, decision) {
+    if (decision.code === "case_not_found")
+        return;
+    try {
+        (0, evolution_1.consumeEvolutionBudget)(agentRoot, evolutionCaseId, "spawn_coding", {
+            reason: `coding_spawn blocked: ${decision.reason}`,
+        });
+    }
+    catch {
+        // consumeEvolutionBudget records the block before throwing.
+    }
+}
 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: {
@@ -43,6 +174,7 @@ const codingSpawnTool = {
                 taskRef: { type: "string" },
                 scopeFile: { type: "string" },
                 stateFile: { type: "string" },
+                evolutionCaseId: { type: "string" },
             },
             required: ["runner", "workdir", "prompt", "taskRef"],
         },
@@ -52,7 +184,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 +197,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 +262,20 @@ exports.codingToolDefinitions = [
                 prompt,
                 taskRef,
             };
+            const evolutionCaseId = optionalArg(args, "evolutionCaseId");
+            if (evolutionCaseId)
+                request.evolutionCaseId = evolutionCaseId;
+            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 +283,61 @@ 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.evolutionCaseId) {
+                const decision = (0, evolution_1.evaluateEvolutionAction)((0, identity_1.getAgentRoot)(), request.evolutionCaseId, "spawn_coding");
+                if (!decision.allowed) {
+                    recordBlockedEvolutionSpawn((0, identity_1.getAgentRoot)(), request.evolutionCaseId, decision);
+                    return blockedEvolutionSpawnResult(request.evolutionCaseId, decision);
+                }
+            }
+            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 (request.evolutionCaseId) {
+                (0, evolution_1.consumeEvolutionBudget)((0, identity_1.getAgentRoot)(), request.evolutionCaseId, "spawn_coding", {
+                    target: session.id,
+                    reason: `coding session ${session.id} spawned`,
+                });
+            }
+            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 +351,28 @@ exports.codingToolDefinitions = [
             }
             return JSON.stringify(session);
         },
+        summaryKeys: ["runner", "workdir", "taskRef"],
+        riskProfile: {
+            mutates: ["durable_state_write", "external_side_effect"],
+            risk: "high",
+            reason: "spawns a separate coding process and may create obligations",
+        },
     },
     {
         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 +384,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 +400,8 @@ exports.codingToolDefinitions = [
                 return "input is required";
             return JSON.stringify((0, index_1.getCodingSessionManager)().sendInput(sessionId, input));
         },
+        summaryKeys: ["sessionId", "input"],
+        riskProfile: { mutates: "external_side_effect", risk: "high", reason: "sends input to a live coding process" },
     },
     {
         tool: codingKillTool,
@@ -202,5 +412,7 @@ exports.codingToolDefinitions = [
                 return "sessionId is required";
             return JSON.stringify((0, index_1.getCodingSessionManager)().killSession(sessionId));
         },
+        summaryKeys: ["sessionId"],
+        riskProfile: { mutates: "external_side_effect", risk: "high", reason: "terminates a live coding process" },
     },
 ];

package/dist/repertoire/commerce-errors.js

@@ -0,0 +1,109 @@
+"use strict";
+/**
+ * Commerce-specific error types and helpers.
+ *
+ * These errors carry structured `code` and `meta` fields for nerves event
+ * compatibility and provide patterns for common commerce failure modes:
+ * retry, price change detection, and partial failure reporting.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProfileError = exports.BookingError = exports.PaymentError = exports.CommerceError = void 0;
+exports.retryOnce = retryOnce;
+exports.priceChangeGuard = priceChangeGuard;
+exports.partialFailureReport = partialFailureReport;
+// ---------------------------------------------------------------------------
+// Error types
+// ---------------------------------------------------------------------------
+class CommerceError extends Error {
+    code;
+    meta;
+    constructor(message, code, meta = {}) {
+        super(message);
+        this.name = "CommerceError";
+        this.code = code;
+        this.meta = meta;
+    }
+}
+exports.CommerceError = CommerceError;
+class PaymentError extends CommerceError {
+    constructor(message, code, meta = {}) {
+        super(message, code, meta);
+        this.name = "PaymentError";
+    }
+}
+exports.PaymentError = PaymentError;
+class BookingError extends CommerceError {
+    constructor(message, code, meta = {}) {
+        super(message, code, meta);
+        this.name = "BookingError";
+    }
+}
+exports.BookingError = BookingError;
+class ProfileError extends CommerceError {
+    constructor(message, code, meta = {}) {
+        super(message, code, meta);
+        this.name = "ProfileError";
+    }
+}
+exports.ProfileError = ProfileError;
+// ---------------------------------------------------------------------------
+// Transient error detection
+// ---------------------------------------------------------------------------
+const TRANSIENT_CODES = new Set(["COMMERCE_TRANSIENT", "COMMERCE_TIMEOUT", "COMMERCE_NETWORK"]);
+function isTransient(err) {
+    return err instanceof CommerceError && TRANSIENT_CODES.has(err.code);
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Retry a function once on transient failure, then throw.
+ * Non-transient errors are thrown immediately without retry.
+ */
+async function retryOnce(fn) {
+    try {
+        return await fn();
+    }
+    catch (err) {
+        if (!isTransient(err))
+            throw err;
+        // One retry
+        return fn();
+    }
+}
+/**
+ * Throw PaymentError if the actual price differs from the approved price
+ * by more than 5%. Used to protect against price changes between search
+ * and booking.
+ */
+function priceChangeGuard(approved, actual) {
+    if (approved === 0 && actual === 0)
+        return;
+    if (approved === 0) {
+        throw new PaymentError(`price changed from $0 to $${actual} — cannot verify percentage change`, "PAYMENT_PRICE_CHANGED", { approved, actual });
+    }
+    const delta = Math.abs(actual - approved) / approved;
+    if (delta > 0.05) {
+        throw new PaymentError(`price changed by ${(delta * 100).toFixed(1)}% (approved: $${approved}, actual: $${actual})`, "PAYMENT_PRICE_CHANGED", { approved, actual, deltaPercent: delta * 100 });
+    }
+}
+/**
+ * Format a human-readable status report for multi-service booking attempts.
+ * Each entry has a service name, status, and optional error message.
+ */
+function partialFailureReport(results) {
+    if (results.length === 0) {
+        return "no services attempted.";
+    }
+    const lines = results.map((r) => {
+        const status = r.status === "success" ? "success" : "failed";
+        const detail = r.error ? ` — ${r.error}` : "";
+        return `  ${r.service}: ${status}${detail}`;
+    });
+    const succeeded = results.filter((r) => r.status === "success").length;
+    const failed = results.length - succeeded;
+    return [
+        `booking status: ${succeeded} succeeded, ${failed} failed`,
+        ...lines,
+    ].join("\n");
+}