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

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/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/status-list.ts

@@ -27,6 +27,7 @@
  */
 
 import type { RunSnapshot, StageSnapshot, StageStatus } from "../shared/store-types.js";
+import { effectiveRunStatus } from "../shared/returned-run-status.js";
 import { elapsedRunMs, elapsedStageMs } from "../shared/timing.js";
 import type { GraphTheme } from "./graph-theme.js";
 import { fmtDuration } from "./status-helpers.js";
@@ -162,7 +163,7 @@ function renderRunEntry(
 function runAccent(run: RunSnapshot, theme?: GraphTheme): string {
   if (!theme) return "#000000";
   if (isQuitRun(run)) return theme.warning;
-  switch (run.status) {
+  switch (effectiveRunStatus(run)) {
     case "completed": return theme.success;
     case "running":   return theme.warning;
     case "paused":    return theme.warning;
@@ -178,7 +179,7 @@ function runAccent(run: RunSnapshot, theme?: GraphTheme): string {
 
 function runTrailing(run: RunSnapshot, theme?: GraphTheme): { text: string; fg?: string } | undefined {
   if (isQuitRun(run)) return { text: "○ quit", fg: theme?.warning };
-  switch (run.status) {
+  switch (effectiveRunStatus(run)) {
     case "completed": return { text: "✓ completed", fg: theme?.success };
     case "running":   return { text: "● running", fg: theme?.warning };
     case "paused":    return { text: "❚❚ paused", fg: theme?.warning };
@@ -212,7 +213,7 @@ function runCardMeta(run: RunSnapshot, now: number): string {
       : undefined;
 
   if (isQuitRun(run)) return "resumable via /workflow resume";
-  if (run.status === "running") {
+  if (effectiveRunStatus(run) === "running") {
     if (isChain) parts.push(`${done}/${total}`);
     const labels = runningStageLabels(run);
     if (labels) parts.push(labels);
@@ -220,7 +221,7 @@ function runCardMeta(run: RunSnapshot, now: number): string {
     return parts.join(" · ");
   }
 
-  if (run.status === "paused") {
+  if (effectiveRunStatus(run) === "paused") {
     if (isChain) parts.push(`${done}/${total}`);
     const labels = pausedStageLabels(run);
     if (labels) parts.push(labels);
@@ -228,7 +229,7 @@ function runCardMeta(run: RunSnapshot, now: number): string {
     return parts.join(" · ");
   }
 
-  if (run.status === "failed" || run.status === "killed") {
+  if (effectiveRunStatus(run) === "failed" || effectiveRunStatus(run) === "killed") {
     const failed = run.stages.find((s) => s.status === "failed");
     if (failed && isChain) parts.push(`failed at ${failed.name}`);
     else if (failed) parts.push(failed.name);
@@ -239,7 +240,7 @@ function runCardMeta(run: RunSnapshot, now: number): string {
     return parts.join(" · ");
   }
 
-  if (run.status === "completed" || run.status === "skipped" || run.status === "cancelled" || run.status === "blocked") {
+  if (["completed", "skipped", "cancelled", "blocked"].includes(effectiveRunStatus(run))) {
     if (run.exitReason !== undefined && run.exitReason.length > 0) parts.push(run.exitReason);
     if (!isChain && run.stages[0]) parts.push(run.stages[0].name);
     const dur = lastStageDuration(run, now);
@@ -292,7 +293,7 @@ function stageCells(run: RunSnapshot): Array<{ status: StageStatus }> {
 }
 
 function stageStatusFromRun(run: RunSnapshot): StageStatus {
-  switch (run.status) {
+  switch (effectiveRunStatus(run)) {
     case "completed": return "completed";
     case "skipped":   return "skipped";
     case "cancelled": return "skipped";
@@ -324,22 +325,26 @@ interface Counts {
   paused: number;
   quit: number;
   completed: number;
+  blocked: number;
   failed: number;
   pending: number;
 }
 
 function countBuckets(runs: readonly RunSnapshot[]): Counts {
-  const c: Counts = { active: 0, paused: 0, quit: 0, completed: 0, failed: 0, pending: 0 };
+  const c: Counts = { active: 0, paused: 0, quit: 0, completed: 0, blocked: 0, failed: 0, pending: 0 };
   for (const r of runs) {
+    const status = effectiveRunStatus(r);
     if (isQuitRun(r)) c.quit++;
     else if (r.endedAt === undefined) {
-      if (r.status === "pending") c.pending++;
-      else if (r.status === "paused") c.paused++;
-      else if (r.status === "running") c.active++;
-      else if (r.status === "completed") c.completed++;
+      if (status === "pending") c.pending++;
+      else if (status === "paused") c.paused++;
+      else if (status === "running") c.active++;
+      else if (status === "completed") c.completed++;
+      else if (status === "blocked") c.blocked++;
       else c.failed++;
-    } else if (r.status === "completed") c.completed++;
-    else if (r.status === "skipped" || r.status === "cancelled" || r.status === "blocked") c.completed++;
+    } else if (status === "completed") c.completed++;
+    else if (status === "blocked") c.blocked++;
+    else if (status === "skipped" || status === "cancelled") c.completed++;
     else c.failed++;
   }
   return c;
@@ -348,6 +353,7 @@ function countBuckets(runs: readonly RunSnapshot[]): Counts {
 function themedBadges(c: Counts, theme: GraphTheme): FlatBandBadge[] {
   const out: FlatBandBadge[] = [];
   if (c.completed > 0) out.push({ text: `✓ ${c.completed}`, fg: theme.success });
+  if (c.blocked > 0) out.push({ text: `↑ ${c.blocked} blocked`, fg: theme.warning });
   if (c.active > 0) out.push({ text: `● ${c.active}`, fg: theme.warning });
   // Keep the word label: the pause glyph is less familiar than the other
   // status glyphs, so this intentional asymmetry improves scanability.
@@ -361,6 +367,7 @@ function themedBadges(c: Counts, theme: GraphTheme): FlatBandBadge[] {
 function plainBadges(c: Counts): FlatBandBadge[] {
   const out: FlatBandBadge[] = [];
   if (c.completed > 0) out.push({ text: `✓ ${c.completed}` });
+  if (c.blocked > 0) out.push({ text: `↑ ${c.blocked} blocked` });
   if (c.active > 0) out.push({ text: `● ${c.active}` });
   // Keep the word label: the pause glyph is less familiar than the other
   // status glyphs, so this intentional asymmetry improves scanability.
@@ -393,7 +400,7 @@ function emptyStateLine(theme?: GraphTheme): string {
 
 function statusIconForRun(run: RunSnapshot): string {
   if (isQuitRun(run)) return "○";
-  switch (run.status) {
+  switch (effectiveRunStatus(run)) {
     case "completed": return "✓";
     case "skipped": return "⊘";
     case "cancelled": return "⊘";

package/dist/builtin/workflows/src/tui/workflow-attach-pane.ts

@@ -32,10 +32,9 @@ import type { StageSnapshot, StoreSnapshot } from "../shared/store-types.js";
 import { expandWorkflowGraph } from "../shared/expanded-workflow-graph.js";
 import { WORKFLOW_STATUS_KEY } from "./workflow-status.js";
 /**
- * Surface used to write Pi's footer/status tag while the attach pane is
- * mounted. Passing `undefined` clears the slot — required on dispose so
- * the `pi-workflows/<workflow>[/<stage>]` tag does NOT linger in every
- * subsequent chat message after the overlay is closed.
+ * Surface for the overlay footer/status tag. Passing `undefined` on dispose
+ * prevents `pi-workflows/<workflow>[/<stage>]` from lingering in later chat
+ * messages after the overlay closes.
  * cross-ref: @bastani/atomic docs/extensions.md
  * §Widgets, Status, and Footer (`ctx.ui.setStatus`).
  */
@@ -134,6 +133,7 @@ export class WorkflowAttachPane implements Component {
       initialFocusedStageId,
       getViewportRows: this.getViewportRows,
       piKeybindings: this.piKeybindings,
+      footerData: this.footerData,
       requestRender: () => {
         if (this.mode !== "graph") return;
         this.hostRequestRender?.();

package/dist/core/agent-session-auto-compaction.d.ts

@@ -1,7 +1,18 @@
 import type { AssistantMessage } from "@earendil-works/pi-ai/compat";
 import type { AgentSessionInternalSurface as AgentSession } from "./agent-session-methods.ts";
+/**
+ * Upper bound on consecutive automatic continuations of a response that was
+ * truncated at the output-token cap ("length") while the context is still
+ * below the compaction budget. Each continuation regenerates the cut-off turn,
+ * so a model that insists on emitting more than its per-turn output cap can
+ * still terminate instead of looping forever.
+ */
+export declare const MAX_LENGTH_CONTINUATION_ATTEMPTS = 3;
+export declare const MAX_OUTPUT_BUDGET_ERROR_CONTINUATION_ATTEMPTS = 1;
 export declare function _checkCompaction(this: AgentSession, assistantMessage: AssistantMessage, skipAbortedCheck?: boolean): Promise<void>;
 export declare function _isCopilotServerCapBelowSelectedContextWindow(this: AgentSession, assistantMessage: AssistantMessage): boolean;
+export declare function isRetryWorthyLengthStop(assistantMessage: AssistantMessage): boolean;
+export declare function isRetryWorthyOutputBudgetError(assistantMessage: AssistantMessage): boolean;
 export declare function shouldRetryAfterThresholdCompaction(assistantMessage: AssistantMessage): boolean;
 /**
  * Internal: remove an incomplete assistant from retry context before auto-continuing after compaction.
@@ -10,23 +21,32 @@ export declare function _dropTrailingAutoCompactionRetryAssistantIfPresent(this:
 /**
  * Internal: schedule a live post-event continuation probe after compaction_end listeners can flush queues.
  */
-export declare function _schedulePostAutoCompactionContinuationProbe(this: AgentSession, reason: "overflow" | "threshold", willRetry: boolean): void;
-export declare function _awaitPendingOverflowPostCompactionContinuation(this: AgentSession): Promise<void>;
+export declare function _schedulePostAutoCompactionContinuationProbe(this: AgentSession, _reason: "overflow" | "threshold", willRetry: boolean): void;
+export declare function _awaitPendingPostCompactionContinuation(this: AgentSession): Promise<void>;
 /**
  * Internal: resume generation after successful auto-compaction only when active work remains.
  */
 export declare function _resumeAfterAutoCompaction(this: AgentSession): Promise<void>;
+/**
+ * Internal: resume a response that was truncated at the output-token cap
+ * ("length") when the context does not warrant compaction. The generation is
+ * continued directly so the model finishes the work it was cut off from, rather
+ * than dead-ending on the truncation. Bounded by MAX_LENGTH_CONTINUATION_ATTEMPTS
+ * so a turn that keeps exceeding the per-turn output cap can still terminate.
+ */
+export declare function _resumeAfterLengthTruncation(this: AgentSession): void;
 export declare function _runAutoCompaction(this: AgentSession, reason: "overflow" | "threshold", willRetry: boolean): Promise<void>;
 /**
  * Toggle auto-compaction setting.
  */
 export declare const agentSessionAutoCompactionMethods: {
-    _awaitPendingOverflowPostCompactionContinuation: typeof _awaitPendingOverflowPostCompactionContinuation;
+    _awaitPendingPostCompactionContinuation: typeof _awaitPendingPostCompactionContinuation;
     _checkCompaction: typeof _checkCompaction;
     _isCopilotServerCapBelowSelectedContextWindow: typeof _isCopilotServerCapBelowSelectedContextWindow;
     _dropTrailingAutoCompactionRetryAssistantIfPresent: typeof _dropTrailingAutoCompactionRetryAssistantIfPresent;
     _schedulePostAutoCompactionContinuationProbe: typeof _schedulePostAutoCompactionContinuationProbe;
     _resumeAfterAutoCompaction: typeof _resumeAfterAutoCompaction;
+    _resumeAfterLengthTruncation: typeof _resumeAfterLengthTruncation;
     _runAutoCompaction: typeof _runAutoCompaction;
 };
 //# sourceMappingURL=agent-session-auto-compaction.d.ts.map