pulseed 0.6.0 → 0.6.2

package/dist/interface/chat/cross-platform-session.js

@@ -2,7 +2,10 @@ import { randomUUID } from "node:crypto";
 import * as path from "node:path";
 import { ChatRunner } from "./chat-runner.js";
 import { createIngressRouter, } from "./ingress-router.js";
-import { recognizeRuntimeControlIntent } from "../../runtime/control/index.js";
+import { classifyRuntimeControlIntent } from "../../runtime/control/index.js";
+import { classifyFreeformRouteIntent } from "./freeform-route-classifier.js";
+import { deriveRunSpecFromText } from "../../runtime/run-spec/index.js";
+import { intakeSetupSecrets } from "./setup-secret-intake.js";
 import { StateManager } from "../../base/state/state-manager.js";
 import { buildAdapterRegistry, buildLLMClient } from "../../base/llm/provider-factory.js";
 import { loadProviderConfig } from "../../base/llm/provider-config.js";
@@ -19,7 +22,11 @@ import { buildCliDataSourceRegistry } from "../cli/data-source-bootstrap.js";
 import { ConcurrencyController, createBuiltinTools, ToolExecutor, ToolPermissionManager, ToolRegistry, } from "../../tools/index.js";
 import { createNativeChatAgentLoopRunner, createNativeReviewAgentLoopRunner, shouldUseNativeTaskAgentLoop, } from "../../orchestrator/execution/agent-loop/index.js";
 import { RuntimeControlService, createDaemonRuntimeControlExecutor, } from "../../runtime/control/index.js";
+import { ApprovalBroker } from "../../runtime/approval-broker.js";
+import { ApprovalStore, createRuntimeStorePaths } from "../../runtime/store/index.js";
+import { classifyConversationalApprovalDecision } from "../../runtime/conversational-approval-decision.js";
 import { registerGlobalCrossPlatformChatSessionManager } from "./cross-platform-session-global.js";
