@gajae-code/coding-agent 0.5.4 → 0.6.1

package/src/modes/components/skill-message.ts

@@ -1,9 +1,20 @@
 import type { TextContent } from "@gajae-code/ai";
 import type { Component } from "@gajae-code/tui";
-import { Box, Container, Markdown, Spacer, Text, truncateToWidth } from "@gajae-code/tui";
+import {
+	Box,
+	Container,
+	Markdown,
+	replaceTabs,
+	Spacer,
+	Text,
+	truncateToWidth,
+	wrapTextWithAnsi,
+} from "@gajae-code/tui";
 import { getMarkdownTheme, theme } from "../../modes/theme/theme";
 import type { CustomMessage, SkillPromptDetails } from "../../session/messages";
 
+const COLLAPSED_ARGS_PREVIEW_WIDTH = 96;
+const COLLAPSED_ARGS_PREVIEW_LINES = 6;
 export class SkillMessageComponent extends Container {
 	#box: Box;
 	#contentComponent?: Component;
@@ -43,14 +54,16 @@ export class SkillMessageComponent extends Container {
 		const name = details?.name ?? "unknown";
 		const args = details?.args?.trim();
 
-		// Single compact line: `[skill] <name>: <args>`. The summary is the
-		// args the user typed; with none, just `[skill] <name>`. Collapsed to
-		// one line — path / line-count / full prompt body are debugging detail
-		// and only render once expanded.
-		const summary = args ? truncateToWidth(args.replace(/\s+/g, " "), 72) : undefined;
+		// Collapsed view keeps args readable without exposing the full prompt body.
+		// Each visual line is bounded, but multi-line arguments remain multi-line so
+		// the invocation context is not mistaken for a one-line truncated payload.
+		const argsPreview = args ? this.#formatArgsPreview(args) : [];
 		const header = `${theme.fg("customMessageLabel", theme.bold("[skill]"))} ${theme.fg("customMessageText", name)}`;
-		const headerText = summary ? `${header}${theme.fg("customMessageText", `: ${summary}`)}` : header;
-		this.#box.addChild(new Text(headerText, 0, 0));
+		this.#box.addChild(new Text(header, 0, 0));
+		if (argsPreview.length > 0) {
+			this.#box.addChild(new Spacer(1));
+			this.#box.addChild(new Text(argsPreview.map(line => theme.fg("customMessageText", line)).join("\n"), 0, 0));
+		}
 
 		if (!this.#expanded) {
 			return;
@@ -70,6 +83,18 @@ export class SkillMessageComponent extends Container {
 			);
 		}
 
+		if (args) {
+			this.#box.addChild(new Spacer(1));
+			const argsHeader = theme.fg("customMessageLabel", theme.bold("Arguments"));
+			this.#box.addChild(new Text(argsHeader, 0, 0));
+			this.#box.addChild(new Spacer(1));
+			this.#box.addChild(
+				new Markdown(replaceTabs(args), 0, 0, getMarkdownTheme(), {
+					color: (value: string) => theme.fg("customMessageText", value),
+				}),
+			);
+		}
+
 		const text = this.#extractText();
 		if (!text) {
 			return;
@@ -86,6 +111,35 @@ export class SkillMessageComponent extends Container {
 		this.#box.addChild(this.#contentComponent);
 	}
 
+	#formatArgsPreview(args: string): string[] {
+		const preview: string[] = [];
+		let omitted = false;
+		const sourceLines = replaceTabs(args).split(/\r?\n/);
+		for (let index = 0; index < sourceLines.length; index += 1) {
+			const sourceLine = sourceLines[index]?.trimEnd() ?? "";
+			const wrapped = wrapTextWithAnsi(sourceLine.length > 0 ? sourceLine : " ", COLLAPSED_ARGS_PREVIEW_WIDTH);
+			for (const line of wrapped.length > 0 ? wrapped : [""]) {
+				if (preview.length >= COLLAPSED_ARGS_PREVIEW_LINES) {
+					omitted = true;
+					break;
+				}
+				preview.push(truncateToWidth(line, COLLAPSED_ARGS_PREVIEW_WIDTH));
+			}
+			if (omitted) break;
+		}
+		if (sourceLines.length > 0 && preview.length === COLLAPSED_ARGS_PREVIEW_LINES) {
+			const visibleSource = preview.join("\n");
+			omitted ||= replaceTabs(args).trimEnd().length > visibleSource.trimEnd().length;
+		}
+		if (omitted && preview.length > 0) {
+			preview[preview.length - 1] = truncateToWidth(
+				`${preview[preview.length - 1]} …`,
+				COLLAPSED_ARGS_PREVIEW_WIDTH,
+			);
+		}
+		return preview;
+	}
+
 	#extractText(): string {
 		if (typeof this.message.content === "string") {
 			return this.message.content;

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

@@ -44,6 +44,10 @@ export interface StatusLineSettings {
 	sessionAccent?: boolean;
 }
 
+export interface StatusLineComponentOptions {
+	version?: string;
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Per-message token cache
 // ═══════════════════════════════════════════════════════════════════════════
@@ -161,6 +165,7 @@ export class StatusLineComponent implements Component {
 	#skillHudEntries: SkillActiveEntry[] = [];
 	#skillHudLastFetch = 0;
 	#skillHudInFlight = false;
+	#version: string | undefined;
 
 	// Git status caching (1s TTL)
 	#cachedGitStatus: { staged: number; unstaged: number; untracked: number } | null = null;
@@ -197,7 +202,10 @@ export class StatusLineComponent implements Component {
 	#nonMessageTokensCache: number | undefined;
 	#nonMessageInputsKey: string | undefined;
 
-	constructor(private readonly session: AgentSession) {
+	constructor(
+		private readonly session: AgentSession,
+		options: StatusLineComponentOptions = {},
+	) {
 		this.#settings = {
 			preset: settings.get("statusLine.preset"),
 			leftSegments: settings.get("statusLine.leftSegments"),
@@ -208,6 +216,7 @@ export class StatusLineComponent implements Component {
 			segmentOptions: settings.getGroup("statusLine").segmentOptions,
 			sessionAccent: settings.get("statusLine.sessionAccent"),
 		};
+		this.#version = options.version?.trim() || undefined;
 	}
 
 	updateSettings(settings: StatusLineSettings): void {
@@ -701,6 +710,9 @@ export class StatusLineComponent implements Component {
 			const label = `${formatCount("job", runningBackgroundJobs)} running`;
 			rightParts.push(theme.fg("statusLineSubagents", `${icon}${label}`));
 		}
+		if (this.#version) {
+			rightParts.push(theme.fg("dim", `v${this.#version}`));
+		}
 		const topFillWidth = Math.max(0, width);
 		const left = [...leftParts];
 		const right = [...rightParts];

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

@@ -34,6 +34,8 @@ function isExpandable(obj: unknown): obj is Expandable {
 export class InputController {
 	constructor(private ctx: InteractiveModeContext) {}
 
+	#lastBackgroundFoldKeyTime = 0;
+
 	/** 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. */
@@ -195,6 +197,8 @@ export class InputController {
 		this.ctx.editor.onExpandTools = () => this.toggleToolOutputExpansion();
 		this.ctx.editor.setActionKeys("app.message.dequeue", this.ctx.keybindings.getKeys("app.message.dequeue"));
 		this.ctx.editor.onDequeue = () => this.handleDequeue();
+		this.ctx.editor.setActionKeys("app.message.queue", this.ctx.keybindings.getKeys("app.message.queue"));
+		this.ctx.editor.onQueue = () => void this.handleQueueSubmit();
 
 		this.ctx.editor.clearCustomKeyHandlers();
 		// Wire up extension shortcuts
@@ -206,16 +210,22 @@ export class InputController {
 		}
 
 		for (const key of this.ctx.keybindings.getKeys("app.session.new")) {
-			this.ctx.editor.setCustomKeyHandler(key, () => this.ctx.handleClearCommand());
+			this.ctx.editor.setCustomKeyHandler(key, () => void this.ctx.handleClearCommand());
 		}
 		for (const key of this.ctx.keybindings.getKeys("app.session.tree")) {
-			this.ctx.editor.setCustomKeyHandler(key, () => this.ctx.showTreeSelector());
+			this.ctx.editor.setCustomKeyHandler(key, () => {
+				this.ctx.showTreeSelector();
+			});
 		}
 		for (const key of this.ctx.keybindings.getKeys("app.session.fork")) {
-			this.ctx.editor.setCustomKeyHandler(key, () => this.ctx.showUserMessageSelector());
+			this.ctx.editor.setCustomKeyHandler(key, () => {
+				this.ctx.showUserMessageSelector();
+			});
 		}
 		for (const key of this.ctx.keybindings.getKeys("app.session.resume")) {
-			this.ctx.editor.setCustomKeyHandler(key, () => this.ctx.showSessionSelector());
+			this.ctx.editor.setCustomKeyHandler(key, () => {
+				this.ctx.showSessionSelector();
+			});
 		}
 		for (const key of this.ctx.keybindings.getKeys("app.message.followUp")) {
 			this.ctx.editor.setCustomKeyHandler(key, () => void this.handleFollowUp());
@@ -224,13 +234,22 @@ export class InputController {
 			this.ctx.editor.setCustomKeyHandler(key, () => void this.ctx.handleSTTToggle());
 		}
 		for (const key of this.ctx.keybindings.getKeys("app.clipboard.copyLine")) {
-			this.ctx.editor.setCustomKeyHandler(key, () => this.handleCopyCurrentLine());
+			this.ctx.editor.setCustomKeyHandler(key, () => {
+				this.handleCopyCurrentLine();
+			});
 		}
 		for (const key of this.ctx.keybindings.getKeys("app.session.observe")) {
-			this.ctx.editor.setCustomKeyHandler(key, () => this.ctx.showSessionObserver());
+			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.setCustomKeyHandler(key, () => {
+				this.ctx.showJobsOverlay();
+			});
+		}
+		for (const key of this.ctx.keybindings.getKeys("app.tool.backgroundFold")) {
+			this.ctx.editor.setCustomKeyHandler(key, () => this.handleForegroundToolBackgroundFold());
 		}
 
 		this.ctx.editor.onChange = (text: string) => {
@@ -311,8 +330,8 @@ export class InputController {
 			// Handle skill commands (/skill:name [args]). While streaming, Enter
 			// honors `busyPromptMode`: "steer" interrupts the active turn, "queue"
 			// runs after it completes (matches the free-text Enter semantics applied
-			// a few lines below at the streaming branch). Ctrl+Enter always routes
-			// through `handleFollowUp` and dispatches the same helper with `"followUp"`.
+			// a few lines below at the streaming branch). Explicit queue shortcuts
+			// route through `handleFollowUp` and dispatch as `followUp`.
 			if (await this.#invokeSkillCommand(text, this.#busyStreamingBehavior())) {
 				return;
 			}
@@ -481,7 +500,7 @@ export class InputController {
 	 * completes (in submission order). Only consulted while streaming.
 	 */
 	#busyStreamingBehavior(): "steer" | "followUp" {
-		return this.ctx.settings.get("busyPromptMode") === "queue" ? "followUp" : "steer";
+		return this.ctx.settings.get("busyPromptMode") === "steer" ? "steer" : "followUp";
 	}
 
 	/**
@@ -580,7 +599,7 @@ export class InputController {
 
 		// Skill commands invoke through the custom-message path regardless of
 		// which keybinding submitted them. Enter routes them as `steer`;
-		// Ctrl+Enter (this handler) routes them as `followUp`.
+		// explicit queue shortcuts route them as `followUp`.
 		if (await this.#invokeSkillCommand(text, "followUp")) {
 			return;
 		}
@@ -602,6 +621,11 @@ export class InputController {
 		await this.ctx.withLocalSubmission(text, () => this.ctx.session.prompt(text));
 	}
 
+	/** Send editor text explicitly as a queued next-turn message. */
+	async handleQueueSubmit(): Promise<void> {
+		return this.handleFollowUp();
+	}
+
 	restoreQueuedMessagesToEditor(options?: { abort?: boolean; currentText?: string }): number {
 		this.ctx.locallySubmittedUserSignatures.clear();
 		const { steering, followUp } = this.ctx.session.clearQueue();
@@ -690,6 +714,31 @@ export class InputController {
 		process.kill(0, "SIGTSTP");
 	}
 
+	handleForegroundToolBackgroundFold(): boolean {
+		if (!this.ctx.session.hasForegroundBashBackgroundRequestHandler?.()) {
+			this.#lastBackgroundFoldKeyTime = 0;
+			return false;
+		}
+
+		const now = Date.now();
+		if (now - this.#lastBackgroundFoldKeyTime > 750) {
+			this.#lastBackgroundFoldKeyTime = now;
+			this.ctx.showStatus("Press Ctrl+B again to fold supported foreground bash into a background job");
+			return true;
+		}
+		this.#lastBackgroundFoldKeyTime = 0;
+
+		if (!this.ctx.session.requestForegroundBashBackground?.()) {
+			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;
+	}
+
 	handleTextPaste(text: string): boolean | Promise<boolean> {
 		const imagePath = this.#getPastedImagePathCandidate(text);
 		return imagePath ? this.#attachPastedImagePath(imagePath) : false;

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

@@ -49,6 +49,10 @@ import {
 import { setSessionTerminalTitle } from "../../utils/title-generator";
 import { AgentDashboard } from "../components/agent-dashboard";
 import { AssistantMessageComponent } from "../components/assistant-message";
+import {
+	CustomModelPresetWizardComponent,
+	type CustomModelPresetWizardSubmit,
+} from "../components/custom-model-preset-wizard";
 import { CustomProviderWizardComponent, type CustomProviderWizardSubmit } from "../components/custom-provider-wizard";
 import { ExtensionDashboard } from "../components/extensions";
 import { HistorySearchComponent } from "../components/history-search";
@@ -213,6 +217,36 @@ export class SelectorController {
 		this.ctx.ui.requestRender();
 	}
 
+	showCustomModelPresetWizard(): void {
+		this.showSelector(done => {
+			let wizard: CustomModelPresetWizardComponent;
+			const submit = async (input: CustomModelPresetWizardSubmit): Promise<void> => {
+				try {
+					const profile = await this.ctx.session.modelRegistry.saveCustomModelProfile(input.name, input.profile);
+					await this.ctx.session.modelRegistry.refresh("offline");
+					await this.ctx.notifyConfigChanged?.();
+					this.ctx.showStatus(`Custom model preset created: ${profile.displayName ?? profile.name}`);
+					done();
+					this.ctx.ui.requestRender();
+				} catch (err) {
+					const message = err instanceof Error ? err.message : String(err);
+					wizard.setSubmitError(`Preset creation failed: ${message}`);
+				}
+			};
+			wizard = new CustomModelPresetWizardComponent(
+				input => {
+					void submit(input);
+				},
+				() => {
+					done();
+					this.ctx.ui.requestRender();
+				},
+				() => this.ctx.ui.requestRender(),
+			);
+			return { component: wizard, focus: wizard };
+		});
+	}
+
 	showCustomProviderWizard(): void {
 		this.showSelector(done => {
 			let wizard: CustomProviderWizardComponent;
@@ -618,6 +652,11 @@ export class SelectorController {
 				this.ctx.session.scopedModels,
 				async selection => {
 					try {
+						if (selection.kind === "createProfile") {
+							done();
+							this.showCustomModelPresetWizard();
+							return;
+						}
 						if (selection.kind === "profile") {
 							await activateModelProfile(
 								{

package/src/modes/interactive-mode.ts

@@ -406,7 +406,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.hookWidgetContainerBelow = new Container();
 		this.editorContainer = new Container();
 		this.editorContainer.addChild(this.editor);
-		this.statusLine = new StatusLineComponent(session);
+		this.statusLine = new StatusLineComponent(session, { version: this.#version });
 		this.statusLine.setAutoCompactEnabled(session.autoCompactionEnabled);
 
 		this.hideThinkingBlock = settings.get("hideThinkingBlock");

package/src/modes/print-mode.ts

@@ -23,6 +23,12 @@ export interface PrintModeOptions {
 	initialMessage?: string;
 	/** Images to attach to the initial message */
 	initialImages?: ImageContent[];
+	/**
+	 * When true, an assistant error/abort does not call process.exit(); print mode
+	 * returns instead so the caller (e.g. RLM autonomous mode) can run its own
+	 * finalization/cleanup before the process exits.
+	 */
+	suppressProcessExit?: boolean;
 }
 
 /**
@@ -84,10 +90,14 @@ export async function runPrintMode(session: AgentSession, options: PrintModeOpti
 			) {
 				const errorLine = sanitizeText(assistantMsg.errorMessage || `Request ${assistantMsg.stopReason}`);
 				const flushed = process.stderr.write(`${errorLine}\n`);
-				if (flushed) {
-					process.exit(1);
-				} else {
-					process.stderr.once("drain", () => process.exit(1));
+				// When the caller owns finalization (RLM autonomous), return instead of
+				// exiting so its cleanup runs; the caller surfaces a non-zero exit itself.
+				if (!options.suppressProcessExit) {
+					if (flushed) {
+						process.exit(1);
+					} else {
+						process.stderr.once("drain", () => process.exit(1));
+					}
 				}
 			}