topchester-ai 0.1.0

package/dist/cli.mjs

@@ -0,0 +1,2986 @@
+#!/usr/bin/env node
+import { cwd, stderr, stdout } from "node:process";
+import { basename, delimiter, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { Command } from "commander";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { generateText, streamText } from "ai";
+import { constants, existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { parse } from "yaml";
+import { ZodError, z } from "zod";
+import pino from "pino";
+import { access, mkdir, open, readFile, readdir, realpath, rm, stat, writeFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { Input, ProcessTerminal, TUI, isKeyRelease, isKeyRepeat, matchesKey, truncateToWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { execFile } from "node:child_process";
+//#region src/model/index.ts
+var ModelGateway = class {
+	#config;
+	constructor(config) {
+		this.#config = config;
+	}
+	resolveModel(purpose = this.#config.defaultPurpose) {
+		const modelConfig = this.#config.models[purpose] ?? this.#config.models.fallback;
+		if (!modelConfig) throw new Error(`No model configured for purpose "${purpose}".`);
+		const providerId = modelConfig.provider ?? this.#config.defaultProvider;
+		if (!providerId) throw new Error(`No provider configured for model "${modelConfig.name}".`);
+		const modelId = modelConfig.name;
+		const providerConfig = this.#config.providers[providerId];
+		if (!providerConfig) throw new Error(`No provider configured for model provider "${providerId}".`);
+		return {
+			model: createOpenAICompatible({
+				name: providerId,
+				baseURL: providerConfig.baseURL,
+				apiKey: resolveApiKey(providerConfig),
+				headers: providerConfig.headers,
+				supportsStructuredOutputs: providerConfig.supportsStructuredOutputs
+			}).chatModel(modelId),
+			providerId,
+			modelId,
+			purpose
+		};
+	}
+	async generateText(request) {
+		const resolved = this.resolveModel(request.purpose);
+		return {
+			text: (await generateText({
+				model: resolved.model,
+				system: request.system,
+				prompt: request.prompt,
+				abortSignal: request.abortSignal
+			})).text,
+			providerId: resolved.providerId,
+			modelId: resolved.modelId,
+			purpose: resolved.purpose
+		};
+	}
+	async *streamText(request) {
+		yield* streamText({
+			model: this.resolveModel(request.purpose).model,
+			system: request.system,
+			prompt: request.prompt,
+			abortSignal: request.abortSignal
+		}).textStream;
+	}
+};
+function resolveApiKey(config) {
+	if (config.apiKey !== void 0) return config.apiKey;
+	if (config.apiKeyEnv === void 0) return;
+	return process.env[config.apiKeyEnv];
+}
+//#endregion
+//#region src/config/index.ts
+const modelPurposeSchema = z.enum([
+	"agent.primary",
+	"agent.fast",
+	"kb.scan",
+	"kb.summarize",
+	"kb.extract",
+	"kb.embed",
+	"fallback"
+]);
+const providerSchema = z.object({
+	type: z.literal("openai-compatible"),
+	baseURL: z.string().url(),
+	apiKeyEnv: z.string().optional(),
+	apiKey: z.string().optional(),
+	headers: z.record(z.string(), z.string()).optional(),
+	supportsStructuredOutputs: z.boolean().optional()
+});
+const modelAssignmentSchema = z.object({
+	name: z.string(),
+	provider: z.string().optional()
+});
+const providersSchema = z.object({ default: z.string().optional() }).catchall(providerSchema.or(z.string()));
+const topchesterConfigSchema = z.object({ models: z.object({
+	defaultPurpose: modelPurposeSchema.optional(),
+	assignments: z.partialRecord(modelPurposeSchema, modelAssignmentSchema).optional(),
+	providers: providersSchema.optional()
+}).optional() });
+function loadTopchesterConfig(options) {
+	const paths = [
+		join(homedir(), ".config/topchester/config.yaml"),
+		join(options.workspaceRoot, "topchester.yaml"),
+		join(options.workspaceRoot, ".topchester/config.local.yaml"),
+		process.env.TOPCHESTER_CONFIG,
+		options.configPath
+	].filter((path) => Boolean(path));
+	let merged = {};
+	for (const path of paths) {
+		const resolvedPath = isAbsolute(path) ? path : resolve(options.workspaceRoot, path);
+		if (!existsSync(resolvedPath)) continue;
+		const parsed = parse(readFileSync(resolvedPath, "utf8"));
+		merged = deepMerge(merged, topchesterConfigSchema.parse(parsed));
+	}
+	return topchesterConfigSchema.parse(merged);
+}
+function deepMerge(base, override) {
+	if (!isPlainObject(base) || !isPlainObject(override)) return override;
+	const result = { ...base };
+	for (const [key, value] of Object.entries(override)) result[key] = key in result ? deepMerge(result[key], value) : value;
+	return result;
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/app/paths.ts
+const TOPCHESTER_STATE_DIR = ".agents/topchester";
+const TOPCHESTER_SESSIONS_DIR = `${TOPCHESTER_STATE_DIR}/sessions`;
+const TOPCHESTER_LOGS_DIR = `${TOPCHESTER_STATE_DIR}/logs`;
+`${TOPCHESTER_LOGS_DIR}`;
+function resolveWorkspacePath(workspaceRoot, path) {
+	return isAbsolute(path) ? path : resolve(workspaceRoot, path);
+}
+function getTopchesterStatePath(workspaceRoot) {
+	return resolveWorkspacePath(workspaceRoot, TOPCHESTER_STATE_DIR);
+}
+function getTopchesterSessionsPath(workspaceRoot) {
+	return resolveWorkspacePath(workspaceRoot, TOPCHESTER_SESSIONS_DIR);
+}
+function getTopchesterLogsPath(workspaceRoot) {
+	return resolveWorkspacePath(workspaceRoot, TOPCHESTER_LOGS_DIR);
+}
+function getTopchesterLogFilePath(workspaceRoot, logFile = process.env.TOPCHESTER_LOG_FILE) {
+	return logFile ? resolveWorkspacePath(workspaceRoot, logFile) : join(getTopchesterLogsPath(workspaceRoot), "topchester.log");
+}
+//#endregion
+//#region src/logging/index.ts
+const LOG_LEVELS = new Set([
+	"fatal",
+	"error",
+	"warn",
+	"info",
+	"debug",
+	"trace",
+	"silent"
+]);
+function createTopchesterLogger(workspaceRoot) {
+	const level = normalizeLogLevel(process.env.TOPCHESTER_LOG_LEVEL);
+	if (level === "silent") return {
+		logger: pino({ enabled: false }),
+		level
+	};
+	const logFilePath = getTopchesterLogFilePath(workspaceRoot);
+	mkdirSync(dirname(logFilePath), { recursive: true });
+	const logger = pino({
+		base: void 0,
+		level,
+		timestamp: pino.stdTimeFunctions.isoTime
+	}, pino.destination({
+		dest: logFilePath,
+		sync: true
+	}));
+	logger.debug({
+		event: "logger_ready",
+		logFilePath,
+		level
+	}, "logger ready");
+	return {
+		logger,
+		level,
+		logFilePath
+	};
+}
+function normalizeLogLevel(level) {
+	const normalized = level?.trim().toLowerCase();
+	if (!normalized || normalized === "off") return "silent";
+	return LOG_LEVELS.has(normalized) ? normalized : "info";
+}
+//#endregion
+//#region src/app/context.ts
+function createAppContext(options) {
+	const config = loadTopchesterConfig(options);
+	const modelGateway = new ModelGateway(normalizeModelGatewayConfig(config));
+	const loggerInfo = createTopchesterLogger(options.workspaceRoot);
+	return {
+		workspaceRoot: options.workspaceRoot,
+		config,
+		modelGateway,
+		devFlags: new Set(options.devFlags ?? []),
+		logger: loggerInfo.logger,
+		logFilePath: loggerInfo.logFilePath
+	};
+}
+function normalizeModelGatewayConfig(config) {
+	const { default: defaultProvider, ...namedProviders } = config.models?.providers ?? {};
+	return {
+		defaultPurpose: config.models?.defaultPurpose ?? "agent.primary",
+		models: config.models?.assignments ?? {},
+		defaultProvider: typeof defaultProvider === "string" ? defaultProvider : void 0,
+		providers: Object.fromEntries(Object.entries(namedProviders).filter((entry) => {
+			return typeof entry[1] !== "string";
+		}))
+	};
+}
+//#endregion
+//#region src/cli/ui.ts
+const colors = {
+	bgSoftGray: "\x1B[48;5;236m",
+	cyan: "\x1B[36m",
+	dim: "\x1B[2m",
+	green: "\x1B[32m",
+	red: "\x1B[31m",
+	reset: "\x1B[0m",
+	yellow: "\x1B[33m"
+};
+const ui = {
+	heading(text) {
+		return color(`Topchester ${text}`, "cyan");
+	},
+	label(text) {
+		return color(text, "dim");
+	},
+	ok(text) {
+		return color(text, "green");
+	},
+	warn(text) {
+		return color(text, "yellow");
+	},
+	error(text) {
+		return color(text, "red");
+	},
+	softBackground(text) {
+		return color(text, "bgSoftGray");
+	},
+	async spinner(text, action) {
+		return withStatusLine(text, action, void 0, 80, false);
+	},
+	async progress(text, action) {
+		let latest = text;
+		return withStatusLine(text, () => action((message) => {
+			latest = message;
+		}), () => latest, 80, true);
+	}
+};
+async function withStatusLine(text, action, getText = () => text, progressEveryMs = 80, emitPlainProgress = false) {
+	if (!shouldUseColor()) {
+		if (!emitPlainProgress) return action();
+		const timer = setInterval(() => {
+			stderr.write(`${getText()}\n`);
+		}, Math.max(progressEveryMs, 5e3));
+		try {
+			return await action();
+		} finally {
+			clearInterval(timer);
+		}
+	}
+	const frames = [
+		"⠋",
+		"⠙",
+		"⠹",
+		"⠸",
+		"⠼",
+		"⠴",
+		"⠦",
+		"⠧",
+		"⠇",
+		"⠏"
+	];
+	let index = 0;
+	stderr.write(`${color(frames[index], "cyan")} ${getText()}`);
+	const timer = setInterval(() => {
+		index = (index + 1) % frames.length;
+		stderr.write(`\r\u001b[2K${color(frames[index], "cyan")} ${getText()}`);
+	}, progressEveryMs);
+	try {
+		return await action();
+	} finally {
+		clearInterval(timer);
+		stderr.write(`\r\u001b[2K`);
+	}
+}
+function color(text, colorName) {
+	if (!shouldUseColor()) return text;
+	return `${colors[colorName]}${text}${colors.reset}`;
+}
+function shouldUseColor() {
+	if (process.env.NO_COLOR) return false;
+	if (process.env.FORCE_COLOR && process.env.FORCE_COLOR !== "0") return true;
+	return stdout.isTTY === true;
+}
+//#endregion
+//#region src/knowledge/status.ts
+function getKnowledgeStatus(workspaceRoot) {
+	const kbPathSource = process.env.TOPCHESTER_KB_DIR ? "env" : "default";
+	const cachePathSource = process.env.TOPCHESTER_KB_CACHE_DIR ? "env" : "default";
+	const kbPath = resolveWorkspacePath(workspaceRoot, process.env.TOPCHESTER_KB_DIR ?? "topchester-kb");
+	const cachePath = resolveWorkspacePath(workspaceRoot, process.env.TOPCHESTER_KB_CACHE_DIR ?? ".agents/topchester-kb-cache");
+	const kbStat = safeStat(kbPath);
+	const cacheStat = safeStat(cachePath);
+	return {
+		workspaceRoot,
+		kbPath,
+		cachePath,
+		kbExists: Boolean(kbStat),
+		kbIsDirectory: kbStat?.isDirectory() ?? false,
+		cacheExists: Boolean(cacheStat),
+		cacheIsDirectory: cacheStat?.isDirectory() ?? false,
+		kbPathSource,
+		cachePathSource
+	};
+}
+function safeStat(path) {
+	if (!existsSync(path)) return;
+	return statSync(path);
+}
+//#endregion
+//#region src/knowledge/compiler/inventory.ts
+const DEFAULT_EXCLUDED_DIRS = new Set([
+	".git",
+	"node_modules",
+	"dist",
+	"coverage",
+	".agents/topchester",
+	".agents/topchester-kb-cache",
+	"topchester-kb"
+]);
+const BINARY_FILE_EXTENSIONS = new Set([
+	".avif",
+	".bmp",
+	".class",
+	".db",
+	".dll",
+	".dmg",
+	".doc",
+	".docx",
+	".dylib",
+	".eot",
+	".exe",
+	".gif",
+	".gz",
+	".ico",
+	".jar",
+	".jpeg",
+	".jpg",
+	".mov",
+	".mp3",
+	".mp4",
+	".otf",
+	".pdf",
+	".png",
+	".sqlite",
+	".tar",
+	".tgz",
+	".ttf",
+	".wasm",
+	".webm",
+	".webp",
+	".woff",
+	".woff2",
+	".zip"
+]);
+const BINARY_FILE_NAMES = new Set([".ds_store"]);
+const BINARY_SNIFF_BYTES = 4096;
+const BINARY_CONTROL_BYTE_RATIO_THRESHOLD = .3;
+async function listProjectFilesForL1(workspaceRoot, options = {}) {
+	const excludedDirs = buildExcludedDirs(workspaceRoot, options.excludedPaths ?? []);
+	const rules = await loadGitignoreRules(workspaceRoot, excludedDirs);
+	const files = [];
+	await walkDirectory(workspaceRoot, workspaceRoot, rules, files, excludedDirs);
+	files.sort((a, b) => a.path.localeCompare(b.path));
+	return {
+		workspaceRoot,
+		gitignoreFiles: rules.map((rule) => join(rule.baseDir, ".gitignore")).filter(unique).sort(),
+		files
+	};
+}
+async function loadGitignoreRules(workspaceRoot, excludedDirs) {
+	const gitignorePaths = [];
+	await collectGitignorePaths(workspaceRoot, workspaceRoot, gitignorePaths, excludedDirs);
+	const rules = [];
+	for (const gitignorePath of gitignorePaths.sort()) {
+		const content = await readFile(gitignorePath, "utf8");
+		const baseDir = dirname(gitignorePath);
+		for (const rawLine of content.split(/\r?\n/)) {
+			const rule = parseGitignoreLine(baseDir, rawLine);
+			if (rule) rules.push(rule);
+		}
+	}
+	return rules;
+}
+async function collectGitignorePaths(workspaceRoot, dir, gitignorePaths, excludedDirs) {
+	const entries = await readdir(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		const absolutePath = join(dir, entry.name);
+		const relativePath = toPosixPath(relative(workspaceRoot, absolutePath));
+		if (entry.name === ".gitignore") {
+			gitignorePaths.push(absolutePath);
+			continue;
+		}
+		if (!entry.isDirectory() || shouldSkipDirectoryByDefault(relativePath, excludedDirs)) continue;
+		await collectGitignorePaths(workspaceRoot, absolutePath, gitignorePaths, excludedDirs);
+	}
+}
+async function walkDirectory(workspaceRoot, dir, rules, files, excludedDirs) {
+	const entries = await readdir(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		const absolutePath = join(dir, entry.name);
+		const relativePath = toPosixPath(relative(workspaceRoot, absolutePath));
+		if (entry.isDirectory()) {
+			if (!shouldSkipDirectoryByDefault(relativePath, excludedDirs) && !isIgnored(workspaceRoot, absolutePath, true, rules, excludedDirs)) await walkDirectory(workspaceRoot, absolutePath, rules, files, excludedDirs);
+			continue;
+		}
+		if (!entry.isFile() || isIgnored(workspaceRoot, absolutePath, false, rules, excludedDirs)) continue;
+		const fileStat = await stat(absolutePath);
+		if (await isBinaryFile(absolutePath, relativePath)) continue;
+		files.push({
+			path: relativePath,
+			sizeBytes: fileStat.size,
+			hash: await hashFile$1(absolutePath)
+		});
+	}
+}
+async function isBinaryFile(absolutePath, relativePath) {
+	const lowerRelativePath = relativePath.toLowerCase();
+	const fileName = lowerRelativePath.split("/").at(-1) ?? lowerRelativePath;
+	if (BINARY_FILE_NAMES.has(fileName) || BINARY_FILE_EXTENSIONS.has(extname(lowerRelativePath))) return true;
+	const fileHandle = await open(absolutePath, "r");
+	try {
+		const buffer = Buffer.alloc(BINARY_SNIFF_BYTES);
+		const { bytesRead } = await fileHandle.read(buffer, 0, BINARY_SNIFF_BYTES, 0);
+		return looksBinary(buffer.subarray(0, bytesRead));
+	} finally {
+		await fileHandle.close();
+	}
+}
+function looksBinary(buffer) {
+	if (buffer.length === 0) return false;
+	let suspiciousControlBytes = 0;
+	for (const byte of buffer) {
+		if (byte === 0) return true;
+		if (byte < 32 && !(byte === 7 || byte === 8 || byte === 9 || byte === 10 || byte === 12 || byte === 13 || byte === 27)) suspiciousControlBytes += 1;
+	}
+	return suspiciousControlBytes / buffer.length > BINARY_CONTROL_BYTE_RATIO_THRESHOLD;
+}
+async function hashFile$1(absolutePath) {
+	const fileHandle = await open(absolutePath, "r");
+	try {
+		const hash = createHash("sha256");
+		const stream = fileHandle.createReadStream();
+		for await (const chunk of stream) hash.update(chunk);
+		return `sha256:${hash.digest("hex")}`;
+	} finally {
+		await fileHandle.close();
+	}
+}
+function parseGitignoreLine(baseDir, rawLine) {
+	let line = rawLine.trim();
+	if (!line || line.startsWith("#")) return;
+	const negated = line.startsWith("!");
+	if (negated) line = line.slice(1);
+	if (!line) return;
+	const directoryOnly = line.endsWith("/");
+	line = line.replace(/^\/+/, "").replace(/\/+$/, "");
+	if (!line) return;
+	return {
+		baseDir,
+		pattern: line,
+		negated,
+		directoryOnly
+	};
+}
+function isIgnored(workspaceRoot, absolutePath, isDirectory, rules, excludedDirs) {
+	let ignored = false;
+	for (const rule of rules) {
+		const relativeToRule = toPosixPath(relative(rule.baseDir, absolutePath));
+		if (relativeToRule.startsWith("../") || relativeToRule === "..") continue;
+		if (rule.directoryOnly && !isDirectory) continue;
+		if (matchesRule(relativeToRule, rule.pattern)) ignored = !rule.negated;
+	}
+	if (ignored) return true;
+	return shouldSkipDirectoryByDefault(toPosixPath(relative(workspaceRoot, absolutePath)), excludedDirs) && isDirectory;
+}
+function matchesRule(relativePath, pattern) {
+	if (pattern.includes("/")) return matchGlob(relativePath, pattern) || relativePath.startsWith(`${pattern}/`);
+	return relativePath.split("/").some((part) => matchGlob(part, pattern));
+}
+function matchGlob(value, pattern) {
+	let regex = "^";
+	for (let index = 0; index < pattern.length; index += 1) {
+		const char = pattern[index];
+		const nextChar = pattern[index + 1];
+		if (char === "*" && nextChar === "*") {
+			regex += ".*";
+			index += 1;
+			continue;
+		}
+		if (char === "*") {
+			regex += "[^/]*";
+			continue;
+		}
+		if (char === "?") {
+			regex += "[^/]";
+			continue;
+		}
+		regex += escapeRegexChar(char);
+	}
+	regex += "$";
+	return new RegExp(regex).test(value);
+}
+function escapeRegexChar(value) {
+	return /[.+^${}()|[\]\\]/.test(value) ? `\\${value}` : value;
+}
+function shouldSkipDirectoryByDefault(relativePath, excludedDirs = DEFAULT_EXCLUDED_DIRS) {
+	return excludedDirs.has(relativePath) || [...excludedDirs].some((dir) => relativePath.startsWith(`${dir}/`));
+}
+function toPosixPath(path) {
+	return path.split(sep).join("/");
+}
+function unique(value, index, array) {
+	return array.indexOf(value) === index;
+}
+function buildExcludedDirs(workspaceRoot, excludedPaths) {
+	const dirs = new Set(DEFAULT_EXCLUDED_DIRS);
+	for (const excludedPath of excludedPaths) {
+		const workspaceRelativePath = toPosixPath(relative(workspaceRoot, excludedPath));
+		if (!workspaceRelativePath || workspaceRelativePath === "." || workspaceRelativePath.startsWith("../")) continue;
+		dirs.add(workspaceRelativePath);
+	}
+	return dirs;
+}
+//#endregion
+//#region src/knowledge/compiler/l1-entry.ts
+const l1FileEntrySchemaPath = "../schema/file-entry.v1.json";
+const l1FileScanStatuses = [
+	"current",
+	"changed",
+	"missing_entry",
+	"missing_file",
+	"suspect",
+	"invalid"
+];
+const l1ConfidenceLevels = [
+	"low",
+	"medium",
+	"high"
+];
+const nonEmptyStringSchema = z.string().min(1);
+const sha256HashSchema = z.string().regex(/^sha256:[a-f0-9]{64}$/);
+const isoUtcTimestampSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?Z$/).refine((value) => !Number.isNaN(Date.parse(value)), { message: "Expected a valid UTC ISO timestamp" });
+const l1FileIdSchema = nonEmptyStringSchema.refine((value) => value.startsWith("file:"), { message: "Expected a file: id" });
+const l1ModuleIdSchema = nonEmptyStringSchema.refine((value) => value.startsWith("module:"), { message: "Expected a module: id" });
+const l1FeatureIdSchema = nonEmptyStringSchema.refine((value) => value.startsWith("feature:"), { message: "Expected a feature: id" });
+const l1FileSymbolSchema = z.object({
+	id: nonEmptyStringSchema.refine((value) => value.startsWith("symbol:"), { message: "Expected a symbol: id" }),
+	kind: nonEmptyStringSchema,
+	name: nonEmptyStringSchema,
+	exported: z.boolean(),
+	summary: nonEmptyStringSchema
+}).strict();
+const l1FileEvidenceSchema = z.object({
+	kind: nonEmptyStringSchema,
+	value: nonEmptyStringSchema
+}).strict();
+const l1FileEntrySchema = z.object({
+	$schema: z.literal(l1FileEntrySchemaPath),
+	id: l1FileIdSchema,
+	layer: z.literal("L1"),
+	type: z.literal("file"),
+	path: nonEmptyStringSchema,
+	language: nonEmptyStringSchema,
+	content_hash: sha256HashSchema,
+	size_bytes: z.number().int().nonnegative(),
+	last_scanned_at: isoUtcTimestampSchema,
+	scan_status: z.enum(l1FileScanStatuses),
+	summary: nonEmptyStringSchema,
+	responsibilities: z.array(nonEmptyStringSchema),
+	symbols: z.array(l1FileSymbolSchema),
+	imports: z.array(l1FileIdSchema),
+	exports: z.array(nonEmptyStringSchema),
+	module_ids: z.array(l1ModuleIdSchema),
+	feature_ids: z.array(l1FeatureIdSchema),
+	test_ids: z.array(l1FileIdSchema),
+	evidence: z.array(l1FileEvidenceSchema),
+	confidence: z.enum(l1ConfidenceLevels)
+}).strict().refine((entry) => entry.id === `file:${entry.path}`, {
+	message: "File entry id must match path",
+	path: ["id"]
+});
+function parseL1FileEntry(value) {
+	return l1FileEntrySchema.parse(value);
+}
+const l1QueueStatusSchema = z.enum([
+	"queued",
+	"in_progress",
+	"completed",
+	"failed",
+	"changed",
+	"missing_file"
+]);
+const l1QueueFailureSchema = z.object({
+	code: z.string().min(1),
+	message: z.string().min(1),
+	failedAt: isoUtcTimestampSchema
+}).strict();
+const l1QueueItemSchema = z.object({
+	id: l1FileIdSchema,
+	path: z.string().min(1),
+	sizeBytes: z.number().int().nonnegative(),
+	hash: sha256HashSchema,
+	status: l1QueueStatusSchema,
+	failure: l1QueueFailureSchema.optional()
+}).strict().refine((item) => item.id === `file:${item.path}`, {
+	message: "L1 queue item id must match path",
+	path: ["id"]
+});
+const l1QueueFileSchema = z.object({
+	layer: z.literal("L1"),
+	generatedAt: isoUtcTimestampSchema,
+	queuedFiles: z.array(l1QueueItemSchema)
+}).strict();
+function createL1QueueItem(file) {
+	return l1QueueItemSchema.parse({
+		...file,
+		id: `file:${file.path}`,
+		status: "queued"
+	});
+}
+function createL1QueueFile(queuedFiles, generatedAt) {
+	return l1QueueFileSchema.parse({
+		layer: "L1",
+		generatedAt,
+		queuedFiles
+	});
+}
+//#endregion
+//#region src/knowledge/progress.ts
+function formatProgressBar(completed, total, width = 20) {
+	const safeTotal = Math.max(total, 0);
+	const filled = safeTotal === 0 ? width : Math.floor((safeTotal === 0 ? 0 : Math.min(Math.max(completed, 0), safeTotal)) / safeTotal * width);
+	return `${"█".repeat(filled)}${"░".repeat(width - filled)}`;
+}
+function formatCountProgress(label, completed, total, detail) {
+	const safeTotal = Math.max(total, 0);
+	const safeCompleted = safeTotal === 0 ? 0 : Math.min(Math.max(completed, 0), safeTotal);
+	const percent = safeTotal === 0 ? 100 : Math.floor(safeCompleted / safeTotal * 100);
+	const suffix = detail ? ` ${detail}` : "";
+	return `${label} [${formatProgressBar(safeCompleted, safeTotal)}] ${safeCompleted}/${safeTotal} (${percent}%)${suffix}`;
+}
+//#endregion
+//#region src/knowledge/compiler/path-encoding.ts
+function getL1FileEntryRelativePath(filePath) {
+	return `${normalizeL1FilePath(filePath)}.json`;
+}
+function getL1FileEntryPath(kbPath, filePath) {
+	return join(kbPath, "l1-files", getL1FileEntryRelativePath(filePath));
+}
+function normalizeL1FilePath(filePath) {
+	const normalizedPath = filePath.replace(/^\.\//, "");
+	if (!normalizedPath || /^[A-Za-z]:/.test(normalizedPath) || normalizedPath.startsWith("/") || normalizedPath.includes("\0") || normalizedPath.includes("\\") || normalizedPath.split("/").some((part) => !part || part === "." || part === "..")) throw new Error(`Invalid workspace-relative file path: ${filePath}`);
+	return normalizedPath;
+}
+//#endregion
+//#region src/knowledge/compiler/l1-processor.ts
+const MAX_L1_PROMPT_FILE_BYTES = 256 * 1024;
+async function processL1Queue(options) {
+	const now = options.now ?? (() => /* @__PURE__ */ new Date());
+	let queuedFiles = l1QueueFileSchema.parse(JSON.parse(await readFile(options.queuePath, "utf8"))).queuedFiles.map(validateQueueItemPath);
+	await removeOrphanedL1Entries(options.kbPath, new Set(queuedFiles.map((item) => item.path)));
+	for (const [index, item] of queuedFiles.entries()) {
+		options.onProgress?.({ message: formatL1ProgressMessage("Processing L1 files", index, queuedFiles.length, item.path) });
+		if (item.status === "completed" && await hasCurrentEntry(options.kbPath, item)) {
+			options.onProgress?.({ message: formatL1ProgressMessage("Processing L1 files", index + 1, queuedFiles.length, item.path) });
+			continue;
+		}
+		queuedFiles[index] = markInProgress(item);
+		await persistQueue(options.queuePath, queuedFiles, now().toISOString());
+		if (await hasCurrentEntry(options.kbPath, item)) queuedFiles[index] = markTerminal(item, "completed");
+		else queuedFiles[index] = (await processL1QueueItem({
+			...options,
+			item,
+			now
+		})).item;
+		await persistQueue(options.queuePath, queuedFiles, now().toISOString());
+		options.onProgress?.({ message: formatL1ProgressMessage("Processing L1 files", index + 1, queuedFiles.length, item.path) });
+	}
+	const summary = await summarizeL1Queue(options.kbPath, queuedFiles);
+	await writeManifest(options, summary, now().toISOString());
+	return {
+		queuedFiles,
+		summary
+	};
+}
+function formatL1ProgressMessage(label, completed, total, path) {
+	return formatCountProgress(label, completed, total, path);
+}
+async function processL1QueueItem(options) {
+	const now = options.now ?? (() => /* @__PURE__ */ new Date());
+	const failedAt = () => now().toISOString();
+	try {
+		const normalizedPath = normalizeL1FilePath(options.item.path);
+		const realWorkspaceRoot = await realpath(options.workspaceRoot);
+		const absolutePath = await realpath(join(realWorkspaceRoot, normalizedPath)).catch((error) => {
+			if (isNodeErrorCode(error, "ENOENT")) return;
+			throw error;
+		});
+		if (!absolutePath) return { item: markTerminal(options.item, "missing_file") };
+		if (!isInsideDirectory(realWorkspaceRoot, absolutePath)) return { item: markTerminal(options.item, "changed") };
+		const fileStat = await stat(absolutePath).catch((error) => {
+			if (isNodeErrorCode(error, "ENOENT")) return;
+			throw error;
+		});
+		if (!fileStat) return { item: markTerminal(options.item, "missing_file") };
+		if (!fileStat.isFile()) return { item: failItem(options.item, "not_file", "Queued path is not a file.", failedAt()) };
+		const currentHash = await hashFile(absolutePath);
+		if (fileStat.size !== options.item.sizeBytes || currentHash !== options.item.hash) return { item: markTerminal(options.item, "changed") };
+		if (fileStat.size > MAX_L1_PROMPT_FILE_BYTES) return { item: failItem(options.item, "file_too_large", `File is too large for V0 L1 prompt processing (${fileStat.size} bytes).`, failedAt()) };
+		const content = await readFile(absolutePath, "utf8");
+		const entry = normalizeL1FileEntry(parseL1ModelJson((await options.model.generateText({
+			purpose: "kb.summarize",
+			system: buildL1FileEntrySystemPrompt(),
+			prompt: buildL1FileEntryPrompt({
+				path: normalizedPath,
+				content
+			})
+		})).text), {
+			path: normalizedPath,
+			hash: currentHash,
+			sizeBytes: fileStat.size,
+			scannedAt: now().toISOString()
+		});
+		const entryPath = getL1FileEntryPath(options.kbPath, normalizedPath);
+		await mkdir(dirname(entryPath), { recursive: true });
+		await writeFile(entryPath, `${JSON.stringify(entry, null, 2)}\n`);
+		return {
+			item: markTerminal(options.item, "completed"),
+			entry,
+			entryPath
+		};
+	} catch (error) {
+		return { item: failItem(options.item, classifyFailure(error), sanitizeErrorMessage(error), failedAt()) };
+	}
+}
+function buildL1FileEntrySystemPrompt() {
+	return [
+		"You summarize one repository file for Topchester's L1 knowledge base.",
+		"Return exactly one JSON object and no markdown.",
+		"Do not include secrets, credentials, or raw provider payloads."
+	].join("\n");
+}
+function buildL1FileEntryPrompt(input) {
+	return [
+		"Create an L1 file entry for this workspace-relative path.",
+		"The compiler will overwrite id, path, content_hash, size_bytes, last_scanned_at, and scan_status.",
+		"Use this JSON shape:",
+		JSON.stringify({
+			$schema: l1FileEntrySchemaPath,
+			id: "file:<path>",
+			layer: "L1",
+			type: "file",
+			path: "<path>",
+			language: "typescript",
+			content_hash: "sha256:<hash>",
+			size_bytes: 0,
+			last_scanned_at: "2026-05-11T00:00:00Z",
+			scan_status: "current",
+			summary: "One clear sentence.",
+			responsibilities: ["What this file owns or does."],
+			symbols: [],
+			imports: [],
+			exports: [],
+			module_ids: [],
+			feature_ids: [],
+			test_ids: [],
+			evidence: [{
+				kind: "path",
+				value: "<path>"
+			}],
+			confidence: "medium"
+		}, null, 2),
+		`Path: ${input.path}`,
+		"File content:",
+		"```",
+		input.content,
+		"```"
+	].join("\n");
+}
+function parseL1ModelJson(text) {
+	const trimmed = text.trim();
+	if (!trimmed) throw new Error("Model returned empty output.");
+	const jsonObjects = extractTopLevelJsonObjects(trimmed);
+	if (jsonObjects.length !== 1) throw new Error(jsonObjects.length === 0 ? "Model output did not contain a JSON object." : "Model output was ambiguous.");
+	return JSON.parse(jsonObjects[0]);
+}
+function normalizeL1FileEntry(value, deterministic) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Model JSON was not an object.");
+	return parseL1FileEntry({
+		...normalizeModelOwnedL1Fields(value, deterministic.path),
+		$schema: l1FileEntrySchemaPath,
+		id: `file:${deterministic.path}`,
+		layer: "L1",
+		type: "file",
+		path: deterministic.path,
+		content_hash: deterministic.hash,
+		size_bytes: deterministic.sizeBytes,
+		last_scanned_at: deterministic.scannedAt,
+		scan_status: "current"
+	});
+}
+function normalizeModelOwnedL1Fields(value, path) {
+	const record = value;
+	return {
+		...record,
+		responsibilities: normalizeStringArray(record.responsibilities),
+		symbols: normalizeSymbols(record.symbols, path),
+		imports: normalizePrefixedIds(record.imports, "file:"),
+		exports: normalizeStringArray(record.exports),
+		module_ids: normalizePrefixedIds(record.module_ids, "module:"),
+		feature_ids: normalizePrefixedIds(record.feature_ids, "feature:"),
+		test_ids: normalizePrefixedIds(record.test_ids, "file:"),
+		evidence: normalizeEvidence(record.evidence)
+	};
+}
+function normalizeStringArray(value) {
+	if (!Array.isArray(value)) return [];
+	return value.filter((item) => typeof item === "string" && item.trim().length > 0);
+}
+function normalizePrefixedIds(value, prefix) {
+	return normalizeStringArray(value).filter((item) => item.startsWith(prefix));
+}
+function normalizeEvidence(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((item) => {
+		if (!item || typeof item !== "object" || Array.isArray(item)) return [];
+		const record = item;
+		if (typeof record.kind !== "string" || record.kind.trim().length === 0) return [];
+		if (typeof record.value !== "string" || record.value.trim().length === 0) return [];
+		return [{
+			kind: record.kind,
+			value: record.value
+		}];
+	});
+}
+function normalizeSymbols(value, path) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((item) => {
+		if (typeof item === "string") {
+			const name = item.trim();
+			if (!name || !path) return [];
+			return [{
+				id: `symbol:${path}#${name}`,
+				kind: "symbol",
+				name,
+				exported: false,
+				summary: `Symbol named ${name}.`
+			}];
+		}
+		if (!item || typeof item !== "object" || Array.isArray(item)) return [];
+		const record = item;
+		const rawId = typeof record.id === "string" && record.id.startsWith("symbol:") ? record.id : void 0;
+		const name = typeof record.name === "string" && record.name.trim().length > 0 ? record.name : rawId?.slice(rawId.lastIndexOf("#") + 1);
+		if (!name || !path) return [];
+		return [{
+			id: rawId ?? `symbol:${path}#${name}`,
+			kind: typeof record.kind === "string" && record.kind.trim().length > 0 ? record.kind : "symbol",
+			name,
+			exported: typeof record.exported === "boolean" ? record.exported : false,
+			summary: typeof record.summary === "string" && record.summary.trim().length > 0 ? record.summary : `Symbol named ${name}.`
+		}];
+	});
+}
+function extractTopLevelJsonObjects(text) {
+	const objects = [];
+	let depth = 0;
+	let start = -1;
+	let inString = false;
+	let escaped = false;
+	for (let index = 0; index < text.length; index += 1) {
+		const char = text[index];
+		if (inString) {
+			if (escaped) escaped = false;
+			else if (char === "\\") escaped = true;
+			else if (char === "\"") inString = false;
+			continue;
+		}
+		if (char === "\"") {
+			inString = true;
+			continue;
+		}
+		if (char === "{") {
+			if (depth === 0) start = index;
+			depth += 1;
+			continue;
+		}
+		if (char === "}" && depth > 0) {
+			depth -= 1;
+			if (depth === 0 && start >= 0) {
+				objects.push(text.slice(start, index + 1));
+				start = -1;
+			}
+		}
+	}
+	return objects.filter((objectText) => {
+		try {
+			JSON.parse(objectText);
+			return true;
+		} catch {
+			return false;
+		}
+	});
+}
+async function hashFile(absolutePath) {
+	const fileHandle = await open(absolutePath, "r");
+	try {
+		const hash = createHash("sha256");
+		const stream = fileHandle.createReadStream();
+		for await (const chunk of stream) hash.update(chunk);
+		return `sha256:${hash.digest("hex")}`;
+	} finally {
+		await fileHandle.close();
+	}
+}
+function markTerminal(item, status) {
+	const { failure: _failure, ...rest } = item;
+	return {
+		...rest,
+		status
+	};
+}
+function markInProgress(item) {
+	const { failure: _failure, ...rest } = item;
+	return {
+		...rest,
+		status: "in_progress"
+	};
+}
+function failItem(item, code, message, failedAt) {
+	return {
+		...item,
+		status: "failed",
+		failure: sanitizeFailure({
+			code,
+			message,
+			failedAt
+		})
+	};
+}
+function sanitizeFailure(failure) {
+	return {
+		code: failure.code.replace(/[^a-z0-9_]/gi, "_").slice(0, 64) || "failed",
+		message: sanitizeErrorText(failure.message),
+		failedAt: failure.failedAt
+	};
+}
+function sanitizeErrorMessage(error) {
+	if (error instanceof ZodError) return `L1 entry validation failed: ${error.issues.map((issue) => issue.path.join(".") || issue.message).join(", ")}`;
+	if (error instanceof SyntaxError) return "Model output was not valid JSON.";
+	if (error instanceof Error) return error.message;
+	return "L1 processing failed.";
+}
+function sanitizeErrorText(text) {
+	return text.replace(/sk-[A-Za-z0-9_-]+/g, "[redacted]").replace(/SECRET_SENTINEL_[A-Za-z0-9_-]+/g, "[redacted]").slice(0, 500);
+}
+function classifyFailure(error) {
+	if (error instanceof ZodError) return "validation_error";
+	if (error instanceof SyntaxError) return "json_parse_error";
+	return "processing_error";
+}
+function isNodeErrorCode(error, code) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+function isInsideDirectory(directory, target) {
+	const relativePath = relative(directory, target);
+	return relativePath === "" || !relativePath.startsWith("..") && !relativePath.startsWith("/") && relativePath !== "..";
+}
+function validateQueueItemPath(item) {
+	const normalizedPath = normalizeL1FilePath(item.path);
+	if (item.path !== normalizedPath || item.id !== `file:${normalizedPath}`) throw new Error(`Invalid persisted L1 queue item path: ${item.path}`);
+	return item;
+}
+async function persistQueue(queuePath, queuedFiles, generatedAt) {
+	const queue = createL1QueueFile(queuedFiles, generatedAt);
+	await writeFile(queuePath, `${JSON.stringify(queue, null, 2)}\n`);
+}
+async function hasCurrentEntry(kbPath, item) {
+	try {
+		const entryPath = getL1FileEntryPath(kbPath, item.path);
+		const entry = parseL1FileEntry(JSON.parse(await readFile(entryPath, "utf8")));
+		return entry.scan_status === "current" && entry.path === item.path && entry.content_hash === item.hash;
+	} catch {
+		return false;
+	}
+}
+async function removeOrphanedL1Entries(kbPath, currentPaths) {
+	const entryPaths = await listL1EntryJsonFiles(join(kbPath, "l1-files")).catch((error) => {
+		if (isNodeErrorCode(error, "ENOENT")) return [];
+		throw error;
+	});
+	for (const entryPath of entryPaths) try {
+		const entry = parseL1FileEntry(JSON.parse(await readFile(entryPath, "utf8")));
+		if (!currentPaths.has(entry.path)) await rm(entryPath, { force: true });
+	} catch {
+		await rm(entryPath, { force: true });
+	}
+}
+async function listL1EntryJsonFiles(directory) {
+	const entries = await readdir(directory, { withFileTypes: true });
+	const filePaths = [];
+	for (const entry of entries) {
+		const entryPath = join(directory, entry.name);
+		if (entry.isDirectory()) filePaths.push(...await listL1EntryJsonFiles(entryPath));
+		else if (entry.isFile() && entry.name.endsWith(".json")) filePaths.push(entryPath);
+	}
+	return filePaths;
+}
+async function summarizeL1Queue(kbPath, queuedFiles) {
+	let currentEntries = 0;
+	for (const item of queuedFiles) if (await hasCurrentEntry(kbPath, item)) currentEntries += 1;
+	return {
+		queued: queuedFiles.filter((item) => item.status === "queued" || item.status === "in_progress").length,
+		completed: queuedFiles.filter((item) => item.status === "completed").length,
+		failed: queuedFiles.filter((item) => item.status === "failed").length,
+		changed: queuedFiles.filter((item) => item.status === "changed").length,
+		missing: queuedFiles.filter((item) => item.status === "missing_file").length,
+		currentEntries
+	};
+}
+async function writeManifest(options, summary, generatedAt) {
+	await writeFile(options.manifestPath, `${JSON.stringify({
+		name: "topchester-kb",
+		version: 1,
+		generatedAt,
+		workspaceRoot: options.workspaceRoot,
+		l1QueuePath: options.queuePath,
+		queuedFileCount: summary.queued + summary.completed + summary.failed + summary.changed + summary.missing,
+		l1: summary,
+		gitignoreFiles: options.gitignoreFiles
+	}, null, 2)}\n`);
+}
+//#endregion
+//#region src/knowledge/compiler/index.ts
+async function compileKnowledgeBase(workspaceRoot, options = {}) {
+	options.onProgress?.({ message: "Checking project knowledge folders..." });
+	const status = getKnowledgeStatus(workspaceRoot);
+	if (!status.kbExists || !status.kbIsDirectory) throw new Error("Run `topchester kb init` before compiling the project knowledge base.");
+	if (options.requireModel) assertKbSummarizeModelConfigured(options.model);
+	await mkdir(status.cachePath, { recursive: true });
+	options.onProgress?.({ message: "Reading .gitignore files and listing project files..." });
+	const inventory = await listProjectFilesForL1(workspaceRoot, { excludedPaths: [status.kbPath, status.cachePath] });
+	options.onProgress?.({ message: `Queued ${inventory.files.length} project files for L1...` });
+	const queuedFiles = inventory.files.map(createL1QueueItem);
+	const queuePath = join(status.cachePath, "l1-queue.json");
+	const manifestPath = join(status.kbPath, "manifest.json");
+	const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const queue = createL1QueueFile(queuedFiles, generatedAt);
+	options.onProgress?.({ message: "Writing L1 queue and manifest..." });
+	await writeFile(queuePath, `${JSON.stringify(queue, null, 2)}\n`);
+	const l1 = {
+		queued: queuedFiles.length,
+		completed: 0,
+		failed: 0,
+		changed: 0,
+		missing: 0,
+		currentEntries: 0
+	};
+	await writeFile(manifestPath, `${JSON.stringify({
+		name: "topchester-kb",
+		version: 1,
+		generatedAt,
+		workspaceRoot,
+		l1QueuePath: queuePath,
+		queuedFileCount: queuedFiles.length,
+		l1,
+		gitignoreFiles: inventory.gitignoreFiles
+	}, null, 2)}\n`);
+	options.onProgress?.({ message: "Processing L1 file entries with the configured model..." });
+	const processed = options.model ? await processL1Queue({
+		workspaceRoot,
+		kbPath: status.kbPath,
+		queuePath,
+		manifestPath,
+		gitignoreFiles: inventory.gitignoreFiles,
+		model: options.model,
+		onProgress: options.onProgress
+	}) : void 0;
+	return {
+		workspaceRoot,
+		kbPath: status.kbPath,
+		cachePath: status.cachePath,
+		gitignoreFiles: inventory.gitignoreFiles,
+		queuedFiles: processed?.queuedFiles ?? queuedFiles,
+		queuePath,
+		manifestPath,
+		l1: processed?.summary ?? l1
+	};
+}
+function formatKnowledgeCompileResult(result) {
+	const l1 = result.l1 ?? {
+		queued: result.queuedFiles.length,
+		completed: 0,
+		failed: 0,
+		changed: 0,
+		missing: 0,
+		currentEntries: 0
+	};
+	const totalQueued = result.queuedFiles.length;
+	const hasPartialOutcomes = l1.failed > 0 || l1.changed > 0 || l1.missing > 0;
+	const state = l1.completed === totalQueued && !hasPartialOutcomes ? "L1 entries are ready and current" : hasPartialOutcomes ? "partial L1 compile; some files need attention" : "L1 file queue is ready";
+	return [
+		"KB compile",
+		`workspace: ${result.workspaceRoot}`,
+		`gitignore files read: ${result.gitignoreFiles.length}`,
+		`queue: ${result.queuePath}`,
+		`manifest: ${result.manifestPath}`,
+		`queued: ${totalQueued}`,
+		`completed: ${l1.completed}`,
+		`failed: ${l1.failed}`,
+		`changed: ${l1.changed}`,
+		`missing: ${l1.missing}`,
+		`current L1 entries: ${l1.currentEntries}`,
+		`state: ${state}`
+	];
+}
+function isPartialKnowledgeCompileResult(result) {
+	const l1 = result.l1;
+	return Boolean(l1 && (l1.failed > 0 || l1.changed > 0 || l1.missing > 0 || l1.completed !== result.queuedFiles.length));
+}
+function assertKbSummarizeModelConfigured(model) {
+	if (!model) throw new Error("No model configured for purpose \"kb.summarize\"; L1 entries were not processed.");
+	const maybeResolvable = model;
+	if (maybeResolvable.resolveModel) maybeResolvable.resolveModel("kb.summarize");
+}
+//#endregion
+//#region src/knowledge/init.ts
+async function initializeKnowledgeBase(workspaceRoot, options = {}) {
+	options.onProgress?.({ message: "Checking project knowledge folders..." });
+	const status = getKnowledgeStatus(workspaceRoot);
+	const paths = [
+		getTopchesterStatePath(workspaceRoot),
+		getTopchesterSessionsPath(workspaceRoot),
+		getTopchesterLogsPath(workspaceRoot),
+		status.kbPath,
+		`${status.kbPath}/l1-files`,
+		`${status.kbPath}/l2-modules`,
+		`${status.kbPath}/l3-features`,
+		`${status.kbPath}/graph`,
+		`${status.kbPath}/reviews`,
+		status.cachePath
+	];
+	const createdPaths = [];
+	const existingPaths = [];
+	for (const path of paths) {
+		options.onProgress?.({ message: `Preparing ${path}...` });
+		if (await directoryExists(path)) {
+			existingPaths.push(path);
+			continue;
+		}
+		await mkdir(path, { recursive: true });
+		createdPaths.push(path);
+	}
+	return {
+		workspaceRoot,
+		createdPaths,
+		existingPaths
+	};
+}
+function formatKnowledgeInitResult(result) {
+	const lines = ["KB init", `workspace: ${result.workspaceRoot}`];
+	for (const path of result.createdPaths) lines.push(`created: ${path}`);
+	for (const path of result.existingPaths) lines.push(`already exists: ${path}`);
+	lines.push("state: project knowledge folders are ready");
+	return lines;
+}
+async function directoryExists(path) {
+	try {
+		if (!(await stat(path)).isDirectory()) throw new Error(`${path} exists but is not a folder`);
+		return true;
+	} catch (error) {
+		if (isNodeError$1(error) && error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+function isNodeError$1(error) {
+	return error instanceof Error && "code" in error;
+}
+//#endregion
+//#region src/knowledge/reset.ts
+async function resetKnowledgeBase(workspaceRoot, options = {}) {
+	options.onProgress?.({ message: "Checking project knowledge paths..." });
+	const status = getKnowledgeStatus(workspaceRoot);
+	const paths = dedupePaths([status.kbPath, status.cachePath]);
+	const removedPaths = [];
+	const missingPaths = [];
+	for (const path of paths) {
+		assertSafeResetPath(workspaceRoot, path);
+		options.onProgress?.({ message: `Removing ${path}...` });
+		if (await removeIfPresent(path)) removedPaths.push(path);
+		else missingPaths.push(path);
+	}
+	return {
+		workspaceRoot,
+		removedPaths,
+		missingPaths
+	};
+}
+function formatKnowledgeResetResult(result) {
+	const lines = ["KB reset", `workspace: ${result.workspaceRoot}`];
+	for (const path of result.removedPaths) lines.push(`removed: ${path}`);
+	for (const path of result.missingPaths) lines.push(`already missing: ${path}`);
+	lines.push("state: project knowledge base was reset");
+	lines.push("next: run `topchester kb init` to start clean");
+	return lines;
+}
+async function removeIfPresent(path) {
+	try {
+		await rm(path, {
+			recursive: true,
+			force: false
+		});
+		return true;
+	} catch (error) {
+		if (isNodeError(error) && error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+function dedupePaths(paths) {
+	return [...new Set(paths.map((path) => resolve(path)))];
+}
+function assertSafeResetPath(workspaceRoot, path) {
+	const workspace = resolve(workspaceRoot);
+	const target = resolve(path);
+	if (target === workspace) throw new Error(`Refusing to reset KB because the configured KB path is the workspace root: ${target}`);
+	if (dirname(target) === target) throw new Error(`Refusing to reset KB because the configured KB path is a filesystem root: ${target}`);
+}
+function isNodeError(error) {
+	return error instanceof Error && "code" in error;
+}
+//#endregion
+//#region src/tui/busy.ts
+var BusyIndicator = class {
+	app;
+	tui;
+	options;
+	frames = [
+		"⠋",
+		"⠙",
+		"⠹",
+		"⠸",
+		"⠼",
+		"⠴",
+		"⠦",
+		"⠧",
+		"⠇",
+		"⠏"
+	];
+	timer;
+	index = 0;
+	ticks = 0;
+	activityOverride;
+	constructor(app, tui, options) {
+		this.app = app;
+		this.tui = tui;
+		this.options = options;
+	}
+	start() {
+		this.app.setStatus(this.options.status);
+		this.app.setPromptHint(this.options.promptHint);
+		this.render();
+		this.timer = setInterval(() => {
+			this.index = (this.index + 1) % this.frames.length;
+			this.ticks += 1;
+			this.render();
+			this.tui.requestRender();
+		}, 80);
+	}
+	stop() {
+		if (this.timer) {
+			clearInterval(this.timer);
+			this.timer = void 0;
+		}
+		this.app.setPromptHint(void 0);
+		this.app.setEphemeralLine(void 0);
+	}
+	setActivity(activity) {
+		this.activityOverride = activity;
+		this.render();
+		this.tui.requestRender();
+	}
+	render() {
+		if (this.activityOverride) {
+			this.app.setEphemeralLine(`${this.frames[this.index]} ${this.activityOverride}`);
+			return;
+		}
+		const activityEveryMs = this.options.activityEveryMs ?? 1200;
+		const activityIndex = Math.floor(this.ticks * 80 / activityEveryMs) % this.options.activities.length;
+		this.app.setEphemeralLine(`${this.frames[this.index]} ${this.options.activities[activityIndex]}`);
+	}
+};
+//#endregion
+//#region src/agent/commands.ts
+const slashCommandSuggestions = [
+	{
+		value: "/kb status",
+		description: "show project knowledge base status"
+	},
+	{
+		value: "/kb compile",
+		description: "process project files into L1 entries"
+	},
+	{
+		value: "/kb init",
+		description: "start project knowledge base setup"
+	},
+	{
+		value: "/kb reset",
+		description: "delete the local knowledge base and cache"
+	}
+];
+const slashCommands = [{
+	name: "kb",
+	description: "knowledge base commands",
+	execute: executeKbCommand
+}];
+function parseSlashCommand(input) {
+	const trimmed = input.trim();
+	if (!trimmed.startsWith("/")) return;
+	const parts = trimmed.slice(1).split(/\s+/).filter(Boolean);
+	const name = parts[0];
+	if (!name) return;
+	return {
+		name,
+		args: parts.slice(1)
+	};
+}
+async function executeSlashCommand(input, context) {
+	const parsed = parseSlashCommand(input);
+	if (!parsed) return { messages: ["That is not a slash command."] };
+	const command = slashCommands.find((candidate) => candidate.name === parsed.name);
+	if (!command) return { messages: [`Unknown command: /${parsed.name}`, "Try /kb status."] };
+	return command.execute(parsed.args, context);
+}
+function getSlashCommandSuggestions(input) {
+	const trimmed = input.trimStart();
+	if (!trimmed.startsWith("/")) return [];
+	const query = trimmed.toLowerCase();
+	return slashCommandSuggestions.filter((suggestion) => suggestion.value.toLowerCase().startsWith(query));
+}
+async function executeKbCommand(args, context) {
+	const subcommand = args[0];
+	if (subcommand === "status") return { messages: formatKnowledgeStatus(getKnowledgeStatus(context.workspaceRoot)) };
+	if (subcommand === "init") return { messages: formatKnowledgeInitResult(await initializeKnowledgeBase(context.workspaceRoot)) };
+	if (subcommand === "compile") {
+		if (!context.modelGateway) return { messages: ["No model configured for purpose \"kb.summarize\"; L1 entries were not processed."] };
+		try {
+			return { messages: formatKnowledgeCompileResult(await compileKnowledgeBase(context.workspaceRoot, {
+				model: context.modelGateway,
+				requireModel: true,
+				onProgress: context.onProgress
+			})) };
+		} catch (error) {
+			return { messages: [`KB compile failed: ${error instanceof Error ? error.message : "Unknown error."}`] };
+		}
+	}
+	if (subcommand === "reset") return { messages: formatKnowledgeResetResult(await resetKnowledgeBase(context.workspaceRoot)) };
+	return { messages: ["Usage: /kb init, /kb compile, /kb reset, or /kb status"] };
+}
+function formatKnowledgeStatus(status) {
+	const lines = [
+		"KB status",
+		`workspace: ${status.workspaceRoot}`,
+		`knowledge folder: ${formatPathStatus$2(status.kbPath, status.kbExists, status.kbIsDirectory)} (${status.kbPathSource})`,
+		`local cache folder: ${formatPathStatus$2(status.cachePath, status.cacheExists, status.cacheIsDirectory)} (${status.cachePathSource})`
+	];
+	if (!status.kbExists) lines.push("state: no knowledge base found yet");
+	else if (!status.kbIsDirectory) lines.push("state: knowledge base path is not a folder");
+	else lines.push("state: knowledge base found");
+	return lines;
+}
+function formatPathStatus$2(path, exists, isDirectory) {
+	if (!exists) return `${path} [missing]`;
+	if (!isDirectory) return `${path} [not a folder]`;
+	return `${path} [ok]`;
+}
+//#endregion
+//#region src/tui/messages.ts
+function systemMessage(text) {
+	return {
+		kind: "system",
+		text
+	};
+}
+function userMessage(text) {
+	return {
+		kind: "user",
+		text
+	};
+}
+function agentMessage(text, meta) {
+	return {
+		kind: "agent",
+		text,
+		meta
+	};
+}
+function modalMessage(message) {
+	return {
+		kind: "modal",
+		...message
+	};
+}
+function renderChatMessage(message, options = {}) {
+	if (message.kind === "modal") return renderChatModal(message, options.selectedActionIndex);
+	if (message.text.length === 0) return [""];
+	const lines = message.text.split("\n");
+	if (message.kind === "user") return renderUserMessage(lines);
+	if (message.kind === "system") return renderSystemMessage(lines);
+	const prefix = getPrefix(message.kind);
+	const rendered = prefix.length === 0 ? lines : lines.map((line, index) => `${index === 0 ? prefix : " ".repeat(prefix.length)}${line}`);
+	if (message.meta) rendered.push(ui.label(message.meta));
+	return rendered;
+}
+function renderUserMessage(lines) {
+	const prefix = "You: ";
+	return [
+		"",
+		...lines.map((line, index) => `${index === 0 ? prefix : " ".repeat(5)}${line}`),
+		""
+	];
+}
+function renderSystemMessage(lines) {
+	const bodyPrefix = "  ";
+	return [`${ui.ok("✦")} ${ui.label("System")}:`, ...lines.map((line) => `${bodyPrefix}${line}`)];
+}
+function getPrefix(kind) {
+	switch (kind) {
+		case "agent": return "";
+		case "user": return `${ui.label("You")}: `;
+		case "system": return `${ui.label("System")}: `;
+	}
+}
+function renderChatModal(message, selectedActionIndex) {
+	const icon = message.tone === "warning" ? "⚠️" : "ℹ️";
+	const title = message.tone === "warning" ? ui.warn(message.title) : ui.label(message.title);
+	const bodyLines = message.body ? ["", ...message.body.split("\n")] : [];
+	const actionLines = message.actions.map((action, index) => {
+		return `${selectedActionIndex === index ? ">" : " "} ${index + 1}) ${action.label}`;
+	});
+	const contentLines = [
+		`${icon}  ${title}:`,
+		...bodyLines,
+		"",
+		...actionLines
+	];
+	const contentWidth = Math.max(...contentLines.map(stripAnsi$1).map((line) => line.length), 1);
+	const top = `╭${"─".repeat(contentWidth + 2)}╮`;
+	const bottom = `╰${"─".repeat(contentWidth + 2)}╯`;
+	return [
+		top,
+		...contentLines.map((line) => `│ ${line}${" ".repeat(contentWidth - stripAnsi$1(line).length)} │`),
+		bottom
+	];
+}
+function stripAnsi$1(text) {
+	let plain = "";
+	for (let index = 0; index < text.length; index += 1) {
+		if (text.charCodeAt(index) === 27 && text[index + 1] === "[") {
+			index += 2;
+			while (index < text.length && text[index] !== "m") index += 1;
+			continue;
+		}
+		plain += text[index];
+	}
+	return plain;
+}
+//#endregion
+//#region src/tui/keys.ts
+function isUpKey(data) {
+	return matchesKey(data, "up") || data === "\x1B[A";
+}
+function isDownKey(data) {
+	return matchesKey(data, "down") || data === "\x1B[B";
+}
+function isEnterKey(data) {
+	return matchesKey(data, "enter") || data === "\n" || data === "\r";
+}
+function isTabKey(data) {
+	return matchesKey(data, "tab") || data === "	";
+}
+function isPageUpKey(data) {
+	return data === "\x1B[5~";
+}
+function isPageDownKey(data) {
+	return data === "\x1B[6~";
+}
+function isHomeKey(data) {
+	return matchesKey(data, "home") || data === "\x1B[H" || data === "\x1B[1~";
+}
+function isEndKey(data) {
+	return matchesKey(data, "end") || data === "\x1B[F" || data === "\x1B[4~";
+}
+function parseMouseWheel(data) {
+	const sgrMatch = data.match(new RegExp(`^${escapeRegex("\x1B")}${escapeRegex("[<")}(\\d+);\\d+;\\d+M$`));
+	if (sgrMatch) return getWheelDirection(Number(sgrMatch[1]));
+	if (data.startsWith("\x1B[M") && data.length >= 6) return getWheelDirection(data.charCodeAt(3) - 32);
+}
+function getWheelDirection(button) {
+	if ((button & 64) !== 64) return;
+	return (button & 1) === 0 ? "up" : "down";
+}
+function escapeRegex(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//#endregion
+//#region src/tui/status.ts
+function getStartupThreadMessages(context) {
+	const assignments = context.config.models?.assignments ?? {};
+	const providers = context.config.models?.providers ?? {};
+	const lines = [
+		ui.heading(""),
+		`${ui.label("workspace")}: ${context.workspaceRoot}`,
+		`${ui.label("default model")}: ${context.config.models?.defaultPurpose ?? "agent.primary"}`
+	];
+	if (Object.keys(assignments).length === 0) lines.push(`${ui.label("model assignments")}: none configured`);
+	else {
+		lines.push(`${ui.label("model assignments")}:`);
+		for (const [purpose, model] of Object.entries(assignments)) {
+			const provider = model.provider ? ` [${model.provider}]` : "";
+			lines.push(`  ${purpose}: ${model.name}${provider}`);
+		}
+	}
+	const namedProviders = Object.entries(providers).filter(([providerId]) => providerId !== "default");
+	if (namedProviders.length === 0) lines.push(`${ui.label("providers")}: none configured`);
+	else {
+		lines.push(`${ui.label("providers")}:`);
+		if (typeof providers.default === "string") lines.push(`  default: ${providers.default}`);
+		for (const [providerId, provider] of namedProviders) {
+			if (typeof provider === "string") continue;
+			const auth = provider.apiKeyEnv ? `env:${provider.apiKeyEnv}` : provider.apiKey ? "inline" : "none";
+			lines.push(`  ${providerId}: ${provider.type} ${provider.baseURL} auth=${auth}`);
+		}
+	}
+	lines.push("");
+	lines.push("Ask Topchester what you want to change.");
+	return [systemMessage(lines.join("\n"))];
+}
+function renderStaticLayout(messages, folderName = "", modelLabel = "") {
+	const threadLines = messages.flatMap((message) => renderChatMessage(message));
+	const status = formatStatusLine(folderName, modelLabel);
+	return [
+		...threadLines,
+		"",
+		"┌──────────────────────────────────────────────────────────────────────┐",
+		"│ >                                                                    │",
+		"└──────────────────────────────────────────────────────────────────────┘",
+		status
+	].join("\n");
+}
+function getFolderName(path) {
+	return basename(path) || path;
+}
+function formatStatusLine(folderName, modelLabel, status = "ready") {
+	const folder = folderName ? ` · folder: ${folderName}` : "";
+	const model = modelLabel ? ` · model: ${modelLabel}` : "";
+	return `${ui.label("status")}: ${status}${folder}${model}`;
+}
+function formatPathStatus$1(path, exists, isDirectory) {
+	if (!exists) return `${path} ${ui.warn("[missing]")}`;
+	if (!isDirectory) return `${path} ${ui.error("[not a folder]")}`;
+	return `${path} ${ui.ok("[ok]")}`;
+}
+function getModelLabel(context) {
+	const purpose = context.config.models?.defaultPurpose ?? "agent.primary";
+	const model = context.config.models?.assignments?.[purpose] ?? context.config.models?.assignments?.fallback;
+	if (!model) return "not set";
+	const provider = model.provider ?? context.config.models?.providers?.default;
+	return typeof provider === "string" ? `${model.name} [${provider}]` : model.name;
+}
+//#endregion
+//#region src/tui/text.ts
+function padLines(lines, height, width) {
+	return [...Array.from({ length: Math.max(0, height - lines.length) }, () => ""), ...lines].map((line) => truncateToWidth(line, width, "…", true));
+}
+function padThreadLine(line, innerWidth, width) {
+	return truncateToWidth(` ${truncateToWidth(line, innerWidth, "…", true)} `, width, "…", true);
+}
+function stripAnsi(text) {
+	let plain = "";
+	for (let index = 0; index < text.length; index += 1) {
+		if (text.charCodeAt(index) === 27 && text[index + 1] === "[") {
+			index += 2;
+			while (index < text.length && text[index] !== "m") index += 1;
+			continue;
+		}
+		plain += text[index];
+	}
+	return plain;
+}
+//#endregion
+//#region src/tui/layout.ts
+var ChatLayout = class {
+	terminal;
+	messages;
+	folderName;
+	modelLabel;
+	exitAgent;
+	input = new Input();
+	status = "ready";
+	ephemeralLine;
+	noticeLine;
+	promptHint;
+	cancelPending;
+	submitMessage;
+	submitCommand;
+	activeModalActionIndex = 0;
+	activeSlashSuggestionIndex = 0;
+	threadScrollOffset = 0;
+	constructor(terminal, messages, folderName, modelLabel, exitAgent = () => {}) {
+		this.terminal = terminal;
+		this.messages = messages;
+		this.folderName = folderName;
+		this.modelLabel = modelLabel;
+		this.exitAgent = exitAgent;
+		this.input.onSubmit = (value) => {
+			if (value.trim().length > 0) {
+				const message = value.trim();
+				this.addMessage(userMessage(message));
+				this.input.setValue("");
+				this.submitUserInput(message);
+			}
+		};
+	}
+	addMessage(message) {
+		this.messages.push(message);
+		this.threadScrollOffset = 0;
+		if (message.kind === "modal") this.activeModalActionIndex = 0;
+	}
+	setStatus(status) {
+		this.status = status;
+	}
+	isReady() {
+		return this.status === "ready";
+	}
+	setEphemeralLine(line) {
+		this.ephemeralLine = line;
+	}
+	setNoticeLine(line) {
+		this.noticeLine = line;
+	}
+	setPromptHint(hint) {
+		this.promptHint = hint;
+	}
+	setCancelPending(cancel) {
+		this.cancelPending = cancel;
+	}
+	setSubmitMessage(submit) {
+		this.submitMessage = submit;
+	}
+	setSubmitCommand(submit) {
+		this.submitCommand = submit;
+	}
+	setInputValue(value) {
+		this.input.setValue(value);
+	}
+	getConversationTurns() {
+		return this.messages.flatMap((message) => {
+			if (message.kind === "user") return [{
+				role: "user",
+				text: message.text
+			}];
+			if (message.kind === "agent" && message.text !== "ready") return [{
+				role: "assistant",
+				text: message.text
+			}];
+			return [];
+		});
+	}
+	get focused() {
+		return this.input.focused;
+	}
+	set focused(value) {
+		this.input.focused = value;
+	}
+	handleInput(data) {
+		if (this.cancelPending && matchesKey(data, "escape")) {
+			this.cancelPending();
+			return;
+		}
+		if (this.handleModalInput(data)) return;
+		if (this.handleSlashSuggestionInput(data)) return;
+		if (this.handleThreadScrollInput(data)) return;
+		this.input.handleInput(data);
+	}
+	invalidate() {
+		this.input.invalidate();
+	}
+	render(width) {
+		const safeWidth = Math.max(20, width);
+		const footerLines = this.getActiveModal() ? this.renderModalHelp(safeWidth) : this.renderPrompt(safeWidth);
+		const threadHeight = Math.max(1, this.terminal.rows - footerLines.length);
+		const allThreadLines = this.renderThread(safeWidth);
+		const maxScrollOffset = Math.max(0, allThreadLines.length - threadHeight);
+		this.threadScrollOffset = Math.min(this.threadScrollOffset, maxScrollOffset);
+		const end = allThreadLines.length - this.threadScrollOffset;
+		const start = Math.max(0, end - threadHeight);
+		return [...padLines(allThreadLines.slice(start, end), threadHeight, safeWidth), ...footerLines];
+	}
+	renderThread(width) {
+		const innerWidth = Math.max(1, width - 2);
+		const activeModalIndex = this.getActiveModalIndex();
+		const lines = this.messages.flatMap((message, index) => {
+			const messageLines = renderChatMessage(message, { selectedActionIndex: index === activeModalIndex ? this.activeModalActionIndex : void 0 });
+			const spacer = index === this.messages.length - 1 ? [] : [padThreadLine("", innerWidth, width)];
+			return [...this.renderThreadMessageLines(messageLines, innerWidth, width, message.kind === "user"), ...spacer];
+		});
+		if (this.ephemeralLine) lines.push(...this.renderThreadMessageLines([this.ephemeralLine], innerWidth, width, false));
+		if (this.noticeLine) lines.push(...this.renderThreadMessageLines([this.noticeLine], innerWidth, width, false));
+		return lines;
+	}
+	renderThreadMessageLines(lines, innerWidth, width, highlight) {
+		return lines.flatMap((line) => {
+			const styleLine = (value) => highlight ? ui.softBackground(value) : value;
+			if (line.length === 0) return [styleLine(padThreadLine("", innerWidth, width))];
+			return wrapTextWithAnsi(line, innerWidth).map((wrappedLine) => styleLine(padThreadLine(wrappedLine, innerWidth, width)));
+		});
+	}
+	renderPrompt(width) {
+		const top = `┌${"─".repeat(Math.max(0, width - 2))}┐`;
+		const bottom = `└${"─".repeat(Math.max(0, width - 2))}┘`;
+		const prefix = "> ";
+		const innerWidth = Math.max(1, width - 4 - 2);
+		const inputLine = this.promptHint ? truncateToWidth(ui.label(this.promptHint), innerWidth, "…", true) : truncateToWidth(renderInputWithoutPrompt(this.input, innerWidth), innerWidth, "…", true);
+		const status = truncateToWidth(formatStatusLine(this.folderName, this.modelLabel, this.status), width, "…", true);
+		return [
+			...this.renderSlashSuggestions(width),
+			top,
+			`│ ${prefix}${inputLine} │`,
+			bottom,
+			status
+		];
+	}
+	renderSlashSuggestions(width) {
+		const suggestions = this.getSlashSuggestions();
+		if (suggestions.length === 0 || this.promptHint) return [];
+		this.activeSlashSuggestionIndex = Math.min(this.activeSlashSuggestionIndex, suggestions.length - 1);
+		const innerWidth = Math.max(1, width - 4);
+		const visibleSuggestions = suggestions.slice(0, 6);
+		const lines = [
+			ui.label("slash commands"),
+			...visibleSuggestions.map((suggestion, index) => {
+				return truncateToWidth(`${index === this.activeSlashSuggestionIndex ? ">" : " "} ${suggestion.value} — ${suggestion.description}`, innerWidth, "…", true);
+			}),
+			ui.label("Tab complete · ↑↓ choose")
+		];
+		const maxLineWidth = Math.max(...lines.map(stripAnsi).map((line) => line.length), 1);
+		const boxWidth = Math.min(innerWidth, maxLineWidth);
+		const top = `╭${"─".repeat(boxWidth + 2)}╮`;
+		const bottom = `╰${"─".repeat(boxWidth + 2)}╯`;
+		return [
+			top,
+			...lines.map((line) => `│ ${line}${" ".repeat(Math.max(0, boxWidth - stripAnsi(line).length))} │`),
+			bottom
+		];
+	}
+	renderModalHelp(width) {
+		const help = "↑↓ navigate   Enter select   Esc cancel";
+		const status = formatStatusLine(this.folderName, this.modelLabel, this.status);
+		return [truncateToWidth(`  ${help}`, width, "…", true), truncateToWidth(`  ${status}`, width, "…", true)];
+	}
+	handleModalInput(data) {
+		const activeModal = this.getActiveModal();
+		if (!activeModal) return false;
+		if (isUpKey(data)) {
+			this.activeModalActionIndex = (this.activeModalActionIndex - 1 + activeModal.actions.length) % activeModal.actions.length;
+			return true;
+		}
+		if (isDownKey(data)) {
+			this.activeModalActionIndex = (this.activeModalActionIndex + 1) % activeModal.actions.length;
+			return true;
+		}
+		if (matchesKey(data, "enter") || data === "\n" || data === "\r") {
+			const action = activeModal.actions[this.activeModalActionIndex];
+			if (action.label === "Exit") {
+				this.exitAgent();
+				return true;
+			}
+			this.submitModalAction(action.value ?? action.label);
+			return true;
+		}
+		if (matchesKey(data, "escape")) {
+			this.addMessage(userMessage("Cancel"));
+			return true;
+		}
+		return false;
+	}
+	handleThreadScrollInput(data) {
+		const pageSize = Math.max(1, Math.floor(this.terminal.rows / 2));
+		const wheel = parseMouseWheel(data);
+		if (isUpKey(data)) {
+			this.threadScrollOffset += 3;
+			return true;
+		}
+		if (isDownKey(data)) {
+			this.threadScrollOffset = Math.max(0, this.threadScrollOffset - 3);
+			return true;
+		}
+		if (wheel === "up") {
+			this.threadScrollOffset += 3;
+			return true;
+		}
+		if (wheel === "down") {
+			this.threadScrollOffset = Math.max(0, this.threadScrollOffset - 3);
+			return true;
+		}
+		if (isPageUpKey(data)) {
+			this.threadScrollOffset += pageSize;
+			return true;
+		}
+		if (isPageDownKey(data)) {
+			this.threadScrollOffset = Math.max(0, this.threadScrollOffset - pageSize);
+			return true;
+		}
+		if (isHomeKey(data)) {
+			this.threadScrollOffset = Number.MAX_SAFE_INTEGER;
+			return true;
+		}
+		if (isEndKey(data)) {
+			this.threadScrollOffset = 0;
+			return true;
+		}
+		return false;
+	}
+	handleSlashSuggestionInput(data) {
+		const suggestions = this.getSlashSuggestions();
+		if (suggestions.length === 0) {
+			this.activeSlashSuggestionIndex = 0;
+			return false;
+		}
+		if (isUpKey(data)) {
+			this.activeSlashSuggestionIndex = (this.activeSlashSuggestionIndex - 1 + suggestions.length) % suggestions.length;
+			return true;
+		}
+		if (isDownKey(data)) {
+			this.activeSlashSuggestionIndex = (this.activeSlashSuggestionIndex + 1) % suggestions.length;
+			return true;
+		}
+		if (isTabKey(data)) {
+			this.completeSlashSuggestion(suggestions);
+			return true;
+		}
+		if (isEnterKey(data) && this.input.getValue().trim() !== suggestions[this.activeSlashSuggestionIndex]?.value) {
+			this.completeSlashSuggestion(suggestions);
+			return true;
+		}
+		return false;
+	}
+	completeSlashSuggestion(suggestions) {
+		this.input.setValue(suggestions[this.activeSlashSuggestionIndex]?.value ?? this.input.getValue());
+		this.input.handleInput("\x1B[F");
+	}
+	getSlashSuggestions() {
+		return getSlashCommandSuggestions(this.input.getValue());
+	}
+	getActiveModal() {
+		return this.messages[this.getActiveModalIndex()];
+	}
+	getActiveModalIndex() {
+		return this.messages[this.messages.length - 1]?.kind === "modal" ? this.messages.length - 1 : -1;
+	}
+	submitModalAction(message) {
+		this.addMessage(userMessage(message));
+		this.submitUserInput(message);
+	}
+	submitUserInput(message) {
+		if (message.startsWith("/")) this.submitCommand?.(message);
+		else this.submitMessage?.(message);
+	}
+};
+function renderInputWithoutPrompt(input, width) {
+	return (input.render(width + 2)[0] ?? "").replace(/^> /, "");
+}
+//#endregion
+//#region src/agent/conversation.ts
+function buildConversationPrompt(turns, latestMessage) {
+	const lines = turns.map((turn) => {
+		return `${turn.role === "user" ? "User" : "Assistant"}: ${turn.text}`;
+	});
+	if (lines.at(-1) !== `User: ${latestMessage}`) lines.push(`User: ${latestMessage}`);
+	return lines.join("\n\n");
+}
+//#endregion
+//#region src/agent/events.ts
+const agentEvent = {
+	status(status) {
+		return {
+			type: "status",
+			status
+		};
+	},
+	systemMessage(text) {
+		return {
+			type: "message",
+			role: "system",
+			text
+		};
+	},
+	assistantMessage(text, meta) {
+		return meta === void 0 ? {
+			type: "message",
+			role: "assistant",
+			text
+		} : {
+			type: "message",
+			role: "assistant",
+			text,
+			meta
+		};
+	},
+	toolCall(call, label) {
+		return {
+			type: "tool_call",
+			call,
+			label
+		};
+	},
+	knowledgeStatus(status) {
+		return {
+			type: "knowledge_status",
+			status
+		};
+	},
+	choice(options) {
+		return {
+			type: "choice",
+			...options
+		};
+	}
+};
+function choiceAction(label, value) {
+	return value === void 0 ? { label } : {
+		label,
+		value
+	};
+}
+//#endregion
+//#region src/agent/health.ts
+async function checkAgentReady(modelGateway, abortSignal) {
+	const abortController = new AbortController();
+	let timedOut = false;
+	const timeout = setTimeout(() => {
+		timedOut = true;
+		abortController.abort();
+	}, 3e4);
+	const abort = () => abortController.abort();
+	abortSignal?.addEventListener("abort", abort, { once: true });
+	try {
+		return (await modelGateway.generateText({
+			purpose: "agent.fast",
+			system: "You are a startup health check. Reply with exactly one word: ready",
+			prompt: "Reply with exactly: ready",
+			abortSignal: abortController.signal
+		})).text.trim().toLowerCase().includes("ready") ? "ready" : "not-ready";
+	} catch (error) {
+		if (timedOut && isAbortError(error)) return "timed-out";
+		throw error;
+	} finally {
+		clearTimeout(timeout);
+		abortSignal?.removeEventListener("abort", abort);
+	}
+}
+function isAbortError(error) {
+	if (!(error instanceof Error)) return false;
+	return error.name === "AbortError" || error.message.toLowerCase().includes("aborted");
+}
+//#endregion
+//#region src/agent/tools/types.ts
+function defineTool(definition) {
+	return definition;
+}
+//#endregion
+//#region src/agent/tools/find-file.ts
+const findFileArgsSchema = z.object({
+	query: z.string().min(1),
+	path: z.string().optional().default("."),
+	limit: z.number().int().min(1).max(200).optional().default(50)
+});
+const ignoredDirectories = new Set([
+	".git",
+	".agents",
+	".cache",
+	".next",
+	".turbo",
+	"build",
+	"coverage",
+	"dist",
+	"node_modules"
+]);
+const findFileTool = defineTool({
+	name: "find_file",
+	description: "Find files by fuzzy name inside the workspace.",
+	prompt: "find_file: find files by fuzzy name inside the workspace. To use it, reply with only JSON: {\"tool\":\"find_file\",\"args\":{\"query\":\"runtime\"}}",
+	argsSchema: findFileArgsSchema,
+	execute: (context, args) => findWorkspaceFilesByName(context.workspaceRoot, args, {
+		pathEnv: context.pathEnv,
+		logger: context.logger
+	})
+});
+async function findWorkspaceFilesByName(workspaceRoot, args, options = {}) {
+	const scopedPath = resolveWorkspaceScopedPath$1(workspaceRoot, args.path);
+	const matches = (await collectWorkspaceFiles(scopedPath.workspaceRoot, scopedPath.path, scopedPath.relativePath, options)).map((path) => {
+		const score = scoreFileMatch(args.query, path);
+		return score > 0 ? {
+			path,
+			score
+		} : void 0;
+	}).filter((match) => Boolean(match)).sort((left, right) => right.score - left.score || left.path.localeCompare(right.path)).slice(0, args.limit);
+	return {
+		tool: "find_file",
+		path: scopedPath.relativePath,
+		content: matches.length > 0 ? matches.map((match) => match.path).join("\n") : "No matching files."
+	};
+}
+async function collectWorkspaceFiles(workspaceRoot, startPath, relativeStartPath, options) {
+	const nativeFiles = await collectWorkspaceFilesWithNativeCommand(workspaceRoot, relativeStartPath, options);
+	if (nativeFiles) return nativeFiles;
+	options.logger?.debug({
+		event: "native_tool_selected",
+		tool: "find_file",
+		nativeTool: "node",
+		path: relativeStartPath
+	}, "native tool selected");
+	return collectWorkspaceFilesWithNode(workspaceRoot, startPath);
+}
+async function collectWorkspaceFilesWithNativeCommand(workspaceRoot, relativeStartPath, options) {
+	const pathEnv = options.pathEnv ?? process.env.PATH ?? "";
+	const collectors = [
+		createRipgrepCollector,
+		createFdCollector,
+		createFindCollector
+	];
+	for (const createCollector of collectors) {
+		const collector = await createCollector(pathEnv, relativeStartPath);
+		if (!collector) continue;
+		options.logger?.debug({
+			event: "native_tool_selected",
+			tool: "find_file",
+			nativeTool: collector.name,
+			path: relativeStartPath
+		}, "native tool selected");
+		const result = await runCommand$1(collector.command, collector.args, workspaceRoot);
+		options.logger?.debug({
+			event: "find_file_command_result",
+			command: collector.name,
+			exitCode: result.exitCode,
+			stdoutLength: result.stdout.length,
+			stderrLength: result.stderr.length
+		}, "find_file command result");
+		options.logger?.trace({
+			event: "find_file_command_output",
+			command: collector.name,
+			stdout: result.stdout,
+			stderr: result.stderr
+		}, "find_file command output");
+		if (result.exitCode === 0) return normalizeCommandFileList(workspaceRoot, result.stdout);
+	}
+}
+async function collectWorkspaceFilesWithNode(workspaceRoot, startPath) {
+	const files = [];
+	const pending = [startPath];
+	while (pending.length > 0) {
+		const currentPath = pending.pop() ?? startPath;
+		const entries = await readdir(currentPath, { withFileTypes: true });
+		for (const entry of entries) {
+			const absolutePath = resolve(currentPath, entry.name);
+			const relativePath = relative(workspaceRoot, absolutePath);
+			if (entry.isDirectory()) {
+				if (!ignoredDirectories.has(entry.name)) pending.push(absolutePath);
+				continue;
+			}
+			if (entry.isFile()) files.push(relativePath || ".");
+		}
+	}
+	return files;
+}
+async function createRipgrepCollector(pathEnv, relativeStartPath) {
+	const command = await findExecutable$1("rg", pathEnv);
+	if (!command) return;
+	return {
+		name: "rg",
+		command,
+		args: [
+			"--files",
+			"--hidden",
+			...ignoredDirectoryGlobArgs(),
+			"--",
+			relativeStartPath
+		]
+	};
+}
+async function createFdCollector(pathEnv, relativeStartPath) {
+	const fdCommand = await findExecutable$1("fd", pathEnv);
+	const fdfindCommand = fdCommand ? void 0 : await findExecutable$1("fdfind", pathEnv);
+	const command = fdCommand ?? fdfindCommand;
+	if (!command) return;
+	return {
+		name: fdCommand ? "fd" : "fdfind",
+		command,
+		args: [
+			"--type",
+			"f",
+			"--hidden",
+			"--color",
+			"never",
+			...ignoredDirectoryExcludeArgs(),
+			".",
+			relativeStartPath
+		]
+	};
+}
+async function createFindCollector(pathEnv, relativeStartPath) {
+	const command = await findExecutable$1("find", pathEnv);
+	if (!command) return;
+	return {
+		name: "find",
+		command,
+		args: [
+			relativeStartPath,
+			"(",
+			...ignoredDirectoryFindPruneArgs(),
+			")",
+			"-prune",
+			"-o",
+			"-type",
+			"f",
+			"-print"
+		]
+	};
+}
+function ignoredDirectoryGlobArgs() {
+	return [...ignoredDirectories].flatMap((directory) => ["--glob", `!${directory}/**`]);
+}
+function ignoredDirectoryExcludeArgs() {
+	return [...ignoredDirectories].flatMap((directory) => ["--exclude", directory]);
+}
+function ignoredDirectoryFindPruneArgs() {
+	return [...ignoredDirectories].flatMap((directory, index) => index === 0 ? ["-name", directory] : [
+		"-o",
+		"-name",
+		directory
+	]);
+}
+function normalizeCommandFileList(workspaceRoot, stdout) {
+	return stdout.split("\n").map((line) => normalizeCommandFilePath(workspaceRoot, line)).filter((path) => Boolean(path));
+}
+function normalizeCommandFilePath(workspaceRoot, path) {
+	const trimmed = path.trim();
+	if (!trimmed) return;
+	const relativePath = isAbsolute(trimmed) ? relative(workspaceRoot, trimmed) : trimmed.replace(/^\.\//, "");
+	if (!relativePath || relativePath.startsWith("..") || isAbsolute(relativePath)) return;
+	return relativePath;
+}
+function scoreFileMatch(query, path) {
+	const normalizedQuery = normalize(query);
+	const normalizedPath = normalize(path);
+	const normalizedName = normalize(basename(path));
+	if (!normalizedQuery) return 0;
+	const exactScore = scoreExactMatch(normalizedQuery, normalizedPath, normalizedName);
+	if (exactScore > 0) return exactScore;
+	const pathTokenScore = scoreTokenMatch(normalizedQuery, normalizedPath);
+	const nameTokenScore = scoreTokenMatch(normalizedQuery, normalizedName);
+	const nameFuzzyScore = scoreSubsequenceMatch(normalizedQuery, normalizedName);
+	const pathFuzzyScore = scoreSubsequenceMatch(normalizedQuery, normalizedPath);
+	return Math.max(pathTokenScore, nameTokenScore, nameFuzzyScore, pathFuzzyScore);
+}
+function scoreExactMatch(query, path, name) {
+	if (name === query) return 1e3;
+	if (path === query) return 950;
+	const nameIndex = name.indexOf(query);
+	if (nameIndex >= 0) return 900 - nameIndex - Math.max(0, name.length - query.length) / 100;
+	const pathIndex = path.indexOf(query);
+	if (pathIndex >= 0) return 800 - pathIndex - Math.max(0, path.length - query.length) / 100;
+	return 0;
+}
+function scoreTokenMatch(query, value) {
+	const tokens = query.split(/[^a-z0-9]+/).filter(Boolean);
+	if (tokens.length <= 1 || !tokens.every((token) => value.includes(token))) return 0;
+	return 700 - Math.max(0, value.length - query.length) / 100;
+}
+function scoreSubsequenceMatch(query, value) {
+	let queryIndex = 0;
+	let gapCount = 0;
+	let lastMatchIndex = -1;
+	for (let valueIndex = 0; valueIndex < value.length && queryIndex < query.length; valueIndex += 1) {
+		if (value[valueIndex] !== query[queryIndex]) continue;
+		if (lastMatchIndex >= 0) gapCount += valueIndex - lastMatchIndex - 1;
+		lastMatchIndex = valueIndex;
+		queryIndex += 1;
+	}
+	if (queryIndex !== query.length) return 0;
+	return 600 - gapCount - Math.max(0, value.length - query.length) / 100;
+}
+function normalize(value) {
+	return value.trim().toLowerCase().replaceAll("\\", "/");
+}
+function resolveWorkspaceScopedPath$1(workspaceRoot, path) {
+	const resolvedWorkspace = resolve(workspaceRoot);
+	const resolvedPath = isAbsolute(path) ? resolve(path) : resolve(resolvedWorkspace, path);
+	const relativePath = relative(resolvedWorkspace, resolvedPath);
+	if (relativePath.startsWith("..") || isAbsolute(relativePath)) throw new Error(`find_file can only search inside the workspace: ${path}`);
+	return {
+		workspaceRoot: resolvedWorkspace,
+		path: resolvedPath,
+		relativePath: relativePath || "."
+	};
+}
+async function findExecutable$1(name, pathEnv) {
+	for (const pathEntry of pathEnv.split(delimiter).filter(Boolean)) {
+		const executablePath = join(pathEntry, name);
+		try {
+			await access(executablePath, constants.X_OK);
+			return executablePath;
+		} catch {
+			continue;
+		}
+	}
+}
+function runCommand$1(command, args, cwd) {
+	return new Promise((resolveCommand) => {
+		execFile(command, args, {
+			cwd,
+			maxBuffer: 5e6
+		}, (error, stdout, stderr) => {
+			resolveCommand({
+				exitCode: getExitCode$1(error),
+				stdout: String(stdout),
+				stderr: String(stderr)
+			});
+		});
+	});
+}
+function getExitCode$1(error) {
+	if (!error) return 0;
+	if (isRecord$2(error) && typeof error.code === "number") return error.code;
+	return 1;
+}
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null;
+}
+const grepTool = defineTool({
+	name: "grep",
+	description: "Search text inside the workspace.",
+	prompt: "grep: search text inside the workspace. To use it, reply with only JSON: {\"tool\":\"grep\",\"args\":{\"pattern\":\"function name\",\"path\":\"src\"}}",
+	argsSchema: z.object({
+		pattern: z.string(),
+		path: z.string().optional()
+	}),
+	execute: (context, args) => grepWorkspace(context.workspaceRoot, args, {
+		pathEnv: context.pathEnv,
+		logger: context.logger
+	})
+});
+async function grepWorkspace(workspaceRoot, args, options = {}) {
+	const scopedPath = resolveWorkspaceScopedPath(workspaceRoot, args.path ?? ".");
+	const executable = await findSearchExecutable(options.pathEnv);
+	if (!executable) {
+		const warning = "grep could not run because neither rg nor grep is available on PATH.";
+		options.logger?.debug({
+			event: "native_tool_unavailable",
+			tool: "grep",
+			candidates: ["rg", "grep"],
+			path: scopedPath.relativePath
+		}, "native tool unavailable");
+		return {
+			tool: "grep",
+			path: scopedPath.relativePath,
+			content: warning,
+			warning
+		};
+	}
+	const commandArgs = executable.name === "rg" ? [
+		"--line-number",
+		"--color",
+		"never",
+		"--hidden",
+		"--glob",
+		"!.git/**",
+		"--no-heading",
+		"--",
+		args.pattern,
+		scopedPath.relativePath
+	] : [
+		"-R",
+		"-n",
+		"--",
+		args.pattern,
+		scopedPath.relativePath
+	];
+	options.logger?.debug({
+		event: "native_tool_selected",
+		tool: "grep",
+		nativeTool: executable.name,
+		path: scopedPath.relativePath
+	}, "native tool selected");
+	const result = await runCommand(executable.path, commandArgs, scopedPath.workspaceRoot);
+	options.logger?.debug({
+		event: "grep_command_result",
+		command: executable.name,
+		exitCode: result.exitCode,
+		stdoutLength: result.stdout.length,
+		stderrLength: result.stderr.length
+	}, "grep command result");
+	options.logger?.trace({
+		event: "grep_command_output",
+		command: executable.name,
+		stdout: result.stdout,
+		stderr: result.stderr
+	}, "grep command output");
+	if (result.exitCode > 1) throw new Error(`${executable.name} failed: ${result.stderr.trim() || result.stdout.trim() || `exit ${result.exitCode}`}`);
+	return {
+		tool: "grep",
+		path: scopedPath.relativePath,
+		command: executable.name,
+		content: truncateToolOutput(result.stdout.trimEnd() || "No matches.")
+	};
+}
+function resolveWorkspaceScopedPath(workspaceRoot, path) {
+	const resolvedWorkspace = resolve(workspaceRoot);
+	const resolvedPath = isAbsolute(path) ? resolve(path) : resolve(resolvedWorkspace, path);
+	const relativePath = relative(resolvedWorkspace, resolvedPath);
+	if (relativePath.startsWith("..") || isAbsolute(relativePath)) throw new Error(`grep can only search inside the workspace: ${path}`);
+	return {
+		workspaceRoot: resolvedWorkspace,
+		path: resolvedPath,
+		relativePath: relativePath || "."
+	};
+}
+async function findSearchExecutable(pathEnv = process.env.PATH ?? "") {
+	for (const name of ["rg", "grep"]) {
+		const executablePath = await findExecutable(name, pathEnv);
+		if (executablePath) return {
+			name,
+			path: executablePath
+		};
+	}
+}
+async function findExecutable(name, pathEnv) {
+	for (const pathEntry of pathEnv.split(delimiter).filter(Boolean)) {
+		const executablePath = join(pathEntry, name);
+		try {
+			await access(executablePath, constants.X_OK);
+			return executablePath;
+		} catch {
+			continue;
+		}
+	}
+}
+function runCommand(command, args, cwd) {
+	return new Promise((resolveCommand) => {
+		execFile(command, args, {
+			cwd,
+			maxBuffer: 5e6
+		}, (error, stdout, stderr) => {
+			const code = getExitCode(error);
+			resolveCommand({
+				exitCode: error ? code : 0,
+				stdout: String(stdout),
+				stderr: String(stderr)
+			});
+		});
+	});
+}
+function getExitCode(error) {
+	if (isRecord$1(error) && typeof error.code === "number") return error.code;
+	return 1;
+}
+function truncateToolOutput(output) {
+	const maxLength = 4e4;
+	if (output.length <= maxLength) return output;
+	return `${output.slice(0, maxLength)}\n\n[truncated]`;
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null;
+}
+const readFileTool = defineTool({
+	name: "read_file",
+	description: "Read a UTF-8 file inside the workspace.",
+	prompt: "read_file: read a UTF-8 file inside the workspace. To use it, reply with only JSON: {\"tool\":\"read_file\",\"args\":{\"path\":\"package.json\"}}",
+	argsSchema: z.object({ path: z.string() }),
+	execute: (context, args) => readWorkspaceFile(context.workspaceRoot, args.path)
+});
+async function readWorkspaceFile(workspaceRoot, path) {
+	const resolvedWorkspace = resolve(workspaceRoot);
+	const resolvedPath = isAbsolute(path) ? resolve(path) : resolve(resolvedWorkspace, path);
+	const relativePath = relative(resolvedWorkspace, resolvedPath);
+	if (relativePath.startsWith("..") || isAbsolute(relativePath)) throw new Error(`read_file can only read files inside the workspace: ${path}`);
+	const content = await readFile(resolvedPath, "utf8");
+	return {
+		tool: "read_file",
+		path: relativePath || ".",
+		content
+	};
+}
+//#endregion
+//#region src/agent/tools/registry.ts
+const toolRegistry = {
+	[readFileTool.name]: readFileTool,
+	[grepTool.name]: grepTool,
+	[findFileTool.name]: findFileTool
+};
+function isToolName(name) {
+	return name in toolRegistry;
+}
+function getToolDefinition(name) {
+	return toolRegistry[name];
+}
+function getToolPromptLines() {
+	return Object.values(toolRegistry).map((tool) => tool.prompt);
+}
+//#endregion
+//#region src/agent/tools/executor.ts
+async function executeToolCall(workspaceRoot, call, options = {}) {
+	const definition = getToolDefinition(call.tool);
+	const startedAt = Date.now();
+	const context = {
+		workspaceRoot,
+		pathEnv: options.pathEnv,
+		logger: options.logger
+	};
+	options.logger?.debug({
+		event: "tool_call",
+		tool: call.tool,
+		args: call.args
+	}, "tool call");
+	try {
+		const result = await definition.execute(context, call.args);
+		const durationMs = Date.now() - startedAt;
+		options.logger?.debug({
+			event: "tool_result",
+			tool: result.tool,
+			path: result.path,
+			command: result.command,
+			warning: result.warning,
+			durationMs,
+			contentLength: result.content.length
+		}, "tool result");
+		options.logger?.trace({
+			event: "tool_result_content",
+			tool: result.tool,
+			path: result.path,
+			content: result.content
+		}, "tool result content");
+		return result;
+	} catch (error) {
+		options.logger?.error({
+			event: "tool_error",
+			tool: call.tool,
+			durationMs: Date.now() - startedAt,
+			err: error
+		}, "tool failed");
+		throw error;
+	}
+}
+//#endregion
+//#region src/agent/tools/parser.ts
+function parseToolCall(text) {
+	const trimmed = stripJsonFence(text.trim());
+	let value;
+	try {
+		value = JSON.parse(trimmed);
+	} catch {
+		return;
+	}
+	if (!isRecord(value) || typeof value.tool !== "string") return;
+	if (!isToolName(value.tool)) return;
+	const definition = getToolDefinition(value.tool);
+	const parsed = definition.argsSchema.safeParse(value.args);
+	if (!parsed.success) return;
+	return {
+		tool: definition.name,
+		args: parsed.data
+	};
+}
+function stripJsonFence(text) {
+	return text.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i)?.[1] ?? text;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+//#endregion
+//#region src/agent/prompts.ts
+function getChatSystemPrompt() {
+	return [
+		"You are Topchester, a plain-spoken terminal coding agent for software engineering work.",
+		"Your job is to turn ordinary user requests into concrete repository work: inspect the codebase, make focused changes when tools allow it, verify the result when possible, and report the outcome clearly.",
+		"",
+		"Working style:",
+		"- Start by understanding the user's intent and the surrounding code before proposing or changing anything non-trivial.",
+		"- Prefer local project evidence over assumptions. Use search and read tools to find relevant files, examples, tests, commands, and conventions.",
+		"- Break multi-step work into a short internal plan. If a planning or todo tool is available, use it for non-trivial tasks and keep it current as work progresses.",
+		"- Use the most specific available tool for the job. Prefer dedicated file/search/edit/test tools over shell commands when both are available.",
+		"- Follow existing project style, naming, dependencies, and test patterns. Do not introduce new libraries or broad abstractions unless the existing code clearly supports that choice.",
+		"- Verify changes with the narrowest relevant test or check when tools allow it. If verification is not possible, say what was not run and why.",
+		"- Do not commit changes unless the user explicitly asks.",
+		"- Keep user-facing responses concise and concrete. Mention changed files, verification, and any remaining risk.",
+		"- Ask a clarifying question only when the missing information blocks useful progress or the safe interpretation is genuinely unclear.",
+		"",
+		"You have these tools available:",
+		...getToolPromptLines(),
+		"",
+		"Tool use:",
+		"- Use read/search tools when the user asks about files, code, symbols, usages, tests, or project behavior.",
+		"- Use edit/write tools when they are available and the user asks you to implement, fix, add, update, or refactor code.",
+		"- Use command/test tools when they are available and you need to inspect the environment, run tests, format, lint, typecheck, or verify behavior.",
+		"- After each tool result, decide the next useful action from the new evidence. Continue until the request is handled or blocked.",
+		"Do not make up file contents or search results."
+	].join("\n");
+}
+//#endregion
+//#region src/agent/runtime.ts
+var TopchesterAgentRuntime = class {
+	context;
+	constructor(context) {
+		this.context = context;
+	}
+	async checkAgent(abortSignal) {
+		const result = await checkAgentReady(this.context.modelGateway, abortSignal);
+		if (result === "ready") return [agentEvent.assistantMessage("ready"), agentEvent.status("ready")];
+		if (result === "timed-out") return [agentEvent.systemMessage("Agent is taking a while, so I skipped the startup check."), agentEvent.status("ready")];
+		return [agentEvent.systemMessage("Agent did not say it was ready."), agentEvent.status("ready")];
+	}
+	checkKnowledgeBase() {
+		return getKnowledgeStatusEvents(getKnowledgeStatus(this.context.workspaceRoot), this.context.devFlags);
+	}
+	async submitMessage(conversation, message, abortSignal) {
+		const prompt = buildConversationPrompt(conversation, message);
+		const startedAt = Date.now();
+		const result = await this.context.modelGateway.generateText({
+			purpose: "agent.primary",
+			system: getChatSystemPrompt(),
+			prompt,
+			abortSignal
+		});
+		const durationMs = Date.now() - startedAt;
+		const meta = formatAgentMessageMeta(result.modelId, durationMs);
+		const toolCall = parseToolCall(result.text);
+		this.context.logger.debug({
+			event: "model_response",
+			purpose: "agent.primary",
+			modelId: result.modelId,
+			durationMs,
+			textLength: result.text.length,
+			hasToolCall: Boolean(toolCall)
+		}, "model response");
+		this.context.logger.trace({
+			event: "model_response_text",
+			purpose: "agent.primary",
+			modelId: result.modelId,
+			text: result.text
+		}, "model response text");
+		if (toolCall) {
+			const toolResult = await executeToolCall(this.context.workspaceRoot, toolCall, { logger: this.context.logger });
+			const finalStartedAt = Date.now();
+			const finalResult = await this.context.modelGateway.generateText({
+				purpose: "agent.primary",
+				system: getChatSystemPrompt(),
+				prompt: `${prompt}\n\n${formatToolResultForPrompt(toolResult)}\n\nAnswer the user's request using the tool result above. Do not guess.`,
+				abortSignal
+			});
+			const finalModelDurationMs = Date.now() - finalStartedAt;
+			const finalDurationMs = durationMs + finalModelDurationMs;
+			const finalMeta = formatAgentMessageMeta(finalResult.modelId, finalDurationMs);
+			this.context.logger.debug({
+				event: "model_response",
+				purpose: "agent.primary",
+				modelId: finalResult.modelId,
+				durationMs: finalModelDurationMs,
+				totalDurationMs: finalDurationMs,
+				textLength: finalResult.text.length,
+				afterTool: toolCall.tool
+			}, "model response after tool");
+			this.context.logger.trace({
+				event: "model_response_text",
+				purpose: "agent.primary",
+				modelId: finalResult.modelId,
+				afterTool: toolCall.tool,
+				text: finalResult.text
+			}, "model response text after tool");
+			return [
+				agentEvent.toolCall(toolCall, formatToolCallMessage(toolCall)),
+				agentEvent.assistantMessage(finalResult.text.trim() || "I got an empty response from the model.", finalMeta),
+				agentEvent.status("ready")
+			];
+		}
+		return [agentEvent.assistantMessage(result.text.trim() || "I got an empty response from the model.", meta), agentEvent.status("ready")];
+	}
+	async submitSlashCommand(command, onProgress) {
+		const result = await executeSlashCommand(command, {
+			workspaceRoot: this.context.workspaceRoot,
+			modelGateway: this.context.modelGateway,
+			onProgress
+		});
+		return [agentEvent.systemMessage(result.messages.join("\n")), agentEvent.status("ready")];
+	}
+};
+function getKnowledgeStatusEvents(status, devFlags = /* @__PURE__ */ new Set()) {
+	const events = [agentEvent.knowledgeStatus(status)];
+	if (devFlags.has("disable-kb-check-modal")) return events;
+	if (!status.kbExists) events.push(agentEvent.choice({
+		tone: "warning",
+		title: "No KB found",
+		body: "Topchester needs a project knowledge base before normal coding can start.",
+		actions: [choiceAction("Create KB now", "/kb init"), choiceAction("Exit")]
+	}));
+	else if (!status.kbIsDirectory) events.push(agentEvent.choice({
+		tone: "warning",
+		title: "KB path is not a folder",
+		body: `This path exists but is not a folder:\n${status.kbPath}`,
+		actions: [choiceAction("Exit")]
+	}));
+	return events;
+}
+function formatToolResultForPrompt(result) {
+	const path = result.path ? ` ${JSON.stringify(result.path)}` : "";
+	const command = result.command ? ` via ${result.command}` : "";
+	const warning = result.warning ? `\nWarning: ${result.warning}` : "";
+	return [
+		`Tool result from ${result.tool}${path}${command}:${warning}`,
+		"```",
+		result.content,
+		"```"
+	].join("\n");
+}
+function formatToolCallMessage(call) {
+	switch (call.tool) {
+		case "read_file": return `Tool read_file: ${call.args.path}`;
+		case "grep": return `Tool grep: ${call.args.pattern} in ${call.args.path ?? "."}`;
+		case "find_file": return `Tool find_file: ${call.args.query} in ${call.args.path}`;
+	}
+}
+function formatAgentMessageMeta(model, durationMs) {
+	return `${model} · ${formatDuration(durationMs)}`;
+}
+function formatDuration(durationMs) {
+	const totalSeconds = Math.max(0, durationMs / 1e3);
+	if (totalSeconds < 10) return `${formatNumber(totalSeconds, 1)} sec`;
+	if (totalSeconds < 60) return `${Math.round(totalSeconds)} sec`;
+	const minutes = Math.floor(totalSeconds / 60);
+	const seconds = Math.round(totalSeconds % 60);
+	if (seconds === 0) return `${minutes} min`;
+	return `${minutes} min ${seconds} sec`;
+}
+function formatNumber(value, fractionDigits) {
+	return value.toLocaleString("en", {
+		minimumFractionDigits: fractionDigits,
+		maximumFractionDigits: fractionDigits
+	});
+}
+//#endregion
+//#region src/tui/runtime-events.ts
+function renderRuntimeEvent(event) {
+	switch (event.type) {
+		case "message": return [event.role === "assistant" ? agentMessage(event.text, event.meta) : systemMessage(event.text)];
+		case "tool_call": return [systemMessage(event.label)];
+		case "knowledge_status": return [systemMessage(`KB status: ${formatPathStatus$1(event.status.kbPath, event.status.kbExists, event.status.kbIsDirectory)} (${event.status.kbPathSource})`)];
+		case "choice": return [modalMessage({
+			tone: event.tone,
+			title: event.title,
+			body: event.body,
+			actions: event.actions
+		})];
+		case "status": return [];
+	}
+}
+//#endregion
+//#region src/tui/terminal.ts
+function enterAlternateScreen(terminal) {
+	terminal.write("\x1B[?1049h");
+	terminal.clearScreen();
+}
+function exitAlternateScreen(terminal) {
+	terminal.write("\x1B[?1049l");
+}
+//#endregion
+//#region src/tui/shell.ts
+var TopchesterTuiShell = class {
+	context;
+	runtime;
+	constructor(context, runtime) {
+		this.context = context;
+		this.runtime = runtime ?? new TopchesterAgentRuntime(context);
+	}
+	async render() {
+		const messages = getStartupThreadMessages(this.context);
+		const folderName = getFolderName(this.context.workspaceRoot);
+		const modelLabel = getModelLabel(this.context);
+		if (!process.stdin.isTTY || !process.stdout.isTTY) {
+			console.log(renderStaticLayout(messages, folderName, modelLabel));
+			return;
+		}
+		const terminal = new ProcessTerminal();
+		enterAlternateScreen(terminal);
+		const tui = new TUI(terminal, true);
+		const exit = () => {
+			tui.stop();
+			exitAlternateScreen(terminal);
+		};
+		const app = new ChatLayout(terminal, messages, folderName, modelLabel, () => {
+			exit();
+			process.exit(0);
+		});
+		app.setSubmitMessage((message) => {
+			this.submitChatMessage(app, tui, message);
+		});
+		app.setSubmitCommand((command) => {
+			this.submitSlashCommand(app, tui, command);
+		});
+		tui.addChild(app);
+		tui.setFocus(app);
+		tui.addInputListener(createExitConfirmationInputListener({
+			setNoticeLine: (line) => {
+				app.setNoticeLine(line);
+			},
+			requestRender: () => {
+				tui.requestRender();
+			},
+			exit: () => {
+				exit();
+				process.exit(0);
+			}
+		}));
+		tui.start();
+		this.checkAgent(app, tui);
+	}
+	async checkAgent(app, tui) {
+		const busy = new BusyIndicator(app, tui, {
+			status: "checking agent",
+			promptHint: "press Esc to stop",
+			activities: [
+				"Checking model config...",
+				"Calling agent.fast...",
+				"Waiting for model..."
+			]
+		});
+		const abortController = new AbortController();
+		let cancelled = false;
+		app.setCancelPending(() => {
+			cancelled = true;
+			abortController.abort();
+		});
+		busy.start();
+		tui.requestRender();
+		try {
+			this.applyRuntimeEvents(app, await this.runtime.checkAgent(abortController.signal));
+		} catch (error) {
+			if (cancelled) {
+				app.addMessage(systemMessage("Agent check stopped."));
+				app.setStatus("ready");
+			} else {
+				const message = error instanceof Error ? error.message : String(error);
+				app.addMessage(systemMessage(`Agent check failed: ${message}`));
+				app.setStatus("agent check failed");
+			}
+		} finally {
+			app.setCancelPending(void 0);
+			busy.stop();
+		}
+		if (app.isReady()) this.applyRuntimeEvents(app, this.runtime.checkKnowledgeBase());
+		tui.requestRender();
+	}
+	async submitChatMessage(app, tui, message) {
+		const busy = new BusyIndicator(app, tui, {
+			status: "thinking",
+			promptHint: "press Esc to stop",
+			activities: [
+				"Thinking...",
+				"Calling model...",
+				"Writing response..."
+			]
+		});
+		const abortController = new AbortController();
+		let cancelled = false;
+		app.setCancelPending(() => {
+			cancelled = true;
+			abortController.abort();
+		});
+		busy.start();
+		tui.requestRender();
+		try {
+			this.applyRuntimeEvents(app, await this.runtime.submitMessage(app.getConversationTurns(), message, abortController.signal));
+		} catch (error) {
+			if (cancelled) {
+				app.addMessage(systemMessage("Response stopped."));
+				app.setStatus("ready");
+			} else {
+				const errorMessage = error instanceof Error ? error.message : String(error);
+				app.addMessage(systemMessage(`Chat failed: ${errorMessage}`));
+				app.setStatus("chat failed");
+			}
+		} finally {
+			app.setCancelPending(void 0);
+			busy.stop();
+			tui.requestRender();
+		}
+	}
+	async submitSlashCommand(app, tui, command) {
+		const busy = new BusyIndicator(app, tui, {
+			status: "running command",
+			promptHint: "working...",
+			activities: getSlashCommandActivities(command),
+			activityEveryMs: 5e3
+		});
+		busy.start();
+		tui.requestRender();
+		try {
+			this.applyRuntimeEvents(app, await this.runtime.submitSlashCommand(command, (event) => {
+				busy.setActivity(event.message);
+			}));
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			app.addMessage(systemMessage(`Command failed: ${errorMessage}`));
+			app.setStatus("command failed");
+		} finally {
+			busy.stop();
+			tui.requestRender();
+		}
+	}
+	applyRuntimeEvents(app, events) {
+		for (const event of events) {
+			if (event.type === "status") app.setStatus(event.status);
+			for (const message of renderRuntimeEvent(event)) app.addMessage(message);
+		}
+	}
+};
+function getSlashCommandActivities(command) {
+	if (command.startsWith("/kb compile")) return [
+		"Checking project knowledge folders...",
+		"Reading .gitignore files...",
+		"Listing project files...",
+		"Queueing L1 work..."
+	];
+	if (command.startsWith("/kb reset")) return [
+		"Checking project knowledge paths...",
+		"Removing knowledge folder...",
+		"Removing local cache folder..."
+	];
+	return [
+		"Running command...",
+		"Preparing project knowledge folders...",
+		"Writing project knowledge folders..."
+	];
+}
+function createExitConfirmationInputListener(options) {
+	const timeoutMs = options.timeoutMs ?? 2500;
+	let exitPending = false;
+	let exitPendingUntil = 0;
+	let clearTimer;
+	const clearExitNotice = () => {
+		clearTimer = void 0;
+		exitPending = false;
+		exitPendingUntil = 0;
+		options.setNoticeLine(void 0);
+		options.requestRender();
+	};
+	return (data) => {
+		if ((isKeyRelease(data) || isKeyRepeat(data)) && matchesKey(data, "ctrl+c")) return { consume: true };
+		if (!matchesKey(data, "ctrl+c")) return;
+		if (exitPending && Date.now() <= exitPendingUntil) {
+			if (clearTimer) {
+				clearTimeout(clearTimer);
+				clearTimer = void 0;
+			}
+			options.exit();
+			return { consume: true };
+		}
+		exitPending = true;
+		exitPendingUntil = Date.now() + timeoutMs;
+		options.setNoticeLine("press Ctrl-C again to exit.");
+		options.requestRender();
+		if (clearTimer) clearTimeout(clearTimer);
+		clearTimer = setTimeout(clearExitNotice, timeoutMs);
+		clearTimer.unref?.();
+		return { consume: true };
+	};
+}
+//#endregion
+//#region src/cli.ts
+const program = new Command();
+program.name("topchester").description("KB-first terminal coding agent").version("0.0.0");
+program.option("-c, --config <path>", "explicit config file path").option("--workspace <path>", "workspace root", cwd()).option("--dev <flag>", "enable a development flag", collectDevFlag, []);
+program.action(async () => {
+	await new TopchesterTuiShell(createContextFromOptions()).render();
+});
+program.command("dev").description("start local development mode").action(() => {
+	const context = createContextFromOptions();
+	console.log("Topchester local dev mode");
+	printStartupSummary(context);
+});
+const kbCommand = program.command("kb").description("knowledge base commands");
+kbCommand.command("init").description("initialize a project knowledge base").action(async () => {
+	const context = createContextFromOptions();
+	const result = await ui.progress("Preparing project knowledge folders...", (report) => initializeKnowledgeBase(context.workspaceRoot, { onProgress: (event) => report(event.message) }));
+	console.log(formatKnowledgeInitResult(result).join("\n"));
+});
+kbCommand.command("compile").description("compile the project knowledge base").action(async () => {
+	const context = createContextFromOptions();
+	const result = await ui.progress("Processing L1 file entries...", (report) => compileKnowledgeBase(context.workspaceRoot, {
+		model: context.modelGateway,
+		requireModel: true,
+		onProgress: (event) => report(event.message)
+	}));
+	console.log(formatKnowledgeCompileResult(result).join("\n"));
+	if (isPartialKnowledgeCompileResult(result)) process.exitCode = 2;
+});
+kbCommand.command("reset").description("delete the local project knowledge base and cache").action(async () => {
+	const context = createContextFromOptions();
+	const result = await ui.progress("Resetting project knowledge base...", (report) => resetKnowledgeBase(context.workspaceRoot, { onProgress: (event) => report(event.message) }));
+	console.log(formatKnowledgeResetResult(result).join("\n"));
+});
+kbCommand.command("status").description("show project knowledge base status").action(async () => {
+	const context = createContextFromOptions();
+	const status = await ui.spinner("Checking knowledge base...", () => getKnowledgeStatus(context.workspaceRoot));
+	console.log(ui.heading("KB status"));
+	console.log(`${ui.label("workspace")}: ${status.workspaceRoot}`);
+	console.log(`${ui.label("knowledge folder")}: ${formatPathStatus(status.kbPath, status.kbExists, status.kbIsDirectory)} ${ui.label(`(${status.kbPathSource})`)}`);
+	console.log(`${ui.label("local cache folder")}: ${formatPathStatus(status.cachePath, status.cacheExists, status.cacheIsDirectory)} ${ui.label(`(${status.cachePathSource})`)}`);
+	if (!status.kbExists) console.log(`${ui.label("state")}: ${ui.warn("no knowledge base found yet")}`);
+	else if (!status.kbIsDirectory) console.log(`${ui.label("state")}: ${ui.error("knowledge base path is not a folder")}`);
+	else console.log(`${ui.label("state")}: ${ui.ok("knowledge base found")}`);
+});
+await program.parseAsync();
+function printStartupSummary(context) {
+	const assignments = context.config.models?.assignments ?? {};
+	const providers = context.config.models?.providers ?? {};
+	console.log(`workspace: ${context.workspaceRoot}`);
+	console.log(`default model purpose: ${context.config.models?.defaultPurpose ?? "agent.primary"}`);
+	if (context.devFlags.size > 0) console.log(`dev flags: ${[...context.devFlags].join(", ")}`);
+	if (context.logFilePath) console.log(`log file: ${context.logFilePath}`);
+	if (Object.keys(assignments).length === 0) console.log("model assignments: none configured");
+	else {
+		console.log("model assignments:");
+		for (const [purpose, model] of Object.entries(assignments)) {
+			const provider = model.provider ? ` [${model.provider}]` : "";
+			console.log(`  ${purpose}: ${model.name}${provider}`);
+		}
+	}
+	const namedProviders = Object.entries(providers).filter(([providerId]) => providerId !== "default");
+	if (namedProviders.length === 0) console.log("providers: none configured");
+	else {
+		console.log("providers:");
+		if (typeof providers.default === "string") console.log(`  default: ${providers.default}`);
+		for (const [providerId, provider] of namedProviders) {
+			if (typeof provider === "string") continue;
+			const auth = provider.apiKeyEnv ? `env:${provider.apiKeyEnv}` : provider.apiKey ? "inline" : "none";
+			console.log(`  ${providerId}: ${provider.type} ${provider.baseURL} auth=${auth}`);
+		}
+	}
+}
+function createContextFromOptions() {
+	const options = program.opts();
+	return createAppContext({
+		workspaceRoot: options.workspace,
+		configPath: options.config && (isAbsolute(options.config) ? options.config : resolve(cwd(), options.config)),
+		devFlags: options.dev
+	});
+}
+function collectDevFlag(flag, flags) {
+	return [...flags, flag];
+}
+function formatPathStatus(path, exists, isDirectory) {
+	if (!exists) return `${path} ${ui.warn("[missing]")}`;
+	if (!isDirectory) return `${path} ${ui.error("[not a folder]")}`;
+	return `${path} ${ui.ok("[ok]")}`;
+}
+//#endregion
+export {};
+
+//# sourceMappingURL=cli.mjs.map