@ouro.bot/cli 0.1.0-alpha.8 → 0.1.0-alpha.800

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,152 @@ 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).
+ * 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 +190,7 @@ const codingSpawnTool = {
                 taskRef: { type: "string" },
                 scopeFile: { type: "string" },
                 stateFile: { type: "string" },
+                evolutionCaseId: { type: "string" },
             },
             required: ["runner", "workdir", "prompt", "taskRef"],
         },
@@ -52,12 +200,26 @@ 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: {
+                sessionId: { type: "string" },
+            },
+        },
+    },
+};
+const codingTailTool = {
+    type: "function",
+    function: {
+        name: "coding_tail",
+        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: {
                 sessionId: { type: "string" },
             },
+            required: ["sessionId"],
         },
     },
 };
@@ -93,7 +255,7 @@ const codingKillTool = {
 exports.codingToolDefinitions = [
     {
         tool: codingSpawnTool,
-        handler: async (args) => {
+        handler: async (args, ctx) => {
             emitCodingToolEvent("coding_spawn");
             const rawRunner = requireArg(args, "runner");
             if (!rawRunner)
@@ -116,34 +278,135 @@ 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;
             const stateFile = optionalArg(args, "stateFile");
             if (stateFile)
                 request.stateFile = stateFile;
-            const session = await (0, index_1.getCodingSessionManager)().spawnSession(request);
+            const manager = (0, index_1.getCodingSessionManager)();
+            const existingSessions = await listCodingSessions(manager);
+            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",
+                    event: "repertoire.coding_codex_spawned",
+                    message: "spawned codex coding session",
+                    meta: { sessionId: session.id, taskRef: args.taskRef },
+                });
+            }
+            if (ctx?.codingFeedback) {
+                (0, index_1.attachCodingSessionFeedback)(manager, session, ctx.codingFeedback);
+            }
             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: async (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(await listCodingSessions(manager), ctx?.currentSession));
             }
-            const session = manager.getSession(sessionId);
+            const session = await getCodingSession(manager, sessionId);
             if (!session)
                 return `session not found: ${sessionId}`;
-            return JSON.stringify(session);
+            return appendCompletionScrutiny(JSON.stringify(session), session);
         },
+        summaryKeys: ["sessionId"],
+    },
+    {
+        tool: codingTailTool,
+        handler: async (args) => {
+            emitCodingToolEvent("coding_tail");
+            const sessionId = requireArg(args, "sessionId");
+            if (!sessionId)
+                return "sessionId is required";
+            const session = await getCodingSession((0, index_1.getCodingSessionManager)(), sessionId);
+            if (!session)
+                return `session not found: ${sessionId}`;
+            return appendCompletionScrutiny((0, index_1.formatCodingTail)(session), session);
+        },
+        summaryKeys: ["sessionId"],
     },
     {
         tool: codingSendInputTool,
-        handler: (args) => {
+        handler: async (args) => {
             emitCodingToolEvent("coding_send_input");
             const sessionId = requireArg(args, "sessionId");
             if (!sessionId)
@@ -151,17 +414,21 @@ 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;