@ghfs/cli 0.0.1 → 0.0.3

package/dist/cli.mjs

@@ -0,0 +1,3237 @@
+#!/usr/bin/env node
+import { a as formatIssueNumber, i as formatDuration, n as normalizeReactions, o as formatTerminalLink$1, r as countNoun, s as formatValue, t as createRepositoryProvider } from "./factory-COZFMWsb.mjs";
+import process from "node:process";
+import { cac } from "cac";
+import { basename, dirname, isAbsolute, join, resolve } from "pathe";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { existsSync } from "node:fs";
+import { createJiti } from "jiti";
+import { access, mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import * as v from "valibot";
+import { parse, stringify } from "yaml";
+import { randomBytes } from "node:crypto";
+import c from "ansis";
+import * as p from "@clack/prompts";
+import { cancel, confirm, isCancel, multiselect, password, select } from "@clack/prompts";
+
+//#region src/config/auth.ts
+const execFileAsync$1 = promisify(execFile);
+async function resolveAuthToken(options) {
+	const configuredToken = options.token?.trim();
+	if (configuredToken) return configuredToken;
+	const token = await readTokenFromGhCli();
+	if (token) return token;
+	const envToken = await readTokenFromEnv();
+	if (envToken) return envToken;
+	if (!options.interactive || !process.stdin.isTTY) throw new Error("Missing GitHub token. Set GH_TOKEN/GITHUB_TOKEN or run gh auth login.");
+	if (!options.promptForToken) throw new Error("Missing GitHub token. Set GH_TOKEN/GITHUB_TOKEN or run gh auth login.");
+	const promptedToken = await options.promptForToken();
+	if (promptedToken?.trim()) return promptedToken.trim();
+	throw new Error("Token prompt cancelled");
+}
+async function readTokenFromGhCli() {
+	try {
+		return (await execFileAsync$1("gh", ["auth", "token"])).stdout.trim() || void 0;
+	} catch {
+		return;
+	}
+}
+async function readTokenFromEnv() {
+	await import("dotenv").then((mod) => mod.config());
+	for (const name of ["GH_TOKEN", "GITHUB_TOKEN"]) {
+		const value = process.env[name]?.trim();
+		if (value) return value;
+	}
+}
+
+//#endregion
+//#region src/constants.ts
+const CONFIG_FILE_CANDIDATES = [
+	"ghfs.config.ts",
+	"ghfs.config.mts",
+	"ghfs.config.mjs",
+	"ghfs.config.js",
+	"ghfs.config.cjs"
+];
+const DEFAULT_STORAGE_DIR = ".ghfs";
+const ISSUE_DIR_NAME = "issues";
+const PULL_DIR_NAME = "pulls";
+const CLOSED_DIR_NAME = "closed";
+const SYNC_STATE_FILE_NAME = ".sync.json";
+const ISSUES_INDEX_FILE_NAME = "issues.md";
+const PULLS_INDEX_FILE_NAME = "pulls.md";
+const REPO_SNAPSHOT_FILE_NAME = "repo.json";
+const EXECUTE_FILE_NAME = "execute.yml";
+const EXECUTE_MD_FILE_NAME = "execute.md";
+const EXECUTE_SCHEMA_RELATIVE_PATH = "schema/execute.schema.json";
+
+//#endregion
+//#region src/config/load.ts
+async function loadUserConfig(cwd) {
+	const configPath = findConfigFile(cwd);
+	if (!configPath) return { config: {} };
+	return {
+		path: configPath,
+		config: extractUserConfig(await createJiti(resolve(cwd, "ghfs.config.ts"), { interopDefault: true }).import(configPath))
+	};
+}
+function extractUserConfig(loaded) {
+	if (!loaded || typeof loaded !== "object") return {};
+	if ("default" in loaded) {
+		const config = loaded.default;
+		if (config && typeof config === "object") return config;
+		return {};
+	}
+	return loaded;
+}
+async function resolveConfig(options = {}) {
+	const cwd = options.cwd ?? process.cwd();
+	const overrides = options.overrides ?? {};
+	const { config: userConfig } = await loadUserConfig(cwd);
+	const merged = mergeUserConfig(userConfig, overrides);
+	const directory = merged.directory ?? DEFAULT_STORAGE_DIR;
+	const configuredToken = merged.auth?.token?.trim() || "";
+	const repo = merged.repo?.trim() || "";
+	const issuesEnabled = merged.sync?.issues ?? true;
+	const pullsEnabled = merged.sync?.pulls ?? true;
+	const closedMode = merged.sync?.closed ?? false;
+	const patchesMode = merged.sync?.patches ?? "open";
+	return {
+		cwd,
+		repo,
+		directory,
+		auth: { token: configuredToken },
+		sync: {
+			issues: issuesEnabled,
+			pulls: pullsEnabled,
+			closed: closedMode,
+			patches: patchesMode
+		}
+	};
+}
+function getStorageDirAbsolute(config) {
+	return resolve(config.cwd, config.directory);
+}
+function getExecuteFile(config) {
+	return join(config.directory, EXECUTE_FILE_NAME);
+}
+function findConfigFile(cwd) {
+	for (const candidate of CONFIG_FILE_CANDIDATES) {
+		const fullPath = resolve(cwd, candidate);
+		if (existsSync(fullPath)) return fullPath;
+	}
+}
+function mergeUserConfig(base, overrides) {
+	return {
+		...base,
+		...overrides,
+		auth: {
+			...base.auth,
+			...overrides.auth
+		},
+		sync: {
+			...base.sync,
+			...overrides.sync
+		}
+	};
+}
+
+//#endregion
+//#region src/utils/fs.ts
+async function pathExists(path) {
+	try {
+		await access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function writeFileEnsured(path, content) {
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, content, "utf8");
+}
+async function removePath(path) {
+	await rm(path, { force: true });
+}
+async function movePath(from, to) {
+	await mkdir(dirname(to), { recursive: true });
+	await rename(from, to);
+}
+async function removePatchIfExists(storageDirAbsolute, number) {
+	const pullsDir = join(storageDirAbsolute, PULL_DIR_NAME);
+	let entries;
+	try {
+		entries = await readdir(pullsDir, { withFileTypes: true });
+	} catch {
+		return 0;
+	}
+	const padded = String(number).padStart(5, "0");
+	let removed = 0;
+	for (const entry of entries) {
+		if (!entry.isFile()) continue;
+		const fileName = entry.name;
+		const isLegacyPatch = fileName === `${number}.patch`;
+		const isCurrentPatch = fileName.startsWith(`${padded}-`) && fileName.endsWith(".patch");
+		if (!isLegacyPatch && !isCurrentPatch) continue;
+		await removePath(join(pullsDir, fileName));
+		removed += 1;
+	}
+	return removed;
+}
+
+//#endregion
+//#region src/config/repo.ts
+const execFileAsync = promisify(execFile);
+async function resolveRepo(options) {
+	if (options.cliRepo) {
+		const repo = normalizeRepo(options.cliRepo);
+		if (!repo) throw new Error(`Invalid --repo value: ${options.cliRepo}`);
+		return {
+			repo,
+			source: "cli",
+			candidates: []
+		};
+	}
+	if (options.configRepo) {
+		const repo = normalizeRepo(options.configRepo);
+		if (!repo) throw new Error(`Invalid repo in ghfs.config.ts: ${options.configRepo}`);
+		return {
+			repo,
+			source: "config",
+			candidates: []
+		};
+	}
+	const candidates = [];
+	const gitCandidate = await detectRepoFromGit(options.cwd);
+	const pkgCandidate = await detectRepoFromPackageJson(options.cwd);
+	if (gitCandidate) candidates.push(gitCandidate);
+	if (pkgCandidate) candidates.push(pkgCandidate);
+	if (gitCandidate && pkgCandidate && gitCandidate.repo !== pkgCandidate.repo) {
+		if (options.interactive && process.stdin.isTTY && options.selectRepoChoice) {
+			const repo = await options.selectRepoChoice(gitCandidate, pkgCandidate);
+			if (!repo) throw new Error("Repository selection cancelled");
+			const normalizedRepo = normalizeRepo(repo);
+			if (!normalizedRepo || normalizedRepo !== gitCandidate.repo && normalizedRepo !== pkgCandidate.repo) throw new Error(`Invalid repository selection: ${repo}`);
+			return {
+				repo: normalizedRepo,
+				source: normalizedRepo === gitCandidate.repo ? "git" : "package-json",
+				candidates
+			};
+		}
+		throw new Error(`Repo mismatch detected. git=${gitCandidate.repo} package.json=${pkgCandidate.repo}. Use --repo to disambiguate.`);
+	}
+	if (gitCandidate) return {
+		repo: gitCandidate.repo,
+		source: "git",
+		candidates
+	};
+	if (pkgCandidate) return {
+		repo: pkgCandidate.repo,
+		source: "package-json",
+		candidates
+	};
+	throw new Error("Could not resolve repository. Provide --repo or set repo in ghfs.config.ts.");
+}
+function normalizeRepo(input) {
+	const trimmed = input.trim();
+	if (!trimmed) return void 0;
+	const shortMatch = trimmed.match(/^([\w.-]+)\/([\w.-]+)$/);
+	if (shortMatch) return `${shortMatch[1]}/${stripGitSuffix(shortMatch[2])}`;
+	const githubPrefixMatch = trimmed.match(/^github:([\w.-]+)\/([\w.-]+)$/);
+	if (githubPrefixMatch) return `${githubPrefixMatch[1]}/${stripGitSuffix(githubPrefixMatch[2])}`;
+	const sshScpMatch = trimmed.match(/^git@github\.com:([\w.-]+)\/([\w.-]+?)(?:\.git)?$/);
+	if (sshScpMatch) return `${sshScpMatch[1]}/${stripGitSuffix(sshScpMatch[2])}`;
+	try {
+		const url = new URL(trimmed);
+		if (url.hostname !== "github.com") return void 0;
+		const segments = url.pathname.replace(/^\//, "").split("/").filter(Boolean);
+		if (segments.length < 2) return void 0;
+		return `${segments[0]}/${stripGitSuffix(segments[1])}`;
+	} catch {
+		return;
+	}
+}
+async function detectRepoFromGit(cwd) {
+	let stdout;
+	try {
+		stdout = (await execFileAsync("git", ["remote"], { cwd })).stdout;
+	} catch {
+		return;
+	}
+	const remotes = stdout.split("\n").map((line) => line.trim()).filter(Boolean);
+	if (!remotes.length) return void 0;
+	const orderedRemotes = prioritizeRemotes(remotes);
+	for (const remote of orderedRemotes) try {
+		const repo = normalizeRepo((await execFileAsync("git", [
+			"remote",
+			"get-url",
+			remote
+		], { cwd })).stdout.trim());
+		if (repo) return {
+			source: "git",
+			repo,
+			detail: `remote:${remote}`
+		};
+	} catch {
+		continue;
+	}
+}
+async function detectRepoFromPackageJson(cwd) {
+	const path = `${cwd}/package.json`;
+	if (!await pathExists(path)) return void 0;
+	let parsed;
+	try {
+		parsed = JSON.parse(await readFile(path, "utf8"));
+	} catch {
+		return;
+	}
+	if (!parsed || typeof parsed !== "object") return void 0;
+	const repository = parsed.repository;
+	if (typeof repository === "string") {
+		const repo = normalizeRepo(repository);
+		if (repo) return {
+			source: "package-json",
+			repo,
+			detail: "package.json#repository"
+		};
+	}
+	if (repository && typeof repository === "object") {
+		const url = repository.url;
+		if (typeof url === "string") {
+			const repo = normalizeRepo(url);
+			if (repo) return {
+				source: "package-json",
+				repo,
+				detail: "package.json#repository.url"
+			};
+		}
+	}
+}
+function prioritizeRemotes(remotes) {
+	const unique = [...new Set(remotes)];
+	const priority = ["origin", "upstream"];
+	const prioritized = priority.filter((name) => unique.includes(name));
+	const rest = unique.filter((name) => !priority.includes(name));
+	return [...prioritized, ...rest];
+}
+function stripGitSuffix(name) {
+	return name.replace(/\.git$/, "");
+}
+
+//#endregion
+//#region src/execute/actions.ts
+const ACTIONS_SUPPORTED = [
+	"close",
+	"close-with-comment",
+	"reopen",
+	"set-title",
+	"set-body",
+	"add-comment",
+	"add-labels",
+	"remove-labels",
+	"set-labels",
+	"add-assignees",
+	"remove-assignees",
+	"set-assignees",
+	"set-milestone",
+	"clear-milestone",
+	"lock",
+	"unlock",
+	"request-reviewers",
+	"remove-reviewers",
+	"mark-ready-for-review",
+	"convert-to-draft"
+];
+const ACTIONS_ALIAS_MAP = {
+	"open": "reopen",
+	"closes": "close",
+	"close-comment": "close-with-comment",
+	"comment-close": "close-with-comment",
+	"close-and-comment": "close-with-comment",
+	"comment-and-close": "close-with-comment",
+	"label": "add-labels",
+	"labels": "add-labels",
+	"tag": "add-labels",
+	"tags": "add-labels",
+	"add-tag": "add-labels",
+	"assign": "add-assignees",
+	"assignee": "add-assignees",
+	"assignees": "add-assignees",
+	"body": "set-body",
+	"title": "set-title",
+	"retitle": "set-title",
+	"ready": "mark-ready-for-review",
+	"undraft": "mark-ready-for-review",
+	"draft": "convert-to-draft",
+	"comment": "add-comment"
+};
+const ACTIONS_COLOR_HEX = {
+	"close": "#ef4444",
+	"close-with-comment": "#fb7185",
+	"reopen": "#22c55e",
+	"set-title": "#3b82f6",
+	"set-body": "#06b6d4",
+	"add-comment": "#f97316",
+	"add-labels": "#84cc16",
+	"remove-labels": "#f43f5e",
+	"set-labels": "#eab308",
+	"add-assignees": "#10b981",
+	"remove-assignees": "#fb7185",
+	"set-assignees": "#0ea5e9",
+	"set-milestone": "#6366f1",
+	"clear-milestone": "#f59e0b",
+	"lock": "#a855f7",
+	"unlock": "#14b8a6",
+	"request-reviewers": "#38bdf8",
+	"remove-reviewers": "#e879f9",
+	"mark-ready-for-review": "#34d399",
+	"convert-to-draft": "#f472b6"
+};
+const ACTION_NAMES_SET = new Set(ACTIONS_SUPPORTED);
+const ACTION_ALIASES = Object.keys(ACTIONS_ALIAS_MAP);
+const ACTION_INPUTS = [...ACTIONS_SUPPORTED, ...ACTION_ALIASES];
+function resolveActionName(action) {
+	const normalized = normalizeActionInput(action);
+	if (!normalized) return void 0;
+	if (ACTION_NAMES_SET.has(normalized)) return normalized;
+	return ACTIONS_ALIAS_MAP[normalized];
+}
+function normalizeActionInput(action) {
+	return action.trim().toLowerCase();
+}
+
+//#endregion
+//#region src/execute/schema.ts
+const executeSchema = {
+	$id: "https://ghfs.dev/schema/execute.json",
+	type: "array",
+	items: {
+		type: "object",
+		additionalProperties: true,
+		required: ["number", "action"],
+		properties: {
+			number: { type: "number" },
+			action: {
+				type: "string",
+				enum: [...ACTION_INPUTS]
+			},
+			ifUnchangedSince: {
+				type: "string",
+				format: "date-time"
+			},
+			title: { type: "string" },
+			body: { type: "string" },
+			labels: {
+				type: "array",
+				items: { type: "string" }
+			},
+			assignees: {
+				type: "array",
+				items: { type: "string" }
+			},
+			milestone: { anyOf: [{ type: "string" }, { type: "number" }] },
+			reviewers: {
+				type: "array",
+				items: { type: "string" }
+			},
+			reason: {
+				type: "string",
+				enum: [
+					"resolved",
+					"off-topic",
+					"too heated",
+					"too-heated",
+					"spam"
+				]
+			}
+		}
+	}
+};
+const EXECUTE_FILE_PLACEHOLDER = [
+	`# yaml-language-server: $schema=./${EXECUTE_SCHEMA_RELATIVE_PATH}`,
+	"# Add operations as YAML list items, then run: ghfs execute --run",
+	"# Action names are case-insensitive and support aliases (for example: label, assign, comment, close-comment).",
+	"# - action: close",
+	"#   number: 123",
+	"[]",
+	""
+].join("\n");
+const EXECUTE_MD_FILE_PLACEHOLDER = [
+	"# Add one action per line, then run: ghfs execute --run",
+	"# Command names are case-insensitive and support aliases.",
+	"# close #123 #124",
+	"# label #123 bug, triage",
+	"# assign #123 antfu",
+	"# comment #123 \"Need more context\"",
+	"# close-comment #123 \"Closing as completed\"",
+	"# set-title #123 \"new title\"",
+	"# add-tag #123 foo, bar",
+	""
+].join("\n");
+async function writeExecuteSchema(storageDirAbsolute) {
+	const schemaPath = getExecuteSchemaPath(storageDirAbsolute);
+	await mkdir(dirname(schemaPath), { recursive: true });
+	await writeFile(schemaPath, `${JSON.stringify(executeSchema, null, 2)}\n`, "utf8");
+	return schemaPath;
+}
+async function ensureExecuteArtifacts(executeFilePath) {
+	const storageDirAbsolute = dirname(executeFilePath);
+	const [schemaPath] = await Promise.all([
+		ensureExecuteSchema(storageDirAbsolute),
+		ensureExecuteFile(executeFilePath),
+		ensureExecuteMdFile(storageDirAbsolute)
+	]);
+	return {
+		executeFilePath,
+		schemaPath
+	};
+}
+async function ensureExecuteSchema(storageDirAbsolute) {
+	const schemaPath = getExecuteSchemaPath(storageDirAbsolute);
+	if (await pathExists(schemaPath)) return schemaPath;
+	return writeExecuteSchema(storageDirAbsolute);
+}
+async function ensureExecuteFile(executeFilePath) {
+	if (await pathExists(executeFilePath)) return;
+	await mkdir(dirname(executeFilePath), { recursive: true });
+	await writeFile(executeFilePath, EXECUTE_FILE_PLACEHOLDER, "utf8");
+}
+async function ensureExecuteMdFile(storageDirAbsolute) {
+	const executeMdPath = join(storageDirAbsolute, EXECUTE_MD_FILE_NAME);
+	if (await pathExists(executeMdPath)) return;
+	await mkdir(dirname(executeMdPath), { recursive: true });
+	await writeFile(executeMdPath, EXECUTE_MD_FILE_PLACEHOLDER, "utf8");
+}
+function getExecuteSchemaPath(storageDirAbsolute) {
+	return join(storageDirAbsolute, EXECUTE_SCHEMA_RELATIVE_PATH);
+}
+
+//#endregion
+//#region src/execute/validate.ts
+const executeOpSchema = v.looseObject({
+	number: v.number(),
+	action: v.string(),
+	ifUnchangedSince: v.optional(v.string()),
+	title: v.optional(v.string()),
+	body: v.optional(v.string()),
+	labels: v.optional(v.array(v.string())),
+	assignees: v.optional(v.array(v.string())),
+	milestone: v.optional(v.union([v.string(), v.number()])),
+	reviewers: v.optional(v.array(v.string())),
+	reason: v.optional(v.picklist([
+		"resolved",
+		"off-topic",
+		"too heated",
+		"too-heated",
+		"spam"
+	]))
+});
+const executeFileSchema = v.array(executeOpSchema);
+async function readAndValidateExecuteFileWithSource(path) {
+	const raw = await readFile(path, "utf8");
+	let parsed;
+	try {
+		parsed = parse(raw);
+	} catch (error) {
+		throw new Error(`Failed to parse execute YAML: ${error.message}`);
+	}
+	const parsedResult = v.safeParse(executeFileSchema, parsed);
+	if (!parsedResult.success) {
+		const message = parsedResult.issues.map((issue) => {
+			const path = issue.path?.map((segment) => String(segment.key)).join(".");
+			return `${path ? `${path}: ` : ""}${issue.message}`;
+		}).join("; ");
+		throw new Error(`Invalid execute file: ${message}`);
+	}
+	const { pending, sourceActions, actionErrors } = normalizeActionInputs(parsedResult.output);
+	if (actionErrors.length) throw new Error(`Invalid execute file: ${actionErrors.join("; ")}`);
+	const customErrors = validateExecuteRules(pending);
+	if (customErrors.length) throw new Error(`Invalid execute file: ${customErrors.join("; ")}`);
+	return {
+		ops: pending,
+		sourceActions
+	};
+}
+async function writeExecuteFile(path, pending) {
+	const content = stringify(pending);
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, content.endsWith("\n") ? content : `${content}\n`, "utf8");
+}
+function validateExecuteRules(pending) {
+	const errors = [];
+	for (const [index, op] of pending.entries()) {
+		const key = `[${index}]`;
+		errors.push(...validateOperationRules(key, op));
+	}
+	return errors;
+}
+function validateOperationRules(key, op) {
+	const errors = [];
+	if (!Number.isInteger(op.number) || op.number <= 0) errors.push(`${key}: number must be a positive integer`);
+	switch (op.action) {
+		case "set-title":
+			if (!isNonEmptyString(op.title)) errors.push(`${key}: set-title requires title`);
+			break;
+		case "set-body":
+		case "add-comment":
+		case "close-with-comment":
+			if (!isNonEmptyString(op.body)) errors.push(`${key}: ${op.action} requires body`);
+			break;
+		case "add-labels":
+		case "remove-labels":
+		case "set-labels":
+			if (!isStringArray(op.labels)) errors.push(`${key}: ${op.action} requires labels[]`);
+			break;
+		case "add-assignees":
+		case "remove-assignees":
+		case "set-assignees":
+			if (!isStringArray(op.assignees)) errors.push(`${key}: ${op.action} requires assignees[]`);
+			break;
+		case "set-milestone":
+			if (!(typeof op.milestone === "string" || typeof op.milestone === "number")) errors.push(`${key}: set-milestone requires milestone`);
+			break;
+		case "request-reviewers":
+		case "remove-reviewers":
+			if (!isStringArray(op.reviewers)) errors.push(`${key}: ${op.action} requires reviewers[]`);
+			break;
+		default: break;
+	}
+	if (op.ifUnchangedSince && Number.isNaN(Date.parse(op.ifUnchangedSince))) errors.push(`${key}: ifUnchangedSince must be a valid datetime`);
+	return errors;
+}
+function isNonEmptyString(value) {
+	return typeof value === "string" && value.trim().length > 0;
+}
+function isStringArray(value) {
+	return Array.isArray(value) && value.every((entry) => typeof entry === "string") && value.length > 0;
+}
+function normalizeActionInputs(pending) {
+	const normalized = [];
+	const sourceActions = [];
+	const actionErrors = [];
+	for (const [index, op] of pending.entries()) {
+		const sourceAction = op.action;
+		sourceActions.push(sourceAction);
+		const action = resolveActionName(sourceAction);
+		if (!action) {
+			actionErrors.push(`[${index}]: unknown action: ${sourceAction}`);
+			continue;
+		}
+		normalized.push({
+			...op,
+			action
+		});
+	}
+	return {
+		pending: normalized,
+		sourceActions,
+		actionErrors
+	};
+}
+
+//#endregion
+//#region src/execute/sources/execute-md.ts
+const MULTI_SIMPLE_ACTIONS = new Set([
+	"close",
+	"reopen",
+	"clear-milestone",
+	"unlock",
+	"mark-ready-for-review",
+	"convert-to-draft"
+]);
+function parseExecuteMdLine(line) {
+	const trimmed = line.trim();
+	if (!trimmed || isCommentLine(trimmed)) return void 0;
+	const tokens = tokenizeCommand(trimmed);
+	if (!tokens) return {
+		kind: "warning",
+		message: "invalid quoted string syntax"
+	};
+	if (tokens.length === 0) return void 0;
+	const [commandInput, ...args] = tokens;
+	const command = resolveActionName(commandInput);
+	if (!command) return {
+		kind: "warning",
+		message: `unrecognized action pattern: ${commandInput}`
+	};
+	if (command === "set-title") return parseSetTitle(args);
+	if (command === "add-labels") return parseAddLabels(args, commandInput);
+	if (command === "add-assignees") return parseAddAssignees(args, commandInput);
+	if (command === "add-comment") return parseAddComment(args, commandInput);
+	if (command === "close-with-comment") return parseCloseWithComment(args, commandInput);
+	if (MULTI_SIMPLE_ACTIONS.has(command)) return parseMultiSimpleAction(command, args, commandInput);
+	return {
+		kind: "warning",
+		message: `unrecognized action pattern: ${commandInput}`
+	};
+}
+async function readExecuteMdFile(path) {
+	if (!await pathExists(path)) return parseExecuteMd("");
+	return parseExecuteMd(await readFile(path, "utf8"));
+}
+function parseExecuteMd(raw) {
+	const lines = raw.split(/\r?\n/);
+	const ops = [];
+	const parsedLines = [];
+	const warnings = [];
+	let inHtmlCommentBlock = false;
+	for (const [lineIndex, rawLine] of lines.entries()) {
+		const trimmed = rawLine.trim();
+		if (inHtmlCommentBlock) {
+			parsedLines.push({
+				kind: "raw",
+				raw: rawLine
+			});
+			if (trimmed.includes("-->")) inHtmlCommentBlock = false;
+			continue;
+		}
+		if (trimmed.startsWith("<!--")) {
+			parsedLines.push({
+				kind: "raw",
+				raw: rawLine
+			});
+			if (!trimmed.includes("-->")) inHtmlCommentBlock = true;
+			continue;
+		}
+		const parsed = parseExecuteMdLine(rawLine);
+		if (!parsed) {
+			parsedLines.push({
+				kind: "raw",
+				raw: rawLine
+			});
+			continue;
+		}
+		if (parsed.kind === "warning") {
+			warnings.push(`execute-md line ${lineIndex + 1}: ${parsed.message}`);
+			parsedLines.push({
+				kind: "raw",
+				raw: rawLine
+			});
+			continue;
+		}
+		if (parsed.kind === "single") {
+			const opIndex = ops.length;
+			ops.push(parsed.op);
+			parsedLines.push({
+				kind: "single",
+				raw: rawLine,
+				opIndex
+			});
+			continue;
+		}
+		const opIndexes = [];
+		for (const number of parsed.numbers) {
+			opIndexes.push(ops.length);
+			ops.push({
+				action: parsed.action,
+				number
+			});
+		}
+		parsedLines.push({
+			kind: "multi",
+			action: parsed.action,
+			command: parsed.command,
+			opIndexes
+		});
+	}
+	return {
+		ops,
+		warnings,
+		lines: parsedLines
+	};
+}
+function stringifyExecuteMd(parsed, remainingOpIndexes) {
+	const lines = [];
+	for (const line of parsed.lines) {
+		if (line.kind === "raw") {
+			lines.push(line.raw);
+			continue;
+		}
+		if (line.kind === "single") {
+			if (remainingOpIndexes.has(line.opIndex)) lines.push(line.raw);
+			continue;
+		}
+		const numbers = line.opIndexes.filter((index) => remainingOpIndexes.has(index)).map((index) => parsed.ops[index]?.number).filter((value) => typeof value === "number");
+		if (numbers.length > 0) lines.push(`${line.command} ${numbers.map((number) => `#${number}`).join(" ")}`);
+	}
+	return `${lines.join("\n")}\n`;
+}
+function parseSetTitle(args) {
+	if (args.length !== 2) return {
+		kind: "warning",
+		message: "set-title expects: set-title #<number> \"<title>\""
+	};
+	const number = parseIssueRef(args[0]);
+	if (!number) return {
+		kind: "warning",
+		message: "set-title expects a single issue reference (#123)"
+	};
+	return {
+		kind: "single",
+		op: {
+			action: "set-title",
+			number,
+			title: args[1]
+		}
+	};
+}
+function parseAddLabels(args, command) {
+	if (args.length < 2) return {
+		kind: "warning",
+		message: `${command} expects: ${command} #<number> <label1, label2>`
+	};
+	const number = parseIssueRef(args[0]);
+	if (!number) return {
+		kind: "warning",
+		message: `${command} expects a single issue reference (#123)`
+	};
+	const labels = args.slice(1).flatMap((value) => value.split(",")).map((value) => value.trim()).filter(Boolean);
+	if (labels.length === 0) return {
+		kind: "warning",
+		message: `${command} requires at least one label`
+	};
+	return {
+		kind: "single",
+		op: {
+			action: "add-labels",
+			number,
+			labels
+		}
+	};
+}
+function parseAddAssignees(args, command) {
+	if (args.length < 2) return {
+		kind: "warning",
+		message: `${command} expects: ${command} #<number> <assignee1, assignee2>`
+	};
+	const number = parseIssueRef(args[0]);
+	if (!number) return {
+		kind: "warning",
+		message: `${command} expects a single issue reference (#123)`
+	};
+	const assignees = args.slice(1).flatMap((value) => value.split(",")).map((value) => value.trim()).filter(Boolean);
+	if (assignees.length === 0) return {
+		kind: "warning",
+		message: `${command} requires at least one assignee`
+	};
+	return {
+		kind: "single",
+		op: {
+			action: "add-assignees",
+			number,
+			assignees
+		}
+	};
+}
+function parseAddComment(args, command) {
+	if (args.length < 2) return {
+		kind: "warning",
+		message: `${command} expects: ${command} #<number> "<comment>"`
+	};
+	const number = parseIssueRef(args[0]);
+	if (!number) return {
+		kind: "warning",
+		message: `${command} expects a single issue reference (#123)`
+	};
+	const body = args.slice(1).join(" ").trim();
+	if (!body) return {
+		kind: "warning",
+		message: `${command} requires a non-empty comment`
+	};
+	return {
+		kind: "single",
+		op: {
+			action: "add-comment",
+			number,
+			body
+		}
+	};
+}
+function parseCloseWithComment(args, command) {
+	if (args.length < 2) return {
+		kind: "warning",
+		message: `${command} expects: ${command} #<number> "<comment>"`
+	};
+	const number = parseIssueRef(args[0]);
+	if (!number) return {
+		kind: "warning",
+		message: `${command} expects a single issue reference (#123)`
+	};
+	const body = args.slice(1).join(" ").trim();
+	if (!body) return {
+		kind: "warning",
+		message: `${command} requires a non-empty comment`
+	};
+	return {
+		kind: "single",
+		op: {
+			action: "close-with-comment",
+			number,
+			body
+		}
+	};
+}
+function parseMultiSimpleAction(action, args, command) {
+	const numbers = args.map(parseIssueRef);
+	if (numbers.length === 0 || numbers.some((number) => !number)) return {
+		kind: "warning",
+		message: `${command} expects one or more issue references (#123 #456)`
+	};
+	return {
+		kind: "multi",
+		action,
+		command,
+		numbers
+	};
+}
+function parseIssueRef(value) {
+	const match = value.match(/^#(\d+)$/);
+	if (!match) return void 0;
+	const number = Number.parseInt(match[1], 10);
+	if (!Number.isInteger(number) || number <= 0) return void 0;
+	return number;
+}
+function tokenizeCommand(value) {
+	const tokens = [];
+	let index = 0;
+	while (index < value.length) {
+		while (index < value.length && /\s/.test(value[index])) index += 1;
+		if (index >= value.length) break;
+		if (value[index] === "\"") {
+			index += 1;
+			let token = "";
+			let closed = false;
+			while (index < value.length) {
+				const char = value[index];
+				if (char === "\\") {
+					const next = value[index + 1];
+					if (next === "\"" || next === "\\") {
+						token += next;
+						index += 2;
+						continue;
+					}
+				}
+				if (char === "\"") {
+					closed = true;
+					index += 1;
+					break;
+				}
+				token += char;
+				index += 1;
+			}
+			if (!closed) return void 0;
+			tokens.push(token);
+			continue;
+		}
+		const start = index;
+		while (index < value.length && !/\s/.test(value[index])) index += 1;
+		tokens.push(value.slice(start, index));
+	}
+	return tokens;
+}
+function isCommentLine(trimmed) {
+	return trimmed.startsWith("#") || trimmed.startsWith("//") || trimmed.startsWith("<!--");
+}
+
+//#endregion
+//#region package.json
+var version = "0.0.3";
+
+//#endregion
+//#region src/meta.ts
+const GHFS_NAME = "ghfs";
+const GHFS_VERSION = version;
+
+//#endregion
+//#region src/sync/state.ts
+function getSyncStatePath(storageDirAbsolute) {
+	return join(storageDirAbsolute, SYNC_STATE_FILE_NAME);
+}
+async function loadSyncState(storageDirAbsolute) {
+	const path = getSyncStatePath(storageDirAbsolute);
+	try {
+		const raw = await readFile(path, "utf8");
+		const parsed = JSON.parse(raw);
+		if (parsed.version !== 2) return createEmptySyncState();
+		return {
+			version: 2,
+			items: normalizeItems(parsed.items),
+			executions: normalizeExecutions(parsed.executions),
+			ghfsVersion: typeof parsed.ghfsVersion === "string" ? parsed.ghfsVersion : void 0,
+			repo: parsed.repo,
+			lastSyncedAt: parsed.lastSyncedAt,
+			lastSince: parsed.lastSince,
+			lastRepoUpdatedAt: parsed.lastRepoUpdatedAt,
+			lastSyncRun: parsed.lastSyncRun
+		};
+	} catch {
+		return createEmptySyncState();
+	}
+}
+function normalizeItems(items) {
+	if (!items) return {};
+	if (typeof items !== "object" || Array.isArray(items)) return {};
+	const normalizedItems = {};
+	for (const [key, item] of Object.entries(items)) {
+		const normalizedItem = normalizeItem(item);
+		if (!normalizedItem) continue;
+		normalizedItems[key] = normalizedItem;
+	}
+	return normalizedItems;
+}
+function normalizeExecutions(executions) {
+	if (!Array.isArray(executions)) return [];
+	return executions.map((execution) => {
+		if (!execution || typeof execution !== "object") return execution;
+		const typedExecution = execution;
+		if (typedExecution.mode === "dry-run") return {
+			...typedExecution,
+			mode: "report"
+		};
+		return typedExecution;
+	});
+}
+async function saveSyncState(storageDirAbsolute, state) {
+	await mkdir(storageDirAbsolute, { recursive: true });
+	const normalizedState = {
+		...state,
+		ghfsVersion: state.ghfsVersion ?? GHFS_VERSION
+	};
+	await writeFile(getSyncStatePath(storageDirAbsolute), `${JSON.stringify(normalizedState, null, 2)}\n`, "utf8");
+}
+function createEmptySyncState() {
+	return {
+		version: 2,
+		items: {},
+		executions: []
+	};
+}
+function appendExecution(state, result, limit = 20) {
+	const nextExecutions = [result, ...state.executions].slice(0, limit);
+	return {
+		...state,
+		executions: nextExecutions
+	};
+}
+function normalizeItem(item) {
+	if (!item || typeof item !== "object") return void 0;
+	if (!item.lastUpdatedAt || !item.lastSyncedAt || !item.filePath) return void 0;
+	if (!item.data || !item.data.item) return void 0;
+	const comments = Array.isArray(item.data.comments) ? item.data.comments : [];
+	return {
+		...item,
+		data: {
+			...item.data,
+			item: {
+				...item.data.item,
+				reactions: normalizeReactions(item.data.item.reactions)
+			},
+			comments: comments.filter((comment) => comment && typeof comment === "object").map((comment) => ({
+				...comment,
+				reactions: normalizeReactions(comment.reactions)
+			}))
+		}
+	};
+}
+
+//#endregion
+//#region src/execute/sources/per-item.ts
+async function loadPerItemSource(storageDir) {
+	const syncState = await loadSyncState(storageDir);
+	const ops = [];
+	const warnings = [];
+	const repo = syncState.repo;
+	for (const tracked of Object.values(syncState.items)) {
+		const markdownPath = join(storageDir, tracked.filePath);
+		if (!await pathExists(markdownPath)) {
+			warnings.push(`per-item: missing markdown for ${formatIssueNumber(tracked.number, { repo })} (${tracked.filePath})`);
+			continue;
+		}
+		const frontmatter = parseFrontmatter(await readFile(markdownPath, "utf8"));
+		if (!frontmatter) {
+			warnings.push(`per-item: invalid or missing frontmatter for ${formatIssueNumber(tracked.number, { repo })}`);
+			continue;
+		}
+		const trackedItem = tracked.data.item;
+		const itemOps = computePerItemOps({
+			number: tracked.number,
+			current: {
+				title: trackedItem.title,
+				state: trackedItem.state,
+				labels: trackedItem.labels,
+				assignees: trackedItem.assignees,
+				milestone: trackedItem.milestone
+			},
+			desired: frontmatter,
+			updatedAt: trackedItem.updatedAt
+		});
+		ops.push(...itemOps);
+	}
+	return {
+		ops,
+		warnings
+	};
+}
+function computePerItemOps(input) {
+	const ops = [];
+	const ifUnchangedSince = input.updatedAt;
+	if (input.current.title !== input.desired.title) ops.push({
+		action: "set-title",
+		number: input.number,
+		title: input.desired.title,
+		ifUnchangedSince
+	});
+	if (input.current.state !== input.desired.state) ops.push({
+		action: input.desired.state === "closed" ? "close" : "reopen",
+		number: input.number,
+		ifUnchangedSince
+	});
+	if (!sameStringSet(input.current.labels, input.desired.labels)) {
+		const additions = diffStrings(input.desired.labels, input.current.labels);
+		const deletions = diffStrings(input.current.labels, input.desired.labels);
+		if (additions.length > 0 && deletions.length > 0) ops.push({
+			action: "set-labels",
+			number: input.number,
+			labels: input.desired.labels,
+			ifUnchangedSince
+		});
+		else if (additions.length > 0) ops.push({
+			action: "add-labels",
+			number: input.number,
+			labels: additions,
+			ifUnchangedSince
+		});
+		else if (deletions.length > 0) ops.push({
+			action: "remove-labels",
+			number: input.number,
+			labels: deletions,
+			ifUnchangedSince
+		});
+	}
+	if (!sameStringSet(input.current.assignees, input.desired.assignees)) {
+		if (input.desired.assignees.length > 0) ops.push({
+			action: "set-assignees",
+			number: input.number,
+			assignees: input.desired.assignees,
+			ifUnchangedSince
+		});
+		else if (input.current.assignees.length > 0) ops.push({
+			action: "remove-assignees",
+			number: input.number,
+			assignees: input.current.assignees,
+			ifUnchangedSince
+		});
+	}
+	if (normalizeMilestone(input.current.milestone) !== normalizeMilestone(input.desired.milestone)) if (input.desired.milestone) ops.push({
+		action: "set-milestone",
+		number: input.number,
+		milestone: input.desired.milestone,
+		ifUnchangedSince
+	});
+	else ops.push({
+		action: "clear-milestone",
+		number: input.number,
+		ifUnchangedSince
+	});
+	return ops;
+}
+function parseFrontmatter(raw) {
+	const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+	if (!match) return void 0;
+	let parsed;
+	try {
+		parsed = parse(match[1]);
+	} catch {
+		return;
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
+	const data = parsed;
+	const title = typeof data.title === "string" && data.title.trim().length > 0 ? data.title.trim() : void 0;
+	const state = data.state === "open" || data.state === "closed" ? data.state : void 0;
+	if (!title || !state) return void 0;
+	return {
+		title,
+		state,
+		labels: normalizeStringArray(data.labels ?? data.tags),
+		assignees: normalizeStringArray(data.assignees),
+		milestone: normalizeMilestone(data.milestone)
+	};
+}
+function normalizeStringArray(value) {
+	if (!Array.isArray(value)) return [];
+	const unique = /* @__PURE__ */ new Set();
+	for (const entry of value) {
+		if (typeof entry !== "string") continue;
+		const normalized = entry.trim();
+		if (!normalized) continue;
+		unique.add(normalized);
+	}
+	return [...unique];
+}
+function sameStringSet(left, right) {
+	if (left.length !== right.length) return false;
+	const sortedLeft = [...left].sort();
+	const sortedRight = [...right].sort();
+	return sortedLeft.every((value, index) => value === sortedRight[index]);
+}
+function normalizeMilestone(value) {
+	if (typeof value !== "string") return null;
+	const normalized = value.trim();
+	return normalized.length > 0 ? normalized : null;
+}
+function diffStrings(source, target) {
+	const targetSet = new Set(target);
+	return source.filter((value) => !targetSet.has(value));
+}
+
+//#endregion
+//#region src/execute/sources/index.ts
+async function loadExecuteSources(executeFilePath) {
+	const storageDir = dirname(executeFilePath);
+	const executeMdPath = join(storageDir, EXECUTE_MD_FILE_NAME);
+	const yml = await readAndValidateExecuteFileWithSource(executeFilePath);
+	const ymlOps = yml.ops;
+	const executeMd = await readExecuteMdFile(executeMdPath);
+	const perItem = await loadPerItemSource(storageDir);
+	const mergedOps = [
+		...ymlOps,
+		...executeMd.ops,
+		...perItem.ops
+	];
+	const customErrors = validateExecuteRules(mergedOps);
+	if (customErrors.length) throw new Error(`Invalid execute file: ${customErrors.join("; ")}`);
+	return {
+		ops: mergedOps,
+		warnings: [...executeMd.warnings, ...perItem.warnings],
+		async writeRemaining(remainingIndexes) {
+			await writeExecuteFile(executeFilePath, ymlOps.map((op, index) => ({
+				op,
+				index
+			})).filter((item) => remainingIndexes.has(item.index)).map(({ op, index }) => ({
+				...op,
+				action: yml.sourceActions[index] ?? op.action
+			})));
+			if (!await pathExists(executeMdPath)) return;
+			const mdOffset = ymlOps.length;
+			const mdRemaining = /* @__PURE__ */ new Set();
+			for (const index of remainingIndexes) if (index >= mdOffset) mdRemaining.add(index - mdOffset);
+			await writeFile(executeMdPath, stringifyExecuteMd(executeMd, mdRemaining), "utf-8");
+		}
+	};
+}
+
+//#endregion
+//#region src/execute/index.ts
+var ExecuteCancelledError = class extends Error {
+	constructor() {
+		super("Execution cancelled");
+		this.name = "ExecuteCancelledError";
+	}
+};
+function isExecuteCancelledError(error) {
+	return error instanceof ExecuteCancelledError;
+}
+async function executePendingChanges(options) {
+	try {
+		await ensureExecuteArtifacts(options.executeFilePath);
+		const sources = await loadExecuteSources(options.executeFilePath);
+		const allOps = sources.ops;
+		for (const warning of sources.warnings) options.onWarning?.(warning);
+		if (allOps.length === 0) return {
+			runId: createRunId(),
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			mode: "report",
+			repo: options.repo,
+			planned: 0,
+			applied: 0,
+			failed: 0,
+			details: []
+		};
+		const interactive = process.stdin.isTTY && !options.nonInteractive;
+		if (interactive && !options.prompts) throw new Error("Interactive execute prompts are unavailable. Use --non-interactive or provide prompts.");
+		const selected = Array.isArray(options.selectedIndexes) ? selectOperationsByIndexes(allOps, options.selectedIndexes) : interactive ? await selectOperations(allOps, options.prompts) : allOps.map((op, index) => ({
+			op,
+			index
+		}));
+		const runId = createRunId();
+		const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+		const mode = options.apply ? "apply" : "report";
+		options.reporter?.onStart?.({
+			repo: options.repo,
+			mode,
+			planned: selected.length
+		});
+		if (selected.length === 0) {
+			const result = {
+				runId,
+				createdAt,
+				mode,
+				repo: options.repo,
+				planned: 0,
+				applied: 0,
+				failed: 0,
+				details: []
+			};
+			options.reporter?.onComplete?.({ result });
+			return result;
+		}
+		options.onPlan?.(selected.map((item) => item.op));
+		if (!options.apply) {
+			const result = {
+				runId,
+				createdAt,
+				mode: "report",
+				repo: options.repo,
+				planned: selected.length,
+				applied: 0,
+				failed: 0,
+				details: selected.map(({ op, index }) => ({
+					op: index + 1,
+					action: op.action,
+					number: op.number,
+					status: "planned",
+					message: describeExecutionAction(op.action, op.number)
+				}))
+			};
+			options.reporter?.onComplete?.({ result });
+			return result;
+		}
+		if (interactive) {
+			if (!await confirmApply(selected.length, options.prompts)) throw new ExecuteCancelledError();
+		}
+		const provider = options.provider ?? createRepositoryProvider({
+			token: options.token,
+			repo: options.repo
+		});
+		const details = [];
+		const appliedIndexes = /* @__PURE__ */ new Set();
+		let applied = 0;
+		let failed = 0;
+		for (const { op, index } of selected) try {
+			const target = await applyOperation(provider, op);
+			appliedIndexes.add(index);
+			await persistRemainingOps(sources.writeRemaining, allOps, appliedIndexes);
+			const detail = {
+				op: index + 1,
+				action: op.action,
+				number: op.number,
+				target,
+				status: "applied",
+				message: describeExecutionAction(op.action, op.number)
+			};
+			details.push(detail);
+			applied += 1;
+			options.reporter?.onProgress?.({
+				repo: options.repo,
+				mode: "apply",
+				planned: selected.length,
+				completed: details.length,
+				applied,
+				failed,
+				detail
+			});
+		} catch (error) {
+			failed += 1;
+			const detail = {
+				op: index + 1,
+				action: op.action,
+				number: op.number,
+				status: "failed",
+				message: error.message
+			};
+			details.push(detail);
+			options.reporter?.onProgress?.({
+				repo: options.repo,
+				mode: "apply",
+				planned: selected.length,
+				completed: details.length,
+				applied,
+				failed,
+				detail
+			});
+			if (!options.continueOnError) break;
+		}
+		const result = {
+			runId,
+			createdAt,
+			mode: "apply",
+			repo: options.repo,
+			planned: selected.length,
+			applied,
+			failed,
+			details
+		};
+		options.reporter?.onComplete?.({ result });
+		return result;
+	} catch (error) {
+		options.reporter?.onError?.({ error });
+		throw error;
+	}
+}
+async function persistRemainingOps(writeRemaining, allOps, appliedIndexes) {
+	const remainingIndexes = /* @__PURE__ */ new Set();
+	for (const [index] of allOps.entries()) if (!appliedIndexes.has(index)) remainingIndexes.add(index);
+	await writeRemaining(remainingIndexes);
+}
+async function applyOperation(provider, op) {
+	const item = await provider.fetchItemSnapshot(op.number);
+	const isPull = item.kind === "pull";
+	if (op.ifUnchangedSince) {
+		const remoteUpdatedAt = item.updatedAt;
+		if (remoteUpdatedAt && new Date(remoteUpdatedAt).getTime() > new Date(op.ifUnchangedSince).getTime()) throw new Error(`Operation conflict: remote updated_at=${remoteUpdatedAt}`);
+	}
+	switch (op.action) {
+		case "close":
+			await provider.actionClose(op.number);
+			break;
+		case "reopen":
+			await provider.actionReopen(op.number);
+			break;
+		case "set-title":
+			await provider.actionSetTitle(op.number, op.title);
+			break;
+		case "set-body":
+			await provider.actionSetBody(op.number, op.body);
+			break;
+		case "add-comment":
+			await provider.actionAddComment(op.number, op.body);
+			break;
+		case "close-with-comment":
+			await provider.actionAddComment(op.number, op.body);
+			await provider.actionClose(op.number);
+			break;
+		case "add-labels":
+			await provider.actionAddLabels(op.number, op.labels);
+			break;
+		case "remove-labels":
+			await provider.actionRemoveLabels(op.number, op.labels);
+			break;
+		case "set-labels":
+			await provider.actionSetLabels(op.number, op.labels);
+			break;
+		case "add-assignees":
+			await provider.actionAddAssignees(op.number, op.assignees);
+			break;
+		case "remove-assignees":
+			await provider.actionRemoveAssignees(op.number, op.assignees);
+			break;
+		case "set-assignees":
+			await provider.actionSetAssignees(op.number, op.assignees);
+			break;
+		case "set-milestone":
+			await provider.actionSetMilestone(op.number, op.milestone);
+			break;
+		case "clear-milestone":
+			await provider.actionClearMilestone(op.number);
+			break;
+		case "lock":
+			await provider.actionLock(op.number, op.reason);
+			break;
+		case "unlock":
+			await provider.actionUnlock(op.number);
+			break;
+		case "request-reviewers":
+			ensurePullAction(op.action, op.number, isPull);
+			await provider.actionRequestReviewers(op.number, op.reviewers);
+			break;
+		case "remove-reviewers":
+			ensurePullAction(op.action, op.number, isPull);
+			await provider.actionRemoveReviewers(op.number, op.reviewers);
+			break;
+		case "mark-ready-for-review":
+			ensurePullAction(op.action, op.number, isPull);
+			await provider.actionMarkReadyForReview(op.number);
+			break;
+		case "convert-to-draft":
+			ensurePullAction(op.action, op.number, isPull);
+			await provider.actionConvertToDraft(op.number);
+			break;
+		default: throw new Error(`Unsupported action: ${String(op.action)}`);
+	}
+	return item.kind;
+}
+function createRunId() {
+	return `run_${(/* @__PURE__ */ new Date()).toISOString().replace(/[-:.TZ]/g, "")}_${Math.random().toString(36).slice(2, 7)}`;
+}
+async function selectOperations(ops, prompts) {
+	const selectedIndexes = await prompts.selectOperations(ops);
+	if (!selectedIndexes) throw new ExecuteCancelledError();
+	const selectedIndexesSet = new Set(selectedIndexes);
+	return ops.map((op, index) => ({
+		op,
+		index
+	})).filter((item) => selectedIndexesSet.has(item.index));
+}
+async function confirmApply(count, prompts) {
+	const result = await prompts.confirmApply(count);
+	if (result == null) return false;
+	return result;
+}
+function selectOperationsByIndexes(ops, selectedIndexes) {
+	const selectedSet = /* @__PURE__ */ new Set();
+	for (const index of selectedIndexes) if (Number.isInteger(index) && index >= 0 && index < ops.length) selectedSet.add(index);
+	return ops.map((op, index) => ({
+		op,
+		index
+	})).filter((item) => selectedSet.has(item.index));
+}
+function ensurePullAction(action, number, isPull) {
+	if (!isPull) throw new Error(`Action ${action} requires #${number} to be a pull request`);
+}
+function describeExecutionAction(action, number) {
+	return `${action} #${number}`;
+}
+
+//#endregion
+//#region src/sync/execution-log.ts
+async function appendExecutionResult(storageDirAbsolute, result) {
+	await saveSyncState(storageDirAbsolute, appendExecution(await loadSyncState(storageDirAbsolute), result));
+}
+
+//#endregion
+//#region src/utils/sync.ts
+function resolveSince(options, syncState) {
+	if (options.full) return void 0;
+	if (options.since) return options.since;
+	return syncState.lastSyncedAt;
+}
+function normalizeIssueNumbers(numbers) {
+	if (!numbers) return void 0;
+	return [...new Set(numbers.filter((number) => Number.isInteger(number) && number > 0))];
+}
+
+//#endregion
+//#region src/sync/markdown.ts
+const FIELDS_ALWAYS_KEEP = new Set(["labels", "assignees"]);
+const FIELDS_ALWAYS_EXCLUDE = new Set(["repo", "kind"]);
+const REACTION_FIELDS = [
+	{
+		key: "plusOne",
+		emoji: "👍"
+	},
+	{
+		key: "minusOne",
+		emoji: "👎"
+	},
+	{
+		key: "laugh",
+		emoji: "😄"
+	},
+	{
+		key: "hooray",
+		emoji: "🎉"
+	},
+	{
+		key: "confused",
+		emoji: "😕"
+	},
+	{
+		key: "heart",
+		emoji: "❤️"
+	},
+	{
+		key: "rocket",
+		emoji: "🚀"
+	},
+	{
+		key: "eyes",
+		emoji: "👀"
+	}
+];
+function renderIssueMarkdown(input) {
+	const url = input.url || `https://github.com/${input.repo}/${input.kind === "pull" ? "pull" : "issues"}/${input.number}`;
+	const frontmatter = {
+		repo: input.repo,
+		number: input.number,
+		kind: input.kind,
+		url,
+		state: input.state,
+		title: input.title,
+		author: input.author,
+		labels: input.labels,
+		assignees: input.assignees,
+		milestone: input.milestone,
+		created_at: input.createdAt,
+		updated_at: input.updatedAt,
+		closed_at: input.closedAt,
+		last_synced_at: input.lastSyncedAt,
+		reactions: formatReactionsFrontmatter(input.reactions),
+		is_draft: input.pr?.isDraft,
+		merged: input.pr?.merged,
+		merged_at: input.pr?.mergedAt,
+		base_ref: input.pr?.baseRef,
+		head_ref: input.pr?.headRef,
+		reviewers_requested: input.pr?.requestedReviewers
+	};
+	const compactFrontmatter = Object.fromEntries(Object.entries(frontmatter).filter(([key, value]) => {
+		if (FIELDS_ALWAYS_EXCLUDE.has(key)) return false;
+		if (FIELDS_ALWAYS_KEEP.has(key)) return true;
+		if (value === void 0 || value === null || value === false) return false;
+		if (Array.isArray(value)) return value.length > 0;
+		return true;
+	}));
+	const sections = [
+		`# ${input.title}`,
+		"",
+		"## Description",
+		"",
+		input.body?.trim() || "_No description._"
+	];
+	const bodyReactionsLine = formatReactionsLine(input.reactions);
+	if (bodyReactionsLine) {
+		sections.push("");
+		sections.push(bodyReactionsLine);
+	}
+	sections.push("");
+	sections.push("---");
+	sections.push("");
+	sections.push("## Comments");
+	sections.push("");
+	if (input.comments.length === 0) sections.push("_No comments._");
+	else for (const [index, comment] of input.comments.entries()) {
+		if (index > 0) {
+			sections.push("---");
+			sections.push("");
+		}
+		sections.push(`### @${comment.author} on ${comment.createdAt}`);
+		sections.push(`<!-- comment-id:${comment.id} updated:${comment.updatedAt} -->`);
+		sections.push("");
+		sections.push(comment.body?.trim() || "_No content._");
+		const reactionsLine = formatReactionsLine(comment.reactions);
+		if (reactionsLine) {
+			sections.push("");
+			sections.push(reactionsLine);
+		}
+		sections.push("");
+	}
+	return [
+		"---",
+		stringify(compactFrontmatter).trimEnd(),
+		"---",
+		"",
+		...sections,
+		""
+	].join("\n");
+}
+function formatReactionsLine(reactions) {
+	const entries = getReactionEntries(reactions);
+	if (entries.length === 0) return void 0;
+	return `> ${entries.map((entry) => `\`${entry.emoji} ${entry.count}\``).join(" | ")}`;
+}
+function formatReactionsFrontmatter(reactions) {
+	const entries = getReactionEntries(reactions);
+	if (entries.length === 0) return void 0;
+	return Object.fromEntries(entries.map((entry) => [entry.emoji, entry.count]));
+}
+function getReactionEntries(reactions) {
+	const normalized = normalizeReactions(reactions);
+	return REACTION_FIELDS.map(({ key, emoji }) => {
+		const count = normalized[key];
+		if (!count) return void 0;
+		return {
+			emoji,
+			count
+		};
+	}).filter((entry) => Boolean(entry));
+}
+
+//#endregion
+//#region src/utils/string.ts
+function slugifyTitle(title, maxLength = 48) {
+	const normalized = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+	if (!normalized) return "item";
+	return normalized.slice(0, maxLength).replace(/-+$/g, "") || "item";
+}
+
+//#endregion
+//#region src/sync/paths.ts
+const FILE_NUMBER_PAD_LENGTH = 5;
+const MAX_SLUG_LENGTH = 48;
+function getIssueMarkdownPath(storageDirAbsolute, number, state, title) {
+	const fileName = getItemFileName(number, title);
+	if (state === "closed") return join(storageDirAbsolute, ISSUE_DIR_NAME, CLOSED_DIR_NAME, fileName);
+	return join(storageDirAbsolute, ISSUE_DIR_NAME, fileName);
+}
+function getPullMarkdownPath(storageDirAbsolute, number, state, title) {
+	const fileName = getItemFileName(number, title);
+	if (state === "closed") return join(storageDirAbsolute, PULL_DIR_NAME, CLOSED_DIR_NAME, fileName);
+	return join(storageDirAbsolute, PULL_DIR_NAME, fileName);
+}
+function getItemMarkdownPath(storageDirAbsolute, kind, number, state, title) {
+	if (kind === "pull") return getPullMarkdownPath(storageDirAbsolute, number, state, title);
+	return getIssueMarkdownPath(storageDirAbsolute, number, state, title);
+}
+function getItemFileName(number, title) {
+	return `${String(number).padStart(FILE_NUMBER_PAD_LENGTH, "0")}-${slugifyTitle(title, MAX_SLUG_LENGTH)}.md`;
+}
+function getPrPatchPath(storageDirAbsolute, number, title) {
+	return join(storageDirAbsolute, PULL_DIR_NAME, getItemFileName(number, title).replace(/\.md$/, ".patch"));
+}
+
+//#endregion
+//#region src/sync/sync-repository-utils.ts
+function createCounters(scanned = 0, selected = 0) {
+	return {
+		scanned,
+		selected,
+		processed: 0,
+		skipped: 0,
+		written: 0,
+		moved: 0,
+		patchesWritten: 0,
+		patchesDeleted: 0
+	};
+}
+function addItemStats(counters, stats) {
+	counters.skipped += stats.skipped;
+	counters.written += stats.written;
+	counters.moved += stats.moved;
+	counters.patchesWritten += stats.patchesWritten;
+	counters.patchesDeleted += stats.patchesDeleted;
+}
+function shouldSyncKind(sync, kind) {
+	return kind === "issue" ? sync.issues : sync.pulls;
+}
+function shouldSyncIssue(sync, issue) {
+	return shouldSyncKind(sync, issue.kind);
+}
+function resolvePatchPlan(patchesMode, kind, state) {
+	if (kind !== "pull") return {
+		shouldWritePatch: false,
+		shouldDeletePatch: false
+	};
+	const shouldWritePatch = patchesMode === "all" || patchesMode === "open" && state === "open";
+	return {
+		shouldWritePatch,
+		shouldDeletePatch: !shouldWritePatch
+	};
+}
+function relativeToStorage(storageDirAbsolute, absolutePath) {
+	if (absolutePath.startsWith(storageDirAbsolute)) return absolutePath.slice(storageDirAbsolute.length + 1);
+	return basename(absolutePath);
+}
+
+//#endregion
+//#region src/sync/sync-repository-storage.ts
+async function resolveIssuePaths(storageDirAbsolute, kind, number, title, state, trackedFilePath) {
+	const closedPath = getItemMarkdownPath(storageDirAbsolute, kind, number, "closed", title);
+	const openPath = getItemMarkdownPath(storageDirAbsolute, kind, number, "open", title);
+	const hasClosedFile = await pathExists(closedPath);
+	const hasOpenFile = await pathExists(openPath);
+	const trackedPath = resolveTrackedPath(storageDirAbsolute, trackedFilePath);
+	const hasTrackedFile = trackedPath ? await pathExists(trackedPath) : false;
+	const targetPath = getItemMarkdownPath(storageDirAbsolute, kind, number, state, title);
+	const hasTargetFile = state === "open" ? hasOpenFile : hasClosedFile;
+	const matchedPaths = await findMatchedMarkdownPaths(storageDirAbsolute, kind, number, [
+		openPath,
+		closedPath,
+		trackedPath
+	]);
+	return {
+		openPath,
+		closedPath,
+		targetPath,
+		patchPath: getPrPatchPath(storageDirAbsolute, number, title),
+		trackedPath,
+		hasOpenFile,
+		hasClosedFile,
+		hasTrackedFile,
+		matchedPaths,
+		hasLocalFile: hasOpenFile || hasClosedFile || hasTrackedFile || matchedPaths.length > 0,
+		hasTargetFile
+	};
+}
+async function moveMarkdownByState(paths, state) {
+	const sourcePath = resolveMoveSourcePath(paths, state);
+	if (!sourcePath) return 0;
+	if (sourcePath === paths.targetPath) return 0;
+	if (await pathExists(paths.targetPath)) return 0;
+	await movePath(sourcePath, paths.targetPath);
+	return 1;
+}
+function resolveMoveSourcePath(paths, state) {
+	if (paths.hasTrackedFile && paths.trackedPath && paths.trackedPath !== paths.targetPath) return paths.trackedPath;
+	if (state === "open" && paths.hasClosedFile && paths.closedPath !== paths.targetPath) return paths.closedPath;
+	if (state === "closed" && paths.hasOpenFile && paths.openPath !== paths.targetPath) return paths.openPath;
+	if (paths.hasOpenFile && paths.openPath !== paths.targetPath) return paths.openPath;
+	if (paths.hasClosedFile && paths.closedPath !== paths.targetPath) return paths.closedPath;
+	return paths.matchedPaths.find((path) => path !== paths.targetPath);
+}
+function getExistingMarkdownPaths(paths) {
+	const markdownPaths = /* @__PURE__ */ new Set();
+	if (paths.hasOpenFile) markdownPaths.add(paths.openPath);
+	if (paths.hasClosedFile) markdownPaths.add(paths.closedPath);
+	if (paths.hasTrackedFile && paths.trackedPath) markdownPaths.add(paths.trackedPath);
+	for (const matchedPath of paths.matchedPaths) markdownPaths.add(matchedPath);
+	return [...markdownPaths];
+}
+function resolveTrackedPath(storageDirAbsolute, trackedFilePath) {
+	if (!trackedFilePath) return void 0;
+	if (isAbsolute(trackedFilePath)) return trackedFilePath;
+	return join(storageDirAbsolute, trackedFilePath);
+}
+function resolveTrackedPathOrJoin(storageDirAbsolute, trackedFilePath) {
+	return resolveTrackedPath(storageDirAbsolute, trackedFilePath) ?? join(storageDirAbsolute, trackedFilePath);
+}
+async function findMatchedMarkdownPaths(storageDirAbsolute, kind, number, knownPaths) {
+	const matchedPaths = /* @__PURE__ */ new Set();
+	const knownPathSet = new Set(knownPaths.filter(Boolean));
+	const padded = String(number).padStart(5, "0");
+	const kindDir = kind === "issue" ? ISSUE_DIR_NAME : PULL_DIR_NAME;
+	for (const stateDir of ["", CLOSED_DIR_NAME]) {
+		const dir = stateDir ? join(storageDirAbsolute, kindDir, stateDir) : join(storageDirAbsolute, kindDir);
+		let files;
+		try {
+			files = await readdir(dir);
+		} catch {
+			continue;
+		}
+		for (const fileName of files) {
+			if (!fileName.startsWith(`${padded}-`) || !fileName.endsWith(".md")) continue;
+			const fullPath = join(dir, fileName);
+			if (!knownPathSet.has(fullPath)) matchedPaths.add(fullPath);
+		}
+	}
+	return [...matchedPaths];
+}
+function updateTrackedItem(context, number, kind, state, issueUpdatedAt, markdownPath, patchPath, data) {
+	context.syncState.items[String(number)] = {
+		number,
+		kind,
+		state,
+		lastUpdatedAt: issueUpdatedAt,
+		lastSyncedAt: context.syncedAt,
+		filePath: relativeToStorage(context.storageDirAbsolute, markdownPath),
+		patchPath: patchPath ? relativeToStorage(context.storageDirAbsolute, patchPath) : void 0,
+		data
+	};
+}
+async function pruneTrackedClosedItems(storageDirAbsolute, syncState, sync) {
+	if (sync.issues) await rm(join(storageDirAbsolute, ISSUE_DIR_NAME, CLOSED_DIR_NAME), {
+		recursive: true,
+		force: true
+	});
+	if (sync.pulls) await rm(join(storageDirAbsolute, PULL_DIR_NAME, CLOSED_DIR_NAME), {
+		recursive: true,
+		force: true
+	});
+	let patchesDeleted = 0;
+	for (const item of Object.values(syncState.items)) {
+		if (item.state !== "closed") continue;
+		if (!shouldSyncKind(sync, item.kind)) continue;
+		await removePath(resolveTrackedPathOrJoin(storageDirAbsolute, item.filePath));
+		if (item.kind === "pull") patchesDeleted += await removePatchIfExists(storageDirAbsolute, item.number);
+		delete syncState.items[String(item.number)];
+	}
+	return patchesDeleted;
+}
+async function pruneMissingOpenTrackedItems(storageDirAbsolute, syncState, openNumbers, sync) {
+	let patchesDeleted = 0;
+	for (const item of Object.values(syncState.items)) {
+		if (item.state !== "open") continue;
+		if (!shouldSyncKind(sync, item.kind)) continue;
+		if (openNumbers.has(item.number)) continue;
+		await removePath(resolveTrackedPathOrJoin(storageDirAbsolute, item.filePath));
+		if (item.kind === "pull") patchesDeleted += await removePatchIfExists(storageDirAbsolute, item.number);
+		delete syncState.items[String(item.number)];
+	}
+	return patchesDeleted;
+}
+
+//#endregion
+//#region src/sync/sync-repository-item.ts
+async function prepareIssueCandidateSync(context, issue) {
+	const number = issue.number;
+	const kind = issue.kind;
+	const state = issue.state;
+	const tracked = context.syncState.items[String(number)];
+	const paths = await resolveIssuePaths(context.storageDirAbsolute, kind, number, issue.title, state, tracked?.filePath);
+	const patchPlan = resolvePatchPlan(context.config.sync.patches, kind, state);
+	if (state === "closed" && context.config.sync.closed === false) {
+		delete context.syncState.items[String(number)];
+		return {
+			number,
+			kind,
+			state,
+			action: "remove",
+			paths,
+			patchPlan
+		};
+	}
+	if (state === "closed" && context.config.sync.closed === true && !paths.hasLocalFile) {
+		delete context.syncState.items[String(number)];
+		return {
+			number,
+			kind,
+			state,
+			action: "remove",
+			paths,
+			patchPlan
+		};
+	}
+	const hasCanonicalData = Boolean(tracked?.data && (kind !== "pull" || tracked.data.pull));
+	const shouldRefetch = !tracked || tracked.lastUpdatedAt !== issue.updatedAt || !hasCanonicalData;
+	const data = shouldRefetch ? await fetchCanonicalData(context, issue) : tracked.data;
+	updateTrackedItem(context, number, kind, state, issue.updatedAt, paths.targetPath, patchPlan.shouldWritePatch ? paths.patchPath : void 0, data);
+	return {
+		number,
+		kind,
+		state,
+		action: resolveSyncAction(shouldRefetch, paths, state),
+		paths,
+		patchPlan
+	};
+}
+async function materializePreparedIssue(context, candidate) {
+	const { number, kind, state, action, patchPlan, paths } = candidate;
+	if (action === "remove") {
+		for (const markdownPath of getExistingMarkdownPaths(paths)) await removePath(markdownPath);
+		let patchesDeleted = 0;
+		if (kind === "pull") patchesDeleted += await removePatchIfExists(context.storageDirAbsolute, number);
+		return {
+			kind,
+			action,
+			skipped: 0,
+			written: 0,
+			moved: 0,
+			patchesWritten: 0,
+			patchesDeleted
+		};
+	}
+	if (action === "skip") {
+		let patchesDeleted = 0;
+		if (patchPlan.shouldDeletePatch) patchesDeleted += await removePatchIfExists(context.storageDirAbsolute, number);
+		return {
+			kind,
+			action,
+			skipped: 1,
+			written: 0,
+			moved: 0,
+			patchesWritten: 0,
+			patchesDeleted
+		};
+	}
+	const tracked = context.syncState.items[String(number)];
+	if (!tracked) throw new Error(`Missing tracked canonical data for ${formatIssueNumber(number, {
+		repo: context.repoSlug,
+		kind
+	})}`);
+	const markdown = buildTrackedMarkdown(context, tracked);
+	const moved = await moveMarkdownByState(paths, state);
+	await writeFileEnsured(paths.targetPath, markdown);
+	const patchStats = await syncPatchByPlan(context, number, paths.patchPath, patchPlan);
+	return {
+		kind,
+		action,
+		skipped: 0,
+		written: 1,
+		moved,
+		patchesWritten: patchStats.patchesWritten,
+		patchesDeleted: patchStats.patchesDeleted
+	};
+}
+async function rematerializeTrackedMarkdown(context) {
+	let processed = 0;
+	let written = 0;
+	let moved = 0;
+	for (const tracked of Object.values(context.syncState.items)) {
+		const paths = await resolveIssuePaths(context.storageDirAbsolute, tracked.kind, tracked.number, tracked.data.item.title, tracked.state, tracked.filePath);
+		moved += await moveMarkdownByState(paths, tracked.state);
+		await writeFileEnsured(paths.targetPath, buildTrackedMarkdown(context, tracked));
+		tracked.filePath = relativeToStorage(context.storageDirAbsolute, paths.targetPath);
+		tracked.lastSyncedAt = context.syncedAt;
+		processed += 1;
+		written += 1;
+	}
+	return {
+		processed,
+		written,
+		moved
+	};
+}
+async function reconcileMarkdownFilesByScan(context) {
+	let written = 0;
+	let moved = 0;
+	const expectedPaths = /* @__PURE__ */ new Set();
+	for (const tracked of Object.values(context.syncState.items)) {
+		const paths = await resolveIssuePaths(context.storageDirAbsolute, tracked.kind, tracked.number, tracked.data.item.title, tracked.state, tracked.filePath);
+		expectedPaths.add(paths.targetPath);
+		const movedByState = !paths.hasTargetFile ? await moveMarkdownByState(paths, tracked.state) : 0;
+		let changed = movedByState > 0;
+		if (!await pathExists(paths.targetPath)) {
+			await writeFileEnsured(paths.targetPath, buildTrackedMarkdown(context, tracked));
+			written += 1;
+			changed = true;
+		}
+		tracked.filePath = relativeToStorage(context.storageDirAbsolute, paths.targetPath);
+		if (changed) tracked.lastSyncedAt = context.syncedAt;
+		moved += movedByState;
+	}
+	moved += await moveExtraMarkdownFilesToClosed(context.storageDirAbsolute, expectedPaths);
+	return {
+		written,
+		moved
+	};
+}
+function resolveSyncAction(shouldRefetch, paths, state) {
+	if (shouldRefetch) return "refetch";
+	if (paths.hasTargetFile) return "skip";
+	if (resolveMoveSourcePath(paths, state)) return "move";
+	return "create";
+}
+async function fetchCanonicalData(context, issue) {
+	return {
+		item: issue,
+		comments: await context.provider.fetchComments(issue.number),
+		pull: issue.kind === "pull" ? await context.provider.fetchPullMetadata(issue.number) : void 0
+	};
+}
+async function syncPatchByPlan(context, number, patchPath, patchPlan) {
+	let patchesWritten = 0;
+	let patchesDeleted = 0;
+	if (patchPlan.shouldWritePatch) {
+		const patch = await context.provider.fetchPullPatch(number);
+		await removePatchIfExists(context.storageDirAbsolute, number);
+		await writeFileEnsured(patchPath, patch);
+		patchesWritten += 1;
+	}
+	if (patchPlan.shouldDeletePatch) patchesDeleted += await removePatchIfExists(context.storageDirAbsolute, number);
+	return {
+		patchesWritten,
+		patchesDeleted
+	};
+}
+function buildTrackedMarkdown(context, tracked) {
+	return renderIssueMarkdown({
+		repo: context.repoSlug,
+		number: tracked.data.item.number,
+		kind: tracked.data.item.kind,
+		url: tracked.data.item.url,
+		state: tracked.data.item.state,
+		title: tracked.data.item.title,
+		body: tracked.data.item.body ?? "",
+		author: tracked.data.item.author ?? "unknown",
+		labels: tracked.data.item.labels,
+		assignees: tracked.data.item.assignees,
+		milestone: tracked.data.item.milestone,
+		createdAt: tracked.data.item.createdAt,
+		updatedAt: tracked.data.item.updatedAt,
+		closedAt: tracked.data.item.closedAt,
+		lastSyncedAt: context.syncedAt,
+		reactions: normalizeReactions(tracked.data.item.reactions),
+		comments: tracked.data.comments.map((comment) => ({
+			id: comment.id,
+			author: comment.author ?? "unknown",
+			body: comment.body ?? "",
+			createdAt: comment.createdAt,
+			updatedAt: comment.updatedAt,
+			reactions: normalizeReactions(comment.reactions)
+		})),
+		pr: tracked.data.pull
+	});
+}
+async function moveExtraMarkdownFilesToClosed(storageDirAbsolute, expectedPaths) {
+	let moved = 0;
+	moved += await moveOpenMarkdownFilesToClosed(join(storageDirAbsolute, ISSUE_DIR_NAME), expectedPaths);
+	moved += await moveOpenMarkdownFilesToClosed(join(storageDirAbsolute, PULL_DIR_NAME), expectedPaths);
+	return moved;
+}
+async function moveOpenMarkdownFilesToClosed(kindDirAbsolute, expectedPaths) {
+	let moved = 0;
+	const openFiles = await listOpenMarkdownFiles(kindDirAbsolute);
+	const closedDirAbsolute = join(kindDirAbsolute, CLOSED_DIR_NAME);
+	for (const markdownPath of openFiles) {
+		if (expectedPaths.has(markdownPath)) continue;
+		await movePath(markdownPath, await resolveUniqueClosedTarget(closedDirAbsolute, basename(markdownPath)));
+		moved += 1;
+	}
+	return moved;
+}
+async function listOpenMarkdownFiles(kindDirAbsolute) {
+	try {
+		return (await readdir(kindDirAbsolute, {
+			withFileTypes: true,
+			encoding: "utf8"
+		})).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => join(kindDirAbsolute, entry.name));
+	} catch {
+		return [];
+	}
+}
+async function resolveUniqueClosedTarget(closedDirAbsolute, fileName) {
+	const baseName = fileName.replace(/\.md$/i, "");
+	let candidate = join(closedDirAbsolute, fileName);
+	let index = 1;
+	while (await pathExists(candidate)) {
+		candidate = join(closedDirAbsolute, `${baseName}-extra-${index}.md`);
+		index += 1;
+	}
+	return candidate;
+}
+
+//#endregion
+//#region src/sync/sync-repository-provider.ts
+async function fetchIssueCandidatesByPagination(context, since) {
+	const issues = [];
+	let scanned = 0;
+	const allOpenNumbers = context.config.sync.closed === false && !since ? /* @__PURE__ */ new Set() : void 0;
+	const state = context.config.sync.closed === false ? "open" : "all";
+	for await (const page of context.provider.paginateItems({
+		state,
+		since
+	})) for (const issue of page) {
+		if (!shouldSyncIssue(context.config.sync, issue)) continue;
+		scanned += 1;
+		issues.push(issue);
+		if (state === "open" && allOpenNumbers) allOpenNumbers.add(issue.number);
+	}
+	return {
+		issues,
+		scanned,
+		allOpenNumbers
+	};
+}
+async function fetchIssueCandidatesByNumbers(context, numbers) {
+	const issues = (await context.provider.fetchItemsByNumbers(numbers)).filter((issue) => shouldSyncIssue(context.config.sync, issue));
+	return {
+		issues,
+		scanned: issues.length
+	};
+}
+
+//#endregion
+//#region src/utils/markdown.ts
+function getTimestamp(value) {
+	const timestamp = Date.parse(value);
+	if (Number.isFinite(timestamp)) return timestamp;
+	return Number.NEGATIVE_INFINITY;
+}
+function renderRowsTable(rows) {
+	const lines = ["| Number | Title | Labels | Updated | File |", "| --- | --- | --- | --- | --- |"];
+	if (rows.length === 0) {
+		lines.push("| - | - | - | - | - |");
+		return lines;
+	}
+	for (const row of rows) {
+		const labels = row.labels.length ? row.labels.map((label) => `\`${escapeInlineCode(label)}\``).join(", ") : "-";
+		lines.push(`| #${row.number} | ${escapeTableCell(row.title)} | ${labels} | ${escapeTableCell(row.updatedAt)} | [${row.filePath}](${row.filePath}) |`);
+	}
+	return lines;
+}
+function escapeTableCell(value) {
+	return value.replace(/\r?\n/g, " ").replace(/\|/g, "\\|").trim() || "-";
+}
+function escapeInlineCode(value) {
+	return value.replace(/`/g, "\\`");
+}
+
+//#endregion
+//#region src/sync/sync-repository-snapshot.ts
+async function writeRepoSnapshot(context) {
+	const repoSnapshot = await buildRepoSnapshot(context);
+	await mkdir(context.storageDirAbsolute, { recursive: true });
+	await writeFile(join(context.storageDirAbsolute, REPO_SNAPSHOT_FILE_NAME), `${JSON.stringify(repoSnapshot, null, 2)}\n`, "utf8");
+}
+async function writeRepositoryIndexes(context) {
+	const [issuesMarkdown, pullsMarkdown] = await Promise.all([renderIndexMarkdown(context, "issue"), renderIndexMarkdown(context, "pull")]);
+	await mkdir(context.storageDirAbsolute, { recursive: true });
+	await Promise.all([writeFile(join(context.storageDirAbsolute, ISSUES_INDEX_FILE_NAME), issuesMarkdown, "utf8"), writeFile(join(context.storageDirAbsolute, PULLS_INDEX_FILE_NAME), pullsMarkdown, "utf8")]);
+}
+async function renderIndexMarkdown(context, kind) {
+	const rows = Object.values(context.syncState.items).filter((item) => item.kind === kind).map((item) => readIndexRow(item));
+	const openRows = sortRows(rows.filter((row) => row.state === "open"));
+	const closedRows = sortRows(rows.filter((row) => row.state === "closed"));
+	return [
+		`# ${kind === "issue" ? "Issues" : "Pull Requests"}`,
+		"",
+		`- repo: ${context.repoSlug}`,
+		`- synced_at: ${context.syncedAt}`,
+		`- total: ${rows.length}`,
+		`- open: ${openRows.length}`,
+		`- closed: ${closedRows.length}`,
+		"",
+		`## Open (${openRows.length})`,
+		"",
+		...renderRowsTable(openRows),
+		"",
+		`## Closed (${closedRows.length})`,
+		"",
+		...renderRowsTable(closedRows),
+		""
+	].join("\n");
+}
+function readIndexRow(item) {
+	return {
+		number: item.number,
+		state: item.state,
+		title: item.data.item.title,
+		labels: item.data.item.labels,
+		updatedAt: item.data.item.updatedAt,
+		filePath: item.filePath
+	};
+}
+function sortRows(rows) {
+	return [...rows].sort((left, right) => {
+		const updatedDiff = getTimestamp(right.updatedAt) - getTimestamp(left.updatedAt);
+		if (updatedDiff !== 0) return updatedDiff;
+		return right.number - left.number;
+	});
+}
+async function buildRepoSnapshot(context) {
+	const [repoResult, labelsResult, milestonesResult] = await Promise.all([
+		context.provider.fetchRepository(),
+		context.provider.fetchRepositoryLabels(),
+		context.provider.fetchRepositoryMilestones()
+	]);
+	const repository = repoResult;
+	const labels = labelsResult.map((label) => ({
+		name: label.name,
+		color: label.color,
+		description: label.description ?? null,
+		default: Boolean(label.default)
+	})).sort((left, right) => left.name.localeCompare(right.name));
+	const milestones = milestonesResult.map((milestone) => ({
+		number: milestone.number,
+		title: milestone.title,
+		state: milestone.state,
+		description: milestone.description ?? null,
+		due_on: milestone.due_on,
+		open_issues: milestone.open_issues,
+		closed_issues: milestone.closed_issues,
+		created_at: milestone.created_at,
+		updated_at: milestone.updated_at,
+		closed_at: milestone.closed_at
+	})).sort((left, right) => left.number - right.number);
+	return {
+		repo: context.repoSlug,
+		synced_at: context.syncedAt,
+		repository: {
+			owner: repository.owner.login,
+			name: repository.name,
+			full_name: repository.full_name,
+			description: repository.description ?? null,
+			private: repository.private,
+			archived: repository.archived,
+			default_branch: repository.default_branch,
+			html_url: repository.html_url,
+			fork: repository.fork,
+			open_issues_count: repository.open_issues_count,
+			has_issues: repository.has_issues,
+			has_projects: repository.has_projects,
+			has_wiki: repository.has_wiki,
+			created_at: repository.created_at,
+			updated_at: repository.updated_at,
+			pushed_at: repository.pushed_at
+		},
+		labels,
+		milestones
+	};
+}
+
+//#endregion
+//#region src/sync/sync-repository.ts
+async function syncRepository(options) {
+	const reporter = options.reporter;
+	const startedAt = /* @__PURE__ */ new Date();
+	const startedAtIso = startedAt.toISOString();
+	const runId = createSyncRunId();
+	const provider = options.provider ?? createRepositoryProvider({
+		token: options.token,
+		repo: options.repo
+	});
+	const storageDirAbsolute = resolve(options.config.cwd, options.config.directory);
+	const targetNumbers = normalizeIssueNumbers(options.numbers);
+	const counters = createCounters();
+	const stageDurations = createStageDurations();
+	let errorReported = false;
+	reporter?.onStart?.({
+		repo: options.repo,
+		startedAt: startedAtIso,
+		numbersCount: targetNumbers?.length,
+		snapshot: cloneSnapshot(counters)
+	});
+	let context;
+	let since;
+	let repoUpdatedAt;
+	let candidates = {
+		issues: [],
+		scanned: 0
+	};
+	const preparedCandidates = [];
+	let updatedIssues = 0;
+	let updatedPulls = 0;
+	let ghfsVersionMismatch = false;
+	let previousGhfsVersion;
+	const runStage = async (stage, message, fn) => {
+		reporter?.onStageStart?.({
+			stage,
+			message,
+			snapshot: cloneSnapshot(counters)
+		});
+		const stageStartedAt = Date.now();
+		try {
+			const result = await fn();
+			const durationMs = Date.now() - stageStartedAt;
+			stageDurations[stage] = durationMs;
+			reporter?.onStageEnd?.({
+				stage,
+				message,
+				durationMs,
+				snapshot: cloneSnapshot(counters)
+			});
+			return result;
+		} catch (error) {
+			errorReported = true;
+			stageDurations[stage] = Date.now() - stageStartedAt;
+			reporter?.onError?.({
+				stage,
+				error,
+				snapshot: cloneSnapshot(counters)
+			});
+			throw error;
+		}
+	};
+	try {
+		let shouldEarlyReturn = false;
+		await runStage("metadata", "Fetch repository metadata", async () => {
+			const syncState = await loadSyncState(storageDirAbsolute);
+			since = targetNumbers ? void 0 : resolveSince(options, syncState);
+			const syncedAt = (/* @__PURE__ */ new Date()).toISOString();
+			context = {
+				provider,
+				repoSlug: options.repo,
+				storageDirAbsolute,
+				config: options.config,
+				syncState,
+				syncedAt,
+				totalIssues: 0,
+				totalPulls: 0
+			};
+			previousGhfsVersion = syncState.ghfsVersion;
+			ghfsVersionMismatch = syncState.ghfsVersion !== GHFS_VERSION;
+			if (targetNumbers) return;
+			repoUpdatedAt = (await provider.fetchRepository()).updated_at;
+			if (!options.full && syncState.lastRepoUpdatedAt && syncState.lastRepoUpdatedAt === repoUpdatedAt) shouldEarlyReturn = true;
+			reporter?.onStageUpdate?.({
+				stage: "metadata",
+				snapshot: cloneSnapshot(counters),
+				message: `since=${since ?? "(full)"} repoUpdatedAt=${repoUpdatedAt}`
+			});
+		});
+		assertContext(context);
+		const syncContext = context;
+		if (!shouldEarlyReturn) {
+			await runStage("pagination", "Pagination", async () => {
+				const paginatedSince = options.full ? void 0 : since;
+				candidates = targetNumbers ? await fetchIssueCandidatesByNumbers(syncContext, targetNumbers) : await fetchIssueCandidatesByPagination(syncContext, paginatedSince);
+				counters.scanned = candidates.scanned;
+				counters.selected = candidates.issues.length;
+				reporter?.onStageUpdate?.({
+					stage: "pagination",
+					snapshot: cloneSnapshot(counters),
+					message: `scanned=${counters.scanned} selected=${counters.selected}`
+				});
+			});
+			await runStage("fetch", "Fetch updated issues/PRs", async () => {
+				for (const issue of candidates.issues) {
+					const prepared = await prepareIssueCandidateSync(syncContext, issue);
+					preparedCandidates.push(prepared);
+					counters.processed += 1;
+					if (prepared.action === "refetch" || prepared.action === "create") if (prepared.kind === "issue") updatedIssues += 1;
+					else updatedPulls += 1;
+					reporter?.onStageUpdate?.({
+						stage: "fetch",
+						snapshot: cloneSnapshot(counters),
+						message: `${formatIssueNumber(issue.number, {
+							repo: options.repo,
+							kind: issue.kind
+						})} ${prepared.kind} ${prepared.action}`
+					});
+				}
+			});
+			syncContext.syncState.repo = options.repo;
+			if (!targetNumbers) {
+				syncContext.syncState.lastSyncedAt = syncContext.syncedAt;
+				syncContext.syncState.lastSince = since;
+				syncContext.syncState.lastRepoUpdatedAt = repoUpdatedAt;
+			}
+			await saveSyncState(syncContext.storageDirAbsolute, syncContext.syncState);
+			await runStage("materialize", "Materialize local files", async () => {
+				for (const prepared of preparedCandidates) addItemStats(counters, await materializePreparedIssue(syncContext, prepared));
+			});
+			await runStage("prune", "Prune stale local artifacts", async () => {
+				if (options.config.sync.closed === false) counters.patchesDeleted += await pruneTrackedClosedItems(syncContext.storageDirAbsolute, syncContext.syncState, options.config.sync);
+				if (!targetNumbers && options.config.sync.closed === false && candidates.allOpenNumbers) counters.patchesDeleted += await pruneMissingOpenTrackedItems(syncContext.storageDirAbsolute, syncContext.syncState, candidates.allOpenNumbers, options.config.sync);
+				reporter?.onStageUpdate?.({
+					stage: "prune",
+					snapshot: cloneSnapshot(counters),
+					message: `patchesDeleted=${counters.patchesDeleted}`
+				});
+			});
+		}
+		await runStage("save", "Save sync state", async () => {
+			if (ghfsVersionMismatch) {
+				const rematerialized = await rematerializeTrackedMarkdown(syncContext);
+				reporter?.onStageUpdate?.({
+					stage: "save",
+					snapshot: cloneSnapshot(counters),
+					message: `regenerated=${rematerialized.written} version=${previousGhfsVersion ?? "(none)"}->${GHFS_VERSION}`
+				});
+			}
+			const scanStats = await reconcileMarkdownFilesByScan(syncContext);
+			counters.written += scanStats.written;
+			counters.moved += scanStats.moved;
+			reporter?.onStageUpdate?.({
+				stage: "save",
+				snapshot: cloneSnapshot(counters),
+				message: `scan-fixed written=${scanStats.written} moved=${scanStats.moved}`
+			});
+			if (!shouldEarlyReturn) await writeRepoSnapshot(syncContext);
+			if (!shouldEarlyReturn || ghfsVersionMismatch) await writeRepositoryIndexes(syncContext);
+			syncContext.syncState.ghfsVersion = GHFS_VERSION;
+			await saveSyncState(syncContext.storageDirAbsolute, syncContext.syncState);
+		});
+		const totals = computeTotals(syncContext.syncState.items);
+		syncContext.totalIssues = totals.totalIssues;
+		syncContext.totalPulls = totals.totalPulls;
+		const finishedAt = /* @__PURE__ */ new Date();
+		const durationMs = Math.max(0, finishedAt.getTime() - startedAt.getTime());
+		const requestCount = provider.getRequestCount();
+		const summary = {
+			repo: options.repo,
+			since,
+			syncedAt: syncContext.syncedAt,
+			totalIssues: totals.totalIssues,
+			totalPulls: totals.totalPulls,
+			updatedIssues,
+			updatedPulls,
+			trackedItems: totals.trackedItems,
+			requestCount,
+			scanned: counters.scanned,
+			selected: counters.selected,
+			processed: counters.processed,
+			skipped: counters.skipped,
+			written: counters.written,
+			moved: counters.moved,
+			patchesWritten: counters.patchesWritten,
+			patchesDeleted: counters.patchesDeleted,
+			durationMs
+		};
+		syncContext.syncState.lastSyncRun = {
+			runId,
+			repo: options.repo,
+			startedAt: startedAtIso,
+			finishedAt: finishedAt.toISOString(),
+			durationMs,
+			requestCount,
+			since,
+			numbersCount: targetNumbers?.length,
+			counters: cloneSnapshot(counters),
+			stages: { ...stageDurations }
+		};
+		await saveSyncState(syncContext.storageDirAbsolute, syncContext.syncState);
+		reporter?.onComplete?.({
+			summary,
+			stages: { ...stageDurations }
+		});
+		return summary;
+	} catch (error) {
+		if (!errorReported) reporter?.onError?.({
+			error,
+			snapshot: cloneSnapshot(counters)
+		});
+		throw error;
+	}
+}
+function assertContext(context) {
+	if (!context) throw new Error("Sync context was not initialized");
+}
+function createSyncRunId() {
+	return `sync_${(/* @__PURE__ */ new Date()).toISOString().replace(/[-:.TZ]/g, "")}_${randomBytes(3).toString("hex")}`;
+}
+function createStageDurations() {
+	return {
+		metadata: 0,
+		pagination: 0,
+		fetch: 0,
+		materialize: 0,
+		prune: 0,
+		save: 0
+	};
+}
+function cloneSnapshot(counters) {
+	return {
+		scanned: counters.scanned,
+		selected: counters.selected,
+		processed: counters.processed,
+		skipped: counters.skipped,
+		written: counters.written,
+		moved: counters.moved,
+		patchesWritten: counters.patchesWritten,
+		patchesDeleted: counters.patchesDeleted
+	};
+}
+function computeTotals(items) {
+	let totalIssues = 0;
+	let totalPulls = 0;
+	for (const item of Object.values(items)) if (item.kind === "issue") totalIssues += 1;
+	else totalPulls += 1;
+	return {
+		totalIssues,
+		totalPulls,
+		trackedItems: totalIssues + totalPulls
+	};
+}
+
+//#endregion
+//#region src/cli/action-color.ts
+function colorizeAction(action, enabled = true) {
+	if (!enabled) return action;
+	const colorHex = ACTIONS_COLOR_HEX[action];
+	if (!colorHex) return c.white(action);
+	return c.hex(colorHex)(action);
+}
+function describeCliOperation(op, options = {}) {
+	const tty = options.tty ?? false;
+	const issueRef = formatIssueRef(op.number, options.repo, tty);
+	const action = colorizeAction(op.action, tty);
+	const values = formatOperationValues(op);
+	if (!values) return `${issueRef} ${action}`;
+	return `${issueRef} ${action} ${values}`;
+}
+function formatIssueRef(number, repo, tty) {
+	const text = `#${number}`;
+	if (!tty || !repo || !repo.includes("/")) return text;
+	return formatTerminalLink(text, `https://github.com/${repo}/issues/${number}`);
+}
+function formatTerminalLink(text, url) {
+	return `\u001B]8;;${url}\u001B\\${text}\u001B]8;;\u001B\\`;
+}
+function formatOperationValues(op) {
+	switch (op.action) {
+		case "set-title": return wrapTextValue(op.title);
+		case "set-body":
+		case "add-comment":
+		case "close-with-comment": return wrapTextValue(op.body);
+		case "add-labels":
+		case "remove-labels":
+		case "set-labels": return joinValues(op.labels);
+		case "add-assignees":
+		case "remove-assignees":
+		case "set-assignees": return joinValues(op.assignees);
+		case "set-milestone": return op.milestone != null ? String(op.milestone) : void 0;
+		case "request-reviewers":
+		case "remove-reviewers": return joinValues(op.reviewers);
+		case "lock": return op.reason;
+		default: return;
+	}
+}
+function joinValues(values) {
+	if (!values || values.length === 0) return void 0;
+	return values.join(", ");
+}
+function wrapTextValue(value) {
+	if (!value) return void 0;
+	const normalized = value.trim();
+	if (normalized.length <= 48) return normalized;
+	return `${normalized.slice(0, 45)}...`;
+}
+
+//#endregion
+//#region src/cli/errors.ts
+function withErrorHandling(fn) {
+	return (...args) => {
+		fn(...args).catch((error) => {
+			console.error(error);
+			process.exit(1);
+		});
+	};
+}
+
+//#endregion
+//#region src/cli/meta.ts
+const CLI_NAME = GHFS_NAME;
+const CLI_VERSION = GHFS_VERSION;
+function ASCII_HEADER(repo) {
+	return c.gray([
+		"      _   ___     ",
+		"  ___| |_|  _|___ ",
+		` | . |   |  _|_ -|  ${c.green.bold(CLI_NAME)} ${c.blue(`v${CLI_VERSION}`)}`,
+		` |_  |_|_|_| |___|  → ${repo}`,
+		" |___|            ",
+		""
+	].join("\n"));
+}
+function toGitHubRepoUrl(repo) {
+	return `https://github.com/${repo}`;
+}
+
+//#endregion
+//#region src/cli/printer.ts
+function createCliPrinter(command, options = {}) {
+	const mode = resolveMode(options);
+	const progressEvery = options.progressEvery ?? 25;
+	const write = (message) => {
+		if (message == null) return;
+		console.log(message);
+	};
+	const writeError = (message) => {
+		console.error(message);
+	};
+	const printer = {
+		mode,
+		header(repo) {
+			if (mode !== "rich") return;
+			write(ASCII_HEADER(formatTerminalLink$1(repo, toGitHubRepoUrl(repo))));
+		},
+		start(message) {
+			if (mode === "rich") p.intro(message);
+			else write(message);
+		},
+		step(message) {
+			if (mode === "rich") p.log.step(message);
+			else write(message);
+		},
+		info(message) {
+			if (mode === "rich") p.log.info(message);
+			else write(message);
+		},
+		success(message) {
+			if (mode === "rich") p.log.success(message);
+			else write(message);
+		},
+		warn(message) {
+			if (mode === "rich") p.log.warn(message);
+			else write(message);
+		},
+		error(message) {
+			if (mode === "rich") p.log.error(message);
+			else writeError(message);
+		},
+		done(message) {
+			if (mode === "rich") p.outro(message);
+			else write(message);
+		},
+		note(message, title) {
+			if (mode === "rich") p.note(message, title, { format: (line) => line });
+			else {
+				if (title) write(`--- ${title} ---`);
+				write(message);
+				if (title) write("---");
+			}
+		},
+		table(title, entries, options) {
+			const lines = formatKeyValueLines(entries, options);
+			if (lines.length !== 0) printer.note(lines.join("\n"), title);
+		},
+		print(lines) {
+			for (const line of lines) console.log(line);
+		},
+		createSyncReporter() {
+			return mode === "rich" ? createRichSyncReporter(printer) : createPlainSyncReporter(printer, progressEvery);
+		},
+		createExecuteReporter() {
+			return mode === "rich" ? createRichExecuteReporter(printer) : createPlainExecuteReporter(printer);
+		}
+	};
+	return printer;
+}
+function createRichSyncReporter(printer) {
+	let stageSpinner = p.spinner();
+	let syncProgress = p.progress({ max: 1 });
+	let hasSyncProgress = false;
+	let lastProcessed = 0;
+	return {
+		onStart() {},
+		onStageStart(event) {
+			if (isHiddenSyncStage(event.stage)) return;
+			if (event.stage === "fetch") {
+				hasSyncProgress = true;
+				syncProgress = p.progress({ max: Math.max(event.snapshot.selected, 1) });
+				lastProcessed = 0;
+				syncProgress.start(formatSyncProgressLine(event.snapshot));
+				return;
+			}
+			stageSpinner = p.spinner();
+			stageSpinner.start(event.message);
+		},
+		onStageUpdate(event) {
+			if (event.stage === "fetch" && hasSyncProgress) {
+				const nextProcessed = event.snapshot.processed;
+				const advanceBy = Math.max(0, nextProcessed - lastProcessed);
+				const message = formatSyncProgressLine(event.snapshot, event.message);
+				if (advanceBy > 0) syncProgress.advance(advanceBy, message);
+				else syncProgress.message(message);
+				lastProcessed = nextProcessed;
+				return;
+			}
+			if (isHiddenSyncStage(event.stage)) return;
+			if (event.message) stageSpinner.message(event.message);
+		},
+		onStageEnd(event) {
+			if (isHiddenSyncStage(event.stage)) return;
+			const completionLine = formatStageCompletionLine(event.stage, event.snapshot, event.durationMs);
+			if (event.stage === "fetch" && hasSyncProgress) {
+				const advanceBy = Math.max(0, event.snapshot.processed - lastProcessed);
+				if (advanceBy > 0) syncProgress.advance(advanceBy);
+				if (completionLine) syncProgress.stop(completionLine);
+				else syncProgress.clear();
+				hasSyncProgress = false;
+				return;
+			}
+			if (completionLine) stageSpinner.stop(completionLine);
+			else stageSpinner.clear();
+		},
+		onComplete(event) {
+			printer.success(`Sync finished. ${event.summary.updatedIssues} issues and ${event.summary.updatedPulls} PRs updated${c.dim(` (${formatDuration(event.summary.durationMs)})`)}.`);
+		},
+		onError(event) {
+			const message = `Sync failed${event.stage && !isHiddenSyncStage(event.stage) ? ` while ${describeStage(event.stage)}` : ""}: ${toErrorMessage(event.error)}`;
+			if (hasSyncProgress) {
+				syncProgress.error(message);
+				hasSyncProgress = false;
+				return;
+			}
+			stageSpinner.error(message);
+		}
+	};
+}
+function createPlainSyncReporter(printer, progressEvery) {
+	let lastProgress = 0;
+	return {
+		onStart() {},
+		onStageStart(event) {
+			if (isHiddenSyncStage(event.stage)) return;
+			printer.step(event.message);
+		},
+		onStageUpdate(event) {
+			if (event.stage === "fetch") {
+				const processed = event.snapshot.processed;
+				if (!(processed === 0 || processed === event.snapshot.selected || processed - lastProgress >= progressEvery)) return;
+				lastProgress = processed;
+				printer.step(formatSyncProgressLine(event.snapshot, event.message));
+				return;
+			}
+			if (isHiddenSyncStage(event.stage)) return;
+			if (event.message) printer.info(event.message);
+		},
+		onStageEnd(event) {
+			if (isHiddenSyncStage(event.stage)) return;
+			const completionLine = formatStageCompletionLine(event.stage, event.snapshot, event.durationMs);
+			if (!completionLine) return;
+			printer.step(completionLine);
+		},
+		onComplete(event) {
+			printer.success(`Sync finished. ${event.summary.updatedIssues} issues and ${event.summary.updatedPulls} PRs updated${c.dim(` (${formatDuration(event.summary.durationMs)})`)}.`);
+		},
+		onError(event) {
+			const stage = event.stage && !isHiddenSyncStage(event.stage) ? ` while ${describeStage(event.stage)}` : "";
+			printer.error(c.red(`Sync failed${stage}: ${toErrorMessage(event.error)}`));
+		}
+	};
+}
+function createRichExecuteReporter(printer) {
+	let applyProgress = p.progress({ max: 1 });
+	let hasApplyProgress = false;
+	let lastCompleted = 0;
+	return {
+		onStart(event) {
+			const runMode = event.mode === "apply" ? "apply run" : "report mode";
+			printer.step(`Starting ${runMode} with ${countNoun(event.planned, "planned operation")}.`);
+			if (event.mode === "apply") {
+				hasApplyProgress = true;
+				applyProgress = p.progress({ max: Math.max(event.planned, 1) });
+				lastCompleted = 0;
+				applyProgress.start(`Completed 0 of ${countNoun(event.planned, "operation")}`);
+			}
+		},
+		onProgress(event) {
+			if (!hasApplyProgress) return;
+			const advanceBy = Math.max(0, event.completed - lastCompleted);
+			const message = `Completed ${event.completed} of ${countNoun(event.planned, "operation")} (${event.applied} applied, ${event.failed} failed). Latest: operation #${event.detail.op} ${event.detail.status}.`;
+			if (advanceBy > 0) applyProgress.advance(advanceBy, message);
+			else applyProgress.message(message);
+			lastCompleted = event.completed;
+		},
+		onComplete(event) {
+			if (hasApplyProgress) {
+				const advanceBy = Math.max(0, event.result.details.length - lastCompleted);
+				if (advanceBy > 0) applyProgress.advance(advanceBy);
+				applyProgress.stop(`Apply run finished (${event.result.applied} applied, ${event.result.failed} failed).`);
+				hasApplyProgress = false;
+			}
+			const runMode = event.result.mode === "apply" ? "Apply run" : "Report mode";
+			printer.success(`${runMode} finished. Planned ${event.result.planned}, applied ${event.result.applied}, failed ${event.result.failed}.`);
+		},
+		onError(event) {
+			const message = `Execution failed: ${toErrorMessage(event.error)}`;
+			if (hasApplyProgress) {
+				applyProgress.error(message);
+				hasApplyProgress = false;
+				return;
+			}
+			printer.error(c.red(message));
+		}
+	};
+}
+function createPlainExecuteReporter(printer) {
+	return {
+		onStart(event) {
+			const runMode = event.mode === "apply" ? "apply run" : "report mode";
+			printer.step(`Starting ${runMode} with ${countNoun(event.planned, "planned operation")}.`);
+		},
+		onProgress(event) {
+			printer.step(`Completed ${event.completed} of ${countNoun(event.planned, "operation")} (${event.applied} applied, ${event.failed} failed). Latest: operation #${event.detail.op} ${event.detail.status}.`);
+		},
+		onComplete(event) {
+			const runMode = event.result.mode === "apply" ? "Apply run" : "Report mode";
+			printer.success(`${runMode} finished. Planned ${event.result.planned}, applied ${event.result.applied}, failed ${event.result.failed}.`);
+		},
+		onError(event) {
+			printer.error(c.red(`Execution failed: ${toErrorMessage(event.error)}`));
+		}
+	};
+}
+function resolveMode(options) {
+	const isTTY = options.isTTY ?? Boolean(process.stdout.isTTY);
+	const isCI = options.isCI ?? Boolean(process.env.CI);
+	return isTTY && !isCI ? "rich" : "plain";
+}
+function formatSyncProgressLine(snapshot, message) {
+	const line = `Fetched ${snapshot.processed} of ${countNoun(snapshot.selected, "item")} (${snapshot.skipped} skipped, ${snapshot.written} written, ${snapshot.moved} moved, ${countNoun(snapshot.patchesWritten, "patch")} added, ${countNoun(snapshot.patchesDeleted, "patch")} removed)`;
+	if (!message) return line;
+	return `${line}. Current: ${message}`;
+}
+function formatStageCompletionLine(stage, snapshot, durationMs) {
+	if (!hasStageEffect(stage, snapshot)) return void 0;
+	const duration = c.dim(` (${formatDuration(durationMs)})`);
+	if (stage === "pagination") return `Pagination scanned ${countNoun(snapshot.scanned, "candidate item")}${duration}.`;
+	if (stage === "fetch") return `Fetched updated issues/PRs (${snapshot.processed}/${snapshot.selected})${duration}.`;
+}
+function toErrorMessage(error) {
+	return error.message || String(error);
+}
+function formatKeyValueLines(entries, options = {}) {
+	const { indent = 1, dimKey = true, excludeZero = false } = options;
+	const padding = " ".repeat(Math.max(0, indent));
+	const validEntries = entries.filter(([, value]) => {
+		if (value == null) return false;
+		if (excludeZero && value === 0) return false;
+		return true;
+	});
+	const keyWidth = Math.max(0, ...validEntries.map(([key]) => key.length));
+	return validEntries.map(([key, value]) => {
+		const displayKey = dimKey ? c.dim(key.padStart(keyWidth, " ")) : key.padStart(keyWidth, " ");
+		if (value == null) return void 0;
+		if (excludeZero && value === 0) return void 0;
+		return `${padding}${displayKey}  ${formatValue(value)}`;
+	}).filter((x) => x != null);
+}
+function hasStageEffect(stage, snapshot) {
+	if (isHiddenSyncStage(stage)) return false;
+	if (stage === "pagination") return snapshot.scanned > 0;
+	if (stage === "fetch") return snapshot.processed > 0;
+	return true;
+}
+function isHiddenSyncStage(stage) {
+	return stage !== "pagination" && stage !== "fetch";
+}
+function describeStage(stage) {
+	if (stage === "pagination") return "running pagination";
+	if (stage === "fetch") return "fetching updated issues and pull requests";
+	if (stage === "metadata") return "fetching repository metadata";
+	if (stage === "materialize") return "materializing local files";
+	if (stage === "prune") return "pruning local artifacts";
+	return "saving sync state";
+}
+
+//#endregion
+//#region src/cli/prompts.ts
+async function promptForToken() {
+	const result = await password({
+		message: "Enter a GitHub token (PAT) for ghfs:",
+		validate: (value) => value?.trim().length ? void 0 : "Token is required"
+	});
+	if (isCancel(result)) {
+		cancel("Token prompt cancelled");
+		return;
+	}
+	return result.trim();
+}
+async function promptRepoChoice(gitCandidate, pkgCandidate) {
+	const result = await select({
+		message: "Detected conflicting GitHub repositories. Which one should ghfs use?",
+		options: [{
+			label: `${gitCandidate.repo} (${gitCandidate.detail})`,
+			value: gitCandidate.repo
+		}, {
+			label: `${pkgCandidate.repo} (${pkgCandidate.detail})`,
+			value: pkgCandidate.repo
+		}],
+		initialValue: gitCandidate.repo
+	});
+	if (isCancel(result)) {
+		cancel("Repository selection cancelled");
+		return;
+	}
+	return result;
+}
+function createExecutePrompts(options = {}) {
+	return {
+		selectOperations: (ops) => promptExecuteOperations(ops, options),
+		confirmApply: confirmExecuteApply
+	};
+}
+async function promptExecuteOperations(ops, options) {
+	const selectedByDefault = ops.map((_, index) => index);
+	const result = await multiselect({
+		message: "Select operations to include",
+		options: ops.map((op, index) => ({
+			label: describeCliOperation(op, {
+				tty: true,
+				repo: options.repo
+			}),
+			value: index
+		})),
+		initialValues: selectedByDefault,
+		required: false
+	});
+	if (isCancel(result)) {
+		cancel("Operation selection cancelled");
+		return;
+	}
+	return [...result];
+}
+async function confirmExecuteApply(count) {
+	const result = await confirm({
+		message: `Run ${count} ${count === 1 ? "operation" : "operations"} on GitHub?`,
+		initialValue: false
+	});
+	if (isCancel(result)) {
+		cancel("Execution cancelled");
+		return;
+	}
+	return result;
+}
+
+//#endregion
+//#region src/cli/commands/execute.ts
+const PLAN_PREVIEW_LIMIT = 20;
+const defaultDependencies = {
+	createCliPrinter,
+	resolveConfig,
+	isTTY: () => Boolean(process.stdin.isTTY),
+	resolveRepo,
+	resolveAuthToken,
+	executePendingChanges,
+	appendExecutionResult,
+	syncRepository,
+	createExecutePrompts,
+	promptForToken,
+	promptRepoChoice
+};
+function registerExecuteCommand(cli) {
+	cli.command("execute", "Execute operations from .ghfs/execute.yml").option("--repo <repo>", "GitHub repository in owner/name format").option("--file <file>", "Path to execute yaml file").option("--run", "Run mutations on GitHub").option("--non-interactive", "Disable interactive prompts").option("--continue-on-error", "Continue applying ops after a failure").action(withErrorHandling(async (options) => runExecuteCommand(options)));
+}
+async function runExecuteCommand(options, dependencies = defaultDependencies) {
+	const printer = dependencies.createCliPrinter("execute");
+	const config = await dependencies.resolveConfig();
+	const storageDirAbsolute = getStorageDirAbsolute(config);
+	const interactive = dependencies.isTTY() && !options.nonInteractive;
+	const runMutations = Boolean(options.run);
+	let resolvedRepo;
+	let repoForRun = options.repo?.trim() || config.repo;
+	let tokenForRun = "";
+	if (runMutations) {
+		resolvedRepo = await dependencies.resolveRepo({
+			cwd: config.cwd,
+			cliRepo: options.repo,
+			configRepo: config.repo,
+			interactive,
+			selectRepoChoice: dependencies.promptRepoChoice
+		});
+		repoForRun = resolvedRepo.repo;
+		printer.header(resolvedRepo.repo);
+		tokenForRun = await dependencies.resolveAuthToken({
+			token: config.auth.token,
+			interactive,
+			promptForToken: dependencies.promptForToken
+		});
+	} else if (repoForRun) printer.header(repoForRun);
+	const prompts = dependencies.createExecutePrompts({ repo: repoForRun || void 0 });
+	const executeFilePath = resolve(config.cwd, options.file ?? getExecuteFile(config));
+	let result;
+	try {
+		result = await dependencies.executePendingChanges({
+			config,
+			repo: repoForRun || "(repo not resolved)",
+			token: tokenForRun,
+			executeFilePath,
+			apply: runMutations,
+			nonInteractive: Boolean(options.nonInteractive),
+			continueOnError: Boolean(options.continueOnError),
+			onPlan: runMutations ? void 0 : (ops) => printExecutionPlan(printer, ops, repoForRun || void 0),
+			onWarning: (warning) => printer.warn(warning),
+			prompts
+		});
+	} catch (error) {
+		if (isExecuteCancelledError(error)) {
+			printer.info("Execution cancelled.");
+			return;
+		}
+		throw error;
+	}
+	if (!runMutations) {
+		if (interactive && result.planned > 0) {
+			if (await prompts.confirmApply(result.planned)) {
+				resolvedRepo = await dependencies.resolveRepo({
+					cwd: config.cwd,
+					cliRepo: options.repo,
+					configRepo: config.repo,
+					interactive,
+					selectRepoChoice: dependencies.promptRepoChoice
+				});
+				repoForRun = resolvedRepo.repo;
+				tokenForRun = await dependencies.resolveAuthToken({
+					token: config.auth.token,
+					interactive,
+					promptForToken: dependencies.promptForToken
+				});
+				const selectedIndexes = result.details.filter((detail) => detail.status === "planned").map((detail) => detail.op - 1).filter((index) => index >= 0);
+				try {
+					result = await dependencies.executePendingChanges({
+						config,
+						repo: repoForRun,
+						token: tokenForRun,
+						executeFilePath,
+						apply: true,
+						selectedIndexes,
+						nonInteractive: true,
+						continueOnError: Boolean(options.continueOnError),
+						onWarning: (warning) => printer.warn(warning),
+						prompts
+					});
+				} catch (error) {
+					if (isExecuteCancelledError(error)) {
+						printer.info("Execution cancelled.");
+						return;
+					}
+					throw error;
+				}
+				await dependencies.appendExecutionResult(storageDirAbsolute, result);
+				printFailedOperations(printer, result, resolvedRepo.repo);
+				const affectedNumbers = [...new Set(result.details.filter((detail) => detail.status === "applied").map((detail) => detail.number))];
+				if (affectedNumbers.length > 0) printPostRunSyncSummary(printer, await dependencies.syncRepository({
+					config,
+					repo: resolvedRepo.repo,
+					token: tokenForRun,
+					numbers: affectedNumbers,
+					reporter: printer.createSyncReporter()
+				}));
+				printExecutionSummary(printer, result);
+				if (result.failed > 0) process.exitCode = 1;
+				return;
+			}
+		}
+		printReportSummary(printer, result);
+		return;
+	}
+	await dependencies.appendExecutionResult(storageDirAbsolute, result);
+	printFailedOperations(printer, result, resolvedRepo?.repo || repoForRun || void 0);
+	const affectedNumbers = [...new Set(result.details.filter((detail) => detail.status === "applied").map((detail) => detail.number))];
+	if (affectedNumbers.length > 0) printPostRunSyncSummary(printer, await dependencies.syncRepository({
+		config,
+		repo: resolvedRepo?.repo || repoForRun || "",
+		token: tokenForRun,
+		numbers: affectedNumbers,
+		reporter: printer.createSyncReporter()
+	}));
+	printExecutionSummary(printer, result);
+	if (result.failed > 0) process.exitCode = 1;
+}
+function printExecutionPlan(printer, ops, repo) {
+	const colorize = printer.mode === "rich";
+	if (ops.length === 0) {
+		printer.info("No operations planned.");
+		return;
+	}
+	printer.info(`Planned ${countNoun(ops.length, "operation")}.`);
+	const previewEntries = ops.slice(0, PLAN_PREVIEW_LIMIT).map((op, index) => [`#${index + 1}`, describeCliOperation(op, {
+		tty: colorize,
+		repo
+	})]);
+	printer.table("Planned operations", previewEntries, { dimKey: false });
+	const remaining = ops.length - PLAN_PREVIEW_LIMIT;
+	if (remaining > 0) printer.info(`...and ${countNoun(remaining, "more operation")}.`);
+}
+function printReportSummary(printer, result) {
+	printer.success(`${countNoun(result.planned, "operation")} found.`);
+	if (result.planned > 0) printer.info("Run `ghfs execute --run` to execute these operations.");
+}
+function printFailedOperations(printer, result, repo) {
+	const colorize = printer.mode === "rich";
+	const failed = result.details.filter((detail) => detail.status === "failed");
+	if (failed.length === 0) return;
+	printer.warn(`${countNoun(failed.length, "operation")} failed:`);
+	printer.print(failed.map((detail) => `${detail.op}. ${describeCliOperation(detail, {
+		tty: colorize,
+		repo
+	})}: ${detail.message}`));
+}
+function printPostRunSyncSummary(printer, summary) {
+	const refreshed = summary.updatedIssues + summary.updatedPulls;
+	printer.info(`Post-run sync refreshed ${countNoun(refreshed, "item")} in ${formatDuration(summary.durationMs)} (${summary.requestCount} requests).`);
+}
+function printExecutionSummary(printer, result) {
+	const summary = `Execution summary: planned ${result.planned}, applied ${result.applied}, failed ${result.failed}.`;
+	if (result.failed > 0) {
+		printer.warn(summary);
+		return;
+	}
+	printer.success(summary);
+}
+
+//#endregion
+//#region src/sync/status.ts
+async function getStatusSummary(config) {
+	const syncState = await loadSyncState(resolve(config.cwd, config.directory));
+	const items = Object.values(syncState.items);
+	const openCount = items.filter((item) => item.state === "open").length;
+	const closedCount = items.filter((item) => item.state === "closed").length;
+	const lastExecution = syncState.executions[0];
+	const lastSyncRun = syncState.lastSyncRun;
+	return {
+		repo: syncState.repo,
+		lastSyncedAt: syncState.lastSyncedAt,
+		totalTracked: items.length,
+		openCount,
+		closedCount,
+		executionRuns: syncState.executions.length,
+		lastSyncRun: lastSyncRun ? {
+			runId: lastSyncRun.runId,
+			startedAt: lastSyncRun.startedAt,
+			finishedAt: lastSyncRun.finishedAt,
+			durationMs: lastSyncRun.durationMs,
+			requestCount: lastSyncRun.requestCount,
+			since: lastSyncRun.since,
+			numbersCount: lastSyncRun.numbersCount,
+			counters: {
+				scanned: lastSyncRun.counters.scanned,
+				selected: lastSyncRun.counters.selected,
+				processed: lastSyncRun.counters.processed,
+				skipped: lastSyncRun.counters.skipped,
+				written: lastSyncRun.counters.written,
+				moved: lastSyncRun.counters.moved,
+				patchesWritten: lastSyncRun.counters.patchesWritten,
+				patchesDeleted: lastSyncRun.counters.patchesDeleted
+			},
+			stages: {
+				metadata: lastSyncRun.stages.metadata,
+				pagination: lastSyncRun.stages.pagination,
+				fetch: lastSyncRun.stages.fetch,
+				materialize: lastSyncRun.stages.materialize,
+				prune: lastSyncRun.stages.prune,
+				save: lastSyncRun.stages.save
+			}
+		} : void 0,
+		lastExecution: lastExecution ? {
+			runId: lastExecution.runId,
+			createdAt: lastExecution.createdAt,
+			mode: lastExecution.mode,
+			planned: lastExecution.planned,
+			applied: lastExecution.applied,
+			failed: lastExecution.failed
+		} : void 0
+	};
+}
+
+//#endregion
+//#region src/cli/commands/status.ts
+function registerStatusCommand(cli) {
+	cli.command("status", "Show local sync status").action(withErrorHandling(async () => {
+		const printer = createCliPrinter("status");
+		printer.start("Reading local sync state");
+		const summary = await getStatusSummary(await resolveConfig());
+		printer.table("Status", [
+			["repo", summary.repo ?? "(not resolved yet)"],
+			["last sync", summary.lastSyncedAt],
+			["tracked items", summary.totalTracked],
+			["open items", summary.openCount],
+			["closed items", summary.closedCount],
+			["execution runs", summary.executionRuns]
+		], { excludeZero: true });
+		printer.done("");
+	}));
+}
+
+//#endregion
+//#region src/cli/summary.ts
+function printSyncSummaryTable(printer, summary, title) {
+	printer.table(title, [
+		["total issues count", summary.totalIssues],
+		["total prs count", summary.totalPulls],
+		["issues updated", summary.updatedIssues],
+		["prs updated", summary.updatedPulls],
+		["local tracked issues", summary.trackedItems],
+		["github requests", summary.requestCount],
+		["duration", formatDuration(summary.durationMs)]
+	]);
+}
+
+//#endregion
+//#region src/cli/commands/sync.ts
+function registerSyncCommand(cli) {
+	setupSyncCommand(cli.command("sync", "Sync issues and pull requests to local mirror"));
+	setupSyncCommand(cli.command("", "Sync issues and pull requests to local mirror"));
+}
+function setupSyncCommand(command) {
+	command.option("--repo <repo>", "GitHub repository in owner/name format").option("--since <iso>", "Only sync records updated since ISO datetime").option("--full", "Full sync ignoring previous cursor").action(withErrorHandling(async (options) => {
+		const printer = createCliPrinter("sync");
+		const config = await resolveConfig();
+		await ensureExecuteArtifacts(resolve(config.cwd, getExecuteFile(config)));
+		const repo = await resolveRepo({
+			cwd: config.cwd,
+			cliRepo: options.repo,
+			configRepo: config.repo,
+			interactive: process.stdin.isTTY,
+			selectRepoChoice: promptRepoChoice
+		});
+		printer.header(repo.repo);
+		const token = await resolveAuthToken({
+			token: config.auth.token,
+			interactive: process.stdin.isTTY,
+			promptForToken
+		});
+		printSyncSummaryTable(printer, await syncRepository({
+			config,
+			repo: repo.repo,
+			token,
+			since: options.since,
+			full: Boolean(options.full),
+			reporter: printer.createSyncReporter()
+		}), "Summary");
+		printer.done("Sync finished");
+	}));
+}
+
+//#endregion
+//#region src/cli/index.ts
+function createCli() {
+	const cli = cac(CLI_NAME);
+	registerSyncCommand(cli);
+	registerExecuteCommand(cli);
+	registerStatusCommand(cli);
+	cli.help();
+	cli.version(CLI_VERSION);
+	return cli;
+}
+function runCli(argv = process.argv) {
+	createCli().parse(argv);
+}
+
+//#endregion
+//#region src/cli.ts
+runCli();
+
+//#endregion
+export {  };