specrails-desktop 2.62.0 → 2.63.0

package/docs/platforms/windows-parity.md

@@ -6,8 +6,8 @@ This audit covers the `codex/multi-repo-projects` branch, including mission stee
 
 | Feature | Windows implementation and checks |
 | --- | --- |
-| Installation, native runtimes | Native x64/ARM64 NSIS and MSI builds; embedded WebView2 offline provisioning; bundled Node/Git/core/OpenSpec; staged SQLite and full ConPTY/WinPTY dependency validation. |
-| Desktop updates | Installer-specific Tauri targets keep NSIS and MSI separate. Missing, empty or ambiguous artifact/signature pairs fail manifest generation. Generic NSIS entries remain for older clients. Publication is serialized, and previous download installers are retained until the remote manifest matches the new release. |
+| Installation, native runtimes | Native x64/ARM64 NSIS builds; WebView2 provisioning through the embedded bootstrapper; bundled Node/Git/core/OpenSpec; staged SQLite and full ConPTY/WinPTY dependency validation. |
+| Desktop updates | NSIS-specific and generic Tauri targets both reference the NSIS installer; earlier MSI installs fall back to the generic entry and the NSIS installer removes the WiX installation. Missing, empty or ambiguous artifact/signature pairs fail manifest generation. Publication is serialized, and previous download installers are retained until the remote manifest matches the new release. |
 | Startup and project catalog | Recover the actual Windows profile rather than inventing `C:\Users\Default`; SQLite catalog/repository IDs reopen under the same Unicode/spaced profile. |
 | Projects and multi-repo | Repository membership and canonical identity use real paths; junction and case aliases cannot add the same repository twice. Shared backlog and per-repository jobs retain their existing regression coverage. |
 | Core setup and updates | Offline assembly from the shipped core; preserve and restore the previous active framework if Windows junction replacement fails. Installed-package smoke waits for the real workspace marker. |
@@ -28,7 +28,7 @@ This audit covers the `codex/multi-repo-projects` branch, including mission stee
 
 `.github/workflows/windows-parity.yml` runs a `windows-parity` job on `windows-latest` (x64) for every pull request and push to `main`, adding `windows-11-arm` on the `main` pushes. It installs dependencies, checks TypeScript, runs release/PTY helper regression tests, native filesystem/process tests (retried once, they drive real processes), the application build, native host build/tests, and four real native fixtures: WebView2 capture/selection, authentication popups, mission window handoff, and browser multiwindow transfer/parking. It is deliberately a separate workflow from `ci.yml`: `release.yml` waits for CI only, so a slow or flaky Windows run never delays the release PR, while Desktop Release still builds and installs on Windows before publication. The jsdom client suite is not repeated on Windows; it runs on Linux in CI. The bundled-core matrix in `ci.yml` exercises Windows junction/copy relocation for providers.
 
-`.github/workflows/desktop-release.yml` builds the real installers and runs `scripts/smoke-windows-installers.ps1` before publishing artifacts. For each NSIS and MSI package, the script installs into a temporary path containing spaces and drives `scripts/smoke-installed-windows.mjs` with the installed Node runtime. The driver uses an isolated user profile and tests:
+`.github/workflows/desktop-release.yml` builds the real installers and runs `scripts/smoke-windows-installers.ps1` before publishing artifacts. The script fails on any MSI bundle, then installs the NSIS package into a temporary path containing spaces and drives `scripts/smoke-installed-windows.mjs` with the installed Node runtime. The driver uses an isolated user profile and tests:
 
 1. The installed pkg sidecar boots with bundled resources and authenticates API access.
 2. A temporary Git repository is registered and core assembly completes offline.
@@ -53,7 +53,7 @@ The detachable-window implementation has passed native macOS fixtures locally, i
 
 Before claiming complete Windows parity, record successful x64 and ARM64 CI/release runs and exercise the actual installed UI on supported Windows versions:
 
-- Clean NSIS and MSI installs, in-place upgrades from the previous release, relaunch, tray quit and uninstall. Verify one installation entry and preserved projects/logs.
+- Clean NSIS installs, in-place upgrades from the previous release (including an MSI-installed release migrating through the updater), relaunch, tray quit and uninstall. Verify one installation entry and preserved projects/logs.
 - Native browsing and capture at 100%, 150% and 200% display scaling; resize, maximize, multi-monitor movement, keyboard/clipboard, popup/self-close, and the relevant Okta/SSO tenant. Detach two active missions, minimize main independently, move them between monitors, and reattach into a window with its own open browser; verify both sessions and pending inputs remain intact.
 - Provider authentication and one real mission/rail per enabled provider; steering during a tool call; cancellation; multi-repo integration/checkout with clean and conflicting working trees.
 - Long-running frontend/backend processes, immediate startup failure, stopping nested processes, app quit/update during execution, and persisted logs after restart.

