@bastani/atomic 0.8.31-alpha.4 → 0.9.0-alpha.1

package/dist/builtin/web-access/web-search-summary.ts

@@ -0,0 +1,170 @@
+import { complete, getModel, type Model } from "@mariozechner/pi-ai";
+import type { QueryResultData } from "./storage.js";
+import {
+	buildDeterministicSummary,
+	generateSummaryDraft,
+	type SummaryGenerationContext,
+	type SummaryMeta,
+} from "./summary-review.js";
+import { loadConfig } from "./web-search-config.js";
+import { filterByQueryIndices, normalizeSummaryMeta } from "./web-search-formatting.js";
+
+async function resolveFirstAvailableModel(
+	ctx: SummaryGenerationContext,
+	candidates: Array<{ provider: string; id: string }>,
+): Promise<{ model: Model; apiKey: string; headers?: Record<string, string> }> {
+	for (const { provider, id } of candidates) {
+		const model = getModel(provider, id);
+		if (!model) continue;
+		const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+		if (auth.ok && auth.apiKey) return { model, apiKey: auth.apiKey, headers: auth.headers };
+	}
+	throw new Error(`No model available: ${candidates.map(c => `${c.provider}/${c.id}`).join(", ")}`);
+}
+
+export async function rewriteSearchQuery(
+	query: string,
+	ctx: SummaryGenerationContext,
+	signal: AbortSignal,
+): Promise<string> {
+	const { model, apiKey, headers } = await resolveFirstAvailableModel(ctx, [
+		{ provider: "anthropic", id: "claude-haiku-4-5" },
+		{ provider: "google", id: "gemini-2.5-flash" },
+		{ provider: "openai", id: "gpt-4.1-mini" },
+	]);
+	const response = await complete(
+		model,
+		{
+			messages: [{
+				role: "user",
+				content: [{ type: "text", text: `Rewrite this web search query to get better, more specific results. Add relevant year qualifiers, precise technical terms, and specificity. Return ONLY the improved query text, nothing else.\n\nQuery: ${query}` }],
+				timestamp: Date.now(),
+			}],
+		},
+		{ apiKey, headers, signal },
+	);
+	if (response.stopReason === "aborted") throw new Error("Aborted");
+	const contentParts = Array.isArray(response.content) ? response.content : [];
+	const text = contentParts
+		.map(p => {
+			if (!p || typeof p !== "object") return "";
+			const part = p as Record<string, unknown>;
+			return typeof part.text === "string" ? part.text : "";
+		})
+		.join("")
+		.trim();
+	if (!text) throw new Error("Rewrite returned empty response");
+	return text;
+}
+
+export async function generateSummaryForSelectedIndices(
+	selectedQueryIndices: number[],
+	resultsByIndex: Map<number, QueryResultData>,
+	summaryContext: SummaryGenerationContext,
+	signal?: AbortSignal,
+	modelOverride?: string,
+	feedback?: string,
+): Promise<{ summary: string; meta: SummaryMeta }> {
+	const selectedResults: QueryResultData[] = [];
+	for (const qi of selectedQueryIndices) {
+		const result = resultsByIndex.get(qi);
+		if (result) selectedResults.push(result);
+	}
+	if (selectedResults.length === 0) {
+		throw new Error("No selected results available for summary generation");
+	}
+	try {
+		return await generateSummaryDraft(selectedResults, summaryContext, signal, modelOverride, feedback);
+	} catch (err) {
+		const isEmptyResponse = err instanceof Error && err.message.includes("Summary model returned empty response");
+		if (!isEmptyResponse) throw err;
+		const deterministic = buildDeterministicSummary(selectedResults);
+		return {
+			summary: deterministic.summary,
+			meta: {
+				...deterministic.meta,
+				fallbackReason: "summary-model-empty-response",
+			},
+		};
+	}
+}
+
+export async function loadSummaryModelChoices(
+	summaryContext: SummaryGenerationContext,
+): Promise<{ summaryModels: Array<{ value: string; label: string }>; defaultSummaryModel: string | null }> {
+	const summaryModels: Array<{ value: string; label: string }> = [];
+	const seen = new Set<string>();
+	const availableValues = new Set<string>();
+
+	const addModel = (provider: string, id: string) => {
+		const value = `${provider}/${id}`;
+		if (seen.has(value)) return;
+		seen.add(value);
+		summaryModels.push({ value, label: value });
+	};
+
+	try {
+		const availableModels = summaryContext.modelRegistry.getAvailable();
+		for (const model of availableModels) {
+			const value = `${model.provider}/${model.id}`;
+			availableValues.add(value);
+			addModel(model.provider, model.id);
+		}
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		console.error(`Failed to load summary models: ${message}`);
+	}
+
+	const currentModelValue = summaryContext.model
+		? `${summaryContext.model.provider}/${summaryContext.model.id}`
+		: null;
+	if (summaryContext.model && currentModelValue && !seen.has(currentModelValue)) {
+		addModel(summaryContext.model.provider, summaryContext.model.id);
+	}
+
+	const config = loadConfig();
+	const configuredSummaryModel = typeof config.summaryModel === "string" ? config.summaryModel.trim() : "";
+	const preferredDefaults = [
+		"anthropic/claude-haiku-4-5",
+		"openai-codex/gpt-5.3-codex-spark",
+	];
+
+	let defaultSummaryModel: string | null = null;
+	if (configuredSummaryModel.length > 0 && availableValues.has(configuredSummaryModel)) {
+		defaultSummaryModel = configuredSummaryModel;
+	}
+	if (!defaultSummaryModel) {
+		for (const preferred of preferredDefaults) {
+			if (availableValues.has(preferred)) {
+				defaultSummaryModel = preferred;
+				break;
+			}
+		}
+	}
+	if (!defaultSummaryModel && summaryModels.length > 0) {
+		defaultSummaryModel = summaryModels[0].value;
+	}
+
+	return { summaryModels, defaultSummaryModel };
+}
+
+export function resolveSummaryForSubmit(
+	payload: { selectedQueryIndices: number[]; summary?: string; summaryMeta?: SummaryMeta },
+	resultsByIndex: Map<number, QueryResultData>,
+): { approvedSummary: string; summaryMeta: SummaryMeta } {
+	const submittedSummary = typeof payload.summary === "string" ? payload.summary.trim() : "";
+	if (submittedSummary.length > 0) {
+		return {
+			approvedSummary: submittedSummary,
+			summaryMeta: normalizeSummaryMeta(payload.summaryMeta, submittedSummary),
+		};
+	}
+
+	const selected = filterByQueryIndices(payload.selectedQueryIndices, resultsByIndex).results;
+	const fallbackResults = selected.length > 0 ? selected : [...resultsByIndex.values()];
+	const deterministic = buildDeterministicSummary(fallbackResults);
+	return {
+		approvedSummary: deterministic.summary,
+		summaryMeta: deterministic.meta,
+	};
+}

