@ouro.bot/cli 0.1.0-alpha.803 → 0.1.0-alpha.805

package/dist/heart/daemon/daemon.js

@@ -82,6 +82,11 @@ const router_1 = require("../external-events/router");
 const habit_policy_1 = require("../../rsvp/habit-policy");
 const container_runtime_1 = require("./container-runtime");
 const habit_session_1 = require("../habits/habit-session");
+const turn_execution_lease_1 = require("../turn-execution-lease");
+const frontend_session_service_1 = require("../frontend-session-service");
+const frontend_socket_1 = require("../frontend-socket");
+const frontend_journal_1 = require("../frontend-journal");
+const frontend_approval_runtime_1 = require("../frontend-approval-runtime");
 const PIDFILE_PATH = path.join(os.homedir(), ".ouro-cli", "daemon.pids");
 /**
  * Defense-in-depth: detect if we're running under vitest. The pidfile lives
@@ -556,33 +561,35 @@ function taskIdFromTaskPokePrivateWakeCommand(command) {
  * restarts the daemon process (fresh module cache).
  */
 async function handleAgentSenseTurn(command, runtime) {
-    try {
-        const { setAgentName } = await Promise.resolve().then(() => __importStar(require("../identity")));
-        setAgentName(command.agent);
-        const { runSenseTurn } = await Promise.resolve().then(() => __importStar(require("../../senses/shared-turn")));
-        const result = await runSenseTurn({
-            agentName: command.agent,
-            channel: command.channel,
-            sessionKey: command.sessionKey,
-            friendId: command.friendId,
-            userMessage: command.message,
-            ...(runtime?.socketPath ? { toolContext: { daemonSocketPath: runtime.socketPath } } : {}),
-            // Per-turn, per-agent runtime MCP injection (e.g. Workbench's ouro_workbench).
-            // Scoped to THIS turn only — never stored as module state, so a concurrent
-            // turn for a different agent cannot inherit these servers.
-            ...(command.runtimeMcp ? { runtimeMcpServers: command.runtimeMcp } : {}),
-        });
-        return {
-            ok: true,
-            message: result.response,
-            data: { ponderDeferred: result.ponderDeferred },
-        };
-    }
-    catch (error) {
-        /* v8 ignore next -- branch: String(error) fallback only for non-Error throws @preserve */
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        return { ok: false, error: `sense turn failed: ${errorMessage}` };
-    }
+    return (0, turn_execution_lease_1.withTurnExecutionLease)(async () => {
+        try {
+            const { setAgentName } = await Promise.resolve().then(() => __importStar(require("../identity")));
+            setAgentName(command.agent);
+            const { runSenseTurn } = await Promise.resolve().then(() => __importStar(require("../../senses/shared-turn")));
+            const result = await runSenseTurn({
+                agentName: command.agent,
+                channel: command.channel,
+                sessionKey: command.sessionKey,
+                friendId: command.friendId,
+                userMessage: command.message,
+                ...(runtime?.socketPath ? { toolContext: { daemonSocketPath: runtime.socketPath } } : {}),
+                // Per-turn, per-agent runtime MCP injection (e.g. Workbench's ouro_workbench).
+                // Scoped to THIS turn only — never stored as module state, so a concurrent
+                // turn for a different agent cannot inherit these servers.
+                ...(command.runtimeMcp ? { runtimeMcpServers: command.runtimeMcp } : {}),
+            });
+            return {
+                ok: true,
+                message: result.response,
+                data: { ponderDeferred: result.ponderDeferred },
+            };
+        }
+        catch (error) {
+            /* v8 ignore next -- branch: String(error) fallback only for non-Error throws @preserve */
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return { ok: false, error: `sense turn failed: ${errorMessage}` };
+        }
+    });
 }
 async function handleAgentAskTurn(command, runtime) {
     /* v8 ignore start -- ask command parameter defaults are legacy MCP compatibility; send_message shares the primary path @preserve */
@@ -614,12 +621,16 @@ class OuroDaemon {
     mode;
     server = null;
     mailboxServer = null;
+    frontendSocketServer = null;
     socketIdentity = null;
     senseAutostartTimer = null;
     externalEventReconcileTimer = null;
     externalEventReconcileRunning = false;
     constructedAtMs = Date.now();
     mailboxServerFactory;
+    frontendSocketPath;
+    frontendSessionService;
+    frontendSocketServerFactory;
     privateRuntimePolicyDeps;
     onStopCommandComplete;
     externalEventRoot;
@@ -644,6 +655,17 @@ class OuroDaemon {
         this.bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
         this.mode = options.mode ?? "production";
         this.mailboxServerFactory = options.mailboxServerFactory ?? this.createDefaultMailboxServer.bind(this);
+        this.frontendSocketPath = options.frontendSocketPath ?? (0, frontend_socket_1.frontendSocketPathForDaemon)(this.socketPath);
+        /* v8 ignore next -- path-only default adapter; frontend service tests inject and verify the same root contract @preserve */
+        const frontendAgentRoot = (agent) => path.join(this.bundlesRoot, `${agent}.ouro`);
+        this.frontendSessionService = options.frontendSessionService ?? new frontend_session_service_1.FrontendSessionService({
+            journal: new frontend_journal_1.FrontendJournalStore({ agentRoot: frontendAgentRoot }),
+            authority: (0, frontend_approval_runtime_1.createFrontendApprovalRuntime)({
+                agentRoot: frontendAgentRoot,
+                settleApproval: frontend_approval_runtime_1.settleFrontendApproval,
+            }),
+        });
+        this.frontendSocketServerFactory = options.frontendSocketServerFactory ?? frontend_socket_1.startFrontendSocketServer;
         this.privateRuntimePolicyDeps = options.privateRuntimePolicyDeps ?? {};
         this.onStopCommandComplete = options.onStopCommandComplete ?? null;
         this.externalEventRoot = options.externalEventRoot ?? null;
@@ -848,6 +870,21 @@ class OuroDaemon {
                 meta: { port: mailbox_types_1.MAILBOX_DEFAULT_PORT },
             });
         }
+        try {
+            this.frontendSocketServer = await this.frontendSocketServerFactory({
+                socketPath: this.frontendSocketPath,
+                service: this.frontendSessionService,
+            });
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "daemon",
+                event: "daemon.frontend_socket_start_failed",
+                message: `Frontend socket failed to start: ${String(error)}`,
+                meta: { socketPath: this.frontendSocketPath },
+            });
+        }
     }
     triggerAutoStartAgents() {
         if (this.processManager.triggerAutoStartAgents) {
@@ -1117,6 +1154,12 @@ class OuroDaemon {
             message: "stopping daemon server",
             meta: { socketPath: this.socketPath },
         });
+        this.frontendSessionService.cancelAllTurns();
+        if (this.frontendSocketServer) {
+            await this.frontendSocketServer.stop();
+            this.frontendSocketServer = null;
+        }
+        this.frontendSessionService.close?.();
         (0, update_checker_1.stopUpdateChecker)();
         (0, mcp_manager_1.shutdownSharedMcpManager)();
         this.scheduler.stop?.();
@@ -2402,28 +2445,32 @@ class OuroDaemon {
                 return this.handlePrivateRuntimeWake(this.buildAwaitPrivateWakeCommand(command));
             }
             case "mcp.list": {
-                (0, identity_1.setAgentName)(command.agent ?? "default");
-                const mcpManager = await (0, mcp_manager_1.getSharedMcpManager)();
-                if (!mcpManager) {
-                    return { ok: true, data: [], message: "no MCP servers configured" };
-                }
-                return { ok: true, data: mcpManager.listAllTools() };
+                return (0, turn_execution_lease_1.withTurnExecutionLease)(async () => {
+                    (0, identity_1.setAgentName)(command.agent ?? "default");
+                    const mcpManager = await (0, mcp_manager_1.getSharedMcpManager)();
+                    if (!mcpManager) {
+                        return { ok: true, data: [], message: "no MCP servers configured" };
+                    }
+                    return { ok: true, data: mcpManager.listAllTools() };
+                });
             }
             case "mcp.call": {
-                (0, identity_1.setAgentName)(command.agent ?? "default");
-                const mcpCallManager = await (0, mcp_manager_1.getSharedMcpManager)();
-                if (!mcpCallManager) {
-                    return { ok: false, error: "no MCP servers configured" };
-                }
-                try {
-                    const parsedArgs = command.args ? JSON.parse(command.args) : {};
-                    const result = await mcpCallManager.callTool(command.server, command.tool, parsedArgs);
-                    return { ok: true, data: result };
-                }
-                catch (error) {
-                    /* v8 ignore next -- defensive: callTool errors are always Error instances @preserve */
-                    return { ok: false, error: error instanceof Error ? error.message : String(error) };
-                }
+                return (0, turn_execution_lease_1.withTurnExecutionLease)(async () => {
+                    (0, identity_1.setAgentName)(command.agent ?? "default");
+                    const mcpCallManager = await (0, mcp_manager_1.getSharedMcpManager)();
+                    if (!mcpCallManager) {
+                        return { ok: false, error: "no MCP servers configured" };
+                    }
+                    try {
+                        const parsedArgs = command.args ? JSON.parse(command.args) : {};
+                        const result = await mcpCallManager.callTool(command.server, command.tool, parsedArgs);
+                        return { ok: true, data: result };
+                    }
+                    catch (error) {
+                        /* v8 ignore next -- defensive: callTool errors are always Error instances @preserve */
+                        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+                    }
+                });
             }
             case "hatch.start":
                 return {

package/dist/heart/daemon/sense-manager.js

@@ -359,7 +359,7 @@ function senseRepairHint(agent, sense) {
     }
     /* v8 ignore next -- Workbench is deliberately not daemon-managed, so getSenseInventory never asks the daemon manager for a repair hint @preserve */
     if (sense === "workbench") {
-        return `Agent-runnable: install Ouro Workbench.app, then launch the boss through Workbench or run 'ouro mcp-serve --agent ${agent} --workbench-mcp'; 'ouro connect workbench --agent ${agent}' only cleans stale bundle entries.`;
+        return `Agent-runnable: install Ouro Workbench.app, then launch the boss through Workbench or run 'ouro acp-serve --agent ${agent} --workbench-mcp'; 'ouro connect workbench --agent ${agent}' only cleans stale bundle entries.`;
     }
     return `Run 'ouro connect bluebubbles --agent ${agent}' to attach BlueBubbles on this machine; then run 'ouro up' again.`;
 }

package/dist/heart/frontend-approval-runtime.js

@@ -0,0 +1,432 @@
+"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.settleFrontendApproval = settleFrontendApproval;
+exports.createFrontendApprovalRuntime = createFrontendApprovalRuntime;
+const node_crypto_1 = require("node:crypto");
+const path = __importStar(require("node:path"));
+const approval_files_1 = require("./approval-files");
+const approval_store_1 = require("./approval-store");
+const tool_approval_1 = require("./tool-approval");
+const core_1 = require("./core");
+const identity_1 = require("./identity");
+const turn_execution_lease_1 = require("./turn-execution-lease");
+const context_1 = require("../mind/context");
+const session_transaction_1 = require("../mind/session-transaction");
+const tools_1 = require("../repertoire/tools");
+const mcp_manager_1 = require("../repertoire/mcp-manager");
+const runtime_1 = require("../nerves/runtime");
+const PERMISSION_OPTIONS = [
+    { optionId: "allow-once", name: "Allow once", kind: "allow_once" },
+    { optionId: "reject-once", name: "Reject", kind: "reject_once" },
+];
+/* v8 ignore start -- lazy default adapter avoids widening every daemon test mock; settlement behavior is covered through the injected dependency @preserve */
+async function defaultReleaseRuntimeMcpServers() {
+    const manager = await Promise.resolve().then(() => __importStar(require("../repertoire/mcp-manager")));
+    await manager.releaseRuntimeMcpServers();
+}
+/* v8 ignore stop */
+const DEFAULT_SETTLEMENT_DEPENDENCIES = {
+    withTurnExecutionLease: turn_execution_lease_1.withTurnExecutionLease,
+    setAgentName: identity_1.setAgentName,
+    withSessionTurnLease: session_transaction_1.withSessionTurnLease,
+    readSessionTransaction: session_transaction_1.readSessionTransaction,
+    executeApprovalDecision: tool_approval_1.executeApprovalDecision,
+    resolveToolDefinition: tools_1.resolveToolDefinition,
+    approvalPolicyForInvocation: tools_1.approvalPolicyForInvocation,
+    execTool: tools_1.execTool,
+    getSharedMcpManager: mcp_manager_1.getSharedMcpManager,
+    releaseRuntimeMcpServers: defaultReleaseRuntimeMcpServers,
+    loadSession: context_1.loadSession,
+    postTurnTrim: context_1.postTurnTrim,
+    postTurnPersist: context_1.postTurnPersist,
+    resumeApprovalContinuation: core_1.resumeApprovalContinuation,
+    runAgent: core_1.runAgent,
+    randomUUID: node_crypto_1.randomUUID,
+};
+async function settleFrontendApproval(input, dependencies = DEFAULT_SETTLEMENT_DEPENDENCIES) {
+    const token = input.tokenStore.get(input.suspension.approvalId);
+    if (!token)
+        throw new Error(`frontend approval decision token is unavailable: ${input.suspension.approvalId}`);
+    const checkpoint = input.checkpointStore.read(input.suspension.approvalId);
+    if (!checkpoint)
+        throw new Error(`frontend approval checkpoint is unavailable: ${input.suspension.approvalId}`);
+    const record = input.approvalStore.read(input.suspension.approvalId);
+    if (!record)
+        throw new Error(`frontend approval record is unavailable: ${input.suspension.approvalId}`);
+    return dependencies.withTurnExecutionLease(async () => {
+        dependencies.setAgentName(input.request.agent);
+        try {
+            const mcpManager = await dependencies.getSharedMcpManager(input.request.runtimeMcpServers ? { runtimeServers: input.request.runtimeMcpServers } : undefined) ?? undefined;
+            return await dependencies.withSessionTurnLease(record.sessionPath, async (lease) => {
+                const currentRevision = dependencies.readSessionTransaction(record.sessionPath, lease).revision;
+                const continuationSignal = input.optionId === "cancelled" ? AbortSignal.abort() : input.signal;
+                const liveToolContext = input.approvalRequest.liveToolContext ?? {
+                    signin: async () => undefined,
+                    agentRoot: input.agentRoot,
+                    currentSession: {
+                        friendId: input.request.friendId,
+                        channel: input.request.channel,
+                        key: input.request.sessionKey,
+                        sessionPath: record.sessionPath,
+                    },
+                    currentUserMessage: input.request.message,
+                };
+                const terminal = await dependencies.executeApprovalDecision({
+                    approvalStore: input.approvalStore,
+                    checkpointStore: input.checkpointStore,
+                    decision: {
+                        approvalId: record.approvalId,
+                        decisionToken: token,
+                        decision: input.optionId === "allow-once" ? "approve" : "deny",
+                        requesterId: input.request.friendId,
+                        transport: "frontend",
+                        transportUserId: input.request.friendId,
+                        transportChatId: input.request.sessionKey,
+                        transportMessageId: record.approvalId,
+                        sessionKey: input.request.sessionKey,
+                        ...(input.optionId === "expired" ? { decisionAt: Date.parse(record.expiresAt) } : {}),
+                    },
+                    ownerId: `frontend-decision-${dependencies.randomUUID()}`,
+                    currentSessionRevision: currentRevision,
+                    resolveTool: dependencies.resolveToolDefinition,
+                    resolveApprovalPolicy: (name, args) => dependencies.approvalPolicyForInvocation(name, args, liveToolContext),
+                    liveGuard: async () => ({ ok: true }),
+                    liveRisk: async () => ({ ok: true }),
+                    execute: (name, args) => dependencies.execTool(name, args, liveToolContext),
+                });
+                input.tokenStore.remove(record.approvalId);
+                const existing = dependencies.loadSession(record.sessionPath);
+                const existingStructuredOutputIds = new Set(existing?.structuredOutputs.map((output) => output.id) ?? []);
+                const deliveries = [];
+                let response = "";
+                const emit = input.frontendEventSink.onEvent;
+                const callbacks = {
+                    settleOutputMode: "retractable_buffer",
+                    onModelStart: () => emit({ type: "model_started", data: {} }),
+                    onModelStreamStart: () => emit({ type: "model_stream_started", data: {} }),
+                    onTextChunk: (text) => {
+                        response += text;
+                        emit({ type: "text_delta", data: { text } });
+                    },
+                    onReasoningChunk: (text) => emit({ type: "reasoning_delta", data: { text } }),
+                    onToolStart: (name, args) => emit({ type: "tool_started", data: { name, args } }),
+                    onToolEnd: (name, summary, success) => emit({ type: "tool_completed", data: { name, summary, success } }),
+                    onError: (error, severity) => emit({ type: "error", data: { message: error.message, severity } }),
+                    onClearText: () => {
+                        response = "";
+                        emit({ type: "text_cleared", data: {} });
+                    },
+                };
+                let continuationEpoch = 0;
+                const continuationOwnerId = `frontend-continuation-${dependencies.randomUUID()}`;
+                const nestedCoordinator = {
+                    propose: (request) => input.approvalCoordinatorFactory({
+                        request: input.request,
+                        publish: input.publish,
+                    })({
+                        sessionPath: record.sessionPath,
+                        baseSessionRevision: dependencies.readSessionTransaction(record.sessionPath, lease).revision,
+                    }).propose(request),
+                };
+                const persist = (messages, result) => {
+                    const expectedRevision = dependencies.readSessionTransaction(record.sessionPath, lease).revision;
+                    const prepared = dependencies.postTurnTrim(messages, result?.usage);
+                    dependencies.postTurnPersist(record.sessionPath, prepared, result?.usage, existing?.state, lease, expectedRevision);
+                };
+                const continuation = await dependencies.resumeApprovalContinuation({
+                    record: terminal,
+                    checkpoint,
+                    currentSessionRevision: dependencies.readSessionTransaction(record.sessionPath, lease).revision,
+                    sessionMessages: checkpoint.preCallMessages,
+                    callbacks,
+                    channel: input.request.channel,
+                    claimContinuation: () => {
+                        const claim = input.approvalStore.claimContinuation({
+                            approvalId: record.approvalId,
+                            ownerId: continuationOwnerId,
+                        });
+                        continuationEpoch = claim.record.continuationEpoch;
+                        return claim;
+                    },
+                    markContinuationMaterialized: () => {
+                        input.approvalStore.markContinuationMaterialized({
+                            approvalId: record.approvalId,
+                            ownerId: continuationOwnerId,
+                            epoch: continuationEpoch,
+                        });
+                    },
+                    markContinuationAttempted: () => {
+                        input.approvalStore.markContinuationAttempted({
+                            approvalId: record.approvalId,
+                            ownerId: continuationOwnerId,
+                            epoch: continuationEpoch,
+                        });
+                    },
+                    completeContinuation: () => {
+                        input.approvalStore.completeContinuation({
+                            approvalId: record.approvalId,
+                            ownerId: continuationOwnerId,
+                            epoch: continuationEpoch,
+                        });
+                    },
+                    runAgent: dependencies.runAgent,
+                    runAgentOptions: {
+                        mcpManager,
+                        toolContext: liveToolContext,
+                        approvalCoordinator: nestedCoordinator,
+                    },
+                    persist,
+                    deliver: async (text) => {
+                        response = text;
+                        deliveries.push({ kind: "text", text });
+                        emit({ type: "assistant_delivery", data: { kind: "text", text } });
+                    },
+                    signal: continuationSignal,
+                });
+                const persisted = dependencies.loadSession(record.sessionPath);
+                for (const output of persisted?.structuredOutputs ?? []) {
+                    if (!existingStructuredOutputIds.has(output.id)) {
+                        emit({ type: "structured_output", data: { output } });
+                    }
+                }
+                const turnOutcome = continuation.outcome === "terminal_notice"
+                    ? "settled"
+                    : continuation.outcome === "already_continued"
+                        ? "superseded"
+                        : continuation.outcome;
+                if (turnOutcome === "suspended" && !continuation.suspension) {
+                    throw new Error("frontend approval continuation omitted its nested suspension");
+                }
+                return {
+                    response,
+                    ponderDeferred: false,
+                    deliveries,
+                    deliveryFailures: [],
+                    sessionPath: record.sessionPath,
+                    turnOutcome,
+                    ...(continuation.suspension ? { suspension: continuation.suspension } : {}),
+                };
+            });
+        }
+        finally {
+            if (input.request.runtimeMcpServers) {
+                await dependencies.releaseRuntimeMcpServers();
+            }
+        }
+    });
+}
+function createFrontendApprovalRuntime(options) {
+    const agentRoot = options.agentRoot ?? identity_1.getAgentRoot;
+    const now = options.now ?? Date.now;
+    const approvalTimeoutMs = options.approvalTimeoutMs ?? 300_000;
+    const settleApproval = options.settleApproval ?? settleFrontendApproval;
+    if (!Number.isSafeInteger(approvalTimeoutMs) || approvalTimeoutMs < 1) {
+        throw new Error("approvalTimeoutMs must be a positive integer");
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.frontend_approval_runtime_ready",
+        message: "frontend approval runtime ready",
+    });
+    const states = new Map();
+    const pending = new Map();
+    let closed = false;
+    function closeStatesWhenIdle() {
+        if (!closed || pending.size > 0)
+            return;
+        for (const state of states.values())
+            state.approvalStore.close();
+        states.clear();
+    }
+    function stateFor(agent) {
+        let state = states.get(agent);
+        if (state)
+            return state;
+        const stateRoot = path.join(agentRoot(agent), "state", "approvals");
+        state = {
+            approvalStore: (0, approval_store_1.openApprovalStore)({ databasePath: path.join(stateRoot, "approvals.sqlite") }),
+            checkpointStore: new approval_files_1.FileApprovalCheckpointStore(path.join(stateRoot, "checkpoints.json")),
+            tokenStore: new approval_files_1.FileApprovalTokenStore(path.join(stateRoot, "tokens.json")),
+        };
+        states.set(agent, state);
+        return state;
+    }
+    function settlePending(item, optionId) {
+        if (item.settled)
+            return false;
+        item.settled = true;
+        item.resolve(optionId);
+        item.publish("permission_resolved", { requestId: item.requestId, optionId }, "permission_resolved");
+        return true;
+    }
+    const runtime = {
+        approvalCoordinatorFactory(input) {
+            return (context) => ({
+                propose: async (request) => {
+                    if (closed)
+                        throw new Error("frontend approval runtime is closed");
+                    if (request.toolCall.type !== "function")
+                        throw new Error("frontend approval requires a function tool call");
+                    const state = stateFor(input.request.agent);
+                    const committed = (0, tool_approval_1.commitApprovalProposal)({
+                        approvalStore: state.approvalStore,
+                        checkpointStore: state.checkpointStore,
+                        tokenStore: state.tokenStore,
+                        proposal: {
+                            toolCallId: request.toolCall.id,
+                            toolName: request.toolCall.function.name,
+                            arguments: request.arguments,
+                            schemaDigest: request.schemaDigest,
+                            toolDigest: request.toolDigest,
+                            policyDigest: request.policyDigest,
+                            policyId: request.policyId,
+                            sessionKey: input.request.sessionKey,
+                            sessionPath: context.sessionPath,
+                            baseSessionRevision: context.baseSessionRevision,
+                            checkpointDigest: "0".repeat(64),
+                            requesterId: input.request.friendId,
+                            transport: "frontend",
+                            transportUserId: input.request.friendId,
+                            transportChatId: input.request.sessionKey,
+                            expiresAt: new Date(now() + approvalTimeoutMs).toISOString(),
+                            frozenAssistantMessage: request.frozenAssistantMessage,
+                        },
+                        preCallMessages: request.preCallMessages,
+                    });
+                    const decision = Promise.withResolvers();
+                    state.approvalStore.bindPrompt({
+                        approvalId: committed.record.approvalId,
+                        transport: "frontend",
+                        transportChatId: input.request.sessionKey,
+                        transportMessageId: committed.record.approvalId,
+                    });
+                    const item = {
+                        requestId: committed.record.approvalId,
+                        toolCallId: request.toolCall.id,
+                        title: `Approve ${request.toolCall.function.name}`,
+                        request: input.request,
+                        approvalRequest: request,
+                        expiresAt: Date.parse(committed.record.expiresAt),
+                        publish: input.publish,
+                        decision: decision.promise,
+                        resolve: decision.resolve,
+                        settled: false,
+                    };
+                    pending.set(committed.record.approvalId, item);
+                    input.publish("permission_requested", {
+                        requestId: committed.record.approvalId,
+                        toolCallId: request.toolCall.id,
+                        title: `Approve ${request.toolCall.function.name}`,
+                        options: PERMISSION_OPTIONS,
+                    }, "permission_requested");
+                    return {
+                        approvalId: committed.record.approvalId,
+                        checkpointDigest: committed.record.checkpointDigest,
+                        suspendedSessionRevision: committed.record.suspendedSessionRevision,
+                    };
+                },
+            });
+        },
+        async resumeApproval(input) {
+            const item = pending.get(input.suspension.approvalId);
+            if (!item || item.request.turnId !== input.request.turnId) {
+                throw new Error(`frontend approval ${input.suspension.approvalId} does not own turn ${input.request.turnId}`);
+            }
+            const abort = () => settlePending(item, "cancelled");
+            if (input.signal.aborted)
+                abort();
+            else
+                input.signal.addEventListener("abort", abort, { once: true });
+            const timeout = setTimeout(() => settlePending(item, "expired"), Math.max(0, item.expiresAt - now()));
+            try {
+                const optionId = await item.decision;
+                const state = stateFor(input.request.agent);
+                return await settleApproval({
+                    ...input,
+                    approvalRequest: item.approvalRequest,
+                    optionId,
+                    publish: item.publish,
+                    agentRoot: agentRoot(input.request.agent),
+                    ...state,
+                    approvalCoordinatorFactory: runtime.approvalCoordinatorFactory,
+                });
+            }
+            finally {
+                clearTimeout(timeout);
+                input.signal.removeEventListener("abort", abort);
+                pending.delete(input.suspension.approvalId);
+                closeStatesWhenIdle();
+            }
+        },
+        resolvePermission(requestId, optionId) {
+            if (closed || (optionId !== "allow-once" && optionId !== "reject-once" && optionId !== "cancelled"))
+                return false;
+            const item = pending.get(requestId);
+            return item ? settlePending(item, optionId) : false;
+        },
+        cancelTurn(turnId) {
+            for (const item of pending.values()) {
+                if (item.request.turnId === turnId)
+                    settlePending(item, "cancelled");
+            }
+        },
+        pendingPermissions(ref) {
+            return [...pending.values()].flatMap((item) => {
+                if (item.settled
+                    || item.request.agent !== ref.agent
+                    || item.request.friendId !== ref.friendId
+                    || item.request.sessionKey !== ref.sessionKey)
+                    return [];
+                return [{
+                        requestId: item.requestId,
+                        turnId: item.request.turnId,
+                        toolCallId: item.toolCallId,
+                        title: item.title,
+                        options: [...PERMISSION_OPTIONS],
+                    }];
+            });
+        },
+        close() {
+            if (closed)
+                return;
+            for (const item of pending.values())
+                settlePending(item, "cancelled");
+            closed = true;
+            closeStatesWhenIdle();
+        },
+    };
+    return runtime;
+}