@gajae-code/coding-agent 0.12.12 → 0.12.14

package/src/cli/marketplace-hint.ts

@@ -0,0 +1,39 @@
+/**
+ * Install-failure hints for marketplace-shaped plugin names.
+ *
+ * A bare spec (no `@marketplace`) is always classified as npm, so a user who
+ * copies a plugin name out of `plugin discover` gets an npm resolution failure
+ * with no hint that the same name is offered by a registered marketplace.
+ *
+ * Kept dependency-free — the marketplace barrel loads native addons — so this
+ * takes the narrow catalog surface it actually reads instead of the manager.
+ */
+
+/** The catalog lookups this module needs; `MarketplaceManager` satisfies it. */
+export interface MarketplaceCatalogLookup {
+	listMarketplaces(): Promise<ReadonlyArray<{ name: string }>>;
+	getPluginInfo(name: string, marketplace: string): Promise<unknown | null>;
+}
+
+/**
+ * A bare name carries no `@scope`, version specifier, or path separator, so it
+ * is the only install spec shape that is safe to echo back in an error.
+ */
+export function isBareInstallName(spec: string): boolean {
+	return spec.length > 0 && !spec.includes("@") && !spec.includes("/") && !spec.includes("\\");
+}
+
+/**
+ * Names of registered marketplaces whose catalog offers a plugin under exactly
+ * `name`. Only marketplace names are returned: they are user-chosen registry
+ * labels, never the plugin source, so they carry no credentials or home paths.
+ */
+export async function findMarketplacesOffering(catalogs: MarketplaceCatalogLookup, name: string): Promise<string[]> {
+	const marketplaces = await catalogs.listMarketplaces();
+	const offering: string[] = [];
+	for (const marketplace of marketplaces) {
+		const info = await catalogs.getPluginInfo(name, marketplace.name).catch(() => null);
+		if (info) offering.push(marketplace.name);
+	}
+	return offering;
+}

package/src/cli/plugin-cli.ts

@@ -155,6 +155,7 @@ export function parsePluginArgs(args: string[]): PluginCommandArgs | undefined {
 }
 
 import { classifyInstallTarget } from "./classify-install-target";
+import { findMarketplacesOffering, isBareInstallName } from "./marketplace-hint";
 
 export { classifyInstallTarget } from "./classify-install-target";
 
@@ -609,6 +610,15 @@ async function handleInstall(
 			// The spec can carry credentials, a query string, or an absolute home
 			// path, so report the failure without echoing it or the raw cause.
 			console.error(chalk.red(`${theme.status.error} Failed to install plugin (${describeInstallFailure(err)})`));
+			// A bare name (no `@scope`, no version, no path separator) is safe to
+			// echo, and it is exactly the shape a user copies out of
+			// `plugin discover`. Point at the qualified spec that would work.
+			if (isBareInstallName(spec)) {
+				const offering = await findMarketplacesOffering(mktMgr, spec).catch(() => []);
+				for (const marketplace of offering) {
+					console.error(chalk.dim(`  Try: ${APP_NAME} plugin install ${spec}@${marketplace}`));
+				}
+			}
 			process.exit(1);
 		}
 	}

package/src/cli.ts

@@ -389,11 +389,34 @@ function routeLegacyRootArgv(argv: readonly string[]): string[] | undefined {
 	return ["team", size, ...remaining];
 }
 
