@gajae-code/coding-agent 0.8.0 → 0.8.2

package/src/cli/completion-cli.ts

@@ -0,0 +1,234 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import type { ArgDescriptor, CommandCtor, CommandEntry, FlagDescriptor } from "@gajae-code/utils/cli";
+
+export type FigName = string | string[];
+
+export interface FigArg {
+	name: string;
+	description?: string;
+	isOptional?: boolean;
+	isVariadic?: boolean;
+	suggestions?: string[];
+}
+
+export interface FigOption {
+	name: FigName;
+	description?: string;
+	args?: FigArg;
+	isRepeatable?: boolean;
+}
+
+export interface FigSubcommand {
+	name: FigName;
+	description?: string;
+	options?: FigOption[];
+	args?: FigArg | FigArg[];
+}
+
+export interface FigSpec extends FigSubcommand {
+	name: string;
+	subcommands?: FigSubcommand[];
+}
+
+export type InshellisenseIndexStatus = "created" | "updated" | "already-compatible" | "overwritten";
+
+export interface InstallGjcInshellisenseSpecOptions {
+	dir?: string;
+	force?: boolean;
+}
+
+export interface InstallGjcInshellisenseSpecResult {
+	directory: string;
+	specPath: string;
+	indexPath: string;
+	indexStatus: InshellisenseIndexStatus;
+}
+
+const GENERATED_INDEX_MARKER = "// Generated by gjc completion inshellisense";
+const BUILTIN_ROOT_OPTIONS: FigOption[] = [
+	{ name: ["-h", "--help"], description: "Show help" },
+	{ name: ["-v", "--version"], description: "Show version" },
+];
+const BUILTIN_COMMAND_OPTIONS: FigOption[] = [{ name: ["-h", "--help"], description: "Show help" }];
+
+export function defaultInshellisenseSpecDir(homeDir: string = os.homedir()): string {
+	return path.join(homeDir, ".fig", "autocomplete", "build");
+}
+
+function nameList(name: FigName): string[] {
+	return Array.isArray(name) ? name : [name];
+}
+
+function optionKey(option: FigOption): string {
+	return nameList(option.name).join("\u0000");
+}
+
+function combineOptions(primary: FigOption[], secondary: FigOption[]): FigOption[] {
+	const seen = new Set<string>();
+	const combined: FigOption[] = [];
+	for (const option of [...primary, ...secondary]) {
+		const key = optionKey(option);
+		if (seen.has(key)) continue;
+		seen.add(key);
+		combined.push(option);
+	}
+	return combined;
+}
+
+function commandEntryName(entry: CommandEntry): FigName {
+	const names = [entry.name, ...(entry.aliases ?? [])];
+	return names.length === 1 ? names[0]! : names;
+}
+
+function flagName(name: string, descriptor: FlagDescriptor): FigName {
+	const longName = `--${name}`;
+	if (!descriptor.char) return longName;
+	return [`-${descriptor.char}`, longName];
+}
+
+function argSuggestions(options: readonly string[] | undefined): string[] | undefined {
+	return options && options.length > 0 ? [...options] : undefined;
+}
+
+function optionArgName(name: string, descriptor: FlagDescriptor): string {
+	if (descriptor.options && descriptor.options.length > 0) return name;
+	return descriptor.kind === "integer" ? "int" : "value";
+}
+
+function figOptionFromFlag(name: string, descriptor: FlagDescriptor): FigOption {
+	const option: FigOption = {
+		name: flagName(name, descriptor),
+	};
+	if (descriptor.description) option.description = descriptor.description;
+	if (descriptor.multiple) option.isRepeatable = true;
+	if (descriptor.kind !== "boolean") {
+		const arg: FigArg = { name: optionArgName(name, descriptor) };
+		const suggestions = argSuggestions(descriptor.options);
+		if (suggestions) arg.suggestions = suggestions;
+		option.args = arg;
+	}
+	return option;
+}
+
+function figOptionsFromFlags(flags: Record<string, FlagDescriptor> | undefined): FigOption[] {
+	if (!flags) return [];
+	return Object.entries(flags).map(([name, descriptor]) => figOptionFromFlag(name, descriptor));
+}
+
+function figArgFromDescriptor(name: string, descriptor: ArgDescriptor): FigArg {
+	const arg: FigArg = { name };
+	if (descriptor.description) arg.description = descriptor.description;
+	if (!descriptor.required) arg.isOptional = true;
+	if (descriptor.multiple) arg.isVariadic = true;
+	const suggestions = argSuggestions(descriptor.options);
+	if (suggestions) arg.suggestions = suggestions;
+	return arg;
+}
+
+function figArgsFromDescriptors(args: Record<string, ArgDescriptor> | undefined): FigArg | FigArg[] | undefined {
+	if (!args) return undefined;
+	const values = Object.entries(args).map(([name, descriptor]) => figArgFromDescriptor(name, descriptor));
+	if (values.length === 0) return undefined;
+	return values.length === 1 ? values[0] : values;
+}
+
+function commandToSubcommand(entry: CommandEntry, command: CommandCtor): FigSubcommand {
+	const subcommand: FigSubcommand = { name: commandEntryName(entry) };
+	if (command.description) subcommand.description = command.description;
+	const options = combineOptions(BUILTIN_COMMAND_OPTIONS, figOptionsFromFlags(command.flags));
+	if (options.length > 0) subcommand.options = options;
+	const args = figArgsFromDescriptors(command.args);
+	if (args) subcommand.args = args;
+	return subcommand;
+}
+
+export async function buildGjcFigSpec(entries: CommandEntry[], rootCommandOverride?: CommandCtor): Promise<FigSpec> {
+	const subcommands: FigSubcommand[] = [];
+	let rootCommand: CommandCtor | undefined = rootCommandOverride;
+
+	for (const entry of entries) {
+		if (entry.name === "launch" && rootCommandOverride) {
+			continue;
+		}
+		let command: CommandCtor;
+		try {
+			command = await entry.load();
+		} catch {
+			if (entry.name !== "launch") {
+				subcommands.push({ name: commandEntryName(entry) });
+			}
+			continue;
+		}
+		if (entry.name === "launch") {
+			rootCommand = command;
+			continue;
+		}
+		if (command.hidden) continue;
+		subcommands.push(commandToSubcommand(entry, command));
+	}
+
+	const spec: FigSpec = {
+		name: "gjc",
+		description: rootCommand?.description ?? "Gajae Code CLI",
+	};
+	const rootOptions = combineOptions(BUILTIN_ROOT_OPTIONS, figOptionsFromFlags(rootCommand?.flags));
+	if (rootOptions.length > 0) spec.options = rootOptions;
+	const rootArgs = figArgsFromDescriptors(rootCommand?.args);
+	if (rootArgs) spec.args = rootArgs;
+	if (subcommands.length > 0) spec.subcommands = subcommands;
+	return spec;
+}
+
+export function renderFigSpecModule(spec: FigSpec): string {
+	return `const completionSpec = ${JSON.stringify(spec, null, "\t")};\n\nexport default completionSpec;\n`;
+}
+
+export function renderInshellisenseIndexModule(): string {
+	return `${GENERATED_INDEX_MARKER}\n\nexport default ["gjc"];\nexport const diffVersionedCompletions = [];\n`;
+}
+
+async function fileTextIfExists(filePath: string): Promise<string | undefined> {
+	try {
+		return await Bun.file(filePath).text();
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return undefined;
+		throw error;
+	}
+}
+
+function indexDeclaresGjc(content: string): boolean {
+	return /["']gjc["']/.test(content);
+}
+
+async function resolveIndexStatus(indexPath: string, force: boolean | undefined): Promise<InshellisenseIndexStatus> {
+	const existing = await fileTextIfExists(indexPath);
+	if (existing === undefined) return "created";
+	if (existing.includes(GENERATED_INDEX_MARKER)) {
+		return existing === renderInshellisenseIndexModule() ? "already-compatible" : "updated";
+	}
+	if (indexDeclaresGjc(existing)) return "already-compatible";
+	if (force) return "overwritten";
+	throw new Error(
+		`inshellisense index already exists at ${indexPath} and does not list gjc; rerun with --force to overwrite it or pass --dir to install into a GJC-only specs directory`,
+	);
+}
+
+export async function installGjcInshellisenseSpec(
+	spec: FigSpec,
+	options: InstallGjcInshellisenseSpecOptions = {},
+): Promise<InstallGjcInshellisenseSpecResult> {
+	const directory = path.resolve(options.dir ?? defaultInshellisenseSpecDir());
+	const specPath = path.join(directory, "gjc.js");
+	const indexPath = path.join(directory, "index.js");
+	const indexStatus = await resolveIndexStatus(indexPath, options.force);
+
+	await fs.mkdir(directory, { recursive: true });
+	await Bun.write(specPath, renderFigSpecModule(spec));
+	if (indexStatus !== "already-compatible") {
+		await Bun.write(indexPath, renderInshellisenseIndexModule());
+	}
+
+	return { directory, specPath, indexPath, indexStatus };
+}

package/src/cli/config-cli.ts

@@ -33,6 +33,7 @@ export interface ConfigCommandArgs {
 	value?: string;
 	flags: {
 		json?: boolean;
+		showSecrets?: boolean;
 	};
 }
 // =============================================================================
@@ -47,6 +48,19 @@ type CliSettingDef = {
 };
 
 const ALL_SETTING_PATHS = Object.keys(SETTINGS_SCHEMA) as SettingPath[];
+const REDACTED_SECRET_VALUE = "<redacted>";
+const SECRET_SETTING_SEGMENT_PATTERN = /(?:api[-_]?key|token|secret|password|passwd|pwd|credential)/i;
+
+function isSecretSettingPath(path: string): boolean {
+	return path.split(".").some(segment => SECRET_SETTING_SEGMENT_PATTERN.test(segment));
+}
+
+function redactConfigValue(path: string, value: unknown, showSecrets?: boolean): unknown {
+	if (showSecrets || typeof value !== "string" || !isSecretSettingPath(path)) {
+		return value;
+	}
+	return REDACTED_SECRET_VALUE;
+}
 
 /** Find setting definition by path */
 function findSettingDef(path: string): CliSettingDef | undefined {
@@ -105,6 +119,8 @@ export function parseConfigArgs(args: string[]): ConfigCommandArgs | undefined {
 		const arg = args[i];
 		if (arg === "--json") {
 			result.flags.json = true;
+		} else if (arg === "--show-secrets") {
+			result.flags.showSecrets = true;
 		} else if (!arg.startsWith("-")) {
 			positionalArgs.push(arg);
 		}
@@ -265,14 +281,15 @@ export async function runConfigCommand(cmd: ConfigCommandArgs): Promise<void> {
 	}
 }
 
-function handleList(flags: { json?: boolean }): void {
+function handleList(flags: { json?: boolean; showSecrets?: boolean }): void {
 	const defs = ALL_SETTING_PATHS.map(path => findSettingDef(path)).filter((def): def is CliSettingDef => !!def);
 
 	if (flags.json) {
 		const result: Record<string, { value: unknown; type: string; description: string }> = {};
 		for (const def of defs) {
+			const value = settings.get(def.path);
 			result[def.path] = {
-				value: settings.get(def.path),
+				value: redactConfigValue(def.path, value, flags.showSecrets),
 				type: def.type,
 				description: def.description,
 			};
@@ -301,7 +318,8 @@ function handleList(flags: { json?: boolean }): void {
 		console.log(chalk.bold.blue(`[${group}]`));
 		for (const def of groups[group]) {
 			const value = settings.get(def.path);
-			const valueStr = formatValue(value);
+			const displayValue = redactConfigValue(def.path, value, flags.showSecrets);
+			const valueStr = formatValue(displayValue);
 			const typeStr = getTypeDisplay(def);
 			console.log(`  ${chalk.white(def.path)} = ${valueStr} ${chalk.dim(typeStr)}`);
 		}
@@ -309,7 +327,7 @@ function handleList(flags: { json?: boolean }): void {
 	}
 }
 
-function handleGet(key: string | undefined, flags: { json?: boolean }): void {
+function handleGet(key: string | undefined, flags: { json?: boolean; showSecrets?: boolean }): void {
 	if (!key) {
 		console.error(chalk.red(`Usage: ${APP_NAME} config get <key>`));
 		console.error(chalk.dim(`\nRun '${APP_NAME} config list' to see available keys`));
@@ -324,16 +342,23 @@ function handleGet(key: string | undefined, flags: { json?: boolean }): void {
 	}
 
 	const value = settings.get(def.path);
+	const displayValue = redactConfigValue(def.path, value, flags.showSecrets);
 
 	if (flags.json) {
-		console.log(JSON.stringify({ key: def.path, value, type: def.type, description: def.description }, null, 2));
+		console.log(
+			JSON.stringify({ key: def.path, value: displayValue, type: def.type, description: def.description }, null, 2),
+		);
 		return;
 	}
 
-	console.log(formatValue(value));
+	console.log(formatValue(displayValue));
 }
 
-async function handleSet(key: string | undefined, value: string | undefined, flags: { json?: boolean }): Promise<void> {
+async function handleSet(
+	key: string | undefined,
+	value: string | undefined,
+	flags: { json?: boolean; showSecrets?: boolean },
+): Promise<void> {
 	if (!key || value === undefined) {
 		console.error(chalk.red(`Usage: ${APP_NAME} config set <key> <value>`));
 		console.error(chalk.dim(`\nRun '${APP_NAME} config list' to see available keys`));
@@ -355,11 +380,12 @@ async function handleSet(key: string | undefined, value: string | undefined, fla
 	}
 
 	const newValue = settings.get(def.path);
+	const displayValue = redactConfigValue(def.path, newValue, flags.showSecrets);
 
 	if (flags.json) {
-		console.log(JSON.stringify({ key: def.path, value: newValue }));
+		console.log(JSON.stringify({ key: def.path, value: displayValue }));
 	} else {
-		console.log(chalk.green(`${theme.status.success} Set ${def.path} = ${formatValue(newValue)}`));
+		console.log(chalk.green(`${theme.status.success} Set ${def.path} = ${formatValue(displayValue)}`));
 	}
 }
 
@@ -409,6 +435,7 @@ ${chalk.bold("Commands:")}
 
 ${chalk.bold("Options:")}
   --json             Output as JSON
+  --show-secrets     Show secret-like setting values without redaction (unsafe)
 
 ${chalk.bold("Examples:")}
   ${APP_NAME} config list
@@ -418,6 +445,7 @@ ${chalk.bold("Examples:")}
   ${APP_NAME} config set defaultThinkingLevel medium
   ${APP_NAME} config reset steeringMode
   ${APP_NAME} config list --json
+  ${APP_NAME} config get auth.broker.token --show-secrets
   ${APP_NAME} config init-xdg
 
 ${chalk.bold("Boolean Values:")}

package/src/cli/fast-help.ts

@@ -15,6 +15,7 @@ export function getExtraHelpText(): string {
   ${APP_NAME} deep-interview       - Run requirements interview workflow
   ${APP_NAME} skills               - List/read embedded workflow skills
   ${APP_NAME} config               - List, get, and set configuration values
+  ${APP_NAME} stats                - View AI usage statistics (tokens, cost, requests)
   ${APP_NAME} notify               - Send or test notifications
   ${APP_NAME} daemon               - Manage background daemon helpers
   ${APP_NAME} mcp                  - Manage MCP server registrations

package/src/cli/notify-cli.ts

@@ -58,6 +58,11 @@ interface TelegramUser {
 	allows_users_to_create_topics?: boolean;
 }
 
+interface TelegramChat {
+	id?: number | string;
+	type?: string;
+}
+
 type ThreadedModeState = "enabled" | "disabled" | "unknown";
 type ThreadedModeFinalLabel = "verified" | "unverified" | "unknown";
 
@@ -148,6 +153,7 @@ async function runSetup(deps: NotifyCommandDeps): Promise<void> {
 	let chatId: string;
 	if (deps.setupChatId?.trim()) {
 		chatId = deps.setupChatId.trim();
+		await verifyPrivateChatId(fetchImpl, apiBase, token, chatId);
 		process.stdout.write(`Using provided chat id ${chatId} (non-interactive).\n`);
 	} else {
 		const stale = await getUpdates(fetchImpl, apiBase, token, { timeout: 0, allowed_updates: ["message"] });
@@ -170,16 +176,76 @@ async function runSetup(deps: NotifyCommandDeps): Promise<void> {
 	);
 }
 
-async function promptForToken(): Promise<string> {
-	if (!process.stdin.isTTY) {
+type TokenPromptInput = NodeJS.ReadStream & {
+	isRaw?: boolean;
+	setRawMode?: (mode: boolean) => unknown;
+};
+
+type TokenPromptOutput = Pick<NodeJS.WriteStream, "write">;
+
+export async function promptForToken(
+	input: TokenPromptInput = process.stdin,
+	output: TokenPromptOutput = process.stdout,
+): Promise<string> {
+	if (!input.isTTY) {
 		throw new Error("notify setup requires an interactive TTY unless setupToken is injected.");
 	}
-	const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: true });
-	try {
-		return (await rl.question("Telegram BotFather token: ")).trim();
-	} finally {
-		rl.close();
+	if (typeof input.setRawMode !== "function") {
+		throw new Error("notify setup requires a TTY with raw input support unless setupToken is injected.");
 	}
+
+	output.write("Telegram BotFather token: ");
+	const wasRaw = input.isRaw === true;
+	input.setRawMode(true);
+
+	return await new Promise<string>((resolve, reject) => {
+		let value = "";
+		let settled = false;
+
+		const cleanup = () => {
+			input.off("data", onData);
+			input.off("error", onError);
+			input.setRawMode?.(wasRaw);
+			output.write("\n");
+		};
+
+		const finish = (callback: () => void) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			callback();
+		};
+
+		const accept = () => finish(() => resolve(value.trim()));
+		const cancel = () => finish(() => reject(new Error("Telegram bot token prompt cancelled.")));
+		const onError = (error: Error) => finish(() => reject(error));
+		const onData = (chunk: Buffer | string) => {
+			for (const char of String(chunk)) {
+				if (char === "\r" || char === "\n") {
+					accept();
+					return;
+				}
+				if (char === "\u0003") {
+					cancel();
+					return;
+				}
+				if (char === "\u0004") {
+					if (value) accept();
+					else cancel();
+					return;
+				}
+				if (char === "\u007f" || char === "\b") {
+					value = value.slice(0, -1);
+					continue;
+				}
+				if (char >= " ") value += char;
+			}
+		};
+
+		input.on("data", onData);
+		input.once("error", onError);
+		input.resume();
+	});
 }
 
 const THREADED_ENABLED_SUCCESS =
@@ -223,6 +289,24 @@ async function getMe(fetchImpl: typeof fetch, apiBase: string, token: string): P
 	return user;
 }
 
+async function verifyPrivateChatId(
+	fetchImpl: typeof fetch,
+	apiBase: string,
+	token: string,
+	chatId: string,
+): Promise<void> {
+	const chat = (await callTelegram<unknown>(fetchImpl, apiBase, token, "getChat", { chat_id: chatId })) as
+		| TelegramChat
+		| undefined;
+	if (!chat || typeof chat !== "object") {
+		throw new Error("Telegram getChat returned invalid Telegram response: missing valid Chat result.");
+	}
+	if (chat.type !== "private") {
+		const type = typeof chat.type === "string" && chat.type ? chat.type : "unknown";
+		throw new Error(`Provided chat id ${chatId} is a ${type} chat; pairing requires a private Telegram chat.`);
+	}
+}
+
 function threadedModeState(user: TelegramUser): ThreadedModeState {
 	if (user.has_topics_enabled === true) return "enabled";
 	if (user.has_topics_enabled === false) return "disabled";

package/src/cli.ts

@@ -36,6 +36,7 @@ export const commands: CommandEntry[] = [
 	{ name: "gc", load: () => import("./commands/gc").then(m => m.default) },
 	{ name: "ralplan", load: () => import("./commands/ralplan").then(m => m.default) },
 	{ name: "config", load: () => import("./commands/config").then(m => m.default) },
+	{ name: "stats", load: () => import("./commands/stats").then(m => m.default) },
 	{ name: "notify", load: () => import("./commands/notify").then(m => m.default) },
 	{ name: "daemon", load: () => import("./commands/daemon").then(m => m.default) },
 	{ name: "web-search", aliases: ["q"], load: () => import("./commands/web-search").then(m => m.default) },
@@ -52,6 +53,7 @@ export const commands: CommandEntry[] = [
 	{ name: "rlm", load: () => import("./commands/rlm").then(m => m.default) },
 	{ name: "update", load: () => import("./commands/update").then(m => m.default) },
 	{ name: "plugin", load: () => import("./commands/plugin").then(m => m.default) },
+	{ name: "completion", load: () => import("./commands/completion").then(m => m.default) },
 	{ name: "launch", load: () => import("./commands/launch").then(m => m.default) },
 ];
 
@@ -110,7 +112,7 @@ function hasRootVersionFlag(argv: string[]): boolean {
 	return hasRootFastFlag(argv, versionFlags);
 }
 
-class RootHelpCommand extends Command {
+export class RootHelpCommand extends Command {
 	static description = "Red-claw AI coding assistant";
 	static hidden = true;
 	static args = {

package/src/commands/completion.ts

@@ -0,0 +1,84 @@
+/**
+ * Generate shell completion specs for external completion engines.
+ */
+import { Args, Command, Flags } from "@gajae-code/utils/cli";
+import { commands, RootHelpCommand } from "../cli";
+import {
+	buildGjcFigSpec,
+	defaultInshellisenseSpecDir,
+	type InstallGjcInshellisenseSpecResult,
+	installGjcInshellisenseSpec,
+	renderFigSpecModule,
+} from "../cli/completion-cli";
+
+const TARGETS = ["inshellisense", "fig"] as const;
+
+type CompletionTarget = (typeof TARGETS)[number];
+
+function normalizeTarget(target: CompletionTarget): "inshellisense" {
+	return target === "fig" ? "inshellisense" : target;
+}
+
+function formatInstallResult(result: InstallGjcInshellisenseSpecResult, customDir: boolean): string {
+	const lines = [
+		"Installed GJC inshellisense completion spec:",
+		`  spec:  ${result.specPath}`,
+		`  index: ${result.indexPath} (${result.indexStatus})`,
+	];
+	if (customDir) {
+		lines.push(
+			"Add the install directory to inshellisense's [specs].path setting, then restart the inshellisense session.",
+		);
+	} else {
+		lines.push("Restart the inshellisense session, or run `is reinit` if your shell integration needs a refresh.");
+	}
+	return `${lines.join("\n")}\n`;
+}
+
+export default class Completion extends Command {
+	static description = "Generate shell completion specs";
+
+	static args = {
+		target: Args.string({
+			description: "Completion format",
+			required: false,
+			options: TARGETS,
+		}),
+	};
+
+	static flags = {
+		install: Flags.boolean({ description: "Install the generated spec for inshellisense" }),
+		dir: Flags.string({ description: "Install directory (defaults to ~/.fig/autocomplete/build)" }),
+		force: Flags.boolean({ description: "Overwrite an existing non-GJC inshellisense index.js" }),
+		json: Flags.boolean({ description: "Output JSON instead of JavaScript or status text" }),
+	};
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Completion);
+		const target = normalizeTarget((args.target ?? "inshellisense") as CompletionTarget);
+		if (target !== "inshellisense") {
+			process.stderr.write(`Unsupported completion target: ${target}\n`);
+			process.exitCode = 1;
+			return;
+		}
+		if ((flags.dir || flags.force) && !flags.install) {
+			process.stderr.write("--dir and --force only apply with --install\n");
+			process.exitCode = 1;
+			return;
+		}
+
+		const spec = await buildGjcFigSpec(commands, RootHelpCommand);
+		if (!flags.install) {
+			process.stdout.write(flags.json ? `${JSON.stringify(spec, null, 2)}\n` : renderFigSpecModule(spec));
+			return;
+		}
+
+		const directory = flags.dir ?? defaultInshellisenseSpecDir();
+		const result = await installGjcInshellisenseSpec(spec, { dir: directory, force: flags.force });
+		if (flags.json) {
+			process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+			return;
+		}
+		process.stdout.write(formatInstallResult(result, flags.dir !== undefined));
+	}
+}

package/src/commands/config.ts

@@ -29,6 +29,7 @@ export default class Config extends Command {
 
 	static flags = {
 		json: Flags.boolean({ description: "Output JSON" }),
+		"show-secrets": Flags.boolean({ description: "Show secret-like setting values without redaction (unsafe)" }),
 	};
 
 	async run(): Promise<void> {
@@ -42,6 +43,7 @@ export default class Config extends Command {
 			value,
 			flags: {
 				json: flags.json,
+				showSecrets: flags["show-secrets"],
 			},
 		};
 

package/src/commands/deep-interview.ts

@@ -8,6 +8,7 @@ export default class DeepInterview extends Command {
 		quick: Flags.boolean({ description: "Seed a quick deep-interview run" }),
 		standard: Flags.boolean({ description: "Seed a standard deep-interview run" }),
 		deep: Flags.boolean({ description: "Seed a deep deep-interview run" }),
+		trace: Flags.boolean({ description: "Run a bounded trace evidence pre-step before interview questions" }),
 		threshold: Flags.string({ description: "Override ambiguity threshold for kickoff" }),
 		"threshold-source": Flags.string({ description: "Describe the threshold override source" }),
 		"session-id": Flags.string({
@@ -25,7 +26,7 @@ export default class DeepInterview extends Command {
 		json: Flags.boolean({ description: "Output JSON" }),
 	};
 	static examples = [
-		'$ gjc deep-interview --standard "<idea>"',
+		'$ gjc deep-interview --trace --standard "<idea>"',
 		"$ gjc deep-interview --write --stage final --slug my-feature --spec ./final-spec.md",
 		"$ gjc deep-interview --write --stage final --slug my-feature --spec ./final-spec.md --deliberate",
 	];