@firatcand/roster 0.1.0

package/bin/roster.js

@@ -0,0 +1,2093 @@
+#!/usr/bin/env node
+import chalk from "chalk";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, statSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { rm } from "node:fs/promises";
+import fsExtra from "fs-extra";
+import { execFileSync } from "node:child_process";
+import YAML from "yaml";
+import { z } from "zod";
+//#region src/lib/paths.ts
+function findRosterRoot() {
+	const here = dirname(fileURLToPath(import.meta.url));
+	const candidates = [
+		resolve(here, "..", ".."),
+		resolve(here, ".."),
+		here
+	];
+	for (const dir of candidates) try {
+		if (JSON.parse(readFileSync(resolve(dir, "package.json"), "utf8")).name === "@firatcand/roster") return dir;
+	} catch {
+		continue;
+	}
+	throw new Error("roster: could not locate package.json");
+}
+const ROSTER_ROOT = findRosterRoot();
+function getPackageVersion() {
+	const pkg = JSON.parse(readFileSync(resolve(ROSTER_ROOT, "package.json"), "utf8"));
+	if (typeof pkg.version !== "string" || pkg.version.length === 0) throw new Error("roster: package.json has no version field");
+	return pkg.version;
+}
+//#endregion
+//#region src/lib/tools.ts
+function claudeHome() {
+	return process.env["ROSTER_CLAUDE_HOME"] ?? join(homedir(), ".claude");
+}
+function codexHome() {
+	return process.env["ROSTER_CODEX_HOME"] ?? join(homedir(), ".codex");
+}
+function geminiHome() {
+	return process.env["ROSTER_GEMINI_HOME"] ?? join(homedir(), ".gemini");
+}
+function defaultDefinitions() {
+	const claude = claudeHome();
+	const codex = codexHome();
+	const gemini = geminiHome();
+	return [
+		{
+			key: "claude",
+			name: "Claude Code",
+			configRoot: claude,
+			skillsTarget: join(claude, "skills"),
+			agentsTarget: join(claude, "agents"),
+			skillsLayout: "dir",
+			skillsFileExt: null,
+			agentsLayout: "md-copy",
+			installLink: "https://claude.ai/code"
+		},
+		{
+			key: "codex",
+			name: "Codex CLI",
+			configRoot: codex,
+			skillsTarget: join(codex, "skills"),
+			agentsTarget: join(codex, "agents"),
+			skillsLayout: "dir",
+			skillsFileExt: null,
+			agentsLayout: "codex-toml",
+			installLink: "https://github.com/openai/codex"
+		},
+		{
+			key: "gemini",
+			name: "Gemini CLI",
+			configRoot: gemini,
+			skillsTarget: join(gemini, "extensions"),
+			agentsTarget: join(gemini, "agents"),
+			skillsLayout: "dir",
+			skillsFileExt: null,
+			agentsLayout: "md-copy",
+			installLink: "https://github.com/google-gemini/gemini-cli"
+		}
+	];
+}
+function detectTools() {
+	return defaultDefinitions().filter((def) => existsSync(def.configRoot));
+}
+function allTools() {
+	return defaultDefinitions();
+}
+var RosterError = class extends Error {
+	header;
+	body;
+	remedy;
+	exitCode;
+	constructor(opts) {
+		super(`${opts.header}\n${opts.body}\n${opts.remedy}`);
+		this.name = "RosterError";
+		this.header = opts.header;
+		this.body = opts.body;
+		this.remedy = opts.remedy;
+		this.exitCode = opts.exitCode;
+	}
+};
+function isRosterError(err) {
+	return err instanceof RosterError;
+}
+function permissionError(targetPath, cause) {
+	const syscall = cause.syscall ? ` (${cause.syscall})` : "";
+	return new RosterError({
+		header: `${chalk.red.bold("roster:")} permission denied`,
+		body: `  ${cause.code ?? "EACCES"}${syscall} writing ${targetPath}`,
+		remedy: `  Re-run with sudo, or run: sudo chown -R "$USER" ${targetPath}`,
+		exitCode: 1
+	});
+}
+function noToolsError(tools) {
+	const links = tools.map((t) => `  ${t.name.padEnd(12)} ${t.installLink}`).join("\n");
+	return new RosterError({
+		header: `${chalk.red.bold("roster:")} no AI tools detected on this machine`,
+		body: "Install at least one of:\n" + links,
+		remedy: `Re-run ${chalk.bold("roster install")} after installing one.`,
+		exitCode: 3
+	});
+}
+function missingScaffoldError(scaffoldPath) {
+	return new RosterError({
+		header: `${chalk.red.bold("roster:")} scaffold templates missing`,
+		body: `  Expected at ${scaffoldPath}`,
+		remedy: "  This roster install is broken — reinstall with: npm install -g @firatcand/roster",
+		exitCode: 1
+	});
+}
+function userCancelledInit() {
+	return new RosterError({
+		header: `${chalk.dim("roster:")} cancelled`,
+		body: "  Nothing written.",
+		remedy: "  Re-run with --force to overwrite an existing CLAUDE.md.",
+		exitCode: 2
+	});
+}
+function userCancelledInstall() {
+	return new RosterError({
+		header: `${chalk.dim("roster:")} cancelled`,
+		body: "  Nothing written.",
+		remedy: `  Re-run ${chalk.bold("roster install")} when ready.`,
+		exitCode: 2
+	});
+}
+function unexpectedError(err) {
+	const message = err instanceof Error ? err.message : String(err);
+	const wrapped = new RosterError({
+		header: `${chalk.red.bold("roster:")} unexpected error`,
+		body: `  ${message}`,
+		remedy: "  Re-run with --debug for a full stack trace.",
+		exitCode: 1
+	});
+	if (err instanceof Error && err.stack) {
+		const wrapperHeader = wrapped.stack?.split("\n", 1)[0] ?? `RosterError: ${message}`;
+		const originalFrames = err.stack.replace(/^[^\n]*\n?/, "");
+		wrapped.stack = originalFrames ? `${wrapperHeader}\n${originalFrames}` : wrapperHeader;
+	}
+	return wrapped;
+}
+function renderError(err, opts) {
+	const out = opts.stream ?? process.stderr;
+	out.write(err.header + "\n");
+	if (err.body) out.write(err.body + "\n");
+	out.write(err.remedy + "\n");
+	if (opts.debug && err.stack) out.write(err.stack + "\n");
+}
+//#endregion
+//#region src/lib/frontmatter.ts
+function renderSkillFrontmatterContent(content, toolKey) {
+	const fmMatch = content.match(/^---\n([\s\S]*?)\n---\n/);
+	if (!fmMatch) return content;
+	const lines = (fmMatch[1] ?? "").split("\n").filter((l) => !/^installed_for:\s/.test(l));
+	lines.push(`installed_for: ${toolKey}`);
+	return `---\n${lines.join("\n")}\n---\n` + content.slice(fmMatch[0].length);
+}
+//#endregion
+//#region src/lib/agent-render.ts
+var RosterAgentRenderError = class extends Error {
+	field;
+	constructor(message, field) {
+		super(message);
+		this.name = "RosterAgentRenderError";
+		this.field = field;
+	}
+};
+const HEADER_COMMENT = "# Generated by roster install — DO NOT EDIT.\n# Tracks openai/codex#19399 (Codex Windows subagent TOML ignored).\n# Remove the Windows runtime-injection workaround when this issue closes.\n";
+const REQUIRED_FIELDS = ["name", "description"];
+function parseAgentSource(content) {
+	const fmMatch = content.match(/^---\n([\s\S]*?)\n---\n?/);
+	if (!fmMatch) throw new RosterAgentRenderError("Agent source has no YAML frontmatter block", "frontmatter");
+	const fmBody = fmMatch[1] ?? "";
+	const body = content.slice(fmMatch[0].length);
+	const fields = parseFlatFrontmatter(fmBody);
+	for (const required of REQUIRED_FIELDS) if (!fields[required] || fields[required].length === 0) throw new RosterAgentRenderError(`Required frontmatter field missing or empty: ${required}`, required);
+	const name = fields["name"];
+	if (name.endsWith(".persona")) throw new RosterAgentRenderError(`Agent name "${name}" must not end with ".persona" — collides with sidecar sibling`, "name");
+	const legacyReasoning = fields["reasoning_effort"];
+	const modelReasoningEffort = fields["model_reasoning_effort"] ?? legacyReasoning;
+	return {
+		name,
+		description: fields["description"],
+		body: body.replace(/^[\n\r]+/, "").replace(/\s+$/, "") + "\n",
+		model: fields["model"],
+		modelReasoningEffort
+	};
+}
+function parseFlatFrontmatter(fm) {
+	const out = {};
+	const lines = fm.split("\n");
+	for (const raw of lines) {
+		const line = raw.replace(/\r$/, "");
+		if (line.length === 0) continue;
+		if (line.startsWith("#")) continue;
+		const match = line.match(/^([A-Za-z_][A-Za-z0-9_-]*):\s*(.*)$/);
+		if (!match) throw new RosterAgentRenderError(`Unparseable frontmatter line: ${line}`, "frontmatter");
+		const key = match[1];
+		out[key] = unquoteYamlScalar((match[2] ?? "").trim(), key);
+	}
+	return out;
+}
+function unquoteYamlScalar(raw, key) {
+	if (raw.length === 0) return "";
+	const first = raw[0];
+	if (first === "\"" || first === "'") {
+		if (raw.length < 2 || raw[raw.length - 1] !== first) throw new RosterAgentRenderError(`Unterminated quoted scalar for ${key}: ${raw}`, key);
+		const inner = raw.slice(1, -1);
+		if (first === "\"") return inner.replace(/\\"/g, "\"").replace(/\\\\/g, "\\");
+		return inner;
+	}
+	return raw;
+}
+function renderCodexAgentToml(source) {
+	return renderFromParsed(parseAgentSource(source));
+}
+function renderFromParsed(s) {
+	const lines = [];
+	lines.push(HEADER_COMMENT.trimEnd());
+	lines.push("");
+	lines.push(`name = ${quoteBasic(s.name)}`);
+	lines.push(`description = ${quoteBasic(s.description)}`);
+	if (s.model !== void 0) lines.push(`model = ${quoteBasic(s.model)}`);
+	if (s.modelReasoningEffort !== void 0) lines.push(`model_reasoning_effort = ${quoteBasic(s.modelReasoningEffort)}`);
+	lines.push("");
+	lines.push("developer_instructions = \"\"\"");
+	lines.push(escapeTripleBasic(s.body).replace(/\n$/, ""));
+	lines.push("\"\"\"");
+	lines.push("");
+	return {
+		toml: lines.join("\n"),
+		personaBody: s.body
+	};
+}
+function quoteBasic(value) {
+	return "\"" + value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"") + "\"";
+}
+function escapeTripleBasic(body) {
+	return body.replace(/"""/g, "\\\"\\\"\\\"");
+}
+//#endregion
+//#region src/lib/install.ts
+const { copy, ensureDir } = fsExtra;
+var RosterPathTraversalError = class extends Error {
+	target;
+	root;
+	label;
+	constructor(target, root, label) {
+		super(`Refusing to write ${label} outside configRoot: ${target} is not under ${root}`);
+		this.name = "RosterPathTraversalError";
+		this.target = target;
+		this.root = root;
+		this.label = label;
+	}
+};
+function assertWithinRoot(target, root, label) {
+	const absRoot = resolve(root);
+	const absTarget = resolve(target);
+	const rel = relative(absRoot, absTarget);
+	if (rel === "" || rel === ".") return;
+	if (rel === ".." || rel.startsWith(".." + sep) || isAbsolute(rel)) throw new RosterPathTraversalError(absTarget, absRoot, label);
+}
+function isEacces(err) {
+	return typeof err === "object" && err !== null && err.code === "EACCES";
+}
+async function defaultConfirm$1(message) {
+	const { confirm } = await import("@inquirer/prompts");
+	return confirm({
+		message,
+		default: false
+	});
+}
+const consoleLogger$1 = {
+	log: (m) => console.log(m),
+	warn: (m) => console.warn(m)
+};
+function renderSkillFrontmatter(skillMdPath, toolKey) {
+	if (!existsSync(skillMdPath)) return;
+	const content = readFileSync(skillMdPath, "utf8");
+	const newContent = renderSkillFrontmatterContent(content, toolKey);
+	if (newContent !== content) writeFileSync(skillMdPath, newContent);
+}
+async function prepareTargetForWrite(targetPath, kind, logger, confirm) {
+	if (existsSync(targetPath) && lstatSync(targetPath).isSymbolicLink()) {
+		if (!await confirm(`${targetPath} is a symbolic link. Replace it with the bundled ${kind}?`)) {
+			logger.warn(chalk.dim(`  ~ preserved symlink: ${targetPath}`));
+			return false;
+		}
+		await rm(targetPath, { force: true });
+	}
+	return true;
+}
+async function copyOne(srcPath, targetPath, kind, logger, confirm) {
+	try {
+		if (!await prepareTargetForWrite(targetPath, kind, logger, confirm)) return false;
+		await copy(srcPath, targetPath, {
+			overwrite: true,
+			errorOnExist: false
+		});
+		return true;
+	} catch (err) {
+		if (isEacces(err)) throw permissionError(targetPath, err);
+		throw err;
+	}
+}
+async function writeRenderedOne(targetPath, contents, kind, logger, confirm) {
+	try {
+		if (!await prepareTargetForWrite(targetPath, kind, logger, confirm)) return false;
+		writeFileSync(targetPath, contents);
+		return true;
+	} catch (err) {
+		if (isEacces(err)) throw permissionError(targetPath, err);
+		throw err;
+	}
+}
+async function installToTool(tool, opts) {
+	const logger = opts.logger ?? consoleLogger$1;
+	const confirm = opts.confirm ?? defaultConfirm$1;
+	const silent = opts.silent ?? false;
+	const info = (msg) => {
+		if (!silent) logger.log(msg);
+	};
+	assertWithinRoot(tool.skillsTarget, tool.configRoot, "skillsTarget");
+	if (tool.agentsTarget) assertWithinRoot(tool.agentsTarget, tool.configRoot, "agentsTarget");
+	try {
+		await ensureDir(tool.skillsTarget);
+		if (tool.agentsTarget) await ensureDir(tool.agentsTarget);
+	} catch (err) {
+		if (isEacces(err)) throw permissionError(tool.skillsTarget, err);
+		throw err;
+	}
+	let skillsCount = 0;
+	if (existsSync(opts.skills)) {
+		const entries = readdirSync(opts.skills, { withFileTypes: true });
+		for (const dirent of entries) {
+			if (!dirent.isDirectory()) continue;
+			const srcDir = join(opts.skills, dirent.name);
+			const srcSkillMd = join(srcDir, "SKILL.md");
+			if (!existsSync(srcSkillMd)) {
+				logger.warn(chalk.yellow(`  ! skill ${dirent.name}: SKILL.md missing — skipped`));
+				continue;
+			}
+			let srcPath;
+			let targetPath;
+			let renderedSkillMd;
+			if (tool.skillsLayout === "file") {
+				const ext = tool.skillsFileExt ?? ".md";
+				srcPath = srcSkillMd;
+				targetPath = join(tool.skillsTarget, `${dirent.name}${ext}`);
+				renderedSkillMd = targetPath;
+			} else {
+				srcPath = srcDir;
+				targetPath = join(tool.skillsTarget, dirent.name);
+				renderedSkillMd = join(targetPath, "SKILL.md");
+			}
+			assertWithinRoot(targetPath, tool.configRoot, "skill targetPath");
+			info(chalk.dim(`  + skill ${dirent.name} -> ${targetPath}`));
+			if (await copyOne(srcPath, targetPath, "skill", logger, confirm)) {
+				renderSkillFrontmatter(renderedSkillMd, tool.key);
+				skillsCount++;
+			}
+		}
+	}
+	let agentsCount = 0;
+	if (tool.agentsTarget && existsSync(opts.agents)) {
+		const entries = readdirSync(opts.agents, { withFileTypes: true });
+		for (const dirent of entries) {
+			if (!dirent.isFile() || !dirent.name.endsWith(".md")) continue;
+			const srcPath = join(opts.agents, dirent.name);
+			if (tool.agentsLayout === "codex-toml") {
+				const baseName = dirent.name.replace(/\.md$/, "");
+				const tomlTarget = join(tool.agentsTarget, `${baseName}.toml`);
+				const personaTarget = join(tool.agentsTarget, `${baseName}.persona.md`);
+				assertWithinRoot(tomlTarget, tool.configRoot, "agent targetPath");
+				assertWithinRoot(personaTarget, tool.configRoot, "agent persona targetPath");
+				let rendered;
+				try {
+					rendered = renderCodexAgentToml(readFileSync(srcPath, "utf8"));
+				} catch (err) {
+					if (err instanceof RosterAgentRenderError) {
+						logger.warn(chalk.yellow(`  ! agent ${dirent.name}: ${err.message} — skipped`));
+						continue;
+					}
+					throw err;
+				}
+				info(chalk.dim(`  + agent ${dirent.name} -> ${tomlTarget}`));
+				const wroteToml = await writeRenderedOne(tomlTarget, rendered.toml, "agent", logger, confirm);
+				const wrotePersona = await writeRenderedOne(personaTarget, rendered.personaBody, "agent persona", logger, confirm);
+				if (wroteToml && wrotePersona) agentsCount++;
+				continue;
+			}
+			const targetPath = join(tool.agentsTarget, dirent.name);
+			assertWithinRoot(targetPath, tool.configRoot, "agent targetPath");
+			info(chalk.dim(`  + agent ${dirent.name} -> ${targetPath}`));
+			if (await copyOne(srcPath, targetPath, "agent", logger, confirm)) agentsCount++;
+		}
+	}
+	return {
+		skillsCount,
+		skillsTarget: tool.skillsTarget,
+		agentsCount,
+		agentsTarget: tool.agentsTarget
+	};
+}
+//#endregion
+//#region src/lib/install-args.ts
+const KNOWN_TOOL_KEYS = [
+	"claude",
+	"codex",
+	"gemini"
+];
+const TOOL_LIST = KNOWN_TOOL_KEYS.join(" | ");
+function isToolKey(value) {
+	return KNOWN_TOOL_KEYS.includes(value);
+}
+function parseInstallArgs(args) {
+	let silent = false;
+	let verbose = false;
+	let all = false;
+	let toolValue = null;
+	let toolFlagSeen = false;
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--silent") silent = true;
+		else if (arg === "--verbose") verbose = true;
+		else if (arg === "--all") all = true;
+		else if (arg === "--tool") {
+			toolFlagSeen = true;
+			const next = args[i + 1];
+			if (next === void 0 || next.startsWith("-")) return {
+				kind: "err",
+				message: `--tool requires a tool name (${TOOL_LIST})`
+			};
+			toolValue = next;
+			i++;
+		} else if (arg.startsWith("--tool=")) {
+			toolFlagSeen = true;
+			const value = arg.slice(7);
+			if (value === "") return {
+				kind: "err",
+				message: `--tool requires a tool name (${TOOL_LIST})`
+			};
+			toolValue = value;
+		}
+	}
+	if (all && toolFlagSeen) return {
+		kind: "err",
+		message: "flags --all and --tool are mutually exclusive"
+	};
+	if (toolFlagSeen && toolValue !== null) {
+		if (!isToolKey(toolValue)) return {
+			kind: "err",
+			message: `unknown tool '${toolValue}'; expected one of: ${TOOL_LIST}`
+		};
+		return {
+			kind: "ok",
+			silent,
+			verbose,
+			target: {
+				mode: "tool",
+				key: toolValue
+			}
+		};
+	}
+	if (all) return {
+		kind: "ok",
+		silent,
+		verbose,
+		target: { mode: "all" }
+	};
+	return {
+		kind: "ok",
+		silent,
+		verbose,
+		target: { mode: "interactive" }
+	};
+}
+//#endregion
+//#region src/lib/doctor-args.ts
+function parseDoctorArgs(args) {
+	let json = false;
+	let silent = false;
+	for (const arg of args) if (arg === "--json") json = true;
+	else if (arg === "--silent") silent = true;
+	return {
+		kind: "ok",
+		json,
+		silent
+	};
+}
+//#endregion
+//#region src/lib/schedule-args.ts
+const SCHEDULE_SUBCOMMANDS = new Set(["validate"]);
+function parseScheduleArgs(args) {
+	const [first, ...rest] = args;
+	if (first === void 0) return {
+		kind: "err",
+		message: "missing subcommand for 'schedule' (available: validate)"
+	};
+	if (!SCHEDULE_SUBCOMMANDS.has(first)) return {
+		kind: "err",
+		message: `unknown 'schedule' subcommand '${first}' (available: validate)`
+	};
+	let json = false;
+	let silent = false;
+	let cwd;
+	for (let i = 0; i < rest.length; i++) {
+		const arg = rest[i];
+		if (arg === "--json") json = true;
+		else if (arg === "--silent") silent = true;
+		else if (arg === "--cwd") {
+			const next = rest[i + 1];
+			if (next === void 0) return {
+				kind: "err",
+				message: "--cwd requires a path argument"
+			};
+			cwd = next;
+			i++;
+		} else if (arg.startsWith("--cwd=")) cwd = arg.slice(6);
+		else if (arg.startsWith("-")) return {
+			kind: "err",
+			message: `unknown flag for 'schedule ${first}': ${arg}`
+		};
+		else return {
+			kind: "err",
+			message: `unexpected positional argument for 'schedule ${first}': ${arg}`
+		};
+	}
+	return {
+		kind: "ok",
+		subcommand: first,
+		json,
+		silent,
+		cwd
+	};
+}
+//#endregion
+//#region src/lib/fs-utils.ts
+function entryAtPath$1(path) {
+	try {
+		const st = lstatSync(path);
+		return {
+			exists: true,
+			isSymlink: st.isSymbolicLink(),
+			isDirectory: st.isDirectory(),
+			unreadable: false
+		};
+	} catch (err) {
+		const code = err.code;
+		if (code === "ENOENT" || code === "ENOTDIR") return {
+			exists: false,
+			isSymlink: false,
+			isDirectory: false,
+			unreadable: false
+		};
+		return {
+			exists: true,
+			isSymlink: false,
+			isDirectory: false,
+			unreadable: true,
+			error: err.message
+		};
+	}
+}
+const FALLBACK_CODES = new Set([
+	"EPERM",
+	"ENOSYS",
+	"EXDEV"
+]);
+function probeSymlinkSupport(cwd) {
+	const tempPath = join(cwd, `.roster-probe-${Date.now()}`);
+	try {
+		symlinkSync("CONTEXT.md", tempPath);
+		unlinkSync(tempPath);
+		return true;
+	} catch (err) {
+		const code = err.code;
+		if (code !== void 0 && FALLBACK_CODES.has(code)) return false;
+		throw err;
+	}
+}
+function safeRead(path) {
+	try {
+		return readFileSync(path, "utf8");
+	} catch {
+		return null;
+	}
+}
+function safeReadlink(path) {
+	try {
+		return readlinkSync(path);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/lib/project-context.ts
+function substitute$1(template, vars) {
+	return template.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] ?? `{{${key}}}`);
+}
+const MARKER_RE = /^<!--\s*roster:(managed|user):(start|end)\s+(\S+)\s*-->$/;
+function parseRegions(content) {
+	const managed = /* @__PURE__ */ new Map();
+	const user = /* @__PURE__ */ new Map();
+	const errors = [];
+	let open = null;
+	const lines = content.split("\n");
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		const m = MARKER_RE.exec(line.trim());
+		if (!m) {
+			if (open) open.lines.push(line);
+			continue;
+		}
+		const [, kind, action, name] = m;
+		if (action === "start") if (open) {
+			errors.push(`Line ${i + 1}: start of region '${name}' found while region '${open.name}' is still open`);
+			open.lines.push(line);
+		} else open = {
+			kind,
+			name,
+			startLine: i + 1,
+			lines: []
+		};
+		else if (!open) errors.push(`Line ${i + 1}: end marker for '${name}' found with no open region`);
+		else if (open.name !== name) {
+			errors.push(`Line ${i + 1}: end marker for '${name}' does not match open region '${open.name}'`);
+			open = null;
+		} else {
+			const innerContent = open.lines.join("\n");
+			if (open.kind === "managed") managed.set(open.name, innerContent);
+			else user.set(open.name, innerContent);
+			open = null;
+		}
+	}
+	if (open) errors.push(`End of file: region '${open.name}' (started at line ${open.startLine}) was never closed`);
+	return {
+		managed,
+		user,
+		ok: errors.length === 0,
+		errors
+	};
+}
+function mergeRegions(existing, fresh, opts) {
+	const existingParsed = parseRegions(existing);
+	if (!existingParsed.ok) {
+		if (!opts.force) throw new Error(`roster: CONTEXT.md has malformed region markers:\n` + existingParsed.errors.map((e) => `  - ${e}`).join("\n") + `\n  Re-run with --force to overwrite, or repair the markers manually.`);
+		return {
+			merged: fresh,
+			warnings: ["Malformed markers in existing CONTEXT.md — overwrote with fresh template."]
+		};
+	}
+	const freshParsed = parseRegions(fresh);
+	const warnings = [];
+	const outputLines = [];
+	let skipLines = false;
+	const freshLines = fresh.split("\n");
+	for (const line of freshLines) {
+		const m = MARKER_RE.exec(line.trim());
+		if (!m) {
+			if (!skipLines) outputLines.push(line);
+			continue;
+		}
+		const [, kind, action, name] = m;
+		if (action === "start") {
+			outputLines.push(line);
+			if (kind === "managed") {
+				const freshContent = freshParsed.managed.get(name) ?? "";
+				outputLines.push(freshContent);
+				skipLines = true;
+			} else {
+				const existingContent = existingParsed.user.get(name);
+				if (existingContent !== void 0) outputLines.push(existingContent);
+				else {
+					const freshContent = freshParsed.user.get(name) ?? "";
+					outputLines.push(freshContent);
+				}
+				skipLines = true;
+			}
+		} else {
+			skipLines = false;
+			outputLines.push(line);
+		}
+	}
+	for (const [name, content] of existingParsed.user) if (!freshParsed.user.has(name)) {
+		outputLines.push("");
+		outputLines.push(`<!-- roster:user:start ${name} -->`);
+		outputLines.push(content);
+		outputLines.push(`<!-- roster:user:end ${name} -->`);
+	}
+	return {
+		merged: outputLines.join("\n"),
+		warnings
+	};
+}
+function renderTemplate(projectName) {
+	return substitute$1(readFileSync(join(ROSTER_ROOT, "templates", "CONTEXT.template.md"), "utf8"), { PROJECT_NAME: projectName });
+}
+function ensureSymlink(cwd, linkName, target, force, result) {
+	const linkPath = join(cwd, linkName);
+	const entry = entryAtPath$1(linkPath);
+	if (entry.unreadable) throw new Error(`roster: could not stat ${linkPath}: ${entry.error ?? "unknown error"}`);
+	if (entry.isDirectory) throw new Error(`roster: cannot create symlink at ${linkPath} — a directory exists at that path. Remove it and re-run.`);
+	if (!entry.exists) {
+		symlinkSync(target, linkPath);
+		result.filesLinked.push(linkName);
+		return;
+	}
+	if (entry.isSymlink) {
+		const actual = safeReadlink(linkPath);
+		if (actual === null) throw new Error(`roster: could not read symlink at ${linkPath}`);
+		if (actual === target) {
+			result.filesSkipped.push(linkName);
+			return;
+		}
+		if (!force) throw new Error(`roster: ${linkPath} is a symlink pointing to '${actual}', expected '${target}'. Re-run with --force to re-link.`);
+		unlinkSync(linkPath);
+		symlinkSync(target, linkPath);
+		result.filesLinked.push(linkName);
+		return;
+	}
+	if (!force) throw new Error(`roster: ${linkPath} is a regular file. Re-run with --force to replace it with a symlink.`);
+	unlinkSync(linkPath);
+	symlinkSync(target, linkPath);
+	result.filesLinked.push(linkName);
+}
+function writeContextAndLinks(cwd, projectName, opts) {
+	const result = {
+		filesWritten: [],
+		filesUpdated: [],
+		filesSkipped: [],
+		filesLinked: [],
+		warnings: []
+	};
+	const fresh = renderTemplate(projectName);
+	const contextPath = join(cwd, "CONTEXT.md");
+	let effectiveContent;
+	if (existsSync(contextPath)) {
+		const existing = readFileSync(contextPath, "utf8");
+		const { merged, warnings } = mergeRegions(existing, fresh, { force: opts.force });
+		result.warnings.push(...warnings);
+		effectiveContent = merged;
+		if (merged !== existing) {
+			writeFileSync(contextPath, merged, "utf8");
+			result.filesUpdated.push("CONTEXT.md");
+		} else result.filesSkipped.push("CONTEXT.md");
+	} else {
+		writeFileSync(contextPath, fresh, "utf8");
+		result.filesWritten.push("CONTEXT.md");
+		effectiveContent = fresh;
+	}
+	if ((opts.platform ?? process.platform) === "win32") {
+		for (const name of ["CLAUDE.md", "AGENTS.md"]) {
+			writeFileSync(join(cwd, name), effectiveContent, "utf8");
+			result.filesWritten.push(name);
+		}
+		return result;
+	}
+	if (!probeSymlinkSupport(cwd)) {
+		for (const name of ["CLAUDE.md", "AGENTS.md"]) {
+			writeFileSync(join(cwd, name), effectiveContent, "utf8");
+			result.filesWritten.push(name);
+		}
+		result.warnings.push("Symlinks not supported on this filesystem — wrote CLAUDE.md and AGENTS.md as regular files.");
+		return result;
+	}
+	for (const name of ["CLAUDE.md", "AGENTS.md"]) ensureSymlink(cwd, name, "CONTEXT.md", opts.force, result);
+	return result;
+}
+function auditWorkspace(cwd, opts) {
+	const contextPath = join(cwd, "CONTEXT.md");
+	const contextMdExists = existsSync(contextPath);
+	const items = [];
+	const warnings = [];
+	const platform = opts?.platform ?? process.platform;
+	if (!contextMdExists) return {
+		cwd,
+		contextMdExists: false,
+		items: [],
+		warnings,
+		ok: true
+	};
+	for (const linkName of ["CLAUDE.md", "AGENTS.md"]) {
+		const linkPath = join(cwd, linkName);
+		const entry = entryAtPath$1(linkPath);
+		if (!entry.exists && !entry.unreadable) {
+			items.push({
+				name: linkName,
+				status: "missing"
+			});
+			continue;
+		}
+		if (entry.unreadable) {
+			items.push({
+				name: linkName,
+				status: "unreadable",
+				reason: entry.error
+			});
+			continue;
+		}
+		if (entry.isDirectory) {
+			items.push({
+				name: linkName,
+				status: "is-directory",
+				reason: "directory found at expected link path"
+			});
+			continue;
+		}
+		if (platform === "win32") {
+			const contextContent = safeRead(contextPath);
+			const fileContent = safeRead(linkPath);
+			if (contextContent === null || fileContent === null) {
+				items.push({
+					name: linkName,
+					status: "unreadable",
+					reason: "could not read file for comparison"
+				});
+				continue;
+			}
+			if (contextContent === fileContent) items.push({
+				name: linkName,
+				status: "ok"
+			});
+			else items.push({
+				name: linkName,
+				status: "content-diverged",
+				reason: "file content differs from CONTEXT.md"
+			});
+			continue;
+		}
+		if (!entry.isSymlink) {
+			items.push({
+				name: linkName,
+				status: "not-a-symlink",
+				reason: "regular file, re-run roster init --force to repair"
+			});
+			continue;
+		}
+		const actual = safeReadlink(linkPath);
+		if (actual === null) {
+			items.push({
+				name: linkName,
+				status: "unreadable",
+				reason: "could not read symlink target"
+			});
+			continue;
+		}
+		if (actual === "CONTEXT.md") items.push({
+			name: linkName,
+			status: "ok"
+		});
+		else items.push({
+			name: linkName,
+			status: "wrong-target",
+			reason: `points to '${actual}', expected 'CONTEXT.md'`
+		});
+	}
+	return {
+		cwd,
+		contextMdExists,
+		items,
+		warnings,
+		ok: items.every((i) => i.status === "ok")
+	};
+}
+const FORGE_MARKERS = [
+	"BRIEF.md",
+	"spec/PRD.md",
+	"plans/phases.yaml"
+];
+const TEMPLATE_SUFFIX_RE = /\.template(\.[^.]+)?$/;
+function readTemplate(name) {
+	return readFileSync(join(ROSTER_ROOT, "templates", name), "utf8");
+}
+function substitute(template, vars) {
+	return template.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] ?? `{{${key}}}`);
+}
+function detectForgeMarkers(cwd) {
+	return FORGE_MARKERS.filter((m) => existsSync(join(cwd, m)));
+}
+function entryAtPath(path) {
+	try {
+		return {
+			exists: true,
+			isSymlink: lstatSync(path).isSymbolicLink()
+		};
+	} catch {
+		return {
+			exists: false,
+			isSymlink: false
+		};
+	}
+}
+function walkScaffold(srcRoot, dstRoot, vars) {
+	const written = [];
+	function walk(srcDir, dstDir) {
+		const entries = readdirSync(srcDir, { withFileTypes: true });
+		for (const entry of entries) {
+			const srcPath = join(srcDir, entry.name);
+			if (entry.isDirectory()) {
+				const subDst = join(dstDir, entry.name);
+				mkdirSync(subDst, { recursive: true });
+				walk(srcPath, subDst);
+				continue;
+			}
+			if (!entry.isFile()) throw new Error(`roster: unexpected entry type in scaffold: ${srcPath}. Scaffold must contain only regular files and directories.`);
+			if (TEMPLATE_SUFFIX_RE.test(entry.name)) {
+				const dstPath = join(dstDir, entry.name.replace(TEMPLATE_SUFFIX_RE, "$1"));
+				if (entryAtPath(dstPath).isSymlink) throw new Error(`roster: refusing to overwrite symlink at ${dstPath}. Remove the symlink and re-run roster init.`);
+				writeFileSync(dstPath, substitute(readFileSync(srcPath, "utf8"), vars), "utf8");
+				written.push(relative(dstRoot, dstPath));
+				continue;
+			}
+			const dstPath = join(dstDir, entry.name);
+			if (entryAtPath(dstPath).exists) continue;
+			copyFileSync(srcPath, dstPath);
+			written.push(relative(dstRoot, dstPath));
+		}
+	}
+	mkdirSync(dstRoot, { recursive: true });
+	walk(srcRoot, dstRoot);
+	return written;
+}
+async function defaultConfirm(message) {
+	const { confirm } = await import("@inquirer/prompts");
+	return confirm({
+		message,
+		default: false
+	});
+}
+const consoleLogger = {
+	log: (m) => console.log(m),
+	warn: (m) => console.warn(m)
+};
+function ensureEnvExample(cwd) {
+	const target = join(cwd, ".env.example");
+	if (existsSync(target)) return;
+	writeFileSync(target, readTemplate("env.example"), "utf8");
+}
+function appendGitignoreBlock(cwd) {
+	const path = join(cwd, ".gitignore");
+	const block = readTemplate("gitignore-defaults.txt");
+	if (!existsSync(path)) {
+		writeFileSync(path, block, "utf8");
+		return "written";
+	}
+	const current = readFileSync(path, "utf8");
+	if (current.includes("# Roster defaults")) return "skipped";
+	writeFileSync(path, current + (current.endsWith("\n") ? "\n" : "\n\n") + block, "utf8");
+	return "written";
+}
+async function maybeGitInit(cwd, noGit, confirm) {
+	if (noGit) return false;
+	if (existsSync(join(cwd, ".git"))) return false;
+	if (!await confirm("Initialize a git repo here?")) return false;
+	try {
+		execFileSync("git", ["init", "-q"], {
+			cwd,
+			stdio: "ignore"
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function executeInit(opts) {
+	const projectName = opts.name ?? basename(opts.cwd);
+	const logger = opts.logger ?? consoleLogger;
+	const silent = opts.silent ?? false;
+	const force = opts.force ?? false;
+	const migrate = opts.migrate ?? false;
+	const confirm = opts.confirm ?? defaultConfirm;
+	const info = (msg) => {
+		if (!silent) logger.log(msg);
+	};
+	const forgeMarkers = detectForgeMarkers(opts.cwd);
+	const contextMdPath = join(opts.cwd, "CONTEXT.md");
+	const claudeMdPath = join(opts.cwd, "CLAUDE.md");
+	const contextMdExists = existsSync(contextMdPath);
+	const claudeMdExists = existsSync(claudeMdPath);
+	const claudeMdIsSymlink = claudeMdExists ? (() => {
+		try {
+			return lstatSync(claudeMdPath).isSymbolicLink();
+		} catch {
+			return false;
+		}
+	})() : false;
+	const isMigration = claudeMdExists && !contextMdExists && !claudeMdIsSymlink;
+	const cancelledResult = {
+		status: "cancelled",
+		workspaceRoot: opts.cwd,
+		projectName,
+		filesWritten: [],
+		filesUpdated: [],
+		filesSkipped: [],
+		filesLinked: [],
+		warnings: [],
+		gitInitialized: false
+	};
+	if (isMigration && !force && !migrate) {
+		info("roster: detected a pre-CONTEXT.md workspace (CLAUDE.md is a regular file).\n  - Re-run with --migrate to upgrade and preserve your CLAUDE.md content.\n  - Re-run with --force to replace CLAUDE.md without preserving content.\n  - Or manually delete CLAUDE.md and re-run roster init.");
+		return cancelledResult;
+	}
+	if (!isMigration && (contextMdExists || claudeMdExists) && !force) {
+		const message = forgeMarkers.length > 0 ? `This looks like a forge-initialized project (found: ${forgeMarkers.join(", ")}). Running roster init will update CONTEXT.md and add the agent-team scaffold. Continue?` : `CONTEXT.md or CLAUDE.md already exists in this directory. Overwrite?`;
+		let ok;
+		try {
+			ok = await confirm(message);
+		} catch {
+			ok = false;
+		}
+		if (!ok) return cancelledResult;
+	} else if (forgeMarkers.length > 0 && !isMigration && !silent) logger.warn(chalk.yellow(`Detected forge artifacts (${forgeMarkers.join(", ")}); roster scaffold will be added alongside.`));
+	const filesWritten = [];
+	const filesUpdated = [];
+	const filesSkipped = [];
+	const filesLinked = [];
+	const warnings = [];
+	const scaffoldSrc = join(ROSTER_ROOT, "templates", "scaffold");
+	if (!existsSync(scaffoldSrc)) throw missingScaffoldError(scaffoldSrc);
+	const scaffoldFiles = walkScaffold(scaffoldSrc, opts.cwd, { PROJECT_NAME: projectName });
+	filesWritten.push(...scaffoldFiles);
+	if (isMigration && migrate) {
+		const existingClaudeMd = readFileSync(claudeMdPath, "utf8");
+		const oldTemplateSrc = join(ROSTER_ROOT, "templates", "CLAUDE.project.template.md");
+		let oldTemplateRendered = "";
+		try {
+			oldTemplateRendered = substitute(readFileSync(oldTemplateSrc, "utf8"), { PROJECT_NAME: projectName });
+		} catch {}
+		const userLines = [];
+		const existingLines = existingClaudeMd.split("\n");
+		if (!oldTemplateRendered || existingClaudeMd.trim() !== oldTemplateRendered.trim()) {
+			const templateSet = new Set(oldTemplateRendered.split("\n").map((l) => l.trim()));
+			for (const line of existingLines) if (!templateSet.has(line.trim())) userLines.push(line);
+		}
+		if (userLines.length > 0) {
+			const rendered = substitute(readFileSync(join(ROSTER_ROOT, "templates", "CONTEXT.template.md"), "utf8"), { PROJECT_NAME: projectName });
+			const USER_START = `<!-- roster:user:start workspace -->`;
+			const USER_END = `<!-- roster:user:end workspace -->`;
+			const userPlaceholder = `## Workspace: ${projectName}\n\n[Replace this section with project-specific context: domain, goals, constraints.]`;
+			const userInjected = userLines.join("\n").trim();
+			writeFileSync(contextMdPath, rendered.replace(`${USER_START}\n${userPlaceholder}\n${USER_END}`, `${USER_START}\n${userInjected}\n${USER_END}`), "utf8");
+		}
+		unlinkSync(claudeMdPath);
+		const agentsMdPath = join(opts.cwd, "AGENTS.md");
+		if (existsSync(agentsMdPath) && !lstatSync(agentsMdPath).isSymbolicLink()) unlinkSync(agentsMdPath);
+	}
+	const writeResult = writeContextAndLinks(opts.cwd, projectName, {
+		force,
+		platform: opts.platform
+	});
+	filesWritten.push(...writeResult.filesWritten);
+	filesUpdated.push(...writeResult.filesUpdated);
+	filesSkipped.push(...writeResult.filesSkipped);
+	filesLinked.push(...writeResult.filesLinked);
+	warnings.push(...writeResult.warnings);
+	if (!existsSync(join(opts.cwd, ".env.example"))) {
+		ensureEnvExample(opts.cwd);
+		filesWritten.push(".env.example");
+	}
+	if (appendGitignoreBlock(opts.cwd) === "written") filesWritten.push(".gitignore");
+	else filesSkipped.push(".gitignore");
+	const gitInitialized = await maybeGitInit(opts.cwd, opts.noGit ?? false, confirm);
+	const totalChanged = filesWritten.length + filesUpdated.length + filesLinked.length;
+	if (!silent) {
+		info("");
+		info(`${chalk.green("✓")} Initialized ${chalk.bold(projectName)} in ${opts.cwd}`);
+		if (totalChanged > 8) info(chalk.dim(`Files: ${totalChanged} written/linked`));
+		else {
+			const changed = [
+				...filesWritten,
+				...filesUpdated,
+				...filesLinked
+			];
+			info(chalk.dim("Files: ") + changed.join(", "));
+		}
+		for (const w of warnings) info(chalk.yellow(w));
+		if (gitInitialized) info(chalk.dim("Git: initialized .git/"));
+		info("");
+		info(`${chalk.dim("Next: ")}${chalk.bold("open in Claude Code")}${chalk.dim(" and run ")}${chalk.bold("/chief-of-staff audit-repo")}`);
+	}
+	return {
+		status: "ok",
+		workspaceRoot: opts.cwd,
+		projectName,
+		filesWritten,
+		filesUpdated,
+		filesSkipped,
+		filesLinked,
+		warnings,
+		gitInitialized
+	};
+}
+//#endregion
+//#region src/lib/audit.ts
+function listDirNames(root, kind) {
+	if (!existsSync(root)) return [];
+	return readdirSync(root, { withFileTypes: true }).filter((d) => kind === "dir" ? d.isDirectory() : d.isFile()).map((d) => d.name).sort();
+}
+function walkSourceFiles(root) {
+	const out = [];
+	function recurse(dir, rel) {
+		for (const dirent of readdirSync(dir, { withFileTypes: true })) {
+			const full = join(dir, dirent.name);
+			const nextRel = rel ? join(rel, dirent.name) : dirent.name;
+			if (dirent.isDirectory()) recurse(full, nextRel);
+			else if (dirent.isFile()) out.push(nextRel);
+		}
+	}
+	recurse(root, "");
+	return out;
+}
+function auditSkillDir(name, srcDir, targetDir, toolKey) {
+	if (!existsSync(targetDir)) return {
+		kind: "skill",
+		name,
+		status: "missing",
+		targetPath: targetDir
+	};
+	try {
+		const files = walkSourceFiles(srcDir);
+		for (const rel of files) {
+			const tgt = join(targetDir, rel);
+			if (!existsSync(tgt)) return {
+				kind: "skill",
+				name,
+				status: "stale",
+				targetPath: targetDir,
+				reason: `missing file: ${rel}`
+			};
+			if (rel === "SKILL.md") {
+				if (renderSkillFrontmatterContent(readFileSync(join(srcDir, rel), "utf8"), toolKey) !== readFileSync(tgt, "utf8")) return {
+					kind: "skill",
+					name,
+					status: "stale",
+					targetPath: targetDir,
+					reason: `bytes differ: ${rel}`
+				};
+				continue;
+			}
+			const srcBytes = readFileSync(join(srcDir, rel));
+			const tgtBytes = readFileSync(tgt);
+			if (Buffer.compare(srcBytes, tgtBytes) !== 0) return {
+				kind: "skill",
+				name,
+				status: "stale",
+				targetPath: targetDir,
+				reason: `bytes differ: ${rel}`
+			};
+		}
+		return {
+			kind: "skill",
+			name,
+			status: "ok",
+			targetPath: targetDir
+		};
+	} catch (err) {
+		return {
+			kind: "skill",
+			name,
+			status: "stale",
+			targetPath: targetDir,
+			reason: err.code ?? "EUNKNOWN"
+		};
+	}
+}
+function auditSkillFlatFile(name, srcSkillMd, targetFile, toolKey) {
+	if (!existsSync(targetFile)) return {
+		kind: "skill",
+		name,
+		status: "missing",
+		targetPath: targetFile
+	};
+	try {
+		if (renderSkillFrontmatterContent(readFileSync(srcSkillMd, "utf8"), toolKey) !== readFileSync(targetFile, "utf8")) return {
+			kind: "skill",
+			name,
+			status: "stale",
+			targetPath: targetFile,
+			reason: "bytes differ"
+		};
+		return {
+			kind: "skill",
+			name,
+			status: "ok",
+			targetPath: targetFile
+		};
+	} catch (err) {
+		return {
+			kind: "skill",
+			name,
+			status: "stale",
+			targetPath: targetFile,
+			reason: err.code ?? "EUNKNOWN"
+		};
+	}
+}
+function auditAgentMdCopy(name, srcFile, targetFile) {
+	if (!existsSync(targetFile)) return {
+		kind: "agent",
+		name,
+		status: "missing",
+		targetPath: targetFile
+	};
+	try {
+		const srcBytes = readFileSync(srcFile);
+		const tgtBytes = readFileSync(targetFile);
+		if (Buffer.compare(srcBytes, tgtBytes) !== 0) return {
+			kind: "agent",
+			name,
+			status: "stale",
+			targetPath: targetFile,
+			reason: "bytes differ"
+		};
+		return {
+			kind: "agent",
+			name,
+			status: "ok",
+			targetPath: targetFile
+		};
+	} catch (err) {
+		return {
+			kind: "agent",
+			name,
+			status: "stale",
+			targetPath: targetFile,
+			reason: err.code ?? "EUNKNOWN"
+		};
+	}
+}
+function auditAgentCodexToml(name, srcFile, tomlTarget, personaTarget) {
+	if (!existsSync(tomlTarget)) return {
+		kind: "agent",
+		name,
+		status: "missing",
+		targetPath: tomlTarget
+	};
+	if (!existsSync(personaTarget)) return {
+		kind: "agent",
+		name,
+		status: "missing",
+		targetPath: personaTarget,
+		reason: "persona sidecar missing"
+	};
+	try {
+		const rendered = renderCodexAgentToml(readFileSync(srcFile, "utf8"));
+		if (readFileSync(tomlTarget, "utf8") !== rendered.toml) return {
+			kind: "agent",
+			name,
+			status: "stale",
+			targetPath: tomlTarget,
+			reason: "toml bytes differ"
+		};
+		if (readFileSync(personaTarget, "utf8") !== rendered.personaBody) return {
+			kind: "agent",
+			name,
+			status: "stale",
+			targetPath: personaTarget,
+			reason: "persona bytes differ"
+		};
+		return {
+			kind: "agent",
+			name,
+			status: "ok",
+			targetPath: tomlTarget
+		};
+	} catch (err) {
+		if (err instanceof RosterAgentRenderError) return {
+			kind: "agent",
+			name,
+			status: "stale",
+			targetPath: tomlTarget,
+			reason: `render: ${err.field}`
+		};
+		return {
+			kind: "agent",
+			name,
+			status: "stale",
+			targetPath: tomlTarget,
+			reason: err.code ?? "EUNKNOWN"
+		};
+	}
+}
+function auditTool(tool, sources) {
+	const items = [];
+	for (const skillName of listDirNames(sources.skills, "dir")) {
+		const srcDir = join(sources.skills, skillName);
+		if (tool.skillsLayout === "file") {
+			const srcSkillMd = join(srcDir, "SKILL.md");
+			if (!existsSync(srcSkillMd)) continue;
+			const ext = tool.skillsFileExt ?? ".md";
+			const targetFile = join(tool.skillsTarget, `${skillName}${ext}`);
+			items.push(auditSkillFlatFile(skillName, srcSkillMd, targetFile, tool.key));
+		} else {
+			if (!existsSync(join(srcDir, "SKILL.md"))) continue;
+			const targetDir = join(tool.skillsTarget, skillName);
+			items.push(auditSkillDir(skillName, srcDir, targetDir, tool.key));
+		}
+	}
+	if (tool.agentsTarget) for (const agentName of listDirNames(sources.agents, "file")) {
+		if (!agentName.endsWith(".md")) continue;
+		const srcFile = join(sources.agents, agentName);
+		if (tool.agentsLayout === "codex-toml") {
+			const baseName = agentName.replace(/\.md$/, "");
+			const tomlTarget = join(tool.agentsTarget, `${baseName}.toml`);
+			const personaTarget = join(tool.agentsTarget, `${baseName}.persona.md`);
+			items.push(auditAgentCodexToml(agentName, srcFile, tomlTarget, personaTarget));
+		} else {
+			const targetFile = join(tool.agentsTarget, agentName);
+			items.push(auditAgentMdCopy(agentName, srcFile, targetFile));
+		}
+	}
+	const ok = items.every((i) => i.status === "ok");
+	return {
+		tool: tool.key,
+		toolName: tool.name,
+		configRoot: tool.configRoot,
+		items,
+		ok
+	};
+}
+const KEBAB_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+const CRON_ALIASES = new Set([
+	"@hourly",
+	"@daily",
+	"@weekly",
+	"@monthly",
+	"@yearly",
+	"@annually"
+]);
+const FIELD_RANGES = [
+	{
+		min: 0,
+		max: 59
+	},
+	{
+		min: 0,
+		max: 23
+	},
+	{
+		min: 1,
+		max: 31
+	},
+	{
+		min: 1,
+		max: 12
+	},
+	{
+		min: 0,
+		max: 7
+	}
+];
+const FIELD_NAMES = [
+	"minute",
+	"hour",
+	"day-of-month",
+	"month",
+	"day-of-week"
+];
+function validateCronAtom(atom, range) {
+	if (atom === "*") return true;
+	if (atom.includes("/")) {
+		const parts = atom.split("/");
+		if (parts.length !== 2) return false;
+		const [base, stepStr] = parts;
+		if (!base || !stepStr) return false;
+		const step = Number(stepStr);
+		if (!Number.isInteger(step) || step <= 0) return false;
+		if (base === "*") return true;
+		return validateCronAtom(base, range);
+	}
+	if (atom.includes("-")) {
+		const parts = atom.split("-");
+		if (parts.length !== 2) return false;
+		const [aStr, bStr] = parts;
+		if (!aStr || !bStr) return false;
+		const a = Number(aStr);
+		const b = Number(bStr);
+		if (!Number.isInteger(a) || !Number.isInteger(b)) return false;
+		if (a < range.min || b > range.max || a > b) return false;
+		return true;
+	}
+	if (atom.length === 0) return false;
+	const n = Number(atom);
+	if (!Number.isInteger(n)) return false;
+	return n >= range.min && n <= range.max;
+}
+function validateCronField(field, range) {
+	if (field.length === 0) return false;
+	return field.split(",").every((atom) => validateCronAtom(atom, range));
+}
+function validateCronExpression(expr) {
+	const trimmed = expr.trim();
+	if (trimmed.length === 0) return {
+		ok: false,
+		reason: "empty cron expression"
+	};
+	if (trimmed.startsWith("@")) {
+		if (CRON_ALIASES.has(trimmed)) return { ok: true };
+		return {
+			ok: false,
+			reason: `unsupported alias '${trimmed}' (allowed: @hourly @daily @weekly @monthly @yearly @annually)`
+		};
+	}
+	const fields = trimmed.split(/\s+/);
+	if (fields.length !== 5) return {
+		ok: false,
+		reason: `expected 5 space-separated fields, got ${fields.length}`
+	};
+	for (let i = 0; i < 5; i++) {
+		const field = fields[i];
+		const range = FIELD_RANGES[i];
+		if (!validateCronField(field, range)) return {
+			ok: false,
+			reason: `${FIELD_NAMES[i]} field '${field}' is invalid (range ${range.min}-${range.max})`
+		};
+	}
+	return { ok: true };
+}
+function isValidIanaTimezone(tz) {
+	try {
+		new Intl.DateTimeFormat("en-US", { timeZone: tz });
+		return true;
+	} catch {
+		return false;
+	}
+}
+const kebabString = (label) => z.string().min(1, { message: `${label}: required` }).refine((s) => KEBAB_RE.test(s), { message: `${label}: must be kebab-case (lowercase letters, digits, hyphens)` });
+const cronString = z.string().min(1, { message: "cron: required" }).superRefine((expr, ctx) => {
+	const result = validateCronExpression(expr);
+	if (!result.ok) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: `cron: '${expr}' is not a valid cron expression (${result.reason})`
+	});
+});
+const timezoneString = z.string().min(1).refine(isValidIanaTimezone, { message: "timezone: not a valid IANA timezone" });
+const retryPolicySchema = z.object({
+	max_attempts: z.number().int({ message: "retry_policy.max_attempts: must be an integer" }).min(1, { message: "retry_policy.max_attempts: must be ≥ 1" }).max(5, { message: "retry_policy.max_attempts: must be ≤ 5" }),
+	backoff_seconds: z.number().int({ message: "retry_policy.backoff_seconds: must be an integer" }).min(0, { message: "retry_policy.backoff_seconds: must be ≥ 0" }).max(3600, { message: "retry_policy.backoff_seconds: must be ≤ 3600" })
+}).strict();
+const TOOL_VALUES = ["claude", "codex"];
+const INSTALL_MODE_VALUES = ["ui-handoff", "via-cron"];
+const scheduleEntrySchema = z.object({
+	name: kebabString("name"),
+	agent: kebabString("agent"),
+	plan: kebabString("plan"),
+	cron: cronString,
+	tool: z.enum(TOOL_VALUES, { error: (issue) => {
+		const base = `tool: must be one of ${TOOL_VALUES.map((v) => `'${v}'`).join(" | ")}`;
+		return issue.code === "invalid_value" ? `${base} (got '${String(issue.input)}')` : base;
+	} }),
+	install_mode: z.enum(INSTALL_MODE_VALUES, { error: (issue) => {
+		const base = `install_mode: must be one of ${INSTALL_MODE_VALUES.map((v) => `'${v}'`).join(" | ")}`;
+		return issue.code === "invalid_value" ? `${base} (got '${String(issue.input)}')` : base;
+	} }),
+	timezone: timezoneString.optional(),
+	max_duration_minutes: z.number().int({ message: "max_duration_minutes: must be an integer" }).min(1, { message: "max_duration_minutes: must be ≥ 1" }).max(1440, { message: "max_duration_minutes: must be ≤ 1440" }).optional(),
+	hitl_routing: z.string().min(1).refine((p) => p.startsWith("roster/"), { message: "hitl_routing: must be a path under roster/" }).optional(),
+	retry_policy: retryPolicySchema.optional()
+}).strict();
+const scheduleFileSchema = z.object({
+	version: z.number().int({ message: "version: must be an integer" }).refine((n) => n === 1, { message: `version: unsupported schema version (expected 1)` }),
+	schedules: z.array(scheduleEntrySchema)
+}).strict();
+function flattenZodErrors(error) {
+	return error.issues.map((e) => ({
+		path: e.path.length === 0 ? "<root>" : e.path.map((p) => String(p)).join("."),
+		message: e.message
+	}));
+}
+function findDuplicateNames(entries) {
+	const seen = /* @__PURE__ */ new Map();
+	const errors = [];
+	entries.forEach((entry, i) => {
+		const first = seen.get(entry.name);
+		if (first !== void 0) errors.push({
+			path: `schedules.${i}.name`,
+			message: `name: duplicate of entry ${first} ('${entry.name}')`
+		});
+		else seen.set(entry.name, i);
+	});
+	return errors;
+}
+//#endregion
+//#region src/lib/schedule-validate.ts
+function rosterDir(cwd) {
+	return join(cwd, "roster");
+}
+function findScheduleFiles(cwd) {
+	const root = rosterDir(cwd);
+	let topEntries;
+	try {
+		topEntries = readdirSync(root);
+	} catch {
+		return [];
+	}
+	const found = [];
+	for (const entry of topEntries) {
+		const fnDir = join(root, entry);
+		let s;
+		try {
+			s = statSync(fnDir);
+		} catch {
+			continue;
+		}
+		if (!s.isDirectory()) continue;
+		const candidate = join(fnDir, "schedules.yaml");
+		try {
+			statSync(candidate);
+			found.push(candidate);
+		} catch {}
+	}
+	return found.sort();
+}
+function readFile(path) {
+	try {
+		return {
+			ok: true,
+			content: readFileSync(path, "utf8")
+		};
+	} catch (err) {
+		const e = err;
+		return {
+			ok: false,
+			error: e.code ?? e.message ?? "unreadable"
+		};
+	}
+}
+function parseYaml(content) {
+	try {
+		return {
+			ok: true,
+			value: YAML.parse(content)
+		};
+	} catch (err) {
+		return {
+			ok: false,
+			error: (err instanceof Error ? err.message : String(err)).replace(/\n+/g, " ").trim()
+		};
+	}
+}
+function validateOneFile(cwd, absPath) {
+	const relativePath = relative(cwd, absPath);
+	let stat;
+	try {
+		stat = statSync(absPath);
+	} catch (err) {
+		return {
+			path: absPath,
+			relativePath,
+			status: "fail",
+			entryCount: 0,
+			errors: [{
+				path: "<file>",
+				message: `cannot stat: ${err.code ?? "unknown"}`
+			}]
+		};
+	}
+	if (!stat.isFile()) return {
+		path: absPath,
+		relativePath,
+		status: "fail",
+		entryCount: 0,
+		errors: [{
+			path: "<file>",
+			message: stat.isDirectory() ? "expected file, found directory" : "expected regular file (got non-file entry)"
+		}]
+	};
+	const read = readFile(absPath);
+	if (!read.ok) return {
+		path: absPath,
+		relativePath,
+		status: "fail",
+		entryCount: 0,
+		errors: [{
+			path: "<file>",
+			message: `cannot read file: ${read.error}`
+		}]
+	};
+	const parsed = parseYaml(read.content);
+	if (!parsed.ok) return {
+		path: absPath,
+		relativePath,
+		status: "fail",
+		entryCount: 0,
+		errors: [{
+			path: "<file>",
+			message: `YAML parse error: ${parsed.error}`
+		}]
+	};
+	if (parsed.value === null || parsed.value === void 0) return {
+		path: absPath,
+		relativePath,
+		status: "fail",
+		entryCount: 0,
+		errors: [{
+			path: "<file>",
+			message: "file is empty or contains only null"
+		}]
+	};
+	const schemaResult = scheduleFileSchema.safeParse(parsed.value);
+	if (!schemaResult.success) return {
+		path: absPath,
+		relativePath,
+		status: "fail",
+		entryCount: 0,
+		errors: flattenZodErrors(schemaResult.error)
+	};
+	const errors = findDuplicateNames(schemaResult.data.schedules);
+	return {
+		path: absPath,
+		relativePath,
+		status: errors.length === 0 ? "pass" : "fail",
+		entryCount: schemaResult.data.schedules.length,
+		errors
+	};
+}
+function validateSchedulesInCwd(cwd) {
+	const reports = findScheduleFiles(cwd).map((f) => validateOneFile(cwd, f));
+	return {
+		ok: reports.every((r) => r.status === "pass"),
+		cwd,
+		files: reports
+	};
+}
+//#endregion
+//#region src/lib/platform.ts
+function getPlatform() {
+	const override = process.env["ROSTER_PLATFORM"];
+	if (override) return override;
+	return process.platform;
+}
+function isWindows() {
+	return getPlatform() === "win32";
+}
+//#endregion
+//#region src/commands/doctor.ts
+function tildify$2(path) {
+	const home = homedir();
+	return path.startsWith(home) ? "~" + path.slice(home.length) : path;
+}
+function icon(status) {
+	if (status === "ok") return chalk.green("✓");
+	if (status === "missing") return chalk.red("✗");
+	return chalk.yellow("!");
+}
+function label(status) {
+	if (status === "ok") return chalk.dim("OK");
+	if (status === "missing") return chalk.red("MISSING");
+	return chalk.yellow("STALE");
+}
+function computeSummary(results) {
+	const s = {
+		ok: 0,
+		missing: 0,
+		stale: 0
+	};
+	for (const r of results) for (const item of r.items) s[item.status]++;
+	return s;
+}
+function workspaceIcon(status) {
+	if (status === "ok") return chalk.green("✓");
+	return chalk.red("✗");
+}
+function workspaceLabel(status) {
+	switch (status) {
+		case "ok": return chalk.dim("OK");
+		case "missing": return chalk.red("MISSING");
+		case "wrong-target": return chalk.red("WRONG TARGET");
+		case "not-a-symlink": return chalk.yellow("NOT A SYMLINK");
+		case "content-diverged": return chalk.yellow("CONTENT DIVERGED");
+		case "is-directory": return chalk.red("IS DIRECTORY");
+		case "unreadable": return chalk.red("UNREADABLE");
+	}
+}
+function renderSchedulingSection(report) {
+	if (report.files.length === 0) return [];
+	const lines = [""];
+	lines.push(`Scheduling  ${tildify$2(report.cwd)}`);
+	for (const file of report.files) if (file.status === "pass") {
+		const entryWord = file.entryCount === 1 ? "entry" : "entries";
+		lines.push(`  ${chalk.green("✓")} ${file.relativePath}   ${chalk.dim("OK")} ${chalk.dim(`(${file.entryCount} ${entryWord})`)}`);
+	} else {
+		lines.push(`  ${chalk.red("✗")} ${file.relativePath}   ${chalk.red("FAIL")}`);
+		for (const e of file.errors) lines.push(`      ${chalk.red("-")} ${chalk.dim(e.path + ":")} ${e.message}`);
+	}
+	return lines;
+}
+function renderWorkspaceSection(audit) {
+	if (!audit.contextMdExists && audit.items.length === 0) return [];
+	const lines = [""];
+	lines.push(`Workspace  ${tildify$2(audit.cwd)}`);
+	if (audit.contextMdExists) lines.push(`  ${chalk.green("✓")} CONTEXT.md   ${chalk.dim("present")}`);
+	else lines.push(`  ${chalk.red("✗")} CONTEXT.md   ${chalk.red("MISSING")}`);
+	for (const item of audit.items) {
+		const nameCol = item.name.padEnd(12);
+		const detail = item.reason ? chalk.dim(` (${item.reason})`) : "";
+		lines.push(`  ${workspaceIcon(item.status)} ${nameCol} ${workspaceLabel(item.status)}${detail}`.trimEnd());
+	}
+	for (const w of audit.warnings) lines.push(`  ${chalk.yellow("!")} ${w}`);
+	return lines;
+}
+function computeWorkarounds(results) {
+	const workarounds = [];
+	if (isWindows() && results.some((r) => r.tool === "codex")) workarounds.push({
+		id: "codex-windows-19399",
+		toolKey: "codex",
+		status: "active",
+		summary: "Codex Windows TOML config ignored — runtime injection ACTIVE",
+		reference: "https://github.com/openai/codex/issues/19399"
+	});
+	return workarounds;
+}
+function renderText$1(results, summary, workarounds) {
+	const lines = [""];
+	lines.push(chalk.bold("roster doctor"));
+	for (const r of results) {
+		lines.push("");
+		lines.push(`${chalk.bold(r.toolName)} ${chalk.dim(tildify$2(r.configRoot))}`);
+		for (const item of r.items) {
+			const kindCol = chalk.dim(item.kind.padEnd(5));
+			const nameCol = item.name.padEnd(22);
+			const detail = item.status !== "ok" && item.reason ? chalk.dim(` (${item.reason})`) : "";
+			lines.push(`  ${icon(item.status)} ${kindCol} ${nameCol} ${label(item.status)}${detail}`.trimEnd());
+		}
+		for (const w of workarounds.filter((x) => x.toolKey === r.tool)) {
+			lines.push(`  ${chalk.yellow("!")} ${chalk.dim("w/a  ")} ${w.id.padEnd(22)} ${chalk.yellow(w.summary)}`);
+			lines.push(`        ${chalk.dim(w.reference)}`);
+		}
+	}
+	lines.push("");
+	if (summary.missing === 0 && summary.stale === 0) lines.push(chalk.green("All installed skills and agents are up to date."));
+	else {
+		const bits = [];
+		if (summary.missing > 0) bits.push(`${summary.missing} missing`);
+		if (summary.stale > 0) bits.push(`${summary.stale} stale`);
+		const toolWord = results.length === 1 ? "tool" : "tools";
+		lines.push(chalk.yellow(`Summary: ${bits.join(", ")} across ${results.length} ${toolWord}.`));
+		lines.push(`${chalk.dim("Run ")}${chalk.bold("roster install")}${chalk.dim(" to repair.")}`);
+	}
+	return lines;
+}
+function executeDoctor(opts) {
+	const detected = detectTools();
+	const sources = {
+		skills: join(ROSTER_ROOT, "skills"),
+		agents: join(ROSTER_ROOT, "agents")
+	};
+	const workspace = auditWorkspace(opts.cwd);
+	const scheduling = validateSchedulesInCwd(opts.cwd);
+	if (detected.length === 0) {
+		if (opts.json) {
+			const payload = {
+				ok: scheduling.ok,
+				rosterVersion: getPackageVersion(),
+				tools: [],
+				summary: {
+					ok: 0,
+					missing: 0,
+					stale: 0
+				},
+				workspace,
+				scheduling,
+				workarounds: [],
+				note: "no tools detected"
+			};
+			console.log(JSON.stringify(payload, null, 2));
+		}
+		return 3;
+	}
+	const results = detected.map((t) => auditTool(t, sources));
+	const summary = computeSummary(results);
+	const workarounds = computeWorkarounds(results);
+	const allOk = results.every((r) => r.ok) && workspace.ok && scheduling.ok;
+	if (opts.json) {
+		const payload = {
+			ok: allOk,
+			rosterVersion: getPackageVersion(),
+			tools: results,
+			summary,
+			workspace,
+			scheduling,
+			workarounds
+		};
+		console.log(JSON.stringify(payload, null, 2));
+	} else if (!opts.silent) {
+		for (const line of renderText$1(results, summary, workarounds)) console.log(line);
+		for (const line of renderWorkspaceSection(workspace)) console.log(line);
+		for (const line of renderSchedulingSection(scheduling)) console.log(line);
+	}
+	return allOk ? 0 : 1;
+}
+//#endregion
+//#region src/commands/schedule.ts
+function tildify$1(path) {
+	const home = homedir();
+	return path.startsWith(home) ? "~" + path.slice(home.length) : path;
+}
+function countTotalErrors(report) {
+	return report.files.reduce((acc, f) => acc + f.errors.length, 0);
+}
+function renderText(report) {
+	const lines = [""];
+	lines.push(chalk.bold("roster schedule validate"));
+	lines.push(chalk.dim(`cwd: ${tildify$1(report.cwd)}`));
+	if (report.files.length === 0) {
+		lines.push("");
+		lines.push(chalk.dim("No roster/<function>/schedules.yaml files found."));
+		return lines;
+	}
+	for (const file of report.files) {
+		lines.push("");
+		if (file.status === "pass") {
+			const entryWord = file.entryCount === 1 ? "entry" : "entries";
+			lines.push(`${chalk.green("✓")} ${file.relativePath}  ${chalk.dim("PASS")} ${chalk.dim(`(${file.entryCount} ${entryWord})`)}`);
+		} else {
+			lines.push(`${chalk.red("✗")} ${file.relativePath}  ${chalk.red("FAIL")}`);
+			for (const e of file.errors) lines.push(`    ${chalk.red("-")} ${chalk.dim(e.path + ":")} ${e.message}`);
+		}
+	}
+	lines.push("");
+	if (report.ok) {
+		const totalEntries = report.files.reduce((acc, f) => acc + f.entryCount, 0);
+		const fileWord = report.files.length === 1 ? "file" : "files";
+		const entryWord = totalEntries === 1 ? "entry" : "entries";
+		lines.push(chalk.green(`All schedules valid (${totalEntries} ${entryWord} across ${report.files.length} ${fileWord}).`));
+	} else {
+		const errs = countTotalErrors(report);
+		const fileWord = report.files.length === 1 ? "file" : "files";
+		lines.push(chalk.yellow(`Summary: ${errs} error${errs === 1 ? "" : "s"} across ${report.files.length} ${fileWord}.`));
+		lines.push(`${chalk.dim("Run ")}${chalk.bold("roster schedule validate --json")}${chalk.dim(" for machine-readable output.")}`);
+	}
+	return lines;
+}
+function executeScheduleValidate(opts) {
+	const report = validateSchedulesInCwd(opts.cwd);
+	if (opts.json) console.log(JSON.stringify(report, null, 2));
+	else if (!opts.silent) for (const line of renderText(report)) console.log(line);
+	return report.ok ? 0 : 1;
+}
+//#endregion
+//#region src/bin/roster.ts
+const SUBCOMMANDS = new Set([
+	"install",
+	"init",
+	"doctor",
+	"schedule"
+]);
+function tildify(path) {
+	const home = homedir();
+	return path.startsWith(home) ? "~" + path.slice(home.length) : path;
+}
+function printBanner(version) {
+	console.log();
+	console.log(`${chalk.bold.cyan("roster")}${chalk.dim(` v${version}`)}`);
+	console.log(chalk.dim("Multi-agent workspace scaffolder for Claude Code, Codex CLI, and Gemini."));
+	console.log();
+}
+function printHelp(version) {
+	printBanner(version);
+	const lines = [
+		chalk.bold("Usage:"),
+		`  roster                       ${chalk.dim("Interactive install (alias of `roster install`)")}`,
+		`  roster install               ${chalk.dim("Copy skills + agents into detected AI tool config dirs")}`,
+		`  roster init [name]           ${chalk.dim("Scaffold a multi-agent workspace in the current dir")}`,
+		`  roster doctor                ${chalk.dim("Audit installed skills + agents per AI tool")}`,
+		`  roster schedule validate     ${chalk.dim("Validate roster/<function>/schedules.yaml files")}`,
+		"",
+		chalk.bold("Flags:"),
+		`  -h, --help                   ${chalk.dim("Show this help")}`,
+		`  -v, --version                ${chalk.dim("Print version and exit")}`,
+		`  --silent                     ${chalk.dim("Suppress non-error output (install)")}`,
+		`  --verbose                    ${chalk.dim("Log each file path written (install)")}`,
+		`  --all                        ${chalk.dim("Install to every detected tool (install)")}`,
+		`  --tool <name>                ${chalk.dim("Install to a single tool: claude | codex | gemini")}`,
+		`  --migrate                    ${chalk.dim("Upgrade pre-CONTEXT.md workspace, preserving CLAUDE.md content (init)")}`,
+		`  --json                       ${chalk.dim("Emit machine-readable JSON (doctor, schedule validate)")}`,
+		`  --cwd <dir>                  ${chalk.dim("Run schedule validate against a different cwd")}`,
+		`  --debug                      ${chalk.dim("Print full stack trace on error (global)")}`,
+		"",
+		chalk.bold("Exit codes:"),
+		`  0  ${chalk.dim("success")}`,
+		`  1  ${chalk.dim("generic error")}`,
+		`  2  ${chalk.dim("user cancelled")}`,
+		`  3  ${chalk.dim("no AI tool detected")}`,
+		"",
+		chalk.dim("Docs: https://github.com/firatcand/roster")
+	];
+	console.log(lines.join("\n"));
+	console.log();
+}
+function unknownCommandError(command) {
+	return new RosterError({
+		header: `${chalk.red.bold("roster:")} unknown command ${chalk.yellow(`'${command}'`)}`,
+		body: "",
+		remedy: `  Run ${chalk.bold("roster --help")} to see available commands.`,
+		exitCode: 1
+	});
+}
+function toolHints(tools) {
+	return tools.map((t) => ({
+		name: t.name,
+		installLink: t.installLink
+	}));
+}
+function summarizeInstall(tool, result) {
+	const skillsLine = `${result.skillsCount} skills → ${tildify(result.skillsTarget)}`;
+	const agentsLine = result.agentsTarget ? `${result.agentsCount} agents → ${tildify(result.agentsTarget)}` : `${result.agentsCount} agents → (n/a)`;
+	return `${chalk.green("✓")} ${chalk.bold(tool.name)} — ${skillsLine}, ${agentsLine}`;
+}
+async function promptForTools(detected) {
+	if (detected.length === 1) return detected;
+	const { checkbox, confirm } = await import("@inquirer/prompts");
+	let selectedKeys;
+	try {
+		selectedKeys = await checkbox({
+			message: "Install roster into which AI tools?",
+			choices: detected.map((t) => ({
+				name: t.name,
+				value: t.key,
+				checked: true
+			}))
+		});
+	} catch {
+		return null;
+	}
+	if (selectedKeys.length === 0) {
+		let exitAnyway;
+		try {
+			exitAnyway = await confirm({
+				message: "No tools selected. Exit without installing?",
+				default: true
+			});
+		} catch {
+			return null;
+		}
+		if (exitAnyway) return null;
+		return promptForTools(detected);
+	}
+	return detected.filter((t) => selectedKeys.includes(t.key));
+}
+async function runInstall(args) {
+	const parsed = parseInstallArgs(args);
+	if (parsed.kind === "err") throw new RosterError({
+		header: `${chalk.red.bold("roster:")} ${parsed.message}`,
+		body: "",
+		remedy: `  Run ${chalk.bold("roster --help")} for usage.`,
+		exitCode: 1
+	});
+	const { silent, verbose, target } = parsed;
+	const version = getPackageVersion();
+	if (!silent) printBanner(version);
+	const detected = detectTools();
+	if (detected.length === 0) throw noToolsError(toolHints(allTools()));
+	let targetTools;
+	if (target.mode === "all") targetTools = detected;
+	else if (target.mode === "tool") {
+		const match = detected.find((t) => t.key === target.key);
+		if (!match) throw new RosterError({
+			header: `${chalk.red.bold("roster:")} ${target.key} not detected on this machine`,
+			body: `  --tool ${target.key} was requested, but no ${target.key} install was found.`,
+			remedy: `  Install it first, or omit ${chalk.bold("--tool")} to install to all detected tools.`,
+			exitCode: 3
+		});
+		targetTools = [match];
+	} else targetTools = await promptForTools(detected);
+	if (targetTools === null) throw userCancelledInstall();
+	const skillsSrc = join(ROSTER_ROOT, "skills");
+	const agentsSrc = join(ROSTER_ROOT, "agents");
+	const confirmFn = target.mode !== "interactive" ? async () => false : void 0;
+	for (const tool of targetTools) {
+		const result = await installToTool(tool, {
+			skills: skillsSrc,
+			agents: agentsSrc,
+			silent: !verbose,
+			...confirmFn ? { confirm: confirmFn } : {}
+		});
+		if (!silent) console.log(summarizeInstall(tool, result));
+	}
+	if (!silent) {
+		console.log();
+		console.log(`${chalk.dim("Next: ")}${chalk.bold("roster init")}${chalk.dim(" to scaffold a workspace.")}`);
+	}
+	return 0;
+}
+async function runInit(args) {
+	const silent = args.includes("--silent");
+	const force = args.includes("--force");
+	const migrate = args.includes("--migrate");
+	const noGit = args.includes("--no-git") || args.includes("--skip-git");
+	const name = args.find((a) => !a.startsWith("-"));
+	if (!silent) printBanner(getPackageVersion());
+	if ((await executeInit({
+		cwd: process.cwd(),
+		name,
+		silent,
+		force,
+		migrate,
+		noGit
+	})).status === "cancelled") throw userCancelledInit();
+	return 0;
+}
+function runSchedule(args) {
+	const parsed = parseScheduleArgs(args);
+	if (parsed.kind === "err") throw new RosterError({
+		header: `${chalk.red.bold("roster:")} ${parsed.message}`,
+		body: "",
+		remedy: `  Run ${chalk.bold("roster --help")} for usage.`,
+		exitCode: 1
+	});
+	if (parsed.subcommand === "validate") return executeScheduleValidate({
+		cwd: parsed.cwd ?? process.cwd(),
+		json: parsed.json,
+		silent: parsed.silent
+	});
+	throw new RosterError({
+		header: `${chalk.red.bold("roster:")} schedule subcommand not implemented`,
+		body: "",
+		remedy: `  Run ${chalk.bold("roster --help")} for usage.`,
+		exitCode: 1
+	});
+}
+function runDoctor(args) {
+	const parsed = parseDoctorArgs(args);
+	if (parsed.kind === "err") throw new RosterError({
+		header: `${chalk.red.bold("roster:")} ${parsed.message}`,
+		body: "",
+		remedy: `  Run ${chalk.bold("roster --help")} for usage.`,
+		exitCode: 1
+	});
+	const code = executeDoctor({
+		json: parsed.json,
+		silent: parsed.silent,
+		cwd: process.cwd()
+	});
+	if (code === 3 && !parsed.json) throw noToolsError(toolHints(allTools()));
+	return code;
+}
+function isSubcommand(value) {
+	return SUBCOMMANDS.has(value);
+}
+const rawArgs = process.argv.slice(2);
+const debugMode = rawArgs.includes("--debug");
+async function main() {
+	const version = getPackageVersion();
+	const args = debugMode ? rawArgs.filter((a) => a !== "--debug") : rawArgs;
+	if (args.includes("--help") || args.includes("-h")) {
+		printHelp(version);
+		return 0;
+	}
+	if (args.includes("--version") || args.includes("-v")) {
+		console.log(version);
+		return 0;
+	}
+	const [first, ...rest] = args;
+	if (first === void 0) return runInstall(rest);
+	if (isSubcommand(first)) {
+		if (first === "install") return runInstall(rest);
+		if (first === "init") return await runInit(rest);
+		if (first === "doctor") return runDoctor(rest);
+		if (first === "schedule") return runSchedule(rest);
+	}
+	throw unknownCommandError(first);
+}
+main().then((code) => process.exit(code)).catch((err) => {
+	const rosterErr = isRosterError(err) ? err : unexpectedError(err);
+	renderError(rosterErr, { debug: debugMode });
+	process.exit(rosterErr.exitCode);
+});
+//#endregion
+export {};