@bastani/atomic 0.9.5-alpha.7 → 0.9.5-alpha.9

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/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/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 } : {}),
+      });
+    }
   }
 }
 

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

@@ -15,7 +15,7 @@ import {
 
 import type { Store } from "./store.js";
 import type { RunSnapshot } from "./store-types.js";
-import type { WorkflowInputValues } from "./types.js";
+import type { WorkflowInputValues, WorkflowSerializableValue } from "./types.js";
 
 // ---------------------------------------------------------------------------
 // Config option
@@ -32,7 +32,25 @@ export type ResumeInFlight = "ask" | "auto" | "never";
 export interface SessionEntry {
   readonly id: string;
   readonly type: string;
-  readonly payload: Record<string, unknown>;
+  readonly payload?: Record<string, WorkflowSerializableValue>;
+  readonly customType?: string;
+  readonly data?: Record<string, WorkflowSerializableValue>;
+}
+
+export interface NormalizedSessionEntry {
+  readonly id: string;
+  readonly type: string;
+  readonly payload: Record<string, WorkflowSerializableValue>;
+}
+
+export function normalizeSessionEntries(entries: readonly SessionEntry[]): readonly NormalizedSessionEntry[] {
+  return entries.flatMap((entry): readonly NormalizedSessionEntry[] => {
+    if (entry.type === "custom" && typeof entry.customType === "string" && entry.data !== undefined) {
+      return [{ id: entry.id, type: entry.customType, payload: entry.data }];
+    }
+    if (entry.payload !== undefined) return [{ id: entry.id, type: entry.type, payload: entry.payload }];
+    return [];
+  });
 }
 
 /** Structural type for pi's sessionManager (optional — degrades gracefully). */
@@ -69,7 +87,7 @@ export function scanInFlightRuns(entries: readonly SessionEntry[]): InFlightRun[
   const started = new Map<string, { name: string; inputs: WorkflowInputValues; startTs: number; stageIds: string[] }>();
   const ended = new Set<string>();
 
-  for (const entry of entries) {
+  for (const entry of normalizeSessionEntries(entries)) {
     if (entry.type === "workflow.run.start") {
       const runId = entry.payload["runId"];
       const name = entry.payload["name"];
@@ -168,8 +186,8 @@ export function restoreOnSessionStart(
   const getEntries = sessionManager.getEntries;
   if (typeof getEntries !== "function") return;
 
-  const entries = getEntries.call(sessionManager);
-  const sessionEntries = entries as readonly SessionEntry[];
+  const entries = getEntries.call(sessionManager) as readonly SessionEntry[];
+  const sessionEntries = normalizeSessionEntries(entries);
   restoreTerminalRuns(sessionEntries, store);
   const inFlight = scanInFlightRuns(sessionEntries);
   if (inFlight.length === 0) return;

package/dist/builtin/workflows/src/shared/persistence-session-entries.ts

@@ -112,6 +112,8 @@ export interface RunEndPayload {
   readonly failedStageId?: string;
   readonly resumable?: boolean;
   readonly retryAfterMs?: number;
+  readonly endedAt?: number;
+  readonly durationMs?: number;
   readonly ts: number;
 }
 
@@ -254,6 +256,8 @@ export function appendRunEnd(api: PersistenceAPI, payload: RunEndPayload): void
     ...(terminalPayload.failedStageId !== undefined ? { failedStageId: terminalPayload.failedStageId } : {}),
     ...(terminalPayload.resumable !== undefined ? { resumable: terminalPayload.resumable } : {}),
     ...(terminalPayload.retryAfterMs !== undefined ? { retryAfterMs: terminalPayload.retryAfterMs } : {}),
+    ...(terminalPayload.endedAt !== undefined ? { endedAt: terminalPayload.endedAt } : {}),
+    ...(terminalPayload.durationMs !== undefined ? { durationMs: terminalPayload.durationMs } : {}),
     ts: terminalPayload.ts,
   });
 }

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;
 }