@ghfs/cli 0.0.4 → 0.1.1

package/dist/cli.mjs

@@ -1,23 +1,15 @@
 #!/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-DYHQBeCz.mjs";
+import { c as CodedError, i as formatDuration, o as formatTerminalLink$1, r as countNoun, s as formatValue, u as log } from "./factory-DmX3S7tf.mjs";
+import { a as executePendingChanges, c as GHFS_NAME, d as ACTIONS_COLOR_HEX, f as pathExists, h as resolveConfig, i as appendExecutionResult, l as GHFS_VERSION, m as getStorageDirAbsolute, n as slugifyRepoName, o as isExecuteCancelledError, p as getExecuteFile, r as syncRepository, s as loadSyncState, t as createUiServer, u as ensureExecuteArtifacts } from "./server-BwSU4kqr.mjs";
 import process from "node:process";
 import { cac } from "cac";
-import { basename, dirname, extname, isAbsolute, join, normalize, resolve } from "pathe";
+import { 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, stat, writeFile } from "node:fs/promises";
-import * as v from "valibot";
-import { parse, stringify } from "yaml";
-import { randomBytes } from "node:crypto";
+import { readFile } from "node:fs/promises";
 import c from "ansis";
 import * as p from "@clack/prompts";
 import { cancel, confirm, isCancel, multiselect, password, select } from "@clack/prompts";
