@bastani/atomic 0.9.5-alpha.8 → 0.9.5

package/dist/builtin/subagents/src/slash/slash-live-state.ts

@@ -14,6 +14,12 @@ interface SlashSnapshot {
 	version: number;
 }
 
+export interface SlashSnapshotStore {
+	liveSnapshots: Map<string, SlashSnapshot>;
+	finalSnapshots: Map<string, SlashSnapshot>;
+	versionCounter: number;
+}
+
 interface SequentialChainStepLike {
 	agent: string;
 	task?: string;
@@ -25,9 +31,26 @@ interface ParallelChainStepLike {
 
 type ChainStepLike = SequentialChainStepLike | ParallelChainStepLike;
 
-const liveSnapshots = new Map<string, SlashSnapshot>();
-const finalSnapshots = new Map<string, SlashSnapshot>();
-let versionCounter = 1;
+const defaultStoreOwner = {};
+
+function getStoreRegistry(): WeakMap<object, SlashSnapshotStore> {
+	const key = "__piSubagentSlashSnapshotStores";
+	const globalStore = globalThis as Record<string, unknown>;
+	const existing = globalStore[key];
+	if (existing instanceof WeakMap) return existing as WeakMap<object, SlashSnapshotStore>;
+	const registry = new WeakMap<object, SlashSnapshotStore>();
+	globalStore[key] = registry;
+	return registry;
+}
+
+export function getSlashSnapshotStore(owner: object = defaultStoreOwner): SlashSnapshotStore {
+	const registry = getStoreRegistry();
+	const existing = registry.get(owner);
+	if (existing) return existing;
+	const store = { liveSnapshots: new Map(), finalSnapshots: new Map(), versionCounter: 1 };
+	registry.set(owner, store);
+	return store;
+}
 
 const EMPTY_MESSAGES: Message[] = [];
 const EMPTY_USAGE: Usage = {
@@ -39,8 +62,8 @@ const EMPTY_USAGE: Usage = {
 	turns: 0,
 };
 
-function nextVersion(): number {
-	return versionCounter++;
+function nextVersion(store: SlashSnapshotStore): number {
+	return store.versionCounter++;
 }
 
 function cloneUsage(): Usage {
@@ -60,7 +83,7 @@ function createPlaceholderResult(
 		messages: EMPTY_MESSAGES,
 		usage: cloneUsage(),
 		progress: {
-			...(index !== undefined ? { index } : {}),
+			index: index ?? 0,
 			agent,
 			status,
 			task,
@@ -164,6 +187,7 @@ function buildSingleInitialResult(params: SubagentParamsLike): AgentToolResult<D
 			...(params.context ? { context: params.context } : {}),
 			results: [createPlaceholderResult(agent, task, "running")],
 			progress: [{
+				index: 0,
 				agent,
 				status: "running",
 				task,
@@ -177,14 +201,15 @@ function buildSingleInitialResult(params: SubagentParamsLike): AgentToolResult<D
 	};
 }
 
-export function buildSlashInitialResult(requestId: string, params: SubagentParamsLike): SlashMessageDetails {
+export function buildSlashInitialResult(requestId: string, params: SubagentParamsLike, owner?: object): SlashMessageDetails {
+	const store = getSlashSnapshotStore(owner);
 	const result = (params.tasks?.length ?? 0) > 0
 		? buildParallelInitialResult(params)
 		: (params.chain?.length ?? 0) > 0
 			? buildChainInitialResult(params)
 			: buildSingleInitialResult(params);
-	liveSnapshots.set(requestId, { result, version: nextVersion() });
-	finalSnapshots.delete(requestId);
+	store.liveSnapshots.set(requestId, { result, version: nextVersion(store) });
+	store.finalSnapshots.delete(requestId);
 	return { requestId, result };
 }
 
@@ -200,8 +225,9 @@ function cloneResultsWithProgress(
 	});
 }
 
-export function applySlashUpdate(requestId: string, update: SlashSubagentUpdate): void {
-	const snapshot = liveSnapshots.get(requestId);
+export function applySlashUpdate(requestId: string, update: SlashSubagentUpdate, owner?: object): void {
+	const store = getSlashSnapshotStore(owner);
+	const snapshot = store.liveSnapshots.get(requestId);
 	if (!snapshot) return;
 	const progress = update.progress;
 	if (!progress || !snapshot.result.details) return;
@@ -212,30 +238,32 @@ export function applySlashUpdate(requestId: string, update: SlashSubagentUpdate)
 		results: cloneResultsWithProgress(snapshot.result.details.results, progress),
 		...(snapshot.result.details.mode === "chain" && currentStepIndex >= 0 ? { currentStepIndex } : {}),
 	};
-	liveSnapshots.set(requestId, {
+	store.liveSnapshots.set(requestId, {
 		result: {
 			...snapshot.result,
 			details: nextDetails,
 		},
-		version: nextVersion(),
+		version: nextVersion(store),
 	});
 }
 
-export function finalizeSlashResult(response: SlashSubagentResponse): SlashMessageDetails {
+export function finalizeSlashResult(response: SlashSubagentResponse, owner?: object): SlashMessageDetails {
+	const store = getSlashSnapshotStore(owner);
 	const snapshot = {
 		result: response.result,
-		version: nextVersion(),
+		version: nextVersion(store),
 	};
-	finalSnapshots.set(response.requestId, snapshot);
-	liveSnapshots.delete(response.requestId);
+	store.finalSnapshots.set(response.requestId, snapshot);
+	store.liveSnapshots.delete(response.requestId);
 	return {
 		requestId: response.requestId,
 		result: response.result,
 	};
 }
 
-export function failSlashResult(requestId: string, params: SubagentParamsLike, message: string): SlashMessageDetails {
-	const initial = buildSlashInitialResult(requestId, params).result;
+export function failSlashResult(requestId: string, params: SubagentParamsLike, message: string, owner?: object): SlashMessageDetails {
+	const store = getSlashSnapshotStore(owner);
+	const initial = buildSlashInitialResult(requestId, params, owner).result;
 	const failedResults = initial.details.results.map((result) => ({
 		...result,
 		exitCode: 1,
@@ -250,9 +278,9 @@ export function failSlashResult(requestId: string, params: SubagentParamsLike, m
 			progress: failedResults.map((entry) => entry.progress!).filter(Boolean),
 		},
 	};
-	const snapshot = { result, version: nextVersion() };
-	finalSnapshots.set(requestId, snapshot);
-	liveSnapshots.delete(requestId);
+	const snapshot = { result, version: nextVersion(store) };
+	store.finalSnapshots.set(requestId, snapshot);
+	store.liveSnapshots.delete(requestId);
 	return { requestId, result };
 }
 
@@ -268,25 +296,28 @@ export function resolveSlashMessageDetails(value: unknown): SlashMessageDetails
 	return isSlashMessageDetails(value) ? value : undefined;
 }
 
-export function getSlashRenderableSnapshot(details: SlashMessageDetails): SlashSnapshot {
-	return finalSnapshots.get(details.requestId)
-		?? liveSnapshots.get(details.requestId)
+export function getSlashRenderableSnapshot(details: SlashMessageDetails, owner?: object): SlashSnapshot {
+	const store = getSlashSnapshotStore(owner);
+	return store.finalSnapshots.get(details.requestId)
+		?? store.liveSnapshots.get(details.requestId)
 		?? { result: details.result, version: 0 };
 }
 
-export function restoreSlashFinalSnapshots(entries: unknown[]): void {
-	liveSnapshots.clear();
-	finalSnapshots.clear();
+export function restoreSlashFinalSnapshots(entries: unknown[], owner?: object): void {
+	const store = getSlashSnapshotStore(owner);
+	store.liveSnapshots.clear();
+	store.finalSnapshots.clear();
 	for (const entry of entries) {
 		const e = entry as { type?: string; customType?: string; details?: unknown };
 		if (e?.type !== "custom_message" || e.customType !== SLASH_RESULT_TYPE) continue;
 		const details = resolveSlashMessageDetails(e.details);
 		if (!details) continue;
-		finalSnapshots.set(details.requestId, { result: details.result, version: nextVersion() });
+		store.finalSnapshots.set(details.requestId, { result: details.result, version: nextVersion(store) });
 	}
 }
 
-export function clearSlashSnapshots(): void {
-	liveSnapshots.clear();
-	finalSnapshots.clear();
+export function clearSlashSnapshots(owner?: object): void {
+	const store = getSlashSnapshotStore(owner);
+	store.liveSnapshots.clear();
+	store.finalSnapshots.clear();
 }

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

@@ -61,6 +61,13 @@ export function renderSubagentResult(
 	theme: Theme,
 ): Component {
 	const d = result.details;
+	if (d?.asyncId && d.results.length === 0) {
+		const contextPrefix = d.context === "fork" ? `${theme.fg("warning", "[fork]")} ` : "";
+		const container = new Container();
+		container.addChild(new Text(`${contextPrefix}${theme.fg("success", "launched")} · async run ${d.asyncId}`, 0, 0));
+		container.addChild(new Text(theme.fg("dim", "completion pending; the detached result will be delivered when it finishes"), 0, 0));
+		return container;
+	}
 	if (!d || !d.results.length) {
 		const t = result.content[0];
 		const text = t?.type === "text" ? t.text : "(no output)";

package/dist/builtin/subagents/src/tui/render-stable-output.ts

@@ -76,6 +76,7 @@ export function subagentResultRenderKey(
 		options.expanded ? "expanded" : "compact",
 		details.mode,
 		details.currentStepIndex ?? "",
+		details.asyncId ?? "",
 		details.totalSteps ?? "",
 		progressRenderKey(details.progressSummary),
 		progressKeys.join("|"),

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

@@ -60,53 +60,81 @@ interface RenderRequestingContext {
 	ui: ExtensionContext["ui"] & { requestRender?: () => void };
 }
 
-// There is only ever one async-agents widget per host process, so the mounted
-// component reads its driving context/jobs/pulse frame from module-level
-// singletons instead of remounting the widget for every visible update.
-let latestWidgetCtx: ExtensionContext | undefined;
-let latestWidgetJobs: AsyncJobState[] = [];
-let latestWidgetFrameNow = 0;
-let latestWidgetExpanded = false;
-let latestWidgetSnapshotKey: string | undefined;
-let latestWidgetPulseFrame: number | undefined;
-let mountedWidgetCtx: ExtensionContext | undefined;
-let mountedWidgetOwnerKey: string | undefined;
-let widgetMounted = false;
-
-function getLatestWidgetJobs(): AsyncJobState[] {
-	return latestWidgetJobs;
+interface WidgetAnimationState {
+	latestCtx?: ExtensionContext;
+	latestJobs: AsyncJobState[];
+	frameNow: number;
+	expanded: boolean;
+	snapshotKey?: string;
+	pulseFrame?: number;
+	mountedCtx?: ExtensionContext;
+	mountedOwnerKey?: string;
+	surfaceKey?: object;
+	mounted: boolean;
 }
 
-function getLatestWidgetFrameNow(): number {
-	return latestWidgetFrameNow;
+interface WidgetSurfaceState {
+	activeOwner?: object;
 }
 
-function getLatestWidgetPulseFrame(): number | undefined {
-	return latestWidgetPulseFrame;
+interface WidgetRegistry {
+	states: WeakMap<object, WidgetAnimationState>;
+	surfaces: WeakMap<object, WidgetSurfaceState>;
 }
 
-function getLatestWidgetExpanded(): boolean {
-	// LiveWidgetComponent re-renders outside a specific renderWidget() call, so
-	// remember the last expansion state observed from a live host UI. Workflow
-	// stage-node detach can briefly repaint the mounted singleton with a stale or
-	// no-UI context before the next subagent status update refreshes it; falling
-	// back to the cached value avoids a transient collapse while jobs keep running.
-	if (!latestWidgetCtx?.hasUI) return latestWidgetExpanded;
-	const expanded = latestWidgetCtx.ui.getToolsExpanded?.();
-	if (typeof expanded === "boolean") latestWidgetExpanded = expanded;
-	return latestWidgetExpanded;
+const defaultWidgetOwner = {};
+
+function getWidgetRegistry(): WidgetRegistry {
+	const key = "__piSubagentWidgetRegistry";
+	const globalStore = globalThis as Record<string, unknown>;
+	const existing = globalStore[key] as WidgetRegistry | undefined;
+	if (existing?.states instanceof WeakMap && existing.surfaces instanceof WeakMap) return existing;
+	const registry: WidgetRegistry = { states: new WeakMap(), surfaces: new WeakMap() };
+	globalStore[key] = registry;
+	return registry;
+}
+
+function getWidgetState(owner: object): WidgetAnimationState {
+	const registry = getWidgetRegistry();
+	const existing = registry.states.get(owner);
+	if (existing) return existing;
+	const state: WidgetAnimationState = {
+		latestJobs: [],
+		frameNow: 0,
+		expanded: false,
+		mounted: false,
+	};
+	registry.states.set(owner, state);
+	return state;
+}
+
+function getSurfaceState(surfaceKey: object): WidgetSurfaceState {
+	const registry = getWidgetRegistry();
+	const existing = registry.surfaces.get(surfaceKey);
+	if (existing) return existing;
+	const surface = {};
+	registry.surfaces.set(surfaceKey, surface);
+	return surface;
+}
+
+function getExpanded(state: WidgetAnimationState): boolean {
+	if (!state.latestCtx?.hasUI) return state.expanded;
+	const expanded = state.latestCtx.ui.getToolsExpanded?.();
+	if (typeof expanded === "boolean") state.expanded = expanded;
+	return state.expanded;
 }
 
-function clearLatestWidgetState(): void {
-	latestWidgetCtx = undefined;
-	latestWidgetJobs = [];
-	latestWidgetFrameNow = 0;
-	latestWidgetExpanded = false;
-	latestWidgetSnapshotKey = undefined;
-	latestWidgetPulseFrame = undefined;
-	mountedWidgetCtx = undefined;
-	mountedWidgetOwnerKey = undefined;
-	widgetMounted = false;
+function clearWidgetState(state: WidgetAnimationState): void {
+	state.latestCtx = undefined;
+	state.latestJobs = [];
+	state.frameNow = 0;
+	state.expanded = false;
+	state.snapshotKey = undefined;
+	state.pulseFrame = undefined;
+	state.mountedCtx = undefined;
+	state.mountedOwnerKey = undefined;
+	state.surfaceKey = undefined;
+	state.mounted = false;
 }
 
 function getWidgetOwnerKey(ctx: ExtensionContext): string {
@@ -137,6 +165,28 @@ function getWidgetOwnerKey(ctx: ExtensionContext): string {
 	return `${sessionOwner}|cwd:${cwdOwner}`;
 }
 
+function widgetStatusText(jobs: AsyncJobState[]): string | undefined {
+	if (jobs.length === 0) return undefined;
+	const counts = new Map<string, number>();
+	for (const job of jobs) counts.set(job.status, (counts.get(job.status) ?? 0) + 1);
+	const ordered = ["running", "queued", "complete", "failed", "paused"];
+	const parts = ordered
+		.map((status) => {
+			const count = counts.get(status) ?? 0;
+			return count > 0 ? `${count} ${status}` : undefined;
+		})
+		.filter((part): part is string => part !== undefined);
+	return `Async agents: ${parts.join(", ")}`;
+}
+
+function setWidgetStatus(ctx: ExtensionContext, jobs: AsyncJobState[]): void {
+	try {
+		ctx.ui.setStatus?.(WIDGET_KEY, widgetStatusText(jobs));
+	} catch {
+		// Status mirroring must never prevent the primary widget render path.
+	}
+}
+
 function requestWidgetRender(ctx: ExtensionContext): void {
 	(ctx as RenderRequestingContext).ui.requestRender?.();
 }
@@ -150,25 +200,44 @@ function unmountWidgetBestEffort(ctx: ExtensionContext | undefined): void {
 		// reload/session rebinding, but local state still needs to move on so the
 		// next status update can mount cleanly on the active UI context.
 	}
+	try {
+		ctx.ui.setStatus?.(WIDGET_KEY, undefined);
+	} catch {
+		// Status mirroring cleanup must never block primary widget teardown.
+	}
 }
 
 function widgetSnapshotKey(jobs: AsyncJobState[]): string {
 	return jobs.map(widgetRenderKey).join("\n");
 }
 
-function refreshWidgetSnapshot(jobs: AsyncJobState[]): void {
+function refreshWidgetSnapshot(state: WidgetAnimationState, jobs: AsyncJobState[]): void {
 	const snapshotKey = widgetSnapshotKey(jobs);
-	if (snapshotKey === latestWidgetSnapshotKey) return;
-	latestWidgetSnapshotKey = snapshotKey;
-	latestWidgetFrameNow = Date.now();
-	latestWidgetPulseFrame = advanceResultPulseFrame(latestWidgetPulseFrame);
+	if (snapshotKey === state.snapshotKey) return;
+	state.snapshotKey = snapshotKey;
+	state.frameNow = Date.now();
+	state.pulseFrame = advanceResultPulseFrame(state.pulseFrame);
 }
 
-// Full teardown: clear the mounted widget if possible, and forget the driving
-// context/jobs entirely.
-export function stopWidgetAnimation(): void {
-	if (widgetMounted) unmountWidgetBestEffort(mountedWidgetCtx);
-	clearLatestWidgetState();
+function releaseMountedWidget(state: WidgetAnimationState, owner: object): void {
+	if (state.mounted) unmountWidgetBestEffort(state.mountedCtx);
+	if (state.surfaceKey) {
+		const surface = getSurfaceState(state.surfaceKey);
+		if (surface.activeOwner === owner) surface.activeOwner = undefined;
+	}
+	clearWidgetState(state);
+}
+
+// Full teardown. Explicit API ownership is authoritative; logical context
+// matching only protects context-driven teardown from stale session wrappers.
+export function stopWidgetAnimation(ownerCtx?: ExtensionContext, owner: object = defaultWidgetOwner): void {
+	const state = getWidgetState(owner);
+	if (ownerCtx && state.mounted && state.mountedOwnerKey !== getWidgetOwnerKey(ownerCtx)) return;
+	if (state.surfaceKey && getSurfaceState(state.surfaceKey).activeOwner !== owner) {
+		clearWidgetState(state);
+		return;
+	}
+	releaseMountedWidget(state, owner);
 }
 
 export function buildWidgetLines(jobs: AsyncJobState[], theme: Theme, width = getTermWidth(), expanded = false, now: number = Date.now(), pulseFrame?: number): string[] {
@@ -241,55 +310,54 @@ export function buildWidgetLines(jobs: AsyncJobState[], theme: Theme, width = ge
 	return lines;
 }
 
-/**
- * Render the async jobs widget
- */
-export function renderWidget(ctx: ExtensionContext, jobs: AsyncJobState[]): void {
+/** Render the async jobs widget for one ExtensionAPI owner. */
+export function renderWidget(ctx: ExtensionContext, jobs: AsyncJobState[], owner: object = defaultWidgetOwner): void {
+	const state = getWidgetState(owner);
 	const ownerKey = getWidgetOwnerKey(ctx);
+	const requestedSurfaceKey = ctx.ui.setWidget;
+	const requestedSurface = getSurfaceState(requestedSurfaceKey);
 	if (jobs.length === 0) {
-		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();
+		if (requestedSurface.activeOwner && requestedSurface.activeOwner !== owner) return;
+		if (state.surfaceKey && getSurfaceState(state.surfaceKey).activeOwner !== owner) return;
+		if (state.mounted && state.mountedOwnerKey !== ownerKey) return;
+		if (ctx.hasUI) setWidgetStatus(ctx, []);
+		stopWidgetAnimation(ctx, owner);
 		return;
 	}
 	if (!ctx.hasUI) {
-		stopWidgetAnimation();
+		stopWidgetAnimation(ctx, owner);
 		return;
 	}
-	latestWidgetCtx = ctx;
-	latestWidgetJobs = [...jobs];
-	refreshWidgetSnapshot(jobs);
-	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;
+	// Workflow stages forward the host's setWidget function, which identifies the
+	// shared widget surface. A stage cannot replace a parent already active there.
+	if (!state.mounted && requestedSurface.activeOwner && requestedSurface.activeOwner !== owner) return;
+	state.latestCtx = ctx;
+	state.latestJobs = [...jobs];
+	refreshWidgetSnapshot(state, jobs);
+	if (state.mounted && state.mountedOwnerKey !== ownerKey) {
+		releaseMountedWidget(state, owner);
+		state.latestCtx = ctx;
+		state.latestJobs = [...jobs];
+		refreshWidgetSnapshot(state, jobs);
 	}
-	if (!widgetMounted) {
-		// belowEditor keeps the live async widget pinned to the bottom viewport,
-		// matching the workflow companion widget's placement (#1109). The pulse frame
-		// is advanced only by semantic async status updates, not by a cosmetic timer.
-		ctx.ui.setWidget(WIDGET_KEY, buildWidgetComponent(getLatestWidgetJobs, getLatestWidgetExpanded, getLatestWidgetFrameNow, getLatestWidgetPulseFrame), {
-			placement: "belowEditor",
-		});
-		mountedWidgetCtx = ctx;
-		mountedWidgetOwnerKey = ownerKey;
-		widgetMounted = true;
+	setWidgetStatus(ctx, jobs);
+	if (!state.mounted) {
+		const surface = getSurfaceState(requestedSurfaceKey);
+		if (surface.activeOwner && surface.activeOwner !== owner) return;
+		ctx.ui.setWidget(WIDGET_KEY, buildWidgetComponent(
+			() => state.latestJobs,
+			() => getExpanded(state),
+			() => state.frameNow,
+			() => state.pulseFrame,
+		), { placement: "belowEditor" });
+		state.mountedCtx = ctx;
+		state.mountedOwnerKey = ownerKey;
+		state.surfaceKey = requestedSurfaceKey;
+		state.mounted = true;
+		surface.activeOwner = owner;
 	} else {
-		// The mounted widget reads latestWidgetJobs via getLatestWidgetJobs(), so a
-		// 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;
+		state.mountedCtx = ctx;
+		state.mountedOwnerKey = ownerKey;
 		requestWidgetRender(ctx);
 	}
-	// The async pulse is update-driven like foreground subagent results, so no
-	// periodic cosmetic ticker is needed.
 }

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

@@ -4,6 +4,34 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [0.9.5] - 2026-07-11
+
+### Changed
+
+- Aligned the web-access extension peer dependency with upstream `pi-tui` `^0.80.6` as part of the consolidated Pi sync; no web-access source behavior changed ([#1703](https://github.com/bastani-inc/atomic/issues/1703)).
+
+### Fixed
+
+- Retry failed lazy initialization and initial or later-generation lifecycle replays before a subsequent `web_search` or `fetch_content` executes, while concurrent cold/retry callers share one attempt ([#1704](https://github.com/bastani-inc/atomic/issues/1704)).
+- Fixed native Bun loading of the heavy web-access graph by resolving pi-ai compatibility helpers from the installed `@earendil-works/pi-ai/compat` package, so `web_search`, `code_search`, `fetch_content`, and `get_search_content` initialize through their lazy wrappers ([#1728](https://github.com/bastani-inc/atomic/issues/1728)).
+- Made lazy lifecycle replay generation-safe and session-leased: replay is committed only after successful dispatch, lifecycle changes during replay advance to the latest snapshot, shutdown does not report completion until retired replay/initializer cleanup settles, calls spanning teardown reject, and replacement wrappers cannot be mutated by late old cleanup.
+- Recheck each invocation's abort signal after shared lazy initialization and provider/curator execution, preserving the exact host abort reason without cancelling initialization for other callers while keeping explicit curator user cancellation result-shaped.
+- Classify non-empty all-failed search/fetch batches as host-visible tool errors with provider/fetch stage diagnostics while retaining per-item payloads and keeping partial successes successful.
+
+## [0.9.5-alpha.10] - 2026-07-11
+
+### Changed
+
+- Aligned the web-access extension peer dependency with upstream `pi-tui` `^0.80.6` as part of the consolidated Pi sync; no web-access source behavior changed ([#1703](https://github.com/bastani-inc/atomic/issues/1703)).
+
+### Fixed
+
+- Retry failed lazy initialization and initial or later-generation lifecycle replays before a subsequent `web_search` or `fetch_content` executes, while concurrent cold/retry callers share one attempt ([#1704](https://github.com/bastani-inc/atomic/issues/1704)).
+- Fixed native Bun loading of the heavy web-access graph by resolving pi-ai compatibility helpers from the installed `@earendil-works/pi-ai/compat` package, so `web_search`, `code_search`, `fetch_content`, and `get_search_content` initialize through their lazy wrappers ([#1728](https://github.com/bastani-inc/atomic/issues/1728)).
+- Made lazy lifecycle replay generation-safe and session-leased: replay is committed only after successful dispatch, lifecycle changes during replay advance to the latest snapshot, shutdown does not report completion until retired replay/initializer cleanup settles, calls spanning teardown reject, and replacement wrappers cannot be mutated by late old cleanup.
+- Recheck each invocation's abort signal after shared lazy initialization and provider/curator execution, preserving the exact host abort reason without cancelling initialization for other callers while keeping explicit curator user cancellation result-shaped.
+- Classify non-empty all-failed search/fetch batches as host-visible tool errors with provider/fetch stage diagnostics while retaining per-item payloads and keeping partial successes successful.
+
 ## [0.9.4] - 2026-07-03
 
 ### Changed

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

@@ -72,6 +72,10 @@ fetch_content({ url: "/path/to/recording.mp4", prompt: "What error appears on sc
 
 ## Tools
 
+The public tools register immediately and share one lazy initialization attempt on first use. Calls wait for initialization and active-session replay before provider work begins; a rejected initializer or replay can be retried by a later call. Initialization and replay are leased to the active session: shutdown retires the lease and cleans its candidate, so calls spanning shutdown reject and a restarted session creates a fresh provider wrapper. An abort that arrives during the shared wait cancels only that invocation. Host cancellation after provider or curator work rejects with the exact host abort reason, while an explicit user action in the curator remains a successful `{ cancelled: true, cancelReason: "user" }` result. Resetting the application-owned attempt does not guarantee re-evaluation of an ESM module whose evaluation itself failed.
+
+For batch search/fetch calls, partial success remains usable and retains item-level errors. A non-empty batch where every provider request or URL fetch fails is reported through Atomic's tool-error channel with aggregate stage metadata while the per-item diagnostics remain stored in the result.
+
 ### web_search
 
 Search the web via Exa, Perplexity AI, or Gemini. Returns a synthesized answer with source citations.

package/dist/builtin/web-access/content-tools.ts

@@ -1,5 +1,5 @@
 import type { ExtensionAPI } from "@bastani/atomic";
-import { Text } from "@mariozechner/pi-tui";
+import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import {
 	renderCodeSearchResult,
@@ -102,6 +102,7 @@ export function registerContentTools(pi: ExtensionAPI, deps: RegisterContentTool
 				frames: params.frames,
 				model: params.model,
 			});
+			signal?.throwIfAborted();
 			const successful = fetchResults.filter((r) => !r.error).length;
 			const totalChars = fetchResults.reduce((sum, r) => sum + r.content.length, 0);
 
@@ -120,7 +121,7 @@ export function registerContentTools(pi: ExtensionAPI, deps: RegisterContentTool
 				if (result.error) {
 					return {
 						content: [{ type: "text", text: `Error: ${result.error}` }],
-						details: { urls: urlList, urlCount: 1, successful: 0, error: result.error, responseId, prompt: params.prompt, timestamp: params.timestamp, frames: params.frames },
+						details: { outcome: "all_failed", stage: "fetch", urls: urlList, urlCount: 1, successful: 0, error: result.error, responseId, prompt: params.prompt, timestamp: params.timestamp, frames: params.frames },
 					};
 				}
 
@@ -177,9 +178,13 @@ export function registerContentTools(pi: ExtensionAPI, deps: RegisterContentTool
 			}
 			output += `\n---\nUse get_search_content({ responseId: "${responseId}", urlIndex: 0 }) to retrieve full content.`;
 
+			const allFailed = successful === 0;
 			return {
 				content: [{ type: "text", text: output }],
-				details: { urls: urlList, urlCount: urlList.length, successful, totalChars, responseId },
+				details: {
+					...(allFailed ? { outcome: "all_failed", stage: "fetch", error: `All ${urlList.length} URL fetch(es) failed`, failedUrls: urlList.length } : {}),
+					urls: urlList, urlCount: urlList.length, successful, totalChars, responseId,
+				},
 			};
 		},
 

package/dist/builtin/web-access/index-heavy.ts

@@ -2,7 +2,7 @@ import type { ExtensionAPI } from "@bastani/atomic";
 import { CONFIG_DIR_NAME } from "@bastani/atomic";
 import { appendFileSync } from "node:fs";
 import { getActiveGoogleEmail, isGeminiWebAvailable } from "./gemini-web.js";
-import { isBrowserCookieAccessAllowed } from "./gemini-web-config.ts";
+import { isBrowserCookieAccessAllowed } from "./gemini-web-config.js";
 import { deleteResult, getAllResults } from "./storage.js";
 import { loadConfigForExtensionInit, resolveWorkflow, saveConfig, type WebSearchWorkflow } from "./web-search-config.js";