@oh-my-pi/pi-coding-agent 17.2.9 → 17.2.11

package/src/registry/persisted-agents.ts

@@ -1,26 +1,281 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { ADVISOR_TRANSCRIPT_FILENAME, isAdvisorTranscriptName } from "../advisor/transcript-recorder";
-import { SessionManager } from "../session/session-manager";
+import { resolveExplicitModelRole } from "../config/model-resolver";
+import { EPHEMERAL_MODEL_CHANGE_ROLE } from "../session/session-entries";
+import { visitEntriesFromFileStream } from "../session/session-loader";
+import { loadBundledAgents } from "../task/agents";
+import { isReadOnlyAgent } from "../task/read-only-policy";
 import { persistedVibeChildIds } from "../vibe/runtime";
-import { type AgentRegistry, MAIN_AGENT_ID } from "./agent-registry";
+import {
+	type AgentHistorySummary,
+	type AgentMetricsSummary,
+	type AgentRegistry,
+	getAgentTombstonePath,
+	MAIN_AGENT_ID,
+} from "./agent-registry";
+
+/** Maximum prefix entries inspected for task metadata. */
+const MAX_METADATA_LINES = 64;
+
+interface PersistedAgentMetadata {
+	activity?: string;
+	createdAt?: number;
+	lastActivity?: number;
+	history?: AgentHistorySummary;
+}
+
+interface PersistedTranscript {
+	id: string;
+	sessionFile: string;
+	createdAt?: number;
+	lastActivity?: number;
+}
+
+function recordOf(value: unknown): Record<string, unknown> | undefined {
+	return typeof value === "object" && value !== null && !Array.isArray(value)
+		? (value as Record<string, unknown>)
+		: undefined;
+}
+
+function timestampOf(value: unknown): number | undefined {
+	if (typeof value !== "string") return undefined;
+	const timestamp = Date.parse(value);
+	return Number.isFinite(timestamp) ? timestamp : undefined;
+}
+
+function summarizePersistedTask(task: string): string | undefined {
+	const withoutPreamble = task.replace(/^Complete the assignment below,\s*thoroughly:\s*/i, "");
+	const lines = withoutPreamble.split(/\r?\n/);
+	const targetIndex = lines.findIndex(line => line.trim().toLowerCase() === "# target");
+	const targetLines: string[] = [];
+	if (targetIndex >= 0) {
+		for (const line of lines.slice(targetIndex + 1)) {
+			if (line.trimStart().startsWith("# ")) break;
+			targetLines.push(line);
+		}
+	}
+	const summary = (targetLines.length > 0 ? targetLines : lines).join(" ").replace(/\s+/g, " ").trim();
+	return summary ? summary.slice(0, 1_000) : undefined;
+}
+
+function finiteNumber(value: unknown): number {
+	return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+function inferBundledAgent(systemPrompt: string): { agent?: string; modelRole?: string; readOnly?: boolean } {
+	const matches = loadBundledAgents().filter(agent => {
+		const rolePrompt = agent.systemPrompt.trim();
+		return rolePrompt.length > 0 && systemPrompt.includes(rolePrompt);
+	});
+	// `task` and `sonic` intentionally share a prompt body. Ambiguous historical
+	// prompts stay unlabelled rather than inventing provenance.
+	if (matches.length !== 1) return {};
+	const [agent] = matches;
+	return {
+		agent: agent.name,
+		modelRole: resolveExplicitModelRole(agent.model),
+		readOnly: isReadOnlyAgent(agent),
+	};
+}
+
+function usageTokens(usage: Record<string, unknown>): number {
+	const computed = finiteNumber(usage.input) + finiteNumber(usage.output) + finiteNumber(usage.cacheWrite);
+	return computed > 0 ? computed : finiteNumber(usage.totalTokens);
+}
+
+interface AssistantMetrics {
+	tokens: number;
+	tools: number;
+	cost: number;
+	contextTokens?: number;
+	resolvedModel?: string;
+}
+
+function assistantMetrics(message: Record<string, unknown>): AssistantMetrics {
+	const usage = recordOf(message.usage) ?? {};
+	const cost = recordOf(usage.cost);
+	const content = Array.isArray(message.content) ? message.content : [];
+	const provider = typeof message.provider === "string" ? message.provider : undefined;
+	const model = typeof message.model === "string" ? message.model : undefined;
+	return {
+		tokens: usageTokens(usage),
+		tools: content.filter(part => recordOf(part)?.type === "toolCall").length,
+		cost: finiteNumber(cost?.total),
+		contextTokens: finiteNumber(usage.totalTokens) || undefined,
+		resolvedModel: provider && model ? `${provider}/${model}` : undefined,
+	};
+}
+
+async function readPersistedAgentHistory(
+	transcript: PersistedTranscript,
+	shouldContinue: () => boolean,
+): Promise<AgentHistorySummary> {
+	const parents = new Map<string, string | undefined>();
+	const assistantById = new Map<string, AssistantMetrics>();
+	const modelChangeById = new Map<string, { model: string; role?: string; resolvedModelIsFallback: boolean }>();
+	let leafId: string | undefined;
+	let leafTimestamp: number | undefined;
+	try {
+		await visitEntriesFromFileStream(
+			transcript.sessionFile,
+			entry => {
+				const record = recordOf(entry);
+				if (!record) return;
+				const id = typeof record.id === "string" ? record.id : undefined;
+				if (!id) return;
+				const parentId = typeof record.parentId === "string" ? record.parentId : undefined;
+				parents.set(id, parentId);
+				leafId = id;
+				const parsedTimestamp = timestampOf(record.timestamp);
+				if (parsedTimestamp !== undefined) leafTimestamp = parsedTimestamp;
+				if (record.type === "model_change" && typeof record.model === "string") {
+					modelChangeById.set(id, {
+						model: record.model,
+						role: typeof record.role === "string" ? record.role : undefined,
+						resolvedModelIsFallback: record.resolvedModelIsFallback === true,
+					});
+					return;
+				}
+				if (record.type !== "message") return;
+				const message = recordOf(record.message);
+				if (message?.role === "assistant") assistantById.set(id, assistantMetrics(message));
+			},
+			{ shouldContinue },
+		);
+	} catch {
+		return {};
+	}
+
+	const metrics: AgentMetricsSummary = {
+		tokens: 0,
+		requests: 0,
+		tools: 0,
+		cost: 0,
+		durationMs: Math.max(
+			0,
+			(leafTimestamp ?? transcript.lastActivity ?? transcript.createdAt ?? 0) -
+				(transcript.createdAt ?? leafTimestamp ?? 0),
+		),
+		durationKind: "span",
+	};
+	let resolvedModel: string | undefined;
+	let resolvedModelIsFallback: boolean | undefined;
+	let modelRole: string | undefined;
+	let contextTokens: number | undefined;
+	let modelChangeFound = false;
+	const visited = new Set<string>();
+	for (let id = leafId; id && !visited.has(id); id = parents.get(id)) {
+		visited.add(id);
+		const modelChange = modelChangeById.get(id);
+		if (modelChange && !modelChangeFound) {
+			modelChangeFound = true;
+			resolvedModel = modelChange.model;
+			resolvedModelIsFallback = modelChange.resolvedModelIsFallback;
+			if (modelChange.role && modelChange.role !== EPHEMERAL_MODEL_CHANGE_ROLE) {
+				modelRole = modelChange.role;
+			}
+		}
+		const assistant = assistantById.get(id);
+		if (!assistant) continue;
+		if (!modelChangeFound && resolvedModel === undefined && assistant.resolvedModel) {
+			resolvedModel = assistant.resolvedModel;
+		}
+		metrics.requests++;
+		metrics.tokens += assistant.tokens;
+		metrics.tools += assistant.tools;
+		metrics.cost += assistant.cost;
+		contextTokens ??= assistant.contextTokens;
+	}
+	if (contextTokens !== undefined) metrics.contextTokens = contextTokens;
+	return {
+		...(metrics.requests > 0 ? { metrics } : {}),
+		...(resolvedModel ? { resolvedModel, resolvedModelIsFallback } : {}),
+		...(modelRole ? { modelRole } : {}),
+	};
+}
 
 /**
- * Child ids owned by the Vibe roster persisted in this session file. Vibe
- * workers are revived through the Vibe registry's own journal, so the generic
- * persisted-subagent scan must not register them as plain `sub` refs.
+ * Read only the small session prefix needed by the Hub. A subagent's first
+ * `session_init` is written before its conversation, so this never walks a
+ * multi-megabyte historical transcript just to populate one roster row.
  */
-async function readPersistedVibeChildIds(sessionFile: string): Promise<Set<string>> {
-	let sessionManager: SessionManager;
+async function readPersistedAgentMetadata(sessionFile: string): Promise<PersistedAgentMetadata> {
+	const stat = fs.promises.stat(sessionFile).catch(() => undefined);
+	const artifactBase = sessionFile.slice(0, -".jsonl".length);
+	const outputPath = `${artifactBase}.md`;
+	const patchPath = `${artifactBase}.patch`;
+	const artifactFiles = Promise.all([Bun.file(outputPath).exists(), Bun.file(patchPath).exists()]);
+	let createdAt: number | undefined;
+	let activity: string | undefined;
+	let history: AgentHistorySummary = {};
 	try {
-		sessionManager = await SessionManager.open(sessionFile, undefined, undefined, { suppressBreadcrumb: true });
+		await visitEntriesFromFileStream(
+			sessionFile,
+			entry => {
+				const record = recordOf(entry);
+				if (!record) return;
+				if (record.type === "session") {
+					createdAt ??= timestampOf(record.timestamp);
+					return;
+				}
+				if (record.type === "model_change") {
+					if (typeof record.model === "string") history.resolvedModel = record.model;
+					if (typeof record.role === "string" && record.role !== EPHEMERAL_MODEL_CHANGE_ROLE) {
+						history.modelRole = record.role;
+					}
+					if (typeof record.resolvedModelIsFallback === "boolean") {
+						history.resolvedModelIsFallback = record.resolvedModelIsFallback;
+					}
+					return;
+				}
+				if (record.type !== "session_init") return;
+				createdAt ??= timestampOf(record.timestamp);
+				if (typeof record.task === "string") activity = summarizePersistedTask(record.task);
+				const inferred = typeof record.systemPrompt === "string" ? inferBundledAgent(record.systemPrompt) : {};
+				history = {
+					...history,
+					...inferred,
+					agent: typeof record.agent === "string" ? record.agent : inferred.agent,
+					modelRole:
+						typeof record.modelRole === "string" ? record.modelRole : (history.modelRole ?? inferred.modelRole),
+					resolvedModel: typeof record.resolvedModel === "string" ? record.resolvedModel : history.resolvedModel,
+					readOnly: typeof record.readOnly === "boolean" ? record.readOnly : inferred.readOnly,
+				};
+				return false;
+			},
+			{ maxRecords: MAX_METADATA_LINES },
+		);
 	} catch {
-		return new Set();
+		// A readable transcript is still useful even when its optional metadata
+		// prefix is malformed.
 	}
+	const [file, [hasOutput, hasPatch]] = await Promise.all([stat, artifactFiles]);
+	return {
+		activity,
+		createdAt: createdAt ?? file?.birthtimeMs,
+		lastActivity: file?.mtimeMs,
+		history: {
+			...history,
+			...(hasOutput ? { outputPath } : {}),
+			...(hasPatch ? { patchPath } : {}),
+		},
+	};
+}
+
+async function readPersistedVibeChildIds(sessionFile: string, shouldContinue: () => boolean): Promise<Set<string>> {
+	const ids = new Set<string>();
 	try {
-		return persistedVibeChildIds(sessionManager.getEntries());
-	} finally {
-		await sessionManager.close();
+		await visitEntriesFromFileStream(
+			sessionFile,
+			entry => {
+				for (const id of persistedVibeChildIds([entry])) ids.add(id);
+			},
+			{ shouldContinue },
+		);
+		return ids;
+	} catch {
+		return new Set();
 	}
 }
 
@@ -28,11 +283,30 @@ async function readPersistedVibeChildIds(sessionFile: string): Promise<Set<strin
 export async function registerPersistedSubagents(
 	registry: AgentRegistry,
 	sessionFile: string | null | undefined,
+	options: { shouldContinue?: () => boolean } = {},
 ): Promise<void> {
 	if (!sessionFile?.endsWith(".jsonl")) return;
-	const vibeOwnedIds = await readPersistedVibeChildIds(sessionFile);
+	const shouldContinue = options.shouldContinue ?? (() => true);
+	if (!shouldContinue()) return;
+	const vibeOwnedIds = await readPersistedVibeChildIds(sessionFile, shouldContinue);
+	if (!shouldContinue()) return;
 	const root = sessionFile.slice(0, -6);
-	await registerPersistedSubagentsFromDir(registry, root, undefined, vibeOwnedIds);
+	const transcripts: PersistedTranscript[] = [];
+	await registerPersistedSubagentsFromDir(registry, root, undefined, vibeOwnedIds, transcripts, shouldContinue);
+	if (!shouldContinue()) return;
+	let nextTranscript = 0;
+	const workers = Array.from({ length: Math.min(4, transcripts.length) }, async () => {
+		for (;;) {
+			if (!shouldContinue()) return;
+			const index = nextTranscript++;
+			const transcript = transcripts[index];
+			if (!transcript) return;
+			const history = await readPersistedAgentHistory(transcript, shouldContinue);
+			if (!shouldContinue()) return;
+			registry.setHistory(transcript.id, history, transcript.sessionFile);
+		}
+	});
+	await Promise.all(workers);
 }
 
 async function registerPersistedSubagentsFromDir(
@@ -40,14 +314,25 @@ async function registerPersistedSubagentsFromDir(
 	dir: string,
 	parentId: string | undefined,
 	vibeOwnedIds: ReadonlySet<string>,
+	transcripts: PersistedTranscript[],
+	shouldContinue: () => boolean,
 ): Promise<void> {
+	if (!shouldContinue()) return;
 	let entries: fs.Dirent[];
 	try {
 		entries = await fs.promises.readdir(dir, { withFileTypes: true });
 	} catch {
 		return;
 	}
+	if (!shouldContinue()) return;
+	let entriesSinceYield = 0;
 	for (const entry of entries) {
+		if (!shouldContinue()) return;
+		if (++entriesSinceYield >= 16) {
+			entriesSinceYield = 0;
+			await Bun.sleep(0);
+		}
+		if (!shouldContinue()) return;
 		if (!entry.isFile() || !entry.name.endsWith(".jsonl") || entry.name.includes(".bak")) continue;
 		const sessionFile = path.join(dir, entry.name);
 		// The advisor transcript is observability-only: register it as a non-peer
@@ -66,6 +351,8 @@ async function registerPersistedSubagentsFromDir(
 			// user task literally named `<owner>/advisor`): leave it, skip the advisor.
 			if (existing && existing.kind !== "advisor") continue;
 			if (existing?.sessionFile !== sessionFile) {
+				const metadata = await readPersistedAgentMetadata(sessionFile);
+				if (!shouldContinue()) return;
 				// The id is reused across `/new`; refresh it to the current session's file.
 				if (existing) registry.unregister(advisorId);
 				registry.register({
@@ -75,14 +362,34 @@ async function registerPersistedSubagentsFromDir(
 					parentId: owner,
 					session: null,
 					sessionFile,
+					activity: metadata.activity,
+					createdAt: metadata.createdAt,
+					lastActivity: metadata.lastActivity,
+					history: { ...metadata.history, readOnly: true },
 					status: "parked",
 				});
+				transcripts.push({
+					id: advisorId,
+					sessionFile,
+					createdAt: metadata.createdAt,
+					lastActivity: metadata.lastActivity,
+				});
 			}
 			continue;
 		}
 		const id = entry.name.slice(0, -6);
 		if (vibeOwnedIds.has(id) && registry.get(id)?.sessionFile !== sessionFile) continue;
+		let tombstoned = false;
+		try {
+			await fs.promises.access(getAgentTombstonePath(sessionFile));
+			tombstoned = true;
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code !== "ENOENT") continue;
+		}
+		if (!shouldContinue()) return;
 		if (!registry.get(id)) {
+			const metadata = await readPersistedAgentMetadata(sessionFile);
+			if (!shouldContinue()) return;
 			registry.register({
 				id,
 				displayName: id,
@@ -90,9 +397,27 @@ async function registerPersistedSubagentsFromDir(
 				parentId: parentId ?? MAIN_AGENT_ID,
 				session: null,
 				sessionFile,
-				status: "parked",
+				activity: metadata.activity,
+				createdAt: metadata.createdAt,
+				lastActivity: metadata.lastActivity,
+				history: metadata.history,
+				status: tombstoned ? "aborted" : "parked",
+			});
+			const ref = registry.get(id);
+			transcripts.push({
+				id,
+				sessionFile,
+				createdAt: ref?.createdAt,
+				lastActivity: ref?.lastActivity,
 			});
 		}
-		await registerPersistedSubagentsFromDir(registry, path.join(dir, id), id, vibeOwnedIds);
+		await registerPersistedSubagentsFromDir(
+			registry,
+			path.join(dir, id),
+			id,
+			vibeOwnedIds,
+			transcripts,
+			shouldContinue,
+		);
 	}
 }

package/src/sdk.ts

@@ -123,18 +123,12 @@ import lateDiagnosticTemplate from "./prompts/tools/lsp-late-diagnostic.md" with
 import { AgentLifecycleManager } from "./registry/agent-lifecycle";
 import { type AgentRef, AgentRegistry, MAIN_AGENT_ID } from "./registry/agent-registry";
 import {
-	builtinCredentialSecretEntries,
-	collectEnvSecrets,
+	buildSecretObfuscator,
 	deobfuscateSessionContext,
 	deobfuscateToolArguments,
-	getExistingSecretPlaceholderKey,
-	getSecretPlaceholderKey,
-	getSecretPlaceholderKeySync,
-	loadSecrets,
 	obfuscateMessages,
 	obfuscateProviderContext,
-	SecretObfuscator,
-	secretEntriesNeedPlaceholderKey,
+	type SecretObfuscator,
 } from "./secrets";
 import { AgentSession, type InitialRetryFallbackState, type PlanYolo, type Prewalk } from "./session/agent-session";
 import { discoverAuthStorage as discoverAuthStorageFromConfig } from "./session/auth-broker-config";
@@ -1039,7 +1033,7 @@ function createCustomToolsExtension(tools: CustomTool[]): ExtensionFactory {
 					success: event.success,
 					attempt: event.attempt,
 					finalError: event.finalError,
-					recoveredErrors: event.recoveredErrors,
+					retryErrors: event.retryErrors,
 				},
 				ctx,
 			),
@@ -1377,46 +1371,9 @@ async function createAgentSessionScoped(options: CreateAgentSessionOptions): Pro
 
 	// Load and create secret obfuscator early so resumed session state and prompt warnings
 	// reflect actual loaded secrets, not just the setting toggle.
-	let obfuscator: SecretObfuscator | undefined;
-	if (settings.get("secrets.enabled")) {
-		const fileEntries = await logger.time("loadSecrets", loadSecrets, cwd, agentDir);
-		const envEntries = collectEnvSecrets();
-		// Built-in credential-pattern entries come last so user-configured entries
-		// (plain literals, custom regexes) take precedence in the scan order.
-		const allEntries = [...envEntries, ...fileEntries, ...builtinCredentialSecretEntries()];
-		// Only CONFIGURED entries force startup key creation: a configured
-		// obfuscate-mode secret — or a default (no custom `replacement`)
-		// replace-mode regex whose key-derived idempotent fallback marker needs a
-		// stable key across restarts (see `secretEntryNeedsPlaceholderKey`) —
-		// mints placeholders as soon as the obfuscator is built. The built-in
-		// credential-pattern entry matches dynamically, so it resolves the
-		// persisted key lazily on first match instead of creating the key file
-		// for every secrets.enabled session; a session whose content never
-		// contains a credential-shaped token must not require the key, otherwise a
-		// headless run on an unwritable default config root pays for a feature it
-		// does not use.
-		const needsPlaceholderKey = secretEntriesNeedPlaceholderKey([...envEntries, ...fileEntries]);
-		const explicitAgentDir = options.agentDir;
-		const placeholderKey = needsPlaceholderKey
-			? await getSecretPlaceholderKey(explicitAgentDir)
-			: await getExistingSecretPlaceholderKey(explicitAgentDir);
-		if (allEntries.length > 0) {
-			obfuscator = new SecretObfuscator(
-				allEntries,
-				placeholderKey ?? (() => getSecretPlaceholderKeySync(explicitAgentDir)),
-			);
-		}
-		if (obfuscator?.hasSecrets() !== true && placeholderKey !== undefined) {
-			// No configured entry produced an active secret (e.g. only ignored short
-			// plain entries, or no entries at all), but a persisted key exists. Build a
-			// redaction-only obfuscator so a tool read of the key file does not ship the
-			// reusable HMAC key to the provider.
-			obfuscator = new SecretObfuscator(
-				[{ type: "plain", mode: "replace", content: placeholderKey }],
-				placeholderKey,
-			);
-		}
-	}
+	const obfuscator: SecretObfuscator | undefined = settings.get("secrets.enabled")
+		? await buildSecretObfuscator(cwd, agentDir, options.agentDir)
+		: undefined;
 	const secretsEnabled = obfuscator?.hasSecrets() === true;
 
 	// An abnormal process exit after a non-terminal message tail is durable

package/src/secrets/index.ts

@@ -4,7 +4,13 @@ import * as path from "node:path";
 import { SENSITIVE_TOKEN_RE } from "@oh-my-pi/pi-ai/providers/transform-messages";
 import { getSecretPlaceholderKeyPath, isEnoent, logger } from "@oh-my-pi/pi-utils";
 import { YAML } from "bun";
-import { regexHasUnresolvableShortMatchFallback, type SecretEntry, sanitizeSecretFriendlyName } from "./obfuscator";
+import {
+	regexHasUnresolvableShortMatchFallback,
+	type SecretEntry,
+	SecretObfuscator,
+	sanitizeSecretFriendlyName,
+	secretEntriesNeedPlaceholderKey,
+} from "./obfuscator";
 import { compileSecretRegex } from "./regex";
 
 const PLACEHOLDER_KEY_RE = /^[A-Za-z0-9_-]{43}$/;
@@ -223,6 +229,51 @@ export function builtinCredentialSecretEntries(): SecretEntry[] {
 	];
 }
 
+/**
+ * Build the session secret obfuscator from every configured source: secrets.yml
+ * (project + global), secret-shaped environment variables, and the built-in
+ * credential patterns. Callers gate on `secrets.enabled`.
+ *
+ * Only CONFIGURED entries force startup key creation: a configured
+ * obfuscate-mode secret — or a default (no custom `replacement`) replace-mode
+ * regex whose key-derived idempotent fallback marker needs a stable key across
+ * restarts (see `secretEntryNeedsPlaceholderKey`) — mints placeholders as soon
+ * as the obfuscator is built. The built-in credential-pattern entry matches
+ * dynamically, so it resolves the persisted key lazily on first match instead
+ * of creating the key file for every secrets-enabled session.
+ *
+ * When no configured entry produced an active secret but a persisted key
+ * exists, returns a redaction-only obfuscator so a tool read of the key file
+ * does not ship the reusable HMAC key to the provider. Returns undefined when
+ * there is nothing to protect.
+ *
+ * `keyDir` is the explicit agent dir override for the placeholder-key file
+ * (default XDG/agent location when omitted).
+ */
+export async function buildSecretObfuscator(
+	cwd: string,
+	agentDir: string,
+	keyDir?: string,
+): Promise<SecretObfuscator | undefined> {
+	const fileEntries = await logger.time("loadSecrets", loadSecrets, cwd, agentDir);
+	const envEntries = collectEnvSecrets();
+	// Built-in credential-pattern entries come last so user-configured entries
+	// (plain literals, custom regexes) take precedence in the scan order.
+	const allEntries = [...envEntries, ...fileEntries, ...builtinCredentialSecretEntries()];
+	const needsPlaceholderKey = secretEntriesNeedPlaceholderKey([...envEntries, ...fileEntries]);
+	const placeholderKey = needsPlaceholderKey
+		? await getSecretPlaceholderKey(keyDir)
+		: await getExistingSecretPlaceholderKey(keyDir);
+	let obfuscator: SecretObfuscator | undefined;
+	if (allEntries.length > 0) {
+		obfuscator = new SecretObfuscator(allEntries, placeholderKey ?? (() => getSecretPlaceholderKeySync(keyDir)));
+	}
+	if (obfuscator?.hasSecrets() !== true && placeholderKey !== undefined) {
+		obfuscator = new SecretObfuscator([{ type: "plain", mode: "replace", content: placeholderKey }], placeholderKey);
+	}
+	return obfuscator;
+}
+
 async function loadSecretsFile(filePath: string): Promise<SecretEntry[]> {
 	try {
 		const text = await Bun.file(filePath).text();

package/src/session/agent-session-events.ts

@@ -2,7 +2,7 @@ import type { AgentEvent, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { CompactionResult } from "@oh-my-pi/pi-agent-core/compaction";
 import type { Effort } from "@oh-my-pi/pi-ai";
 import type { Rule } from "../capability/rule";
-import type { RecoveredRetryError } from "../extensibility/shared-events";
+import type { RetryErrorUpdate } from "../extensibility/shared-events";
 import type { Goal, GoalModeState } from "../goals/state";
 import type { ConfiguredThinkingLevel } from "../thinking";
 import type { TodoItem } from "../tools/todo";
@@ -43,7 +43,7 @@ export type AgentSessionEvent =
 			success: boolean;
 			attempt: number;
 			finalError?: string;
-			recoveredErrors?: RecoveredRetryError[];
+			retryErrors?: RetryErrorUpdate[];
 	  }
 	| { type: "retry_fallback_applied"; from: string; to: string; role: string }
 	| { type: "retry_fallback_succeeded"; model: string; role: string }