package/dist/builtin/web-access/web-search-tool.ts

@@ -0,0 +1,290 @@
+import type { ExtensionAPI } from "@bastani/atomic";
+import { Text } from "@mariozechner/pi-tui";
+import { StringEnum } from "@mariozechner/pi-ai";
+import { Type } from "typebox";
+import { renderWebSearchResult } from "./result-renderers.js";
+import type { ExtractedContent } from "./extract.js";
+import { search } from "./gemini-search.js";
+import { type QueryResultData } from "./storage.js";
+import type { SummaryGenerationContext } from "./summary-review.js";
+import {
+	loadConfig,
+	loadConfigForExtensionInit,
+	loadCuratorBootstrap,
+	normalizeProviderInput,
+	normalizeQueryList,
+	resolveWorkflow,
+	type CuratorWorkflow,
+} from "./web-search-config.js";
+import { buildCurationCancelledReturn, extractDomain } from "./web-search-formatting.js";
+import type { SearchReturnBuilder } from "./web-search-return.js";
+import { loadSummaryModelChoices } from "./web-search-summary.js";
+import type { PendingCurate, WebSearchRuntimeState } from "./web-search-types.js";
+
+interface RegisterWebSearchToolDeps {
+	state: WebSearchRuntimeState;
+	closeCurator(): void;
+	openCuratorBrowser(pc: PendingCurate, searchesComplete?: boolean): Promise<void>;
+	buildSearchReturn: SearchReturnBuilder;
+}
+
+export function registerWebSearchTool(pi: ExtensionAPI, deps: RegisterWebSearchToolDeps): void {
+	pi.registerTool({
+		name: "web_search",
+		label: "Web Search",
+		description:
+			`Search the web using Perplexity AI, Exa, or Gemini. Returns an AI-synthesized answer with source citations. For comprehensive research, prefer queries (plural) with 2-4 varied angles over a single query — each query gets its own synthesized answer, so varying phrasing and scope gives much broader coverage. When includeContent is true, full page content is fetched in the background. Searches auto-open the interactive browser curator and stream results live; set workflow to "none" to skip curation. Provider auto-selects: Exa (direct API with key, MCP fallback without), else Perplexity (needs key), else Gemini API (needs key), else Gemini Web (needs a supported Chromium-based browser login).`,
+		promptSnippet:
+			"Use for web research questions. Prefer {queries:[...]} with 2-4 varied angles over a single query for broader coverage.",
+		parameters: Type.Object({
+			query: Type.Optional(Type.String({ description: "Single search query. For research tasks, prefer 'queries' with multiple varied angles instead." })),
+			queries: Type.Optional(Type.Array(Type.String(), { description: "Multiple queries searched in sequence, each returning its own synthesized answer. Prefer this for research — vary phrasing, scope, and angle across 2-4 queries to maximize coverage. Good: ['React vs Vue performance benchmarks 2026', 'React vs Vue developer experience comparison', 'React ecosystem size vs Vue ecosystem']. Bad: ['React vs Vue', 'React vs Vue comparison', 'React vs Vue review'] (too similar, redundant results)." })),
+			numResults: Type.Optional(Type.Number({ description: "Results per query (default: 5, max: 20)" })),
+			includeContent: Type.Optional(Type.Boolean({ description: "Fetch full page content (async)" })),
+			recencyFilter: Type.Optional(
+				StringEnum(["day", "week", "month", "year"], { description: "Filter by recency" }),
+			),
+			domainFilter: Type.Optional(Type.Array(Type.String(), { description: "Limit to domains (prefix with - to exclude)" })),
+			provider: Type.Optional(
+				StringEnum(["auto", "perplexity", "gemini", "exa"], { description: "Search provider (default: auto)" }),
+			),
+			workflow: Type.Optional(
+				StringEnum(["none", "summary-review"], {
+					description: "Search workflow mode: none = no curator, summary-review = open curator with auto summary draft (default)",
+				}),
+			),
+		}),
+
+		async execute(_toolCallId, params, signal, onUpdate, ctx) {
+			const rawQueryList: unknown[] = Array.isArray(params.queries)
+				? params.queries
+				: (params.query !== undefined ? [params.query] : []);
+			const queryList = normalizeQueryList(rawQueryList);
+			const configWorkflow = loadConfigForExtensionInit().workflow;
+			const workflow = resolveWorkflow(params.workflow ?? configWorkflow, ctx?.hasUI !== false);
+			const shouldCurate = workflow !== "none";
+
+			if (queryList.length === 0) {
+				return {
+					content: [{ type: "text", text: "Error: No query provided. Use 'query' or 'queries' parameter." }],
+					details: { error: "No query provided" },
+				};
+			}
+
+			if (shouldCurate && !ctx) {
+				return {
+					content: [{ type: "text", text: "Error: Curation requires an active extension context." }],
+					details: { error: "Missing extension context" },
+				};
+			}
+
+			if (shouldCurate) {
+				const activeCtx = ctx;
+				if (!activeCtx) {
+					return {
+						content: [{ type: "text", text: "Error: Curation requires an active extension context." }],
+						details: { error: "Missing extension context" },
+					};
+				}
+				deps.closeCurator();
+
+				let resolvePromise: (value: unknown) => void = () => {};
+				const promise = new Promise<unknown>((resolve) => {
+					resolvePromise = resolve;
+				});
+				const includeContent = params.includeContent ?? false;
+				const searchResults = new Map<number, QueryResultData>();
+				const allInlineContent: ExtractedContent[] = [];
+				const searchAbort = new AbortController();
+				const searchSignal = signal
+					? AbortSignal.any([signal, searchAbort.signal])
+					: searchAbort.signal;
+				let cancelled = false;
+
+				const bootstrap = await loadCuratorBootstrap(params.provider);
+				const availableProviders = bootstrap.availableProviders;
+				const defaultProvider = bootstrap.defaultProvider;
+				const curatorTimeoutSeconds = bootstrap.timeoutSeconds;
+				const curatorWorkflow: CuratorWorkflow = "summary-review";
+
+				const summaryContext: SummaryGenerationContext = {
+					model: activeCtx.model,
+					modelRegistry: activeCtx.modelRegistry,
+				};
+				const summaryModelChoices = await loadSummaryModelChoices(summaryContext);
+
+				const pc: PendingCurate = {
+					phase: "searching",
+					workflow: curatorWorkflow,
+					summaryContext,
+					searchResults,
+					allInlineContent,
+					queryList,
+					includeContent,
+					numResults: params.numResults,
+					recencyFilter: params.recencyFilter,
+					domainFilter: params.domainFilter,
+					availableProviders,
+					defaultProvider,
+					summaryModels: summaryModelChoices.summaryModels,
+					defaultSummaryModel: summaryModelChoices.defaultSummaryModel,
+					timeoutSeconds: curatorTimeoutSeconds,
+					onUpdate: onUpdate as PendingCurate["onUpdate"],
+					signal,
+					abortSearches: () => {
+						if (!searchAbort.signal.aborted) searchAbort.abort();
+					},
+					finish: () => {},
+					cancel: () => {},
+				};
+
+				const onAbort = () => deps.closeCurator();
+				const finish = (value: unknown) => {
+					if (cancelled) return;
+					cancelled = true;
+					pc.abortSearches();
+					signal?.removeEventListener("abort", onAbort);
+					deps.state.pendingCurate = null;
+					resolvePromise(value);
+				};
+
+				const cancel = (reason: "user" | "stale" = "stale") => {
+					if (cancelled) return;
+					finish(buildCurationCancelledReturn(reason));
+				};
+
+				pc.finish = finish;
+				pc.cancel = cancel;
+				deps.state.pendingCurate = pc;
+				signal?.addEventListener("abort", onAbort, { once: true });
+				pc.browserPromise = deps.openCuratorBrowser(pc, false);
+
+				for (let qi = 0; qi < queryList.length; qi++) {
+					if (signal?.aborted || cancelled || searchAbort.signal.aborted) break;
+					onUpdate?.({
+						content: [{ type: "text", text: `Searching ${qi + 1}/${queryList.length}: "${queryList[qi]}"...` }],
+						details: { phase: "searching", progress: qi / queryList.length, currentQuery: queryList[qi] },
+					});
+					const requestedProvider = pc.defaultProvider;
+					try {
+						const { answer, results, inlineContent, provider } = await search(queryList[qi], {
+							provider: requestedProvider,
+							numResults: params.numResults,
+							recencyFilter: params.recencyFilter,
+							domainFilter: params.domainFilter,
+							includeContent: params.includeContent,
+							signal: searchSignal,
+						});
+						if (signal?.aborted || cancelled || searchAbort.signal.aborted) break;
+						searchResults.set(qi, { query: queryList[qi], answer, results, error: null, provider });
+						if (inlineContent) allInlineContent.push(...inlineContent);
+						if (deps.state.activeCurator) {
+							deps.state.activeCurator.pushResult(qi, {
+								answer,
+								results: results.map(r => ({ title: r.title, url: r.url, domain: extractDomain(r.url) })),
+								provider,
+							});
+						}
+					} catch (err) {
+						if (signal?.aborted || cancelled || searchAbort.signal.aborted) break;
+						const message = err instanceof Error ? err.message : String(err);
+						searchResults.set(qi, { query: queryList[qi], answer: "", results: [], error: message, provider: requestedProvider });
+						if (deps.state.activeCurator) {
+							deps.state.activeCurator.pushError(qi, message, requestedProvider);
+						}
+					}
+				}
+
+				if (signal?.aborted || cancelled || searchAbort.signal.aborted) {
+					cancel();
+					return promise;
+				}
+
+				await pc.browserPromise;
+				if (deps.state.activeCurator) {
+					deps.state.activeCurator.searchesDone();
+					pc.onUpdate?.({
+						content: [{ type: "text", text: "All searches complete — waiting for summary approval in browser..." }],
+						details: { phase: "curating", progress: 1 },
+					});
+				}
+
+				return promise;
+			}
+
+			const searchResults: QueryResultData[] = [];
+			const allUrls: string[] = [];
+			const allInlineContent: ExtractedContent[] = [];
+			const resolvedProvider = normalizeProviderInput(params.provider ?? loadConfig().provider);
+
+			for (let i = 0; i < queryList.length; i++) {
+				const query = queryList[i];
+
+				onUpdate?.({
+					content: [{ type: "text", text: `Searching ${i + 1}/${queryList.length}: "${query}"...` }],
+					details: { phase: "search", progress: i / queryList.length, currentQuery: query },
+				});
+
+				try {
+					const { answer, results, inlineContent, provider } = await search(query, {
+						provider: resolvedProvider,
+						numResults: params.numResults,
+						recencyFilter: params.recencyFilter,
+						domainFilter: params.domainFilter,
+						includeContent: params.includeContent,
+						signal,
+					});
+
+					searchResults.push({ query, answer, results, error: null, provider });
+					for (const r of results) {
+						if (!allUrls.includes(r.url)) {
+							allUrls.push(r.url);
+						}
+					}
+					if (inlineContent) allInlineContent.push(...inlineContent);
+				} catch (err) {
+					const message = err instanceof Error ? err.message : String(err);
+					const requestedProvider = typeof resolvedProvider === "string" && resolvedProvider !== "auto"
+						? resolvedProvider
+						: undefined;
+					searchResults.push({ query, answer: "", results: [], error: message, provider: requestedProvider });
+				}
+			}
+
+			return deps.buildSearchReturn({
+				queryList,
+				results: searchResults,
+				urls: allUrls,
+				includeContent: params.includeContent ?? false,
+				inlineContent: allInlineContent.length > 0 ? allInlineContent : undefined,
+			});
+		},
+
+		renderCall(args, theme) {
+			const input = args as { query?: unknown; queries?: unknown };
+			const rawQueryList: unknown[] = Array.isArray(input.queries)
+				? input.queries
+				: (input.query !== undefined ? [input.query] : []);
+			const queryList = normalizeQueryList(rawQueryList);
+			if (queryList.length === 0) {
+				return new Text(theme.fg("toolTitle", theme.bold("search ")) + theme.fg("error", "(no query)"), 0, 0);
+			}
+			if (queryList.length === 1) {
+				const q = queryList[0];
+				const display = q.length > 60 ? q.slice(0, 57) + "..." : q;
+				return new Text(theme.fg("toolTitle", theme.bold("search ")) + theme.fg("accent", `"${display}"`), 0, 0);
+			}
+			const lines = [theme.fg("toolTitle", theme.bold("search ")) + theme.fg("accent", `${queryList.length} queries`)];
+			for (const q of queryList.slice(0, 5)) {
+				const display = q.length > 50 ? q.slice(0, 47) + "..." : q;
+				lines.push(theme.fg("muted", `  "${display}"`));
+			}
+			if (queryList.length > 5) {
+				lines.push(theme.fg("muted", `  ... and ${queryList.length - 5} more`));
+			}
+			return new Text(lines.join("\n"), 0, 0);
+		},
+
+		renderResult: renderWebSearchResult,
+	});
+}

