@gajae-code/coding-agent 0.15.4 → 0.15.6

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

@@ -1,7 +1,7 @@
 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, matchesKey, type SlashCommand } from "@gajae-code/tui";
+import { type AutocompleteProvider, getKeybindings, matchesKey, type SlashCommand } from "@gajae-code/tui";
 import { $pickenv, logger, sanitizeText } from "@gajae-code/utils";
 import { type AppKeybinding, KEYBINDINGS } from "../../config/keybindings";
 import { isSettingsInitialized, settings } from "../../config/settings";
@@ -1855,19 +1855,36 @@ export class InputController {
 		const now = Date.now();
 		if (now - this.#lastBackgroundFoldKeyTime > BACKGROUND_FOLD_DOUBLE_PRESS_MS) {
 			this.#lastBackgroundFoldKeyTime = now;
-			this.ctx.showStatus("Press Ctrl+B again to fold supported foreground bash into a background job");
+			const foldKeys = getKeybindings().getKeys("app.tool.backgroundFold");
+			this.ctx.showStatus(
+				`Press ${foldKeys.join(" / ")} again to fold supported foreground bash into a background job`,
+			);
 			return true;
 		}
 		this.#lastBackgroundFoldKeyTime = 0;
 
-		if (!this.ctx.session.requestForegroundBashBackground?.()) {
+		try {
+			const request = this.ctx.session.requestForegroundBashBackground?.() ?? Promise.resolve(false);
+			void request
+				.then(backgrounded => {
+					if (backgrounded) {
+						this.ctx.showStatus("Folding foreground bash into a quiet background job…");
+						return;
+					}
+					this.ctx.showWarning(
+						"No supported foreground tool can be folded. Use managed async bash/auto-background; raw Ctrl+Z/bg is not supported inside the TUI.",
+					);
+				})
+				.catch(() => {
+					this.ctx.showWarning(
+						"No supported foreground tool can be folded. Use managed async bash/auto-background; raw Ctrl+Z/bg is not supported inside the TUI.",
+					);
+				});
+		} catch {
 			this.ctx.showWarning(
 				"No supported foreground tool can be folded. Use managed async bash/auto-background; raw Ctrl+Z/bg is not supported inside the TUI.",
 			);
-			return true;
 		}
-
-		this.ctx.showStatus("Folding foreground bash into a quiet background job…");
 		return true;
 	}
 

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;

package/src/modes/prompt-action-autocomplete.ts

@@ -1,9 +1,12 @@
 import {
 	type AutocompleteItem,
 	type AutocompleteProvider,
+	autocompleteFuzzyMatch,
+	autocompleteFuzzyScore,
 	CombinedAutocompleteProvider,
 	extractSlashCommandTokenPrefix,
 	getSlashCommandMatchRank,
+	normalizeFuzzyText,
 	type SlashCommand,
 } from "@gajae-code/tui";
 import type { KeybindingsManager } from "../config/keybindings";
@@ -50,43 +53,6 @@ interface PromptActionAutocompleteOptions {
 	getPromptSuggestion?: () => string | null;
 }
 
-function fuzzyMatch(query: string, target: string): boolean {
-	if (query.length === 0) return true;
-	if (query.length > target.length) return false;
-
-	let queryIndex = 0;
-	for (let targetIndex = 0; targetIndex < target.length && queryIndex < query.length; targetIndex += 1) {
-		if (query[queryIndex] === target[targetIndex]) {
-			queryIndex += 1;
-		}
-	}
-
-	return queryIndex === query.length;
-}
-
-function fuzzyScore(query: string, target: string): number {
-	if (query.length === 0) return 1;
-	if (target === query) return 100;
-	if (target.startsWith(query)) return 80;
-	if (target.includes(query)) return 60;
-
-	let queryIndex = 0;
-	let gaps = 0;
-	let lastMatchIndex = -1;
-	for (let targetIndex = 0; targetIndex < target.length && queryIndex < query.length; targetIndex += 1) {
-		if (query[queryIndex] === target[targetIndex]) {
-			if (lastMatchIndex >= 0 && targetIndex - lastMatchIndex > 1) {
-				gaps += 1;
-			}
-			lastMatchIndex = targetIndex;
-			queryIndex += 1;
-		}
-	}
-
-	if (queryIndex !== query.length) return 0;
-	return Math.max(1, 40 - gaps * 5);
-}
-
 function isPromptActionItem(item: AutocompleteItem): item is PromptActionAutocompleteItem {
 	return "actionId" in item && "execute" in item && typeof item.execute === "function";
 }
@@ -127,6 +93,7 @@ function sortSlashCommandSuggestions(
 ): { items: AutocompleteItem[]; prefix: string } | null {
 	if (!suggestions) return null;
 	const query = suggestions.prefix.slice(1).toLowerCase();
+	const normalizedQuery = normalizeFuzzyText(query);
 	const commandIndexes = new Map(commands.map((command, index) => [command.name, index]));
 	const commandByName = new Map(commands.map(command => [command.name, command]));
 	const items = suggestions.items
@@ -135,13 +102,20 @@ function sortSlashCommandSuggestions(
 			const commandIndex = commandIndexes.get(item.value) ?? index;
 			const lowerName = item.value.toLowerCase();
 			const lowerDesc = command?.description?.toLowerCase() ?? item.description?.toLowerCase() ?? "";
-			const nameScore = fuzzyMatch(query, lowerName) ? fuzzyScore(query, lowerName) : 0;
-			const descScore = fuzzyMatch(query, lowerDesc) ? fuzzyScore(query, lowerDesc) * 0.5 : 0;
+			const normalizedName = normalizeFuzzyText(item.value);
+			const normalizedDesc = normalizeFuzzyText(lowerDesc);
+			const nameScore = autocompleteFuzzyMatch(normalizedQuery, normalizedName)
+				? autocompleteFuzzyScore(normalizedQuery, normalizedName)
+				: 0;
+			const descScore = autocompleteFuzzyMatch(normalizedQuery, normalizedDesc)
+				? autocompleteFuzzyScore(normalizedQuery, normalizedDesc) * 0.5
+				: 0;
+			const isAscii = /^[\x00-\x7F]*$/.test(`${query}${item.value}`);
 			return {
 				item,
 				index,
 				commandIndex,
-				matchRank: getSlashCommandMatchRank(query, lowerName),
+				matchRank: isAscii ? getSlashCommandMatchRank(query, lowerName) : 4,
 				priority: getSlashCommandPriority(command, item),
 				score: Math.max(nameScore, descScore),
 			};
@@ -219,14 +193,14 @@ export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 					const searchable = [action.id, action.label, action.description, ...action.keywords]
 						.join(" ")
 						.toLowerCase();
-					if (!fuzzyMatch(query, searchable)) return null;
+					if (!autocompleteFuzzyMatch(query, searchable)) return null;
 					return {
 						value: action.label,
 						label: action.label,
 						description: action.description,
 						actionId: action.id,
 						execute: action.execute,
-						score: fuzzyScore(query, searchable),
+						score: autocompleteFuzzyScore(query, searchable),
 					} satisfies PromptActionAutocompleteItem & { score: number };
 				})
 				.filter(item => item !== null)
@@ -350,7 +324,10 @@ export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 		if (!prefix) return null;
 		const query = prefix.slice(1).toLowerCase();
 		if (query.length === 0 && !options.includeEmpty) return null;
-		const normalizedQuery = query.startsWith("skill-") ? `skill:${query.slice("skill-".length)}` : query;
+		const normalizedQuery = normalizeFuzzyText(
+			query.startsWith("skill-") ? `skill:${query.slice("skill-".length)}` : query,
+		);
+		if (query.length > 0 && normalizedQuery.length === 0) return null;
 		const exactNonSkillCommand = this.#commands.some(
 			command => command.name === query && !command.name.startsWith("skill:"),
 		);