-import { createServer } from "node:http";
-import { createBirpcGroup } from "birpc";
-import { parse as parse$1, stringify as stringify$1 } from "structured-clone-es";
-import { WebSocketServer } from "ws";
 //#region src/config/auth.ts
 const execFileAsync$1 = promisify(execFile);
 async function resolveAuthToken(options) {
@@ -27,11 +19,11 @@ async function resolveAuthToken(options) {
 	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.");
+	if (!options.interactive || !process.stdin.isTTY) throw new CodedError(log.GHFS0001());
+	if (!options.promptForToken) throw new CodedError(log.GHFS0001());
 	const promptedToken = await options.promptForToken();
 	if (promptedToken?.trim()) return promptedToken.trim();
-	throw new Error("Token prompt cancelled");
+	throw new CodedError(log.GHFS0002());
 }
 async function readTokenFromGhCli() {
 	try {
@@ -48,143 +40,12 @@ async function readTokenFromEnv() {
 	}
 }
 //#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 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 ?? ".ghfs";
-	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}`);
+		if (!repo) throw new CodedError(log.GHFS0010({ value: options.cliRepo }));
 		return {
 			repo,
 			source: "cli",
@@ -193,7 +54,7 @@ async function resolveRepo(options) {
 	}
 	if (options.configRepo) {
 		const repo = normalizeRepo(options.configRepo);
-		if (!repo) throw new Error(`Invalid repo in ghfs.config.ts: ${options.configRepo}`);
+		if (!repo) throw new CodedError(log.GHFS0011({ value: options.configRepo }));
 		return {
 			repo,
 			source: "config",
@@ -208,16 +69,19 @@ async function resolveRepo(options) {
 	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");
+			if (!repo) throw new CodedError(log.GHFS0012());
 			const normalizedRepo = normalizeRepo(repo);
-			if (!normalizedRepo || normalizedRepo !== gitCandidate.repo && normalizedRepo !== pkgCandidate.repo) throw new Error(`Invalid repository selection: ${repo}`);
+			if (!normalizedRepo || normalizedRepo !== gitCandidate.repo && normalizedRepo !== pkgCandidate.repo) throw new CodedError(log.GHFS0013({ value: 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.`);
+		throw new CodedError(log.GHFS0014({
+			gitRepo: gitCandidate.repo,
+			pkgRepo: pkgCandidate.repo
+		}));
 	}
 	if (gitCandidate) return {
 		repo: gitCandidate.repo,
@@ -229,7 +93,7 @@ async function resolveRepo(options) {
 		source: "package-json",
 		candidates
 	};
-	throw new Error("Could not resolve repository. Provide --repo or set repo in ghfs.config.ts.");
+	throw new CodedError(log.GHFS0015());
 }
 function normalizeRepo(input) {
 	const trimmed = input.trim();
@@ -258,2290 +122,63 @@ async function detectRepoFromGit(cwd) {
 		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`, examples:",
-	"#",
-	"# - action: close",
-	"#   number: 123",
-	""
-].join("\n");
-const EXECUTE_MD_FILE_PLACEHOLDER = [
-	"<!-- Add one action per line, then run: `ghfs execute`, examples: -->",
-	"",
-	"<!-- 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.4";
-//#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/diff.ts
-function computeExecuteDiffOps(options) {
-	const ops = [];
-	const ifUnchangedSince = options.ifUnchangedSince;
-	const current = normalizeDiffFields(options.current);
-	const desired = normalizeDiffFields(options.desired);
-	if (current.title !== desired.title) ops.push({
-		action: "set-title",
-		number: options.number,
-		title: desired.title,
-		ifUnchangedSince
-	});
-	if (options.includeBody && current.body !== desired.body && desired.body) ops.push({
-		action: "set-body",
-		number: options.number,
-		body: desired.body,
-		ifUnchangedSince
-	});
-	if (current.state !== desired.state) ops.push({
-		action: desired.state === "closed" ? "close" : "reopen",
-		number: options.number,
-		ifUnchangedSince
-	});
-	if (!sameStringSet(current.labels, desired.labels)) {
-		const additions = diffStrings(desired.labels, current.labels);
-		const deletions = diffStrings(current.labels, desired.labels);
-		if (additions.length > 0 && deletions.length > 0) ops.push({
-			action: "set-labels",
-			number: options.number,
-			labels: desired.labels,
-			ifUnchangedSince
-		});
-		else if (additions.length > 0) ops.push({
-			action: "add-labels",
-			number: options.number,
-			labels: additions,
-			ifUnchangedSince
-		});
-		else if (deletions.length > 0) ops.push({
-			action: "remove-labels",
-			number: options.number,
-			labels: deletions,
-			ifUnchangedSince
-		});
-	}
-	if (!sameStringSet(current.assignees, desired.assignees)) {
-		if (desired.assignees.length > 0) ops.push({
-			action: "set-assignees",
-			number: options.number,
-			assignees: desired.assignees,
-			ifUnchangedSince
-		});
-		else if (current.assignees.length > 0) ops.push({
-			action: "remove-assignees",
-			number: options.number,
-			assignees: current.assignees,
-			ifUnchangedSince
-		});
-	}
-	if (current.milestone !== desired.milestone) if (desired.milestone) ops.push({
-		action: "set-milestone",
-		number: options.number,
-		milestone: desired.milestone,
-		ifUnchangedSince
-	});
-	else ops.push({
-		action: "clear-milestone",
-		number: options.number,
-		ifUnchangedSince
-	});
-	if (!sameStringSet(current.reviewers, desired.reviewers)) {
-		const additions = diffStrings(desired.reviewers, current.reviewers);
-		const deletions = diffStrings(current.reviewers, desired.reviewers);
-		if (additions.length > 0) ops.push({
-			action: "request-reviewers",
-			number: options.number,
-			reviewers: additions,
-			ifUnchangedSince
-		});
-		if (deletions.length > 0) ops.push({
-			action: "remove-reviewers",
-			number: options.number,
-			reviewers: deletions,
-			ifUnchangedSince
-		});
-	}
-	if (typeof current.isDraft === "boolean" && typeof desired.isDraft === "boolean" && current.isDraft !== desired.isDraft) ops.push({
-		action: desired.isDraft ? "convert-to-draft" : "mark-ready-for-review",
-		number: options.number,
-		ifUnchangedSince
-	});
-	return ops;
-}
-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 normalizeMilestone(value) {
-	if (typeof value !== "string") return null;
-	const normalized = value.trim();
-	return normalized.length > 0 ? normalized : null;
-}
-function normalizeBody(value) {
-	if (value == null) return null;
-	const trimmed = value.trim();
-	return trimmed.length > 0 ? trimmed : null;
-}
-function normalizeDiffFields(fields) {
-	return {
-		...fields,
-		title: fields.title.trim(),
-		body: normalizeBody(fields.body),
-		labels: normalizeStringArray(fields.labels),
-		assignees: normalizeStringArray(fields.assignees),
-		milestone: normalizeMilestone(fields.milestone),
-		reviewers: normalizeStringArray(fields.reviewers),
-		isDraft: Boolean(fields.isDraft)
-	};
-}
-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 diffStrings(source, target) {
-	const targetSet = new Set(target);
-	return source.filter((value) => !targetSet.has(value));
-}
-//#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) {
-	return computeExecuteDiffOps({
-		number: input.number,
-		current: {
-			...input.current,
-			body: null,
-			reviewers: []
-		},
-		desired: {
-			...input.desired,
-			body: null,
-			reviewers: []
-		},
-		ifUnchangedSince: input.updatedAt
-	});
-}
-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)
-	};
-}
-//#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 entries = mergedOps.map((op, mergedIndex) => {
-		if (mergedIndex < ymlOps.length) return {
-			op,
-			source: "execute.yml",
-			sourceIndex: mergedIndex,
-			mergedIndex
-		};
-		const mdOffset = mergedIndex - ymlOps.length;
-		if (mdOffset < executeMd.ops.length) return {
-			op,
-			source: "execute.md",
-			sourceIndex: mdOffset,
-			mergedIndex
-		};
-		return {
-			op,
-			source: "per-item",
-			sourceIndex: mdOffset - executeMd.ops.length,
-			mergedIndex
-		};
-	});
-	const customErrors = validateExecuteRules(mergedOps);
-	if (customErrors.length) throw new Error(`Invalid execute file: ${customErrors.join("; ")}`);
-	return {
-		ops: mergedOps,
-		entries,
-		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 && index < mdOffset + executeMd.ops.length) 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;
+	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;
 	}
-	return moved;
 }
-async function listOpenMarkdownFiles(kindDirAbsolute) {
+async function detectRepoFromPackageJson(cwd) {
+	const path = `${cwd}/package.json`;
+	if (!await pathExists(path)) return void 0;
+	let parsed;
 	try {
-		return (await readdir(kindDirAbsolute, {
-			withFileTypes: true,
-			encoding: "utf8"
-		})).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => join(kindDirAbsolute, entry.name));
+		parsed = JSON.parse(await readFile(path, "utf8"));
 	} 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;
+		return;
 	}
-	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}) |`);
+	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"
+		};
 	}