package/dist/builtin/web-access/web-search-types.ts

@@ -0,0 +1,50 @@
+import type { CuratorServerHandle } from "./curator-server.js";
+import type { ExtractedContent } from "./extract.js";
+import type { ResolvedSearchProvider } from "./gemini-search.js";
+import type { QueryResultData } from "./storage.js";
+import type { SummaryGenerationContext } from "./summary-review.js";
+import type { GlimpseWindow } from "./web-search-browser.js";
+import type { CuratorWorkflow, ProviderAvailability } from "./web-search-config.js";
+
+export interface WebSearchToolUpdate {
+	content: Array<{ type: string; text: string }>;
+	details?: Record<string, unknown>;
+}
+
+export interface PendingCurate {
+	phase: "searching" | "curating";
+	workflow: CuratorWorkflow;
+	summaryContext: SummaryGenerationContext;
+	searchResults: Map<number, QueryResultData>;
+	allInlineContent: ExtractedContent[];
+	queryList: string[];
+	includeContent: boolean;
+	numResults?: number;
+	recencyFilter?: "day" | "week" | "month" | "year";
+	domainFilter?: string[];
+	availableProviders: ProviderAvailability;
+	defaultProvider: ResolvedSearchProvider;
+	summaryModels: Array<{ value: string; label: string }>;
+	defaultSummaryModel: string | null;
+	timeoutSeconds: number;
+	onUpdate: ((update: WebSearchToolUpdate) => void) | undefined;
+	signal: AbortSignal | undefined;
+	abortSearches: () => void;
+	finish: (value: unknown) => void;
+	cancel: (reason?: "user" | "stale") => void;
+	browserPromise?: Promise<void>;
+}
+
+export interface WebSearchRuntimeState {
+	sessionActive: boolean;
+	pendingCurate: PendingCurate | null;
+	activeCurator: CuratorServerHandle | null;
+	glimpseWin: GlimpseWindow | null;
+}
+
+export function cancelPendingCurate(
+	state: WebSearchRuntimeState,
+	reason: "user" | "stale" = "stale",
+): void {
+	state.pendingCurate?.cancel(reason);
+}

