@gajae-code/coding-agent 0.14.2 → 0.15.0

package/src/autoresearch/types.ts

@@ -1,7 +1,12 @@
-import type { AgentToolResult } from "@gajae-code/agent-core";
-import type { ExtensionAPI, ExtensionContext } from "../extensibility/extensions";
-import type { SessionEntry } from "../session/session-manager";
-import type { TruncationResult } from "../session/streaming-output";
+/**
+ * Shared types for the rebuilt autoresearch capability modules.
+ *
+ * These mirror the deleted extension's `types.ts` surface (metrics, ASI,
+ * experiment statuses) without the extension-only runtime types (dashboards,
+ * tool factories, session entries). The mission/verdict/ledger types live in
+ * `gjc-runtime/autoresearch-runtime.ts`; run storage and dashboard models live
+ * in `runs.ts` / `dashboard.ts`.
+ */
 
 export type MetricDirection = "lower" | "higher";
 export type ExperimentStatus = "keep" | "discard" | "crash" | "checks_failed";
@@ -20,149 +25,3 @@ export interface MetricDef {
 	name: string;
 	unit: string;
 }
-
-export interface ExperimentResult {
-	runNumber: number | null;
-	commit: string;
-	metric: number;
-	metrics: NumericMetricMap;
-	status: ExperimentStatus;
-	description: string;
-	timestamp: number;
-	segment: number;
-	confidence: number | null;
-	asi?: ASIData;
-	modifiedPaths: string[];
-	scopeDeviations: string[];
-	justification: string | null;
-	flagged: boolean;
-	flaggedReason: string | null;
-}
-
-export interface ExperimentState {
-	results: ExperimentResult[];
-	bestMetric: number | null;
-	bestDirection: MetricDirection;
-	metricName: string;
-	metricUnit: string;
-	secondaryMetrics: MetricDef[];
-	name: string | null;
-	goal: string | null;
-	currentSegment: number;
-	maxExperiments: number | null;
-	confidence: number | null;
-	scopePaths: string[];
-	offLimits: string[];
-	constraints: string[];
-	notes: string;
-	branch: string | null;
-	baselineCommit: string | null;
-	sessionId: number | null;
-}
-
-export interface RunExperimentProgressDetails {
-	phase: "running";
-	elapsed: string;
-	truncation?: TruncationResult;
-	fullOutputPath?: string;
-	runDirectory?: string;
-}
-
-export interface RunDetails {
-	runNumber: number;
-	runDirectory: string;
-	benchmarkLogPath: string;
-	command: string;
-	exitCode: number | null;
-	durationSeconds: number;
-	passed: boolean;
-	crashed: boolean;
-	timedOut: boolean;
-	tailOutput: string;
-	parsedMetrics: NumericMetricMap | null;
-	parsedPrimary: number | null;
-	parsedAsi: ASIData | null;
-	metricName: string;
-	metricUnit: string;
-	preRunDirtyPaths: string[];
-	abandonedPriorRun: number | null;
-	truncation?: TruncationResult;
-	fullOutputPath?: string;
-}
-
-export interface LogDetails {
-	experiment: ExperimentResult;
-	state: ExperimentState;
-	wallClockSeconds: number | null;
-	scopeDeviations: string[];
-	justification: string | null;
-	flaggedRuns: Array<{ runId: number; reason: string }>;
-}
-
-export interface PendingRunSummary {
-	command: string;
-	durationSeconds: number | null;
-	parsedAsi: ASIData | null;
-	parsedMetrics: NumericMetricMap | null;
-	parsedPrimary: number | null;
-	passed: boolean;
-	preRunDirtyPaths: string[];
-	runDirectory: string;
-	runNumber: number;
-	exitCode: number | null;
-	timedOut: boolean;
-}
-
-export interface RunningExperiment {
-	startedAt: number;
-	command: string;
-	runDirectory: string;
-	runNumber: number;
-}
-
-export interface AutoresearchRuntime {
-	autoresearchMode: boolean;
-	autoResumeArmed: boolean;
-	dashboardExpanded: boolean;
-	lastAutoResumePendingRunNumber: number | null;
-	lastRunDuration: number | null;
-	lastRunAsi: ASIData | null;
-	lastRunArtifactDir: string | null;
-	lastRunNumber: number | null;
-	lastRunSummary: PendingRunSummary | null;
-	runningExperiment: RunningExperiment | null;
-	state: ExperimentState;
-	goal: string | null;
-}
-
-export interface AutoresearchControlEntryData {
-	mode: "on" | "off" | "clear";
-	goal?: string;
-}
-
-export interface ReconstructedControlState {
-	autoresearchMode: boolean;
-	goal: string | null;
-	lastMode: AutoresearchControlEntryData["mode"] | null;
-}
-
-export interface RuntimeStore {
-	clear(sessionKey: string): void;
-	ensure(sessionKey: string): AutoresearchRuntime;
-}
-
-export interface DashboardController {
-	clear(ctx: ExtensionContext): void;
-	requestRender(): void;
-	showOverlay(ctx: ExtensionContext, runtime: AutoresearchRuntime): Promise<void>;
-	updateWidget(ctx: ExtensionContext, runtime: AutoresearchRuntime): void;
-}
-
-export interface AutoresearchToolFactoryOptions {
-	dashboard: DashboardController;
-	getRuntime(ctx: ExtensionContext): AutoresearchRuntime;
-	pi: ExtensionAPI;
-}
-
-export type AutoresearchToolResult<TDetails> = AgentToolResult<TDetails>;
-export type SessionEntries = SessionEntry[];

