fix(coding-agent): resolve v0.18.8 CI lifecycle regressions

packages/coding-agent/changelog.d/6508-deadline-recovery-tools-drain.md

@@ -0,0 +1,3 @@
+### Fixes
+
+- **SDK deadline recovery now immediately retries when pending tools drain (#6508)**. The deadline recovery loop was using a 1-second retry timer that could miss the exact moment when tools drained to zero pending. In CI environments with scheduler variation, the recovery loop could timeout waiting for the timer to fire even though tools had already drained. The fix adds immediate retry (0ms delay) when tools transition from pending to settled, ensuring the deadline recovery publishes the terminal result without waiting for the scheduled retry timer. Regression test in `session-runtime.test.ts` validates that deadline recovery completes even with pending tools that drain before timeout.

packages/coding-agent/changelog.d/issue-6508-lifecycle-ownership.md

@@ -0,0 +1,3 @@
+### Fixed
+- Keep accepted SDK prompt terminal outcomes private until exact run/tool settlement evidence is available.
+- Preserve queued subagent owner and generation identity through shutdown cancellation and queue draining.

packages/coding-agent/src/prompts/tools/read.md

@@ -73,7 +73,7 @@ For `.sqlite`, `.sqlite3`, `.db`, `.db3`:
 
 `agent://<id>`, `artifact://<id>`, `rule://<name>`, and `local://<name>.md` resolve transparently and accept the same line selectors as filesystem paths. Use `artifact://<id>` to recover full output that a previous bash/eval/tool result spilled or truncated.
 
-Bundled skills have no filesystem home, so the skill tool and skill discovery report them as `embedded:gjc/skills/<name>/SKILL.md`; read that identifier verbatim. Bundled skill fragments, when surfaced, likewise use `embedded:gjc/skill-fragments/...` identifiers.
+Bundled skills have no filesystem home, so the skill tool and skill discovery report them as `embedded:gjc/skills/<name>/SKILL.md`; read that identifier verbatim. Bundled skill fragments, when surfaced, likewise use `embedded:gjc/skill-fragments/…` identifiers.
 
 <critical>
 - Always include `path`; never call `read` with `{}`.

packages/coding-agent/src/sdk/bus/reconciliation-store.ts

@@ -670,11 +670,22 @@ export interface ReconciliationStore {
 	delete(): Promise<void>;
 }
 
+export interface ReconciliationStoreInstrumentationEvent {
+	at: number;
+	phase: "enqueued" | "started" | "completed" | "failed";
+	operation?: string;
+	substep?: string;
+	error?: string;
+	/** Detailed information about lock acquisition, promise identity, db state, etc. */
+	detail?: string;
+}
+
 export function createReconciliationStore(options: {
 	sessionFile: string | null | undefined;
 	sessionId: string;
 	fs?: ReconciliationStoreFs;
 	now?: () => number;
+	onInstrumentationForTests?: (event: ReconciliationStoreInstrumentationEvent) => void;
 }): ReconciliationStore {
 	const fileFs = options.fs ?? nodeFs;
 	const now = options.now ?? Date.now;
@@ -701,20 +712,56 @@ export function createReconciliationStore(options: {
 		const directory = path.dirname(filePath);
 		let temporary: string | undefined;
 		try {
+			try {
+				options.onInstrumentationForTests?.({ at: Date.now(), phase: "started", substep: "mkdir" });
+			} catch {}
 			await fileFs.mkdir(directory, { recursive: true, mode: 0o700 });
+			try {
+				options.onInstrumentationForTests?.({ at: Date.now(), phase: "completed", substep: "mkdir" });
+			} catch {}
 			temporary = `${filePath}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
+			try {
+				options.onInstrumentationForTests?.({ at: Date.now(), phase: "started", substep: "writeFile" });
+			} catch {}
 			await fileFs.writeFile(temporary, `${JSON.stringify(document)}\n`, { mode: 0o600 });
 			try {
+				options.onInstrumentationForTests?.({ at: Date.now(), phase: "completed", substep: "writeFile" });
+			} catch {}
+			try {
+				try {
+					options.onInstrumentationForTests?.({ at: Date.now(), phase: "started", substep: "open" });
+				} catch {}
 				const handle = await fileFs.open(temporary, "r+");
 				try {
+					options.onInstrumentationForTests?.({ at: Date.now(), phase: "completed", substep: "open" });
+				} catch {}
+				try {
+					try {
+						options.onInstrumentationForTests?.({ at: Date.now(), phase: "started", substep: "sync" });
+					} catch {}
 					await handle.sync();
+					try {
+						options.onInstrumentationForTests?.({ at: Date.now(), phase: "completed", substep: "sync" });
+					} catch {}
 				} finally {
+					try {
+						options.onInstrumentationForTests?.({ at: Date.now(), phase: "started", substep: "close" });
+					} catch {}
 					await handle.close();
+					try {
+						options.onInstrumentationForTests?.({ at: Date.now(), phase: "completed", substep: "close" });
+					} catch {}
 				}
 			} catch {
 				// fsync optional on some fs seams
 			}
+			try {
+				options.onInstrumentationForTests?.({ at: Date.now(), phase: "started", substep: "rename" });
+			} catch {}
 			await fileFs.rename(temporary, filePath);
+			try {
+				options.onInstrumentationForTests?.({ at: Date.now(), phase: "completed", substep: "rename" });
+			} catch {}
 		} catch (error) {
 			// Every persistence-path failure (mkdir included) is evidence a drained
 			// window must surface, never silently treat as quiescent (#4743).
@@ -723,6 +770,9 @@ export function createReconciliationStore(options: {
 				code: "reconciliation_persist_failed",
 			});
 			unreportedPersistFailures.push(coded);
+			try {
+				options.onInstrumentationForTests?.({ at: Date.now(), phase: "failed", error: coded.message });
+			} catch {}
 			throw coded;
 		}
 	};
@@ -795,7 +845,26 @@ export function createReconciliationStore(options: {
 	const transact = async (
 		mutator: (records: DurableReconciliationRecord[]) => DurableReconciliationRecord[],
 	): Promise<void> => {
+		const promiseId = `reconcil-transact-${randomUUID().slice(0, 8)}`;
+		const enqueueTime = Date.now();
 		const run = async () => {
+			const lockWaitMs = Date.now() - enqueueTime;
+			try {
+				options.onInstrumentationForTests?.({
+					at: enqueueTime,
+					phase: "enqueued",
+					operation: "transact",
+					detail: `promise=${promiseId}`,
+				});
+			} catch {}
+			try {
+				options.onInstrumentationForTests?.({
+					at: Date.now(),
+					phase: "started",
+					operation: "transact",
+					detail: `promise=${promiseId} lock-wait=${lockWaitMs}ms`,
+				});
+			} catch {}
 			const next = mutator(memory.map(r => ({ ...r })));
 			await writeAtomic({
 				version: RECONCILIATION_STORE_VERSION,
@@ -805,19 +874,55 @@ export function createReconciliationStore(options: {
 				...(terminalKeyMemory.length > 0 ? { evictedTerminalKeys: terminalKeyMemory } : {}),
 			});
 			memory = next;
+			try {
+				options.onInstrumentationForTests?.({
+					at: Date.now(),
+					phase: "completed",
+					operation: "transact",
+					detail: `promise=${promiseId}`,
+				});
+			} catch {}
 		};
 		const pending = chain.then(run, run);
-		chain = pending.then(
+		const settled = pending.then(
 			() => undefined,
 			() => undefined,
 		);
-		await pending;
+		chain = settled;
+		try {
+			await pending;
+		} catch (error) {
+			try {
+				options.onInstrumentationForTests?.({
+					at: Date.now(),
+					phase: "failed",
+					operation: "transact",
+					detail: `promise=${promiseId} lock-wait=${Date.now() - enqueueTime}ms`,
+					error: error instanceof Error ? error.message : String(error),
+				});
+			} catch {}
+			throw error;
+		}
 	};
 
 	const transactTerminalScopes = async (
 		mutator: (scopes: DurableTerminalScopeRecord[]) => DurableTerminalScopeRecord[],
 	): Promise<void> => {
 		const run = async () => {
+			try {
+				options.onInstrumentationForTests?.({
+					at: Date.now(),
+					phase: "enqueued",
+					operation: "transactTerminalScopes",
+				});
+			} catch {}
+			try {
+				options.onInstrumentationForTests?.({
+					at: Date.now(),
+					phase: "started",
+					operation: "transactTerminalScopes",
+				});
+			} catch {}
 			const next = mutator(terminalMemory.map(s => ({ ...s })));
 			await writeAtomic({
 				version: RECONCILIATION_STORE_VERSION,
@@ -827,13 +932,33 @@ export function createReconciliationStore(options: {
 				...(terminalKeyMemory.length > 0 ? { evictedTerminalKeys: terminalKeyMemory } : {}),
 			});
 			terminalMemory = next;
+			try {
+				options.onInstrumentationForTests?.({
+					at: Date.now(),
+					phase: "completed",
+					operation: "transactTerminalScopes",
+				});
+			} catch {}
 		};
 		const pending = chain.then(run, run);
-		chain = pending.then(
+		const settled = pending.then(
 			() => undefined,
 			() => undefined,
 		);
-		await pending;
+		chain = settled;
+		try {
+			await pending;
+		} catch (error) {
+			try {
+				options.onInstrumentationForTests?.({
+					at: Date.now(),
+					phase: "failed",
+					operation: "transactTerminalScopes",
+					error: error instanceof Error ? error.message : String(error),
+				});
+			} catch {}
+			throw error;
+		}
 	};
 
 	const transactTerminalState = async (
@@ -843,6 +968,20 @@ export function createReconciliationStore(options: {
 		},
 	): Promise<void> => {
 		const run = async () => {
+			try {
+				options.onInstrumentationForTests?.({
+					at: Date.now(),
+					phase: "enqueued",
+					operation: "transactTerminalState",
+				});
+			} catch {}
+			try {
+				options.onInstrumentationForTests?.({
+					at: Date.now(),
+					phase: "started",
+					operation: "transactTerminalState",
+				});
+			} catch {}
 			const next = mutator({
 				scopes: terminalMemory.map(s => ({ ...s })),
 				keys: terminalKeyMemory.map(k => ({ ...k })),
@@ -856,19 +995,53 @@ export function createReconciliationStore(options: {
 			});
 			terminalMemory = next.scopes;
 			terminalKeyMemory = next.keys;
+			try {
+				options.onInstrumentationForTests?.({
+					at: Date.now(),
+					phase: "completed",
+					operation: "transactTerminalState",
+				});
+			} catch {}
 		};
 		const pending = chain.then(run, run);
-		chain = pending.then(
+		const settled = pending.then(
 			() => undefined,
 			() => undefined,
 		);
-		await pending;
+		chain = settled;
+		try {
+			await pending;
+		} catch (error) {
+			try {
+				options.onInstrumentationForTests?.({
+					at: Date.now(),
+					phase: "failed",
+					operation: "transactTerminalState",
+					error: error instanceof Error ? error.message : String(error),
+				});
+			} catch {}
+			throw error;
+		}
 	};
 
 	const transactTerminalKeys = async (
 		mutator: (keys: EvictedTerminalKeyEntry[]) => EvictedTerminalKeyEntry[],
 	): Promise<void> => {
 		const run = async () => {
+			try {
+				options.onInstrumentationForTests?.({
+					at: Date.now(),
+					phase: "enqueued",
+					operation: "transactTerminalKeys",
+				});
+			} catch {}
+			try {
+				options.onInstrumentationForTests?.({
+					at: Date.now(),
+					phase: "started",
+					operation: "transactTerminalKeys",
+				});
+			} catch {}
 			const next = mutator(terminalKeyMemory.map(k => ({ ...k })));
 			await writeAtomic({
 				version: RECONCILIATION_STORE_VERSION,
@@ -878,13 +1051,33 @@ export function createReconciliationStore(options: {
 				...(next.length > 0 ? { evictedTerminalKeys: next } : {}),
 			});
 			terminalKeyMemory = next;
+			try {
+				options.onInstrumentationForTests?.({
+					at: Date.now(),
+					phase: "completed",
+					operation: "transactTerminalKeys",
+				});
+			} catch {}
 		};
 		const pending = chain.then(run, run);
-		chain = pending.then(
+		const settled = pending.then(
 			() => undefined,
 			() => undefined,
 		);
-		await pending;
+		chain = settled;
+		try {
+			await pending;
+		} catch (error) {
+			try {
+				options.onInstrumentationForTests?.({
+					at: Date.now(),
+					phase: "failed",
+					operation: "transactTerminalKeys",
+					error: error instanceof Error ? error.message : String(error),
+				});
+			} catch {}
+			throw error;
+		}
 	};
 
 	const deleteStore = async (): Promise<void> => {