@gajae-code/coding-agent 0.13.0 → 0.13.2

package/src/modes/acp/acp-agent.ts

@@ -162,6 +162,7 @@ type BrokerSession = {
 	sessionId: string;
 	locator?: { repo?: string };
 	live?: boolean;
+	terminal?: boolean;
 	endpointGeneration?: number;
 	endpointMtimeMs?: number;
 	title?: string;
@@ -252,7 +253,11 @@ export function paginateAcpSessions(
 			(value): value is BrokerSession & { locator: { repo: string } } =>
 				typeof value?.sessionId === "string" && typeof value.locator?.repo === "string",
 		)
-		.filter(value => !cwd || value.locator.repo === cwd);
+		.filter(value => !cwd || value.locator.repo === cwd)
+		// DR-1 retains closed/unregistered rows in the broker index for inspect
+		// and offline tail; ACP's session/list advertises only loadable sessions,
+		// so terminal rows are excluded here (matching the pre-DR-1 wire shape).
+		.filter(value => value.terminal !== true);
 	const sessions = filtered.slice(offset, offset + SESSION_PAGE_SIZE).map(value => {
 		const metadata = sessionMetadata.get(value.sessionId);
 		const updatedAt =
@@ -1245,7 +1250,10 @@ export class AcpAgent implements Agent {
 				if (
 					typeof candidate?.sessionId !== "string" ||
 					typeof candidate.locator?.repo !== "string" ||
-					path.resolve(candidate.locator.repo) !== path.resolve(params.cwd)
+					path.resolve(candidate.locator.repo) !== path.resolve(params.cwd) ||
+					// A DR-1 terminal row is not a loadable session: adopting its cwd
+					// here would re-arm teardown authority for a host that is gone.
+					candidate.terminal === true
 				)
 					continue;
 				if (discovered.has(candidate.sessionId))

package/src/modes/components/model-selector.ts

@@ -1,5 +1,5 @@
 import { ThinkingLevel } from "@gajae-code/agent-core";
-import { getSupportedEfforts, type Model, modelsAreEqual } from "@gajae-code/ai/core";
+import { getSupportedEfforts, type Model, modelSupportsServiceTier, modelsAreEqual } from "@gajae-code/ai/core";
 import {
 	Container,
 	fuzzyFilter,
@@ -365,8 +365,8 @@ export class ModelSelectorComponent extends Container {
 	#currentThinkingLevel?: ThinkingLevel;
 	#activeModelProfile?: string;
 	#configuredDefaultChain?: readonly string[];
-	#isFastForProvider: (provider?: string) => boolean = () => false;
-	#isFastForSubagentProvider: (provider?: string) => boolean = () => false;
+	#isFastForProvider: (provider?: string, supportsServiceTier?: boolean) => boolean = () => false;
+	#isFastForSubagentProvider: (provider?: string, supportsServiceTier?: boolean) => boolean = () => false;
 	#isCurrentModelFastModeActive: () => boolean = () => false;
 	#pendingActionItem?: ModelItem | CanonicalModelItem;
 	#selectedActionIndex: number = 0;
@@ -374,6 +374,8 @@ export class ModelSelectorComponent extends Container {
 	#selectedThinkingIndex: number = 0;
 	#assignmentState: "idle" | "assigning" = "idle";
 	#closeAfterAssignment = false;
+	#unsubscribeCatalogChanged: () => void = () => {};
+	#disposed = false;
 
 	// Preset landing state
 	#viewMode: ModelSelectorViewMode = "presets";
@@ -405,8 +407,8 @@ export class ModelSelectorComponent extends Container {
 			temporaryOnly?: boolean;
 			initialSearchInput?: string;
 			sessionId?: string;
-			isFastForProvider?: (provider?: string) => boolean;
-			isFastForSubagentProvider?: (provider?: string) => boolean;
+			isFastForProvider?: (provider?: string, supportsServiceTier?: boolean) => boolean;
+			isFastForSubagentProvider?: (provider?: string, supportsServiceTier?: boolean) => boolean;
 			isCurrentModelFastModeActive?: () => boolean;
 			currentThinkingLevel?: ThinkingLevel;
 			activeModelProfile?: string;
@@ -434,7 +436,10 @@ export class ModelSelectorComponent extends Container {
 		// session's effective predicate so an auto-disabled provider shows no glyph.
 		this.#isCurrentModelFastModeActive =
 			options?.isCurrentModelFastModeActive ??
-			(() => (this.#currentModel ? this.#isFastForProvider(this.#currentModel.provider) : false));
+			(() =>
+				this.#currentModel
+					? this.#isFastForProvider(this.#currentModel.provider, modelSupportsServiceTier(this.#currentModel))
+					: false);
 		const initialSearchInput = options?.initialSearchInput;
 		this.#viewMode = this.#temporaryOnly || initialSearchInput || scopedModels.length > 0 ? "models" : "presets";
 
@@ -479,6 +484,13 @@ export class ModelSelectorComponent extends Container {
 		// Add bottom border
 		this.addChild(new DynamicBorder());
 
+		if (typeof this.#modelRegistry.onCatalogChanged === "function") {
+			this.#unsubscribeCatalogChanged = this.#modelRegistry.onCatalogChanged(() => {
+				if (this.#disposed) return;
+				if (this.#refreshCatalogView()) this.#tui.requestRender();
+			});
+		}
+
 		// Load models and do initial render
 		this.#loadModels().then(() => {
 			this.#buildProviderTabs();
@@ -504,6 +516,13 @@ export class ModelSelectorComponent extends Container {
 		});
 	}
 
+	override dispose(): void {
+		if (this.#disposed) return;
+		this.#disposed = true;
+		this.#unsubscribeCatalogChanged();
+		super.dispose();
+	}
+
 	#isActiveDefaultFallback(): boolean {
 		if (!this.#currentModel) return false;
 		const configuredChain =
@@ -1705,11 +1724,12 @@ export class ModelSelectorComponent extends Container {
 					// other modelRoles rows show pure intent.
 					const isSubagentRole = roleInfo.settingsPath === "task.agentModelOverrides";
 					const isCurrentRow = this.#currentModel !== undefined && modelsAreEqual(this.#currentModel, item.model);
+					const supportsServiceTier = modelSupportsServiceTier(assigned.model);
 					const roleFast = isSubagentRole
-						? this.#isFastForSubagentProvider(assigned.model.provider)
+						? this.#isFastForSubagentProvider(assigned.model.provider, supportsServiceTier)
 						: isCurrentRow
 							? this.#isCurrentModelFastModeActive()
-							: this.#isFastForProvider(assigned.model.provider);
+							: this.#isFastForProvider(assigned.model.provider, supportsServiceTier);
 					if (roleFast && isCurrentRow && !isSubagentRole) {
 						currentModelEffectiveGlyphRendered = true;
 					}

package/src/modes/controllers/plan-mode-controller.ts

@@ -145,7 +145,7 @@ export class PlanModeController {
 		await this.ctx.session.abort({ timeoutMs: ABORT_TIMEOUT_MS });
 		if (this.#previousTools?.length) await this.ctx.session.setActiveToolsByName(this.#previousTools);
 		if (this.#providerSessionScope && !this.ctx.session.isStreaming) {
-			if (this.ctx.session.restoreTemporaryProviderSessionScope(this.#providerSessionScope))
+			if (await this.ctx.session.restoreTemporaryProviderSessionScope(this.#providerSessionScope))
 				this.#providerSessionScope = undefined;
 		} else if (this.#previousModelState) {
 			const previous = this.#previousModelState;
@@ -187,7 +187,7 @@ export class PlanModeController {
 			});
 		} catch (error) {
 			if (this.#providerSessionScope)
-				this.ctx.session.restoreTemporaryProviderSessionScope(this.#providerSessionScope);
+				await this.ctx.session.restoreTemporaryProviderSessionScope(this.#providerSessionScope);
 			this.#providerSessionScope = undefined;
 			this.ctx.showWarning(
 				`Failed to switch model after streaming: ${error instanceof Error ? error.message : String(error)}`,
@@ -284,7 +284,7 @@ export class PlanModeController {
 			});
 		} catch (error) {
 			if (this.#providerSessionScope)
-				this.ctx.session.restoreTemporaryProviderSessionScope(this.#providerSessionScope);
+				await this.ctx.session.restoreTemporaryProviderSessionScope(this.#providerSessionScope);
 			this.#providerSessionScope = undefined;
 			this.ctx.showWarning(
 				`Failed to switch to plan model for plan mode: ${error instanceof Error ? error.message : String(error)}`,

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

@@ -2476,8 +2476,10 @@ export class SelectorController {
 					currentThinkingLevel: this.ctx.session.thinkingLevel,
 					activeModelProfile:
 						this.ctx.session.getActiveModelProfile?.() ?? this.ctx.settings.get("modelProfile.default"),
-					isFastForProvider: provider => this.ctx.session.isFastForProvider(provider),
-					isFastForSubagentProvider: provider => this.ctx.session.isFastForSubagentProvider(provider),
+					isFastForProvider: (provider, supportsServiceTier) =>
+						this.ctx.session.isFastForProvider(provider, supportsServiceTier),
+					isFastForSubagentProvider: (provider, supportsServiceTier) =>
+						this.ctx.session.isFastForSubagentProvider(provider, supportsServiceTier),
 					isCurrentModelFastModeActive: () => this.ctx.session.isFastModeActive(),
 				},
 			);

package/src/modes/interactive-mode.ts

@@ -1345,7 +1345,11 @@ export class InteractiveMode implements InteractiveModeContext {
 			this.editorContainer.clear();
 			this.editorContainer.addChild(this.editor);
 		}
+		// Re-mounting after a cancelled action must invalidate the editor so the
+		// inline prompt suggestion is rendered again on the restored composer.
+		this.editor.invalidate();
 		this.ui.setFocus(this.editor);
+		this.ui.requestRender();
 	}
 
 	#createPetWidget(editor: CustomEditor): GajaePetWidget {

package/src/runtime/process-lifecycle.ts

@@ -28,7 +28,9 @@
  * drain it, so a chatty child whose stdout is never read can still block on a
  * full pipe. That draining is the adopter's responsibility.
  */
+import * as fs from "node:fs";
 import { logger, postmortem, ptree } from "@gajae-code/utils";
+import { type LinuxProcPidProbeResult, probeLinuxProcPidSync } from "../gjc-runtime/linux-proc";
 
 const DEFAULT_GRACEFUL_MS = 2_000;
 // Hard cap for how long `dispose()` waits after SIGKILL before giving up so a
@@ -69,6 +71,63 @@ function groupAlive(pgid: number): boolean {
 	}
 }
 
+/** Whether an unreadable `/proc` entry might still describe a running process. */
+export function procEntryMayStillBeRunning(error: unknown): boolean {
+	const code = (error as NodeJS.ErrnoException).code;
+	return code !== "ENOENT" && code !== "ESRCH";
+}
+
+/** Whether a process-group leader still has the spawn-time identity we own. */
+export function groupLeaderIdentityMatches(
+	expectedStartTime: string | undefined,
+	leader: LinuxProcPidProbeResult,
+): boolean {
+	// An absent leader cannot be a recycled leader. Its group may still contain
+	// descendants that we own, including when the root exits before we can read
+	// its start time immediately after spawn.
+	if (leader.kind === "absent") return true;
+	return expectedStartTime !== undefined && leader.kind === "live" && leader.startTime === expectedStartTime;
+}
+
+/**
+ * Whether a POSIX process group still has a *running* member. Zombies are
+ * inert: they execute no code and can only be reaped by their parent, which
+ * the owned process cannot control. Teardown must not wait on an external
+ * reaper, so disposal considers a group terminated once every member is dead
+ * or a zombie. On Linux this inspects `/proc`; elsewhere it conservatively
+ * falls back to {@link groupAlive} (zombies count as alive), so teardown there
+ * relies on the bounded SIGTERM/SIGKILL windows rather than zombie detection.
+ */
+function groupHasRunningMembers(pgid: number): boolean {
+	if (!groupAlive(pgid)) return false;
+	if (process.platform !== "linux") return true;
+	try {
+		for (const entry of fs.readdirSync("/proc")) {
+			if (entry.length === 0 || entry.charCodeAt(0) < 0x30 || entry.charCodeAt(0) > 0x39) continue;
+			let stat: string;
+			try {
+				stat = fs.readFileSync(`/proc/${entry}/stat`, "utf8");
+			} catch (error) {
+				// Entries disappearing during enumeration are expected. Every other
+				// failure leaves the member's state unknowable, so fail closed.
+				if (!procEntryMayStillBeRunning(error)) continue;
+				return true;
+			}
+			// Format: pid (comm) state ppid pgrp session tty ...; comm may contain
+			// spaces or parens, so parse everything after the last ')'.
+			const fields = stat.slice(stat.lastIndexOf(")") + 2).split(" ");
+			const state = fields[0] ?? "";
+			if (Number(fields[2]) === pgid && state !== "Z" && state !== "X") {
+				return true;
+			}
+		}
+		return false;
+	} catch {
+		// /proc unavailable or unreadable: keep the conservative behavior.
+		return true;
+	}
+}
+
 /** Options for {@link spawnOwnedProcess}. */
 export interface SpawnOwnedOptions {
 	cwd?: string;
@@ -97,6 +156,14 @@ export interface AwaitExitResult {
 	code: number | null;
 }
 
+/** The observed outcome of an owned-process teardown attempt. */
+export type OwnedProcessTeardownStatus = "terminated" | "still_running" | "identity_unverified";
+
+/** Result of {@link OwnedProcess.dispose}. */
+export interface OwnedProcessTeardownResult {
+	status: OwnedProcessTeardownStatus;
+}
+
 /** A spawned child process owned by the runtime with guaranteed teardown. */
 export interface OwnedProcess {
 	readonly child: ptree.ChildProcess;
@@ -116,7 +183,7 @@ export interface OwnedProcess {
 	 * abort listener and deregisters from the live-owner set only after teardown
 	 * has completed. Repeated/concurrent calls return the same in-flight promise.
 	 */
-	dispose(): Promise<void>;
+	dispose(): Promise<OwnedProcessTeardownResult>;
 }
 
 const liveOwners = new Set<OwnedProcess>();
@@ -155,9 +222,10 @@ export function spawnOwnedProcess(cmd: string[], opts: SpawnOwnedOptions = {}):
 	// On POSIX with `detached`, the child is its own process-group leader, so the
 	// group id equals its pid. `undefined` => single-process (Windows/opt-out).
 	const pgid = useGroup ? child.pid : undefined;
-
+	const groupLeader = pgid === undefined ? undefined : probeLinuxProcPidSync(pgid);
+	const groupLeaderStartTime = groupLeader?.kind === "live" ? groupLeader.startTime : undefined;
 	let disposed = false;
-	let disposePromise: Promise<void> | undefined;
+	let disposePromise: Promise<OwnedProcessTeardownResult> | undefined;
 	let deregistered = false;
 	// Terminal once teardown/reconciliation has confirmed the group is gone. A
 	// late dispose() must then be a true no-op and never re-probe a pgid the OS
@@ -172,14 +240,28 @@ export function spawnOwnedProcess(cmd: string[], opts: SpawnOwnedOptions = {}):
 		}
 	};
 
-	const deregister = (): void => {
+	const deregister = (terminal = true): void => {
 		if (deregistered) return;
 		deregistered = true;
-		terminated = true;
+		if (terminal) terminated = true;
 		liveOwners.delete(owner);
 		removeAbort();
 	};
 
+	// Identity verification exists to stop a recycled pgid from being signalled.
+	// It is only decidable where the leader's spawn-time identity is readable
+	// (`/proc`). Elsewhere the group id is still ours for the lifetime of the
+	// owned child, so an unverifiable probe must not be reported as a mismatch —
+	// doing so skips SIGTERM/SIGKILL entirely and leaks the whole child tree.
+	const groupIdentityMatches = (): boolean => {
+		if (pgid === undefined) return false;
+		if (process.platform !== "linux") return true;
+		const leader = probeLinuxProcPidSync(pgid);
+		// Once the original leader has exited, its group can still own descendants.
+		// A replacement group has a leader at this pid, whose start time must match.
+		return groupLeaderIdentityMatches(groupLeaderStartTime, leader);
+	};
+
 	const signalTree = (signal: NodeJS.Signals): void => {
 		const pid = child.pid;
 		if (pid === undefined) return;
@@ -232,51 +314,68 @@ export function spawnOwnedProcess(cmd: string[], opts: SpawnOwnedOptions = {}):
 				if (timer) clearTimeout(timer);
 			}
 		},
-		dispose(): Promise<void> {
+		dispose(): Promise<OwnedProcessTeardownResult> {
 			// Already terminal (e.g. clean drain reconciled and deregistered):
 			// never re-probe the pgid; treat dispose as a settled no-op.
 			if (terminated) {
 				disposed = true;
-				if (!disposePromise) disposePromise = Promise.resolve();
+				if (!disposePromise) disposePromise = Promise.resolve({ status: "terminated" });
 				return disposePromise;
 			}
 			if (disposePromise) return disposePromise;
 			disposed = true;
 			removeAbort();
-			disposePromise = (async () => {
+			const result = (status: OwnedProcessTeardownStatus): OwnedProcessTeardownResult => ({ status });
+			disposePromise = (async (): Promise<OwnedProcessTeardownResult> => {
 				try {
 					if (pgid !== undefined) {
-						// Group ownership: reap until the whole group is gone, even if
-						// the root has already exited (it may have backgrounded children).
-						if (!groupAlive(pgid)) return;
+						// Group ownership: terminate every *running* member, even if the
+						// root has already exited (it may have backgrounded children).
+						// Liveness is measured by running members, not raw group
+						// existence: SIGTERM'd descendants become zombies that only their
+						// parent (often PID 1) can reap, and teardown must not burn its
+						// grace window waiting on an external reaper.
+						if (!groupAlive(pgid)) return result("terminated");
+						if (!groupIdentityMatches()) return result("identity_unverified");
 						signalTree("SIGTERM");
-						if (await pollUntil(() => !groupAlive(pgid), gracefulMs)) return;
+						if (await pollUntil(() => !groupHasRunningMembers(pgid), gracefulMs)) return result("terminated");
+						if (!groupIdentityMatches()) return result("identity_unverified");
 						signalTree("SIGKILL");
-						if (!(await pollUntil(() => !groupAlive(pgid), SIGKILL_REAP_CAP_MS))) {
-							logger.warn("owned process group still alive after SIGKILL", {
-								name: opts.name,
-								pgid,
-							});
-						}
-						return;
+						if (await pollUntil(() => !groupHasRunningMembers(pgid), SIGKILL_REAP_CAP_MS))
+							return result("terminated");
+						logger.warn("owned process group still running after SIGKILL", {
+							name: opts.name,
+							pgid,
+						});
+						return result("still_running");
 					}
 					// Single-process fallback (Windows / processGroup:false).
-					if (child.exitCode !== null) return;
+					if (child.exitCode !== null) return result("terminated");
 					signalTree("SIGTERM");
-					if ((await owner.awaitExit({ timeoutMs: gracefulMs })).exited) return;
+					if ((await owner.awaitExit({ timeoutMs: gracefulMs })).exited) return result("terminated");
 					signalTree("SIGKILL");
-					await owner.awaitExit({ timeoutMs: SIGKILL_REAP_CAP_MS });
+					return (await owner.awaitExit({ timeoutMs: SIGKILL_REAP_CAP_MS })).exited
+						? result("terminated")
+						: result("still_running");
 				} catch (err) {
 					logger.warn("owned process dispose failed", {
 						name: opts.name,
 						error: err instanceof Error ? err.message : String(err),
 					});
-				} finally {
-					// FIX: deregister only after teardown has completed so a postmortem
-					// firing mid-grace still sees the owner and awaits this dispose.
-					deregister();
+					return result("still_running");
 				}
-			})();
+			})().then(res => {
+				// `identity_unverified` and `still_running` leave the owner registered
+				// so a later postmortem or caller retry can make another bounded attempt.
+				// Only a confirmed `terminated` closes the book.
+				if (res.status === "terminated") {
+					deregister(true);
+				} else {
+					disposePromise = undefined;
+					disposed = false;
+				}
+				return res;
+			});
 			return disposePromise;
 		},
 	};

package/src/runtime-mcp/transports/stdio.ts

@@ -89,10 +89,10 @@ export class StdioTransport implements MCPTransport {
 	 * Start the subprocess and begin reading.
 	 */
 	async connect(): Promise<void> {
-		if (this.#closePromise) {
-			throw new MCPExpectedFailure();
-		}
 		if (this.#connected) return;
+		if (this.#closePromise || this.#process) {
+			throw new MCPExpectedFailure(new Error("MCP stdio child teardown is incomplete"));
+		}
 
 		const args = this.config.args ?? [];
 		const env = this.config.noInheritEnv
@@ -244,7 +244,9 @@ export class StdioTransport implements MCPTransport {
 	}
 
 	#handleClose(failure?: MCPExpectedFailure): void {
-		void this.#closeInternal(true, failure);
+		void this.#closeInternal(true, failure).catch(error => {
+			this.onError?.(error instanceof Error ? error : new Error(String(error)));
+		});
 	}
 
 	async request<T = unknown>(
@@ -374,11 +376,14 @@ export class StdioTransport implements MCPTransport {
 
 		const stdin = this.#getStdin();
 		const process = this.#process;
-		this.#process = null;
 		if (process) {
 			stdin?.end();
-			await process.dispose().catch(() => {});
+			const teardown = await process.dispose();
 			await process.awaitExit({ timeoutMs: CLOSE_WAIT_MS }).catch(() => ({ exited: false, code: null }));
+			if (teardown.status !== "terminated") {
+				throw new MCPExpectedFailure(new Error(`stdio child teardown ${teardown.status}`));
+			}
+			this.#process = null;
 		}
 
 		if (!fromReadLoop && this.#readLoop) {

package/src/sdk/acp/adapter.ts

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { lifecycleRequestTimeoutMs } from "../broker/startup-budget";
-import { SdkClient, SdkClientError, type SdkFrame } from "../client";
+import { SdkClient, SdkClientError, type SdkFrame, type SdkSentRecord } from "../client";
 import { assertReverseResponseFrame, ReverseLeaseError } from "../host/reverse-leases";
 import { validateAdapterControl, validateAdapterSecretFields } from "../protocol/adapter-validation";
 import { OPERATIONS } from "../protocol/operation-registry";
@@ -224,16 +224,24 @@ export class AcpSdkAdapter {
 		if (isLifecycleOperation(operation) && !idempotencyKey)
 			throw new AcpSdkAdapterError("invalid_input", "idempotencyKey is required for lifecycle operations.");
 		// The broker may hold a startup in its admission queue before the readiness
-		// clock even starts, so the caller deadline covers the queue wait too; sizing
-		// it on readiness alone times out requests the broker is still running. A
-		// request that named no readiness budget is queued for the default one, so it
-		// needs the same extension rather than the client's generic request deadline.
+		// clock starts, so the caller deadline covers the queue wait too.
 		const timeoutMs = lifecycleRequestTimeoutMs(operation, input);
-		const response = await this.#client.global(operation, input, {
-			idempotencyKey,
-			...(timeoutMs === undefined ? {} : { timeoutMs }),
-		});
-		return response;
+		try {
+			return await this.#client.global(operation, input, {
+				idempotencyKey,
+				...(timeoutMs === undefined ? {} : { timeoutMs }),
+			});
+		} catch (error) {
+			if (
+				isLifecycleOperation(operation) &&
+				error instanceof SdkClientError &&
+				error.code === "uncertain_after_send" &&
+				error.details &&
+				typeof error.details === "object"
+			)
+				return await this.#client.lookupLifecycle(error.details as SdkSentRecord);
+			throw error;
+		}
 	}
 
 	async sdkControl(params: { operation: string; input?: JsonObject }): Promise<unknown> {

package/src/sdk/broker/broker.ts

@@ -45,7 +45,7 @@ import {
 	readBrokerDiscovery,
 	redactBrokerDiscovery,
 } from "./discovery";
-import { deriveIdempotencyIdentity } from "./identity";
+import { deriveIdempotencyIdentity, deriveLegacyTargetIdentity } from "./identity";
 import { canonicalDeleteLocatorPath, executeLifecycle, isCanonicalSessionId } from "./lifecycle";
 import {
 	type LifecycleDurableEffectsReceipt,
@@ -237,6 +237,14 @@ function lifecycleResponseState(response: BrokerResponse): LifecycleState {
 	return response.error.code === "terminal_uncertain" ? "terminal_uncertain" : "terminal_error";
 }
 
+const LIFECYCLE_OPERATIONS = new Set([
+	"session.create",
+	"session.fork",
+	"session.resume",
+	"session.close",
+	"session.delete",
+]);
+
 type InputNormalization = { input: Record<string, unknown> } | BrokerResponse;
 
 type SessionListCursor = {
@@ -457,7 +465,7 @@ function lifecycleTarget(operation: string, input: Record<string, unknown>): unk
 		case "session.resume":
 		case "session.close":
 		case "session.delete":
-			return { sessionId: id };
+			return { root, sessionId: id };
 		default:
 			return { operation, root, sessionId: id };
 	}
@@ -1411,6 +1419,7 @@ export class Broker {
 		elevationRequestId?: string,
 	): Promise<BrokerResponse> {
 		if (this.#stopping) return error("broker_restarting", "broker is stopping");
+		const fingerprint = JSON.stringify({ operation, input: JSON.parse(JSON.stringify(input)) });
 		const normalization = normalizeBrokerInput(operation, input);
 		if (isBrokerResponse(normalization)) return normalization;
 		const approvedInput = input;
@@ -1454,6 +1463,32 @@ export class Broker {
 		if (operation === "elevation.issue") return this.#elevationIssueRequest(input);
 		if (operation === "elevation.status") return this.#elevationStatusRequest(input);
 		if (operation === "session.control") return this.#sessionControlRequest(input);
+		if (operation === "broker.lookup_lifecycle") {
+			const requestedOperation = typeof input.operation === "string" ? input.operation : undefined;
+			const fingerprint = typeof input.fingerprint === "string" ? input.fingerprint : undefined;
+			if (!idempotencyKey || !requestedOperation || !fingerprint)
+				return error("invalid_input", "operation, idempotencyKey, and fingerprint are required");
+			if (!LIFECYCLE_OPERATIONS.has(requestedOperation))
+				return error("not_found", "lifecycle operation was not found");
+			const identity = await deriveIdempotencyIdentity(this.settings.agentDir, requestedOperation, idempotencyKey);
+			const entry = this.ledger.get(identity);
+			if (!entry) return error("not_found", "lifecycle operation was not found");
+			if (entry.fingerprint !== fingerprint)
+				return error("idempotency_conflict", "lifecycle request fingerprint differs");
+			if (entry.state === "terminal_uncertain")
+				return {
+					ok: false,
+					error: { code: "terminal_uncertain", message: "lifecycle outcome is still uncertain" },
+				};
+			// Reconcile to the terminal original response contract: callers expect
+			// the BrokerResponse they would have received, not a lookup envelope.
+			return (
+				(entry.response as BrokerResponse) ?? {
+					ok: false,
+					error: { code: "terminal_uncertain", message: "lifecycle outcome has no recorded response" },
+				}
+			);
+		}
 		if (!idempotencyKey) return error("invalid_input", "idempotencyKey is required for lifecycle operations");
 		// Elevation gate (F1.3): allowlisted raw operations execute only behind a
 		// broker-owned single-use grant. Validation is fail-closed and happens
@@ -1504,7 +1539,20 @@ export class Broker {
 		const target = createHash("sha256")
 			.update(canonicalJson(lifecycleTarget(operation, input)))
 			.digest("hex");
-		const identity = await deriveIdempotencyIdentity(this.settings.agentDir, operation, idempotencyKey, target);
+		const identity = await deriveIdempotencyIdentity(this.settings.agentDir, operation, idempotencyKey);
+		const operationKey = `${operation}\0${idempotencyKey}`;
+		const legacyIdentity = await deriveLegacyTargetIdentity(
+			this.settings.agentDir,
+			operation,
+			idempotencyKey,
+			target,
+		);
+		if (!this.ledger.get(identity)) {
+			if (await this.ledger.migrateIdentity(legacyIdentity, identity, { operationKey, fingerprint })) {
+				// Exact target-derived legacy identity migrated without granting new authority.
+			} else if (this.ledger.findByOperationKey(operationKey) || this.ledger.hasLegacyIdentity())
+				return error("idempotency_conflict", "legacy lifecycle request has an ambiguous target");
+		}
 		let reconstructedDeleteCleanup: BrokerCleanupEvidence | undefined;
 		if (operation === "session.delete" && input.cwd === undefined && input.sessionPath === undefined) {
 			const entry = this.ledger.get(identity);
@@ -1570,7 +1618,10 @@ export class Broker {
 		await prev;
 		try {
 			const beforeBegin = this.ledger.get(identity);
-			const begun = await this.ledger.begin(identity, requestHash);
+			const begun = await this.ledger.begin(identity, requestHash, {
+				operationKey,
+				fingerprint,
+			});
 			if (begun.kind === "replay") {
 				const replay = begun.entry.response as BrokerResponse;
 				const cleanup = cleanupFromResponse(replay) ?? reconstructedDeleteCleanup;

package/src/sdk/broker/ensure.ts

@@ -5,6 +5,7 @@ import * as fs from "node:fs/promises";
 import path from "node:path";
 import { type BrokerDiscovery, brokerProcessIncarnation, readBrokerDiscovery } from "./discovery";
 import { resolveSdkInternalSpawnCommand, type SdkInternalSpawnCommand } from "./runtime";
+import { BrokerStartupError, clearBrokerStartupFailureMarker, readBrokerStartupFailureMarker } from "./startup-failure";
 export interface EnsureBrokerSettings {
 	agentDir: string;
 	heartbeatTtlMs?: number;
@@ -301,6 +302,8 @@ async function ensureBrokerOnce(settings: EnsureBrokerSettings, initiator: Ensur
 
 	const command = resolveSdkInternalSpawnCommand("broker-internal");
 	const spawnLog = await openBrokerSpawnLog(settings.agentDir);
+	// A stale marker must never be misattributed to this spawn; clear it first.
+	await clearBrokerStartupFailureMarker(settings.agentDir);
 	try {
 		const child = spawn(command.file, [...command.args, "--agent-dir", settings.agentDir], {
 			detached: true,
@@ -358,16 +361,16 @@ async function ensureBrokerOnce(settings: EnsureBrokerSettings, initiator: Ensur
 			}
 		}
 		const spawnLogTail = exitedBeforeDiscovery && spawnLog ? await readBrokerSpawnLogTail(spawnLog.path) : "";
+		const marker = await readBrokerStartupFailureMarker(settings.agentDir);
 		const failure = spawnError
 			? new Error(`Failed to spawn detached SDK broker: ${spawnError.message}`)
 			: exitedBeforeDiscovery
-				? new Error(
-						`Detached SDK broker exited before discovery (code=${child.exitCode}, signal=${child.signalCode}).${
-							spawnLogTail
-								? ` Broker stderr: ${spawnLogTail}`
-								: " The broker wrote no stderr; see the gjc log for its lock-contention diagnostic."
-						}`,
-					)
+				? new BrokerStartupError({
+						exitCode: child.exitCode,
+						signal: child.signalCode,
+						reason: marker?.reason ?? "Detached SDK broker exited before publishing discovery.",
+						stderrExcerpt: spawnLogTail.length > 0 ? spawnLogTail : undefined,
+					})
 				: discoveryError
 					? discoveryError
 					: new Error("Timed out waiting for detached SDK broker discovery.");

package/src/sdk/broker/identity.ts

@@ -40,6 +40,16 @@ export async function getBrokerIdentityKey(agentDir: string): Promise<string> {
 }
 
 export async function deriveIdempotencyIdentity(
+	agentDir: string,
+	operation: string,
+	callerKey: string,
+	_protocolVersionOrLegacyTargetHash?: string,
+): Promise<string> {
+	const key = await getBrokerIdentityKey(agentDir);
+	return createHmac("sha256", Buffer.from(key, "hex")).update(`3|${operation}|${callerKey}`).digest("hex");
+}
+
+export async function deriveLegacyTargetIdentity(
 	agentDir: string,
 	operation: string,
 	callerKey: string,