@gajae-code/coding-agent 0.4.2 → 0.4.4

package/src/setup/hermes-setup.ts

@@ -0,0 +1,429 @@
+import * as crypto from "node:crypto";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { YAML } from "bun";
+import {
+	COORDINATOR_MCP_PROTOCOL_VERSION,
+	COORDINATOR_MCP_SERVER_NAME,
+	COORDINATOR_MCP_TOOL_NAMES,
+} from "../coordinator/contract";
+import { createCoordinatorMcpServer } from "../coordinator-mcp/server";
+import operatorInstructionsTemplate from "./hermes/templates/operator-instructions.v1.md" with { type: "text" };
+
+export type HermesMutationClass = "sessions" | "questions" | "reports";
+export type HermesSetupMode = "render" | "install" | "check" | "smoke";
+
+export interface HermesSetupFlags {
+	json?: boolean;
+	check?: boolean;
+	smoke?: boolean;
+	install?: boolean;
+	force?: boolean;
+	root?: string[];
+	repo?: string;
+	profile?: string;
+	sessionCommand?: string;
+	stateRoot?: string;
+	mutation?: string[];
+	artifactByteCap?: string;
+	serverKey?: string;
+	gjcCommand?: string;
+	target?: string;
+	profileDir?: string;
+}
+
+export interface CoordinatorSetupSpec {
+	schemaVersion: 1;
+	coordinator: "hermes";
+	serverKey: string;
+	serverName: typeof COORDINATOR_MCP_SERVER_NAME;
+	protocolVersion: typeof COORDINATOR_MCP_PROTOCOL_VERSION;
+	gjcCommand: string;
+	args: ["mcp-serve", "coordinator"];
+	roots: string[];
+	namespace: {
+		profile?: string;
+		repo?: string;
+	};
+	sessionCommand?: string;
+	stateRoot?: string;
+	mutationPolicy: {
+		classes: HermesMutationClass[];
+		perCallConsentRequired: true;
+	};
+	artifactByteCap?: number;
+	installTarget?: {
+		kind: "profile-dir" | "config-file";
+		path: string;
+	};
+	operatorTemplateVersion: 1;
+	contractDocVersion: 1;
+}
+
+export interface HermesSetupResult {
+	ok: boolean;
+	mode: HermesSetupMode;
+	files_written: string[];
+	previews: Array<{ path: string; content: string }>;
+	warnings: string[];
+	smoke: null | {
+		ok: boolean;
+		protocolVersion: string;
+		serverName: string;
+		requiredTools: string[];
+		missingTools: string[];
+	};
+}
+
+class HermesSetupError extends Error {
+	readonly exitCode: number;
+	constructor(message: string, exitCode: number) {
+		super(message);
+		this.name = "HermesSetupError";
+		this.exitCode = exitCode;
+	}
+}
+
+const MUTATION_CLASSES: HermesMutationClass[] = ["sessions", "questions", "reports"];
+const MANAGED_BY = "gjc";
+const SETUP_SCHEMA_VERSION = "1";
+const DEFAULT_SERVER_KEY = "gjc_coordinator";
+const DEFAULT_GJC_COMMAND = "gjc";
+const DEFAULT_TIMEOUT = 180;
+const DEFAULT_CONNECT_TIMEOUT = 60;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function optionalTrim(value: string | undefined): string | undefined {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : undefined;
+}
+
+function normalizeRoots(roots: string[] | undefined): string[] {
+	if (!roots || roots.length === 0) {
+		throw new HermesSetupError("Hermes setup requires at least one --root <path>.", 2);
+	}
+	const seen = new Set<string>();
+	const normalized: string[] = [];
+	const home = path.resolve(os.homedir());
+	for (const root of roots) {
+		const trimmed = root.trim();
+		if (!trimmed) {
+			throw new HermesSetupError("Hermes setup root entries must not be empty.", 2);
+		}
+		const resolved = path.resolve(trimmed);
+		if (resolved === path.parse(resolved).root || resolved === path.resolve("/home") || resolved === home) {
+			throw new HermesSetupError(`Refusing broad Hermes MCP root: ${resolved}`, 2);
+		}
+		if (!seen.has(resolved)) {
+			seen.add(resolved);
+			normalized.push(resolved);
+		}
+	}
+	return normalized;
+}
+
+function parseMutationClasses(values: string[] | undefined): HermesMutationClass[] {
+	if (!values || values.length === 0) return [];
+	const classes: HermesMutationClass[] = [];
+	for (const raw of values) {
+		for (const part of raw.split(",")) {
+			const value = part.trim();
+			if (!value) continue;
+			if (value === "all") {
+				for (const cls of MUTATION_CLASSES) {
+					if (!classes.includes(cls)) classes.push(cls);
+				}
+				continue;
+			}
+			if (!MUTATION_CLASSES.includes(value as HermesMutationClass)) {
+				throw new HermesSetupError(`Invalid Hermes mutation class: ${value}`, 2);
+			}
+			if (!classes.includes(value as HermesMutationClass)) classes.push(value as HermesMutationClass);
+		}
+	}
+	return classes;
+}
+
+function parseByteCap(value: string | undefined): number | undefined {
+	if (value === undefined) return undefined;
+	const parsed = Number(value);
+	if (!Number.isInteger(parsed) || parsed <= 0) {
+		throw new HermesSetupError("--artifact-byte-cap must be a positive integer.", 2);
+	}
+	return parsed;
+}
+
+function normalizeInstallTarget(flags: HermesSetupFlags): CoordinatorSetupSpec["installTarget"] {
+	if (flags.target && flags.profileDir) {
+		throw new HermesSetupError("Use exactly one of --target or --profile-dir for Hermes setup install targets.", 2);
+	}
+	if (!flags.target && !flags.profileDir) return undefined;
+	return flags.profileDir
+		? { kind: "profile-dir", path: path.resolve(flags.profileDir) }
+		: { kind: "config-file", path: path.resolve(flags.target!) };
+}
+
+export function buildHermesSetupSpec(flags: HermesSetupFlags): CoordinatorSetupSpec {
+	const roots = normalizeRoots(flags.root);
+	return {
+		schemaVersion: 1,
+		coordinator: "hermes",
+		serverKey: optionalTrim(flags.serverKey) ?? DEFAULT_SERVER_KEY,
+		serverName: COORDINATOR_MCP_SERVER_NAME,
+		protocolVersion: COORDINATOR_MCP_PROTOCOL_VERSION,
+		gjcCommand: optionalTrim(flags.gjcCommand) ?? DEFAULT_GJC_COMMAND,
+		args: ["mcp-serve", "coordinator"],
+		roots,
+		namespace: {
+			...(optionalTrim(flags.profile) ? { profile: optionalTrim(flags.profile) } : {}),
+			...(optionalTrim(flags.repo) ? { repo: optionalTrim(flags.repo) } : {}),
+		},
+		...(optionalTrim(flags.sessionCommand) ? { sessionCommand: flags.sessionCommand } : {}),
+		...(optionalTrim(flags.stateRoot) ? { stateRoot: path.resolve(flags.stateRoot!) } : {}),
+		mutationPolicy: {
+			classes: parseMutationClasses(flags.mutation),
+			perCallConsentRequired: true,
+		},
+		...(parseByteCap(flags.artifactByteCap) ? { artifactByteCap: parseByteCap(flags.artifactByteCap) } : {}),
+		...(normalizeInstallTarget(flags) ? { installTarget: normalizeInstallTarget(flags) } : {}),
+		operatorTemplateVersion: 1,
+		contractDocVersion: 1,
+	};
+}
+
+function canonicalize(value: unknown): unknown {
+	if (Array.isArray(value)) return value.map(item => canonicalize(item));
+	if (!isRecord(value)) return value;
+	const output: Record<string, unknown> = {};
+	for (const key of Object.keys(value).sort()) {
+		const item = value[key];
+		if (item !== undefined) output[key] = canonicalize(item);
+	}
+	return output;
+}
+
+function signaturePayload(spec: CoordinatorSetupSpec): Record<string, unknown> {
+	return {
+		args: spec.args,
+		artifactByteCap: spec.artifactByteCap,
+		command: spec.gjcCommand,
+		contractDocVersion: spec.contractDocVersion,
+		coordinator: spec.coordinator,
+		mutationClasses: spec.mutationPolicy.classes,
+		namespace: spec.namespace,
+		operatorTemplateVersion: spec.operatorTemplateVersion,
+		roots: spec.roots,
+		schemaVersion: spec.schemaVersion,
+		serverKey: spec.serverKey,
+		sessionCommand: spec.sessionCommand,
+		stateRoot: spec.stateRoot,
+	};
+}
+
+export function computeHermesSetupSignature(spec: CoordinatorSetupSpec): string {
+	const canonical = JSON.stringify(canonicalize(signaturePayload(spec)));
+	return crypto.createHash("sha256").update(canonical).digest("hex");
+}
+
+export function renderHermesServerBlock(spec: CoordinatorSetupSpec): Record<string, unknown> {
+	const env: Record<string, string> = {
+		GJC_COORDINATOR_MCP_WORKDIR_ROOTS: spec.roots.join(path.delimiter),
+		GJC_COORDINATOR_MCP_SETUP_MANAGED_BY: MANAGED_BY,
+		GJC_COORDINATOR_MCP_SETUP_SCHEMA_VERSION: SETUP_SCHEMA_VERSION,
+		GJC_COORDINATOR_MCP_SETUP_SIGNATURE: computeHermesSetupSignature(spec),
+	};
+	if (spec.namespace.profile) env.GJC_COORDINATOR_MCP_PROFILE = spec.namespace.profile;
+	if (spec.namespace.repo) env.GJC_COORDINATOR_MCP_REPO = spec.namespace.repo;
+	if (spec.stateRoot) env.GJC_COORDINATOR_MCP_STATE_ROOT = spec.stateRoot;
+	if (spec.mutationPolicy.classes.length > 0)
+		env.GJC_COORDINATOR_MCP_MUTATIONS = spec.mutationPolicy.classes.join(",");
+	if (spec.artifactByteCap !== undefined) env.GJC_COORDINATOR_MCP_ARTIFACT_BYTE_CAP = String(spec.artifactByteCap);
+	if (spec.sessionCommand) env.GJC_COORDINATOR_MCP_SESSION_COMMAND = spec.sessionCommand;
+	return {
+		command: spec.gjcCommand,
+		args: spec.args,
+		env,
+		timeout: DEFAULT_TIMEOUT,
+		connect_timeout: DEFAULT_CONNECT_TIMEOUT,
+		enabled: true,
+	};
+}
+
+function renderConfigYaml(spec: CoordinatorSetupSpec): string {
+	return YAML.stringify({ mcp_servers: { [spec.serverKey]: renderHermesServerBlock(spec) } }, null, 2);
+}
+
+function renderOperatorTemplate(spec: CoordinatorSetupSpec): string {
+	return operatorInstructionsTemplate
+		.replaceAll("{{SERVER_KEY}}", spec.serverKey)
+		.replaceAll("{{TOOL_PREFIX}}", "gjc_coordinator")
+		.replaceAll("{{TEMPLATE_VERSION}}", String(spec.operatorTemplateVersion));
+}
+
+function serverBlockIsManaged(block: unknown): boolean {
+	if (!isRecord(block)) return false;
+	const env = block.env;
+	return (
+		isRecord(env) &&
+		env.GJC_COORDINATOR_MCP_SETUP_MANAGED_BY === MANAGED_BY &&
+		env.GJC_COORDINATOR_MCP_SETUP_SCHEMA_VERSION === SETUP_SCHEMA_VERSION &&
+		typeof env.GJC_COORDINATOR_MCP_SETUP_SIGNATURE === "string"
+	);
+}
+
+async function readYamlConfig(configPath: string): Promise<Record<string, unknown>> {
+	const exists = await Bun.file(configPath).exists();
+	if (!exists) return {};
+	const content = await Bun.file(configPath).text();
+	if (!content.trim()) return {};
+	const parsed = YAML.parse(content);
+	if (!isRecord(parsed)) {
+		throw new HermesSetupError(`Hermes config must be a YAML object: ${configPath}`, 2);
+	}
+	return parsed;
+}
+
+async function backupFile(filePath: string): Promise<string | null> {
+	if (!(await Bun.file(filePath).exists())) return null;
+	const stamp = new Date().toISOString().replaceAll(":", "").replaceAll(".", "");
+	const backupPath = `${filePath}.bak.${stamp}`;
+	await Bun.write(backupPath, Bun.file(filePath));
+	return backupPath;
+}
+
+function mergeHermesConfig(
+	existing: Record<string, unknown>,
+	spec: CoordinatorSetupSpec,
+	force: boolean,
+): Record<string, unknown> {
+	const currentServers = isRecord(existing.mcp_servers) ? existing.mcp_servers : {};
+	const existingBlock = currentServers[spec.serverKey];
+	if (existingBlock !== undefined && !serverBlockIsManaged(existingBlock) && !force) {
+		throw new HermesSetupError(`Hermes MCP server '${spec.serverKey}' already exists and is not managed by GJC.`, 3);
+	}
+	return {
+		...existing,
+		mcp_servers: {
+			...currentServers,
+			[spec.serverKey]: renderHermesServerBlock(spec),
+		},
+	};
+}
+
+function configPathForTarget(spec: CoordinatorSetupSpec): string | null {
+	if (!spec.installTarget) return null;
+	if (spec.installTarget.kind === "config-file") return spec.installTarget.path;
+	return path.join(spec.installTarget.path, "config.yaml");
+}
+
+function operatorPathForTarget(spec: CoordinatorSetupSpec): string | null {
+	if (spec.installTarget?.kind !== "profile-dir") return null;
+	return path.join(spec.installTarget.path, "skills", "autonomous-ai-agents", "gajae-code", "SKILL.md");
+}
+
+async function installConfig(spec: CoordinatorSetupSpec, force: boolean): Promise<string[]> {
+	const configPath = configPathForTarget(spec);
+	if (!configPath) return [];
+	const existing = await readYamlConfig(configPath);
+	const merged = mergeHermesConfig(existing, spec, force);
+	if (force) await backupFile(configPath);
+	await fs.mkdir(path.dirname(configPath), { recursive: true });
+	await Bun.write(configPath, YAML.stringify(merged, null, 2));
+	const written = [configPath];
+	const operatorPath = operatorPathForTarget(spec);
+	if (operatorPath) {
+		if ((await Bun.file(operatorPath).exists()) && !force) {
+			const current = await Bun.file(operatorPath).text();
+			if (
+				!current.includes("GJC Hermes operator instructions") ||
+				!current.includes(`Server key: ${spec.serverKey}`)
+			) {
+				throw new HermesSetupError(
+					`Operator instruction target already exists and is not managed by GJC: ${operatorPath}`,
+					3,
+				);
+			}
+		}
+		if (force) await backupFile(operatorPath);
+		await fs.mkdir(path.dirname(operatorPath), { recursive: true });
+		await Bun.write(operatorPath, renderOperatorTemplate(spec));
+		written.push(operatorPath);
+	}
+	return written;
+}
+
+async function runSmoke(spec: CoordinatorSetupSpec): Promise<HermesSetupResult["smoke"]> {
+	const requiredTools = [...COORDINATOR_MCP_TOOL_NAMES];
+	const server = createCoordinatorMcpServer({ env: {} });
+	const listed = await server.handleJsonRpc({ jsonrpc: "2.0", id: 1, method: "tools/list", params: {} });
+	const advertised = new Set((listed.result?.tools ?? []).map((tool: { name: string }) => tool.name));
+	const missingTools = requiredTools.filter(tool => !advertised.has(tool));
+	return {
+		ok: missingTools.length === 0,
+		protocolVersion: spec.protocolVersion,
+		serverName: spec.serverName,
+		requiredTools,
+		missingTools,
+	};
+}
+
+export async function runHermesSetup(flags: HermesSetupFlags): Promise<HermesSetupResult> {
+	const spec = buildHermesSetupSpec(flags);
+	if (flags.install && !spec.installTarget) {
+		throw new HermesSetupError("Hermes setup --install requires --target or --profile-dir.", 2);
+	}
+	if (!flags.install && spec.installTarget && !flags.check && !flags.smoke) {
+		throw new HermesSetupError(
+			"Hermes setup target/profile-dir writes require --install; omit the target for render-only output.",
+			2,
+		);
+	}
+	const mode: HermesSetupMode = flags.smoke ? "smoke" : flags.check ? "check" : flags.install ? "install" : "render";
+	const configPath = configPathForTarget(spec) ?? "hermes-config.yaml";
+	const previews = [
+		{ path: configPath, content: renderConfigYaml(spec) },
+		{ path: operatorPathForTarget(spec) ?? "operator-instructions.v1.md", content: renderOperatorTemplate(spec) },
+	];
+	const files_written = flags.install ? await installConfig(spec, Boolean(flags.force)) : [];
+	const smoke = flags.smoke ? await runSmoke(spec) : null;
+	if (smoke && !smoke.ok) {
+		throw new HermesSetupError(`Hermes MCP smoke failed; missing tools: ${smoke.missingTools.join(", ")}`, 4);
+	}
+	return {
+		ok: true,
+		mode,
+		files_written,
+		previews,
+		warnings: spec.sessionCommand
+			? [
+					"Using explicit GJC_COORDINATOR_MCP_SESSION_COMMAND exactly as supplied; provider/model validation is not performed.",
+				]
+			: ["No session command supplied; spawned sessions use the default GJC command/model resolution."],
+		smoke,
+	};
+}
+
+export function formatHermesSetupResult(result: HermesSetupResult): string {
+	const lines = [`Hermes setup ${result.mode} complete.`];
+	if (result.files_written.length > 0) {
+		lines.push("Written:");
+		for (const file of result.files_written) lines.push(`- ${file}`);
+	}
+	if (result.files_written.length === 0) {
+		lines.push("No files written. Use --install with --target or --profile-dir to apply.");
+		for (const preview of result.previews) lines.push(`Preview: ${preview.path}`);
+	}
+	for (const warning of result.warnings) lines.push(`Warning: ${warning}`);
+	if (result.smoke) {
+		lines.push(`Smoke: ${result.smoke.ok ? "passed" : "failed"} (${result.smoke.requiredTools.length} tools)`);
+	}
+	return lines.join("\n");
+}
+
+export function hermesSetupExitCode(error: unknown): number {
+	return error instanceof HermesSetupError ? error.exitCode : 1;
+}