+/**
+ * Map the common mistaken `models` subcommand spelling to non-agent listing.
+ *
+ * Agents frequently run `gjc models` from the bash tool expecting a catalog.
+ * Without this route, `models` was a positional launch prompt and nested agents
+ * re-invoked `gjc models`, spawning an unbounded process chain (#3857).
+ * Always rewrite to `launch --list-models` so the invocation exits after a
+ * bounded listing and never starts an interactive agent session.
+ */
+export function routeModelsAlias(argv: readonly string[]): string[] | undefined {
+	if (argv[0] !== "models") return undefined;
+	const rest = argv.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("@"))) {
+		return ["launch", "--list-models", rest.join(" ")];
+	}
+	// Mixed flags still go through list-models first so "models" is never a prompt.
+	return ["launch", "--list-models", ...rest];
+}
+
 /** Apply the same default-launch routing used by runCli after root fast paths. */
 export function routeRootArgv(argv: readonly string[]): string[] {
 	const normalizedArgv = normalizeResumeAlias(argv);
 	const legacyArgv = routeLegacyRootArgv(normalizedArgv);
 	if (legacyArgv) return legacyArgv;
+	const modelsArgv = routeModelsAlias(normalizedArgv);
+	if (modelsArgv) return modelsArgv;
 	const first = normalizedArgv[0];
 	return first === "--help" || first === "-h" || first === "--version" || first === "-v" || first === "help"
 		? normalizedArgv

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

@@ -13,13 +13,15 @@ import type {
 	GcPruneOutcome,
 	GcRecord,
 	GcStoreAdapter,
+	GcWarning,
 } 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";
 
 const MAX_WALK_DEPTH = 6;
-const MAX_WALK_ENTRIES = 20_000;
+/** Default per-root walk budget. Truncation is a warning, not a hard error. */
+export const FILE_LOCK_GC_MAX_WALK_ENTRIES = 20_000;
 
 // High-cardinality, lock-free subtrees we never descend into. `.lock` dirs are
 // created next to config files, never inside these.
@@ -30,6 +32,11 @@ interface WalkState {
 	truncated: boolean;
 }
 
+export interface FileLocksGcCollectOptions {
+	/** Override per-root entry budget (tests). Defaults to {@link FILE_LOCK_GC_MAX_WALK_ENTRIES}. */
+	maxWalkEntries?: number;
+}
+
 // Global, env-aware GJC lock roots. Per the approved scope this covers the
 // user config root, the agent dir (honors GJC_CODING_AGENT_DIR), and the
 // configured receipt-spool dir — NOT the invocation cwd's project `.gjc`.
@@ -102,8 +109,9 @@ async function walkForLockDirs(
 	state: WalkState,
 	lockDirs: Set<string>,
 	errors: GcError[],
+	maxWalkEntries: number,
 ): Promise<void> {
-	if (state.entries >= MAX_WALK_ENTRIES) {
+	if (state.entries >= maxWalkEntries) {
 		state.truncated = true;
 		return;
 	}
@@ -137,45 +145,58 @@ async function walkForLockDirs(
 	}
 
 	for (const entry of entries) {
-		if (state.entries >= MAX_WALK_ENTRIES) {
+		if (state.entries >= maxWalkEntries) {
 			state.truncated = true;
 			return;
 		}
 		if (PRUNED_DIR_NAMES.has(entry)) continue;
-		await walkForLockDirs(path.join(dir, entry), depth + 1, state, lockDirs, errors);
+		await walkForLockDirs(path.join(dir, entry), depth + 1, state, lockDirs, errors, maxWalkEntries);
 	}
 }
 
-export const fileLocksGcAdapter: GcStoreAdapter = {
-	store: "file_locks",
-	async collect(ctx: GcContext): Promise<GcCollectResult> {
-		const records: GcRecord[] = [];
-		const errors: GcError[] = [];
-		const lockDirs = new Set<string>();
+/**
+ * Discover + classify file-lock records. Each known lock root gets its own walk
+ * budget so truncating one root never skips the others. Caps surface as
+ * warnings (partial results), not hard discovery errors.
+ */
+export async function collectFileLocksForGc(
+	ctx: GcContext,
+	options: FileLocksGcCollectOptions = {},
+): Promise<GcCollectResult> {
+	const maxWalkEntries = options.maxWalkEntries ?? FILE_LOCK_GC_MAX_WALK_ENTRIES;
+	const records: GcRecord[] = [];
+	const errors: GcError[] = [];
+	const warnings: GcWarning[] = [];
+	const lockDirs = new Set<string>();
+
+	for (const root of knownFileLockRoots(ctx)) {
+		// Fresh budget per root so a huge agent dir cannot starve config/spool.
 		const state: WalkState = { entries: 0, truncated: false };
-
-		for (const root of knownFileLockRoots(ctx)) {
-			await walkForLockDirs(root, 0, state, lockDirs, errors);
-			if (state.truncated) break;
-		}
-
+		await walkForLockDirs(root, 0, state, lockDirs, errors, maxWalkEntries);
 		if (state.truncated) {
-			errors.push({
+			warnings.push({
 				store: "file_locks",
-				scope: "discovery",
-				message: `file lock discovery capped at ${MAX_WALK_ENTRIES} entries`,
+				scope: root,
+				message: `file lock discovery capped at ${maxWalkEntries} entries for root ${root} (scanned ${state.entries})`,
 			});
 		}
+	}
 
-		for (const lockDir of lockDirs) {
-			try {
-				records.push(await collectLockRecord(lockDir, ctx));
-			} catch (error) {
-				errors.push({ store: "file_locks", scope: lockDir, message: errorMessage(error) });
-			}
+	for (const lockDir of lockDirs) {
+		try {
+			records.push(await collectLockRecord(lockDir, ctx));
+		} catch (error) {
+			errors.push({ store: "file_locks", scope: lockDir, message: errorMessage(error) });
 		}
+	}
 
-		return { records, errors };
+	return { records, errors, warnings };
+}
+
+export const fileLocksGcAdapter: GcStoreAdapter = {
+	store: "file_locks",
+	async collect(ctx: GcContext): Promise<GcCollectResult> {
+		return collectFileLocksForGc(ctx);
 	},
 	async prune(record: GcRecord, ctx: GcContext): Promise<GcPruneOutcome> {
 		const lockDir = record.path ?? record.id;

package/src/config/model-profiles.ts

@@ -264,25 +264,25 @@ export const BUILTIN_MODEL_PROFILES: readonly ModelProfileDefinition[] = [
 		architect: "cursor/composer-2.5-fast",
 	}),
 	profile("minimax-eco", ["minimax-code"], {
-		default: "minimax-code/minimax-m3:low",
-		executor: "minimax-code/minimax-m3:minimal",
-		planner: "minimax-code/minimax-m3:low",
-		critic: "minimax-code/minimax-m3:medium",
-		architect: "minimax-code/minimax-m3:high",
+		default: "minimax-code/MiniMax-M3:low",
+		executor: "minimax-code/MiniMax-M3:minimal",
+		planner: "minimax-code/MiniMax-M3:low",
+		critic: "minimax-code/MiniMax-M3:medium",
+		architect: "minimax-code/MiniMax-M3:high",
 	}),
 	profile("minimax-medium", ["minimax-code"], {
-		default: "minimax-code/minimax-m3:medium",
-		executor: "minimax-code/minimax-m3:low",
-		planner: "minimax-code/minimax-m3:medium",
-		critic: "minimax-code/minimax-m3:high",
-		architect: "minimax-code/minimax-m3:xhigh",
+		default: "minimax-code/MiniMax-M3:medium",
+		executor: "minimax-code/MiniMax-M3:low",
+		planner: "minimax-code/MiniMax-M3:medium",
+		critic: "minimax-code/MiniMax-M3:high",
+		architect: "minimax-code/MiniMax-M3:xhigh",
 	}),
 	profile("minimax-pro", ["minimax-code"], {
-		default: "minimax-code/minimax-m3:xhigh",
-		executor: "minimax-code/minimax-m3:medium",
-		planner: "minimax-code/minimax-m3:high",
-		critic: "minimax-code/minimax-m3:xhigh",
-		architect: "minimax-code/minimax-m3:xhigh",
+		default: "minimax-code/MiniMax-M3:xhigh",
+		executor: "minimax-code/MiniMax-M3:medium",
+		planner: "minimax-code/MiniMax-M3:high",
+		critic: "minimax-code/MiniMax-M3:xhigh",
+		architect: "minimax-code/MiniMax-M3:xhigh",
 	}),
 	profile("alibaba-token-plan-balanced", ["alibaba-token-plan"], {
 		default: "alibaba-token-plan/qwen3.8-max-preview:medium",
@@ -306,11 +306,11 @@ export const BUILTIN_MODEL_PROFILES: readonly ModelProfileDefinition[] = [
 		critic: "alibaba-token-plan/qwen3.8-max-preview:xhigh",
 	}),
 	profile("alibaba-token-plan-qwen-deepseek", ["alibaba-token-plan"], {
-		default: "alibaba-token-plan/qwen-3.8-max:high",
+		default: "alibaba-token-plan/qwen3.8-max:high",
 		executor: "alibaba-token-plan/deepseek-v4-flash-0731:high",
 		planner: "alibaba-token-plan/deepseek-v4-flash-0731:max",
-		architect: "alibaba-token-plan/qwen-3.8-max:xhigh",
-		critic: "alibaba-token-plan/qwen-3.8-max:xhigh",
+		architect: "alibaba-token-plan/qwen3.8-max:xhigh",
+		critic: "alibaba-token-plan/qwen3.8-max:xhigh",
 	}),
 	profile("alibaba-token-plan-glm-deepseek", ["alibaba-token-plan"], {
 		default: "alibaba-token-plan/glm-5.2:high",

package/src/config/model-registry.ts

@@ -926,12 +926,24 @@ const customReferenceMap = buildCustomReferenceMap();
 
 function getCustomReferenceCandidateIds(modelId: string): string[] {
 	const candidates = new Set<string>();
-	const minimaxM = /^minimax-m(\d+(?:\.\d+)*)$/i.exec(modelId.trim());
-	const queue = minimaxM ? [`MiniMax-M${minimaxM[1]}`, modelId] : [modelId];
+	const trimmedId = modelId.trim();
+	const minimaxM = /^minimax-m(\d+(?:\.\d+)*)$/i.exec(trimmedId);
+	const queue = minimaxM ? [`MiniMax-M${minimaxM[1]}`, trimmedId] : [trimmedId];
 	if (minimaxM) {
-		// MiniMax catalogs include lowercase wire ids plus display-cased aliases.
-		// Custom providers should keep the lowercase wire id while inheriting the
-		// canonical display casing when the alias exists.
+		// First-class MiniMax catalogs expose canonical `MiniMax-M*` ids only,
+		// but custom providers may still use lowercase wire ids. Normalize to
+		// the canonical display casing so metadata inheritance keeps working.
+	}
+	// Namespaced wire IDs (e.g. `cline-pass/deepseek-v4-flash`) keep the full id for
+	// the API request, but should still try the leaf segment against bundled
+	// references so capability metadata is not silently replaced by 128K/16K defaults.
+	// Only an exact leaf match in the reference map inherits; unknown leaves stay defaulted.
+	const slashIndex = trimmedId.lastIndexOf("/");
+	if (slashIndex >= 0 && slashIndex < trimmedId.length - 1) {
+		const leafId = trimmedId.slice(slashIndex + 1).trim();
+		if (leafId && leafId !== trimmedId) {
+			queue.push(leafId);
+		}
 	}
 	for (let index = 0; index < queue.length; index += 1) {
 		const candidate = queue[index]?.trim();

package/src/config/models-config-schema.ts

@@ -20,7 +20,7 @@ const ReasoningEffortMapSchema = z.object({
 	max: z.string().optional(),
 });
 
-export const OpenAICompatSchema = z.object({
+export const ModelCompatSchema = z.object({
 	supportsStore: z.boolean().optional(),
 	supportsDeveloperRole: z.boolean().optional(),
 	sendSessionHeaders: z.boolean().optional(),
@@ -48,8 +48,13 @@ export const OpenAICompatSchema = z.object({
 	extraBody: z.record(z.string(), z.unknown()).optional(),
 	supportsStrictMode: z.boolean().optional(),
 	toolStrictMode: z.enum(["all_strict", "none"]).optional(),
+	supportsLongCacheRetention: z.boolean().optional(),
+	promptCacheMode: z.enum(["none", "explicit", "automatic"]).optional(),
 });
 
+// Backward-compatible export for callers that imported the original schema name.
+export const OpenAICompatSchema = ModelCompatSchema;
+
 export const GJC_MODEL_EFFORT_IDS = ["minimal", "low", "medium", "high", "xhigh", "max"] as const;
 export const GJC_MODEL_ASSIGNMENT_TARGET_IDS = ["default", "executor", "architect", "planner", "critic"] as const;
 export const EffortSchema = z.enum(GJC_MODEL_EFFORT_IDS);
@@ -146,7 +151,7 @@ const ModelDefinitionSchema = z
 		contextWindow: z.number().optional(),
 		maxTokens: z.number().optional(),
 		headers: z.record(z.string(), z.string()).optional(),
-		compat: OpenAICompatSchema.optional(),
+		compat: ModelCompatSchema.optional(),
 		contextPromotionTarget: z.string().min(1).optional(),
 		wireModelId: z.string().min(1).optional(),
 		requestTransform: RequestTransformSchema.optional(),
@@ -173,7 +178,7 @@ export const ModelOverrideSchema = z
 		contextWindow: z.number().optional(),
 		maxTokens: z.number().optional(),
 		headers: z.record(z.string(), z.string()).optional(),
-		compat: OpenAICompatSchema.optional(),
+		compat: ModelCompatSchema.optional(),
 		contextPromotionTarget: z.string().min(1).optional(),
 		wireModelId: z.string().min(1).optional(),
 		requestTransform: RequestTransformSchema.optional(),
@@ -221,7 +226,7 @@ const ProviderConfigSchema = z
 			])
 			.optional(),
 		headers: z.record(z.string(), z.string()).optional(),
-		compat: OpenAICompatSchema.optional(),
+		compat: ModelCompatSchema.optional(),
 		webSearch: z.enum(["on", "off", "auto"]).optional(),
 		authHeader: z.boolean().optional(),
 		auth: ProviderAuthSchema.optional(),

package/src/defaults/gjc/skills/deep-interview/SKILL.md

@@ -122,7 +122,7 @@ Deep Interview threshold: <resolvedThresholdPercent> (source: <resolvedThreshold
    - Substitute `<resolvedThreshold>`, `<resolvedThresholdPercent>`, and `<resolvedThresholdSource>` throughout the remaining instructions before continuing.
    - Include `threshold_source` in the first `gjc deep-interview write` payload and preserve it on later state updates; do not edit `.gjc/_session-{sessionid}/state` files directly unless an explicit force override is active.
    - Include both threshold and source in the final spec metadata.
-- Read any `language` object from active deep-interview state and carry `language.instruction` forward mechanically. If absent, default to English unless `{{ARGUMENTS}}` makes another user/session language obvious or the user explicitly requests another language. Do not add language-specific special cases.
+- Read any `language` object from active deep-interview state and carry `language.instruction` forward mechanically. If absent, default to English unless the appended `User:` request makes another user/session language obvious or the user explicitly requests another language. Do not add language-specific special cases.
 
 ## Phase 0.5: Suitability Gate
 

package/src/gjc-runtime/deep-interview-recorder.ts

@@ -11,6 +11,7 @@ import {
 	assertDeepInterviewInputWithinLimit,
 	assertDeepInterviewIntentManifest,
 	assertDeepInterviewStructuredResponseWithinLimit,
+	canonicalizeDeepInterviewText,
 	createDeepInterviewIntentManifest,
 	type DeepInterviewEstablishedFact,
 	type DeepInterviewIntentItem,
@@ -106,16 +107,19 @@ export function buildAnswerShell(
 	input: DeepInterviewAnswerInput,
 	now: string = new Date().toISOString(),
 ): DeepInterviewRoundRecord {
+	const questionText = canonicalizeDeepInterviewText(input.questionText);
+	const selectedOptions = input.selectedOptions?.map(canonicalizeDeepInterviewText);
+	const customInput = input.customInput === undefined ? undefined : canonicalizeDeepInterviewText(input.customInput);
 	return {
 		round_key: deriveRoundKey(input.interviewId, input),
 		round_id: input.round_id,
 		round: input.round,
 		question_id: input.questionId,
-		question_text: input.questionText,
-		question_hash: questionHash(input.questionText),
-		answer_hash: answerHash(input.selectedOptions, input.customInput),
-		selected_options: input.selectedOptions,
-		custom_input: input.customInput,
+		question_text: questionText,
+		question_hash: questionHash(questionText),
+		answer_hash: answerHash(selectedOptions, customInput),
+		selected_options: selectedOptions,
+		custom_input: customInput,
 		component: input.component,
 		dimension: input.dimension,
 		ambiguity_at_ask: input.ambiguity,

package/src/gjc-runtime/deep-interview-state.ts

@@ -97,13 +97,34 @@ export function hashContent(value: string): string {
 	return createHash("sha256").update(value).digest("hex").slice(0, 32);
 }
 
+/**
+ * Canonicalize interview prose to NFC.
+ *
+ * Hangul, unlike most Latin prose, routinely reaches the interview in both
+ * composed and decomposed form (macOS-sourced pastes and some IME/clipboard
+ * paths emit NFD), and the two forms are the same text for the user while
+ * being different JavaScript strings. Canonicalizing at the identity and
+ * length boundaries keeps one round per answer and keeps the character caps
+ * script-fair: decomposed Hangul otherwise costs two to three code points per
+ * syllable against the same budget.
+ */
+export function canonicalizeDeepInterviewText(value: string): string {
+	return value.normalize("NFC");
+}
+
 export function questionHash(questionText: string): string {
-	return hashContent(questionText);
+	return hashContent(canonicalizeDeepInterviewText(questionText));
 }
 
 export function answerHash(selectedOptions: string[] | undefined, customInput: string | undefined): string {
 	return createHash("sha256")
-		.update(JSON.stringify({ selected: selectedOptions ?? [], custom: customInput ?? null }))
+		.update(
+			JSON.stringify({
+				selected: (selectedOptions ?? []).map(canonicalizeDeepInterviewText),
+				custom:
+					customInput === undefined || customInput === null ? null : canonicalizeDeepInterviewText(customInput),
+			}),
+		)
 		.digest("hex");
 }
 
@@ -471,10 +492,13 @@ export function assertDeepInterviewStructuredResponseWithinLimit(value: unknown)
 /**
  * Assert a free-text input is within its size cap. Never inspects content for shell
  * metacharacters — free-text fields accept prose verbatim; this only bounds length.
+ * The cap is measured on the NFC form so decomposed Hangul is charged the same
+ * budget as the identical composed text.
  */
 export function assertDeepInterviewInputWithinLimit(value: string, max: number, fieldName = "input"): void {
 	if (typeof value !== "string") throw new Error(`${fieldName} must be a string`);
-	if (deepInterviewCharacterCount(value) > max) throw new Error(`${fieldName} exceeds max length ${max}`);
+	if (deepInterviewCharacterCount(canonicalizeDeepInterviewText(value)) > max)
+		throw new Error(`${fieldName} exceeds max length ${max}`);
 }
 
 /** Validate user-supplied deep-interview prose before an envelope is persisted. */

package/src/gjc-runtime/gc-render.ts

@@ -72,6 +72,12 @@ export function buildGcReportText(report: GcReport): string {
 		lines.push("");
 	}
 
+	if (report.warnings.length > 0) {
+		lines.push(`Warnings (${report.warnings.length})`);
+		for (const warning of report.warnings) lines.push(`  [${warning.store}/${warning.scope}] ${warning.message}`);
+		lines.push("");
+	}
+
 	if (report.errors.length > 0) {
 		lines.push(`Errors (${report.errors.length})`);
 		for (const err of report.errors) lines.push(`  [${err.store}/${err.scope}] ${err.message}`);
@@ -82,7 +88,8 @@ export function buildGcReportText(report: GcReport): string {
 	lines.push(
 		`Summary: discovered=${c.discovered} stale=${c.stale} alive=${c.alive} eperm=${c.eperm} unknown=${c.unknown} ` +
 			`terminal_lifecycle=${c.terminal_lifecycle} unclassified=${c.unclassified} ` +
-			`${report.dry_run ? `would_remove=${c.would_remove}` : `removed=${c.removed} failed=${c.failed}`} errors=${c.errors}`,
+			`${report.dry_run ? `would_remove=${c.would_remove}` : `removed=${c.removed} failed=${c.failed}`} ` +
+			`errors=${c.errors} warnings=${report.warnings.length}`,
 	);
 	lines.push("");
 	return `${lines.join("\n")}`;

package/src/gjc-runtime/gc-runtime.ts

@@ -78,9 +78,18 @@ export interface GcError {
 	message: string;
 }
 
+/** Non-fatal discovery partials (e.g. traversal caps). Does not affect exit code. */
+export interface GcWarning {
+	store: GcStore;
+	scope: string;
+	message: string;
+}
+
 export interface GcCollectResult {
 	records: GcRecord[];
 	errors: GcError[];
+	/** Optional partial-result notices; omitted by adapters that have none. */
+	warnings?: GcWarning[];
 }
 
 export interface GcPruneOutcome {
@@ -140,6 +149,8 @@ export interface GcReport {
 	stores: Record<GcStore, GcRecord[]>;
 	counts: GcCounts;
 	errors: GcError[];
+	/** Partial-result notices that do not fail the run (e.g. walk caps). */
+	warnings: GcWarning[];
 	session_index?: GcSessionIndexHealth;
 }
 
@@ -298,12 +309,14 @@ function parseGcArgs(argv: string[]): ParsedGcArgs {
 export async function collectGcReport(adapters: GcStoreAdapter[], ctx: GcContext, prune: boolean): Promise<GcReport> {
 	const stores = emptyStores();
 	const errors: GcError[] = [];
+	const warnings: GcWarning[] = [];
 
 	for (const adapter of adapters) {
 		try {
 			const result = await adapter.collect(ctx);
 			stores[adapter.store].push(...result.records);
 			errors.push(...result.errors);
+			if (result.warnings) warnings.push(...result.warnings);
 		} catch (error) {
 			errors.push({
 				store: adapter.store,
@@ -350,7 +363,7 @@ export async function collectGcReport(adapters: GcStoreAdapter[], ctx: GcContext
 		}
 	}
 
-	return { dry_run: !prune, stores, counts: computeCounts(stores, errors), errors };
+	return { dry_run: !prune, stores, counts: computeCounts(stores, errors), errors, warnings };
 }
 
 /**
@@ -358,6 +371,7 @@ export async function collectGcReport(adapters: GcStoreAdapter[], ctx: GcContext
  * - usage/parse error => 2
  * - hard discovery errors => 1 (both modes)
  * - prune mode with a failed intended removal => 1
+ * - warnings alone never fail the run
  * - otherwise => 0
  */
 export function computeExitCode(report: GcReport): number {