@gajae-code/coding-agent 0.14.2 → 0.15.0

package/dist/types/tools/skill.d.ts

@@ -10,10 +10,15 @@
  * project/user skills have no native workflow mode-state, so they are dispatched
  * directly and tracked by the prompt observer instead.
  *
- * Canonical workflow chaining is refused unless the caller's `current_phase` is
- * in `{complete, completed, handoff, failed, cancelled, canceled, inactive}`.
- * The agent declares readiness either by writing `current_phase: "handoff"` to
- * its mode-state or by running the handoff verb directly.
+ * Canonical workflow chaining is refused unless the caller's phase permits it:
+ * the generic terminal set `{complete, completed, handoff, failed, cancelled,
+ * canceled, inactive}`, the caller's manifest-declared terminal states (e.g.
+ * ralplan `final`), or — for autoresearch only — any phase with a declared
+ * handoff edge (`intake`/`research`/`verdict`): a research mission never
+ * mutates and guards no approval gate, its mission state is durable, so an
+ * ongoing or verdict-complete mission may hand off to planning at any point.
+ * ralplan/ultragoal keep the explicit write-to-handoff step for live phases:
+ * their mid-flight chaining is exactly what the approval-gate guard blocks.
  */
 import type { AgentTool, AgentToolResult } from "@gajae-code/agent-core";
 import * as z from "zod/v4";

package/dist/types/tools/subagent.d.ts

@@ -1,6 +1,6 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@gajae-code/agent-core";
 import * as z from "zod/v4";