package/dist/builtin/workflows/CHANGELOG.md

@@ -6,14 +6,17 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [0.9.0-alpha.1] - 2026-06-20
+
 ### Breaking Changes
 
 - Renamed the builtin `open-claude-design` workflow output `browse_cli_status` to `playwright_cli_status` as part of migrating the workflow's preview/review tooling from the removed `browse` CLI to the `playwright-cli` command. Update any workflow-composition consumers that read `browse_cli_status`.
 
 ### Added
 
+- Added a deterministic workflow-stage resume stop hook: after an interactive interrupt/pause is resumed with a message, the executor suppresses the #1099/#1264 readiness prompt for that resume-answer turn (including `ask_user_question` turns) and, when the stage remains promptable, sends `Continue where you left off.` in the same stage session once per resume; schema-backed stages that already finalized with `structured_output` consume the token without a second prompt ([#1407](https://github.com/bastani-inc/atomic/issues/1407)).
 - Added a QA end-to-end proof video to the builtin `ralph` workflow. For UI-applicable or full-stack changes, the orchestrator now runs a `playwright-cli` end-to-end QA pass that drives the running app like a user, records a reviewable video (`playwright-cli video-start`/`video-stop`) to a stable run path, references it in the implementation notes (`## QA E2E Video`), and exposes it as the new optional `qa_video_path` output so the proof is available when the orchestrator finishes. When `create_pr=true`, the final `pull-request` stage attaches or links that video to the created PR/MR/review (embedding/linking where the provider supports media uploads, otherwise surfacing the absolute path). When no user-visible UI scenario applies, no video is produced and the notes record why.
