@gajae-code/coding-agent 0.15.4 → 0.15.6

package/src/cli/model-presets-cli.ts

@@ -0,0 +1,100 @@
+import { getAgentDir } from "@gajae-code/utils";
+import {
+	getModelPresetRegistryStatus,
+	type ModelPresetRegistryStatus,
+	refreshModelPresetRegistry,
+	rollbackModelPresetRegistry,
+	setModelPresetRegistryDisabled,
+	setModelPresetRegistryPin,
+} from "../config/model-preset-registry";
+
+export const MODEL_PRESETS_ACTIONS = ["status", "refresh", "rollback", "pin", "unpin", "disable", "enable"] as const;
+export type ModelPresetsAction = (typeof MODEL_PRESETS_ACTIONS)[number];
+
+export interface ModelPresetsCommandArgs {
+	action: ModelPresetsAction;
+	revision?: string;
+	json?: boolean;
+	agentDir?: string;
+}
+
+function parseRevision(value: string | undefined, action: "rollback" | "pin"): number {
+	if (!value || !/^\d+$/.test(value)) throw new Error(`${action} requires a positive accepted revision.`);
+	const revision = Number(value);
+	if (!Number.isSafeInteger(revision) || revision <= 0)
+		throw new Error(`${action} requires a positive accepted revision.`);
+	return revision;
+}
+
+function humanStatus(status: ModelPresetRegistryStatus): string {
+	const lines = [
+		`source: ${status.source}`,
+		`cache: ${status.cacheHealth}`,
+		`contract: ${status.contractVersion}`,
+		`active revision: ${status.activeRevisionId ?? status.activeRevision ?? "none"}`,
+		`highest seen revision: ${status.highestSeenRevision ?? "none"}`,
+		`pinned revision: ${status.pinnedRevision ?? "none"}`,
+		`disabled: ${status.disabled ? "yes" : "no"}`,
+		`profiles: ${status.profileCount}`,
+		`model presets: ${status.presetCount}`,
+		`history: ${status.historyRevisions.length > 0 ? status.historyRevisions.join(", ") : "none"}`,
+	];
+	if (status.manifestSha256) lines.push(`manifest sha256: ${status.manifestSha256}`);
+	if (status.snapshotSha256) lines.push(`snapshot sha256: ${status.snapshotSha256}`);
+	if (status.profilesSha256) lines.push(`profiles sha256: ${status.profilesSha256}`);
+	if (status.presetsSha256) lines.push(`presets sha256: ${status.presetsSha256}`);
+	if (status.keyId) lines.push(`signature key: ${status.keyId}`);
+	if (status.sourceRevision) lines.push(`source revision: ${status.sourceRevision}`);
+	if (status.acceptedAt) lines.push(`accepted: ${status.acceptedAt}`);
+	if (status.lastCheckedAt) lines.push(`last checked: ${status.lastCheckedAt}`);
+	if (status.retainedProfiles.length > 0)
+		lines.push(`retained removed profiles: ${status.retainedProfiles.join(", ")}`);
+	if (status.retainedPresets.length > 0) lines.push(`retained removed presets: ${status.retainedPresets.join(", ")}`);
+	if (status.lastError) lines.push(`last error: ${status.lastError}`);
+	return `${lines.join("\n")}\n`;
+}
+
+function writeStatus(status: ModelPresetRegistryStatus, json: boolean): void {
+	process.stdout.write(json ? `${JSON.stringify(status)}\n` : humanStatus(status));
+}
+
+export async function runModelPresetsCommand(args: ModelPresetsCommandArgs): Promise<void> {
+	const agentDir = args.agentDir ?? getAgentDir();
+	const dependencies = { agentDir };
+	switch (args.action) {
+		case "status":
+			writeStatus(getModelPresetRegistryStatus(dependencies), args.json === true);
+			return;
+		case "refresh": {
+			const result = await refreshModelPresetRegistry(dependencies);
+			if (args.json) {
+				process.stdout.write(`${JSON.stringify({ result, status: getModelPresetRegistryStatus(dependencies) })}\n`);
+			} else {
+				process.stdout.write(
+					result.status === "updated"
+						? `Accepted preset registry revision ${result.revision}.\n`
+						: result.status === "not_modified"
+							? "Preset registry is already current.\n"
+							: "Preset registry refresh is disabled.\n",
+				);
+			}
+			return;
+		}
+		case "rollback":
+			await rollbackModelPresetRegistry({ ...dependencies, revision: parseRevision(args.revision, "rollback") });
+			break;
+		case "pin":
+			await setModelPresetRegistryPin({ ...dependencies, revision: parseRevision(args.revision, "pin") });
+			break;
+		case "unpin":
+			await setModelPresetRegistryPin(dependencies);
+			break;
+		case "disable":
+			await setModelPresetRegistryDisabled({ ...dependencies, disabled: true });
+			break;
+		case "enable":
+			await setModelPresetRegistryDisabled({ ...dependencies, disabled: false });
+			break;
+	}
+	writeStatus(getModelPresetRegistryStatus(dependencies), args.json === true);
+}

