@gajae-code/coding-agent 0.3.0 → 0.3.2

package/src/modes/controllers/extension-ui-controller.ts

@@ -25,11 +25,17 @@ import type { InteractiveModeContext } from "../../modes/types";
 import { setSessionTerminalTitle, setTerminalTitle } from "../../utils/title-generator";
 
 const MAX_WIDGET_LINES = 10;
+const HOOK_SELECTOR_MOUSE_REPORTING_ENABLE = "\x1b[?1006h\x1b[?1000h";
+const HOOK_SELECTOR_MOUSE_REPORTING_DISABLE = "\x1b[?1000l\x1b[?1006l";
+const HOOK_SELECTOR_CHROME_ROWS = 7;
+const HOOK_SELECTOR_OUTLINE_ROWS = 2;
 
 export class ExtensionUiController {
 	#extensionTerminalInputUnsubscribers = new Set<() => void>();
 	#hookWidgetsAbove = new Map<string, ExtensionUiComponent>();
 	#hookWidgetsBelow = new Map<string, ExtensionUiComponent>();
+	#hookSelectorMouseReportingEnabled = false;
+
 	constructor(private ctx: InteractiveModeContext) {}
 
 	/**
@@ -589,12 +595,20 @@ export class ExtensionUiController {
 			() => this.hideHookSelector(),
 			dialogOptions?.signal,
 		);
-		const maxVisible = Math.max(4, Math.min(15, this.ctx.ui.terminal.rows - 12));
 		const requestedTitleRows = dialogOptions?.scrollTitleRows;
-		const selectorChromeRows = 7;
-		const availableTitleRows = this.ctx.ui.terminal.rows - maxVisible - selectorChromeRows;
+		const baseMaxVisible = Math.max(4, Math.min(15, this.ctx.ui.terminal.rows - 12));
+		const scrollOptionRows = Math.max(1, Math.min(baseMaxVisible, options.length));
+		const maxVisible =
+			requestedTitleRows === undefined ? baseMaxVisible : Math.min(15, Math.max(3, scrollOptionRows + 1));
+		const listChromeRows = dialogOptions?.outline === true ? HOOK_SELECTOR_OUTLINE_ROWS : 0;
+		const availableTitleRows =
+			this.ctx.ui.terminal.rows - scrollOptionRows - listChromeRows - HOOK_SELECTOR_CHROME_ROWS;
 		const scrollTitleRows =
 			requestedTitleRows === undefined ? undefined : Math.max(1, Math.min(requestedTitleRows, availableTitleRows));
+		if (scrollTitleRows !== undefined) {
+			this.#enableHookSelectorMouseReporting();
+		}
+
 		this.ctx.hookSelector = new HookSelectorComponent(
 			title,
 			options,
@@ -640,10 +654,32 @@ export class ExtensionUiController {
 		attachAbort();
 		return promise;
 	}
+
+	#enableHookSelectorMouseReporting(): void {
+		if (this.#hookSelectorMouseReportingEnabled) return;
+		this.#hookSelectorMouseReportingEnabled = true;
+		this.#writeTerminalControl(HOOK_SELECTOR_MOUSE_REPORTING_ENABLE);
+	}
+
+	#disableHookSelectorMouseReporting(): void {
+		if (!this.#hookSelectorMouseReportingEnabled) return;
+		this.#hookSelectorMouseReportingEnabled = false;
+		this.#writeTerminalControl(HOOK_SELECTOR_MOUSE_REPORTING_DISABLE);
+	}
+
+	#writeTerminalControl(sequence: string): void {
+		try {
+			this.ctx.ui.terminal.write(sequence);
+		} catch {
+			// Terminal teardown can race selector cleanup; normal shutdown restores modes.
+		}
+	}
+
 	/**
 	 * Hide the hook selector.
 	 */
 	hideHookSelector(): void {
+		this.#disableHookSelectorMouseReporting();
 		this.ctx.hookSelector?.dispose();
 		this.ctx.editorContainer.clear();
 		this.ctx.editorContainer.addChild(this.ctx.editor);

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

@@ -1,4 +1,5 @@
 import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { type AgentMessage, ThinkingLevel } from "@gajae-code/agent-core";
 import type { AutocompleteProvider, SlashCommand } from "@gajae-code/tui";
 import { $env, sanitizeText } from "@gajae-code/utils";
@@ -13,7 +14,7 @@ import { SKILL_PROMPT_MESSAGE_TYPE, type SkillPromptDetails } from "../../sessio
 import { executeBuiltinSlashCommand } from "../../slash-commands/builtin-registry";
 import { copyToClipboard, readImageFromClipboard } from "../../utils/clipboard";
 import { getEditorCommand, openInEditor } from "../../utils/external-editor";
-import { ensureSupportedImageInput } from "../../utils/image-loading";
+import { ensureSupportedImageInput, ImageInputTooLargeError, loadImageInput } from "../../utils/image-loading";
 import { resizeImage } from "../../utils/image-resize";
 import { generateSessionTitle, setSessionTerminalTitle } from "../../utils/title-generator";
 
@@ -22,6 +23,8 @@ interface Expandable {
 }
 
 const INTERACTIVE_ABORT_CLEANUP_TIMEOUT_MS = 5_000;
+const CLIPBOARD_TEMP_IMAGE_FILE_PATTERN = /^clipboard-\d{4}-\d{2}-\d{2}-\d{6}-[A-Za-z0-9]+\.(?:png|jpe?g|gif|webp)$/i;
+const MACOS_CLIPBOARD_TEMP_DIR_PATTERN = /^\/var\/folders\/[^/]+\/[^/]+\/T$/;
 
 function isExpandable(obj: unknown): obj is Expandable {
 	return typeof obj === "object" && obj !== null && "setExpanded" in obj && typeof obj.setExpanded === "function";
@@ -30,8 +33,17 @@ function isExpandable(obj: unknown): obj is Expandable {
 export class InputController {
 	constructor(private ctx: InteractiveModeContext) {}
 
-	#abortInteractive(): Promise<void> {
-		return this.ctx.session.abort({ timeoutMs: INTERACTIVE_ABORT_CLEANUP_TIMEOUT_MS, cause: "user_interrupt" });
+	/** Set after a first Esc silently consumes a queued steer. Kept until the
+	 *  queued steer is either cancelled by a second Esc or drained by continuation,
+	 *  so abort cleanup going idle cannot turn the second Esc into an idle action. */
+	#steerConsumePending = false;
+
+	#abortInteractive(options?: { silent?: boolean }): Promise<void> {
+		return this.ctx.session.abort({
+			timeoutMs: INTERACTIVE_ABORT_CLEANUP_TIMEOUT_MS,
+			cause: "user_interrupt",
+			silent: options?.silent,
+		});
 	}
 
 	setupKeyHandlers(): void {
@@ -40,6 +52,7 @@ export class InputController {
 			Boolean(
 				this.ctx.loadingAnimation ||
 					this.ctx.hasActiveBtw() ||
+					(this.#steerConsumePending && this.ctx.session.hasQueuedSteering) ||
 					this.ctx.session.isStreaming ||
 					this.ctx.session.isCompacting ||
 					this.ctx.session.isGeneratingHandoff ||
@@ -54,6 +67,17 @@ export class InputController {
 			if (this.ctx.hasActiveBtw() && this.ctx.handleBtwEscape()) {
 				return;
 			}
+			if (this.#steerConsumePending) {
+				if (this.ctx.session.hasQueuedSteering) {
+					// Second Esc before the scheduled steer continuation drains the
+					// queue: restore/drop the queued steer and perform a real abort,
+					// even if abort cleanup already made the session look idle.
+					this.#steerConsumePending = false;
+					this.restoreQueuedMessagesToEditor({ abort: true });
+					return;
+				}
+				this.#steerConsumePending = false;
+			}
 			if (this.ctx.loadingAnimation) {
 				if (this.ctx.cancelPendingSubmission()) {
 					return;
@@ -73,7 +97,15 @@ export class InputController {
 				this.ctx.isPythonMode = false;
 				this.ctx.updateEditorBorderColor();
 			} else if (this.ctx.session.isStreaming) {
-				void this.#abortInteractive();
+				if (this.ctx.session.hasQueuedSteering && !this.#steerConsumePending) {
+					// First Esc with a queued steer: silently consume it and
+					// auto-continue via steer-on-interrupt instead of stalling on
+					// "Operation aborted".
+					this.#steerConsumePending = true;
+					void this.#abortInteractive({ silent: true });
+				} else {
+					void this.#abortInteractive();
+				}
 			} else if (!this.ctx.editor.getText().trim()) {
 				// Double-interrupt with empty editor triggers /tree, /branch, or nothing based on setting
 				const action = settings.get("doubleEscapeAction");
@@ -132,6 +164,13 @@ export class InputController {
 			this.ctx.keybindings.getKeys("app.clipboard.copyPrompt"),
 		);
 		this.ctx.editor.onCopyPrompt = () => this.handleCopyPrompt();
+		this.ctx.editor.onPasteText = text => this.handleTextPaste(text);
+		this.ctx.editor.onPastePendingInputCleared = (reason, droppedInputCount) => {
+			const reasonText = reason === "timeout" ? "timed out" : "exceeded the input queue limit";
+			this.ctx.showWarning(
+				`Paste handling ${reasonText}; discarded ${droppedInputCount} buffered input event${droppedInputCount === 1 ? "" : "s"}.`,
+			);
+		};
 		this.ctx.editor.setActionKeys("app.tools.expand", this.ctx.keybindings.getKeys("app.tools.expand"));
 		this.ctx.editor.onExpandTools = () => this.toggleToolOutputExpansion();
 		this.ctx.editor.setActionKeys("app.message.dequeue", this.ctx.keybindings.getKeys("app.message.dequeue"));
@@ -170,6 +209,9 @@ export class InputController {
 		for (const key of this.ctx.keybindings.getKeys("app.session.observe")) {
 			this.ctx.editor.setCustomKeyHandler(key, () => this.ctx.showSessionObserver());
 		}
+		for (const key of this.ctx.keybindings.getKeys("app.jobs.open")) {
+			this.ctx.editor.setCustomKeyHandler(key, () => this.ctx.showJobsOverlay());
+		}
 
 		this.ctx.editor.onChange = (text: string) => {
 			const wasBashMode = this.ctx.isBashMode;
@@ -602,6 +644,55 @@ export class InputController {
 		process.kill(0, "SIGTSTP");
 	}
 
+	handleTextPaste(text: string): boolean | Promise<boolean> {
+		const imagePath = this.#getPastedImagePathCandidate(text);
+		return imagePath ? this.#attachPastedImagePath(imagePath) : false;
+	}
+
+	async #attachPastedImagePath(imagePath: string): Promise<boolean> {
+		try {
+			const image = await loadImageInput({
+				path: imagePath,
+				cwd: this.ctx.sessionManager.getCwd(),
+				autoResize: this.ctx.settings.get("images.autoResize"),
+			});
+			if (!image) {
+				this.ctx.showStatus("Unsupported pasted clipboard image file");
+				return true;
+			}
+
+			this.ctx.pendingImages.push({
+				type: "image",
+				data: image.data,
+				mimeType: image.mimeType,
+			});
+			this.ctx.editor.insertText(`${this.#nextImagePlaceholder()} `);
+			this.ctx.showStatus(`Attached image: ${path.basename(image.resolvedPath)}`, { dim: true });
+			this.ctx.ui.requestRender();
+			return true;
+		} catch (error) {
+			if (error instanceof ImageInputTooLargeError) {
+				this.ctx.showStatus(error.message);
+				return true;
+			}
+			this.ctx.showStatus("Failed to attach pasted clipboard image");
+			return true;
+		}
+	}
+
+	#getPastedImagePathCandidate(text: string): string | undefined {
+		const resolvedPath = path.resolve(text.trim());
+		const parentDir = path.dirname(resolvedPath);
+		const isClipboardTempPath =
+			(parentDir === "/tmp" || MACOS_CLIPBOARD_TEMP_DIR_PATTERN.test(parentDir)) &&
+			CLIPBOARD_TEMP_IMAGE_FILE_PATTERN.test(path.basename(resolvedPath));
+		return isClipboardTempPath ? resolvedPath : undefined;
+	}
+
+	#nextImagePlaceholder(): string {
+		return `[image ${this.ctx.pendingImages.length}]`;
+	}
+
 	async handleImagePaste(): Promise<boolean> {
 		try {
 			const image = await readImageFromClipboard();
@@ -616,7 +707,7 @@ export class InputController {
 					this.ctx.showStatus(`Unsupported clipboard image format: ${image.mimeType}`);
 					return false;
 				}
-				if (settings.get("images.autoResize")) {
+				if (this.ctx.settings.get("images.autoResize")) {
 					try {
 						const resized = await resizeImage({
 							type: "image",
@@ -634,10 +725,7 @@ export class InputController {
 					data: imageData.data,
 					mimeType: imageData.mimeType,
 				});
-				// Insert placeholder at cursor like Anthropic model does
-				const imageNum = this.ctx.pendingImages.length;
-				const placeholder = `[Image #${imageNum}]`;
-				this.ctx.editor.insertText(`${placeholder} `);
+				this.ctx.editor.insertText(`${this.#nextImagePlaceholder()} `);
 				this.ctx.ui.requestRender();
 				return true;
 			}

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

@@ -4,6 +4,7 @@ import type { OAuthProvider } from "@gajae-code/ai/utils/oauth/types";
 import type { Component, OverlayHandle } from "@gajae-code/tui";
 import { Input, Loader, Spacer, Text } from "@gajae-code/tui";
 import { getAgentDbPath, getProjectDir } from "@gajae-code/utils";
+import { activateModelProfile } from "../../config/model-profile-activation";
 import { settings } from "../../config/settings";
 import { DebugSelectorComponent } from "../../debug";
 import { disableProvider, enableProvider } from "../../discovery";
@@ -35,12 +36,15 @@ import {
 	MODEL_ONBOARDING_PROVIDER_PRESET_COMMAND,
 	MODEL_ONBOARDING_SETUP_COMMAND,
 } from "../../setup/model-onboarding-guidance";
+import { addApiCompatibleProvider, formatProviderSetupResult } from "../../setup/provider-onboarding";
 import { isSearchProviderPreference, setPreferredImageProvider, setPreferredSearchProvider } from "../../tools";
 import { setSessionTerminalTitle } from "../../utils/title-generator";
 import { AgentDashboard } from "../components/agent-dashboard";
 import { AssistantMessageComponent } from "../components/assistant-message";
+import { CustomProviderWizardComponent, type CustomProviderWizardSubmit } from "../components/custom-provider-wizard";
 import { ExtensionDashboard } from "../components/extensions";
 import { HistorySearchComponent } from "../components/history-search";
+import { JobsOverlayComponent } from "../components/jobs-overlay";
 import { ModelSelectorComponent, type ModelSelectorSelection } from "../components/model-selector";
 import { OAuthSelectorComponent } from "../components/oauth-selector";
 import { PluginSelectorComponent } from "../components/plugin-selector";
@@ -55,6 +59,7 @@ import { ThemeSelectorComponent } from "../components/theme-selector";
 import { ToolExecutionComponent } from "../components/tool-execution";
 import { TreeSelectorComponent } from "../components/tree-selector";
 import { UserMessageSelectorComponent } from "../components/user-message-selector";
+import type { JobsObserver } from "../jobs-observer";
 import type { SessionObserverRegistry } from "../session-observer-registry";
 
 const CALLBACK_SERVER_PROVIDERS = new Set<string>([
@@ -117,7 +122,9 @@ export class SelectorController {
 			const selector = new ProviderOnboardingSelectorComponent(
 				(action: ProviderOnboardingAction) => {
 					done();
-					if (action === "oauth-login") {
+					if (action === "custom-provider-wizard") {
+						this.showCustomProviderWizard();
+					} else if (action === "oauth-login") {
 						void this.showOAuthSelector("login");
 					} else {
 						this.ctx.showStatus(formatProviderOnboardingCommandGuide());
@@ -132,6 +139,36 @@ export class SelectorController {
 		});
 	}
 
+	showCustomProviderWizard(): void {
+		this.showSelector(done => {
+			let wizard: CustomProviderWizardComponent;
+			const submit = async (input: CustomProviderWizardSubmit): Promise<void> => {
+				try {
+					const result = await addApiCompatibleProvider(input);
+					await this.ctx.session.modelRegistry.refresh("offline");
+					await this.ctx.notifyConfigChanged?.();
+					this.ctx.showStatus(formatProviderSetupResult(result));
+					done();
+					this.ctx.ui.requestRender();
+				} catch (err) {
+					const message = err instanceof Error ? err.message : String(err);
+					wizard.setSubmitError(`Provider setup failed: ${message}`);
+				}
+			};
+			wizard = new CustomProviderWizardComponent(
+				input => {
+					void submit(input);
+				},
+				() => {
+					done();
+					this.ctx.ui.requestRender();
+				},
+				() => this.ctx.ui.requestRender(),
+			);
+			return { component: wizard, focus: wizard };
+		});
+	}
+
 	showSettingsSelector(): void {
 		getAvailableThemes().then(availableThemes => {
 			this.showSelector(done => {
@@ -500,6 +537,27 @@ export class SelectorController {
 							this.ctx.ui.requestRender();
 							return;
 						}
+						if (selection.kind === "profile") {
+							await activateModelProfile(
+								{
+									session: this.ctx.session,
+									modelRegistry: this.ctx.session.modelRegistry,
+									settings: this.ctx.settings,
+									profileName: selection.profileName,
+								},
+								{ persistDefault: selection.setDefault },
+							);
+							this.ctx.statusLine.invalidate();
+							this.ctx.updateEditorBorderColor();
+							this.ctx.showStatus(
+								selection.setDefault
+									? `Default model profile: ${selection.profileName}`
+									: `Model profile: ${selection.profileName}`,
+							);
+							done();
+							this.ctx.ui.requestRender();
+							return;
+						}
 						const { model, role, thinkingLevel, selector } = selection;
 						if (role === null) {
 							// Temporary: update agent state but don't persist to settings
@@ -1150,4 +1208,31 @@ export class SelectorController {
 		this.ctx.ui.setFocus(selector);
 		this.ctx.ui.requestRender();
 	}
+
+	/**
+	 * Jobs overlay: navigate ongoing monitor + cron jobs (Monitors then Crons,
+	 * newest-first), drill into per-type detail, and cancel/delete with a y/N
+	 * confirm. Built from nested SelectLists (list -> detail -> confirm) so focus
+	 * stays on the active SelectList.
+	 */
+	showJobsOverlay(observer: JobsObserver): void {
+		let overlay: JobsOverlayComponent | undefined;
+		const close = () => {
+			this.ctx.editorContainer.clear();
+			this.ctx.editorContainer.addChild(this.ctx.editor);
+			this.ctx.ui.setFocus(this.ctx.editor);
+			this.ctx.ui.requestRender();
+		};
+		overlay = new JobsOverlayComponent(observer, {
+			close,
+			requestRender: () => {
+				if (overlay) this.ctx.ui.setFocus(overlay.getFocus());
+				this.ctx.ui.requestRender();
+			},
+		});
+		this.ctx.editorContainer.clear();
+		this.ctx.editorContainer.addChild(overlay);
+		this.ctx.ui.setFocus(overlay.getFocus());
+		this.ctx.ui.requestRender();
+	}
 }

package/src/modes/index.ts

@@ -5,6 +5,7 @@ import { postmortem } from "@gajae-code/utils";
  * Run modes for the coding agent.
  */
 export { runAcpMode } from "./acp";
+export { runBridgeMode } from "./bridge/bridge-mode";
 export { InteractiveMode, type InteractiveModeOptions } from "./interactive-mode";
 export { type PrintModeOptions, runPrintMode } from "./print-mode";
 export {

package/src/modes/interactive-mode.ts

@@ -28,6 +28,7 @@ import {
 } from "@gajae-code/tui";
 import { APP_NAME, adjustHsv, getProjectDir, hsvToRgb, isEnoent, logger, postmortem, prompt } from "@gajae-code/utils";
 import chalk from "chalk";
+import { AsyncJobManager } from "../async";
 import { KeybindingsManager } from "../config/keybindings";
 import { isSettingsInitialized, type Settings, settings } from "../config/settings";
 import { DEFAULT_GJC_DEFINITION_NAMES } from "../defaults/gjc-defaults";
@@ -88,6 +89,7 @@ import { InputController } from "./controllers/input-controller";
 import { SelectorController } from "./controllers/selector-controller";
 import { SSHCommandController } from "./controllers/ssh-command-controller";
 import { TodoCommandController } from "./controllers/todo-command-controller";
+import { JobsObserver } from "./jobs-observer";
 import { OAuthManualInputManager } from "./oauth-manual-input";
 import { SessionObserverRegistry } from "./session-observer-registry";
 import { interruptHint } from "./shared";
@@ -330,6 +332,7 @@ export class InteractiveMode implements InteractiveModeContext {
 	#voicePreviousUseTerminalCursor: boolean | null = null;
 	#resizeHandler?: () => void;
 	#observerRegistry: SessionObserverRegistry;
+	#jobsObserver?: JobsObserver;
 	#eventBus?: EventBus;
 	#eventBusUnsubscribers: Array<() => void> = [];
 	#welcomeComponent?: WelcomeComponent;
@@ -525,6 +528,19 @@ export class InteractiveMode implements InteractiveModeContext {
 			this.ui.requestRender();
 		});
 
+		// Event-driven monitor/cron jobs widget. Scoped to this session's owner so
+		// overlay actions cannot mutate another agent's background work.
+		const jobManager = AsyncJobManager.instance();
+		if (jobManager) {
+			const jobsObserver = new JobsObserver(jobManager, this.session.getAgentId());
+			this.#jobsObserver = jobsObserver;
+			this.statusLine.setJobs(jobsObserver.getSnapshot());
+			jobsObserver.onChange(() => {
+				this.statusLine.setJobs(jobsObserver.getSnapshot());
+				this.ui.requestRender();
+			});
+		}
+
 		// Load initial todos
 		await this.#loadTodoList();
 
@@ -1843,6 +1859,8 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#observerRegistry.dispose();
 		this.#eventController.dispose();
 		this.statusLine.dispose();
+		this.#jobsObserver?.dispose();
+		this.editor.dispose();
 		if (this.#resizeHandler) {
 			process.stdout.removeListener("resize", this.#resizeHandler);
 			this.#resizeHandler = undefined;
@@ -1944,6 +1962,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			nextEditor.setHistoryStorage(this.historyStorage);
 		}
 		nextEditor.setText(previousText);
+		previousEditor.dispose();
 
 		this.editorContainer.clear();
 		this.editor = nextEditor;
@@ -2317,6 +2336,14 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#selectorController.showSessionObserver(this.#observerRegistry);
 	}
 
+	showJobsOverlay(): void {
+		if (!this.#jobsObserver) {
+			this.showStatus("Background jobs are unavailable in this session");
+			return;
+		}
+		this.#selectorController.showJobsOverlay(this.#jobsObserver);
+	}
+
 	resetObserverRegistry(): void {
 		this.#observerRegistry.resetSessions();
 		this.#observerRegistry.setMainSession(this.sessionManager.getSessionFile() ?? undefined);

package/src/modes/jobs-observer.ts

@@ -0,0 +1,204 @@
+/**
+ * JobsObserver
+ *
+ * Single, event-driven aggregator over the two background-work sources surfaced
+ * by the status-line jobs widget and the jobs overlay:
+ *  - monitor jobs (bash jobs started by the `monitor` tool, tracked in `AsyncJobManager`)
+ *  - cron jobs (tracked in the cron module's owner-scoped schedule store)
+ *
+ * It subscribes to change hooks on both sources (no polling), debounces bursts
+ * to a microtask, and exposes a precomputed snapshot so the status-line render
+ * loop never scans the underlying stores. A failure latch keeps the widget red
+ * until `acknowledgeFailures()` is called (when the overlay opens), so a failed
+ * job that evicts before the user looks is not silently lost.
+ */
+import type { AsyncJob, AsyncJobManager } from "../async";
+import { deleteCronJobById, listCronSnapshots, onCronChange } from "../tools/cron";
+
+export type JobsWorstState = "none" | "running" | "failed";
+
+export interface MonitorJobView {
+	id: string;
+	label: string;
+	status: AsyncJob["status"];
+	startTime: number;
+}
+
+export interface CronJobView {
+	id: string;
+	humanSchedule: string;
+	cronExpression: string;
+	prompt: string;
+	recurring: boolean;
+	nextFireAt?: number;
+	createdAt: number;
+}
+
+export interface JobsSnapshot {
+	monitors: MonitorJobView[];
+	crons: CronJobView[];
+	activeMonitorCount: number;
+	activeCronCount: number;
+	worstState: JobsWorstState;
+	failedUnacknowledged: boolean;
+}
+
+export const EMPTY_JOBS_SNAPSHOT: JobsSnapshot = {
+	monitors: [],
+	crons: [],
+	activeMonitorCount: 0,
+	activeCronCount: 0,
+	worstState: "none",
+	failedUnacknowledged: false,
+};
+
+export class JobsObserver {
+	readonly #manager: AsyncJobManager;
+	readonly #ownerId: string | undefined;
+	readonly #unsubscribers: Array<() => void> = [];
+	readonly #listeners = new Set<() => void>();
+	#failedUnacknowledged = false;
+	#notifyScheduled = false;
+	#disposed = false;
+	#snapshot: JobsSnapshot = EMPTY_JOBS_SNAPSHOT;
+	readonly #acknowledgedFailedIds = new Set<string>();
+
+	constructor(manager: AsyncJobManager, ownerId: string | undefined) {
+		this.#manager = manager;
+		this.#ownerId = ownerId;
+		this.#unsubscribers.push(manager.onChange(() => this.#onUpstreamChange()));
+		this.#unsubscribers.push(onCronChange(() => this.#onUpstreamChange()));
+		this.#recompute();
+	}
+
+	/** Subscribe to debounced change events. Returns an unsubscribe function. */
+	onChange(cb: () => void): () => void {
+		this.#listeners.add(cb);
+		return () => {
+			this.#listeners.delete(cb);
+		};
+	}
+
+	#onUpstreamChange(): void {
+		if (this.#disposed) return;
+		this.#recompute();
+		if (this.#notifyScheduled) return;
+		this.#notifyScheduled = true;
+		queueMicrotask(() => {
+			this.#notifyScheduled = false;
+			if (this.#disposed) return;
+			this.#emit();
+		});
+	}
+
+	#emit(): void {
+		for (const cb of this.#listeners) {
+			try {
+				cb();
+			} catch {
+				// Listener errors are isolated; a bad subscriber must not break others.
+			}
+		}
+	}
+
+	#listMonitorJobs(): AsyncJob[] {
+		const filter = this.#ownerId ? { ownerId: this.#ownerId } : undefined;
+		return this.#manager.getAllJobs(filter).filter(job => job.type === "bash" && job.metadata?.monitor === true);
+	}
+
+	/**
+	 * Recompute and store the snapshot. Called on construction and on every
+	 * upstream change; the status-line render path only reads the stored
+	 * snapshot (never scans the manager/cron stores).
+	 */
+	#recompute(): void {
+		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);
+		}
+		// 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),
+		);
+		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 }))
+			.sort((a, b) => b.startTime - a.startTime);
+		const crons: CronJobView[] = cronSnapshots
+			.map(snapshot => ({
+				id: snapshot.id,
+				humanSchedule: snapshot.humanSchedule,
+				cronExpression: snapshot.cron_expression,
+				prompt: snapshot.prompt,
+				recurring: snapshot.recurring,
+				nextFireAt: snapshot.nextFireAt,
+				createdAt: snapshot.createdAt,
+			}))
+			.sort((a, b) => b.createdAt - a.createdAt);
+		const worstState: JobsWorstState = this.#failedUnacknowledged
+			? "failed"
+			: activeMonitors.length > 0 || crons.length > 0
+				? "running"
+				: "none";
+		this.#snapshot = {
+			monitors,
+			crons,
+			activeMonitorCount: activeMonitors.length,
+			activeCronCount: crons.length,
+			worstState,
+			failedUnacknowledged: this.#failedUnacknowledged,
+		};
+	}
+
+	/** Return the precomputed snapshot (recomputed on each upstream change). */
+	getSnapshot(): JobsSnapshot {
+		return this.#snapshot;
+	}
+
+	/** 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);
+		}
+		if (!this.#failedUnacknowledged) return;
+		this.#failedUnacknowledged = false;
+		this.#recompute();
+		this.#emit();
+	}
+
+	/** Cancel a running monitor job. Returns true when the job was cancelled. */
+	cancelMonitor(id: string): boolean {
+		return this.#manager.cancel(id);
+	}
+
+	/** Delete a visible scheduled cron job. Returns true when removed. */
+	deleteCron(id: string): boolean {
+		return deleteCronJobById(this.#ownerId, id);
+	}
+
+	/** Bounded tail of a monitor job's captured output (for the detail view). */
+	getMonitorOutput(id: string): string {
+		const slice = this.#manager.readOutputSince(id, 0, this.#ownerId ? { ownerId: this.#ownerId } : undefined);
+		return slice?.text ?? "";
+	}
+
+	dispose(): void {
+		this.#disposed = true;
+		for (const unsubscribe of this.#unsubscribers) {
+			try {
+				unsubscribe();
+			} catch {
+				// best-effort teardown
+			}
+		}
+		this.#unsubscribers.length = 0;
+		this.#listeners.clear();
+	}
+}