@gajae-code/coding-agent 0.18.12 → 0.19.0

package/scripts/acp-conformance-agent.ts

@@ -102,21 +102,31 @@ server = Bun.serve({
 		if (prompt.includes("sleep")) {
 			const requested = Number(/\bsleep\s+(\d+)/.exec(prompt)?.[1] ?? 0);
 			const delay = Math.min(Math.max(requested, 0), 30_000);
+			let closed = false;
+			let close = (): void => {};
 			const stream = new ReadableStream<Uint8Array>({
 				start(controller) {
-					let closed = false;
-					const close = () => {
+					close = () => {
 						if (closed) return;
 						closed = true;
+						request.signal.removeEventListener("abort", close);
 						controller.close();
 					};
 					request.signal.addEventListener("abort", close, { once: true });
+					// The body parse above may yield long enough for the client to abort before
+					// this response stream installs its listener. Signals do not replay abort
+					// events to late listeners, so close immediately when that already happened.
+					if (request.signal.aborted) close();
 					void Bun.sleep(delay).then(() => {
 						if (closed) return;
 						controller.enqueue(new TextEncoder().encode(textCompletion("slept")));
 						close();
 					});
 				},
+				cancel() {
+					closed = true;
+					request.signal.removeEventListener("abort", close);
+				},
 			});
 			return new Response(stream, { headers: { "content-type": "text/event-stream" } });
 		}

package/scripts/generate-sdk-operation-inventory.ts

@@ -27,6 +27,10 @@ const LOCKED_EXCLUSIONS: Readonly<Record<string, string>> = {
 		"internal read-only run-resource-ledger view, threaded via terminalAbortSeams so the prompt deadline can find a tool-call boundary; not a user-facing SDK control seam",
 	"agent_session:markProfileRoleOverrideManual":
 		"internal profile role-layer ownership tracking after explicit user assignments; not a user-facing SDK control seam",
+	"agent_session:notifySessionIdentityChanged":
+		"internal session-identity listener fan-out for in-process session surfaces; not a user-facing SDK control seam",
+	"agent_session:subscribeSessionIdentityChanges":
+		"internal session-identity subscription used by in-process adapters to follow session replacement; not a user-facing SDK control seam",
 	"slash_command:routing":
 		"visual/local-only autorouting settings toggle and smart-routing panel entry, not a user-facing SDK control seam",
 	"slash_command:mcp":
@@ -85,6 +89,8 @@ const LOCKED_EXCLUSIONS: Readonly<Record<string, string>> = {
 		"internal session-scoped startup-profile recovery marker, not a user-facing SDK control seam",
 	"agent_session:getUnavailableModelProfile":
 		"internal session-scoped startup-profile recovery status for UI rendering, not a public SDK operation",
+	"agent_session:getActivatedModelProfile":
+		"internal model-profile activation provenance used to gate role-only materialization, not a user-facing SDK control seam",
 	"agent_session:getConfigurationPaths":
 		"internal config hot-reload path identity projection, not a user-facing SDK control seam",
 	"agent_session:validateConfiguration":
@@ -121,6 +127,8 @@ const LOCKED_EXCLUSIONS: Readonly<Record<string, string>> = {
 		"internal tool-selection predicate used to preserve the --no-tools boundary, not a user-facing SDK control seam",
 	"agent_session:getEffectiveActiveWorkflowSkillState":
 		"internal restored-or-live workflow guard for session rescope, not a user-facing SDK control seam",
+	"agent_session:refreshEffectiveActiveWorkflowSkillState":
+		"internal durable workflow identity refresh before session safety checks, not an independent public SDK operation",
 	"agent_session:replaceOwnedMcpManager":
 		"internal cwd-rebinding helper for owned MCP authority after move_session, not a user-facing SDK control seam",
 	"agent_session:replaceNamedCustomTools":
@@ -159,6 +167,8 @@ const LOCKED_EXCLUSIONS: Readonly<Record<string, string>> = {
 		"test-only parked terminal persistence seam, not a user-facing SDK control seam",
 	"agent_session:flushParkedAgentEndForCoordinatorPersistForTests":
 		"test-only parked terminal flush seam, not a user-facing SDK control seam",
+	"agent_session:waitForAgentEndHandlingForTests":
+		"test-only SDK terminal-event handler completion barrier, not a user-facing SDK control seam",
 	"agent_session:setCancelAndSubmitAbortOutcomeProviderForTests":
 		"test-only cancellation seam, not a user-facing SDK control seam",
 	"agent_session:awaitDisposeCompletion": "test-only disposal completion seam, not a user-facing SDK control seam",
@@ -193,6 +203,12 @@ const LOCKED_EXCLUSIONS: Readonly<Record<string, string>> = {
 	"agent_session:onJobFold": "internal fold-event plumbing feeding the bash_folded event frame, not a control seam",
 
 	"agent_session:getSelectedMCPToolNames": "internal accessor/plumbing, not a user-facing control seam",
+	"agent_session:getActiveMCPToolNames":
+		"internal MCP bridge subset used by mode controllers to preserve live selections across tool swaps; not a user-facing SDK control seam",
+	"agent_session:hasMCPToolSelectionAuthority":
+		"internal MCP-selection authority predicate used by catalog and mode-transition reconciliation; not a user-facing SDK control seam",
+	"agent_session:hasCommittedMCPToolSelectionAuthority":
+		"internal committed MCP-selection authority predicate used by catalog reconciliation; not a user-facing SDK control seam",
 	"agent_session:isToolDiscoveryEnabled": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:getDiscoverableToolSearchIndex": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:getSelectedDiscoveredToolNames": "internal accessor/plumbing, not a user-facing control seam",

package/src/capability/fs.ts

@@ -241,6 +241,28 @@ async function openIsolatedFile(abs: string, options?: ReadFileOptions): Promise
 	}
 }
 
+/**
+ * A lexical path outside the boundary keeps the historical ancestor read.
+ * A path inside the boundary must still be inside after realpath, so a
+ * repository symlink cannot be opened as its external target.
+ */
+async function containedReadPath(abs: string, options?: ReadFileOptions): Promise<string | null> {
+	const root = options?.containmentRoot;
+	if (!root || options?.isolatedHome) return abs;
+	const lexical = path.resolve(abs);
+	const boundary = path.resolve(root);
+	if (!isWithinOrEqual(boundary, lexical)) return lexical;
+	try {
+		const [boundaryReal, targetReal] = await Promise.all([
+			fs.promises.realpath(boundary),
+			fs.promises.realpath(lexical),
+		]);
+		return isWithinOrEqual(boundaryReal, targetReal) ? targetReal : null;
+	} catch {
+		return null;
+	}
+}
+
 export async function readFile(filePath: string, options?: ReadFileOptions): Promise<string | null> {
 	let abs: string | null;
 	try {
@@ -250,13 +272,19 @@ export async function readFile(filePath: string, options?: ReadFileOptions): Pro
 	}
 	if (abs === null) return null;
 	if (!(await isCurrentIsolatedPath(abs, options))) return null;
-	const useCache = !options?.bypassCache && !options?.isolatedHome;
+	// A contained read must not share the lexical cache with a different boundary.
+	const useCache = !options?.bypassCache && !options?.isolatedHome && !options?.containmentRoot;
 	if (useCache && contentCache.has(abs)) {
 		return contentCache.get(abs) ?? null;
 	}
 	if (!options?.isolatedHome) {
+		const readable = await containedReadPath(abs, options);
+		if (readable === null) {
+			if (useCache) contentCache.set(abs, null);
+			return null;
+		}
 		try {
-			const content = await Bun.file(abs).text();
+			const content = await Bun.file(readable).text();
 			if (useCache) contentCache.set(abs, content);
 			return content;
 		} catch {
@@ -460,7 +488,7 @@ export async function findRepoRoot(
 	let current = resolvePath(startDir);
 	const stop = stopAt ? resolvePath(stopAt) : undefined;
 	while (true) {
-		const entries = await readDirEntries(current, options);
+		const entries = await readDirEntries(current, { ...options, bypassCache: true });
 		if (entries.some(e => e.name === ".git")) {
 			return current;
 		}

package/src/capability/rule.ts

@@ -18,6 +18,8 @@ export interface RuleFrontmatter {
 	alwaysApply?: boolean;
 	/** New key for TTSR match conditions. */
 	condition?: string | string[];
+	/** AST-grep pattern(s) for TTSR AST matching (evaluated on completed tool args). */
+	astCondition?: string | string[];
 	/** New key for TTSR stream scope. */
 	scope?: string | string[];
 	/** Per-rule TTSR interrupt mode override. */
@@ -48,6 +50,8 @@ export interface Rule {
 	description?: string;
 	/** Regex condition(s) that can trigger TTSR interruption. */
 	condition?: string[];
+	/** AST-grep pattern(s) for TTSR AST matching (evaluated on completed tool args). */
+	astCondition?: string[];
 	/** Optional stream scope tokens (for example: text, thinking, tool:edit(*.ts)). */
 	scope?: string[];
 	/** Per-rule TTSR interrupt mode override (falls back to global ttsr.interruptMode). */
@@ -182,17 +186,21 @@ function isLikelyFileGlob(value: string): boolean {
 }
 
 /**
- * Parse `condition` + `scope` from rule frontmatter.
+ * Parse `condition`, `astCondition`, and `scope` from rule frontmatter.
  *
  * - `condition` accepts string or string[]
+ * - `astCondition` accepts string or string[] (ast-grep patterns)
  * - `scope` accepts string or string[]
  * - legacy `ttsr_trigger` / `ttsrTrigger` are accepted as a `condition` fallback
  * - condition tokens that look like file globs become scope shorthands:
  *   `*.rs` => `tool:edit(*.rs)`, `tool:write(*.rs)` and a catch-all condition `.*`
  */
-export function parseRuleConditionAndScope(frontmatter: RuleFrontmatter): Pick<Rule, "condition" | "scope"> {
+export function parseRuleConditionAndScope(
+	frontmatter: RuleFrontmatter,
+): Pick<Rule, "condition" | "astCondition" | "scope"> {
 	const rawCondition = frontmatter.condition ?? frontmatter.ttsr_trigger ?? frontmatter.ttsrTrigger;
 	const parsedCondition = normalizeRuleField(rawCondition);
+	const parsedAstCondition = normalizeRuleField(frontmatter.astCondition);
 	const parsedScope = normalizeScopeField(frontmatter.scope);
 
 	const inferredScope: string[] = [];
@@ -214,6 +222,7 @@ export function parseRuleConditionAndScope(frontmatter: RuleFrontmatter): Pick<R
 	const scope = [...(parsedScope ?? []), ...inferredScope];
 	return {
 		condition: condition.length > 0 ? Array.from(new Set(condition)) : undefined,
+		astCondition: parsedAstCondition ? Array.from(new Set(parsedAstCondition)) : undefined,
 		scope: scope.length > 0 ? Array.from(new Set(scope)) : undefined,
 	};
 }

package/src/cli/append-system-prompt.ts

@@ -0,0 +1,12 @@
+export interface AppendSystemPromptCandidate {
+	level: "user" | "project";
+	path: string;
+}
+
+/** First user file. A repository copy is untrusted project text and is never selected. */
+export function selectAppendSystemPromptFile(candidates: readonly AppendSystemPromptCandidate[]): string | undefined {
+	for (const candidate of candidates) {
+		if (candidate.level === "user") return candidate.path;
+	}
+	return undefined;
+}

package/src/cli/args.ts

@@ -3,7 +3,7 @@
  */
 import * as path from "node:path";
 import { ThinkingLevel } from "@gajae-code/agent-core";
-import { logger } from "@gajae-code/utils";
+import { $pickenv, logger } from "@gajae-code/utils";
 import { CliParseError } from "@gajae-code/utils/cli";
 import { parseThinkingLevel } from "../thinking";
 import { BUILTIN_TOOLS } from "../tools";
@@ -46,8 +46,6 @@ export interface Args {
 	allowHome?: boolean;
 	provider?: string;
 	model?: string;
-	smol?: string;
-	slow?: string;
 	plan?: string;
 	mpreset?: string;
 	default?: boolean;
@@ -228,10 +226,6 @@ export function parseArgs(args: string[], authority: ParseArgsAuthority = "local
 			result.provider = takeFlagValue(args, i++, "--provider");
 		} else if (arg === "--model") {
 			result.model = takeFlagValue(args, i++, "--model");
-		} else if (arg === "--smol") {
-			result.smol = takeFlagValue(args, i++, "--smol");
-		} else if (arg === "--slow") {
-			result.slow = takeFlagValue(args, i++, "--slow");
 		} else if (arg === "--plan") {
 			result.plan = takeFlagValue(args, i++, "--plan");
 		} else if (arg === "--mpreset") {
@@ -427,3 +421,13 @@ export function assertLocalLaunchArgs(parsed: Args): void {
 		if (!launchFlagIsOwnedBy(name, "local")) throw new CliParseError(`Unknown option: ${token}`);
 	}
 }
+
+/**
+ * Resolve the ephemeral `plan` model-role override that plan mode switches to.
+ *
+ * Precedence is CLI `--plan` > `GJC_PLAN_MODEL` > legacy `PI_PLAN_MODEL`.
+ * `$pickenv` trims values and treats empty/whitespace as unset.
+ */
+export function resolvePlanModelOverride(parsed: Pick<Args, "plan">): string | undefined {
+	return parsed.plan ?? $pickenv("GJC_PLAN_MODEL", "PI_PLAN_MODEL");
+}

package/src/cli/customize-doctor-precedence.ts

@@ -0,0 +1,31 @@
+export interface DiscoveryPrecedenceCandidate {
+	key: string | undefined;
+	provider: string;
+	scope: "user" | "project" | "native";
+	eligible: boolean;
+	enabled: boolean;
+}
+
+export interface DiscoveryPrecedenceResult {
+	shadowed: boolean;
+	shadowedBy?: { provider: string; scope: DiscoveryPrecedenceCandidate["scope"] };
+}
+
+/** Resolve ordered discovery candidates without allowing ineligible or disabled entries to own keys. */
+export function resolveDiscoveryPrecedence(
+	candidates: readonly DiscoveryPrecedenceCandidate[],
+): DiscoveryPrecedenceResult[] {
+	const winners = new Map<string, { provider: string; scope: DiscoveryPrecedenceCandidate["scope"] }>();
+
+	return candidates.map(candidate => {
+		if (!candidate.eligible || candidate.key === undefined) return { shadowed: false };
+
+		const winner = winners.get(candidate.key);
+		if (winner) return { shadowed: true, shadowedBy: winner };
+
+		if (candidate.enabled) {
+			winners.set(candidate.key, { provider: candidate.provider, scope: candidate.scope });
+		}
+		return { shadowed: false };
+	});
+}

package/src/cli/customize-doctor.ts

@@ -54,6 +54,7 @@ import {
 	isCanonicalGjcWorkflowSkillFilesystemAlias,
 } from "../skill-state/canonical-skills";
 import { expandTilde } from "../tools/path-utils";
+import { resolveDiscoveryPrecedence } from "./customize-doctor-precedence";
 
 // =============================================================================
 // Public types (stable JSON contract)
@@ -67,9 +68,10 @@ export type CustomizeSurfaceKind = "mcp" | "skill" | "hook" | "tool" | "extensio
  *
  * - `canonical`: project/global `.gjc` entries and GJC bundled defaults — the
  *   primary load path and the persisted authority for sessions.
- * - `convention`: items from registered non-native conventions that are part of
- *   the discovery load path (claude-plugins, claude/codex hooks, agents,
- *   cursor, gemini, opencode, windsurf, cline, github, mcp-json, ssh).
+ * - `convention`: items exposed by registered non-native discovery providers
+ *   (claude-plugins, claude/codex hooks, agents, cursor, gemini, opencode,
+ *   windsurf, cline, github, mcp-json, ssh). The item status identifies whether
+ *   a discovered item is active, stored-only, or otherwise excluded at runtime.
  * - `import-candidate`: Claude Code / Codex project (+ global) files on
  *   surfaces GJC deliberately never loads. Reported for provenance only; never
  *   active runtime authority. Candidates for a future import flow (#4291).
@@ -267,7 +269,7 @@ const SOURCE_CLASS_DESCRIPTIONS: Array<{ sourceClass: CustomizeSourceClass; desc
 	{
 		sourceClass: "convention",
 		description:
-			"Items from other registered conventions (claude-plugins, claude/codex hooks, agents, cursor, gemini, opencode, windsurf, cline, github, mcp-json, ssh) that are part of the discovery load path.",
+			"Items exposed by registered convention providers (claude-plugins, claude/codex hooks, agents, cursor, gemini, opencode, windsurf, cline, github, mcp-json, ssh); item status identifies runtime eligibility.",
 	},
 	{
 		sourceClass: "import-candidate",
@@ -394,6 +396,7 @@ async function discoverCapability<T extends { _source: SourceMeta }>(
 		nameOf: (item: T) => string;
 		pathOf: (item: T) => string;
 		extensionIdOf?: (item: T) => string | undefined;
+		precedenceEligible?: (item: T) => boolean;
 	},
 ): Promise<DiscoveredSet<T>> {
 	const disabledProviders = new Set(activeSettings.get("disabledProviders"));
@@ -405,41 +408,34 @@ async function discoverCapability<T extends { _source: SourceMeta }>(
 		includeDisabledProviders: true,
 	});
 
-	// First item per dedup key wins (highest priority provider first in `all`).
-	const winners = new Map<string, { provider: string; scope: "user" | "project" | "native" }>();
-	const entries: DiscoveredEntry<T>[] = [];
-	for (const item of result.all) {
-		const key = capability.key(item);
-		const scope = scopeOf(item._source);
-		let shadowed = (item as { _shadowed?: boolean })._shadowed === true;
-		let shadowedBy: { provider: string; scope: string } | undefined;
-		if (key !== undefined) {
-			const winner = winners.get(key);
-			if (winner) {
-				shadowed = true;
-				shadowedBy = winner;
-			} else if (!disabledProviders.has(item._source.provider)) {
-				// Only enabled providers can own a dedup key; a disabled
-				// higher-priority provider must never shadow an enabled
-				// lower-priority source (includeDisabledProviders reports it
-				// as a listed item without giving it effective precedence).
-				winners.set(key, { provider: item._source.provider, scope });
-			}
-		}
-		entries.push({
+	// Resolve provider-order winners only after applying surface eligibility and
+	// the configured provider-disabled policy.
+	const resolvedPrecedence = resolveDiscoveryPrecedence(
+		result.all.map(item => ({
+			key: capability.key(item),
+			provider: item._source.provider,
+			scope: scopeOf(item._source),
+			eligible: options.precedenceEligible?.(item) ?? true,
+			enabled: !disabledProviders.has(item._source.provider),
+		})),
+	);
+	const entries: DiscoveredEntry<T>[] = result.all.map((item, index) => {
+		const precedence = resolvedPrecedence[index];
+		if (!precedence) throw new Error("discovery precedence result is missing an item");
+		return {
 			item,
 			name: options.nameOf(item),
 			path: options.pathOf(item),
 			provider: item._source.provider,
 			providerName: item._source.providerName,
-			scope,
+			scope: scopeOf(item._source),
 			priority: capability.providers.find(p => p.id === item._source.provider)?.priority ?? 0,
-			shadowed,
-			shadowedBy,
+			shadowed: precedence.shadowed,
+			shadowedBy: precedence.shadowedBy,
 			invalidReason: capability.validate?.(item),
 			extensionId: options.extensionIdOf?.(item),
-		});
-	}
+		};
+	});
 
 	entries.sort((a, b) => a.name.localeCompare(b.name) || a.provider.localeCompare(b.provider));
 
@@ -954,6 +950,7 @@ async function collectHooks(cwd: string, activeSettings: SettingsInstance): Prom
 	return collectNotExecutedAtStartup("hook", hookCapability, cwd, activeSettings, {
 		nameOf: hook => hook.name,
 		pathOf: hook => hook.path,
+		precedenceEligible: hook => hook.level !== "project",
 		notExecutedDetail:
 			"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: [
@@ -989,6 +986,7 @@ async function collectExtensions(cwd: string, activeSettings: SettingsInstance):
 interface NotExecutedOptions<T extends { _source: SourceMeta }> {
 	nameOf: (item: T) => string;
 	pathOf: (item: T) => string;
+	precedenceEligible?: (item: T) => boolean;
 	notExecutedDetail: string;
 	notExecutedRemediation: string[];
 }
@@ -1004,6 +1002,7 @@ async function collectNotExecutedAtStartup<T extends { _source: SourceMeta }>(
 		nameOf: options.nameOf,
 		pathOf: options.pathOf,
 		extensionIdOf: item => capability.toExtensionId?.(item),
+		precedenceEligible: options.precedenceEligible,
 	});
 	const disabledExts = disabledExtensionIds(activeSettings);
 	const disabledProviders = new Set(activeSettings.get("disabledProviders"));
@@ -1019,6 +1018,18 @@ async function collectNotExecutedAtStartup<T extends { _source: SourceMeta }>(
 				[`Fix ${entry.path}`],
 			);
 		}
+		if (kind === "hook" && entry.scope === "project") {
+			return finalizeItem(
+				base,
+				"stored-only",
+				"storage-only",
+				"Project-scoped hooks are stored for inspection, but ordinary sessions do not load repository hook modules.",
+				[
+					"Import the hook into Global .gjc to load it for future sessions",
+					"or configure an explicit hook path if repository-local activation is intentional",
+				],
+			);
+		}
 		if (entry.extensionId !== undefined && disabledExts.has(entry.extensionId)) {
 			return finalizeItem(
 				base,
@@ -1360,13 +1371,12 @@ async function collectPluginBundles(cwd: string): Promise<CustomizeDoctorSurface
 // Foreign conventions (Claude project / Codex project)
 //
 // Claude Code / Codex project hooks are discovered by the registered
-// claude-hooks/codex-hooks providers (see discovery/index.ts) and appear in the
-// Hooks surface above; sessions surface them in the extension dashboard but do
-// not execute hook files. Every OTHER `.claude`/`.codex` surface (MCP, skills,
-// tools, extensions, commands, prompts, settings) is deliberately not part of
-// the load path: the doctor reports those files by invoking the canonical
-// provider load functions directly (without registering the providers) and
-// marks every such item as `ignored`.
+// claude-hooks/codex-hooks providers (see discovery/index.ts), but like native
+// project hooks are stored-only and are not imported by ordinary sessions.
+// Every OTHER `.claude`/`.codex` surface (MCP, skills, tools, extensions,
+// commands, prompts, settings) is deliberately not part of the load path: the
+// doctor reports those files by invoking canonical provider load functions
+// directly (without registering the providers) and marks them `ignored`.
 // =============================================================================
 
 interface ForeignConventionDescriptor {
@@ -1468,7 +1478,7 @@ function foreignItem(
 async function collectForeignConventions(cwd: string): Promise<ForeignConventionCollection> {
 	const ctx: LoadContext = { cwd, home: os.homedir(), repoRoot: await findRepoRoot(cwd) };
 	const itemsByKind: Map<CustomizeSurfaceKind, CustomizeDoctorItem[]> = new Map();
-	const policyNote = `${FOREIGN_CONVENTIONS.map(d => d.dirName).join(" and ")} project hooks are discovered by GJC (see the Hooks surface); all other ${FOREIGN_CONVENTIONS.map(d => d.providerName).join(" / ")} project config surfaces (MCP servers, skills, tools, extensions, commands, prompts, settings) are not part of the GJC load path. Those files are reported below as import candidates for provenance but are never discovered by sessions.`;
+	const policyNote = `${FOREIGN_CONVENTIONS.map(d => d.dirName).join(" and ")} project hooks are shown as stored-only (see the Hooks surface); ordinary sessions do not load repository hook modules. All other ${FOREIGN_CONVENTIONS.map(d => d.providerName).join(" / ")} project config surfaces (MCP servers, skills, tools, extensions, commands, prompts, settings) are not part of the GJC load path and are reported below as import candidates for provenance.`;
 
 	for (const desc of FOREIGN_CONVENTIONS) {
 		const inspection = await desc.inspect(ctx);

package/src/cli/fast-help.ts

@@ -81,8 +81,6 @@ Environment Variables:
   GJC_CODING_AGENT_DIR       - Session storage directory (default: ~/${CONFIG_DIR_NAME}/agent)
   GJC_UI_LANGUAGE            - Explicit first-use onboarding language (en, ko, zh, or ja); invalid values use English without prompting
   GJC_PACKAGE_DIR            - Override package directory (for Nix/Guix store paths)
-  GJC_SMOL_MODEL              - Override smol/fast model (see --smol)
-  GJC_SLOW_MODEL              - Override slow/reasoning model (see --slow)
   GJC_PLAN_MODEL              - Override planning model (see --plan)
   GJC_MODEL_PRESET_REGISTRY_URL - HTTPS latest.json override for the signed preset registry
   GJC_MODEL_PRESET_REGISTRY_DISABLED - Disable registry fetch/use (1/true/yes/on)

package/src/cli/migrate-cli.ts

@@ -1,5 +1,5 @@
 /**
- * `gjc migrate` — import MCP servers, skills, and instruction files from other coding agents.
+ * `gjc migrate` — import MCP servers, skills, slash commands, and instruction files from other coding agents.
  */
 import * as os from "node:os";
 import * as path from "node:path";
@@ -55,8 +55,18 @@ function resolveDestinations(project: boolean, cwd: string): MigrateDestinations
 	const scope = project ? "project" : "user";
 	const agentDir = project ? getProjectAgentDir(cwd) : getAgentDir();
 	const skillsDir = path.join(agentDir, "skills");
+	const commandsDir = path.join(agentDir, "commands");
+	const agentsDir = path.join(agentDir, "agents");
+	const hooksDir = path.join(agentDir, "hooks");
 	const instructionsPath = path.join(agentDir, "AGENTS.md");
-	return { mcpConfigPath: getMCPConfigPath(scope, cwd), skillsDir, instructionsPath };
+	return {
+		mcpConfigPath: getMCPConfigPath(scope, cwd),
+		skillsDir,
+		commandsDir,
+		agentsDir,
+		hooksDir,
+		instructionsPath,
+	};
 }
 
 /** Run the migration and return the report (does not set process.exitCode). */
@@ -71,12 +81,13 @@ export async function runMigrate(args: MigrateCommandArgs): Promise<MigrateRepor
 		results.push(await getAdapter(source).collect({ homeDir, cwd, scope: args.project ? "project" : "user" }));
 	}
 
-	const { actions, warnings } = await planMigration({ results, destinations, force: args.force });
+	const { actions, warnings, manualActions } = await planMigration({ results, destinations, force: args.force });
 	const finalActions = args.dryRun ? actions : await executeActions(actions, { project: args.project });
 
 	return buildReport({
 		actions: finalActions,
 		warnings,
+		manualActions,
 		sources,
 		destinations,
 		dryRun: args.dryRun,

package/src/cli/public-command-errors.ts

@@ -111,6 +111,8 @@ export const PUBLIC_COMMAND_DIAGNOSTICS = {
 	// of them and never implies that another key would be safe.
 	lifecycle_idempotency_conflict:
 		"The broker reported an idempotency conflict. Reconcile existing lifecycle state before deciding whether another request is safe.",
+	lifecycle_legacy_history_ambiguous:
+		"The broker refused admission because legacy lifecycle history cannot prove this target is unrelated. This request was not dispatched; this refusal does not settle earlier effects. Preserve the ledger and original operation, request key, and target. For a prior session.create, use read-only session.lookup with its original key and create target; not_found is not proof of no effect. An empty transcript, stopped host, or fresh key does not resolve this fence. Do not edit the ledger, force deletion, or retry with another key; missing identity or terminal effect evidence requires operator investigation.",
 	// Refusals of the request payload itself: the broker's own text names the missing field
 	// (a required `sessionPath`, for one), and it is never rendered, so the class is named here.
 	lifecycle_input_refused:

package/src/cli/root-flags.ts

@@ -10,8 +10,6 @@ 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 = {
 	model: Flags.string({ description: 'Model to use (fuzzy match: "opus", "gpt-5.2", or "openai/gpt-5.2")' }),
-	smol: Flags.string({ description: "Smol/fast model for lightweight tasks (or GJC_SMOL_MODEL env)" }),
-	slow: Flags.string({ description: "Slow/reasoning model for thorough analysis (or GJC_SLOW_MODEL env)" }),
 	plan: Flags.string({ description: "Plan model for architectural planning (or GJC_PLAN_MODEL env)" }),
 	mpreset: Flags.string({ description: "Model profile preset to activate for this session" }),
 	default: Flags.boolean({ description: "Persist --mpreset as the default model profile" }),