-	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
+	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"
 			};
-			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 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 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
-	};
+function stripGitSuffix(name) {
+	return name.replace(/\.git$/, "");
 }
 //#endregion
 //#region src/cli/action-color.ts
@@ -2601,7 +238,12 @@ function wrapTextValue(value) {
 function withErrorHandling(fn) {
 	return (...args) => {
 		fn(...args).catch((error) => {
-			console.error(error);
+			if (error instanceof CodedError) {
+				const d = error.diagnostic;
+				console.error(c.red(`[${d.code}] ${d.message}`));
+				if (d.fix) console.error(c.dim(`  fix: ${d.fix}`));
+				if (d.docs) console.error(c.dim(`  see: ${d.docs}`));
+			} else console.error(error);
 			process.exit(1);
 		});
 	};
@@ -2743,7 +385,7 @@ function createRichSyncReporter(printer) {
 			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$2(event.error)}`;
+			const message = `Sync failed${event.stage && !isHiddenSyncStage(event.stage) ? ` while ${describeStage(event.stage)}` : ""}: ${toErrorMessage(event.error)}`;
 			if (hasSyncProgress) {
 				syncProgress.error(message);
 				hasSyncProgress = false;
@@ -2783,7 +425,7 @@ function createPlainSyncReporter(printer, progressEvery) {
 		},
 		onError(event) {
 			const stage = event.stage && !isHiddenSyncStage(event.stage) ? ` while ${describeStage(event.stage)}` : "";
-			printer.error(c.red(`Sync failed${stage}: ${toErrorMessage$2(event.error)}`));
+			printer.error(c.red(`Sync failed${stage}: ${toErrorMessage(event.error)}`));
 		}
 	};
 }
@@ -2821,7 +463,7 @@ function createRichExecuteReporter(printer) {
 			printer.success(`${runMode} finished. Planned ${event.result.planned}, applied ${event.result.applied}, failed ${event.result.failed}.`);
 		},
 		onError(event) {
-			const message = `Execution failed: ${toErrorMessage$2(event.error)}`;
+			const message = `Execution failed: ${toErrorMessage(event.error)}`;
 			if (hasApplyProgress) {
 				applyProgress.error(message);
 				hasApplyProgress = false;
@@ -2845,7 +487,7 @@ function createPlainExecuteReporter(printer) {
 			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$2(event.error)}`));
+			printer.error(c.red(`Execution failed: ${toErrorMessage(event.error)}`));
 		}
 	};
 }
