headlesscode 1.0.2

package/src/tools/run-tests.ts

@@ -0,0 +1,302 @@
+/**
+ * `run_tests` — run the SPECIFIC test file(s) relevant to a set of changed
+ * files, instead of always paying the full `npm test` cost (~70 files,
+ * measured 111s live) during the iterative edit-check-edit loop.
+ *
+ * Selection is the heuristic in src/tools/test-selection.ts (direct
+ * `src/foo/bar.ts` → `src/foo/__tests__/bar.test.ts` match, then reverse
+ * dependency via the REAL import graph — the same resolution the
+ * `import_graph` tool uses), and the matched files run through the SAME
+ * `tsx` invocation `npm test` uses per-file, sequentially, stopping at the
+ * first failure exactly like `npm test`'s `&&` chain.
+ *
+ * SECURITY: the selected test paths come from an untrusted workspace (they
+ * are file names that can contain shell metacharacters), so they are passed
+ * to `spawn` as ARGV with `shell: false` — never interpolated into a shell
+ * command string. See issue #62 (the old `shellQuote` allowed command
+ * substitution via `$()`/backticks in a hostile test file name).
+ *
+ * IMPORTANT (this is the tool's whole point, stated to the model): a
+ * passing selective run is NOT full-suite green. The FULL `npm test` is
+ * still what gates a merge/PR and is still required once before
+ * `attempt_completion`. This tool exists to make the per-edit loop cheap,
+ * not to replace the final confidence run.
+ */
+
+import { execFileSync, spawn } from "node:child_process"
+import type OpenAI from "openai"
+
+import type { ToolContext, ToolResult } from "../engine/types.js"
+import { getCodeIntelCache } from "../codeintel/program.js"
+import { selectTestsForChangedFiles } from "./test-selection.js"
+
+export const RUN_TESTS_NAME = "run_tests"
+
+/** Default per-test-file timeout, seconds (a single tsx-invoked suite). */
+const DEFAULT_TEST_TIMEOUT_S = 180
+
+const RUN_TESTS_DESCRIPTION = `Run the SPECIFIC test file(s) relevant to one or more changed files, instead of always paying the full npm test cost during the iterative edit-check-edit loop. Selection is automatic: for each changed file it looks for a direct test (src/foo/bar.ts → src/foo/__tests__/bar.test.ts), then for test files that import the changed file (via the real import graph, 1-2 hops). Matched files run through the same tsx invocation npm test uses per-file, sequentially, stopping at the first failure.
+
+Use this after editing a file to quickly verify you didn't break its tests — NOT as a replacement for the full suite. A passing selective run does NOT prove the whole project is green: run the full npm test once right before attempt_completion.
+
+When no specific test matches (e.g. you changed package.json or a script), the tool reports "no specific tests matched — consider running the full suite" honestly rather than silently running nothing.
+
+Parameters:
+- paths: (optional) The changed file path(s), relative to the workspace root. Omit to infer from the session's baseline checkpoint (or the workspace's git status when no checkpoint service is active).
+- timeout: (optional) Per-test-file timeout in seconds (default 180).
+
+Example: { "paths": ["src/tools/executor.ts"], "timeout": 120 }`
+
+const RT_PATHS_PARAMETER_DESCRIPTION = `Changed file path(s), relative to the workspace root. Omit to infer from the session's baseline checkpoint (or the workspace's git status).`
+const RT_TIMEOUT_PARAMETER_DESCRIPTION = `Per-test-file timeout in seconds (default 180).`
+
+export const runTestsTool = {
+	type: "function",
+	function: {
+		name: RUN_TESTS_NAME,
+		description: RUN_TESTS_DESCRIPTION,
+		// Note: strict mode is intentionally disabled for this tool (mirrors
+		// read_command_output.ts's precedent). With strict: true, every
+		// property must be in `required`, which forces nullable-union types
+		// (`type: ["array", "null"]`) for genuinely optional params so the
+		// model can omit them — DeepSeek's OpenRouter endpoint rejects that
+		// union-type syntax outright ("unknown variant `array`, expected one
+		// of `string`, `number`, `integer`, `boolean`, `null`"), breaking
+		// EVERY session's very first request since the tool list itself is
+		// sent up front. Plain, non-strict optional properties avoid this
+		// entirely and match how ask_followup_question's `follow_up`
+		// (required) array param is already declared elsewhere.
+		parameters: {
+			type: "object",
+			properties: {
+				paths: {
+					type: "array",
+					items: { type: "string" },
+					description: RT_PATHS_PARAMETER_DESCRIPTION,
+				},
+				timeout: {
+					type: "integer",
+					description: RT_TIMEOUT_PARAMETER_DESCRIPTION,
+				},
+			},
+			additionalProperties: false,
+		},
+	},
+} satisfies OpenAI.Chat.ChatCompletionTool
+
+/** Infer changed files from the workspace's own git status (fallback). */
+function changedFilesFromGit(workspaceRoot: string): string[] {
+	try {
+		const out = execFileSync("git", ["status", "--short", "--untracked-files=all"], {
+			cwd: workspaceRoot,
+			encoding: "utf-8",
+			timeout: 15_000,
+		})
+		const files: string[] = []
+		for (const line of out.split("\n")) {
+			const trimmed = line.trim()
+			if (trimmed === "") {
+				continue
+			}
+			// Format: "<XY> <path>" (2 status chars + space); renames are
+			// "R  old -> new" — the current path is the rename target.
+			const m = trimmed.match(/^.{1,2}\s+(.+)$/)
+			if (m === null) {
+				continue
+			}
+			let p = m[1]!.trim()
+			const arrow = p.indexOf(" -> ")
+			if (arrow !== -1) {
+				p = p.slice(arrow + 4)
+			}
+			files.push(p)
+		}
+		return files
+	} catch {
+		return []
+	}
+}
+
+function ok(content: string): ToolResult {
+	return { content, isError: false }
+}
+
+function err(content: string): ToolResult {
+	return { content: `[Error] ${content}`, isError: true }
+}
+
+/** Cap on the combined test output fed back to the model. */
+const MAX_TEST_OUTPUT_CHARS = 30_000
+
+function truncateOutput(text: string): { text: string; truncated: boolean } {
+	if (text.length <= MAX_TEST_OUTPUT_CHARS) {
+		return { text, truncated: false }
+	}
+	return { text: `${text.slice(0, MAX_TEST_OUTPUT_CHARS)}\n…[output truncated]`, truncated: true }
+}
+
+interface OneFileResult {
+	rel: string
+	exitCode: number | null
+	output: string
+	timedOut: boolean
+}
+
+/**
+ * Run one test file via `npx --no-install tsx <file>` (the npm-test
+ * invocation). The test path is treated as UNTRUSTED input (it comes from a
+ * workspace's file names): it is passed as a separate argv element with
+ * `shell: false`, so no shell metacharacter in it — `$()`, backticks, `;`,
+ * `&`, spaces, quotes — can ever be interpreted (issue #62). `npx
+ * --no-install` avoids any network fetch if the local tsx is missing.
+ */
+export function runOneTestFile(workspaceRoot: string, rel: string, timeoutS: number): Promise<OneFileResult> {
+	return new Promise((resolve) => {
+		let stdout = ""
+		let stderr = ""
+		let settled = false
+		let timedOut = false
+
+		const finish = (exitCode: number | null): void => {
+			if (!settled) {
+				settled = true
+				resolve({ rel, exitCode, output: `${stdout}${stderr}`, timedOut })
+			}
+		}
+
+		let child
+		try {
+			child = spawn("npx", ["--no-install", "tsx", rel], {
+				cwd: workspaceRoot,
+				// `shell: false` (default) — argv is passed verbatim, never
+				// re-parsed by a shell. This is the actual security boundary.
+				shell: false,
+				stdio: ["ignore", "pipe", "pipe"],
+				env: { ...process.env, LANG: "en_US.UTF-8", LC_ALL: "en_US.UTF-8" },
+			})
+		} catch (error) {
+			resolve({ rel, exitCode: null, output: `spawn error: ${error instanceof Error ? error.message : String(error)}`, timedOut: false })
+			return
+		}
+
+		const timer = setTimeout(() => {
+			timedOut = true
+			child.kill("SIGKILL")
+		}, timeoutS * 1000)
+
+		child.stdout?.on("data", (chunk: Buffer) => {
+			stdout += chunk.toString()
+		})
+		child.stderr?.on("data", (chunk: Buffer) => {
+			stderr += chunk.toString()
+		})
+		child.on("error", (error) => {
+			clearTimeout(timer)
+			stdout += `spawn error: ${error.message}\n`
+			finish(null)
+		})
+		child.on("close", (code) => {
+			clearTimeout(timer)
+			finish(code)
+		})
+	})
+}
+
+/**
+ * Run the `run_tests` tool. `getSessionChangedFiles` is the session-provided
+ * inference hook (checkpoint-diff based — see HeadlessSession); when absent
+ * or returning undefined the handler falls back to the workspace git status.
+ */
+export async function runTestsHandler(
+	args: Record<string, unknown>,
+	ctx: ToolContext,
+	getSessionChangedFiles?: () => Promise<string[] | undefined>,
+): Promise<ToolResult> {
+	const rawPaths = args.paths
+	const timeoutS =
+		typeof args.timeout === "number" && args.timeout > 0
+			? args.timeout
+			: typeof args.timeout === "string" && Number(args.timeout) > 0
+				? Number(args.timeout)
+				: DEFAULT_TEST_TIMEOUT_S
+
+	let changedFiles: string[] | undefined
+	if (Array.isArray(rawPaths) && rawPaths.length > 0) {
+		changedFiles = rawPaths
+			.filter((p): p is string => typeof p === "string" && p.trim() !== "")
+			.map((p) => p.trim())
+		if (changedFiles.length === 0) {
+			return err("run_tests: 'paths' must be a non-empty array of file path strings")
+		}
+	}
+
+	if (changedFiles === undefined) {
+		// Session-baseline inference first (checkpoint diff), then git status.
+		try {
+			changedFiles = (await getSessionChangedFiles?.()) ?? changedFilesFromGit(ctx.workspaceRoot)
+		} catch {
+			changedFiles = changedFilesFromGit(ctx.workspaceRoot)
+		}
+	}
+	if (changedFiles === undefined || changedFiles.length === 0) {
+		return err(
+			"run_tests: no changed files could be determined (no 'paths' given, no session baseline, and the workspace has no git status to read). Pass explicit 'paths', or run the full suite (npm test).",
+		)
+	}
+
+	const intel = getCodeIntelCache(ctx.workspaceRoot).get()
+	const { tests, notes } = selectTestsForChangedFiles(intel, ctx.workspaceRoot, changedFiles)
+
+	if (tests.length === 0) {
+		// Fail-safe: never report a silent pass of zero tests.
+		return err(
+			`run_tests: no specific tests matched for the changed file(s). ${notes.join("; ")} — consider running the full suite (npm test) instead of treating this as a pass.`,
+		)
+	}
+
+	const header = `run_tests: ${tests.length} test file(s) matched for ${changedFiles.length} changed file(s):\n${tests
+		.map((t) => `  ${t}`)
+		.join("\n")}`
+	const noteLine = notes.length > 0 ? `Selection notes:\n${notes.map((n) => `  - ${n}`).join("\n")}` : ""
+
+	// Run each file sequentially, stopping at the first failure (mirrors
+	// `npm test`'s `&&` chain). Failures and passes are both reported with
+	// their real output — the model must not mistake a selective pass for a
+	// full-suite green (the trailer says so explicitly).
+	const blocks: string[] = [header, noteLine, ""]
+	for (const rel of tests) {
+		// Defense-in-depth (the argv spawn in runOneTestFile is the primary
+		// boundary): reject paths containing newlines outright — they cannot
+		// be legitimate test files, and they would let a workspace smuggle
+		// forged "test result" content (a fake pass/fail line) into the tool
+		// result. Nothing is run for such a path.
+		if (/\r?\n/.test(rel)) {
+			blocks.push(`── ${rel} ─ (skipped: path contains a newline — not a legitimate test file)`)
+			blocks.push("[run_tests] FAILED: test path contains a newline (potential output-injection attempt)")
+			return err(blocks.join("\n"))
+		}
+		const result = await runOneTestFile(ctx.workspaceRoot, rel, timeoutS)
+		const { text: output, truncated } = truncateOutput(result.output)
+		blocks.push(`── ${rel} ─${truncated ? " (output truncated)" : ""}`)
+		blocks.push(output.trim() === "" ? "(no output)" : output)
+		if (result.timedOut) {
+			blocks.push(`[run_tests] ${rel} timed out after ${timeoutS}s (killed)`)
+			return err(blocks.join("\n"))
+		}
+		if (result.exitCode !== 0) {
+			blocks.push(`[run_tests] FAILED at ${rel} (exit ${result.exitCode ?? "spawn error"}) — remaining files not run (same as npm test's && chain)`)
+			return err(blocks.join("\n"))
+		}
+		blocks.push(`[run_tests] ${rel} exited 0`)
+	}
+
+	blocks.push(
+		"",
+		"[run_tests] all matched test file(s) passed.",
+		"NOTE: a passing selective run is NOT full-suite green — run the full `npm test` once before attempt_completion.",
+	)
+	return ok(blocks.join("\n"))
+}
+
+/** Exported for tests: the pure git-status fallback inference. */
+export { changedFilesFromGit }

