@ouro.bot/cli 0.1.0-alpha.686 → 0.1.0-alpha.687

package/changelog.json

@@ -1,6 +1,17 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.687",
+      "changes": [
+        "Route coding sessions through Workbench behind a default-off feature flag.",
+        "Tighten Workbench coding adapter construction and coverage.",
+        "Handle Workbench MCP subprocess broken pipes without leaking unhandled test/runtime errors.",
+        "Fail Workbench coding spawns when the initial task prompt is not confirmed delivered.",
+        "Remove legacy inner-dialog source shims and stale auto-start config fallback so private-runtime startup is controlled only by privateRuntime.autoStart.",
+        "Exclude private-runtime barrel and type-only modules from code coverage so CI enforces executable code instead of inert export surfaces."
+      ]
+    },
     {
       "version": "0.1.0-alpha.686",
       "changes": [

package/dist/heart/config.js

@@ -106,6 +106,9 @@ const DEFAULT_LOCAL_RUNTIME_CONFIG = {
         perplexityApiKey: "",
         openaiEmbeddingsApiKey: "",
     },
+    features: {
+        workbenchCoding: false,
+    },
 };
 function defaultRuntimeConfig() {
     return {
@@ -118,6 +121,7 @@ function defaultRuntimeConfig() {
         bluebubblesChannel: { ...DEFAULT_LOCAL_RUNTIME_CONFIG.bluebubblesChannel },
         vault: { ...DEFAULT_LOCAL_RUNTIME_CONFIG.vault },
         integrations: { ...DEFAULT_LOCAL_RUNTIME_CONFIG.integrations },
+        features: { ...DEFAULT_LOCAL_RUNTIME_CONFIG.features },
     };
 }
 let _runtimeConfigOverride = null;

package/dist/heart/daemon/agent-discovery.js

@@ -37,7 +37,6 @@ exports.isLibraryKind = isLibraryKind;
 exports.listAllBundleAgents = listAllBundleAgents;
 exports.listEnabledBundleAgents = listEnabledBundleAgents;
 exports.readPrivateRuntimeConfig = readPrivateRuntimeConfig;
-exports.isInnerDialogAutoStartEnabled = isInnerDialogAutoStartEnabled;
 exports.listBundleSyncRows = listBundleSyncRows;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -182,14 +181,6 @@ function readPrivateRuntimeConfig(agent, options = {}) {
                 source: "privateRuntime",
             };
         }
-        const innerDialog = parsed.innerDialog;
-        if (innerDialog && typeof innerDialog === "object" && !Array.isArray(innerDialog)) {
-            return {
-                autoStart: innerDialog.autoStart === true,
-                source: "legacy-innerDialog",
-                compatibilityNote: "innerDialog.autoStart is a legacy migration input; use privateRuntime.autoStart.",
-            };
-        }
         return { autoStart: false, source: "default" };
     }
     catch (error) {
@@ -208,14 +199,6 @@ function readPrivateRuntimeConfig(agent, options = {}) {
         return { autoStart: false, source: "unreadable", error: message };
     }
 }
