@gajae-code/coding-agent 0.18.1 → 0.18.5

package/src/config/autorouting-tier-map.ts

@@ -45,8 +45,9 @@ export const TIER_MAP_VERSION = 1;
 
 export const CURATED_TIER_LABELS = {
 	"anthropic/claude-haiku-4-5": [{ tier: "fast", rank: 1 }],
-	"anthropic/claude-sonnet-5": [{ tier: "balanced", rank: 1 }],
-	"anthropic/claude-sonnet-4-6": [{ tier: "balanced", rank: 2 }],
+	"anthropic/claude-sonnet-5-5": [{ tier: "balanced", rank: 1 }],
+	"anthropic/claude-sonnet-5": [{ tier: "balanced", rank: 2 }],
+	"anthropic/claude-sonnet-4-6": [{ tier: "balanced", rank: 3 }],
 	"anthropic/claude-opus-5-5": [{ tier: "strong", effort: "high", rank: 1 }],
 	"anthropic/claude-opus-5": [{ tier: "strong", effort: "high", rank: 2 }],
 	"anthropic/claude-opus-4-8": [{ tier: "strong", effort: "high", rank: 3 }],
@@ -55,6 +56,7 @@ export const CURATED_TIER_LABELS = {
 		{ tier: "balanced", effort: "medium", rank: 1 },
 	],
 	"openai-codex/gpt-6-sol": [{ tier: "strong", effort: "high", rank: 1 }],
+	"openai-codex/gpt-6.1-sol": [{ tier: "strong", effort: "high", rank: 2 }],
 	"google/gemini-3.5-flash-lite": [{ tier: "fast", rank: 1 }],
 	"google/gemini-2.5-flash-lite": [{ tier: "fast", rank: 2 }],
 	"google/gemini-3.5-flash": [{ tier: "balanced", rank: 1 }],
@@ -75,6 +77,22 @@ export const CURATED_TIER_LABELS = {
 
 /** Generated from packages/ai/src/models.json at feature land: 3936 in-scope baseline skips. */
 export const TIER_MAP_SKIP_LIST = {
+	"amazon-bedrock/anthropic.claude-sonnet-5-5": { rationale: "Sonnet 5.5 catalog addition (#6111); not yet curated" },
+	"amazon-bedrock/au.anthropic.claude-sonnet-5-5": {
+		rationale: "Sonnet 5.5 catalog addition (#6111); not yet curated",
+	},
+	"amazon-bedrock/eu.anthropic.claude-sonnet-5-5": {
+		rationale: "Sonnet 5.5 catalog addition (#6111); not yet curated",
+	},
+	"amazon-bedrock/global.anthropic.claude-sonnet-5-5": {
+		rationale: "Sonnet 5.5 catalog addition (#6111); not yet curated",
+	},
+	"amazon-bedrock/jp.anthropic.claude-sonnet-5-5": {
+		rationale: "Sonnet 5.5 catalog addition (#6111); not yet curated",
+	},
+	"amazon-bedrock/us.anthropic.claude-sonnet-5-5": {
+		rationale: "Sonnet 5.5 catalog addition (#6111); not yet curated",
+	},
 	"kiro/claude-opus-5-5": { rationale: "post-rebase catalog addition from dev; not yet curated" },
 	"kiro/claude-opus-5.5": { rationale: "post-rebase catalog addition from dev; not yet curated" },
 	"alibaba-token-plan/qwen3.8-flash": { rationale: "post-rebase catalog addition from dev; not yet curated" },

package/src/config/model-preset-registry.ts

@@ -652,6 +652,9 @@ function assertRegistryIdentityPolicy(value: unknown): void {
 }
 
 function assertCanonicalUnicode(value: string): void {
+	// Native well-formedness check first; the scan below only runs to name the
+	// offending surrogate when the string is malformed.
+	if (value.isWellFormed()) return;
 	for (let index = 0; index < value.length; index++) {
 		const code = value.charCodeAt(index);
 		if (code >= 0xd800 && code <= 0xdbff) {
@@ -665,6 +668,18 @@ function assertCanonicalUnicode(value: string): void {
 	}
 }
 
+/** Characters JSON.stringify escapes in strings (lone surrogates are rejected earlier). */
+const JSON_STRING_ESCAPES = /["\\\u0000-\u001f]/;
+
+/**
+ * Quote a string exactly as JSON.stringify does. Registry documents are almost
+ * entirely plain ASCII identifiers, so skipping the per-call JSON.stringify for
+ * strings with nothing to escape removes most of the serializer's cost.
+ */
+function quoteCanonicalString(value: string): string {
+	return JSON_STRING_ESCAPES.test(value) ? JSON.stringify(value) : `"${value}"`;
+}
+
 function serializeCanonicalJson(value: unknown, stack: Set<object>): string {
 	if (value === null) return "null";
 	if (typeof value === "boolean") return value ? "true" : "false";
@@ -674,7 +689,7 @@ function serializeCanonicalJson(value: unknown, stack: Set<object>): string {
 	}
 	if (typeof value === "string") {
 		assertCanonicalUnicode(value);
-		return JSON.stringify(value);
+		return quoteCanonicalString(value);
 	}
 	if (typeof value !== "object") throw new TypeError(`Canonical JSON rejects ${typeof value}.`);
 	if (stack.has(value)) throw new TypeError("Canonical JSON rejects cycles.");
@@ -694,7 +709,7 @@ function serializeCanonicalJson(value: unknown, stack: Set<object>): string {
 		const entries: string[] = [];
 		for (const key of Object.keys(record).sort()) {
 			assertCanonicalUnicode(key);
-			entries.push(`${JSON.stringify(key)}:${serializeCanonicalJson(record[key], stack)}`);
+			entries.push(`${quoteCanonicalString(key)}:${serializeCanonicalJson(record[key], stack)}`);
 		}
 		return `{${entries.join(",")}}`;
 	} finally {

package/src/config/model-profile-activation.ts

@@ -17,6 +17,7 @@ import {
 export { resolveModelProfileName } from "./model-profile-contract";
 
 import {
+	createRegistrySelectorIndex,
 	GJC_MODEL_ASSIGNMENT_TARGETS,
 	type GjcModelAssignmentTargetId,
 	isAuthenticated,
@@ -675,6 +676,7 @@ export async function resolveMissingSessionModelRecovery(options: {
 		options.skips.every(skip => skip.reason === "unknown_model");
 	if (!allSelectorsUnknown) return undefined;
 	const fullCatalog = options.modelRegistry.getAll();
+	const catalogIndex = createRegistrySelectorIndex(fullCatalog);
 	const savedSelectorsMissingFromCatalog = resolveConfiguredModelPatterns(
 		options.defaultEntries,
 		options.settings,
@@ -688,7 +690,7 @@ export async function resolveMissingSessionModelRecovery(options: {
 			}).model
 		)
 			return false;
-		return !registrySelectorResolvesToModel(selector, fullCatalog);
+		return !registrySelectorResolvesToModel(selector, catalogIndex);
 	});
 	const savedConcreteDefault = options.savedDefault ? parseModelString(options.savedDefault) : undefined;
 	const savedConcreteDefaultMissingFromCatalog =

package/src/config/model-profiles.ts

@@ -93,6 +93,13 @@ export const BUILTIN_MODEL_PROFILES: readonly ModelProfileDefinition[] = [
 		critic: "openai-codex/gpt-6-sol:max",
 		architect: "openai-codex/gpt-6-sol:xhigh",
 	}),
+	profile("codex-sol61", ["openai-codex"], {
+		default: "openai-codex/gpt-6.1-sol:medium",
+		executor: "openai-codex/gpt-6.1-sol:medium",
+		planner: "openai-codex/gpt-6.1-sol:high",
+		critic: "openai-codex/gpt-6.1-sol:xhigh",
+		architect: "openai-codex/gpt-6-astra:xhigh",
+	}),
 	profile("lunamaxxing", ["openai-codex"], {
 		default: "openai-codex/gpt-6-luna:medium",
 		executor: "openai-codex/gpt-6-luna:xhigh",
@@ -256,14 +263,14 @@ export const BUILTIN_MODEL_PROFILES: readonly ModelProfileDefinition[] = [
 	}),
 	profile("claude-opus", ["anthropic"], {
 		default: ["anthropic/claude-opus-5-5:medium", "anthropic/claude-opus-4-6:xhigh"],
-		executor: "anthropic/claude-sonnet-5",
+		executor: "anthropic/claude-sonnet-5-5",
 		planner: ["anthropic/claude-opus-5-5:medium", "anthropic/claude-opus-4-6:low"],
 		critic: ["anthropic/claude-opus-5-5:high", "anthropic/claude-opus-4-6:high"],
 		architect: ["anthropic/claude-opus-5-5:high", "anthropic/claude-opus-4-6:xhigh"],
 	}),
 	profile("claude-fable", ["anthropic"], {
 		default: "anthropic/claude-fable-5-1:xhigh",
-		executor: "anthropic/claude-sonnet-5",
+		executor: "anthropic/claude-sonnet-5-5",
 		planner: "anthropic/claude-fable-5-1:low",
 		critic: "anthropic/claude-fable-5-1:high",
 		architect: "anthropic/claude-fable-5-1:xhigh",
@@ -491,7 +498,7 @@ export const BUILTIN_MODEL_PROFILES: readonly ModelProfileDefinition[] = [
 	profile("opus-codex", ["anthropic", "openai-codex"], {
 		default: "anthropic/claude-opus-5-5:medium",
 		executor: "openai-codex/gpt-5.6-terra:low",
-		planner: "anthropic/claude-sonnet-5",
+		planner: "anthropic/claude-sonnet-5-5",
 		critic: "openai-codex/gpt-6-sol:xhigh",
 		architect: "openai-codex/gpt-6-sol:high",
 	}),
@@ -555,6 +562,7 @@ const PROFILE_PRESENTATION: Record<string, ModelProfilePresentation> = {
 	"codex-eco": { displayName: "Codex Eco", providerGroup: "CODEX" },
 	"codex-medium": { displayName: "Codex Medium", providerGroup: "CODEX" },
 	"codex-pro": { displayName: "Codex Pro", providerGroup: "CODEX" },
+	"codex-sol61": { displayName: "Codex Sol 6.1", providerGroup: "CODEX" },
 	lunamaxxing: { displayName: "LunaMaxxing", providerGroup: "CODEX" },
 	"astra-lite": { displayName: "ASTRA-Lite", providerGroup: "CODEX" },
 	"astra-default": { displayName: "ASTRA-Default", providerGroup: "CODEX" },

package/src/config/model-registry.ts

@@ -782,26 +782,53 @@ function registryModelMetadataWithoutApiSpecificFields(model: Model<Api>): Parti
 	return metadata;
 }
 
-export function registrySelectorResolvesToModel(selector: string, models: readonly Model<Api>[]): boolean {
+/**
+ * Lowercased lookup keys for a model catalog, so selector resolution is a set
+ * lookup instead of a scan that re-lowercases every model id per selector.
+ */
+export interface RegistrySelectorIndex {
+	/** `id` and `provider/id`. */
+	exact: ReadonlySet<string>;
+	/** `id` alone. */
+	ids: ReadonlySet<string>;
+	/** Model ids per provider, for parsed `provider/id` selectors (nested, so no delimiter can collide). */
+	providerIds: ReadonlyMap<string, ReadonlySet<string>>;
+	/** Every `/`-delimited suffix of each id (`a/b/c` → `b/c`, `c`). */
+	idSuffixes: ReadonlySet<string>;
+}
+
+export function createRegistrySelectorIndex(models: readonly Model<Api>[]): RegistrySelectorIndex {
+	const exact = new Set<string>();
+	const ids = new Set<string>();
+	const providerIds = new Map<string, Set<string>>();
+	const idSuffixes = new Set<string>();
+	for (const model of models) {
+		const id = model.id.toLowerCase();
+		const provider = model.provider.toLowerCase();
+		ids.add(id);
+		exact.add(id);
+		exact.add(`${provider}/${id}`);
+		let providerModelIds = providerIds.get(provider);
+		if (!providerModelIds) {
+			providerModelIds = new Set<string>();
+			providerIds.set(provider, providerModelIds);
+		}
+		providerModelIds.add(id);
+		for (let slash = id.indexOf("/"); slash !== -1; slash = id.indexOf("/", slash + 1)) {
+			idSuffixes.add(id.slice(slash + 1));
+		}
+	}
+	return { exact, ids, providerIds, idSuffixes };
+}
+
+export function registrySelectorResolvesToModel(selector: string, index: RegistrySelectorIndex): boolean {
 	const normalizedSelector = selector.trim().toLowerCase();
-	if (
-		models.some(
-			model =>
-				model.id.toLowerCase() === normalizedSelector ||
-				`${model.provider}/${model.id}`.toLowerCase() === normalizedSelector,
-		)
-	)
-		return true;
+	if (index.exact.has(normalizedSelector)) return true;
 	const suffix = splitSelectorThinkingSuffix(normalizedSelector);
 	const baseSelector = suffix.thinkingLevel === undefined ? normalizedSelector : suffix.selector;
 	const parsed = parseModelString(baseSelector);
-	if (parsed)
-		return models.some(
-			model => model.provider.toLowerCase() === parsed.provider && model.id.toLowerCase() === parsed.id,
-		);
-	return models.some(
-		model => model.id.toLowerCase() === baseSelector || model.id.toLowerCase().endsWith(`/${baseSelector}`),
-	);
+	if (parsed) return index.providerIds.get(parsed.provider)?.has(parsed.id) ?? false;
+	return index.ids.has(baseSelector) || index.idSuffixes.has(baseSelector);
 }
 
 function filterMaterializedRegistryProfiles(
@@ -810,6 +837,7 @@ function filterMaterializedRegistryProfiles(
 	dynamicProviders: ReadonlySet<string>,
 ): Map<string, ModelProfileDefinition> {
 	const filtered = new Map<string, ModelProfileDefinition>();
+	const index = createRegistrySelectorIndex(models);
 	for (const [name, profile] of profiles) {
 		if (
 			profile.source === "registry" &&
@@ -818,7 +846,7 @@ function filterMaterializedRegistryProfiles(
 				return (
 					selectors.length > 0 &&
 					!selectors.some(selector => {
-						if (registrySelectorResolvesToModel(selector, models)) return true;
+						if (registrySelectorResolvesToModel(selector, index)) return true;
 						const suffix = splitSelectorThinkingSuffix(selector);
 						const parsed = parseModelString(suffix.thinkingLevel ? suffix.selector : selector);
 						return parsed !== undefined && dynamicProviders.has(parsed.provider);

package/src/exa/mcp-client.ts

@@ -187,7 +187,16 @@ export function formatSearchResults(data: ExaSearchResponse): string {
  * Format a non-search MCP response as human-readable text.
  * Handles objects, arrays, primitives, and common MCP response shapes.
  */
-export function formatGenericResponse(data: unknown): string {
+// Nesting depth is bounded. Each object level re-indents the entire formatted
+// subtree, so cost grows super-linearly with depth: 500/1000/2000/4000/8000
+// levels cost 60ms/227ms/730ms/5.9s/94s. A tool-call payload is whatever the
+// remote MCP server returned, and `MCP_MAX_CONTENT_BYTES` does not bound depth
+// — 8000 levels of `{"a":` is under 47 KB. The limit matches the one the
+// session-import walker already applies (`sanitizeImportedValue`, depth > 64).
+const MAX_GENERIC_RESPONSE_DEPTH = 64;
+
+export function formatGenericResponse(data: unknown, depth = 0): string {
+	if (depth > MAX_GENERIC_RESPONSE_DEPTH) return "[depth-limit]";
 	if (data === null || data === undefined) return "No result.";
 	if (typeof data === "string") return data;
 	if (typeof data === "number" || typeof data === "boolean") return String(data);
@@ -199,14 +208,22 @@ export function formatGenericResponse(data: unknown): string {
 			const item = data[i];
 			if (typeof item === "object" && item !== null) {
 				const record = item as Record<string, unknown>;
-				const title = (record.title ?? record.name ?? record.id ?? `Item ${i + 1}`) as string;
+				const rawTitle = record.title ?? record.name ?? record.id;
+				// A remote title is unvalidated JSON: stringify non-strings through the
+				// depth-bounded path instead of template coercion, which recurses unbounded.
+				const title =
+					rawTitle === undefined || rawTitle === null
+						? `Item ${i + 1}`
+						: typeof rawTitle === "string"
+							? rawTitle
+							: formatValue(rawTitle, depth + 2);
 				parts.push(`\n### ${title}`);
 				for (const [k, v] of Object.entries(record)) {
 					if (["title", "name", "id"].includes(k)) continue;
-					parts.push(`- **${k}:** ${formatValue(v)}`);
+					parts.push(`- **${k}:** ${formatValue(v, depth + 2)}`);
 				}
 			} else {
-				parts.push(`- ${formatValue(item)}`);
+				parts.push(`- ${formatValue(item, depth + 1)}`);
 			}
 		}
 		return parts.join("\n");
@@ -231,10 +248,10 @@ export function formatGenericResponse(data: unknown): string {
 			if (k === "content") continue; // handled above
 			if (v === null || v === undefined) continue;
 			if (typeof v === "object") {
-				const formatted = formatGenericResponse(v);
+				const formatted = formatGenericResponse(v, depth + 1);
 				if (formatted) lines.push(`- **${k}:**\n${indent(formatted, 2)}`);
 			} else {
-				lines.push(`- **${k}:** ${formatValue(v)}`);
+				lines.push(`- **${k}:** ${formatValue(v, depth + 1)}`);
 			}
 		}
 		return lines.join("\n") || "(empty)";
@@ -243,12 +260,28 @@ export function formatGenericResponse(data: unknown): string {
 	return String(data);
 }
 
-function formatValue(v: unknown): string {
+function formatValue(v: unknown, depth: number): string {
 	if (v === null || v === undefined) return "—";
-	if (typeof v === "object") return JSON.stringify(v);
+	if (typeof v === "object") return JSON.stringify(truncateDepth(v, depth));
 	return String(v);
 }
 
+/**
+ * Copies a value, replacing anything nested past MAX_GENERIC_RESPONSE_DEPTH with
+ * "[depth-limit]", so JSON.stringify never recurses through a remote payload's
+ * unbounded structure.
+ */
+function truncateDepth(value: unknown, depth: number): unknown {
+	if (value === null || typeof value !== "object") return value;
+	if (depth > MAX_GENERIC_RESPONSE_DEPTH) return "[depth-limit]";
+	if (Array.isArray(value)) return value.map(item => truncateDepth(item, depth + 1));
+	// Null prototype: an own "__proto__" key from a parsed payload must stay an
+	// own data property instead of hitting the Object.prototype setter.
+	const copy: Record<string, unknown> = Object.create(null);
+	for (const [key, child] of Object.entries(value)) copy[key] = truncateDepth(child, depth + 1);
+	return copy;
+}
+
 function indent(text: string, spaces: number): string {
 	const pad = " ".repeat(spaces);
 	return text

package/src/exec/bash-shell-guardian.ts

@@ -1,6 +1,7 @@
 import { dlopen, FFIType, ptr } from "bun:ffi";
 import * as childProcess from "node:child_process";
 import { createHmac, randomUUID, timingSafeEqual } from "node:crypto";
+import * as fsSync from "node:fs";
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
@@ -63,10 +64,10 @@ export function extendOwnedDarwinAncestry<T extends { uniqueId: bigint; parentUn
 	return addedPids;
 }
 
-function authenticateOwnershipRecord(
+export function authenticateOwnershipRecord(
 	line: string,
 	ledgerToken: string,
-): { processRef?: NativeProcess; darwinUniqueId?: bigint } | undefined {
+): { processRef?: NativeProcess; darwinUniqueId?: bigint; pending?: true } | undefined {
 	const record = parseOwnershipRecord(line);
 	if (!record) return undefined;
 	const uniqueId = record.darwinUniqueId ?? "";
@@ -80,15 +81,20 @@ function authenticateOwnershipRecord(
 		return undefined;
 	}
 	if (received.byteLength !== expected.byteLength || !timingSafeEqual(received, expected)) return undefined;
-	if (process.platform === "darwin" && !record.darwinUniqueId) return undefined;
 	const { Process } = require("@gajae-code/natives") as NativeProcessBindings;
 	const owned = Process.fromPid(record.pid);
-	return {
-		...(owned?.incarnation === record.incarnation ? { processRef: owned } : {}),
-		...(record.darwinUniqueId ? { darwinUniqueId: BigInt(record.darwinUniqueId) } : {}),
-	};
+	const darwinUniqueId = record.darwinUniqueId ? { darwinUniqueId: BigInt(record.darwinUniqueId) } : {};
+	if (owned?.incarnation === record.incarnation) return { processRef: owned, ...darwinUniqueId };
+	// fromPid() conflates death with an inconclusive lookup. Only a confirmed
+	// absence or a different incarnation settles the record; an unknown result
+	// keeps it pending so the caller retries the line on the next scan.
+	if (!owned && Process.observe(record.pid).status === "unknown") return { pending: true, ...darwinUniqueId };
+	return darwinUniqueId;
 }
 
+/** Scans an inconclusive ledger record may stay pending before tracking fails closed. */
+const MAX_PENDING_LEDGER_ATTEMPTS = 50;
+
 function enableLinuxChildSubreaper(): boolean {
 	if (process.platform !== "linux") return true;
 	try {
@@ -157,14 +163,27 @@ function findDarwinLedgerHolders(device: number, inode: bigint): NativeProcess[]
 	}
 }
 
-type DarwinAncestryTracker = {
+export type DarwinAncestryTracker = {
 	seed(uniqueId: bigint): void;
 	track(processRef: NativeProcess, uniqueId?: bigint): boolean;
+	trackGuardian(processRef: NativeProcess, uniqueId?: bigint): boolean;
 	poll(): boolean;
 	close(): void;
 };
 
-function createDarwinAncestryTracker(owned: Map<string, NativeProcess>): DarwinAncestryTracker | undefined {
+export type DarwinIdentity = { uniqueId: bigint; parentUniqueId: bigint };
+
+/** Test seams for the Darwin tracker; production uses libproc and the natives binding. */
+export type DarwinAncestryTrackerDeps = {
+	uniqueIdentity?: (pid: number) => DarwinIdentity | undefined;
+	fromPid?: (pid: number) => NativeProcess | null | undefined;
+	observe?: (pid: number) => { status: "present" | "absent" | "unknown"; incarnation?: string };
+};
+
+export function createDarwinAncestryTracker(
+	owned: Map<string, NativeProcess>,
+	deps: DarwinAncestryTrackerDeps = {},
+): DarwinAncestryTracker | undefined {
 	if (process.platform !== "darwin") return undefined;
 	try {
 		const proc = dlopen("/usr/lib/libproc.dylib", {
@@ -180,10 +199,12 @@ function createDarwinAncestryTracker(owned: Map<string, NativeProcess>): DarwinA
 		// own children still chain, but it is retried on every poll until retained.
 		const retainedUniqueIds = new Set<bigint>();
 		const { Process } = require("@gajae-code/natives") as NativeProcessBindings;
+		const fromPid = deps.fromPid ?? ((pid: number) => Process.fromPid(pid));
+		const observe = deps.observe ?? ((pid: number) => Process.observe(pid));
 		// Reuse buffer across poll iterations to avoid allocations inside the loop.
 		const identityBuffer = new Uint8Array(56);
 		const identityView = new DataView(identityBuffer.buffer);
-		const uniqueIdentity = (pid: number): { uniqueId: bigint; parentUniqueId: bigint } | undefined => {
+		const defaultUniqueIdentity = (pid: number): { uniqueId: bigint; parentUniqueId: bigint } | undefined => {
 			const bytes = proc.symbols.proc_pidinfo(pid, 17, 0, ptr(identityBuffer), identityBuffer.byteLength);
 			if (bytes !== identityBuffer.byteLength) return undefined;
 			return {
@@ -191,9 +212,92 @@ function createDarwinAncestryTracker(owned: Map<string, NativeProcess>): DarwinA
 				parentUniqueId: identityView.getBigUint64(24, true),
 			};
 		};
+		const uniqueIdentity = deps.uniqueIdentity ?? defaultUniqueIdentity;
+		const incarnationOnlyAnchors: NativeProcess[] = [];
+		const anchorKeys = new Set<string>();
+		const addIncarnationOnlyAnchor = (processRef: NativeProcess): void => {
+			const key = `${processRef.pid}:${processRef.incarnation}`;
+			if (anchorKeys.has(key)) return;
+			anchorKeys.add(key);
+			incarnationOnlyAnchors.push(processRef);
+		};
+		// children() validates its parent and then snapshots the process table; the
+		// parent can exit and its pid be reused in between, returning a stranger's
+		// children. Only trust a snapshot if the parent still holds its incarnation
+		// after it was taken.
+		const childrenOf = (parent: NativeProcess): NativeProcess[] => {
+			const children = parent.children();
+			return fromPid(parent.pid)?.incarnation === parent.incarnation ? children : [];
+		};
+		const seedAnchorDescendants = (anchor: NativeProcess): void => {
+			const pending = [...childrenOf(anchor)];
+			while (pending.length > 0) {
+				const child = pending.pop()!;
+				retainOwnedProcess(owned, child);
+				// The unique id is read from a bare pid, so bracket it with incarnation
+				// checks against this handle: a pid reused in between would otherwise
+				// seed an unrelated process (and its descendants) as owned.
+				if (fromPid(child.pid)?.incarnation === child.incarnation) {
+					const childId = uniqueIdentity(child.pid)?.uniqueId;
+					if (fromPid(child.pid)?.incarnation === child.incarnation) {
+						if (childId !== undefined) {
+							knownUniqueIds.add(childId);
+							retainedUniqueIds.add(childId);
+						} else {
+							// Its flavor-17 query is denied too: without a unique id the
+							// ancestry walk can never reach its subtree, so it must outlive
+							// this anchor's pruning as an incarnation-only anchor itself.
+							addIncarnationOnlyAnchor(child);
+						}
+					}
+				}
+				pending.push(...childrenOf(child));
+			}
+		};
 		const track = (processRef: NativeProcess, signedUniqueId?: bigint): boolean => {
+			// The bare-pid unique-id query is only trusted if the same incarnation
+			// holds on both sides of it; otherwise a pid reused after the record was
+			// authenticated would seed the replacement's ancestry as owned.
+			let identity: { uniqueId: bigint; parentUniqueId: bigint } | undefined;
+			if (signedUniqueId === undefined) {
+				const queried = uniqueIdentity(processRef.pid);
+				const after = observe(processRef.pid);
+				if (
+					after.status === "absent" ||
+					(after.status === "present" && after.incarnation !== processRef.incarnation)
+				) {
+					// Confirmed exited or reused since authentication: retain nothing new.
+					return true;
+				}
+				// Present with the same incarnation keeps the queried id. An
+				// inconclusive lookup cannot vouch for it, so the record falls through
+				// as incarnation-only and is kept as an anchor rather than dropped.
+				identity = after.status === "present" ? queried : undefined;
+			}
+			const uniqueId = signedUniqueId ?? identity?.uniqueId;
+			if (uniqueId === undefined) {
+				// Incarnation-only record: the child has no unique id to anchor the
+				// ancestry graph. Keep it as an anchor whose live descendants poll()
+				// seeds by unique id, so their subtrees stay tracked after the child
+				// exits and they reparent (PPID discovery alone would lose them).
+				// Residual gap (accepted over #6085's exit 70): if the child forks a
+				// descendant that leaves the supervisor process group, then exits before
+				// this record is scanned, nothing links that descendant back to us. The
+				// ledger watcher scans on append to keep that window minimal.
+				retainOwnedProcess(owned, processRef);
+				addIncarnationOnlyAnchor(processRef);
+				seedAnchorDescendants(processRef);
+				return true;
+			}
+			knownUniqueIds.add(uniqueId);
+			retainedUniqueIds.add(uniqueId);
+			retainOwnedProcess(owned, processRef);
+			return true;
+		};
+		const trackGuardian = (processRef: NativeProcess, signedUniqueId?: bigint): boolean => {
 			const identity = signedUniqueId === undefined ? uniqueIdentity(processRef.pid) : undefined;
 			const uniqueId = signedUniqueId ?? identity?.uniqueId;
+			// Guardian registration is strict: must have a unique id
 			if (uniqueId === undefined) return false;
 			knownUniqueIds.add(uniqueId);
 			retainedUniqueIds.add(uniqueId);
@@ -205,7 +309,19 @@ function createDarwinAncestryTracker(owned: Map<string, NativeProcess>): DarwinA
 				knownUniqueIds.add(uniqueId);
 			},
 			track,
+			trackGuardian,
 			poll() {
+				// Re-seed live anchors, then drop exited ones: their descendants were
+				// seeded by unique id while the anchor was alive, and ancestry now
+				// carries them, so re-walking a dead anchor only costs time.
+				for (let index = incarnationOnlyAnchors.length - 1; index >= 0; index--) {
+					const anchor = incarnationOnlyAnchors[index]!;
+					seedAnchorDescendants(anchor);
+					if (fromPid(anchor.pid)?.incarnation !== anchor.incarnation) {
+						incarnationOnlyAnchors.splice(index, 1);
+						anchorKeys.delete(`${anchor.pid}:${anchor.incarnation}`);
+					}
+				}
 				const capacity = proc.symbols.proc_listallpids(null, 0);
 				if (capacity <= 0) return false;
 				const pids = new Int32Array(capacity + 64);
@@ -225,10 +341,10 @@ function createDarwinAncestryTracker(owned: Map<string, NativeProcess>): DarwinA
 				extendOwnedDarwinAncestry(knownUniqueIds, identities);
 				for (const [pid, listed] of identities) {
 					if (!knownUniqueIds.has(listed.uniqueId) || retainedUniqueIds.has(listed.uniqueId)) continue;
-					const before = Process.fromPid(pid);
+					const before = fromPid(pid);
 					if (!before) continue;
 					const identity = uniqueIdentity(pid);
-					const after = Process.fromPid(pid);
+					const after = fromPid(pid);
 					if (identity?.uniqueId === listed.uniqueId && after?.incarnation === before.incarnation) {
 						retainOwnedProcess(owned, after);
 						retainedUniqueIds.add(listed.uniqueId);
@@ -275,7 +391,7 @@ export async function runBashShellGuardian(): Promise<void> {
 	if (darwinTracker) {
 		const { Process } = require("@gajae-code/natives") as NativeProcessBindings;
 		const guardian = Process.fromPid(process.pid);
-		if (!guardian || !darwinTracker.track(guardian)) {
+		if (!guardian || !darwinTracker.trackGuardian(guardian)) {
 			darwinTracker.close();
 			await ledger.close();
 			await fs.rm(ownershipFilePath, { force: true });
@@ -306,6 +422,8 @@ export async function runBashShellGuardian(): Promise<void> {
 	input.once("close", () => supervisor.stdin.end());
 	let cleaning: Promise<void> | undefined;
 	let ledgerBuffer = "";
+	let pendingLedgerLines: string[] = [];
+	const pendingAttempts = new Map<string, number>();
 	let ownershipScan = Promise.resolve(true);
 	const scanOwnership = (): Promise<boolean> => {
 		ownershipScan = ownershipScan.then(async previousOk => {
@@ -317,11 +435,23 @@ export async function runBashShellGuardian(): Promise<void> {
 				return false;
 			}
 			ledgerBuffer += content;
-			const lines = ledgerBuffer.split("\n");
-			ledgerBuffer = lines.pop() ?? "";
+			const fresh = ledgerBuffer.split("\n");
+			ledgerBuffer = fresh.pop() ?? "";
+			const lines = [...pendingLedgerLines, ...fresh];
+			pendingLedgerLines = [];
 			for (const line of lines) {
 				if (!line) continue;
 				const owned = authenticateOwnershipRecord(line, ledgerToken);
+				if (owned?.pending) {
+					// Inconclusive lookup: retry next scan, bounded so a pid stuck in an
+					// unknown state cannot grow the queue or starve cleanup forever.
+					const attempts = (pendingAttempts.get(line) ?? 0) + 1;
+					if (attempts > MAX_PENDING_LEDGER_ATTEMPTS) return false;
+					pendingAttempts.set(line, attempts);
+					pendingLedgerLines.push(line);
+				} else {
+					pendingAttempts.delete(line);
+				}
 				if (owned?.darwinUniqueId && darwinTracker) darwinTracker.seed(owned.darwinUniqueId);
 				if (owned?.processRef && darwinTracker && !darwinTracker.track(owned.processRef, owned.darwinUniqueId))
 					return false;
@@ -335,28 +465,48 @@ export async function runBashShellGuardian(): Promise<void> {
 		return ownershipScan;
 	};
 	let periodicScanActive = false;
-	const ownershipScanTimer = darwinTracker
-		? setInterval(() => {
-				if (periodicScanActive) return;
-				periodicScanActive = true;
-				void scanOwnership()
-					.then(ok => {
-						if (ok || supervisor.exitCode !== null || supervisor.signalCode !== null) return;
-						if (supervisor.pid) {
-							try {
-								process.kill(-supervisor.pid, "SIGKILL");
-							} catch {}
-						}
-						supervisor.kill("SIGKILL");
-					})
-					.finally(() => {
-						periodicScanActive = false;
-					});
-			}, 100)
-		: undefined;
+	let periodicScanRequested = false;
+	const runPeriodicScan = (): void => {
+		if (periodicScanActive) {
+			periodicScanRequested = true;
+			return;
+		}
+		periodicScanActive = true;
+		void scanOwnership()
+			.then(ok => {
+				if (ok || supervisor.exitCode !== null || supervisor.signalCode !== null) return;
+				if (supervisor.pid) {
+					try {
+						process.kill(-supervisor.pid, "SIGKILL");
+					} catch {}
+				}
+				supervisor.kill("SIGKILL");
+			})
+			.finally(() => {
+				periodicScanActive = false;
+				if (periodicScanRequested && !cleaning) {
+					periodicScanRequested = false;
+					runPeriodicScan();
+				}
+			});
+	};
+	const ownershipScanTimer = darwinTracker ? setInterval(runPeriodicScan, 100) : undefined;
+	// Scan as soon as the supervisor appends a ledger record instead of waiting
+	// for the next tick. An incarnation-only record's descendants are only
+	// reachable while that child is alive, so the anchor must be taken promptly.
+	let ledgerWatcher: fsSync.FSWatcher | undefined;
+	if (darwinTracker) {
+		try {
+			ledgerWatcher = fsSync.watch(ownershipFilePath, runPeriodicScan);
+			ledgerWatcher.on("error", () => {});
+		} catch {
+			ledgerWatcher = undefined;
+		}
+	}
 	const cleanup = (): Promise<void> => {
 		cleaning ??= (async () => {
 			if (ownershipScanTimer) clearInterval(ownershipScanTimer);
+			ledgerWatcher?.close();
 			let trackingOk = await scanOwnership();
 			if (supervisor.exitCode === null && supervisor.signalCode === null) {
 				if (process.platform !== "win32" && supervisor.pid) {