specrails-desktop 2.64.1 → 2.65.0

package/server/dist/modules/missions/runtime/mission-core-sessions.js

@@ -1,12 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MissionCoreSessions = exports.GLOBAL_SCOPE = void 0;
+exports.MissionCoreSessions = exports.GLOBAL_SCOPE = exports.FlowSessionUnavailableError = void 0;
 const agent_mcp_config_1 = require("../../../agent-mcp-config");
 const agent_sessions_1 = require("../../agent-sessions");
 const agent_store_1 = require("../../agents/runtime/agent-store");
 const agent_session_store_1 = require("./agent-session-store");
+const agent_flow_prompt_1 = require("./agent-flow-prompt");
 const core_session_runner_1 = require("./core-session-runner");
 const mission_session_projector_1 = require("./mission-session-projector");
+const mission_tool_policy_1 = require("./mission-tool-policy");
+/** Why a Flow turn cannot run on Core sessions (there is no legacy Flow path). */
+class FlowSessionUnavailableError extends Error {
+    code = 'flow_sessions_unavailable';
+    constructor(message) {
+        super(message);
+        this.name = 'FlowSessionUnavailableError';
+    }
+}
+exports.FlowSessionUnavailableError = FlowSessionUnavailableError;
 exports.GLOBAL_SCOPE = 'global';
 /**
  * Missions' side of Core agent sessions: decides whether a turn runs in Core,
@@ -21,9 +32,16 @@ class MissionCoreSessions {
     handles = new Map();
     /** Missions with a turn being prepared or running: their capability belongs to that turn. */
     activeTurns = new Set();
+    /** Core sessions with a projector: the mission's (its conversation id) and Flow sessions (`flow:<flowId>`). */
     tracked = new Set();
-    /** Last turn context per mission: the policy its session runs with. */
+    /** Last turn context per Core session: the policy it runs with. */
     contexts = new Map();
+    /** The Core session the conversation's latest turn ran in (sub-agent tools act on it). */
+    current = new Map();
+    /** Core sessions closed (Flow pause/hand-off/renewal, mission generation renewal): never sent another turn. */
+    closedSessions = new Set();
+    /** Tracked Core session → the conversation that owns it (every mission generation and Flow session). */
+    owners = new Map();
     constructor(deps) {
         this.deps = deps;
     }
