@prometheus-ai/agent 0.5.4 → 0.5.8

package/src/session/agent-storage.ts

@@ -4,6 +4,7 @@ import * as path from "node:path";
 import {
 	type AuthCredential,
 	type AuthCredentialStore,
+	isSqliteBusyError,
 	SqliteAuthCredentialStore,
 	type StoredAuthCredential,
 } from "@prometheus-ai/ai";
@@ -78,10 +79,14 @@ export class AgentStorage {
 	 * AuthCredentialStore handles auth_credentials and cache tables.
 	 */
 	#initializeSchema(): void {
+		// Install the busy handler BEFORE any lock-taking statement (incl.
+		// `PRAGMA journal_mode=WAL`, which acquires an exclusive lock during WAL
+		// recovery). Without this, concurrent prometheus startups can crash here with
+		// `SQLITE_BUSY` / `SQLITE_BUSY_RECOVERY`. See issue #2421.
+		this.#db.run("PRAGMA busy_timeout = 5000");
 		this.#db.run(`
 PRAGMA journal_mode=WAL;
 PRAGMA synchronous=NORMAL;
-PRAGMA busy_timeout=5000;
 
 CREATE TABLE IF NOT EXISTS model_usage (
 	model_key TEXT PRIMARY KEY,
@@ -208,7 +213,8 @@ FROM model_usage_legacy
 
 	/**
 	 * Returns singleton instance for the given database path, creating if needed.
-	 * Retries on SQLITE_BUSY with exponential backoff.
+	 * Retries on the `SQLITE_BUSY` family (including `SQLITE_BUSY_RECOVERY`) with
+	 * exponential backoff. See issue #2421.
 	 * @param dbPath - Path to the SQLite database file (defaults to config path)
 	 * @returns AgentStorage instance for the given path
 	 */
@@ -216,7 +222,7 @@ FROM model_usage_legacy
 		const existing = instances.get(dbPath);
 		if (existing) return existing;
 
-		const maxRetries = 3;
+		const maxRetries = 4;
 		const baseDelayMs = 100;
 		let lastError: Error | undefined;
 
@@ -226,17 +232,20 @@ FROM model_usage_legacy
 				instances.set(dbPath, storage);
 				return storage;
 			} catch (err) {
-				const isSqliteBusy = err && typeof err === "object" && (err as { code?: string }).code === "SQLITE_BUSY";
-				if (!isSqliteBusy) {
+				if (!isSqliteBusyError(err)) {
 					throw err;
 				}
-				lastError = err as Error;
-				const delayMs = baseDelayMs * 2 ** attempt;
-				await Bun.sleep(delayMs);
+				lastError = err instanceof Error ? err : new Error(String(err));
+				if (attempt < maxRetries - 1) {
+					await Bun.sleep(baseDelayMs * 2 ** attempt);
+				}
 			}
 		}
 
-		throw lastError ?? new Error("Failed to open database after retries");
+		throw new Error(
+			`Failed to open agent database at '${dbPath}' after ${maxRetries} attempts: ${lastError?.message}`,
+			{ cause: lastError },
+		);
 	}
 
 	/**

package/src/session/auth-broker-config.ts

@@ -65,13 +65,42 @@ async function readConfigYaml(): Promise<ConfigSnapshot> {
 	}
 }
 
+/**
+ * Process-lifetime memo for {@link resolveAuthBrokerConfig}. Keyed on the env
+ * inputs (plus agent dir, which decides which config.yml is read) so tests
+ * that flip `PROMETHEUS_AUTH_BROKER_*` between cases still observe the change, while
+ * repeated resolution within one CLI invocation (startup, subagent sessions)
+ * skips the config.yml read and any `!command` token resolution.
+ */
+let cachedConfigKey: string | null = null;
+let cachedConfigPromise: Promise<AuthBrokerClientConfig | null> | null = null;
+
 /**
  * Read broker configuration. Returns null when the URL is missing
  * (broker disabled — local store is used). Throws when URL is set but no
  * token is available — the caller cannot fall back silently because the
  * user explicitly asked to use the broker.
+ *
+ * Successful resolutions (including "no broker configured") are memoized for
+ * the process lifetime; failures are not, so a missing token can be fixed and
+ * retried. Concurrent callers share one in-flight resolution.
  */
