@bastani/atomic 0.9.4 → 0.9.5-alpha.10

package/dist/builtin/workflows/src/runs/foreground/executor-hil.ts

@@ -310,7 +310,7 @@ export function toolResultHasChatAnswer(result: unknown): boolean {
   );
 }
 
-export const RESUME_CONTINUATION_PROMPT = "Continue where you left off.";
+export { RESUME_CONTINUATION_PROMPT } from "../../shared/resume-continuation.js";
 
 export function shouldInjectResumeContinuation(state: {
   readonly resumeOccurred: boolean;

package/dist/builtin/workflows/src/runs/foreground/executor-stage-control.ts

@@ -1,6 +1,7 @@
 import type { StageControlHandle, AgentSessionEventListener } from "./stage-control-registry.js";
 import type { LiveStageRuntime } from "./executor-stage-types.js";
 import { isTerminalStage } from "./executor-scheduler.js";
+import { StageToolExecutionBuffer } from "./stage-tool-execution-buffer.js";
 
 export function createStageControlHandle(runtime: LiveStageRuntime): StageControlHandle {
   const ensureMessagingSession = async (): Promise<void> => {
@@ -15,6 +16,8 @@ export function createStageControlHandle(runtime: LiveStageRuntime): StageContro
       throw new Error(`atomic-workflows: cannot message stage "${runtime.name}" because no retained session metadata is available.`);
     }
   };
+  const toolExecutions = new StageToolExecutionBuffer();
+  const unsubscribeToolExecutions = runtime.innerCtx.subscribe((event) => toolExecutions.record(event));
 
   return {
     runId: runtime.runId,
@@ -41,6 +44,9 @@ export function createStageControlHandle(runtime: LiveStageRuntime): StageContro
     get agentSession() {
       return runtime.innerCtx.__agentSession();
     },
+    pendingToolExecutionEvents() {
+      return toolExecutions.replayEvents();
+    },
     async ensureAttached() {
       runtime.throwIfStageMutationBlocked();
       await ensureMessagingSession();
@@ -120,6 +126,8 @@ export function createStageControlHandle(runtime: LiveStageRuntime): StageContro
       return runtime.innerCtx.subscribe(listener);
     },
     async dispose() {
+      unsubscribeToolExecutions();
+      toolExecutions.clear();
       await runtime.releaseLiveHandle();
     },
   };

package/dist/builtin/workflows/src/runs/foreground/executor-stage-factory.ts

@@ -24,7 +24,7 @@ import type { LiveStageMutableState, LiveStageRuntime, StageContextWithMeta, Sta
 import { createStageControlHandle } from "./executor-stage-control.js";
 import { createTrackedStageCaller } from "./executor-stage-call.js";
 import { createStageContext } from "./executor-stage-context.js";
-import { stageOptionsWithGitWorktree, stageOptionsWithInputDefaults } from "./executor-direct-helpers.js";
+import { stageOptionsWithGitWorktree, stageOptionsWithInputDefaults, type GitWorktreeSetupCache } from "./executor-direct-helpers.js";
 
 export function createWorkflowStageFactory(input: {
   readonly runId: string;
@@ -38,6 +38,7 @@ export function createWorkflowStageFactory(input: {
   readonly limiter: ConcurrencyLimiter;
   readonly inputRuntimeDefaults: Partial<StageOptions>;
   readonly workflowInvocationCwd: string;
+  readonly gitWorktreeSetupCache: GitWorktreeSetupCache;
   readonly stageRegistry: StageControlRegistry;
   readonly exit: WorkflowExitManager;
   readonly classifyExecutorFailure: (error: unknown) => WorkflowFailure;
@@ -45,7 +46,7 @@ export function createWorkflowStageFactory(input: {
 }): (name: string, options?: StageOptions, stageFailFastScope?: ParallelFailFastScope) => StageContextWithMeta {
   return (name: string, options?: StageOptions, stageFailFastScope?: ParallelFailFastScope): StageContextWithMeta => {
     input.exit.throwIfWorkflowExitSelected();
-    options = stageOptionsWithGitWorktree(stageOptionsWithInputDefaults(options, input.inputRuntimeDefaults), input.workflowInvocationCwd);
+    options = stageOptionsWithGitWorktree(stageOptionsWithInputDefaults(options, input.inputRuntimeDefaults), input.workflowInvocationCwd, input.gitWorktreeSetupCache);
     const stageId = crypto.randomUUID();
     const provisionalParentIds = input.tracker.onSpawn(stageId, name);
     const scopedParentIds = input.opts.continuation === undefined ? stageFailFastScope?.parentIds : undefined;
@@ -54,7 +55,7 @@ export function createWorkflowStageFactory(input: {
       input.tracker.replaceParents(stageId, scopedParentIds);
     }
 
-    const replayKey = `stage:${name}`;
+    const replayKey = options?.durableReplayKey ?? `stage:${name}`;
     const replayDecision = input.replayIndex.decide({
       displayName: name,
       replayKey,

package/dist/builtin/workflows/src/runs/foreground/stage-control-registry.ts

@@ -59,6 +59,8 @@ export interface StageControlHandle {
   readonly messages: AgentSession["messages"];
   /** Live coding-agent session when available, used by embedded chat/footer UI. */
   readonly agentSession?: AgentSession;
+  /** Replayable in-flight tool starts/partial updates for stage-chat remounts. */
+  pendingToolExecutionEvents?(): readonly AgentSessionEvent[];
   /** Ensure the SDK session exists. Cheap when already attached. */
   ensureAttached(): Promise<void>;
   /** Send a prompt. Use only when the stage is idle / not streaming. */

package/dist/builtin/workflows/src/runs/foreground/stage-runner-controller.ts

@@ -6,6 +6,7 @@ import { missingAdapter, stripWorkflowOnlyOptions, unavailableSync } from "./sta
 import { asAgentSession, disposeStageSession, normalizeSessionCreateResult } from "./stage-runner-session.js";
 import { structuredOutputToolErrorFromEvent } from "./stage-runner-structured-output.js";
 import { sendStageUserMessage } from "./stage-runner-send-user-message.js";
+import { nextResumedContextOverflowFallbackIndex, terminatingToolCallId, unresolvedContextOverflowFailure, unresolvedContextOverflowMessage } from "./stage-runner-unresolved-overflow.js";
 import type { AgentSessionConsumer, StageModelFallbackMeta, StageRunnerOpts, StageSessionCreateOptions, StageSessionCreateResult, StageSessionEvent, StageSessionRuntime, WorkflowFastModeSettingsManager } from "./stage-runner-types.js";
 
 type PauseRequest = {
@@ -19,6 +20,7 @@ export class StageSessionController {
   private readonly terminatingToolCallIds = new Set<string>();
   private latestStructuredOutputToolErrorValue: string | undefined;
   private unsubscribeTerminateWatcher: (() => void) | undefined;
+  private unresolvedContextOverflowMessage: string | undefined;
   private disposed = false;
   private pendingThinkingLevel: Parameters<StageContext["setThinkingLevel"]>[0] | undefined;
   private readonly pendingListeners = new Set<(event: StageSessionEvent) => void>();
@@ -325,7 +327,9 @@ export class StageSessionController {
     }
     this.unsubscribeTerminateWatcher?.();
     this.unsubscribeTerminateWatcher = result.session.subscribe((event) => {
-      this.recordTerminatingToolCall(event);
+      const terminatingId = terminatingToolCallId(event);
+      if (terminatingId !== undefined) this.terminatingToolCallIds.add(terminatingId);
+      this.unresolvedContextOverflowMessage = unresolvedContextOverflowMessage(event) ?? this.unresolvedContextOverflowMessage;
       this.latestStructuredOutputToolErrorValue =
         structuredOutputToolErrorFromEvent(event) ?? this.latestStructuredOutputToolErrorValue;
     });
@@ -361,24 +365,29 @@ export class StageSessionController {
         continue;
       }
       const promptStartIndex = activeSession.messages.length;
+      this.unresolvedContextOverflowMessage = undefined;
       try {
         await activeSession.prompt(nextText, sdkOptions);
         const pendingPauseAfterPrompt = this.pauseRequest;
         if (pendingPauseAfterPrompt) {
           const { message } = await pendingPauseAfterPrompt.deferred.promise;
+          this.throwUnresolvedContextOverflowIfPresent();
           nextText = message;
           if (nextText === undefined) return { terminalScanStartIndex: activeSession.messages.length };
           continue;
         }
+        this.throwUnresolvedContextOverflowIfPresent();
         return { terminalScanStartIndex: promptStartIndex };
       } catch (err) {
         const pendingPauseAfterThrow = this.pauseRequest;
         if (pendingPauseAfterThrow) {
           const { message } = await pendingPauseAfterThrow.deferred.promise;
+          this.throwUnresolvedContextOverflowIfPresent();
           nextText = message;
           if (nextText === undefined) return { terminalScanStartIndex: activeSession.messages.length };
           continue;
         }
+        this.throwUnresolvedContextOverflowIfPresent();
         throw err;
       }
     }
@@ -420,10 +429,10 @@ export class StageSessionController {
         this.notifyModelFallbackMetaChange();
         throw err;
       }
-      this.pendingFallbackWarnings.push(`[fallback] resume on ${resumedLabel} failed: ${message}. Restarting fallback from ${this.candidateLabel(candidates[0]!)}.`);
-      await this.disposeCurrentSession();
-      this.activeCandidateIndex = undefined;
-      return false;
+      const resumedOverflowNextIndex = nextResumedContextOverflowFallbackIndex(err, this.activeCandidateIndex, candidates.length);
+      if (resumedOverflowNextIndex === "terminal") { this.modelWarnings.push(...this.pendingFallbackWarnings); this.pendingFallbackWarnings.length = 0; this.notifyModelFallbackMetaChange(); throw err; }
+      this.pendingFallbackWarnings.push(resumedOverflowNextIndex === undefined ? `[fallback] resume on ${resumedLabel} failed: ${message}. Restarting fallback from ${this.candidateLabel(candidates[0]!)}.` : `[fallback] resume on ${resumedLabel} failed: ${message}. Retrying with ${this.candidateLabel(candidates[resumedOverflowNextIndex]!)}.`);
+      await this.disposeCurrentSession(); this.activeCandidateIndex = resumedOverflowNextIndex; return false;
     }
   }
 
@@ -479,22 +488,12 @@ export class StageSessionController {
   private candidateLabel(candidate: WorkflowResolvedModelCandidate): string {
     return candidate.reasoningLevel !== undefined ? `${candidate.id}:${candidate.reasoningLevel}` : candidate.id;
   }
-
   private isWorkflowFastModeEnabled(): boolean | undefined {
     const model = this.session?.model;
     const settingsManager = this.sessionSettingsManager ?? this.effectiveStageOptions?.settingsManager;
-    if (model === undefined || settingsManager === undefined) return undefined;
-    return shouldApplyCodexFastModeForScope(model, settingsManager.getCodexFastModeSettings(), "workflow");
-  }
-
-  private recordTerminatingToolCall(event: unknown): void {
-    if (event === null || typeof event !== "object") return;
-    const record = event as Record<string, unknown>;
-    if (record["type"] !== "tool_execution_end") return;
-    const result = record["result"];
-    if (result === null || typeof result !== "object") return;
-    if ((result as Record<string, unknown>)["terminate"] !== true) return;
-    const callId = record["toolCallId"];
-    if (typeof callId === "string" && callId.length > 0) this.terminatingToolCallIds.add(callId);
+    return model === undefined || settingsManager === undefined
+      ? undefined
+      : shouldApplyCodexFastModeForScope(model, settingsManager.getCodexFastModeSettings(), "workflow");
   }
+  private throwUnresolvedContextOverflowIfPresent(): void { const message = this.unresolvedContextOverflowMessage; this.unresolvedContextOverflowMessage = undefined; if (message !== undefined) throw unresolvedContextOverflowFailure(message); }
 }

package/dist/builtin/workflows/src/runs/foreground/stage-runner-unresolved-overflow.ts

@@ -0,0 +1,38 @@
+import { WorkflowPromptModelFailure } from "./stage-runner-messages.js";
+
+export function unresolvedContextOverflowMessage(event: unknown): string | undefined {
+  if (event === null || typeof event !== "object") return undefined;
+  const record = event as Record<string, unknown>;
+  if (record["type"] !== "compaction_end" || record["unresolvedOverflow"] !== true) return undefined;
+  const message = record["errorMessage"];
+  return typeof message === "string" && message.trim().length > 0
+    ? message
+    : "Context overflow recovery was exhausted for the current model.";
+}
+
+export function unresolvedContextOverflowFailure(message: string): WorkflowPromptModelFailure {
+  return new WorkflowPromptModelFailure({ message, code: "context_length_exceeded", stopReason: "error" });
+}
+
+export function isUnresolvedContextOverflowFailure(error: unknown): boolean {
+  if (!(error instanceof WorkflowPromptModelFailure)) return false;
+  const cause = error.cause;
+  if (cause === null || typeof cause !== "object") return false;
+  return (cause as { readonly code?: unknown }).code === "context_length_exceeded";
+}
+
+export function nextResumedContextOverflowFallbackIndex(error: unknown, currentIndex: number | undefined, candidateCount: number): number | "terminal" | undefined {
+  if (!isUnresolvedContextOverflowFailure(error) || currentIndex === undefined) return undefined;
+  const nextIndex = currentIndex + 1;
+  return nextIndex >= candidateCount ? "terminal" : nextIndex;
+}
+
+export function terminatingToolCallId(event: unknown): string | undefined {
+  if (event === null || typeof event !== "object") return undefined;
+  const record = event as Record<string, unknown>;
+  const result = record["result"];
+  if (record["type"] !== "tool_execution_end" || result === null || typeof result !== "object") return undefined;
+  if ((result as Record<string, unknown>)["terminate"] !== true) return undefined;
+  const callId = record["toolCallId"];
+  return typeof callId === "string" && callId.length > 0 ? callId : undefined;
+}

package/dist/builtin/workflows/src/runs/foreground/stage-tool-execution-buffer.ts

@@ -0,0 +1,47 @@
+import type { AgentSessionEvent } from "@bastani/atomic";
+
+interface PendingToolExecution {
+  start: AgentSessionEvent;
+  update?: AgentSessionEvent;
+}
+
+function eventType(event: AgentSessionEvent): string {
+  return String((event as { type?: unknown }).type ?? "");
+}
+
+function toolCallId(event: AgentSessionEvent): string | undefined {
+  const value = (event as { toolCallId?: unknown }).toolCallId;
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+export class StageToolExecutionBuffer {
+  private readonly pending = new Map<string, PendingToolExecution>();
+
+  record(event: AgentSessionEvent): void {
+    const type = eventType(event);
+    if (type === "agent_start" || type === "agent_end") {
+      this.pending.clear();
+      return;
+    }
+    const id = toolCallId(event);
+    if (id === undefined) return;
+    if (type === "tool_execution_start") {
+      this.pending.set(id, { start: event });
+      return;
+    }
+    if (type === "tool_execution_update") {
+      const existing = this.pending.get(id);
+      if (existing) existing.update = event;
+      return;
+    }
+    if (type === "tool_execution_end") this.pending.delete(id);
+  }
+
+  replayEvents(): readonly AgentSessionEvent[] {
+    return [...this.pending.values()].flatMap((entry) => entry.update ? [entry.start, entry.update] : [entry.start]);
+  }
+
+  clear(): void {
+    this.pending.clear();
+  }
+}

package/dist/builtin/workflows/src/runs/shared/model-fallback-candidates.ts

@@ -140,7 +140,7 @@ function resolveLongContextWindow(value: WorkflowModelValue): number | undefined
   return longTier > defaultContextWindow ? longTier : undefined;
 }
 
-const WORKFLOW_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"] as const satisfies readonly WorkflowThinkingLevel[];
+const WORKFLOW_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const satisfies readonly WorkflowThinkingLevel[];
 const WORKFLOW_THINKING_LEVEL_SET: ReadonlySet<string> = new Set(WORKFLOW_THINKING_LEVELS);
 
 export function splitReasoningSuffix(model: string): { readonly baseModel: string; readonly level?: WorkflowThinkingLevel } {

package/dist/builtin/workflows/src/runs/shared/worktree-git.ts

@@ -5,41 +5,160 @@ import { createGitEnvironment } from "@bastani/atomic";
 import type { GitResult, GitWorktreeSetupOptions, GitWorktreeSetupResult } from "./worktree-types.js";
 
 const DISABLED_GIT_HOOKS_PATH = process.platform === "win32" ? "NUL" : "/dev/null";
+const GIT_COMMAND_TIMEOUT_MS = 60_000;
+const GIT_READ_ONLY_PROBE_TIMEOUT_ATTEMPTS = 2;
 
-export function runGit(cwd: string, args: string[]): GitResult {
-	const result = spawnSync("git", [
+export type GitRunner = (cwd: string, args: readonly string[]) => GitResult;
+
+let gitRunnerOverride: GitRunner | undefined;
+
+function gitCommandArgs(args: readonly string[]): string[] {
+	return [
 		"-c",
 		`core.hooksPath=${DISABLED_GIT_HOOKS_PATH}`,
 		"-c",
 		"core.fsmonitor=false",
 		...args,
-	], {
+	];
+}
+
+function gitCommandArgv(args: readonly string[]): string[] {
+	return ["git", ...gitCommandArgs(args)];
+}
+
+function withGitResultDiagnostics(result: GitResult, cwd: string, args: readonly string[]): GitResult {
+	return {
+		...result,
+		argv: result.argv ?? gitCommandArgv(args),
+		cwd: result.cwd ?? cwd,
+		timeoutMs: result.timeoutMs ?? GIT_COMMAND_TIMEOUT_MS,
+	};
+}
+
+function runGitProcess(cwd: string, args: readonly string[]): GitResult {
+	const startedAt = Date.now();
+	const result = spawnSync("git", gitCommandArgs(args), {
 		cwd,
 		encoding: "utf-8",
-		env: createGitEnvironment({ GIT_OPTIONAL_LOCKS: "0" }),
-		timeout: 5000,
+		env: createGitEnvironment({
+			GIT_OPTIONAL_LOCKS: "0",
+			GIT_TERMINAL_PROMPT: "0",
+			GCM_INTERACTIVE: "never",
+		}),
+		timeout: GIT_COMMAND_TIMEOUT_MS,
 	});
 	return {
 		stdout: result.stdout ?? "",
 		stderr: result.stderr ?? "",
-		status: result.status,
+		status: result.status ?? null,
+		signal: result.signal ?? null,
+		elapsedMs: Math.max(0, Date.now() - startedAt),
 		...(result.error === undefined ? {} : { error: result.error }),
 	};
 }
 
-export function runGitChecked(cwd: string, args: string[]): string {
-	const result = runGit(cwd, args);
-	if (result.status !== 0) {
-		const command = `git -C ${cwd} ${args.join(" ")}`;
-		const message = result.stderr.trim() || result.stdout.trim() || `${command} failed`;
-		throw new Error(message);
+export function withGitRunnerForTest<T>(runner: GitRunner, callback: () => T): T {
+	const previous = gitRunnerOverride;
+	gitRunnerOverride = runner;
+	try {
+		return callback();
+	} finally {
+		gitRunnerOverride = previous;
 	}
+}
+
+export function runGit(cwd: string, args: readonly string[]): GitResult {
+	return withGitResultDiagnostics((gitRunnerOverride ?? runGitProcess)(cwd, args), cwd, args);
+}
+
+export function runGitChecked(cwd: string, args: readonly string[]): string {
+	const result = runGit(cwd, args);
+	if (result.status !== 0) throw new Error(gitFailureMessage(result));
 	return result.stdout;
 }
 
+function gitErrorCode(error: Error): string | undefined {
+	return "code" in error ? String((error as Error & { readonly code?: unknown }).code) : undefined;
+}
+
+export function isGitTimeoutResult(result: GitResult): boolean {
+	const error = result.error;
+	if (error === undefined) return false;
+	const code = gitErrorCode(error)?.toUpperCase();
+	const message = error.message.toLowerCase();
+	return code === "ETIMEDOUT" || message.includes("etimedout") || message.includes("timed out");
+}
+
+function formatGitDiagnosticArg(value: string): string {
+	if (/^[A-Za-z0-9_./:@%+=,\\-]+$/.test(value)) return value;
+	return JSON.stringify(value);
+}
+
+function formatGitCommand(argv: readonly string[]): string {
+	return argv.map(formatGitDiagnosticArg).join(" ");
+}
+
+function gitDiagnosticSuffix(result: GitResult): string {
+	const details: string[] = [];
+	if (result.argv !== undefined && result.argv.length > 0) details.push(`command: ${formatGitCommand(result.argv)}`);
+	if (result.cwd !== undefined) details.push(`cwd: ${result.cwd}`);
+	if (result.timeoutMs !== undefined) details.push(`timeout: ${result.timeoutMs}ms`);
+	if (result.elapsedMs !== undefined) details.push(`elapsed: ${result.elapsedMs}ms`);
+	details.push(`status: ${result.status === null ? "null" : result.status}`);
+	if (result.signal !== undefined) details.push(`signal: ${result.signal ?? "null"}`);
+	if (result.attempts !== undefined && result.attempts > 1) details.push(`attempts: ${result.attempts}`);
+	return details.length === 0 ? "" : ` (${details.join("; ")})`;
+}
+
 export function gitFailureMessage(result: GitResult): string {
-	if (result.error !== undefined) return result.error.message;
-	return result.stderr.trim() || result.stdout.trim() || `git exited with status ${result.status}`;
+	if (result.error !== undefined) {
+		const code = gitErrorCode(result.error);
+		if (isGitTimeoutResult(result)) {
+			return `git command timed out after ${result.timeoutMs ?? GIT_COMMAND_TIMEOUT_MS}ms${code === undefined ? "" : ` (${code})`}: ${result.error.message}${gitDiagnosticSuffix(result)}`;
+		}
+		return `${code === undefined ? result.error.message : `${code}: ${result.error.message}`}${gitDiagnosticSuffix(result)}`;
+	}
+	return `${result.stderr.trim() || result.stdout.trim() || `git exited with status ${result.status}`}${gitDiagnosticSuffix(result)}`;
+}
+
+function runGitReadOnlyProbe(cwd: string, args: readonly string[]): GitResult {
+	let attempts = 1;
+	let result = runGit(cwd, args);
+	while (attempts < GIT_READ_ONLY_PROBE_TIMEOUT_ATTEMPTS && result.status !== 0 && isGitTimeoutResult(result)) {
+		attempts += 1;
+		result = runGit(cwd, args);
+	}
+	return attempts > 1 ? { ...result, attempts } : result;
+}
+
+export interface GitWorktreeSetupCache {
+	get(options: GitWorktreeSetupOptions): GitWorktreeSetupResult;
+}
+
+function gitWorktreeSetupCacheKey(options: GitWorktreeSetupOptions): string {
+	return JSON.stringify([
+		path.resolve(options.cwd),
+		options.gitWorktreeDir.trim(),
+		options.baseBranch?.trim() ?? "",
+	]);
+}
+
+export function createGitWorktreeSetupCache(): GitWorktreeSetupCache {
+	const results = new Map<string, GitWorktreeSetupResult>();
+	return {
+		get(options) {
+			const key = gitWorktreeSetupCacheKey(options);
+			const cached = results.get(key);
+			if (cached !== undefined) return cached;
+			const setup = setupGitWorktree(options);
+			results.set(key, setup);
+			return setup;
+		},
+	};
+}
+
+export function setupGitWorktreeCached(options: GitWorktreeSetupOptions, cache?: GitWorktreeSetupCache): GitWorktreeSetupResult {
+	return cache?.get(options) ?? setupGitWorktree(options);
 }
 
 function quoteShellArg(value: string): string {
@@ -122,22 +241,38 @@ function pathExistsSync(value: string): boolean {
 }
 
 function repositoryRootForGitWorktree(cwd: string): string {
-	const result = runGit(cwd, ["rev-parse", "--show-toplevel"]);
+	const result = runGitReadOnlyProbe(cwd, ["rev-parse", "--show-toplevel"]);
 	if (result.status !== 0) {
+		if (isGitTimeoutResult(result)) {
+			throw new Error(`Timed out while checking the Git repository for gitWorktreeDir from ${cwd}. Git reported: ${gitFailureMessage(result)}`);
+		}
 		throw new Error(`gitWorktreeDir requires the workflow to be invoked from inside a Git repository. Start from a Git checkout or omit gitWorktreeDir. Git reported: ${gitFailureMessage(result)}`);
 	}
 	return result.stdout.trim();
 }
 
-function gitTopLevel(cwd: string): string | undefined {
-	const result = runGit(cwd, ["rev-parse", "--show-toplevel"]);
-	if (result.status !== 0) return undefined;
+export function gitTopLevelFromResult(result: GitResult, cwd: string, description: string): string | undefined {
+	if (result.status !== 0) {
+		if (isGitTimeoutResult(result)) {
+			throw new Error(`Timed out while validating ${description}. Git reported: ${gitFailureMessage(result)}`);
+		}
+		return undefined;
+	}
 	return gitPathFromOutput(result.stdout, cwd);
 }
 
+function gitTopLevel(cwd: string): string | undefined {
+	return gitTopLevelFromResult(runGitReadOnlyProbe(cwd, ["rev-parse", "--show-toplevel"]), cwd, `gitWorktreeDir ${cwd}`);
+}
+
 function gitCommonDirForWorktree(cwd: string): string {
-	const result = runGit(cwd, ["rev-parse", "--git-common-dir"]);
-	if (result.status !== 0) throw new Error(gitFailureMessage(result));
+	const result = runGitReadOnlyProbe(cwd, ["rev-parse", "--git-common-dir"]);
+	if (result.status !== 0) {
+		if (isGitTimeoutResult(result)) {
+			throw new Error(`Timed out while validating Git common directory for gitWorktreeDir ${cwd}. Git reported: ${gitFailureMessage(result)}`);
+		}
+		throw new Error(`Failed to validate Git common directory for gitWorktreeDir ${cwd}. Git reported: ${gitFailureMessage(result)}`);
+	}
 	const gitPath = gitPathFromOutput(result.stdout, cwd);
 	if (gitPath === undefined) throw new Error("git rev-parse --git-common-dir returned an empty path");
 	return gitPath;

package/dist/builtin/workflows/src/runs/shared/worktree-types.ts

@@ -65,7 +65,13 @@ export interface GitResult {
 	stdout: string;
 	stderr: string;
 	status: number | null;
+	signal?: NodeJS.Signals | null;
 	error?: Error;
+	argv?: readonly string[];
+	cwd?: string;
+	timeoutMs?: number;
+	elapsedMs?: number;
+	attempts?: number;
 }
 
 export interface GitWorktreeSetupOptions {

package/dist/builtin/workflows/src/runs/shared/worktree.ts

@@ -1,4 +1,4 @@
-export { setupGitWorktree } from "./worktree-git.js";
+export { createGitWorktreeSetupCache, setupGitWorktree, setupGitWorktreeCached } from "./worktree-git.js";
 export {
 	cleanupWorktrees,
 	createWorktrees,
@@ -16,3 +16,4 @@ export type {
 	WorktreeSetup,
 	WorktreeTaskCwdConflict,
 } from "./worktree-types.js";
+export type { GitWorktreeSetupCache } from "./worktree-git.js";

package/dist/builtin/workflows/src/shared/authoring-contract-stage.d.ts

@@ -20,7 +20,7 @@ export type WorkflowInputSchema = TSchema;
 export type WorkflowOutputSchema = TSchema;
 export type WorkflowOutputMode = "inline" | "file-only";
 export type WorkflowContextMode = "fresh" | "fork";
-export type WorkflowThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
+export type WorkflowThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
 export type WorkflowExecutionMode = "interactive" | "non_interactive";
 export type WorkflowExitStatus = "completed" | "skipped" | "cancelled" | "blocked";
 export type RunStatus = "pending" | "running" | "paused" | WorkflowExitStatus | "failed" | "killed";
@@ -34,7 +34,7 @@ export interface WorkflowExitOptions<TOutputs extends WorkflowOutputValues = Wor
     readonly outputs?: WorkflowExitOutputValues<TOutputs>;
 }
 export interface WorkflowModelFallbackFields {
-    /** Ordered model IDs to try after `model` fails; entries may use `:off|minimal|low|medium|high|xhigh` reasoning suffixes. */
+    /** Ordered model IDs to try after `model` fails; entries may use `:off|minimal|low|medium|high|xhigh|max` reasoning suffixes. */
     readonly fallbackModels?: readonly string[];
     /** Optional deprecated compatibility helper aligned to `fallbackModels`; ignored for entries with a reasoning suffix. */
     readonly fallbackThinkingLevels?: readonly string[];

package/dist/builtin/workflows/src/shared/authoring-contract-stage.ts

@@ -29,7 +29,7 @@ export type WorkflowOutputSchema = TSchema;
 
 export type WorkflowOutputMode = "inline" | "file-only";
 export type WorkflowContextMode = "fresh" | "fork";
-export type WorkflowThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
+export type WorkflowThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
 export type WorkflowExecutionMode = "interactive" | "non_interactive";
 export type WorkflowExitStatus = "completed" | "skipped" | "cancelled" | "blocked";
 export type RunStatus = "pending" | "running" | "paused" | WorkflowExitStatus | "failed" | "killed";
@@ -48,7 +48,7 @@ export interface WorkflowExitOptions<TOutputs extends WorkflowOutputValues = Wor
 }
 
 export interface WorkflowModelFallbackFields {
-  /** Ordered model IDs to try after `model` fails; entries may use `:off|minimal|low|medium|high|xhigh` reasoning suffixes. */
+  /** Ordered model IDs to try after `model` fails; entries may use `:off|minimal|low|medium|high|xhigh|max` reasoning suffixes. */
   readonly fallbackModels?: readonly string[];
   /** Optional deprecated compatibility helper aligned to `fallbackModels`; ignored for entries with a reasoning suffix. */
   readonly fallbackThinkingLevels?: readonly string[];

package/dist/builtin/workflows/src/shared/persistence-restore-helpers.ts

@@ -1,7 +1,7 @@
 import { Value } from "typebox/value";
 import { workflowSerializableObjectSchema } from "./serializable.js";
 import type { Store } from "./store.js";
-import type { SessionEntry } from "./persistence-restore.js";
+import type { NormalizedSessionEntry as SessionEntry } from "./persistence-restore.js";
 import type {
   RunStatus,
   StageSnapshot,
@@ -255,6 +255,14 @@ function numericRetryAfterMs(value: unknown): number | undefined {
   return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
 }
 
+function numericTimestamp(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+
+function numericDuration(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+
 export function findRunBlockedMetadata(
   entries: readonly SessionEntry[],
   runId: string,
@@ -360,6 +368,8 @@ export function restoreTerminalRuns(entries: readonly SessionEntry[], store: Sto
     const retryAfterMs = numericRetryAfterMs(end["retryAfterMs"]);
     const failureMessage = end["failureMessage"];
     const failedStageId = end["failedStageId"];
+    const restoredEndedAt = numericTimestamp(end["endedAt"]);
+    const restoredDurationMs = numericDuration(end["durationMs"]);
     store.recordRunEnd(
       runId,
       status,
@@ -378,6 +388,13 @@ export function restoreTerminalRuns(entries: readonly SessionEntry[], store: Sto
         ...(typeof exitReason === "string" ? { exitReason } : {}),
       },
     );
+    const restoredRun = store.runs().find((run) => run.id === runId);
+    if (restoredRun !== undefined && (restoredEndedAt !== undefined || restoredDurationMs !== undefined)) {
+      Object.assign(restoredRun, {
+        ...(restoredEndedAt !== undefined ? { endedAt: restoredEndedAt } : {}),
+        ...(restoredDurationMs !== undefined ? { durationMs: restoredDurationMs } : {}),
+      });
+    }
   }
 }