pulseed 0.6.4 → 0.6.6

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

@@ -4,11 +4,8 @@ import { ChatRunner } from "./chat-runner.js";
 import { ChatSessionCatalog } from "./chat-session-store.js";
 import { createIngressRouter, } from "./ingress-router.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 { buildAdapterRegistry, buildGatewayLLMClient } from "../../base/llm/provider-factory.js";
 import { loadProviderConfig } from "../../base/llm/provider-config.js";
 import { TrustManager } from "../../platform/traits/trust-manager.js";
 import { ObservationEngine } from "../../platform/observation/observation-engine.js";
@@ -23,127 +20,233 @@ 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 { createCapabilityExecutionResolver } from "../../runtime/capability-execution-resolver.js";
 import { ApprovalBroker } from "../../runtime/approval-broker.js";
-import { ApprovalStore, createRuntimeStorePaths } from "../../runtime/store/index.js";
+import { ApprovalStore, CapabilityVerificationStore, PermissionGrantCapabilitySchema, PermissionGrantExcludedCapabilitySchema, PermissionGrantStore, PermissionWaitPlanStore, createRuntimeStorePaths, } from "../../runtime/store/index.js";
 import { classifyConversationalApprovalDecision } from "../../runtime/conversational-approval-decision.js";
+import { classifyConversationalPermissionGrantDecision, } from "../../runtime/permission-grant-decision.js";
 import { registerGlobalCrossPlatformChatSessionManager } from "./cross-platform-session-global.js";
-import { createPendingPermissionTask, isPermissionApprovalStale, } from "../../runtime/permission-dialogue.js";
+import { createPendingPermissionTask, getPendingPermissionTask, getPendingPermissionGrantProposal, isPermissionApprovalStale, PendingPermissionGrantProposalSchema, } from "../../runtime/permission-dialogue.js";
 import { buildCompanionRuntimeContract, evaluateCompanionOutputPolicy, } from "../../runtime/companion-policy.js";
+import { EXTERNAL_SURFACE_METADATA_KEY } from "../../runtime/gateway/channel-policy.js";
 import { normalizeUserInput } from "./user-input.js";
