@gajae-code/coding-agent 0.16.3 → 0.16.6

package/src/sdk/bus/slack-live-provider.ts

@@ -294,6 +294,18 @@ export class SlackLiveProvider implements SlackProviderClient, SlackDiagnosticPr
 		return message;
 	}
 
+	async addReaction(input: { channel: string; timestamp: string; name: string; signal?: AbortSignal }): Promise<void> {
+		await this.#api(
+			"reactions.add",
+			{
+				channel: input.channel,
+				timestamp: input.timestamp,
+				name: input.name,
+			},
+			input.signal,
+		);
+	}
+
 	async findMessageByClientMsgId(input: {
 		channel: string;
 		clientMsgId: string;

package/src/sdk/bus/slack-provider.ts

@@ -57,6 +57,7 @@ export interface SlackProviderClient {
 		threadTs?: string;
 		signal?: AbortSignal;
 	}): Promise<SlackMessageSearchResult | null>;
+	addReaction?(input: { channel: string; timestamp: string; name: string; signal?: AbortSignal }): Promise<void>;
 	/**
 	 * Prove that an operator-supplied timestamp addresses a real message in the
 	 * requested channel. Adoption of an existing root is refused when a client
@@ -108,6 +109,10 @@ export class SlackProvider {
 		return (await this.client.findMessageByClientMsgId?.(input)) ?? null;
 	}
 
+	async addReaction(input: { channel: string; timestamp: string; name: string; signal?: AbortSignal }): Promise<void> {
+		await this.client.addReaction?.(input);
+	}
+
 	/** Fail-closed root verification: a client without this capability can never confirm a root. */
 	async findMessageByTimestamp(input: { channel: string; ts: string }): Promise<SlackMessageSearchResult | null> {
 		return (await this.client.findMessageByTimestamp?.(input)) ?? null;

package/src/sdk/bus/telegram-daemon.ts

@@ -4821,7 +4821,11 @@ export class TelegramNotificationDaemon {
 					.catch(() => undefined);
 			}
 		};
-		const parsed = parseLifecycleCommand(text, commandCtx);
+		const threadSessionId =
+			threadId === undefined
+				? undefined
+				: this.topics.sessionForLifecycleTopic(String(threadId), String(this.opts.chatId));
+		const parsed = parseLifecycleCommand(text, { ...commandCtx, threadSessionId });
 		if (parsed.kind === "none") return false;
 		if (updateId !== undefined && this.dispatchState.seenUpdateIds.has(updateId)) return true;
 		if (updateId !== undefined) await this.rememberSeenUpdateId(updateId);
@@ -4841,7 +4845,17 @@ export class TelegramNotificationDaemon {
 					? `Recent sessions could not be verified: ${recent.message}`
 					: recent.entries.length
 						? recent.entries
-								.map(entry => `• ${code(entry.sessionId)}${entry.path ? ` (${code(entry.path)})` : ""}`)
+								.map(entry => {
+									const connected = this.#logicalSessionOwners.has(entry.sessionId);
+									return [
+										`${connected ? "🟢 connected" : "⚪ saved"} — ${code(entry.sessionId)}`,
+										entry.title ? `  ${code(entry.title)}` : undefined,
+										entry.path ? `  ${code(entry.path)}` : undefined,
+										connected ? undefined : `  Resume: ${code(`/session_resume ${entry.sessionId}`)}`,
+									]
+										.filter((line): line is string => line !== undefined)
+										.join("\n");
+								})
 								.join("\n")
 						: "No recent sessions.";
 			await replyHtml(

package/src/sdk/bus/topic-registry.ts

@@ -775,6 +775,25 @@ export class TopicRegistry {
 		return this.byTopic.get(topicId);
 	}
 
+	/**
+	 * Resolve a durable topic association for explicit lifecycle controls.
+	 *
+	 * Unlike inbound message routing, this may return an inactive session so a
+	 * user can resume it from its old topic. Ambiguous, malformed, cross-chat,
+	 * and quarantined records fail closed.
+	 */
+	sessionForLifecycleTopic(topicId: string, chatId: string): string | undefined {
+		if (!isValidTopicId(topicId)) return undefined;
+		const matches = [...this.topics].filter(
+			([, record]) =>
+				record.topicId === topicId &&
+				record.chatId === chatId &&
+				!record.bindingMalformed &&
+				record.authorityState !== "legacy_quarantined",
+		);
+		return matches.length === 1 ? matches[0]![0] : undefined;
+	}
+
 	/** All session ids with a persisted topic record. */
 	sessionIds(): string[] {
 		return [...this.topics.keys()];

package/src/sdk/cli/master-cli.ts

@@ -15,7 +15,7 @@ import { SdkClientError } from "../client";
 import { dispatchSpawnGlobal } from "../lifecycle/broker-client";
 
 const MASTER_CAPABILITY_ENV = "GJC_MASTER_CAPABILITY";
-const MASTER_SESSION_ENV = "GJC_SESSION_ID";
+const MASTER_SESSION_ENV = "GJC_MASTER_OWNER_SESSION_ID";
 const SPAWN_TIMEOUT_MS = 120_000;
 
 export class SdkMasterCliError extends Error {

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

@@ -334,13 +334,14 @@ function throwResponseFailure(response: unknown): void {
 async function paginatedSessionList(
 	router: SessionRouter,
 	input: JsonRecord = {},
-	requestKey = `${SDK_SESSION_CLI_LIFECYCLE_ACTOR.namespace}:session.list`,
+	requestKey = `${SDK_SESSION_CLI_LIFECYCLE_ACTOR.namespace}:session.list:${randomBytes(12).toString("hex")}`,
 ): Promise<unknown> {
 	try {
 		const pages = await traverseSessionList(
 			input,
 			async pageInput => {
-				const response = object(await router.listBrokerSessions(pageInput, requestKey));
+				const cursor = typeof pageInput.cursor === "string" ? pageInput.cursor : "initial";
+				const response = object(await router.listBrokerSessions(pageInput, `${requestKey}:${cursor}`));
 				if (response?.ok === false) {
 					const failure = object(response.error);
 					throw new SdkClientError(
@@ -375,10 +376,10 @@ type SessionRows = {
 	sessions: SdkSessionRowV1[];
 };
 
-async function sessionRows(agentDir: string): Promise<SessionRows> {
+async function sessionRows(agentDir: string, input: JsonRecord = {}): Promise<SessionRows> {
 	await ensureBroker({ agentDir });
 	return await withRouter(agentDir, async router => {
-		const response = await paginatedSessionList(router);
+		const response = await paginatedSessionList(router, input);
 		const result = resultObject(response) ?? {};
 		let sessions: SdkSessionRowV1[];
 		try {
@@ -454,7 +455,7 @@ export async function runSdkSearch(
 	createService: (agentDir: string) => SessionLifecycleService = createBrokerSessionLifecycleService,
 	probe: (agentDir: string, result: SdkSearchResultV1) => Promise<SdkSearchResultV1> = probeSearchRows,
 ): Promise<{ result: SdkSearchResultV1; exitCode: 0 | 1 }> {
-	const agentDir = args.agentDir ?? getAgentDir();
+	const agentDir = path.resolve(args.agentDir ?? getAgentDir());
 	const locator = await resolveSessionLocator(args.repo ?? process.cwd(), agentDir);
 	const scope: ScopeNameV1 =
 		args.scope === undefined || args.scope === "repo" || args.scope === "pwd" || args.scope === "global"
@@ -689,7 +690,7 @@ async function runList(agentDir: string, args: SdkSessionCliArgs): Promise<unkno
 }
 
 async function runInspect(agentDir: string, sessionId: string): Promise<unknown> {
-	const listing = await sessionRows(agentDir);
+	const listing = await sessionRows(agentDir, { resolveSessionId: sessionId });
 	const session = listing.sessions.find(candidate => candidate.sessionId === sessionId);
 	if (!session)
 		throw new SdkSessionCliError("session_unavailable", `Session ${sessionId} is not indexed by the broker.`, 1);
@@ -1671,7 +1672,9 @@ export async function runTail(
 	sessionId: string,
 	args: SdkSessionCliArgs,
 ): Promise<unknown> {
-	const row = (await sessionRows(agentDir)).sessions.find(candidate => candidate.sessionId === sessionId);
+	const row = (await sessionRows(agentDir, { resolveSessionId: sessionId })).sessions.find(
+		candidate => candidate.sessionId === sessionId,
+	);
 	if (!row)
 		throw new SdkSessionCliError("session_unavailable", `Session ${sessionId} is not indexed by the broker.`, 1);
 	if (row.deleted)
@@ -1801,7 +1804,7 @@ export async function runSdkSessionCli(
 				"Expected one of: list, inspect, send, status, tail, retire, raw (control|query|global).",
 				2,
 			);
-		const agentDir = args.agentDir ?? getAgentDir();
+		const agentDir = path.resolve(args.agentDir ?? getAgentDir());
 		if (action === "list") {
 			writeOutput(stripSecretFields(await runList(agentDir, args)));
 			return;

package/src/sdk/client/client.ts

@@ -31,6 +31,14 @@ export class SdkClientError extends Error {
 	}
 }
 
+/** A prepared transport operation failed before any wire handoff. */
+export class SdkPreparedDispatchError extends SdkClientError {
+	constructor(error: SdkClientError) {
+		super(error.code, error.message, error.details, error.reconnect);
+		this.name = "SdkPreparedDispatchError";
+	}
+}
+
 export type SdkReconnectTerminationReason = "attempts_exhausted" | "deadline" | "cancelled";
 
 /**
@@ -90,6 +98,8 @@ export interface SdkRequestOptions {
 	 * alter that settlement.
 	 */
 	onDispatch?: SdkDispatchHandler;
+	/** Internal prepared-dispatch mode: fail pre-send instead of reconnecting. */
+	connectedOnly?: boolean;
 }
 export type SdkFrame = Record<string, unknown>;
 /**
@@ -157,6 +167,7 @@ type Incarnation = {
 };
 type Pending = {
 	readonly incarnation: Incarnation;
+	readonly connectedOnly: boolean;
 	resolve: (value: unknown) => void;
 	reject: (error: Error) => void;
 	timer: NodeJS.Timeout;
@@ -453,11 +464,30 @@ export class SdkClient {
 	}
 
 	async #request(frame: Frame, options: SdkRequestOptions, onResponse?: () => void): Promise<unknown> {
-		if (this.#closed) throw new SdkClientError("connection_closed", "SDK client closed");
-		this.#throwIfDeadlineElapsed();
-		const incarnation = await this.#connect();
+		if (this.#closed) {
+			const error = new SdkClientError("connection_closed", "SDK client closed");
+			throw options.connectedOnly ? new SdkPreparedDispatchError(error) : error;
+		}
+		try {
+			this.#throwIfDeadlineElapsed();
+		} catch (error) {
+			if (options.connectedOnly && error instanceof SdkClientError) throw new SdkPreparedDispatchError(error);
+			throw error;
+		}
+		let incarnation: Incarnation;
+		if (options.connectedOnly) {
+			try {
+				incarnation = this.#requireConnectedIncarnation();
+			} catch (error) {
+				if (error instanceof SdkClientError) throw new SdkPreparedDispatchError(error);
+				throw error;
+			}
+		} else incarnation = await this.#connect();
 		const timeoutMs = this.#remainingTimeout(options.timeoutMs ?? this.#timeoutMs);
-		if (timeoutMs <= 0) throw this.#deadlineError();
+		if (timeoutMs <= 0) {
+			const error = this.#deadlineError();
+			throw options.connectedOnly ? new SdkPreparedDispatchError(error) : error;
+		}
 		const id = randomUUID();
 		const requestFrame = {
 			...frame,
@@ -482,6 +512,7 @@ export class SdkClient {
 		const deferred = Promise.withResolvers<unknown>();
 		const pending: Pending = {
 			incarnation,
+			connectedOnly: options.connectedOnly === true,
 			resolve: deferred.resolve,
 			reject: deferred.reject,
 			sent: false,
@@ -502,7 +533,8 @@ export class SdkClient {
 		};
 		this.#pending.set(id, pending);
 		if (!this.#isActive(incarnation) || incarnation.socket.readyState !== WebSocket.OPEN) {
-			this.#settlePending(id, pending, new SdkClientError("unavailable", "SDK WebSocket is not connected"));
+			const error = new SdkClientError("unavailable", "SDK WebSocket is not connected");
+			this.#settlePending(id, pending, options.connectedOnly ? new SdkPreparedDispatchError(error) : error);
 			return await deferred.promise;
 		}
 		if (options.beforeDispatch) {
@@ -553,16 +585,22 @@ export class SdkClient {
 				this.#settlePending(
 					id,
 					pending,
-					new SdkClientError("connection_closed", "SDK client closed during dispatch"),
+					options.connectedOnly
+						? new SdkPreparedDispatchError(
+								new SdkClientError("connection_closed", "SDK client closed during dispatch"),
+							)
+						: new SdkClientError("connection_closed", "SDK client closed during dispatch"),
 				);
 			return await deferred.promise;
 		}
 		if (this.#deadline !== undefined && Date.now() >= this.#deadline) {
-			this.#settlePending(id, pending, this.#deadlineError());
+			const error = this.#deadlineError();
+			this.#settlePending(id, pending, options.connectedOnly ? new SdkPreparedDispatchError(error) : error);
 			return await deferred.promise;
 		}
 		if (incarnation.socket.readyState !== WebSocket.OPEN) {
-			this.#settlePending(id, pending, new SdkClientError("unavailable", "SDK WebSocket is not connected"));
+			const error = new SdkClientError("unavailable", "SDK WebSocket is not connected");
+			this.#settlePending(id, pending, options.connectedOnly ? new SdkPreparedDispatchError(error) : error);
 			return await deferred.promise;
 		}
 		// Handoff bookkeeping is reentrancy-safe: `sent` flips BEFORE the wire
@@ -593,12 +631,14 @@ export class SdkClient {
 				// in which case that settlement stands and must not be displaced.
 				pending.sent = false;
 				this.#sentRecords.delete(id);
+				const sendError =
+					error instanceof SdkClientError
+						? error
+						: new SdkClientError("unavailable", "SDK WebSocket send failed", error);
 				this.#settlePending(
 					id,
 					pending,
-					error instanceof SdkClientError
-						? error
-						: new SdkClientError("unavailable", "SDK WebSocket send failed", error),
+					options.connectedOnly ? new SdkPreparedDispatchError(sendError) : sendError,
 				);
 			}
 			return await deferred.promise;
@@ -649,6 +689,13 @@ export class SdkClient {
 		return await cycle.promise!;
 	}
 
+	#requireConnectedIncarnation(): Incarnation {
+		const current = this.#currentSocketRecord;
+		if (!current || !this.#isActive(current) || current.socket.readyState !== WebSocket.OPEN)
+			throw new SdkClientError("connection_closed", "SDK WebSocket disconnected before prepared dispatch.");
+		return current;
+	}
+
 	async #openWithRetry(cycle: Cycle): Promise<Incarnation> {
 		const startedAt = Date.now();
 		let attemptsConsumed = 0;
@@ -983,12 +1030,14 @@ export class SdkClient {
 		clearTimeout(pending.timer);
 		if (responseReceived) pending.onResponse?.();
 		if (result instanceof Error) {
-			if (
-				transportFailure &&
-				pending.sent &&
+			const errorResult =
+				!pending.sent &&
+				pending.connectedOnly &&
 				result instanceof SdkClientError &&
-				(result.code === "timeout" || result.code === "connection_closed")
-			)
+				!(result instanceof SdkPreparedDispatchError)
+					? new SdkPreparedDispatchError(result)
+					: result;
+			if (transportFailure && pending.sent && errorResult instanceof SdkClientError)
 				pending.reject(
 					new SdkClientError(
 						"uncertain_after_send",
@@ -998,7 +1047,7 @@ export class SdkClient {
 				);
 			else {
 				this.#sentRecords.delete(id);
-				pending.reject(result);
+				pending.reject(errorResult);
 			}
 			return;
 		}

package/src/sdk/host/host.ts

@@ -1,5 +1,6 @@
 import { logger } from "@gajae-code/utils";
 import { AUTOROUTING_INACTIVE_WARNING } from "../../config/autorouting-contract";
+import { FileLockAcquireError } from "../../config/file-lock";
 import { redactBrokerRuntimeCapabilities, redactObservedRequestContent } from "./control/runtime-gate";
 import { type EventFrame, SessionEventStream } from "./events";
 import { isAutoroutingInactive } from "./internal-autorouting-state";
@@ -363,10 +364,10 @@ export class SessionSdkHost {
 		return "activated";
 	}
 
-	async stop(): Promise<"stopped" | "already"> {
+	async stop(options: { allowLockContention?: boolean } = {}): Promise<"stopped" | "already"> {
 		if (this.#stopPromise) return this.#stopPromise;
 		if (!this.#started) return "already";
-		const stopPromise = this.#stopStartedHost();
+		const stopPromise = this.#stopStartedHost(options);
 		this.#stopPromise = stopPromise;
 		try {
 			return await stopPromise;
@@ -375,18 +376,37 @@ export class SessionSdkHost {
 		}
 	}
 
-	async #stopStartedHost(): Promise<"stopped"> {
+	async #stopStartedHost(options: { allowLockContention?: boolean }): Promise<"stopped"> {
 		// Fence before the first await: everything after this point is teardown,
 		// and no in-flight activation may publish readiness across it.
 		this.#stopping = true;
 		this.#unsubscribe?.();
 		this.#unsubscribe = undefined;
-		if (this.#registration?.writer.unregister)
-			await this.#registration.writer.unregister({
-				sessionId: this.#options.sessionId,
-				stateRoot: this.#options.stateRoot,
-				endpointGeneration: this.events.generation,
-			});
+		if (this.#registration?.writer.unregister) {
+			try {
+				await this.#registration.writer.unregister({
+					sessionId: this.#options.sessionId,
+					stateRoot: this.#options.stateRoot,
+					endpointGeneration: this.events.generation,
+				});
+			} catch (error) {
+				// A live broker may hold the shared session-index lock beyond the
+				// bounded acquisition budget. Unregistration is best effort: leaving
+				// the durable row in place is fail-closed because peers still fence
+				// authority on process liveness and incarnation, while propagating the
+				// contention error turns ordinary shutdown into an uncaught failure.
+				if (
+					!options.allowLockContention ||
+					!(error instanceof FileLockAcquireError) ||
+					error.code !== "acquire_timeout"
+				)
+					throw error;
+				logger.warn("sdk broker unregister deferred because the session index is busy", {
+					holder: error.holder,
+					lockPath: error.lockPath,
+				});
+			}
+		}
 		this.#started = false;
 		this.#stopping = false;
 		return "stopped";

package/src/sdk/host/query/revision-store.ts

@@ -397,20 +397,29 @@ export class RevisionStore {
 		if (!revision) return undefined;
 		revision.lastAccessed = this.now();
 		if (!revision.index?.items) return undefined;
-		const items: unknown[] = [];
+		const ranges = revision.index.items.slice(offset);
+		let count = 0;
 		let itemsBytes = 2; // []
-		for (const range of revision.index.items.slice(offset)) {
-			// The manifest records the canonical item length, so reject an oversized
-			// item before reading or parsing its complete range.
-			if (range.end - range.start > targetBytes) break;
-			const value = JSON.parse(await this.#readRange(revision, range));
-			const itemBytes = Buffer.byteLength(JSON.stringify(value));
-			const candidateBytes = itemsBytes + itemBytes + (items.length ? 1 : 0);
-			if (candidateBytes > targetBytes && items.length) break;
+		for (const range of ranges) {
+			// Indexed ranges contain canonical JSON, so their byte lengths select
+			// the page without repeatedly loading and hashing the same chunk.
+			const itemBytes = range.end - range.start;
+			if (itemBytes > targetBytes) break;
+			const candidateBytes = itemsBytes + itemBytes + (count ? 1 : 0);
+			if (candidateBytes > targetBytes && count) break;
 			if (candidateBytes > 1024 * 1024) break;
-			items.push(value);
+			count++;
 			itemsBytes = candidateBytes;
 		}
+		const items: unknown[] = [];
+		if (count) {
+			const start = ranges[0]!.start;
+			const bytes = await this.#readBytes(revision, start, ranges[count - 1]!.end);
+			for (let index = 0; index < count; index++) {
+				const range = ranges[index]!;
+				items.push(JSON.parse(bytes.subarray(range.start - start, range.end - start).toString("utf8")));
+			}
+		}
 		return { items, complete: offset + items.length >= revision.index.items.length };
 	}
 	/** Returns canonical root JSON in a UTF-8-safe bounded range without parsing it. */
@@ -1095,9 +1104,6 @@ export class RevisionStore {
 		}
 		return Buffer.concat(values);
 	}
-	async #readRange(revision: Revision, range: { start: number; end: number }): Promise<string> {
-		return (await this.#readBytes(revision, range.start, range.end)).toString("utf8");
-	}
 
 	async #readChunks(chunks: string[], lengths: number[]): Promise<Buffer | undefined> {
 		if (!this.#directory || chunks.length === 0) return undefined;

package/src/sdk/host/reverse-leases.ts

@@ -89,7 +89,7 @@ export class ReverseLeaseRuntime {
 	readonly #onDefinitionsRemoved?: ReverseLeaseOptions["onDefinitionsRemoved"];
 	readonly #onCancel?: ReverseLeaseOptions["onCancel"];
 	readonly #leases = new Map<string, ProviderLease>();
-	readonly #idempotency = new Map<string, { fingerprint: string; lease: ProviderLease }>();
+	readonly #idempotency = new Map<string, { connectionId: string; fingerprint: string; lease: ProviderLease }>();
 	readonly #outstanding = new Map<string, Outstanding>();
 	readonly #installedCapabilities = new Set<string>();
 	readonly #sweepTimer: ReturnType<typeof setInterval>;
@@ -139,7 +139,7 @@ export class ReverseLeaseRuntime {
 				active: true,
 			};
 			this.#leases.set(capability, lease);
-			if (idempotencyKey) this.#idempotency.set(key, { fingerprint, lease });
+			if (idempotencyKey) this.#idempotency.set(key, { connectionId, fingerprint, lease });
 			return { ...lease };
 		}
 		const reclaiming =
@@ -152,7 +152,7 @@ export class ReverseLeaseRuntime {
 			existing!.expiresAt = now + this.#leaseTtlMs;
 			existing!.graceUntil = undefined;
 			existing!.active = true;
-			if (idempotencyKey) this.#idempotency.set(key, { fingerprint, lease: existing! });
+			if (idempotencyKey) this.#idempotency.set(key, { connectionId, fingerprint, lease: existing! });
 			return { ...existing! };
 		}
 		this.#installDefinitionsFor(capability, definitions);
@@ -165,7 +165,7 @@ export class ReverseLeaseRuntime {
 			active: true,
 		};
 		this.#leases.set(capability, lease);
-		if (idempotencyKey) this.#idempotency.set(key, { fingerprint, lease });
+		if (idempotencyKey) this.#idempotency.set(key, { connectionId, fingerprint, lease });
 		return { ...lease };
 	}
 
@@ -197,6 +197,9 @@ export class ReverseLeaseRuntime {
 
 	disconnect(connectionId: string): void {
 		const now = this.#now();
+		for (const [key, entry] of this.#idempotency) {
+			if (entry.connectionId === connectionId) this.#idempotency.delete(key);
+		}
 		for (const lease of this.#leases.values())
 			if (lease.connectionId === connectionId) {
 				lease.expiresAt = now;

package/src/sdk/host/session-runtime.test.ts

@@ -2125,7 +2125,7 @@ describe("SessionSdkSessionRuntime", () => {
 			while (!transport.sent.some(frame => frame.id === "predecessor-prompt")) await Bun.sleep(10);
 			await handlers.get("agent_start")?.({}, ctx); // lifecycle epoch 1
 			await handlers.get("agent_end")?.(
-				{ type: "agent_end", stopReason: "maintenance", maintenanceOutcome: "completed" },
+				{ type: "agent_end", stopReason: "maintenance", maintenanceOutcome: "compacted" },
 				ctx,
 			);
 			transport.feed("client", {
@@ -2148,7 +2148,7 @@ describe("SessionSdkSessionRuntime", () => {
 			while (abortCalls < 1) await Bun.sleep(10);
 			await handlers.get("agent_end")?.({ type: "agent_end" }, ctx); // delayed predecessor
 			await handlers.get("agent_end")?.(
-				{ type: "agent_end", stopReason: "maintenance", maintenanceOutcome: "completed" },
+				{ type: "agent_end", stopReason: "maintenance", maintenanceOutcome: "compacted" },
 				ctx,
 			);
 			abortRelease.resolve();
@@ -5261,7 +5261,7 @@ describe("post-acceptance invocation terminalization", () => {
 		}
 	});
 
-	test("a later provider error enriches but never re-opens an already terminal prompt", async () => {
+	test("a later provider error never changes or re-opens an already terminal prompt", async () => {
 		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-terminalize-once-"));
 		try {
 			const inflight = Promise.withResolvers<void>();
@@ -5282,13 +5282,8 @@ describe("post-acceptance invocation terminalization", () => {
 			// A lifecycle frame arriving after the terminal must not resurrect the record either.
 			await harness.emit("agent_start");
 			const settled = await harness.query("turn.prompt_status", { commandId, turnId });
-			// The late reason attaches to the settled record, so `error` is the only field that may
-			// appear; status, terminalAt, and identity stay exactly as claimed.
-			const { error: _claimedReason, ...claimedTerminal } = claimed;
-			const { error: _lateReason, ...settledTerminal } = settled.result ?? {};
-			expect(settledTerminal).toEqual(claimedTerminal);
-			// The recorded reason is the sanitized late failure: never fabricated, never raw.
-			expect(settled.result?.error).toEqual({ code: "upstream_error", message: "Prompt submission failed." });
+			// A rejected submission after terminal publication is only a cleanup diagnostic.
+			expect(settled.result).toEqual(claimed);
 			await harness.stop();
 		} finally {
 			await Bun.sleep(50);
@@ -7145,3 +7140,50 @@ test("SDK-only host rebinds the steering snapshot when the requester's turn wins
 		await rm(cwd, { recursive: true, force: true });
 	}
 });
+
+describe("rejection terminalization idempotency", () => {
+	test("cleanup rejection after success preserves the sole correlated wire terminal and durable result", async () => {
+		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-cleanup-rejection-"));
+		const cleanup = Promise.withResolvers<void>();
+		const harness = await invocationHarness("cleanup-rejection", cwd, {
+			sendUserMessage: async (_content, options) => {
+				await options?.onPreflightAcceptCommit?.();
+				await cleanup.promise;
+			},
+		});
+		const warning = spyOn(logger, "warn").mockImplementation(() => {});
+		try {
+			const accepted = await harness.control("turn.prompt", { text: "complete before cleanup" });
+			expect(accepted.ok).toBe(true);
+			const ids = { commandId: accepted.result?.commandId, turnId: accepted.result?.turnId };
+			await harness.emit("agent_start");
+			await harness.emit("agent_end", {
+				messages: [{ role: "assistant", content: [{ type: "text", text: "Completed." }], stopReason: "stop" }],
+			});
+			const before = await settledStatus(harness, "turn.result", { kind: "prompt", ...ids });
+			expect(before.status).toBe("terminal_ok");
+			cleanup.reject(new Error("post-turn cleanup failed"));
+			await Bun.sleep(50);
+			const after = await harness.query("turn.result", { kind: "prompt", ...ids });
+			expect(after.result).toEqual(before);
+			expect(warning).toHaveBeenCalledWith("SDK submission cleanup failed after terminal publication", {
+				kind: "prompt",
+				...ids,
+				error: { code: "internal", message: "Prompt submission failed." },
+			});
+			const correlated = harness.broadcasts.filter(
+				frame => (frame.payload as { commandId?: string } | undefined)?.commandId === ids.commandId,
+			);
+			expect(correlated.filter(frame => frame.kind === "agent_failed")).toHaveLength(0);
+			const terminals = correlated.filter(frame => frame.kind === "agent_end");
+			expect(terminals).toHaveLength(1);
+			expect(terminals[0]).toMatchObject({
+				payload: { ...ids, outcome: (before as { outcome?: unknown }).outcome },
+			});
+		} finally {
+			warning.mockRestore();
+			await harness.stop();
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+});