@gajae-code/coding-agent 0.16.1 → 0.16.3

package/src/sdk/router/session-router.ts

@@ -338,6 +338,8 @@ type AttachedSession = {
 	replayPending: boolean;
 	replayPendingSince?: number;
 	replayPendingToken?: object;
+	drainingHeldSeq?: number;
+	drainingHeldBatch?: HeldFrame[];
 	readyTail: Promise<void>;
 	readonly publication: { promise: Promise<void>; resolve: () => void; reject: (reason?: unknown) => void };
 	dispose: () => void;
@@ -1899,44 +1901,53 @@ export class SessionRouter {
 	}
 
 	async #reinitializeAttachment(attached: AttachedSession): Promise<void> {
-		const previous = attached.readyTail;
+		// A prior ready tail may be waiting for publication work carried by the dead
+		// socket. Chaining the reconnect behind it prevents the replacement from even
+		// issuing replay. Replace its hold-array identity to fence that tail, but carry
+		// forward frames it had not started draining; the active draining sequence is
+		// already represented by the independent frame tail.
+		if (attached.barrier.held) {
+			const carried = [...(attached.drainingHeldBatch ?? []), ...attached.barrier.held];
+			attached.drainingHeldBatch = undefined;
+			attached.barrier.held = carried
+				.filter(entry => entry.seq !== attached.drainingHeldSeq)
+				.filter((entry, index, entries) => entries.findIndex(candidate => candidate.seq === entry.seq) === index);
+		}
 		const replayToken = {};
 		attached.replayPending = true;
 		attached.replayPendingSince = Date.now();
 		attached.replayPendingToken = replayToken;
-		const current = previous
-			.catch(() => undefined)
-			.then(async () => {
-				if (!this.#attachmentLive(attached)) return;
-				const proven = await this.#readProvenEndpoint(attached.indexed);
-				if (
-					!proven ||
-					proven.endpoint.url !== attached.endpoint.url ||
-					proven.endpoint.token !== attached.endpoint.token ||
-					proven.endpoint.pid !== attached.pid ||
-					!sameEndpointIdentity(attached.endpointIdentity, proven.identity)
-				) {
-					await this.#retireAttachment(attached, proven ? "replaced_same_generation" : undefined);
-					return;
-				}
-				attached.initializingPublication = true;
-				try {
-					void Promise.resolve()
-						.then(() => this.#deps.onNotificationSubscriptionReady?.(attached.notificationSubscription))
-						.catch(error => {
-							this.#detachNotification(attached, "cancelled");
-							logger.warn(`SDK notification subscription reconnect hook failed locally: ${String(error)}`);
-						});
-					await this.#deps.onAttachmentReady?.(attached.capability);
-					await this.#deps.onReplayReady?.();
-				} catch {
-					await this.#retireAttachment(attached);
-					return;
-				} finally {
-					attached.initializingPublication = false;
-				}
-				if (this.#attachmentLive(attached)) await this.#replayAttachment(attached, attached.cursor.seq);
-			});
+		const current = Promise.resolve().then(async () => {
+			if (!this.#attachmentLive(attached)) return;
+			const proven = await this.#readProvenEndpoint(attached.indexed);
+			if (
+				!proven ||
+				proven.endpoint.url !== attached.endpoint.url ||
+				proven.endpoint.token !== attached.endpoint.token ||
+				proven.endpoint.pid !== attached.pid ||
+				!sameEndpointIdentity(attached.endpointIdentity, proven.identity)
+			) {
+				await this.#retireAttachment(attached, proven ? "replaced_same_generation" : undefined);
+				return;
+			}
+			attached.initializingPublication = true;
+			try {
+				void Promise.resolve()
+					.then(() => this.#deps.onNotificationSubscriptionReady?.(attached.notificationSubscription))
+					.catch(error => {
+						this.#detachNotification(attached, "cancelled");
+						logger.warn(`SDK notification subscription reconnect hook failed locally: ${String(error)}`);
+					});
+				await this.#deps.onAttachmentReady?.(attached.capability);
+				await this.#deps.onReplayReady?.();
+			} catch {
+				await this.#retireAttachment(attached);
+				return;
+			} finally {
+				attached.initializingPublication = false;
+			}
+			if (this.#attachmentLive(attached)) await this.#replayAttachment(attached, attached.cursor.seq);
+		});
 		attached.readyTail = current.finally(() => {
 			if (attached.replayPendingToken === replayToken) {
 				attached.replayPending = false;
@@ -2294,7 +2305,19 @@ export class SessionRouter {
 				return;
 			}
 			const batch = held.splice(0, held.length).sort((left, right) => left.seq - right.seq);
-			for (const entry of batch) await this.#enqueueFrame(attached, entry.frame, "ordered");
+			attached.drainingHeldBatch = batch;
+			for (;;) {
+				const entry = batch.shift();
+				if (!entry) break;
+				attached.drainingHeldSeq = entry.seq;
+				try {
+					await this.#enqueueFrame(attached, entry.frame, "ordered");
+				} finally {
+					if (attached.drainingHeldSeq === entry.seq) attached.drainingHeldSeq = undefined;
+				}
+				if (attached.barrier.held !== held) return;
+			}
+			if (attached.drainingHeldBatch === batch) attached.drainingHeldBatch = undefined;
 		}
 	}
 
@@ -2374,7 +2397,7 @@ export class SessionRouter {
 				this.#failBarrier(attached, "replay response contained a malformed event");
 				return;
 			}
-			let previousSeq = sinceSeq;
+			let previousSeq = -1;
 			for (const event of events) {
 				if (event.type !== "event") {
 					this.#failBarrier(attached, "replay response contained a non-event frame");
@@ -2411,7 +2434,7 @@ export class SessionRouter {
 				}
 				const retained = events
 					.map(event => readSequence(event.seq))
-					.find(seq => seq !== undefined && seq <= gap.toSeq);
+					.find(seq => seq !== undefined && seq >= gap.fromSeq && seq <= gap.toSeq);
 				if (retained !== undefined) {
 					this.#failBarrier(
 						attached,

package/src/sdk/session.ts

@@ -2720,7 +2720,6 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			hasForegroundBashBackgroundRequestHandler: () => session?.hasForegroundBashBackgroundRequestHandler() ?? false,
 			requestForegroundBashBackground: (reason, adapter) =>
 				Promise.resolve(session?.requestForegroundBashBackground(reason, adapter) ?? false),
-			getToolInterruptPolicy: () => agent?.getToolInterruptPolicy() ?? "abort_tools",
 
 			getCredentialSessionId: () => session?.credentialSessionId ?? credentialSessionId,
 			getMcpManager: () => mcpManager ?? options.inheritedMcpManager,

package/src/tools/bash.ts

@@ -1139,20 +1139,22 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 
 	/**
 	 * Whether a queued user steer may fold the running foreground wait. Mirrors
-	 * the loop's own steer admission: `busyPromptMode=queue` never admits a
-	 * steer into the busy run, and `toolInterruptPolicy=finish_tools` explicitly
-	 * lets the tool finish, so neither may fold. The
-	 * auto-background setting is deliberately not consulted: like the chord,
-	 * a steer fold is a user action.
+	 * the loop's steer admission: `busyPromptMode=queue` never admits a steer
+	 * into the busy run, so it never folds. `toolInterruptPolicy` is
+	 * deliberately NOT a gate: `finish_tools` means "do not kill the batch to
+	 * deliver a steer", and a fold kills nothing. It is the one way to deliver
+	 * the steer now AND let the command finish, so it applies under both
+	 * policies; the policy only decides what the loop does with sibling tools
+	 * after the fold returns. The auto-background setting is likewise not
+	 * consulted: like the chord, a steer fold is a user action.
 	 *
-	 * Fails closed: a session that cannot prove its tool interrupt policy or
-	 * report newly admitted steering is not steer-foldable.
+	 * Fails closed: a session that cannot report newly admitted steering or
+	 * accept a fold request is not steer-foldable.
 	 */
 	#steerFoldEnabled(): boolean {
-		const { waitForUserSteering, getToolInterruptPolicy, requestForegroundBashBackground } = this.session;
-		if (!waitForUserSteering || !getToolInterruptPolicy || !requestForegroundBashBackground) return false;
-		if (this.session.settings.get("busyPromptMode") !== "steer") return false;
-		return getToolInterruptPolicy() === "abort_tools";
+		const { waitForUserSteering, requestForegroundBashBackground } = this.session;
+		if (!waitForUserSteering || !requestForegroundBashBackground) return false;
+		return this.session.settings.get("busyPromptMode") === "steer";
 	}
 
 	/**
@@ -1161,8 +1163,8 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 	 * when the wait starts, or one that arrives inside the grace window, never
 	 * folds: the command finishes normally and that steer is consumed at the
 	 * ordinary tool boundary. The watcher keeps observing so a later qualifying
-	 * steer still folds, and re-checks the gates at that moment so a
-	 * `busyPromptMode`/`toolInterruptPolicy` change during the command is honored.
+	 * steer still folds, and re-checks the gate at that moment so a
+	 * `busyPromptMode` change during the command is honored.
 	 * Returns a stop function; call it when the wait settles. No-op when steer
 	 * folding is gated off at start.
 	 */

package/src/tools/index.ts

@@ -242,8 +242,6 @@ export interface ToolSession {
 	hasForegroundBashBackgroundRequestHandler?: () => boolean;
 	/** Request that a foreground wait fold into a background job, if supported. `reason` names the trigger; `adapter` targets a specific wait instead of the newest registration. */
 	requestForegroundBashBackground?: (reason?: FoldReason, adapter?: FoldAdapter) => Promise<boolean>;
-	/** Current tool interrupt policy; `finish_tools` lets the running tool finish, so a steer must not fold it. */
-	getToolInterruptPolicy?: () => "abort_tools" | "finish_tools";
 
 	/** Get the session-owned or inherited async job manager. */
 	getAsyncJobManager?: () => AsyncJobManager | undefined;

package/src/tools/tool-catalog.generated.ts

@@ -2319,7 +2319,7 @@ export const TOOL_CATALOG: Readonly<Record<string, ToolCatalogEntry>> = {
 	"job": {
 		"name": "job",
 		"label": "Job",
-		"description": "Inspects, waits, or cancels async jobs.\n\nBackground 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.\n\nIn 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`), or automatically when the user sends a steer after the command has run for at least 2 seconds (with `busyPromptMode=steer` and `toolInterruptPolicy=abort_tools`). 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. Job listings expose `foldReason` (`steer`, `chord`, `timer`, or `sdk_control`) beside `backgrounded` so you can tell why a job left the foreground. `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.\n\n# Operations\n\n## `list: true`\nUse to inspect what's running.\n\n## `tail: [id, …]`\nShow the retained output buffer for one or more background jobs without waiting.\n- Use this to reopen/tail a backgrounded long-running bash/tool output after folding it away.\n- Output is bounded by the manager retention window; stale cursors may report that only the retained tail is available.\n- Prefer `tail` over polling when you only need to peek at progress, so the conversation can continue without flooding the TUI.\n\n## `poll: [id, …]`\nBlock until the specified jobs finish or the wait window (~30 s, not configurable) elapses.\n- Use when you are genuinely blocked on a result and have no other work to do.\n- Returns the current snapshot when the timer elapses; running jobs remain running.\n- Completed jobs include their final output in the returned snapshot.\n\n## `cancel: [id, …]`\nStop running jobs.\n- Use when a job is stalled, hung, or no longer needed.\n- Returns immediately after cancelling.",
+		"description": "Inspects, waits, or cancels async jobs.\n\nBackground 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.\n\nIn 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`), or automatically when the user sends a steer after the command has run for at least 2 seconds (with `busyPromptMode=steer` (`toolInterruptPolicy` is not a gate)). 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. Job listings expose `foldReason` (`steer`, `chord`, `timer`, or `sdk_control`) beside `backgrounded` so you can tell why a job left the foreground. `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.\n\n# Operations\n\n## `list: true`\nUse to inspect what's running.\n\n## `tail: [id, …]`\nShow the retained output buffer for one or more background jobs without waiting.\n- Use this to reopen/tail a backgrounded long-running bash/tool output after folding it away.\n- Output is bounded by the manager retention window; stale cursors may report that only the retained tail is available.\n- Prefer `tail` over polling when you only need to peek at progress, so the conversation can continue without flooding the TUI.\n\n## `poll: [id, …]`\nBlock until the specified jobs finish or the wait window (~30 s, not configurable) elapses.\n- Use when you are genuinely blocked on a result and have no other work to do.\n- Returns the current snapshot when the timer elapses; running jobs remain running.\n- Completed jobs include their final output in the returned snapshot.\n\n## `cancel: [id, …]`\nStop running jobs.\n- Use when a job is stalled, hung, or no longer needed.\n- Returns immediately after cancelling.",
 		"parameters": {
 			"type": "object",
 			"properties": {

package/src/utils/external-editor.ts

@@ -65,8 +65,22 @@ const ENABLE_ECHO_INPUT = 0x0004;
 const ENABLE_WINDOW_INPUT = 0x0008;
 const ENABLE_VIRTUAL_TERMINAL_INPUT = 0x0200;
 
-function prepareWindowsConsoleForExternalEditor(): void {
-	if (process.platform !== "win32") return;
+interface RawModeInput {
+	setRawMode?: (mode: boolean) => unknown;
+}
+
+export function prepareWindowsConsoleForExternalEditor(
+	platform: NodeJS.Platform = process.platform,
+	input: RawModeInput = process.stdin,
+): void {
+	if (platform !== "win32") return;
+	// Native Windows terminals can expose stdin through a ConPTY pipe rather than
+	// a console input handle. In that case GetConsoleMode/SetConsoleMode below
+	// cannot re-arm the input stream, but the runtime's TTY implementation can.
+	try {
+		input.setRawMode?.(true);
+	} catch {}
+
 	try {
 		const kernel32 = dlopen("kernel32.dll", {
 			GetStdHandle: { args: [FFIType.i32], returns: FFIType.ptr },