@gajae-code/coding-agent 0.16.1 → 0.16.4

package/scripts/capture-status-line-custom-editor-showcase.ts

@@ -0,0 +1,151 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import {
+	renderStatusLineCustomEditorShowcase,
+	STATUS_LINE_CUSTOM_EDITOR_SHOWCASE_ENTRIES,
+	type StatusLineCustomEditorShowcaseEntry,
+} from "../test/fixtures/tui/status-line-custom-editor-showcase";
+import { ansiToHtml } from "./capture-sticky-viewport-showcase";
+
+const CANONICAL_COMMAND =
+	"bun packages/coding-agent/scripts/capture-status-line-custom-editor-showcase.ts --out .gjc/qa/status-line-custom-editor-<run>";
+const CAPTURE_TOOL_VERSION = "status-line-custom-editor-showcase-v1";
+const SOURCE_PATHS = [
+	"packages/coding-agent/src/modes/components/settings-selector.ts",
+	"packages/coding-agent/src/modes/components/tool-status-header.ts",
+	"packages/coding-agent/src/modes/controllers/selector-controller.ts",
+	"packages/tui/src/components/settings-list.ts",
+	"packages/coding-agent/test/fixtures/tui/status-line-custom-editor-showcase.ts",
+	"packages/coding-agent/scripts/verify-status-line-custom-editor-showcase.ts",
+] as const;
+
+interface ArtifactFile {
+	path: string;
+	sha256: string;
+	byte_length: number;
+}
+
+interface ManifestEntry {
+	key: string;
+	stateId: string;
+	viewport: { columns: number; rows: number };
+	renderMode: string;
+	simulatedStatusbarRows: number;
+	files: ArtifactFile[];
+}
+
+function usage(): never {
+	throw new Error(`Usage: ${CANONICAL_COMMAND}`);
+}
+
+function outputPath(args: string[]): string {
+	if (args.length !== 2 || args[0] !== "--out" || !args[1]) usage();
+	return args[1];
+}
+
+function json(value: unknown): string {
+	return `${JSON.stringify(value, null, 2)}\n`;
+}
+
+function sha256(value: string): string {
+	return new Bun.CryptoHasher("sha256").update(value).digest("hex");
+}
+
+function commandOutput(command: string[]): string | undefined {
+	const result = Bun.spawnSync({ cmd: command, stdout: "pipe", stderr: "pipe" });
+	if (result.exitCode !== 0) return undefined;
+	const output = result.stdout.toString().trim();
+	return output || undefined;
+}
+
+async function sourceHash(): Promise<string> {
+	const entries = await Promise.all(
+		SOURCE_PATHS.map(async sourcePath => `${sourcePath}:${sha256(await Bun.file(sourcePath).text())}`),
+	);
+	return `sha256:${sha256(entries.join("\n"))}`;
+}
+
+function entryKey(entry: StatusLineCustomEditorShowcaseEntry): string {
+	return `${entry.stateId}/${entry.columns}x${entry.rows}/${entry.renderMode}`;
+}
+
+function simulatedStatusbarRows(text: string): number {
+	const lines = Bun.stripANSI(text).split("\n");
+	const heading = lines.findIndex(line => line.includes("Simulated statusbar"));
+	if (heading < 0) return 0;
+	let end = heading + 1;
+	while (end < lines.length && lines[end]?.trim() && !lines[end]?.includes("Warning:")) end++;
+	return Math.max(0, end - heading - 1);
+}
+
+async function writeArtifact(root: string, relativePath: string, content: string): Promise<ArtifactFile> {
+	const fullPath = path.join(root, relativePath);
+	await fs.mkdir(path.dirname(fullPath), { recursive: true });
+	await Bun.write(fullPath, content);
+	return { path: relativePath, sha256: sha256(content), byte_length: Buffer.byteLength(content) };
+}
+
+async function main(): Promise<void> {
+	const root = outputPath(process.argv.slice(2));
+	const sourceHead = commandOutput(["git", "rev-parse", "HEAD"]);
+	if (!sourceHead) throw new Error("Could not resolve source HEAD");
+	const captureActor = commandOutput(["gh", "api", "user", "--jq", ".login"]) ?? "unauthenticated";
+	const digest = await sourceHash();
+	const independentReviewPath = path.join(root, "independent-review.json");
+	const existingIndependentReview = (await Bun.file(independentReviewPath).exists())
+		? await Bun.file(independentReviewPath).text()
+		: undefined;
+	await fs.rm(root, { recursive: true, force: true });
+	await fs.mkdir(root, { recursive: true });
+	if (existingIndependentReview !== undefined) {
+		await Bun.write(independentReviewPath, existingIndependentReview);
+	}
+	const entries: ManifestEntry[] = [];
+	for (const entry of STATUS_LINE_CUSTOM_EDITOR_SHOWCASE_ENTRIES) {
+		const key = entryKey(entry);
+		const dir = key.replace(/[^a-zA-Z0-9._/-]/g, "_");
+		const terminalAnsi = await renderStatusLineCustomEditorShowcase(entry);
+		const renderedRows = terminalAnsi.split("\n").length;
+		if (renderedRows > entry.rows) {
+			throw new Error(`${key}: rendered ${renderedRows} rows for a ${entry.rows}-row viewport`);
+		}
+		const statusbarRows = simulatedStatusbarRows(terminalAnsi);
+		const terminalPlain = Bun.stripANSI(terminalAnsi);
+		const html = ansiToHtml(terminalAnsi);
+		const metadata = json({
+			tool: CAPTURE_TOOL_VERSION,
+			command: CANONICAL_COMMAND,
+			stateId: entry.stateId,
+			viewport: { columns: entry.columns, rows: entry.rows },
+			renderMode: entry.renderMode,
+			fixedClock: "2026-01-01T00:00:00.000Z",
+			simulatedStatusbarRows: statusbarRows,
+			wrappingPolicy: statusbarRows > 2 ? "two-row" : "single-row",
+		});
+		const files = [
+			await writeArtifact(root, `${dir}/terminal.txt`, terminalPlain),
+			await writeArtifact(root, `${dir}/terminal-ansi.txt`, terminalAnsi),
+			await writeArtifact(root, `${dir}/terminal.html`, html),
+			await writeArtifact(root, `${dir}/metadata.json`, metadata),
+		];
+		entries.push({
+			key,
+			stateId: entry.stateId,
+			viewport: { columns: entry.columns, rows: entry.rows },
+			renderMode: entry.renderMode,
+			simulatedStatusbarRows: statusbarRows,
+			files,
+		});
+	}
+	await writeArtifact(
+		root,
+		"manifest.json",
+		json({ tool: CAPTURE_TOOL_VERSION, sourceHead, sourceHash: digest, captureActor, entries }),
+	);
+	process.stdout.write(`Captured ${entries.length} status-line custom editor showcase entries at ${root}\n`);
+}
+
+void main().catch(error => {
+	process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+	process.exit(1);
+});

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

