specrails-desktop 2.61.0 → 2.63.0

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;

package/server/dist/modules/project-settings/adapters/http.js

@@ -1,16 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerProjectSettingsHttp = registerProjectSettingsHttp;
+exports.registerEnvPassthroughStatusHttp = registerEnvPassthroughStatusHttp;
 const __1 = require("..");
 /** Inbound adapter: translate HTTP into use cases and domain errors into HTTP. */
-function registerProjectSettingsHttp(router, serviceForRequest) {
+function registerProjectSettingsHttp(router, serviceForRequest, 
+/** Observer for committed changes (e.g. open agent sessions re-reading policy). */
+onUpdated) {
     router.get('/:projectId/settings', (req, res) => {
         res.json(serviceForRequest(req).getSettings());
     });
     router.patch('/:projectId/settings', (req, res) => {
         try {
-            const settings = serviceForRequest(req).updateSettings(req.body);
+            const service = serviceForRequest(req);
+            const previous = onUpdated ? service.getSettings() : null;
+            const settings = service.updateSettings(req.body);
             res.json({ ok: true, settings });
+            if (onUpdated && previous) {
+                try {
+                    onUpdated(req, settings, previous);
+                }
+                catch (error) {
+                    console.error('[project-router] settings observer error:', error);
+                }
+            }
         }
         catch (error) {
             if (error instanceof __1.SettingsValidationError) {
@@ -22,3 +35,26 @@ function registerProjectSettingsHttp(router, serviceForRequest) {
         }
     });
 }
+/** Inbound adapter for `GET /:projectId/env-passthrough/status` and
+ * `POST /:projectId/env-passthrough/recheck`. Responses carry names and
+ * states only; values never reach this adapter. */
+function registerEnvPassthroughStatusHttp(router, port) {
+    router.get('/:projectId/env-passthrough/status', async (req, res) => {
+        try {
+            res.json(await port.read(req));
+        }
+        catch (error) {
+            console.error('[project-router] env status error:', error);
+            res.status(500).json({ error: 'Failed to read environment status' });
+        }
+    });
+    router.post('/:projectId/env-passthrough/recheck', async (req, res) => {
+        try {
+            res.json(await port.recheck(req));
+        }
+        catch (error) {
+            console.error('[project-router] env recheck error:', error);
+            res.status(500).json({ error: 'Failed to recheck environment' });
+        }
+    });
+}

package/server/dist/modules/project-settings/adapters/sqlite.js

@@ -18,13 +18,25 @@ function parseWorktreeEnvPassthrough(raw) {
         return [];
     }
 }
+/** A stored value that no longer parses (hand-edited, older shape) reads as "same as the mission agent". */
+function readSubagentRuntime(raw) {
+    if (!raw)
+        return null;
+    try {
+        return (0, domain_1.parseSubagentRuntimeSetting)(JSON.parse(raw));
+    }
+    catch {
+        return null;
+    }
+}
 function getProjectSettings(db) {
-    // Read the settings as one snapshot instead of preparing six separate queries.
+    // Read the settings as one snapshot instead of preparing separate queries.
     const rows = db.prepare(`
     SELECT key, value FROM queue_state WHERE key IN (
       'config.pipeline_telemetry_enabled', 'config.orchestrator_model',
       'config.pre_prompt', 'config.freestyle_pre_prompt',
-      'config.integration_branch', 'config.worktree_env_passthrough'
+      'config.integration_branch', 'config.worktree_env_passthrough',
+      'config.allow_subagents', 'config.subagent_runtime'
     )
   `).all();
     const settings = new Map(rows.map(row => [row.key, row]));
@@ -42,6 +54,8 @@ function getProjectSettings(db) {
         freestylePrePrompt: freestylePrePromptRow?.value ?? '',
         integrationBranch: integrationBranchRow?.value ?? '',
         worktreeEnvPassthrough: parseWorktreeEnvPassthrough(worktreeEnvPassthroughRow?.value),
+        allowSubagents: settings.get('config.allow_subagents')?.value === 'true',
+        subagentRuntime: readSubagentRuntime(settings.get('config.subagent_runtime')?.value),
     };
 }
 /** Resolve the effective Freestyle pre-prompt: the per-project override when
@@ -81,6 +95,20 @@ function updateProjectSettings(db, patch) {
             db.prepare(`INSERT OR REPLACE INTO queue_state (key, value) VALUES ('config.integration_branch', ?)`).run(patch.integrationBranch.trim());
         }
     }
+    if (patch.allowSubagents !== undefined) {
+        if (patch.allowSubagents) {
+            db.prepare(`INSERT OR REPLACE INTO queue_state (key, value) VALUES ('config.allow_subagents', 'true')`).run();
+        }
+        else {
+            db.prepare(`DELETE FROM queue_state WHERE key = 'config.allow_subagents'`).run();
+        }
+    }
+    if (patch.subagentRuntime !== undefined) {
+        if (patch.subagentRuntime === null)
+            db.prepare(`DELETE FROM queue_state WHERE key = 'config.subagent_runtime'`).run();
+        else
+            db.prepare(`INSERT OR REPLACE INTO queue_state (key, value) VALUES ('config.subagent_runtime', ?)`).run(JSON.stringify(patch.subagentRuntime));
+    }
     if (patch.worktreeEnvPassthrough !== undefined) {
         const names = (0, domain_1.normalizeWorktreeEnvPassthrough)(patch.worktreeEnvPassthrough);
         if (names.length === 0) {

package/server/dist/modules/project-settings/domain.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SettingsValidationError = exports.WORKTREE_ENV_NAME_RE = exports.DEFAULT_FREESTYLE_PRE_PROMPT = void 0;
+exports.parseSubagentRuntimeSetting = parseSubagentRuntimeSetting;
 exports.normalizeWorktreeEnvPassthrough = normalizeWorktreeEnvPassthrough;
 exports.parseProjectSettingsPatch = parseProjectSettingsPatch;
 const git_branch_name_1 = require("../../shared/git-branch-name");
@@ -18,6 +19,22 @@ exports.DEFAULT_FREESTYLE_PRE_PROMPT = [
     'Never ask for confirmation; there is no human to answer. Choose the recommended option and proceed.',
     'Run every command in the FOREGROUND and wait for it to finish — never background a command (no run_in_background, no trailing `&`): your reply ends the step and anything still running is killed with its output lost.',
 ].join('\n');
+const PROVIDER_ID_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
+/** Strict shape check shared by project and app settings; null clears the choice. */
+function parseSubagentRuntimeSetting(value) {
+    if (value === null)
+        return null;
+    const input = value;
+    if (!input || typeof input !== 'object' || Array.isArray(input))
+        throw new SettingsValidationError('subagentRuntime must be an object or null');
+    if (typeof input.provider !== 'string' || !PROVIDER_ID_RE.test(input.provider))
+        throw new SettingsValidationError('subagentRuntime.provider must be a provider id');
+    if (typeof input.model !== 'string' || !input.model.trim() || input.model.length > 200)
+        throw new SettingsValidationError('subagentRuntime.model must be a model name');
+    if (input.effort !== undefined && input.effort !== null && (typeof input.effort !== 'string' || !input.effort.trim() || input.effort.length > 50))
+        throw new SettingsValidationError('subagentRuntime.effort must be an effort level or null');
+    return { provider: input.provider, model: input.model.trim(), effort: typeof input.effort === 'string' ? input.effort.trim() : null };
+}
 exports.WORKTREE_ENV_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const WORKTREE_ENV_MAX_NAMES = 64;
 const WORKTREE_ENV_MAX_NAME_LENGTH = 128;
@@ -82,6 +99,13 @@ function parseProjectSettingsPatch(input) {
             throw new SettingsValidationError(error instanceof Error ? error.message : 'invalid worktreeEnvPassthrough');
         }
     }
+    if (values.subagentRuntime !== undefined)
+        patch.subagentRuntime = parseSubagentRuntimeSetting(values.subagentRuntime);
+    if (values.allowSubagents !== undefined) {
+        if (typeof values.allowSubagents !== 'boolean')
+            throw new SettingsValidationError('allowSubagents must be a boolean');
+        patch.allowSubagents = values.allowSubagents;
+    }
     if (values.integrationBranch !== undefined) {
         const branch = values.integrationBranch;
         if (typeof branch !== 'string')

package/server/dist/modules/project-settings/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SettingsValidationError = exports.normalizeWorktreeEnvPassthrough = exports.WORKTREE_ENV_NAME_RE = exports.DEFAULT_FREESTYLE_PRE_PROMPT = exports.createProjectSettingsService = void 0;
+exports.SettingsValidationError = exports.parseSubagentRuntimeSetting = exports.normalizeWorktreeEnvPassthrough = exports.WORKTREE_ENV_NAME_RE = exports.DEFAULT_FREESTYLE_PRE_PROMPT = exports.createProjectSettingsService = void 0;
 // Public application API. Infrastructure adapters are wired only at composition roots.
 var application_1 = require("./application");
 Object.defineProperty(exports, "createProjectSettingsService", { enumerable: true, get: function () { return application_1.createProjectSettingsService; } });
@@ -8,4 +8,5 @@ var domain_1 = require("./domain");
 Object.defineProperty(exports, "DEFAULT_FREESTYLE_PRE_PROMPT", { enumerable: true, get: function () { return domain_1.DEFAULT_FREESTYLE_PRE_PROMPT; } });
 Object.defineProperty(exports, "WORKTREE_ENV_NAME_RE", { enumerable: true, get: function () { return domain_1.WORKTREE_ENV_NAME_RE; } });
 Object.defineProperty(exports, "normalizeWorktreeEnvPassthrough", { enumerable: true, get: function () { return domain_1.normalizeWorktreeEnvPassthrough; } });
+Object.defineProperty(exports, "parseSubagentRuntimeSetting", { enumerable: true, get: function () { return domain_1.parseSubagentRuntimeSetting; } });
 Object.defineProperty(exports, "SettingsValidationError", { enumerable: true, get: function () { return domain_1.SettingsValidationError; } });

package/server/dist/modules/specs/runtime/spec-models.js

@@ -9,7 +9,7 @@ exports.CLAUDE_MODELS = [
     { value: 'sonnet', label: 'Sonnet 5.5' },
     { value: 'fable', label: 'Fable 5.1' },
     { value: 'opus', label: 'Claude Opus' },
-    { value: 'haiku', label: 'Claude Haiku' },
+    { value: 'haiku', label: 'Claude Haiku 5.5' },
 ];
 exports.CODEX_MODELS = [
     { value: 'gpt-6.1-sol', label: 'GPT-6.1 Sol' },

package/server/dist/path-resolver.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AUTH_ENV_VARS = void 0;
+exports.LOGIN_SHELL_PROBE_TIMEOUT_MS = exports.AUTH_ENV_VARS = void 0;
 exports.ensureWindowsBaseEnv = ensureWindowsBaseEnv;
 exports.resolveBundledRuntimePath = resolveBundledRuntimePath;
 exports.resolveBundledNodeExe = resolveBundledNodeExe;
@@ -12,6 +12,10 @@ exports.parseLoginShellOutput = parseLoginShellOutput;
 exports.augmentPathFromLoginShell = augmentPathFromLoginShell;
 exports.parseLoginShellEnv = parseLoginShellEnv;
 exports.augmentEnvFromLoginShell = augmentEnvFromLoginShell;
+exports.resolveLoginShellProbeTimeoutMs = resolveLoginShellProbeTimeoutMs;
+exports.hasCompleteLoginShellEnvBlock = hasCompleteLoginShellEnvBlock;
+exports.readEnvFromLoginShell = readEnvFromLoginShell;
+exports.readEnvFromLoginShellSyncDetailed = readEnvFromLoginShellSyncDetailed;
 exports.readEnvFromLoginShellSync = readEnvFromLoginShellSync;
 exports.augmentEnvFromLoginShellSync = augmentEnvFromLoginShellSync;
 exports.augmentAuthEnvFromLoginShell = augmentAuthEnvFromLoginShell;
@@ -580,17 +584,130 @@ async function augmentEnvFromLoginShell(names, opts = {}) {
         });
     });
 }
