@sayknow-cli/coding-agent 0.3.7 → 0.3.8

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 "@sayknow-cli/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 InstallSkcInshellisenseSpecOptions {
+	dir?: string;
+	force?: boolean;
+}
+
+export interface InstallSkcInshellisenseSpecResult {
+	directory: string;
+	specPath: string;
+	indexPath: string;
+	indexStatus: InshellisenseIndexStatus;
+}
+
+const GENERATED_INDEX_MARKER = "// Generated by skc 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 buildSkcFigSpec(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: "skc",
+		description: rootCommand?.description ?? "Sayknow-CLI 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 ["skc"];\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 indexDeclaresSkc(content: string): boolean {
+	return /["']skc["']/.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 (indexDeclaresSkc(existing)) return "already-compatible";
+	if (force) return "overwritten";
+	throw new Error(
+		`inshellisense index already exists at ${indexPath} and does not list skc; rerun with --force to overwrite it or pass --dir to install into a SKC-only specs directory`,
+	);
+}
+
+export async function installSkcInshellisenseSpec(
+	spec: FigSpec,
+	options: InstallSkcInshellisenseSpecOptions = {},
+): Promise<InstallSkcInshellisenseSpecResult> {
+	const directory = path.resolve(options.dir ?? defaultInshellisenseSpecDir());
+	const specPath = path.join(directory, "skc.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,43 @@ type CliSettingDef = {
 };
 
 const ALL_SETTING_PATHS = Object.keys(SETTINGS_SCHEMA) as SettingPath[];
+const REDACTED_SECRET_VALUE = "<redacted>";
+const SECRET_SETTING_WORDS = new Set(["token", "secret", "password", "passwd", "pwd", "credential", "credentials"]);
+const SECRET_SETTING_COMPOUND_PREFIXES = [
+	"api",
+	"auth",
+	"access",
+	"refresh",
+	"bearer",
+	"session",
+	"client",
+	"broker",
+	"bot",
+	"basic",
+];
+const SECRET_SETTING_COMPOUND_SUFFIXES = ["token", "secret", "password", "credential"];
+
+function isSecretSettingSegment(segment: string): boolean {
+	const normalized = segment.toLowerCase();
+	if (SECRET_SETTING_WORDS.has(normalized)) return true;
+	if (/api[-_]?key/i.test(segment)) return true;
+	const words = normalized.split(/[-_]/).filter(Boolean);
+	if (words.some(word => SECRET_SETTING_WORDS.has(word))) return true;
+	return SECRET_SETTING_COMPOUND_PREFIXES.some(prefix =>
+		SECRET_SETTING_COMPOUND_SUFFIXES.some(suffix => normalized === `${prefix}${suffix}`),
+	);
+}
+
+function isSecretSettingPath(path: string): boolean {
+	return path.split(".").some(segment => isSecretSettingSegment(segment));
+}
+
+function redactConfigValue(path: string, value: unknown, showSecrets?: boolean): unknown {
+	if (showSecrets || value === undefined || value === null || !isSecretSettingPath(path)) {
+		return value;
+	}
+	return REDACTED_SECRET_VALUE;
+}
 
 /** Find setting definition by path */
 function findSettingDef(path: string): CliSettingDef | undefined {
@@ -105,6 +143,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 +305,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 +342,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 +351,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 +366,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 +404,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 +459,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 +469,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/fixture-report.test.ts

@@ -0,0 +1,230 @@
+import { describe, expect, it } from "bun:test";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { sessionRoot } from "../skc-runtime/session-layout";
+import type { TaskTokenLog } from "../task/types";
+import { buildFixtureReport, type LiveRunReportShape, runFixtureReport } from "./fixture-report";
+
+function expectParseReportCompatible(report: LiveRunReportShape, fixtureId: string): void {
+	expect(report.schemaVersion).toBe(1);
+	expect(typeof report.binaryId).toBe("string");
+	expect(report.binaryId.length).toBeGreaterThan(0);
+	expect(report.fixtureId).toBe(fixtureId);
+	for (const value of Object.values(report.totals)) {
+		expect(typeof value).toBe("number");
+		expect(Number.isFinite(value)).toBe(true);
+	}
+	expect(report.receiptArtifactRatio).toBeNull();
+	expect(report.spawnDecisions).toBeNull();
+	expect(report.roi).toBeNull();
+}
+
+describe("fixture report", () => {
+	it("reports empty logs as a schema-v1 null-cache-hit report", () => {
+		const report = buildFixtureReport("empty-fixture", []);
+
+		expectParseReportCompatible(report, "empty-fixture");
+		expect(report.totals).toEqual({
+			turns: 0,
+			inputTokens: 0,
+			outputTokens: 0,
+			cacheReadTokens: 0,
+			cacheWriteTokens: 0,
+			totalTokens: 0,
+		});
+		expect(report.cacheHitRate).toBeNull();
+	});
+
+	it("sums deterministic fixed-fixture raw token buckets without folding cache into input", () => {
+		const logs: TaskTokenLog[] = [
+			{
+				subagentId: "root",
+				agent: "main",
+				turn: 1,
+				at: "2026-01-01T00:00:00.000Z",
+				input: 100,
+				output: 20,
+				cacheRead: 40,
+				cacheWrite: 10,
+				totalTokens: 170,
+				model: "fixture-model",
+			},
+			{
+				subagentId: "1-executor",
+				agent: "executor",
+				turn: 1,
+				at: "2026-01-01T00:00:01.000Z",
+				input: 60,
+				output: 15,
+				cacheRead: 20,
+				cacheWrite: 5,
+				totalTokens: 100,
+				model: "fixture-model",
+			},
+		];
+		const report = buildFixtureReport("fixed-fixture", logs);
+		const inputTokens = logs.reduce((sum, log) => sum + log.input, 0);
+		const outputTokens = logs.reduce((sum, log) => sum + log.output, 0);
+		const cacheReadTokens = logs.reduce((sum, log) => sum + log.cacheRead, 0);
+		const cacheWriteTokens = logs.reduce((sum, log) => sum + log.cacheWrite, 0);
+		const totalTokens = inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens;
+
+		expectParseReportCompatible(report, "fixed-fixture");
+		expect(report.totals).toEqual({
+			turns: logs.length,
+			inputTokens,
+			outputTokens,
+			cacheReadTokens,
+			cacheWriteTokens,
+			totalTokens,
+		});
+		expect(report.cacheHitRate).toBe(cacheReadTokens / (inputTokens + cacheReadTokens));
+	});
+
+	it("emits only parseReport-compatible schema-v1 fields", () => {
+		const report = buildFixtureReport("shape-fixture", [
+			{
+				subagentId: "root",
+				turn: 1,
+				at: "2026-01-01T00:00:00.000Z",
+				input: 0,
+				output: 0,
+				cacheRead: 1,
+				cacheWrite: 0,
+				totalTokens: 1,
+			},
+		]);
+
+		expect(Object.keys(report).sort()).toEqual([
+			"binaryId",
+			"cacheHitRate",
+			"fixtureId",
+			"receiptArtifactRatio",
+			"roi",
+			"schemaVersion",
+			"spawnDecisions",
+			"totals",
+		]);
+		expect(Object.keys(report.totals).sort()).toEqual([
+			"cacheReadTokens",
+			"cacheWriteTokens",
+			"inputTokens",
+			"outputTokens",
+			"totalTokens",
+			"turns",
+		]);
+		expectParseReportCompatible(report, "shape-fixture");
+	});
+});
+
+async function captureRun(fixtureId: string): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+	const originalCwd = process.cwd();
+	const originalStdout = process.stdout.write.bind(process.stdout);
+	const originalStderr = process.stderr.write.bind(process.stderr);
+	let exitCode = 0;
+	let stdout = "";
+	let stderr = "";
+	process.stdout.write = ((chunk: string | Uint8Array): boolean => {
+		stdout += typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf-8");
+		return true;
+	}) as typeof process.stdout.write;
+	process.stderr.write = ((chunk: string | Uint8Array): boolean => {
+		stderr += typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf-8");
+		return true;
+	}) as typeof process.stderr.write;
+	try {
+		exitCode = await runFixtureReport(fixtureId);
+		return { stdout, stderr, exitCode };
+	} finally {
+		process.stdout.write = originalStdout;
+		process.stderr.write = originalStderr;
+		process.chdir(originalCwd);
+	}
+}
+
+describe("runFixtureReport CLI degradation", () => {
+	it("exits non-zero without emitting JSON for an unknown fixture id", async () => {
+		await withTempCwd(async () => {
+			const { stdout, stderr, exitCode } = await captureRun("definitely-not-a-real-session-id");
+			expect(exitCode).toBe(1);
+			expect(stdout).toBe("");
+			expect(stderr).toContain("unknown fixture id");
+		});
+	});
+
+	it("reads only the requested session token-log directory", async () => {
+		await withTempCwd(async () => {
+			const firstSession = "fixture-session-a";
+			const secondSession = "fixture-session-b";
+			await writeTokenLog(firstSession, { input: 100, output: 10, cacheRead: 0, cacheWrite: 0, totalTokens: 110 });
+			await writeTokenLog(secondSession, { input: 900, output: 90, cacheRead: 0, cacheWrite: 0, totalTokens: 990 });
+
+			const { stdout, exitCode } = await captureRun(firstSession);
+			const report = JSON.parse(stdout) as LiveRunReportShape;
+
+			expect(exitCode).toBe(0);
+			expect(report.fixtureId).toBe(firstSession);
+			expect(report.totals.totalTokens).toBe(110);
+		});
+	});
+
+	it("emits deterministic PR9 default-candidate fixture reports", async () => {
+		await withTempCwd(async () => {
+			const { stdout, exitCode } = await captureRun("pr9.read-artifact-spill-threshold.after");
+			const report = JSON.parse(stdout) as LiveRunReportShape;
+
+			expect(exitCode).toBe(0);
+			expectParseReportCompatible(report, "pr9.read-artifact-spill-threshold.after");
+			expect(report.totals.totalTokens).toBe(20_100);
+		});
+	});
+
+	it("exits non-zero without emitting JSON for a corrupt token-log", async () => {
+		await withTempCwd(async () => {
+			const id = "corrupt-session";
+			const dir = join(sessionRoot(process.cwd(), id), "token-logs");
+			await mkdir(dir, { recursive: true });
+			await writeFile(join(dir, "token-log.jsonl"), "not json\n{}\n", "utf-8");
+			const { stdout, stderr, exitCode } = await captureRun(id);
+			expect(exitCode).toBe(1);
+			expect(stdout).toBe("");
+			expect(stderr).toContain("failed to build fixture report");
+		});
+	});
+});
+
+async function withTempCwd(fn: (cwd: string) => Promise<void>): Promise<void> {
+	const originalCwd = process.cwd();
+	const dir = await mkdtemp(join(tmpdir(), "skc-fixture-report-"));
+	process.chdir(dir);
+	try {
+		await fn(dir);
+	} finally {
+		// Restore the real cwd BEFORE removing the temp dir, otherwise the process
+		// is left sitting in a deleted directory and later tests in the same
+		// process fail with ENOENT on relative-path/process.cwd() operations.
+		process.chdir(originalCwd);
+		await rm(dir, { recursive: true, force: true });
+	}
+}
+
+async function writeTokenLog(
+	sessionId: string,
+	metrics: { input: number; output: number; cacheRead: number; cacheWrite: number; totalTokens: number },
+): Promise<void> {
+	const dir = join(sessionRoot(process.cwd(), sessionId), "token-logs");
+	await mkdir(dir, { recursive: true });
+	await writeFile(
+		join(dir, "token-log.jsonl"),
+		`${JSON.stringify({
+			subagentId: "root",
+			agent: "main",
+			turn: 1,
+			at: "2026-01-01T00:00:00.000Z",
+			model: "fixture-model",
+			...metrics,
+		})}\n`,
+		"utf-8",
+	);
+}