@gajae-code/coding-agent 0.11.6 → 0.11.8

package/dist/types/tools/image-gen.d.ts

@@ -2,7 +2,7 @@ import { type Model } from "@gajae-code/ai";
 import * as z from "zod/v4";
 import { type ModelRegistry } from "../config/model-registry";
 import type { CustomTool } from "../extensibility/custom-tools/types";
-type ImageProvider = "antigravity" | "gemini" | "openai" | "openai-codex" | "openrouter";
+type ImageProvider = "alibaba" | "antigravity" | "gemini" | "openai" | "openai-codex" | "openrouter";
 declare const responseModalitySchema: z.ZodEnum<{
     IMAGE: "IMAGE";
     TEXT: "TEXT";
@@ -55,6 +55,52 @@ interface OpenAIResponsesUsage {
     total_tokens?: number;
 }
 type ImageUsageMetadata = GeminiUsageMetadata | OpenAIResponsesUsage;
+interface AlibabaImageContentPart {
+    type?: string;
+    text?: string;
+    image?: string;
+}
+interface AlibabaImageResponse {
+    code?: string;
+    message?: string;
+    output?: {
+        choices?: Array<{
+            message?: {
+                content?: AlibabaImageContentPart[];
+            };
+        }>;
+    };
+}
+/** Map the tool's image_size values onto wan2.7's 1K/2K size classes. */
+export declare function resolveAlibabaImageSize(imageSize: string | undefined): string | undefined;
+/**
+ * Build the Bailian multimodal-generation request body for wan2.7 image
+ * generation/editing. Input images ride along as data URLs; generation-only
+ * calls send just the prompt text. The sync endpoint returns OSS URLs inline.
+ */
+export declare function buildAlibabaImageRequest(model: string, promptText: string, inputImages: InlineImageData[], imageSize: string | undefined): {
+    model: string;
+    input: {
+        messages: Array<{
+            role: "user";
+            content: Array<{
+                text: string;
+            } | {
+                image: string;
+            }>;
+        }>;
+    };
+    parameters: {
+        n: number;
+        watermark: boolean;
+        size?: string;
+    };
+};
+/** Collect OSS image URLs and any text parts from a Bailian image response. */
+export declare function collectAlibabaImageResult(response: AlibabaImageResponse): {
+    imageUrls: string[];
+    responseText?: string;
+};
 interface ImageGenToolDetails {
     provider: ImageProvider;
     model: string;
@@ -72,6 +118,22 @@ interface InlineImageData {
 }
 /** Set the preferred image provider from settings */
 export declare function setPreferredImageProvider(provider: ImageProvider | "auto"): void;
+/** Provider → default image model mapping for auto-binding */
+export declare const IMAGE_PROVIDER_DEFAULTS: Record<string, string>;
+/** Resolved image generation configuration from settings */
+export interface ImageProviderConfig {
+    provider: ImageProvider | "auto" | "custom";
+    model: string | null;
+    customUrl?: string;
+    customKey?: string;
+    customKeyEnv?: string;
+}
+/** Set the configured image provider + model from settings */
+export declare function setConfiguredImageModel(config: ImageProviderConfig | null): void;
+/** Get the current configured image model (for UI display) */
+export declare function getConfiguredImageModel(): ImageProviderConfig | null;
+/** Resolve the effective image model for a configured provider */
+export declare function resolveImageModel(provider: string, modelOverride: string | null): string;
 export declare function isOpenAIHostedImageModel(model: Model | undefined): model is Model;
 export declare const imageGenTool: CustomTool<typeof imageGenSchema, ImageGenToolDetails>;
 export declare function getImageGenTools(modelRegistry?: ModelRegistry, activeModel?: Model): Promise<Array<CustomTool<typeof imageGenSchema, ImageGenToolDetails>>>;

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

@@ -82,6 +82,8 @@ export interface AskAnswerRequest {
     options: string[];
     interaction: "selector" | "custom_editor" | "clarification_editor";
     controls: readonly AskRemoteControl[];
+    /** Optional zero-based recommendation into the authoritative raw options. */
+    recommendedIndex?: number;
 }
 export type AskRemoteInteraction = {
     kind: "value";
@@ -155,6 +157,8 @@ export interface ToolSession {
      *  its terminal-phase chain guard. Returns the raw phase string or undefined
      *  when no active skill (or accessor) is available. */
     getActiveSkillPhase?: () => string | undefined;
+    /** Restrict provider-facing deep-interview ask metadata to the active workflow stage. */
+    getDeepInterviewAskStage?: () => "topology" | "post-topology" | undefined;
     /** Pre-loaded prompt templates */
     promptTemplates?: PromptTemplate[];
     /** Whether LSP integrations are enabled */

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

@@ -15,6 +15,13 @@ export type SkillDiscoveryToolInput = z.infer<typeof skillDiscoverySchema>;
 export interface SkillDiscoveryToolDetails {
     candidates: RuntimeSkillDiscoveryCandidate[];
     count: number;
+    /**
+     * Present only when zero candidates were returned AND discovery config gates
+     * (`skills.enabled` / `skills.enablePiProject` / `skills.enablePiUser`)
+     * prevented some or all of the requested scope from being searched. Without
+     * this, a disabled config is indistinguishable from "no skills exist".
+     */
+    notice?: string;
 }
 export declare class SkillDiscoveryTool implements AgentTool<typeof skillDiscoverySchema, SkillDiscoveryToolDetails> {
     #private;

package/dist/types/tools/sqlite-reader.d.ts

@@ -32,6 +32,13 @@ export type SqliteRowLookup = {
 } | {
     kind: "rowid";
 };
+/**
+ * Keep raw reads deliberately narrower than SQLite's full grammar. Comments are
+ * rejected, and a statement terminator is accepted only as the final
+ * non-whitespace character. Quoted semicolons remain ordinary query data.
+ */
+export declare function validateSqliteReadQuery(sql: string): string;
+export declare function enforceSqliteQueryOnly(db: Database): void;
 export declare function parseSqlitePathCandidates(filePath: string): SqlitePathCandidate[];
 export declare function isSqliteFile(absolutePath: string): Promise<boolean>;
 export declare function parseSqliteSelector(subPath: string, queryString: string): SqliteSelector;

package/dist/types/utils/prompt-suggestion.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Predict the user's likely next prompt after an agent turn using a smol,
+ * fast model. Native GJC port of the ghost-text prompt-suggestion behavior
+ * from Claude Code: the prediction renders as dim ghost text in the empty
+ * composer and Tab accepts it.
+ */
+import type { AgentMessage } from "@gajae-code/agent-core";
+import { type Api, type Model } from "@gajae-code/ai";
+import type { ModelRegistry } from "../config/model-registry";
+import type { Settings } from "../config/settings";
+export declare const PROMPT_SUGGESTION_MAX_WORDS = 12;
+export declare const PROMPT_SUGGESTION_MAX_CHARS = 100;
+/**
+ * Strip wrapper tags and label prefixes a model sometimes adds despite being
+ * told to reply with only the suggestion.
+ */
+export declare function sanitizePromptSuggestion(raw: string): string;
+/**
+ * Heuristic gate rejecting model output that would make a bad ghost-text
+ * suggestion. Returns the rejection reason, or null when the text is usable.
+ */
+export declare function suppressPromptSuggestionReason(text: string): string | null;
+/**
+ * Build a compact recent-conversation transcript for the prediction request.
+ * Returns null when there is no user message to predict from.
+ */
+export declare function buildPromptSuggestionContext(messages: AgentMessage[]): string | null;
+/**
+ * Generate a predicted next user prompt from the recent conversation.
+ * Returns null when no usable suggestion is produced (silence is the
+ * expected steady state).
+ */
+export declare function generatePromptSuggestion(messages: AgentMessage[], registry: ModelRegistry, settings: Settings, sessionId?: string, currentModel?: Model<Api>, metadataResolver?: (provider: string) => Record<string, unknown> | undefined): Promise<string | null>;

package/dist/types/utils/shell-snapshot.d.ts

@@ -1,5 +1,17 @@
+interface ShellSnapshotCacheOptions {
+    tempRoot: string;
+    home: string | (() => string);
+    platform: NodeJS.Platform;
+}
+declare function createShellSnapshotCache(options: ShellSnapshotCacheOptions): {
+    getOrCreateSnapshot(shell: string, env: Record<string, string | undefined>): Promise<string | null>;
+    cleanup(): Promise<void>;
+};
+/** @internal Test-only factory for isolated filesystem and platform assertions. */
+export declare const createShellSnapshotCacheForTesting: typeof createShellSnapshotCache;
 /**
  * Create a shell snapshot, caching the result.
  * Returns the path to the snapshot file, or null if creation failed.
  */
 export declare function getOrCreateSnapshot(shell: string, env: Record<string, string | undefined>): Promise<string | null>;
+export {};

package/dist/types/web/insane/bridge.d.ts

@@ -16,6 +16,7 @@ import { spawn as nodeSpawn } from "node:child_process";
 export declare const INSANE_VENDOR_DIR: string;
 /** Stable note prefixes — tests assert on these without depending on full stderr. */
 export declare const INSANE_NOTES: {
+    readonly securityDisabled: `insane fallback disabled: remote renderer cannot preserve validated network routing`;
     readonly guardBlocked: (reason: string) => string;
     readonly vendorMissing: `insane fallback unavailable: vendor engine missing at packages/coding-agent/vendor/insane-search`;
     readonly noPython: `insane fallback unavailable: python3 not found; install python3 and curl_cffi, then retry with web.insaneFallback=true`;

package/dist/types/web/insane/url-guard.d.ts

@@ -10,6 +10,18 @@ export interface PublicUrlRejected {
 export type PublicUrlResult = PublicUrlAccepted | PublicUrlRejected;
 /** Resolver seam so tests can inject DNS results without real lookups. */
 export type AddressResolver = (hostname: string) => Promise<string[]>;
+type ProxyEnvironment = Record<string, string | undefined>;
+export type GuardedPublicFetchResult = {
+    ok: true;
+    response: Response;
+    logicalUrl: URL;
+    wireUrl: URL;
+} | {
+    ok: false;
+    reason: string;
+    logicalUrl: string;
+};
+export declare function hasConfiguredProxy(env: ProxyEnvironment): boolean;
 /** True for any address that is not a routable public unicast address. */
 export declare function isPrivateOrSpecialAddress(address: string): boolean;
 /**
@@ -19,7 +31,12 @@ export declare function isPrivateOrSpecialAddress(address: string): boolean;
  */
 export declare function validatePublicHttpUrl(rawUrl: string, options?: {
     resolver?: AddressResolver;
+    signal?: AbortSignal;
 }): Promise<PublicUrlResult>;
+export declare function guardedPublicFetch(rawUrl: string, init?: BunFetchRequestInit, options?: {
+    resolver?: AddressResolver;
+}): Promise<GuardedPublicFetchResult>;
 export declare function validatePublicHttpUrlForInsane(rawUrl: string, options?: {
     resolver?: AddressResolver;
 }): Promise<PublicUrlResult>;
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/coding-agent",
-	"version": "0.11.6",
+	"version": "0.11.8",
 	"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",
@@ -53,13 +53,13 @@
 		"@agentclientprotocol/sdk": "1.2.1",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@gajae-code/stats": "0.11.6",
-		"@gajae-code/agent-core": "0.11.6",
-		"@gajae-code/ai": "0.11.6",
-		"@gajae-code/bridge-client": "0.11.6",
-		"@gajae-code/natives": "0.11.6",
-		"@gajae-code/tui": "0.11.6",
-		"@gajae-code/utils": "0.11.6",
+		"@gajae-code/stats": "0.11.8",
+		"@gajae-code/agent-core": "0.11.8",
+		"@gajae-code/ai": "0.11.8",
+		"@gajae-code/bridge-client": "0.11.8",
+		"@gajae-code/natives": "0.11.8",
+		"@gajae-code/tui": "0.11.8",
+		"@gajae-code/utils": "0.11.8",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",

package/scripts/capture-platform-shortcut-labels-showcase.ts

@@ -0,0 +1,342 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import {
+	PLATFORM_SHORTCUT_LABELS_SHOWCASE_ENTRIES,
+	PLATFORM_SHORTCUT_LABELS_SHOWCASE_EXPECTED_ENTRY_COUNT,
+	type PlatformShortcutLabelsShowcaseEntry,
+	renderPlatformShortcutLabelsShowcase,
+} from "../test/fixtures/tui/platform-shortcut-labels-showcase";
+
+const CANONICAL_COMMAND =
+	"bun packages/coding-agent/scripts/capture-platform-shortcut-labels-showcase.ts --output .gjc/qa/platform-shortcut-labels";
+const CAPTURE_TOOL_VERSION = "platform-shortcut-labels-fixture-injected-platform-v1";
+const EXPECTED_KEYS = [
+	"darwin/composer-idle/80x24/unicode-color",
+	"darwin/composer-idle/120x36/unicode-color",
+	"darwin/composer-idle/160x48/unicode-color",
+	"darwin/composer-busy-effective-queue-remap/80x24/unicode-color",
+	"darwin/composer-busy-effective-queue-remap/120x36/unicode-color",
+	"darwin/composer-busy-effective-queue-remap/160x48/unicode-color",
+	"darwin/status-effective-remap-unbound/80x24/unicode-color",
+	"darwin/status-effective-remap-unbound/120x36/unicode-color",
+	"darwin/status-effective-remap-unbound/160x48/unicode-color",
+	"darwin/welcome-flow/80x24/unicode-color",
+	"darwin/welcome-flow/120x36/unicode-color",
+	"darwin/welcome-flow/160x48/unicode-color",
+	"win32/composer-idle/80x24/unicode-color",
+	"win32/composer-idle/120x36/unicode-color",
+	"win32/composer-busy-effective-queue-remap/80x24/unicode-color",
+	"win32/composer-busy-effective-queue-remap/120x36/unicode-color",
+	"win32/status-effective-remap-unbound/80x24/unicode-color",
+	"win32/status-effective-remap-unbound/120x36/unicode-color",
+	"win32/welcome-flow/80x24/unicode-color",
+	"win32/welcome-flow/120x36/unicode-color",
+	"linux/composer-idle/80x24/unicode-color",
+	"linux/composer-idle/120x36/unicode-color",
+	"linux/composer-busy-effective-queue-remap/80x24/unicode-color",
+	"linux/composer-busy-effective-queue-remap/120x36/unicode-color",
+	"linux/status-effective-remap-unbound/80x24/unicode-color",
+	"linux/status-effective-remap-unbound/120x36/unicode-color",
+	"linux/welcome-flow/80x24/unicode-color",
+	"linux/welcome-flow/120x36/unicode-color",
+	"darwin/composer-idle/80x24/ascii-no-color",
+	"darwin/composer-busy-effective-queue-remap/80x24/ascii-no-color",
+	"darwin/status-effective-remap-unbound/80x24/ascii-no-color",
+	"darwin/welcome-flow/80x24/ascii-no-color",
+	"darwin/status-effective-remap-unbound/48x36/unicode-color",
+	"darwin/welcome-flow/48x36/unicode-color",
+] as const;
+
+type ArtifactFile = { path: string; sha256: string; byte_length: number };
+type ManifestEntry = {
+	key: string;
+	platform: string;
+	surface: string;
+	viewport: { id: string; columns: number; rows: number };
+	render_mode: string;
+	capture_mode: "fixture-injected-platform";
+	files: ArtifactFile[];
+};
+
+function usage(): never {
+	throw new Error(`Usage: ${CANONICAL_COMMAND}`);
+}
+function outputPath(args: string[]): string {
+	if (args.length !== 2 || args[0] !== "--output" || !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 escapeHtml(value: string): string {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+type AnsiStyle = {
+	foreground?: string;
+	background?: string;
+	bold?: boolean;
+	dim?: boolean;
+	italic?: boolean;
+	underline?: boolean;
+	inverse?: boolean;
+};
+
+const ANSI_COLORS: Record<number, string> = {
+	30: "#000000",
+	31: "#cc0000",
+	32: "#4e9a06",
+	33: "#c4a000",
+	34: "#3465a4",
+	35: "#75507b",
+	36: "#06989a",
+	37: "#d3d7cf",
+	90: "#555753",
+	91: "#ef2929",
+	92: "#8ae234",
+	93: "#fce94f",
+	94: "#729fcf",
+	95: "#ad7fa8",
+	96: "#34e2e2",
+	97: "#eeeeec",
+};
+
+function ansi256Color(index: number): string {
+	if (index < 16) return ANSI_COLORS[index < 8 ? index + 30 : index + 82] ?? "#ffffff";
+	if (index >= 232) {
+		const value = (index - 232) * 10 + 8;
+		return `rgb(${value},${value},${value})`;
+	}
+	const value = index - 16;
+	const red = Math.floor(value / 36);
+	const green = Math.floor((value % 36) / 6);
+	const blue = value % 6;
+	const channel = (component: number) => (component === 0 ? 0 : component * 40 + 55);
+	return `rgb(${channel(red)},${channel(green)},${channel(blue)})`;
+}
+
+function styleAttribute(style: AnsiStyle): string {
+	const declarations: string[] = [];
+	if (style.foreground) declarations.push(`color:${style.foreground}`);
+	if (style.background) declarations.push(`background-color:${style.background}`);
+	if (style.bold) declarations.push("font-weight:700");
+	if (style.dim) declarations.push("opacity:.65");
+	if (style.italic) declarations.push("font-style:italic");
+	if (style.underline) declarations.push("text-decoration:underline");
+	if (style.inverse) declarations.push("filter:invert(1)");
+	return declarations.join(";");
+}
+
+const NON_VISUAL_TERMINAL_CONTROL = /\x1b_[^\x1b\x07]*(?:\x07|\x1b\\)/g;
+
+/** Render emitted SGR styles as safe inline CSS without retaining terminal control codes. */
+function ansiToHtml(value: string): string {
+	const visibleText = value.replace(NON_VISUAL_TERMINAL_CONTROL, "");
+	const sgr = /\x1b\[([0-9;]*)m/g;
+	let body = "";
+	let offset = 0;
+	let spanOpen = false;
+	let style: AnsiStyle = {};
+	const close = () => {
+		if (!spanOpen) return;
+		body += "</span>";
+		spanOpen = false;
+	};
+	const open = () => {
+		const attribute = styleAttribute(style);
+		if (!attribute) return;
+		body += `<span style="${attribute}">`;
+		spanOpen = true;
+	};
+
+	for (const match of visibleText.matchAll(sgr)) {
+		body += escapeHtml(visibleText.slice(offset, match.index));
+		offset = (match.index ?? 0) + match[0].length;
+		close();
+		const codes = (match[1] || "0").split(";").map(Number);
+		for (let index = 0; index < codes.length; index += 1) {
+			const code = codes[index];
+			if (code === 0) style = {};
+			else if (code === 1) style.bold = true;
+			else if (code === 2) style.dim = true;
+			else if (code === 3) style.italic = true;
+			else if (code === 4) style.underline = true;
+			else if (code === 7) style.inverse = true;
+			else if (code === 22) {
+				style.bold = false;
+				style.dim = false;
+			} else if (code === 23) style.italic = false;
+			else if (code === 24) style.underline = false;
+			else if (code === 27) style.inverse = false;
+			else if (code === 39) style.foreground = undefined;
+			else if (code === 49) style.background = undefined;
+			else if (code in ANSI_COLORS) style.foreground = ANSI_COLORS[code];
+			else if (code >= 40 && code <= 47) style.background = ANSI_COLORS[code - 10];
+			else if (code >= 100 && code <= 107) style.background = ANSI_COLORS[code - 10];
+			else if (code === 38 || code === 48) {
+				const colorMode = codes[index + 1];
+				if (colorMode === 2) {
+					const red = codes[index + 2];
+					const green = codes[index + 3];
+					const blue = codes[index + 4];
+					if ([red, green, blue].every(Number.isInteger)) {
+						if (code === 38) style.foreground = `rgb(${red},${green},${blue})`;
+						else style.background = `rgb(${red},${green},${blue})`;
+					}
+					index += 4;
+				} else if (colorMode === 5 && Number.isInteger(codes[index + 2])) {
+					if (code === 38) style.foreground = ansi256Color(codes[index + 2]!);
+					else style.background = ansi256Color(codes[index + 2]!);
+					index += 2;
+				}
+			}
+		}
+		open();
+	}
+	body += escapeHtml(visibleText.slice(offset));
+	close();
+	return `<!doctype html>\n<html lang="en"><head><meta charset="utf-8"><meta name="color-scheme" content="dark"><title>Platform shortcut labels showcase</title><style>body{margin:0;background:#110b0b;color:#ffe7dc;overflow:auto}pre{margin:0;padding:1em;white-space:pre;font-family:ui-monospace,monospace;line-height:1.2}</style></head><body><pre>${body}</pre></body></html>\n`;
+}
+function validateMatrix(entries: readonly PlatformShortcutLabelsShowcaseEntry[]): void {
+	if (PLATFORM_SHORTCUT_LABELS_SHOWCASE_EXPECTED_ENTRY_COUNT !== 34)
+		throw new Error("Expected showcase entry count must remain 34");
+	if (entries.length !== PLATFORM_SHORTCUT_LABELS_SHOWCASE_EXPECTED_ENTRY_COUNT)
+		throw new Error(`Showcase matrix changed: expected 34 entries, received ${entries.length}`);
+	const actual = entries.map(entry => entry.key);
+	if (new Set(actual).size !== actual.length) throw new Error("Showcase matrix contains duplicate entry keys");
+	const expected = new Set<string>(EXPECTED_KEYS);
+	const missing = EXPECTED_KEYS.filter(key => !actual.includes(key));
+	const surplus = actual.filter(key => !expected.has(key));
+	if (missing.length || surplus.length || actual.some((key, index) => key !== EXPECTED_KEYS[index]))
+		throw new Error(
+			`Showcase matrix keys differ; missing=${missing.join(",") || "none"}; surplus=${surplus.join(",") || "none"}`,
+		);
+}
+async function writeArtifact(filePath: string, content: string, outputRoot: string): Promise<ArtifactFile> {
+	await Bun.write(filePath, content);
+	return {
+		path: path.relative(outputRoot, filePath).split(path.sep).join("/"),
+		sha256: sha256(content),
+		byte_length: Buffer.byteLength(content, "utf8"),
+	};
+}
+async function captureEntry(
+	entry: PlatformShortcutLabelsShowcaseEntry,
+	outputRoot: string,
+	capturedAt: string,
+): Promise<ManifestEntry> {
+	const rendered = await renderPlatformShortcutLabelsShowcase(entry);
+	const directory = path.join(outputRoot, entry.platform, entry.surface, entry.viewport.id, entry.renderMode);
+	await fs.mkdir(directory, { recursive: true });
+	const html = ansiToHtml(rendered.terminalAnsiText);
+	const metadata = json({
+		schema_version: 1,
+		entry_key: entry.key,
+		platform: entry.platform,
+		viewport: entry.viewport,
+		render_mode: entry.renderMode,
+		capture_mode: rendered.captureMode,
+		platform_provenance: rendered.platformProvenance,
+		key_display_context: rendered.keyDisplayContext,
+		components: rendered.components,
+		capture_timestamp: capturedAt,
+		command_or_replay_source: CANONICAL_COMMAND,
+		fixture_source: "packages/coding-agent/test/fixtures/tui/platform-shortcut-labels-showcase.ts",
+		tool_version: CAPTURE_TOOL_VERSION,
+		terminal: {
+			columns: entry.viewport.columns,
+			rows: entry.viewport.rows,
+			font_rendering_assumptions:
+				"Embedded red-claw truecolor theme; HTML uses a monospace terminal fallback stack.",
+			wrapping_policy:
+				"Real components render at the recorded terminal-cell width; CJK content is retained for width review.",
+			ansi_control_semantics:
+				"terminal-ansi.txt preserves emitted SGR sequences; terminal.txt strips them; ascii-no-color strips styling only.",
+		},
+		provenance: {
+			platform: "fixture-injected-platform",
+			live_capture: false,
+			native_platform_claim: entry.platform === "darwin" ? "none (fixture only)" : "none",
+		},
+		fixed_clock_timestamp: rendered.fixedClockTimestamp,
+	});
+	const files = await Promise.all([
+		writeArtifact(path.join(directory, "terminal.txt"), rendered.terminalText, outputRoot),
+		writeArtifact(path.join(directory, "terminal-ansi.txt"), rendered.terminalAnsiText, outputRoot),
+		writeArtifact(path.join(directory, "terminal.html"), html, outputRoot),
+		writeArtifact(path.join(directory, "metadata.json"), metadata, outputRoot),
+	]);
+	return {
+		key: entry.key,
+		platform: entry.platform,
+		surface: entry.surface,
+		viewport: entry.viewport,
+		render_mode: entry.renderMode,
+		capture_mode: rendered.captureMode,
+		files,
+	};
+}
+async function main(): Promise<void> {
+	const root = path.resolve(outputPath(process.argv.slice(2)));
+	const capturedAt = new Date().toISOString();
+	validateMatrix(PLATFORM_SHORTCUT_LABELS_SHOWCASE_ENTRIES);
+	await fs.mkdir(root, { recursive: true });
+	const entries: ManifestEntry[] = [];
+	for (const entry of PLATFORM_SHORTCUT_LABELS_SHOWCASE_ENTRIES)
+		entries.push(await captureEntry(entry, root, capturedAt));
+	const manifest = json({
+		schema_version: 1,
+		capture_tool: CAPTURE_TOOL_VERSION,
+		capture_mode: "fixture-injected-platform",
+		command: CANONICAL_COMMAND,
+		capture_timestamp: capturedAt,
+		expected_entry_count: 34,
+		entry_count: entries.length,
+		ordered_keys: EXPECTED_KEYS,
+		provenance: "fixture-injected-platform",
+		review_input_file: "visual-review-input.json",
+		entries,
+	});
+	const manifestSha256 = sha256(manifest);
+	await Bun.write(path.join(root, "manifest.json"), manifest);
+	await Bun.write(
+		path.join(root, "visual-review-input.json"),
+		json({
+			schema_version: 1,
+			manifest_sha256: manifestSha256,
+			expected_manifest_entries: 34,
+			ordered_keys: EXPECTED_KEYS,
+			evidence_scope: {
+				component_surface: "Real CustomEditor, StatusLineComponent, and WelcomeComponent rendering.",
+				operations_boundary: "Fixed clock, in-memory settings, and explicit injected KeyDisplayContext platform.",
+				external_effects: "No network, filesystem settings, daemon, or live native platform capture is invoked.",
+			},
+			review_requirements: [
+				"Inspect every recorded key.",
+				"Confirm Darwin glyphs and ASCII/no-color variants retain the same labels.",
+				"Confirm CJK and terminal-cell width evidence in both 48x36 entries.",
+				"Confirm all platform provenance is fixture-injected-platform.",
+			],
+			required_feature_cases: [
+				{
+					id: "darwin-composer",
+					entry_key: "darwin/composer-idle/80x24/unicode-color",
+					focus: "Darwin modifier and Enter glyph labels.",
+				},
+				{
+					id: "effective-remap",
+					entry_key: "darwin/status-effective-remap-unbound/80x24/unicode-color",
+					focus: "Effective remap and unbound action labels.",
+				},
+				{ id: "cjk-width", entry_key: "darwin/welcome-flow/48x36/unicode-color", focus: "CJK width and wrapping." },
+			],
+		}),
+	);
+	process.stdout.write(
+		`Captured ${entries.length} deterministic platform shortcut showcase entries to ${root}\nmanifest.json sha256: ${manifestSha256}\n`,
+	);
+}
+await main();