-/** Read missing configured names without mutating the caller's or global env.
- * Callers own any cache so project credentials cannot leak across scopes. */
-function readEnvFromLoginShellSync(names, opts = {}) {
+/** Default budget for the asynchronous project-env probe. Real interactive
+ * profiles (oh-my-zsh, nvm, powerlevel10k, conda) routinely exceed 1.5 s. */
+exports.LOGIN_SHELL_PROBE_TIMEOUT_MS = 10_000;
+const LOGIN_SHELL_PROBE_MAX_TIMEOUT_MS = 120_000;
+const LOGIN_SHELL_OUTPUT_CAP = 1024 * 1024;
+/** `SPECRAILS_LOGIN_SHELL_TIMEOUT_MS` overrides the asynchronous probe budget.
+ * Invalid or non-positive values fall back to the 10 s default; values are
+ * capped at 2 minutes so a typo cannot park a probe forever. */
+function resolveLoginShellProbeTimeoutMs(env = process.env) {
+    const raw = env.SPECRAILS_LOGIN_SHELL_TIMEOUT_MS?.trim();
+    if (!raw || !/^\d+$/.test(raw))
+        return exports.LOGIN_SHELL_PROBE_TIMEOUT_MS;
+    const value = Number(raw);
+    if (!Number.isFinite(value) || value <= 0)
+        return exports.LOGIN_SHELL_PROBE_TIMEOUT_MS;
+    return Math.min(value, LOGIN_SHELL_PROBE_MAX_TIMEOUT_MS);
+}
+/** True when the probe output contains the complete env sentinel block. The
+ * block is the proof that the printf ran, independent of the shell's status. */
+function hasCompleteLoginShellEnvBlock(stdout) {
+    const begin = stdout.indexOf(ENV_BEGIN);
+    return begin !== -1 && stdout.indexOf(ENV_END, begin + ENV_BEGIN.length) !== -1;
+}
+function loginShellProbeSkipped(names = []) {
+    return { values: {}, status: 'skipped', exitCode: null, shell: null, names };
+}
+function pickRecovered(stdout, wanted) {
+    const recovered = parseLoginShellEnv(stdout);
+    const out = {};
+    for (const key of wanted) {
+        const val = recovered[key];
+        if (val)
+            out[key] = val;
+    }
+    return out;
+}
+function settleLoginShellProbe(stdout, wanted, shell, exitCode, timedOut) {
+    if (hasCompleteLoginShellEnvBlock(stdout)) {
+        return { values: pickRecovered(stdout, wanted), status: 'ok', exitCode, shell, names: wanted };
+    }
+    return { values: {}, status: timedOut ? 'timeout' : 'failed', exitCode, shell, names: wanted };
+}
+function wantedLoginShellNames(names, env) {
     if (process.platform === 'win32')
-        return {};
+        return null;
     if (process.env.NODE_ENV === 'test' || process.env.VITEST === 'true')
-        return {};
+        return null;
+    return normalizeLoginShellEnvNames(names).filter((name) => !env[name]);
+}
+/** Asynchronously read missing configured names from the login shell without
+ * blocking the event loop or mutating any environment. Values from a complete
+ * sentinel block are accepted regardless of the shell's exit status. Output is
+ * capped at 1 MiB; the child is killed at the timeout. Callers own any cache. */
+function readEnvFromLoginShell(names, opts = {}) {
     const env = opts.env ?? process.env;
-    const wanted = normalizeLoginShellEnvNames(names).filter((name) => !env[name]);
+    const wanted = wantedLoginShellNames(names, env);
+    if (wanted === null)
+        return Promise.resolve(loginShellProbeSkipped());
     if (wanted.length === 0)
-        return {};
+        return Promise.resolve(loginShellProbeSkipped(wanted));
+    const spawnFn = opts.spawnFn ?? child_process_1.spawn;
+    const timeoutMs = opts.timeoutMs ?? resolveLoginShellProbeTimeoutMs(env);
+    const shell = resolveLoginShell(env);
+    const command = buildLoginShellEnvCommand(wanted);
+    return new Promise((resolve) => {
+        let child;
+        try {
+            child = spawnFn(shell, ['-l', '-i', '-c', command], { env, stdio: ['ignore', 'pipe', 'pipe'] });
+        }
+        catch {
+            resolve({ values: {}, status: 'failed', exitCode: null, shell, names: wanted });
+            return;
+        }
+        let stdout = '';
+        let timedOut = false;
+        let settled = false;
+        const kill = () => { try {
+            child.kill('SIGKILL');
+        }
+        catch { /* ignore */ } };
+        const timer = setTimeout(() => {
+            timedOut = true;
+            kill();
+            // Settle now: a background job started by the profile can keep the pipes
+            // (and so 'close') open long after the shell itself was killed. A complete
+            // block printed before a hung exit hook is still a success.
+            finish(null);
+        }, timeoutMs);
+        const finish = (exitCode) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(settleLoginShellProbe(stdout, wanted, shell, exitCode, timedOut));
+        };
+        child.stdout?.on('data', (chunk) => {
+            if (stdout.length >= LOGIN_SHELL_OUTPUT_CAP)
+                return;
+            stdout += chunk.toString('utf-8');
+            if (stdout.length >= LOGIN_SHELL_OUTPUT_CAP) {
+                stdout = stdout.slice(0, LOGIN_SHELL_OUTPUT_CAP);
+                if (!hasCompleteLoginShellEnvBlock(stdout))
+                    kill();
+            }
+        });
+        child.stderr?.on('data', () => { });
+        child.on('error', () => finish(null));
+        child.on('close', (code) => finish(typeof code === 'number' ? code : null));
+    });
+}
+function isSpawnSyncTimeout(res) {
+    const error = res.error;
+    return Boolean(error && (error.code === 'ETIMEDOUT' || /ETIMEDOUT/.test(error.message)));
+}
+/** Synchronous, detailed variant used only as the cold fallback at spawn time.
+ * Keeps the short 1.5 s budget so a cold spawn never freezes the server for
+ * long, and accepts a complete sentinel block regardless of exit status. */
+function readEnvFromLoginShellSyncDetailed(names, opts = {}) {
+    const env = opts.env ?? process.env;
+    const wanted = wantedLoginShellNames(names, env);
+    if (wanted === null)
+        return loginShellProbeSkipped();
+    if (wanted.length === 0)
+        return loginShellProbeSkipped(wanted);
     const spawnSyncFn = opts.spawnSyncFn ?? child_process_1.spawnSync;
     const timeoutMs = opts.timeoutMs ?? LOGIN_SHELL_TIMEOUT_MS;
     const shell = resolveLoginShell(env);
@@ -602,23 +719,21 @@ function readEnvFromLoginShellSync(names, opts = {}) {
             encoding: 'utf8',
             stdio: ['ignore', 'pipe', 'pipe'],
             timeout: timeoutMs,
-            maxBuffer: 1024 * 1024,
+            // An interactive shell can ignore SIGTERM; the cold fallback must stay bounded.
+            killSignal: 'SIGKILL',
+            maxBuffer: LOGIN_SHELL_OUTPUT_CAP,
         });
     }
     catch {
-        return {};
+        return { values: {}, status: 'failed', exitCode: null, shell, names: wanted };
     }