package/src/cli/update-cli.ts

@@ -17,6 +17,8 @@ import { isUpdateChannel, UPDATE_CHANNELS, type UpdateChannel } from "../config/
 import { installDefaultGjcDefinitions } from "../defaults/gjc-defaults";
 import { theme } from "../modes/theme/theme";
 import { getNotificationConfig, type NotificationProvider, resolveNotificationProvider } from "../sdk/bus/config";
+import type { TelemetryDetails, TelemetryEventName } from "../telemetry";
+import { recordTelemetryEvent } from "../telemetry";
 import { runDaemonCommand } from "./daemon-cli";
 import {
 	fetchGithubChannelRelease,
@@ -163,11 +165,12 @@ function isPathInDirectory(filePath: string, directoryPath: string): boolean {
 }
 
 export type PackageManagerTarget = { manager: "npm"; packageName: string };
+type MigrationUpdateTarget = { method: "migrate"; path: string; previousPath?: string };
 export type UpdateTarget =
 	| { method: "bun" }
 	| { method: "npm"; packageName: string }
 	| { method: "binary"; path: string }
-	| { method: "migrate"; path: string; previousPath?: string };
+	| MigrationUpdateTarget;
 
 type PathPlatform = NodeJS.Platform;
 type PackageExists = (packageName: string, packageRoot: string) => boolean;
@@ -506,6 +509,73 @@ async function verifyInstalledRuntime(
 	}
 }
 
+interface MigrationTargetVerificationOptions {
+	runtimePath: string;
+	verifyChecksum: () => Promise<void>;
+	verifyRuntime: () => Promise<InstalledVersionVerification>;
+}
+
+interface MigrationChecksumOptions {
+	tag: string;
+	assetName: string;
+	filePath: string;
+}
+
+type MigrationChecksumVerifier = (options: MigrationChecksumOptions) => Promise<unknown>;
+
+async function verifyMigrationTargetWith(
+	options: MigrationTargetVerificationOptions,
+): Promise<InstalledVersionVerification> {
+	try {
+		await options.verifyChecksum();
+	} catch {
+		return { ok: false, path: options.runtimePath };
+	}
+	return await options.verifyRuntime();
+}
+
+async function verifyMigrationTarget(
+	release: Pick<ReleaseInfo, "tag" | "version">,
+	runtimePath: string,
+	verifyChecksum: MigrationChecksumVerifier = verifyDownloadedBinaryChecksum,
+	verifyRuntime: (
+		expectedVersion: string,
+		runtimePath: string,
+	) => Promise<InstalledVersionVerification> = verifyInstalledRuntime,
+): Promise<InstalledVersionVerification> {
+	return await verifyMigrationTargetWith({
+		runtimePath,
+		verifyChecksum: async () => {
+			await verifyChecksum({
+				tag: release.tag,
+				assetName: getBinaryName(),
+				filePath: runtimePath,
+			});
+		},
+		verifyRuntime: async () => await verifyRuntime(release.version, runtimePath),
+	});
+}
+
+export async function verifyMigrationTargetForTest(
+	options: MigrationTargetVerificationOptions,
+): Promise<InstalledVersionVerification> {
+	return await verifyMigrationTargetWith(options);
+}
+
+export async function verifyMigrationTargetAdapterForTest(options: {
+	release: Pick<ReleaseInfo, "tag" | "version">;
+	runtimePath: string;
+	verifyChecksum: MigrationChecksumVerifier;
+	verifyRuntime: (expectedVersion: string, runtimePath: string) => Promise<InstalledVersionVerification>;
+}): Promise<InstalledVersionVerification> {
+	return await verifyMigrationTarget(
+		options.release,
+		options.runtimePath,
+		options.verifyChecksum,
+		options.verifyRuntime,
+	);
+}
+
 function printRestartGuidance(): void {
 	console.log(chalk.dim(`Restart ${APP_NAME} to use the new version`));
 }
