@gajae-code/coding-agent 0.16.3 → 0.16.6

package/src/cli/customize-doctor.ts

@@ -38,6 +38,8 @@ import { initializeWithSettings, loadCapability } from "../discovery";
 import { inspectClaudeConvention } from "../discovery/claude";
 import { inspectCodexConvention } from "../discovery/codex";
 import { scanSkillsFromDir } from "../discovery/helpers";
+import { functionHookGrantHash, normalizeFunctionHookGrant } from "../extensibility/extensions/function-hooks";
+import { compileGjcPluginBundle } from "../extensibility/gjc-plugins/compiler";
 import { summarizeGjcPluginObservability } from "../extensibility/gjc-plugins/observability";
 import { loadEffectiveGjcPluginRegistry } from "../extensibility/gjc-plugins/registry";
 import { getEnabledPlugins } from "../extensibility/plugins/loader";
@@ -47,7 +49,10 @@ import { loadAllMCPConfigs } from "../runtime-mcp/config";
 import { readDisabledServers } from "../runtime-mcp/config-writer";
 import { canonicalizeMCPEndpoint } from "../runtime-mcp/pool-key";
 import { redactMCPEndpoint } from "../runtime-mcp/redaction";
-import { CANONICAL_GJC_WORKFLOW_SKILLS } from "../skill-state/canonical-skills";
+import {
+	getSkillFilesystemIdentity,
+	isCanonicalGjcWorkflowSkillFilesystemAlias,
+} from "../skill-state/canonical-skills";
 import { expandTilde } from "../tools/path-utils";
 
 // =============================================================================
@@ -153,6 +158,29 @@ export interface CustomizeDoctorItem {
 	mcp?: McpSafeSummary;
 	/** Present only for quarantined plugin-bundle surfaces. */
 	quarantineCode?: string;
+	/** Metadata-only Function Hook policy projection; hook code is never executed. */
+	functionHooks?: CustomizeFunctionHookSummary[];
+}
+
+export interface CustomizeFunctionHookSummary {
+	extensionId: string;
+	order: number;
+	event: string;
+	target?: string;
+	phase?: "before" | "after";
+	scope: "user" | "project";
+	plugin: string;
+	relativePath: string;
+	status: "disabled" | "quarantined" | "blocked-isolate" | "legacy-active";
+	requestedCapabilities: string[];
+	effectiveCapabilities: string[];
+	attenuateDownstream: string[];
+	networkDestinations: string[];
+	filesystemRoots: string[];
+	capabilityHash?: string;
+	implementationHash?: string;
+	quarantineCode?: string;
+	remediation: string;
 }
 
 export interface CustomizeDoctorSurface {
@@ -200,8 +228,6 @@ export interface CustomizeDoctorCommandOptions {
 
 const REDACTED = "<redacted>";
 
-const BUILT_IN_SKILL_NAMES = new Set<string>(CANONICAL_GJC_WORKFLOW_SKILLS);
-
 const SENSITIVE_KEY_PATTERN =
 	/(?:token|secret|key|credential|password|passwd|pwd|authorization|auth|bearer|cookie|session|apikey)/i;
 
@@ -655,7 +681,7 @@ async function collectSkills(cwd: string, activeSettings: SettingsInstance): Pro
 			cwd,
 			disabledExtensions: activeSettings.get("disabledExtensions"),
 		});
-		for (const skill of result.skills) loadedNames.add(skill.name);
+		for (const skill of result.skills) loadedNames.add(getSkillFilesystemIdentity(skill.name));
 	}
 
 	const skillScopeNotes: string[] = [];
@@ -730,7 +756,7 @@ async function collectSkills(cwd: string, activeSettings: SettingsInstance): Pro
 				[`Move the skill under .gjc/skills/<name>/SKILL.md to make it loadable`],
 			);
 		}