-/**
- * Legacy compatibility shim for older call sites. New code should use
- * readPrivateRuntimeConfig() so compatibility notes and failure provenance are
- * preserved.
- */
-function isInnerDialogAutoStartEnabled(agent, options = {}) {
-    return readPrivateRuntimeConfig(agent, options).autoStart;
-}
 /**
  * Read the per-agent sync block from each enabled bundle's agent.json.
  * Used by the daemon (and stopped-state status renderer) to build per-agent

package/dist/mind/pending.js

@@ -33,11 +33,10 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.INNER_DIALOG_PENDING = exports.PRIVATE_RUNTIME_PENDING = void 0;
+exports.PRIVATE_RUNTIME_PENDING = void 0;
 exports.getPendingDir = getPendingDir;
 exports.getDeferredReturnDir = getDeferredReturnDir;
 exports.getPrivateRuntimePendingDir = getPrivateRuntimePendingDir;
-exports.getInnerDialogPendingDir = getInnerDialogPendingDir;
 exports.hasPendingMessages = hasPendingMessages;
 exports.queuePendingMessage = queuePendingMessage;
 exports.enqueueDeferredReturn = enqueueDeferredReturn;
@@ -60,12 +59,6 @@ exports.PRIVATE_RUNTIME_PENDING = { friendId: "self", channel: "inner", key: "di
 function getPrivateRuntimePendingDir(agentName) {
     return getPendingDir(agentName, exports.PRIVATE_RUNTIME_PENDING.friendId, exports.PRIVATE_RUNTIME_PENDING.channel, exports.PRIVATE_RUNTIME_PENDING.key);
 }
-/** Legacy alias for readers and callers that still reference the historical path name. */
-exports.INNER_DIALOG_PENDING = exports.PRIVATE_RUNTIME_PENDING;
-/** Legacy alias for readers and callers that still reference the historical path name. */
-function getInnerDialogPendingDir(agentName) {
-    return getPrivateRuntimePendingDir(agentName);
-}
 function hasPendingMessages(pendingDir) {
     if (!fs.existsSync(pendingDir))
         return false;

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/spawner.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCodingPrompt = buildCodingPrompt;
 exports.spawnCodingProcess = spawnCodingProcess;
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
@@ -96,7 +97,7 @@ function appendFileSection(sections, label, filePath, deps) {
         return;
     sections.push(`${label} (${filePath}):\n${content}`);
 }
-function buildPrompt(request, deps) {
+function buildCodingPrompt(request, deps) {
     const sections = [];
     sections.push([
         "Execution contract:",
@@ -123,7 +124,7 @@ function spawnCodingProcess(request, deps = {}) {
     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 prompt = buildCodingPrompt(request, { existsSync, readFileSync });
     const { command, args } = buildCommandArgs(request.runner, request.workdir, request.parentAgent);
     const env = buildSpawnEnv(baseEnv, homeDir);
     (0, runtime_1.emitNervesEvent)({

package/dist/repertoire/coding/tools.js

@@ -35,6 +35,22 @@ function emitCodingToolEvent(toolName) {
         meta: { toolName },
     });
 }
+function isRefreshableCodingSessionManager(manager) {
+    return typeof manager.refreshSessions === "function"
+        && typeof manager.refreshSession === "function";
+}
+async function listCodingSessions(manager) {
+    return isRefreshableCodingSessionManager(manager) ? manager.refreshSessions() : manager.listSessions();
+}
+async function getCodingSession(manager, sessionId) {
+    return isRefreshableCodingSessionManager(manager) ? manager.refreshSession(sessionId) : manager.getSession(sessionId);
+}
+async function sendCodingInput(manager, sessionId, input) {
+    return manager.sendInput(sessionId, input);
+}
+async function killCodingSession(manager, sessionId) {
+    return manager.killSession(sessionId);
+}
 /**
  * Count distinct file paths mentioned in a coding session's stdout output.
  * Looks for path-like tokens (containing / and a file extension).
@@ -283,7 +299,7 @@ exports.codingToolDefinitions = [
             if (stateFile)
                 request.stateFile = stateFile;
             const manager = (0, index_1.getCodingSessionManager)();
-            const existingSessions = manager.listSessions();
+            const existingSessions = await listCodingSessions(manager);
             const existingSession = findReusableCodingSession(existingSessions, request);
             if (existingSession) {
                 (0, runtime_1.emitNervesEvent)({
@@ -360,14 +376,14 @@ exports.codingToolDefinitions = [
     },
     {
         tool: codingStatusTool,
-        handler: (args, ctx) => {
+        handler: async (args, ctx) => {
             emitCodingToolEvent("coding_status");
             const manager = (0, index_1.getCodingSessionManager)();
             const sessionId = requireArg(args, "sessionId");
             if (!sessionId) {
-                return JSON.stringify(selectCodingStatusSessions(manager.listSessions(), ctx?.currentSession));
+                return JSON.stringify(selectCodingStatusSessions(await listCodingSessions(manager), ctx?.currentSession));
             }
-            const session = manager.getSession(sessionId);
+            const session = await getCodingSession(manager, sessionId);
             if (!session)
                 return `session not found: ${sessionId}`;
             return appendCompletionScrutiny(JSON.stringify(session), session);
@@ -376,12 +392,12 @@ exports.codingToolDefinitions = [
     },
     {
         tool: codingTailTool,
-        handler: (args) => {
+        handler: async (args) => {
             emitCodingToolEvent("coding_tail");
             const sessionId = requireArg(args, "sessionId");
             if (!sessionId)
                 return "sessionId is required";
-            const session = (0, index_1.getCodingSessionManager)().getSession(sessionId);
+            const session = await getCodingSession((0, index_1.getCodingSessionManager)(), sessionId);
             if (!session)
                 return `session not found: ${sessionId}`;
             return appendCompletionScrutiny((0, index_1.formatCodingTail)(session), session);
@@ -390,7 +406,7 @@ exports.codingToolDefinitions = [
     },
     {
         tool: codingSendInputTool,
-        handler: (args) => {
+        handler: async (args) => {
             emitCodingToolEvent("coding_send_input");
             const sessionId = requireArg(args, "sessionId");
             if (!sessionId)
@@ -398,19 +414,19 @@ exports.codingToolDefinitions = [
             const input = requireArg(args, "input");
             if (!input)
                 return "input is required";
-            return JSON.stringify((0, index_1.getCodingSessionManager)().sendInput(sessionId, input));
+            return JSON.stringify(await sendCodingInput((0, index_1.getCodingSessionManager)(), sessionId, input));
         },
         summaryKeys: ["sessionId", "input"],
         riskProfile: { mutates: "external_side_effect", risk: "high", reason: "sends input to a live coding process" },
     },
     {
         tool: codingKillTool,
-        handler: (args) => {
+        handler: async (args) => {
             emitCodingToolEvent("coding_kill");
             const sessionId = requireArg(args, "sessionId");
             if (!sessionId)
                 return "sessionId is required";
-            return JSON.stringify((0, index_1.getCodingSessionManager)().killSession(sessionId));
+            return JSON.stringify(await killCodingSession((0, index_1.getCodingSessionManager)(), sessionId));
         },
         summaryKeys: ["sessionId"],
         riskProfile: { mutates: "external_side_effect", risk: "high", reason: "terminates a live coding process" },

package/dist/repertoire/coding/workbench-client.js

@@ -0,0 +1,272 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkbenchMcpClient = void 0;
+exports.defaultWorkbenchMcpCandidates = defaultWorkbenchMcpCandidates;
+exports.resolveWorkbenchMcpPath = resolveWorkbenchMcpPath;
+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 defaultWorkbenchMcpCandidates(homeDir = os.homedir()) {
+    return [
+        path.join(homeDir, "Applications", "Ouro Workbench.app", "Contents", "MacOS", "OuroWorkbenchMCP"),
+        path.join("/Applications", "Ouro Workbench.app", "Contents", "MacOS", "OuroWorkbenchMCP"),
+    ];
+}
+function resolveWorkbenchMcpPath(options = {}) {
+    const existsSync = options.existsSync ?? fs.existsSync;
+    const candidates = [
+        ...(options.executablePath ? [options.executablePath] : []),
+        ...defaultWorkbenchMcpCandidates(options.homeDir),
+    ];
+    return candidates.find((candidate) => existsSync(candidate)) ?? null;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function parseJson(text, toolName) {
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        throw new Error(`Workbench MCP ${toolName} returned non-JSON text: ${String(error)}`);
+    }
+}
+function responseIdMatches(response, id) {
+    return response.id === id || response.id === String(id);
+}
+function responseText(response, toolName) {
+    if (response.error) {
+        throw new Error(response.error.message ?? `Workbench MCP ${toolName} returned an RPC error`);
+    }
+    const text = response.result?.content?.map((item) => item.text ?? "").join("\n") ?? "";
+    if (response.result?.isError) {
+        throw new Error(text.trim() || `Workbench MCP ${toolName} returned an error`);
+    }
+    return text;
+}
+function isBrokenPipe(error) {
+    return error.code === "EPIPE";
+}
+class WorkbenchMcpClient {
+    executablePath;
+    spawnFn;
+    timeoutMs;
+    pollIntervalMs;
+    createTimeoutMs;
+    actionTimeoutMs;
+    constructor(options = {}) {
+        const executablePath = resolveWorkbenchMcpPath(options);
+        if (!executablePath) {
+            throw new Error("OuroWorkbenchMCP not found in ~/Applications or /Applications");
+        }
+        this.executablePath = executablePath;
+        this.spawnFn = options.spawnFn ?? ((command, args, spawnOptions) => (0, child_process_1.spawn)(command, args, spawnOptions));
+        this.timeoutMs = options.timeoutMs ?? 10_000;
+        this.pollIntervalMs = options.pollIntervalMs ?? 250;
+        this.createTimeoutMs = options.createTimeoutMs ?? 10_000;
+        this.actionTimeoutMs = options.actionTimeoutMs ?? 10_000;
+    }
+    get commandPath() {
+        return this.executablePath;
+    }
+    async callToolText(name, args) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "repertoire",
+            event: "repertoire.workbench_mcp_call_start",
+            message: "calling Workbench MCP tool",
+            meta: { name },
+        });
+        const child = this.spawnFn(this.executablePath, [], {
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        const stderrChunks = [];
+        const stdoutChunks = [];
+        child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+        const result = await new Promise((resolve, reject) => {
+            let settled = false;
+            let timer;
+            const settle = (fn) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                fn();
+            };
+            timer = setTimeout(() => {
+                settle(() => {
+                    child.kill("SIGTERM");
+                    reject(new Error(`Workbench MCP ${name} timed out after ${this.timeoutMs}ms`));
+                });
+            }, this.timeoutMs);
+            child.on("error", (error) => {
+                settle(() => reject(error));
+            });
+            child.stdin.on("error", (error) => {
+                if (isBrokenPipe(error))
+                    return;
+                settle(() => reject(error));
+            });
+            child.on("exit", () => {
+                const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
+                const stdout = Buffer.concat(stdoutChunks).toString("utf-8");
+                if (!settled) {
+                    if (stderr.length > 0 && stdout.trim().length === 0) {
+                        settle(() => reject(new Error(stderr)));
+                        return;
+                    }
+                    settle(() => reject(new Error(`Workbench MCP ${name} exited before returning a response`)));
+                }
+            });
+            child.stdout.on("data", (chunk) => {
+                stdoutChunks.push(chunk);
+                for (const line of Buffer.concat(stdoutChunks).toString("utf-8").split(/\r?\n/)) {
+                    if (!line.trim())
+                        continue;
+                    let response;
+                    try {
+                        response = JSON.parse(line);
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (!responseIdMatches(response, 2))
+                        continue;
+                    settle(() => {
+                        try {
+                            resolve(responseText(response, name));
+                        }
+                        catch (error) {
+                            reject(error);
+                        }
+                    });
+                }
+            });
+            const initialize = { jsonrpc: "2.0", id: 1, method: "initialize", params: {} };
+            const toolCall = { jsonrpc: "2.0", id: 2, method: "tools/call", params: { name, arguments: args } };
+            child.stdin.write(`${JSON.stringify(initialize)}\n`);
+            child.stdin.write(`${JSON.stringify(toolCall)}\n`);
+            child.stdin.end();
+        }).finally(() => {
+            if (!child.killed) {
+                child.kill("SIGTERM");
+            }
+        });
+        (0, runtime_1.emitNervesEvent)({
+            component: "repertoire",
+            event: "repertoire.workbench_mcp_call_end",
+            message: "Workbench MCP tool returned",
+            meta: { name },
+        });
+        return result;
+    }
+    async callToolJson(name, args) {
+        return parseJson(await this.callToolText(name, args), name);
+    }
+    async createSession(args) {
+        return this.callToolJson("workbench_create_session", { ...args, format: "json" });
+    }
+    async listSessions(args = {}) {
+        const result = await this.callToolJson("workbench_sessions", args);
+        return Array.isArray(result.sessions) ? result.sessions : [];
+    }
+    async transcriptTail(entry, maxBytes = 64_000) {
+        return this.callToolText("workbench_transcript_tail", { entry, maxBytes });
+    }
+    async requestAction(args) {
+        return this.callToolJson("workbench_request_action", { ...args, format: "json" });
+    }
+    async actionResult(requestId) {
+        return this.callToolJson("workbench_action_result", { requestId });
+    }
+    async createCodingSession(request) {
+        const source = request.source ?? "ouro-coding";
+        const group = request.group ?? path.basename(request.workingDirectory);
+        const createAck = await this.createSession({
+            owner: request.owner,
+            name: request.name,
+            command: request.command,
+            workingDirectory: request.workingDirectory,
+            group,
+            createGroupIfMissing: true,
+            trust: request.trust ?? "trusted",
+            autoResume: request.autoResume ?? true,
+            source,
+        });
+        const session = await this.waitForSession({
+            owner: request.owner,
+            name: request.name,
+            timeoutMs: this.createTimeoutMs,
+        });
+        const promptAck = await this.requestAction({
+            source,
+            action: "sendInput",
+            entry: session.id,
+            text: request.prompt,
+            appendNewline: true,
+        });
+        const promptResult = promptAck.requestId
+            ? await this.waitForAction(promptAck.requestId, this.actionTimeoutMs)
+            : undefined;
+        return { session, createAck, promptAck, promptResult };
+    }
+    async waitForSession(input) {
+        const deadline = Date.now() + (input.timeoutMs ?? this.createTimeoutMs);
+        let lastSessions = [];
+        while (Date.now() <= deadline) {
+            lastSessions = await this.listSessions({ owner: input.owner, name: input.name, includeArchived: true });
+            const match = lastSessions.find((session) => session.name.toLowerCase() === input.name.toLowerCase()
+                && (session.owner?.name === input.owner || !session.owner?.name));
+            if (match)
+                return match;
+            await sleep(this.pollIntervalMs);
+        }
+        throw new Error(`Workbench did not create session "${input.name}" for ${input.owner}; last matches=${lastSessions.length}`);
+    }
+    async waitForAction(requestId, timeoutMs = this.actionTimeoutMs) {
+        const deadline = Date.now() + timeoutMs;
+        let latest = null;
+        while (Date.now() <= deadline) {
+            latest = await this.actionResult(requestId);
+            if (latest.state !== "queued")
+                return latest;
+            await sleep(this.pollIntervalMs);
+        }
+        return latest ?? { requestId, state: "queued" };
+    }
+}
+exports.WorkbenchMcpClient = WorkbenchMcpClient;

package/dist/repertoire/coding/workbench-manager.js

@@ -0,0 +1,346 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkbenchCodingSessionManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const spawner_1 = require("./spawner");
+function cloneSession(session) {
+    return {
+        ...session,
+        originSession: session.originSession ? { ...session.originSession } : undefined,
+        failure: session.failure ? { ...session.failure, args: [...session.failure.args] } : null,
+    };
+}
+function sanitizeNamePart(value, fallback) {
+    const sanitized = (value ?? fallback)
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return sanitized.length > 0 ? sanitized : fallback;
+}
+function timestampPart(iso) {
+    return iso.replace(/[-:.]/g, "").replace("Z", "Z");
+}
+function sessionNameForRequest(request, nowIso) {
+    return [
+        "coding",
+        request.runner,
+        sanitizeNamePart(request.taskRef, "task"),
+        timestampPart(nowIso),
+    ].join("-");
+}
+function commandForRunner(runner) {
+    return runner === "claude" ? "claude" : "codex";
+}
+function runnerFromWorkbenchSession(session, fallback) {
+    const name = session.name.toLowerCase();
+    if (name.includes("claude"))
+        return "claude";
+    if (name.includes("codex"))
+        return "codex";
+    return fallback;
+}
+function mapWorkbenchStatus(session) {
+    switch (session.status) {
+        case "configured":
+        case "running":
+            return "running";
+        case "waitingForInput":
+            return "waiting_input";
+        case "exited":
+            return session.exitCode === 0 ? "completed" : "failed";
+        case "needsRecovery":
+        case "manualActionNeeded":
+            return "stalled";
+        default:
+            return "running";
+    }
+}
+function checkpointFor(session, status) {
+    if (session.attentionPrompt?.trim())
+        return session.attentionPrompt.trim();
+    if (session.attentionReason?.trim())
+        return session.attentionReason.trim();
+    if (session.attention?.trim())
+        return session.attention.trim();
+    if (status === "completed")
+        return "completed";
+    if (status === "failed")
+        return session.exitCode === undefined ? "exited" : `exit code ${session.exitCode}`;
+    if (status === "stalled")
+        return "needs Workbench recovery";
+    return null;
+}
+function failureFor(session, command) {
+    if (mapWorkbenchStatus(session) !== "failed")
+        return null;
+    return {
+        command,
+        args: [],
+        code: session.exitCode ?? null,
+        signal: null,
+        stdoutTail: "",
+        stderrTail: checkpointFor(session, "failed"),
+    };
+}
+function resultToActionResult(action, sessionId, result) {
+    if (result.state === "applied" || result.state === "appliedUnconfirmed") {
+        return { ok: true, message: `${action} applied for ${sessionId}` };
+    }
+    if (result.state === "queued") {
+        return { ok: false, message: `${action} queued for ${sessionId} but not confirmed` };
+    }
+    return { ok: false, message: result.result ?? `${action} ${result.state} for ${sessionId}` };
+}
+function promptDeliveryFailure(result) {
+    const sessionId = result.session.id;
+    if (result.promptAck.ok === false) {
+        return `Workbench denied initial prompt for ${sessionId}`;
+    }
+    switch (result.promptResult?.state) {
+        case "applied":
+        case "appliedUnconfirmed":
+            return null;
+        case "failed":
+            return `Workbench failed initial prompt for ${sessionId}`;
+        case "queued":
+            return `Workbench queued initial prompt for ${sessionId} but did not confirm delivery`;
+        case "unknown":
+        case undefined:
+            return `Workbench did not confirm initial prompt delivery for ${sessionId}`;
+    }
+}
+class WorkbenchCodingSessionManager {
+    records = new Map();
+    listeners = new Map();
+    client;
+    agentName;
+    nowIso;
+    existsSync;
+    readFileSync;
+    source;
+    constructor(options) {
+        this.client = options.client;
+        this.agentName = options.agentName;
+        this.nowIso = options.nowIso ?? (() => new Date().toISOString());
+        this.existsSync = options.existsSync ?? fs.existsSync;
+        this.readFileSync = options.readFileSync ?? fs.readFileSync;
+        this.source = options.source ?? "ouro-coding";
+    }
+    async spawnSession(request) {
+        const now = this.nowIso();
+        const name = sessionNameForRequest(request, now);
+        const normalizedRequest = {
+            ...request,
+            parentAgent: request.parentAgent ?? this.agentName,
+        };
+        const prompt = (0, spawner_1.buildCodingPrompt)(normalizedRequest, {
+            existsSync: this.existsSync,
+            readFileSync: this.readFileSync,
+        });
+        const result = await this.client.createCodingSession({
+            owner: normalizedRequest.parentAgent,
+            name,
+            command: commandForRunner(normalizedRequest.runner),
+            workingDirectory: normalizedRequest.workdir,
+            prompt,
+            group: path.basename(normalizedRequest.workdir),
+            trust: "trusted",
+            autoResume: normalizedRequest.autoRestartOnCrash !== false,
+            source: this.source,
+        });
+        const promptFailure = promptDeliveryFailure(result);
+        if (promptFailure) {
+            throw new Error(promptFailure);
+        }
+        const session = this.toCodingSession(result.session, normalizedRequest);
+        this.records.set(session.id, { request: normalizedRequest, session });
+        (0, runtime_1.emitNervesEvent)({
+            component: "repertoire",
+            event: "repertoire.workbench_coding_session_spawned",
+            message: "Workbench coding session spawned",
+            meta: { id: session.id, runner: session.runner, workdir: session.workdir },
+        });
+        this.notifyListeners(session.id, { kind: "spawned", session: cloneSession(session) });
+        return cloneSession(session);
+    }
+    async refreshSessions() {
+        const workbenchSessions = await this.client.listSessions({ owner: this.agentName, includeArchived: true });
+        for (const workbenchSession of workbenchSessions) {
+            if (!workbenchSession.name.toLowerCase().startsWith("coding-"))
+                continue;
+            const existing = this.records.get(workbenchSession.id);
+            const fallbackRequest = existing?.request ?? this.fallbackRequest(workbenchSession);
+            const session = this.toCodingSession(workbenchSession, fallbackRequest, existing?.session);
+            this.records.set(session.id, { request: fallbackRequest, session });
+        }
+        return this.listSessions();
+    }
+    async refreshSession(sessionId) {
+        const sessions = await this.refreshSessions();
+        const session = sessions.find((item) => item.id === sessionId) ?? null;
+        if (!session)
+            return null;
+        const tail = await this.client.transcriptTail(sessionId);
+        const record = this.records.get(sessionId);
+        record.session.stdoutTail = tail;
+        record.session.lastActivityAt = this.nowIso();
+        record.session.checkpoint = tail.trim().split(/\r?\n/).filter(Boolean).at(-1) ?? record.session.checkpoint;
+        return cloneSession(record.session);
+    }
+    listSessions() {
+        return [...this.records.values()]
+            .map((record) => cloneSession(record.session))
+            .sort((left, right) => left.id.localeCompare(right.id));
+    }
+    getSession(sessionId) {
+        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);
+        };
+    }
+    async sendInput(sessionId, input) {
+        return this.queueAction(sessionId, "sendInput", { text: input, appendNewline: true });
+    }
+    async killSession(sessionId) {
+        const actionResult = await this.queueAction(sessionId, "terminate", {});
+        if (actionResult.ok) {
+            const record = this.records.get(sessionId);
+            record.session.status = "killed";
+            record.session.endedAt = this.nowIso();
+            record.session.checkpoint = "terminated by parent agent";
+            this.notifyListeners(sessionId, { kind: "killed", session: cloneSession(record.session) });
+        }
+        return actionResult;
+    }
+    checkStalls() {
+        return 0;
+    }
+    shutdown() {
+        this.listeners.clear();
+    }
+    async queueAction(sessionId, action, extra) {
+        let record = this.records.get(sessionId);
+        if (!record) {
+            await this.refreshSessions();
+            record = this.records.get(sessionId);
+        }
+        if (!record) {
+            return { ok: false, message: `session not found: ${sessionId}` };
+        }
+        const ack = await this.client.requestAction({
+            source: this.source,
+            action,
+            entry: sessionId,
+            ...extra,
+        });
+        if (!ack.requestId) {
+            return { ok: ack.ok === true, message: ack.message ?? `${action} queued for ${sessionId}` };
+        }
+        const result = await this.client.waitForAction(ack.requestId);
+        const actionResult = resultToActionResult(action, sessionId, result);
+        if (actionResult.ok && action === "sendInput") {
+            record.session.status = "running";
+            record.session.lastActivityAt = this.nowIso();
+            this.notifyListeners(sessionId, { kind: "progress", session: cloneSession(record.session) });
+        }
+        return actionResult;
+    }
+    fallbackRequest(session) {
+        const runner = runnerFromWorkbenchSession(session, "codex");
+        return {
+            runner,
+            workdir: session.workingDirectory ?? "",
+            prompt: "",
+            taskRef: session.name,
+            parentAgent: this.agentName,
+            autoRestartOnCrash: session.autoResume,
+        };
+    }
+    toCodingSession(workbenchSession, request, previous) {
+        const runner = runnerFromWorkbenchSession(workbenchSession, request.runner);
+        const status = mapWorkbenchStatus(workbenchSession);
+        const workdir = workbenchSession.workingDirectory ?? request.workdir;
+        const lastActivityAt = workbenchSession.lastOutputAt ?? workbenchSession.startedAt ?? previous?.lastActivityAt ?? this.nowIso();
+        const startedAt = workbenchSession.startedAt ?? previous?.startedAt ?? this.nowIso();
+        const command = commandForRunner(runner);
+        return {
+            id: workbenchSession.id,
+            runner,
+            workdir,
+            taskRef: request.taskRef,
+            originSession: request.originSession ? { ...request.originSession } : undefined,
+            obligationId: request.obligationId,
+            evolutionCaseId: request.evolutionCaseId,
+            scopeFile: request.scopeFile,
+            stateFile: request.stateFile,
+            checkpoint: checkpointFor(workbenchSession, status),
+            artifactPath: workbenchSession.transcriptPath,
+            status,
+            stdoutTail: previous?.stdoutTail ?? "",
+            stderrTail: previous?.stderrTail ?? "",
+            pid: workbenchSession.pid ?? null,
+            startedAt,
+            lastActivityAt,
+            endedAt: status === "completed" || status === "failed" ? lastActivityAt : null,
+            restartCount: previous?.restartCount ?? 0,
+            lastExitCode: workbenchSession.exitCode ?? null,
+            lastSignal: null,
+            failure: failureFor(workbenchSession, command),
+        };
+    }
+    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));
+        }
+    }
+}
+exports.WorkbenchCodingSessionManager = WorkbenchCodingSessionManager;

package/dist/senses/bluebubbles-meta-guard.js

@@ -6,9 +6,8 @@
 // Failure mode is "drop and log", never queue for later delivery.
 //
 // Patterns are deliberately narrow: bracketed system markers and angle-bracket
-// reasoning tags. Plain prose mentioning "inner dialog" or "attention queue"
-// is NOT blocked, so user-facing replies that legitimately discuss those
-// concepts still pass.
+// reasoning tags. Plain prose mentioning related concepts is NOT blocked, so
+// user-facing replies that legitimately discuss those concepts still pass.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.containsInternalMetaMarkers = containsInternalMetaMarkers;
 exports.emitBluebubblesMetaBlocked = emitBluebubblesMetaBlocked;

package/dist/senses/proactive-content-guard.js

@@ -8,8 +8,8 @@ const PROACTIVE_INTERNAL_CONTENT_PATTERNS = [
     // PR 447 patterns: raw meta markers
     { reason: "raw_meta_marker", pattern: /<\s*\/?\s*(think|analysis|commentary)\b[^>]*>/i },
     { reason: "raw_meta_marker", pattern: /\[\s*surfaced from inner dialog\s*\]/i },
-    // Inner dialog / attention / obligation references
-    { reason: "inner_dialog_reference", pattern: /\binner (dialog|dialogue)\b/i },
+    // Stale private-runtime vocabulary / attention / obligation references
+    { reason: "legacy_private_runtime_reference", pattern: /\binner (dialog|dialogue)\b/i },
     { reason: "attention_queue_reference", pattern: /\battention queues?\b/i },
     { reason: "return_obligation_reference", pattern: /\b(return|held|heart|inner)\s+obligations?\b/i },
     // Surfacing mechanics

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.686",
+  "version": "0.1.0-alpha.687",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",

package/dist/senses/inner-dialog-worker.js

@@ -1,61 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HEARTBEAT_OK_REST_SUPPRESSION_MS = exports.HABIT_RECURSION_BURST_THRESHOLD = exports.HABIT_RECURSION_BURST_WINDOW_MS = exports.HABIT_RECURSION_MIN_INTERVAL_MS = exports.MAX_CONSECUTIVE_INSTINCT_TURNS = void 0;
-exports.createInnerDialogWorker = createInnerDialogWorker;
-exports.startInnerDialogWorker = startInnerDialogWorker;
-const runtime_1 = require("../nerves/runtime");
-const innerDialog = __importStar(require("./inner-dialog"));
-const privateRuntimeWorker = __importStar(require("./private-runtime-worker"));
-exports.MAX_CONSECUTIVE_INSTINCT_TURNS = 3;
-exports.HABIT_RECURSION_MIN_INTERVAL_MS = 5_000;
-exports.HABIT_RECURSION_BURST_WINDOW_MS = 60_000;
-exports.HABIT_RECURSION_BURST_THRESHOLD = 5;
-exports.HEARTBEAT_OK_REST_SUPPRESSION_MS = 20 * 60_000;
-function createInnerDialogWorker(runTurn = (options) => {
-    return innerDialog.runInnerDialogTurn(options);
-}, hasPendingWork, nowSource) {
-    return privateRuntimeWorker.createPrivateRuntimeWorker(runTurn, hasPendingWork, nowSource);
-}
-async function startInnerDialogWorker() {
-    (0, runtime_1.emitNervesEvent)({
-        level: "info",
-        component: "senses",
-        event: "senses.inner_dialog_worker_compat_start",
-        message: "legacy inner-dialog worker startup delegated to private-runtime worker",
-        meta: { target: "private-runtime-worker" },
-    });
-    await privateRuntimeWorker.startPrivateRuntimeWorker();
-}

package/dist/senses/inner-dialog.js

@@ -1,23 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runInnerDialogTurn = exports.innerDialogSessionPath = exports.loadInnerDialogInstincts = exports.buildInnerDialogBootstrapMessage = void 0;
-__exportStar(require("./private-runtime"), exports);
-var private_runtime_1 = require("./private-runtime");
-Object.defineProperty(exports, "buildInnerDialogBootstrapMessage", { enumerable: true, get: function () { return private_runtime_1.buildPrivateRuntimeBootstrapMessage; } });
-Object.defineProperty(exports, "loadInnerDialogInstincts", { enumerable: true, get: function () { return private_runtime_1.loadPrivateRuntimeInstincts; } });
-Object.defineProperty(exports, "innerDialogSessionPath", { enumerable: true, get: function () { return private_runtime_1.privateRuntimeSessionPath; } });
-Object.defineProperty(exports, "runInnerDialogTurn", { enumerable: true, get: function () { return private_runtime_1.runPrivateRuntimeTurn; } });