package/src/tools/set-indentation-tool.ts

@@ -0,0 +1,49 @@
+/**
+ * `set_indentation` schema (issue #141) — sets ONE line's leading
+ * indentation to an exact tab count. The handler lives in executor.ts
+ * (setIndentationHandler) alongside edit_file/write_to_file, since it needs
+ * the same private path-safety/protected-file helpers those tools already
+ * use; this file only holds the schema, mirroring run-tests.ts's split.
+ *
+ * All 3 parameters are required — deliberately, unlike run_tests's optional
+ * paths/timeout: a tool with any optional parameter hits a known
+ * llama.cpp/llama-cpp-python grammar-constrained-decoding bug that corrupts
+ * structured tool calls (see prompt.ts's patchEditFileToolForLocalModels
+ * doc comment). Keeping every parameter required sidesteps that bug
+ * category entirely, on top of this tool's main point — see executor.ts's
+ * setIndentationHandler doc comment for the real motivation (a local model
+ * struggling to compose two multi-line strings differing only in tab
+ * count, not a matching-strictness problem).
+ */
+
+import type OpenAI from "openai"
+
+export const SET_INDENTATION_NAME = "set_indentation"
+
+const SET_INDENTATION_DESCRIPTION = `Change ONE line's leading indentation to an exact number of tabs, without touching the rest of the line or any other line. Use this for a pure indentation/whitespace-only fix instead of edit_file — edit_file requires typing out the full line twice (once in old_string, once in new_string) differing only in leading whitespace, which is easy to get subtly wrong. This tool takes a plain line number and a plain tab count instead.
+
+Only fixes indentation made of TABS. If the file uses space-based indentation, use edit_file instead.
+
+Example: { "path": "src/foo.ts", "line": 42, "tabs": 3 } sets line 42's leading whitespace to exactly 3 tabs (\\t\\t\\t), replacing however many tabs/spaces were there before.`
+
+const SI_PATH_PARAMETER_DESCRIPTION = `File path, relative to the workspace root.`
+const SI_LINE_PARAMETER_DESCRIPTION = `1-indexed line number to change. Use read_file first to confirm it.`
+const SI_TABS_PARAMETER_DESCRIPTION = `Exact number of leading tab characters the line should have after this call (0 removes all leading indentation).`
+
+export const setIndentationTool = {
+	type: "function",
+	function: {
+		name: SET_INDENTATION_NAME,
+		description: SET_INDENTATION_DESCRIPTION,
+		parameters: {
+			type: "object",
+			properties: {
+				path: { type: "string", description: SI_PATH_PARAMETER_DESCRIPTION },
+				line: { type: "integer", description: SI_LINE_PARAMETER_DESCRIPTION },
+				tabs: { type: "integer", description: SI_TABS_PARAMETER_DESCRIPTION },
+			},
+			required: ["path", "line", "tabs"],
+			additionalProperties: false,
+		},
+	},
+} satisfies OpenAI.Chat.ChatCompletionTool