package/src/capability/index.ts

@@ -6,9 +6,8 @@
  * - Registering providers (where to find it)
  * - Loading items for a capability across all providers
  */
-import * as os from "node:os";
 import * as path from "node:path";
-import { getProjectDir, logger } from "@gajae-code/utils";
+import { getAgentDir, getProjectDir, getTrustedHomeDir, logger } from "@gajae-code/utils";
 
 import type { Settings } from "../config/settings";
 import { clearCache as clearFsCache, findRepoRoot, cacheStats as fsCacheStats, invalidate as invalidateFs } from "./fs";
@@ -237,9 +236,10 @@ export async function loadCapability<T>(capabilityId: string, options: LoadOptio
 	}
 
 	const cwd = options.cwd ?? getProjectDir();
-	const home = os.homedir();
+	const home = getTrustedHomeDir();
+	const userAgentDir = options.agentDir ? path.resolve(options.agentDir) : getAgentDir();
 	const repoRoot = await findRepoRoot(cwd);
-	const ctx: LoadContext = { cwd, home, repoRoot };
+	const ctx: LoadContext = { cwd, home, userAgentDir, repoRoot };
 	const providers = filterProviders(capability, options);
 
 	return await loadImpl(capability, providers, ctx, options);

package/src/capability/types.ts

@@ -15,6 +15,20 @@ export interface LoadContext {
 	cwd: string;
 	/** User home directory */
 	home: string;
+	/**
+	 * GJC's user-scope config directory: the resolved agent directory
+	 * (`getAgentDir()`), which `--agent-dir`, `GJC_CODING_AGENT_DIR` and
+	 * `setAgentDir()` redirect away from `<home>/.gjc/agent`. `loadCapability`
+	 * always sets it; ad-hoc contexts built for path scanning may omit it, and
+	 * consumers then fall back to the same process-wide `getAgentDir()`.
+	 *
+	 * A native surface whose write path targets the agent directory resolves its
+	 * user scope from here, or discovery reads a different file than the one the
+	 * writer produced: `gjc mcp add` (user scope) writes `getMCPConfigPath("user")`
+	 * under this directory. Surfaces whose writers are home-relative (skills) keep
+	 * resolving from `home`.
+	 */
+	userAgentDir?: string;
 	/** Git repository root (directory containing .git), or null if not in a repo */
 	repoRoot: string | null;
 }
@@ -67,6 +81,12 @@ export interface LoadOptions {
 	excludeProviders?: string[];
 	/** Custom cwd. Default: getProjectDir() */
 	cwd?: string;
+	/**
+	 * Agent directory backing `LoadContext.userAgentDir`. Default: getAgentDir().
+	 * Set it when loading for a session whose agent directory differs from the
+	 * process-wide one (`createAgentSession({ agentDir })`).
+	 */
+	agentDir?: string;
 	/** Include items even if they fail validation. Default: false */
 	includeInvalid?: boolean;
 	/** Include items disabled via settings. Default: false */

package/src/cli/accounts-cli.ts

@@ -10,6 +10,8 @@ import {
 	type AuthStorage,
 	type CredentialInventoryRecord,
 	type CredentialRemovalTarget,
+	OAuthCredentialSelectorError,
+	type OAuthPinTarget,
 	resolveOAuthStorageProvider,
 } from "@gajae-code/ai/core";
 import { getAgentDir } from "@gajae-code/utils";
@@ -45,6 +47,10 @@ class AccountsCommandError extends Error {
 		this.name = "AccountsCommandError";
 	}
 }