package/src/task/agents.ts

@@ -59,7 +59,7 @@ const EMBEDDED_AGENT_DEFS: EmbeddedAgentDef[] = [
 			name: "task",
 			description: "General-purpose subagent with full capabilities for delegated multi-step tasks",
 			spawns: "*",
-			model: "pi/task",
+			model: "pi/default",
 			thinkingLevel: Effort.Medium,
 			hide: true,
 		},

package/src/task/index.ts

@@ -1324,6 +1324,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 							progressMap.set(index, {
 								...structuredClone(progress),
 							});
+							AsyncJobManager.instance()?.recordSubagentProgress(task.id, progress);
 							emitProgress();
 						},
 						authStorage: this.session.authStorage,
@@ -1384,6 +1385,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 							progressMap.set(index, {
 								...structuredClone(progress),
 							});
+							AsyncJobManager.instance()?.recordSubagentProgress(task.id, progress);
 							emitProgress();
 						},
 						authStorage: this.session.authStorage,

package/src/task/render.ts

@@ -690,6 +690,20 @@ function renderAgentProgress(
 	return lines;
 }
 
+/**
+ * Public wrapper to render a single subagent's live `AgentProgress` for the
+ * `subagent` await panel. Reuses the internal task-progress renderer so the
+ * await panel stays at parity with the inline task panel.
+ */
+export function renderSubagentLiveProgress(
+	progress: AgentProgress,
+	expanded: boolean,
+	theme: Theme,
+	spinnerFrame?: number,
+): string[] {
+	return renderAgentProgress(progress, true, expanded, theme, spinnerFrame);
+}
+
 /**
  * Render review result with combined verdict + findings in tree structure.
  */

