@bastani/atomic 0.8.19 → 0.8.20

package/dist/builtin/subagents/src/runs/shared/parallel-utils.ts

@@ -18,6 +18,7 @@ export interface RunnerSubagentStep {
 	outputMode?: "inline" | "file-only";
 	sessionFile?: string;
 	maxSubagentDepth?: number;
+	workflowStageSubagentGuard?: boolean;
 }
 
 export interface ParallelStepGroup {

package/dist/builtin/subagents/src/runs/shared/run-history.ts

@@ -54,6 +54,6 @@ export function loadRunsForAgent(agent: string): RunEntry[] {
 
 	return lines
 		.map((line) => { try { return JSON.parse(line) as RunEntry; } catch { return undefined; } })
-		.filter((entry): entry is RunEntry => Boolean(entry) && entry.agent === agent)
+		.filter((entry): entry is RunEntry => entry !== undefined && entry.agent === agent)
 		.reverse();
 }

package/dist/builtin/subagents/src/shared/settings.ts

@@ -70,6 +70,7 @@ interface ParallelTaskItem {
 /** Parallel step: multiple agents running concurrently */
 interface ParallelStep {
 	parallel: ParallelTaskItem[];
+	cwd?: string;
 	concurrency?: number;
 	failFast?: boolean;
 	worktree?: boolean;

package/dist/builtin/subagents/src/shared/types.ts

@@ -5,13 +5,15 @@
 import * as os from "node:os";
 import * as path from "node:path";
 import type { Message } from "@earendil-works/pi-ai";
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import type { FSWatcher } from "node:fs";
 import type { ExtensionContext } from "@bastani/atomic";
-import { APP_NAME, getEnvValue } from "@bastani/atomic";
+import { APP_NAME, getEnvValue, WORKFLOW_STAGE_SUBAGENT_GUARD_ENV } from "@bastani/atomic";
 
 const ENV_PREFIX = APP_NAME.toUpperCase();
 const SUBAGENT_MAX_DEPTH_ENV = `${ENV_PREFIX}_SUBAGENT_MAX_DEPTH`;
 const SUBAGENT_DEPTH_ENV = `${ENV_PREFIX}_SUBAGENT_DEPTH`;
+export { WORKFLOW_STAGE_SUBAGENT_GUARD_ENV };
 
 // ============================================================================
 // Basic Types
@@ -254,6 +256,9 @@ export interface Details {
 	currentStepIndex?: number;   // 0-indexed current step (for running chains)
 }
 
+// Upstream AgentToolResult omits the runtime isError flag that subagent tool results still emit/read.
+export type SubagentToolResult = AgentToolResult<Details> & { isError?: boolean };
+
 // ============================================================================
 // Artifacts
 // ============================================================================
@@ -572,6 +577,7 @@ export interface RunSyncOptions {
 	outputPath?: string;
 	outputMode?: OutputMode;
 	maxSubagentDepth?: number;
+	workflowStageSubagentGuard?: boolean;
 	nestedRoute?: NestedRouteInfo;
 	/** Override the agent's default model (format: "provider/id" or just "id") */
 	modelOverride?: string;
@@ -758,19 +764,87 @@ export function resolveChildMaxSubagentDepth(parentMaxDepth: number, agentMaxDep
 	return normalizedAgent === undefined ? normalizedParent : Math.min(normalizedParent, normalizedAgent);
 }
 
-export function checkSubagentDepth(configMaxDepth?: number): { blocked: boolean; depth: number; maxDepth: number } {
+export function hasWorkflowStageSubagentGuard(): boolean {
+	return getEnvValue(WORKFLOW_STAGE_SUBAGENT_GUARD_ENV) === "1";
+}
+
+export function isWorkflowStageOrchestrationContext(ctx: Pick<ExtensionContext, "orchestrationContext">): boolean {
+	return ctx.orchestrationContext?.kind === "workflow-stage";
+}
+
+export function resolveWorkflowStageMaxSubagentDepth(
+	ctx: Pick<ExtensionContext, "orchestrationContext">,
+	configMaxDepth?: number,
+): number {
+	const maxDepth = resolveCurrentMaxSubagentDepth(configMaxDepth);
+	return isWorkflowStageOrchestrationContext(ctx)
+		// Workflow stages reserve one child-subagent hop; a 0-depth constraint would
+		// prevent the stage from delegating to its configured subagent at all.
+		? Math.min(maxDepth, Math.max(1, ctx.orchestrationContext?.constraints.maxSubagentDepth ?? 1))
+		: maxDepth;
+}
+
+export interface SubagentDepthPolicy {
+	maxSubagentDepth: number;
+	workflowStageSubagentGuard: boolean;
+}
+
+export function resolveSubagentDepthPolicy(
+	ctx: Pick<ExtensionContext, "orchestrationContext">,
+	configMaxDepth?: number,
+): SubagentDepthPolicy {
+	return {
+		maxSubagentDepth: resolveWorkflowStageMaxSubagentDepth(ctx, configMaxDepth),
+		workflowStageSubagentGuard: isWorkflowStageOrchestrationContext(ctx),
+	};
+}
+
+function workflowStageSubagentDepthMessage(depth: number, maxDepth: number, action: "call" | "resume" = "call"): string {
+	return `Nested subagent ${action} blocked (depth=${depth}, max=${maxDepth}). Sub-agents inside workflow stages cannot spawn nested sub-agents.`;
+}
+
+export function subagentDepthBlockedMessage(
+	depth: number,
+	maxDepth: number,
+	options?: { action?: "call" | "resume"; workflowStageGuard?: boolean },
+): string {
+	const action = options?.action ?? "call";
+	if (options?.workflowStageGuard) {
+		return workflowStageSubagentDepthMessage(depth, maxDepth, action);
+	}
+	if (action === "resume") {
+		return `Nested subagent resume blocked (depth=${depth}, max=${maxDepth}). Complete the follow-up directly instead.`;
+	}
+	return `Nested subagent call blocked (depth=${depth}, max=${maxDepth}). ` +
+		"You are running at the maximum subagent nesting depth. " +
+		"Complete your current task directly without delegating to further subagents.";
+}
+
+export interface SubagentDepthCheck {
+	blocked: boolean;
+	depth: number;
+	maxDepth: number;
+	workflowStageGuard: boolean;
+}
+
+export function checkSubagentDepth(configMaxDepth?: number): SubagentDepthCheck {
 	const depth = Number(getEnvValue(SUBAGENT_DEPTH_ENV) ?? "0");
 	const maxDepth = resolveCurrentMaxSubagentDepth(configMaxDepth);
 	const blocked = Number.isFinite(depth) && depth >= maxDepth;
-	return { blocked, depth, maxDepth };
+	return { blocked, depth, maxDepth, workflowStageGuard: hasWorkflowStageSubagentGuard() };
 }
 
-export function getSubagentDepthEnv(maxDepth?: number): Record<string, string> {
+export function getSubagentDepthEnv(maxDepth?: number, options?: { workflowStageSubagentGuard?: boolean }): Record<string, string> {
 	const parentDepth = Number(getEnvValue(SUBAGENT_DEPTH_ENV) ?? "0");
+	// Preserve an inherited workflow-stage marker for descendants; callers that
+	// mutate process.env in tests must clear it to avoid intentional propagation.
 	const nextDepth = Number.isFinite(parentDepth) ? parentDepth + 1 : 1;
 	return {
 		[SUBAGENT_DEPTH_ENV]: String(nextDepth),
 		[SUBAGENT_MAX_DEPTH_ENV]: String(normalizeMaxSubagentDepth(maxDepth) ?? resolveCurrentMaxSubagentDepth()),
+		...(options?.workflowStageSubagentGuard || hasWorkflowStageSubagentGuard()
+			? { [WORKFLOW_STAGE_SUBAGENT_GUARD_ENV]: "1" }
+			: {}),
 	};
 }
 

package/dist/builtin/subagents/src/tui/render.ts

@@ -88,10 +88,28 @@ function truncLine(text: string, maxWidth: number): string {
 }
 
 const RUNNING_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-const STATIC_RUNNING_GLYPH = "●";
+
+/**
+ * Spinner cadence (ms per frame). The running glyph is derived from wall-clock
+ * time so every active spinner advances smoothly and in lockstep, independent
+ * of how often (or how irregularly) progress data updates arrive. The animation
+ * timers below only schedule re-renders; the displayed frame always comes from
+ * the clock. This fixes the frozen/stuttering spinner from issue #1084 while
+ * keeping per-frame diffs to a single glyph cell so the differential renderer
+ * never needs a full-clear (no flicker).
+ */
+export const RUNNING_ANIMATION_MS = 80;
 
 type ProgressSeedSource = Partial<Pick<AgentProgress, "index" | "toolCount" | "tokens" | "durationMs" | "lastActivityAt" | "currentToolStartedAt" | "turnCount">>;
 
+/**
+ * Wall-clock-derived animation frame counter. Advances exactly one step every
+ * `RUNNING_ANIMATION_MS`. Exposed for tests so they can pin a deterministic now.
+ */
+export function currentRunningFrame(now: number = Date.now()): number {
+	return Math.floor(now / RUNNING_ANIMATION_MS);
+}
+
 function runningSeed(...values: Array<number | undefined>): number | undefined {
 	let seed: number | undefined;
 	for (const value of values) {
@@ -102,8 +120,11 @@ function runningSeed(...values: Array<number | undefined>): number | undefined {
 }
 
 function runningGlyph(seed?: number): string {
-	if (seed === undefined) return STATIC_RUNNING_GLYPH;
-	return RUNNING_FRAMES[Math.abs(seed) % RUNNING_FRAMES.length]!;
+	// Fold the wall-clock frame into the (optional) progress seed so the glyph
+	// advances over time. The frame is always finite, so a running entity always
+	// animates; the seed only offsets its starting phase between concurrent agents.
+	const animatedSeed = runningSeed(seed, currentRunningFrame()) ?? 0;
+	return RUNNING_FRAMES[Math.abs(animatedSeed) % RUNNING_FRAMES.length]!;
 }
 
 function progressRunningSeed(progress: ProgressSeedSource | undefined): number | undefined {
@@ -119,17 +140,85 @@ function progressRunningSeed(progress: ProgressSeedSource | undefined): number |
 	);
 }
 
-interface LegacyResultAnimationContext {
-	state: { subagentResultAnimationTimer?: ReturnType<typeof setInterval> };
+type ResultAnimationState = { subagentResultAnimationTimer?: ReturnType<typeof setInterval> };
+
+interface ResultAnimationContext {
+	state: ResultAnimationState;
+	invalidate: () => void;
 }
 
-export function clearLegacyResultAnimationTimer(context: LegacyResultAnimationContext): void {
+type LegacyResultAnimationContext = { state: ResultAnimationState };
+type ResultAnimationEntry = ResultAnimationContext;
+
+// Registry of every live result-animation timer so they can be torn down in one
+// shot on reload/shutdown even if their owning render context never re-renders.
+// Each tick reads the latest `invalidate` from here so a re-sync can refresh the
+// callback if the host ever swaps render contexts for the same renderable.
+const resultAnimationTimers = new Map<ReturnType<typeof setInterval>, ResultAnimationEntry>();
+
+function resultIsRunning(result: AgentToolResult<Details>): boolean {
+	return Boolean(
+		result.details?.progress?.some((entry) => entry.status === "running")
+		|| result.details?.results.some((entry) => entry.progress?.status === "running"),
+	);
+}
+
+function stopResultAnimation(context: LegacyResultAnimationContext): void {
 	const timer = context.state.subagentResultAnimationTimer;
 	if (!timer) return;
 	clearInterval(timer);
+	resultAnimationTimers.delete(timer);
 	context.state.subagentResultAnimationTimer = undefined;
 }
 
+export function clearLegacyResultAnimationTimer(context: LegacyResultAnimationContext): void {
+	stopResultAnimation(context);
+}
+
+/**
+ * Keep a running subagent result's spinner animating by scheduling a steady
+ * re-render while it is active, and tearing the timer down once it settles.
+ * The timer only calls `context.invalidate()`; the glyph value itself comes
+ * from {@link currentRunningFrame}, so each tick produces a single-glyph diff.
+ */
+export function syncResultAnimation(result: AgentToolResult<Details>, context: ResultAnimationContext): void {
+	if (!resultIsRunning(result)) {
+		stopResultAnimation(context);
+		return;
+	}
+	const existing = context.state.subagentResultAnimationTimer;
+	if (existing) {
+		// Keep using the most recent invalidate in case the host handed us a fresh
+		// render context object on this re-sync.
+		const entry = resultAnimationTimers.get(existing);
+		if (entry) entry.invalidate = context.invalidate;
+		return;
+	}
+	const timer = setInterval(() => {
+		const entry = resultAnimationTimers.get(timer);
+		if (!entry) return;
+		try {
+			entry.invalidate();
+		} catch {
+			// A cosmetic spinner tick must never crash the host (e.g. a stale extension
+			// context after reload/session swap, or any other render glitch). Stop this
+			// timer; the next real render re-syncs and restarts it while still running.
+			stopResultAnimation(context);
+		}
+	}, RUNNING_ANIMATION_MS);
+	timer.unref?.();
+	context.state.subagentResultAnimationTimer = timer;
+	resultAnimationTimers.set(timer, { state: context.state, invalidate: context.invalidate });
+}
+
+export function stopResultAnimations(): void {
+	for (const [timer, entry] of resultAnimationTimers) {
+		clearInterval(timer);
+		entry.state.subagentResultAnimationTimer = undefined;
+	}
+	resultAnimationTimers.clear();
+}
+
 function extractOutputTarget(task: string): string | undefined {
 	const writeToMatch = task.match(/\[Write to:\s*([^\]\n]+)\]/i);
 	if (writeToMatch?.[1]?.trim()) return writeToMatch[1].trim();
@@ -836,18 +925,95 @@ function fitWidgetLineBudget(lines: string[], theme: Theme, width: number, expan
 	return [...lines.slice(0, visibleLines), truncLine(theme.fg("dim", hint), width)];
 }
 
-function buildWidgetComponent(jobs: AsyncJobState[], expanded: boolean): (_tui: unknown, theme: Theme) => Component {
-	return (_tui, theme) => {
-		const width = getTermWidth();
+/**
+ * Live async-agents widget. Recomputes its lines on every render so the
+ * wall-clock-driven running glyph (and elapsed-time labels) stay current; the
+ * widget animation ticker below schedules those re-renders while jobs run.
+ */
+class LiveWidgetComponent implements Component {
+	private readonly container = new Container();
+
+	constructor(
+		private readonly jobs: AsyncJobState[],
+		private readonly theme: Theme,
+		private readonly getExpanded: () => boolean,
+	) {}
+
+	render(width: number): string[] {
+		const expanded = this.getExpanded();
 		const lines = expanded
-			? buildWidgetLines(jobs, theme, width, true)
-			: jobs.length === 1
-				? compactSingleWidgetLines(jobs[0]!, theme, width)
-				: buildWidgetLines(jobs, theme, width, false);
-		const container = new Container();
-		for (const line of fitWidgetLineBudget(lines, theme, width, expanded)) container.addChild(new Text(line, 1, 0));
-		return container;
-	};
+			? buildWidgetLines(this.jobs, this.theme, width, true)
+			: this.jobs.length === 1
+				? compactSingleWidgetLines(this.jobs[0]!, this.theme, width)
+				: buildWidgetLines(this.jobs, this.theme, width, false);
+		this.container.clear();
+		for (const line of fitWidgetLineBudget(lines, this.theme, width, expanded)) this.container.addChild(new Text(line, 1, 0));
+		return this.container.render(width);
+	}
+
+	invalidate(): void {
+		this.container.invalidate();
+	}
+}
+
+function buildWidgetComponent(jobs: AsyncJobState[], getExpanded: () => boolean): (_tui: unknown, theme: Theme) => Component {
+	return (_tui, theme) => new LiveWidgetComponent(jobs, theme, getExpanded);
+}
+
+interface RenderRequestingContext {
+	ui: ExtensionContext["ui"] & { requestRender?: () => void };
+}
+
+// There is only ever one async-agents widget per host process, so the widget
+// ticker keeps its driving context/jobs in module-level singletons.
+let latestWidgetCtx: ExtensionContext | undefined;
+let latestWidgetJobs: AsyncJobState[] = [];
+let widgetTimer: ReturnType<typeof setInterval> | undefined;
+
+function hasAnimatedWidgetJobs(jobs: AsyncJobState[]): boolean {
+	// Animate while any job — or any of its nested steps — is still running so the
+	// header/step spinners never freeze before the work actually settles.
+	return jobs.some((job) => job.status === "running" || job.steps?.some((step) => step.status === "running"));
+}
+
+function refreshAnimatedWidget(): void {
+	if (!latestWidgetCtx?.hasUI) return;
+	try {
+		// The cast is required because narrowing on `hasUI` above collapses `ui` to
+		// the base ExtensionUIContext, which does not declare the optional
+		// requestRender that the running interactive host actually provides.
+		(latestWidgetCtx as RenderRequestingContext).ui.requestRender?.();
+	} catch {
+		// Never let a cosmetic widget tick crash the host; stop on any error.
+		stopWidgetAnimation();
+	}
+}
+
+function ensureWidgetAnimation(): void {
+	if (widgetTimer) return;
+	widgetTimer = setInterval(() => {
+		if (!hasAnimatedWidgetJobs(latestWidgetJobs)) {
+			stopWidgetAnimation();
+			return;
+		}
+		refreshAnimatedWidget();
+	}, RUNNING_ANIMATION_MS);
+	widgetTimer.unref?.();
+}
+
+// Stop only the ticker, keeping the last-rendered widget context/jobs intact.
+function stopWidgetTicker(): void {
+	if (widgetTimer) {
+		clearInterval(widgetTimer);
+		widgetTimer = undefined;
+	}
+}
+
+// Full teardown: stop the ticker and forget the driving context/jobs entirely.
+export function stopWidgetAnimation(): void {
+	stopWidgetTicker();
+	latestWidgetCtx = undefined;
+	latestWidgetJobs = [];
 }
 
 export function buildWidgetLines(jobs: AsyncJobState[], theme: Theme, width = getTermWidth(), expanded = false): string[] {
@@ -925,11 +1091,29 @@ export function buildWidgetLines(jobs: AsyncJobState[], theme: Theme, width = ge
  */
 export function renderWidget(ctx: ExtensionContext, jobs: AsyncJobState[]): void {
 	if (jobs.length === 0) {
+		stopWidgetAnimation();
 		if (ctx.hasUI) ctx.ui.setWidget(WIDGET_KEY, undefined);
 		return;
 	}
-	if (!ctx.hasUI) return;
-	ctx.ui.setWidget(WIDGET_KEY, buildWidgetComponent(jobs, ctx.ui.getToolsExpanded?.() ?? false));
+	if (!ctx.hasUI) {
+		stopWidgetAnimation();
+		return;
+	}
+	latestWidgetCtx = ctx;
+	latestWidgetJobs = [...jobs];
+	// belowEditor: the widget animates a running glyph / elapsed labels on a
+	// timer. pi-tui full-clears the screen+scrollback whenever a changed line
+	// sits above the viewport fold, so an aboveEditor widget flickers once the
+	// bottom region grows tall and pushes it above the fold. Rendering below the
+	// editor keeps the live line within the bottom viewport (flicker-free), and
+	// matches the workflow companion widget's placement (#1109).
+	ctx.ui.setWidget(WIDGET_KEY, buildWidgetComponent(jobs, () => ctx.ui.getToolsExpanded?.() ?? false), {
+		placement: "belowEditor",
+	});
+	// Keep the just-rendered ctx/jobs as the last-rendered state; only the ticker
+	// is conditional on whether anything is still animating.
+	if (hasAnimatedWidgetJobs(jobs)) ensureWidgetAnimation();
+	else stopWidgetTicker();
 }
 
 function renderSingleCompact(d: Details, r: Details["results"][number], theme: Theme): Component {

package/dist/builtin/web-access/CHANGELOG.md

@@ -4,6 +4,16 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [0.8.20] - 2026-05-29
+
+### Changed
+- Promoted the 0.8.20 prerelease changes to a stable release.
+
+## [0.8.20-0] - 2026-05-29
+
+### Changed
+- Bumped `linkedom` to 0.18.12 to align with the pi 0.77.0 upgrade.
+
 ## [0.8.18] - 2026-05-27
 
 ### Changed

package/dist/builtin/web-access/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/web-access",
-  "version": "0.8.19",
+  "version": "0.8.20",
   "private": true,
   "description": "Atomic extension for web search, URL fetching, GitHub repo cloning, PDF/video extraction. Fork of: https://github.com/nicobailon/pi-web-access",
   "contributors": [
@@ -42,7 +42,7 @@
   },
   "dependencies": {
     "@mozilla/readability": "^0.6.0",
-    "linkedom": "^0.16.0",
+    "linkedom": "^0.18.12",
     "p-limit": "^6.1.0",
     "turndown": "^7.2.0",
     "unpdf": "^1.6.2"

package/dist/builtin/workflows/CHANGELOG.md

@@ -6,6 +6,31 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [0.8.20] - 2026-05-29
+
+### Changed
+
+- Promoted the 0.8.20 prerelease changes to a stable release.
+
+## [0.8.20-0] - 2026-05-29
+
+### Added
+
+- Added main-chat lifecycle steer notices for workflow completion, failure, and awaiting-input pauses with global notification config controls ([#1085](https://github.com/flora131/atomic/issues/1085)).
+
+### Fixed
+
+- Fixed the background-workflow companion counter widget flickering every second while a run is active by updating a single long-lived above-editor widget in place instead of disposing and re-mounting a fresh widget factory on each elapsed-clock tick ([#1109](https://github.com/flora131/atomic/issues/1109)).
+- Fixed workflow lifecycle completion/failure/awaiting-input notices crashing the TUI on narrow or freshly-resized terminals: the notice component now wraps to the render width (hard-breaking long run ids) instead of emitting a single fixed line, which pi-tui rejects with a hard "Rendered line exceeds terminal width" throw ([#1109](https://github.com/flora131/atomic/issues/1109)).
+- Fixed the workflow companion counter widget triggering a full-screen redraw (clear + scrollback wipe) on every elapsed-clock tick after the terminal is resized while a run is active. The widget now mounts `belowEditor` instead of `aboveEditor`, keeping its live clock line within the bottom viewport; pi-tui full-clears the screen whenever a changed line sits above the viewport fold, and an above-editor widget was pushed above the fold once the editor/status region grew tall ([#1109](https://github.com/flora131/atomic/issues/1109)).
+- Disabled workflows in non-interactive (`-p` / `--print` / `--mode json`) sessions, which bind a no-op UI surface and cannot drive workflow prompts, pickers, or the graph overlay: the `workflow` tool is removed from the model's active tool set at session start, and the `/workflow` command (reachable via `atomic -p "/workflow …"`) is refused — preventing headless runs from stalling on work that can never complete ([#1096](https://github.com/flora131/atomic/issues/1096)).
+- Escaped workflow lifecycle notice text and structured response hints, isolated lifecycle send failures from store subscribers, and rejected empty lifecycle notification event lists ([#1085](https://github.com/flora131/atomic/issues/1085)).
+- Fixed stage awaiting-input lifecycle notice dedupe so promptless pauses after resolved prompts are not suppressed by historical prompt metadata ([#1085](https://github.com/flora131/atomic/issues/1085)).
+- Reset workflow lifecycle-notification dedupe state at chat session boundaries so reused workflow run IDs in later sessions still emit completion/failure/input notices ([#1085](https://github.com/flora131/atomic/issues/1085)).
+- Warn before starting or resuming another session when workflows are still in flight, allowing users to cancel before those runs are killed and current-session workflow history is cleared ([#1082](https://github.com/flora131/atomic/issues/1082)).
+- Prevented workflow stage sessions from exposing or executing the `workflow` tool while preserving stage-level subagent delegation.
+- Retained completed, failed, and killed workflow runs in user-facing status/connect surfaces and changed workflow kill controls to mark runs killed without removing them from live inspection history ([#1083](https://github.com/flora131/atomic/issues/1083)).
+
 ## [0.8.18] - 2026-05-27
 
 ### Changed

package/dist/builtin/workflows/README.md

@@ -27,6 +27,21 @@ Adding workflow files under `.atomic/workflows/` (project scope) or `~/.atomic/a
 }
 ```
 
+### Workflow lifecycle notifications
+
+Workflow lifecycle notices are enabled by default. They send steer prompts into the main chat/model context when a run completes, fails, or pauses for input. Configure them in the same extension config file:
+
+```json
+{
+  "workflowNotifications": {
+    "enabled": true,
+    "notifyOn": ["completed", "failed", "awaiting_input"]
+  }
+}
+```
+
+Set `enabled` to `false` to disable all notices, or narrow `notifyOn` to a non-empty list of selected events. Emitted notices use steer delivery and wake an idle model so the lifecycle update enters the model context when it happens.
+
 ---
 
 ## Authoring API
@@ -243,12 +258,12 @@ registry.get("alpha"); // compiled workflow definition | undefined
 | `/workflow <name> [key=value ...]`    | Start a named workflow, passing optional input overrides |
 | `/workflow <name> --help`             | Print the workflow's input schema                        |
 | `/workflow list`                      | List all registered workflows with descriptions          |
-| `/workflow status [run-id]`           | Show active runs or details for one run                  |
+| `/workflow status [run-id]`           | Show active plus retained terminal/current-session runs, or details for one run |
 | `/workflow connect [run-id]`          | Attach to a workflow run overlay                         |
 | `/workflow attach [run-id] [stage]`   | Open the attach/chat pane for a run or stage             |
 | `/workflow pause [run-id] [stage]`    | Pause a live run or stage                                |
 | `/workflow interrupt [run-id\|--all]` | Pause active/named/all active runs so they can resume    |
-| `/workflow kill [run-id\|--all]`      | Kill and remove active/named/all active runs from status |
+| `/workflow kill [run-id\|--all]`      | Kill in-flight workflow runs; killed runs are retained for inspection |
 | `/workflow resume <run-id>`           | Resume paused work or re-open a run snapshot             |
 | `/workflow reload`                    | Reload discovered workflow resources in-process          |
 | `/workflow inputs <name>`             | Print the input schema for a workflow                    |
@@ -302,7 +317,7 @@ Press **F2** while a workflow is running to open the DAG overlay for the active
 
 `@bastani/workflows` follows pi's package/extension model: pi loads `src/extension/index.ts` from the package `pi.extensions` manifest, then the extension registers the `workflow` tool, `/workflow` slash command, renderers, widget, and lifecycle hooks in-process.
 
-For interactive use, run workflows through `/workflow <name> [key=value ...]` or let the LLM call the `workflow` tool. For library or scripted use, call the explicit programmatic runner:
+For interactive use, run workflows through `/workflow <name> [key=value ...]` or let the LLM call the `workflow` tool. Both the `/workflow` command and the `workflow` tool are disabled in non-interactive (`-p` / `--print` / `--mode json`) sessions, which bind a no-op UI surface and therefore cannot drive workflow pickers, the graph overlay, or human-in-the-loop prompts. For library or scripted use, call the explicit programmatic runner instead:
 
 ```ts
 import { runWorkflow, type WorkflowOptions } from "@bastani/workflows";
@@ -429,6 +444,10 @@ Config-based discovery (`~/.atomic/agent/extensions/workflow/config.json` or `.a
 {
   "workflows": {
     "my-team-workflows": { "path": "/shared/team/workflows" }
+  },
+  "workflowNotifications": {
+    "enabled": true,
+    "notifyOn": ["completed", "failed", "awaiting_input"]
   }
 }
 ```

package/dist/builtin/workflows/builtin/deep-research-codebase.ts

@@ -401,7 +401,7 @@ export async function runDeepResearchCodebaseWorkflow(
     fallbackModels: [
       "openai-codex/gpt-5.5",
       "github-copilot/gpt-5.5",
-      "anthropic/claude-opus-4-7",
+      "anthropic/claude-opus-4-8",
       "github-copilot/claude-opus-4.7",
     ],
     thinkingLevel: "high" as const,

package/dist/builtin/workflows/builtin/open-claude-design.ts

@@ -222,12 +222,14 @@ export default defineWorkflow("open-claude-design")
       DEFAULT_MAX_REFINEMENTS,
     );
 
-    const { runId, artifactDir, previewPath, specPath } = prepareArtifactDir(ctx.cwd);
+    const { runId, artifactDir, previewPath, specPath } = prepareArtifactDir(
+      ctx.cwd,
+    );
     const previewFileUrl = `file://${previewPath}`;
     const specFileUrl = `file://${specPath}`;
 
     const designModelConfig = {
-      model: "anthropic/claude-opus-4-7",
+      model: "anthropic/claude-opus-4-8",
       fallbackModels: [
         "github-copilot/claude-opus-4.7",
         "anthropic/claude-sonnet-4-6",
@@ -710,7 +712,10 @@ export default defineWorkflow("open-claude-design")
               ["preview_path", previewPath],
               ["preview_file_url", previewFileUrl],
               ["current_design_and_feedback", "{previous}"],
-              ["playwright_browser_bootstrap", PLAYWRIGHT_BROWSER_BOOTSTRAP_RULES],
+              [
+                "playwright_browser_bootstrap",
+                PLAYWRIGHT_BROWSER_BOOTSTRAP_RULES,
+              ],
               [
                 "instructions",
                 [
@@ -798,7 +803,10 @@ export default defineWorkflow("open-claude-design")
             ],
             ["preview_path", previewPath],
             ["preview_file_url", previewFileUrl],
-            ["playwright_browser_bootstrap", PLAYWRIGHT_BROWSER_BOOTSTRAP_RULES],
+            [
+              "playwright_browser_bootstrap",
+              PLAYWRIGHT_BROWSER_BOOTSTRAP_RULES,
+            ],
             [
               "instructions",
               [

package/dist/builtin/workflows/builtin/ralph.ts

@@ -417,7 +417,7 @@ async function runRalphWorkflow(
     fallbackModels: [
       "openai-codex/gpt-5.5",
       "github-copilot/gpt-5.5",
-      "anthropic/claude-opus-4-7",
+      "anthropic/claude-opus-4-8",
       "github-copilot/claude-opus-4.7",
     ],
     thinkingLevel: "high" as const,
@@ -453,7 +453,7 @@ async function runRalphWorkflow(
     fallbackModels: [
       "openai-codex/gpt-5.5",
       "github-copilot/gpt-5.5",
-      "anthropic/claude-opus-4-7",
+      "anthropic/claude-opus-4-8",
       "github-copilot/claude-opus-4.7",
     ],
     thinkingLevel: "high" as const,

package/dist/builtin/workflows/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/workflows",
-  "version": "0.8.19",
+  "version": "0.8.20",
   "private": true,
   "description": "Atomic extension for multi-stage workflow authoring and execution.",
   "contributors": [