+export function toAccountsCommandError(error: unknown): AccountsCommandError | undefined {
+	if (error instanceof OAuthCredentialSelectorError) return new AccountsCommandError(error.message);
+	return undefined;
+}
 
 function writeJson(value: unknown): void {
 	process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
@@ -264,7 +270,12 @@ async function runPin(
 		) {
 			throw new AccountsCommandError(`Provider ${provider} is not configured; no pin was written.`);
 		}
-		const target = storage.resolveOAuthPinTarget(provider, selector);
+		let target: OAuthPinTarget;
+		try {
+			target = storage.resolveOAuthPinTarget(provider, selector);
+		} catch (error) {
+			throw toAccountsCommandError(error) ?? error;
+		}
 		const canonicalSelector = `${target.canonicalSelector.kind}:${target.canonicalSelector.value}`;
 		await writePersistentPin(provider, canonicalSelector, false, startupAuth.credentialStoreIdentity);
 		if (flags.json) writeJson({ ok: true, provider, selector: canonicalSelector });
@@ -276,6 +287,7 @@ function accountMatches(row: CredentialInventoryRecord, rawAccount: string): boo
 	const value = rawAccount.trim();
 	if (value.length === 0) return false;
 	if (/^[1-9]\d*$/.test(value) && row.id === Number(value)) return true;
+	if (/^id:[1-9]\d*$/i.test(value) && row.id === Number(value.slice(3))) return true;
 	const identity = inventoryIdentity(row);
 	return identity?.toLowerCase() === value.toLowerCase();
 }
@@ -286,7 +298,6 @@ function removalCandidates(
 ): Array<{ row: CredentialInventoryRecord; target: CredentialRemovalTarget }> {
 	const targetById = new Map(targets.map(target => [target.id, target]));
 	return inventory
-		.filter(row => row.credentialKind === "oauth")
 		.map(row => ({ row, target: targetById.get(row.id) }))
 		.filter((entry): entry is { row: CredentialInventoryRecord; target: CredentialRemovalTarget } => !!entry.target);
 }
@@ -299,10 +310,10 @@ function throwLogoutResolutionError(
 	const lines =
 		candidates.length > 0
 			? ["Safe candidates:", ...candidates.map(candidate => formatCandidate(candidate.row))]
-			: ["No OAuth account candidates found."];
+			: ["No removable credentials found."];
 	const prefix = account
 		? `Account ${JSON.stringify(account)} for ${provider} was missing or ambiguous.`
-		: `No removable OAuth accounts found for ${provider}.`;
+		: `No removable stored credentials found for ${provider}.`;
 	throw new AccountsCommandError(`${prefix} No credentials were removed.\n${lines.join("\n")}`);
 }
 
@@ -340,7 +351,7 @@ async function runLogout(providerArg: string | undefined, flags: AccountsCommand
 		if (flags.json) writeJson({ ok: true, provider, removedIds: [...result.ids] });
 		else
 			writeText([
-				`Removed ${result.ids.length} OAuth account${result.ids.length === 1 ? "" : "s"} from ${provider}.`,
+				`Removed ${result.ids.length} stored credential${result.ids.length === 1 ? "" : "s"} from ${provider}.`,
 			]);
 	} finally {
 		storage.close();
@@ -388,6 +399,11 @@ export async function runAccountsCommand(cmd: AccountsCommandArgs): Promise<void
 			writeJsonFailure(error);
 			return;
 		}
+		if (error instanceof AccountsCommandError) {
+			process.stderr.write(`${error.message}\n`);
+			process.exitCode = 1;
+			return;
+		}
 		throw error;
 	}
 }

package/src/cli/config-cli.ts

@@ -11,6 +11,11 @@ import { APP_NAME, getAgentDir } from "@gajae-code/utils";
 import { YAML } from "bun";
 import chalk from "chalk";
 import { AtomicYamlReplaceError, AtomicYamlRetargetError } from "../config/atomic-yaml-patch";