-export async function resolveAuthBrokerConfig(): Promise<AuthBrokerClientConfig | null> {
+export function resolveAuthBrokerConfig(): Promise<AuthBrokerClientConfig | null> {
+	const key = `${process.env.PROMETHEUS_AUTH_BROKER_URL ?? ""}\u0000${process.env.PROMETHEUS_AUTH_BROKER_TOKEN ?? ""}\u0000${getAgentDir()}`;
+	if (cachedConfigPromise && cachedConfigKey === key) return cachedConfigPromise;
+	const promise = resolveAuthBrokerConfigUncached();
+	cachedConfigKey = key;
+	cachedConfigPromise = promise;
+	promise.catch(() => {
+		if (cachedConfigPromise === promise) {
+			cachedConfigPromise = null;
+			cachedConfigKey = null;
+		}
+	});
+	return promise;
+}
+
+async function resolveAuthBrokerConfigUncached(): Promise<AuthBrokerClientConfig | null> {
 	const envUrl = process.env.PROMETHEUS_AUTH_BROKER_URL;
 	const envToken = process.env.PROMETHEUS_AUTH_BROKER_TOKEN;
 

package/src/session/auth-storage.ts

@@ -10,7 +10,13 @@ export type {
 	AuthCredentialStore,
 	AuthStorageData,
 	AuthStorageOptions,
+	CredentialOrigin,
+	CredentialOriginKind,
+	OAuthAccountIdentity,
 	OAuthCredential,
+	ResetCreditAccountStatus,
+	ResetCreditRedeemOutcome,
+	ResetCreditTarget,
 	SerializedAuthStorage,
 	SnapshotResponse,
 	StoredAuthCredential,

package/src/session/codex-auto-reset.ts

@@ -0,0 +1,202 @@
+/**
+ * Pure decision predicate for auto-redeeming a saved OpenAI Codex rate-limit
+ * reset, plus the process-wide coordinator that serializes attempts.
+ *
+ * WHY THIS IS REACTIVE-ONLY (never proactive):
+ * The only trustworthy "blocked right now" signal is a live 429 /
+ * `usage_limit_reached` from a request authenticated as the session's active
+ * Codex credential. The session hook calls this predicate from the usage-limit
+ * branch of the retry pipeline, *after* free remedies (sibling-account switch)
+ * fail and *before* model fallback. A proactive surface (the status-line usage
+ * poll) cannot be used: at `used_percent < 100` the account is not actually
+ * limited, so redeeming would be a credit-wasting no-op; at exactly 100 the
+ * user may be idle, so the freshly-reset weekly window would tick away with
+ * nobody working. Saved resets are a scarce, ~monthly, effectively
+ * irreversible resource — every gate here is biased to precision over recall:
+ * we would rather miss a redeem than waste a credit.
+ *
+ * THE DECISION-2 TRAP (status MUST NOT be used to find the blocker):
+ * `openai-codex.ts` applies the top-level `rate_limit.limit_reached` flag to
+ * BOTH the primary (5h) and secondary (weekly) `buildUsageLimit` calls, so when
+ * an account is blocked, *both* limit entries carry `status: "exhausted"`
+ * regardless of which window is actually at 100%. Only `amount.usedFraction`
+ * disambiguates which window is the real blocker. This module therefore keys
+ * eligibility off exact limit ids (`openai-codex:primary` /
+ * `openai-codex:secondary`) and `usedFraction`, never off `status`.
+ *
+ * ANTI-WASTE GATES (in evaluation order): the policy must not be set to "no";
+ * the active model must be Codex (not Spark — a Spark block lives on a
+ * separate meter and it is unknown whether a credit even resets it); a fresh
+ * usage report for the active account must confirm `limitReached`; the WEEKLY
+ * (secondary) window must be genuinely exhausted — a 5h-only block self-heals
+ * within the hour, so a credit spent there buys nothing; the natural reset must be far
+ * enough away to justify spending a ~30-day credit yet within one plausible
+ * window length; a credit must be verifiably available above the reserve; and
+ * the same block episode must not have been attempted already (debounce +
+ * per-account cooldown). All of this is pure — no fetches, no IO. The only
+ * stateful piece is the {@link CodexAutoRedeemCoordinator} container, whose
+ * read-only views are passed in so the predicate itself stays deterministic.
+ */
+import type { OAuthAccountIdentity, ResetCreditTarget, UsageReport } from "@prometheus-ai/ai";
+import type { CodexAutoRedeemMode } from "../config/settings-schema";
+import { reportMatchesActiveAccount } from "../slash-commands/helpers/active-oauth-account";
+
+/** Weekly window counts as exhausted at `usedFraction >= 0.999` (used_percent >= 99.9). */
+export const WEEKLY_EXHAUSTED_MIN_FRACTION = 0.999;
+/** A weekly reset can never be more than one window length (7d) away; +1h slack for skew. */
+export const MAX_PLAUSIBLE_REMAINING_MS = 7 * 24 * 3_600_000 + 60 * 60_000;
+
+/** Report must be no older than the 5-min usage cache TTL plus slack. */
+export const REPORT_FRESHNESS_MS = 10 * 60_000;
+/** Per-account cooldown that catches blockKey drift across a minute boundary. */
+export const ATTEMPT_COOLDOWN_MS = 60_000;
+/** Minute bucket for blockKey, absorbing `reset_after_seconds`-derived jitter. */
+export const DEBOUNCE_BUCKET_MS = 60_000;
+
+export function shouldEvaluateCodexAutoRedeem(mode: CodexAutoRedeemMode): boolean {
+	return mode !== "no";
+}
+
+export function shouldPromptCodexAutoRedeem(mode: CodexAutoRedeemMode): boolean {
+	return mode === "unset";
+}
+
+export type CodexAutoRedeemSkipReason =
+	| "disabled"
+	| "wrong-provider"
+	| "spark-model"
+	| "no-identity"
+	| "no-report"
+	| "stale-report"
+	| "not-limit-reached"
+	| "weekly-not-exhausted"
+	| "no-reset-time"
+	| "reset-too-soon"
+	| "reset-implausible"
+	| "credits-unknown"
+	| "reserve"
+	| "already-attempted"
+	| "cooldown";
+
+export interface CodexAutoRedeemInput {
+	nowMs: number;
+	/** `this.model.provider`. */
+	provider: string;
+	/** `this.model.id`. */
+	modelId: string;
+	settings: { autoRedeem: boolean; minBlockedMinutes: number; keepCredits: number };
+	/** `getOAuthAccountIdentity("openai-codex", sessionId)`, captured at hook entry before any await. */
+	identity: OAuthAccountIdentity | undefined;
+	/** `session.fetchUsageReports()` (≤5-min cache). */
+	reports: UsageReport[] | null;
+	attemptedBlockKeys: ReadonlySet<string>;
+	lastAttemptAtByAccount: ReadonlyMap<string, number>;
+}
+
+export interface CodexAutoRedeemRedeemDecision {
+	redeem: true;
+	target: ResetCreditTarget;
+	accountKey: string;
+	blockKey: string;
+	weeklyResetAtMs: number;
+	remainingMs: number;
+	availableCount: number;
+}
+
+export type CodexAutoRedeemDecision =
+	| CodexAutoRedeemRedeemDecision
+	| { redeem: false; reason: CodexAutoRedeemSkipReason };
+
+/** Trimmed lowercase, or undefined when blank. Mirrors `normalizeIdentityValue` in active-oauth-account.ts. */
+function normalize(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim() ? value.trim().toLowerCase() : undefined;
+}
+
+/**
+ * Decide whether to auto-redeem a saved Codex reset for the active account.
+ *
+ * Pure: every gate below is a function of the snapshot inputs only. Order
+ * matters — cheapest / most-decisive gates first so the common "not eligible"
+ * paths short-circuit before any account/report matching.
+ */
+export function evaluateCodexAutoRedeem(input: CodexAutoRedeemInput): CodexAutoRedeemDecision {
+	const { nowMs, settings } = input;
+	if (!settings.autoRedeem) return { redeem: false, reason: "disabled" };
+	if (input.provider !== "openai-codex") return { redeem: false, reason: "wrong-provider" };
+	// Unknown #1: it is unknown whether a credit resets the separate Spark meter.
+	if (input.modelId.includes("-spark")) return { redeem: false, reason: "spark-model" };
+
+	const accountKey = normalize(input.identity?.accountId) ?? normalize(input.identity?.email);
+	if (!accountKey) return { redeem: false, reason: "no-identity" };
+
+	const report = input.reports?.find(
+		r => r.provider === "openai-codex" && reportMatchesActiveAccount(r, input.identity),
+	);
+	if (!report) return { redeem: false, reason: "no-report" };
+	if (nowMs - report.fetchedAt > REPORT_FRESHNESS_MS) return { redeem: false, reason: "stale-report" };
+	// The wire's own blocked flag must confirm the 429.
+	if (report.metadata?.limitReached !== true) return { redeem: false, reason: "not-limit-reached" };
+
+	// EXACT ids — never `status` (see the Decision-2 trap in the module docs).
+	// The saved reset applies to the WEEKLY window, so that is the blocker we act
+	// on. A 5h-only block (weekly still has headroom) self-heals within the hour,
+	// so spending a scarce ~monthly credit there would be wasted.
+	const weekly = report.limits.find(l => l.id === "openai-codex:secondary");
+	const wUsed = weekly?.amount.usedFraction;
+	if (!weekly || wUsed === undefined || wUsed < WEEKLY_EXHAUSTED_MIN_FRACTION) {
+		return { redeem: false, reason: "weekly-not-exhausted" };
+	}
+
+	const resetsAt = weekly.window?.resetsAt;
+	if (resetsAt === undefined) return { redeem: false, reason: "no-reset-time" };
+	const remainingMs = resetsAt - nowMs;
+	// anti-waste: too close to the natural reset — let it roll over instead of spending a credit.
+	if (remainingMs < settings.minBlockedMinutes * 60_000) return { redeem: false, reason: "reset-too-soon" };
+	if (remainingMs > MAX_PLAUSIBLE_REMAINING_MS) return { redeem: false, reason: "reset-implausible" };
+
+	const available = report.resetCredits?.availableCount;
+	// can't verify availability from the snapshot → don't spend (precision over recall).
+	if (available === undefined) return { redeem: false, reason: "credits-unknown" };
+	if (available - Math.max(0, Math.trunc(settings.keepCredits)) < 1) {
+		return { redeem: false, reason: "reserve" };
+	}
+
+	const blockKey = `${accountKey}|${Math.round(resetsAt / DEBOUNCE_BUCKET_MS)}`;
+	if (input.attemptedBlockKeys.has(blockKey)) return { redeem: false, reason: "already-attempted" };
+	const lastAt = input.lastAttemptAtByAccount.get(accountKey);
+	if (lastAt !== undefined && nowMs - lastAt < ATTEMPT_COOLDOWN_MS) return { redeem: false, reason: "cooldown" };
+
+	return {
+		redeem: true,
+		target: { accountId: input.identity?.accountId, email: input.identity?.email },
+		accountKey,
+		blockKey,
+		weeklyResetAtMs: resetsAt,
+		remainingMs,
+		availableCount: available,
+	};
+}
+
+/**
+ * Process-wide (NOT per-session) coordinator state. Parallel subagent sessions
+ * share the same Codex accounts and must not race a double-spend, so this is a
+ * single shared container, not a per-session field.
+ *
+ * - `attemptedBlockKeys`: one attempt EVER per block episode, regardless of
+ *   outcome — recorded before calling the consume so exceptions can't re-enter.
+ * - `lastAttemptAtByAccount`: per-account cooldown timestamps (epoch ms),
+ *   catching blockKey drift across a minute boundary.
+ * - `inFlightByAccount`: serializes per account — a second session for the same
+ *   account adopts the in-flight promise instead of starting a second consume.
+ */
+export interface CodexAutoRedeemCoordinator {
+	attemptedBlockKeys: Set<string>;
+	lastAttemptAtByAccount: Map<string, number>;
+	inFlightByAccount: Map<string, Promise<boolean>>;
+}
+
+export const defaultCodexAutoRedeemCoordinator: CodexAutoRedeemCoordinator = {
+	attemptedBlockKeys: new Set(),
+	lastAttemptAtByAccount: new Map(),
+	inFlightByAccount: new Map(),
+};

package/src/session/history-storage.ts

@@ -84,12 +84,13 @@ export class HistoryStorage {
 
 		this.#db = new Database(dbPath);
 
-		const hasFts = this.#db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='history_fts'").get();
+		// Install the busy handler BEFORE any lock-taking statement. See #2421.
+		this.#db.run("PRAGMA busy_timeout = 5000");
 
+		const hasFts = this.#db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='history_fts'").get();
 		this.#db.run(`
 PRAGMA journal_mode=WAL;
 PRAGMA synchronous=NORMAL;
-PRAGMA busy_timeout=5000;
 
 CREATE TABLE IF NOT EXISTS history (
 	id INTEGER PRIMARY KEY AUTOINCREMENT,

package/src/session/indexed-session-storage.ts

@@ -173,6 +173,10 @@ export class IndexedSessionStorage implements SessionStorage {
 		}
 	}
 
+	writeTextAtomic(path: string, content: string): Promise<void> {
+		return this.writeText(path, content);
+	}
+
 	async rename(src: string, dst: string): Promise<void> {
 		await this.#awaitPath(src);
 		await this.#awaitPath(dst);
@@ -390,14 +394,7 @@ class IndexedSessionStorageWriter implements SessionStorageWriter {
 		return next;
 	}
 
-	writeLineSync(line: string): void {
-		if (this.#closed) throw new Error("Writer closed");
-		if (this.#error) throw this.#error;
-		const mtimeMs = this.#storage._appendForWriter(this.#path, line);
-		this.#trackPromise(this.#storage._queueAppend(this.#path, line, mtimeMs, () => this.#error));
-	}
-
-	async writeLine(line: string): Promise<void> {
+	async append(line: string): Promise<void> {
 		if (this.#closed) throw new Error("Writer closed");
 		if (this.#error) throw this.#error;
 		const mtimeMs = this.#storage._appendForWriter(this.#path, line);
@@ -410,8 +407,8 @@ class IndexedSessionStorageWriter implements SessionStorageWriter {
 		if (this.#error) throw this.#error;
 	}
 
-	async fsync(): Promise<void> {
-		await this.flush();
+	isOpen(): boolean {
+		return !this.#closed;
 	}
 
 	async close(): Promise<void> {

package/src/session/messages.ts

@@ -8,8 +8,7 @@ import type { AgentMessage } from "@prometheus-ai/agent-core";
 import {
 	type BranchSummaryMessage,
 	type CompactionSummaryMessage,
-	renderBranchSummaryContext,
-	renderCompactionSummaryContext,
+	convertMessageToLlm,
 } from "@prometheus-ai/agent-core/compaction/messages";
 import type {
 	AssistantMessage,
@@ -17,7 +16,6 @@ import type {
 	Message,
 	MessageAttribution,
 	TextContent,
-	ToolResultMessage,
 	UserMessage,
 } from "@prometheus-ai/ai";
 import { prompt } from "@prometheus-ai/utils";
@@ -28,25 +26,25 @@ export {
 	type CompactionSummaryMessage,
 	createBranchSummaryMessage,
 	createCompactionSummaryMessage,
+	createCustomMessage,
 } from "@prometheus-ai/agent-core/compaction/messages";
 
 import type { OutputMeta } from "../tools/output-meta";
 import { formatOutputNotice } from "../tools/output-meta";
 
 export const SKILL_PROMPT_MESSAGE_TYPE = "skill-prompt";
+export const LSP_LATE_DIAGNOSTIC_MESSAGE_TYPE = "lsp-late-diagnostic";
 
 export interface SkillPromptDetails {
 	name: string;
 	path: string;
 	args?: string;
 	lineCount: number;
-	/** Internal: tag used by AgentSession to remove the pending-display chip
-	 *  from `#steeringMessages` / `#followUpMessages` when the agent consumes
-	 *  this message. Not surfaced to renderers; the `__` prefix signals
-	 *  "private". Optional — non-streaming skill prompts never set it. Stripped
-	 *  from persisted `details` by `SessionManager.appendCustomMessageEntry`
-	 *  via the `INTERNAL_DETAILS_FIELDS` allowlist below. */
-	__pendingDisplayTag?: string;
+	/** Internal: compact label shown for a queued custom message. Optional —
+	 *  non-streaming skill prompts never set it. Stripped from persisted
+	 *  `details` by `SessionManager.appendCustomMessageEntry` via the
+	 *  `INTERNAL_DETAILS_FIELDS` allowlist below. */
+	__queueChipText?: string;
 }
 
 /** Sentinel value for `AssistantMessage.errorMessage` indicating that the abort
@@ -58,10 +56,10 @@ export interface SkillPromptDetails {
  *
  *  Consumers: `AgentSession.#handleAgentEvent` (stamper) writes this value;
  *  `EventController.#handleMessageEnd`, `AssistantMessageComponent`,
- *  `ui-helpers.addMessageToChat` (renderers), `SessionObserverOverlay
+ *  `ui-helpers.addMessageToChat` (renderers), `AgentHubOverlayComponent
  *  #buildTranscriptLines`, `runPrintMode`, and `AcpAgent#replayAssistantMessage`
  *  (fallback error emission) read it via `isSilentAbort`. */
-export const SILENT_ABORT_MARKER = "__prometheus.silent_abort__";
+export const SILENT_ABORT_MARKER = "__omp.silent_abort__";
 
 /** Type-guard for `SILENT_ABORT_MARKER`. Renderers MUST branch on this rather
  *  than string-comparing inline so refactors to the marker constant (e.g.,
@@ -70,12 +68,46 @@ export function isSilentAbort(errorMessage: string | undefined): boolean {
 	return errorMessage === SILENT_ABORT_MARKER;
 }
 
-/** Extract the optional `__pendingDisplayTag` field from a CustomMessage's
+/** Reason threaded through `AbortController.abort(reason)` when the user aborts
+ *  the turn with Esc (see `AgentSession.abort`). The agent keeps it on the
+ *  aborted assistant message's `errorMessage` so queued follow-ups/tool-result
+ *  placeholders can distinguish a deliberate interrupt from a bare lifecycle
+ *  abort, but interactive renderers suppress this redundant transcript line. */
+export const USER_INTERRUPT_LABEL = "Interrupted by user";
+
+export function isUserInterruptAbort(errorMessage: string | undefined): boolean {
+	return errorMessage === USER_INTERRUPT_LABEL;
+}
+
+export function shouldRenderAbortReason(errorMessage: string | undefined): boolean {
+	return !isSilentAbort(errorMessage) && !isUserInterruptAbort(errorMessage);
+}
+
+/** Sentinel `errorMessage` the agent stamps on any abort that carried no custom
+ *  reason (bare `abort()`). Renderers treat it as "no specific reason given". */
+const GENERIC_ABORT_SENTINEL = "Request was aborted";
+
+/** Resolve the operator-facing label for an aborted assistant turn. A custom
+ *  abort reason threaded onto `errorMessage` is returned verbatim; aborts with
+ *  no threaded reason fall back to the retry-aware generic label. Call
+ *  `shouldRenderAbortReason` before rendering when user interrupts should stay
+ *  visually quiet. */
+export function resolveAbortLabel(errorMessage: string | undefined, retryAttempt = 0): string {
+	if (errorMessage && errorMessage !== GENERIC_ABORT_SENTINEL && !isSilentAbort(errorMessage)) {
+		return errorMessage;
+	}
+	if (retryAttempt > 0) {
+		return `Aborted after ${retryAttempt} retry attempt${retryAttempt > 1 ? "s" : ""}`;
+	}
+	return "Operation aborted";
+}
+
+/** Extract the optional `__queueChipText` field from a CustomMessage's
  *  `details` blob. Safe over `unknown`; returns undefined when the field is
  *  absent or non-string. */
-export function readPendingDisplayTag(details: unknown): string | undefined {
+export function readQueueChipText(details: unknown): string | undefined {
 	if (typeof details !== "object" || details === null) return undefined;
-	const candidate = (details as { __pendingDisplayTag?: unknown }).__pendingDisplayTag;
+	const candidate = (details as { __queueChipText?: unknown }).__queueChipText;
 	return typeof candidate === "string" ? candidate : undefined;
 }
 
@@ -84,7 +116,7 @@ export function readPendingDisplayTag(details: unknown): string | undefined {
  *  the CustomMessageEntry to disk. Scoped intentionally narrow: only fields
  *  declared here are stripped. Adding a new entry is a deliberate, reviewed
  *  change — unrelated future payload fields are never silently dropped. */
-export const INTERNAL_DETAILS_FIELDS = ["__pendingDisplayTag"] as const;
+export const INTERNAL_DETAILS_FIELDS = ["__queueChipText"] as const;
 
 /** Return a `details` copy with every key in `INTERNAL_DETAILS_FIELDS`
  *  removed. Returns the input unchanged when there is nothing to strip
@@ -185,15 +217,6 @@ export function wrapSteeringForModel(messages: AgentMessage[]): AgentMessage[] {
 	return wrappedMessages ?? messages;
 }
 
-function getPrunedToolResultContent(message: ToolResultMessage): (TextContent | ImageContent)[] {
-	if (message.prunedAt === undefined) {
-		return message.content;
-	}
-	const textBlocks = message.content.filter((content): content is TextContent => content.type === "text");
-	const text = textBlocks.map(block => block.text).join("") || "[Output truncated]";
-	return [{ type: "text", text }];
-}
-
 /** Result of filtering image blocks out of a `(TextContent | ImageContent)[]` array. */
 interface StripContentResult {
 	content: (TextContent | ImageContent)[];
@@ -443,26 +466,6 @@ export function sanitizeRehydratedOpenAIResponsesAssistantMessage(message: Assis
 	};
 }
 
-/** Convert CustomMessageEntry to AgentMessage format */
-export function createCustomMessage(
-	customType: string,
-	content: string | (TextContent | ImageContent)[],
-	display: boolean,
-	details: unknown | undefined,
-	timestamp: string,
-	attribution?: MessageAttribution,
-): CustomMessage {
-	return {
-		role: "custom",
-		customType,
-		content,
-		display,
-		details,
-		attribution,
-		timestamp: new Date(timestamp).getTime(),
-	};
-}
-
 /**
  * Transform AgentMessages (including custom types) to LLM-compatible Messages.
  *
@@ -495,77 +498,38 @@ export function convertToLlm(messages: AgentMessage[]): Message[] {
 						attribution: "user",
 						timestamp: m.timestamp,
 					};
-				case "custom":
-				case "hookMessage": {
-					const content = typeof m.content === "string" ? [{ type: "text" as const, text: m.content }] : m.content;
-					const role = "user";
-					const attribution = m.attribution;
-					return {
-						role,
-						content,
-						attribution,
-						timestamp: m.timestamp,
-					};
-				}
-				case "branchSummary":
-					return {
-						role: "user",
-						content: [
-							{
-								type: "text" as const,
-								text: renderBranchSummaryContext(m.summary),
-							},
-						],
-						attribution: "agent",
-						timestamp: m.timestamp,
-					};
-				case "compactionSummary":
-					return {
-						role: "user",
-						content: [
-							{
-								type: "text" as const,
-								text: renderCompactionSummaryContext(m.summary),
-							},
-						],
-						attribution: "agent",
-						providerPayload: m.providerPayload,
-						timestamp: m.timestamp,
-					};
 				case "fileMention": {
 					const fileContents = m.files
 						.map(file => {
 							const inner = file.content ? `\n${file.content}\n` : "\n";
 							return `<file path="${file.path}">${inner}</file>`;
 						})
-						.join("\n\n");
-					const content: (TextContent | ImageContent)[] = [
-						{ type: "text" as const, text: `<system-reminder>\n${fileContents}\n</system-reminder>` },
-					];
+						.join("\n");
+					const content: (TextContent | ImageContent)[] = [{ type: "text" as const, text: fileContents }];
 					for (const file of m.files) {
 						if (file.image) {
 							content.push(file.image);
 						}
 					}
 					return {
-						role: "user",
+						role: "developer",
 						content,
 						attribution: "user",
 						timestamp: m.timestamp,
 					};
 				}
+				case "custom":
+				case "hookMessage":
+				case "branchSummary":
+				case "compactionSummary":
 				case "user":
-					return { ...m, attribution: m.attribution ?? "user" };
 				case "developer":
-					return { ...m, attribution: m.attribution ?? "agent" };
 				case "assistant":
-					return m;
 				case "toolResult":
-					return {
-						...m,
-						content: getPrunedToolResultContent(m as ToolResultMessage),
-						attribution: m.attribution ?? "agent",
-					};
+					// Core roles share one transformer with agent-core —
+					// duplicating them here is how snapcompact frames once
+					// silently fell off the provider request.
+					return convertMessageToLlm(m);
 				default:
 					m satisfies never;
 					return undefined;