@@ -364,16 +341,18 @@ export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 					`skill-${skillName}`,
 					...(exactNonSkillCommand ? [] : [skillName]),
 					command.description ?? "",
-				].map(target => target.toLowerCase());
+				].map(target => normalizeFuzzyText(target));
 				if (
-					!searchTargets.some(target => fuzzyMatch(normalizedQuery, target) || target.includes(normalizedQuery))
+					!searchTargets.some(
+						target => autocompleteFuzzyMatch(normalizedQuery, target) || target.includes(normalizedQuery),
+					)
 				) {
 					return null;
 				}
 				const bestScore = Math.max(
 					...searchTargets.map(target =>
-						fuzzyMatch(normalizedQuery, target)
-							? fuzzyScore(normalizedQuery, target)
+						autocompleteFuzzyMatch(normalizedQuery, target)
+							? autocompleteFuzzyScore(normalizedQuery, target)
 							: target.includes(normalizedQuery)
 								? 60
 								: 0,

package/src/modes/runtime-init.ts

@@ -343,7 +343,7 @@ export async function initializeExtensions(session: AgentSession, options: Initi
 						return { retried: true, immediate: true };
 					}
 					case "bash.background": {
-						if (!session.requestForegroundBashBackground())
+						if (!(await session.requestForegroundBashBackground()))
 							throw Object.assign(
 								new Error("The active bash command cannot be moved to a managed background job."),
 								{ code: "not_foldable" },

package/src/modes/utils/injected-user-submission.ts

@@ -17,7 +17,11 @@ import type { InteractiveModeContext } from "../types";
  * (unhandled rejection → resident crash).
  */
 export function extensionUserMessageContentError(content: string | (TextContent | ImageContent)[]): Error | undefined {
-	if (typeof content === "string") return undefined;
+	if (typeof content === "string") {
+		if (content.trim().length === 0)
+			return Object.assign(new Error("Prompt must not be empty."), { code: "invalid_input" });
+		return undefined;
+	}
 	if (!Array.isArray(content)) {
 		return Object.assign(new Error("sendUserMessage requires string or content-array content."), {
 			code: "invalid_input",
@@ -30,6 +34,16 @@ export function extensionUserMessageContentError(content: string | (TextContent
 			});
 		}
 	}
+	const text = content
+		.filter((part): part is TextContent => part.type === "text")
+		.map(part => part.text)
+		.join("\n");
+	const hasUsableImage = content.some(
+		(part): part is ImageContent =>
+			part.type === "image" && typeof part.data === "string" && part.data.trim().length > 0,
+	);
+	if (text.trim().length === 0 && !hasUsableImage)
+		return Object.assign(new Error("Prompt must not be empty."), { code: "invalid_input" });
 	return undefined;
 }
 export function normalizeInjectedUserContent(content: string | (TextContent | ImageContent)[]): {

package/src/prompts/tools/bash.md

@@ -16,8 +16,8 @@ Executes bash command in shell session for terminal operations like git, bun, ca
 {{#if asyncEnabled}}
 - Use `async: true` for long-running commands when you don't need immediate output; the call returns a background job ID and the result is delivered automatically as a follow-up.
 {{/if}}
-{{#if autoBackgroundEnabled}}
-- In the interactive TUI, the user can press `Ctrl+B` twice while a supported managed foreground bash command is still running to fold it into a quiet background job. Do not instruct users to use raw shell `Ctrl+Z`/`bg` inside the GJC TUI; ownership and output routing are not safe there.
+{{#if foregroundFoldEnabled}}
+- In the interactive TUI, the user can press the fold chord twice (default `Alt+Shift+B`, plus `Cmd+B` on macOS; remappable via the `app.tool.backgroundFold` keybinding) while a foreground command is still running to fold it into a background job. All three command surfaces fold: managed non-PTY bash, editor/ACP client-terminal commands, and PTY-mode commands. A folded command keeps its original timeout and is never killed or restarted by folding; a folded PTY continues output-only, so it stops accepting input. The turn then ends cleanly and a later turn resumes automatically with the command's result, so the interrupted task is finished rather than abandoned. `task`/`subagent` waits are deliberately NOT foldable. Do not instruct users to use raw shell `Ctrl+Z`/`bg` inside the GJC TUI; ownership and output routing are not safe there.
 {{/if}}
 </instruction>
 {{#if restrictedAllowedPrefixes}}

package/src/prompts/tools/fold-receipt.md

@@ -0,0 +1,3 @@
+This result came from a folded {{kind}} wait (job {{jobId}}).
+Output reference: {{outputInstruction}}
+{{cwdNotice}}{{intentNotice}}

package/src/prompts/tools/job.md

@@ -2,7 +2,7 @@ Inspects, waits, or cancels async jobs.
 
 Background job results are delivered automatically when complete. Jobs that back task subagents should be controlled via the `subagent` tool when it is available; use `job` for non-subagent jobs (async bash, monitors) and as a compatibility fallback. Running job output stays quiet by default to avoid flooding the conversation; use `tail` when you explicitly want to show/reopen retained output. Reach for this tool only when you need to inspect or intervene.
 
-In the interactive TUI, supported managed foreground bash can be folded into a background job by pressing `Ctrl+B` twice while it is running. Raw shell `Ctrl+Z`/`bg` is not the supported path inside GJC because it bypasses job ownership and output-routing contracts.
+In the interactive TUI, a running foreground command can be folded into a background job by pressing the fold chord twice (default `Alt+Shift+B`, plus `Cmd+B` on macOS; remappable via `app.tool.backgroundFold`). This covers managed non-PTY bash, editor/ACP client-terminal commands, and PTY-mode commands. A folded job keeps its original deadline, is never killed or restarted by folding, and its result wakes a later turn automatically; a folded PTY continues output-only and no longer accepts input. `task`/`subagent` waits are not foldable. Raw shell `Ctrl+Z`/`bg` is not the supported path inside GJC because it bypasses job ownership and output-routing contracts.
 
 # Operations
 

package/src/sdk/acp/adapter.ts

@@ -9,7 +9,11 @@ import {
 	type SessionReconcileUncertainTarget,
 	validateSessionReconcileUncertainTarget,
 } from "../lifecycle/service";
-import { validateAdapterControl, validateAdapterSecretFields } from "../protocol/adapter-validation";
+import {
+	validateAdapterControl,
+	validateAdapterSecretFields,
+	validateRequiredPromptText,
+} from "../protocol/adapter-validation";
 import { OPERATIONS } from "../protocol/operation-registry";
 import { type SessionAttachment, type SessionRouter, SessionRouterError } from "../router";
 import { ACP_SESSION_RECONNECT, SESSION_ABORT_TIMEOUT_MS } from "../session-reconnect";
@@ -343,7 +347,18 @@ export class AcpSdkAdapter {
 	}
 
 	async prompt(params: JsonObject | string): Promise<unknown> {
-		const text = typeof params === "string" ? params : String(params.prompt ?? params.text ?? "");
+		const rawText =
+			typeof params === "string"
+				? params
+				: params !== null && typeof params === "object"
+					? (params.prompt ?? params.text)
+					: undefined;
+		const text = typeof rawText === "string" ? rawText : "";
+		const invalid = validateRequiredPromptText("turn.prompt", {
+			text,
+			...(typeof params === "object" && Array.isArray(params.images) ? { images: params.images } : {}),
+		});
+		if (invalid) throw new AcpSdkAdapterError(invalid.code, invalid.message);
 		return await this.#requestSession({
 			type: "control_request",
 			operation: "turn.prompt",