specrails-desktop 2.60.0 → 2.62.0

package/server/dist/modules/agent-sessions/adapters/rpc-client.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StdioSessionHostClient = exports.MAX_RESPONSE_BYTES = void 0;
+const node_string_decoder_1 = require("node:string_decoder");
+const errors_1 = require("../domain/errors");
+/** Longest accepted response line from the host. */
+exports.MAX_RESPONSE_BYTES = 16 * 1024 * 1024;
+/**
+ * JSON-RPC 2.0 client for the Core session host over NDJSON stdio.
+ * Requests time out; every pending request is rejected when the connection
+ * ends; notifications fan out to subscribers (session.event, session.lagged,
+ * host.leaseLost).
+ */
+class StdioSessionHostClient {
+    transport;
+    options;
+    nextId = 1;
+    pending = new Map();
+    eventListeners = new Set();
+    lagListeners = new Set();
+    closeListeners = new Set();
+    closedReason = null;
+    closedCode = null;
+    constructor(transport, options = {}) {
+        this.transport = transport;
+        this.options = options;
+        const decoder = new node_string_decoder_1.StringDecoder('utf8');
+        let buffer = '';
+        transport.stdout.on('data', (chunk) => {
+            buffer += typeof chunk === 'string' ? chunk : decoder.write(chunk);
+            for (;;) {
+                const newline = buffer.indexOf('\n');
+                if (newline < 0)
+                    break;
+                const line = buffer.slice(0, newline).trim();
+                buffer = buffer.slice(newline + 1);
+                if (line)
+                    this.receive(line);
+            }
+            if (Buffer.byteLength(buffer) > exports.MAX_RESPONSE_BYTES)
+                this.markClosed('Session host sent an oversized frame');
+        });
+        transport.stdout.on('end', () => this.markClosed('Session host closed its output'));
+        transport.stdin.on('error', () => this.markClosed('Session host input closed'));
+    }
+    get closed() {
+        return this.closedReason !== null;
+    }
+    request(method, params = {}) {
+        if (this.closedReason)
+            return Promise.reject(new errors_1.SessionRequestError(this.closedReason, this.closedCode ? { code: this.closedCode, retryable: false } : { code: 'host_unavailable', retryable: true }));
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new errors_1.SessionRequestError(`Session host did not answer ${method} in time`, { code: 'host_timeout', retryable: true }));
+            }, this.options.timeoutMs ?? 60_000);
+            timer.unref?.();
+            this.pending.set(id, { method, resolve: resolve, reject, timer });
+            this.transport.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id, method, params })}\n`);
+        });
+    }
+    onEvent(listener) {
+        this.eventListeners.add(listener);
+        return () => { this.eventListeners.delete(listener); };
+    }
+    onLagged(listener) {
+        this.lagListeners.add(listener);
+        return () => { this.lagListeners.delete(listener); };
+    }
+    onClose(listener) {
+        if (this.closedReason) {
+            listener(this.closedReason, this.closedCode ?? undefined);
+            return () => { };
+        }
+        this.closeListeners.add(listener);
+        return () => { this.closeListeners.delete(listener); };
+    }
+    async close() {
+        if (this.closedReason)
+            return;
+        await this.options.onClose?.();
+        this.markClosed('Session host closed');
+    }
+    /** The process ended (called by the launcher). A known `code` (e.g. `journal_locked`) travels to pending requests and close listeners. */
+    markClosed(reason, code) {
+        if (this.closedReason)
+            return;
+        this.closedReason = reason;
+        this.closedCode = code ?? null;
+        for (const [id, request] of this.pending) {
+            clearTimeout(request.timer);
+            request.reject(new errors_1.SessionRequestError(reason, code ? { code, retryable: false } : { code: 'host_unavailable', retryable: true }));
+            this.pending.delete(id);
+        }
+        for (const listener of this.closeListeners)
+            listener(reason, code);
+        this.closeListeners.clear();
+    }
+    receive(line) {
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (typeof message.method === 'string') {
+            const params = (message.params ?? {});
+            if (message.method === 'session.event') {
+                const envelope = { sessionId: String(params.sessionId), seq: Number(params.seq), event: params.event };
+                for (const listener of this.eventListeners)
+                    listener(envelope);
+            }
+            else if (message.method === 'session.lagged') {
+                for (const listener of this.lagListeners)
+                    listener(String(params.sessionId), Number(params.deliveredSeq));
+            }
+            else if (message.method === 'host.leaseLost') {
+                this.markClosed('Another session host took over this scope', 'journal_locked');
+            }
+            return;
+        }
+        // The host could not start and printed its fatal result (e.g. another host owns the journal).
+        if (message.type === 'runtime-result' && message.status === 'failed') {
+            const error = message.error;
+            const detail = typeof error === 'object' && error !== null ? error : { message: error };
+            this.markClosed(typeof detail.message === 'string' ? detail.message : 'The session host failed to start', typeof detail.code === 'string' ? detail.code : undefined);
+            return;
+        }
+        if (typeof message.id !== 'number')
+            return;
+        const request = this.pending.get(message.id);
+        if (!request)
+            return;
+        this.pending.delete(message.id);
+        clearTimeout(request.timer);
+        if (message.error && typeof message.error === 'object') {
+            const error = message.error;
+            request.reject(new errors_1.SessionRequestError(error.message ?? `Session host rejected ${request.method}`, error.data ?? { code: 'internal', retryable: false }, error.code));
+        }
+        else {
+            request.resolve(message.result ?? {});
+        }
+    }
+}
+exports.StdioSessionHostClient = StdioSessionHostClient;

package/server/dist/modules/agent-sessions/application/session-event-pump.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionEventPump = void 0;
+const projection_1 = require("../domain/projection");
+const PAGE = 500;
+/**
+ * Applies one Core session's committed events to a surface sink exactly once
+ * and in order. Duplicates are ignored, gaps are filled from the host's
+ * journal (`session.events`), and `attach` rebuilds the in-memory projection
+ * by replaying up to the sink's cursor without re-applying anything.
+ */
+class SessionEventPump {
+    sessionId;
+    client;
+    sink;
+    listener;
+    state;
+    chain = Promise.resolve();
+    detached = false;
+    constructor(sessionId, client, sink, listener = () => { }) {
+        this.sessionId = sessionId;
+        this.client = client;
+        this.sink = sink;
+        this.listener = listener;
+        this.state = (0, projection_1.initialProjection)(sessionId);
+    }
+    get projection() {
+        return this.state;
+    }
+    /** Rebuild state up to the sink cursor, then apply everything after it. */
+    attach() {
+        return this.enqueue(async () => {
+            const cursor = this.sink.cursor(this.sessionId);
+            this.state = (0, projection_1.initialProjection)(this.sessionId);
+            await this.fetchFrom(0, cursor);
+            await this.fetchFrom(this.state.lastSeq);
+        });
+    }
+    /** A live notification. */
+    push(envelope) {
+        if (envelope.sessionId !== this.sessionId)
+            return Promise.resolve();
+        return this.enqueue(async () => {
+            const result = (0, projection_1.reduceEnvelope)(this.state, envelope);
+            if (result.status === 'duplicate')
+                return;
+            if (result.status === 'gap') {
+                await this.fetchFrom(this.state.lastSeq);
+                return;
+            }
+            this.commit(envelope.seq, result.state, result.ops);
+        });
+    }
+    /** The host dropped queued notifications; catch up from the journal. */
+    catchUp() {
+        return this.enqueue(() => this.fetchFrom(this.state.lastSeq));
+    }
+    detach() {
+        this.detached = true;
+    }
+    /** Page through the journal; events up to `rebuildUntil` only rebuild state. */
+    async fetchFrom(afterSeq, rebuildUntil = 0) {
+        let cursor = afterSeq;
+        for (;;) {
+            if (this.detached)
+                return;
+            if (rebuildUntil > 0 && cursor >= rebuildUntil)
+                return;
+            const page = await this.client.request('session.events', { sessionId: this.sessionId, afterSeq: cursor, limit: PAGE });
+            for (const envelope of page.events) {
+                const result = (0, projection_1.reduceEnvelope)(this.state, envelope);
+                if (result.status !== 'applied')
+                    continue;
+                if (envelope.seq <= rebuildUntil)
+                    this.state = result.state;
+                else
+                    this.commit(envelope.seq, result.state, result.ops);
+                cursor = envelope.seq;
+                if (rebuildUntil > 0 && cursor >= rebuildUntil)
+                    return;
+            }
+            if (!page.hasMore || page.events.length === 0)
+                return;
+        }
+    }
+    commit(seq, state, ops) {
+        // The sink owns the transaction (ops + cursor); state advances only after it committed.
+        this.sink.apply(this.sessionId, seq, ops);
+        this.state = state;
+        if (ops.length > 0)
+            this.listener(this.sessionId, ops, state);
+    }
+    enqueue(task) {
+        const run = this.chain.then(task);
+        this.chain = run.catch(() => undefined);
+        return run;
+    }
+}
+exports.SessionEventPump = SessionEventPump;

package/server/dist/modules/agent-sessions/domain/availability.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CORE_SESSIONS_FLAG = void 0;
+exports.parseCoreSessionsFlag = parseCoreSessionsFlag;
+exports.resolveCoreSessionsAvailability = resolveCoreSessionsAvailability;
+exports.DEFAULT_CORE_SESSIONS_FLAG = 'auto';
+function parseCoreSessionsFlag(raw) {
+    const value = raw?.trim().toLowerCase();
+    if (value === 'on' || value === '1' || value === 'true')
+        return 'on';
+    if (value === 'auto')
+        return 'auto';
+    if (value === 'off' || value === '0' || value === 'false')
+        return 'off';
+    return exports.DEFAULT_CORE_SESSIONS_FLAG;
+}
+function resolveCoreSessionsAvailability(flag, capabilities, contractCompatible = true) {
+    if (flag === 'off')
+        return { enabled: false, flag, reason: 'Core sessions are disabled (SPECRAILS_CORE_SESSIONS=off)' };
+    if (capabilities?.sessions !== 1)
+        return { enabled: false, flag, reason: 'The selected Core does not advertise the sessions capability; using legacy transports' };
+    if (!contractCompatible)
+        return { enabled: false, flag, reason: 'The selected Core session contract is not compatible with this Desktop; using legacy transports' };
+    return { enabled: true, flag, reason: flag === 'on' ? 'Core sessions forced on' : 'Core sessions available' };
+}

package/server/dist/modules/agent-sessions/domain/errors.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionRequestError = void 0;
+exports.isSessionRequestError = isSessionRequestError;
+/** A session protocol request failed; `code` is Core's stable error code. */
+class SessionRequestError extends Error {
+    rpcCode;
+    code;
+    retryable;
+    detail;
+    constructor(message, data, rpcCode) {
+        super(message);
+        this.rpcCode = rpcCode;
+        this.name = 'SessionRequestError';
+        this.code = data.code;
+        this.retryable = data.retryable;
+        this.detail = data.detail;
+    }
+}
+exports.SessionRequestError = SessionRequestError;
+function isSessionRequestError(error, code) {
+    return error instanceof SessionRequestError && (code === undefined || error.code === code);
+}

package/server/dist/modules/agent-sessions/domain/host-state.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INITIAL_HOST_STATE = exports.DEFAULT_SUPERVISION = void 0;
+exports.canTransition = canTransition;
+exports.onDemand = onDemand;
+exports.onReady = onReady;
+exports.onFailure = onFailure;
+exports.onFatal = onFatal;
+exports.onRestartDue = onRestartDue;
+exports.onRetry = onRetry;
+exports.onStop = onStop;
+exports.acceptsSessions = acceptsSessions;
+exports.DEFAULT_SUPERVISION = Object.freeze({
+    baseDelayMs: 500,
+    maxDelayMs: 30_000,
+    maxFailures: 5,
+    failureWindowMs: 5 * 60_000,
+});
+exports.INITIAL_HOST_STATE = Object.freeze({ status: 'absent', failures: [] });
+const TRANSITIONS = Object.freeze({
+    absent: ['starting', 'stopped'],
+    starting: ['ready', 'restarting', 'degraded', 'stopped'],
+    ready: ['restarting', 'degraded', 'stopped'],
+    restarting: ['starting', 'degraded', 'stopped'],
+    degraded: ['starting', 'stopped'],
+    stopped: [],
+});
+function canTransition(from, to) {
+    return from === to || TRANSITIONS[from].includes(to);
+}
+function transition(state, to, failures = state.failures) {
+    if (!canTransition(state.status, to))
+        throw new Error(`Session host: ${state.status} → ${to} is not allowed`);
+    return { status: to, failures };
+}
+/** A session is needed in this scope. */
+function onDemand(state) {
+    if (state.status === 'absent')
+        return { state: transition(state, 'starting'), decision: { action: 'start' } };
+    return { state, decision: { action: 'none' } };
+}
+function onReady(state) {
+    return transition(state, 'ready');
+}
+/** The host exited unexpectedly or failed to start. */
+function onFailure(state, now, policy = exports.DEFAULT_SUPERVISION) {
+    if (state.status === 'stopped')
+        return { state, decision: { action: 'none' } };
+    const failures = [...state.failures.filter((at) => now - at < policy.failureWindowMs), now];
+    if (failures.length >= policy.maxFailures) {
+        return { state: transition(state, 'degraded', failures), decision: { action: 'degrade', reason: `${failures.length} host failures within ${Math.round(policy.failureWindowMs / 1000)}s` } };
+    }
+    const delayMs = Math.min(policy.maxDelayMs, policy.baseDelayMs * 2 ** (failures.length - 1));
+    return { state: transition(state, 'restarting', failures), decision: { action: 'restart', delayMs } };
+}
+/** A failure no restart can fix (e.g. another host owns the scope's journal): degrade at once. */
+function onFatal(state, reason) {
+    if (state.status === 'stopped' || state.status === 'degraded')
+        return { state, decision: { action: 'none' } };
+    return { state: transition(state, 'degraded'), decision: { action: 'degrade', reason } };
+}
+/** The restart delay elapsed. */
+function onRestartDue(state) {
+    if (state.status !== 'restarting')
+        return { state, decision: { action: 'none' } };
+    return { state: transition(state, 'starting'), decision: { action: 'start' } };
+}
+/** A user explicitly retries a degraded scope (e.g. after fixing Core). */
+function onRetry(state) {
+    if (state.status !== 'degraded')
+        return { state, decision: { action: 'none' } };
+    return { state: transition(state, 'starting', []), decision: { action: 'start' } };
+}
+function onStop(state) {
+    return state.status === 'stopped' ? state : transition(state, 'stopped');
+}
+/** Whether new turns in this scope should use Core sessions right now. */
+function acceptsSessions(state) {
+    return state.status !== 'degraded' && state.status !== 'stopped';
+}

package/server/dist/modules/agent-sessions/domain/projection.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initialProjection = initialProjection;
+exports.reduceEnvelope = reduceEnvelope;
+exports.liveSubagentCount = liveSubagentCount;
+const protocol_1 = require("./protocol");
+function initialProjection(sessionId, lastSeq = 0) {
+    return { sessionId, lastSeq, phase: 'idle', processAlive: false, openTurn: null, liveSubagents: 0, subagents: {} };
+}
+const KNOWN = new Set(protocol_1.KNOWN_EVENT_TYPES);
+function phaseOp(state) {
+    return { kind: 'resident.phase', phase: state.phase, liveSubagents: state.liveSubagents, processAlive: state.processAlive };
+}
+function reduceEnvelope(state, envelope) {
+    if (envelope.sessionId !== state.sessionId)
+        throw new Error(`Event for ${envelope.sessionId} applied to ${state.sessionId}`);
+    if (envelope.seq <= state.lastSeq)
+        return { status: 'duplicate', state, ops: [] };
+    if (envelope.seq !== state.lastSeq + 1)
+        return { status: 'gap', state, ops: [], expected: state.lastSeq + 1 };
+    const next = { ...state, lastSeq: envelope.seq };
+    const event = envelope.event;
+    if (!KNOWN.has(event.type))
+        return { status: 'applied', state: next, ops: [] };
+    const ops = [];
+    switch (event.type) {
+        case 'session.phase':
+            next.phase = event.phase;
+            ops.push(phaseOp(next));
+            break;
+        case 'session.process':
+            next.processAlive = event.state === 'started';
+            ops.push(phaseOp(next));
+            break;
+        case 'session.provider-ref':
+            ops.push({ kind: 'provider.ref', providerSessionRef: event.providerSessionRef });
+            break;
+        case 'session.updated':
+            ops.push({ kind: 'session.updated', changes: event.changes, outcome: event.outcome });
+            break;
+        case 'session.closed':
+            ops.push({ kind: 'session.closed', reason: event.reason });
+            break;
+        case 'input.accepted':
+            ops.push({ kind: 'input.state', inputId: event.inputId, state: 'accepted', turnId: null, reason: null });
+            break;
+        case 'input.state':
+            ops.push({ kind: 'input.state', inputId: event.inputId, state: event.state, turnId: event.turnId ?? null, reason: event.reason ?? null });
+            break;
+        case 'turn.started':
+            next.openTurn = { turnId: event.turnId, origin: event.origin, startedAt: event.at };
+            ops.push({ kind: 'turn.opened', turnId: event.turnId, origin: event.origin, inputIds: [...event.inputIds], triggeredBy: [...(event.trigger?.subagentIds ?? [])], at: event.at });
+            break;
+        case 'turn.output':
+            ops.push({ kind: 'turn.delta', turnId: event.turnId, channel: event.channel, delta: event.delta });
+            break;
+        case 'turn.tool': {
+            const { type: _type, at: _at, turnId, ...tool } = event;
+            ops.push({ kind: 'turn.tool', turnId, tool });
+            break;
+        }
+        case 'turn.completed': {
+            const open = next.openTurn;
+            next.openTurn = null;
+            ops.push({ kind: 'turn.closed', turnId: event.turnId, origin: open?.origin ?? 'user', status: event.status, text: event.text, error: event.error ?? null, usage: event.usage, startedAt: open?.startedAt ?? event.at, at: event.at });
+            break;
+        }
+        case 'subagent.started': {
+            const existing = next.subagents[event.subagentId];
+            const node = existing
+                ? { ...existing, phase: 'running', reason: null, endedAt: null, restarts: existing.restarts + (existing.phase === 'idle' ? 1 : 0) }
+                : {
+                    subagentId: event.subagentId,
+                    parentId: event.parentId,
+                    kind: event.kind,
+                    agentType: event.agentType ?? null,
+                    description: event.description,
+                    phase: 'running',
+                    reason: null,
+                    restarts: 0,
+                    startedAt: event.at,
+                    endedAt: null,
+                    usage: null,
+                    toolUses: null,
+                    durationMs: null,
+                    resultSummary: null,
+                    launchedInTurnId: next.openTurn?.turnId ?? null,
+                    delegated: event.delegated ?? null,
+                };
+            next.subagents = { ...next.subagents, [node.subagentId]: node };
+            ops.push({ kind: 'subagent.upsert', subagent: node });
+            break;
+        }
+        case 'subagent.phase': {
+            const node = next.subagents[event.subagentId];
+            if (!node)
+                break;
+            const live = event.phase === 'running';
+            const updated = { ...node, phase: event.phase, reason: event.reason ?? (live ? null : node.reason), endedAt: live ? null : event.at };
+            next.subagents = { ...next.subagents, [node.subagentId]: updated };
+            ops.push({ kind: 'subagent.upsert', subagent: updated });
+            break;
+        }
+        case 'subagent.usage': {
+            const node = next.subagents[event.subagentId];
+            if (!node)
+                break;
+            const updated = { ...node, usage: event.usage, toolUses: event.toolUses ?? node.toolUses, durationMs: event.durationMs ?? node.durationMs };
+            next.subagents = { ...next.subagents, [node.subagentId]: updated };
+            ops.push({ kind: 'subagent.upsert', subagent: updated });
+            if (event.billing === 'separate' && node.delegated)
+                ops.push({ kind: 'subagent.billed', subagentId: node.subagentId, driver: node.delegated.driver, model: event.usage.model ?? node.delegated.model, usage: event.usage, seq: envelope.seq, at: event.at });
+            break;
+        }
+        case 'subagent.result': {
+            const node = next.subagents[event.subagentId];
+            if (!node)
+                break;
+            const updated = { ...node, resultSummary: event.summary };
+            next.subagents = { ...next.subagents, [node.subagentId]: updated };
+            ops.push({ kind: 'subagent.upsert', subagent: updated });
+            break;
+        }
+        case 'subagent.output':
+            ops.push({ kind: 'subagent.output', subagentId: event.subagentId, channel: event.channel, delta: event.delta ?? null, tool: event.tool ?? null, seq: envelope.seq });
+            break;
+        case 'subagents.settled':
+            next.liveSubagents = event.live;
+            ops.push(phaseOp(next));
+            break;
+        case 'output.truncated':
+            ops.push({ kind: 'notice', level: 'info', code: 'output_truncated', message: `${event.droppedEvents} output chunks (${event.droppedBytes} bytes) were not stored` });
+            break;
+        case 'provider.diagnostic':
+            if (event.level === 'warning')
+                ops.push({ kind: 'notice', level: 'warning', code: event.code, message: event.message });
+            break;
+        case 'session.opened':
+        case 'notice.interruption':
+            break;
+    }
+    return { status: 'applied', state: next, ops };
+}
+/** Number of sub-agents the provider is still running. */
+function liveSubagentCount(state) {
+    return Object.values(state.subagents).filter((node) => node.phase === 'running').length;
+}

package/server/dist/modules/agent-sessions/domain/protocol.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * Session protocol v1 wire types, as Desktop consumes them from the Core
+ * session host (`specrails-core runtime host --stdio`). This is Desktop's
+ * anti-corruption layer for the protocol: Core's internals never leak in.
+ * Drift is checked against the resolved Core's integration contract
+ * (`agentRuntime.sessions`) by `checkSessionContract` and check-core-compat.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KNOWN_EVENT_TYPES = exports.SUPPORTED_PROTOCOL_VERSIONS = void 0;
+exports.checkSessionContract = checkSessionContract;
+exports.SUPPORTED_PROTOCOL_VERSIONS = Object.freeze([1]);
+/** Event types this Desktop understands; newer Cores may send more (ignored). */
+exports.KNOWN_EVENT_TYPES = Object.freeze([
+    'session.opened',
+    'session.phase',
+    'session.process',
+    'session.provider-ref',
+    'session.updated',
+    'session.closed',
+    'input.accepted',
+    'input.state',
+    'turn.started',
+    'turn.output',
+    'turn.tool',
+    'turn.completed',
+    'subagent.started',
+    'subagent.phase',
+    'subagent.output',
+    'subagent.usage',
+    'subagent.result',
+    'subagents.settled',
+    'output.truncated',
+    'notice.interruption',
+    'provider.diagnostic',
+]);
+/** Compare a Core contract block with what this Desktop speaks. Pure. */
+function checkSessionContract(block) {
+    if (!block)
+        return { compatible: false, protocolVersion: null, unknownEventTypes: [], missingEventTypes: [], reasons: ['Core does not declare agentRuntime.sessions'] };
+    const common = block.protocolVersions.filter((version) => exports.SUPPORTED_PROTOCOL_VERSIONS.includes(version));
+    const declared = new Set(block.eventTypes);
+    const known = new Set(exports.KNOWN_EVENT_TYPES);
+    const missingEventTypes = exports.KNOWN_EVENT_TYPES.filter((type) => !declared.has(type));
+    const reasons = [];
+    if (common.length === 0)
+        reasons.push(`No common protocol version (Core ${block.protocolVersions.join(', ')}; Desktop ${exports.SUPPORTED_PROTOCOL_VERSIONS.join(', ')})`);
+    if (block.cliOperation !== 'host')
+        reasons.push(`Unexpected session CLI operation "${block.cliOperation}"`);
+    if (missingEventTypes.length)
+        reasons.push(`Core no longer declares: ${missingEventTypes.join(', ')}`);
+    return {
+        compatible: reasons.length === 0,
+        protocolVersion: common.length ? Math.max(...common) : null,
+        unknownEventTypes: block.eventTypes.filter((type) => !known.has(type)),
+        missingEventTypes,
+        reasons,
+    };
+}

package/server/dist/modules/agent-sessions/domain/subagent-policy.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSubagentPolicy = resolveSubagentPolicy;
+exports.resolveSubagentRuntime = resolveSubagentRuntime;
+/** The project setting decides; conversations without a project use the global one. */
+function resolveSubagentPolicy(input) {
+    const allowed = input.projectAllows ?? input.globalAllows;
+    return allowed ? 'enabled' : 'disabled';
+}
+/**
+ * Hybrid runtime (core-agent-sessions-host D9): native unless the user chose a
+ * provider other than the mission's; then Core launches them. Overrides a
+ * driver cannot apply are dropped (the UI never offers them).
+ */
+function resolveSubagentRuntime(input) {
+    const { choice } = input;
+    if (!choice)
+        return { runtime: { mode: 'native' } };
+    if (choice.provider === input.missionProvider) {
+        const caps = input.drivers.find((driver) => driver.id === input.missionProvider)?.capabilities;
+        return {
+            runtime: {
+                mode: 'native',
+                ...(caps?.subagentModel ? { model: choice.model } : {}),
+                ...(caps?.subagentEffort && choice.effort ? { effort: choice.effort } : {}),
+            },
+        };
+    }
+    if (!input.delegation)
+        return { runtime: { mode: 'native' }, unavailable: 'delegation_unsupported' };
+    if (!input.drivers.some((driver) => driver.id === choice.provider))
+        return { runtime: { mode: 'native' }, unavailable: 'driver_unavailable' };
+    return { runtime: { mode: 'delegated', driver: choice.provider, model: choice.model, ...(choice.effort ? { effort: choice.effort } : {}) } };
+}

package/server/dist/modules/agent-sessions/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionEventPump = exports.resolveCoreSessionsAvailability = exports.parseCoreSessionsFlag = exports.DEFAULT_CORE_SESSIONS_FLAG = exports.acceptsSessions = exports.DEFAULT_SUPERVISION = exports.resolveSubagentRuntime = exports.resolveSubagentPolicy = exports.reduceEnvelope = exports.liveSubagentCount = exports.initialProjection = exports.isSessionRequestError = exports.SessionRequestError = exports.checkSessionContract = exports.KNOWN_EVENT_TYPES = exports.SUPPORTED_PROTOCOL_VERSIONS = void 0;
+/**
+ * Agent sessions: Desktop as the host of Core's agent session runtime.
+ * Public API for conversational features (missions first). Adapters and the
+ * runtime registry are exposed through focused subpaths, not this barrel.
+ */
+var protocol_1 = require("./domain/protocol");
+Object.defineProperty(exports, "SUPPORTED_PROTOCOL_VERSIONS", { enumerable: true, get: function () { return protocol_1.SUPPORTED_PROTOCOL_VERSIONS; } });
+Object.defineProperty(exports, "KNOWN_EVENT_TYPES", { enumerable: true, get: function () { return protocol_1.KNOWN_EVENT_TYPES; } });
+Object.defineProperty(exports, "checkSessionContract", { enumerable: true, get: function () { return protocol_1.checkSessionContract; } });
+var errors_1 = require("./domain/errors");
+Object.defineProperty(exports, "SessionRequestError", { enumerable: true, get: function () { return errors_1.SessionRequestError; } });
+Object.defineProperty(exports, "isSessionRequestError", { enumerable: true, get: function () { return errors_1.isSessionRequestError; } });
+var projection_1 = require("./domain/projection");
+Object.defineProperty(exports, "initialProjection", { enumerable: true, get: function () { return projection_1.initialProjection; } });
+Object.defineProperty(exports, "liveSubagentCount", { enumerable: true, get: function () { return projection_1.liveSubagentCount; } });
+Object.defineProperty(exports, "reduceEnvelope", { enumerable: true, get: function () { return projection_1.reduceEnvelope; } });
+var subagent_policy_1 = require("./domain/subagent-policy");
+Object.defineProperty(exports, "resolveSubagentPolicy", { enumerable: true, get: function () { return subagent_policy_1.resolveSubagentPolicy; } });
+Object.defineProperty(exports, "resolveSubagentRuntime", { enumerable: true, get: function () { return subagent_policy_1.resolveSubagentRuntime; } });
+var host_state_1 = require("./domain/host-state");
+Object.defineProperty(exports, "DEFAULT_SUPERVISION", { enumerable: true, get: function () { return host_state_1.DEFAULT_SUPERVISION; } });
+Object.defineProperty(exports, "acceptsSessions", { enumerable: true, get: function () { return host_state_1.acceptsSessions; } });
+var availability_1 = require("./domain/availability");
+Object.defineProperty(exports, "DEFAULT_CORE_SESSIONS_FLAG", { enumerable: true, get: function () { return availability_1.DEFAULT_CORE_SESSIONS_FLAG; } });
+Object.defineProperty(exports, "parseCoreSessionsFlag", { enumerable: true, get: function () { return availability_1.parseCoreSessionsFlag; } });
+Object.defineProperty(exports, "resolveCoreSessionsAvailability", { enumerable: true, get: function () { return availability_1.resolveCoreSessionsAvailability; } });
+var session_event_pump_1 = require("./application/session-event-pump");
+Object.defineProperty(exports, "SessionEventPump", { enumerable: true, get: function () { return session_event_pump_1.SessionEventPump; } });

package/server/dist/modules/agent-sessions/ports.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });