@gajae-code/coding-agent 0.16.3 → 0.16.6

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":
@@ -113,12 +115,21 @@ const LOCKED_EXCLUSIONS: Readonly<Record<string, string>> = {
 	"agent_session:getPendingNextTurnMessagesForTests": "read-only test seam, not a user-facing SDK control seam",
 	"agent_session:queueCoordinatorRuntimeStatePersistForTests":
 		"test-only coordinator persistence ordering seam, not a user-facing SDK control seam",
+	"agent_session:awaitCoordinatorRuntimeStatePersistenceForTests":
+		"test-only coordinator persistence drain barrier, not a user-facing SDK control seam",
 	"agent_session:parkAgentEndForCoordinatorPersistForTests":
 		"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: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/capability/index.ts

@@ -7,7 +7,14 @@
  * - Loading items for a capability across all providers
  */
 import * as path from "node:path";
-import { getAgentDir, getProjectDir, getTrustedHomeDir, logger } from "@gajae-code/utils";
+import {
+	getAgentDir,
+	getAgentProfileAuthority,
+	getProjectDir,
+	getTrustedHomeDir,
+	logger,
+	normalizePathForComparison,
+} from "@gajae-code/utils";
 
 import type { Settings } from "../config/settings";
 import { clearCache as clearFsCache, findRepoRoot, cacheStats as fsCacheStats, invalidate as invalidateFs } from "./fs";
@@ -243,8 +250,13 @@ export async function loadCapability<T>(capabilityId: string, options: LoadOptio
 	const cwd = options.cwd ?? getProjectDir();
 	const home = getTrustedHomeDir();
 	const userAgentDir = options.agentDir ? path.resolve(options.agentDir) : getAgentDir();
+	const profileAuthority =
+		options.profileAuthority ??
+		(options.agentDir && normalizePathForComparison(userAgentDir) !== normalizePathForComparison(getAgentDir())
+			? "custom"
+			: getAgentProfileAuthority());
 	const repoRoot = await findRepoRoot(cwd);
-	const ctx: LoadContext = { cwd, home, userAgentDir, repoRoot, settings: options.settings };
+	const ctx: LoadContext = { cwd, home, userAgentDir, profileAuthority, repoRoot, settings: options.settings };
 	const providers = filterProviders(capability, options);
 
 	return await loadImpl(capability, providers, ctx, options);

package/src/capability/types.ts

@@ -29,6 +29,8 @@ export interface LoadContext {
 	 * produced. This includes MCP registrations and user-installed skills.
 	 */
 	userAgentDir?: string;
+	/** Resolver-owned classification for the selected user agent directory. */
+	profileAuthority?: "default" | "custom";
 	/** Git repository root (directory containing .git), or null if not in a repo */
 	repoRoot: string | null;
 	/** Owning session settings for provider policy decisions. */
@@ -89,6 +91,8 @@ export interface LoadOptions {
 	 * process-wide one (`createAgentSession({ agentDir })`).
 	 */
 	agentDir?: string;
+	/** Resolver-owned classification for `agentDir`; preserve it across HOME/config refreshes. */
+	profileAuthority?: "default" | "custom";
 	/** Include items even if they fail validation. Default: false */
 	includeInvalid?: boolean;
 	/** Include items disabled via settings. Default: false */

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;