@bastani/atomic 0.9.5-alpha.8 → 0.9.5

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;

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/resume-continuation.ts

@@ -0,0 +1,2 @@
+export const RESUME_CONTINUATION_PROMPT =
+  "Continue where you left off. If you believe you are finished with your original task (or a redefined task if the user told you), stop.";

package/dist/builtin/workflows/src/shared/returned-run-status.ts

@@ -0,0 +1,116 @@
+import type { RunEndMetadata } from "./store-public-types.js";
+import type { RunSnapshot, RunStatus, StageSnapshot, WorkflowFailureKind } from "./store-types.js";
+import type { WorkflowOutputValues } from "./types.js";
+
+const RETURNED_BLOCKED_STATUSES = new Set([
+  "blocked",
+  "needs_human",
+  "incomplete",
+  "auth_blocked",
+  "active",
+]);
+
+export interface StructuredRecoverableWorkflowFailure {
+  readonly error: string;
+  readonly metadata: RunEndMetadata;
+}
+
+export function normalizeReturnedWorkflowStatus(status: unknown): string | undefined {
+  if (typeof status !== "string") return undefined;
+  const normalized = status.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+  return normalized.length > 0 ? normalized : undefined;
+}
+
+export function isReturnedBlockedWorkflowStatus(status: string): boolean {
+  return RETURNED_BLOCKED_STATUSES.has(status);
+}
+
+export function isReturnedResumableBlockedWorkflowStatus(status: string): boolean {
+  return status !== "blocked" && isReturnedBlockedWorkflowStatus(status);
+}
+
+export function actionableReturnedStatusText(result: WorkflowOutputValues | undefined): string | undefined {
+  return stringResultField(result, "summary") ?? stringResultField(result, "remaining_work") ?? stringResultField(result, "result");
+}
+
+export function structuredRecoverableWorkflowFailure(
+  run: Pick<RunSnapshot,
+    | "error"
+    | "failureKind"
+    | "failureCode"
+    | "failureRecoverability"
+    | "failureDisposition"
+    | "failureMessage"
+    | "failedStageId"
+    | "retryAfterMs"
+    | "stages"
+  >,
+): StructuredRecoverableWorkflowFailure | undefined {
+  const runFailure = structuredRecoverableFailureFromSnapshot(run);
+  if (runFailure !== undefined) return runFailure;
+  if (run.failedStageId === undefined) return undefined;
+
+  const failedStage = run.stages.find((stage) => stage.id === run.failedStageId);
+  return failedStage === undefined
+    ? undefined
+    : structuredRecoverableFailureFromSnapshot(failedStage, failedStage.id);
+}
+
+export function structuredRecoverableWorkflowFailureText(
+  run: Pick<RunSnapshot,
+    | "error"
+    | "failureKind"
+    | "failureCode"
+    | "failureRecoverability"
+    | "failureDisposition"
+    | "failureMessage"
+    | "failedStageId"
+    | "retryAfterMs"
+    | "stages"
+  >,
+): string | undefined {
+  return structuredRecoverableWorkflowFailure(run)?.error;
+}
+
+export function effectiveRunStatus(run: RunSnapshot): RunStatus {
+  if (run.status !== "completed") return run.status;
+  if (structuredRecoverableWorkflowFailure(run) !== undefined) return "blocked";
+  const returnedStatus = normalizeReturnedWorkflowStatus(run.result?.["status"]);
+  if (returnedStatus === "failed") return "failed";
+  if (returnedStatus !== undefined && isReturnedBlockedWorkflowStatus(returnedStatus)) return "blocked";
+  return run.status;
+}
+
+function structuredRecoverableFailureFromSnapshot(
+  snapshot: Pick<RunSnapshot | StageSnapshot, "error" | "failureKind" | "failureCode" | "failureRecoverability" | "failureDisposition" | "failureMessage" | "retryAfterMs">,
+  failedStageId?: string,
+): StructuredRecoverableWorkflowFailure | undefined {
+  if (snapshot.failureDisposition !== "active_blocked") return undefined;
+  if (snapshot.failureRecoverability !== "recoverable") return undefined;
+  if (!isRecoverableProviderFailureKind(snapshot.failureKind)) return undefined;
+  const error = snapshot.error ?? snapshot.failureMessage ?? "Workflow is blocked by a recoverable provider failure.";
+  return {
+    error,
+    metadata: {
+      failureKind: snapshot.failureKind,
+      ...(snapshot.failureCode !== undefined ? { failureCode: snapshot.failureCode } : {}),
+      failureRecoverability: snapshot.failureRecoverability,
+      failureDisposition: snapshot.failureDisposition,
+      failureMessage: snapshot.failureMessage ?? error,
+      ...(failedStageId !== undefined ? { failedStageId } : {}),
+      resumable: true,
+      ...(snapshot.retryAfterMs !== undefined ? { retryAfterMs: snapshot.retryAfterMs } : {}),
+    },
+  };
+}
+
+function isRecoverableProviderFailureKind(kind: WorkflowFailureKind | undefined): kind is "auth" | "rate_limit" | "provider" {
+  return kind === "auth" || kind === "rate_limit" || kind === "provider";
+}
+
+
+
+function stringResultField(result: WorkflowOutputValues | undefined, key: string): string | undefined {
+  const value = result?.[key];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}