-    if (res.error || res.status !== 0)
-        return {};
     const stdout = typeof res.stdout === 'string' ? res.stdout : res.stdout?.toString('utf8') ?? '';
-    const recovered = parseLoginShellEnv(stdout);
-    const out = {};
-    for (const key of wanted) {
-        const val = recovered[key];
-        if (val)
-            out[key] = val;
-    }
-    return out;
+    return settleLoginShellProbe(stdout, wanted, shell, typeof res.status === 'number' ? res.status : null, isSpawnSyncTimeout(res));
+}
+/** Read missing configured names without mutating the caller's or global env.
+ * Callers own any cache so project credentials cannot leak across scopes. */
+function readEnvFromLoginShellSync(names, opts = {}) {
+    return readEnvFromLoginShellSyncDetailed(names, opts).values;
 }
 /** Compatibility backfill for callers that intentionally augment process.env.
  * Failed probes remain retryable; successful names are already present. */

package/server/dist/plugins/codex-spawn.js

@@ -3,18 +3,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCodexPluginMcpServers = resolveCodexPluginMcpServers;
 exports.buildCodexPluginArgs = buildCodexPluginArgs;
 const path_1 = __importDefault(require("path"));
 const manager_1 = require("./manager");
-/** Materialize app-installed plugins in the actual Codex invocation. The
+/** MCP servers of app-installed plugins active for this Codex invocation. The
  * legacy per-project CODEX_HOME is an install record, not the provider's
  * runtime home: switching HOME would discard the user's login and settings. */
