@gajae-code/coding-agent 0.15.6 → 0.16.1

package/src/cli/update-cli.ts

@@ -9,7 +9,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { pipeline } from "node:stream/promises";
-import { $which, APP_NAME, isCompiledBinary, isEnoent, VERSION } from "@gajae-code/utils";
+import { $which, APP_NAME, isCompiledBinary, isEnoent, redactCrashSecrets, VERSION } from "@gajae-code/utils";
 import { $ } from "bun";
 import chalk from "chalk";
 import { Settings } from "../config/settings";
@@ -55,6 +55,7 @@ export interface InstalledVersionVerification {
 	ok: boolean;
 	actual?: string;
 	path?: string;
+	versionOutput?: string;
 	smokeTestFailed?: boolean;
 	smokeTestOutput?: string;
 	cleanupWarning?: string;
@@ -462,6 +463,71 @@ export function parseReportedVersionForTest(output: string): string | undefined
 	return parseReportedVersion(output);
 }
 
+const VERIFICATION_OUTPUT_MAX_LENGTH = 512;
+const ANSI_ESCAPE = /\x1b(?:\[[0-?]*[ -/]*[@-~]|\][^\x07]*(?:\x07|\x1b\\))/gu;
+const UNSAFE_CONTROL = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/gu;
+
+function sanitizeVerificationOutput(...streams: Array<string | undefined>): string | undefined {
+	const output = streams
+		.map(stream => stream?.replace(ANSI_ESCAPE, "").replace(UNSAFE_CONTROL, " ").replace(/\s+/g, " ").trim() ?? "")
+		.filter(Boolean)
+		.filter((stream, index, all) => all.indexOf(stream) === index)
+		.join(" ");
+	if (!output) return undefined;
+	const redacted = redactCrashSecrets(output);
+	if (redacted.length <= VERIFICATION_OUTPUT_MAX_LENGTH) return redacted;
+	return `${redacted.slice(0, VERIFICATION_OUTPUT_MAX_LENGTH - 3)}...`;
+}
+
+export function sanitizeVerificationOutputForTest(
+	stderr: string | undefined,
+	stdout: string | undefined,
+): string | undefined {
+	return sanitizeVerificationOutput(stderr, stdout);
+}
+
+interface InstalledVersionCommandResult {
+	exitCode: number | null;
+	stdout: string;
+	stderr: string;
+}
+
+type InstalledVersionCommandRunner = (runtimePath: string) => Promise<InstalledVersionCommandResult>;
+
+async function verifyInstalledVersionWith(
+	expectedVersion: string,
+	runtimePath: string | undefined,
+	runVersion: InstalledVersionCommandRunner,
+): Promise<InstalledVersionVerification> {
+	if (!runtimePath) return { ok: false };
+	try {
+		const result = await runVersion(runtimePath);
+		if (result.exitCode !== 0) {
+			return {
+				ok: false,
+				path: runtimePath,
+				versionOutput: sanitizeVerificationOutput(result.stderr, result.stdout),
+			};
+		}
+		const actual = parseReportedVersion(result.stdout);
+		return { ok: actual === expectedVersion, actual, path: runtimePath };
+	} catch (error) {
+		return {
+			ok: false,
+			path: runtimePath,
+			versionOutput: sanitizeVerificationOutput(error instanceof Error ? error.message : String(error)),
+		};
+	}
+}
+
+export async function verifyInstalledVersionForTest(options: {
+	expectedVersion: string;
+	runtimePath: string | undefined;
+	runVersion: InstalledVersionCommandRunner;
+}): Promise<InstalledVersionVerification> {
+	return await verifyInstalledVersionWith(options.expectedVersion, options.runtimePath, options.runVersion);
+}
+
 /**
  * Run the resolved gjc binary and check if it reports the expected version.
  */