package/docs/platforms/windows.md

@@ -15,14 +15,14 @@ Installers are published on every release under:
 
 > 📥 `https://specrails.dev/downloads/specrails-desktop/latest/`
 
-Pick the pair that matches your CPU architecture:
+Pick the installer that matches your CPU architecture:
 
-| Architecture | NSIS installer (recommended) | MSI installer (enterprise/group-policy) |
-| --- | --- | --- |
-| x64 | `specrails-desktop-<version>-x64-setup.exe` | `specrails-desktop-<version>-x64.msi` |
-| ARM64 | `specrails-desktop-<version>-arm64-setup.exe` | `specrails-desktop-<version>-arm64.msi` |
+| Architecture | Installer |
+| --- | --- |
+| x64 | `specrails-desktop-<version>-x64-setup.exe` |
+| ARM64 | `specrails-desktop-<version>-arm64-setup.exe` |
 
-If you are unsure which to use, the NSIS `-setup.exe` is the right choice for individual installs; the MSI exists for enterprise deployment. Versioned copies live at `downloads/specrails-desktop/v<version>/` for archival and deep-linking.
+Windows ships only the NSIS installer. For unattended or managed deployment, run it silently with `/S` (optionally `/D=<install dir>` as the last argument). Releases up to 2.62 also published an `.msi`; see [Updates](#updates) for how those installations migrate. The installer provisions Microsoft Edge WebView2 when it is missing, downloading it through a small embedded bootstrapper (Windows 11 and current Windows 10 already include it). Versioned copies live at `downloads/specrails-desktop/v<version>/` for archival and deep-linking.
 
 A machine-readable `manifest.json` in `latest/` describes the current release (version, sha256, size) per platform, including `windows-x64` and `windows-arm64` entries — consumers can read it to build download links without hardcoding a version.
 
@@ -59,7 +59,7 @@ When the bundle is present, the Tauri host sets `SPECRAILS_IS_DESKTOP=1` and `SP
 
 The desktop app self-updates via the Tauri updater plugin. It checks a GitHub Releases `latest.json` endpoint and, on Windows, applies updates with `installMode: "passive"` — the update runs with a minimal progress UI and the app relaunches into the new version.
 
-Updates preserve the installation format: NSIS installs receive a signed `-setup.exe` updater artifact, and MSI installs receive a signed `.msi` artifact for the same architecture. The signatures are Tauri/minisign integrity signatures, separate from Authenticode signing. An incomplete installer/signature pair blocks publication; the release no longer silently substitutes MSI for NSIS.
+Updates use the signed NSIS `-setup.exe` for the same architecture. Installations made from an earlier `.msi` receive that NSIS update too: the installer detects the MSI installation and removes it before installing, so a single installation remains (Windows may ask for administrator approval to remove the machine-wide MSI). The signatures are Tauri/minisign integrity signatures, separate from Authenticode signing. An incomplete installer/signature pair blocks publication.
 
 Normal quit and updates request an authenticated graceful shutdown of the owned sidecar first, giving processes and persistent logs time to close before a bounded force-stop fallback.
 
@@ -73,8 +73,8 @@ Reserved paths (`.specrails/profiles/**`, `.claude/agents/custom-*.md`) are pres
 
 ## Uninstall
 
-- NSIS: use the **Start Menu → Specrails → Uninstall** entry, or *Settings → Apps*.
-- MSI: use *Settings → Apps* or `msiexec /x <msi-path>`.
+- Use the **Start Menu → Specrails → Uninstall** entry, or *Settings → Apps*.
+- An installation from an earlier `.msi` release that has not updated yet: *Settings → Apps* or `msiexec /x <msi-path>`.
 
 ## Known limitations
 

package/local-runner/dist/specrails-local-runner.js

@@ -4036,7 +4036,7 @@ var require_core = __commonJS({
       constructor(opts = {}) {
         this.schemas = {};
         this.refs = {};
-        this.formats = {};
+        this.formats = /* @__PURE__ */ Object.create(null);
         this._compilations = /* @__PURE__ */ new Set();
         this._loading = {};
         this._cache = /* @__PURE__ */ new Map();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "specrails-desktop",
-  "version": "2.62.0",
+  "version": "2.63.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -56,7 +56,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@tailwindcss/typography": "^0.5.19",
-    "ajv": "^8.17.1",
+    "ajv": "^8.20.0",
     "better-sqlite3": "^12.8.0",
     "chokidar": "^5.0.0",
     "cross-spawn": "^7.0.6",
@@ -71,29 +71,28 @@
     "selfsigned": "^5.5.0",
     "tree-kill": "^1.2.2",
     "werift": "^0.23.0",
-    "ws": "^8.21.0",
+    "ws": "^8.22.0",
     "zod": "^3.25.76"
   },
   "devDependencies": {
+    "@babel/parser": "^7.29.9",
     "@tauri-apps/cli": "^2.0.0",
     "@types/better-sqlite3": "^7.6.0",
-    "@types/chokidar": "^1.7.5",
     "@types/cross-spawn": "^6.0.6",
-    "@types/diff": "^7.0.2",
     "@types/express": "^5.0.6",
     "@types/js-yaml": "^4.0.9",
     "@types/multer": "^2.1.0",
-    "@types/node": "^25.5.0",
+    "@types/node": "^26.6.5",
     "@types/pdf-parse": "^1.1.5",
     "@types/supertest": "^7.2.0",
     "@types/ws": "^8.5.0",
-    "@vitest/coverage-v8": "^4.1.10",
+    "@vitest/coverage-v8": "^5.0.3",
     "concurrently": "^9.2.1",
     "esbuild": "^0.28.1",
     "supertest": "^7.2.2",
     "tsx": "^4.23.0",
-    "typescript": "^5.4.0",
-    "vitest": "^4.1.10"
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.3"
   },
   "overrides": {
     "ip": "npm:@eggjs/ip@2.1.0",

package/server/dist/mcp/tools/env.js

@@ -15,6 +15,26 @@ function uniq(names) {
     }
     return out;
 }