package/dist/builtin/workflows/src/shared/workflow-failures-decisions.ts

@@ -186,6 +186,8 @@ const PROVIDER_UNAVAILABLE_PHRASES: readonly TokenMatch[] = [
   ["provider", "error"],
   ["model", "unavailable"],
   ["503"],
+  ["git", "command", "timed", "out"],
+  ["spawnsync", "git", "etimedout"],
 ];
 
 const AUTH_CONTEXT = new Set([

package/dist/builtin/workflows/src/tui/graph-view-render-helpers.ts

@@ -5,6 +5,7 @@ import {
   OVERLAY_LINE_COUNT,
   OVERLAY_VERTICAL_MARGIN_ROWS,
 } from "./graph-view-constants.js";
+import { WORKFLOW_STATUS_KEY } from "./workflow-status.js";
 import { GraphViewState } from "./graph-view-state.js";
 import { renderOutlinePill } from "./header.js";
 import { NODE_H, NODE_W } from "./layout.js";
@@ -78,12 +79,25 @@ export abstract class GraphViewRenderHelpers extends GraphViewState {
    * the header band: `backgroundPanel` chrome, outlined accent pill
    * flush-left, hints flowing right on the centre row.
    */
+  protected _externalStatusText(): string | null {
+    const entries = Array.from(this.footerData?.getExtensionStatuses() ?? [])
+      .filter(([key, value]) => (
+        value.trim().length > 0 &&
+        key !== WORKFLOW_STATUS_KEY &&
+        !key.startsWith(`${WORKFLOW_STATUS_KEY}:`)
+      ))
+      .sort(([a], [b]) => a.localeCompare(b));
+    if (entries.length === 0) return null;
+    return entries.map(([, value]) => value.trim()).join(" · ");
+  }
+
   protected _renderStatusline(width: number): string[] {
     const t = this.graphTheme;
     const chromeBg = hexBg(t.backgroundPanel);
     const text = hexToAnsi(t.text);
     const muted = hexToAnsi(t.textMuted);
     const dim = hexToAnsi(t.dim);
+    const accent = hexToAnsi(t.accent);
 
     const {
       top,
@@ -92,13 +106,17 @@ export abstract class GraphViewRenderHelpers extends GraphViewState {
       visibleWidth: pillW,
     } = renderOutlinePill(MODE_PILL_LABEL, t.accent, chromeBg);
 
-    // Hints — `<key> <label>` separated by `  ·  `.
+    // Hints — `<key> <label>` separated by `  ·  `. When other extensions
+    // publish status text (for example the async subagent widget), include it
+    // ahead of the controls so fullscreen workflow overlays do not hide it.
     const sep = `${chromeBg}  ${dim}·${RESET}${chromeBg}  `;
-    const segments = HINT_KEYS.map(
+    const statusText = this._externalStatusText();
+    const statusSegment = statusText ? [`${accent}${statusText}${RESET}${chromeBg}`] : [];
+    const hintSegments = HINT_KEYS.map(
       ({ key, label }) =>
         `${text}${BOLD}${key}${RESET}${chromeBg} ${muted}${label}${RESET}${chromeBg}`,
     );
-    const hintsStyledRaw = segments.join(sep);
+    const hintsStyledRaw = [...statusSegment, ...hintSegments].join(sep);
 
     const leftEdgePad = 1;
     const rightEdgePad = 2;

package/dist/builtin/workflows/src/tui/graph-view-state.ts

@@ -1,3 +1,4 @@
+import type { ReadonlyFooterDataProvider } from "@bastani/atomic";
 import type { Store } from "../shared/store.js";
 import type {
   PendingPrompt,
@@ -63,6 +64,7 @@ export abstract class GraphViewState {
   protected getViewportRows?: () => number | undefined;
   protected requestRender?: () => void;
   protected piKeybindings?: unknown;
+  protected footerData?: ReadonlyFooterDataProvider;
 
   /** Active HIL prompt state, set when `_rebuildLayout` sees a new prompt id. */
   protected promptState: PromptCardState | null = null;
@@ -102,6 +104,7 @@ export abstract class GraphViewState {
     this.getViewportRows = opts.getViewportRows;
     this.requestRender = opts.requestRender;
     this.piKeybindings = opts.piKeybindings;
+    this.footerData = opts.footerData;
 
     this._unsubscribe = this.store.subscribe((snap) => {
       this.currentSnapshot = snap;

package/dist/builtin/workflows/src/tui/graph-view-types.ts

@@ -1,3 +1,4 @@
+import type { ReadonlyFooterDataProvider } from "@bastani/atomic";
 import type { Store } from "../shared/store.js";
 import type { GraphTheme } from "./graph-theme.js";
 
@@ -66,4 +67,6 @@ export interface GraphViewOpts {
   requestRender?: () => void;
   /** Host Pi keybindings manager used by run-level prompt cards. */
   piKeybindings?: unknown;
+  /** Host footer/status provider used to surface non-workflow extension statuses inside the fullscreen graph overlay. */
+  footerData?: ReadonlyFooterDataProvider;
 }

package/dist/builtin/workflows/src/tui/stage-chat-view-archive-history.ts

@@ -24,7 +24,7 @@ export function renderReadOnlyArchiveBody(
   }
 
   const t = ctx.theme;
-  const calloutRows = 6;
+  const calloutRows = 5;
   const transcriptBudget = Math.max(1, budget - calloutRows);
   const lines = ctx.chatHost.renderBody(width, transcriptBudget);
   const callout: string[] = [];
@@ -46,17 +46,6 @@ export function renderReadOnlyArchiveBody(
       0,
     ).render(width),
   );
-  callout.push(
-    ...new Text(
-      paint("esc", t.accent, { bold: true }) +
-        paint(" close", t.textMuted) +
-        paint("  ·  ", t.dim) +
-        paint("ctrl+d", t.accent, { bold: true }) +
-        paint(" return to graph", t.textMuted),
-      2,
-      0,
-    ).render(width),
-  );
   lines.push(...callout);
   while (lines.length < budget) lines.push(blankLine(width));
   if (lines.length > budget) lines.length = budget;
@@ -111,17 +100,6 @@ function renderReadOnlyPromptArchiveBody(
   bodyLines.push(...new Text(paint("your response", t.textMuted, { bold: true }), 2, 0).render(innerWidth));
   bodyLines.push(...new Text(paint(answer, answer.startsWith("(") ? t.dim : t.text), 4, 0).render(innerWidth));
   bodyLines.push("");
-  bodyLines.push(
-    ...new Text(
-      paint("esc", t.accent, { bold: true }) +
-        paint(" close", t.textMuted) +
-        paint("  ·  ", t.dim) +
-        paint("ctrl+d", t.accent, { bold: true }) +
-        paint(" return to graph", t.textMuted),
-      2,
-      0,
-    ).render(innerWidth),
-  );
 
   const title = stage.status === "skipped" ? "QUESTION SKIPPED" : "QUESTION ASKED";
   const cardLines = renderRoundedBoxLines({