@@ -1062,6 +1132,7 @@ async function updateViaBinaryAt(
 export interface UpdateCommandDependencies {
 	getLatestRelease?: (options?: LatestReleaseLookupOptions) => Promise<ReleaseInfo>;
 	resolveUpdateTarget?: () => Promise<UpdateTarget>;
+	verifyMigrationTarget?: (release: ReleaseInfo, runtimePath: string) => Promise<InstalledVersionVerification>;
 	performUpdate?: (
 		target: UpdateTarget,
 		expectedVersion: string,
@@ -1073,6 +1144,7 @@ export interface UpdateCommandDependencies {
 	restartDaemon?: (settings: Settings) => Promise<void>;
 	recoverNotifications?: (settings: Settings) => Promise<void>;
 	runPostUpdateRecovery?: (runtimePath: string) => Promise<void>;
+	recordTelemetryEvent?: (event: TelemetryEventName, details: TelemetryDetails) => unknown;
 	exit?: (code: number) => never;
 }
 
@@ -1265,6 +1337,24 @@ export function resolveUpdateDecision(options: {
 	return { install: true, kind: options.comparison > 0 ? "new-version" : "force" };
 }
 
+function printVerifiedMigrationTarget(target: MigrationUpdateTarget, version: string): void {
+	console.log(
+		chalk.green(
+			`${theme.status.success} Standalone ${APP_NAME} ${version} is already installed and verified at ${target.path}`,
+		),
+	);
+	if (target.previousPath) {
+		console.log(chalk.yellow(`${target.previousPath} shadows it on PATH.`));
+		console.log(
+			chalk.cyan(
+				`The standalone directory ${path.dirname(target.path)} must precede the shim directory ${path.dirname(target.previousPath)} on PATH.`,
+			),
+		);
+		return;
+	}
+	console.log(chalk.cyan(`Ensure the standalone directory ${path.dirname(target.path)} is on PATH.`));
+}
+
 export async function runUpdateCommand(
 	opts: UpdateCommandOptions,
 	deps: UpdateCommandDependencies = {},
@@ -1272,9 +1362,28 @@ export async function runUpdateCommand(
 	const channel = opts.channel ?? "stable";
 	const lookupRelease = deps.getLatestRelease ?? getLatestRelease;
 	const resolveTarget = deps.resolveUpdateTarget ?? resolveUpdateTarget;
+	const verifyTarget = deps.verifyMigrationTarget ?? verifyMigrationTarget;
 	const update = deps.performUpdate ?? performUpdate;
 	const refreshDefaults = deps.refreshInstalledDefaultSkills ?? refreshInstalledDefaultSkills;
 	const exit = deps.exit ?? process.exit;
+	const recordEvent = deps.recordTelemetryEvent ?? ((event, details) => recordTelemetryEvent(event, details));
+	const pendingTelemetry = new Set<Promise<void>>();
+	const record = (event: TelemetryEventName, details: TelemetryDetails): void => {
+		const result = recordEvent(event, details);
+		if (result !== null && (typeof result === "object" || typeof result === "function") && "then" in result) {
+			const pending = Promise.resolve(result as PromiseLike<unknown>).then(
+				() => undefined,
+				() => undefined,
+			);
+			pendingTelemetry.add(pending);
+			void pending.finally(() => pendingTelemetry.delete(pending));
+		}
+	};
+	const flushTelemetryBeforeExit = async (): Promise<never> => {
+		await Promise.race([Promise.allSettled([...pendingTelemetry]), Bun.sleep(2000)]);
+		return exit(1);
+	};
+	record("update_check_started", { channel });
 
 	console.log(chalk.dim(`Current version: ${VERSION}`));
 	if (channel !== "stable") {
@@ -1285,16 +1394,18 @@ export async function runUpdateCommand(
 	try {
 		target = await resolveTarget();
 	} catch (err) {
+		record("update_check_completed", { channel, result: "failed" });
 		console.error(chalk.red(err instanceof Error ? err.message : String(err)));
-		return exit(1);
+		return flushTelemetryBeforeExit();
 	}
 
 	let release: ReleaseInfo;
 	try {
 		release = await lookupRelease({ channel });
 	} catch (err) {
+		record("update_check_completed", { channel, result: "failed" });
 		console.error(chalk.red(`Failed to check for updates: ${err}`));
-		return exit(1);
+		return flushTelemetryBeforeExit();
 	}
 
 	// A config file that exists but could not be read changes which registry
@@ -1307,12 +1418,13 @@ export async function runUpdateCommand(
 	try {
 		comparison = compareVersions(release.version, VERSION);
 	} catch (err) {
+		record("update_check_completed", { channel, result: "failed" });
 		console.error(
 			chalk.red(
 				`Failed to check for updates: the ${channel} channel reported an unparseable version "${release.version}": ${err instanceof Error ? err.message : String(err)}`,
 			),
 		);
-		return exit(1);
+		return flushTelemetryBeforeExit();
 	}
 
 	const decision = resolveUpdateDecision({
@@ -1323,7 +1435,24 @@ export async function runUpdateCommand(
 		migrate: target?.method === "migrate",
 	});
 
+	if (target.method === "migrate" && decision.install && !opts.force) {
+		const releaseLock = await acquireBinaryUpdateLock(target.path);
+		try {
+			const verification = await verifyTarget(release, target.path);
+			if (verification.ok) {
+				record("update_check_completed", { channel, result: "available" });
+				record("update_install_started", { channel, installMethod: target.method });
+				printVerifiedMigrationTarget(target, release.version);
+				record("update_install_completed", { channel, result: "installed", installMethod: target.method });
+				return;
+			}
+		} finally {
+			await releaseLock();
+		}
+	}
+
 	if (!decision.install) {
+		record("update_check_completed", { channel, result: "up_to_date" });
 		console.log(chalk.green(`${theme.status.success} Already up to date`));
 		return;
 	}
@@ -1338,9 +1467,14 @@ export async function runUpdateCommand(
 		console.log(chalk.yellow(`Forcing reinstall of ${release.version}`));
 	}
 
-	if (opts.check) return;
+	record("update_check_completed", { channel, result: "available" });
+	if (opts.check) {
+		record("update_install_completed", { channel, result: "skipped" });
+		return;
+	}
 
 	let installedVersion: string | undefined;
+	record("update_install_started", { channel, installMethod: target.method });
 	try {
 		const resolved = target ?? (await resolveTarget());
 		const verification = await update(resolved, release.version, release.registry);
@@ -1349,16 +1483,18 @@ export async function runUpdateCommand(
 			await (deps.runPostUpdateRecovery ?? runPostUpdateRecovery)(verification.path);
 		} else if (!deps.performUpdate) throw new Error("verified installed runtime path is unavailable");
 	} catch (err) {
+		record("update_install_failed", { channel, result: "failed", installMethod: target.method });
 		const prefix = installedVersion
 			? `Updated to ${installedVersion}, but post-update recovery failed`
 			: "Update failed";
 		console.error(chalk.red(`${prefix}: ${err}`));
-		return exit(1);
+		return flushTelemetryBeforeExit();
 	}
 
 	// The installed runtime completes recovery before this old updater process
 	// refreshes opt-in local definitions, avoiding stale-module daemon control.
 	await refreshDefaults();
+	record("update_install_completed", { channel, result: "installed", installMethod: target.method });
 }
 
 /**

package/src/cli.ts

@@ -54,6 +54,7 @@ export const commands: CommandEntry[] = [
 	{ name: "daemon", load: () => import("./commands/daemon").then(m => m.default) },
 	{ name: "web-search", aliases: ["q"], load: () => import("./commands/web-search").then(m => m.default) },
 	{ name: "local-provider", load: () => import("./commands/local-provider").then(m => m.default) },
+	{ name: "model-presets", load: () => import("./commands/model-presets").then(m => m.default) },
 	{ name: "mcp-serve", load: () => import("./commands/mcp-serve").then(m => m.default) },
 	{ name: "mcp", load: () => import("./commands/mcp").then(m => m.default) },
 	{
@@ -364,6 +365,7 @@ function routeLegacyRootArgv(argv: readonly string[]): string[] | undefined {
 export function routeModelsAlias(argv: readonly string[]): string[] | undefined {
 	if (argv[0] !== "models") return undefined;
 	const rest = argv.slice(1);
+	if (rest[0] === "presets") return ["model-presets", ...rest.slice(1)];
 	if (rest.length === 0) return ["launch", "--list-models"];
 	// Pure search tokens become a single fuzzy pattern (matches --list-models).
 	if (rest.every(token => !token.startsWith("-") && !token.startsWith("@"))) {
@@ -461,7 +463,9 @@ export async function runCli(argv: string[]): Promise<void> {
 	}
 	const normalizedArgv = normalizeResumeAlias(argv);
 	const legacyArgv = routeLegacyRootArgv(normalizedArgv);
-	if (!legacyArgv && hasRootHelpFlag(normalizedArgv)) {
+	const modelPresetsArgv =
+		normalizedArgv[0] === "models" && normalizedArgv[1] === "presets" ? routeModelsAlias(normalizedArgv) : undefined;
+	if (!legacyArgv && !modelPresetsArgv && hasRootHelpFlag(normalizedArgv)) {
 		const { renderRootHelp } = await import("@gajae-code/utils/cli");
 		const { getExtraHelpText } = await import("./cli/fast-help");
 		renderRootHelp({ bin: APP_NAME, version: VERSION, commands: new Map([["launch", RootHelpCommand]]) });
@@ -475,7 +479,7 @@ export async function runCli(argv: string[]): Promise<void> {
 		process.stdout.write(`${APP_NAME}/${VERSION}\n`);
 		return;
 	}
-	const runArgv = legacyArgv ?? routeRootArgv(normalizedArgv);
+	const runArgv = legacyArgv ?? modelPresetsArgv ?? routeRootArgv(normalizedArgv);
 	if (isStatsHelpFastPath(runArgv)) {
 		showStatsFastHelp();
 		return;

package/src/commands/auth-gateway.ts

@@ -22,24 +22,27 @@ export default class AuthGateway extends Command {
 	};
 
 	static flags = {
-		json: Flags.boolean({ description: "Output JSON (token/status)" }),
+		json: Flags.boolean({ description: "Output JSON (token/status/check)" }),
 		bind: Flags.string({ description: "Bind address for `serve` (host:port)", char: "b" }),
+		provider: Flags.string({
+			description: "Required provider scope for `serve`; also filters `status` and `check`",
+		}),
 		regenerate: Flags.boolean({ description: "Regenerate the gateway bearer token (token)" }),
 		"no-auth": Flags.boolean({
 			description:
-				"Disable inbound bearer-token auth (serve). Useful when bound to loopback — any caller is allowed.",
+				"Disable inbound bearer-token auth (serve). Loopback non-browser clients without an Origin header are allowed.",
 		}),
 	};
 
 	static examples = [
-		"# Boot the gateway against the configured broker\n  gjc auth-gateway serve",
-		"# Boot on a non-default port\n  gjc auth-gateway serve --bind=127.0.0.1:4000",
+		"# Boot a provider-scoped gateway against the configured broker\n  gjc auth-gateway serve --provider=openai-codex",
+		"# Boot on a non-default port\n  gjc auth-gateway serve --provider=openai-codex --bind=127.0.0.1:4000",
 		"# Print the gateway bearer token (creates one on first run)\n  gjc auth-gateway token",
 		"# Rotate the gateway bearer token\n  gjc auth-gateway token --regenerate",
-		"# Run on loopback without any bearer (anyone on this host can call)\n  gjc auth-gateway serve --no-auth",
-		"# Show local gateway + broker config status\n  gjc auth-gateway status",
-		"# Probe each broker credential to see which one is producing 401s\n  gjc auth-gateway check",
-		"# Same, machine-readable for scripts\n  gjc auth-gateway check --json",
+		"# Run the scoped gateway on loopback for non-browser local clients without a bearer\n  gjc auth-gateway serve --provider=openai-codex --no-auth",
+		"# Show scoped local gateway + broker config status\n  gjc auth-gateway status --provider=openai-codex",
+		"# Probe credentials for one gateway scope\n  gjc auth-gateway check --provider=openai-codex",
+		"# Same, machine-readable for scripts\n  gjc auth-gateway check --provider=openai-codex --json",
 	];
 
 	async run(): Promise<void> {
@@ -53,6 +56,7 @@ export default class AuthGateway extends Command {
 			flags: {
 				json: flags.json,
 				bind: flags.bind,
+				provider: flags.provider,
 				regenerate: flags.regenerate,
 				noAuth: flags["no-auth"],
 			},

package/src/commands/gc.ts

@@ -20,6 +20,11 @@ function resolveDiskPolicyFromSettings(): Partial<GcDiskPolicy> | undefined {
 export default class Gc extends Command {
 	static description = "Garbage-collect stale GJC session/PID records (dry-run by default)";
 	static strict = false;
+	// The hand parser in gc-runtime owns the real syntax (repeatable space-form
+	// operands, dash-prefix rejection, orphan-operand rules); delegate help so the
+	// public output is the authoritative gcHelpText() instead of generic flag
+	// metadata that would advertise unsupported `--flag=<value>` forms.
+	static delegateHelp = true;
 	static flags = {
 		json: Flags.boolean({ char: "j", description: "Emit machine-readable JSON", default: false }),
 		prune: Flags.boolean({ description: "Remove stale records (default: report only)", default: false }),
@@ -33,6 +38,18 @@ export default class Gc extends Command {
 			description: "Quarantine a corrupt session-index suffix and retain its valid prefix",
 			default: false,
 		}),
+		"empty-delete-receipts": Flags.boolean({
+			description: "Report (and with --prune, prune) empty .gjc-delete-* receipts under --root/--manifest",
+			default: false,
+		}),
+		root: Flags.string({
+			description: "Operand root for --empty-delete-receipts (repeatable)",
+			multiple: true,
+		}),
+		manifest: Flags.string({
+			description: 'JSON {"roots":[...]} file for --empty-delete-receipts (repeatable)',
+			multiple: true,
+		}),
 	};
 
 	static examples = [
@@ -44,6 +61,8 @@ export default class Gc extends Command {
 		"gjc gc --disk --json",
 		"gjc gc --disk --prune",
 		"gjc gc --repair-session-index --json",
+		"gjc gc --empty-delete-receipts --root ~/.gjc/agent/session-states",
+		"gjc gc --empty-delete-receipts --manifest receipts-manifest.json --prune --json",
 	];
 
 	async run(): Promise<void> {

package/src/commands/model-presets.ts

@@ -0,0 +1,24 @@
+import { Args, Command, Flags } from "@gajae-code/utils/cli";
+import { MODEL_PRESETS_ACTIONS, type ModelPresetsAction, runModelPresetsCommand } from "../cli/model-presets-cli";
+
+export default class ModelPresets extends Command {
+	static description = "Manage the signed model preset registry";
+
+	static args = {
+		action: Args.string({ description: "Action", required: false, options: MODEL_PRESETS_ACTIONS }),
+		revision: Args.string({ description: "Accepted revision for pin or rollback", required: false }),
+	};
+
+	static flags = {
+		json: Flags.boolean({ description: "Output JSON" }),
+	};
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(ModelPresets);
+		await runModelPresetsCommand({
+			action: (args.action ?? "status") as ModelPresetsAction,
+			revision: args.revision,
+			json: flags.json,
+		});
+	}
+}

package/src/commands/sdk.ts

@@ -838,6 +838,10 @@ class SdkSessionHelp extends Command {
 			description: "Workspace directory for saved-session resolution (default: current directory)",
 		}),
 		op: Flags.string({ description: "Raw control or global operation" }),
+		scope: Flags.string({
+			description: "list scope: repo (default), cwd, worktree, or all",
+			options: ["repo", "cwd", "worktree", "all"],
+		}),
 		query: Flags.string({ description: "Raw query name" }),
 		"json-input": Flags.string({ description: "SDK request JSON object" }),
 		"json-input-file": Flags.string({ description: "Read SDK request JSON from a 0600 file" }),
@@ -894,6 +898,7 @@ class SdkSessionCommand extends Command {
 			allEvents: Boolean(flagRec["all-events"]),
 			agentDir: flagRec["agent-dir"] as string | undefined,
 			repo: flagRec.repo as string | undefined,
+			scope: flagRec.scope as string | undefined,
 		});
 	}
 }

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

@@ -146,6 +146,7 @@ export const TIER_MAP_SKIP_LIST = {
 	},
 	"vercel-ai-gateway/google/gemini-3.7-flash": { rationale: "post-rebase catalog addition from dev; not yet curated" },
 	"zai/glm-5.3": { rationale: "post-rebase catalog addition from dev; not yet curated" },
+	"zai/glm-5.3-flash": { rationale: "post-feature catalog addition; not yet curated" },
 	"cursor/gemini-3.7-flash-high": {
 		rationale: "post-rebase catalog addition from dev; not yet curated",
 	},
@@ -5885,6 +5886,38 @@ export const TIER_MAP_SKIP_LIST = {
 	"zenmux/z-ai/glm-5.2": { baseline: true, rationale: "pre-feature baseline; not yet curated" },
 	"zenmux/z-ai/glm-5.2-free": { baseline: true, rationale: "pre-feature baseline; not yet curated" },
 	"zenmux/z-ai/glm-5v-turbo": { baseline: true, rationale: "pre-feature baseline; not yet curated" },
+	"kiro/auto": { rationale: "Kiro API-key catalog addition; not yet curated" },
+	"kiro/claude-haiku-4-5": { rationale: "Kiro API-key catalog addition; not yet curated" },
+	"kiro/claude-haiku-4.5": { rationale: "Kiro API-key catalog addition; not yet curated" },
+	"kiro/claude-opus-4-5": { rationale: "Kiro API-key catalog addition; not yet curated" },
+	"kiro/claude-opus-4-6": { rationale: "Kiro API-key catalog addition; not yet curated" },
+	"kiro/claude-opus-4-7": { rationale: "Kiro API-key catalog addition; not yet curated" },
+	"kiro/claude-opus-4-8": { rationale: "Kiro API-key catalog addition; not yet curated" },
+	"kiro/claude-opus-4.5": { rationale: "Kiro API-key catalog addition; not yet curated" },
+	"kiro/claude-opus-4.6": { rationale: "Kiro API-key catalog addition; not yet curated" },
+	"kiro/claude-opus-4.7": { rationale: "Kiro API-key catalog addition; not yet curated" },
+	"kiro/claude-opus-4.8": { rationale: "Kiro API-key catalog addition; not yet curated" },
+	"kiro/claude-opus-5": { rationale: "Kiro API-key catalog addition; not yet curated" },
+	"kiro/claude-sonnet-4": { rationale: "Kiro API-key catalog addition; not yet curated" },
+	"kiro/claude-sonnet-4-5": { rationale: "Kiro API-key catalog addition; not yet curated" },
+	"kiro/claude-sonnet-4-6": { rationale: "Kiro API-key catalog addition; not yet curated" },
+	"kiro/claude-sonnet-4.5": { rationale: "Kiro API-key catalog addition; not yet curated" },
+	"kiro/claude-sonnet-4.6": { rationale: "Kiro API-key catalog addition; not yet curated" },
+	"kiro/claude-sonnet-5": { rationale: "Kiro API-key catalog addition; not yet curated" },
+	"kiro/deepseek-3-2": { rationale: "Kiro API-key catalog addition; not yet curated" },
+	"kiro/deepseek-3.2": { rationale: "Kiro API-key catalog addition; not yet curated" },
+	"kiro/glm-5": { rationale: "Kiro API-key catalog addition; not yet curated" },
+	"kiro/gpt-5-6-luna": { rationale: "Kiro API-key catalog addition; not yet curated" },
+	"kiro/gpt-5-6-sol": { rationale: "Kiro API-key catalog addition; not yet curated" },
+	"kiro/gpt-5-6-terra": { rationale: "Kiro API-key catalog addition; not yet curated" },
+	"kiro/gpt-5.6-luna": { rationale: "Kiro API-key catalog addition; not yet curated" },
+	"kiro/gpt-5.6-sol": { rationale: "Kiro API-key catalog addition; not yet curated" },
+	"kiro/gpt-5.6-terra": { rationale: "Kiro API-key catalog addition; not yet curated" },
+	"kiro/minimax-m2-1": { rationale: "Kiro API-key catalog addition; not yet curated" },
+	"kiro/minimax-m2-5": { rationale: "Kiro API-key catalog addition; not yet curated" },
+	"kiro/minimax-m2.1": { rationale: "Kiro API-key catalog addition; not yet curated" },
+	"kiro/minimax-m2.5": { rationale: "Kiro API-key catalog addition; not yet curated" },
+	"kiro/qwen3-coder-next": { rationale: "Kiro API-key catalog addition; not yet curated" },
 } as const satisfies TierMapSkipList;
 
 export const CURATED_TIER_MAP: AutoroutingCuratedTierMap = {

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

@@ -17,7 +17,7 @@ import type {
 } from "../gjc-runtime/gc-runtime";
 import { gcPidStatusLabel } from "../gjc-runtime/gc-runtime";
 import { resolveReceiptSpoolDir } from "../harness-control-plane/receipt-spool";
-import { readFileLockInfoForGc, removeFileLockDirForGc } from "./file-lock";
+import { readFileLockObservationForGc, removeFileLockDirForGc } from "./file-lock";
 
 const MAX_WALK_DEPTH = 6;
 /** Default per-root walk budget. Truncation is a warning, not a hard error. */
@@ -68,7 +68,8 @@ function keptMalformedRecord(lockDir: string): GcRecord {
 }
 
 async function collectLockRecord(lockDir: string, ctx: GcContext): Promise<GcRecord> {
-	const info = await readFileLockInfoForGc(lockDir);
+	const observation = await readFileLockObservationForGc(lockDir);
+	const info = observation?.info;
 	if (!info) return keptMalformedRecord(lockDir);
 	if (info.owner_host_id !== undefined) {
 		return {
@@ -203,7 +204,8 @@ export const fileLocksGcAdapter: GcStoreAdapter = {
 	},
 	async prune(record: GcRecord, ctx: GcContext): Promise<GcPruneOutcome> {
 		const lockDir = record.path ?? record.id;
-		const info = await readFileLockInfoForGc(lockDir);
+		const observation = await readFileLockObservationForGc(lockDir);
+		const info = observation?.info;
 		if (!info) return { removed: false, skipped: "lock_no_longer_dead_or_missing" };
 		if (info.owner_host_id !== undefined) {
 			return { removed: false, skipped: "host_qualified_lock_requires_owner_reclamation" };
@@ -220,13 +222,16 @@ export const fileLocksGcAdapter: GcStoreAdapter = {
 		// so removal re-verifies the on-disk identity under the unlink and refuses
 		// to delete a recreated LIVE lock (TOCTOU).
 		try {
-			const removal = await removeFileLockDirForGc(lockDir, info);
+			const removal = await removeFileLockDirForGc(lockDir, info, observation?.identity);
 			if (removal === "owner_changed") {
 				return { removed: false, skipped: "file_lock_owner_changed_before_delete" };
 			}
 			if (removal === "missing") {
 				return { removed: false, skipped: "lock_no_longer_dead_or_missing" };
 			}
+			if (removal === "cleanup_failed") {
+				return { removed: false, skipped: "lock_removal_denied_by_native_identity_guard" };
+			}
 			return { removed: true };
 		} catch (error) {
 			return { removed: false, error: errorMessage(error) };