package/src/tools/test-selection.ts

@@ -0,0 +1,160 @@
+/**
+ * Test-selection heuristic for the `run_tests` tool.
+ *
+ * Deliberately simple — the goal is "much better than always running the
+ * full suite during the iterative edit-check-edit loop", not a perfect
+ * solver:
+ *
+ *   1. Direct match: `src/foo/bar.ts` changed → `src/foo/__tests__/bar.test.ts`
+ *      if it exists (this repo's test-file convention). A changed file that
+ *      IS itself a test runs itself.
+ *   2. Reverse-dependency match: reuse the REAL import graph
+ *      (src/codeintel/import-graph.ts — the same resolution the `import_graph`
+ *      tool uses, correct on `paths` aliases and extension resolution) to find
+ *      which files import the changed file — directly (1 hop) or through one
+ *      intermediate module (2 hops, the common "lib → helper → test" case).
+ *      Any importer that is a test file is selected.
+ *   3. No match → the caller reports "no specific tests matched — consider
+ *      running the full suite" rather than silently running nothing.
+ *
+ * A source file's own direct test wins over reverse-dependency matches for
+ * determinism; everything is deduped and sorted for stable output.
+ */
+
+import * as fs from "node:fs"
+import * as path from "node:path"
+
+import { getImportGraph } from "../codeintel/import-graph.js"
+import type { CodeIntel } from "../codeintel/program.js"
+
+/** True for `foo.test.ts` / `foo.spec.tsx` style names, or any file inside a `__tests__` dir. */
+export function isTestFile(relPath: string): boolean {
+	const normalized = relPath.split(path.sep).join("/")
+	if (/(^|\/)__tests__(\/|$)/.test(normalized)) {
+		return true
+	}
+	return /[^/]+\.(test|spec)\.(m|c)?[tj]sx?$/i.test(normalized)
+}
+
+/**
+ * Direct match for a changed source file: `src/foo/bar.ts` →
+ * `src/foo/__tests__/bar.test.ts`. Only applies to source extensions the
+ * project can test (TS/JS); returns undefined for everything else (scripts,
+ * config, docs — those have no per-file test to run directly).
+ */
+export function directTestMatch(relSource: string): string | undefined {
+	const normalized = relSource.split(path.sep).join("/")
+	if (!/\.(m|c)?[tj]sx?$/i.test(normalized)) {
+		return undefined
+	}
+	const dir = path.posix.dirname(normalized)
+	const base = path.posix.basename(normalized).replace(/\.(m|c)?[tj]sx?$/i, "")
+	// Never map a test file onto a sibling test (it already matched itself).
+	if (isTestFile(normalized)) {
+		return undefined
+	}
+	return `${dir}/__tests__/${base}.test.ts`
+}
+
+/**
+ * Reverse-dependency match: every TEST file that (transitively, up to
+ * `maxDepth` hops) imports the changed file, per the real import graph.
+ * `absTarget` is the changed file's absolute path.
+ */
+export function reverseDependencyTests(
+	intel: CodeIntel,
+	workspaceRoot: string,
+	absTarget: string,
+	maxDepth = 2,
+): string[] {
+	const graph = getImportGraph(intel)
+	const found: string[] = []
+	const seenFiles = new Set<string>([absTarget])
+
+	// BFS from the changed file along reverse import edges (`importedBy`).
+	let frontier = [absTarget]
+	for (let depth = 0; depth < maxDepth && frontier.length > 0; depth++) {
+		const next: string[] = []
+		for (const file of frontier) {
+			for (const importer of graph.importedBy.get(file) ?? []) {
+				if (seenFiles.has(importer)) {
+					continue
+				}
+				seenFiles.add(importer)
+				const rel = path.relative(workspaceRoot, importer).split(path.sep).join("/")
+				if (isTestFile(rel)) {
+					found.push(rel)
+				}
+				next.push(importer)
+			}
+		}
+		frontier = next
+	}
+	return found
+}
+
+export interface TestSelectionResult {
+	/** Selected test files, workspace-relative posix paths, sorted + deduped. */
+	tests: string[]
+	/** Human-readable notes on WHY each file was selected (for the tool result). */
+	notes: string[]
+}
+
+/**
+ * Select the test file(s) to run for a set of changed workspace-relative
+ * files. Returns an empty `tests` list (with a note) when nothing matches —
+ * the caller must report the fail-safe "no specific tests matched" instead
+ * of pretending zero tests ran.
+ */
+export function selectTestsForChangedFiles(
+	intel: CodeIntel,
+	workspaceRoot: string,
+	changedFiles: string[],
+): TestSelectionResult {
+	const tests = new Set<string>()
+	const notes: string[] = []
+	const seenNotes = new Set<string>()
+
+	const note = (text: string): void => {
+		if (!seenNotes.has(text)) {
+			seenNotes.add(text)
+			notes.push(text)
+		}
+	}
+
+	for (const rel of changedFiles) {
+		const normalized = rel.split(path.sep).join("/")
+		if (isTestFile(normalized)) {
+			tests.add(normalized)
+			note(`direct: ${normalized} is itself a test file`)
+			continue
+		}
+		const direct = directTestMatch(normalized)
+		if (direct !== undefined && fileExists(path.join(workspaceRoot, direct))) {
+			tests.add(direct)
+			note(`direct: ${normalized} changed → ${direct}`)
+			continue
+		}
+		const abs = path.resolve(workspaceRoot, normalized)
+		const reverse = reverseDependencyTests(intel, workspaceRoot, abs)
+		if (reverse.length > 0) {
+			for (const t of reverse) {
+				tests.add(t)
+			}
+			note(`reverse-dependency: ${normalized} is imported by ${reverse.join(", ")}`)
+			continue
+		}
+		note(`no test matched ${normalized} (no direct test, no test imports it)`)
+	}
+
+	const sorted = [...tests].sort()
+	return { tests: sorted, notes }
+}
+
+function fileExists(p: string): boolean {
+	try {
+		return fs.statSync(p).isFile()
+	} catch {
+		return false
+	}
+}