-function buildCodexPluginArgs(options) {
+function resolveCodexPluginMcpServers(options) {
     if (options.providerId !== 'codex')
         return [];
     const manager = (0, manager_1.getPluginManager)();
     const state = manager.getProjectState(options.stateRoot);
-    const args = [];
+    const servers = [];
     for (const [name, installed] of Object.entries(state.plugins ?? {})) {
         if (!installed || typeof installed !== 'object')
             continue;
@@ -30,7 +31,6 @@ function buildCodexPluginArgs(options) {
         // owned keys or overwrite Specrails' authenticated bridge.
         if (keys.length !== 1 || !/^[A-Za-z][A-Za-z0-9_-]*$/.test(keys[0]) || keys[0] === 'specrails')
             continue;
-        const server = keys[0];
         const serverArgs = [...entry.args];
         // Serena's '.' must mean this invocation's source/worktree, even when
         // the CLI starts in an app-managed conversation or artifact directory.
@@ -39,9 +39,17 @@ function buildCodexPluginArgs(options) {
             if (project >= 0)
                 serverArgs[project + 1] = path_1.default.resolve(options.repositoryPath);
         }
-        const prefix = `mcp_servers.${server}`;
-        args.push('-c', `${prefix}.command=${JSON.stringify(entry.command)}`, '-c', `${prefix}.args=${JSON.stringify(serverArgs)}`, '-c', `${prefix}.enabled=true`);
-        for (const [key, value] of Object.entries(entry.env ?? {})) {
+        servers.push({ name: keys[0], command: entry.command, args: serverArgs, ...(entry.env && Object.keys(entry.env).length ? { env: { ...entry.env } } : {}) });
+    }
+    return servers;
+}
+/** Materialize app-installed plugins in a spawned Codex CLI invocation. */
+function buildCodexPluginArgs(options) {
+    const args = [];
+    for (const server of resolveCodexPluginMcpServers(options)) {
+        const prefix = `mcp_servers.${server.name}`;
+        args.push('-c', `${prefix}.command=${JSON.stringify(server.command)}`, '-c', `${prefix}.args=${JSON.stringify(server.args)}`, '-c', `${prefix}.enabled=true`);
+        for (const [key, value] of Object.entries(server.env ?? {})) {
             args.push('-c', `${prefix}.env.${JSON.stringify(key)}=${JSON.stringify(value)}`);
         }
     }