@gajae-code/coding-agent 0.3.0 → 0.3.1

package/src/modes/components/jobs-overlay.ts

@@ -0,0 +1,172 @@
+import { Container, type SelectItem, SelectList } from "@gajae-code/tui";
+import type { JobsSnapshot } from "../jobs-observer";
+import { getSelectListTheme } from "../theme/theme";
+import { DynamicBorder } from "./dynamic-border";
+import {
+	buildConfirmItems,
+	buildJobDetailItems,
+	buildJobsListItems,
+	type JobRef,
+	parseJobRef,
+} from "./jobs-overlay-model";
+
+/**
+ * Generic single-level selector used by the jobs overlay. The selector
+ * controller mounts a fresh instance per navigation level (list -> detail ->
+ * confirm); focus is placed on the inner SelectList, matching the existing
+ * selector components (e.g. ThemeSelectorComponent).
+ */
+export class JobsSelectorComponent extends Container {
+	#selectList: SelectList;
+
+	constructor(items: SelectItem[], onSelect: (item: SelectItem) => void, onCancel: () => void, maxVisible = 12) {
+		super();
+		this.addChild(new DynamicBorder());
+		this.#selectList = new SelectList(items, maxVisible, getSelectListTheme());
+		this.#selectList.onSelect = onSelect;
+		this.#selectList.onCancel = onCancel;
+		this.addChild(this.#selectList);
+		this.addChild(new DynamicBorder());
+	}
+
+	getSelectList(): SelectList {
+		return this.#selectList;
+	}
+}
+
+export interface JobsOverlayController {
+	acknowledgeFailures(): void;
+	getSnapshot(): JobsSnapshot;
+	getMonitorOutput(id: string): string;
+	cancelMonitor(id: string): boolean;
+	deleteCron(id: string): boolean;
+}
+
+export interface JobsOverlayCallbacks {
+	close(): void;
+	requestRender(): void;
+}
+
+type JobsOverlayView = "list" | "detail" | "confirm";
+type JobsOverlayAction = "cancel" | "delete";
+
+export class JobsOverlayComponent extends Container {
+	readonly #controller: JobsOverlayController;
+	readonly #callbacks: JobsOverlayCallbacks;
+	#view: JobsOverlayView = "list";
+	#ref: JobRef | undefined;
+	#action: JobsOverlayAction | undefined;
+	#selectList: SelectList | undefined;
+
+	constructor(controller: JobsOverlayController, callbacks: JobsOverlayCallbacks) {
+		super();
+		this.#controller = controller;
+		this.#callbacks = callbacks;
+		this.#controller.acknowledgeFailures();
+		this.#renderList();
+	}
+
+	getFocus(): SelectList {
+		if (!this.#selectList) throw new Error("Jobs overlay has no focusable list");
+		return this.#selectList;
+	}
+
+	handleInput(data: string): void {
+		if (this.#view === "confirm") {
+			const key = data.toLowerCase();
+			if (key === "y") {
+				this.#confirmYes();
+				return;
+			}
+			if (key === "n") {
+				this.#renderDetail();
+				return;
+			}
+		}
+		this.#selectList?.handleInput(data);
+	}
+
+	#replaceList(
+		items: SelectItem[],
+		onSelect: (item: SelectItem) => void,
+		onCancel: () => void,
+		maxVisible = 12,
+	): void {
+		this.clear();
+		this.addChild(new DynamicBorder());
+		this.#selectList = new SelectList(items, maxVisible, getSelectListTheme());
+		this.#selectList.onSelect = onSelect;
+		this.#selectList.onCancel = onCancel;
+		this.addChild(this.#selectList);
+		this.addChild(new DynamicBorder());
+		this.#callbacks.requestRender();
+	}
+
+	#renderList(): void {
+		this.#view = "list";
+		this.#ref = undefined;
+		this.#action = undefined;
+		const snapshot = this.#controller.getSnapshot();
+		const built = buildJobsListItems(snapshot);
+		const items = built.length > 0 ? built : [{ value: "close", label: "No active monitor or cron jobs" }];
+		this.#replaceList(
+			items,
+			item => {
+				const ref = parseJobRef(item.value);
+				if (ref) this.#renderDetail(ref);
+				else this.#callbacks.close();
+			},
+			() => this.#callbacks.close(),
+		);
+	}
+
+	#renderDetail(ref = this.#ref): void {
+		if (!ref) {
+			this.#renderList();
+			return;
+		}
+		this.#view = "detail";
+		this.#ref = ref;
+		this.#action = undefined;
+		const output = ref.kind === "monitor" ? this.#controller.getMonitorOutput(ref.id) : "";
+		const items = buildJobDetailItems(this.#controller.getSnapshot(), ref, output);
+		this.#replaceList(
+			items,
+			item => {
+				if (item.value === "action:cancel") this.#renderConfirm("cancel");
+				else if (item.value === "action:delete") this.#renderConfirm("delete");
+				else if (item.value === "back") this.#renderList();
+			},
+			() => this.#callbacks.close(),
+		);
+	}
+
+	#renderConfirm(action: JobsOverlayAction): void {
+		if (!this.#ref) {
+			this.#renderList();
+			return;
+		}
+		this.#view = "confirm";
+		this.#action = action;
+		const label = action === "cancel" ? "cancel this monitor" : "delete this cron";
+		this.#replaceList(
+			buildConfirmItems(label),
+			item => {
+				if (item.value === "yes") this.#confirmYes();
+				else this.#renderDetail();
+			},
+			() => this.#renderDetail(),
+			4,
+		);
+	}
+
+	#confirmYes(): void {
+		if (!this.#ref || !this.#action) {
+			this.#renderList();
+			return;
+		}
+		if (this.#action === "cancel") this.#controller.cancelMonitor(this.#ref.id);
+		else this.#controller.deleteCron(this.#ref.id);
+		this.#renderList();
+	}
+}

