@gajae-code/coding-agent 0.12.6 → 0.12.7

package/src/modes/acp/acp-client-bridge.ts

@@ -4,8 +4,6 @@
  * `AgentSession`) can route through the client when it advertises the
  * relevant capabilities at `initialize` time.
  */
-
-import { randomUUID } from "node:crypto";
 import type {
 	PermissionOption as AcpPermissionOption,
 	TerminalHandle as AcpTerminalHandle,
@@ -21,25 +19,10 @@ import type {
 	ClientBridgePermissionOption,
 	ClientBridgePermissionOutcome,
 	ClientBridgePermissionToolCall,
-	ClientBridgeProviderLeaseIdentity,
 	ClientBridgeTerminalHandle,
 } from "../../session/client-bridge";
 import { resolveAcpPermissionMode } from "./permission-mode";
 
-const ACP_TERMINAL_PUBLICATION_WAIT_MS = 500;
-
-async function settleTerminalCleanup(operation: () => Promise<unknown>): Promise<boolean> {
-	return await Promise.race([
-		Promise.resolve()
-			.then(operation)
-			.then(
-				() => true,
-				() => false,
-			),
-		Bun.sleep(ACP_TERMINAL_PUBLICATION_WAIT_MS).then(() => false),
-	]);
-}
-
 export { type AcpPermissionMode, resolveAcpPermissionMode } from "./permission-mode";
 
 export function createAcpClientBridge(
@@ -56,15 +39,6 @@ export function createAcpClientBridge(
 	};
 
 	const bridge: ClientBridge = { capabilities, deferAgentInitiatedTurns: true };
-	const connectionId = `acp:${sessionId}`;
-	const connectionGeneration = 1;
-	const terminalProviderLeaseId = `${connectionId}:${randomUUID()}`;
-	const terminalProviderIdentity: ClientBridgeProviderLeaseIdentity = {
-		leaseId: terminalProviderLeaseId,
-		connectionId,
-		connectionGeneration,
-		fence: randomUUID(),
-	};
 
 	if (capabilities.readTextFile) {
 		bridge.readTextFile = async params => {
@@ -89,49 +63,8 @@ export function createAcpClientBridge(
 	}
 
 	if (capabilities.terminal) {
-		let terminalPublicationFailed = false;
-		bridge.quarantineProviderLease = async (providerLease, _reason) => {
-			if (
-				typeof providerLease === "string" ||
-				providerLease.leaseId !== terminalProviderIdentity.leaseId ||
-				providerLease.connectionId !== terminalProviderIdentity.connectionId ||
-				providerLease.connectionGeneration !== terminalProviderIdentity.connectionGeneration ||
-				providerLease.fence !== terminalProviderIdentity.fence
-			)
-				throw new Error("terminal provider lease mismatch");
-			terminalPublicationFailed = true;
-		};
-		let terminalCreationTail = Promise.resolve();
-		const withTerminalCreationAdmission = async <T>(operation: () => Promise<T>): Promise<T> => {
-			const previous = terminalCreationTail;
-			const release = Promise.withResolvers<void>();
-			terminalCreationTail = previous.then(() => release.promise);
-			await previous;
-			try {
-				return await operation();
-			} finally {
-				release.resolve();
-			}
-		};
 		bridge.createTerminal = (params: ClientBridgeCreateTerminalParams) =>
-			withTerminalCreationAdmission(async () => {
-				if (terminalPublicationFailed) throw new Error("terminal provider quarantined after publication failure");
-				const creationTimeout = AbortSignal.timeout(ACP_TERMINAL_PUBLICATION_WAIT_MS);
-				const creationSignal = params.signal ? AbortSignal.any([params.signal, creationTimeout]) : creationTimeout;
-				return await createTerminalHandle(
-					connection,
-					sessionId,
-					params,
-					creationSignal,
-					terminalProviderIdentity,
-					() => {
-						terminalPublicationFailed = true;
-					},
-					() => {
-						terminalPublicationFailed = true;
-					},
-				);
-			});
+			createTerminalHandle(connection, sessionId, params);
 	}
 
 	if (promptPermission) {
@@ -146,97 +79,21 @@ async function createTerminalHandle(
 	connection: AgentSideConnection,
 	sessionId: string,
 	params: ClientBridgeCreateTerminalParams,
-	creationSignal: AbortSignal,
-	providerIdentity: ClientBridgeProviderLeaseIdentity,
-	onCreationUncertain: () => void,
-	onPublicationFailure: () => void,
 ): Promise<ClientBridgeTerminalHandle> {
-	if (creationSignal.aborted) throw new Error("terminal creation aborted");
-	const creation = Promise.resolve().then(() =>
-		connection.createTerminal({
-			sessionId,
-			command: params.command,
-			...(params.args ? { args: params.args } : {}),
-			...(params.env ? { env: params.env } : {}),
-			...(params.cwd ? { cwd: params.cwd } : {}),
-			...(typeof params.outputByteLimit === "number" ? { outputByteLimit: params.outputByteLimit } : {}),
-		}),
-	);
-	const creationAborted = Promise.withResolvers<"aborted">();
-	const onCreationAbort = () => creationAborted.resolve("aborted");
-	creationSignal.addEventListener("abort", onCreationAbort, { once: true });
-	if (creationSignal.aborted) creationAborted.resolve("aborted");
-	const creationOutcome = await Promise.race([
-		creation.then(
-			handle => ({ status: "created" as const, handle }),
-			error => ({ status: "failed" as const, error }),
-		),
-		creationAborted.promise.then(() => ({ status: "aborted" as const })),
-	]);
-	creationSignal.removeEventListener("abort", onCreationAbort);
-	if (creationOutcome.status === "aborted") {
-		onCreationUncertain();
-		void creation.then(
-			async handle => {
-				await settleTerminalCleanup(() => handle.kill());
-				await settleTerminalCleanup(() => handle.release());
-			},
-			() => undefined,
-		);
-		throw new Error("terminal creation aborted");
-	}
-	if (creationOutcome.status === "failed") {
-		onCreationUncertain();
-		throw creationOutcome.error;
-	}
-	const handle = creationOutcome.handle;
-	const publication = Promise.resolve().then(() =>
-		connection.sessionUpdate({
-			sessionId,
-			update: {
-				sessionUpdate: "tool_call_update",
-				toolCallId: params.toolCallId,
-				status: "in_progress",
-				content: [{ type: "terminal", terminalId: handle.id }],
-			},
-		}),
-	);
-	const aborted = Promise.withResolvers<"aborted">();
-	const onAbort = () => aborted.resolve("aborted");
-	params.signal?.addEventListener("abort", onAbort, { once: true });
-	if (params.signal?.aborted) aborted.resolve("aborted");
-	const outcome = await Promise.race([
-		publication.then(
-			() => ({ status: "published" as const }),
-			error => ({ status: "failed" as const, error }),
-		),
-		Bun.sleep(ACP_TERMINAL_PUBLICATION_WAIT_MS).then(() => ({ status: "timeout" as const })),
-		aborted.promise.then(() => ({ status: "aborted" as const })),
-	]);
-	params.signal?.removeEventListener("abort", onAbort);
-	if (outcome.status !== "published") {
-		const killed = await settleTerminalCleanup(() => handle.kill());
-		const released = await settleTerminalCleanup(() => handle.release());
-		if (!params.signal?.aborted || !killed || !released) onPublicationFailure();
-		if (outcome.status === "failed") throw outcome.error;
-		throw new Error(
-			outcome.status === "aborted"
-				? "terminal publication aborted"
-				: `terminal publication did not settle within ${ACP_TERMINAL_PUBLICATION_WAIT_MS}ms`,
-		);
-	}
-	return wrapTerminalHandle(handle, providerIdentity.leaseId, providerIdentity);
+	const handle = await connection.createTerminal({
+		sessionId,
+		command: params.command,
+		...(params.args ? { args: params.args } : {}),
+		...(params.env ? { env: params.env } : {}),
+		...(params.cwd ? { cwd: params.cwd } : {}),
+		...(typeof params.outputByteLimit === "number" ? { outputByteLimit: params.outputByteLimit } : {}),
+	});
+	return wrapTerminalHandle(handle);
 }
 
-function wrapTerminalHandle(
-	handle: AcpTerminalHandle,
-	providerLeaseId: string,
-	providerLeaseIdentity: ClientBridgeProviderLeaseIdentity,
-): ClientBridgeTerminalHandle {
+function wrapTerminalHandle(handle: AcpTerminalHandle): ClientBridgeTerminalHandle {
 	return {
 		terminalId: handle.id,
-		providerLeaseId,
-		providerLeaseIdentity,
 		async currentOutput() {
 			const out = await handle.currentOutput();
 			return {

package/src/prompts/tools/bash.md

@@ -65,5 +65,5 @@ Use it only for sanctioned GJC workflow CLI persistence or state read/write/cont
 # Output minimizer
 
 - Bash stdout/stderr may be rewritten before you see it: long output keeps only the last 1 KiB by default to reduce noise and input-token use. Explicit `tools.artifactTailBytes` / `tools.artifactHeadBytes` settings can set the tail budget or retain both ends. Prefer focused commands and dedicated `search`/`find` tools over producing broad output. Test/lint runners (e.g. `bun test`, `cargo test`, ESLint) are also passed through heuristic filters that drop noise and keep failures.
-- When the local minimizer changes visible text, successful artifact storage appends a footer containing an `artifact://<id>` reference. Artifact allocation is best-effort on direct, async, and monitor paths, and only decimal session artifact ids are accepted. Native callback delivery bounds both the core-to-native relay and N-API queue with backpressure and preserves a 64 KiB terminal tail after its core stream budget, emitting at most one typed aggregate loss marker. Complete artifacts are labeled as full output; hard-capped artifacts, streams that lost bytes before Bash capture, reader/client captures that cannot prove completeness, and loss counters beyond JavaScript's exact integer range report incompleteness instead. If artifact allocation/storage is unavailable before a writer/save operation is attempted, truncation may have no reference or diagnostic. If an artifact writer/save operation is attempted and fails, a bounded diagnostic is emitted without inventing an artifact URI.
-- ACP/client-terminal output can arrive already truncated from the beginning. Terminal creation, kill, output-recovery, and release RPCs are settlement-bounded; stalled or failed exit/kill/output operations report source-capture uncertainty instead of hanging or claiming completeness. Treat any truncation notice or metadata as evidence that the visible tail is incomplete. Recover omitted output only when an `artifact://` footer or metadata reference is present; truncation evidence without a reference means the visible output is incomplete and no artifact is recoverable. Output with neither truncation evidence nor an artifact reference is the complete emitted output.
+- When the local minimizer changes visible text, successful artifact storage appends a footer containing an `artifact://<id>` reference. Complete artifacts are labeled as full output; hard-capped artifacts report omitted bytes instead. If artifact allocation/storage is unavailable before a writer/save operation is attempted, truncation may have no reference or diagnostic. If an artifact writer/save operation is attempted and fails, a bounded diagnostic is emitted without inventing an artifact URI.
+- ACP/client-terminal output can arrive already truncated from the beginning. Treat any truncation notice or metadata as evidence that the visible tail is incomplete. Recover omitted output only when an `artifact://` footer or metadata reference is present; truncation evidence without a reference means the visible output is incomplete and no artifact is recoverable. Output with neither truncation evidence nor an artifact reference is the complete emitted output.

package/src/sdk/acp/adapter.ts

@@ -42,9 +42,6 @@ export type AcpReconnectFailedHandler = (error: SdkClientError) => void;
 export type AcpFrameHandler = (frame: SdkFrame) => void;
 type ReverseRequest = {
 	state: "pending" | "cancelled";
-	connectionId?: string;
-	capability?: string;
-	leaseId?: string;
 	controller?: AbortController;
 	cancelTimer?: NodeJS.Timeout;
 };
@@ -68,15 +65,6 @@ function isLifecycleOperation(operation: string): boolean {
 	);
 }
 
-const MAX_PENDING_REVERSE_PROVIDER_CALLS = 64;
-
-type ProviderCallToken = {
-	method: string;
-	promise?: Promise<unknown>;
-};
-
-const PROVIDER_CLOSE_SETTLEMENT_MS = 1_000;
-
 /**
  * Pure ACP-to-SDK adapter. It deliberately owns neither an AgentSession nor an
  * ACP bridge: all session work is performed through authenticated v3 frames.
@@ -95,13 +83,10 @@ export class AcpSdkAdapter {
 	#reclaiming?: Promise<void>;
 	#reverseRequests = new Map<string, ReverseRequest>();
 	#reconnectFailedHandlers = new Set<AcpReconnectFailedHandler>();
-	#pendingReverseProviderCalls = new Set<ProviderCallToken>();
 	#frameHandlers = new Set<AcpFrameHandler>();
 
 	#reverseCancelTtlMs: number;
 	#closed = false;
-	#closePromise?: Promise<void>;
-	#terminalCleanupUncertain = false;
 
 	constructor(options: AcpSdkAdapterOptions) {
 		this.#client = options.client ?? new SdkClient(options.url, options.token);
@@ -155,16 +140,10 @@ export class AcpSdkAdapter {
 	}
 
 	async close(): Promise<void> {
-		this.#closePromise ??= this.#closeInternal();
-		await this.#closePromise;
-	}
-
-	async #closeInternal(): Promise<void> {
 		if (this.#closed) return;
 		this.#closed = true;
 		if (this.#heartbeat) clearInterval(this.#heartbeat);
-		for (const [id, request] of this.#reverseRequests) {
-			if (request.state === "pending") this.#sendReverseCancellation(id, request);
+		for (const request of this.#reverseRequests.values()) {
 			request.controller?.abort();
 			if (request.cancelTimer) clearTimeout(request.cancelTimer);
 		}
@@ -172,21 +151,7 @@ export class AcpSdkAdapter {
 		this.#unsubscribe?.();
 		this.#unsubscribeReconnect?.();
 		this.#unsubscribeReconnectFailed?.();
-
-		const terminalSettled = await this.#awaitTerminalProviderSettlement();
-		let clientError: unknown;
-		try {
-			await this.#client.close();
-		} catch (error) {
-			clientError = error;
-		}
-		if (!terminalSettled) {
-			throw new AcpSdkAdapterError(
-				"ownership_uncertain",
-				"ACP terminal provider cleanup did not settle before adapter close.",
-			);
-		}
-		if (clientError) throw clientError;
+		await this.#client.close();
 	}
 
 	async prompt(params: JsonObject | string): Promise<unknown> {
@@ -390,7 +355,7 @@ export class AcpSdkAdapter {
 		)
 			return;
 		const controller = new AbortController();
-		const active: ReverseRequest = { state: "pending", connectionId, capability, leaseId, controller };
+		const active: ReverseRequest = { state: "pending", controller };
 		this.#reverseRequests.set(id, active);
 		try {
 			const request = frame.payload as JsonObject | undefined;
@@ -458,175 +423,19 @@ export class AcpSdkAdapter {
 
 	#abortActiveReverseRequests(): void {
 		for (const [id, request] of this.#reverseRequests) {
-			if (request.state === "pending") this.#sendReverseCancellation(id, request);
 			request.state = "cancelled";
 			request.controller?.abort();
 			this.#finishReverse(id, request);
 		}
 	}
 
-	#sendReverseCancellation(id: string, request: ReverseRequest): void {
-		if (!request.connectionId || !request.leaseId) return;
-		try {
-			const cancellation = this.#client.send({
-				type: "reverse_cancel",
-				id,
-				connectionId: request.connectionId,
-				leaseId: request.leaseId,
-			});
-			void Promise.resolve(cancellation).catch(() => {});
-		} catch {
-			// Cancellation is best effort while local retirement remains authoritative.
-		}
-	}
-
-	async #awaitTerminalProviderSettlement(): Promise<boolean> {
-		const deadline = Date.now() + PROVIDER_CLOSE_SETTLEMENT_MS;
-		for (;;) {
-			const pending = [...this.#pendingReverseProviderCalls].filter(token =>
-				["terminal.create", "terminal.kill", "terminal.release"].includes(token.method),
-			);
-			if (pending.length === 0) return !this.#terminalCleanupUncertain;
-			const remaining = deadline - Date.now();
-			if (remaining <= 0) return false;
-			const promises = pending.flatMap(token => (token.promise ? [token.promise] : []));
-			if (promises.length === 0) {
-				await Bun.sleep(Math.min(remaining, 1));
-				continue;
-			}
-			await Promise.race([Promise.allSettled(promises), Bun.sleep(remaining)]);
-		}
-	}
-
-	#reserveProviderCalls(method: string): { call: ProviderCallToken; cleanup: ProviderCallToken[] } {
-		const cleanup =
-			method === "terminal.create"
-				? ([{ method: "terminal.kill" }, { method: "terminal.release" }] satisfies ProviderCallToken[])
-				: [];
-		const required = 1 + cleanup.length;
-		if (this.#pendingReverseProviderCalls.size + required > MAX_PENDING_REVERSE_PROVIDER_CALLS)
-			throw new AcpSdkAdapterError("acp_reverse_capacity", "ACP reverse provider call capacity reached.");
-		const call: ProviderCallToken = { method };
-		this.#pendingReverseProviderCalls.add(call);
-		for (const token of cleanup) this.#pendingReverseProviderCalls.add(token);
-		return { call, cleanup };
-	}
-
-	#releaseReservedProviderCalls(tokens: readonly ProviderCallToken[]): void {
-		for (const token of tokens) {
-			if (!token.promise) this.#pendingReverseProviderCalls.delete(token);
-		}
-	}
-
-	#startProviderCall(
-		method: string,
-		payload: JsonObject,
-		signal: AbortSignal | undefined,
-		token: ProviderCallToken,
-	): Promise<unknown> {
-		let providerCall: Promise<unknown>;
-		try {
-			if (!this.#connection) throw new AcpSdkAdapterError("acp_reverse_unavailable");
-			if (this.#connection.request)
-				providerCall = Promise.resolve(this.#connection.request(method, payload, { cancellationSignal: signal }));
-			else {
-				const target = this.#connection[method];
-				if (typeof target !== "function")
-					throw new AcpSdkAdapterError("acp_reverse_unsupported", `ACP client does not support ${method}.`);
-				providerCall = Promise.resolve((target as (params: JsonObject) => Promise<unknown>)(payload));
-			}
-		} catch (error) {
-			if (token.method === "terminal.kill" || token.method === "terminal.release")
-				this.#terminalCleanupUncertain = true;
-			this.#pendingReverseProviderCalls.delete(token);
-			return Promise.reject(error);
-		}
-		token.promise = providerCall;
-		void providerCall.then(
-			() => this.#pendingReverseProviderCalls.delete(token),
-			() => {
-				if (token.method === "terminal.kill" || token.method === "terminal.release")
-					this.#terminalCleanupUncertain = true;
-				this.#pendingReverseProviderCalls.delete(token);
-			},
-		);
-		return providerCall;
-	}
-
 	async #forwardReverse(method: string, payload: JsonObject, signal: AbortSignal): Promise<unknown> {
 		if (!method || !this.#connection) throw new AcpSdkAdapterError("acp_reverse_unavailable");
-		if (signal.aborted) throw new AcpSdkAdapterError("request_cancelled", "Reverse request was cancelled.");
-		const reservation = this.#reserveProviderCalls(method);
-		const providerCall = this.#startProviderCall(method, payload, signal, reservation.call);
-		const cancelled = Promise.withResolvers<{ status: "cancelled" }>();
-		const onAbort = () => cancelled.resolve({ status: "cancelled" });
-		signal.addEventListener("abort", onAbort, { once: true });
-		if (signal.aborted) cancelled.resolve({ status: "cancelled" });
-		let outcome:
-			| { status: "resolved"; result: unknown }
-			| { status: "rejected"; error: unknown }
-			| { status: "cancelled" };
-		try {
-			outcome = await Promise.race([
-				providerCall.then(
-					result => ({ status: "resolved" as const, result }),
-					error => ({ status: "rejected" as const, error }),
-				),
-				cancelled.promise,
-			]);
-		} finally {
-			signal.removeEventListener("abort", onAbort);
-		}
-		if (outcome.status === "cancelled" || signal.aborted) {
-			if (method === "terminal.create") {
-				void providerCall
-					.then(
-						result => this.#cleanupCancelledTerminalCreate(result, reservation.cleanup),
-						() => {
-							this.#releaseReservedProviderCalls(reservation.cleanup);
-						},
-					)
-					.catch(() => {
-						this.#terminalCleanupUncertain = true;
-						this.#releaseReservedProviderCalls(reservation.cleanup);
-					});
-			} else this.#releaseReservedProviderCalls(reservation.cleanup);
-			throw new AcpSdkAdapterError("request_cancelled", "Reverse request was cancelled.");
-		}
-		this.#releaseReservedProviderCalls(reservation.cleanup);
-		if (outcome.status === "rejected") throw outcome.error;
-		return outcome.result;
-	}
-
-	async #cleanupCancelledTerminalCreate(result: unknown, cleanupTokens: readonly ProviderCallToken[]): Promise<void> {
-		const terminalId =
-			result && typeof result === "object" && typeof (result as { terminalId?: unknown }).terminalId === "string"
-				? (result as { terminalId: string }).terminalId
-				: undefined;
-		if (!terminalId || !this.#connection) {
-			this.#terminalCleanupUncertain = true;
-			this.#releaseReservedProviderCalls(cleanupTokens);
-			return;
-		}
-		for (const [index, method] of (["terminal.kill", "terminal.release"] as const).entries()) {
-			const token = cleanupTokens[index];
-			if (!token) continue;
-			let providerCall: Promise<unknown>;
-			try {
-				providerCall = this.#startProviderCall(method, { terminalId }, AbortSignal.timeout(500), token);
-			} catch {
-				this.#terminalCleanupUncertain = true;
-				this.#releaseReservedProviderCalls([token]);
-				continue;
-			}
-			const cleanupOutcome = await Promise.race([
-				providerCall.then(
-					() => "settled" as const,
-					() => "failed" as const,
-				),
-				Bun.sleep(500).then(() => "timeout" as const),
-			]);
-			if (cleanupOutcome === "failed") this.#terminalCleanupUncertain = true;
-		}
+		if (this.#connection.request)
+			return await this.#connection.request(method, payload, { cancellationSignal: signal });
+		const target = this.#connection[method];
+		if (typeof target !== "function")
+			throw new AcpSdkAdapterError("acp_reverse_unsupported", `ACP client does not support ${method}.`);
+		return await (target as (params: JsonObject) => Promise<unknown>)(payload);
 	}
 }

package/src/sdk/bus/chat-daemon-control.ts

@@ -40,13 +40,11 @@ export type ChatDaemonAction = "stop" | "reload";
  * daemon transports. Generation 16 applies Telegram sound-policy configuration
  * through shared notification parsing. Generation 17 bound managed-session
  * replacement to exact native filesystem authority; generation 18 retired that
- * binding, generation 19 bound exact cleanup to parent/link-count authority,
- * generation 20 refreshed retained cleanup semantics, and generation 21 hardens
- * exact Bash process-tree ownership shared by chat daemon cleanup.
+ * binding, and generation 19 binds exact cleanup to parent/link-count authority.
  */
 export const CHAT_DAEMON_GENERATIONS: Readonly<Record<ChatDaemonKind, number>> = {
-	discord: 21,
-	slack: 21,
+	discord: 20,
+	slack: 20,
 };
 
 export function chatDaemonGeneration(kind: ChatDaemonKind): number {