+import { buildCompanionRuntimeContract, evaluateCompanionOutputPolicy, } from "../../runtime/companion-policy.js";
 function normalizeIdentity(value) {
     const trimmed = value?.trim();
     return trimmed ? trimmed : null;
@@ -82,9 +89,11 @@ function resolveRuntimeControl(channel, runtimeControl, metadata) {
     const approvalMode = runtimeControl?.approvalMode
         ?? (metadata?.["runtime_control_approved"] === true
             ? "preapproved"
-            : channel === "tui" || channel === "cli"
-                ? "interactive"
-                : "disallowed");
+            : metadata?.["runtime_control_denied"] === true
+                ? "disallowed"
+                : channel === "tui" || channel === "cli"
+                    ? "interactive"
+                    : "disallowed");
     return {
         allowed: runtimeControl?.allowed ?? approvalMode !== "disallowed",
         approvalMode,
@@ -125,22 +134,46 @@ function normalizeActor(channel, input) {
         ...input.actor,
     };
 }
-function safeInvoke(handler, event) {
+async function safeInvoke(handler, event) {
     if (!handler)
         return;
     try {
-        const result = handler(event);
-        if (result && typeof result.catch === "function") {
-            void result.catch(() => undefined);
-        }
+        await handler(event);
     }
-    catch {
+    catch (err) {
         // Event streaming should not break chat delivery.
+        console.warn("[chat] event delivery failed", {
+            eventType: event.type,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+}
+class ChatEventDeliveryQueue {
+    handler;
+    upstream;
+    queue = Promise.resolve();
+    constructor(handler, upstream) {
+        this.handler = handler;
+        this.upstream = upstream;
+    }
+    dispatch = (event) => {
+        this.queue = this.queue.then(async () => {
+            await safeInvoke(this.handler, event);
+            if (this.upstream && this.upstream !== this.handler) {
+                await safeInvoke(this.upstream, event);
+            }
+        });
+        return this.queue;
+    };
+    async drain() {
+        await this.queue;
     }
 }
 export class CrossPlatformChatSessionManager {
     deps;
     sessions = new Map();
+    activeApprovalEventHandlers = new Map();
+    approvalSideTurnIngressIds = new Set();
     ingressRouter = createIngressRouter();
     constructor(deps) {
         this.deps = deps;
@@ -164,51 +197,154 @@ export class CrossPlatformChatSessionManager {
             channel: options.channel ?? (options.platform ? "plugin_gateway" : "cli"),
             actor: options.actor,
             replyTarget: options.replyTarget,
-            runtimeControl: options.runtimeControl ?? {
-                allowed: true,
-                approvalMode: "interactive",
-            },
+            runtimeControl: options.runtimeControl,
+            companion: options.companion,
             cwd: options.cwd,
             timeoutMs: options.timeoutMs,
-            metadata: options.metadata,
+            metadata: {
+                ...(options.metadata ?? {}),
+                ...(options.runtimeControl ? { runtime_control_explicit: true } : {}),
+            },
             onEvent: options.onEvent,
         });
+        const approvalReply = await this.tryResolveConversationalApprovalReply(ingress);
+        if (approvalReply) {
+            return {
+                success: true,
+                output: approvalReply,
+                elapsed_ms: 0,
+            };
+        }
         const session = this.getOrCreateSession(ingress, options.cwd);
+        if (ingress.ingress_id && this.approvalSideTurnIngressIds.delete(ingress.ingress_id)) {
+            return this.executeInSession(session, ingress, options);
+        }
         const queueEntry = session.queue.then(() => this.executeInSession(session, ingress, options));
         session.queue = queueEntry.then(() => undefined, () => undefined);
         return queueEntry;
     }
     async processIncomingMessage(input) {
-        const result = await this.executeIngress(this.createIngressMessage(input), input);
+        const ingress = this.createIngressMessage(input);
+        if (input.approvalResponse) {
+            return this.resolveConversationalApprovalIngress(ingress, input.approvalResponse);
+        }
+        const approvalReply = await this.tryResolveConversationalApprovalReply(ingress);
+        if (approvalReply) {
+            return approvalReply;
+        }
+        const result = await this.executeIngress(ingress, input);
         return result.output;
     }
     async interruptAndRedirect(input) {
-        const ingress = this.createIngressMessage(input);
+        const ingress = this.ensureCompanionContract(this.createIngressMessage(input));
+        const approvalReply = await this.tryResolveConversationalApprovalReply(ingress);
+        if (approvalReply) {
+            return {
+                success: true,
+                output: approvalReply,
+                elapsed_ms: 0,
+            };
+        }
         const session = this.getOrCreateSession(ingress, input.cwd);
+        const decision = evaluateCompanionOutputPolicy(ingress.companion.turn_policy);
+        if (!decision.delivered) {
+            return {
+                success: true,
+                output: formatCompanionPolicyDecision(decision),
+                elapsed_ms: 0,
+            };
+        }
         const previousOnEvent = session.runner.onEvent;
+        let deliveryQueue = null;
         if (input.onEvent) {
-            const handler = input.onEvent;
-            const upstream = this.deps.onEvent;
-            session.runner.onEvent = (event) => {
-                safeInvoke(handler, event);
-                if (upstream && upstream !== handler) {
-                    safeInvoke(upstream, event);
-                }
-            };
+            deliveryQueue = new ChatEventDeliveryQueue(input.onEvent, this.deps.onEvent);
+            session.runner.onEvent = deliveryQueue.dispatch;
         }
         try {
             return await session.runner.interruptAndRedirect(input.text, session.info.cwd, input.timeoutMs);
         }
         finally {
+            await deliveryQueue?.drain();
             session.runner.onEvent = previousOnEvent;
         }
     }
     async executeIngress(ingress, options = {}) {
-        const session = this.getOrCreateSession(ingress, options.cwd);
-        const queueEntry = session.queue.then(() => this.executeInSession(session, ingress, options));
+        const normalizedIngress = this.ensureCompanionContract(ingress);
+        const decision = evaluateCompanionOutputPolicy(normalizedIngress.companion.turn_policy);
+        if (!decision.delivered) {
+            return {
+                success: true,
+                output: formatCompanionPolicyDecision(decision),
+                elapsed_ms: 0,
+            };
+        }
+        const session = this.getOrCreateSession(normalizedIngress, options.cwd);
+        if (normalizedIngress.ingress_id && this.approvalSideTurnIngressIds.delete(normalizedIngress.ingress_id)) {
+            return this.executeInSession(session, normalizedIngress, options);
+        }
+        const queueEntry = session.queue.then(() => this.executeInSession(session, normalizedIngress, options));
         session.queue = queueEntry.then(() => undefined, () => undefined);
         return queueEntry;
     }
+    async resolveConversationalApprovalIngress(ingress, response) {
+        const broker = this.deps.approvalBroker;
+        if (!broker) {
+            return "Approval response could not be recorded because approval handling is unavailable.";
+        }
+        const origin = createApprovalOriginFromIngress(ingress);
+        if (!origin) {
+            return "Approval response could not be recorded because the conversation origin is incomplete.";
+        }
+        const resolved = await broker.resolveConversationalApproval(response.approval_id, response.approved, origin);
+        return resolved
+            ? "Approval response recorded."
+            : "Approval response did not match an active approval for this conversation.";
+    }
+    async tryResolveConversationalApprovalReply(ingress) {
+        const broker = this.deps.approvalBroker;
+        if (!broker) {
+            return null;
+        }
+        const origin = createApprovalOriginFromIngress(ingress);
+        if (!origin) {
+            return null;
+        }
+        const lookup = await broker.findPendingConversationalApproval(origin);
+        if (lookup.status === "none") {
+            return null;
+        }
+        if (lookup.status === "ambiguous") {
+            return "Multiple active approvals match this conversation. Please use the specific approval response.";
+        }
+        const approval = lookup.approval;
+        const decision = await classifyConversationalApprovalDecision(ingress.text, {
+            approval,
+            replyOrigin: origin,
+            llmClient: this.deps.llmClient,
+            priorTurnState: this.describeLastRouteForApproval(ingress),
+        });
+        if (decision.decision === "approve" || decision.decision === "reject") {
+            const resolved = await broker.resolveConversationalApproval(approval.approval_id, decision.decision === "approve", approval.origin ?? origin);
+            return resolved
+                ? "Approval response recorded."
+                : "Approval response did not match an active approval for this conversation.";
+        }
+        if (decision.decision === "clarify") {
+            return decision.clarification ?? "Approval is still pending. Please clarify what you need before approving or rejecting.";
+        }
+        if (decision.decision === "side_question" || decision.decision === "new_intent") {
+            if (ingress.ingress_id) {
+                this.approvalSideTurnIngressIds.add(ingress.ingress_id);
+            }
+            return null;
+        }
+        return decision.clarification ?? "Approval reply was ambiguous. The approval remains pending.";
+    }
+    describeLastRouteForApproval(ingress) {
+        const session = this.sessions.get(buildSessionKeyFromParts(ingress));
+        const route = session?.lastRoute;
+        return route ? JSON.stringify(route) : "none";
+    }
     handleIncomingMessage(input) {
         return this.processIncomingMessage(input);
     }
@@ -237,6 +373,16 @@ export class CrossPlatformChatSessionManager {
         const identityKey = normalizeIdentity(input.identity_key) ?? undefined;
         const conversationId = normalizeIdentity(input.conversation_id) ?? undefined;
         const messageId = normalizeIdentity(input.message_id) ?? undefined;
+        const companion = this.buildCompanionContractForIngress({
+            identity_key: identityKey,
+            platform,
+            conversation_id: conversationId,
+            user_id: userId,
+            message_id: messageId,
+            goal_id: goalId,
+            replyTarget: input.replyTarget,
+            companion: input.companion,
+        });
         return {
             ingress_id: randomUUID(),
             received_at: new Date().toISOString(),
@@ -256,6 +402,7 @@ export class CrossPlatformChatSessionManager {
                 actor: input.actor,
             }),
             runtimeControl: resolveRuntimeControl(channel, input.runtimeControl, metadata),
+            companion,
             metadata,
             replyTarget: normalizeReplyTarget(channel, {
                 platform,
@@ -268,6 +415,43 @@ export class CrossPlatformChatSessionManager {
             }),
         };
     }
+    ensureCompanionContract(ingress) {
+        if (ingress.companion) {
+            return ingress;
+        }
+        return {
+            ...ingress,
+            companion: this.buildCompanionContractForIngress({
+                identity_key: ingress.identity_key,
+                platform: ingress.platform,
+                conversation_id: ingress.conversation_id,
+                user_id: ingress.user_id,
+                message_id: ingress.message_id,
+                goal_id: ingress.goal_id,
+                replyTarget: ingress.replyTarget,
+            }),
+        };
+    }
+    buildCompanionContractForIngress(input) {
+        const sessionKey = buildSessionKeyFromParts({
+            identity_key: input.identity_key,
+            platform: input.platform,
+            conversation_id: input.conversation_id,
+            user_id: input.user_id,
+        });
+        const replyTargetId = normalizeIdentity(input.replyTarget?.conversation_id ?? input.conversation_id ?? input.replyTarget?.identity_key ?? input.identity_key) ?? undefined;
+        return buildCompanionRuntimeContract({
+            sessionKey,
+            conversationId: input.conversation_id,
+            messageId: input.message_id,
+            goalId: input.goal_id,
+            replyTargetId,
+            presence: input.companion?.presence,
+            turnPolicy: input.companion?.turnPolicy,
+            inputModality: input.companion?.inputModality ?? "text",
+            outputMode: input.companion?.outputMode,
+        });
+    }
     /**
      * Returns the active session info if a matching session is already loaded.
      */
@@ -294,8 +478,6 @@ export class CrossPlatformChatSessionManager {
             return existing;
         }
         const cwd = resolveGitRoot(cwdOverride?.trim() || process.cwd());
-        const runner = new ChatRunner(this.deps);
-        runner.startSession(cwd);
         const now = new Date().toISOString();
         const info = {
             session_key: sessionKey,
@@ -308,6 +490,13 @@ export class CrossPlatformChatSessionManager {
             last_used_at: now,
             metadata: {},
         };
+        const approvalFn = this.createApprovalFn(info);
+        const runner = new ChatRunner({
+            ...this.deps,
+            approvalFn: approvalFn ?? this.deps.approvalFn,
+            runtimeControlApprovalFn: approvalFn ?? this.deps.runtimeControlApprovalFn,
+        });
+        runner.startSession(cwd);
         const created = {
             runner,
             info,
@@ -317,6 +506,55 @@ export class CrossPlatformChatSessionManager {
         this.sessions.set(sessionKey, created);
         return created;
     }
+    createApprovalFn(info) {
+        const broker = this.deps.approvalBroker;
+        if (!broker) {
+            return null;
+        }
+        return async (description) => {
+            const origin = createApprovalOriginFromSessionInfo(info);
+            if (!origin) {
+                return false;
+            }
+            const goalId = typeof info.metadata.goal_id === "string" && info.metadata.goal_id.trim()
+                ? info.metadata.goal_id.trim()
+                : "chat";
+            return broker.requestConversationalApproval(goalId, {
+                id: info.last_message_id ?? info.session_key,
+                description,
+                action: "chat_approval",
+            }, {
+                origin,
+                deliverConversationalApproval: async ({ prompt }) => {
+                    const handler = this.activeApprovalEventHandlers.get(info.session_key);
+                    if (!handler) {
+                        return {
+                            delivered: false,
+                            reason: "originating_conversation_unreachable",
+                        };
+                    }
+                    try {
+                        await handler({
+                            type: "activity",
+                            kind: "checkpoint",
+                            message: prompt,
+                            sourceId: `approval:${info.last_message_id ?? info.session_key}`,
+                            runId: info.session_key,
+                            turnId: info.last_message_id ?? info.session_key,
+                            createdAt: new Date().toISOString(),
+                        });
+                        return { delivered: true };
+                    }
+                    catch (err) {
+                        return {
+                            delivered: false,
+                            reason: err instanceof Error ? err.message : "originating_conversation_unreachable",
+                        };
+                    }
+                },
+            });
+        };
+    }
     async executeInSession(session, ingress, options = {}) {
         session.info.last_used_at = new Date().toISOString();
         session.info.conversation_name = options.conversation_name?.trim() || session.info.conversation_name;
@@ -327,6 +565,9 @@ export class CrossPlatformChatSessionManager {
             ...ingress.replyTarget,
             metadata: cloneMetadata(ingress.replyTarget.metadata),
         };
+        if (ingress.companion) {
+            session.info.active_companion_contract = ingress.companion;
+        }
         session.info.metadata = cloneMetadata(buildSessionMetadata({
             metadata: ingress.metadata,
             channel: ingress.channel,
@@ -341,39 +582,157 @@ export class CrossPlatformChatSessionManager {
             hasToolLoop: this.deps.llmClient !== undefined,
             hasRuntimeControlService: this.deps.runtimeControlService !== undefined,
         };
-        const runtimeControlAllowed = ingress.runtimeControl.allowed
-            && ingress.runtimeControl.approvalMode !== "disallowed"
-            && (capabilities.hasRuntimeControlService
-                || (!capabilities.hasAgentLoop && !capabilities.hasToolLoop));
+        const setupSecretIntake = intakeSetupSecrets(ingress.text);
+        const safeIngressText = setupSecretIntake.redactedText;
+        const hasSetupSecret = setupSecretIntake.suppliedSecrets.length > 0;
+        const shouldPreferFreeformBeforeDeniedRuntimeControl = !hasSetupSecret
+            && !capabilities.hasAgentLoop
+            && ingress.metadata["runtime_control_denied"] === true
+            && ingress.metadata["runtime_control_approved"] !== true
+            && ingress.metadata["runtime_control_explicit"] !== true;
+        const shouldClassifyRuntimeControlForSafety = !hasSetupSecret
+            && capabilities.hasAgentLoop
+            && (ingress.metadata["runtime_control_approved"] === true
+                || ingress.metadata["runtime_control_denied"] === true
+                || ingress.metadata["runtime_control_explicit"] === true);
+        const shouldClassifyRuntimeControl = shouldClassifyRuntimeControlForSafety
+            || (!hasSetupSecret && !capabilities.hasAgentLoop && ((capabilities.hasRuntimeControlService && ingress.runtimeControl.approvalMode !== "disallowed")
+                || ingress.metadata["runtime_control_approved"] === true
+                || ingress.metadata["runtime_control_denied"] === true
+                || ingress.metadata["runtime_control_explicit"] === true));
+        let freeformRouteIntent = shouldPreferFreeformBeforeDeniedRuntimeControl
+            ? await classifyFreeformRouteIntent(safeIngressText, this.deps.llmClient)
+            : null;
+        const runtimeControlClassification = freeformRouteIntent == null && shouldClassifyRuntimeControl
+            ? await classifyRuntimeControlIntent(safeIngressText, this.deps.llmClient)
+            : null;
+        const runtimeControlIntent = runtimeControlClassification?.status === "intent"
+            ? runtimeControlClassification.intent
+            : null;
+        if (!hasSetupSecret && !capabilities.hasAgentLoop && freeformRouteIntent == null && runtimeControlIntent === null) {
+            freeformRouteIntent = await classifyFreeformRouteIntent(safeIngressText, this.deps.llmClient);
+        }
+        const shouldDeriveRunSpecDraft = !capabilities.hasAgentLoop
+            && !hasSetupSecret
+            && runtimeControlIntent === null
+            && freeformRouteIntent != null
+            && (freeformRouteIntent.kind === "run_spec"
+                || freeformRouteIntent.kind === "configure"
+                || freeformRouteIntent.kind === "clarify")
+            && freeformRouteIntent.confidence >= 0.7;
+        const runSpecDraft = shouldDeriveRunSpecDraft
+            ? await deriveRunSpecFromText(safeIngressText, {
+                cwd: ingress.cwd ?? session.info.cwd,
+                conversationId: ingress.conversation_id ?? null,
+                channel: ingress.channel,
+                sessionId: session.runner.getSessionId() ?? ingress.conversation_id ?? null,
+                replyTarget: ingress.replyTarget,
+                originMetadata: {
+                    ingress_id: ingress.ingress_id ?? null,
+                    platform: ingress.platform ?? null,
+                    message_id: ingress.message_id ?? null,
+                    deliveryMode: ingress.deliveryMode ?? null,
+                    metadata: ingress.metadata,
+                },
+                llmClient: this.deps.llmClient,
+            })
+            : null;
         const selectedRoute = this.ingressRouter.selectRoute(ingress, {
             ...capabilities,
-            runtimeControlIntent: runtimeControlAllowed
-                ? await recognizeRuntimeControlIntent(ingress.text, this.deps.llmClient)
-                : null,
+            runtimeControlIntent,
+            runtimeControlUnclassified: shouldClassifyRuntimeControlForSafety
+                && runtimeControlClassification?.status === "unclassified"
+                && ingress.metadata["runtime_control_explicit"] === true,
+            freeformRouteIntent,
+            setupSecretIntake,
+            runSpecDraft,
         });
         session.lastRoute = selectedRoute;
         const previousOnEvent = session.runner.onEvent;
+        let deliveryQueue = null;
         if (options.onEvent) {
-            const handler = options.onEvent;
-            const upstream = this.deps.onEvent;
-            session.runner.onEvent = (event) => {
-                safeInvoke(handler, event);
-                if (upstream && upstream !== handler) {
-                    safeInvoke(upstream, event);
-                }
-            };
+            deliveryQueue = new ChatEventDeliveryQueue(options.onEvent, this.deps.onEvent);
+            this.activeApprovalEventHandlers.set(session.info.session_key, options.onEvent);
+            session.runner.onEvent = deliveryQueue.dispatch;
         }
         else {
+            this.activeApprovalEventHandlers.delete(session.info.session_key);
             session.runner.onEvent = undefined;
         }
         try {
             return await session.runner.executeIngressMessage(ingress, session.info.cwd, options.timeoutMs, selectedRoute);
         }
         finally {
+            await deliveryQueue?.drain();
+            this.activeApprovalEventHandlers.delete(session.info.session_key);
             session.runner.onEvent = previousOnEvent;
         }
     }
 }
+function formatCompanionPolicyDecision(decision) {
+    if (decision.reason === "interruption_requires_explicit_request") {
+        return "The current companion turn is non-interruptible. Send an explicit interruption request before redirecting it.";
+    }
+    if (decision.reason === "suppressed_by_quieting") {
+        return "Companion output was suppressed by the current quieting policy.";
+    }
+    if (decision.reason === "deferred_by_quieting") {
+        return "Companion output was deferred by the current quieting policy.";
+    }
+    return "Companion output is allowed.";
+}
+export function createApprovalOriginFromSessionInfo(info) {
+    const replyTarget = info.active_reply_target;
+    const channel = normalizeIdentity(replyTarget?.platform
+        ?? replyTarget?.channel
+        ?? replyTarget?.surface
+        ?? info.platform);
+    const conversationId = normalizeIdentity(replyTarget?.conversation_id
+        ?? info.conversation_id
+        ?? info.identity_key
+        ?? info.session_key);
+    if (!channel || !conversationId) {
+        return null;
+    }
+    const userId = normalizeIdentity(replyTarget?.user_id ?? info.user_id) ?? undefined;
+    const turnId = normalizeIdentity(replyTarget?.message_id ?? info.last_message_id) ?? undefined;
+    return {
+        channel,
+        conversation_id: conversationId,
+        ...(userId ? { user_id: userId } : {}),
+        session_id: info.session_key,
+        ...(turnId ? { turn_id: turnId } : {}),
+        reply_target: {
+            ...replyTarget,
+            metadata: replyTarget?.metadata ? { ...replyTarget.metadata } : undefined,
+        },
+    };
+}
+function createApprovalOriginFromIngress(ingress) {
+    const channel = normalizeIdentity(ingress.replyTarget.platform
+        ?? ingress.replyTarget.channel
+        ?? ingress.replyTarget.surface
+        ?? ingress.platform);
+    const conversationId = normalizeIdentity(ingress.replyTarget.conversation_id
+        ?? ingress.conversation_id
+        ?? ingress.identity_key);
+    const userId = normalizeIdentity(ingress.replyTarget.user_id ?? ingress.user_id) ?? undefined;
+    const turnId = normalizeIdentity(ingress.replyTarget.message_id ?? ingress.message_id) ?? undefined;
+    if (!channel || !conversationId || !userId || !turnId) {
+        return null;
+    }
+    return {
+        channel,
+        conversation_id: conversationId,
+        user_id: userId,
+        session_id: buildSessionKeyFromParts(ingress),
+        turn_id: turnId,
+        reply_target: {
+            ...ingress.replyTarget,
+            metadata: cloneMetadata(ingress.replyTarget.metadata),
+        },
+    };
+}
 let globalManagerPromise = null;
 export function getGlobalCrossPlatformChatSessionManager() {
     if (globalManagerPromise === null) {
@@ -414,10 +773,20 @@ async function createGlobalCrossPlatformChatSessionManager() {
     });
     await pluginLoader.loadAll().catch(() => []);
     await scheduleEngine.syncExternalSources(pluginLoader.getScheduleSources()).catch(() => undefined);
+    const runtimeRoot = path.join(stateManager.getBaseDir(), "runtime");
+    const runtimeControlService = new RuntimeControlService({
+        runtimeRoot,
+        stateManager,
+        executor: createDaemonRuntimeControlExecutor({
+            baseDir: stateManager.getBaseDir(),
+        }),
+    });
     for (const tool of createBuiltinTools({
         stateManager,
         trustManager,
         registry: toolRegistry,
+        llmClient,
+        runtimeControlService,
         adapterRegistry,
         knowledgeManager,
         observationEngine,
@@ -450,6 +819,9 @@ async function createGlobalCrossPlatformChatSessionManager() {
             traceBaseDir: stateManager.getBaseDir(),
         })
         : undefined;
+    const approvalBroker = new ApprovalBroker({
+        store: new ApprovalStore(createRuntimeStorePaths(runtimeRoot)),
+    });
     return new CrossPlatformChatSessionManager({
         stateManager,
         adapter,
@@ -458,13 +830,8 @@ async function createGlobalCrossPlatformChatSessionManager() {
         toolExecutor,
         chatAgentLoopRunner,
         reviewAgentLoopRunner,
-        runtimeControlService: new RuntimeControlService({
-            runtimeRoot: path.join(stateManager.getBaseDir(), "runtime"),
-            stateManager,
-            executor: createDaemonRuntimeControlExecutor({
-                baseDir: stateManager.getBaseDir(),
-            }),
-        }),
+        approvalBroker,
+        runtimeControlService,
     });
 }
 registerGlobalCrossPlatformChatSessionManager(getGlobalCrossPlatformChatSessionManager);