-- Added a per-model context-window authoring token to workflow model strings: a parenthesized size token placed in the model-name portion, *before* the optional `:reasoning` suffix, e.g. `github-copilot/claude-opus-4.8 (1m):xhigh`. Adopting GitHub Copilot's `Claude Opus 4.8 (1M context)` naming convention keeps the window separate from the reasoning level so the two never collide. The token is resolved against the candidate model's advertised windows — an exact match wins, otherwise the largest supported window not exceeding the request (so `(1m)` selects a model's ~936K long-context tier), and it falls back to the model's default (short) window when no larger tier is available. It applies only to the candidate that carries the token, leaving primary and other fallback models untouched. Also surfaced `contextWindow`/`contextWindowStrict` on `StageOptions` and the workflow tool's direct-task schema for stage-level selection.
+- Added a per-model context-window authoring token to workflow model strings: a parenthesized token in the model-name portion, e.g. `github-copilot/claude-opus-4.8 (1m):xhigh`. The token may precede *or* follow the optional `:reasoning` suffix (`(1m):xhigh` or `:xhigh (1m)`); adopting GitHub Copilot's `Claude Opus 4.8 (1M context)` naming convention keeps the window separate from the reasoning level so the two never collide. Accepted token forms, all selecting the model's long tier when one exists: a generic size-agnostic `(long)` marker, or a rounded size matching the model's long tier (e.g. `(1m)` for claude-opus-4.8's 1M tier or `(1.1m)` for gpt-5.5's 1.05M tier). A request at or below the model's default keeps the default; a request above it selects the long tier (exact match wins, otherwise the smallest advertised window at or above the request, rounding **up** so a rounded marker always reaches the long tier); it falls back to the model's default (short) window when no long tier exists. It applies only to the candidate that carries the token, leaving primary and other fallback models untouched. Without the token, a tiered model now **pins its natural default (short) context window** in workflow stages so a persisted interactive long-context preference does not leak in (a stage-level `contextWindow`/`(long)` token still opts into long context). Also surfaced `contextWindow`/`contextWindowStrict` on `StageOptions` and the workflow tool's direct-task schema for stage-level selection.
 
 ### Changed
 
@@ -21,9 +24,13 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 - Changed the builtin `ralph` workflow review fan-out from two reviewers to three independent reviewers, each running on a different primary model family (Claude Fable 5, GPT-5.5 Codex, and Gemini 3.1 Pro) with shared fallbacks, so the adversarial review gets cross-model coverage instead of repeated passes from one model. The review loop stops only when all three reviewers independently approve (find no issues), so a P0–P3 finding from any single reviewer keeps Ralph iterating instead of being out-voted by a majority quorum. Also strengthened the orchestrator's implementation-notes contract to require verifiable evidence for any claims recorded in the notes and reviewer artifacts.
 - Changed the builtin `deep-research-codebase`, `goal`, `ralph`, and `open-claude-design` workflows to run their GitHub Copilot `claude-opus-4.8` fallbacks at the model's largest advertised long-context (~1M/936K) window via the new `(1m)` token, automatically degrading to the 200K short window when Copilot's long-context tier is unavailable. Other models in each fallback chain are unaffected.
 - Aligned the workflows extension peer dependency with upstream pi TUI `^0.79.7` so workflow graph, custom UI, and prompt-broker integrations consume the latest shared TUI color-scheme, Warp image capability, and compatibility fixes; no workflows extension code changes were made for this metadata sync ([#1413](https://github.com/bastani-inc/atomic/issues/1413)).
+- Changed contributor validation to include the monorepo-wide file-length gate for tracked TS/JS/Rust files in local `prek` hooks and PR CI, with only documented generated/vendored exclusions and no grandfathered baseline allowlist ([#1445](https://github.com/bastani-inc/atomic/issues/1445)).
 
 ### Fixed
 
+- Fixed workflow stage transcripts ignoring the host's resolved non-default session directory in headless runs. Stages without an explicit `sessionDir` now inherit the active main-session directory when it comes from `--session-dir`, `ATOMIC_CODING_AGENT_SESSION_DIR`, or settings; explicit per-stage `sessionDir` still wins, default host sessions keep writing stages to the global store, and forked stages inherit the non-default directory too ([#1444](https://github.com/bastani-inc/atomic/issues/1444)).
+- Fixed a manual workflow pause/resume not updating the main-chat run status the way the `workflow` tool and `/workflow pause`/`/workflow resume` do. Pausing a stage from the attached stage chat (Escape) or any direct live-handle path recorded only the **stage** as paused (`recordStagePaused`) and never the **run** (`recordRunPaused`), so the below-editor status widget and `/workflow status` kept showing the run as `running` (`●`) even though work was paused; resume had the symmetric gap. The executor stage-control handle now records run-level pause/resume itself — marking the run paused once no stage is still actively running (mirroring `pauseRun`'s all-active-stages-paused rule) and restoring it on resume — so manual and tool-driven pause/resume update the main chat identically. Both run-level transitions are idempotent, so the tool/slash path and cascade re-entry stay safe.
+- Fixed the builtin `ralph` workflow review loop iterating until `max_loops` even when reviewers judged the patch correct. The unanimous-approval gate required a literally empty `findings` array, so a single low-priority **P3** nit — or a placeholder/dummy finding a reviewer appended because it wrongly believed an empty array would fail schema validation — kept the loop spinning despite every reviewer reporting `overall_correctness: "patch is correct"`. Approval is now **severity-aware and deterministic**: a reviewer approves when it judged the patch correct, reported no `reviewer_error`, and filed no *blocking* finding, where blocking = **P0/P1/P2** (priority 0/1/2) and **P3** (priority 3) is a non-blocking nice-to-have; a finding without a determinable priority (`null`/`undefined`) is treated as blocking so ambiguity never silently approves. The decision is computed from finding priorities rather than the reviewer's self-reported `stop_review_loop` flag. Extracted the gate into `builtin/ralph-review-gate.ts` (`reviewDecisionApproved`, `isBlockingFinding`) with unit coverage, and updated the reviewer prompt so an empty `findings` array is explicitly valid and placeholder findings are never fabricated ([#1407](https://github.com/bastani-inc/atomic/issues/1407)).
 - Fixed workflow stage **model fallback misreporting configured providers as `No API key found`**. Each fallback candidate session was created with a fresh `AuthStorage`/`ModelRegistry`, so after a primary model failed (for example the Ralph `reviewer-a` chain hitting an unavailable `anthropic/claude-fable-5` and getting a real provider 404), every fallback candidate re-read `auth.json` from scratch. Under concurrent reviewer stages and OAuth token refreshes holding the `auth.json` lock, that fresh synchronous reload could fail and silently fall back to an empty credential set, reporting `No API key found` for `anthropic`/`openai-codex`/`github-copilot` even while sibling reviewer stages used those exact providers successfully. A stage now captures the `ModelRegistry` (and its already-loaded `AuthStorage`) from its first session and threads it into every subsequent fallback candidate, so a successfully-loaded credential store is reused across the whole fallback chain instead of being discarded and re-loaded per candidate. Combined with the coding-agent change that surfaces a real credential-store load failure instead of `No API key found`, a transient store-read failure remains a recoverable/retryable auth failure ([#1431](https://github.com/bastani-inc/atomic/issues/1431)).
 - Fixed post-completion workflow follow-ups replaying the entire model-fallback chain from an unavailable primary instead of resuming on the model the stage settled on. After model fallback succeeded, the stage kept its working `session` but left `sessionPromise` undefined, and `ensureSession()` only checked `sessionPromise` — so a follow-up (`ctx.followUp`/`ctx.steer`/`ensureAttached`, and post-completion `workflow send`/TUI prompts) created a brand-new session from `candidates[0]` (the primary), discarding the working fallback session. For a chain whose primary 404s (e.g. `anthropic/claude-fable-5`), every follow-up re-ran `primary -> 404 -> ... -> working model` and could leave the stage stuck on the unavailable primary. `ensureSession()` now reuses an already-attached session, and `promptWithFallback()` retries the last-settled model first (for both live retained sessions and disk-reattached sessions), restarting the full chain from the primary only if that model fails again retryably ([#1431](https://github.com/bastani-inc/atomic/issues/1431)).