@bastani/atomic 0.8.31-alpha.5 → 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,6 +6,8 @@ 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`.
@@ -14,7 +16,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 - 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
 
@@ -22,6 +24,7 @@ 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