+/** Names and states only: rebuild each record field by field so nothing but
+ *  the documented, value-free fields can ever reach an MCP client. */
+function sanitizeStatus(raw) {
+    const report = (raw && typeof raw === 'object' ? raw : {});
+    const names = Array.isArray(report.names) ? report.names : [];
+    return {
+        checking: report.checking === true,
+        loginShellRecovery: report.loginShellRecovery !== false,
+        timeoutMs: typeof report.timeoutMs === 'number' ? report.timeoutMs : null,
+        statuses: names
+            .filter((entry) => typeof entry?.name === 'string' && typeof entry?.status === 'string')
+            .map((entry) => ({
+            name: entry.name,
+            status: entry.status,
+            shell: typeof entry.shell === 'string' ? entry.shell : null,
+            checkedAt: typeof entry.checkedAt === 'string' ? entry.checkedAt : null,
+            exitCode: typeof entry.exitCode === 'number' ? entry.exitCode : null,
+        })),
+    };
+}
 function envTools() {
     return [
         {
@@ -22,11 +42,12 @@ function envTools() {
             title: 'Project worktree environment',
             description: 'Read, scan, and configure the per-project environment variable NAME allowlist used for rail jobs and isolated loop worktrees. ' +
                 'Values are never read or stored by this tool; runs read them from the server environment and can recover configured names from the login shell when the desktop process is missing them. scan inspects safe repo config files such as package.json, .npmrc, .yarnrc.yml and pnpm-workspace.yaml for ${VAR} / process.env.VAR references and private scoped package auth hints. ' +
-                'Actions: get (read current names), scan (discover candidates), set (write names), auto_configure (scan then merge discovered names into settings).',
+                'Each configured name reports a value-free resolution status: inherited, recovered (from the login shell), not-defined, probe-timeout or probe-failed. ' +
+                'Actions: get (read current names and their statuses), status (statuses only), recheck (probe the login shell now, then return statuses), scan (discover candidates), set (write names), auto_configure (scan then merge discovered names into settings).',
             hintTier: 'read',
             tier: (args) => (args.action === 'set' || args.action === 'auto_configure' ? 'write' : 'read'),
             inputSchema: {
-                action: zod_1.z.enum(['get', 'scan', 'set', 'auto_configure']).describe('Operation'),
+                action: zod_1.z.enum(['get', 'status', 'recheck', 'scan', 'set', 'auto_configure']).describe('Operation'),
                 projectId: zod_1.z.string().optional().describe('Project id (defaults to the active project)'),
                 names: zod_1.z.array(zod_1.z.string()).optional().describe('set: env var names to configure'),
                 merge: zod_1.z.boolean().optional().describe('set: merge with existing names instead of replacing them (default true)'),
@@ -36,7 +57,21 @@ function envTools() {
                 const base = (0, types_1.projectPath)(ctx, args.projectId);
                 if (action === 'get') {
                     const settings = await (0, types_1.apiCall)(ctx, 'GET', `${base}/settings`);
-                    return { names: Array.isArray(settings.worktreeEnvPassthrough) ? settings.worktreeEnvPassthrough : [] };
+                    const names = Array.isArray(settings.worktreeEnvPassthrough) ? settings.worktreeEnvPassthrough : [];
+                    // Statuses are best-effort: an older server without the route still answers names.
+                    try {
+                        const { statuses } = sanitizeStatus(await (0, types_1.apiCall)(ctx, 'GET', `${base}/env-passthrough/status`));
+                        return { names, statuses };
+                    }
+                    catch {
+                        return { names };
+                    }
+                }
+                if (action === 'status') {
+                    return sanitizeStatus(await (0, types_1.apiCall)(ctx, 'GET', `${base}/env-passthrough/status`));
+                }
+                if (action === 'recheck') {
+                    return sanitizeStatus(await (0, types_1.apiCall)(ctx, 'POST', `${base}/env-passthrough/recheck`));
                 }
                 if (action === 'scan') {
                     const project = (0, types_1.requireProject)(ctx, args.projectId).project;

package/server/dist/modules/execution/runtime/queue-manager.js

@@ -2217,8 +2217,12 @@ class QueueManager {
         // values are read from the server env (with login-shell recovery for missing
         // names) at spawn time. Apply this before Specrails' own env overlays so
         // internal SPECRAILS_* control-plane values always win.
+        let environmentNotice = null;
         if (this._db) {
             spawnEnv = (0, project_env_1.applyWorktreeEnvPassthrough)(this._db, spawnEnv);
+            // One value-free line naming unresolved configured names (written to the
+            // job log once the readers exist). The run proceeds without them.
+            environmentNotice = (0, project_env_1.worktreeEnvPassthroughWarning)(this._db, spawnEnv);
         }
         const telemetryEnabled = !!(this._projectId && this._db && (0, db_1.getProjectSettings)(this._db).pipelineTelemetryEnabled);
         // Resolve the framework version ONCE at spawn time — `framework/current`
@@ -2605,6 +2609,10 @@ class QueueManager {
         const stdoutReader = (0, readline_1.createInterface)({ input: child.stdout, crlfDelay: Infinity });
         const stderrReader = (0, readline_1.createInterface)({ input: child.stderr, crlfDelay: Infinity });
         this._jobReaders.set(jobId, { stdout: stdoutReader, stderr: stderrReader });
+        if (environmentNotice) {
+            persistEvent({ event_type: 'log', source: 'stderr', payload: JSON.stringify({ line: environmentNotice }) }, false);
+            emitLine('stderr', environmentNotice);
+        }
         stdoutReader.on('line', (line) => {
             if (this._disposed)
                 return;

package/server/dist/modules/loops/runtime/loop-executors.js

@@ -181,6 +181,7 @@ function createLoopExecutors(opts = {}) {
     const completionContexts = new Map();
     const runtimeConfigPath = (cwd) => (0, node_path_1.join)(opts.pluginScope?.().stateRoot ?? cwd, '.specrails', 'agent-runtime.json');
     return {
+        ...(opts.environmentNotice ? { environmentNotice: opts.environmentNotice } : {}),
         async cancelDefinition({ runId, contextPath, requestId }) {
             const host = (0, agent_runtime_bridge_1.readFrozenRuntimeHost)(contextPath, resolveEnv(), runId);
             await (0, agent_runtime_bridge_1.runAgentRuntimeControl)({ kind: 'cancel', runId, contextPath, requestId, ...host });

package/server/dist/modules/loops/runtime/loop-run-manager.js

@@ -1009,6 +1009,13 @@ class LoopRunManager {
         logLine(`▶ Loop "${req.loopName ?? req.loopId}" started${req.spec?.title ? ` — spec: ${req.spec.title}` : ''}`);
         if (req.isolation)
             logLine(`⎇ Isolated worktree: ${req.isolation.worktreePath} (branch ${req.isolation.branch})`);
+        let environmentNotice = null;
+        try {
+            environmentNotice = this.executors.environmentNotice?.() ?? null;
+        }
+        catch { /* diagnostic only */ }
+        if (environmentNotice)
+            logLine(environmentNotice, 'stderr');
         if (!definitionEngine && !usageTelemetryAvailable) {
             logLine(`⚠️ ${adapter.displayName} does not report token/cost usage in headless mode; usage totals will remain unavailable.` +
                 (configuredMaxCostUsd !== undefined

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

@@ -1,6 +1,7 @@
 "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, 
@@ -34,3 +35,26 @@ onUpdated) {
         }
     });
 }
+/** 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/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. */