@@ -469,15 +535,14 @@ async function verifyInstalledVersion(
 	expectedVersion: string,
 	runtimePath: string | undefined = resolveGjcPath(),
 ): Promise<InstalledVersionVerification> {
-	if (!runtimePath) return { ok: false };
-	try {
-		const result = await $`${runtimePath} --version`.quiet().nothrow();
-		if (result.exitCode !== 0) return { ok: false, path: runtimePath };
-		const actual = parseReportedVersion(result.text());
-		return { ok: actual === expectedVersion, actual, path: runtimePath };
-	} catch {
-		return { ok: false, path: runtimePath };
-	}
+	return await verifyInstalledVersionWith(expectedVersion, runtimePath, async resolvedPath => {
+		const result = await $`${resolvedPath} --version`.quiet().nothrow();
+		return {
+			exitCode: result.exitCode,
+			stdout: result.stdout.toString(),
+			stderr: result.stderr.toString(),
+		};
+	});
 }
 
 async function verifyInstalledRuntime(
@@ -665,7 +730,8 @@ function formatVerificationFailure(result: InstalledVersionVerification, expecte
 	if (result.actual) {
 		return `${APP_NAME} at ${result.path} still reports ${result.actual} (expected ${expectedVersion})`;
 	}
-	return `could not verify updated version${result.path ? ` at ${result.path}` : ""}`;
+	const outputSuffix = result.versionOutput ? `: ${result.versionOutput}` : "";
+	return `could not verify updated version${result.path ? ` at ${result.path}` : ""}${outputSuffix}`;
 }
 
 export function formatVerificationFailureForTest(
@@ -1084,6 +1150,67 @@ function formatRegistryProvenance(version: string, registry: string | undefined)
 	return `Version ${version} was resolved from ${registry}; GitHub release assets may not exist for a version that was never published there.`;
 }
 
+interface ProcessReportWithLibc {
+	header?: {
+		glibcVersionRuntime?: unknown;
+	};
+}
+
+const GLIBC_VERSION_PATTERN = /^\d+\.\d+$/u;
+
+function reportedGlibcVersion(value: unknown): string | undefined {
+	if (typeof value !== "string") return undefined;
+	const version = value.trim();
+	return GLIBC_VERSION_PATTERN.test(version) ? version : undefined;
+}
+
+function runtimeGlibcVersion(): string | undefined {
+	try {
+		const report = process.report?.getReport?.() as ProcessReportWithLibc | undefined;
+		return reportedGlibcVersion(report?.header?.glibcVersionRuntime);
+	} catch {
+		return undefined;
+	}
+}
+
+function hasMuslLoader(): boolean {
+	return (
+		fs.existsSync("/lib/ld-musl-x86_64.so.1") ||
+		fs.existsSync("/lib/ld-musl-aarch64.so.1") ||
+		fs.existsSync("/lib/ld-musl-armhf.so.1")
+	);
+}
+
+type LinuxLibc = "glibc" | "musl" | "unknown";
+
+function detectLinuxLibcFromSignals(glibcVersionRuntime: string | undefined, muslLoaderPresent: boolean): LinuxLibc {
+	if (reportedGlibcVersion(glibcVersionRuntime) !== undefined) return "glibc";
+	return muslLoaderPresent ? "musl" : "unknown";
+}
+
+function detectLinuxLibc(): LinuxLibc {
+	return detectLinuxLibcFromSignals(runtimeGlibcVersion(), hasMuslLoader());
+}
+
+function unsupportedLinuxLibcReason(libc: LinuxLibc): string | undefined {
+	if (libc === "glibc") return undefined;
+	return libc === "musl"
+		? "Unsupported libc: musl. Prebuilt Linux binaries are glibc-only. See docs/install.md"
+		: "Unable to verify an active glibc runtime. Prebuilt Linux binaries are glibc-only. See docs/install.md";
+}
+
+function assertSupportedLinuxLibc(libc: LinuxLibc): void {
+	const reason = unsupportedLinuxLibcReason(libc);
+	if (reason) throw new Error(formatUnsupportedTargetMessage(reason));
+}
+
+export function assertSupportedLinuxLibcForTest(
+	glibcVersionRuntime: string | undefined,
+	muslLoaderPresent: boolean,
+): void {
+	assertSupportedLinuxLibc(detectLinuxLibcFromSignals(glibcVersionRuntime, muslLoaderPresent));
+}
+
 /**
  * Download a release binary to a target path, replacing an existing file.
  */
@@ -1092,18 +1219,8 @@ async function updateViaBinaryAt(
 	expectedVersion: string,
 	registry?: string,
 ): Promise<InstalledVersionVerification> {
-	if (
-		process.platform === "linux" &&
-		(fs.existsSync("/lib/ld-musl-x86_64.so.1") ||
-			fs.existsSync("/lib/ld-musl-aarch64.so.1") ||
-			fs.existsSync("/lib/ld-musl-armhf.so.1"))
-	) {
-		throw new Error(
-			formatUnsupportedTargetMessage(
-				"Unsupported libc: musl. Prebuilt Linux binaries are glibc-only. See docs/install.md",
-			),
-		);
-	}
+	const linuxLibc = process.platform === "linux" ? detectLinuxLibc() : undefined;
+	if (linuxLibc !== undefined) assertSupportedLinuxLibc(linuxLibc);
 	const binaryName = getBinaryName();
 	const url = buildReleaseBinaryUrl(expectedVersion);
 	const registryNote = formatRegistryProvenance(expectedVersion, registry);

package/src/commands/launch.ts

@@ -2,20 +2,30 @@
  * Root command for the coding agent CLI.
  */
 
-import { APP_NAME, setProjectDir } from "@gajae-code/utils";
+import { APP_NAME, getAgentDir, setProjectDir } from "@gajae-code/utils";
 import { Args, Command } from "@gajae-code/utils/cli";
 import { assertLocalLaunchArgs, parseArgs } from "../cli/args";
 import { ROOT_LAUNCH_FLAGS } from "../cli/root-flags";
 import { writeCoordinatorAtomic } from "../coordinator-mcp/durability";
 import { launchDefaultTmuxIfNeeded } from "../gjc-runtime/launch-tmux";
-import { type PreparedLaunchWorktree, prepareLaunchWorktree } from "../gjc-runtime/launch-worktree";
+import {
+	type GjcLaunchWorktreePlan,
+	type PreparedLaunchWorktree,
+	parseLaunchWorktreeMode,
+	planLaunchWorktree,
+	prepareLaunchWorktree,
+} from "../gjc-runtime/launch-worktree";
+import { type LaunchWorktreeReservation, reserveLaunchWorktree } from "../gjc-runtime/launch-worktree-reservation";
 import {
 	GJC_COORDINATOR_SESSION_ID_ENV,
 	GJC_COORDINATOR_SESSION_STATE_FILE_ENV,
 	GJC_TMUX_OWNER_GENERATION_ENV,
 } from "../gjc-runtime/session-state-sidecar";
 import { runRootCommand } from "../main";
+import { assertMasterLaunchArgs } from "../master-mode/context";
 import { prepareAcpTerminalAuthArgs } from "../modes/acp/terminal-auth";
+import { type IndexedSession, SessionIndex } from "../sdk/broker/session-index";
+import { worktreeOccupant } from "../sdk/broker/worktree-occupancy";
 
 export async function persistCoordinatorLaunchFailure(
 	error: unknown,
@@ -56,6 +66,54 @@ export async function persistCoordinatorLaunchFailure(
 	await writeCoordinatorAtomic(stateFile, `${JSON.stringify(payload, null, 2)}\n`);
 }
 
+function worktreeInUseError(worktreePath: string, occupant?: string): Error {
+	const holder = occupant ? `session ${occupant}` : "another launch";
+	return new Error(
+		`worktree_in_use:${worktreePath} is already held by ${holder}. ` +
+			"Use gjc --worktree <name> for a separate checkout, or stop that session.",
+	);
+}
+
+async function reserveLaunchWorktreeOrFail(agentDir: string, worktreePath: string): Promise<LaunchWorktreeReservation> {
+	const reservation = await reserveLaunchWorktree(agentDir, worktreePath);
+	if (!reservation) throw worktreeInUseError(worktreePath);
+	return reservation;
+}
+
+/** Test seam for the path-keyed atomic reservation. */
+export async function reserveLaunchWorktreeForTest(
+	agentDir: string,
+	worktreePath: string,
+): Promise<LaunchWorktreeReservation> {
+	return await reserveLaunchWorktreeOrFail(agentDir, worktreePath);
+}
+
+async function assertLaunchWorktreeUnoccupied(worktree: GjcLaunchWorktreePlan | { enabled: false }): Promise<void> {
+	if (!worktree.enabled) return;
+	let sessions: readonly IndexedSession[];
+	try {
+		sessions = (await new SessionIndex(getAgentDir()).open()).listSessionIdentities();
+	} catch {
+		throw new Error(`worktree_occupancy_unavailable:${worktree.worktreePath}`);
+	}
+	const occupant = worktreeOccupant(sessions, worktree.worktreePath);
+	if (occupant) throw worktreeInUseError(worktree.worktreePath, occupant);
+}
+
+async function reserveLaunchWorktreePreflight(
+	worktree: GjcLaunchWorktreePlan | { enabled: false },
+): Promise<LaunchWorktreeReservation | undefined> {
+	if (!worktree.enabled) return undefined;
+	const reservation = await reserveLaunchWorktreeOrFail(getAgentDir(), worktree.worktreePath);
+	try {
+		await assertLaunchWorktreeUnoccupied(worktree);
+		return reservation;
+	} catch (error) {
+		await reservation.release();
+		throw error;
+	}
+}
+
 export default class Index extends Command {
 	static description = "Red-claw AI coding assistant";
 	static hidden = true;
@@ -93,34 +151,44 @@ export default class Index extends Command {
 		const { args } = prepareAcpTerminalAuthArgs(this.argv);
 		const parsed = parseArgs([...args], "deferred");
 		if (parsed.mode !== "acp") assertLocalLaunchArgs(parsed);
+		assertMasterLaunchArgs(parsed);
 		if (parsed.help || parsed.version) {
 			await runRootCommand(parsed, args);
 			return;
 		}
 
 		let launch: PreparedLaunchWorktree;
+		let reservation: LaunchWorktreeReservation | undefined;
 		try {
+			const plannedWorktree = planLaunchWorktree(process.cwd(), parseLaunchWorktreeMode(args).mode);
+			reservation = await reserveLaunchWorktreePreflight(plannedWorktree);
 			launch = prepareLaunchWorktree(process.cwd(), args);
 		} catch (error) {
+			await reservation?.release();
 			await persistCoordinatorLaunchFailure(error, process.cwd());
 			throw error;
 		}
-		if (launch.worktree.enabled) {
-			process.chdir(launch.cwd);
-			setProjectDir(launch.cwd);
+		try {
+			if (launch.worktree.enabled) {
+				process.chdir(launch.cwd);
+				setProjectDir(launch.cwd);
+			}
+			const launchParsed = parseArgs(launch.args, "deferred");
+			if (launchParsed.mode !== "acp") assertLocalLaunchArgs(launchParsed);
+			assertMasterLaunchArgs(launchParsed);
+			if (
+				launchDefaultTmuxIfNeeded({
+					parsed: launchParsed,
+					rawArgs: launch.args,
+					cwd: launch.cwd,
+					worktreeBranch: launch.worktree.enabled && !launch.worktree.detached ? launch.worktree.branchName : null,
+					project: launch.cwd,
+				})
+			)
+				return;
+			await runRootCommand(launchParsed, launch.args);
+		} finally {
+			await reservation?.release();
 		}
-		const launchParsed = parseArgs(launch.args, "deferred");
-		if (launchParsed.mode !== "acp") assertLocalLaunchArgs(launchParsed);
-		if (
-			launchDefaultTmuxIfNeeded({
-				parsed: launchParsed,
-				rawArgs: launch.args,
-				cwd: launch.cwd,
-				worktreeBranch: launch.worktree.enabled && !launch.worktree.detached ? launch.worktree.branchName : null,
-				project: launch.cwd,
-			})
-		)
-			return;
-		await runRootCommand(launchParsed, launch.args);
 	}
 }

package/src/commands/sdk.ts

@@ -27,7 +27,8 @@ import {
 } from "../sdk/broker/lifecycle";
 import { processIncarnation } from "../sdk/broker/process-incarnation";
 import { writeBrokerStartupFailureMarker } from "../sdk/broker/startup-failure";
-import { runSdkSessionCli } from "../sdk/cli";
+import { renderSdkSearchTable, runSdkSearch, runSdkSessionCli } from "../sdk/cli";
+import { renderSpawnTable, runSdkSpawn, SdkMasterCliError } from "../sdk/cli/master-cli";
 import { runSdkGuidesCli } from "../sdk/guides/cli";
 import { type CreateLifecycleAgentSessionResult, createLifecycleAgentSession } from "../sdk/lifecycle-session";
 import { listManagedSessionCandidates, resolveManagedSessionScope } from "../sdk/session-directory";
@@ -38,6 +39,7 @@ import {
 	SdkStartupRollbackTracker,
 } from "../sdk/startup-capability";
 import { runSdkServe } from "../sdk/transport/serve-cli";
+import { isSessionDisposalIncompleteError } from "../session/agent-session";
 import {
 	type CapturedSessionTranscriptSnapshot,
 	type ResumeSessionIdentity,
@@ -404,11 +406,13 @@ export async function runSessionHost(
 		sleep?: (ms: number) => Promise<void>;
 		cwd?: string;
 		processIncarnation?: (pid: number) => string | undefined;
+		applyStartupModelProfiles?: typeof applyStartupModelProfiles;
 	} = {},
 ): Promise<void> {
 	const now = timing.now ?? Date.now;
 	const sleep = timing.sleep ?? (async ms => await Bun.sleep(ms));
 	const readIncarnation = timing.processIncarnation ?? processIncarnation;
+	const applyModelProfiles = timing.applyStartupModelProfiles ?? applyStartupModelProfiles;
 	const request = readSessionLifecycleLaunchRequest(process.env.GJC_SDK_LIFECYCLE_REQUEST, now());
 	const agentDir = process.env.GJC_AGENT_DIR;
 	if (!agentDir) throw new Error("GJC_AGENT_DIR is required for sdk session-host-internal.");
@@ -582,6 +586,7 @@ export async function runSessionHost(
 				...(mcpStartupTimeoutMs !== undefined ? { mcpStartupTimeoutMs } : {}),
 				...(request.readiness ? { readiness: request.readiness } : {}),
 				...(request.modelId ? { modelId: request.modelId } : {}),
+				lifecycleRequestId: effectMarker,
 			});
 		} catch (error) {
 			throw await registrationFailure(error);
@@ -597,22 +602,32 @@ export async function runSessionHost(
 		throw created.failure;
 	}
 	const { session, capability, rollback, startDeferredMemoryBackend } = created;
+	let lifecycleTranscriptPath: string | undefined;
+	session.registerToolSessionTransitionCleanup(async () => {
+		await session.sessionManager.ensureOnDisk();
+		lifecycleTranscriptPath = session.sessionManager.getSessionFile();
+	});
 	let sessionDisposal: Promise<void> | undefined;
 	const disposeSession = (): Promise<void> => {
-		sessionDisposal ??= session.dispose().catch(() => {});
+		sessionDisposal ??= (async () => {
+			try {
+				await session.dispose();
+			} catch (error) {
+				if (!isSessionDisposalIncompleteError(error)) throw error;
+				await session.awaitDisposeCompletion();
+			}
+		})();
 		return sessionDisposal;
 	};
 	let disposal: Promise<LifecycleTranscriptEvidence | undefined> | undefined;
 	const disposeAndCapture = (): Promise<LifecycleTranscriptEvidence | undefined> => {
 		disposal ??= (async () => {
 			await disposeSession();
+			if (!lifecycleTranscriptPath) return undefined;
 			try {
-				await session.sessionManager.ensureOnDisk();
-				const transcriptPath = session.sessionManager.getSessionFile();
-				if (!transcriptPath) return undefined;
 				const [bytes, stat] = await Promise.all([
-					fs.readFile(transcriptPath),
-					fs.stat(transcriptPath, { bigint: true }),
+					fs.readFile(lifecycleTranscriptPath),
+					fs.stat(lifecycleTranscriptPath, { bigint: true }),
 				]);
 				const digest = createHash("sha256").update(bytes).digest("hex");
 				return {
@@ -706,12 +721,14 @@ export async function runSessionHost(
 		const modelProfileStartup =
 			process.env.GJC_SDK_TEST_HANG_MODEL_PROFILE === cwd
 				? new Promise<void>(() => {})
-				: applyStartupModelProfiles({
+				: applyModelProfiles({
 						session,
 						settings: session.settings,
 						modelRegistry: session.modelRegistry,
 						parsedArgs: parsed,
 						startupThinkingLevel,
+						preferCachedModels: true,
+						preferCachedDefaultProfile: true,
 					});
 		await beforeCutoff(modelProfileStartup);
 		throwIfCutoff();
@@ -838,19 +855,24 @@ 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" }),
 		"json-input-stdin": Flags.boolean({ description: "Read SDK request JSON from standard input" }),
-		"idempotency-key": Flags.string({ description: "Caller idempotency key required for SDK lifecycle globals" }),
-		confirm: Flags.boolean({ description: "Confirm a destructive SDK control operation" }),
+		"idempotency-key": Flags.string({
+			description: "Caller idempotency key required for lifecycle globals and terminal abort controls",
+		}),
+		confirm: Flags.boolean({ description: "Confirm a destructive local CLI control operation" }),
 		cursor: Flags.string({
-			description: "Raw query continuation cursor, or a saved checkpoint token to resume tail from",
+			description: "Raw query continuation cursor, saved checkpoint token, or search continuation cursor",
+		}),
+		scope: Flags.string({
+			description:
+				"session list scope: repo (default), cwd, worktree, or all; search scope: repo (default), pwd, or global",
 		}),
+		limit: Flags.integer({ description: "Search page size from 1 to 100" }),
+		json: Flags.boolean({ description: "Render search as the SdkSearchResultV1 JSON envelope" }),
 		text: Flags.string({ description: "Prompt text for send (alternative to --json-input)" }),
 		"op-ref": Flags.string({ description: "Operation reference for send (defaults to a generated ULID)" }),
 		wait: Flags.boolean({
@@ -864,6 +886,70 @@ class SdkSessionHelp extends Command {
 	async run(): Promise<void> {}
 }
 
+class SdkSpawnCommand extends Command {
+	static description = "Spawn a task-seeded background child session (local interactive master only).";
+	static flags = {
+		cwd: Flags.string({ description: "Working directory for the spawned child" }),
+		prompt: Flags.string({ description: "Seed task delivered once to the child" }),
+		model: Flags.string({ description: "Model selector for the child" }),
+		profile: Flags.string({ description: "Model profile name for the child" }),
+		"agent-dir": Flags.string({ description: "SDK broker state directory" }),
+		"idempotency-key": Flags.string({
+			description: "Idempotency key for replaying an uncertain session.spawn result",
+		}),
+		json: Flags.boolean({ description: "Render the safe spawn result as JSON" }),
+	};
+	async run(): Promise<void> {
+		const { flags } = await this.parse(SdkSpawnCommand);
+		try {
+			const spawn = await runSdkSpawn({
+				cwd: flags.cwd,
+				prompt: flags.prompt,
+				model: flags.model,
+				profile: flags.profile,
+				agentDir: flags["agent-dir"],
+				idempotencyKey: flags["idempotency-key"],
+			});
+			process.stdout.write(`${flags.json ? JSON.stringify(spawn.rendered) : renderSpawnTable(spawn.rendered)}\n`);
+			if (spawn.exitCode !== 0) process.exitCode = spawn.exitCode;
+		} catch (error) {
+			if (error instanceof SdkMasterCliError) {
+				process.stderr.write(`Error: ${error.code}: ${error.message}\n`);
+				process.exitCode = error.exitCode;
+				return;
+			}
+			throw error;
+		}
+	}
+}
+
+class SdkSearchCommand extends Command {
+	static description = "Search broker-visible SDK sessions within an exact repo, pwd, or global scope.";
+	static flags = {
+		"agent-dir": Flags.string({ description: "SDK broker state directory" }),
+		repo: Flags.string({ description: "Workspace directory for scope resolution (default: current directory)" }),
+		scope: Flags.string({ description: "Search scope: repo, pwd, or global (default: repo)" }),
+		limit: Flags.integer({ description: "Search page size from 1 to 100" }),
+		cursor: Flags.string({ description: "Frozen scoped search continuation cursor" }),
+		json: Flags.boolean({ description: "Render exactly the SdkSearchResultV1 JSON envelope" }),
+	};
+	async run(): Promise<void> {
+		const { flags } = await this.parse(SdkSearchCommand);
+		const scope = flags.scope;
+		if (scope !== undefined && scope !== "repo" && scope !== "pwd" && scope !== "global")
+			throw new CliParseError("--scope must be repo, pwd, or global.");
+		const search = await runSdkSearch({
+			agentDir: flags["agent-dir"],
+			repo: flags.repo,
+			scope,
+			limit: flags.limit,
+			cursor: flags.cursor,
+		});
+		process.stdout.write(`${flags.json ? JSON.stringify(search.result) : renderSdkSearchTable(search.result)}\n`);
+		if (search.exitCode !== 0) process.exitCode = search.exitCode;
+	}
+}
+
 class SdkSessionCommand extends Command {
 	static description = SdkSessionHelp.description;
 	static args = SdkSessionHelp.args;
@@ -936,10 +1022,12 @@ class SdkGuidesCommand extends Command {
 
 export default class Sdk extends Command {
 	static description =
-		"gjc sdk serve --stdio | --socket <path> [--session <id>]; gjc sdk session list|inspect|send|status|tail; gjc sdk guides refresh|list|show|status|trust";
+		"gjc sdk serve --stdio | --socket <path> [--session <id>]; gjc sdk search [--scope repo|pwd|global] [--json] [--limit N] [--cursor ...]; gjc sdk spawn --cwd <dir> --prompt <task> (master only); gjc sdk session list|inspect|send|status|tail; gjc sdk guides refresh|list|show|status|trust";
 	static hidden = false;
 	static delegateHelp = true;
-	static args = { action: Args.string({ required: false, options: ["serve", "session", "guides"] }) };
+	static args = {
+		action: Args.string({ required: false, options: ["serve", "search", "spawn", "session", "guides"] }),
+	};
 	static flags = SdkServeHelp.flags;
 	async run(): Promise<void> {
 		const action = this.argv[0];
@@ -947,22 +1035,38 @@ export default class Sdk extends Command {
 			const helpAction =
 				action === "serve"
 					? "sdk serve"
-					: action === "session"
-						? "sdk session"
-						: action === "guides"
-							? "sdk guides"
-							: "sdk";
+					: action === "search"
+						? "sdk search"
+						: action === "spawn"
+							? "sdk spawn"
+							: action === "session"
+								? "sdk session"
+								: action === "guides"
+									? "sdk guides"
+									: "sdk";
 			const helpCommand =
 				action === "serve"
 					? SdkServeHelp
-					: action === "session"
-						? SdkSessionCommand
-						: action === "guides"
-							? SdkGuidesCommand
-							: Sdk;
+					: action === "search"
+						? SdkSearchCommand
+						: action === "spawn"
+							? SdkSpawnCommand
+							: action === "session"
+								? SdkSessionCommand
+								: action === "guides"
+									? SdkGuidesCommand
+									: Sdk;
 			renderCommandHelp("gjc", helpAction, helpCommand);
 			return;
 		}
+		if (action === "search") {
+			await new SdkSearchCommand(this.argv.slice(1), this.config).run();
+			return;
+		}
+		if (action === "spawn") {
+			await new SdkSpawnCommand(this.argv.slice(1), this.config).run();
+			return;
+		}
 		if (action === "session") {
 			await new SdkSessionCommand(this.argv.slice(1), this.config).run();
 			return;
@@ -976,7 +1080,7 @@ export default class Sdk extends Command {
 			return;
 		}
 		if (action !== "broker-internal" && action !== "session-host-internal")
-			throw new CliParseError("Expected action to be serve, session, or guides.");
+			throw new CliParseError("Expected action to be serve, search, spawn, session, or guides.");
 		const internal = parseSdkInternalArgv(this.argv);
 		if (internal.action === "session-host-internal") {
 			await runSessionHost();
@@ -985,6 +1089,9 @@ export default class Sdk extends Command {
 		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 });
 				try {

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

@@ -360,8 +360,19 @@ export const TIER_MAP_SKIP_LIST = {
 	"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-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",
+	},
+	"opencode-go/glm-5.3-flash": { rationale: "post-rebase catalog addition from dev; not yet curated" },
 	"opencode-go/gpt-5.6-luna": { rationale: "post-rebase catalog addition from dev; not yet curated" },
+	"opencode-go/grok-4.6": { rationale: "post-rebase catalog addition from dev; not yet curated" },
 	"opencode-go/hy3": { rationale: "post-rebase catalog addition from dev; not yet curated" },
+	"opencode-go/hy4-preview": { rationale: "post-rebase catalog addition from dev; not yet curated" },
+	"opencode-go/longcat-2.0": { rationale: "post-rebase catalog addition from dev; not yet curated" },
+	"opencode-go/muse-spark-1.2-contributor": {
+		rationale: "post-rebase catalog addition from dev; not yet curated",
+	},
+	"opencode-go/qwen3.8-flash": { rationale: "post-rebase catalog addition from dev; not yet curated" },
 	"opencode-go/qwen3.8-max": { rationale: "post-rebase catalog addition from dev; not yet curated" },
 	"opencode-zen/grok-4.6": { rationale: "post-rebase catalog addition from dev; not yet curated" },
 	"opencode-zen/hy3-free": { rationale: "post-rebase catalog addition from dev; not yet curated" },
@@ -923,6 +934,7 @@ export const TIER_MAP_SKIP_LIST = {
 	"anthropic/claude-3-5-sonnet-20241022": { baseline: true, rationale: "pre-feature baseline; not yet curated" },
 	"anthropic/claude-3-haiku-20240307": { baseline: true, rationale: "pre-feature baseline; not yet curated" },
 	"anthropic/claude-fable-5": { baseline: true, rationale: "pre-feature baseline; not yet curated" },
+	"anthropic/claude-fable-5-1": { rationale: "post-feature catalog addition; not yet curated" },
 	"anthropic/claude-haiku-4-5-20251001": { baseline: true, rationale: "pre-feature baseline; not yet curated" },
 	"anthropic/claude-opus-4-0": { baseline: true, rationale: "pre-feature baseline; not yet curated" },
 	"anthropic/claude-opus-4-1": { baseline: true, rationale: "pre-feature baseline; not yet curated" },