specrails-desktop 2.64.2 → 2.65.0

package/server/dist/modules/missions/runtime/agent-session-store.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSessionCursor = getSessionCursor;
+exports.listSessionCursors = listSessionCursors;
+exports.conversationSessionState = conversationSessionState;
 exports.listActiveSessionCursors = listActiveSessionCursors;
 exports.ensureSessionCursor = ensureSessionCursor;
 exports.advanceSessionCursor = advanceSessionCursor;
@@ -12,10 +14,12 @@ exports.upsertSubagent = upsertSubagent;
 exports.appendSubagentEvent = appendSubagentEvent;
 exports.listSubagents = listSubagents;
 exports.pageSubagentEvents = pageSubagentEvents;
-function getSessionCursor(db, conversationId) {
-    const row = db.prepare('SELECT * FROM agent_session_cursors WHERE conversation_id = ?').get(conversationId);
-    if (!row)
-        return null;
+exports.missionCoreSessionId = missionCoreSessionId;
+exports.isMissionCoreSessionId = isMissionCoreSessionId;
+exports.getMissionCoreSession = getMissionCoreSession;
+exports.setMissionCoreSessionProvider = setMissionCoreSessionProvider;
+exports.renewMissionCoreSession = renewMissionCoreSession;
+function mapCursor(row) {
     return {
         conversationId: String(row.conversation_id),
         coreSessionId: String(row.core_session_id),
@@ -26,45 +30,74 @@ function getSessionCursor(db, conversationId) {
         liveSubagents: Number(row.live_subagents),
     };
 }
-/** Missions whose Core session still has work in flight (non-idle or live sub-agents). */
+/** The cursor of one Core session of a conversation (default: the mission's own). */
+function getSessionCursor(db, conversationId, coreSessionId = conversationId) {
+    const row = db.prepare('SELECT * FROM agent_session_cursors WHERE conversation_id = ? AND core_session_id = ?').get(conversationId, coreSessionId);
+    return row ? mapCursor(row) : null;
+}
+/** Every Core session cursor of a conversation (mission first, then Flow sessions). */
+function listSessionCursors(db, conversationId) {
+    return db.prepare('SELECT * FROM agent_session_cursors WHERE conversation_id = ? ORDER BY (core_session_id = conversation_id) DESC, core_session_id').all(conversationId).map(mapCursor);
+}
+const PHASE_RANK = { idle: 0, background: 1, turn: 2 };
+/**
+ * One conversation's resident state across its Core sessions: the busiest
+ * phase, any live process and the live sub-agents of all of them (a Flow's
+ * sub-agents count as the mission's while it is in Flow). Null when none ran.
+ */
+function conversationSessionState(db, conversationId) {
+    const cursors = listSessionCursors(db, conversationId);
+    if (cursors.length === 0)
+        return null;
+    return {
+        residentPhase: cursors.reduce((phase, cursor) => PHASE_RANK[cursor.residentPhase] > PHASE_RANK[phase] ? cursor.residentPhase : phase, 'idle'),
+        processAlive: cursors.some((cursor) => cursor.processAlive),
+        liveSubagents: cursors.reduce((sum, cursor) => sum + cursor.liveSubagents, 0),
+    };
+}
+/** Conversations with a Core session that still has work in flight (non-idle or live sub-agents). */
 function listActiveSessionCursors(db) {
-    const rows = db.prepare("SELECT conversation_id FROM agent_session_cursors WHERE resident_phase != 'idle' OR live_subagents > 0").all();
-    return rows.map((row) => getSessionCursor(db, row.conversation_id)).filter((row) => row !== null);
+    const rows = db.prepare("SELECT DISTINCT conversation_id FROM agent_session_cursors WHERE resident_phase != 'idle' OR live_subagents > 0").all();
+    return rows.flatMap((row) => {
+        const state = conversationSessionState(db, row.conversation_id);
+        return state ? [{ conversationId: row.conversation_id, ...state }] : [];
+    });
 }
 function ensureSessionCursor(db, conversationId, coreSessionId, scope) {
     db.prepare(`INSERT INTO agent_session_cursors (conversation_id, core_session_id, scope) VALUES (?, ?, ?)
-    ON CONFLICT(conversation_id) DO UPDATE SET core_session_id = excluded.core_session_id, scope = excluded.scope`).run(conversationId, coreSessionId, scope);
+    ON CONFLICT(conversation_id, core_session_id) DO UPDATE SET scope = excluded.scope`).run(conversationId, coreSessionId, scope);
 }
-function advanceSessionCursor(db, conversationId, seq) {
-    db.prepare("UPDATE agent_session_cursors SET last_seq = ?, updated_at = datetime('now') WHERE conversation_id = ?").run(seq, conversationId);
+function advanceSessionCursor(db, conversationId, seq, coreSessionId = conversationId) {
+    db.prepare("UPDATE agent_session_cursors SET last_seq = ?, updated_at = datetime('now') WHERE conversation_id = ? AND core_session_id = ?").run(seq, conversationId, coreSessionId);
 }
-function setResidentState(db, conversationId, phase, processAlive, liveSubagents) {
-    db.prepare("UPDATE agent_session_cursors SET resident_phase = ?, process_alive = ?, live_subagents = ?, updated_at = datetime('now') WHERE conversation_id = ?")
-        .run(phase, processAlive ? 1 : 0, liveSubagents, conversationId);
+function setResidentState(db, conversationId, phase, processAlive, liveSubagents, coreSessionId = conversationId) {
+    db.prepare("UPDATE agent_session_cursors SET resident_phase = ?, process_alive = ?, live_subagents = ?, updated_at = datetime('now') WHERE conversation_id = ? AND core_session_id = ?")
+        .run(phase, processAlive ? 1 : 0, liveSubagents, conversationId, coreSessionId);
 }
 /**
  * Drop a mission's derived session rows so the journal can be replayed into
  * them. Messages and invocations stay: replay recognizes turns it already
  * recorded (see `coreTurnInvocationId`).
  */
-function resetSessionProjection(db, conversationId) {
+function resetSessionProjection(db, conversationId, coreSessionId = conversationId) {
     db.transaction(() => {
-        db.prepare('DELETE FROM agent_subagent_events WHERE conversation_id = ?').run(conversationId);
-        db.prepare('DELETE FROM agent_subagents WHERE conversation_id = ?').run(conversationId);
-        db.prepare("UPDATE agent_session_cursors SET last_seq = 0, resident_phase = 'idle', process_alive = 0, live_subagents = 0, updated_at = datetime('now') WHERE conversation_id = ?").run(conversationId);
+        db.prepare('DELETE FROM agent_subagent_events WHERE conversation_id = ? AND subagent_id IN (SELECT subagent_id FROM agent_subagents WHERE conversation_id = ? AND core_session_id = ?)').run(conversationId, conversationId, coreSessionId);
+        db.prepare('DELETE FROM agent_subagents WHERE conversation_id = ? AND core_session_id = ?').run(conversationId, coreSessionId);
+        db.prepare("UPDATE agent_session_cursors SET last_seq = 0, resident_phase = 'idle', process_alive = 0, live_subagents = 0, updated_at = datetime('now') WHERE conversation_id = ? AND core_session_id = ?").run(conversationId, coreSessionId);
     })();
 }
-/** Deterministic invocation id of a Core turn: recording it twice is a no-op. */
-function coreTurnInvocationId(conversationId, turnId) {
-    return `core-turn:${conversationId}:${turnId}`;
+/** Deterministic invocation id of a Core turn: recording it twice is a no-op.
+ *  A turn of another session of the conversation (Flow) carries its session id. */
+function coreTurnInvocationId(conversationId, turnId, coreSessionId = conversationId) {
+    return coreSessionId === conversationId ? `core-turn:${conversationId}:${turnId}` : `core-turn:${conversationId}:${coreSessionId}:${turnId}`;
 }
-function isCoreTurnRecorded(db, conversationId, turnId) {
-    return !!db.prepare('SELECT 1 FROM agent_invocations WHERE id = ?').get(coreTurnInvocationId(conversationId, turnId))
+function isCoreTurnRecorded(db, conversationId, turnId, coreSessionId = conversationId) {
+    return !!db.prepare('SELECT 1 FROM agent_invocations WHERE id = ?').get(coreTurnInvocationId(conversationId, turnId, coreSessionId))
         || !!db.prepare('SELECT 1 FROM agent_messages WHERE conversation_id = ? AND core_turn_id = ?').get(conversationId, turnId);
 }
-function upsertSubagent(db, conversationId, view) {
-    db.prepare(`INSERT INTO agent_subagents (conversation_id, subagent_id, parent_id, kind, agent_type, description, phase, reason, restarts, launched_turn_id, started_at, ended_at, usage_json, tool_uses, duration_ms, result_summary, delegated_driver, delegated_model, updated_at)
-    VALUES (@conversationId, @subagentId, @parentId, @kind, @agentType, @description, @phase, @reason, @restarts, @launchedInTurnId, @startedAt, @endedAt, @usage, @toolUses, @durationMs, @resultSummary, @delegatedDriver, @delegatedModel, datetime('now'))
+function upsertSubagent(db, conversationId, view, coreSessionId = conversationId) {
+    db.prepare(`INSERT INTO agent_subagents (conversation_id, subagent_id, parent_id, kind, agent_type, description, phase, reason, restarts, launched_turn_id, started_at, ended_at, usage_json, tool_uses, duration_ms, result_summary, delegated_driver, delegated_model, core_session_id, updated_at)
+    VALUES (@conversationId, @subagentId, @parentId, @kind, @agentType, @description, @phase, @reason, @restarts, @launchedInTurnId, @startedAt, @endedAt, @usage, @toolUses, @durationMs, @resultSummary, @delegatedDriver, @delegatedModel, @coreSessionId, datetime('now'))
     ON CONFLICT(conversation_id, subagent_id) DO UPDATE SET
       phase = excluded.phase, reason = excluded.reason, restarts = excluded.restarts, ended_at = excluded.ended_at,
       usage_json = excluded.usage_json, tool_uses = excluded.tool_uses, duration_ms = excluded.duration_ms,
@@ -87,6 +120,7 @@ function upsertSubagent(db, conversationId, view) {
         resultSummary: view.resultSummary,
         delegatedDriver: view.delegated?.driver ?? null,
         delegatedModel: view.delegated?.model ?? null,
+        coreSessionId,
     });
 }
 function appendSubagentEvent(db, conversationId, subagentId, seq, channel, delta, tool) {
@@ -96,6 +130,7 @@ function appendSubagentEvent(db, conversationId, subagentId, seq, channel, delta
 function mapSubagent(row) {
     return {
         conversationId: String(row.conversation_id),
+        coreSessionId: String(row.core_session_id ?? row.conversation_id),
         subagentId: String(row.subagent_id),
         parentId: row.parent_id ?? null,
         kind: row.kind,
@@ -114,8 +149,12 @@ function mapSubagent(row) {
         delegated: row.delegated_driver ? { driver: String(row.delegated_driver), model: String(row.delegated_model ?? '') } : null,
     };
 }
-function listSubagents(db, conversationId) {
-    return db.prepare('SELECT * FROM agent_subagents WHERE conversation_id = ? ORDER BY started_at, rowid').all(conversationId).map(mapSubagent);
+/** Sub-agents of a conversation: all its Core sessions, or only `coreSessionId`'s. */
+function listSubagents(db, conversationId, coreSessionId) {
+    const rows = coreSessionId === undefined
+        ? db.prepare('SELECT * FROM agent_subagents WHERE conversation_id = ? ORDER BY started_at, rowid').all(conversationId)
+        : db.prepare('SELECT * FROM agent_subagents WHERE conversation_id = ? AND core_session_id = ? ORDER BY started_at, rowid').all(conversationId, coreSessionId);
+    return rows.map(mapSubagent);
 }
 function pageSubagentEvents(db, conversationId, subagentId, afterSeq, limit) {
     const rows = db.prepare('SELECT seq, channel, delta, tool_json, created_at FROM agent_subagent_events WHERE conversation_id = ? AND subagent_id = ? AND seq > ? ORDER BY seq LIMIT ?')
@@ -131,3 +170,25 @@ function pageSubagentEvents(db, conversationId, subagentId, afterSeq, limit) {
         hasMore: rows.length > limit,
     };
 }
+function missionCoreSessionId(conversationId, generation) {
+    return generation > 0 ? `${conversationId}:g${generation}` : conversationId;
+}
+/** True for any generation of the mission's own session (never a Flow's). */
+function isMissionCoreSessionId(conversationId, sessionId) {
+    return sessionId === conversationId || new RegExp(`^${conversationId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}:g\\d+$`).test(sessionId);
+}
+function getMissionCoreSession(db, conversationId) {
+    const row = db.prepare('SELECT generation, provider FROM agent_core_sessions WHERE conversation_id = ?').get(conversationId);
+    return row ? { generation: row.generation, provider: row.provider } : { generation: 0, provider: null };
+}
+/** Record the driver of the current generation (first turn of a session). */
+function setMissionCoreSessionProvider(db, conversationId, provider) {
+    db.prepare(`INSERT INTO agent_core_sessions (conversation_id, generation, provider) VALUES (?, 0, ?)
+    ON CONFLICT(conversation_id) DO UPDATE SET provider = excluded.provider, updated_at = datetime('now')`).run(conversationId, provider);
+}
+/** Move the mission to its next session generation, opened with `provider`. Returns the new row. */
+function renewMissionCoreSession(db, conversationId, provider) {
+    db.prepare(`INSERT INTO agent_core_sessions (conversation_id, generation, provider) VALUES (?, 1, ?)
+    ON CONFLICT(conversation_id) DO UPDATE SET generation = generation + 1, provider = excluded.provider, updated_at = datetime('now')`).run(conversationId, provider);
+    return getMissionCoreSession(db, conversationId);
+}

package/server/dist/modules/missions/runtime/core-session-runner.js

@@ -1,13 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionDriverMismatchError = void 0;
 exports.sessionPolicyFor = sessionPolicyFor;
+exports.addUsage = addUsage;
 exports.createCoreSessionRunner = createCoreSessionRunner;
 const node_crypto_1 = require("node:crypto");
 const agent_sessions_1 = require("../../agent-sessions");
+/** The Core session cannot take this turn: opened by another driver, or closed. Nothing was sent. */
+class SessionDriverMismatchError extends Error {
+    code;
+    constructor(sessionId, actual, expected) {
+        super(actual ? `Core session ${sessionId} runs on ${actual}, not ${expected}` : `Session ${sessionId} is closed`);
+        this.name = 'SessionDriverMismatchError';
+        this.code = actual ? 'session_driver_mismatch' : 'session_closed';
+    }
+}
+exports.SessionDriverMismatchError = SessionDriverMismatchError;
 /** The complete session policy sent to Core (`session.update` replaces policy as a whole). */
 function sessionPolicyFor(context) {
     return { ...context.policy, mcp: { servers: context.mcpServers, inheritUserScope: context.policy.mcp?.inheritUserScope ?? false } };
 }
+/** Sum per-turn usage deltas; null stays null only when every side is unknown. */
+function addUsage(a, b) {
+    if (!b)
+        return a;
+    if (!a)
+        return b;
+    const sum = (x, y) => (x === null && y === null ? null : (x ?? 0) + (y ?? 0));
+    return {
+        inputTokens: sum(a.inputTokens, b.inputTokens),
+        outputTokens: sum(a.outputTokens, b.outputTokens),
+        cacheReadTokens: sum(a.cacheReadTokens, b.cacheReadTokens),
+        cacheWriteTokens: sum(a.cacheWriteTokens, b.cacheWriteTokens),
+        totalTokens: sum(a.totalTokens, b.totalTokens),
+        costUsd: sum(a.costUsd, b.costUsd),
+        // One estimated part makes the total an estimate.
+        costEstimated: a.costEstimated || b.costEstimated,
+        model: b.model ?? a.model,
+    };
+}
 function toNormalised(usage) {
     if (!usage)
         return undefined;
@@ -48,6 +79,11 @@ function createCoreSessionRunner(context) {
         let initialAccepted = false;
         let settled = false;
         let lastSeq = 0;
+        // Interrupt delivery: inputs sent to cut the running turn, and whether the
+        // cut turn ended so the runner now follows the correction's turn.
+        const pendingInterrupts = new Set();
+        let awaitingCorrection = false;
+        let carriedUsage = null;
         const unsubscribers = [];
         let resolveDone;
         const done = new Promise((resolve) => { resolveDone = resolve; });
@@ -60,7 +96,7 @@ function createCoreSessionRunner(context) {
                 unsubscribe();
             if (extra.error)
                 emit({ kind: 'error', message: extra.error });
-            const usage = toNormalised(extra.usage);
+            const usage = toNormalised(addUsage(carriedUsage, extra.usage));
             resolveDone({ code, timedOut: false, spawnFailed: false, events, lastResultEvent: null, sessionId: providerRef ?? opts?.sessionId ?? null, stderrTail: '', child: null, ...(usage ? { usage } : {}), ...(turnId ? { coreTurnId: turnId } : {}), ...(extra.errorCode ? { errorCode: extra.errorCode } : {}) });
         };
         const apply = (envelope) => {
@@ -74,6 +110,14 @@ function createCoreSessionRunner(context) {
                     emit({ kind: 'session-started', sessionId: event.providerSessionRef });
                     return;
                 case 'input.state':
+                    if (pendingInterrupts.has(event.inputId)) {
+                        if (event.state !== 'rejected' && event.state !== 'interrupted')
+                            return;
+                        pendingInterrupts.delete(event.inputId);
+                        if (awaitingCorrection && pendingInterrupts.size === 0)
+                            finish(1, { error: `The agent did not take the correction (${event.reason ?? event.state}).` });
+                        return;
+                    }
                     if (event.inputId !== inputId)
                         return;
                     if ((event.state === 'queued' || event.state === 'started') && !initialAccepted) {
@@ -86,6 +130,14 @@ function createCoreSessionRunner(context) {
                 case 'turn.started':
                     if (event.inputIds.includes(inputId))
                         turnId = event.turnId;
+                    else if (awaitingCorrection && event.inputIds.some((id) => pendingInterrupts.has(id))) {
+                        // Follow the correction's turn: its output continues this user turn.
+                        for (const id of event.inputIds)
+                            pendingInterrupts.delete(id);
+                        awaitingCorrection = false;
+                        turnId = event.turnId;
+                        streamed = '';
+                    }
                     return;
                 case 'turn.output':
                     if (event.turnId !== turnId || event.channel !== 'text')
@@ -104,6 +156,15 @@ function createCoreSessionRunner(context) {
                 case 'turn.completed': {
                     if (event.turnId !== turnId)
                         return;
+                    if (pendingInterrupts.size > 0) {
+                        // Cut by (or finished before) a correction: keep its usage and wait for the correction's turn.
+                        if (event.status === 'completed' && event.text.startsWith(streamed) && event.text.length > streamed.length)
+                            emit({ kind: 'text-delta', text: event.text.slice(streamed.length) });
+                        carriedUsage = addUsage(carriedUsage, event.usage);
+                        turnId = null;
+                        awaitingCorrection = true;
+                        return;
+                    }
                     // Core's text is authoritative; emit whatever live deltas missed (e.g. after a lag).
                     if (event.text.startsWith(streamed) && event.text.length > streamed.length)
                         emit({ kind: 'text-delta', text: event.text.slice(streamed.length) });
@@ -151,9 +212,18 @@ function createCoreSessionRunner(context) {
             let snapshot;
             try {
                 snapshot = (await client.request('session.open', { resume: { sessionId } })).snapshot;
+                // A Core session keeps the driver it was opened with: never send this
+                // turn (and this provider's model) to another provider's session.
+                if (snapshot?.driver && snapshot.driver !== context.driver) {
+                    throw new SessionDriverMismatchError(sessionId, snapshot.driver, context.driver);
+                }
+                if (snapshot?.status === 'closed')
+                    throw new SessionDriverMismatchError(sessionId, null, context.driver);
                 await client.request('session.update', { sessionId, ...config });
             }
             catch (error) {
+                if (error instanceof SessionDriverMismatchError)
+                    throw error;
                 if (!(0, agent_sessions_1.isSessionRequestError)(error, 'session_not_found'))
                     throw error;
                 snapshot = (await client.request('session.open', {
@@ -167,7 +237,7 @@ function createCoreSessionRunner(context) {
             }
             lastSeq = snapshot.lastSeq ?? 0;
             context.onHandle?.({ interrupt: async () => { await client.request('session.interrupt', { sessionId }).catch(() => undefined); } });
-            hooks.onInputReady?.(createSteerSink(client, sessionId, () => !settled && turnId !== null));
+            hooks.onInputReady?.(createSteerSink(client, sessionId, () => !settled && (turnId !== null || awaitingCorrection), context.inputDelivery ?? 'steer', pendingInterrupts));
             await client.request('session.send', {
                 sessionId,
                 input: {
@@ -180,22 +250,32 @@ function createCoreSessionRunner(context) {
             await catchUp();
         }
         catch (error) {
-            finish(1, { error: error instanceof Error ? error.message : String(error), ...((0, agent_sessions_1.isSessionRequestError)(error) && error.code ? { errorCode: error.code } : {}) });
+            finish(1, { error: error instanceof Error ? error.message : String(error), ...(error instanceof SessionDriverMismatchError ? { errorCode: error.code } : (0, agent_sessions_1.isSessionRequestError)(error) && error.code ? { errorCode: error.code } : {}) });
         }
         return done;
     };
 }
-/** Native steering into the running turn of the resident session. */
-function createSteerSink(client, sessionId, turnOpen) {
+/** Native steering (or Flow interrupt) into the running turn of the resident session. */
+function createSteerSink(client, sessionId, turnOpen, delivery, pendingInterrupts) {
     return {
         acceptedReceipt: 'received',
         async send(input, onAccepted) {
             if (!turnOpen())
                 return false;
-            await client.request('session.send', {
-                sessionId,
-                input: { inputId: input.id, text: input.text, delivery: 'steer', ...(input.imagePaths?.length ? { attachments: input.imagePaths.map((path) => ({ kind: 'image', path })) } : {}) },
-            });
+            // Registered before the request: Core may cut the turn before it answers.
+            // Never `session.interrupt` first — the delivery itself cuts the turn.
+            if (delivery === 'interrupt')
+                pendingInterrupts.add(input.id);
+            try {
+                await client.request('session.send', {
+                    sessionId,
+                    input: { inputId: input.id, text: input.text, delivery, ...(input.imagePaths?.length ? { attachments: input.imagePaths.map((path) => ({ kind: 'image', path })) } : {}) },
+                });
+            }
+            catch (error) {
+                pendingInterrupts.delete(input.id);
+                throw error;
+            }
             // Core journals the input before it reaches the provider: it will never be replayed.
             onAccepted?.();
             return true;

package/server/dist/modules/missions/runtime/flow-turn-context.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FLOW_SESSION_BOUNDARY = void 0;
+/**
+ * The Flow session boundary, the same one rail write roles run with: no
+ * interactive approvals (Claude `--dangerously-skip-permissions`, Codex
+ * `danger-full-access`) so the agent can run the typecheck, tests and
+ * installs a headless session cannot get approved, default tools. Containment
+ * is the same as a rail's, not an OS sandbox: cwd = the Flow worktree, the
+ * persona rule never to touch anything outside it, and the worktree's own
+ * branch (docs/internals/flow-mode.md#permissions). Normal mission turns keep
+ * their read-only boundary (missionSessionBoundary).
+ */
+exports.FLOW_SESSION_BOUNDARY = Object.freeze({
+    permissions: 'bypass',
+    tools: Object.freeze({ mode: 'default' }),
+});