gsd-pi 2.66.1 → 2.67.0

package/dist/claude-cli-check.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Check if the `claude` binary is installed (regardless of auth state).
+ */
+export declare function isClaudeBinaryInstalled(): boolean;
+/**
+ * Check if the `claude` CLI is installed AND authenticated.
+ */
+export declare function isClaudeCliReady(): boolean;

package/dist/claude-cli-check.js

@@ -0,0 +1,36 @@
+// GSD2 — Claude CLI binary detection for onboarding
+// Lightweight check used at onboarding time (before extensions load).
+// The full readiness check with caching lives in the claude-code-cli extension.
+import { execFileSync } from 'node:child_process';
+/**
+ * Check if the `claude` binary is installed (regardless of auth state).
+ */
+export function isClaudeBinaryInstalled() {
+    try {
+        execFileSync('claude', ['--version'], { timeout: 5_000, stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if the `claude` CLI is installed AND authenticated.
+ */
+export function isClaudeCliReady() {
+    try {
+        execFileSync('claude', ['--version'], { timeout: 5_000, stdio: 'pipe' });
+    }
+    catch {
+        return false;
+    }
+    try {
+        const output = execFileSync('claude', ['auth', 'status'], { timeout: 5_000, stdio: 'pipe' })
+            .toString()
+            .toLowerCase();
+        return !(/not logged in|no credentials|unauthenticated|not authenticated/i.test(output));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/cli.js

@@ -395,8 +395,28 @@ if (isPrintMode) {
         settingsManager,
         sessionManager,
         resourceLoader,
+        isClaudeCodeReady: () => modelRegistry.isProviderRequestReady('claude-code'),
     });
     markStartup('createAgentSession');
+    // Migrate anthropic OAuth users to claude-code provider when CLI is available (#3772).
+    // Anthropic blocks third-party apps from using subscription quotas — routing through
+    // the local claude CLI binary is TOS-compliant.
+    if (modelRegistry.isProviderRequestReady('claude-code') && settingsManager.getDefaultProvider() === 'anthropic') {
+        const currentModelId = settingsManager.getDefaultModel();
+        if (currentModelId) {
+            const ccModel = modelRegistry.find('claude-code', currentModelId);
+            if (ccModel) {
+                try {
+                    await session.setModel(ccModel);
+                    // Only persist after successful session switch to avoid desync
+                    settingsManager.setDefaultModelAndProvider('claude-code', currentModelId);
+                }
+                catch {
+                    // claude-code provider not ready — leave both session and settings unchanged
+                }
+            }
+        }
+    }
     // Validate configured model AFTER extensions have registered their models (#2626).
     // Before this, extension-provided models (e.g. claude-code/*) were not yet in the
     // registry, causing the user's valid choice to be silently overwritten.
@@ -550,8 +570,28 @@ const { session, extensionsResult, modelFallbackMessage: interactiveFallbackMsg
     settingsManager,
     sessionManager,
     resourceLoader,
+    isClaudeCodeReady: () => modelRegistry.isProviderRequestReady('claude-code'),
 });
 markStartup('createAgentSession');
+// Migrate anthropic OAuth users to claude-code provider when CLI is available (#3772).
+// Anthropic blocks third-party apps from using subscription quotas — routing through
+// the local claude CLI binary is TOS-compliant.
+if (modelRegistry.isProviderRequestReady('claude-code') && settingsManager.getDefaultProvider() === 'anthropic') {
+    const currentModelId = settingsManager.getDefaultModel();
+    if (currentModelId) {
+        const ccModel = modelRegistry.find('claude-code', currentModelId);
+        if (ccModel) {
+            try {
+                await session.setModel(ccModel);
+                // Only persist after successful session switch to avoid desync
+                settingsManager.setDefaultModelAndProvider('claude-code', currentModelId);
+            }
+            catch {
+                // claude-code provider not ready — leave both session and settings unchanged
+            }
+        }
+    }
+}
 // Validate configured model AFTER extensions have registered their models (#2626).
 // Before this, extension-provided models (e.g. claude-code/*) were not yet in the
 // registry, causing the user's valid choice to be silently overwritten.

package/dist/onboarding.js

@@ -14,6 +14,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { renderLogo } from './logo.js';
 import { agentDir } from './app-paths.js';
+import { isClaudeCliReady } from './claude-cli-check.js';
 // ─── Constants ────────────────────────────────────────────────────────────────
 const TOOL_KEYS = [
     {
@@ -39,6 +40,7 @@ const TOOL_KEYS = [
 const LLM_PROVIDER_IDS = [
     'anthropic',
     'anthropic-vertex',
+    'claude-code',
     'openai',
     'github-copilot',
     'openai-codex',
@@ -255,7 +257,12 @@ async function runLlmStep(p, pc, authStorage) {
     if (existingAuth) {
         authOptions.push({ value: 'keep', label: `Keep current (${existingAuth})`, hint: 'already configured' });
     }
-    authOptions.push({ value: 'browser', label: 'Sign in with your browser', hint: 'recommended — same login as claude.ai / ChatGPT' }, { value: 'api-key', label: 'Paste an API key', hint: 'from your provider dashboard' }, { value: 'skip', label: 'Skip for now', hint: 'use /login inside GSD later' });
+    // Show Claude Code CLI option at the top when the CLI is installed and authenticated (#3772).
+    // This is the only TOS-compliant path for Anthropic subscription users.
+    if (isClaudeCliReady()) {
+        authOptions.push({ value: 'claude-cli', label: 'Use Claude Code CLI', hint: 'recommended — uses your existing Claude subscription' });
+    }
+    authOptions.push({ value: 'browser', label: 'Sign in with your browser', hint: 'GitHub Copilot, ChatGPT, Google, etc.' }, { value: 'api-key', label: 'Paste an API key', hint: 'from your provider dashboard' }, { value: 'skip', label: 'Skip for now', hint: 'use /login inside GSD later' });
     const method = await p.select({
         message: existingAuth ? `LLM provider: ${existingAuth} — change it?` : 'How do you want to sign in?',
         options: authOptions,
@@ -264,12 +271,22 @@ async function runLlmStep(p, pc, authStorage) {
         return false;
     if (method === 'keep')
         return true;
+    // ── Claude Code CLI path (#3772) ────────────────────────────────────────
+    if (method === 'claude-cli') {
+        p.log.success('Claude Code CLI detected — routing through local CLI (TOS-compliant)');
+        p.log.info('Your Claude subscription will be used for inference. No API key needed.');
+        // Store sentinel so hasAuth('claude-code') returns true on future boots
+        authStorage.set('claude-code', { type: 'api_key', key: 'cli' });
+        return true;
+    }
     // ── Step 2: Which provider? ──────────────────────────────────────────────
     if (method === 'browser') {
+        // Anthropic OAuth is removed from browser auth — it violates Anthropic TOS for
+        // third-party apps (#3772). Anthropic subscription users should use the Claude
+        // Code CLI path (shown above when CLI is installed) or paste an API key.
         const provider = await p.select({
             message: 'Choose provider',
             options: [
-                { value: 'anthropic', label: 'Anthropic (Claude)', hint: 'recommended' },
                 { value: 'github-copilot', label: 'GitHub Copilot' },
                 { value: 'openai-codex', label: 'ChatGPT Plus/Pro (Codex)' },
                 { value: 'google-gemini-cli', label: 'Google Gemini CLI' },

package/dist/resources/extensions/ask-user-questions.js

@@ -58,6 +58,51 @@ export function questionSignature(questions) {
 export function resetAskUserQuestionsCache() {
     turnCache.clear();
 }
+/**
+ * Race a remote channel dispatch against the local TUI. The first to produce
+ * a valid (non-error, non-timeout) result wins. The loser is cancelled via
+ * the shared AbortController.
+ *
+ * If the local TUI responds first, the remote poll is aborted (the message
+ * stays in Discord/Slack but polling stops). If remote responds first, the
+ * local TUI prompt is cancelled.
+ *
+ * Returns null only when both sides fail or are cancelled.
+ */
+async function raceRemoteAndLocal(startRemote, startLocal, controller, questions) {
+    // Wrap local TUI result into the same shape as remote results
+    const localPromise = startLocal().then((result) => {
+        if (!result || Object.keys(result.answers).length === 0)
+            return null;
+        return {
+            content: [{ type: "text", text: formatForLLM(result) }],
+            details: { questions, response: result, cancelled: false },
+        };
+    }).catch(() => null);
+    const remotePromise = startRemote().then((result) => {
+        if (!result)
+            return null;
+        const details = result.details;
+        // Treat timeouts and errors as non-wins — let the local TUI win instead
+        if (details?.timed_out || details?.error)
+            return null;
+        return result;
+    }).catch(() => null);
+    // Race: first non-null result wins
+    const winner = await Promise.race([
+        localPromise.then((r) => r ? { source: "local", result: r } : null),
+        remotePromise.then((r) => r ? { source: "remote", result: r } : null),
+    ]);
+    if (winner) {
+        // Cancel the loser
+        controller.abort();
+        return winner.result;
+    }
+    // First to resolve was null — wait for the other
+    const [localResult, remoteResult] = await Promise.all([localPromise, remotePromise]);
+    controller.abort();
+    return localResult ?? remoteResult;
+}
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 const OTHER_OPTION_LABEL = "None of the above";
 function errorResult(message, questions = []) {
@@ -116,19 +161,42 @@ export default function AskUserQuestions(pi) {
                     return errorResult(`Error: ask_user_questions requires non-empty options for every question (question "${q.id}" has none)`, params.questions);
                 }
             }
-            // Try remote first if configured (works in both interactive and headless modes).
-            // tryRemoteQuestions returns null when no remote channel is configured, so
-            // this is a no-op when the user has not set up Slack/Discord/Telegram.
-            const { tryRemoteQuestions } = await import("./remote-questions/manager.js");
-            const remoteResult = await tryRemoteQuestions(params.questions, signal);
-            if (remoteResult) {
-                // Cache successful remote results to prevent duplicate Discord dispatches
-                const remoteDetails = remoteResult.details;
-                if (remoteDetails && !remoteDetails.timed_out && !remoteDetails.error) {
-                    turnCache.set(sig, remoteResult);
+            // ── Routing: race remote + local, remote-only, or local-only ────────
+            const { tryRemoteQuestions, isRemoteConfigured } = await import("./remote-questions/manager.js");
+            const hasRemote = isRemoteConfigured();
+            // Case 1: Both remote and local UI available — race them.
+            // The first response wins; the loser is cancelled via AbortController.
+            if (hasRemote && ctx.hasUI) {
+                const raceController = new AbortController();
+                // Merge the parent signal so external cancellation propagates.
+                const onParentAbort = () => raceController.abort();
+                signal?.addEventListener("abort", onParentAbort, { once: true });
+                const raceSignal = raceController.signal;
+                const raceResult = await raceRemoteAndLocal(() => tryRemoteQuestions(params.questions, raceSignal), () => showInterviewRound(params.questions, { signal: raceSignal }, ctx), raceController, params.questions);
+                signal?.removeEventListener("abort", onParentAbort);
+                if (raceResult) {
+                    const details = raceResult.details;
+                    if (details && !details.timed_out && !details.error && !details.cancelled) {
+                        turnCache.set(sig, raceResult);
+                    }
+                    return { ...raceResult, details: raceResult.details };
+                }
+                // Both sides failed/cancelled — fall through to error
+                return errorResult("ask_user_questions: no response received from local UI or remote channel", params.questions);
+            }
+            // Case 2: Remote configured but no local UI (headless) — remote only.
+            if (hasRemote && !ctx.hasUI) {
+                const remoteResult = await tryRemoteQuestions(params.questions, signal);
+                if (remoteResult) {
+                    const remoteDetails = remoteResult.details;
+                    if (remoteDetails && !remoteDetails.timed_out && !remoteDetails.error) {
+                        turnCache.set(sig, remoteResult);
+                    }
+                    return { ...remoteResult, details: remoteResult.details };
                 }
-                return { ...remoteResult, details: remoteResult.details };
+                return errorResult("Error: remote channel configured but returned no result", params.questions);
             }
+            // Case 3: No remote — local UI only.
             if (!ctx.hasUI) {
                 return errorResult("Error: UI not available (non-interactive mode)", params.questions);
             }

package/dist/resources/extensions/claude-code-cli/partial-builder.js

@@ -4,7 +4,7 @@
  * Translates the Claude Agent SDK's `BetaRawMessageStreamEvent` sequence
  * into GSD's `AssistantMessageEvent` deltas for incremental TUI rendering.
  */
-import { repairToolJson } from "@gsd/pi-ai";
+import { hasXmlParameterTags, repairToolJson } from "@gsd/pi-ai";
 // ---------------------------------------------------------------------------
 // Content-block mapping helpers
 // ---------------------------------------------------------------------------
@@ -207,14 +207,15 @@ export class PartialMessageBuilder {
                 }
                 if (block.type === "toolCall") {
                     const jsonStr = this.toolJsonAccum.get(streamIndex) ?? "{}";
+                    const jsonForParse = hasXmlParameterTags(jsonStr) ? repairToolJson(jsonStr) : jsonStr;
                     try {
-                        block.arguments = JSON.parse(jsonStr);
+                        block.arguments = JSON.parse(jsonForParse);
                     }
                     catch {
                         // JSON.parse failed — attempt repair for YAML-style bullet
                         // lists that LLMs copy from template formatting (#2660).
                         try {
-                            block.arguments = JSON.parse(repairToolJson(jsonStr));
+                            block.arguments = JSON.parse(repairToolJson(jsonForParse));
                         }
                         catch {
                             // Repair also failed — stream was truncated or garbage.

package/dist/resources/extensions/claude-code-cli/readiness.js

@@ -1,26 +1,77 @@
 /**
  * Readiness check for the Claude Code CLI provider.
  *
- * Verifies the `claude` binary is installed and responsive.
- * Result is cached for 30 seconds to avoid shelling out on every
+ * Verifies the `claude` binary is installed, responsive, AND authenticated.
+ * Results are cached for 30 seconds to avoid shelling out on every
  * model-availability check.
+ *
+ * Auth verification follows the T3 Code pattern: run `claude auth status`
+ * and check the exit code + output for an authenticated session.
  */
-import { execSync } from "node:child_process";
-let cachedReady = null;
+import { execFileSync } from "node:child_process";
+let cachedBinaryPresent = null;
+let cachedAuthed = null;
 let lastCheckMs = 0;
 const CHECK_INTERVAL_MS = 30_000;
-export function isClaudeCodeReady() {
+function refreshCache() {
     const now = Date.now();
-    if (cachedReady !== null && now - lastCheckMs < CHECK_INTERVAL_MS) {
-        return cachedReady;
+    if (cachedBinaryPresent !== null && now - lastCheckMs < CHECK_INTERVAL_MS) {
+        return;
     }
+    // Set timestamp first to prevent re-entrant checks during the same window
+    lastCheckMs = now;
+    // Check binary presence
     try {
-        execSync("claude --version", { timeout: 5_000, stdio: "pipe" });
-        cachedReady = true;
+        execFileSync("claude", ["--version"], { timeout: 5_000, stdio: "pipe" });
+        cachedBinaryPresent = true;
     }
     catch {
-        cachedReady = false;
+        cachedBinaryPresent = false;
+        cachedAuthed = false;
+        return;
     }
-    lastCheckMs = now;
-    return cachedReady;
+    // Check auth status — exit code 0 with non-error output means authenticated
+    try {
+        const output = execFileSync("claude", ["auth", "status"], { timeout: 5_000, stdio: "pipe" })
+            .toString()
+            .toLowerCase();
+        // The CLI outputs "not logged in", "no credentials", or similar when unauthenticated
+        cachedAuthed = !(/not logged in|no credentials|unauthenticated|not authenticated/i.test(output));
+    }
+    catch {
+        // Non-zero exit code means not authenticated
+        cachedAuthed = false;
+    }
+}
+/**
+ * Whether the `claude` binary is installed (regardless of auth state).
+ */
+export function isClaudeBinaryPresent() {
+    refreshCache();
+    return cachedBinaryPresent ?? false;
+}
+/**
+ * Whether the `claude` CLI is authenticated with a valid session.
+ * Returns false if the binary is not installed.
+ */
+export function isClaudeCodeAuthed() {
+    refreshCache();
+    return (cachedBinaryPresent ?? false) && (cachedAuthed ?? false);
+}
+/**
+ * Full readiness check: binary installed AND authenticated.
+ * This is the gating function used by the provider registration.
+ */
+export function isClaudeCodeReady() {
+    refreshCache();
+    return (cachedBinaryPresent ?? false) && (cachedAuthed ?? false);
+}
+/**
+ * Force-clear the cached readiness state.
+ * Useful after the user completes auth setup so the next check is fresh.
+ */
+export function clearReadinessCache() {
+    cachedBinaryPresent = null;
+    cachedAuthed = null;
+    lastCheckMs = 0;
 }

package/dist/resources/extensions/claude-code-cli/stream-adapter.js

@@ -29,6 +29,15 @@ function createAssistantStream() {
 // Claude binary resolution
 // ---------------------------------------------------------------------------
 let cachedClaudePath = null;
+export function getClaudeLookupCommand(platform = process.platform) {
+    return platform === "win32" ? "where claude" : "which claude";
+}
+export function parseClaudeLookupOutput(output) {
+    return output
+        .toString()
+        .trim()
+        .split(/\r?\n/)[0] ?? "";
+}
 /**
  * Resolve the path to the system-installed `claude` binary.
  * The SDK defaults to a bundled cli.js which doesn't exist when
@@ -38,9 +47,7 @@ function getClaudePath() {
     if (cachedClaudePath)
         return cachedClaudePath;
     try {
-        cachedClaudePath = execSync("which claude", { timeout: 5_000, stdio: "pipe" })
-            .toString()
-            .trim();
+        cachedClaudePath = parseClaudeLookupOutput(execSync(getClaudeLookupCommand(), { timeout: 5_000, stdio: "pipe" }));
     }
     catch {
         cachedClaudePath = "claude"; // fall back to PATH resolution

package/dist/resources/extensions/gsd/auto/loop.js

@@ -150,7 +150,7 @@ export async function autoLoop(ctx, pi, s, deps) {
                 }
                 // Verification passed — mark step complete
                 debugLog("autoLoop", { phase: "custom-engine-reconcile", iteration, unitId: iterData.unitId });
-                await engine.reconcile(engineState, {
+                const reconcileResult = await engine.reconcile(engineState, {
                     unitType: iterData.unitType,
                     unitId: iterData.unitId,
                     startedAt: s.currentUnit?.startedAt ?? Date.now(),
@@ -161,6 +161,18 @@ export async function autoLoop(ctx, pi, s, deps) {
                 recentErrorMessages.length = 0;
                 deps.emitJournalEvent({ ts: new Date().toISOString(), flowId, seq: nextSeq(), eventType: "iteration-end", data: { iteration } });
                 debugLog("autoLoop", { phase: "iteration-complete", iteration });
+                if (reconcileResult.outcome === "milestone-complete") {
+                    await deps.stopAuto(ctx, pi, "Workflow complete");
+                    break;
+                }
+                if (reconcileResult.outcome === "pause") {
+                    await deps.pauseAuto(ctx, pi);
+                    break;
+                }
+                if (reconcileResult.outcome === "stop") {
+                    await deps.stopAuto(ctx, pi, reconcileResult.reason ?? "Engine stopped");
+                    break;
+                }
                 continue;
             }
             if (!sidecarItem) {

package/dist/resources/extensions/gsd/auto/phases.js

@@ -338,7 +338,13 @@ export async function runPreDispatch(ic, loopState) {
         ctx.ui.notify(`Milestone ${mid} has no title in roadmap — using ID as fallback.`, "warning");
     }
     // Mid-merge safety check
-    if (deps.reconcileMergeState(s.basePath, ctx)) {
+    const mergeReconcileResult = deps.reconcileMergeState(s.basePath, ctx);
+    if (mergeReconcileResult === "blocked") {
+        await deps.pauseAuto(ctx, pi);
+        debugLog("autoLoop", { phase: "exit", reason: "merge-reconciliation-blocked" });
+        return { action: "break", reason: "merge-reconciliation-blocked" };
+    }
+    if (mergeReconcileResult === "reconciled") {
         deps.invalidateAllCaches();
         state = await deps.deriveState(s.basePath);
         mid = state.activeMilestone?.id;
@@ -947,8 +953,21 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
             debugLog("autoLoop", { phase: "exit", reason: "provider-pause", isTransient: unitResult.errorContext.isTransient });
             return { action: "break", reason: "provider-pause" };
         }
-        ctx.ui.notify(`Session creation timed out or was cancelled for ${unitType} ${unitId}. Will retry.`, "warning");
-        await deps.stopAuto(ctx, pi, "Session creation failed");
+        // Session creation timeout (not a structural error): pause auto-mode
+        // and let the provider-error-resume timer handle recovery (#3767). This
+        // matches the provider-pause path — break out cleanly, don't hard-stop.
+        // Structural errors (TypeError, is not a function) are NOT transient
+        // and must hard-stop to avoid infinite retry loops.
+        if (unitResult.errorContext?.isTransient &&
+            unitResult.errorContext?.category === "timeout") {
+            ctx.ui.notify(`Session creation timed out for ${unitType} ${unitId}. Pausing auto-mode (recoverable).`, "warning");
+            debugLog("autoLoop", { phase: "session-timeout-pause", unitType, unitId });
+            await deps.pauseAuto(ctx, pi);
+            return { action: "break", reason: "session-timeout" };
+        }
+        // All other cancelled states (structural errors, non-transient failures): hard stop
+        ctx.ui.notify(`Session creation failed for ${unitType} ${unitId}: ${unitResult.errorContext?.message ?? "unknown"}. Stopping auto-mode.`, "warning");
+        await deps.stopAuto(ctx, pi, `Session creation failed: ${unitResult.errorContext?.message ?? "unknown"}`);
         debugLog("autoLoop", { phase: "exit", reason: "session-failed" });
         return { action: "break", reason: "session-failed" };
     }

package/dist/resources/extensions/gsd/auto/run-unit.js

@@ -7,6 +7,10 @@ import { NEW_SESSION_TIMEOUT_MS } from "./session.js";
 import { _setCurrentResolve, _setSessionSwitchInFlight } from "./resolve.js";
 import { debugLog } from "../debug-logger.js";
 import { logWarning } from "../workflow-logger.js";
+import { resolveAutoSupervisorConfig } from "../preferences.js";
+// Tracks the latest session-switch attempt so a late timeout settlement from an
+// older runUnit() call cannot clear the guard for a newer one.
+let sessionSwitchGeneration = 0;
 /**
  * Execute a single unit: create a new session, send the prompt, and await
  * the agent_end promise. Returns a UnitResult describing what happened.
@@ -21,10 +25,13 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     debugLog("runUnit", { phase: "session-create", unitType, unitId });
     let sessionResult;
     let sessionTimeoutHandle;
+    const mySessionSwitchGeneration = ++sessionSwitchGeneration;
     _setSessionSwitchInFlight(true);
     try {
         const sessionPromise = s.cmdCtx.newSession().finally(() => {
-            _setSessionSwitchInFlight(false);
+            if (sessionSwitchGeneration === mySessionSwitchGeneration) {
+                _setSessionSwitchInFlight(false);
+            }
         });
         const timeoutPromise = new Promise((resolve) => {
             sessionTimeoutHandle = setTimeout(() => resolve({ cancelled: true }), NEW_SESSION_TIMEOUT_MS);
@@ -83,7 +90,8 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     // If supervision fails to resolve unitPromise within 30s, treat as cancelled.
     // Without this, a crashed agent that never emits agent_end hangs the loop (#3161).
     debugLog("runUnit", { phase: "awaiting-agent-end", unitType, unitId });
-    const UNIT_HARD_TIMEOUT_MS = 30_000;
+    const supervisor = resolveAutoSupervisorConfig();
+    const UNIT_HARD_TIMEOUT_MS = Math.max(30_000, ((supervisor.hard_timeout_minutes ?? 30) * 60 * 1000) + 30_000);
     let unitTimeoutHandle;
     const timeoutResult = new Promise((resolve) => {
         unitTimeoutHandle = setTimeout(() => {

package/dist/resources/extensions/gsd/auto/session.js

@@ -19,7 +19,7 @@
 export const MAX_UNIT_DISPATCHES = 3;
 export const STUB_RECOVERY_THRESHOLD = 2;
 export const MAX_LIFETIME_DISPATCHES = 6;
-export const NEW_SESSION_TIMEOUT_MS = 30_000;
+export const NEW_SESSION_TIMEOUT_MS = 120_000;
 // ─── AutoSession ─────────────────────────────────────────────────────────────
 export class AutoSession {
     // ── Lifecycle ────────────────────────────────────────────────────────────