-		if (BUILT_IN_SKILL_NAMES.has(entry.name)) {
+		if (isCanonicalGjcWorkflowSkillFilesystemAlias(entry.name)) {
 			return finalizeItem(
 				base,
 				"shadowed",
@@ -740,7 +766,7 @@ async function collectSkills(cwd: string, activeSettings: SettingsInstance): Pro
 				{ precedence: { priority: entry.priority, shadowedBy: { provider: "bundled", scope: "native" } } },
 			);
 		}
-		if (loadedNames.has(entry.name)) {
+		if (loadedNames.has(getSkillFilesystemIdentity(entry.name))) {
 			return finalizeItem(base, "loaded", "loaded", "Loaded by session startup.", []);
 		}
 		if (ignoredPatterns.length > 0 || includePatterns.length > 0) {
@@ -809,7 +835,7 @@ async function collectSkills(cwd: string, activeSettings: SettingsInstance): Pro
 				);
 				continue;
 			}
-			if (BUILT_IN_SKILL_NAMES.has(skill.name)) {
+			if (isCanonicalGjcWorkflowSkillFilesystemAlias(skill.name)) {
 				items.push(
 					finalizeItem(
 						base,
@@ -828,7 +854,10 @@ async function collectSkills(cwd: string, activeSettings: SettingsInstance): Pro
 			// in loadedNames even though it loses the name collision to an
 			// earlier-priority source. The collision must report shadowed-by-
 			// precedence, not a second "loaded" item.
-			const collisionWinner = items.find(i => i.name === skill.name && i.status === "loaded");
+			const skillIdentity = getSkillFilesystemIdentity(skill.name);
+			const collisionWinner = items.find(
+				i => getSkillFilesystemIdentity(i.name) === skillIdentity && i.status === "loaded",
+			);
 			if (collisionWinner) {
 				items.push(
 					finalizeItem(
@@ -847,7 +876,7 @@ async function collectSkills(cwd: string, activeSettings: SettingsInstance): Pro
 				);
 				continue;
 			}
-			if (loadedNames.has(skill.name)) {
+			if (loadedNames.has(skillIdentity)) {
 				items.push(
 					finalizeItem(base, "loaded", "loaded", "Loaded by session startup from skills.customDirectories.", []),
 				);
@@ -910,8 +939,11 @@ async function collectHooks(cwd: string, activeSettings: SettingsInstance): Prom
 		nameOf: hook => hook.name,
 		pathOf: hook => hook.path,
 		notExecutedDetail:
-			"Discovered and shown in the extension dashboard, but standalone sessions do not execute hook files. Runtime hooks come from validated GJC plugin bundles.",
-		notExecutedRemediation: ["See `gjc plugin list` for plugin bundles that contribute runtime hooks"],
+			"Trusted filesystem hook module discovered for session-start activation. Doctor does not execute the module, so dynamic Function Hook registrations and effective runtime order remain opaque until a session loads it.",
+		notExecutedRemediation: [
+			"Review the trusted hook source before session startup",
+			"Use plugin-bundle Function Hooks for declarative grants, hashes, quarantine, and metadata-only policy inspection",
+		],
 	});
 }
 
@@ -1140,7 +1172,101 @@ async function collectPluginBundles(cwd: string): Promise<CustomizeDoctorSurface
 	const bundleEntries = await loadEffectiveGjcPluginRegistry(cwd, { migrate: false });
 	const observability = await summarizeGjcPluginObservability(cwd, { migrate: false });
 	const items: CustomizeDoctorItem[] = [...npmItems];
+	let globalFunctionHookOrder = 0;
 	for (const entry of bundleEntries) {
+		const surfaces = observability.surfaces.filter(s => s.plugin === entry.name && s.scope === entry.scope);
+		let compiledHooks = new Map<
+			string,
+			Awaited<ReturnType<typeof compileGjcPluginBundle>>["surfaces"]["hooks"][number]
+		>();
+		try {
+			const compiled = await compileGjcPluginBundle(entry.pluginRoot);
+			compiledHooks = new Map(compiled.surfaces.hooks.map(hook => [hook.extensionId, hook]));
+		} catch {
+			// Existing observability reports unreadable/hash-drift bundles. Keep
+			// declarative rows visible and mark unmatched metadata quarantined.
+		}
+		const functionHooks: CustomizeFunctionHookSummary[] = entry.surfaces.hooks.map(hook => {
+			const observed = surfaces.find(surface => surface.extensionId === hook.extensionId);
+			const compiled = compiledHooks.get(hook.extensionId);
+			const hasGrantMetadata =
+				hook.capabilities !== undefined ||
+				hook.networkDestinations !== undefined ||
+				hook.filesystemRoots !== undefined ||
+				hook.capabilityHash !== undefined;
+			let metadataValid =
+				compiled !== undefined &&
+				((hook.functionHook === true && hasGrantMetadata) ||
+					(hook.functionHook !== true && !hasGrantMetadata && compiled.functionHook !== true));
+			try {
+				const grant = normalizeFunctionHookGrant({
+					capabilities: hook.capabilities,
+					networkDestinations: hook.networkDestinations,
+					filesystemRoots: hook.filesystemRoots,
+				});
+				metadataValid =
+					metadataValid &&
+					hook.functionHook === compiled?.functionHook &&
+					hook.event === compiled?.event &&
+					hook.target === compiled?.target &&
+					hook.phase === compiled?.phase &&
+					hook.relativePath === compiled?.relativePath &&
+					hook.implementationHash === compiled?.implementationHash &&
+					(hook.functionHook !== true ||
+						(hook.capabilityHash?.toLowerCase() === functionHookGrantHash(grant).toLowerCase() &&
+							hook.capabilityHash?.toLowerCase() === compiled?.capabilityHash?.toLowerCase() &&
+							JSON.stringify(grant.capabilities) === JSON.stringify(compiled?.capabilities ?? []) &&
+							JSON.stringify(grant.networkDestinations) ===
+								JSON.stringify(compiled?.networkDestinations ?? []) &&
+							JSON.stringify(grant.filesystemRoots) === JSON.stringify(compiled?.filesystemRoots ?? [])));
+			} catch {
+				metadataValid = false;
+			}
+			const status: CustomizeFunctionHookSummary["status"] =
+				!metadataValid || observed?.status === "quarantined"
+					? "quarantined"
+					: !entry.enabled || entry.disabledSurfaceIds.includes(hook.extensionId)
+						? "disabled"
+						: hook.functionHook === true
+							? "blocked-isolate"
+							: "legacy-active";
+			return {
+				extensionId: hook.extensionId,
+				order: globalFunctionHookOrder++,
+				event: hook.event,
+				...(hook.target === undefined ? {} : { target: hook.target }),
+				...(hook.phase === undefined ? {} : { phase: hook.phase }),
+				scope: entry.scope,
+				plugin: entry.name,
+				relativePath: hook.relativePath,
+				status,
+				requestedCapabilities: [...(hook.capabilities ?? [])],
+				effectiveCapabilities: status === "legacy-active" ? [...(hook.capabilities ?? [])] : [],
+				attenuateDownstream: [],
+				networkDestinations: (hook.networkDestinations ?? []).map(destination => {
+					try {
+						const url = new URL(destination);
+						return url.protocol === "https:" && !url.username && !url.password ? url.origin : "[redacted]";
+					} catch {
+						return "[redacted]";
+					}
+				}),
+				filesystemRoots: [...(hook.filesystemRoots ?? [])],
+				...(hook.capabilityHash === undefined ? {} : { capabilityHash: hook.capabilityHash }),
+				...(hook.implementationHash === undefined ? {} : { implementationHash: hook.implementationHash }),
+				...(observed?.quarantineCode === undefined && metadataValid
+					? {}
+					: { quarantineCode: observed?.quarantineCode ?? "security_policy" }),
+				remediation:
+					status === "blocked-isolate"
+						? "Function Hook remains disabled until a capability-enforcing plugin isolate is available."
+						: status === "quarantined"
+							? "Reinstall the bundle and verify installed metadata and file hashes."
+							: status === "disabled"
+								? `Enable surface ${hook.extensionId} only after reviewing its declared policy.`
+								: "Legacy constrained hook executes under the existing trusted compatibility policy.",
+			};
+		});
 		const base: Omit<CustomizeDoctorItem, "status" | "reason" | "detail" | "remediation"> = {
 			name: entry.name,
 			kind: "plugin-bundle",
@@ -1153,6 +1279,7 @@ async function collectPluginBundles(cwd: string): Promise<CustomizeDoctorSurface
 			trust: TRUST_BY_KIND["plugin-bundle"],
 			restartRequired: true,
 			precedence: { priority: 0 },
+			functionHooks,
 		};
 		if (!entry.enabled) {
 			items.push(
@@ -1166,7 +1293,6 @@ async function collectPluginBundles(cwd: string): Promise<CustomizeDoctorSurface
 			);
 			continue;
 		}
-		const surfaces = observability.surfaces.filter(s => s.plugin === entry.name && s.scope === entry.scope);
 		const quarantined = surfaces.filter(s => s.status === "quarantined");
 		if (quarantined.length > 0) {
 			const codes = Array.from(new Set(quarantined.map(s => s.quarantineCode ?? "unknown"))).join(", ");
@@ -1574,6 +1700,23 @@ export function renderCustomizeDoctorText(report: CustomizeDoctorReport): string
 			lines.push(`    reason: ${item.reason} — ${item.detail}`);
 			lines.push(`    source: ${item.path}`);
 			if (item.quarantineCode) lines.push(`    quarantine code: ${item.quarantineCode}`);
+			for (const hook of item.functionHooks ?? []) {
+				lines.push(
+					`    function hook[${hook.order}]: ${hook.extensionId} event=${hook.event}${hook.target ? ` target=${hook.target}` : ""} status=${hook.status}`,
+				);
+				lines.push(`      provenance: scope=${hook.scope} plugin=${hook.plugin} path=${hook.relativePath}`);
+				lines.push(
+					`      grants: requested=${hook.requestedCapabilities.join(",") || "none"} effective=${hook.effectiveCapabilities.join(",") || "none"} attenuate=${hook.attenuateDownstream.join(",") || "none"}`,
+				);
+				if (hook.networkDestinations.length > 0)
+					lines.push(`      network destinations: ${hook.networkDestinations.join(",")}`);
+				if (hook.filesystemRoots.length > 0)
+					lines.push(`      filesystem roots: ${hook.filesystemRoots.join(",")}`);
+				if (hook.capabilityHash) lines.push(`      capability hash: ${hook.capabilityHash}`);
+				if (hook.implementationHash) lines.push(`      implementation hash: ${hook.implementationHash}`);
+				if (hook.quarantineCode) lines.push(`      quarantine code: ${hook.quarantineCode}`);
+				lines.push(`      remediation: ${hook.remediation}`);
+			}
 			for (const fix of item.remediation) lines.push(`    fix: ${fix}`);
 			lines.push(`    trust: ${item.trust}`);
 			lines.push(`    restart required: ${item.restartRequired ? "yes (new session)" : "no"}`);

package/src/cli/root-flags.ts

@@ -1,6 +1,8 @@
+import { THINKING_EFFORTS } from "@gajae-code/ai/core";
 import { type FlagDescriptor, Flags } from "@gajae-code/utils/cli";
 
-const ROOT_THINKING_EFFORTS = ["minimal", "low", "medium", "high", "xhigh", "max"] as const;
+export const ROOT_THINKING_LEVELS = ["off", ...THINKING_EFFORTS] as const;
+export type RootThinkingLevel = (typeof ROOT_THINKING_LEVELS)[number];
 
 /** Public launch flags shared by root help, completion, and the launch command. */
 export const ROOT_LAUNCH_FLAGS = {
@@ -63,8 +65,8 @@ export const ROOT_LAUNCH_FLAGS = {
 	tmux: Flags.boolean({ description: "Launch interactive startup inside tmux" }),
 	tools: Flags.string({ description: "Comma-separated list of tools to enable (default: all)" }),
 	thinking: Flags.string({
-		description: `Set thinking level: ${ROOT_THINKING_EFFORTS.join(", ")}`,
-		options: ROOT_THINKING_EFFORTS,
+		description: `Set thinking level: ${ROOT_THINKING_LEVELS.join(", ")}`,
+		options: ROOT_THINKING_LEVELS,
 	}),
 	"no-rules": Flags.boolean({ description: "Disable rules discovery and loading" }),
 	export: Flags.string({ description: "Export session file to HTML and exit" }),

package/src/cli.ts

@@ -10,6 +10,15 @@ import { APP_NAME, formatBunRuntimeError, MIN_BUN_VERSION, VERSION } from "@gaja
 import { runFixtureReport } from "./cli/fixture-report";
 import { ROOT_LAUNCH_FLAGS } from "./cli/root-flags";
 import QuickLane from "./commands/quick-lane";
+import { runBashShellGuardian } from "./exec/bash-shell-guardian";
+import { runBashShellSupervisor } from "./exec/bash-shell-supervisor";
+import { runBashShellWorker } from "./exec/bash-shell-worker";
+import {
+	BASH_SHELL_RUNTIME_ARG,
+	BASH_SHELL_SUPERVISOR_ARG,
+	BASH_SHELL_WORKER_ARG,
+} from "./exec/bash-shell-worker-protocol";
+import { smokeTestIsolatedShell } from "./exec/isolated-shell";
 import { smokeTestTabWorker } from "./tools/browser/tab-worker-smoke";
 
 if (Bun.semver.order(Bun.version, MIN_BUN_VERSION) < 0) {
@@ -340,6 +349,7 @@ async function runSmokeTest(): Promise<void> {
 	const { runNativeSmokeTest } = await import("./cli/native-smoke");
 	await runNativeSmokeTest();
 	await smokeTestTabWorker();
+	await smokeTestIsolatedShell();
 	process.stdout.write("smoke-test: ok\n");
 }
 
@@ -392,6 +402,18 @@ export function routeRootArgv(argv: readonly string[]): string[] {
 
 /** Run the CLI with the given argv (no `process.argv` prefix). */
 export async function runCli(argv: string[]): Promise<void> {
+	if (argv.length === 1 && argv[0] === BASH_SHELL_WORKER_ARG) {
+		await runBashShellGuardian();
+		return;
+	}
+	if (argv.length === 1 && argv[0] === BASH_SHELL_SUPERVISOR_ARG) {
+		await runBashShellSupervisor();
+		return;
+	}
+	if (argv.length === 1 && argv[0] === BASH_SHELL_RUNTIME_ARG) {
+		await runBashShellWorker();
+		return;
+	}
 	// macOS malloc-env launch boundary. Re-exec once with a scrubbed environment
 	// BEFORE any fast path or subprocess spawn, so the startup env snapshot Bun hands
 	// to every child lane (Bun.spawn defaults, node:child_process, native PTY, tmux

package/src/commands/sdk.ts

@@ -13,6 +13,7 @@ import { initTheme } from "../modes/theme/theme";
 import { ACP_MCP_REQUEST_TIMEOUT_MS, ACP_MCP_STARTUP_HEADROOM_MS } from "../sdk/acp/mcp";
 import { Broker } from "../sdk/broker/broker";
 import { readBrokerDiscovery } from "../sdk/broker/discovery";
+import { reconcileBrokerGenerationForStartup, withBrokerStartupLock } from "../sdk/broker/ensure";
 import { completeBrokerProcess } from "../sdk/broker/internal";
 import {
 	type LifecycleTranscriptEvidence,
@@ -1086,59 +1087,101 @@ export default class Sdk extends Command {
 			await runSessionHost();
 			return;
 		}
-		const agentDir = internal.agentDir;
-		const broker = new Broker({
-			agentDir,
-			masterOrphanGraceMs: (await Settings.loadForScope({ cwd: process.cwd(), agentDir })).get(
-				"sdk.masterOrphanGraceMs",
-			),
-			resolveDirectoryMigration: async cwd => {
-				const settings = await Settings.loadForScope({ cwd, agentDir });
+		const agentDir = path.resolve(internal.agentDir);
+		let broker: Broker | undefined;
+		try {
+			broker = await withBrokerStartupLock(agentDir, async deadline => {
+				const remainingMs = Math.max(1, deadline - Date.now());
+				const testWatchdogMs = Number(process.env.GJC_SDK_TEST_BROKER_STARTUP_WATCHDOG_MS ?? 0);
+				const watchdogMs =
+					Number.isSafeInteger(testWatchdogMs) && testWatchdogMs > 0 && testWatchdogMs <= remainingMs
+						? testWatchdogMs
+						: remainingMs;
+				const startupWatchdog = setTimeout(() => {
+					process.stderr.write(`SDK broker startup exceeded its ${watchdogMs}ms fence deadline.\n`);
+					process.exit(1);
+				}, watchdogMs);
 				try {
-					const policy = settings.get("session.directoryMigration");
-					return policy === "disabled" ? "disabled" : "copy-retain";
+					if (await reconcileBrokerGenerationForStartup({ agentDir }, deadline)) return undefined;
+					if (process.env.GJC_SDK_TEST_BROKER_STARTUP_STALL === "1") {
+						const stalled = Promise.withResolvers<void>();
+						await stalled.promise;
+					}
+					const startupDelayMs = Number(process.env.GJC_SDK_TEST_BROKER_STARTUP_DELAY_MS ?? 0);
+					if (Number.isSafeInteger(startupDelayMs) && startupDelayMs > 0 && startupDelayMs <= 10_000)
+						await Bun.sleep(startupDelayMs);
+					const candidate = new Broker({
+						agentDir,
+						masterOrphanGraceMs: (await Settings.loadForScope({ cwd: process.cwd(), agentDir })).get(
+							"sdk.masterOrphanGraceMs",
+						),
+						resolveDirectoryMigration: async cwd => {
+							const settings = await Settings.loadForScope({ cwd, agentDir });
+							try {
+								const policy = settings.get("session.directoryMigration");
+								return policy === "disabled" ? "disabled" : "copy-retain";
+							} finally {
+								await settings.close();
+							}
+						},
+					});
+					broker = candidate;
+					await candidate.start();
+					return candidate;
 				} finally {
-					await settings.close();
+					clearTimeout(startupWatchdog);
 				}
-			},
-		});
-		try {
-			await broker.start();
+			});
 		} catch (error) {
+			if (broker) {
+				try {
+					await broker.stop();
+				} catch {
+					// Preserve the startup/fence failure that made this bootstrap unusable.
+				}
+			}
 			// This process spawns detached with stdio ignored (see ensure.ts), so the
 			// durable marker is the only channel the caller has to see why start()
 			// failed instead of a bare exit code (#3963).
-			await writeBrokerStartupFailureMarker(agentDir, {
-				reason: error instanceof Error ? error.message : String(error),
-				exitCode: 1,
-				signal: null,
-				pid: process.pid,
-			});
+			const incarnation = processIncarnation(process.pid);
+			if (incarnation)
+				await writeBrokerStartupFailureMarker(agentDir, {
+					reason: error instanceof Error ? error.message : String(error),
+					exitCode: 1,
+					signal: null,
+					pid: process.pid,
+					incarnation,
+				});
 			throw error;
 		}
-		if (!broker.ownsDiscovery) {
+		if (!broker) return;
+		const runningBroker = broker;
+		if (!runningBroker.ownsDiscovery) {
 			// Another broker owns discovery; this process exits cleanly (code 0) as
 			// the race loser. Record why so a caller polling for a winner that never
 			// appears can diagnose the loss instead of seeing only a bare exit 0.
-			await writeBrokerStartupFailureMarker(agentDir, {
-				reason: "Another broker owns the lock/discovery; this broker exited as the race loser.",
-				exitCode: 0,
-				signal: null,
-				pid: process.pid,
-			});
+			const incarnation = processIncarnation(process.pid);
+			if (incarnation)
+				await writeBrokerStartupFailureMarker(agentDir, {
+					reason: "Another broker owns the lock/discovery; this broker exited as the race loser.",
+					exitCode: 0,
+					signal: null,
+					pid: process.pid,
+					incarnation,
+				});
 			return;
 		}
 		// A live broker must not keep advertising sessions whose host process is
 		// gone; the sweep is the broker-side half of the host reaping bound.
-		const stopSweep = startBrokerDeadRegistrationSweep(broker);
+		const stopSweep = startBrokerDeadRegistrationSweep(runningBroker);
 		const stop = () => {
 			stopSweep();
-			void broker.stop();
+			void runningBroker.stop();
 		};
 		process.once("SIGTERM", stop);
 		process.once("SIGINT", stop);
 		try {
-			await completeBrokerProcess(broker);
+			await completeBrokerProcess(runningBroker);
 		} finally {
 			stopSweep();
 		}

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

@@ -359,6 +359,7 @@ export const TIER_MAP_SKIP_LIST = {
 	"nvidia/poolside/laguna-xs-2.1": { rationale: "post-rebase catalog addition from dev; not yet curated" },
 	"nvidia/thinkingmachines/inkling": { rationale: "post-rebase catalog addition from dev; not yet curated" },
 	"nvidia/upstage/solar-10.7b-instruct": { rationale: "post-rebase catalog addition from dev; not yet curated" },
+	"openai-codex/gpt-6-astra": { rationale: "GPT-6 Astra catalog addition (2026-09-03 release); not yet curated" },
 	"openai-codex/gpt-daybreak-blue-latest": { rationale: "post-rebase catalog addition from dev; not yet curated" },
 	"opencode-go/deepseek-v4-flash-vision-exp": {
 		rationale: "post-rebase catalog addition from dev; not yet curated",

package/src/config/file-lock-gc.ts

@@ -17,7 +17,12 @@ import type {
 } from "../gjc-runtime/gc-runtime";
 import { gcPidStatusLabel } from "../gjc-runtime/gc-runtime";
 import { resolveReceiptSpoolDir } from "../harness-control-plane/receipt-spool";
-import { readFileLockObservationForGc, removeFileLockDirForGc } from "./file-lock";
+import {
+	fileLockStagingOwnerPid,
+	inspectFileLockStagingDir,
+	readFileLockObservationForGc,
+	removeFileLockDirForGc,
+} from "./file-lock";
 
 const MAX_WALK_DEPTH = 6;
 /** Default per-root walk budget. Truncation is a warning, not a hard error. */
@@ -67,7 +72,27 @@ function keptMalformedRecord(lockDir: string): GcRecord {
 	};
 }
 
+function stagingOwnerStatus(ctx: GcContext, pid: number): "alive" | "dead" | "unknown" {
+	const status = gcPidStatusLabel(ctx.probe(pid));
+	return status === "eperm" ? "unknown" : status;
+}
+
 async function collectLockRecord(lockDir: string, ctx: GcContext): Promise<GcRecord> {
+	if (fileLockStagingOwnerPid(path.basename(lockDir)) !== null) {
+		const staging = await inspectFileLockStagingDir(lockDir, pid => stagingOwnerStatus(ctx, pid));
+		return {
+			store: "file_locks",
+			id: lockDir,
+			path: lockDir,
+			pid: staging.pid,
+			pid_status: staging.status,
+			status: "file_lock_staging_orphan",
+			stale: staging.status === "dead",
+			removable: staging.status === "dead",
+			action: "none",
+			reason: staging.reason,
+		};
+	}
 	const observation = await readFileLockObservationForGc(lockDir);
 	const info = observation?.info;
 	if (!info) return keptMalformedRecord(lockDir);
@@ -131,7 +156,7 @@ async function walkForLockDirs(
 	state.entries++;
 	if (!stat.isDirectory() || stat.isSymbolicLink()) return;
 
-	if (path.basename(dir).endsWith(".lock")) {
+	if (path.basename(dir).endsWith(".lock") || fileLockStagingOwnerPid(path.basename(dir)) !== null) {
 		lockDirs.add(dir);
 		return;
 	}
@@ -152,6 +177,11 @@ async function walkForLockDirs(
 			state.truncated = true;
 			return;
 		}
+		// Session index locks live directly in sessions/, but session payload trees remain pruned.
+		if (entry === "sessions") {
+			await walkForLockDirs(path.join(dir, entry), MAX_WALK_DEPTH - 1, state, lockDirs, errors, maxWalkEntries);
+			continue;
+		}
 		if (PRUNED_DIR_NAMES.has(entry)) continue;
 		await walkForLockDirs(path.join(dir, entry), depth + 1, state, lockDirs, errors, maxWalkEntries);
 	}
@@ -204,6 +234,14 @@ export const fileLocksGcAdapter: GcStoreAdapter = {
 	},
 	async prune(record: GcRecord, ctx: GcContext): Promise<GcPruneOutcome> {
 		const lockDir = record.path ?? record.id;
+		if (fileLockStagingOwnerPid(path.basename(lockDir)) !== null) {
+			try {
+				const staging = await inspectFileLockStagingDir(lockDir, pid => stagingOwnerStatus(ctx, pid), true);
+				return staging.removed ? { removed: true } : { removed: false, skipped: staging.reason };
+			} catch (error) {
+				return { removed: false, error: errorMessage(error) };
+			}
+		}
 		const observation = await readFileLockObservationForGc(lockDir);
 		const info = observation?.info;
 		if (!info) return { removed: false, skipped: "lock_no_longer_dead_or_missing" };