@gajae-code/coding-agent 0.15.5 → 0.16.0

package/src/modes/controllers/selector-controller.ts

@@ -4,6 +4,8 @@ import {
 	type Api,
 	type AuthCredentialSelector,
 	type CredentialRemovalTarget,
+	isSqliteCorruptionError,
+	isSqliteError,
 	type Model,
 	resolveOAuthStorageProvider,
 } from "@gajae-code/ai/core";
@@ -106,6 +108,7 @@ import { TelegramDaemonController } from "../../sdk/bus/telegram-daemon-control"
 import { runTelegramSetup, type TelegramSetupPreflight } from "../../sdk/bus/telegram-setup";
 import { clearPersistentPinForRemovedRows } from "../../session/account-inventory";
 import type { DefaultFallbackRuntimeState } from "../../session/agent-session";
+import { CREDENTIAL_STORE_UNREADABLE_MESSAGE } from "../../session/credential-store-errors";
 import { type SessionInfo, SessionManager } from "../../session/session-manager";
 import { getTreeForInternalRead } from "../../session/session-manager-internal";
 import { FileSessionStorage } from "../../session/session-storage";
@@ -125,6 +128,12 @@ import {
 	logCredentialAutoImportFailures,
 	runExternalCredentialAutoImport,
 } from "../../setup/credential-auto-import";