@@ -11,6 +11,8 @@ const inventoryPath = process.env.GJC_SDK_OPERATION_INVENTORY
 
 /** Reviewed seams deliberately excluded from the public SDK operation surface. */
 const LOCKED_EXCLUSIONS: Readonly<Record<string, string>> = {
+	"agent_session:reloadSkills":
+		"internal marketplace lifecycle refresh for the session skill catalog; not an independent SDK ingress operation",
 	"agent_session:getTerminalTurnEpoch":
 		"internal terminal-abort bus seam (epoch only), threaded via terminalAbortSeams; not a user-facing SDK control seam",
 	"agent_session:cancelPendingPreflightForTerminalAbort":
@@ -119,6 +121,13 @@ const LOCKED_EXCLUSIONS: Readonly<Record<string, string>> = {
 		"test-only parked terminal flush seam, 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",
+	"agent_session:setDisposeTimeoutForTests": "test-only disposal timeout seam, not a user-facing SDK control seam",
+	"agent_session:trackPostPromptTaskForTests": "test-only post-prompt task seam, not a user-facing SDK control seam",
+	"agent_session:requestWorkerIntegrationForTests":
+		"test-only worker integration seam, not a user-facing SDK control seam",
+	"agent_session:runWithPromptAdmissionForTests":
+		"test-only prompt admission seam, not a user-facing SDK control seam",
 	"agent_session:getAgentId": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:emitNotice": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:subscribe": "internal accessor/plumbing, not a user-facing control seam",

package/scripts/verify-status-line-custom-editor-showcase.ts

@@ -0,0 +1,309 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { ansiToHtml } from "./capture-sticky-viewport-showcase";
+
+const CAPTURE_TOOL_VERSION = "status-line-custom-editor-showcase-v1";
+const CANONICAL_COMMAND =
+	"bun packages/coding-agent/scripts/capture-status-line-custom-editor-showcase.ts --out .gjc/qa/status-line-custom-editor-<run>";
+const FIXED_CLOCK = "2026-01-01T00:00:00.000Z";
+
+const UNICODE_STATES = [
+	"root-statusbar",
+	"picked-origin-slot",
+	"palette-exact-insert",
+	"separator-control",
+	"separator-choice-focused",
+	"separator-choice-applied",
+	"option-boolean-choice-focused",
+	"option-enum-choice-focused",
+	"option-numeric-choice-focused",
+	"option-choice-applied",
+	"exit-restored",
+	"confirm-persisted",
+	"overflow-two-row-warning",
+] as const;
+const ASCII_STATES = [
+	"root-statusbar",
+	"picked-origin-slot",
+	"separator-choice-focused",
+	"option-boolean-choice-focused",
+	"option-enum-choice-focused",
+	"option-numeric-choice-focused",
+] as const;
+const EXPECTED_KEYS = new Set([
+	...UNICODE_STATES.map(state => `${state}/80x32/unicode-color`),
+	"overflow-two-row-warning/48x40/unicode-color",
+	"narrow-cjk/48x40/unicode-color",
+	...ASCII_STATES.map(state => `${state}/80x32/ascii-no-color`),
+]);
+
+function expectedWrappingPolicy(statusbarRows: number): string {
+	return statusbarRows > 2 ? "two-row" : "single-row";
+}
+
+interface ManifestFile {
+	tool: string;
+	sourceHead: string;
+	sourceHash: string;
+	captureActor: string;
+	entries: Array<{
+		key: string;
+		stateId: string;
+		viewport: { columns: number; rows: number };
+		renderMode: string;
+		simulatedStatusbarRows: number;
+		files: Array<{ path: string; sha256: string; byte_length: number }>;
+	}>;
+	independentReview?: {
+		reviewer: string;
+		reviewerAssociation: "OWNER" | "MEMBER" | "COLLABORATOR";
+		verdict: "approved" | "rejected";
+		evidence: string;
+		manifestSha256?: string;
+		sourceHash?: string;
+		headSha?: string;
+	};
+}
+
+function sha256(value: string): string {
+	return new Bun.CryptoHasher("sha256").update(value).digest("hex");
+}
+
+function measuredStatusbarRows(plain: string): number {
+	const lines = plain.split("\n");
+	const heading = lines.findIndex(line => line.includes("Simulated statusbar"));
+	if (heading < 0) return 0;
+	let end = heading + 1;
+	while (end < lines.length && lines[end]?.trim() && !lines[end]?.includes("Warning:")) end++;
+	return Math.max(0, end - heading - 1);
+}
+
+function parseArgs(args: string[]): { root: string; requireIndependentReview: boolean } {
+	let root = "";
+	let requireIndependentReview = false;
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--root") root = args[++i] ?? "";
+		else if (arg === "--require-independent-review") requireIndependentReview = true;
+		else throw new Error(`Unknown argument: ${arg}`);
+	}
+	if (!root) {
+		throw new Error(
+			"Usage: bun packages/coding-agent/scripts/verify-status-line-custom-editor-showcase.ts --root <dir> [--require-independent-review]",
+		);
+	}
+	return { root, requireIndependentReview };
+}
+
+async function readText(root: string, relativePath: string): Promise<string> {
+	const fullPath = path.resolve(root, relativePath);
+	const resolvedRoot = path.resolve(root);
+	if (!fullPath.startsWith(`${resolvedRoot}${path.sep}`)) throw new Error(`Artifact escapes root: ${relativePath}`);
+	return await Bun.file(fullPath).text();
+}
+
+async function tryReadReview(root: string): Promise<ManifestFile["independentReview"] | undefined> {
+	const reviewPath = path.join(root, "independent-review.json");
+	if (!(await Bun.file(reviewPath).exists())) return undefined;
+	return JSON.parse(await Bun.file(reviewPath).text()) as ManifestFile["independentReview"];
+}
+
+async function collectRelativeFiles(root: string, dir = ""): Promise<string[]> {
+	const fullDir = path.join(root, dir);
+	const entries = await fs.readdir(fullDir, { withFileTypes: true });
+	const files: string[] = [];
+	for (const entry of entries) {
+		const relative = dir ? `${dir}/${entry.name}` : entry.name;
+		if (entry.isDirectory()) {
+			files.push(...(await collectRelativeFiles(root, relative)));
+		} else if (entry.isFile()) {
+			files.push(relative);
+		}
+	}
+	return files;
+}
+
+function requireWitness(entry: ManifestFile["entries"][number], plain: string): void {
+	if (entry.stateId === "exit-restored" || entry.stateId === "confirm-persisted") {
+		if (!plain.includes("Status Line")) throw new Error(`${entry.key}: missing returned settings witness`);
+		return;
+	}
+	const baseWitnesses = [
+		"Status Line Custom Editor",
+		"Simulated statusbar",
+		"Hidden segment palette",
+		"Visible choices",
+	];
+	for (const witness of baseWitnesses) {
+		if (!plain.includes(witness)) throw new Error(`${entry.key}: missing witness ${witness}`);
+	}
+	if (entry.stateId.includes("choice-focused") && !plain.includes("Choices:")) {
+		throw new Error(`${entry.key}: missing choice panel witness`);
+	}
+	if (
+		entry.stateId === "picked-origin-slot" &&
+		(!plain.includes("Selected:") || plain.includes("Floating ghost") || plain.includes("Origin "))
+	) {
+		throw new Error(`${entry.key}: missing selected witness or stale ghost/origin text present`);
+	}
+	if (entry.stateId.includes("overflow") && !plain.includes("Warning: statusbar wrapped to 2 rows")) {
+		throw new Error(`${entry.key}: missing overflow warning`);
+	}
+	if (entry.stateId === "narrow-cjk" && !/[\u3131-\uD7A3\u3040-\u30FF\u3400-\u9FFF]/.test(plain)) {
+		throw new Error(`${entry.key}: missing CJK width witness`);
+	}
+	if (plain.includes("Move left:") || plain.includes("Move right:") || plain.includes("Segment: gajae")) {
+		throw new Error(`${entry.key}: legacy row witness present`);
+	}
+}
+
+async function main(): Promise<void> {
+	const { root, requireIndependentReview } = parseArgs(process.argv.slice(2));
+	const manifestText = await Bun.file(path.join(root, "manifest.json")).text();
+	const manifest = JSON.parse(manifestText) as ManifestFile;
+	const manifestSha256 = sha256(manifestText);
+	if (manifest.tool !== CAPTURE_TOOL_VERSION) throw new Error(`Unexpected tool version: ${manifest.tool}`);
+	if (!/^[0-9a-f]{40}$/.test(manifest.sourceHead)) throw new Error("Manifest source HEAD is not a full commit SHA");
+	if (!/^sha256:[0-9a-f]{64}$/.test(manifest.sourceHash)) throw new Error("Manifest source hash is invalid");
+	const actualKeys = new Set(manifest.entries.map(entry => entry.key));
+	if (manifest.entries.length !== actualKeys.size) throw new Error("Duplicate showcase entries found");
+	if (manifest.entries.length !== EXPECTED_KEYS.size) throw new Error("Unexpected showcase entry count");
+	for (const key of EXPECTED_KEYS) if (!actualKeys.has(key)) throw new Error(`Missing showcase key: ${key}`);
+	for (const key of actualKeys) if (!EXPECTED_KEYS.has(key)) throw new Error(`Unexpected showcase key: ${key}`);
+	if (requireIndependentReview) {
+		const review = manifest.independentReview ?? (await tryReadReview(root));
+		if (
+			review?.verdict !== "approved" ||
+			!review.reviewer?.trim() ||
+			review.reviewer === manifest.captureActor ||
+			!(["OWNER", "MEMBER", "COLLABORATOR"] as const).includes(review.reviewerAssociation) ||
+			!/^https:\/\/github\.com\//.test(review.evidence) ||
+			review.manifestSha256 !== manifestSha256 ||
+			review.sourceHash !== manifest.sourceHash ||
+			review.headSha !== manifest.sourceHead
+		) {
+			throw new Error("Missing approved independent review in manifest");
+		}
+	}
+	const artifactPaths = new Set<string>();
+	const expectedRootFiles = new Set(["manifest.json"]);
+	if (await Bun.file(path.join(root, "independent-review.json")).exists())
+		expectedRootFiles.add("independent-review.json");
+	for (const entry of manifest.entries) {
+		if (entry.key !== `${entry.stateId}/${entry.viewport.columns}x${entry.viewport.rows}/${entry.renderMode}`) {
+			throw new Error(`${entry.key}: key does not match manifest fields`);
+		}
+		const expectedDirectory = entry.key.replace(/[^a-zA-Z0-9._/-]/g, "_");
+		const names = new Set(entry.files.map(file => path.basename(file.path)));
+		if (names.size !== 4 || entry.files.length !== 4)
+			throw new Error(`${entry.key}: artifact membership is not exact`);
+		for (const required of ["terminal.txt", "terminal-ansi.txt", "terminal.html", "metadata.json"]) {
+			if (!names.has(required)) throw new Error(`${entry.key}: missing ${required}`);
+		}
+		for (const file of entry.files) {
+			if (!file.path.startsWith(`${expectedDirectory}/`)) {
+				throw new Error(`${entry.key}: artifact path is not bound to canonical entry directory`);
+			}
+			if (artifactPaths.has(file.path)) throw new Error(`${entry.key}: duplicate artifact path ${file.path}`);
+			artifactPaths.add(file.path);
+			const content = await readText(root, file.path);
+			if (sha256(content) !== file.sha256) throw new Error(`${entry.key}: sha mismatch for ${file.path}`);
+			if (Buffer.byteLength(content) !== file.byte_length) {
+				throw new Error(`${entry.key}: byte length mismatch for ${file.path}`);
+			}
+		}
+		const plainPath = entry.files.find(file => path.basename(file.path) === "terminal.txt")?.path;
+		const ansiPath = entry.files.find(file => path.basename(file.path) === "terminal-ansi.txt")?.path;
+		const htmlPath = entry.files.find(file => path.basename(file.path) === "terminal.html")?.path;
+		const metadataPath = entry.files.find(file => path.basename(file.path) === "metadata.json")?.path;
+		if (!plainPath || !ansiPath || !htmlPath || !metadataPath) throw new Error(`${entry.key}: incomplete file list`);
+		const plain = await readText(root, plainPath);
+		const ansi = await readText(root, ansiPath);
+		const html = await readText(root, htmlPath);
+		if (Bun.stripANSI(ansi) !== plain) throw new Error(`${entry.key}: stripped ANSI differs from plain text`);
+		if (html !== ansiToHtml(ansi)) throw new Error(`${entry.key}: HTML artifact is not canonical ANSI conversion`);
+		if (plain.split("\n").length > entry.viewport.rows) {
+			throw new Error(`${entry.key}: terminal row count exceeds declared viewport`);
+		}
+		for (const line of plain.split("\n")) {
+			if (Bun.stringWidth(line) > entry.viewport.columns) {
+				throw new Error(`${entry.key}: terminal line exceeds declared viewport width`);
+			}
+		}
+		if (entry.renderMode === "ascii-no-color") {
+			if (/\x1b\[[0-9;]*m/.test(ansi)) throw new Error(`${entry.key}: ascii-no-color artifact contains ANSI`);
+			if (/[^\x09\x0a\x0d\x20-\x7e]/.test(plain)) {
+				throw new Error(`${entry.key}: ascii-no-color artifact contains non-ASCII glyphs`);
+			}
+		}
+		const metadata = JSON.parse(await readText(root, metadataPath)) as {
+			tool?: string;
+			command?: string;
+			stateId?: string;
+			viewport?: { columns?: number; rows?: number };
+			renderMode?: string;
+			fixedClock?: string;
+			simulatedStatusbarRows?: number;
+			wrappingPolicy?: string;
+		};
+		const actualStatusbarRows = measuredStatusbarRows(plain);
+		if (
+			metadata.tool !== CAPTURE_TOOL_VERSION ||
+			metadata.command !== CANONICAL_COMMAND ||
+			metadata.stateId !== entry.stateId ||
+			metadata.viewport?.columns !== entry.viewport.columns ||
+			metadata.viewport?.rows !== entry.viewport.rows ||
+			metadata.renderMode !== entry.renderMode ||
+			metadata.fixedClock !== FIXED_CLOCK ||
+			entry.simulatedStatusbarRows !== actualStatusbarRows ||
+			metadata.simulatedStatusbarRows !== actualStatusbarRows ||
+			metadata.wrappingPolicy !== expectedWrappingPolicy(actualStatusbarRows)
+		) {
+			throw new Error(`${entry.key}: metadata does not match manifest`);
+		}
+		requireWitness(entry, plain);
+		if (entry.stateId === "palette-exact-insert" && (plain.includes("Selected:") || plain.includes("{gajae}"))) {
+			throw new Error(`${entry.key}: exact insertion state still has floating/hidden segment evidence`);
+		}
+		if (entry.stateId === "palette-exact-insert" && !plain.includes("left model / path /")) {
+			throw new Error(`${entry.key}: exact insertion state missing ordered layout witness`);
+		}
+		if (
+			entry.stateId === "exit-restored" &&
+			!plain.includes("left=model,path,git right=session_name,jobs separator=slash")
+		) {
+			throw new Error(`${entry.key}: exit-restored state missing exact restored preview witness`);
+		}
+		if (
+			entry.stateId === "confirm-persisted" &&
+			!plain.includes("left=path,git right=session_name,jobs separator=slash")
+		) {
+			throw new Error(`${entry.key}: confirm-persisted state missing exact persisted preview witness`);
+		}
+		if (entry.stateId === "separator-choice-applied" && !plain.includes("[Pipe]")) {
+			throw new Error(`${entry.key}: separator applied state missing Pipe witness`);
+		}
+		if (entry.stateId === "option-choice-applied" && !plain.includes("[40]")) {
+			throw new Error(`${entry.key}: option applied state missing numeric option witness`);
+		}
+		if (entry.stateId.includes("narrow") && !plain.includes("Focused target:")) {
+			throw new Error(`${entry.key}: narrow state missing focused target witness`);
+		}
+		if (entry.stateId === "overflow-two-row-warning" && actualStatusbarRows !== 4) {
+			throw new Error(`${entry.key}: expected two actual and two slot statusbar rows`);
+		}
+		if (entry.stateId === "narrow-cjk" && !plain.includes("상태줄 경계 · 意味の境界 · 语义边界")) {
+			throw new Error(`${entry.key}: missing exact mixed-width semantic witness`);
+		}
+	}
+	for (const filePath of await collectRelativeFiles(root)) {
+		if (expectedRootFiles.has(filePath)) continue;
+		if (!artifactPaths.has(filePath)) throw new Error(`Unmanifested artifact file: ${filePath}`);
+	}
+	process.stdout.write(`Verified ${manifest.entries.length} status-line custom editor showcase entries at ${root}\n`);
+}
+
+void main().catch(error => {
+	process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+	process.exit(1);
+});

package/src/cli/args.ts

@@ -2,12 +2,18 @@
  * CLI argument parsing
  */
 import * as path from "node:path";
-import { type Effort, THINKING_EFFORTS } from "@gajae-code/ai/core";
+import { ThinkingLevel } from "@gajae-code/agent-core";
 import { logger } from "@gajae-code/utils";
 import { CliParseError } from "@gajae-code/utils/cli";
-import { parseEffort } from "../thinking";
+import { parseThinkingLevel } from "../thinking";
 import { BUILTIN_TOOLS } from "../tools";
-import { type ConsumerLaunchFlagName, LAUNCH_PARSE_FLAGS, launchFlagIsOwnedBy } from "./root-flags";
+import {
+	type ConsumerLaunchFlagName,
+	LAUNCH_PARSE_FLAGS,
+	launchFlagIsOwnedBy,
+	ROOT_THINKING_LEVELS,
+	type RootThinkingLevel,
+} from "./root-flags";
 
 const ROOT_FLAG_TOKENS = new Set<string>();
 for (const [name, descriptor] of Object.entries(LAUNCH_PARSE_FLAGS)) {
@@ -55,7 +61,7 @@ export interface Args {
 	mcpConfig?: string;
 	/** Opt a standalone session out of conventional MCP autoload (mutually exclusive with --mcp-config). */
 	noMcp?: boolean;
-	thinking?: Effort;
+	thinking?: RootThinkingLevel;
 	continue?: boolean;
 	resume?: string | true;
 	help?: boolean;
@@ -138,6 +144,7 @@ export function parseArgs(args: string[], authority: ParseArgsAuthority = "local
 		unknownFlags: new Map(),
 	};
 	const consumerFlags = new Map<ConsumerLaunchFlagName, string>();
+	let hasThinkingFlag = false;
 
 	for (let i = 0; i < args.length; i++) {
 		let arg = args[i];
@@ -344,19 +351,23 @@ export function parseArgs(args: string[], authority: ParseArgsAuthority = "local
 			}
 			result.tools = validTools;
 		} else if (arg === "--thinking") {
+			if (hasThinkingFlag) {
+				throw new CliParseError("--thinking can only be specified once");
+			}
+			hasThinkingFlag = true;
 			// Match --credential / --mcp-config: a missing value or a following flag is
 			// a usage error, not a silent no-op / accidental consumption of `-p`.
 			const next = args[i + 1];
 			if (!next || next.startsWith("-")) {
-				throw new CliParseError(`--thinking requires <level> (${THINKING_EFFORTS.join(", ")})`);
+				throw new CliParseError(`--thinking requires <level> (${ROOT_THINKING_LEVELS.join(", ")})`);
 			}
 			const rawThinking = args[++i];
-			const thinking = parseEffort(rawThinking);
-			if (thinking === undefined) {
+			const thinking = parseThinkingLevel(rawThinking);
+			if (thinking === undefined || thinking === ThinkingLevel.Inherit) {
 				// Fail closed: a silent ignore left users believing `ultra` (or any typo)
-				// was applied. Help / Flags.options advertise the real Effort enum.
+				// was applied. Help / Flags.options advertise the root thinking levels.
 				throw new CliParseError(
-					`Invalid --thinking level "${rawThinking}". Expected one of: ${THINKING_EFFORTS.join(", ")}`,
+					`Invalid --thinking level "${rawThinking}". Expected one of: ${ROOT_THINKING_LEVELS.join(", ")}`,
 				);
 			}
 			result.thinking = thinking;

package/src/cli/root-flags.ts

@@ -1,6 +1,8 @@
+import { THINKING_EFFORTS } from "@gajae-code/ai/core";
 import { type FlagDescriptor, Flags } from "@gajae-code/utils/cli";
 
-const ROOT_THINKING_EFFORTS = ["minimal", "low", "medium", "high", "xhigh", "max"] as const;
+export const ROOT_THINKING_LEVELS = ["off", ...THINKING_EFFORTS] as const;
+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 = {
@@ -63,8 +65,8 @@ export const ROOT_LAUNCH_FLAGS = {
 	tmux: Flags.boolean({ description: "Launch interactive startup inside tmux" }),
 	tools: Flags.string({ description: "Comma-separated list of tools to enable (default: all)" }),
 	thinking: Flags.string({
-		description: `Set thinking level: ${ROOT_THINKING_EFFORTS.join(", ")}`,
-		options: ROOT_THINKING_EFFORTS,
+		description: `Set thinking level: ${ROOT_THINKING_LEVELS.join(", ")}`,
+		options: ROOT_THINKING_LEVELS,
 	}),
 	"no-rules": Flags.boolean({ description: "Disable rules discovery and loading" }),
 	export: Flags.string({ description: "Export session file to HTML and exit" }),

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

@@ -359,6 +359,7 @@ export const TIER_MAP_SKIP_LIST = {
 	"nvidia/poolside/laguna-xs-2.1": { rationale: "post-rebase catalog addition from dev; not yet curated" },
 	"nvidia/thinkingmachines/inkling": { rationale: "post-rebase catalog addition from dev; not yet curated" },
 	"nvidia/upstage/solar-10.7b-instruct": { rationale: "post-rebase catalog addition from dev; not yet curated" },
+	"openai-codex/gpt-6-astra": { rationale: "GPT-6 Astra catalog addition (2026-09-03 release); not yet curated" },
 	"openai-codex/gpt-daybreak-blue-latest": { rationale: "post-rebase catalog addition from dev; not yet curated" },
 	"opencode-go/deepseek-v4-flash-vision-exp": {
 		rationale: "post-rebase catalog addition from dev; not yet curated",