gsd-pi 2.66.1-dev.3c26b49 → 2.66.1-dev.3cea7ac

package/packages/pi-tui/src/autocomplete.ts

@@ -159,6 +159,7 @@ export class CombinedAutocompleteProvider implements AutocompleteProvider {
 	): { items: AutocompleteItem[]; prefix: string } | null {
 		const currentLine = lines[cursorLine] || "";
 		const textBeforeCursor = currentLine.slice(0, cursorCol);
+		const trimmedBeforeCursor = textBeforeCursor.trimStart();
 
 		// Check for @ file reference (fuzzy search) - must be after a delimiter or at start
 		const atPrefix = this.extractAtPrefix(textBeforeCursor);
@@ -174,12 +175,12 @@ export class CombinedAutocompleteProvider implements AutocompleteProvider {
 		}
 
 		// Check for slash commands
-		if (textBeforeCursor.startsWith("/")) {
-			const spaceIndex = textBeforeCursor.indexOf(" ");
+		if (trimmedBeforeCursor.startsWith("/")) {
+			const spaceIndex = trimmedBeforeCursor.indexOf(" ");
 
 			if (spaceIndex === -1) {
 				// No space yet - complete command names with fuzzy matching
-				const prefix = textBeforeCursor.slice(1); // Remove the "/"
+				const prefix = trimmedBeforeCursor.slice(1); // Remove the "/"
 				const commandItems = this.commands.map((cmd) => ({
 					name: "name" in cmd ? cmd.name : cmd.value,
 					label: "name" in cmd ? cmd.name : cmd.label,
@@ -196,12 +197,12 @@ export class CombinedAutocompleteProvider implements AutocompleteProvider {
 
 				return {
 					items: filtered,
-					prefix: textBeforeCursor,
+					prefix: `/${prefix}`,
 				};
 			} else {
 				// Space found - complete command arguments
-				const commandName = textBeforeCursor.slice(1, spaceIndex); // Command without "/"
-				const argumentText = textBeforeCursor.slice(spaceIndex + 1); // Text after space
+				const commandName = trimmedBeforeCursor.slice(1, spaceIndex); // Command without "/"
+				const argumentText = trimmedBeforeCursor.slice(spaceIndex + 1); // Text after space
 
 				const command = this.commands.find((cmd) => {
 					const name = "name" in cmd ? cmd.name : cmd.value;
@@ -269,7 +270,8 @@ export class CombinedAutocompleteProvider implements AutocompleteProvider {
 
 		// Check if we're completing a slash command (prefix starts with "/" but NOT a file path)
 		// Slash commands are at the start of the line and don't contain path separators after the first /
-		const isSlashCommand = prefix.startsWith("/") && beforePrefix.trim() === "" && !prefix.slice(1).includes("/");
+		const trimmedPrefix = prefix.trimStart();
+		const isSlashCommand = trimmedPrefix.startsWith("/") && beforePrefix.trim() === "" && !trimmedPrefix.slice(1).includes("/");
 		if (isSlashCommand) {
 			// This is a command name completion
 			const newLine = `${beforePrefix}/${item.value} ${adjustedAfterCursor}`;

package/packages/pi-tui/src/components/__tests__/editor.test.ts

@@ -0,0 +1,64 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+import { Editor, type EditorTheme } from "../editor.js";
+import { CURSOR_MARKER, TUI } from "../../tui.js";
+import type { Terminal } from "../../terminal.js";
+
+function makeTerminal(): Terminal {
+	return {
+		isTTY: true,
+		columns: 80,
+		rows: 24,
+		kittyProtocolActive: false,
+		start() {},
+		stop() {},
+		drainInput: async () => {},
+		write() {},
+		moveBy() {},
+		hideCursor() {},
+		showCursor() {},
+		clearLine() {},
+		clearFromCursor() {},
+		clearScreen() {},
+		setTitle() {},
+	};
+}
+
+const theme: EditorTheme = {
+	borderColor: (text) => text,
+	selectList: {
+		selectedPrefix: (text) => text,
+		selectedText: (text) => text,
+		description: (text) => text,
+		scrollInfo: (text) => text,
+		noMatch: (text) => text,
+	},
+};
+
+describe("Editor", () => {
+	it("clears bracketed paste state when focus is lost", () => {
+		const editor = new Editor(new TUI(makeTerminal()), theme);
+		editor.focused = true;
+
+		editor.handleInput("\x1b[200~partial");
+		editor.focused = false;
+		editor.focused = true;
+		editor.handleInput("hello");
+
+		assert.equal(editor.getText(), "hello");
+	});
+
+	it("keeps the hardware cursor marker visible while autocomplete is open", () => {
+		const editor = new Editor(new TUI(makeTerminal()), theme);
+		editor.focused = true;
+		editor.setText("/se");
+
+		(editor as any).autocompleteState = "regular";
+		(editor as any).autocompleteList = { render: () => [] };
+
+		const rendered = editor.render(40).join("\n");
+
+		assert.ok(rendered.includes(CURSOR_MARKER));
+	});
+});

package/packages/pi-tui/src/components/editor.ts

@@ -128,7 +128,17 @@ export class Editor implements Component, Focusable {
 	};
 
 	/** Focusable interface - set by TUI when focus changes */
-	focused: boolean = false;
+	private _focused: boolean = false;
+	get focused(): boolean {
+		return this._focused;
+	}
+	set focused(value: boolean) {
+		this._focused = value;
+		if (!value) {
+			this.isInPaste = false;
+			this.pasteBuffer = "";
+		}
+	}
 
 	protected tui: TUI;
 	private theme: EditorTheme;
@@ -376,8 +386,9 @@ export class Editor implements Component, Focusable {
 		}
 
 		// Render each visible layout line
-		// Emit hardware cursor marker only when focused and not showing autocomplete
-		const emitCursorMarker = this.focused && !this.autocompleteState;
+		// Keep the hardware cursor anchored while autocomplete is open so IME
+		// candidate windows still attach to the editor caret.
+		const emitCursorMarker = this.focused;
 
 		for (const layoutLine of visibleLines) {
 			let displayText = layoutLine.text;

package/packages/pi-tui/src/stdin-buffer.ts

@@ -361,6 +361,13 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 			return [];
 		}
 
+		// Keep incomplete escape prefixes buffered so split CSI/mouse/focus
+		// sequences do not get emitted as literal text on timeout.
+		// A lone ESC is still flushed so an actual Escape keypress is not lost.
+		if (this.buffer.length > 1 && this.buffer.startsWith(ESC) && isCompleteSequence(this.buffer) === "incomplete") {
+			return [];
+		}
+
 		const sequences = [this.buffer];
 		this.buffer = "";
 		return sequences;

package/packages/pi-tui/src/tui.ts

@@ -590,6 +590,15 @@ export class TUI extends Container {
 			this.cellSizeQueryPending = false;
 		}
 
+		// Don't hold a bare Escape keypress hostage while waiting for the
+		// optional cell-size response. This is the most common early input race.
+		if (this.inputBuffer === "\x1b") {
+			const result = this.inputBuffer;
+			this.inputBuffer = "";
+			this.cellSizeQueryPending = false;
+			return result;
+		}
+
 		// Check if we have a partial cell size response starting (wait for more data)
 		// Patterns that could be incomplete cell size response: \x1b, \x1b[, \x1b[6, \x1b[6;...(no t yet)
 		const partialCellSizePattern = /\x1b(\[6?;?[\d;]*)?$/;

package/src/resources/extensions/ask-user-questions.ts

@@ -107,6 +107,65 @@ export function resetAskUserQuestionsCache(): void {
 	turnCache.clear();
 }
 
+// ─── Race helper ─────────────────────────────────────────────────────────────
+
+interface RaceableResult {
+	content: { type: "text"; text: string }[];
+	details?: unknown;
+}
+
+/**
+ * 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: () => Promise<RaceableResult | null>,
+	startLocal: () => Promise<RoundResult | null | undefined>,
+	controller: AbortController,
+	questions: Question[],
+): Promise<RaceableResult | null> {
+	// Wrap local TUI result into the same shape as remote results
+	const localPromise = startLocal().then((result): RaceableResult | null => {
+		if (!result || Object.keys(result.answers).length === 0) return null;
+		return {
+			content: [{ type: "text" as const, text: formatForLLM(result) }],
+			details: { questions, response: result, cancelled: false } satisfies LocalResultDetails,
+		};
+	}).catch(() => null);
+
+	const remotePromise = startRemote().then((result): RaceableResult | null => {
+		if (!result) return null;
+		const details = result.details as Record<string, unknown> | undefined;
+		// 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" as const, result: r } : null),
+		remotePromise.then((r) => r ? { source: "remote" as const, 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";
@@ -180,20 +239,53 @@ export default function AskUserQuestions(pi: ExtensionAPI) {
 				}
 			}
 
-			// 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 as Record<string, unknown> | undefined;
-				if (remoteDetails && !remoteDetails.timed_out && !remoteDetails.error) {
-					turnCache.set(sig, remoteResult as unknown as CachedResult);
+			// ── 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 as any),
+					raceController,
+					params.questions,
+				);
+
+				signal?.removeEventListener("abort", onParentAbort);
+
+				if (raceResult) {
+					const details = raceResult.details as Record<string, unknown> | undefined;
+					if (details && !details.timed_out && !details.error && !details.cancelled) {
+						turnCache.set(sig, raceResult as unknown as CachedResult);
+					}
+					return { ...raceResult, details: raceResult.details as unknown };
+				}
+				// 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 as Record<string, unknown> | undefined;
+					if (remoteDetails && !remoteDetails.timed_out && !remoteDetails.error) {
+						turnCache.set(sig, remoteResult as unknown as CachedResult);
+					}
+					return { ...remoteResult, details: remoteResult.details as unknown };
 				}
-				return { ...remoteResult, details: remoteResult.details as unknown };
+				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/src/resources/extensions/claude-code-cli/partial-builder.ts

@@ -16,7 +16,7 @@ import type {
 	Usage,
 	WebSearchResultContent,
 } from "@gsd/pi-ai";
-import { repairToolJson } from "@gsd/pi-ai";
+import { hasXmlParameterTags, repairToolJson } from "@gsd/pi-ai";
 import type { BetaContentBlock, BetaRawMessageStreamEvent, NonNullableUsage } from "./sdk-types.js";
 
 // ---------------------------------------------------------------------------
@@ -242,13 +242,14 @@ 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.
 							// Preserve the raw string for diagnostics but signal the

package/src/resources/extensions/claude-code-cli/stream-adapter.ts

@@ -50,6 +50,17 @@ function createAssistantStream(): AssistantMessageEventStream {
 
 let cachedClaudePath: string | null = null;
 
+export function getClaudeLookupCommand(platform: NodeJS.Platform = process.platform): string {
+	return platform === "win32" ? "where claude" : "which claude";
+}
+
+export function parseClaudeLookupOutput(output: Buffer | string): string {
+	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
@@ -58,9 +69,7 @@ let cachedClaudePath: string | null = null;
 function getClaudePath(): string {
 	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/src/resources/extensions/claude-code-cli/tests/partial-builder.test.ts

@@ -130,4 +130,21 @@ describe("PartialMessageBuilder — malformed tool arguments (#2574)", () => {
 			assert.equal(event!.toolCall.arguments.title, "done");
 		}
 	});
+
+	test("XML parameter tags trapped inside valid JSON strings are promoted (#3751)", () => {
+		const builder = new PartialMessageBuilder("claude-sonnet-4-20250514");
+		const malformedJson =
+			'{"narrative":"text.</narrative>\\n<parameter name=\\"verification\\">all tests pass</parameter>\\n<parameter name=\\"verificationEvidence\\">[\\"npm test\\"]</parameter>","oneLiner":"done"}';
+		const event = feedToolCall(builder, [malformedJson]);
+
+		assert.ok(event, "event should not be null");
+		assert.equal(event!.type, "toolcall_end");
+		assert.equal((event as any).malformedArguments, undefined);
+		if (event!.type === "toolcall_end") {
+			assert.equal(event.toolCall.arguments.narrative, "text.");
+			assert.equal(event.toolCall.arguments.verification, "all tests pass");
+			assert.deepEqual(event.toolCall.arguments.verificationEvidence, ["npm test"]);
+			assert.equal(event.toolCall.arguments.oneLiner, "done");
+		}
+	});
 });

package/src/resources/extensions/claude-code-cli/tests/stream-adapter.test.ts

@@ -4,6 +4,8 @@ import {
 	makeStreamExhaustedErrorMessage,
 	buildPromptFromContext,
 	buildSdkOptions,
+	getClaudeLookupCommand,
+	parseClaudeLookupOutput,
 } from "../stream-adapter.ts";
 import type { Context, Message } from "@gsd/pi-ai";
 
@@ -126,3 +128,19 @@ describe("stream-adapter — session persistence (#2859)", () => {
 		);
 	});
 });
+
+describe("stream-adapter — Windows Claude path lookup (#3770)", () => {
+	test("getClaudeLookupCommand uses where on Windows", () => {
+		assert.equal(getClaudeLookupCommand("win32"), "where claude");
+	});
+
+	test("getClaudeLookupCommand uses which on non-Windows platforms", () => {
+		assert.equal(getClaudeLookupCommand("darwin"), "which claude");
+		assert.equal(getClaudeLookupCommand("linux"), "which claude");
+	});
+
+	test("parseClaudeLookupOutput keeps the first native path from multi-line lookup output", () => {
+		const output = "C:\\Users\\Binoy\\.local\\bin\\claude.exe\r\nC:\\Program Files\\Claude\\claude.exe\r\n";
+		assert.equal(parseClaudeLookupOutput(output), "C:\\Users\\Binoy\\.local\\bin\\claude.exe");
+	});
+});

package/src/resources/extensions/gsd/auto/loop-deps.ts

@@ -20,6 +20,7 @@ import type { DispatchAction } from "../auto-dispatch.js";
 import type { WorktreeResolver } from "../worktree-resolver.js";
 import type { CmuxLogLevel } from "../../cmux/index.js";
 import type { JournalEntry } from "../journal.js";
+import type { MergeReconcileResult } from "../auto-recovery.js";
 
 /**
  * Dependencies injected by the caller (auto.ts startAuto) so autoLoop
@@ -118,7 +119,7 @@ export interface LoopDeps {
     milestoneId: string,
     fileType: string,
   ) => string | null;
-  reconcileMergeState: (basePath: string, ctx: ExtensionContext) => boolean;
+  reconcileMergeState: (basePath: string, ctx: ExtensionContext) => MergeReconcileResult;
 
   // Budget/context/secrets
   getLedger: () => unknown;

package/src/resources/extensions/gsd/auto/loop.ts

@@ -194,7 +194,7 @@ export async function autoLoop(
 
         // 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(),
@@ -206,6 +206,19 @@ export async function autoLoop(
         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;
       }
 

package/src/resources/extensions/gsd/auto/phases.ts

@@ -507,7 +507,13 @@ export async function runPreDispatch(
   }
 
   // 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;
@@ -1303,8 +1309,8 @@ export async function runUnitPhase(
       return { action: "break", reason: "provider-pause" };
     }
     // Session creation timeout (not a structural error): pause auto-mode
-    // and let the provider-error-resume timer handle recovery. This matches
-    // the provider-pause path — break out cleanly, don't hard-stop.
+    // 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 (
@@ -1312,7 +1318,7 @@ export async function runUnitPhase(
       unitResult.errorContext?.category === "timeout"
     ) {
       ctx.ui.notify(
-        `Session creation timed out for ${unitType} ${unitId}. Will retry.`,
+        `Session creation timed out for ${unitType} ${unitId}. Pausing auto-mode (recoverable).`,
         "warning",
       );
       debugLog("autoLoop", { phase: "session-timeout-pause", unitType, unitId });
@@ -1639,4 +1645,3 @@ export async function runFinalize(
 
   return { action: "next", data: undefined as void };
 }
-

package/src/resources/extensions/gsd/auto/run-unit.ts

@@ -12,6 +12,11 @@ import type { UnitResult } from "./types.js";
 import { _setCurrentResolve, _setSessionSwitchInFlight } from "./resolve.js";
 import { debugLog } from "../debug-logger.js";
 import { logWarning, logError } 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
@@ -36,10 +41,13 @@ export async function runUnit(
 
   let sessionResult: { cancelled: boolean };
   let sessionTimeoutHandle: ReturnType<typeof setTimeout> | undefined;
+  const mySessionSwitchGeneration = ++sessionSwitchGeneration;
   _setSessionSwitchInFlight(true);
   try {
     const sessionPromise = s.cmdCtx!.newSession().finally(() => {
-      _setSessionSwitchInFlight(false);
+      if (sessionSwitchGeneration === mySessionSwitchGeneration) {
+        _setSessionSwitchInFlight(false);
+      }
     });
     const timeoutPromise = new Promise<{ cancelled: true }>((resolve) => {
       sessionTimeoutHandle = setTimeout(
@@ -112,7 +120,11 @@ export async function runUnit(
   // 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: ReturnType<typeof setTimeout> | undefined;
   const timeoutResult = new Promise<UnitResult>((resolve) => {
     unitTimeoutHandle = setTimeout(() => {

package/src/resources/extensions/gsd/auto/session.ts

@@ -67,7 +67,7 @@ export interface SidecarItem {
 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 ─────────────────────────────────────────────────────────────