@bastani/atomic 0.9.2 → 0.9.3-alpha.2

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

@@ -5,10 +5,10 @@ import type { AgentProgress, AsyncJobStep, Details } from "../shared/types.ts";
 import { formatDuration, formatTokens, formatUsage, shortenPath } from "../shared/formatters.ts";
 import { getSingleResultOutput } from "../shared/utils.ts";
 import { getTermWidth, truncLine, type Theme } from "./render-layout.ts";
-import { clearResultAnimationTimer, ensureResultAnimation, type ResultAnimationContext } from "./render-result-animation.ts";
+import { advanceResultPulseFrame, clearResultAnimationTimer, type ResultAnimationContext } from "./render-result-animation.ts";
 import { renderMultiCompact, renderSingleCompact } from "./render-result-compact.ts";
 import { buildChainRenderEntries, buildMultiProgressLabel, resultRowLabel, workflowGraphHasStatus, type ChainRenderEntry } from "./render-chain-graph.ts";
-import { isRunningSubagentResult, subagentResultRenderKey } from "./render-stable-output.ts";
+import { subagentResultRenderKey } from "./render-stable-output.ts";
 import { modelThinkingBadge, widgetStepStatus } from "./render-event-formatting.ts";
 import {
 	buildLiveStatusLine,
@@ -28,26 +28,27 @@ export function renderLiveSubagentResult(
 ): Component {
 	const nextKey = subagentResultRenderKey(result, options);
 	if (context.state.subagentResultSnapshotKey !== nextKey) {
-		const frameNow = Date.now();
 		context.state.subagentResultSnapshotKey = nextKey;
-		context.state.subagentResultSnapshotNow = frameNow;
-		context.state.subagentResultSpinnerFrameNow = frameNow;
+		context.state.subagentResultSnapshotNow = Date.now();
+		// Advance the activity pulse exactly once per real progress update.
+		// Foreground subagent results render into chat scrollback, which can sit
+		// above the viewport fold. Animating on a timer there forces pi-tui into a
+		// destructive full-screen/scrollback clear on every tick (the flicker that
+		// scaled with widget height). Driving the pulse off genuine updates keeps
+		// the only line diffs tied to content that actually changed, so the
+		// differential renderer repaints exactly as it would for any progress
+		// update — no extra above-fold churn between updates.
+		context.state.subagentResultPulseFrame = advanceResultPulseFrame(context.state.subagentResultPulseFrame);
 	}
 	context.state.subagentResultSnapshotNow ??= Date.now();
-	context.state.subagentResultSpinnerFrameNow ??= context.state.subagentResultSnapshotNow;
-	// Foreground subagent results render inside chat scrollback. Keep semantic
-	// content time stable between tool/progress updates, but let the spinner tick
-	// independently. That limits timer-driven diffs to spinner glyph cells instead
-	// of updating elapsed/tool/activity text and causing broad chatbox churn.
-	if (options.isPartial && isRunningSubagentResult(result)) {
-		ensureResultAnimation(context);
-	} else {
-		clearResultAnimationTimer(context);
-	}
+	context.state.subagentResultPulseFrame ??= 0;
+	// Never schedule timer-driven re-renders for scrollback content; clear any
+	// stale timer a previous version may have installed for this render slot.
+	clearResultAnimationTimer(context);
 	return renderSubagentResult(result, {
 		...options,
 		now: context.state.subagentResultSnapshotNow,
-		spinnerNow: context.state.subagentResultSpinnerFrameNow,
+		pulseFrame: context.state.subagentResultPulseFrame,
 	}, theme);
 }
 
@@ -56,7 +57,7 @@ export function renderLiveSubagentResult(
  */
 export function renderSubagentResult(
 	result: AgentToolResult<Details>,
-	options: { expanded: boolean; now?: number; spinnerNow?: number },
+	options: { expanded: boolean; now?: number; pulseFrame?: number },
 	theme: Theme,
 ): Component {
 	const d = result.details;
@@ -72,7 +73,7 @@ export function renderSubagentResult(
 
 	if (d.mode === "single" && d.results.length === 1) {
 		const r = d.results[0];
-		if (!expanded) return renderSingleCompact(d, r, theme, options.now, options.spinnerNow);
+		if (!expanded) return renderSingleCompact(d, r, theme, options.now, options.pulseFrame);
 		const isRunning = r.progress?.status === "running";
 		const icon = isRunning
 			? theme.fg("warning", "running")
@@ -166,7 +167,7 @@ export function renderSubagentResult(
 		return c;
 	}
 
-	if (!expanded) return renderMultiCompact(d, theme, options.now, options.spinnerNow);
+	if (!expanded) return renderMultiCompact(d, theme, options.now, options.pulseFrame);
 
 	const hasRunning = d.progress?.some((p) => p.status === "running")
 		|| d.results.some((r) => r.progress?.status === "running")

package/dist/builtin/subagents/src/tui/render-status-progress.ts

@@ -2,7 +2,7 @@ import type { AgentProgress, Details } from "../shared/types.ts";
 import { formatDuration, formatTokens, formatToolCall } from "../shared/formatters.ts";
 import { getDisplayItems } from "../shared/utils.ts";
 import { formatActivityLabel } from "../shared/status-format.ts";
-import { getTermWidth, progressRunningSeed, runningGlyph, type Theme } from "./render-layout.ts";
+import { getTermWidth, pulseGlyph, type Theme } from "./render-layout.ts";
 
 export function extractOutputTarget(task: string): string | undefined {
 	const writeToMatch = task.match(/\[Write to:\s*([^\]\n]+)\]/i);
@@ -118,8 +118,8 @@ export function resultStatusLine(result: Details["results"][number], output: str
 	return "Done";
 }
 
-export function resultGlyph(result: Details["results"][number], output: string, theme: Theme, running = result.progress?.status === "running", seed = progressRunningSeed(result.progress ?? result.progressSummary), now?: number): string {
-	if (running) return theme.fg("accent", runningGlyph(seed, now));
+export function resultGlyph(result: Details["results"][number], output: string, theme: Theme, running = result.progress?.status === "running", pulseFrame?: number): string {
+	if (running) return theme.fg("accent", pulseGlyph(pulseFrame));
 	if (result.detached) return theme.fg("warning", "■");
 	if (result.interrupted) return theme.fg("warning", "■");
 	if (result.exitCode !== 0) return theme.fg("error", "✗");

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

@@ -1,5 +1,6 @@
 import type { ExtensionContext } from "@bastani/atomic";
 import { Container, Text, type Component } from "@earendil-works/pi-tui";
+import * as path from "node:path";
 import { MAX_WIDGET_JOBS, WIDGET_KEY, type AsyncJobState } from "../shared/types.ts";
 import { getTermWidth, RUNNING_ANIMATION_MS, runningGlyph, truncLine, type Theme } from "./render-layout.ts";
 import { themeBold } from "./render-status-progress.ts";
@@ -64,6 +65,7 @@ let latestWidgetJobs: AsyncJobState[] = [];
 let latestWidgetFrameNow = 0;
 let widgetTimer: ReturnType<typeof setInterval> | undefined;
 let mountedWidgetCtx: ExtensionContext | undefined;
+let mountedWidgetOwnerKey: string | undefined;
 let widgetMounted = false;
 
 function getLatestWidgetJobs(): AsyncJobState[] {
@@ -87,9 +89,38 @@ function clearLatestWidgetState(): void {
 	latestWidgetJobs = [];
 	latestWidgetFrameNow = 0;
 	mountedWidgetCtx = undefined;
+	mountedWidgetOwnerKey = undefined;
 	widgetMounted = false;
 }
 
+function getWidgetOwnerKey(ctx: ExtensionContext): string {
+	const resolvedCwd = ctx.cwd ? path.resolve(ctx.cwd) : undefined;
+	const cwdOwner = resolvedCwd ?? "cwd:unknown";
+	let sessionOwner = "session:unknown";
+	try {
+		const sessionFile = ctx.sessionManager.getSessionFile?.();
+		if (sessionFile) {
+			const resolvedSessionFile = resolvedCwd
+				? path.resolve(resolvedCwd, sessionFile)
+				: path.resolve(sessionFile);
+			sessionOwner = `sessionFile:${resolvedSessionFile}`;
+		}
+	} catch {
+		// Fall through to the session id fallback below.
+	}
+	if (sessionOwner === "session:unknown") {
+		try {
+			const sessionId = ctx.sessionManager.getSessionId?.();
+			if (sessionId) sessionOwner = `sessionId:${sessionId}`;
+		} catch {
+			// Keep the unknown marker; cwd still scopes ownership.
+		}
+	}
+	// If no session identifier is available, cwd is the best available owner
+	// boundary and may intentionally coalesce concurrent sessions in one folder.
+	return `${sessionOwner}|cwd:${cwdOwner}`;
+}
+
 function requestWidgetRender(ctx: ExtensionContext): void {
 	(ctx as RenderRequestingContext).ui.requestRender?.();
 }
@@ -226,10 +257,12 @@ export function buildWidgetLines(jobs: AsyncJobState[], theme: Theme, width = ge
  * Render the async jobs widget
  */
 export function renderWidget(ctx: ExtensionContext, jobs: AsyncJobState[]): void {
+	const ownerKey = getWidgetOwnerKey(ctx);
 	if (jobs.length === 0) {
-		if (widgetMounted && mountedWidgetCtx !== ctx) {
-			// Empty updates from stale contexts must not clear the active context's
-			// widget. The mounted context owns the eventual teardown.
+		if (widgetMounted && mountedWidgetOwnerKey !== ownerKey) {
+			// With no visible job frame, stale-owner empty updates and newly-active
+			// empty owners are indistinguishable here. Preserve active-widget safety;
+			// host session disposal owns cross-owner empty-session teardown.
 			return;
 		}
 		stopWidgetAnimation();
@@ -242,11 +275,12 @@ export function renderWidget(ctx: ExtensionContext, jobs: AsyncJobState[]): void
 	latestWidgetCtx = ctx;
 	latestWidgetJobs = [...jobs];
 	latestWidgetFrameNow = Date.now();
-	if (widgetMounted && mountedWidgetCtx !== ctx) {
-		// Context rebinding can leave the previous host UI alive briefly; clear the
-		// old mount before installing the singleton widget on the new context.
+	if (widgetMounted && mountedWidgetOwnerKey !== ownerKey) {
+		// Session rebinding can leave the previous host UI alive briefly; clear the
+		// old mount before installing the singleton widget on the new owner/context.
 		unmountWidgetBestEffort(mountedWidgetCtx);
 		mountedWidgetCtx = undefined;
+		mountedWidgetOwnerKey = undefined;
 		widgetMounted = false;
 	}
 	if (!widgetMounted) {
@@ -260,10 +294,15 @@ export function renderWidget(ctx: ExtensionContext, jobs: AsyncJobState[]): void
 			placement: "belowEditor",
 		});
 		mountedWidgetCtx = ctx;
+		mountedWidgetOwnerKey = ownerKey;
 		widgetMounted = true;
 	} else {
 		// The mounted widget reads latestWidgetJobs via getLatestWidgetJobs(), so a
-		// visible->visible update only needs to ask the host to render in place.
+		// visible->visible update only needs to ask the host to render in place. Keep
+		// teardown pointed at the freshest same-owner wrapper because older wrappers
+		// can go stale after host session/context rebinding.
+		mountedWidgetCtx = ctx;
+		mountedWidgetOwnerKey = ownerKey;
 		requestWidgetRender(ctx);
 	}
 	// Keep the just-rendered ctx/jobs as the last-rendered state; only the ticker

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

@@ -5,11 +5,11 @@
  * rendering responsibility across sibling modules.
  */
 
-export { RUNNING_ANIMATION_MS, currentRunningFrame } from "./render-layout.ts";
+export { PULSE_FRAMES, RUNNING_ANIMATION_MS, RUNNING_FRAMES, currentRunningFrame, pulseGlyph } from "./render-layout.ts";
 export {
+	advanceResultPulseFrame,
 	clearLegacyResultAnimationTimer,
 	clearResultAnimationTimer,
-	ensureResultAnimation,
 	stopResultAnimations,
 } from "./render-result-animation.ts";
 export type { SubagentResultRenderState } from "./render-result-animation.ts";

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

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/web-access",
-  "version": "0.9.2",
+  "version": "0.9.3-alpha.2",
   "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": [

package/dist/builtin/workflows/CHANGELOG.md

@@ -6,6 +6,62 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [0.9.3-alpha.2] - 2026-06-27
+
+### Breaking Changes
+
+- Workflow durability is now enabled by default with the zero-infrastructure per-workflow file backend rooted under `~/.atomic/workflow-durable`; the previous process-local in-memory default and `ATOMIC_WORKFLOW_DURABLE_DIR` opt-in path were removed. In-memory durability remains available for explicit test/custom backend overrides and for the privacy opt-out `ATOMIC_WORKFLOW_DURABLE=0`/`false`/`off`/`memory`. ([#1498](https://github.com/bastani-inc/atomic/issues/1498))
+
+### Added
+
+- Added `StageContext.sendUserMessage(content, { deliverAs? })` so workflow authors can inject a normal follow-on user turn into a stage session after `prompt()` resolves. Idle sessions start immediately, streaming sessions queue as follow-up by default (or steering with `deliverAs: "steer"`), schema-backed stages can continue after their one allowed structured `prompt()` without tripping the one-shot prompt guard, follow-on turns preserve the stage MCP allow/deny scope, and native stage sessions accept the same string or text/image block content as `AgentSession.sendUserMessage()`. Durable replayed cached stages now reject this live-session operation instead of silently ignoring it. ([#1520](https://github.com/bastani-inc/atomic/issues/1520))
+- Added cross-session workflow resumability via a durable workflow backend seam (`packages/workflows/src/durable/`). Workflows now persist `ctx.*` operation checkpoints (tool, ui, stage) to a durable backend so a new Atomic session can resume a workflow started in a prior session from the last completed checkpoint, without re-running completed work. Cross-session persistence is enabled by default through a lock-protected per-workflow file backend at `~/.atomic/workflow-durable`; no environment variable is required. When `DBOS_SYSTEM_DATABASE_URL` is set, Atomic lazily initializes DBOS with Postgres-backed workflow/control records and falls back to the file backend if DBOS is unavailable. Top-level workflow metadata is mirrored as `workflow.durable.checkpoint` session entries for `/workflow resume` discovery. ([#1498](https://github.com/bastani-inc/atomic/issues/1498))
+- Introduced `ctx.tool(name, args, fn, options?)` — a durable cached tool execution primitive that runs arbitrary TypeScript code and caches the result so completed side effects are not repeated on resume. Supports optional retry with exponential backoff via `retriesAllowed`, `maxAttempts`, `intervalMs`, and `backoffRate` options. Only `ctx.*` blocks produce durable checkpoints. ([#1498](https://github.com/bastani-inc/atomic/issues/1498))
+- Added durable `ctx.ui` checkpointing: completed `ctx.ui.input` / `confirm` / `select` / `editor` / `custom` responses are cached by prompt identity that includes method, label/message, options, and call order, so repeated prompts do not collide and a resumed workflow does not re-ask already-answered prompts. ([#1498](https://github.com/bastani-inc/atomic/issues/1498))
+- Added durable `ctx.stage` / `ctx.task` / `ctx.chain` / `ctx.parallel` / child `ctx.workflow` checkpointing: completed stage-like outputs are recorded with stable ordinal replay keys and replayed on resume, skipping re-execution while avoiding checkpoint id collisions after redispatch. Chain and parallel items reuse durable task checkpoints, and child workflow calls checkpoint the completed child result at the parent boundary. ([#1498](https://github.com/bastani-inc/atomic/issues/1498))
+- Wired `/workflow resume` into the TUI command surface to fall back to the cross-session durable resume catalog when a target id is not a live run, and to surface durable root workflow history in fresh sessions. It lists resumable workflows by top-level id and resumes via DBOS-style replay (re-dispatch with the original workflow id so completed checkpoints are skipped), mirroring `/resume` ergonomics. ([#1498](https://github.com/bastani-inc/atomic/issues/1498))
+- Added `@dbos-inc/dbos-sdk` as an optional dependency of `@bastani/atomic` so DBOS-backed durable execution is available without a separate install when the SDK resolves. The workflows package remains dependency-free at runtime; the DBOS adapter is loaded lazily only when `DBOS_SYSTEM_DATABASE_URL` is set. ([#1498](https://github.com/bastani-inc/atomic/issues/1498))
+- Added a cross-session resume catalog (`scanResumableWorkflows`) that scans session JSONL files for durable checkpoint entries to build the `/workflow resume` selector list, displaying root workflow name, status, completed checkpoint count, and pending prompts. The scanner understands Atomic's actual extension custom-entry JSONL shape (`type: "custom"`, `customType: "workflow.durable.checkpoint"`) as well as legacy direct checkpoint rows.
+- Added cancellation, failure, and retry semantics for durable workflows: killed/cancelled workflows are marked `cancelled` and excluded from automatic resume; recoverable failures remain in the resumable list; non-recoverable failures are filtered out; `ctx.tool` retries with exponential backoff; pending `ctx.ui` prompts leave off on resume for the user to answer.
+- Added DBOS read-side hydration: when `DBOS_SYSTEM_DATABASE_URL` is set, a fresh Atomic process now hydrates its in-memory checkpoint mirror from DBOS on `/workflow resume` so workflows persisted by a prior session can be discovered and replayed without prior in-process state. Checkpoint records are stored as structured envelopes (including kind, checkpoint id, args hash, prompt hash, and replay key) in DBOS so hydration fully reconstructs the original checkpoint metadata. Root workflow metadata is mirrored separately, so DBOS helper-workflow completion does not make Atomic roots appear completed; `ctx.tool`/`ctx.ui`/`ctx.task` await async DBOS checkpoint persistence before returning side-effect results. Legacy/simple DBOS step outputs without the envelope are handled gracefully as generic stage checkpoints. ([#1498](https://github.com/bastani-inc/atomic/issues/1498))
+
+### Fixed
+
+- Added direct mouse-click activation for visible workflow graph nodes: clicking a node now focuses it and opens/attaches it through the same path as pressing Enter, with hit-testing based on the rendered node rectangles so overlay chrome/scroll geometry stays in sync while wheel scrolling and empty-space/chrome clicks remain safe no-ops. ([#1521](https://github.com/bastani-inc/atomic/issues/1521))
+- Fixed attached workflow stage chats to capture mouse/trackpad wheel events by default and enable button-event SGR terminal reporting, keeping scroll gestures inside the active stage transcript or prompt instead of falling through to terminal/main-chat scrollback; `ctrl+t` now toggles true copy mode by disabling workflow-chat mouse reporting so terminal/tmux text selection works normally. ([#1519](https://github.com/bastani-inc/atomic/issues/1519))
+- Routed idle `StageContext.sendUserMessage()` turns through the workflow stage guard so first-call injected turns record normal stage lifecycle and all idle injected turns observe abort/kill wiring, MCP scope, readiness handling, and the concurrency limiter. ([#1520](https://github.com/bastani-inc/atomic/issues/1520))
+- Fixed attached workflow stage chats so stale terminal, paused, blocked, skipped, or otherwise no-longer-running live stage handles, terminal run/stage transitions before `agent_end`, reopened terminal chats, late post-terminal subagent tool updates, and partial subagent workflow-graph progress no longer keep the `Working...` spinner, animation tick, subagent renderer interval, renderer animation registry entry, or subagent progress spinner active, while genuine follow-up/prompt/resume `agent_start` work still shows progress on retained terminal stage chats. ([#1518](https://github.com/bastani-inc/atomic/issues/1518))
+- Fixed `/workflow resume`'s interactive picker to reuse the same Atomic `/resume` session-selector tree chrome for live, paused, failed-resumable, and cross-session durable workflows, replacing the hand-rolled durable/combined picker so the selector is cosmetically consistent across resume flows. ([#1498](https://github.com/bastani-inc/atomic/issues/1498))
+- Matched `/resume` empty-state behavior for interactive `/workflow resume` by opening the shared empty selector when no resumable workflow rows remain after filtering instead of printing an error. ([#1498](https://github.com/bastani-inc/atomic/issues/1498))
+- Hid `/workflow resume` selector entries that only exist as stale session-cache metadata with no matching durable backend handle and hid durable `running`/`failed`/`blocked` rows whose workflow definition is no longer registered, filtering old pre-checkpoint-engine/test workflow runs instead of surfacing rows that can only fail as stale or missing-definition. ([#1498](https://github.com/bastani-inc/atomic/issues/1498))
+- Persisted terminal non-resumable durable metadata during finalization so non-recoverable failed/blocked workflows do not remain visible in `/workflow resume` as resumable entries after they are completely finished. ([#1498](https://github.com/bastani-inc/atomic/issues/1498))
+- Delayed durable `/workflow resume` discovery for `running`/`paused` workflows until the first durable checkpoint or pending checkpointable prompt exists, records resumable LM-stage session metadata as soon as a stage opens, and reopens that exact Atomic/Pi session file on durable resume so eligible stages continue mid-session while completed tool/UI/stage checkpoints still replay all-or-nothing. CLI/orchestrator quit now leaves durable-progress workflows resumable instead of treating panel close as an authoritative kill; `/workflow kill` remains the explicit non-resumable disposal path, and successful completion still marks the root workflow terminal and removes the row once the whole workflow terminates to the end. ([#1498](https://github.com/bastani-inc/atomic/issues/1498))
+- Fixed repeated quit/resume durable LM-stage cycles by keeping in-progress stage-session metadata separate from completed stage-output checkpoints, persisting DBOS checkpoint records by checkpoint id rather than replay key, removing stale quit snapshots before reusing the original durable workflow id, and sending a single `Continue` continuation message to the recorded LM session instead of replaying the original workflow prompt. ([#1498](https://github.com/bastani-inc/atomic/issues/1498))
+- Made `/workflow resume` list only inactive workflows: actively-running durable runs are hidden from the selector and refused on resume (in-session or cross-session) with an intuitive error pointing at `/workflow connect`/`/workflow kill`, while quitting the CLI/panel flips the durable handle from `running` to `paused` so it re-enters the resumable set. ([#1498](https://github.com/bastani-inc/atomic/issues/1498))
+- Fixed DBOS durable metadata updates to use versioned metadata records with latest-timestamp hydration, removed invalid DBOS `duplicationPolicy` parameters, awaited completed stage checkpoint writes before returning to workflow code where practical, awaited DBOS initialization before first dispatch/list/resume in DBOS-configured runtimes, opened an interactive durable picker for no-arg `/workflow resume` when only durable entries exist (including sessions with only completed local runs), distinguished repeated same-name/same-args `ctx.tool` calls by stable ordinal identity, and made retry backoff observe cancellation before later attempts run. ([#1498](https://github.com/bastani-inc/atomic/issues/1498))
+- Fixed durable stage lifecycle persistence so workflow completion waits for pending backend checkpoint writes (including DBOS async writes) and reports a failed run when those writes fail instead of acknowledging success before checkpoints are durable. Terminal durable status metadata is flushed before completed/failed/cancelled root runs return. Cached `ctx.task`, `ctx.chain`/`ctx.parallel` items, and child `ctx.workflow` replay now record completed replay nodes in the workflow graph/store, matching cached `ctx.stage` visibility. DBOS `recordCheckpointAsync()` updates the replay mirror only after DBOS accepts the checkpoint, so failed durable writes do not make the current process believe a side effect is safely replayable. ([#1498](https://github.com/bastani-inc/atomic/issues/1498))
+- Fixed repeated `ctx.workflow(child)` calls to use a dedicated durable replay-key counter so cache-hit calls do not desync ordinal sequencing across resume; direct completed stages now checkpoint under the durable replay key used for lookup instead of the executor snapshot key; `ctx.exit` terminal states (`cancelled`, `blocked`, `skipped`) are now persisted to durable metadata and flushed; no-arg `/workflow resume` surfaces durable workflow history even when live local runs exist; and `durableBackend` is propagated into child workflow run options so custom backends are shared across parent and child instead of split-braining. ([#1498](https://github.com/bastani-inc/atomic/issues/1498))
+- Fixed durable resume edge cases where workflows discovered only from session JSONL could be dropped before actual resume, schema-backed stage replay returned raw JSON text instead of structured values, parallel fail-fast skipped stages before async finalizers completed, retry backoff left abort listeners behind after normal sleeps, and durable stage checkpointing could ignore an explicit stage replay key. ([#1498](https://github.com/bastani-inc/atomic/issues/1498))
+- Fixed durable replay robustness: child workflow internal `ctx.tool`/`ctx.ui`/`ctx.stage` side effects are now checkpointed under the parent/root durable workflow via a scoped backend keyed by the child boundary, so an interrupted child does not re-execute completed side effects on parent resume (previously child checkpoints were written under a fresh per-run UUID that was never recovered). `/workflow resume` now refuses cache-only entries as `stale` when a workflow has session-JSONL metadata but no durable checkpoint state in the backend, instead of silently re-running from scratch. Durable replay identities (`durableHash`) now use a SHA-256 digest instead of a 32-bit DJB2 hash that could collide across distinct tool/stage identities. `ctx.tool` re-checks cancellation after the tool function resolves and before recording/returning the side-effect result, so a side effect that completes concurrently with cancellation is not persisted as a replayable checkpoint. File-backed durability recovers from a stale lock directory left by a crashed process (backdated beyond a threshold) instead of wedging until the acquire timeout. ([#1498](https://github.com/bastani-inc/atomic/issues/1498))
+- Fixed terminal durable cache suppression so stale session-JSONL entries cannot resurrect workflows the backend knows are completed/cancelled/non-resumable: the backend terminal state now takes precedence over older JSONL cache entries during listing and resume. Successful durable `/workflow resume <id>` now connects/opens the overlay to the resumed run, matching live resume ergonomics. No-arg `/workflow resume` now shows a combined selector (live runs + cross-session durable workflows) so durable workflows are directly selectable even when live runs exist, instead of only being printed as hints. Fixed `ScopedDurableBackend.listCheckpoints` to exclude sibling child scopes that shared a common id prefix (previously re-prefixing caused sibling checkpoints to leak into the wrong scope). Cleaned up a cosmetic merged import line in `run.ts`. ([#1498](https://github.com/bastani-inc/atomic/issues/1498))
+- Fixed empty string stage outputs to be preserved durably as empty strings instead of being collapsed into status objects, so a stage completing with empty assistant text replays as empty rather than appearing to have no checkpoint. Schema-backed stage prompts with empty string results are now also checkpointed. Stage finalization failures (including durable checkpoint write errors) no longer leak the concurrency limiter/semaphore because each cleanup step is independently guarded. Mixed live+durable `/workflow resume` now uses async DBOS-hydrated durable listing (`prepareDurableResumable`) instead of a synchronous in-memory listing so cross-session entries discovered from Postgres are included in the combined selector. Replayed durable stages now register in the graph frontier tracker so parent/lineage topology is preserved for subsequent stages. Dismissing the combined resume picker returns to chat without opening a second live-only picker. ([#1498](https://github.com/bastani-inc/atomic/issues/1498))
+- Fixed Ralph review regressions in durable resume: durable and combined pickers now settle selections before synchronous custom-UI disposal can dismiss them; headless no-arg durable resume prints the catalog instead of awaiting unavailable/no-op picker UI; failed live runs selected from the combined picker resume through the continuation path; durable resume dispatch forwards the interactive/non-interactive command policy; `ctx.ui.custom` replays cached void/`undefined` responses instead of treating them as cache misses; stage finalization errors are rethrown after releasing handles/limiters; and resume integration tests isolate the durable singleton so full integration runs remain deterministic. ([#1498](https://github.com/bastani-inc/atomic/issues/1498))
+- Fixed default file-backed durability to write one JSON state file per root workflow instead of rewriting a shared `state.json` on every checkpoint, avoid all-files scans on point checkpoint lookups, prune completed/cancelled/non-resumable terminal workflow files while retaining running/paused/recoverable-failed files for crash recovery until resumed or killed, use restrictive `0700` durable directories and `0600` state/lock-owner files, fail closed to in-memory durability when no home directory is available, and reclaim stale locks only when their owner marker belongs to a dead process. Added `ATOMIC_WORKFLOW_DURABLE=0`/`false`/`off`/`memory` as a documented privacy opt-out for plaintext cross-session checkpoint persistence. ([#1498](https://github.com/bastani-inc/atomic/issues/1498))
+
+## [0.9.3-alpha.1] - 2026-06-25
+
+### Changed
+
+- Workflow stage sessions are now marked as internal and excluded from the standard Atomic `/resume`, `atomic -r`, and `--continue` history, while remaining fully resumable/inspectable through `/workflow resume`, `/workflow attach`, and the `workflow` tool's `status`/`stages`/`stage`/`resume` actions via the run/stage store and its `sessionFile` links ([#1504](https://github.com/bastani-inc/atomic/issues/1504)).
+- Revised the builtin `goal` worker/continuation prompts and the builtin `ralph` orchestrator prompts to emphasize implementing the requested task through full completion ("do not stop until the objective is complete") instead of preparing a partial implementation for incremental review.
+- Removed model-visible current-iteration/turn/loop information from the builtin `goal`, `ralph`, and `open-claude-design` workflows so models are not biased by which iteration they are on. This drops the worker `Turn: N/M` banner, `Implement iteration N/M` / `Research iteration N/M` framing, "first iteration/worker turn" phrasing, and the live-preview `iteration N/M` label; switches model-relayed artifacts to stable non-ordinal names (`worker-receipt.md`, `review-<reviewer>.json`, `review-round-latest.json`, `orchestrator-report.md`); and strips turn fields from the model-facing goal ledger artifact. Internal UI stage names (e.g. `work-turn-2`, `orchestrator-2`) are unchanged, and the `max_turns`/`max_loops` inputs and `turns_completed`/`iterations_completed` outputs are retained.
+- Raised workflow-stage subagent recursion to the shared five-level nesting budget so workflow stages match main-chat delegation depth.
+
+### Fixed
+
+- Fixed the builtin `open-claude-design` continuation loop so generator stages fork only from prior generator sessions and user-feedback stages fork only from prior feedback sessions; the first feedback stage now starts its own chain instead of inheriting generator context.
+- Fixed workflow config loading and user-global discovery to honor `ATOMIC_CODING_AGENT_DIR` isolation instead of reading `~/.atomic/agent` when an isolated agent dir is configured.
+
 ## [0.9.2] - 2026-06-23
 
 ### Changed

package/dist/builtin/workflows/README.md

@@ -320,7 +320,7 @@ const decision = await ctx.stage("review-gate", { schema: Decision }).prompt(
 
 Atomic registers the canonical `structured_output` tool only for schema-enabled items and automatically adds it to explicit `tools` allowlists. The schema is used directly as the tool argument contract. A schema-backed `StageContext` supports one `prompt()` call because the final-answer tool is a single result contract; create another `ctx.stage(..., { schema })` for another structured prompt. If a turn completes without calling `structured_output`, or the tool call fails schema validation, Atomic sends up to three corrective follow-up prompts that include the exact contract/validation error before failing the item. `ctx.task`/`ctx.chain`/`ctx.parallel` results expose the captured value as `result.structured` and keep `result.text` as formatted JSON for handoffs.
 
-`subagent` is available as a default workflow-stage tool with the same default two-hop nesting budget as main chat: a stage can launch a subagent, and that child can launch one nested subagent before the guard blocks further delegation. `tools` allowlists apply to bundled extension tools as well as built-ins; if a stage sets `tools`, list every tool it should see. Workflow stages can explicitly list `subagent`, `web_search`, `fetch_content`, `intercom`, and other loaded extension tools, while `excludedTools` and `noTools: "all"` still win. Bundled `@bastani/subagents` agent definitions are available to the `subagent` tool in workflow stages, including workflows launched from a subagent child process.
+`subagent` is available as a default workflow-stage tool with the same five-level nesting budget as main chat: a stage can launch recursively delegated subagents until the shared depth guard reaches five delegated levels, then deeper calls are blocked. `tools` allowlists apply to bundled extension tools as well as built-ins; if a stage sets `tools`, list every tool it should see. Workflow stages can explicitly list `subagent`, `web_search`, `fetch_content`, `intercom`, and other loaded extension tools, while `excludedTools` and `noTools: "all"` still win. Bundled `@bastani/subagents` agent definitions are available to the `subagent` tool in workflow stages, including workflows launched from a subagent child process.
 
 ### Model fallbacks
 
@@ -540,7 +540,7 @@ Tradeoff: `Type.Unsafe<T>()` does not deeply validate at runtime — it trusts t
 
 Input overrides are bare `key=value` tokens (no leading `--`). Values are JSON-parsed when possible, so numbers, booleans, and quoted strings work as expected (e.g. `count=3`, `flag=true`, `prompt="multi word value"`). A whole-object override can be passed as a single JSON token (e.g. `{"prompt":"...","count":3}`). Runtime validation is strict: unknown input keys, missing required values, type mismatches, and invalid `select` choices fail before a named workflow run starts.
 
-Workflows always run as **background tasks** in interactive sessions — the chat editor stays free while a run executes. Press **F2** (or `/workflow connect <run-id>`) to attach to the live graph viewer; HIL prompts (`ctx.ui.input/confirm/select/editor/custom`) appear as awaiting-input graph nodes. Press Enter on the node to answer locally, never as a modal dialog over the chat. Human input is detected when those runtime `ctx.ui.*` calls execute; workflows no longer have a declaration-time HIL flag.
+Workflows always run as **background tasks** in interactive sessions — the chat editor stays free while a run executes. Press **F2** (or `/workflow connect <run-id>`) to attach to the live graph viewer; HIL prompts (`ctx.ui.input/confirm/select/editor/custom`) appear as awaiting-input graph nodes. Press Enter on a focused node, or click a visible graph node directly, to open that stage and answer locally, never as a modal dialog over the chat. Attached stage chats capture mouse/trackpad wheel events by default so scrolling stays inside the active stage transcript or prompt instead of falling through to terminal/main-chat scrollback. Press `ctrl+t` to toggle **copy mode**: copy mode disables workflow-chat mouse reporting so normal terminal/tmux text selection can work; press `ctrl+t` again to leave copy mode and restore workflow-chat scrolling. While copy mode is on, wheel/trackpad gestures are handled by the terminal/tmux and may scroll terminal scrollback, so leave copy mode before using the wheel again. Human input is detected when those runtime `ctx.ui.*` calls execute; workflows no longer have a declaration-time HIL flag.
 
 Nested `ctx.workflow(...)` calls are displayed as an expanded graph within the top-level run. `/workflow status` and run pickers list only top-level user-launched workflows, not implementation-owned child runs. The `workflow` tool's `stages`, `stage`, `transcript`, `send`, `pause`, `interrupt`, and `resume` actions can still target visible child stage ids, prefixes, or names from the expanded graph; Atomic routes the control action to the owning nested run internally. (`stages`, `stage`, `transcript`, and `send` are `workflow` tool actions, not `/workflow` slash subcommands; the slash command exposes `connect`, `attach`, `pause`, `list`, `status`, `interrupt`, `kill`, `resume`, `reload`, and `inputs`.)
 
@@ -697,7 +697,7 @@ Child workflow outputs: `result`, `plan` (latest transformed research question),
 
 ### `open-claude-design`
 
-Combined discovery/init → design-system/reference research → curated reference discovery with user preference check → forked generate/user-feedback loop → export/handoff pipeline. The `discovery` stage asks for output type and references, then runs impeccable init in the same stage so PRODUCT.md/DESIGN.md are detected, created, or reconciled. `ds-*` stages handle user-provided URL/file reference extraction directly, then `reference-discovery` uses that context and asks which curated direction you prefer (or asks for a reference image/path/URL if none fit). Export is only `exporter` plus `final-display`.
+Combined discovery/init → design-system/reference research → curated reference discovery with user preference check → separate forked generate and user-feedback chains → export/handoff pipeline. The `discovery` stage asks for output type and references, then runs impeccable init in the same stage so PRODUCT.md/DESIGN.md are detected, created, or reconciled. `ds-*` stages handle user-provided URL/file reference extraction directly, then `reference-discovery` uses that context and asks which curated direction you prefer (or asks for a reference image/path/URL if none fit). Export is only `exporter` plus `final-display`.
 
 ```text
 /workflow open-claude-design prompt="Design a kanban board component"

package/dist/builtin/workflows/builtin/goal-artifacts.ts

@@ -10,20 +10,25 @@ export function artifactSafeName(value: string): string {
   return safe.length > 0 ? safe : "artifact";
 }
 
+function withoutTurn<T extends { readonly turn: number }>(value: T): Omit<T, "turn"> {
+  const copy = { ...value } as Omit<T, "turn"> & { turn?: number };
+  delete copy.turn;
+  return copy;
+}
+
 export async function writeReviewArtifact(
   artifactDir: string,
-  turn: number,
   reviewer: string,
   decision: ReviewDecision,
   rawText: string,
 ): Promise<string> {
   const artifactPath = join(
     artifactDir,
-    `review-turn-${turn}-${artifactSafeName(reviewer)}.json`,
+    `review-${artifactSafeName(reviewer)}.json`,
   );
   await writeFile(
     artifactPath,
-    `${JSON.stringify({ turn, reviewer, decision, raw_text: rawText }, null, 2)}\n`,
+    `${JSON.stringify({ reviewer, decision, raw_text: rawText }, null, 2)}\n`,
     { encoding: "utf8" },
   );
   return artifactPath;
@@ -31,11 +36,11 @@ export async function writeReviewArtifact(
 
 export async function writeReviewRoundArtifact(
   artifactDir: string,
-  turn: number,
   reviews: readonly ReviewRecord[],
 ): Promise<string> {
-  const artifactPath = join(artifactDir, `review-round-${turn}.json`);
-  await writeFile(artifactPath, `${JSON.stringify({ turn, reviews }, null, 2)}\n`, {
+  const artifactPath = join(artifactDir, "review-round-latest.json");
+  const visibleReviews = reviews.map(withoutTurn);
+  await writeFile(artifactPath, `${JSON.stringify({ reviews: visibleReviews }, null, 2)}\n`, {
     encoding: "utf8",
   });
   return artifactPath;

package/dist/builtin/workflows/builtin/goal-ledger.ts

@@ -4,6 +4,38 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { LEDGER_FILENAME, type GoalLedger, type GoalLifecycleEvent } from "./goal-types.js";
 
+type ModelVisibleGoalLedger = Omit<
+  GoalLedger,
+  "turns" | "receipts" | "reviews" | "blockers" | "decisions" | "lifecycle"
+> & {
+  readonly receipts: ReadonlyArray<Omit<GoalLedger["receipts"][number], "turn">>;
+  readonly reviews: ReadonlyArray<Omit<GoalLedger["reviews"][number], "turn">>;
+  readonly blockers: ReadonlyArray<Omit<GoalLedger["blockers"][number], "turn">>;
+  readonly decisions: ReadonlyArray<Omit<GoalLedger["decisions"][number], "turn">>;
+  readonly lifecycle: ReadonlyArray<Omit<GoalLedger["lifecycle"][number], "turn">>;
+};
+
+function withoutTurn<T extends { readonly turn: number }>(value: T): Omit<T, "turn"> {
+  const copy = { ...value } as Omit<T, "turn"> & { turn?: number };
+  delete copy.turn;
+  return copy;
+}
+
+function modelVisibleLedger(ledger: GoalLedger): ModelVisibleGoalLedger {
+  return {
+    goal_id: ledger.goal_id,
+    objective: ledger.objective,
+    status: ledger.status,
+    created_at: ledger.created_at,
+    updated_at: ledger.updated_at,
+    receipts: ledger.receipts.map(withoutTurn),
+    reviews: ledger.reviews.map(withoutTurn),
+    blockers: ledger.blockers.map(withoutTurn),
+    decisions: ledger.decisions.map(withoutTurn),
+    lifecycle: ledger.lifecycle.map(withoutTurn),
+  };
+}
+
 export function appendLifecycleEvent(
   ledger: GoalLedger,
   event: GoalLifecycleEvent["event"],
@@ -48,7 +80,7 @@ export async function writeGoalLedger(
   ledger: GoalLedger,
 ): Promise<void> {
   ledger.updated_at = new Date().toISOString();
-  await writeFile(ledgerPath, `${JSON.stringify(ledger, null, 2)}\n`, {
+  await writeFile(ledgerPath, `${JSON.stringify(modelVisibleLedger(ledger), null, 2)}\n`, {
     encoding: "utf8",
   });
 }

package/dist/builtin/workflows/builtin/goal-prompts.ts

@@ -9,8 +9,9 @@ export { WORKER_PREFLIGHT_CONTRACT };
 
 export const GOAL_CONTINUATION_REFERENCE = [
   "Continuation behavior:",
-  "- This goal persists across turns. Ending this turn does not require shrinking the objective to what fits now.",
-  "- Keep the full objective intact. If it cannot be finished now, make concrete progress toward the real requested end state, leave the goal active, and do not redefine success around a smaller or easier task.",
+  "- This goal persists across workflow continuations. A worker session ending does not require shrinking the objective to what fits immediately.",
+  "- Keep the full objective intact and do not stop until the objective is complete. Do not intentionally leave known required implementation, validation, documentation, or cleanup for a later worker session.",
+  "- If the full objective genuinely cannot be finished with available context/tools, make the most concrete progress toward the real requested end state, leave the goal active, and do not redefine success around a smaller or easier task.",
   "- Temporary rough edges are acceptable while the work is moving in the right direction. Completion still requires the requested end state to be true and verified.",
   "",
   "Work from evidence:",
@@ -20,7 +21,7 @@ export const GOAL_CONTINUATION_REFERENCE = [
   "If todo management is available and the next work is meaningfully multi-step, use it to show a concise plan tied to the real objective. Keep the plan current as steps complete or the next best action changes. Skip planning overhead for trivial one-step progress, and do not treat a todo update as a substitute for doing the work.",
   "",
   "Fidelity:",
-  "- Optimize each turn for movement toward the requested end state, not for the smallest stable-looking subset or easiest passing change.",
+  "- Optimize worker effort for full completion of the requested end state, not for the smallest stable-looking subset or easiest passing change.",
   "- Do not substitute a narrower, safer, smaller, merely compatible, or easier-to-test solution because it is more likely to pass current tests.",
   "- Treat alignment as movement toward the requested end state. An edit is aligned only if it makes the requested final state more true; useful-looking behavior that preserves a different end state is misaligned.",
   "",
@@ -39,20 +40,21 @@ export const GOAL_CONTINUATION_REFERENCE = [
   "",
   "Blocked audit:",
   "- Do not report blocked the first time a blocker appears.",
-  "- Only use blocked when the same blocking condition has repeated for the configured blocker threshold of consecutive goal turns, counting the original worker turn and any workflow continuations.",
+  "- Only use blocked when the same blocking condition has repeated often enough for the controller's blocker policy to identify a true impasse.",
   "- Use blocked only when you are truly at an impasse and cannot make meaningful progress without user input or an external-state change.",
   "- Once the blocked threshold is satisfied, do not keep reporting that you are still blocked while leaving the goal active; report blocked.",
   "- Never use blocked merely because the work is hard, slow, uncertain, incomplete, or would benefit from clarification.",
   "",
-  "Do not report the goal as done unless the goal is complete. Do not mark a goal complete merely because the workflow turn is ending.",
+  "Do not report the goal as done unless the goal is complete. Do not mark a goal complete merely because the worker session is ending.",
 ].join("\n");
 
 export const WORKER_RECEIPT_CONTRACT = [
-  "Produce concrete progress toward the full objective in this turn.",
+  "Implement the requested objective completely before reporting. Do not stop until the objective is complete.",
   "Inspect current files, commands, artifacts, and repository guidance before relying on prior summaries.",
   "Improve, replace, or remove existing work as needed to satisfy the actual objective.",
   "If todo management is available and the next work is meaningfully multi-step, use it to show a concise plan tied to the real objective. Keep the plan current as steps complete or the next best action changes. Skip planning overhead for trivial one-step progress, and do not treat todo updates as a substitute for doing the work.",
-  "If meaningful work remains, do the next safest useful slice; do not redefine success around a smaller task.",
+  "If meaningful work remains, keep working through implementation, validation, documentation, and cleanup instead of stopping at a reviewable partial state.",
+  "Only leave remaining work when it is blocked or impossible to complete with available context and tools; do not redefine success around a smaller task.",
   "Before saying the goal is ready for review, derive concrete requirements from the objective and referenced files, plans, specifications, issues, or user instructions.",
   "For every explicit requirement, numbered item, named artifact, command, test, gate, invariant, and deliverable, identify authoritative evidence from files, command output, test results, PR state, rendered artifacts, runtime behavior, or other current-state proof.",
   "Classify evidence honestly: proves completion, contradicts completion, shows incomplete work, is too weak or indirect, is merely consistent with completion, or is missing.",
@@ -62,7 +64,7 @@ export const WORKER_RECEIPT_CONTRACT = [
 ].join("\n");
 
 export const GOAL_METHOD_REFERENCE = [
-  "Maintain a concrete goal contract for the run: intent, verification oracle, work surface, execution loop, and proof.",
+  "Maintain a concrete goal contract for the run: intent, verification oracle, work surface, execution workflow, and proof.",
   "Infer the owner outcome and a verifiable oracle from the user's task and repository evidence; do not ask the user unless the workflow is truly blocked.",
   "Treat any user-supplied planning artifacts as supporting context, not as the primary success criterion.",
   "Keep pressure on current evidence: the current worktree, artifacts, command output, tests, demos, generated files, and explicit human decisions are more authoritative than prior conversation summaries.",
@@ -135,23 +137,21 @@ export function renderReceiptHistory(ledger: GoalLedger): string {
   if (ledger.receipts.length === 0) return "No prior work receipts.";
   const latestReceipt = ledger.receipts.at(-1);
   if (latestReceipt === undefined) return "No prior work receipts.";
-  return `Latest receipt: turn ${latestReceipt.turn} ${latestReceipt.stage} (artifact: ${latestReceipt.artifact_path}). Read the artifact if you need receipt details.`;
+  return `Latest receipt artifact: ${latestReceipt.artifact_path}. Read it if you need receipt details.`;
 }
 
 export function renderLatestReviewArtifacts(paths: readonly string[]): string {
-  if (paths.length === 0) return "No prior review artifacts; this is the first worker turn.";
+  if (paths.length === 0) return "No prior review artifacts are available.";
   return [
-    "Latest review artifacts from the previous round:",
+    "Latest available review artifacts:",
     ...paths.map((path) => `- ${path}`),
-    "Read only the details needed for the next action; do not load old review rounds unless the latest round explicitly refers to them.",
+    "Read only the details needed for the next action; do not load older review artifacts unless the latest artifacts explicitly refer to them.",
   ].join("\n");
 }
 
 export function renderGoalContinuationPrompt(
   ledger: GoalLedger,
   ledgerPath: string,
-  turn: number,
-  maxTurns: number,
   blockerThreshold: number,
   latestReviewArtifactPaths: readonly string[],
 ): string {
@@ -162,10 +162,9 @@ export function renderGoalContinuationPrompt(
         "Continue working toward the active thread goal.",
         "The goal ledger artifact is the authoritative state for the objective, status, receipts, latest reviewer decisions, blockers, reducer decisions, and lifecycle events.",
         "",
-        "Workflow state:",
-        `- Turn: ${turn}/${maxTurns}`,
+        "Workflow context:",
         `- Goal ledger artifact: ${ledgerPath}`,
-        `- Blocked threshold: same blocker must repeat for at least ${blockerThreshold} consecutive turns before the controller can stop as blocked.`,
+        `- Blocked threshold: same blocker must repeat for at least ${blockerThreshold} controller observations before the controller can stop as blocked.`,
         "- Completion transition: the worker may claim readiness, but reviewer quorum plus the deterministic reducer decides final workflow status.",
         "",
         renderReceiptHistory(ledger),
@@ -182,8 +181,6 @@ export function renderGoalContinuationPrompt(
 export function renderForkedGoalWorkerPrompt(
   ledger: GoalLedger,
   ledgerPath: string,
-  turn: number,
-  maxTurns: number,
   blockerThreshold: number,
   latestReviewArtifactPaths: readonly string[],
 ): string {
@@ -191,14 +188,13 @@ export function renderForkedGoalWorkerPrompt(
     [
       "goal_context",
       [
-        "Continue the same goal-runner worker thread from the previous work turn.",
+        "Continue the same goal-runner worker thread from the previous worker session.",
         "Reuse the goal invariants, project preflight, worker receipt contract, completion audit, and blocked audit.",
         "Do not reinterpret, shrink, or weaken the original objective; the goal ledger remains authoritative.",
         "",
-        "Current workflow state:",
-        `- Turn: ${turn}/${maxTurns}`,
+        "Workflow context:",
         `- Goal ledger artifact: ${ledgerPath}`,
-        `- Blocked threshold: same blocker must repeat for at least ${blockerThreshold} consecutive turns before the controller can stop as blocked.`,
+        `- Blocked threshold: same blocker must repeat for at least ${blockerThreshold} controller observations before the controller can stop as blocked.`,
         "- Completion transition: the worker may claim readiness, but reviewer quorum plus the deterministic reducer decides final workflow status.",
         "",
         renderReceiptHistory(ledger),
@@ -217,7 +213,6 @@ export function renderReviewerPrompt(args: {
   readonly ledgerPath: string;
   readonly workTurnPath: string;
   readonly comparisonBaseBranch: string;
-  readonly turn: number;
   readonly reviewQuorum: number;
   readonly blockerThreshold: number;
 }): string {
@@ -260,7 +255,7 @@ export function renderReviewerPrompt(args: {
       "reference_branch",
       [
         `The baseline branch for comparison is \`${args.comparisonBaseBranch}\`.`,
-        "Compare the current working tree against this baseline branch, not against previous workflow reasoning or expected loop progress.",
+        "Compare the current working tree against this baseline branch, not against previous workflow reasoning or progress expectations.",
         `Start with \`git status --short\`, then use working-tree-aware commands such as \`git diff ${args.comparisonBaseBranch}\` and \`git diff --cached ${args.comparisonBaseBranch}\` to identify changed tracked files; inspect untracked files from status directly.`,
       ].join("\n"),
     ],
@@ -327,8 +322,8 @@ export function renderReviewerPrompt(args: {
       [
         "The structured review decision is only valid after you inspect the actual repository state and compare it against the stated baseline branch.",
         "Do not approve based solely on workflow stage summaries or prior agent reasoning.",
-        "Treat this review as the completion audit for the current goal turn: approval means receipts and current evidence prove the original owner outcome against the full objective.",
-        "Do not approve when proof only shows planning, discovery, task selection, helper documents, or a narrow slice while the broader requested outcome still has safe local work remaining.",
+        "Treat this review as the completion audit for the current repository and goal state: approval means receipts and current evidence prove the original owner outcome against the full objective.",
+        "Do not approve when proof only shows planning, discovery, task selection, helper documents, or a narrow slice while the broader requested outcome still has required work remaining.",
         "The tool call is the final verdict after review work, not a shortcut around review work.",
       ].join("\n"),
     ],
@@ -349,7 +344,7 @@ export function renderReviewerPrompt(args: {
       [
         `Reviewer quorum is ${args.reviewQuorum}; same blocker threshold is ${args.blockerThreshold}. You do not decide final workflow status. The reducer does.`,
         "If the strict blocked audit is satisfied by current evidence, do not invent a finding. Set stop_review_loop=false, goal_oracle_satisfied=false, verification_remaining to the concise blocker, and reviewer_error.kind to dependency_unavailable or tool_failure with reviewer_error.message set to the same concise blocker.",
-        "When the same dependency or tool blocker from prior reviewer history is still present, echo the prior turn's exact blocker string in verification_remaining and reviewer_error.message instead of rephrasing it.",
+        "When the same dependency or tool blocker from prior reviewer history is still present, echo the prior blocker string in verification_remaining and reviewer_error.message instead of rephrasing it.",
         "Use reviewer_error for a blocker only when there is a real impasse that prevents meaningful progress without user input or an external-state change; never for ordinary incomplete work, uncertainty, or useful work remaining.",
       ].join("\n"),
     ],