package/src/modes/components/status-line/presets.ts

@@ -3,7 +3,7 @@ import type { PresetDef, StatusLinePreset } from "./types";
 export const STATUS_LINE_PRESETS: Record<StatusLinePreset, PresetDef> = {
 	default: {
 		leftSegments: ["model", "mode", "git", "pr", "path"],
-		rightSegments: ["session_name", "token_rate", "context_pct", "cost"],
+		rightSegments: ["session_name", "jobs", "token_rate", "context_pct", "cost"],
 		separator: "slash",
 		segmentOptions: {
 			model: { showThinkingLevel: true },
@@ -14,7 +14,7 @@ export const STATUS_LINE_PRESETS: Record<StatusLinePreset, PresetDef> = {
 
 	minimal: {
 		leftSegments: ["path", "git"],
-		rightSegments: ["session_name", "mode", "context_pct"],
+		rightSegments: ["session_name", "jobs", "mode", "context_pct"],
 		separator: "slash",
 		segmentOptions: {
 			path: { abbreviate: true, maxLength: 30 },
@@ -24,7 +24,7 @@ export const STATUS_LINE_PRESETS: Record<StatusLinePreset, PresetDef> = {
 
 	compact: {
 		leftSegments: ["model", "mode", "git", "pr"],
-		rightSegments: ["session_name", "cost", "context_pct"],
+		rightSegments: ["session_name", "jobs", "cost", "context_pct"],
 		separator: "slash",
 		segmentOptions: {
 			model: { showThinkingLevel: false },
@@ -36,6 +36,7 @@ export const STATUS_LINE_PRESETS: Record<StatusLinePreset, PresetDef> = {
 		leftSegments: ["gajae", "hostname", "model", "mode", "path", "git", "pr", "subagents"],
 		rightSegments: [
 			"session_name",
+			"jobs",
 			"token_in",
 			"token_out",
 			"token_rate",
@@ -59,6 +60,7 @@ export const STATUS_LINE_PRESETS: Record<StatusLinePreset, PresetDef> = {
 		leftSegments: ["gajae", "hostname", "model", "mode", "path", "git", "pr", "session", "subagents"],
 		rightSegments: [
 			"session_name",
+			"jobs",
 			"token_in",
 			"token_out",
 			"cache_read",
@@ -82,7 +84,7 @@ export const STATUS_LINE_PRESETS: Record<StatusLinePreset, PresetDef> = {
 	ascii: {
 		// No Nerd Font dependencies
 		leftSegments: ["model", "mode", "path", "git", "pr"],
-		rightSegments: ["session_name", "token_total", "cost", "context_pct"],
+		rightSegments: ["session_name", "jobs", "token_total", "cost", "context_pct"],
 		separator: "ascii",
 		segmentOptions: {
 			model: { showThinkingLevel: true },
@@ -94,7 +96,7 @@ export const STATUS_LINE_PRESETS: Record<StatusLinePreset, PresetDef> = {
 	custom: {
 		// User-defined - these are just defaults that get overridden
 		leftSegments: ["model", "mode", "path", "git", "pr"],
-		rightSegments: ["session_name", "token_total", "cost", "context_pct"],
+		rightSegments: ["session_name", "jobs", "token_total", "cost", "context_pct"],
 		separator: "slash",
 		segmentOptions: {},
 	},

package/src/modes/components/status-line/segments.ts

@@ -270,6 +270,30 @@ const subagentsSegment: StatusLineSegment = {
 	},
 };
 
+const jobsSegment: StatusLineSegment = {
+	id: "jobs",
+	render(ctx) {
+		const { jobs } = ctx;
+		const visible = jobs.activeMonitorCount > 0 || jobs.activeCronCount > 0 || jobs.worstState === "failed";
+		if (!visible) {
+			return { content: "", visible: false };
+		}
+		const parts: string[] = [];
+		if (jobs.activeMonitorCount > 0) {
+			parts.push(withIcon(theme.icon.agents, `${jobs.activeMonitorCount}`));
+		}
+		if (jobs.activeCronCount > 0) {
+			parts.push(withIcon(theme.icon.time, `${jobs.activeCronCount}`));
+		}
+		if (parts.length === 0) {
+			// Nothing active but a failure is unacknowledged — keep a drill-in marker.
+			parts.push(withIcon(theme.icon.warning, "jobs"));
+		}
+		const color: ThemeColor = jobs.worstState === "failed" ? "error" : "statusLineSubagents";
+		return { content: theme.fg(color, parts.join(" ")), visible: true };
+	},
+};
+
 const tokenInSegment: StatusLineSegment = {
 	id: "token_in",
 	render(ctx) {
@@ -521,6 +545,7 @@ export const SEGMENTS: Record<StatusLineSegmentId, StatusLineSegment> = {
 	git: gitSegment,
 	pr: prSegment,
 	subagents: subagentsSegment,
+	jobs: jobsSegment,
 	token_in: tokenInSegment,
 	token_out: tokenOutSegment,
 	token_total: tokenTotalSegment,

package/src/modes/components/status-line/types.ts

@@ -1,5 +1,6 @@
 import type { StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle } from "../../../config/settings-schema";
 import type { AgentSession } from "../../../session/agent-session";
+import type { JobsSnapshot } from "../../jobs-observer";
 import type { StatusLineSegmentOptions, StatusLineSettings } from "../status-line";
 
 export type {
@@ -42,6 +43,7 @@ export interface SegmentContext {
 	contextWindow: number;
 	autoCompactEnabled: boolean;
 	subagentCount: number;
+	jobs: JobsSnapshot;
 	sessionStartTime: number;
 	git: {
 		branch: string | null;

package/src/modes/components/status-line.ts

@@ -11,6 +11,7 @@ import type { AgentSession } from "../../session/agent-session";
 import { readVisibleSkillActiveState, type SkillActiveEntry } from "../../skill-state/active-state";
 import * as git from "../../utils/git";
 import { getSessionAccentAnsi, getSessionAccentHex } from "../../utils/session-color";
+import { EMPTY_JOBS_SNAPSHOT, type JobsSnapshot } from "../jobs-observer";
 import { sanitizeStatusText } from "../shared";
 import { computeNonMessageTokens } from "../utils/context-usage";
 import { renderSkillHudBar } from "./skill-hud/render";
@@ -153,6 +154,7 @@ export class StatusLineComponent implements Component {
 	#autoCompactEnabled: boolean = true;
 	#hookStatuses: Map<string, string> = new Map();
 	#subagentCount: number = 0;
+	#jobs: JobsSnapshot = EMPTY_JOBS_SNAPSHOT;
 	#sessionStartTime: number = Date.now();
 	#planModeStatus: { enabled: boolean; paused: boolean } | null = null;
 	#goalModeStatus: { enabled: boolean; paused: boolean } | null = null;
@@ -220,6 +222,10 @@ export class StatusLineComponent implements Component {
 		this.#subagentCount = count;
 	}
 
+	setJobs(jobs: JobsSnapshot): void {
+		this.#jobs = jobs;
+	}
+
 	setSessionStartTime(time: number): void {
 		this.#sessionStartTime = time;
 	}
@@ -612,6 +618,7 @@ export class StatusLineComponent implements Component {
 			contextWindow,
 			autoCompactEnabled: this.#autoCompactEnabled,
 			subagentCount: this.#subagentCount,
+			jobs: this.#jobs,
 			sessionStartTime: this.#sessionStartTime,
 			git: {
 				branch: this.#getCurrentBranch(),
@@ -687,7 +694,8 @@ export class StatusLineComponent implements Component {
 			}
 		}
 
-		const runningBackgroundJobs = this.session.getAsyncJobSnapshot()?.running.length ?? 0;
+		const runningBackgroundJobs =
+			this.session.getAsyncJobSnapshot()?.running.filter(job => job.metadata?.monitor !== true).length ?? 0;
 		if (runningBackgroundJobs > 0) {
 			const icon = theme.icon.agents ? `${theme.icon.agents} ` : "";
 			const label = `${formatCount("job", runningBackgroundJobs)} running`;

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

@@ -41,6 +41,7 @@ import { AgentDashboard } from "../components/agent-dashboard";
 import { AssistantMessageComponent } from "../components/assistant-message";
 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 +56,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>([
@@ -1150,4 +1152,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 {