package/src/tools/ask.ts

@@ -175,6 +175,7 @@ interface UIContext {
 			onLeft?: () => void;
 			onRight?: () => void;
 			helpText?: string;
+			customInput?: { optionLabel: string; onSubmit: (text: string) => void };
 		},
 	): Promise<string | undefined>;
 	editor(
@@ -194,6 +195,7 @@ async function askSingleQuestion(
 ): Promise<SelectionResult> {
 	const { recommended, timeout, signal, initialSelection, navigation, scrollTitleRows } = options;
 	const doneLabel = getDoneOptionLabel();
+	const otherOptionLabel = options.otherOptionLabel ?? OTHER_OPTION;
 	let selectedOptions = [...(initialSelection?.selectedOptions ?? [])];
 	let customInput = initialSelection?.customInput;
 	let timedOut = false;
@@ -202,11 +204,20 @@ async function askSingleQuestion(
 		prompt: string,
 		optionsToShow: string[],
 		initialIndex?: number,
-	): Promise<{ choice: string | undefined; timedOut: boolean; navigation?: "back" | "forward" }> => {
+	): Promise<{
+		choice: string | undefined;
+		timedOut: boolean;
+		navigation?: "back" | "forward";
+		inlineInput?: string;
+	}> => {
 		let timeoutTriggered = false;
 		const onTimeout = () => {
 			timeoutTriggered = true;
 		};
+		// Inline custom input: the TUI selector keeps the question and option
+		// list on screen and collects the "Other" text below the list, instead
+		// of swapping to a separate editor screen that hides the question.
+		let inlineInput: string | undefined;
 		let navigationAction: "back" | "forward" | undefined;
 		const baseHelpText = navigation
 			? "up/down navigate  enter select  ←/→ question  esc cancel"
@@ -222,6 +233,12 @@ async function askSingleQuestion(
 			scrollTitleRows,
 			onTimeout,
 			helpText,
+			customInput: {
+				optionLabel: otherOptionLabel,
+				onSubmit: (text: string) => {
+					inlineInput = text;
+				},
+			},
 			onLeft: navigation?.allowBack
 				? () => {
 						navigationAction = "back";
@@ -240,16 +257,17 @@ async function askSingleQuestion(
 		if (!timeoutTriggered && choice === undefined && typeof timeout === "number") {
 			timeoutTriggered = Date.now() - startMs >= timeout;
 		}
-		return { choice, timedOut: timeoutTriggered, navigation: navigationAction };
+		return { choice, timedOut: timeoutTriggered, navigation: navigationAction, inlineInput };
 	};
 
+	// Fallback for UI contexts that don't support inline custom input (they
+	// resolve the "Other" label without invoking customInput.onSubmit).
 	const promptForCustomInput = async (): Promise<{ input: string | undefined }> => {
 		const dialogOptions = signal ? { signal } : undefined;
 		const showCustomInput = () => ui.editor("Enter your response:", undefined, dialogOptions, { promptStyle: true });
 		const input = signal ? await untilAborted(signal, showCustomInput) : await showCustomInput();
 		return { input };
 	};
-	const otherOptionLabel = options.otherOptionLabel ?? OTHER_OPTION;
 
 	const promptWithProgress = navigation?.progressText ? `${question} (${navigation.progressText})` : question;
 	if (multi) {
@@ -278,6 +296,7 @@ async function askSingleQuestion(
 				choice,
 				timedOut: selectTimedOut,
 				navigation: arrowNavigation,
+				inlineInput,
 			} = await selectOption(`${prefix}${promptWithProgress}`, opts, cursorIndex);
 
 			if (arrowNavigation) {
@@ -297,11 +316,11 @@ async function askSingleQuestion(
 					timedOut = true;
 					break;
 				}
-				const customResult = await promptForCustomInput();
-				if (customResult.input === undefined) {
+				const input = inlineInput !== undefined ? inlineInput : (await promptForCustomInput()).input;
+				if (input === undefined) {
 					break;
 				}
-				customInput = customResult.input;
+				customInput = input;
 				break;
 			}
 
@@ -353,6 +372,7 @@ async function askSingleQuestion(
 			choice,
 			timedOut: selectTimedOut,
 			navigation: arrowNavigation,
+			inlineInput,
 		} = await selectOption(promptWithProgress, optionsWithNavigation, initialIndex);
 		timedOut = selectTimedOut;
 
@@ -365,12 +385,12 @@ async function askSingleQuestion(
 			}
 		} else if (choice === otherOptionLabel) {
 			if (!selectTimedOut) {
-				const customResult = await promptForCustomInput();
-				if (customResult.input !== undefined) {
-					customInput = customResult.input;
+				const input = inlineInput !== undefined ? inlineInput : (await promptForCustomInput()).input;
+				if (input !== undefined) {
+					customInput = input;
 					selectedOptions = [];
 				}
-				// If editor was dismissed (undefined), keep prior selectedOptions/customInput intact
+				// If input was dismissed (undefined), keep prior selectedOptions/customInput intact
 			}
 		} else {
 			selectedOptions = [stripRecommendedSuffix(choice)];

package/src/tools/bash.ts

@@ -609,6 +609,8 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 			label?: string;
 			ctx?: AgentToolContext;
 			onRawLine?: (line: string, jobId: string) => void;
+			shouldAcceptRawLine?: (jobId: string) => boolean;
+			lifecycle?: import("../async").AsyncJobLifecycleCleanup;
 		} = {},
 	): Promise<{ jobId: string; label: string; commandCwd: string }> {
 		const manager = AsyncJobManager.instance();
@@ -624,12 +626,14 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		let cursorOffset = 0;
 		let lineBuffer = "";
 		const dispatchLines = (chunk: string) => {
+			if (opts.shouldAcceptRawLine?.(currentJobId) === false) return;
 			if (!onRawLine) return;
 			lineBuffer += chunk;
 			let newlineIndex = lineBuffer.indexOf("\n");
 			while (newlineIndex !== -1) {
 				const line = lineBuffer.slice(0, newlineIndex);
 				lineBuffer = lineBuffer.slice(newlineIndex + 1);
+				if (opts.shouldAcceptRawLine?.(currentJobId) === false) return;
 				try {
 					onRawLine(line, currentJobId);
 				} catch (error) {
@@ -642,6 +646,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		};
 		const flushTrailingLine = () => {
 			if (!onRawLine) return;
+			if (opts.shouldAcceptRawLine?.(currentJobId) === false) return;
 			if (lineBuffer.length === 0) return;
 			const remainder = lineBuffer;
 			lineBuffer = "";
@@ -693,7 +698,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 					throw error instanceof Error ? error : new Error(String(error));
 				}
 			},
-			{ ownerId, metadata: { monitor: true } },
+			{ ownerId, metadata: { monitor: true }, lifecycle: opts.lifecycle },
 		);
 		currentJobId = jobId;
 		return { jobId, label, commandCwd: prepared.commandCwd };