package/src/vendor/tests/smoke.ts

@@ -0,0 +1,103 @@
+/**
+ * THROWAWAY SMOKE TEST — proves the vendored prompt builder can be imported
+ * and called headlessly (no VS Code), and that the native tool schemas assemble.
+ *
+ * Run with: npm run smoke  (i.e. tsx src/vendor/tests/smoke.ts)
+ */
+
+import type { ExtensionContext } from "../zoo-code/shim/vscode.js"
+
+// Side effect: installs String.prototype.toPosix() used by prompt sections.
+import "../zoo-code/src/utils/path.js"
+
+import { SYSTEM_PROMPT } from "../zoo-code/src/core/prompts/system.js"
+import {
+	getNativeTools,
+	convertOpenAIToolsToAnthropic,
+} from "../zoo-code/src/core/prompts/tools/native-tools/index.js"
+import { customModesSettingsSchema } from "../zoo-code/types/index.js"
+
+async function main(): Promise<void> {
+	// Minimal ExtensionContext stand-in (the vendored builder only reads
+	// globalState.get("customModes"/"customModePrompts") when building MODES).
+	const context = {
+		globalState: {
+			get: async () => undefined,
+			update: async () => {},
+		},
+		globalStorageUri: { fsPath: process.cwd() },
+		subscriptions: [],
+	} as unknown as ExtensionContext
+
+	// 1. Build a system prompt for the built-in "code" mode, with custom
+	//    instructions text spliced in (the acceptance-criteria shape).
+	const customInstructions = "This is throwaway smoke-test global instructions text."
+	const prompt = await SYSTEM_PROMPT(
+		context,
+		process.cwd(),
+		false,
+		undefined,
+		undefined,
+		"code",
+		undefined,
+		undefined,
+		customInstructions,
+	)
+
+	for (const needle of [
+		"TOOL USE",
+		"OBJECTIVE",
+		"RULES",
+		"MODES",
+		"CAPABILITIES",
+		"SYSTEM INFORMATION",
+		"You are Zoo, a highly skilled software engineer",
+		"USER'S CUSTOM INSTRUCTIONS",
+		`Global Instructions:\n${customInstructions}`,
+	]) {
+		if (!prompt.includes(needle)) {
+			throw new Error(`System prompt missing expected section: "${needle}"`)
+		}
+	}
+
+	// 2. Assemble the native (OpenAI-format) tool schemas.
+	const tools = getNativeTools()
+	if (tools.length < 20) {
+		throw new Error(`Expected >= 20 native tools, got ${tools.length}`)
+	}
+	const names = tools.map((t) => (t.type === "function" ? t.function.name : t.type))
+	if (!names.includes("read_file") || !names.includes("execute_command") || !names.includes("write_to_file")) {
+		throw new Error(`Native tools missing core tools: ${names.join(", ")}`)
+	}
+
+	// 3. Convert to Anthropic format.
+	const anthropicTools = convertOpenAIToolsToAnthropic(tools)
+	if (anthropicTools.length !== tools.length) {
+		throw new Error("Anthropic conversion count mismatch")
+	}
+
+	// 4. The .roomodes zod schema parses a minimal customModes YAML document.
+	const parsed = customModesSettingsSchema.safeParse({
+		customModes: [
+			{
+				slug: "smoke",
+				name: "Smoke",
+				roleDefinition: "You are a smoke test mode.",
+				groups: ["read"],
+			},
+		],
+	})
+	if (!parsed.success) {
+		throw new Error(`customModesSettingsSchema rejected a valid config: ${JSON.stringify(parsed.error)}`)
+	}
+
+	console.log(
+		`[smoke] system prompt built (${prompt.length} chars); native tools: ${tools.length}; anthropic tools: ${anthropicTools.length}; roomodes schema: ok`,
+	)
+	console.log("[smoke] OK")
+}
+
+main().catch((err) => {
+	console.error("[smoke] FAILED:", err)
+	process.exit(1)
+})