-function normalizeIdentity(value) {
-    const trimmed = value?.trim();
-    return trimmed ? trimmed : null;
+import { createSeedyActiveTurnStatus, formatSeedyActiveTurnStatus, } from "./seedy-turn-presence.js";
+import { buildSessionKeyFromParts, buildSessionMetadata, cloneMetadata, cloneReplyTarget, isRecord, normalizeActor, normalizeIdentity, normalizePlatform, normalizeReplyTarget, resolveChannel, resolveRuntimeControl, stringField, } from "./cross-platform-session-normalization.js";
+import { CrossPlatformChatSessionInfoStore } from "./chat-session-data-store.js";
+import { resolveChatStateBaseDir } from "./chat-state-base-dir.js";
+const STANDING_PERMISSION_REVIEW_INTERVAL_MS = 30 * 24 * 60 * 60 * 1000;
+const STANDING_PERMISSION_DEFAULT_EXCLUSIONS = [
+    "destructive_action",
+    "delete",
+    "write_remote",
+    "network_send",
+    "secret_change",
+    "protected_path_mutation",
+    "production_mutation",
+    "billing_or_purchase",
+    "unknown_capability",
+];
+function createPermissionGrantProposalFromApprovalRequest(request) {
+    const decision = isRecord(request.permissionGrantDecision) ? request.permissionGrantDecision : null;
+    if (!decision)
+        return undefined;
+    const capabilities = parsePermissionGrantCapabilities(decision["requiredCapabilities"]);
+    if (capabilities.length === 0)
+        return undefined;
+    const excludedCapabilities = parsePermissionGrantExcludedCapabilities(decision["excludedCapabilities"]);
+    return PendingPermissionGrantProposalSchema.parse({
+        schema_version: "permission-grant-proposal-v1",
+        capabilities,
+        current_request_capabilities: capabilities,
+        excluded_capabilities: excludedCapabilities,
+        default_scope: "run",
+        allowed_scopes: ["once", "run", "goal"],
+        summary: request.reason,
+    });
 }
-function normalizePlatform(value) {
-    const trimmed = value?.trim();
-    return trimmed ? trimmed.toLowerCase() : null;
+function parsePermissionGrantCapabilities(value) {
+    if (!Array.isArray(value))
+        return [];
+    const capabilities = [];
+    const seen = new Set();
+    for (const item of value) {
+        const parsed = PermissionGrantCapabilitySchema.safeParse(item);
+        if (!parsed.success || seen.has(parsed.data))
+            continue;
+        seen.add(parsed.data);
+        capabilities.push(parsed.data);
+    }
+    return capabilities;
 }
-function buildSessionKeyFromParts(params) {
-    const identityKey = normalizeIdentity(params.identity_key);
-    if (identityKey) {
-        return `identity:${identityKey}`;
+function parsePermissionGrantExcludedCapabilities(value) {
+    if (!Array.isArray(value))
+        return [];
+    const capabilities = [];
+    const seen = new Set();
+    for (const item of value) {
+        const parsed = PermissionGrantExcludedCapabilitySchema.safeParse(item);
+        if (!parsed.success || seen.has(parsed.data))
+            continue;
+        seen.add(parsed.data);
+        capabilities.push(parsed.data);
     }
-    const platform = normalizePlatform(params.platform);
-    const conversationId = normalizeIdentity(params.conversation_id);
-    if (platform && conversationId) {
-        return `platform:${platform}:conversation:${conversationId}`;
+    return capabilities;
+}
+function resolveGrantScopeFromReply(approval, proposal, decision, context = {}) {
+    const requestedScope = requestedGrantScope(proposal, decision);
+    if (decision.standing_confirmation) {
+        const now = Date.now();
+        const review = {
+            kind: "periodic",
+            interval_ms: STANDING_PERMISSION_REVIEW_INTERVAL_MS,
+            due_at: now + STANDING_PERMISSION_REVIEW_INTERVAL_MS,
+            last_reviewed_at: now,
+        };
+        switch (decision.standing_confirmation.scope) {
+            case "workspace": {
+                if (!context.cwd) {
+                    return { status: "unavailable", message: "Standing workspace permission requires a current workspace path. The proposal remains pending." };
+                }
+                return {
+                    status: "ok",
+                    scope: { kind: "workspace", workspace_root: path.resolve(context.cwd) },
+                    duration: { kind: "standing" },
+                    review,
+                };
+            }
+            case "project": {
+                if (!context.projectId) {
+                    return { status: "unavailable", message: "Standing project permission requires a current project id. The proposal remains pending." };
+                }
+                return {
+                    status: "ok",
+                    scope: { kind: "project", project_id: context.projectId },
+                    duration: { kind: "standing" },
+                    review,
+                };
+            }
+            case "global":
+                return {
+                    status: "ok",
+                    scope: { kind: "global" },
+                    duration: { kind: "standing" },
+                    review,
+                };
+        }
     }
-    const userId = normalizeIdentity(params.user_id);
-    if (platform && userId) {
-        return `platform:${platform}:user:${userId}`;
+    if (requestedScope === "global" || decision.requested_scope === "standing") {
+        return {
+            status: "needs_confirmation",
+            message: [
+                "Standing or global permission requires a second explicit confirmation naming the broader scope.",
+                `Allowed capabilities: ${proposal.capabilities.join(", ")}.`,
+                `Excluded capabilities: ${proposal.excluded_capabilities.length > 0 ? proposal.excluded_capabilities.join(", ") : "none"}.`,
+                "It can be revoked later with the permission revoke control.",
+                "The proposal remains pending.",
+            ].join(" "),
+        };
+    }
+    if (!proposal.allowed_scopes.includes(requestedScope)) {
+        return {
+            status: "needs_confirmation",
+            message: `The requested ${requestedScope} permission scope is broader than this proposal. The proposal remains pending.`,
+        };
+    }
+    const task = getPendingPermissionTask(approval);
+    switch (requestedScope) {
+        case "once": {
+            const turnId = approval.origin?.turn_id;
+            if (!turnId) {
+                return { status: "unavailable", message: "Permission grant could not be scoped to the current turn. The proposal remains pending." };
+            }
+            return {
+                status: "ok",
+                scope: { kind: "turn", turn_id: turnId },
+                duration: { kind: "once" },
+            };
+        }
+        case "run": {
+            const runId = task?.target.run_id ?? approval.origin?.session_id;
+            if (!runId) {
+                return { status: "unavailable", message: "Permission grant could not be scoped to the current run. The proposal remains pending." };
+            }
+            return {
+                status: "ok",
+                scope: { kind: "run", run_id: runId },
+                duration: { kind: "until_run_done" },
+            };
+        }
+        case "goal": {
+            const goalId = approval.goal_id;
+            if (!goalId) {
+                return { status: "unavailable", message: "Permission grant could not be scoped to the current goal. The proposal remains pending." };
+            }
+            return {
+                status: "ok",
+                scope: { kind: "goal", goal_id: goalId },
+                duration: { kind: "until_goal_done" },
+            };
+        }
+        case "session":
+        case "workspace":
+        case "project":
+            return {
+                status: "needs_confirmation",
+                message: `The requested ${requestedScope} permission scope requires a more specific proposal. The proposal remains pending.`,
+            };
     }
-    return `ephemeral:${randomUUID()}`;
-}
-function buildSessionKey(options) {
-    return buildSessionKeyFromParts(options);
-}
-function cloneMetadata(metadata) {
-    return metadata ? { ...metadata } : {};
-}
-function cloneReplyTarget(target) {
-    return {
-        ...target,
-        metadata: isRecord(target.metadata) ? cloneMetadata(target.metadata) : {},
-    };
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function buildSessionMetadata(options) {
-    return {
-        ...(options.metadata ?? {}),
-        ...(options.channel ? { channel: options.channel } : {}),
-        ...(options.platform ? { platform: options.platform } : {}),
-        ...(options.conversation_id ? { conversation_id: options.conversation_id } : {}),
-        ...(options.conversation_name ? { conversation_name: options.conversation_name } : {}),
-        ...(options.user_id ? { user_id: options.user_id } : {}),
-        ...(options.user_name ? { user_name: options.user_name } : {}),
-    };
 }
-function resolveChannel(input) {
-    if (input.channel)
-        return input.channel;
-    return input.platform ? "plugin_gateway" : "cli";
+function requestedGrantScope(proposal, decision) {
+    if (decision.decision === "approve_current_run")
+        return "run";
+    if (decision.decision === "approve_current_goal")
+        return "goal";
+    if (decision.decision === "extend_scope") {
+        switch (decision.requested_scope) {
+            case "current_run":
+                return "run";
+            case "current_goal":
+                return "goal";
+            case "standing":
+                return "global";
+            case "once":
+            case "session":
+            case "workspace":
+            case "project":
+            case "global":
+                return decision.requested_scope;
+            default:
+                return proposal.default_scope;
+        }
+    }
+    return proposal.default_scope;
 }
-function resolveActorSurface(channel) {
-    switch (channel) {
-        case "plugin_gateway":
-            return "gateway";
-        case "cli":
-            return "cli";
-        case "tui":
-            return "tui";
-        default:
-            return "chat";
+function resolveGrantCapabilitiesFromReply(proposal, decision) {
+    if (decision.decision !== "narrow_scope" || !decision.capabilities) {
+        return proposal.capabilities;
     }
+    const allowed = new Set(proposal.capabilities);
+    return decision.capabilities.filter((capability) => allowed.has(capability));
 }
-function resolveRuntimeControl(channel, runtimeControl, metadata) {
-    const approvalMode = runtimeControl?.approvalMode
-        ?? (metadata?.["runtime_control_approved"] === true
-            ? "preapproved"
-            : metadata?.["runtime_control_denied"] === true
-                ? "disallowed"
-                : channel === "tui" || channel === "cli"
-                    ? "interactive"
-                    : "disallowed");
-    return {
-        allowed: runtimeControl?.allowed ?? approvalMode !== "disallowed",
-        approvalMode,
-    };
+function resolveGrantExcludedCapabilities(proposal, duration) {
+    if (duration.kind !== "standing") {
+        return proposal.excluded_capabilities;
+    }
+    return [...new Set([...proposal.excluded_capabilities, ...STANDING_PERMISSION_DEFAULT_EXCLUSIONS])];
 }
-function normalizeReplyTarget(channel, input) {
-    const platform = normalizePlatform(input.replyTarget?.platform ?? input.platform) ?? undefined;
-    const conversationId = normalizeIdentity(input.replyTarget?.conversation_id ?? input.conversation_id) ?? undefined;
-    const identityKey = normalizeIdentity(input.replyTarget?.identity_key ?? input.identity_key) ?? undefined;
-    const userId = normalizeIdentity(input.replyTarget?.user_id ?? input.user_id) ?? undefined;
-    const messageId = normalizeIdentity(input.replyTarget?.message_id ?? input.message_id) ?? undefined;
+function createPermissionGrantOrigin(origin) {
+    const replyTarget = isRecord(origin.reply_target) ? origin.reply_target : undefined;
+    const platform = normalizeIdentity(stringField(replyTarget, "platform")) ?? undefined;
+    const messageId = normalizeIdentity(stringField(replyTarget, "message_id")) ?? origin.turn_id;
     return {
-        surface: input.replyTarget?.surface ?? resolveActorSurface(channel),
+        channel: origin.channel,
         ...(platform ? { platform } : {}),
-        ...(conversationId ? { conversation_id: conversationId } : {}),
-        ...(identityKey ? { identity_key: identityKey } : {}),
-        ...(userId ? { user_id: userId } : {}),
+        conversation_id: origin.conversation_id,
+        ...(origin.user_id ? { user_id: origin.user_id } : {}),
+        ...(origin.session_id ? { session_id: origin.session_id } : {}),
+        ...(origin.turn_id ? { turn_id: origin.turn_id } : {}),
         ...(messageId ? { message_id: messageId } : {}),
-        deliveryMode: input.replyTarget?.deliveryMode ?? "reply",
-        metadata: {
-            ...(input.metadata ?? {}),
-            ...(input.replyTarget?.metadata ?? {}),
-        },
-        ...input.replyTarget,
-    };
-}
-function normalizeActor(channel, input) {
-    const platform = normalizePlatform(input.actor?.platform ?? input.platform) ?? undefined;
-    const conversationId = normalizeIdentity(input.actor?.conversation_id ?? input.conversation_id) ?? undefined;
-    const identityKey = normalizeIdentity(input.actor?.identity_key ?? input.identity_key) ?? undefined;
-    const userId = normalizeIdentity(input.actor?.user_id ?? input.user_id) ?? undefined;
-    return {
-        surface: input.actor?.surface ?? resolveActorSurface(channel),
-        ...(platform ? { platform } : {}),
-        ...(conversationId ? { conversation_id: conversationId } : {}),
-        ...(identityKey ? { identity_key: identityKey } : {}),
-        ...(userId ? { user_id: userId } : {}),
-        ...input.actor,
+        ...(replyTarget ? { reply_target: { ...replyTarget } } : {}),
     };
 }
 async function safeInvoke(handler, event) {
@@ -211,12 +314,15 @@ export class CrossPlatformChatSessionManager {
             actor: options.actor,
             replyTarget: options.replyTarget,
             runtimeControl: options.runtimeControl,
+            externalSurface: options.externalSurface,
             companion: options.companion,
             cwd: options.cwd,
             timeoutMs: options.timeoutMs,
             metadata: {
                 ...(options.metadata ?? {}),
-                ...(options.runtimeControl ? { runtime_control_explicit: true } : {}),
+                ...(options.runtimeControl?.explicit === true
+                    ? { runtime_control_explicit: true }
+                    : {}),
             },
             onEvent: options.onEvent,
             userInput: options.userInput,
@@ -336,6 +442,20 @@ export class CrossPlatformChatSessionManager {
         if (staleReply) {
             return staleReply;
         }
+        const grantProposal = getPendingPermissionGrantProposal(approval);
+        if (grantProposal) {
+            const grantDecision = await classifyConversationalPermissionGrantDecision(ingress.text, {
+                approval,
+                proposal: grantProposal,
+                replyOrigin: origin,
+                llmClient: this.deps.llmClient,
+                priorTurnState: this.describeLastRouteForApproval(ingress),
+            });
+            const grantReply = await this.resolveConversationalPermissionGrantReply(ingress, approval, origin, grantProposal, grantDecision);
+            if (grantReply !== null) {
+                return grantReply;
+            }
+        }
         const decision = await classifyConversationalApprovalDecision(ingress.text, {
             approval,
             replyOrigin: origin,
@@ -359,6 +479,98 @@ export class CrossPlatformChatSessionManager {
         }
         return decision.clarification ?? "Approval reply was ambiguous. The approval remains pending.";
     }
+    async resolveConversationalPermissionGrantReply(ingress, approval, origin, proposal, decision) {
+        const broker = this.deps.approvalBroker;
+        if (!broker) {
+            return "Approval response could not be recorded because approval handling is unavailable.";
+        }
+        switch (decision.decision) {
+            case "side_question":
+            case "new_intent":
+                if (ingress.ingress_id) {
+                    this.approvalSideTurnIngressIds.add(ingress.ingress_id);
+                }
+                return null;
+            case "clarify":
+                return decision.clarification ?? "Permission proposal is still pending. Please clarify before approving or rejecting.";
+            case "unknown":
+                return decision.clarification ?? "Permission reply was ambiguous. The permission proposal remains pending.";
+            case "reject":
+            case "revoke": {
+                const resolved = await broker.resolveConversationalApproval(approval.approval_id, false, approval.origin ?? origin);
+                return resolved
+                    ? "Approval response recorded."
+                    : "Approval response did not match an active approval for this conversation.";
+            }
+            case "approve_once": {
+                const resolved = await broker.resolveConversationalApproval(approval.approval_id, true, approval.origin ?? origin);
+                return resolved
+                    ? "Approval response recorded."
+                    : "Approval response did not match an active approval for this conversation.";
+            }
+            case "approve_current_run":
+            case "approve_current_goal":
+            case "narrow_scope":
+            case "extend_scope":
+                return this.createPermissionGrantFromReply({
+                    ingress,
+                    approval,
+                    origin,
+                    proposal,
+                    decision,
+                });
+        }
+    }
+    async createPermissionGrantFromReply(input) {
+        const store = this.deps.permissionGrantStore;
+        if (!store) {
+            return "Permission grant could not be recorded because the grant store is unavailable. The approval remains pending.";
+        }
+        const scope = resolveGrantScopeFromReply(input.approval, input.proposal, input.decision, {
+            cwd: input.ingress.cwd,
+            ...(this.deps.permissionGrantContext?.projectId ? { projectId: this.deps.permissionGrantContext.projectId } : {}),
+        });
+        if (scope.status !== "ok") {
+            return scope.message;
+        }
+        const capabilities = resolveGrantCapabilitiesFromReply(input.proposal, input.decision);
+        if (capabilities.length === 0) {
+            return "Permission proposal is still pending. Please name at least one capability to allow.";
+        }
+        const createInput = {
+            grant_id: `permission-grant:${input.approval.approval_id}:${randomUUID()}`,
+            subject: {
+                kind: "operator",
+                id: input.origin.user_id ?? input.origin.session_id ?? input.origin.conversation_id,
+            },
+            origin: createPermissionGrantOrigin(input.origin),
+            source: {
+                kind: "redacted_text",
+                redacted_text: "User replied to a conversational PermissionGrant proposal.",
+                redaction_reason: "chat_permission_reply",
+            },
+            scope: scope.scope,
+            duration: scope.duration,
+            ...(scope.review ? { review: scope.review } : {}),
+            capabilities,
+            excluded_capabilities: resolveGrantExcludedCapabilities(input.proposal, scope.duration),
+            audit_refs: [`approval:${input.approval.approval_id}`],
+        };
+        await store.createActive(createInput);
+        const currentRequestCapabilities = input.proposal.current_request_capabilities ?? input.proposal.capabilities;
+        const currentRequestCovered = input.proposal.excluded_capabilities.length === 0
+            && currentRequestCapabilities.every((capability) => capabilities.includes(capability));
+        const resolved = await this.deps.approvalBroker?.resolveConversationalApproval(input.approval.approval_id, currentRequestCovered, input.approval.origin ?? input.origin);
+        if (!resolved) {
+            return "Permission grant was recorded, but the approval response did not match an active approval for this conversation.";
+        }
+        if (!currentRequestCovered) {
+            return "Permission grant recorded with a narrower boundary; the current approval was not executed.";
+        }
+        return createInput.duration.kind === "standing"
+            ? "Standing permission grant recorded. Approval response recorded. You can revoke it later with the permission revoke control."
+            : "Permission grant recorded. Approval response recorded.";
+    }
     async rejectStalePermissionApprovalIfNeeded(approval, ingress, origin) {
         if (!isPermissionApprovalStale(approval, await this.currentApprovalStateEpoch(ingress))) {
             return null;
@@ -399,12 +611,20 @@ export class CrossPlatformChatSessionManager {
                 ? input.metadata["routed_goal_id"].trim()
                 : "";
         const goalId = normalizeIdentity(input.goal_id ?? metadataGoalId) ?? undefined;
+        const externalSurface = input.externalSurface;
         const metadata = {
             ...(input.metadata ?? {}),
+            ...(externalSurface ? { [EXTERNAL_SURFACE_METADATA_KEY]: externalSurface } : {}),
             ...(goalId ? { goal_id: goalId } : {}),
             ...("sender_id" in input && input.sender_id ? { sender_id: input.sender_id } : {}),
             ...(input.message_id ? { message_id: input.message_id } : {}),
+            ...(input.runtimeControl?.explicit === true
+                ? { runtime_control_explicit: true }
+                : {}),
         };
+        if (!externalSurface) {
+            delete metadata[EXTERNAL_SURFACE_METADATA_KEY];
+        }
         const userId = normalizeIdentity(input.user_id ?? ("sender_id" in input ? input.sender_id : undefined)) ?? undefined;
         const platform = normalizePlatform(input.platform) ?? undefined;
         const identityKey = normalizeIdentity(input.identity_key) ?? undefined;
@@ -430,6 +650,7 @@ export class CrossPlatformChatSessionManager {
             ...(messageId ? { message_id: messageId } : {}),
             ...(goalId ? { goal_id: goalId } : {}),
             ...(userId ? { user_id: userId } : {}),
+            ...(input.cwd ? { cwd: input.cwd } : {}),
             text: input.text,
             userInput: normalizeUserInput(input.userInput, input.text),
             actor: normalizeActor(channel, {
@@ -439,8 +660,9 @@ export class CrossPlatformChatSessionManager {
                 user_id: userId,
                 actor: input.actor,
             }),
-            runtimeControl: resolveRuntimeControl(channel, input.runtimeControl, metadata),
+            runtimeControl: resolveRuntimeControl(channel, input.runtimeControl, metadata, externalSurface),
             companion,
+            ...(externalSurface ? { externalSurface } : {}),
             metadata,
             replyTarget: normalizeReplyTarget(channel, {
                 platform,
@@ -450,13 +672,11 @@ export class CrossPlatformChatSessionManager {
                 message_id: messageId,
                 replyTarget: input.replyTarget,
                 metadata,
+                externalSurface,
             }),
         };
     }
     ensureCompanionContract(ingress) {
-        if (ingress.companion) {
-            return ingress;
-        }
         return {
             ...ingress,
             companion: this.buildCompanionContractForIngress({
@@ -467,6 +687,14 @@ export class CrossPlatformChatSessionManager {
                 message_id: ingress.message_id,
                 goal_id: ingress.goal_id,
                 replyTarget: ingress.replyTarget,
+                companion: ingress.companion
+                    ? {
+                        presence: ingress.companion.presence,
+                        turnPolicy: ingress.companion.turn_policy,
+                        inputModality: ingress.companion.turn_policy.input_modality,
+                        outputMode: ingress.companion.turn_policy.output_mode,
+                    }
+                    : undefined,
             }),
         };
     }
@@ -494,7 +722,7 @@ export class CrossPlatformChatSessionManager {
      * Returns the active session info if a matching session is already loaded.
      */
     getSessionInfo(options) {
-        const sessionKey = buildSessionKey(options);
+        const sessionKey = buildSessionKeyFromParts(options);
         const session = this.sessions.get(sessionKey);
         return session
             ? {
@@ -509,43 +737,20 @@ export class CrossPlatformChatSessionManager {
             }
             : null;
     }
-    sessionInfoRelativePath(sessionKey) {
-        const encoded = Buffer.from(sessionKey, "utf-8").toString("base64url");
-        return path.join("chat", "cross-platform-sessions", `${encoded}.json`);
+    getActiveSeedyTurnStatus(options, statusOptions = {}) {
+        const session = this.sessions.get(buildSessionKeyFromParts(options));
+        return session
+            ? session.runner.getActiveSeedyTurnStatus(statusOptions)
+            : createSeedyActiveTurnStatus(null, statusOptions);
+    }
+    formatActiveSeedyTurnStatus(options, statusOptions = {}) {
+        return formatSeedyActiveTurnStatus(this.getActiveSeedyTurnStatus(options, statusOptions));
     }
     async loadPersistedSessionInfo(sessionKey) {
-        const raw = await this.deps.stateManager.readRaw(this.sessionInfoRelativePath(sessionKey));
-        if (!isRecord(raw) || raw["session_key"] !== sessionKey)
-            return null;
-        const cwd = typeof raw["cwd"] === "string" && raw["cwd"].trim() ? raw["cwd"] : null;
-        const createdAt = typeof raw["created_at"] === "string" && raw["created_at"].trim() ? raw["created_at"] : null;
-        const lastUsedAt = typeof raw["last_used_at"] === "string" && raw["last_used_at"].trim() ? raw["last_used_at"] : null;
-        if (!cwd || !createdAt || !lastUsedAt)
-            return null;
-        return {
-            session_key: sessionKey,
-            ...(typeof raw["identity_key"] === "string" ? { identity_key: raw["identity_key"] } : {}),
-            ...(typeof raw["platform"] === "string" ? { platform: raw["platform"] } : {}),
-            ...(typeof raw["conversation_id"] === "string" ? { conversation_id: raw["conversation_id"] } : {}),
-            ...(typeof raw["conversation_name"] === "string" ? { conversation_name: raw["conversation_name"] } : {}),
-            ...(typeof raw["user_id"] === "string" ? { user_id: raw["user_id"] } : {}),
-            ...(typeof raw["user_name"] === "string" ? { user_name: raw["user_name"] } : {}),
-            cwd,
-            created_at: createdAt,
-            last_used_at: lastUsedAt,
-            ...(typeof raw["last_message_id"] === "string" ? { last_message_id: raw["last_message_id"] } : {}),
-            ...(typeof raw["chat_session_id"] === "string" ? { chat_session_id: raw["chat_session_id"] } : {}),
-            ...(isRecord(raw["active_reply_target"])
-                ? { active_reply_target: cloneReplyTarget(raw["active_reply_target"]) }
-                : {}),
-            ...(isRecord(raw["active_companion_contract"])
-                ? { active_companion_contract: raw["active_companion_contract"] }
-                : {}),
-            metadata: isRecord(raw["metadata"]) ? cloneMetadata(raw["metadata"]) : {},
-        };
+        return new CrossPlatformChatSessionInfoStore(resolveChatStateBaseDir(this.deps.stateManager)).load(sessionKey);
     }
     async persistSessionInfo(info) {
-        await this.deps.stateManager.writeRaw(this.sessionInfoRelativePath(info.session_key), {
+        await new CrossPlatformChatSessionInfoStore(resolveChatStateBaseDir(this.deps.stateManager)).save({
             ...info,
             metadata: cloneMetadata(info.metadata),
             active_reply_target: info.active_reply_target ? cloneReplyTarget(info.active_reply_target) : undefined,
@@ -590,6 +795,10 @@ export class CrossPlatformChatSessionManager {
             approvalFn: approvalFn ?? this.deps.approvalFn,
             approvalRequestFn: approvalRequestFn ?? this.deps.approvalRequestFn,
             runtimeControlApprovalFn: approvalFn ?? this.deps.runtimeControlApprovalFn,
+            permissionGrantContext: {
+                ...this.deps.permissionGrantContext,
+                sessionId: info.session_key,
+            },
         });
         if (info.chat_session_id) {
             const loaded = await new ChatSessionCatalog(this.deps.stateManager).loadSession(info.chat_session_id);
@@ -651,6 +860,7 @@ export class CrossPlatformChatSessionManager {
                             kind: "checkpoint",
                             message: prompt,
                             sourceId: `approval:${info.last_message_id ?? info.session_key}`,
+                            presentation: { gatewayProgress: "user" },
                             runId: info.session_key,
                             turnId: info.last_message_id ?? info.session_key,
                             createdAt: new Date().toISOString(),
@@ -681,22 +891,27 @@ export class CrossPlatformChatSessionManager {
                 ? info.metadata.goal_id.trim()
                 : "chat";
             const stateEpoch = currentStateEpochFromSessionInfo(info);
+            const grantProposal = createPermissionGrantProposalFromApprovalRequest(request);
             return broker.requestConversationalApproval(goalId, createPendingPermissionTask({
                 id: request.callId ?? info.last_message_id ?? info.session_key,
                 description: request.reason,
                 action: request.toolName,
                 target: {
                     session_id: info.session_key,
+                    ...(request.runId ? { run_id: request.runId } : {}),
                     tool_id: request.toolName,
                     ...(request.callId ? { tool_call_id: request.callId } : {}),
                 },
                 stateEpoch,
+                waitPlanId: request.permissionWaitPlanId,
                 stateVersion: info.last_used_at,
                 permissionLevel: request.permissionLevel,
                 isDestructive: request.isDestructive,
                 reversibility: request.reversibility,
+                ...(grantProposal ? { grantProposal } : {}),
             }), {
                 origin,
+                ...(request.approvalId ? { approvalId: request.approvalId } : {}),
                 deliverConversationalApproval: async ({ prompt }) => {
                     const handler = this.activeApprovalEventHandlers.get(info.session_key);
                     if (!handler) {
@@ -711,6 +926,7 @@ export class CrossPlatformChatSessionManager {
                             kind: "checkpoint",
                             message: prompt,
                             sourceId: `approval:${request.callId ?? info.last_message_id ?? info.session_key}`,
+                            presentation: { gatewayProgress: "user" },
                             runId: info.session_key,
                             turnId: info.last_message_id ?? info.session_key,
                             createdAt: new Date().toISOString(),
@@ -730,77 +946,6 @@ export class CrossPlatformChatSessionManager {
     async executeInSession(session, ingress, options = {}) {
         this.updateSessionInfoForIngress(session, ingress, options);
         await this.persistSessionInfo(session.info);
-        const capabilities = {
-            hasAgentLoop: this.deps.chatAgentLoopRunner !== undefined,
-            hasToolLoop: this.deps.llmClient !== undefined,
-            hasRuntimeControlService: this.deps.runtimeControlService !== undefined,
-        };
-        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,
-            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) {
@@ -813,7 +958,13 @@ export class CrossPlatformChatSessionManager {
             session.runner.onEvent = undefined;
         }
         try {
-            return await session.runner.executeIngressMessage(ingress, session.info.cwd, options.timeoutMs, selectedRoute);
+            return await session.runner.executeIngressMessage(ingress, session.info.cwd, options.timeoutMs, undefined, {
+                routeSelector: async (selectionInput) => {
+                    const selectedRoute = await this.selectRouteForSession(session, ingress, selectionInput);
+                    session.lastRoute = selectedRoute;
+                    return selectedRoute;
+                },
+            });
         }
         finally {
             await deliveryQueue?.drain();
@@ -821,6 +972,32 @@ export class CrossPlatformChatSessionManager {
             session.runner.onEvent = previousOnEvent;
         }
     }
+    async selectRouteForSession(session, ingress, input) {
+        const capabilities = {
+            hasAgentLoop: this.deps.chatAgentLoopRunner !== undefined,
+            hasRuntimeControlService: this.deps.runtimeControlService !== undefined,
+        };
+        const setupSecretIntake = input.setupSecretIntake;
+        const safeIngressText = input.safeInput;
+        const hasSetupSecret = setupSecretIntake.suppliedSecrets.length > 0;
+        const metadataRuntimeControlExplicit = ingress.metadata["runtime_control_explicit"] === true || ingress.runtimeControl.explicit === true;
+        const shouldClassifyRuntimeControl = !hasSetupSecret
+            && metadataRuntimeControlExplicit;
+        const runtimeControlClassification = shouldClassifyRuntimeControl
+            ? await classifyRuntimeControlIntent(safeIngressText, this.deps.llmClient)
+            : null;
+        const runtimeControlIntent = runtimeControlClassification?.status === "intent"
+            ? runtimeControlClassification.intent
+            : null;
+        return this.ingressRouter.selectRoute(ingress, {
+            ...capabilities,
+            runtimeControlIntent,
+            runtimeControlUnclassified: metadataRuntimeControlExplicit
+                && runtimeControlClassification?.status === "unclassified"
+                && !hasSetupSecret,
+            setupSecretIntake,
+        });
+    }
     updateSessionInfoForIngress(session, ingress, options = {}) {
         session.info.last_used_at = new Date().toISOString();
         session.info.chat_session_id = session.runner.getSessionId() ?? session.info.chat_session_id;
@@ -965,7 +1142,7 @@ async function createGlobalCrossPlatformChatSessionManager() {
     const providerConfig = await loadProviderConfig();
     const stateManager = new StateManager();
     await stateManager.init();
-    const llmClient = await buildLLMClient();
+    const llmClient = await buildGatewayLLMClient(providerConfig);
     const adapterRegistry = await buildAdapterRegistry(llmClient, providerConfig);
     const adapter = adapterRegistry.getAdapter(providerConfig.adapter);
     const toolRegistry = new ToolRegistry();
@@ -992,9 +1169,16 @@ async function createGlobalCrossPlatformChatSessionManager() {
     await pluginLoader.loadAll().catch(() => []);
     await scheduleEngine.syncExternalSources(pluginLoader.getScheduleSources()).catch(() => undefined);
     const runtimeRoot = path.join(stateManager.getBaseDir(), "runtime");
+    const runtimeStorePaths = createRuntimeStorePaths(runtimeRoot);
+    const controlDbOptions = { controlBaseDir: stateManager.getBaseDir() };
+    const permissionGrantStore = new PermissionGrantStore(runtimeStorePaths, controlDbOptions);
+    const permissionWaitPlanStore = new PermissionWaitPlanStore(runtimeStorePaths, controlDbOptions);
+    const capabilityVerificationStore = new CapabilityVerificationStore(runtimeStorePaths, controlDbOptions);
+    const capabilityExecutionResolver = createCapabilityExecutionResolver({ stateManager });
     const runtimeControlService = new RuntimeControlService({
         runtimeRoot,
         stateManager,
+        permissionGrantStore,
         executor: createDaemonRuntimeControlExecutor({
             baseDir: stateManager.getBaseDir(),
         }),
@@ -1038,17 +1222,23 @@ async function createGlobalCrossPlatformChatSessionManager() {
         })
         : undefined;
     const approvalBroker = new ApprovalBroker({
-        store: new ApprovalStore(createRuntimeStorePaths(runtimeRoot)),
+        store: new ApprovalStore(runtimeStorePaths, controlDbOptions),
+        permissionWaitPlanStore,
     });
     return new CrossPlatformChatSessionManager({
         stateManager,
         adapter,
         llmClient,
+        defaultExecutionSecurity: providerConfig.agent_loop?.security,
         registry: toolRegistry,
         toolExecutor,
         chatAgentLoopRunner,
         reviewAgentLoopRunner,
         approvalBroker,
+        permissionGrantStore,
+        permissionWaitPlanStore,
+        capabilityVerificationStore,
+        capabilityExecutionResolver,
         runtimeControlService,
     });
 }