specrails-desktop 2.60.0 → 2.62.0

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

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionPolicyFor = sessionPolicyFor;
+exports.createCoreSessionRunner = createCoreSessionRunner;
+const node_crypto_1 = require("node:crypto");
+const agent_sessions_1 = require("../../agent-sessions");
+/** 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 } };
+}
+function toNormalised(usage) {
+    if (!usage)
+        return undefined;
+    const result = {};
+    if (usage.inputTokens !== null)
+        result.tokens_in = usage.inputTokens;
+    if (usage.outputTokens !== null)
+        result.tokens_out = usage.outputTokens;
+    if (usage.cacheReadTokens !== null)
+        result.tokens_cache_read = usage.cacheReadTokens;
+    if (usage.cacheWriteTokens !== null)
+        result.tokens_cache_create = usage.cacheWriteTokens;
+    // Only billed cost is "native"; Core estimates are re-derived by Desktop's rate cards.
+    if (usage.costUsd !== null && !usage.costEstimated)
+        result.total_cost_usd = usage.costUsd;
+    if (usage.model)
+        result.model = usage.model;
+    return result;
+}
+/**
+ * Runs one mission user turn inside the conversation's resident Core session,
+ * honouring the existing live-session runner contract (Liskov substitution for
+ * nativeLiveSessionRunner / runAiCliInvocation): the mission manager's queue,
+ * steering, receipts, checkpoints and settlement work unchanged. The turn ends
+ * when Core completes THIS turn; the session, its sub-agents and the provider
+ * process stay alive in Core. Background activity is projected elsewhere.
+ */
+function createCoreSessionRunner(context) {
+    return async (hooks) => {
+        const { client, sessionId } = context;
+        const opts = hooks.buildOpts;
+        const events = [];
+        const emit = (event) => { events.push(event); hooks.onEvent?.(event); };
+        const inputId = `in_${(0, node_crypto_1.randomUUID)()}`;
+        let turnId = null;
+        let streamed = '';
+        let providerRef = null;
+        let initialAccepted = false;
+        let settled = false;
+        let lastSeq = 0;
+        const unsubscribers = [];
+        let resolveDone;
+        const done = new Promise((resolve) => { resolveDone = resolve; });
+        const finish = (code, extra = {}) => {
+            if (settled)
+                return;
+            settled = true;
+            context.onHandle?.(null);
+            for (const unsubscribe of unsubscribers.splice(0))
+                unsubscribe();
+            if (extra.error)
+                emit({ kind: 'error', message: extra.error });
+            const usage = toNormalised(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) => {
+            if (envelope.sessionId !== sessionId || envelope.seq <= lastSeq)
+                return;
+            lastSeq = envelope.seq;
+            const event = envelope.event;
+            switch (event.type) {
+                case 'session.provider-ref':
+                    providerRef = event.providerSessionRef;
+                    emit({ kind: 'session-started', sessionId: event.providerSessionRef });
+                    return;
+                case 'input.state':
+                    if (event.inputId !== inputId)
+                        return;
+                    if ((event.state === 'queued' || event.state === 'started') && !initialAccepted) {
+                        initialAccepted = true;
+                        hooks.onInitialInputAccepted?.();
+                    }
+                    if ((event.state === 'rejected' || event.state === 'interrupted') && !turnId)
+                        finish(1, { error: `The agent did not start this turn (${event.reason ?? event.state}).` });
+                    return;
+                case 'turn.started':
+                    if (event.inputIds.includes(inputId))
+                        turnId = event.turnId;
+                    return;
+                case 'turn.output':
+                    if (event.turnId !== turnId || event.channel !== 'text')
+                        return;
+                    streamed += event.delta;
+                    emit({ kind: 'text-delta', text: event.delta });
+                    return;
+                case 'turn.tool':
+                    if (event.turnId !== turnId)
+                        return;
+                    if (event.phase === 'started')
+                        emit({ kind: 'tool-use', name: event.name, toolUseId: event.toolUseId, inputPreview: event.input === undefined ? '' : JSON.stringify(event.input).slice(0, 1000) });
+                    else
+                        emit({ kind: 'tool-result', toolUseId: event.toolUseId, outputPreview: (event.output ?? '').slice(0, 4000), ...(event.isError ? { isError: true } : {}) });
+                    return;
+                case 'turn.completed': {
+                    if (event.turnId !== turnId)
+                        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) });
+                    if (event.status === 'completed')
+                        finish(0, { usage: event.usage });
+                    else if (event.status === 'stopped')
+                        finish(null, { usage: event.usage });
+                    else
+                        finish(1, { usage: event.usage, error: event.error ?? `The agent turn ${event.status}.` });
+                    return;
+                }
+                default:
+                    return;
+            }
+        };
+        /** Fill gaps from the journal so the turn's completion is never missed. */
+        let catchingUp = null;
+        const catchUp = async () => {
+            if (catchingUp)
+                return catchingUp;
+            catchingUp = (async () => {
+                for (;;) {
+                    const page = await client.request('session.events', { sessionId, afterSeq: lastSeq, limit: 500 });
+                    page.events.forEach(apply);
+                    if (!page.hasMore || settled)
+                        return;
+                }
+            })().finally(() => { catchingUp = null; });
+            return catchingUp;
+        };
+        unsubscribers.push(client.onEvent((envelope) => {
+            if (envelope.sessionId !== sessionId || settled)
+                return;
+            if (envelope.seq > lastSeq + 1 && lastSeq > 0)
+                void catchUp().catch(() => undefined);
+            else
+                apply(envelope);
+        }), client.onLagged((id) => { if (id === sessionId)
+            void catchUp().catch(() => undefined); }));
+        // Registered last: a closed client calls back synchronously.
+        unsubscribers.push(client.onClose((reason) => finish(1, { error: `The session host stopped: ${reason}` })));
+        try {
+            // Open or resume the conversation's Core session, then align its configuration.
+            const config = { model: opts?.model, ...(opts?.reasoning_effort ? { effort: String(opts.reasoning_effort) } : {}), ...(opts?.systemPrompt || context.systemPromptAddendum ? { systemPrompt: [opts?.systemPrompt, context.systemPromptAddendum].filter(Boolean).join('\n\n') } : {}), policy: sessionPolicyFor(context) };
+            let snapshot;
+            try {
+                snapshot = (await client.request('session.open', { resume: { sessionId } })).snapshot;
+                await client.request('session.update', { sessionId, ...config });
+            }
+            catch (error) {
+                if (!(0, agent_sessions_1.isSessionRequestError)(error, 'session_not_found'))
+                    throw error;
+                snapshot = (await client.request('session.open', {
+                    sessionId,
+                    driver: context.driver,
+                    cwd: hooks.cwd,
+                    ...config,
+                    ...(context.legacyProviderSessionRef ? { providerSessionRef: context.legacyProviderSessionRef } : {}),
+                    ...(context.metadata ? { metadata: context.metadata } : {}),
+                })).snapshot;
+            }
+            lastSeq = snapshot.lastSeq ?? 0;
+            context.onHandle?.({ interrupt: async () => { await client.request('session.interrupt', { sessionId }).catch(() => undefined); } });
+            hooks.onInputReady?.(createSteerSink(client, sessionId, () => !settled && turnId !== null));
+            await client.request('session.send', {
+                sessionId,
+                input: {
+                    inputId,
+                    text: opts?.prompt ?? '',
+                    delivery: 'queue',
+                    ...(opts?.imagePaths?.length ? { attachments: opts.imagePaths.map((path) => ({ kind: 'image', path })) } : {}),
+                },
+            });
+            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 } : {}) });
+        }
+        return done;
+    };
+}
+/** Native steering into the running turn of the resident session. */
+function createSteerSink(client, sessionId, turnOpen) {
+    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 })) } : {}) },
+            });
+            // Core journals the input before it reaches the provider: it will never be replayed.
+            onAccepted?.();
+            return true;
+        },
+    };
+}

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