@@ -38,6 +56,8 @@ class MissionCoreSessions {
      * the legacy runners (sessions disabled, scope degraded, provider not served).
      */
     async prepareTurn(conversation, adapter, turn) {
+        if (turn.flow)
+            return this.prepareFlowTurn(conversation, adapter, { ...turn, flow: turn.flow });
         const availability = await this.deps.availability();
         if (!availability.enabled)
             return null;
@@ -59,8 +79,22 @@ class MissionCoreSessions {
         if (!drivers.some((driver) => driver.id === adapter.id))
             return null;
         const conversationId = conversation.id;
-        if (!this.tracked.has(conversationId))
-            await this.track(scope, conversationId, this.deps.broadcast);
+        // A Core session is bound to the driver that opened it: a provider switch
+        // (or a session Core closed) continues in the mission's next generation.
+        const state = (0, agent_session_store_1.getMissionCoreSession)(this.deps.db, conversationId);
+        let sessionId = (0, agent_session_store_1.missionCoreSessionId)(conversationId, state.generation);
+        const openedWith = state.provider ?? this.contexts.get(sessionId)?.provider ?? null;
+        let renewed = false;
+        if ((openedWith && openedWith !== adapter.id) || this.closedSessions.has(sessionId)) {
+            sessionId = await this.renewMissionSession(conversation, adapter.id, openedWith && openedWith !== adapter.id ? 'provider_changed' : 'session_closed');
+            renewed = true;
+        }
+        else if (!state.provider) {
+            (0, agent_session_store_1.setMissionCoreSessionProvider)(this.deps.db, conversationId, adapter.id);
+        }
+        if (!this.tracked.has(sessionId))
+            await this.track(scope, conversationId, sessionId, this.deps.broadcast);
+        this.current.set(conversationId, sessionId);
         // Rotate the capability the resident bridge presents; the previous one is revoked.
         const mcpServers = (0, agent_mcp_config_1.prepareAgentMcpSpec)({ conversationId, port: this.deps.port, capability: turn.capability, external: turn.external });
         // App-installed plugin servers (same set a legacy spawn passes as argv); never shadow a configured name.
@@ -72,23 +106,27 @@ class MissionCoreSessions {
         this.activeTurns.add(conversationId);
         if (previous && previous !== turn.capability)
             this.deps.revokeCapability(previous);
-        // Parity with legacy missions: the adapter declares its permission level; user-scope MCP servers stay inherited.
+        // Missions are read-only (mission-read-only-policy): the adapter declares how its
+        // Core driver enforces that while MCP tools stay callable. User-scope MCP stays inherited.
         const delegation = client.initialize?.capabilities?.delegation === 1;
         const policy = {
             subagents: this.subagentPolicy(conversation),
-            permissions: adapter.capabilities.sessionPermissions ?? 'workspace-write',
+            ...(0, mission_tool_policy_1.missionSessionBoundary)(adapter, drivers.find((driver) => driver.id === adapter.id)),
             mcp: { inheritUserScope: true },
             subagentRuntime: this.subagentRuntime(conversation, adapter.id, drivers, delegation),
         };
-        this.contexts.set(conversationId, { policy, mcpServers, projectId: conversation.pinned_project_id ?? null, scope, provider: adapter.id, drivers, delegation });
+        this.contexts.set(sessionId, { conversationId, policy, mcpServers, projectId: conversation.pinned_project_id ?? null, scope, provider: adapter.id, drivers, delegation, flow: false });
         return {
-            sessionId: conversationId,
+            sessionId,
             client,
             driver: adapter.id,
             policy,
             mcpServers,
             ...(policy.subagentRuntime?.mode === 'delegated' ? { systemPromptAddendum: delegationGuidance(policy.subagentRuntime) } : {}),
-            legacyProviderSessionRef: conversation.session_id ?? null,
+            // A new generation starts clean: the turn seeds it with the conversation
+            // history (never another provider's thread).
+            legacyProviderSessionRef: renewed ? null : ((0, agent_store_1.getAgentConversation)(this.deps.db, conversationId) ?? conversation).session_id ?? null,
+            ...(renewed ? { freshSession: true } : {}),
             metadata: { conversationId, surface: 'mission' },
             onHandle: (handle) => {
                 if (handle) {
@@ -100,6 +138,146 @@ class MissionCoreSessions {
             },
         };
     }
+    /**
+     * Can this conversation's provider run a Flow session in its scope right now?
+     * Resolves the host client; throws `FlowSessionUnavailableError` otherwise.
+     */
+    async assertFlowSupport(conversation, providerId) {
+        const availability = await this.deps.availability();
+        if (!availability.enabled)
+            throw new FlowSessionUnavailableError(`Flow needs Core agent sessions: ${availability.reason}`);
+        const scope = this.scopeOf(conversation);
+        if (!this.deps.registry.available(scope))
+            throw new FlowSessionUnavailableError(`Core sessions are unavailable for ${scope} (${this.deps.registry.status(scope)})`);
+        let client;
+        try {
+            client = await this.deps.registry.acquire(scope);
+        }
+        catch (error) {
+            throw new FlowSessionUnavailableError(`Core sessions are unavailable for ${scope}: ${error.message}`);
+        }
+        if (!(0, agent_sessions_1.hostSupportsFlowSessions)(client.initialize))
+            throw new FlowSessionUnavailableError('The Core session host does not support Flow sessions (flowSessions); update Core');
+        if (!(client.initialize?.drivers ?? []).some((driver) => driver.id === providerId)) {
+            throw new FlowSessionUnavailableError(`Core has no session driver for ${providerId}; Flow cannot run with this provider`);
+        }
+        return { scope, client };
+    }
+    /**
+     * A Flow turn: its own Core session (`flow:<flowId>`) with the worktree as
+     * cwd, the rail write-role permissions (FLOW_SESSION_BOUNDARY), default tools and the same Specrails MCP
+     * the mission presents. Sub-agents follow the mission's project policy
+     * ("Allow sub-agents", "Run sub-agents with"); they inherit the session's cwd
+     * and permissions (Core gives delegated children the parent's cwd). The Flow
+     * session has its own projection (cursor, sub-agents, usage billed `flow`).
+     */
+    async prepareFlowTurn(conversation, adapter, turn) {
+        const { scope, client } = await this.assertFlowSupport(conversation, adapter.id);
+        const conversationId = conversation.id;
+        const sessionId = turn.flow.coreSessionId;
+        if (!this.tracked.has(sessionId))
+            await this.track(scope, conversationId, sessionId, this.deps.broadcast);
+        this.current.set(conversationId, sessionId);
+        const mcpServers = (0, agent_mcp_config_1.prepareAgentMcpSpec)({ conversationId, port: this.deps.port, capability: turn.capability, external: turn.external });
+        for (const plugin of turn.plugins ?? [])
+            if (!mcpServers.some((server) => server.name === plugin.name))
+                mcpServers.push(plugin);
+        const previous = this.capabilities.get(conversationId);
+        this.capabilities.set(conversationId, turn.capability);
+        this.activeTurns.add(conversationId);
+        if (previous && previous !== turn.capability)
+            this.deps.revokeCapability(previous);
+        const drivers = client.initialize?.drivers ?? [];
+        const delegation = client.initialize?.capabilities?.delegation === 1;
+        const subagents = this.subagentPolicy(conversation);
+        const policy = {
+            subagents,
+            ...turn.flow.policy,
+            mcp: { inheritUserScope: true },
+            ...(subagents === 'enabled' ? { subagentRuntime: this.subagentRuntime(conversation, adapter.id, drivers, delegation) } : {}),
+        };
+        this.contexts.set(sessionId, { conversationId, policy, mcpServers, projectId: conversation.pinned_project_id ?? null, scope, provider: adapter.id, drivers, delegation, flow: true });
+        const addendum = subagents !== 'enabled'
+            ? null
+            : policy.subagentRuntime?.mode === 'delegated'
+                ? `${agent_flow_prompt_1.FLOW_SUBAGENTS_ADDENDUM}\n\n${delegationGuidance(policy.subagentRuntime)}`
+                : agent_flow_prompt_1.FLOW_SUBAGENTS_ADDENDUM;
+        return {
+            sessionId,
+            client,
+            driver: adapter.id,
+            policy,
+            mcpServers,
+            ...(addendum ? { systemPromptAddendum: addendum } : {}),
+            inputDelivery: 'interrupt',
+            metadata: { conversationId, surface: 'flow', flowId: turn.flow.flowId },
+            onHandle: (handle) => {
+                if (handle) {
+                    this.handles.set(conversationId, handle);
+                    return;
+                }
+                this.handles.delete(conversationId);
+                this.activeTurns.delete(conversationId);
+            },
+        };
+    }
+    /**
+     * Whether a Flow's Core session can take this turn: not closed, and opened
+     * (if at all in this process) with the same provider — a Core session is
+     * bound to the driver it was opened with.
+     */
+    flowSessionUsable(coreSessionId, providerId) {
+        if (this.closedSessions.has(coreSessionId))
+            return false;
+        const context = this.contexts.get(coreSessionId);
+        return !context || !context.flow || context.provider === providerId;
+    }
+    /** The mission's own current Core session id (its latest generation). */
+    missionSessionId(conversationId) {
+        return (0, agent_session_store_1.missionCoreSessionId)(conversationId, (0, agent_session_store_1.getMissionCoreSession)(this.deps.db, conversationId).generation);
+    }
+    /**
+     * Move the mission to a new Core session opened with `provider`: the current
+     * generation is closed in Core (its journal stays for the projection) and is
+     * never sent another turn. Called between turns only. Returns the new id.
+     */
+    async renewMissionSession(conversation, provider, reason) {
+        const previous = this.missionSessionId(conversation.id);
+        const next = (0, agent_session_store_1.missionCoreSessionId)(conversation.id, (0, agent_session_store_1.renewMissionCoreSession)(this.deps.db, conversation.id, provider).generation);
+        this.closedSessions.add(previous);
+        if (this.current.get(conversation.id) === previous)
+            this.current.delete(conversation.id);
+        this.contexts.delete(previous);
+        console.log(`[agent-chat] mission ${conversation.id} continues in Core session ${next} (${reason})`);
+        try {
+            const client = await this.deps.registry.acquire(this.scopeOf(conversation));
+            await client.request('session.close', { sessionId: previous, reason });
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== 'session_not_found' && code !== 'session_closed')
+                console.warn(`[agent-chat] could not close Core session ${previous}: ${error.message}`);
+        }
+        return next;
+    }
+    /** Close a Flow's Core session (pause, discard, hand-off, renewal). Core keeps
+     * its journal for the projection; the session never takes another turn. Never throws. */
+    async closeFlowSession(conversation, coreSessionId, reason) {
+        this.closedSessions.add(coreSessionId);
+        // Later sub-agent tools act on the mission again; the projection keeps
+        // following the Flow session (background sub-agents may still settle).
+        if (this.current.get(conversation.id) === coreSessionId)
+            this.current.delete(conversation.id);
+        try {
+            const client = await this.deps.registry.acquire(this.scopeOf(conversation));
+            await client.request('session.close', { sessionId: coreSessionId, reason });
+        }
+        catch (error) {
+            if (error.code === 'session_not_found' || error.code === 'session_closed')
+                return;
+            console.warn(`[agent-chat] could not close Flow session ${coreSessionId}: ${error.message}`);
+        }
+    }
     /**
      * The "Allow sub-agents" setting of a scope changed (`projectId: null` = missions
      * without a project): send the new policy to each open session of that scope.
@@ -107,25 +285,28 @@ class MissionCoreSessions {
      * the change as deferred, which the mission shows with "Stop agents and apply now".
      */
     async refreshSubagentPolicy(scope) {
-        for (const [conversationId, context] of [...this.contexts]) {
-            if (context.projectId !== scope.projectId || !this.tracked.has(conversationId))
+        for (const [sessionId, context] of [...this.contexts]) {
+            if (context.projectId !== scope.projectId || !this.tracked.has(sessionId))
                 continue;
-            const conversation = (0, agent_store_1.getAgentConversation)(this.deps.db, conversationId);
+            const conversation = (0, agent_store_1.getAgentConversation)(this.deps.db, context.conversationId);
             if (!conversation)
                 continue;
             const subagents = this.subagentPolicy(conversation);
-            const subagentRuntime = this.subagentRuntime(conversation, context.provider, context.drivers, context.delegation);
+            const subagentRuntime = context.flow && subagents !== 'enabled'
+                ? undefined
+                : this.subagentRuntime(conversation, context.provider, context.drivers, context.delegation);
             if (subagents === context.policy.subagents && JSON.stringify(subagentRuntime) === JSON.stringify(context.policy.subagentRuntime))
                 continue;
-            const next = { ...context, policy: { ...context.policy, subagents, subagentRuntime } };
-            this.contexts.set(conversationId, next);
+            const { subagentRuntime: _previous, ...rest } = context.policy;
+            const next = { ...context, policy: { ...rest, subagents, ...(subagentRuntime ? { subagentRuntime } : {}) } };
+            this.contexts.set(sessionId, next);
             try {
                 const client = await this.deps.registry.acquire(context.scope);
-                await client.request('session.update', { sessionId: conversationId, policy: (0, core_session_runner_1.sessionPolicyFor)(next) });
+                await client.request('session.update', { sessionId, policy: (0, core_session_runner_1.sessionPolicyFor)(next) });
             }
             catch (error) {
                 // The next turn sends the policy again; nothing is lost.
-                console.warn(`[agent-chat] could not update the sub-agent policy of ${conversationId}: ${error.message}`);
+                console.warn(`[agent-chat] could not update the sub-agent policy of ${sessionId}: ${error.message}`);
             }
         }
     }
@@ -169,34 +350,56 @@ class MissionCoreSessions {
         this.deps.revokeCapability(capability);
         (0, agent_mcp_config_1.removeAgentCapabilityFile)(conversationId);
     }
-    /** True when this mission's sub-agents are launched by Core (another provider). */
+    /** The Core session the conversation's sub-agent tools act on: its Flow's while a Flow turn ran last. */
+    sessionOf(conversationId) {
+        return this.current.get(conversationId) ?? this.missionSessionId(conversationId);
+    }
+    /** True when this mission's sub-agents (or its Flow's, while in Flow) are launched by Core (another provider). */
     delegates(conversationId) {
-        return this.contexts.get(conversationId)?.policy.subagentRuntime?.mode === 'delegated';
+        return this.contexts.get(this.sessionOf(conversationId))?.policy.subagentRuntime?.mode === 'delegated';
     }
-    /** Launch a sub-agent on the configured provider (delegated runtime only). */
+    /** Launch a sub-agent on the configured provider (delegated runtime only), in the current session. */
     async delegate(conversation, params) {
-        this.assertDelegates(conversation.id);
+        const sessionId = this.assertDelegates(conversation.id);
         const client = await this.deps.registry.acquire(this.scopeOf(conversation));
-        return client.request('session.delegate', { sessionId: conversation.id, ...params });
+        return client.request('session.delegate', { sessionId, ...params });
     }
     /** Results of delegated sub-agents that finished (or what still runs at the timeout). */
     async waitSubagents(conversation, subagentIds, timeoutMs) {
-        this.assertDelegates(conversation.id);
+        const sessionId = this.assertDelegates(conversation.id);
         const client = await this.deps.registry.acquire(this.scopeOf(conversation));
-        return client.request('session.waitSubagents', { sessionId: conversation.id, ...(subagentIds ? { subagentIds } : {}), timeoutMs });
+        return client.request('session.waitSubagents', { sessionId, ...(subagentIds ? { subagentIds } : {}), timeoutMs });
     }
     assertDelegates(conversationId) {
-        if (!this.tracked.has(conversationId) || !this.delegates(conversationId)) {
+        const sessionId = this.sessionOf(conversationId);
+        if (!this.tracked.has(sessionId) || !this.delegates(conversationId)) {
             throw new Error('This mission does not delegate sub-agents: its agent launches them with its own tool, or sub-agents are off.');
         }
+        return sessionId;
     }
-    /** Stop sub-agents of a mission's Core session (all when `subagentIds` is omitted). */
+    /** Stop sub-agents of a mission's Core sessions (its own and its Flow's; all when `subagentIds` is omitted). */
     async stopSubagents(conversation, subagentIds) {
-        if (!this.tracked.has(conversation.id))
+        const sessions = this.sessionsOf(conversation.id);
+        if (sessions.length === 0)
             return [];
+        // Route each id to the session that launched it.
+        const owner = new Map((0, agent_session_store_1.listSubagents)(this.deps.db, conversation.id).map((row) => [row.subagentId, row.coreSessionId]));
         const client = await this.deps.registry.acquire(this.scopeOf(conversation));
-        const result = await client.request('session.stopSubagents', { sessionId: conversation.id, ...(subagentIds ? { subagentIds } : {}) });
-        return result.stopped ?? [];
+        const stopped = [];
+        for (const sessionId of sessions) {
+            const ids = subagentIds?.filter((id) => (owner.get(id) ?? conversation.id) === sessionId);
+            if (ids && ids.length === 0)
+                continue;
+            const result = await client.request('session.stopSubagents', { sessionId, ...(ids ? { subagentIds: ids } : {}) });
+            stopped.push(...(result.stopped ?? []));
+        }
+        return stopped;
+    }
+    /** Tracked Core sessions of a conversation (its own first). */
+    sessionsOf(conversationId) {
+        const mission = this.missionSessionId(conversationId);
+        const others = [...this.owners].filter(([sessionId, owner]) => owner === conversationId && sessionId !== mission).map(([sessionId]) => sessionId);
+        return [mission, ...others].filter((sessionId) => this.tracked.has(sessionId));
     }
     /**
      * Rebuild a mission's derived session rows (sub-agents, their output, resident
@@ -207,62 +410,97 @@ class MissionCoreSessions {
     async rebuildProjection(conversation) {
         const scope = this.scopeOf(conversation);
         const conversationId = conversation.id;
-        if (!(0, agent_session_store_1.getSessionCursor)(this.deps.db, conversationId))
+        // Every Core session of the mission (its own and its Flows'), each from its own journal.
+        const cursors = (0, agent_session_store_1.listSessionCursors)(this.deps.db, conversationId);
+        if (cursors.length === 0)
             return null;
-        this.deps.registry.untrack(scope, conversationId);
-        this.tracked.delete(conversationId);
-        (0, agent_session_store_1.resetSessionProjection)(this.deps.db, conversationId);
-        let muted = true;
-        try {
-            await this.track(scope, conversationId, (message) => { if (!muted)
-                this.deps.broadcast(message); });
-        }
-        finally {
-            muted = false;
+        let lastSeq = 0;
+        for (const { coreSessionId } of cursors) {
+            this.deps.registry.untrack(scope, coreSessionId);
+            this.tracked.delete(coreSessionId);
+            (0, agent_session_store_1.resetSessionProjection)(this.deps.db, conversationId, coreSessionId);
+            let muted = true;
+            try {
+                await this.track(scope, conversationId, coreSessionId, (message) => { if (!muted)
+                    this.deps.broadcast(message); });
+            }
+            finally {
+                muted = false;
+            }
+            if (coreSessionId === this.missionSessionId(conversationId))
+                lastSeq = (0, agent_session_store_1.getSessionCursor)(this.deps.db, conversationId, coreSessionId)?.lastSeq ?? 0;
         }
-        const cursor = (0, agent_session_store_1.getSessionCursor)(this.deps.db, conversationId);
+        const state = (0, agent_session_store_1.conversationSessionState)(this.deps.db, conversationId);
         const subagents = (0, agent_session_store_1.listSubagents)(this.deps.db, conversationId);
         const timestamp = new Date().toISOString();
-        if (cursor)
-            this.deps.broadcast({ type: 'agent_resident_state', conversationId, phase: cursor.residentPhase, liveSubagents: cursor.liveSubagents, processAlive: cursor.processAlive, timestamp });
+        if (state)
+            this.deps.broadcast({ type: 'agent_resident_state', conversationId, phase: state.residentPhase, liveSubagents: state.liveSubagents, processAlive: state.processAlive, timestamp });
         for (const { conversationId: _owner, ...subagent } of subagents)
             this.deps.broadcast({ type: 'agent_subagent', conversationId, subagent, timestamp });
-        return { lastSeq: cursor?.lastSeq ?? 0, subagents: subagents.length };
+        return { lastSeq, subagents: subagents.length };
     }
-    async track(scope, conversationId, broadcast) {
-        (0, agent_session_store_1.ensureSessionCursor)(this.deps.db, conversationId, conversationId, scope);
+    /** Project one Core session of a conversation: a generation of its own (billed `agent-chat`) or a Flow's (billed `flow`). */
+    async track(scope, conversationId, sessionId, broadcast) {
+        (0, agent_session_store_1.ensureSessionCursor)(this.deps.db, conversationId, sessionId, scope);
+        this.owners.set(sessionId, conversationId);
         const projector = new mission_session_projector_1.MissionSessionProjector(conversationId, {
             db: this.deps.db,
             broadcast,
             adapterFor: this.deps.adapterFor,
             onProcessEnded: (id) => this.releaseCapability(id),
-        });
+            ...(this.deps.agentAudit ? { agentAudit: this.deps.agentAudit } : {}),
+        }, sessionId === conversationId ? {} : (0, agent_session_store_1.isMissionCoreSessionId)(conversationId, sessionId) ? { coreSessionId: sessionId, mission: true } : { coreSessionId: sessionId, surface: 'flow' });
         try {
-            await this.deps.registry.track(scope, conversationId, projector, () => { });
+            await this.deps.registry.track(scope, sessionId, projector, () => { });
         }
         catch (error) {
             // A session that does not exist yet has nothing to replay; tracking starts empty.
             if (error.code !== 'session_not_found')
                 throw error;
         }
-        this.tracked.add(conversationId);
+        this.tracked.add(sessionId);
     }
     /** Conversation deleted: close its Core session and drop all local state. */
     async close(conversation) {
         const scope = this.scopeOf(conversation);
         this.handles.delete(conversation.id);
         this.activeTurns.delete(conversation.id);
-        this.contexts.delete(conversation.id);
+        this.current.delete(conversation.id);
+        // Every session of the conversation stops being projected; Flow sessions are
+        // closed in Core by the Flow module, the mission's current generation here.
+        // (The conversation row may already be gone: derive the sessions from what is tracked.)
+        const toClose = [];
+        for (const [sessionId, context] of [...this.contexts])
+            if (context.conversationId === conversation.id)
+                this.contexts.delete(sessionId);
+        for (const [sessionId, owner] of [...this.owners]) {
+            if (owner !== conversation.id)
+                continue;
+            this.owners.delete(sessionId);
+            if (!this.tracked.delete(sessionId))
+                continue;
+            this.deps.registry.untrack(scope, sessionId);
+            if ((0, agent_session_store_1.isMissionCoreSessionId)(conversation.id, sessionId) && !this.closedSessions.has(sessionId))
+                toClose.push(sessionId);
+        }
         this.releaseCapability(conversation.id, { force: true });
-        if (!this.tracked.delete(conversation.id))
+        if (toClose.length === 0)
             return;
-        this.deps.registry.untrack(scope, conversation.id);
+        let client;
         try {
-            const client = await this.deps.registry.acquire(scope);
-            await client.request('session.close', { sessionId: conversation.id, reason: 'conversation_deleted' });
+            client = await this.deps.registry.acquire(scope);
         }
         catch (error) {
-            console.warn(`[agent-chat] could not close Core session ${conversation.id}: ${error.message}`);
+            console.warn(`[agent-chat] could not close Core sessions of ${conversation.id}: ${error.message}`);
+            return;
+        }
+        for (const sessionId of toClose) {
+            try {
+                await client.request('session.close', { sessionId, reason: 'conversation_deleted' });
+            }
+            catch (error) {
+                console.warn(`[agent-chat] could not close Core session ${sessionId}: ${error.message}`);
+            }
         }
     }
     shutdown() {
@@ -271,7 +509,9 @@ class MissionCoreSessions {
         this.handles.clear();
         this.activeTurns.clear();
         this.contexts.clear();
+        this.current.clear();
         this.tracked.clear();
+        this.owners.clear();
     }
 }
 exports.MissionCoreSessions = MissionCoreSessions;

package/server/dist/modules/missions/runtime/mission-run-notify.js

@@ -153,6 +153,8 @@ async function notifyMissionRunFailure(input) {
     catch (err) {
         console.error('[mission-run] card update failed:', err);
     }
+    if (input.cardOnly)
+        return { card, row: null, turn: 'skipped' };
     const rowPayload = {
         kind: 'run-failure', runId: input.runId, railIndex: input.railIndex, projectId: input.projectId,
         prDeliveryId: envelope.prDeliveryId, ticketIds: input.ticketIds,