@@ -2865,7 +507,7 @@ function formatStageCompletionLine(stage, snapshot, 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$2(error) {
+function toErrorMessage(error) {
 	return error.message || String(error);
 }
 function formatKeyValueLines(entries, options = {}) {
@@ -2972,7 +614,7 @@ async function confirmExecuteApply(count) {
 //#endregion
 //#region src/cli/commands/execute.ts
 const PLAN_PREVIEW_LIMIT = 20;
-const defaultDependencies$1 = {
+const defaultDependencies = {
 	createCliPrinter,
 	resolveConfig,
 	isTTY: () => Boolean(process.stdin.isTTY),
@@ -2988,7 +630,7 @@ const defaultDependencies$1 = {
 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$1) {
+async function runExecuteCommand(options, dependencies = defaultDependencies) {
 	const printer = dependencies.createCliPrinter("execute");
 	const config = await dependencies.resolveConfig();
 	const storageDirAbsolute = getStorageDirAbsolute(config);
@@ -3265,645 +907,67 @@ function setupSyncCommand(command) {
 	}));
 }
 //#endregion
-//#region src/cli/ui/server.ts
-const MIME_TYPES = {
-	".css": "text/css; charset=utf-8",
-	".html": "text/html; charset=utf-8",
-	".ico": "image/x-icon",
-	".js": "text/javascript; charset=utf-8",
-	".json": "application/json; charset=utf-8",
-	".map": "application/json; charset=utf-8",
-	".png": "image/png",
-	".svg": "image/svg+xml",
-	".txt": "text/plain; charset=utf-8",
-	".woff": "font/woff",
-	".woff2": "font/woff2"
-};
-async function createUiServer(options) {
-	const uiRoot = resolve(options.uiDir);
-	const uiRootPrefix = `${uiRoot}/`;
-	const indexPath = resolve(uiRoot, "index.html");
-	await assertFile(indexPath);
-	const server = createServer(async (req, res) => {
-		try {
-			const pathname = normalizeRequestPath(req.url || "/");
-			if (pathname === "/api/metadata.json") {
-				const body = `${JSON.stringify(options.getMetadata())}\n`;
-				res.statusCode = 200;
-				res.setHeader("Content-Type", "application/json; charset=utf-8");
-				res.end(body);
-				return;
-			}
-			const filePath = resolve(uiRoot, `.${pathname === "/" ? "/index.html" : pathname}`);
-			const resolvedFilePath = (filePath === uiRoot || filePath.startsWith(uiRootPrefix)) && await isFile(filePath) ? filePath : indexPath;
-			const body = await readFile(resolvedFilePath);
-			res.statusCode = 200;
-			res.setHeader("Content-Type", mimeTypeFor(resolvedFilePath));
-			res.end(body);
-		} catch (error) {
-			res.statusCode = 500;
-			res.setHeader("Content-Type", "text/plain; charset=utf-8");
-			res.end(`Internal Server Error: ${toErrorMessage$1(error)}`);
-		}
-	});
-	await new Promise((resolvePromise, reject) => {
-		server.once("error", reject);
-		server.listen(options.port, options.host, () => {
-			resolvePromise();
-		});
-	});
-	const address = server.address();
-	if (!address || typeof address === "string") throw new Error("Failed to start UI HTTP server");
-	return {
-		server,
-		close: () => {
-			return new Promise((resolvePromise, reject) => {
-				server.close((error) => {
-					if (error) {
-						reject(error);
-						return;
-					}
-					resolvePromise();
-				});
-			});
-		},
-		url: `http://${address.address === "127.0.0.1" ? "localhost" : address.address}:${address.port}`
-	};
-}
-function normalizeRequestPath(raw) {
-	const pathOnly = raw.split("?")[0].split("#")[0] || "/";
-	let decodedPath = pathOnly;
-	try {
-		decodedPath = decodeURIComponent(pathOnly);
-	} catch {
-		decodedPath = pathOnly;
-	}
-	const normalized = normalize(decodedPath);
-	return normalized.startsWith("/") ? normalized : `/${normalized}`;
-}
-async function assertFile(path) {
-	if (!await isFile(path)) throw new Error(`UI assets not found at ${path}`);
-}
-async function isFile(path) {
-	try {
-		return (await stat(path)).isFile();
-	} catch {
-		return false;
-	}
-}
-function mimeTypeFor(path) {
-	return MIME_TYPES[extname(path)] ?? "application/octet-stream";
-}
-function toErrorMessage$1(error) {
-	if (error instanceof Error) return error.message;
-	return String(error);
-}
-//#endregion
-//#region src/cli/ui/rpc.ts
-const REPLACEABLE_FAMILIES = new Set([
-	"title",
-	"body",
-	"state",
-	"labels",
-	"assignees",
-	"milestone",
-	"reviewers",
-	"draft"
-]);
-function createServerFunctions(options) {
-	const resolveRepoFn = options.resolveRepo ?? resolveRepo;
-	const resolveAuthTokenFn = options.resolveAuthToken ?? resolveAuthToken;
-	const executePendingChangesFn = options.executePendingChanges ?? executePendingChanges;
-	const appendExecutionResultFn = options.appendExecutionResult ?? appendExecutionResult;
-	const syncRepositoryFn = options.syncRepository ?? syncRepository;
-	const loadExecuteSourcesFn = options.loadExecuteSources ?? loadExecuteSources;
-	let executing = false;
-	async function getBootstrap() {
-		const syncState = await loadSyncState(options.storageDirAbsolute);
-		const loaded = await loadExecuteSourcesFn(options.executeFilePath);
-		const items = Object.values(syncState.items).map((entry) => {
-			const item = entry.data.item;
-			return {
-				number: entry.number,
-				kind: entry.kind,
-				state: entry.state,
-				title: item.title,
-				updatedAt: item.updatedAt,
-				createdAt: item.createdAt,
-				closedAt: item.closedAt,
-				author: item.author,
-				url: item.url,
-				labels: item.labels,
-				assignees: item.assignees,
-				milestone: item.milestone,
-				commentsCount: entry.data.comments.length,
-				isDraft: entry.data.pull?.isDraft,
-				merged: entry.data.pull?.merged,
-				requestedReviewers: entry.data.pull?.requestedReviewers ?? []
-			};
-		}).sort((left, right) => right.number - left.number);
-		const queue = toQueueEntries(loaded.entries, syncState.repo);
-		const openCount = items.filter((item) => item.state === "open").length;
-		return {
-			repo: syncState.repo,
-			syncedAt: syncState.lastSyncedAt,
-			lastSyncRunAt: syncState.lastSyncRun?.finishedAt,
-			totalTracked: items.length,
-			openCount,
-			closedCount: items.length - openCount,
-			warnings: loaded.warnings,
-			items,
-			queue,
-			queueSummary: {
-				total: queue.length,
-				executeYml: queue.filter((entry) => entry.source === "execute.yml").length,
-				executeMd: queue.filter((entry) => entry.source === "execute.md").length,
-				perItem: queue.filter((entry) => entry.source === "per-item").length
-			}
-		};
-	}
-	async function getItemDetail(number) {
-		const [syncState, repoSnapshot, loaded, yml] = await Promise.all([
-			loadSyncState(options.storageDirAbsolute),
-			readRepoSnapshot(options.storageDirAbsolute),
-			loadExecuteSourcesFn(options.executeFilePath),
-			readAndValidateExecuteFileWithSource(options.executeFilePath)
-		]);
-		const tracked = syncState.items[String(number)];
-		if (!tracked) throw new Error(`Item #${number} is not available in local mirror`);
-		const queue = toQueueEntries(loaded.entries, syncState.repo).filter((entry) => entry.op.number === number);
-		const effective = applyQueuedYmlOpsToItem(tracked, yml.ops.filter((op) => op.number === number));
-		return {
-			number: tracked.number,
-			kind: tracked.kind,
-			state: effective.state,
-			title: effective.title,
-			body: effective.body,
-			updatedAt: tracked.data.item.updatedAt,
-			createdAt: tracked.data.item.createdAt,
-			closedAt: tracked.data.item.closedAt,
-			author: tracked.data.item.author,
-			url: tracked.data.item.url,
-			labels: effective.labels,
-			assignees: effective.assignees,
-			milestone: effective.milestone,
-			commentsCount: tracked.data.comments.length,
-			comments: tracked.data.comments.map((comment) => ({
-				id: comment.id,
-				author: comment.author,
-				body: comment.body || "",
-				createdAt: comment.createdAt,
-				updatedAt: comment.updatedAt
-			})),
-			isDraft: effective.isDraft,
-			merged: tracked.data.pull?.merged,
-			requestedReviewers: effective.reviewers,
-			labelsCatalog: repoSnapshot?.labels ?? [],
-			milestonesCatalog: (repoSnapshot?.milestones ?? []).map((m) => ({
-				number: m.number,
-				title: m.title,
-				state: m.state
-			})),
-			queue
-		};
-	}
-	async function queueItemEdits(payload) {
-		const tracked = (await loadSyncState(options.storageDirAbsolute)).items[String(payload.number)];
-		if (!tracked) throw new Error(`Item #${payload.number} is not available in local mirror`);
-		const nextOps = toQueuedOps(tracked, payload);
-		const yml = await readAndValidateExecuteFileWithSource(options.executeFilePath);
-		const filteredOps = [];
-		for (const [index, op] of yml.ops.entries()) {
-			const family = getActionFamily(op.action);
-			if (op.number === payload.number && REPLACEABLE_FAMILIES.has(family)) continue;
-			filteredOps.push({
-				...op,
-				_actionInput: yml.sourceActions[index] ?? op.action
-			});
-		}
-		const writable = [...filteredOps.map(({ _actionInput, ...op }) => ({
-			...op,
-			action: _actionInput
-		})), ...nextOps.map((op) => ({
-			...op,
-			action: op.action
-		}))];
-		await writeExecuteFile(options.executeFilePath, writable);
-		return await notifyAndGetBootstrap(options.onStateChanged, getBootstrap);
-	}
-	async function removeQueueYmlEntry(index) {
-		const yml = await readAndValidateExecuteFileWithSource(options.executeFilePath);
-		if (!Number.isInteger(index) || index < 0 || index >= yml.ops.length) throw new Error(`Invalid execute.yml index: ${index}`);
-		const writable = yml.ops.map((op, opIndex) => ({
-			...op,
-			action: yml.sourceActions[opIndex] ?? op.action
-		})).filter((_, opIndex) => opIndex !== index);
-		await writeExecuteFile(options.executeFilePath, writable);
-		return await notifyAndGetBootstrap(options.onStateChanged, getBootstrap);
-	}
-	async function refresh() {
-		return await notifyAndGetBootstrap(options.onStateChanged, getBootstrap);
-	}
-	async function executeNow() {
-		if (executing) throw new Error("Execution is already in progress");
-		executing = true;
-		try {
-			const resolvedRepo = await resolveRepoFn({
-				cwd: options.config.cwd,
-				configRepo: options.config.repo,
-				interactive: false
-			});
-			const token = await resolveAuthTokenFn({
-				token: options.config.auth.token,
-				interactive: false
-			});
-			const result = await executePendingChangesFn({
-				config: options.config,
-				repo: resolvedRepo.repo,
-				token,
-				executeFilePath: options.executeFilePath,
-				apply: true,
-				nonInteractive: true,
-				continueOnError: false,
-				reporter: {
-					onStart: (event) => {
-						fireAndForget(options.onExecuteProgress, {
-							type: "start",
-							planned: event.planned,
-							repo: event.repo
-						});
-					},
-					onProgress: (event) => {
-						fireAndForget(options.onExecuteProgress, {
-							type: "progress",
-							repo: event.repo,
-							planned: event.planned,
-							completed: event.completed,
-							applied: event.applied,
-							failed: event.failed,
-							detail: event.detail
-						});
-					},
-					onError: (event) => {
-						fireAndForget(options.onExecuteProgress, {
-							type: "error",
-							message: toErrorMessage(event.error)
-						});
-					}
-				}
-			});
-			await appendExecutionResultFn(options.storageDirAbsolute, result);
-			const affectedNumbers = [...new Set(result.details.filter((detail) => detail.status === "applied").map((detail) => detail.number))];
-			if (affectedNumbers.length > 0) await syncRepositoryFn({
-				config: options.config,
-				repo: resolvedRepo.repo,
-				token,
-				numbers: affectedNumbers
-			});
-			await options.onExecuteComplete?.(result);
-			return {
-				result,
-				bootstrap: await notifyAndGetBootstrap(options.onStateChanged, getBootstrap)
-			};
-		} finally {
-			executing = false;
-		}
-	}
-	return {
-		getBootstrap,
-		getItemDetail,
-		queueItemEdits,
-		removeQueueYmlEntry,
-		refresh,
-		executeNow
-	};
-}
-function toQueueEntries(entries, repo) {
-	return entries.map((entry) => ({
-		id: `${entry.source}:${entry.sourceIndex}:${entry.mergedIndex}`,
-		mergedIndex: entry.mergedIndex,
-		source: entry.source,
-		sourceIndex: entry.sourceIndex,
-		editable: entry.source === "execute.yml",
-		op: entry.op,
-		description: describeCliOperation(entry.op, {
-			tty: false,
-			repo
-		})
-	}));
-}
-function toQueuedOps(tracked, payload) {
-	const current = tracked.data.item;
-	const reviewersCurrent = tracked.data.pull?.requestedReviewers ?? [];
-	const desiredLabels = normalizeStringArray(payload.labels);
-	const desiredAssignees = normalizeStringArray(payload.assignees);
-	const desiredReviewers = normalizeStringArray(payload.reviewers);
-	const desiredMilestone = normalizeMilestone(payload.milestone);
-	const desiredTitle = payload.title.trim() || current.title;
-	const desiredBody = payload.body.trim().length > 0 ? payload.body : current.body || "";
-	const desiredState = payload.state;
-	const desiredDraft = tracked.kind === "pull" ? Boolean(payload.isDraft) : tracked.data.pull?.isDraft;
-	const ops = computeExecuteDiffOps({
-		number: tracked.number,
-		current: {
-			title: current.title,
-			body: current.body,
-			state: current.state,
-			labels: current.labels,
-			assignees: current.assignees,
-			milestone: current.milestone,
-			reviewers: reviewersCurrent,
-			isDraft: tracked.data.pull?.isDraft
-		},
-		desired: {
-			title: desiredTitle,
-			body: desiredBody,
-			state: desiredState,
-			labels: desiredLabels,
-			assignees: desiredAssignees,
-			milestone: desiredMilestone,
-			reviewers: tracked.kind === "pull" ? desiredReviewers : reviewersCurrent,
-			isDraft: desiredDraft
-		},
-		ifUnchangedSince: current.updatedAt,
-		includeBody: true
-	});
-	const comment = payload.comment.trim();
-	if (comment) ops.push({
-		action: "add-comment",
-		number: tracked.number,
-		body: comment
-	});
-	return ops;
-}
-function applyQueuedYmlOpsToItem(tracked, ops) {
-	let title = tracked.data.item.title;
-	let body = tracked.data.item.body || "";
-	let state = tracked.data.item.state;
-	let labels = [...tracked.data.item.labels];
-	let assignees = [...tracked.data.item.assignees];
-	let milestone = tracked.data.item.milestone;
-	let reviewers = [...tracked.data.pull?.requestedReviewers ?? []];
-	let isDraft = tracked.data.pull?.isDraft;
-	for (const op of ops) switch (op.action) {
-		case "set-title":
-			title = op.title;
-			break;
-		case "set-body":
-			body = op.body;
-			break;
-		case "close":
-		case "close-with-comment":
-			state = "closed";
-			break;
-		case "reopen":
-			state = "open";
-			break;
-		case "add-labels":
-			labels = mergeStrings(labels, op.labels);
-			break;
-		case "remove-labels":
-			labels = removeStrings(labels, op.labels);
-			break;
-		case "set-labels":
-			labels = normalizeStringArray(op.labels);
-			break;
-		case "add-assignees":
-			assignees = mergeStrings(assignees, op.assignees);
-			break;
-		case "remove-assignees":
-			assignees = removeStrings(assignees, op.assignees);
-			break;
-		case "set-assignees":
-			assignees = normalizeStringArray(op.assignees);
-			break;
-		case "set-milestone":
-			milestone = String(op.milestone);
-			break;
-		case "clear-milestone":
-			milestone = null;
-			break;
-		case "request-reviewers":
-			reviewers = mergeStrings(reviewers, op.reviewers);
-			break;
-		case "remove-reviewers":
-			reviewers = removeStrings(reviewers, op.reviewers);
-			break;
-		case "convert-to-draft":
-			if (tracked.kind === "pull") isDraft = true;
-			break;
-		case "mark-ready-for-review":
-			if (tracked.kind === "pull") isDraft = false;
-			break;
-		default: break;
-	}
-	return {
-		title,
-		body,
-		state,
-		labels,
-		assignees,
-		milestone,
-		reviewers,
-		isDraft
-	};
-}
-async function notifyAndGetBootstrap(onStateChanged, getBootstrap) {
-	const bootstrap = await getBootstrap();
-	await onStateChanged?.(bootstrap);
-	return bootstrap;
-}
-function getActionFamily(action) {
-	switch (action) {
-		case "set-title": return "title";
-		case "set-body": return "body";
-		case "close":
-		case "reopen": return "state";
-		case "add-labels":
-		case "remove-labels":
-		case "set-labels": return "labels";
-		case "add-assignees":
-		case "remove-assignees":
-		case "set-assignees": return "assignees";
-		case "set-milestone":
-		case "clear-milestone": return "milestone";
-		case "request-reviewers":
-		case "remove-reviewers": return "reviewers";
-		case "mark-ready-for-review":
-		case "convert-to-draft": return "draft";
-		case "add-comment":
-		case "close-with-comment": return "comment";
-		default: return "other";
-	}
-}
-function mergeStrings(base, incoming) {
-	const known = new Set(base);
-	const merged = [...base];
-	for (const value of normalizeStringArray(incoming)) {
-		if (known.has(value)) continue;
-		known.add(value);
-		merged.push(value);
-	}
-	return merged;
-}
-function removeStrings(base, removing) {
-	const removingSet = new Set(normalizeStringArray(removing));
-	return base.filter((value) => !removingSet.has(value));
-}
-function fireAndForget(callback, payload) {
-	if (!callback) return;
-	Promise.resolve(callback(payload)).catch(() => {});
-}
-function toErrorMessage(error) {
-	if (error instanceof Error) return error.message;
-	return String(error);
-}
-async function readRepoSnapshot(storageDirAbsolute) {
-	const path = resolve(storageDirAbsolute, REPO_SNAPSHOT_FILE_NAME);
-	if (!await pathExists(path)) return void 0;
-	try {
-		const raw = await readFile(path, "utf8");
-		return JSON.parse(raw);
-	} catch {
-		return;
-	}
-}
-//#endregion
-//#region src/cli/ui/ws.ts
-async function createWsServer(options) {
-	const wss = new WebSocketServer({
-		host: options.host,
-		port: options.port ?? 0
-	});
-	await waitForListen(wss);
-	const wsClients = /* @__PURE__ */ new Set();
-	let rpc;
-	const serverFunctions = createServerFunctions({
-		...options,
-		onStateChanged: (bootstrap) => rpc.broadcast.onStateChanged.asEvent(bootstrap),
-		onExecuteProgress: (event) => rpc.broadcast.onExecuteProgress.asEvent(event),
-		onExecuteComplete: (result) => rpc.broadcast.onExecuteComplete.asEvent(result)
-	});
-	rpc = createBirpcGroup(serverFunctions, [], {
-		timeout: 12e4,
-		onFunctionError(error, name) {
-			console.error(c.red(`RPC error on "${name}":`));
-			console.error(error);
-		}
-	});
-	wss.on("connection", (ws) => {
-		wsClients.add(ws);
-		const channel = {
-			post: (d) => ws.send(d),
-			on: (fn) => {
-				ws.on("message", (data) => {
-					fn(data);
-				});
-			},
-			serialize: stringify$1,
-			deserialize: parse$1
-		};
-		rpc.updateChannels((channels) => {
-			channels.push(channel);
-		});
-		ws.on("close", () => {
-			wsClients.delete(ws);
-			rpc.updateChannels((channels) => {
-				const index = channels.indexOf(channel);
-				if (index >= 0) channels.splice(index, 1);
-			});
-		});
-	});
-	return {
-		wss,
-		rpc,
-		serverFunctions,
-		close: async () => {
-			for (const client of wsClients) client.terminate();
-			await new Promise((resolve, reject) => {
-				wss.close((error) => {
-					if (error) {
-						reject(error);
-						return;
-					}
-					resolve();
-				});
-			});
-		},
-		getMetadata() {
-			const address = wss.address();
-			if (!address) throw new Error("WebSocket server is not listening");
-			return {
-				backend: "websocket",
-				websocket: address.port
-			};
-		}
-	};
-}
-async function waitForListen(server) {
-	await new Promise((resolve, reject) => {
-		server.once("listening", () => resolve());
-		server.once("error", (error) => reject(error));
-	});
-}
-//#endregion
 //#region src/cli/commands/ui.ts
-const defaultDependencies = {
-	createCliPrinter,
-	resolveConfig,
-	ensureExecuteArtifacts,
-	createUiServer,
-	createWsServer
-};
 function registerUiCommand(cli) {
-	cli.command("ui", "Serve local Web UI for synced mirror and execute queue").option("--host <host>", "Host for local UI server", { default: "127.0.0.1" }).option("--port <port>", "Port for local UI server", { default: 3589 }).action(withErrorHandling(async (options) => {
-		await runUiCommand(options);
-	}));
-}
-async function runUiCommand(options, dependencies = defaultDependencies) {
-	const printer = dependencies.createCliPrinter("ui");
-	const host = options.host || "127.0.0.1";
-	const parsedPort = Number(options.port);
-	const port = Number.isFinite(parsedPort) && parsedPort >= 0 ? parsedPort : 3589;
-	const config = await dependencies.resolveConfig();
-	const storageDirAbsolute = getStorageDirAbsolute(config);
-	const executeFilePath = resolve(config.cwd, getExecuteFile(config));
-	const uiDir = resolve(config.cwd, "dist/ui");
-	await dependencies.ensureExecuteArtifacts(executeFilePath);
-	const ws = await dependencies.createWsServer({
-		host,
-		config,
-		executeFilePath,
-		storageDirAbsolute
-	});
-	let http;
-	try {
-		http = await dependencies.createUiServer({
-			host,
+	cli.command("ui", "Launch a local web UI for the mirror").option("--repo <repo>", "GitHub repository in owner/name format").option("--port <port>", "Port to listen on", { default: 7710 }).option("--host <host>", "Host to bind", { default: "127.0.0.1" }).option("--no-open", "Do not open the browser automatically").option("--no-portless", "Do not expose the UI through the portless reverse proxy").option("--subdomain <slug>", "Override the portless subdomain (defaults to the repository name)").option("--cwd <cwd>", "Project root directory (defaults to current directory)").action(withErrorHandling(async (options) => {
+		const printer = createCliPrinter("ui");
+		const config = await resolveConfig({ cwd: options.cwd ? resolve(options.cwd) : void 0 });
+		await ensureExecuteArtifacts(resolve(config.cwd, getExecuteFile(config)));
+		const repo = await resolveRepo({
+			cwd: config.cwd,
+			cliRepo: options.repo,
+			configRepo: config.repo,
+			interactive: Boolean(process.stdin.isTTY),
+			selectRepoChoice: promptRepoChoice
+		});
+		printer.header(repo.repo);
+		const initialToken = await resolveAuthToken({
+			token: config.auth.token,
+			interactive: false,
+			promptForToken
+		}).catch(() => "");
+		const port = typeof options.port === "number" ? options.port : Number(options.port ?? 7710);
+		const host = options.host ?? "127.0.0.1";
+		const portlessEnabled = options.portless !== false;
+		const subdomain = options.subdomain?.trim() || slugifyRepoName(repo.repo);
+		const server = await createUiServer({
+			config,
+			repo: repo.repo,
+			initialToken,
 			port,
-			uiDir,
-			getMetadata: ws.getMetadata
+			host,
+			devMode: process.env.GHFS_UI_DEV === "1",
+			portless: portlessEnabled ? {
+				enabled: true,
+				subdomain
+			} : void 0,
+			logger: {
+				info: (message) => printer.info(message),
+				warn: (message) => printer.warn(message)
+			},
+			onRequestToken: async () => resolveAuthToken({
+				token: config.auth.token,
+				interactive: Boolean(process.stdin.isTTY),
+				promptForToken
+			})
 		});
-	} catch (error) {
-		await ws.close().catch(() => {});
-		throw error;
-	}
-	printer.success(`Web UI ready at ${http.url}`);
-	printer.info(`RPC websocket listening on ${ws.getMetadata().websocket}`);
-	printer.info("Press Ctrl+C to stop.");
-	let shuttingDown = false;
-	const shutdown = async () => {
-		if (shuttingDown) return;
-		shuttingDown = true;
-		await Promise.allSettled([http.close(), ws.close()]);
-		process.exit(0);
-	};
-	process.once("SIGINT", () => {
-		shutdown();
-	});
-	process.once("SIGTERM", () => {
-		shutdown();
-	});
+		if (server.portlessUrl) {
+			printer.info(`ghfs UI running at ${server.portlessUrl}`);
+			printer.info(`  direct: ${server.directUrl}`);
+		} else printer.info(`ghfs UI running at ${server.directUrl}`);
+		if (!initialToken) printer.info("No GitHub token yet; sync/execute will prompt or fail until one is available.");
+		if (options.open !== false) {
+			const { default: open } = await import("open");
+			await open(server.url);
+		}
+		const shutdown = async () => {
+			await server.close().catch(() => {});
+			process.exit(0);
+		};
+		process.once("SIGINT", shutdown);
+		process.once("SIGTERM", shutdown);
+		await new Promise(() => {});
+	}));
 }
 //#endregion
 //#region src/cli/index.ts