+import {
+	validateAutoroutingLocal,
+	validateAutoroutingProvenance,
+	validateAutoroutingSetup,
+} from "../config/autorouting-contract";
 import { resolveModelProfileName } from "../config/model-profile-contract";
 import { mergeModelProfiles } from "../config/model-profiles";
 import { ModelsConfigFile } from "../config/model-registry";
@@ -208,7 +213,10 @@ function getTypeDisplay(def: CliSettingDef): string {
 		case "array":
 			return "(array)";
 		case "record":
+		case "constrained-record":
 			return "(record)";
+		case "optional-object":
+			return "(object)";
 		default:
 			return "(string)";
 	}
@@ -264,7 +272,9 @@ function parseAndSetValue(path: SettingPath, rawValue: string): void {
 			parsedValue = parsed;
 			break;
 		}
-		case "record": {
+		case "record":
+		case "constrained-record":
+		case "optional-object": {
 			let parsed: unknown;
 			try {
 				parsed = JSON.parse(trimmed);
@@ -280,6 +290,17 @@ function parseAndSetValue(path: SettingPath, rawValue: string): void {
 		default:
 			parsedValue = trimmed;
 	}
+	const issues =
+		path === "task.autorouting.tiers"
+			? validateAutoroutingLocal({ tiers: parsedValue })
+			: path === "task.autorouting.setup"
+				? validateAutoroutingSetup(parsedValue)
+				: path === "task.autorouting.provenance"
+					? validateAutoroutingProvenance(parsedValue)
+					: [];
+	if (issues.length > 0) {
+		throw new Error(`Invalid value for ${path}: ${issues.map(issue => `${issue.path}: ${issue.detail}`).join("; ")}`);
+	}
 
 	settings.set(path, parsedValue as SettingValue<typeof path>);
 }
@@ -581,6 +602,9 @@ function matchesSettingType(path: SettingPath, value: unknown): boolean {
 		case "array":
 			return Array.isArray(value);
 		case "record":
+		case "constrained-record":
+			return value !== null && typeof value === "object" && !Array.isArray(value);
+		case "optional-object":
 			return value !== null && typeof value === "object" && !Array.isArray(value);
 	}
 }

package/src/cli/fast-help.ts

@@ -12,9 +12,9 @@ export function getExtraHelpText(): string {
   ${APP_NAME} auth-gateway        - Run an auth-gateway forward proxy
   ${APP_NAME} harness              - Run harness control-plane commands
   ${APP_NAME} coordinator          - Manage coordinator/runtime coordination helpers
-  ${APP_NAME} team                 - Run tmux-backed coordinated execution
   ${APP_NAME} ultragoal            - Run durable goal execution workflow
   ${APP_NAME} ralplan              - Run consensus planning workflow
+  ${APP_NAME} autoresearch         - Run autonomous research workflow
   ${APP_NAME} deep-interview       - Run requirements interview workflow
   ${APP_NAME} skills               - List/read embedded workflow skills
   ${APP_NAME} config               - List, get, and set configuration values
@@ -25,7 +25,6 @@ export function getExtraHelpText(): string {
   ${APP_NAME} mcp-serve            - Serve the MCP integration endpoint
   ${APP_NAME} contribute-pr        - Prepare contribution/PR workflow artifacts
   ${APP_NAME} migrate              - Run migration helpers
-  ${APP_NAME} rlm                  - Run RLM helpers
   ${APP_NAME} update               - Update GJC installation artifacts
   ${APP_NAME} plugin               - Install, remove, and list plugins
   ${APP_NAME} web-search           - Search the web from the CLI (alias: q)

package/src/cli/list-models.ts

@@ -69,17 +69,14 @@ export async function listModels(modelRegistry: ModelRegistry, searchPattern?: s
 	}
 
 	const filteredCanonical = modelRegistry
-		.getCanonicalModels({ availableOnly: true, candidates: filteredModels })
-		.map(record => {
-			const selected = modelRegistry.resolveCanonicalModel(record.id, {
-				availableOnly: true,
-				candidates: filteredModels,
-			});
+		.getCanonicalModelSelections({ availableOnly: true, candidates: filteredModels })
+		.map(selection => {
+			const selected = selection.model;
 			if (!selected) return undefined;
 			return {
-				canonical: record.id,
+				canonical: selection.record.id,
 				selected: `${selected.provider}/${selected.id}`,
-				variants: String(record.variants.length),
+				variants: String(selection.record.variants.length),
 				context: formatNumber(selected.contextWindow),
 				maxOut: formatNumber(selected.maxTokens),
 			} satisfies CanonicalRow;

package/src/cli/setup-cli.ts

@@ -596,6 +596,14 @@ async function handleDefaultsSetup(flags: { json?: boolean; check?: boolean; for
 	console.log(chalk.dim(`Target: ${result.targetRoot}`));
 	console.log(chalk.dim(`Written: ${result.written}; skipped: ${result.skipped}`));
 	console.log(chalk.dim(inspectGuidance));
+	const quarantined = result.retired.filter(entry => entry.status === "quarantined");
+	for (const entry of quarantined) {
+		console.log(
+			chalk.dim(
+				`Retired: \`${entry.name}\` is no longer a bundled workflow skill; moved to ${entry.quarantinedTo} so it is no longer discoverable.`,
+			),
+		);
+	}
 	if (result.skipped > 0 && !flags.force) {
 		console.log(
 			chalk.dim(

package/src/cli.ts

@@ -42,10 +42,10 @@ export const commands: CommandEntry[] = [
 	{ name: "accounts", load: () => import("./commands/accounts").then(m => m.default) },
 	{ name: "harness", load: () => import("./commands/harness").then(m => m.default) },
 	{ name: "coordinator", load: () => import("./commands/coordinator").then(m => m.default) },
-	{ name: "team", load: () => import("./commands/team").then(m => m.default) },
 	{ name: "ultragoal", load: () => import("./commands/ultragoal").then(m => m.default) },
 	{ name: "gc", load: () => import("./commands/gc").then(m => m.default) },
 	{ name: "crash", load: () => import("./commands/crash").then(m => m.default) },
+	{ name: "autoresearch", load: () => import("./commands/autoresearch").then(m => m.default) },
 	{ name: "ralplan", load: () => import("./commands/ralplan").then(m => m.default) },
 	{ name: "config", load: () => import("./commands/config").then(m => m.default) },
 	{ name: "stats", load: () => import("./commands/stats").then(m => m.default) },
@@ -63,7 +63,6 @@ export const commands: CommandEntry[] = [
 	},
 	{ name: "deep-interview", load: () => import("./commands/deep-interview").then(m => m.default) },
 	{ name: "migrate", load: () => import("./commands/migrate").then(m => m.default) },
-	{ name: "rlm", load: () => import("./commands/rlm").then(m => m.default) },
 	{ name: "update", load: () => import("./commands/update").then(m => m.default) },
 	{ name: "read", load: () => import("./commands/read").then(m => m.default) },
 	{ name: "customize", load: () => import("./commands/customize").then(m => m.default) },
@@ -350,25 +349,7 @@ export function normalizeResumeAlias(argv: readonly string[]): string[] {
 
 function routeLegacyRootArgv(argv: readonly string[]): string[] | undefined {
 	if (argv[0] === "coordinator-mcp") return ["mcp-serve", "coordinator", ...argv.slice(1)];
-	if (argv[0] !== "--team") return undefined;
-	const sizeValues: string[] = [];
-	const remaining: string[] = [];
-	for (let index = 1; index < argv.length; index++) {
-		const arg = argv[index] ?? "";
-		if (arg === "--team-size") {
-			sizeValues.push(argv[index + 1] ?? "");
-			index++;
-		} else if (arg.startsWith("--team-size=")) {
-			sizeValues.push(arg.slice("--team-size=".length));
-		} else {
-			remaining.push(arg);
-		}
-	}
-	const size = sizeValues[0];
-	if (sizeValues.length !== 1 || !size || !/^[1-9]\d*$/.test(size)) {
-		return ["team", "0", "invalid legacy --team-size"];
-	}
-	return ["team", size, ...remaining];
+	return undefined;
 }
 
 /**

package/src/commands/autoresearch.ts

@@ -0,0 +1,33 @@
+import { Command, renderCommandHelp } from "@gajae-code/utils/cli";
+import { ensureWorkflowSettingsMigrated } from "../config/settings";
+import { runNativeAutoresearchCommand } from "../gjc-runtime/autoresearch-runtime";
+
+export default class Autoresearch extends Command {
+	static description = "Run native GJC Autoresearch workflow commands";
+	static strict = false;
+	static examples = [
+		"$ gjc autoresearch intake --spec <deep-interview-spec.md> --json",
+		"$ gjc autoresearch --spec <deep-interview-spec.md> --json",
+		'$ gjc autoresearch "<goal>"',
+		"$ gjc autoresearch",
+		"$ gjc autoresearch read --json",
+		"$ gjc autoresearch clear --json",
+		"$ gjc autoresearch write --goal <goal> --mode web --slug <slug> --json",
+	];
+	static delegateHelp = true;
+
+	async run(): Promise<void> {
+		// A read-only help request must not perform the workflow-settings
+		// migration (which can create/drain agent.db, write config.yml, and
+		// retire legacy settings.json): render help before the trigger.
+		if (this.argv.includes("--help") || this.argv.includes("-h")) {
+			renderCommandHelp("gjc", "autoresearch", Autoresearch);
+			return;
+		}
+		await ensureWorkflowSettingsMigrated(process.cwd());
+		const result = await runNativeAutoresearchCommand(this.argv, process.cwd());
+		if (result.stdout) process.stdout.write(result.stdout);
+		if (result.stderr) process.stderr.write(result.stderr);
+		process.exitCode = result.status;
+	}
+}

package/src/commands/coordinator.ts

@@ -4,6 +4,7 @@ import {
 	COORDINATOR_MCP_SERVER_NAME,
 	COORDINATOR_MCP_TOOL_NAMES,
 } from "../coordinator/contract";
+import { parseEventWebhookConfig } from "../coordinator-mcp/event-webhook";
 import { buildCoordinatorMcpConfig } from "../coordinator-mcp/policy";
 
 function writeJson(value: unknown): void {
@@ -54,6 +55,20 @@ function coordinatorDoctorPayload(): {
 		status: config.namespace.profile && config.namespace.repo ? "pass" : "warn",
 		detail: `profile=${config.namespace.profile ?? "<unset>"} repo=${config.namespace.repo ?? "<unset>"}`,
 	});
+	let eventWebhookStatus: "pass" | "fail" = "pass";
+	let eventWebhookDetail = "unset; coordinator behavior unchanged";
+	try {
+		const parsed = parseEventWebhookConfig();
+		if (parsed) {
+			eventWebhookDetail = `opt-in webhook delivery enabled for ${parsed.url}${
+				parsed.sessionIds ? ` scoped to ${parsed.sessionIds.size} session(s)` : ""
+			}`;
+		}
+	} catch (error) {
+		eventWebhookStatus = "fail";
+		eventWebhookDetail = error instanceof Error ? error.message : "coordinator_event_webhook_invalid";
+	}
+	checks.push({ id: "event_webhook", status: eventWebhookStatus, detail: eventWebhookDetail });
 	return { ok: checks.every(check => check.status !== "fail"), checks };
 }
 

package/src/commands/launch.ts

@@ -2,12 +2,11 @@
  * Root command for the coding agent CLI.
  */
 
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
 import { APP_NAME, 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 {
@@ -54,8 +53,7 @@ export async function persistCoordinatorLaunchFailure(
 			? { owner_generation: env[GJC_TMUX_OWNER_GENERATION_ENV] ?? null }
 			: {}),
 	};
-	await fs.mkdir(path.dirname(stateFile), { recursive: true });
-	await Bun.write(stateFile, `${JSON.stringify(payload, null, 2)}\n`);
+	await writeCoordinatorAtomic(stateFile, `${JSON.stringify(payload, null, 2)}\n`);
 }
 
 export default class Index extends Command {

package/src/commands/quick-lane.ts

@@ -26,7 +26,7 @@ export default class QuickLane extends Command {
 	static examples = [
 		`$ gjc quick-lane classify "add validation to processKeywordDetector"`,
 		`$ gjc quick-lane classify --json "fix src/hooks/bridge.ts"`,
-		`$ gjc quick-lane classify "team make it better"`,
+		`$ gjc quick-lane classify "autoresearch the caching layer"`,
 	];
 
 	async run(): Promise<void> {

package/src/commands/sdk.ts

@@ -5,6 +5,7 @@ import * as path from "node:path";
 import { logger } from "@gajae-code/utils";
 import { Args, CliParseError, Command, Flags, renderCommandHelp } from "@gajae-code/utils/cli";
 import type { Args as ParsedArgs } from "../cli/args";
+import { parseModelString } from "../config/model-resolver";
 import { Settings } from "../config/settings";
 import { applyStartupModelProfiles, createSessionManager } from "../main";
 import { initializeExtensions } from "../modes/runtime-init";
@@ -56,8 +57,16 @@ export async function lifecycleArgs(
 		messages: [],
 		fileArgs: [],
 		unknownFlags: new Map(),
+		...(process.env.GJC_SDK_TEST_IN_MEMORY_SESSION === "1" ? { noSession: true } : {}),
 		...(request.operation === "session.resume" ? { resume: request.sessionPath } : {}),
 		...(request.modelPreset ? { mpreset: request.modelPreset } : {}),
+		// Explicit model pin (#4707): coordinator-resolved `provider/model`
+		// selector applied exactly like CLI `--model`. createAgentSession
+		// resolves it through the same staged selector resolver, and startup
+		// model-profile application then overrides the activated profile with
+		// this explicit selection (main.ts applyStartupModelProfilesWithPolicy),
+		// matching `gjc --mpreset p --model m` precedence.
+		...(request.modelId ? { model: request.modelId } : {}),
 		...(request.operation === "session.fork"
 			? {
 					fork: request.sourceSessionPath ?? request.sourceSessionId,
@@ -554,6 +563,7 @@ export async function runSessionHost(
 				...(mcpConfigPath ? { mcpConfigPath } : {}),
 				...(mcpStartupTimeoutMs !== undefined ? { mcpStartupTimeoutMs } : {}),
 				...(request.readiness ? { readiness: request.readiness } : {}),
+				...(request.modelId ? { modelId: request.modelId } : {}),
 			});
 		} catch (error) {
 			throw await registrationFailure(error);
@@ -674,6 +684,7 @@ export async function runSessionHost(
 	};
 
 	try {
+		const startupThinkingLevel = request.modelId ? parseModelString(request.modelId)?.thinkingLevel : undefined;
 		const modelProfileStartup =
 			process.env.GJC_SDK_TEST_HANG_MODEL_PROFILE === cwd
 				? new Promise<void>(() => {})
@@ -682,6 +693,7 @@ export async function runSessionHost(
 						settings: session.settings,
 						modelRegistry: session.modelRegistry,
 						parsedArgs: parsed,
+						startupThinkingLevel,
 					});
 		await beforeCutoff(modelProfileStartup);
 		throwIfCutoff();
@@ -720,6 +732,18 @@ export async function runSessionHost(
 	// Readiness is published; the session is live. Memory startup issues one LLM
 	// request per queued rollout, so it must run outside the readiness window and
 	// its failure must never take the session down.
+	if (process.env.GJC_SDK_TEST_EXIT_AFTER_READY === cwd) {
+		process.stderr.write("GJC_SDK_TEST_EXIT_AFTER_READY\n");
+		process.exit(7);
+	}
+	if (process.env.GJC_SDK_TEST_REJECT_AFTER_READY === cwd) {
+		// Simulates the post-readiness liveness watcher rejecting. With the
+		// post-ready startup receipt removed, this unhandled rejection kills the
+		// host without writing any startup receipt; the broker must classify the
+		// death from published ready authority plus proven exit.
+		void Promise.reject(new Error("GJC_SDK_TEST_REJECT_AFTER_READY"));
+		await Bun.sleep(5_000);
+	}
 	startMemoryBackendAfterReadiness(startDeferredMemoryBackend);
 	process.once("SIGTERM", stop);
 	process.once("SIGINT", stop);

package/src/commands/state.ts

@@ -11,7 +11,7 @@ export default class State extends Command {
 		"$ gjc state clear --mode deep-interview",
 		"$ gjc state deep-interview read --json",
 		'$ gjc state ralplan write --input \'{"phase":"planner","active":true}\' --json',
-		"$ gjc state team contract",
+		"$ gjc state autoresearch contract",
 		"$ gjc state deep-interview handoff --to ralplan --json",
 		"$ gjc state doctor --skill ralplan --json",
 	];