-import type { AgentProgress, AgentSource } from "../task/types";
+import type { AgentProgress, AgentSource, LocalErrorSummary } from "../task/types";
 import type { ToolSession } from "./index";
 declare const subagentSchema: z.ZodObject<{
     action: z.ZodEnum<{
@@ -45,6 +45,8 @@ export interface SubagentSnapshot {
     errorText?: string;
     /** Safe setup failure cause retained from the executor launch path. */
     setupFailureSummary?: string;
+    /** Safe, bounded summary of a terminal local (non-provider) failure (e.g. local_buffer_overflow). */
+    localErrorSummary?: LocalErrorSummary;
     resultPreview?: string;
     outputRef?: string;
     truncated?: boolean;
@@ -52,8 +54,8 @@ export interface SubagentSnapshot {
     steerMessage?: string;
     steerState?: "queued" | "resume_queued" | "resume_started";
     steerPauseRequested?: boolean;
-    /** Live streaming progress for the awaited subagent (await panel only; UI detail). */
-    progress?: AgentProgress;
+    /** Bounded live progress approved for the await panel and public tool details. */
+    progress?: SubagentLiveProgress;
     /** True when a live in-session progress producer exists for this subagent. */
     liveProgressAvailable?: boolean;
     /** Model the subagent actually runs on (after any auth fallback). */
@@ -65,6 +67,34 @@ export interface SubagentSnapshot {
     /** True when the effective subagent provider is in fast mode. */
     fastMode?: boolean;
 }
+/**
+ * Public await-panel progress. This is deliberately not `AgentProgress`: raw
+ * progress contains model deltas, tool arguments, arbitrary output, and nested
+ * task payloads that must never enter tool-result, ACP, or telemetry envelopes.
+ */
+export interface SubagentLiveProgress {
+    id: string;
+    status: AgentProgress["status"];
+    currentTool?: string;
+    recentTool?: string;
+    recentOutputSummary?: {
+        lineCount: number;
+    };
+    fastMode?: boolean;
+    retryState?: {
+        attempt: number;
+        maxAttempts: number;
+        unbounded?: boolean;
+        kind: NonNullable<AgentProgress["retryState"]>["kind"];
+        provider?: string;
+        lastProviderProgressAtMs?: number;
+        delayMs: number;
+        startedAtMs: number;
+    };
+    retryFailure?: {
+        attempt: number;
+    };
+}
 export type SubagentAwaitOutcome = "completed" | "timed_out" | "interrupted";
 export interface SubagentToolDetails {
     subagents: SubagentSnapshot[];

package/dist/types/utils/xml-escape.d.ts

@@ -0,0 +1,2 @@
+/** Escape a string for interpolation inside a double- or single-quoted XML attribute. */
+export declare function escapeXmlAttribute(input: string): string;

package/dist/types/workflow/workflow-intent-diff.d.ts

@@ -1,7 +1,7 @@
 import { type WorkflowClaimsLedger, type WorkflowConsensusReport } from "./workflow-intent-report";
 export declare const WORKFLOW_INTENT_DIFF_CUSTOM_TYPE = "workflow-intent-diff";
-export declare const WORKFLOW_INTENT_ROUTES: readonly ["direct", "deep-interview", "ralplan", "ultragoal", "team"];
-export declare const WORKFLOW_ESCALATION_ROUTES: readonly ["deep-interview", "ralplan", "ultragoal", "team"];
+export declare const WORKFLOW_INTENT_ROUTES: readonly ["direct", "deep-interview", "ralplan", "ultragoal", "autoresearch"];
+export declare const WORKFLOW_ESCALATION_ROUTES: readonly ["deep-interview", "ralplan", "ultragoal", "autoresearch"];
 export type WorkflowIntentRoute = (typeof WORKFLOW_INTENT_ROUTES)[number];
 export type WorkflowEscalationRoute = (typeof WORKFLOW_ESCALATION_ROUTES)[number];
 export type DirectTrackingMode = "custom-entry-only" | "not-direct";

package/dist/types/workflow/workflow-intent-report-consumer.d.ts

@@ -7,7 +7,7 @@ export interface WorkflowRouteCounts {
     readonly "deep-interview": number;
     readonly ralplan: number;
     readonly ultragoal: number;
-    readonly team: number;
+    readonly autoresearch: number;
 }
 export interface WorkflowIntentReportEntry {
     readonly entryId: string;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/coding-agent",
-	"version": "0.14.2",
+	"version": "0.15.0",
 	"description": "Gajae Code CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://gajae-code.com",
 	"author": "Yeachan-Heo and Gajae Code Contributors",
@@ -33,6 +33,7 @@
 		"check": "biome check . && bun run check:types",
 		"check:runtime": "bun run generate-hotkeys-docs --check && bun run verify:sdk-canonicalization",
 		"check:types": "tsc -p tsconfig.json --noEmit",
+		"check:autorouting-map": "bun scripts/check-autorouting-tier-map.ts",
 		"lint": "biome lint .",
 		"test": "bun test",
 		"generate-hotkeys-docs": "bun scripts/generate-hotkeys-docs.ts",
@@ -55,12 +56,12 @@
 		"@agentclientprotocol/sdk": "1.3.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@gajae-code/stats": "0.14.2",
-		"@gajae-code/agent-core": "0.14.2",
-		"@gajae-code/ai": "0.14.2",
-		"@gajae-code/natives": "0.14.2",
-		"@gajae-code/tui": "0.14.2",
-		"@gajae-code/utils": "0.14.2",
+		"@gajae-code/stats": "0.15.0",
+		"@gajae-code/agent-core": "0.15.0",
+		"@gajae-code/ai": "0.15.0",
+		"@gajae-code/natives": "0.15.0",
+		"@gajae-code/tui": "0.15.0",
+		"@gajae-code/utils": "0.15.0",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",
@@ -85,7 +86,7 @@
 		"@types/ws": "^8.5.13"
 	},
 	"engines": {
-		"bun": ">=1.3.14"
+		"bun": ">=1.4.0"
 	},
 	"files": [
 		"src",
@@ -150,6 +151,8 @@
 		"./sdk/host/control/runtime-gate.js": null,
 		"./sdk/host/control/runtime-gate": null,
 		"./sdk/host/control/runtime-gate/*": null,
+		"./sdk/host/internal-autorouting-state.js": null,
+		"./sdk/host/internal-autorouting-state": null,
 		"./sdk/lifecycle/broker-client.js": null,
 		"./sdk/lifecycle/broker-client": null,
 		"./sdk/lifecycle/broker-client/*": null,
@@ -200,10 +203,6 @@
 			"types": "./dist/types/cli/commands/*.d.ts",
 			"import": "./src/cli/commands/*.ts"
 		},
-		"./autoresearch": null,
-		"./autoresearch/*": null,
-		"./autoresearch/tools/*": null,
-		"./commands/autoresearch": null,
 		"./commands/ralph": null,
 		"./commands/ultraqa": null,
 		"./commands/ultrawork": null,

package/scripts/build-sdk-package-smoke.ts

@@ -25,7 +25,8 @@ function run(command: string[], cwd: string): string {
 	if (result.exitCode !== 0) {
 		throw new Error(`${command.join(" ")} failed:\n${new TextDecoder().decode(result.stderr)}`);
 	}
-	return new TextDecoder().decode(result.stdout).trim();
+	const lines = new TextDecoder().decode(result.stdout).trim().split(/\r?\n/);
+	return lines.at(-1) ?? "";
 }
 
 function assertExport(module: Record<string, unknown>, name: string, subpath: string): void {
@@ -95,9 +96,10 @@ async function runSmoke(): Promise<Surface> {
 		// Install the matching packed workspace artifacts so the smoke test exercises the
 		// release dependency boundary without falling back to an older registry package.
 		run(["bun", "install", "--ignore-scripts"], tempDir);
-		const installedPackage = JSON.parse(
-			await fs.readFile(path.join(tempDir, "node_modules", packageName, "package.json"), "utf8"),
-		) as { exports?: Record<string, unknown> };
+		const stagedPackageJsonPath = path.join(tempDir, "node_modules", packageName, "package.json");
+		const installedPackage = JSON.parse(await fs.readFile(stagedPackageJsonPath, "utf8")) as {
+			exports?: Record<string, unknown>;
+		};
 		const installedAgentPackagePath = path.join(tempDir, "node_modules", "@gajae-code", "agent-core");
 		const installedAgentPackageJsonPath = path.join(installedAgentPackagePath, "package.json");
 		const installedAgentPackage = JSON.parse(await fs.readFile(installedAgentPackageJsonPath, "utf8")) as {
@@ -150,7 +152,7 @@ async function runSmoke(): Promise<Surface> {
 		const probePath = path.join(tempDir, "probe.ts");
 		await fs.writeFile(
 			probePath,
-			`import * as fs from "node:fs/promises";\nimport * as path from "node:path";\nimport * as root from ${JSON.stringify(packageName)};\nimport * as sdk from ${JSON.stringify(`${packageName}/sdk`)};\nimport * as bus from ${JSON.stringify(`${packageName}/sdk/bus`)};\nconst required = [[root, "createAgentSession", "root"], [root, "SESSION_DIRECTORY_API_VERSION", "root"], [root, "resolveManagedSessionScope", "root"], [root, "listManagedSessionCandidates", "root"], [sdk, "createAgentSession", "sdk"], [bus, "createNotificationsExtension", "sdk/bus"], [sdk, "SESSION_DIRECTORY_API_VERSION", "sdk"], [sdk, "resolveManagedSessionScope", "sdk"], [sdk, "listManagedSessionCandidates", "sdk"]] as const;\nfor (const [module, name, subpath] of required) if (!(name in module)) throw new Error(subpath + " missing " + name);\nconst sandbox = path.join(process.cwd(), "managed-listing-smoke");\nconst cwd = path.join(sandbox, "workspace", "a-b", "c");\nconst agentDir = path.join(sandbox, "agent");\nconst sessionsRoot = path.join(agentDir, "sessions");\nawait fs.mkdir(cwd, { recursive: true });\nconst resolved = await sdk.resolveManagedSessionScope({ cwd, agentDir, sessionsRoot });\nif (resolved.kind !== "resolved") throw new Error("packed resolver failed: " + resolved.message);\nawait fs.mkdir(resolved.scope.directoryPath, { recursive: true, mode: 0o700 });\nawait fs.chmod(sessionsRoot, 0o700);\nawait fs.chmod(resolved.scope.directoryPath, 0o700);\nawait fs.writeFile(path.join(resolved.scope.directoryPath, ".gjc-managed-session-scope.v2.json"), JSON.stringify({ schemaVersion: 1, layoutVersion: 2, identityVersion: 1, platform: process.platform === "win32" ? "win32" : "posix", canonicalPath: resolved.scope.canonicalCwd, identityDigest: resolved.scope.directoryName.slice(3) }) + "\\n", { mode: 0o600 });\nconst transcriptPath = path.join(resolved.scope.directoryPath, "packed-session.jsonl");\nawait fs.writeFile(transcriptPath, JSON.stringify({ type: "session", id: "packed-session", cwd }) + "\\n", { mode: 0o600 });\nconst snapshot = async () => Promise.all((await fs.readdir(sandbox, { recursive: true })).sort().map(async name => { const pathname = path.join(sandbox, name); const stat = await fs.lstat(pathname); return [name, stat.mode, stat.size, stat.mtimeMs, stat.isFile() ? await fs.readFile(pathname, "utf8") : null]; }));\nconst before = JSON.stringify(await snapshot());\nconst listing = await sdk.listManagedSessionCandidates({ scope: resolved.scope });\nif (listing.kind !== "complete" || listing.owned.length !== 1 || listing.owned[0]?.sessionId !== "packed-session") throw new Error("packed readonly listing failed: " + JSON.stringify(listing));\nconst after = JSON.stringify(await snapshot());\nif (after !== before) throw new Error("packed readonly listing mutated the filesystem");\nconst privateSubpath = ${JSON.stringify(`${packageName}/session/internal/managed-session-scope`)};\ntry { await import(privateSubpath); throw new Error("private managed-session scope subpath resolved"); } catch (error) {\n\tif (error instanceof Error && error.message === "private managed-session scope subpath resolved") throw error;\n\tconst message = String(error);\n\tconst exportsRejected = /Package subpath .* is not defined by "exports"/.test(message);\n\tconst bunRejected = message.startsWith("ResolveMessage: Cannot find module '" + privateSubpath + "' from '") && message.endsWith("/probe.ts'");\n\tif (!exportsRejected && !bunRejected) throw new Error("private managed-session scope failed for an unexpected reason: " + message);\n}\nprocess.stdout.write(JSON.stringify({ root: Object.keys(root).sort(), sdk: Object.keys(sdk).sort() }));\n`,
+			`import * as fs from "node:fs/promises";\nimport * as path from "node:path";\nimport * as root from ${JSON.stringify(packageName)};\nimport * as sdk from ${JSON.stringify(`${packageName}/sdk`)};\nimport * as bus from ${JSON.stringify(`${packageName}/sdk/bus`)};\nconst required = [[root, "createAgentSession", "root"], [root, "SESSION_DIRECTORY_API_VERSION", "root"], [root, "resolveManagedSessionScope", "root"], [root, "listManagedSessionCandidates", "root"], [sdk, "createAgentSession", "sdk"], [bus, "createNotificationsExtension", "sdk/bus"], [sdk, "SESSION_DIRECTORY_API_VERSION", "sdk"], [sdk, "resolveManagedSessionScope", "sdk"], [sdk, "listManagedSessionCandidates", "sdk"]] as const;\nfor (const [module, name, subpath] of required) if (!(name in module)) throw new Error(subpath + " missing " + name);\nconst sandbox = path.join(process.cwd(), "managed-listing-smoke");\nconst cwd = path.join(sandbox, "workspace", "a-b", "c");\nconst agentDir = path.join(sandbox, "agent");\nconst sessionsRoot = path.join(agentDir, "sessions");\nawait fs.mkdir(cwd, { recursive: true });\nconst resolved = await sdk.resolveManagedSessionScope({ cwd, agentDir, sessionsRoot });\nif (resolved.kind !== "resolved") throw new Error("packed resolver failed: " + resolved.message);\nawait fs.mkdir(resolved.scope.directoryPath, { recursive: true, mode: 0o700 });\nawait fs.chmod(sessionsRoot, 0o700);\nawait fs.chmod(resolved.scope.directoryPath, 0o700);\nawait fs.writeFile(path.join(resolved.scope.directoryPath, ".gjc-managed-session-scope.v2.json"), JSON.stringify({ schemaVersion: 1, layoutVersion: 2, identityVersion: 1, platform: process.platform === "win32" ? "win32" : "posix", canonicalPath: resolved.scope.canonicalCwd, identityDigest: resolved.scope.directoryName.slice(3) }) + "\\n", { mode: 0o600 });\nconst transcriptPath = path.join(resolved.scope.directoryPath, "packed-session.jsonl");\nawait fs.writeFile(transcriptPath, JSON.stringify({ type: "session", id: "packed-session", cwd }) + "\\n", { mode: 0o600 });\nconst snapshot = async () => Promise.all((await fs.readdir(sandbox, { recursive: true })).sort().map(async name => { const pathname = path.join(sandbox, name); const stat = await fs.lstat(pathname); return [name, stat.mode, stat.size, stat.mtimeMs, stat.isFile() ? await fs.readFile(pathname, "utf8") : null]; }));\nconst before = JSON.stringify(await snapshot());\nconst listing = await sdk.listManagedSessionCandidates({ scope: resolved.scope });\nif (listing.kind !== "complete" || listing.owned.length !== 1 || listing.owned[0]?.sessionId !== "packed-session") throw new Error("packed readonly listing failed: " + JSON.stringify(listing));\nconst after = JSON.stringify(await snapshot());\nif (after !== before) throw new Error("packed readonly listing mutated the filesystem");\nconst privateSubpath = ${JSON.stringify(`${packageName}/session/internal/managed-session-scope`)};\ntry { await import(privateSubpath); throw new Error("private managed-session scope subpath resolved"); } catch (error) {\n\tif (error instanceof Error && error.message === "private managed-session scope subpath resolved") throw error;\n\tconst message = String(error);\n\tconst exportsRejected = /Package subpath .* is not defined by "exports"/.test(message);\n\tconst bunRejected = (message.startsWith("ResolveMessage: Cannot find module '" + privateSubpath + "' from '") && message.endsWith("/probe.ts'")) || (message.startsWith("ResolveMessage: Cannot find package '" + ${JSON.stringify(packageName)} + "' imported from ") && message.endsWith("/probe.ts"));\n\tif (!exportsRejected && !bunRejected) throw new Error("private managed-session scope failed for an unexpected reason: " + message);\n}\nprocess.stdout.write(JSON.stringify({ root: Object.keys(root).sort(), sdk: Object.keys(sdk).sort() }));\n`,
 		);
 		await fs.appendFile(
 			probePath,

package/scripts/check-autorouting-tier-map.ts

@@ -0,0 +1,183 @@
+#!/usr/bin/env bun
+
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { RETIRED_MODEL_KEYS } from "../../ai/src/model-retirements";
+import { isValidAutoroutingSelector } from "../src/config/autorouting-contract";
+import {
+	CURATED_TIER_LABELS,
+	type CuratedTierLabels,
+	TIER_MAP_SKIP_LIST,
+	type TierMapSkipList,
+} from "../src/config/autorouting-tier-map";
+
+export const BASELINE_SKIP_RATIONALE = "pre-feature baseline; not yet curated";
+const DISCOVERY_ONLY_PROVIDERS = new Set(["ollama", "vllm"]);
+const RETIRED_KEYS = new Set<string>(RETIRED_MODEL_KEYS);
+
+export type CommittedCatalogModel = {
+	id?: unknown;
+	provider?: unknown;
+	output?: unknown;
+	[key: string]: unknown;
+};
+
+export type CommittedCatalog = Record<string, Record<string, CommittedCatalogModel>>;
+
+export type AutoroutingTierMapGateReport = {
+	inScopeKeys: string[];
+	labeledKeys: string[];
+	skippedKeys: string[];
+	unlabeledKeys: string[];
+	invalidLabelKeys: string[];
+	outOfScopeLabelKeys: string[];
+	invalidSkipKeys: string[];
+	staleSkipKeys: string[];
+	baselineSkipCount: number;
+};
+
+function modelKey(provider: string, id: string): string {
+	return `${provider}/${id}`;
+}
+
+function isImageGenerationOnly(model: CommittedCatalogModel): boolean {
+	return Array.isArray(model.output) && model.output.length > 0 && model.output.every(output => output === "image");
+}
+
+export function isInAutoroutingGateScope(provider: string, id: string, model: CommittedCatalogModel): boolean {
+	const key = modelKey(provider, id);
+	return (
+		isValidAutoroutingSelector(key) &&
+		!RETIRED_KEYS.has(key) &&
+		!DISCOVERY_ONLY_PROVIDERS.has(provider) &&
+		!isImageGenerationOnly(model)
+	);
+}
+
+export function committedCatalogKeys(catalog: CommittedCatalog): string[] {
+	const keys: string[] = [];
+	for (const [provider, models] of Object.entries(catalog)) {
+		if (models === null || typeof models !== "object" || Array.isArray(models)) continue;
+		for (const [id, model] of Object.entries(models)) {
+			if (isInAutoroutingGateScope(provider, id, model)) keys.push(modelKey(provider, id));
+		}
+	}
+	return keys.sort((left, right) => left.localeCompare(right));
+}
+
+export function getAutoroutingTierMapGateReport(
+	catalog: CommittedCatalog,
+	labels: CuratedTierLabels = CURATED_TIER_LABELS,
+	skips: TierMapSkipList = TIER_MAP_SKIP_LIST,
+): AutoroutingTierMapGateReport {
+	const catalogKeys = new Set(committedCatalogKeys(catalog));
+	const labeledKeys = Object.keys(labels).sort((left, right) => left.localeCompare(right));
+	const skippedKeys = Object.keys(skips).sort((left, right) => left.localeCompare(right));
+	const invalidLabelKeys = labeledKeys.filter(key => !catalogKeys.has(key));
+	const outOfScopeLabelKeys = labeledKeys.filter(key => {
+		const separator = key.indexOf("/");
+		const provider = separator > 0 ? key.slice(0, separator) : key;
+		const id = separator > 0 ? key.slice(separator + 1) : "";
+		const rawModel = catalog[provider]?.[id];
+		return rawModel !== undefined && !isInAutoroutingGateScope(provider, id, rawModel);
+	});
+	const unlabeledKeys = [...catalogKeys].filter(key => !Object.hasOwn(labels, key) && !Object.hasOwn(skips, key));
+	const inScopeKeys = [...catalogKeys];
+	const inScopeSkipped = skippedKeys.filter(key => catalogKeys.has(key));
+	const invalidSkipKeys = skippedKeys.filter(key => {
+		const entry = (skips as Record<string, { rationale?: unknown }>)[key];
+		const rationale = entry?.rationale;
+		return typeof rationale !== "string" || rationale.trim().length === 0 || !isValidAutoroutingSelector(key);
+	});
+	const staleSkipKeys = skippedKeys.filter(key => !catalogKeys.has(key) && !invalidSkipKeys.includes(key));
+	// A key that is both labeled and skipped would let a curated tier assignment hide
+	// behind a skip rationale; it is an invalid skip, not a stale one.
+	const bothLabeledAndSkipped = skippedKeys.filter(key => Object.hasOwn(labels, key));
+	invalidSkipKeys.push(...bothLabeledAndSkipped.filter(key => !invalidSkipKeys.includes(key)));
+	return {
+		inScopeKeys,
+		labeledKeys,
+		skippedKeys: inScopeSkipped,
+		unlabeledKeys: unlabeledKeys.sort((left, right) => left.localeCompare(right)),
+		invalidLabelKeys,
+		outOfScopeLabelKeys,
+		invalidSkipKeys,
+		staleSkipKeys,
+		baselineSkipCount: inScopeSkipped.filter(
+			key => (skips as Record<string, { baseline?: true }>)[key]?.baseline === true,
+		).length,
+	};
+}
+
+export function findUnlabeledAutoroutingKeys(
+	catalog: CommittedCatalog,
+	labels: CuratedTierLabels = CURATED_TIER_LABELS,
+	skips: TierMapSkipList = TIER_MAP_SKIP_LIST,
+): string[] {
+	return getAutoroutingTierMapGateReport(catalog, labels, skips).unlabeledKeys;
+}
+
+export type AutoroutingTierMapGateResult = {
+	ok: boolean;
+	report: AutoroutingTierMapGateReport;
+};
+
+export function checkAutoroutingTierMap(
+	catalog: CommittedCatalog,
+	labels: CuratedTierLabels = CURATED_TIER_LABELS,
+	skips: TierMapSkipList = TIER_MAP_SKIP_LIST,
+): AutoroutingTierMapGateResult {
+	const report = getAutoroutingTierMapGateReport(catalog, labels, skips);
+	const ok =
+		report.unlabeledKeys.length === 0 &&
+		report.invalidLabelKeys.length === 0 &&
+		report.outOfScopeLabelKeys.length === 0 &&
+		report.invalidSkipKeys.length === 0 &&
+		report.staleSkipKeys.length === 0;
+	return { ok, report };
+}
+
+export async function loadCommittedCatalog(
+	repoRoot = path.resolve(import.meta.dir, "../../.."),
+): Promise<CommittedCatalog> {
+	const catalogPath = path.join(repoRoot, "packages/ai/src/models.json");
+	return JSON.parse(await fs.readFile(catalogPath, "utf8")) as CommittedCatalog;
+}
+
+export async function runAutoroutingTierMapGate(repoRoot?: string): Promise<AutoroutingTierMapGateResult> {
+	return checkAutoroutingTierMap(await loadCommittedCatalog(repoRoot));
+}
+
+export const checkTierMap = checkAutoroutingTierMap;
+export const findUnlabeledKeys = findUnlabeledAutoroutingKeys;
+export const runTierMapGate = runAutoroutingTierMapGate;
+
+function printFailure(report: AutoroutingTierMapGateReport): void {
+	const failures = [
+		...new Set([
+			...report.unlabeledKeys,
+			...report.invalidLabelKeys,
+			...report.outOfScopeLabelKeys,
+			...report.invalidSkipKeys,
+			...report.staleSkipKeys,
+		]),
+	].sort((a, b) => a.localeCompare(b));
+	console.error("Autorouting tier-map gate failed.");
+	console.error("Offending provider/model-id keys:");
+	for (const key of failures) console.error(`- ${key}`);
+	console.error(
+		"Add each new key to CURATED_TIER_LABELS with reviewed tier/rank data, or add it to TIER_MAP_SKIP_LIST with a non-empty rationale; remove skip entries whose key left the catalog or the selector grammar.",
+	);
+}
+
+if (import.meta.main) {
+	const result = await runAutoroutingTierMapGate();
+	if (!result.ok) {
+		printFailure(result.report);
+		process.exitCode = 1;
+	} else {
+		console.log(
+			`Autorouting tier-map gate passed: ${result.report.inScopeKeys.length} in-scope keys; ${result.report.baselineSkipCount} baseline skips.`,
+		);
+	}
+}

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

@@ -17,6 +17,8 @@ const LOCKED_EXCLUSIONS: Readonly<Record<string, string>> = {
 		"internal terminal-abort bus seam, threaded via terminalAbortSeams; not a user-facing SDK control seam",
 	"agent_session:abortPromptAndWaitWithTerminal":
 		"internal terminal-abort fencing seam, threaded via terminalAbortSeams; 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:settings": "visual/local-only command, not a user-facing SDK control seam",
 	"slash_command:theme": "visual/local-only command, not a user-facing SDK control seam",
 	"slash_command:copy": "visual/local-only command, not a user-facing SDK control seam",
@@ -73,6 +75,16 @@ const LOCKED_EXCLUSIONS: Readonly<Record<string, string>> = {
 	"agent_session:setForcedToolChoice": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:getActiveSkillState": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:getActiveSkillPhase": "internal accessor/plumbing, not a user-facing control seam",
+	"agent_session:getEffectiveActiveWorkflowSkillState":
+		"internal restored-or-live workflow guard for session rescope, not a user-facing SDK control seam",
+	"agent_session:replaceOwnedMcpManager":
+		"internal cwd-rebinding helper for owned MCP authority after move_session, not a user-facing SDK control seam",
+	"agent_session:replaceNamedCustomTools":
+		"internal cwd-rebinding helper for named custom tools after move_session, not a user-facing SDK control seam",
+	"agent_session:replaceSkills":
+		"internal cwd-rebinding helper for session skills after move_session, not a user-facing SDK control seam",
+	"agent_session:retireWorkspaceTreeForRescope":
+		"internal cwd-rebinding helper that retires the cached workspace tree after move_session, not a user-facing SDK control seam",
 	"agent_session:getDeepInterviewAskStage":
 		"internal AskTool schema-selection accessor, not a user-facing SDK control seam",
 	"agent_session:peekQueueInvoker": "internal accessor/plumbing, not a user-facing control seam",

package/scripts/generate-tool-catalog.ts

@@ -1,3 +1,5 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
 import * as path from "node:path";
 import { toolWireSchema } from "@gajae-code/ai/utils/schema";
 import { TaskTool } from "../src/task";
@@ -80,7 +82,8 @@ function makeSettings() {
 		"task.isolation.mode": "none",
 		"task.simpleMode": "off",
 		"task.simple": "default",
-		"task.parentSpawns": "*",
+		"task.parentSpawns": "executor,architect,planner,critic",
+		"task.allowedAgents": ["executor", "architect", "planner", "critic"],
 		disabledExtensions: [],
 		"memory.backend": "off",
 		"edit.fuzzyMatch": true,
@@ -94,14 +97,16 @@ function makeSettings() {
 		getGroup: (group: string) => {
 			if (group === "skills")
 				return { enabled: true, enablePiUser: true, enablePiProject: true, customDirectories: [] };
-			if (group === "task") return { disabledAgents: [] };
+			if (group === "task") return { disabledAgents: [], agents: [], allowedAgents: values["task.allowedAgents"] };
 			return {};
 		},
 		getNotificationSettingsSnapshot: () => ({ enabled: false, telegram: {}, discord: {}, slack: {} }),
+		// The catalog documents the default configuration, where autorouting is off.
+		getEffectiveAutorouting: () => ({ active: false }),
 	};
 }
 
-function makeSession(cwd: string = path.resolve(import.meta.dir, "../..")): any {
+function makeSession(cwd: string): any {
 	const settings = makeSettings();
 	return {
 		cwd,
@@ -113,6 +118,7 @@ function makeSession(cwd: string = path.resolve(import.meta.dir, "../..")): any
 		hasEditTool: true,
 		taskDepth: 0,
 		currentAgentType: "executor",
+		rescopeSessionCwd: async () => ({ from: cwd, to: cwd }),
 		getSessionFile: () => null,
 		getSessionSpawns: () => null,
 		getSessionId: () => "catalog",
@@ -316,7 +322,21 @@ export async function generateToolCatalogData(
 	options: ToolCatalogGenerationOptions = {},
 ): Promise<Record<string, GeneratedToolCatalogEntry>> {
 	const previousEditVariant = process.env.GJC_EDIT_VARIANT;
+	const previousHome = process.env.HOME;
+	const previousGjcConfigDir = process.env.GJC_CONFIG_DIR;
+	const previousPiConfigDir = process.env.PI_CONFIG_DIR;
+	const previousGjcCodingAgentDir = process.env.GJC_CODING_AGENT_DIR;
+	const previousPiCodingAgentDir = process.env.PI_CODING_AGENT_DIR;
+	const isolatedRoot = await fs.mkdtemp(path.join(os.tmpdir(), "gjc-tool-catalog-"));
+	const gitInit = Bun.spawnSync(["git", "init", "--quiet", isolatedRoot]);
+	if (gitInit.exitCode !== 0)
+		throw new Error(`Failed to initialize isolated tool-catalog repository: ${gitInit.stderr}`);
 	process.env.GJC_EDIT_VARIANT = "replace";
+	process.env.HOME = path.join(isolatedRoot, "home");
+	process.env.GJC_CONFIG_DIR = ".gjc-catalog";
+	process.env.PI_CONFIG_DIR = ".gjc-catalog";
+	process.env.GJC_CODING_AGENT_DIR = path.join(isolatedRoot, "agent");
+	process.env.PI_CODING_AGENT_DIR = path.join(isolatedRoot, "agent");
 	const platform = options.platform ?? process.platform;
 	const arch = options.arch ?? process.arch;
 	try {
@@ -328,7 +348,7 @@ export async function generateToolCatalogData(
 			...HIDDEN_TOOL_DESCRIPTORS,
 			...PLATFORM_EXCLUDED_TOOL_DESCRIPTORS,
 		} as Record<string, any>;
-		const session = makeSession(options.cwd);
+		const session = makeSession(isolatedRoot);
 		const output: Record<string, GeneratedToolCatalogEntry> = {};
 		for (const [name, descriptor] of Object.entries(all)) {
 			let fallback: AuditedFallback | undefined;
@@ -432,10 +452,14 @@ export async function generateToolCatalogData(
 			const choose = <T>(key: string, descriptorValue: T | undefined): T | undefined =>
 				fallback ? (read(key) as T | undefined) : ((read(key) as T | undefined) ?? descriptorValue);
 			const intent = choose("intent", descriptor.metadata.intent);
+			const description = choose("description", descriptor.metadata.description);
 			const entry: GeneratedToolCatalogEntry = {
 				name,
 				label: choose("label", descriptor.presentation.label),
-				description: choose("description", descriptor.metadata.description),
+				description:
+					name === "task" && typeof description === "string"
+						? description.replace(/\n# reviewer\n[^\n]*\n\n/g, "")
+						: description,
 				parameters: serializeCatalogValue(name, "parameters", parameters) as Record<string, unknown>,
 				strict: choose("strict", descriptor.metadata.strict),
 				hidden: choose("hidden", descriptor.metadata.hidden),
@@ -465,6 +489,17 @@ export async function generateToolCatalogData(
 	} finally {
 		if (previousEditVariant === undefined) delete process.env.GJC_EDIT_VARIANT;
 		else process.env.GJC_EDIT_VARIANT = previousEditVariant;
+		if (previousHome === undefined) delete process.env.HOME;
+		else process.env.HOME = previousHome;
+		if (previousGjcConfigDir === undefined) delete process.env.GJC_CONFIG_DIR;
+		else process.env.GJC_CONFIG_DIR = previousGjcConfigDir;
+		if (previousPiConfigDir === undefined) delete process.env.PI_CONFIG_DIR;
+		else process.env.PI_CONFIG_DIR = previousPiConfigDir;
+		if (previousGjcCodingAgentDir === undefined) delete process.env.GJC_CODING_AGENT_DIR;
+		else process.env.GJC_CODING_AGENT_DIR = previousGjcCodingAgentDir;
+		if (previousPiCodingAgentDir === undefined) delete process.env.PI_CODING_AGENT_DIR;
+		else process.env.PI_CODING_AGENT_DIR = previousPiCodingAgentDir;
+		await fs.rm(isolatedRoot, { recursive: true, force: true });
 	}
 }
 

package/src/async/job-manager.ts

@@ -6,7 +6,7 @@ import {
 	retireOwnedRegistrationForDeadLetter,
 	unregisterOwnedRegistration,
 } from "../session/terminal-abort";
-import type { AgentProgress, AgentSource } from "../task/types";
+import type { AgentProgress, AgentSource, LocalErrorSummary } from "../task/types";
 
 const DELIVERY_RETRY_BASE_MS = 500;
 const DELIVERY_RETRY_MAX_MS = 30_000;
@@ -42,6 +42,8 @@ export interface AsyncJob {
 	errorText?: string;
 	/** Safe, bounded cause when session setup failed before the LLM began work. */
 	setupFailureSummary?: string;
+	/** Safe, bounded summary of a terminal local (non-provider) failure kind. */
+	localErrorSummary?: LocalErrorSummary;
 	metadata?: AsyncJobMetadata;
 	/**
 	 * Registry id of the agent that registered the job (e.g. "0-Main",
@@ -85,7 +87,7 @@ export interface AsyncJobMetadata {
  */
 export type SubagentRunOutcome =
 	| { kind: "completed"; text: string }
-	| { kind: "failed"; text: string; setupFailureSummary?: string }
+	| { kind: "failed"; text: string; setupFailureSummary?: string; localErrorSummary?: LocalErrorSummary }
 	| { kind: "paused"; note?: string };
 
 /** Canonical lifecycle of a subagent across pause/resume cycles. */
@@ -985,6 +987,7 @@ export class AsyncJobManager {
 				if (outcome.kind === "failed") {
 					job.status = "failed";
 					job.setupFailureSummary = outcome.setupFailureSummary;
+					job.localErrorSummary = outcome.localErrorSummary;
 					this.#freezeEndTime(job);
 					job.errorText = outcome.text;
 					this.#markRecordTerminal(id, "failed", job.generation);