@@ -0,0 +1,286 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissionCoreSessions = exports.GLOBAL_SCOPE = 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 core_session_runner_1 = require("./core-session-runner");
+const mission_session_projector_1 = require("./mission-session-projector");
+exports.GLOBAL_SCOPE = 'global';
+/**
+ * Missions' side of Core agent sessions: decides whether a turn runs in Core,
+ * keeps each mission's session tracked and projected, and owns the lifetime of
+ * the Specrails MCP capability a resident session presents (it lives until the
+ * next turn rotates it or Core retires the provider process — continuation
+ * turns after sub-agents finish must still reach Specrails tools).
+ */
+class MissionCoreSessions {
+    deps;
+    capabilities = new Map();
+    handles = new Map();
+    /** Missions with a turn being prepared or running: their capability belongs to that turn. */
+    activeTurns = new Set();
+    tracked = new Set();
+    /** Last turn context per mission: the policy its session runs with. */
+    contexts = new Map();
+    constructor(deps) {
+        this.deps = deps;
+    }
+    scopeOf(conversation) {
+        return (conversation.pinned_project_id && this.deps.projectKey(conversation.pinned_project_id)) || exports.GLOBAL_SCOPE;
+    }
+    handle(conversationId) {
+        return this.handles.get(conversationId);
+    }
+    /**
+     * The Core turn context for this mission turn, or null when the turn must use
+     * the legacy runners (sessions disabled, scope degraded, provider not served).
+     */
+    async prepareTurn(conversation, adapter, turn) {
+        const availability = await this.deps.availability();
+        if (!availability.enabled)
+            return null;
+        const scope = this.scopeOf(conversation);
+        if (!this.deps.registry.available(scope)) {
+            this.noticeFallback(conversation.id, scope);
+            return null;
+        }
+        let client;
+        try {
+            client = await this.deps.registry.acquire(scope);
+        }
+        catch (error) {
+            console.warn(`[agent-chat] Core sessions unavailable for ${scope}; using the legacy transport: ${error.message}`);
+            this.noticeFallback(conversation.id, scope);
+            return null;
+        }
+        const drivers = client.initialize?.drivers ?? [];
+        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);
+        // 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.
+        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);
+        // Parity with legacy missions: the adapter declares its permission level; user-scope MCP servers stay inherited.
+        const delegation = client.initialize?.capabilities?.delegation === 1;
+        const policy = {
+            subagents: this.subagentPolicy(conversation),
+            permissions: adapter.capabilities.sessionPermissions ?? 'workspace-write',
+            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 });
+        return {
+            sessionId: conversationId,
+            client,
+            driver: adapter.id,
+            policy,
+            mcpServers,
+            ...(policy.subagentRuntime?.mode === 'delegated' ? { systemPromptAddendum: delegationGuidance(policy.subagentRuntime) } : {}),
+            legacyProviderSessionRef: conversation.session_id ?? null,
+            metadata: { conversationId, surface: 'mission' },
+            onHandle: (handle) => {
+                if (handle) {
+                    this.handles.set(conversationId, handle);
+                    return;
+                }
+                this.handles.delete(conversationId);
+                this.activeTurns.delete(conversationId);
+            },
+        };
+    }
+    /**
+     * 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.
+     * Core applies it at the next idle point; with sub-agents running it reports
+     * 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))
+                continue;
+            const conversation = (0, agent_store_1.getAgentConversation)(this.deps.db, conversationId);
+            if (!conversation)
+                continue;
+            const subagents = this.subagentPolicy(conversation);
+            const subagentRuntime = 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);
+            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) });
+            }
+            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}`);
+            }
+        }
+    }
+    /** The turn runs on the legacy transport because its scope is degraded: say why, once per turn. */
+    noticeFallback(conversationId, scope) {
+        if (this.deps.registry.status(scope) !== 'degraded')
+            return;
+        const code = this.deps.registry.degradedCode(scope) === 'journal_locked' ? 'journal_locked' : 'host_degraded';
+        const detail = this.deps.registry.hosts().find((host) => host.scope === scope)?.detail ?? null;
+        this.deps.broadcast({ type: 'agent_session_notice', conversationId, level: 'warning', code, scope, message: detail ?? code, timestamp: new Date().toISOString() });
+    }
+    /** The hybrid runtime for this mission; says so in the mission when a choice cannot be honoured. */
+    subagentRuntime(conversation, provider, drivers, delegation) {
+        const choice = this.deps.subagentRuntime?.(conversation) ?? null;
+        const resolution = (0, agent_sessions_1.resolveSubagentRuntime)({ choice, missionProvider: provider, drivers, delegation });
+        if (resolution.unavailable && choice && this.subagentPolicy(conversation) === 'enabled') {
+            this.deps.broadcast({ type: 'agent_session_notice', conversationId: conversation.id, level: 'warning', code: `subagents.${resolution.unavailable}`, provider: choice.provider, message: `${choice.provider} sub-agents are not available here; the mission agent runs its own.`, timestamp: new Date().toISOString() });
+        }
+        return resolution.runtime;
+    }
+    subagentPolicy(conversation) {
+        return this.deps.subagentPolicy?.(conversation) ?? 'enabled';
+    }
+    /** True when the capability of this turn must outlive the turn (resident session). */
+    retains(conversationId, capability) {
+        return this.capabilities.get(conversationId) === capability;
+    }
+    /**
+     * Core retired the provider process: nothing can present the capability anymore.
+     * While a turn is prepared or running the capability is that turn's: a process
+     * retired by its own config change (model, effort, policy) is replaced at once
+     * and the new process presents the same capability, so it must stay valid.
+     */
+    releaseCapability(conversationId, options = {}) {
+        if (!options.force && this.activeTurns.has(conversationId))
+            return;
+        const capability = this.capabilities.get(conversationId);
+        if (!capability)
+            return;
+        this.capabilities.delete(conversationId);
+        this.deps.revokeCapability(capability);
+        (0, agent_mcp_config_1.removeAgentCapabilityFile)(conversationId);
+    }
+    /** True when this mission's sub-agents are launched by Core (another provider). */
+    delegates(conversationId) {
+        return this.contexts.get(conversationId)?.policy.subagentRuntime?.mode === 'delegated';
+    }
+    /** Launch a sub-agent on the configured provider (delegated runtime only). */
+    async delegate(conversation, params) {
+        this.assertDelegates(conversation.id);
+        const client = await this.deps.registry.acquire(this.scopeOf(conversation));
+        return client.request('session.delegate', { sessionId: conversation.id, ...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 client = await this.deps.registry.acquire(this.scopeOf(conversation));
+        return client.request('session.waitSubagents', { sessionId: conversation.id, ...(subagentIds ? { subagentIds } : {}), timeoutMs });
+    }
+    assertDelegates(conversationId) {
+        if (!this.tracked.has(conversationId) || !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.');
+        }
+    }
+    /** Stop sub-agents of a mission's Core session (all when `subagentIds` is omitted). */
+    async stopSubagents(conversation, subagentIds) {
+        if (!this.tracked.has(conversation.id))
+            return [];
+        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 ?? [];
+    }
+    /**
+     * Rebuild a mission's derived session rows (sub-agents, their output, resident
+     * state, cursor) by replaying Core's journal from the start. Turns already
+     * recorded as messages/invocations are recognized, not duplicated. The replay
+     * is silent; clients then receive the rebuilt state in one pass.
+     */
+    async rebuildProjection(conversation) {
+        const scope = this.scopeOf(conversation);
+        const conversationId = conversation.id;
+        if (!(0, agent_session_store_1.getSessionCursor)(this.deps.db, conversationId))
+            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;
+        }
+        const cursor = (0, agent_session_store_1.getSessionCursor)(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 });
+        for (const { conversationId: _owner, ...subagent } of subagents)
+            this.deps.broadcast({ type: 'agent_subagent', conversationId, subagent, timestamp });
+        return { lastSeq: cursor?.lastSeq ?? 0, subagents: subagents.length };
+    }
+    async track(scope, conversationId, broadcast) {
+        (0, agent_session_store_1.ensureSessionCursor)(this.deps.db, conversationId, conversationId, scope);
+        const projector = new mission_session_projector_1.MissionSessionProjector(conversationId, {
+            db: this.deps.db,
+            broadcast,
+            adapterFor: this.deps.adapterFor,
+            onProcessEnded: (id) => this.releaseCapability(id),
+        });
+        try {
+            await this.deps.registry.track(scope, conversationId, 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);
+    }
+    /** 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.releaseCapability(conversation.id, { force: true });
+        if (!this.tracked.delete(conversation.id))
+            return;
+        this.deps.registry.untrack(scope, conversation.id);
+        try {
+            const client = await this.deps.registry.acquire(scope);
+            await client.request('session.close', { sessionId: conversation.id, reason: 'conversation_deleted' });
+        }
+        catch (error) {
+            console.warn(`[agent-chat] could not close Core session ${conversation.id}: ${error.message}`);
+        }
+    }
+    shutdown() {
+        for (const conversationId of [...this.capabilities.keys()])
+            this.releaseCapability(conversationId, { force: true });
+        this.handles.clear();
+        this.activeTurns.clear();
+        this.contexts.clear();
+        this.tracked.clear();
+    }
+}
+exports.MissionCoreSessions = MissionCoreSessions;
+/** What the mission agent needs to know when Core launches its sub-agents. */
+function delegationGuidance(runtime) {
+    return [
+        '## Sub-agents',
+        `In this mission, sub-agents run on ${runtime.driver} (${runtime.model}) and are launched by Specrails, not by your own sub-agent tool (it is unavailable).`,
+        'To delegate a self-contained task, call `specrails_mission` with `action: "subagent_start"`, a short `description` and complete `instructions`; set `contextTurns` when it needs this conversation.',
+        'Start several to work in parallel. Collect results with `subagent_wait`; results you do not wait for arrive later as a message. Use `subagent_list` to see them and `subagent_stop` to stop them.',
+    ].join('\n');
+}

package/server/dist/modules/missions/runtime/mission-session-projector.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissionSessionProjector = void 0;
+const desktop_db_1 = require("../../../desktop-db");
+const result_event_1 = require("../../accounting/runtime/result-event");
+const agent_store_1 = require("../../agents/runtime/agent-store");
+const agent_session_store_1 = require("./agent-session-store");
+/**
+ * Missions' ProjectionSink: persists what happens in a mission's Core session
+ * OUTSIDE user turns (which the mission manager settles itself): turns Core or
+ * policy started after sub-agents finished, the sub-agent tree and its output,
+ * and the resident phase. Every apply writes its rows and the cursor in one
+ * transaction; WebSocket messages are sent only after the commit.
+ */
+class MissionSessionProjector {
+    conversationId;
+    deps;
+    background = new Map();
+    constructor(conversationId, deps) {
+        this.conversationId = conversationId;
+        this.deps = deps;
+    }
+    cursor(_sessionId) {
+        return (0, agent_session_store_1.getSessionCursor)(this.deps.db, this.conversationId)?.lastSeq ?? 0;
+    }
+    apply(_sessionId, seq, ops) {
+        const conversationId = this.conversationId;
+        const outbox = [];
+        const timestamp = new Date().toISOString();
+        let processEnded = false;
+        this.deps.db.transaction(() => {
+            for (const op of ops) {
+                switch (op.kind) {
+                    case 'resident.phase': {
+                        const before = (0, agent_session_store_1.getSessionCursor)(this.deps.db, conversationId);
+                        (0, agent_session_store_1.setResidentState)(this.deps.db, conversationId, op.phase, op.processAlive, op.liveSubagents);
+                        if (before?.processAlive && !op.processAlive)
+                            processEnded = true;
+                        outbox.push({ type: 'agent_resident_state', conversationId, phase: op.phase, liveSubagents: op.liveSubagents, processAlive: op.processAlive, timestamp });
+                        break;
+                    }
+                    case 'turn.opened':
+                        if (op.origin === 'user')
+                            break;
+                        this.background.set(op.turnId, { origin: op.origin, triggeredBy: op.triggeredBy, startedAt: op.at });
+                        outbox.push({ type: 'agent_turn_started', conversationId, turnId: op.turnId, origin: op.origin, triggeredBy: op.triggeredBy, timestamp });
+                        break;
+                    case 'turn.delta':
+                        if (op.channel === 'text' && this.background.has(op.turnId))
+                            outbox.push({ type: 'agent_stream', conversationId, turnId: op.turnId, delta: op.delta, timestamp });
+                        break;
+                    case 'turn.tool':
+                        if (!this.background.has(op.turnId))
+                            break;
+                        outbox.push(op.tool.phase === 'started'
+                            ? { type: 'agent_tool', conversationId, turnId: op.turnId, tool: op.tool.name, toolId: op.tool.toolUseId, timestamp }
+                            : { type: 'agent_tool_result', conversationId, turnId: op.turnId, toolId: op.tool.toolUseId, output: (op.tool.output ?? '').slice(0, 4000), ...(op.tool.isError ? { isError: true } : {}), timestamp });
+                        break;
+                    case 'turn.closed': {
+                        const turn = this.background.get(op.turnId);
+                        if (!turn)
+                            break;
+                        this.background.delete(op.turnId);
+                        const conversation = (0, agent_store_1.getAgentConversation)(this.deps.db, conversationId);
+                        if (!conversation)
+                            break;
+                        // A journal replay (projection rebuild) must not record a turn twice.
+                        if ((0, agent_session_store_1.isCoreTurnRecorded)(this.deps.db, conversationId, op.turnId)) {
+                            outbox.push({ type: 'agent_turn_done', conversationId, turnId: op.turnId, origin: turn.origin, status: op.status, triggeredBy: turn.triggeredBy, timestamp });
+                            break;
+                        }
+                        const message = op.text.trim()
+                            ? (0, agent_store_1.addAgentMessage)(this.deps.db, { conversationId, role: 'assistant', content: op.text, turnOrigin: turn.origin, coreTurnId: op.turnId })
+                            : null;
+                        this.recordInvocation(conversation, { id: (0, agent_session_store_1.coreTurnInvocationId)(conversation.id, op.turnId), providerId: conversation.provider, model: null, usage: op.usage, status: op.status, origin: turn.origin, startedAt: turn.startedAt, finishedAt: op.at });
+                        outbox.push({ type: 'agent_turn_done', conversationId, turnId: op.turnId, origin: turn.origin, status: op.status, triggeredBy: turn.triggeredBy, fullText: op.text, ...(message ? { messageId: message.id } : {}), timestamp });
+                        if (conversation.pinned_project_id)
+                            outbox.push({ type: 'spending.invalidated', projectId: conversation.pinned_project_id });
+                        break;
+                    }
+                    case 'subagent.upsert':
+                        (0, agent_session_store_1.upsertSubagent)(this.deps.db, conversationId, op.subagent);
+                        outbox.push({ type: 'agent_subagent', conversationId, subagent: op.subagent, timestamp });
+                        break;
+                    case 'subagent.output':
+                        if (!this.subagentKnown(op.subagentId))
+                            break;
+                        (0, agent_session_store_1.appendSubagentEvent)(this.deps.db, conversationId, op.subagentId, op.seq, op.channel, op.delta, op.tool);
+                        outbox.push({ type: 'agent_subagent_event', conversationId, subagentId: op.subagentId, seq: op.seq, channel: op.channel, ...(op.delta !== null ? { delta: op.delta } : {}), ...(op.tool ? { tool: op.tool } : {}), timestamp });
+                        break;
+                    case 'subagent.billed': {
+                        // A delegated sub-agent's own spend: recorded once (deterministic id), on top of the parent's.
+                        const conversation = (0, agent_store_1.getAgentConversation)(this.deps.db, conversationId);
+                        if (!conversation)
+                            break;
+                        const invocationId = `core-subagent:${conversationId}:${op.subagentId}:${op.seq}`;
+                        if (this.deps.db.prepare('SELECT 1 FROM agent_invocations WHERE id = ?').get(invocationId))
+                            break;
+                        const startedAt = this.subagentStartedAt(op.subagentId) ?? op.at;
+                        this.recordInvocation(conversation, { id: invocationId, providerId: op.driver, model: op.model, usage: op.usage, status: 'completed', origin: 'subagent', startedAt, finishedAt: op.at });
+                        if (conversation.pinned_project_id)
+                            outbox.push({ type: 'spending.invalidated', projectId: conversation.pinned_project_id });
+                        break;
+                    }
+                    case 'session.updated':
+                        outbox.push({ type: 'agent_session_updated', conversationId, outcome: op.outcome, changes: op.changes, timestamp });
+                        break;
+                    case 'notice':
+                        outbox.push({ type: 'agent_session_notice', conversationId, level: op.level, code: op.code, message: op.message, timestamp });
+                        break;
+                    case 'provider.ref':
+                    case 'input.state':
+                    case 'session.closed':
+                        // User inputs, provider refs and closure are settled by the mission manager.
+                        break;
+                }
+            }
+            (0, agent_session_store_1.advanceSessionCursor)(this.deps.db, conversationId, seq);
+        })();
+        for (const message of outbox)
+            this.deps.broadcast(message);
+        if (processEnded)
+            this.deps.onProcessEnded?.(conversationId);
+    }
+    subagentKnown(subagentId) {
+        return !!this.deps.db.prepare('SELECT 1 FROM agent_subagents WHERE conversation_id = ? AND subagent_id = ?').get(this.conversationId, subagentId);
+    }
+    subagentStartedAt(subagentId) {
+        const row = this.deps.db.prepare('SELECT started_at FROM agent_subagents WHERE conversation_id = ? AND subagent_id = ?').get(this.conversationId, subagentId);
+        return row?.started_at ?? null;
+    }
+    recordInvocation(conversation, invocation) {
+        let adapter;
+        try {
+            adapter = this.deps.adapterFor(invocation.providerId);
+        }
+        catch {
+            return;
+        }
+        const usage = invocation.usage;
+        const normalised = {
+            ...(usage.inputTokens !== null ? { tokens_in: usage.inputTokens } : {}),
+            ...(usage.outputTokens !== null ? { tokens_out: usage.outputTokens } : {}),
+            ...(usage.cacheReadTokens !== null ? { tokens_cache_read: usage.cacheReadTokens } : {}),
+            ...(usage.cacheWriteTokens !== null ? { tokens_cache_create: usage.cacheWriteTokens } : {}),
+            ...(usage.costUsd !== null && !usage.costEstimated ? { total_cost_usd: usage.costUsd } : {}),
+            ...(usage.model ?? invocation.model ? { model: usage.model ?? invocation.model } : {}),
+        };
+        const fallbackModel = invocation.model ?? (invocation.providerId === conversation.provider ? conversation.model : null);
+        const { result, estimated } = (0, result_event_1.finaliseNormalisedResult)(adapter, normalised, {
+            ...(fallbackModel ? { fallbackModel } : {}),
+            durationMs: Math.max(0, Date.parse(invocation.finishedAt) - Date.parse(invocation.startedAt)),
+        });
+        (0, desktop_db_1.recordAgentInvocation)(this.deps.db, {
+            id: invocation.id,
+            conversation_id: conversation.id,
+            project_id: conversation.pinned_project_id ?? null,
+            provider: adapter.id,
+            status: invocation.status === 'completed' ? 'success' : invocation.status === 'stopped' || invocation.status === 'interrupted' ? 'aborted' : 'failed',
+            started_at: invocation.startedAt,
+            finished_at: invocation.finishedAt,
+            total_cost_usd_estimated: estimated,
+            origin: invocation.origin,
+            ...result,
+        });
+    }
+}
+exports.MissionSessionProjector = MissionSessionProjector;