+
+function credentialStoreOperationError(action: "Login" | "Logout", error: unknown): string {
+	const code = error && typeof error === "object" ? (error as { code?: unknown }).code : undefined;
+	return `${action} failed: credential store operation failed${typeof code === "string" ? ` (${code})` : ""}.`;
+}
+
 import {
 	filterAutoImportOAuthCredentials,
 	formatDiscoverySummary,
@@ -172,6 +181,7 @@ import {
 	FrictionlessOnboardingSelectorComponent,
 	type FrictionlessOnboardingStage,
 	getFrictionlessOnboardingCopy,
+	InterfaceLanguageSelectorComponent,
 } from "../components/frictionless-onboarding-selector";
 import type { PetMode } from "../components/gajae-pet-widget";
 import { HistorySearchComponent } from "../components/history-search";
@@ -216,6 +226,7 @@ import type { SessionObserverRegistry } from "../session-observer-registry";
 import { buildOAuthLoginAnchor, createOAuthUrlCopyLease } from "../shared/oauth-url-copy";
 import type { TasksAggregator } from "../tasks-aggregator";
 import type { TranscriptItemRegistry } from "../transcript-item-registry";
+import { resolveExplicitUiLanguage, type UiLanguage } from "../ui-language";
 import { acquireResumeProgressLease, type ResumeProgressLease } from "../utils/ui-helpers";
 
 const CALLBACK_SERVER_PROVIDERS = new Set<string>([
@@ -1366,11 +1377,16 @@ export class SelectorController {
 	async #refreshOAuthProviderAuthState(): Promise<void> {
 		const oauthProviders = getOAuthProviders();
 		await Promise.all(
-			oauthProviders.map(provider =>
-				this.ctx.session.modelRegistry
-					.getApiKeyForProvider(provider.id, this.ctx.session.credentialSessionId)
-					.catch(() => undefined),
-			),
+			oauthProviders.map(async provider => {
+				try {
+					await this.ctx.session.modelRegistry.getApiKeyForProvider(
+						provider.id,
+						this.ctx.session.credentialSessionId,
+					);
+				} catch (error) {
+					if (isSqliteError(error)) throw error;
+				}
+			}),
 		);
 	}
 	/**
@@ -1469,11 +1485,57 @@ export class SelectorController {
 
 	async showFrictionlessOnboarding(): Promise<void> {
 		const agentDir = this.ctx.session.getSessionAgentDir();
+		const languagePreference = resolveExplicitUiLanguage(
+			this.ctx.settings.has("ui.language") ? this.ctx.settings.get("ui.language") : undefined,
+			process.env.GJC_UI_LANGUAGE,
+		);
+		let selectedLanguage: UiLanguage = languagePreference.language;
+		if (!languagePreference.hasPreference && this.ctx.settings.canPersistDurableConfig()) {
+			const decision = Promise.withResolvers<UiLanguage | undefined>();
+			let settled = false;
+			let unregisterStop: (() => void) | undefined;
+			const finish = (language: UiLanguage | undefined): void => {
+				if (settled) return;
+				settled = true;
+				unregisterStop?.();
+				decision.resolve(language);
+			};
+			this.showSelector(done => {
+				unregisterStop = this.ctx.onStop(() => {
+					done();
+					finish(undefined);
+				});
+				const selector = new InterfaceLanguageSelectorComponent(
+					language => {
+						done();
+						finish(language);
+					},
+					() => {
+						done();
+						finish(undefined);
+					},
+				);
+				return { component: selector, focus: selector };
+			});
+			selectedLanguage = (await decision.promise) ?? "en";
+			try {
+				await this.ctx.settings.commitAtomicBatch([{ path: "ui.language", op: "set", value: selectedLanguage }]);
+			} catch (error) {
+				this.ctx.showError(
+					error instanceof Error
+						? `${error.message}; continuing in English.`
+						: "Cannot save the interface language; continuing in English.",
+				);
+				selectedLanguage = "en";
+			}
+		} else if (!languagePreference.hasPreference) {
+			this.ctx.showError("Cannot save the interface language; continuing in English.");
+		}
 		const presence = await discoverOnboardingRootPresence();
 		// An explicit `/language` (or settings) selection outranks locale and transcript evidence.
 		const profileOptions = {
 			osLocale: Intl.DateTimeFormat().resolvedOptions().locale,
-			...(this.ctx.settings.has("ui.language") ? { preferredLanguage: this.ctx.settings.get("ui.language") } : {}),
+			preferredLanguage: selectedLanguage,
 		};
 		const initialProfile = deriveOnboardingProfile([], profileOptions);
 
@@ -3557,7 +3619,8 @@ export class SelectorController {
 			}
 			this.ctx.ui.requestRender();
 		} catch (error: unknown) {
-			this.ctx.showError(`Login failed: ${error instanceof Error ? error.message : String(error)}`);
+			if (isSqliteCorruptionError(error)) this.ctx.showError(CREDENTIAL_STORE_UNREADABLE_MESSAGE);
+			else this.ctx.showError(`Login failed: ${error instanceof Error ? error.message : String(error)}`);
 		} finally {
 			oauthUrlCopyLease.release();
 			if (useManualInput) {
@@ -3599,7 +3662,8 @@ export class SelectorController {
 				`Successfully removed ${result.ids.length} stored credential${result.ids.length === 1 ? "" : "s"} from ${providerId}.`,
 			);
 		} catch (error: unknown) {
-			this.ctx.showError(`Logout failed: ${error instanceof Error ? error.message : String(error)}`);
+			if (isSqliteCorruptionError(error)) this.ctx.showError(CREDENTIAL_STORE_UNREADABLE_MESSAGE);
+			else this.ctx.showError(`Logout failed: ${error instanceof Error ? error.message : String(error)}`);
 		}
 	}
 
@@ -3616,75 +3680,90 @@ export class SelectorController {
 				return;
 			}
 			const authStorage = this.ctx.session.modelRegistry.authStorage;
-			const hasOAuthInventory = authStorage
-				.listCredentialInventory(selectedProviderId)
-				.some(row => row.provider === selectedProviderId && row.credentialKind === "oauth");
-			const hasRemovableCredential = authStorage
-				.listCredentialRemovalTargets(selectedProviderId)
-				.some(target => target.provider === selectedProviderId);
-			if (mode === "logout" && hasOAuthInventory && !hasRemovableCredential) {
-				await this.#handleLogout(selectedProviderId);
-				return;
-			}
-			if (hasOAuthInventory && !options?.manualCode) {
-				this.showSelector(done => {
-					let selector: OAuthSelectorComponent;
-					selector = new OAuthSelectorComponent(
-						mode,
-						authStorage,
-						() => undefined,
-						() => {
-							selector.stopValidation();
-							done();
-							this.ctx.ui.requestRender();
-						},
-						{
-							accountProviderId: selectedProviderId,
-							onAccountSelect: async (selectorValue: AuthCredentialSelector) => {
-								await this.ctx.session.setCredentialPin(selectedProviderId, selectorValue);
-								selector.stopValidation();
-								done();
-								this.ctx.showStatus(`Pinned OAuth account for ${selectedProviderId} to this session.`);
-							},
-							onAutoSelect: async () => {
-								await this.ctx.session.setCredentialAuto(selectedProviderId);
-								selector.stopValidation();
-								done();
-								this.ctx.showStatus(`Using AUTO (ranked) OAuth accounts for ${selectedProviderId}.`);
-							},
-							onAddAccount: async () => {
+			try {
+				const hasOAuthInventory = authStorage
+					.listCredentialInventory(selectedProviderId)
+					.some(row => row.provider === selectedProviderId && row.credentialKind === "oauth");
+				const hasRemovableCredential = authStorage
+					.listCredentialRemovalTargets(selectedProviderId)
+					.some(target => target.provider === selectedProviderId);
+				if (mode === "logout" && hasOAuthInventory && !hasRemovableCredential) {
+					await this.#handleLogout(selectedProviderId);
+					return;
+				}
+				if (hasOAuthInventory && !options?.manualCode) {
+					this.showSelector(done => {
+						let selector: OAuthSelectorComponent;
+						selector = new OAuthSelectorComponent(
+							mode,
+							authStorage,
+							() => undefined,
+							() => {
 								selector.stopValidation();
 								done();
-								await this.#handleOAuthLogin(selectedProviderId, options);
+								this.ctx.ui.requestRender();
 							},
-							onAccountRemove: async targets => {
-								await this.#handleLogout(selectedProviderId, targets);
-								selector.stopValidation();
-								done();
+							{
+								accountProviderId: selectedProviderId,
+								onAccountSelect: async (selectorValue: AuthCredentialSelector) => {
+									await this.ctx.session.setCredentialPin(selectedProviderId, selectorValue);
+									selector.stopValidation();
+									done();
+									this.ctx.showStatus(`Pinned OAuth account for ${selectedProviderId} to this session.`);
+								},
+								onAutoSelect: async () => {
+									await this.ctx.session.setCredentialAuto(selectedProviderId);
+									selector.stopValidation();
+									done();
+									this.ctx.showStatus(`Using AUTO (ranked) OAuth accounts for ${selectedProviderId}.`);
+								},
+								onAddAccount: async () => {
+									selector.stopValidation();
+									done();
+									await this.#handleOAuthLogin(selectedProviderId, options);
+								},
+								onAccountRemove: async targets => {
+									await this.#handleLogout(selectedProviderId, targets);
+									selector.stopValidation();
+									done();
+								},
 							},
-						},
-					);
-					return { component: selector, focus: selector };
-				});
+						);
+						return { component: selector, focus: selector };
+					});
+					return;
+				}
+				if (mode === "login") {
+					await this.#handleOAuthLogin(selectedProviderId, options);
+					return;
+				}
+				// mode === "logout" with no OAuth accounts: remove stored api-key credentials directly.
+				await this.#handleLogout(selectedProviderId);
 				return;
-			}
-			if (mode === "login") {
-				await this.#handleOAuthLogin(selectedProviderId, options);
+			} catch (error: unknown) {
+				if (isSqliteCorruptionError(error)) this.ctx.showError(CREDENTIAL_STORE_UNREADABLE_MESSAGE);
+				else if (isSqliteError(error))
+					this.ctx.showError(credentialStoreOperationError(mode === "login" ? "Login" : "Logout", error));
+				else throw error;
 				return;
 			}
-			// mode === "logout" with no OAuth accounts: remove stored api-key credentials directly.
-			await this.#handleLogout(selectedProviderId);
-			return;
 		}
 
 		if (mode === "logout") {
-			await this.#refreshOAuthProviderAuthState();
-			const oauthProviders = getOAuthProviders();
-			const loggedInProviders = oauthProviders.filter(provider =>
-				this.ctx.session.modelRegistry.authStorage.hasAuth(provider.id),
-			);
-			if (loggedInProviders.length === 0) {
-				this.ctx.showStatus("No OAuth providers logged in. Use /login first.");
+			try {
+				await this.#refreshOAuthProviderAuthState();
+				const oauthProviders = getOAuthProviders();
+				const loggedInProviders = oauthProviders.filter(provider =>
+					this.ctx.session.modelRegistry.authStorage.hasAuth(provider.id),
+				);
+				if (loggedInProviders.length === 0) {
+					this.ctx.showStatus("No OAuth providers logged in. Use /login first.");
+					return;
+				}
+			} catch (error: unknown) {
+				if (isSqliteCorruptionError(error)) this.ctx.showError(CREDENTIAL_STORE_UNREADABLE_MESSAGE);
+				else if (isSqliteError(error)) this.ctx.showError(credentialStoreOperationError("Logout", error));
+				else throw error;
 				return;
 			}
 		}
@@ -3807,37 +3886,53 @@ export class SelectorController {
 				}
 			}
 		}
-		this.showSelector(done => {
-			let selector: OAuthSelectorComponent;
-			selector = new OAuthSelectorComponent(
-				mode,
-				this.ctx.session.modelRegistry.authStorage,
-				async (selectedProviderId: string) => {
-					selector.stopValidation();
-					done();
-					await this.showOAuthSelector(mode, selectedProviderId);
-				},
-				() => {
-					selector.stopValidation();
-					done();
-					this.ctx.ui.requestLayoutRender("oauth-selector-close");
-				},
-				{
-					validateAuth: async (selectedProviderId: string) => {
-						const apiKey = await this.ctx.session.modelRegistry.getApiKeyForProvider(
-							selectedProviderId,
-							this.ctx.session.credentialSessionId,
-						);
-						return !!apiKey;
+		try {
+			this.showSelector(done => {
+				let selector: OAuthSelectorComponent;
+				selector = new OAuthSelectorComponent(
+					mode,
+					this.ctx.session.modelRegistry.authStorage,
+					async (selectedProviderId: string) => {
+						selector.stopValidation();
+						done();
+						await this.showOAuthSelector(mode, selectedProviderId);
 					},
-					requestRender: () => {
-						this.ctx.ui.requestLayoutRender("oauth-selector-spinner");
+					() => {
+						selector.stopValidation();
+						done();
+						this.ctx.ui.requestLayoutRender("oauth-selector-close");
 					},
-					externalCredentialCandidates,
-				},
-			);
-			return { component: selector, focus: selector };
-		});
+					{
+						validateAuth: async (selectedProviderId: string) => {
+							const apiKey = await this.ctx.session.modelRegistry.getApiKeyForProvider(
+								selectedProviderId,
+								this.ctx.session.credentialSessionId,
+							);
+							return !!apiKey;
+						},
+						onValidationError: error => {
+							if (!isSqliteError(error)) return false;
+							selector.stopValidation();
+							done();
+							this.ctx.showError(
+								isSqliteCorruptionError(error)
+									? CREDENTIAL_STORE_UNREADABLE_MESSAGE
+									: credentialStoreOperationError("Login", error),
+							);
+							return true;
+						},
+						requestRender: () => {
+							this.ctx.ui.requestLayoutRender("oauth-selector-spinner");
+						},
+						externalCredentialCandidates,
+					},
+				);
+				return { component: selector, focus: selector };
+			});
+		} catch (error: unknown) {
+			if (!isSqliteCorruptionError(error)) throw error;
+			this.ctx.showError(CREDENTIAL_STORE_UNREADABLE_MESSAGE);
+		}
 	}
 
 	showDebugSelector(): void {

package/src/modes/interactive-mode.ts

@@ -426,6 +426,7 @@ export class InteractiveMode implements InteractiveModeContext {
 	lastComposerClearEscapeTime = 0;
 	shutdownRequested = false;
 	#isShuttingDown = false;
+	#shutdownEscalated = false;
 	hookSelector: HookSelectorComponent | undefined = undefined;
 	hookInput: HookInputComponent | undefined = undefined;
 	hookEditor: HookEditorComponent | undefined = undefined;
@@ -1682,7 +1683,19 @@ export class InteractiveMode implements InteractiveModeContext {
 	}
 
 	async shutdown(): Promise<void> {
-		if (this.#isShuttingDown) return;
+		if (this.#isShuttingDown) {
+			// A second explicit exit is an escalation, not another silent no-op. The
+			// graceful path may be waiting on a lock-hostile filesystem; postmortem.quit
+			// has its own bounded cleanup deadline and will force the process out even
+			// when the first shutdown cannot finish.
+			if (!this.#shutdownEscalated) {
+				this.#shutdownEscalated = true;
+				logger.warn("Escalating repeated interactive shutdown request");
+				this.session.abort();
+				void postmortem.quit(1);
+			}
+			return;
+		}
 		this.#isShuttingDown = true;
 
 		// `/btw` owns the shared composer while its panel is open. Never persist a

package/src/modes/jobs-observer.ts

@@ -16,12 +16,48 @@ import type { AsyncJob, AsyncJobManager } from "../async";
 import { deleteCronJobById, listCronSnapshots, onCronChange } from "../tools/cron";
 
 export type JobsWorstState = "none" | "running" | "failed";
+export type JobDeliveryState = "pending" | "delivered" | "failed-visible";
+
+/** The manager-owned, one-pass job projection consumed by this observer. */
+export interface AsyncJobSnapshotEntry {
+	id: string;
+	kind: string;
+	label: string;
+	status: AsyncJob["status"];
+	generation: string;
+	backgrounded: boolean;
+	deliveryState: JobDeliveryState;
+}
+
+/** Scalar delivery failure evidence that may outlive the AsyncJob record. */
+export interface DeadLetteredJobSnapshotEntry {
+	jobId: string;
+	generation: string;
+	ownerId?: string;
+	backgrounded?: boolean;
+	attempt: number;
+	lastError?: string;
+	recordedAt: number;
+}
+
+export interface AsyncJobsSnapshot {
+	jobs: AsyncJobSnapshotEntry[];
+	deadLettered: DeadLetteredJobSnapshotEntry[];
+}
 
 export interface MonitorJobView {
 	id: string;
 	label: string;
 	status: AsyncJob["status"];
 	startTime: number;
+	generation?: string;
+	backgrounded?: boolean;
+	deliveryState?: JobDeliveryState;
+}
+
+export interface FoldedJobView extends AsyncJobSnapshotEntry {
+	/** Safe diagnostic retained for a dead-lettered delivery, when available. */
+	errorText?: string;
 }
 
 export interface CronJobView {
@@ -39,6 +75,10 @@ export interface CronJobView {
 export interface JobsSnapshot {
 	monitors: MonitorJobView[];
 	crons: CronJobView[];
+	/** Backgrounded work and undeliverable terminal work that must stay visible. */
+	foldedJobs?: FoldedJobView[];
+	/** Scalar dead-letter evidence retained for diagnostics and red-drill-in. */
+	deadLettered?: DeadLetteredJobSnapshotEntry[];
 	activeMonitorCount: number;
 	activeCronCount: number;
 	worstState: JobsWorstState;
@@ -48,12 +88,22 @@ export interface JobsSnapshot {
 export const EMPTY_JOBS_SNAPSHOT: JobsSnapshot = {
 	monitors: [],
 	crons: [],
+	foldedJobs: [],
+	deadLettered: [],
 	activeMonitorCount: 0,
 	activeCronCount: 0,
 	worstState: "none",
 	failedUnacknowledged: false,
 };
 
+function jobKey(id: string, generation: string): string {
+	return `${id}\u0000${generation}`;
+}
+
+interface AsyncJobSnapshotSource {
+	getJobsSnapshot?: (filter?: { ownerId?: string }) => AsyncJobsSnapshot;
+}
+
 export class JobsObserver {
 	readonly #manager: AsyncJobManager;
 	readonly #ownerId: string | undefined;
@@ -103,7 +153,14 @@ export class JobsObserver {
 		}
 	}
 
+	#readAsyncJobsSnapshot(): AsyncJobsSnapshot {
+		const source = this.#manager as AsyncJobSnapshotSource;
+		if (typeof source.getJobsSnapshot !== "function") return { jobs: [], deadLettered: [] };
+		return source.getJobsSnapshot(this.#ownerId ? { ownerId: this.#ownerId } : undefined);
+	}
+
 	#listMonitorJobs(): AsyncJob[] {
+		if (typeof this.#manager.getAllJobs !== "function") return [];
 		const filter = this.#ownerId ? { ownerId: this.#ownerId } : undefined;
 		return this.#manager.getAllJobs(filter).filter(job => job.type === "bash" && job.metadata?.monitor === true);
 	}
@@ -114,25 +171,92 @@ export class JobsObserver {
 	 * snapshot (never scans the manager/cron stores).
 	 */
 	#recompute(): void {
+		const asyncSnapshot = this.#readAsyncJobsSnapshot();
+		const snapshotEntries = new Map<string, AsyncJobSnapshotEntry>();
+		for (const entry of asyncSnapshot.jobs) snapshotEntries.set(jobKey(entry.id, entry.generation), entry);
+
 		const monitorJobs = this.#listMonitorJobs();
-		const presentIds = new Set(monitorJobs.map(job => job.id));
-		// Prune acknowledged ids whose jobs have been evicted.
-		for (const id of this.#acknowledgedFailedIds) {
-			if (!presentIds.has(id)) this.#acknowledgedFailedIds.delete(id);
+		const monitorKeys = new Set(monitorJobs.map(job => jobKey(job.id, job.generation)));
+		const presentKeys = new Set<string>([
+			...asyncSnapshot.jobs.map(entry => jobKey(entry.id, entry.generation)),
+			...asyncSnapshot.deadLettered.map(entry => jobKey(entry.jobId, entry.generation)),
+		]);
+		// Prune acknowledged keys whose jobs and scalar dead letters have been evicted.
+		for (const key of this.#acknowledgedFailedIds) {
+			if (!presentKeys.has(key)) this.#acknowledgedFailedIds.delete(key);
 		}
-		// Sticky failure latch: set when an unacknowledged failed monitor is seen
-		// (including at construction); stays set even after the failed job evicts,
-		// until acknowledgeFailures() clears it.
-		const hasUnacknowledgedFailure = monitorJobs.some(
-			job => job.status === "failed" && !this.#acknowledgedFailedIds.has(job.id),
-		);
+
+		// Sticky failure latch: the manager's terminal status and delivery
+		// classification are authoritative; neither is reconstructed from getters.
+		const hasUnacknowledgedFailure =
+			asyncSnapshot.jobs.some(
+				entry =>
+					(entry.deliveryState === "failed-visible" ||
+						(entry.status === "failed" &&
+							(entry.backgrounded || monitorKeys.has(jobKey(entry.id, entry.generation))))) &&
+					!this.#acknowledgedFailedIds.has(jobKey(entry.id, entry.generation)),
+			) ||
+			asyncSnapshot.deadLettered.some(
+				entry => !this.#acknowledgedFailedIds.has(jobKey(entry.jobId, entry.generation)),
+			);
 		if (hasUnacknowledgedFailure) this.#failedUnacknowledged = true;
 
-		const activeMonitors = monitorJobs.filter(job => job.status === "running");
-		const cronSnapshots = listCronSnapshots(this.#ownerId);
 		const monitors: MonitorJobView[] = monitorJobs
-			.map(job => ({ id: job.id, label: job.label, status: job.status, startTime: job.startTime }))
+			.flatMap(job => {
+				const entry = snapshotEntries.get(jobKey(job.id, job.generation));
+				if (!entry) return [];
+				return [
+					{
+						id: entry.id,
+						label: entry.label,
+						status: entry.status,
+						startTime: job.startTime,
+						generation: entry.generation,
+						backgrounded: entry.backgrounded,
+						deliveryState: entry.deliveryState,
+					},
+				];
+			})
 			.sort((a, b) => b.startTime - a.startTime);
+
+		// Keep every backgrounded job visible. A non-delivered terminal entry is
+		// also retained here so pending/failed delivery can never disappear merely
+		// because it was not marked backgrounded by its producer.
+		const deadLettersByKey = new Map(
+			asyncSnapshot.deadLettered.map(entry => [jobKey(entry.jobId, entry.generation), entry] as const),
+		);
+		const foldedJobs: FoldedJobView[] = asyncSnapshot.jobs
+			.filter(
+				entry =>
+					entry.backgrounded ||
+					(entry.status !== "running" &&
+						(entry.deliveryState === "failed-visible" ||
+							(entry.status === "failed" && entry.backgrounded) ||
+							entry.deliveryState !== "delivered")),
+			)
+			.map(entry => {
+				const lastError = deadLettersByKey.get(jobKey(entry.id, entry.generation))?.lastError;
+				return lastError === undefined ? { ...entry } : { ...entry, errorText: lastError };
+			});
+		const foldedKeys = new Set(foldedJobs.map(entry => jobKey(entry.id, entry.generation)));
+		for (const entry of asyncSnapshot.deadLettered) {
+			const key = jobKey(entry.jobId, entry.generation);
+			if (foldedKeys.has(key)) continue;
+			foldedKeys.add(key);
+			foldedJobs.push({
+				id: entry.jobId,
+				kind: "dead-letter",
+				label: entry.jobId,
+				status: "failed",
+				generation: entry.generation,
+				backgrounded: entry.backgrounded === true,
+				deliveryState: "failed-visible",
+				errorText: entry.lastError,
+			});
+		}
+
+		const activeMonitors = monitors.filter(monitor => monitor.status === "running" && !monitor.backgrounded);
+		const cronSnapshots = listCronSnapshots(this.#ownerId);
 		const crons: CronJobView[] = cronSnapshots
 			.map(snapshot => ({
 				id: snapshot.id,
@@ -145,14 +269,17 @@ export class JobsObserver {
 				firing: snapshot.firing,
 			}))
 			.sort((a, b) => b.createdAt - a.createdAt);
+		const hasRunningFoldedJob = foldedJobs.some(job => job.status === "running");
 		const worstState: JobsWorstState = this.#failedUnacknowledged
 			? "failed"
-			: activeMonitors.length > 0 || crons.length > 0
+			: activeMonitors.length > 0 || crons.length > 0 || hasRunningFoldedJob
 				? "running"
 				: "none";
 		this.#snapshot = {
 			monitors,
 			crons,
+			foldedJobs,
+			deadLettered: asyncSnapshot.deadLettered.map(entry => ({ ...entry })),
 			activeMonitorCount: activeMonitors.length,
 			activeCronCount: crons.length,
 			worstState,
@@ -167,8 +294,14 @@ export class JobsObserver {
 
 	/** Clear the failure latch (called when the user opens the jobs overlay). */
 	acknowledgeFailures(): void {
-		for (const job of this.#listMonitorJobs()) {
-			if (job.status === "failed") this.#acknowledgedFailedIds.add(job.id);
+		const asyncSnapshot = this.#readAsyncJobsSnapshot();
+		for (const entry of asyncSnapshot.jobs) {
+			if (entry.status === "failed" || entry.deliveryState === "failed-visible") {
+				this.#acknowledgedFailedIds.add(jobKey(entry.id, entry.generation));
+			}
+		}
+		for (const entry of asyncSnapshot.deadLettered) {
+			this.#acknowledgedFailedIds.add(jobKey(entry.jobId, entry.generation));
 		}
 		if (!this.#failedUnacknowledged) return;
 		this.#failedUnacknowledged = false;