@rafiqui987/markode 0.0.0-stage → 0.2.7

package/dist/cli.js

@@ -0,0 +1,2304 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import fs17 from "fs";
+import path17 from "path";
+
+// src/core/check.ts
+import fs8 from "fs";
+import path8 from "path";
+
+// src/core/config.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { fileURLToPath } from "url";
+var LANGS = ["en", "es", "fr", "pt", "de", "it"];
+var LANG_NAMES = { en: "English", es: "Espa\xF1ol", fr: "Fran\xE7ais", pt: "Portugu\xEAs", de: "Deutsch", it: "Italiano" };
+var DEFAULT_SOURCE = "en";
+var isLang = (v) => LANGS.includes(v);
+var isLangCode = (v) => typeof v === "string" && /^[a-z]{2,3}(-[a-z0-9]{2,8})?$/i.test(v);
+var langName = (code, config) => isLang(code) ? LANG_NAMES[code] : config?.langNames?.[code] ?? code;
+var MAIN_DOCS = ["CLAUDE.md", "AGENTS.md"];
+var otherDoc = (doc) => doc === "CLAUDE.md" ? "AGENTS.md" : "CLAUDE.md";
+var POINTERS = {
+  // Claude Code imports the file: its content is loaded as if it were here.
+  "CLAUDE.md": "@AGENTS.md\n",
+  "AGENTS.md": "# AGENTS.md\n\nThis project's instructions for AI agents are in [CLAUDE.md](CLAUDE.md): read it and follow it.\n"
+};
+var isPointer = (text3, doc = "CLAUDE.md") => text3.trim() === POINTERS[doc].trim();
+var readText = (abs) => {
+  try {
+    return fs.readFileSync(abs, "utf8");
+  } catch {
+    return "";
+  }
+};
+function contentDoc(dir) {
+  for (const doc of MAIN_DOCS) {
+    const abs = path.join(dir, doc);
+    if (!fs.existsSync(abs)) continue;
+    if (fs.existsSync(path.join(dir, otherDoc(doc))) && isPointer(readText(abs), doc)) continue;
+    return abs;
+  }
+  return null;
+}
+function mainDocOf(root2) {
+  const doc = contentDoc(root2);
+  return doc && path.basename(doc);
+}
+function missingMainDoc(dir) {
+  const present = MAIN_DOCS.filter((d) => fs.existsSync(path.join(dir, d)));
+  return present.length === 1 ? otherDoc(present[0]) : null;
+}
+function linkMainDoc(dir) {
+  const missing = missingMainDoc(dir);
+  if (missing) fs.writeFileSync(path.join(dir, missing), POINTERS[missing]);
+  return missing;
+}
+var linkAgentsDoc = (dir) => missingMainDoc(dir) === "CLAUDE.md" && !!linkMainDoc(dir);
+var PKG_ROOT = (() => {
+  let dir = path.dirname(fileURLToPath(import.meta.url));
+  while (!fs.existsSync(path.join(dir, "package.json"))) dir = path.dirname(dir);
+  return dir;
+})();
+var TEMPLATES_DIR = path.join(PKG_ROOT, "templates");
+var WEB_DIR = path.join(PKG_ROOT, "dist", "web");
+var GLOBAL_DIR = process.env.MARKODE_HOME ?? path.join(os.homedir(), ".markode");
+var stateDir = (root2) => path.join(root2, ".markode");
+var configFile = (root2) => path.join(stateDir(root2), "config.json");
+function readConfig(root2) {
+  try {
+    const raw = JSON.parse(fs.readFileSync(configFile(root2), "utf8"));
+    const langs = Array.isArray(raw.langs) ? raw.langs : raw.lang ? [raw.lang] : [];
+    return { mainDoc: raw.mainDoc ?? null, langs: langs.filter(isLangCode), langNames: raw.langNames, workflow: raw.workflow, proposals: raw.proposals, skipLink: raw.skipLink === true || void 0, initializedAt: raw.initializedAt };
+  } catch {
+    return null;
+  }
+}
+function writeConfig(root2, config) {
+  fs.mkdirSync(stateDir(root2), { recursive: true });
+  fs.writeFileSync(configFile(root2), JSON.stringify(config, null, 2) + "\n");
+}
+function safeResolve(root2, rel) {
+  const abs = path.resolve(root2, rel);
+  if (abs !== root2 && !abs.startsWith(root2 + path.sep)) throw new Error(`Path outside project: ${rel}`);
+  return abs;
+}
+var toPosix = (p3) => p3.split(path.sep).join("/");
+var DEFAULT_SETTINGS = { font: "inter", size: 15, lineHeight: 1.65, padding: 28, width: "full", wrap: true, uiLang: "en" };
+var settingsFile = () => path.join(GLOBAL_DIR, "settings.json");
+function readSettings() {
+  try {
+    return { ...DEFAULT_SETTINGS, ...JSON.parse(fs.readFileSync(settingsFile(), "utf8")) };
+  } catch {
+    return { ...DEFAULT_SETTINGS };
+  }
+}
+function writeSettings(patch) {
+  const next = { ...readSettings(), ...patch };
+  fs.mkdirSync(GLOBAL_DIR, { recursive: true });
+  fs.writeFileSync(settingsFile(), JSON.stringify(next, null, 2) + "\n");
+  return next;
+}
+
+// src/core/dashboard.ts
+import fs3 from "fs";
+import path3 from "path";
+import YAML from "yaml";
+
+// src/core/scan.ts
+import fs2 from "fs";
+import path2 from "path";
+import ignore from "ignore";
+var ALWAYS_SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", ".markode", "dist", "build", ".next", ".turbo", "coverage", ".venv"]);
+var IGNORE_FILE = ".markodeignore";
+function loadIgnore(root2, file) {
+  const ig = ignore();
+  try {
+    ig.add(fs2.readFileSync(path2.join(root2, file), "utf8"));
+  } catch {
+  }
+  return ig;
+}
+function readIgnoreList(root2) {
+  try {
+    return fs2.readFileSync(path2.join(root2, IGNORE_FILE), "utf8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+  } catch {
+    return [];
+  }
+}
+function setIgnored(root2, rel, kind, ignored) {
+  const entry = kind === "dir" ? `${rel}/` : rel;
+  const lines = readIgnoreList(root2).filter((l) => l !== entry && l !== rel);
+  if (ignored) lines.push(entry);
+  fs2.writeFileSync(path2.join(root2, IGNORE_FILE), lines.length ? lines.join("\n") + "\n" : "");
+}
+function watchSkips(root2) {
+  const gitIgnore = loadIgnore(root2, ".gitignore");
+  return (rel, isDir2) => {
+    if (!rel || rel.startsWith("..")) return false;
+    if (rel.split("/").some((s) => ALWAYS_SKIP.has(s))) return true;
+    if (isDir2 !== false && gitIgnore.ignores(rel + "/")) return true;
+    return isDir2 !== true && gitIgnore.ignores(rel);
+  };
+}
+function scanTree(root2) {
+  const gitIgnore = loadIgnore(root2, ".gitignore");
+  const mdIgnore = loadIgnore(root2, IGNORE_FILE);
+  function walk(dirAbs, parentIgnored) {
+    let entries;
+    try {
+      entries = fs2.readdirSync(dirAbs, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+    const nodes = [];
+    for (const e of entries) {
+      if (ALWAYS_SKIP.has(e.name)) continue;
+      const abs = path2.join(dirAbs, e.name);
+      const rel = toPosix(path2.relative(root2, abs));
+      if (e.isDirectory()) {
+        if (gitIgnore.ignores(rel + "/")) continue;
+        const ignored = parentIgnored || mdIgnore.ignores(rel + "/");
+        const children = walk(abs, ignored);
+        if (!children.length && !isEmptyDir(abs)) continue;
+        const project = MAIN_DOCS.some((d) => children.some((c) => c.kind === "file" && c.name === d));
+        nodes.push({ name: e.name, path: rel, kind: "dir", project: project || void 0, ignored: ignored || void 0, children });
+      } else if (e.isFile() && e.name.toLowerCase().endsWith(".md")) {
+        if (gitIgnore.ignores(rel)) continue;
+        const ignored = parentIgnored || mdIgnore.ignores(rel);
+        nodes.push({ name: e.name, path: rel, kind: "file", ignored: ignored || void 0 });
+      }
+    }
+    return nodes.sort(compareNodes);
+  }
+  return walk(root2, false);
+}
+function isEmptyDir(abs) {
+  try {
+    return fs2.readdirSync(abs).length === 0;
+  } catch {
+    return false;
+  }
+}
+var collator = new Intl.Collator(void 0, { numeric: true, sensitivity: "base" });
+function compareNodes(a, b) {
+  return (a.kind === "dir" ? 0 : 1) - (b.kind === "dir" ? 0 : 1) || collator.compare(a.name, b.name);
+}
+function flattenFiles(nodes, includeIgnored = false) {
+  const out = [];
+  for (const n of nodes) {
+    if (n.ignored && !includeIgnored) continue;
+    if (n.kind === "file") out.push(n);
+    else out.push(...flattenFiles(n.children ?? [], includeIgnored));
+  }
+  return out;
+}
+function findSubprojects(nodes) {
+  const out = [];
+  for (const n of nodes) {
+    if (n.kind !== "dir") continue;
+    if (n.project) out.push(n.path);
+    out.push(...findSubprojects(n.children ?? []));
+  }
+  return out;
+}
+
+// src/core/dashboard.ts
+function parseFrontmatter(text3) {
+  const m = text3.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!m) return {};
+  try {
+    return YAML.parse(m[1], { logLevel: "error" }) ?? {};
+  } catch {
+    return {};
+  }
+}
+var asText = (v) => v instanceof Date ? v.toISOString().slice(0, 10) : v == null || typeof v === "object" ? null : String(v);
+function summarize(root2) {
+  return flattenFiles(scanTree(root2)).flatMap((f) => {
+    if (f.path.split("/").some((part) => part.startsWith("."))) return [];
+    const text3 = fs3.readFileSync(path3.join(root2, f.path), "utf8");
+    const meta = parseFrontmatter(text3);
+    if (meta.type === "task" && f.name.startsWith("_")) return [];
+    const id = asText(meta.id);
+    const total = text3.match(/^\s*[-*+] \[[ xX]\]/gm)?.length ?? 0;
+    const done = text3.match(/^\s*[-*+] \[[xX]\]/gm)?.length ?? 0;
+    const heading2 = text3.match(/^#\s+(.+)$/m)?.[1];
+    const title = asText(meta.title) ?? (heading2 && id ? heading2.replace(new RegExp(`^${id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*[\xB7:-]\\s*`), "") : heading2);
+    return {
+      path: f.path,
+      title: title ?? f.name.replace(/\.md$/i, ""),
+      type: asText(meta.type),
+      status: asText(meta.status),
+      phase: typeof meta.phase === "number" ? meta.phase : null,
+      updated: asText(meta.updated),
+      id,
+      area: asText(meta.area),
+      tasks: { done, total }
+    };
+  });
+}
+
+// src/core/method.ts
+import fs7 from "fs";
+import path7 from "path";
+import YAML2 from "yaml";
+
+// src/core/profile.ts
+import fs4 from "fs";
+import path4 from "path";
+var KIND_LABEL = { app: "App", library: "Library", mobile: "Mobile", data: "Data / ML", infra: "Infrastructure" };
+var KIND_HINT = {
+  app: "web, API, CLI, desktop",
+  library: "a package other code imports",
+  mobile: "iOS, Android, Flutter, React Native",
+  data: "notebooks, datasets, models",
+  infra: "Terraform, Pulumi, Helm, Kubernetes"
+};
+var EXPERIMENTS_LABEL = {
+  docs: "`docs/experiments.md` (one entry per run: goal, data, result)",
+  mlflow: "MLflow",
+  wandb: "Weights & Biases",
+  dvc: "DVC"
+};
+var SKIP = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "coverage", "vendor", "target", ".git", ".venv", "venv"]);
+var names = (abs) => {
+  try {
+    return fs4.readdirSync(abs, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+};
+function find(abs, re, depth) {
+  for (const e of names(abs)) {
+    if (re.test(e.name)) return path4.join(abs, e.name);
+    if (e.isDirectory() && depth > 0 && !SKIP.has(e.name) && !e.name.startsWith(".")) {
+      const hit = find(path4.join(abs, e.name), re, depth - 1);
+      if (hit) return hit;
+    }
+  }
+  return null;
+}
+var read = (abs) => {
+  try {
+    return fs4.readFileSync(abs, "utf8");
+  } catch {
+    return "";
+  }
+};
+var readJson = (abs) => {
+  try {
+    return JSON.parse(fs4.readFileSync(abs, "utf8"));
+  } catch {
+    return null;
+  }
+};
+var APP_DEPS = ["next", "nuxt", "vite", "react-scripts", "@angular/core", "@sveltejs/kit", "astro", "express", "fastify", "@nestjs/core", "koa", "hono", "electron"];
+function guessKind(dir) {
+  const found = {};
+  const add = (kind, why) => (found[kind] ??= []).push(why);
+  const has2 = (name) => fs4.existsSync(path4.join(dir, name));
+  const pkg = readJson(path4.join(dir, "package.json"));
+  const deps = { ...pkg?.dependencies, ...pkg?.devDependencies };
+  if (has2("pubspec.yaml")) add("mobile", "Flutter (pubspec.yaml)");
+  if (deps["react-native"] || deps.expo) add("mobile", "React Native");
+  if (has2("android") && has2("ios")) add("mobile", "android/ and ios/");
+  else if (find(dir, /\.xcodeproj$/, 1)) add("mobile", "Xcode project");
+  if (find(dir, /\.ipynb$/, 2)) add("data", "notebooks");
+  if (has2("dvc.yaml") || has2("MLproject")) add("data", has2("dvc.yaml") ? "dvc.yaml" : "MLproject");
+  if (find(dir, /\.tf$/, 2)) add("infra", "Terraform");
+  if (has2("Pulumi.yaml")) add("infra", "Pulumi");
+  if (find(dir, /^(Chart|kustomization)\.ya?ml$/, 2)) add("infra", "Helm / Kustomize");
+  if (pkg && !pkg.private && !pkg.bin && (pkg.main || pkg.exports || pkg.module)) add("library", "package.json exports");
+  if (/^\[lib\]/m.test(read(path4.join(dir, "Cargo.toml")))) add("library", "Cargo [lib]");
+  if (pkg?.bin) add("app", "CLI (bin)");
+  const framework = APP_DEPS.find((d) => deps[d]);
+  if (framework) add("app", framework);
+  if (has2("manage.py")) add("app", "Django");
+  if (has2("main.go")) add("app", "main.go");
+  if (has2("Dockerfile")) add("app", "Dockerfile");
+  const kinds = Object.keys(found);
+  const signals = kinds.flatMap((k) => found[k]);
+  const specific = kinds.filter((k) => k !== "app");
+  if (!kinds.length) return { kind: "app", unclear: true, signals };
+  if (specific.length === 1) return { kind: specific[0], unclear: false, signals };
+  if (!specific.length) return { kind: "app", unclear: false, signals };
+  return { kind: specific.find((k) => k !== "library") ?? specific[0], unclear: true, signals };
+}
+function findContracts(root2) {
+  const hit = find(root2, /(\.proto|^openapi.*\.ya?ml|^openapi.*\.json|^asyncapi.*\.ya?ml)$/i, 3);
+  if (!hit) return null;
+  const dir = path4.relative(root2, path4.dirname(hit)).split(path4.sep).join("/");
+  return dir ? `${dir}/` : path4.basename(hit);
+}
+var looksLikeMicroservices = (root2, projects) => projects >= 2 && (!!findContracts(root2) || !!find(root2, /^(docker-)?compose(\.[\w-]+)?\.ya?ml$/, 0));
+function detectProfile(dir, kind) {
+  const has2 = (name) => fs4.existsSync(path4.join(dir, name));
+  const pkg = readJson(path4.join(dir, "package.json"));
+  if (kind === "library") return { kind, published: !!pkg?.publishConfig || !!pkg?.name && !pkg.private };
+  if (kind === "mobile") {
+    const platforms = ["ios", "android", "web"].filter((p3) => has2(p3));
+    return { kind, platforms: platforms.length ? platforms : ["ios", "android"] };
+  }
+  if (kind === "data") {
+    const experiments = has2("dvc.yaml") ? "dvc" : has2("mlruns") ? "mlflow" : has2("wandb") ? "wandb" : "docs";
+    const data = ["data", "datasets"].find(has2);
+    return { kind, dataLocation: data ? `${data}/` : "", experiments };
+  }
+  if (kind === "infra") {
+    const envDir = ["envs", "environments", "env"].find((d) => has2(d));
+    const envs = envDir ? names(path4.join(dir, envDir)).filter((e) => e.isDirectory()).map((e) => e.name) : [];
+    return { kind, environments: envs.length ? envs.join(", ") : "dev, staging, prod" };
+  }
+  return { kind };
+}
+function kindGuidance(p3) {
+  switch (p3.kind) {
+    case "library":
+      return `Library${p3.published ? ", published" : ""}: record public API and versioning decisions in \`docs/architecture/api.md\`; phases only if the user plans milestones.${p3.published ? " One `CHANGELOG.md` entry per release." : ""}`;
+    case "mobile":
+      return `Mobile app (${(p3.platforms ?? []).join(", ") || "platforms not set"}): release and store decisions in \`docs/architecture/releases.md\`.`;
+    case "data":
+      return `Data / ML: each dataset (source, location${p3.dataLocation ? `: \`${p3.dataLocation}\`` : ""}, schema) in \`docs/architecture/data.md\`; experiments tracked in ${EXPERIMENTS_LABEL[p3.experiments ?? "docs"]}.`;
+    case "infra":
+      return `Infrastructure (environments: ${p3.environments || "dev, staging, prod"}): one runbook per operation in \`docs/runbooks/\`; changing an environment is a task.`;
+    default:
+      return null;
+  }
+}
+var contractsGuidance = (contracts) => `Microservices: contracts (APIs, events) live in \`${contracts}\`. Changing one is a shared decision (\`docs/architecture/contracts.md\`) and every consumer gets a task.`;
+function existingDocs(root2) {
+  const docs = path4.join(root2, "docs");
+  const out = [];
+  for (const e of names(docs)) {
+    if (e.name.startsWith(".") || e.name === "tasks" || e.name === "proposals") continue;
+    if (e.isFile() && e.name.toLowerCase().endsWith(".md")) out.push(`docs/${e.name}`);
+    else if (e.isDirectory() && find(path4.join(docs, e.name), /\.md$/i, 2)) out.push(`docs/${e.name}/`);
+  }
+  for (const adr of ["adr", "decisions"]) if (find(path4.join(root2, adr), /\.md$/i, 1)) out.push(`${adr}/`);
+  return out.sort();
+}
+
+// src/core/scaffold.ts
+import fs5 from "fs";
+import path5 from "path";
+var today = () => (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+function fill(text3, vars) {
+  return text3.replace(/\{\{(\w+)\}\}/g, (_, k) => vars[k] ?? "");
+}
+function copyTree(src, dest, vars, created, root2) {
+  for (const e of fs5.readdirSync(src, { withFileTypes: true })) {
+    const from = path5.join(src, e.name);
+    const to = path5.join(dest, fill(e.name, vars));
+    if (e.isDirectory()) {
+      fs5.mkdirSync(to, { recursive: true });
+      copyTree(from, to, vars, created, root2);
+    } else if (!fs5.existsSync(to)) {
+      fs5.writeFileSync(to, fill(fs5.readFileSync(from, "utf8"), vars));
+      created.push(toPosix(path5.relative(root2, to)));
+    }
+  }
+}
+function createMainDoc(root2, name) {
+  const file = path5.join(root2, name);
+  if (fs5.existsSync(file)) return;
+  const text3 = fs5.readFileSync(path5.join(TEMPLATES_DIR, "main.md"), "utf8");
+  fs5.writeFileSync(file, fill(text3, { name: path5.basename(root2), date: today() }));
+}
+function installSkill(root2) {
+  const dir = path5.join(root2, ".claude", "skills", "markode");
+  fs5.mkdirSync(dir, { recursive: true });
+  fs5.copyFileSync(path5.join(TEMPLATES_DIR, "skill", "SKILL.md"), path5.join(dir, "SKILL.md"));
+}
+function ensureGitignore(root2) {
+  const file = path5.join(root2, ".gitignore");
+  const text3 = fs5.existsSync(file) ? fs5.readFileSync(file, "utf8") : "";
+  if (text3.split("\n").some((l) => [".markode", ".markode/", "/.markode", "/.markode/"].includes(l.trim()))) return;
+  fs5.writeFileSync(file, text3 + (text3 && !text3.endsWith("\n") ? "\n" : "") + ".markode/\n");
+}
+function hideInVsCode(root2) {
+  const file = path5.join(root2, ".vscode", "settings.json");
+  let settings = {};
+  if (fs5.existsSync(file)) {
+    try {
+      settings = JSON.parse(fs5.readFileSync(file, "utf8"));
+    } catch {
+      return false;
+    }
+  }
+  settings["files.exclude"] = { ...settings["files.exclude"] ?? {}, "**/.markode": true };
+  fs5.mkdirSync(path5.dirname(file), { recursive: true });
+  fs5.writeFileSync(file, JSON.stringify(settings, null, 2) + "\n");
+  return true;
+}
+function missingMainDocs(root2) {
+  return ["", ...findSubprojects(scanTree(root2))].flatMap((dir) => {
+    const doc = missingMainDoc(path5.join(root2, dir));
+    return doc ? [{ path: path5.posix.join(dir, doc), pointsTo: doc === "CLAUDE.md" ? "AGENTS.md" : "CLAUDE.md" }] : [];
+  });
+}
+function linkMainDocs(root2) {
+  return missingMainDocs(root2).flatMap((m) => linkMainDoc(path5.join(root2, path5.posix.dirname(m.path))) ? [m.path] : []);
+}
+
+// src/core/sdd.ts
+import { spawnSync } from "child_process";
+import fs6 from "fs";
+import path6 from "path";
+var SDD_AGENTS = {
+  claude: { label: "Claude Code", openspec: "claude", speckit: "claude" },
+  codex: { label: "Codex", openspec: "codex", speckit: "codex" },
+  copilot: { label: "GitHub Copilot", openspec: "github-copilot", speckit: "copilot" },
+  gemini: { label: "Gemini CLI", openspec: "gemini", speckit: "gemini" },
+  cursor: { label: "Cursor", openspec: "cursor", speckit: "cursor-agent" }
+};
+var OPENSPEC_PKG = "@fission-ai/openspec@latest";
+var SPECKIT_SRC = "git+https://github.com/github/spec-kit.git";
+function detectWorkflow(root2) {
+  if (fs6.existsSync(path6.join(root2, "openspec"))) return "openspec";
+  if (fs6.existsSync(path6.join(root2, ".specify"))) return "speckit";
+  return null;
+}
+var has = (cmd) => spawnSync(cmd, ["--version"], { stdio: "ignore", shell: process.platform === "win32" }).status === 0;
+var hasUv = () => has("uvx");
+function installCommand(workflow, agents) {
+  if (workflow === "openspec") {
+    const tools = agents.map((a) => SDD_AGENTS[a].openspec).join(",") || "none";
+    const runner = has("pnpm") ? ["pnpm", "dlx"] : has("npx") ? ["npx", "--yes"] : null;
+    return runner && [...runner, OPENSPEC_PKG, "init", "--tools", tools, "--no-animation", "--no-copilot-cloud"];
+  }
+  if (!hasUv()) return null;
+  return ["uvx", "--from", SPECKIT_SRC, "specify", "init", "--here", "--force", "--non-interactive", "--ignore-agent-tools", "--integration", SDD_AGENTS[agents[0] ?? "claude"].speckit];
+}
+function installWorkflow(root2, workflow, agents, official) {
+  const before = new Set(flattenFiles(scanTree(root2), true).map((f) => f.path));
+  const result = { official: false, created: [], ignored: [] };
+  const cmd = official ? installCommand(workflow, agents) : null;
+  if (cmd) {
+    const run = spawnSync(cmd[0], cmd.slice(1), { cwd: root2, encoding: "utf8", timeout: 3e5, shell: process.platform === "win32", env: { ...process.env, NO_COLOR: "1" } });
+    if (run.status === 0) result.official = true;
+    else result.error = (run.error?.message ?? `${run.stderr ?? ""}
+${run.stdout ?? ""}`).trim().split("\n").slice(-6).join("\n");
+  }
+  copyTree(path6.join(TEMPLATES_DIR, "sdd", workflow), root2, { date: today2() }, result.created, root2);
+  const dirs2 = /* @__PURE__ */ new Set();
+  for (const f of flattenFiles(scanTree(root2), true)) {
+    if (before.has(f.path) || !f.path.startsWith(".") || f.path.startsWith(".specify/memory/")) continue;
+    dirs2.add(path6.posix.dirname(f.path));
+  }
+  for (const dir of dirs2) setIgnored(root2, dir, "dir", true);
+  result.ignored = [...dirs2].sort();
+  return result;
+}
+var today2 = () => (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+var WORKFLOW_TEXT = {
+  openspec: [
+    "## Workflow",
+    "",
+    "This project uses [OpenSpec](https://github.com/Fission-AI/OpenSpec) (spec-driven development; guide: `openspec/README.md`):",
+    "",
+    "- `openspec/specs/<domain>/spec.md` describes how the system behaves today.",
+    "- Every change starts in `openspec/changes/<change-id>/` with `proposal.md`, `tasks.md`, an optional `design.md` and delta specs, before any code.",
+    "- When it is done, archive it so its delta specs merge into `openspec/specs/`.",
+    "- Use the `/opsx:*` commands (or the `openspec` CLI) when available."
+  ].join("\n"),
+  speckit: [
+    "## Workflow",
+    "",
+    "This project uses [GitHub Spec Kit](https://github.com/github/spec-kit) (spec-driven development; guide: `specs/README.md`):",
+    "",
+    "- Principles every change must respect: `.specify/memory/constitution.md`.",
+    "- One folder per feature in `specs/NNN-feature-name/`: `spec.md` (what and why), then `plan.md` (how), then `tasks.md`.",
+    "- Use the `/speckit-*` commands when available."
+  ].join("\n")
+};
+function applyWorkflowToFile(file, workflow, text3) {
+  writeManagedBlock(file, workflow === "none" ? null : text3 ?? (workflow === "markode" ? null : WORKFLOW_TEXT[workflow]));
+}
+function writeManagedBlock(file, body, top = false, name = "workflow") {
+  const START2 = `<!-- markode:${name}:start -->`;
+  const END2 = `<!-- markode:${name}:end -->`;
+  const text3 = fs6.readFileSync(file, "utf8");
+  const s = text3.indexOf(START2);
+  const e = text3.indexOf(END2);
+  const existing = s >= 0 && e > s ? text3.slice(s, e + END2.length) : null;
+  if (body === null) {
+    if (existing) fs6.writeFileSync(file, text3.replace(new RegExp(`\\n*${escapeRe(existing)}\\n?`), "\n"));
+    return;
+  }
+  const section2 = `${START2}
+${body}
+${END2}`;
+  if (existing) return fs6.writeFileSync(file, text3.replace(existing, () => section2));
+  const title = top ? /^# .*\n/m.exec(text3) : null;
+  if (title) return fs6.writeFileSync(file, text3.slice(0, title.index + title[0].length) + "\n" + section2 + "\n" + text3.slice(title.index + title[0].length));
+  fs6.writeFileSync(file, text3.replace(/\s*$/, "") + "\n\n" + section2 + "\n");
+}
+var escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var dirs = (abs) => {
+  try {
+    return fs6.readdirSync(abs, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name).sort();
+  } catch {
+    return [];
+  }
+};
+var read2 = (abs) => {
+  try {
+    return fs6.readFileSync(abs, "utf8");
+  } catch {
+    return null;
+  }
+};
+var progress = (text3) => ({ done: text3?.match(/^\s*[-*+] \[[xX]\]/gm)?.length ?? 0, total: text3?.match(/^\s*[-*+] \[[ xX]\]/gm)?.length ?? 0 });
+var heading = (text3) => text3?.match(/^#\s+(.+)$/m)?.[1].trim() ?? null;
+var countSpecs = (abs) => {
+  try {
+    return fs6.readdirSync(abs, { recursive: true }).filter((f) => String(f).endsWith("spec.md")).length;
+  } catch {
+    return 0;
+  }
+};
+function summarizeSdd(root2) {
+  const out = {};
+  const os3 = path6.join(root2, "openspec");
+  if (fs6.existsSync(os3)) {
+    const rel = (...p3) => toPosix(path6.join("openspec", ...p3));
+    out.openspec = {
+      changes: dirs(path6.join(os3, "changes")).filter((id) => id !== "archive").map((id) => {
+        const dir = path6.join(os3, "changes", id);
+        const proposal = read2(path6.join(dir, "proposal.md"));
+        const tasks = read2(path6.join(dir, "tasks.md"));
+        return {
+          id,
+          // "Proposal: Add login" → "Add login"
+          title: heading(proposal)?.replace(/^(change\s+)?proposal:\s*/i, "") ?? id,
+          path: rel("changes", id, proposal !== null ? "proposal.md" : "tasks.md"),
+          artifacts: { proposal: proposal !== null, design: fs6.existsSync(path6.join(dir, "design.md")), tasks: tasks !== null, specs: countSpecs(path6.join(dir, "specs")) },
+          tasks: progress(tasks)
+        };
+      }),
+      specs: dirs(path6.join(os3, "specs")).filter((id) => fs6.existsSync(path6.join(os3, "specs", id, "spec.md"))).map((id) => ({ id, path: rel("specs", id, "spec.md") })),
+      archived: dirs(path6.join(os3, "changes", "archive")).reverse().slice(0, 12).map((id) => {
+        const file = ["proposal.md", "tasks.md"].find((f) => fs6.existsSync(path6.join(os3, "changes", "archive", id, f)));
+        return { id, path: file ? rel("changes", "archive", id, file) : "" };
+      })
+    };
+  }
+  if (fs6.existsSync(path6.join(root2, ".specify"))) {
+    const constitution = read2(path6.join(root2, ".specify", "memory", "constitution.md"));
+    out.speckit = {
+      // The template is full of [PLACEHOLDERS] until /speckit-constitution fills it.
+      constitution: constitution === null ? null : { path: ".specify/memory/constitution.md", filled: !/\[[A-Z_0-9]+\]/.test(constitution) },
+      features: dirs(path6.join(root2, "specs")).map((id) => {
+        const dir = path6.join(root2, "specs", id);
+        const spec = read2(path6.join(dir, "spec.md"));
+        const tasks = read2(path6.join(dir, "tasks.md"));
+        return {
+          id,
+          // "Feature Specification: Login" → "Login"
+          title: heading(spec)?.replace(/^feature specification:\s*/i, "") ?? id,
+          path: toPosix(path6.join("specs", id, spec !== null ? "spec.md" : "plan.md")),
+          artifacts: { spec: spec !== null, plan: fs6.existsSync(path6.join(dir, "plan.md")), tasks: tasks !== null },
+          tasks: progress(tasks)
+        };
+      })
+    };
+  }
+  return out;
+}
+function sddPrefixes(summary) {
+  return [...summary.openspec ? ["openspec/"] : [], ...summary.speckit ? ["specs/", ".specify/"] : []];
+}
+
+// src/core/method.ts
+var SKIP2 = /* @__PURE__ */ new Set(["docs", "node_modules", "dist", "build", "coverage", "tmp", "vendor", "target"]);
+var MANIFESTS = ["package.json", "pyproject.toml", "go.mod", "Cargo.toml", "pom.xml", "build.gradle", "build.gradle.kts", "composer.json", "Gemfile", "deno.json", ".git"];
+var isDir = (abs) => !!fs7.statSync(abs, { throwIfNoEntry: false })?.isDirectory();
+var subdirs = (abs) => {
+  try {
+    return fs7.readdirSync(abs, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".") && !SKIP2.has(e.name)).map((e) => e.name);
+  } catch {
+    return [];
+  }
+};
+var isProject = (abs) => MANIFESTS.some((m) => fs7.existsSync(path7.join(abs, m)));
+function detectAreas(root2) {
+  const globs = [];
+  try {
+    const ws = YAML2.parse(fs7.readFileSync(path7.join(root2, "pnpm-workspace.yaml"), "utf8"), { logLevel: "error" });
+    if (Array.isArray(ws?.packages)) globs.push(...ws.packages);
+  } catch {
+  }
+  try {
+    const ws = JSON.parse(fs7.readFileSync(path7.join(root2, "package.json"), "utf8")).workspaces;
+    globs.push(...Array.isArray(ws) ? ws : Array.isArray(ws?.packages) ? ws.packages : []);
+  } catch {
+  }
+  const found = new Set(findSubprojects(scanTree(root2)));
+  for (const glob of globs) {
+    const g = String(glob).replace(/^\.\//, "").replace(/\/+$/, "");
+    if (g.startsWith("!")) continue;
+    const base = g.replace(/\/\*\*?$/, "");
+    if (base.includes("*")) continue;
+    if (base === g) found.add(g);
+    else for (const name of subdirs(path7.join(root2, base))) found.add(`${base}/${name}`);
+  }
+  if (!isProject(root2)) {
+    for (const top of subdirs(root2)) {
+      if (isProject(path7.join(root2, top))) found.add(top);
+      else for (const name of subdirs(path7.join(root2, top))) if (isProject(path7.join(root2, top, name))) found.add(`${top}/${name}`);
+    }
+  }
+  let unsure = false;
+  if (!globs.length && isProject(root2)) {
+    const tops = subdirs(root2).filter((top) => isProject(path7.join(root2, top)));
+    if (tops.length >= 2 && tops.some((t) => !found.has(t))) tops.forEach((t) => found.add(t)), unsure = true;
+  }
+  const dirs2 = [...found].filter((d) => d && !d.split("/").some((part) => part.startsWith(".") || SKIP2.has(part)) && isDir(path7.join(root2, d)));
+  return { dirs: dirs2.filter((d) => !dirs2.some((o) => o.startsWith(d + "/"))).sort(), unsure };
+}
+function areaDescription(root2, dir) {
+  try {
+    return String(JSON.parse(fs7.readFileSync(path7.join(root2, dir, "package.json"), "utf8")).description ?? "").trim();
+  } catch {
+    return "";
+  }
+}
+var KNOWN_PREFIXES = {
+  apps: "APP",
+  app: "APP",
+  services: "SVC",
+  service: "SVC",
+  packages: "PKG",
+  libs: "LIB",
+  lib: "LIB",
+  infra: "INF",
+  infrastructure: "INF",
+  proto: "PRO",
+  backend: "BE",
+  frontend: "FE",
+  web: "WEB",
+  api: "API",
+  mobile: "MOB",
+  tools: "TLS",
+  scripts: "SCR"
+};
+function suggestPrefix(dir, used) {
+  dir = path7.posix.basename(dir);
+  const base = KNOWN_PREFIXES[dir.toLowerCase()] ?? (dir.replace(/[^a-z0-9]/gi, "").slice(0, 3).toUpperCase() || "AREA");
+  let prefix = base;
+  for (let i = 2; used.has(prefix) || prefix === "CORE"; i++) prefix = `${base}${i}`;
+  used.add(prefix);
+  return prefix;
+}
+var rootPrefix = (areas) => areas.length ? "CORE" : "T";
+function scaffoldMethod(root2, mainDoc, areas) {
+  const created = [];
+  const name = path7.basename(root2);
+  copyTree(path7.join(TEMPLATES_DIR, "method", "root"), root2, { date: today(), name, prefix: rootPrefix(areas), area: areas.length ? "core" : name }, created, root2);
+  for (const a of areas) {
+    const vars = { date: today(), name, prefix: a.prefix, area: a.dir, up: "../".repeat(a.dir.split("/").length) };
+    const dir = path7.join(root2, a.dir);
+    copyTree(path7.join(TEMPLATES_DIR, "method", "area"), dir, vars, created, root2);
+    let doc = contentDoc(dir);
+    if (!doc) {
+      doc = path7.join(dir, mainDoc);
+      fs7.writeFileSync(doc, fill(fs7.readFileSync(path7.join(TEMPLATES_DIR, "method", "area-main.md"), "utf8"), vars));
+      created.push(path7.posix.join(a.dir, mainDoc));
+    }
+    if (claudeUsed(root2, mainDoc) && linkAgentsDoc(dir)) created.push(path7.posix.join(a.dir, "CLAUDE.md"));
+    writeManagedBlock(doc, areaBlock(a, vars.up, mainDoc), true);
+  }
+  return created;
+}
+var claudeUsed = (root2, mainDoc) => mainDoc === "CLAUDE.md" || fs7.existsSync(path7.join(root2, "CLAUDE.md"));
+function areaBlock(a, up, mainDoc) {
+  const guidance = a.profile && kindGuidance(a.profile);
+  return [
+    `- Tasks: one file per task in \`docs/tasks/\`, prefix \`${a.prefix}\`; the status is in each file's frontmatter`,
+    ...guidance ? [`- ${guidance}`] : [],
+    `- Decisions of this project: \`docs/ARCHITECTURE.md\` (created with the first one) \xB7 shared by several projects: \`${up}docs/architecture/\``,
+    `- Overview of the repository and the other projects: \`${up}${mainDoc}\``
+  ].join("\n");
+}
+function methodSection(areas, root2, ctx = {}) {
+  const taskDirs = ["docs/tasks", ...areas.map((a) => `${a.dir}/docs/tasks`)].join(" ");
+  const map = areas.length ? [
+    "",
+    "### Projects",
+    "",
+    "Each project has its own `CLAUDE.md`/`AGENTS.md` and `docs/` (architecture, tasks, proposals). This file and the root `docs/` hold the overview and what is shared by several projects.",
+    "",
+    "| Project | Kind | What it is | Docs | Task prefix |",
+    "|---|---|---|---|---|",
+    ...areas.map((a) => `| \`${a.dir}/\` | ${KIND_LABEL[a.profile?.kind ?? "app"]} | ${root2 && areaDescription(root2, a.dir).replace(/\|/g, "\\|") || "<!-- one line -->"} | \`${a.dir}/docs/\` | ${a.prefix} |`),
+    `| \`docs/\` | | Vision, shared architecture, phases and tasks across projects | \`docs/\` | ${rootPrefix(areas)} |`,
+    ...ctx.contracts ? ["", contractsGuidance(ctx.contracts)] : []
+  ] : [];
+  const guidance = !areas.length && ctx.profile && kindGuidance(ctx.profile);
+  const about = guidance ? ["", "### This project", "", guidance] : [];
+  const existing = ctx.existing?.length ? ["", "### Existing docs", "", "These are the official docs: update them instead of creating new ones in their place.", "", ...ctx.existing.map((d) => `- \`${d}\``)] : [];
+  return [
+    "## Workflow (markode method)",
+    "",
+    "Docs are created when there is something real to write (where each thing goes and templates: skill `markode-method`): vision `docs/vision.md` \xB7 architecture `docs/architecture/` \xB7 phases `docs/phases/` \xB7 tasks `docs/tasks/`.",
+    ...about,
+    ...map,
+    ...existing,
+    "",
+    "### Session start",
+    "",
+    "1. `/markode sync`: apply proposals the user answered while no session was open, and fix what is out of date.",
+    `2. Find tasks in progress: \`grep -rl "^status: in-progress" --include=*.md ${taskDirs}\`.`,
+    '3. Open the one with the most recent `updated`, read its "Next step" and tell the user in one line where we left off.',
+    "4. If there are none, ask the user what to work on.",
+    "",
+    "When the user asks what is pending or where things stand: `/markode-status`.",
+    "",
+    "### During the session",
+    "",
+    `- Read only what the task needs: its file, ${areas.length ? "the `CLAUDE.md`/`AGENTS.md` and `docs/` of its project, " : ""}and the one file in \`docs/architecture/\` that applies.`,
+    '- Tick acceptance criteria as they are met and keep "Next step" current.',
+    "- Before replacing a decision, propose it with the reasons; then update it in its one place.",
+    "",
+    "### Tasks",
+    "",
+    "- The user defines tasks: propose them, but create them only when asked (`/markode-new-task`).",
+    `- One task = one file in ${areas.length ? "`<project>/docs/tasks/`; tasks across projects in `docs/tasks/`" : "`docs/tasks/`"}, prefix \`${rootPrefix(areas)}\`${areas.length ? " at the root" : ""}. Its status lives only in its frontmatter; each phase lists its tasks.`,
+    "- At the end of a session: `/markode-close-session` (it ends with `/markode sync`).",
+    "",
+    "### Documentation without redundancy",
+    "",
+    "- Write only what the code can't tell: decisions and why, hidden conventions, the state of the work.",
+    "- Each fact lives in one place; everything else links to it.",
+    areas.length ? "- A decision affecting one project goes in `<project>/docs/ARCHITECTURE.md`; several projects, in `docs/architecture/`." : "- Decisions go in `docs/architecture/`, one file per topic.",
+    "- Main docs hold orientation, rules and commands only: never decisions or task lists."
+  ].join("\n");
+}
+function installMethodSkills(root2) {
+  const src = path7.join(TEMPLATES_DIR, "method", "skills");
+  for (const name of fs7.readdirSync(src)) fs7.cpSync(path7.join(src, name), path7.join(root2, ".claude", "skills", name), { recursive: true });
+}
+
+// src/core/check.ts
+var TASK_LINE = /^\s*[-*+] \[([ xX])\] .*?\[[^\]]*\]\(([^)\s]+)\)/;
+var LINK = /!?\[[^\]]*\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g;
+function checkDocs(root2) {
+  const docs = summarize(root2);
+  const status = new Map(docs.map((d) => [d.path, d.status ?? ""]));
+  const read3 = (rel) => fs8.readFileSync(path8.join(root2, rel), "utf8");
+  const phases = [];
+  for (const phase of docs.filter((d) => d.type === "phase")) {
+    for (const line of read3(phase.path).split("\n")) {
+      const m = TASK_LINE.exec(line);
+      if (!m) continue;
+      const task = path8.posix.normalize(path8.posix.join(path8.posix.dirname(phase.path), m[2].split("#")[0]));
+      const s = status.get(task);
+      if (s === void 0) continue;
+      const ticked = m[1] !== " ";
+      if (ticked !== (s === "done")) phases.push({ phase: phase.path, task, ticked, status: s });
+    }
+  }
+  const links = [];
+  for (const doc of docs) {
+    let fenced = false;
+    read3(doc.path).split("\n").forEach((line, i) => {
+      if (/^\s*(```|~~~)/.test(line)) fenced = !fenced;
+      if (fenced) return;
+      for (const m of line.matchAll(LINK)) {
+        const target = m[1];
+        if (/^[a-z][\w+.-]*:|^#|^\/|[<{]/i.test(target)) continue;
+        const file = decodeURIComponent(target.split(/[#?]/)[0]);
+        if (file && !fs8.existsSync(path8.join(root2, path8.dirname(doc.path), file))) links.push({ file: doc.path, line: i + 1, target });
+      }
+    });
+  }
+  return { proposals: docs.filter((d) => d.type === "proposal" && d.status === "answered").map((d) => d.path), phases, projects: projectsTable(root2), links };
+}
+function projectsTable(root2) {
+  const doc = mainDocOf(root2);
+  if (!doc) return null;
+  const text3 = fs8.readFileSync(path8.join(root2, doc), "utf8");
+  const section2 = /^### Projects\n([\s\S]*?)(?=^#{1,3} |<!-- markode:workflow:end -->)/m.exec(text3)?.[1];
+  if (!section2) return null;
+  const listed = [...section2.matchAll(/^\|\s*`([^`]+?)\/?`\s*\|/gm)].map((m) => m[1]).filter((d) => d !== "docs");
+  const found = detectAreas(root2).dirs;
+  return { missing: found.filter((d) => !listed.includes(d)), gone: listed.filter((d) => !fs8.existsSync(path8.join(root2, d))) };
+}
+
+// src/core/defaults.ts
+import fs9 from "fs";
+import path9 from "path";
+var BASE_DEFAULTS = {
+  mode: "ask",
+  mainDoc: "CLAUDE.md",
+  workflow: "none",
+  agents: ["claude"],
+  monorepo: "per-project",
+  sourceLang: "en",
+  rules: [],
+  rulesInSubprojects: false,
+  hideInVsCode: true
+};
+var defaultsFile = () => path9.join(GLOBAL_DIR, "defaults.json");
+function readDefaults() {
+  try {
+    const saved = { ...BASE_DEFAULTS, ...JSON.parse(fs9.readFileSync(defaultsFile(), "utf8")) };
+    if (!isLang(saved.sourceLang)) saved.sourceLang = BASE_DEFAULTS.sourceLang;
+    if (!MAIN_DOCS.includes(saved.mainDoc)) saved.mainDoc = BASE_DEFAULTS.mainDoc;
+    if (saved.monorepo !== "single") saved.monorepo = "per-project";
+    return saved;
+  } catch {
+    return null;
+  }
+}
+function writeDefaults(defaults2) {
+  fs9.mkdirSync(GLOBAL_DIR, { recursive: true });
+  fs9.writeFileSync(defaultsFile(), JSON.stringify(defaults2, null, 2) + "\n");
+}
+
+// src/core/i18n.ts
+import crypto from "crypto";
+import fs11 from "fs";
+import path11 from "path";
+
+// src/core/langdetect.ts
+var STOPWORDS = {
+  en: ["the", "and", "is", "are", "of", "to", "in", "for", "with", "this", "that", "it", "on", "be", "as", "by", "not", "or", "from", "when", "each", "use", "should", "will", "can", "all", "has", "have", "which", "only"],
+  es: ["el", "la", "los", "las", "de", "del", "que", "y", "en", "un", "una", "para", "con", "por", "es", "son", "se", "como", "al", "lo", "m\xE1s", "pero", "su", "sus", "este", "esta", "cuando", "cada", "debe", "tambi\xE9n"],
+  fr: ["le", "la", "les", "de", "des", "du", "et", "est", "un", "une", "pour", "dans", "avec", "que", "qui", "en", "sur", "par", "pas", "au", "aux", "ce", "cette", "sont", "ou", "chaque", "doit", "quand", "aussi", "\xEAtre"],
+  pt: ["o", "os", "as", "de", "do", "da", "dos", "das", "que", "e", "em", "um", "uma", "para", "com", "por", "n\xE3o", "\xE9", "s\xE3o", "se", "como", "ao", "mais", "mas", "seu", "sua", "cada", "deve", "quando", "tamb\xE9m"],
+  de: ["der", "die", "das", "und", "ist", "sind", "ein", "eine", "zu", "den", "dem", "mit", "f\xFCr", "von", "auf", "nicht", "auch", "es", "im", "bei", "wird", "werden", "oder", "wenn", "jede", "jeder", "soll", "muss", "kann", "nur"],
+  it: ["il", "lo", "la", "gli", "le", "di", "del", "della", "che", "e", "\xE8", "un", "una", "per", "con", "non", "sono", "si", "come", "al", "alla", "pi\xF9", "ma", "suo", "questo", "questa", "quando", "ogni", "deve", "anche"]
+};
+var SETS = Object.fromEntries(Object.entries(STOPWORDS).map(([l, w]) => [l, new Set(w)]));
+function prose(md) {
+  return md.replace(/^---\r?\n[\s\S]*?\r?\n---/, " ").replace(/```[\s\S]*?```/g, " ").replace(/<!--[\s\S]*?-->/g, " ").replace(/`[^`]*`/g, " ").replace(/\]\([^)]*\)/g, " ").replace(/https?:\/\/\S+/g, " ").replace(/[|#>*_\-[\]()]/g, " ");
+}
+function detectLang(md) {
+  const words = prose(md).toLowerCase().match(/[\p{L}]+/gu) ?? [];
+  if (words.length < 25) return null;
+  const scores = Object.keys(SETS).map((lang) => ({ lang, hits: words.reduce((n, w) => n + (SETS[lang].has(w) ? 1 : 0), 0) }));
+  scores.sort((a, b) => b.hits - a.hits);
+  const [best, second] = scores;
+  if (best.hits < 6 || best.hits < second.hits * 1.5) return null;
+  return best.lang;
+}
+
+// src/core/rules.ts
+import fs10 from "fs";
+import path10 from "path";
+import YAML3 from "yaml";
+var rulesDir = () => path10.join(GLOBAL_DIR, "rules");
+var START = "<!-- markode:rules:start -->";
+var END = "<!-- markode:rules:end -->";
+var slugify = (s) => s.toLowerCase().normalize("NFD").replace(/[̀-ͯ]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+function seedRules() {
+  if (fs10.existsSync(rulesDir())) return;
+  fs10.mkdirSync(rulesDir(), { recursive: true });
+  const src = path10.join(TEMPLATES_DIR, "rules");
+  for (const f of fs10.readdirSync(src)) fs10.copyFileSync(path10.join(src, f), path10.join(rulesDir(), f));
+}
+function parseRule(id, text3) {
+  const m = text3.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  const meta = m ? YAML3.parse(m[1], { logLevel: "error" }) ?? {} : {};
+  return { id, title: meta.title ?? id, body: (m ? m[2] : text3).trim() };
+}
+function listRules() {
+  seedRules();
+  return fs10.readdirSync(rulesDir()).filter((f) => f.endsWith(".md")).map((f) => parseRule(f.slice(0, -3), fs10.readFileSync(path10.join(rulesDir(), f), "utf8"))).sort((a, b) => a.title.localeCompare(b.title));
+}
+function saveRule(rule) {
+  seedRules();
+  const id = rule.id || slugify(rule.title) || `rule-${Date.now()}`;
+  if (!/^[\w-]+$/.test(id)) throw new Error(`Invalid rule id: ${id}`);
+  const text3 = `---
+${YAML3.stringify({ title: rule.title }).trim()}
+---
+${rule.body.trim()}
+`;
+  fs10.writeFileSync(path10.join(rulesDir(), `${id}.md`), text3);
+  return { id, title: rule.title, body: rule.body.trim() };
+}
+function deleteRule(id) {
+  fs10.rmSync(path10.join(rulesDir(), `${path10.basename(id)}.md`), { force: true });
+}
+function appliedRuleIds(docText) {
+  const section2 = extractSection(docText);
+  if (!section2) return [];
+  return [...section2.matchAll(/<!-- rule:([\w-]+) -->/g)].map((m) => m[1]);
+}
+function extractSection(text3) {
+  const s = text3.indexOf(START);
+  const e = text3.indexOf(END);
+  return s >= 0 && e > s ? text3.slice(s, e + END.length) : null;
+}
+function writtenRules(docText) {
+  const section2 = extractSection(docText) ?? "";
+  const out = {};
+  for (const m of section2.matchAll(/<!-- rule:([\w-]+) -->\n([\s\S]*?)(?=\n+<!-- (?:rule:|markode:rules:end))/g)) out[m[1]] = { id: m[1], title: m[1], body: m[2].trim() };
+  return out;
+}
+function sourceLangOf(docText) {
+  const m = /<!-- markode:source-lang:(\w+) -->/.exec(extractSection(docText) ?? "");
+  return m && isLang(m[1]) ? m[1] : DEFAULT_SOURCE;
+}
+function projectSourceLang(root2, mainDoc) {
+  const doc = mainDoc ?? mainDocOf(root2);
+  if (!doc) return DEFAULT_SOURCE;
+  try {
+    return sourceLangOf(fs10.readFileSync(path10.join(root2, doc), "utf8"));
+  } catch {
+    return DEFAULT_SOURCE;
+  }
+}
+function renderSection(rules, sourceLang) {
+  const body = rules.map((r) => `<!-- rule:${r.id} -->
+${r.body}`).join("\n\n");
+  return [
+    START,
+    "## Working rules",
+    "",
+    "This project uses markode: follow `.claude/skills/markode/SKILL.md` when editing any `.md` file.",
+    "",
+    `<!-- markode:source-lang:${sourceLang} -->`,
+    `- Source language of every \`.md\` file: **${LANG_NAMES[sourceLang]}** (\`${sourceLang}\`).`,
+    ...body ? ["", body] : [],
+    END
+  ].join("\n");
+}
+function applyRules(docText, rules, sourceLang = sourceLangOf(docText)) {
+  const section2 = renderSection(rules, sourceLang);
+  const existing = extractSection(docText);
+  if (existing) return docText.replace(existing, () => section2);
+  return docText.replace(/\s*$/, "") + "\n\n" + section2 + "\n";
+}
+function applyRulesToFile(file, ids, sourceLang) {
+  const text3 = fs10.existsSync(file) ? fs10.readFileSync(file, "utf8") : "";
+  const all = listRules();
+  const written = writtenRules(text3);
+  const rules = (ids ?? appliedRuleIds(text3)).map((id) => all.find((r) => r.id === id) ?? written[id]).filter((r) => !!r);
+  fs10.writeFileSync(file, applyRules(text3, rules, sourceLang ?? sourceLangOf(text3)));
+}
+
+// src/core/i18n.ts
+var stateFile = (root2) => path11.join(stateDir(root2), "state.json");
+var translationPath = (root2, lang, rel) => path11.join(stateDir(root2), "i18n", lang, rel);
+var hash = (text3) => crypto.createHash("sha1").update(text3).digest("hex").slice(0, 12);
+var readText2 = (abs) => {
+  try {
+    return fs11.readFileSync(abs, "utf8");
+  } catch {
+    return null;
+  }
+};
+function readState(root2) {
+  try {
+    const raw = JSON.parse(fs11.readFileSync(stateFile(root2), "utf8"));
+    if (!raw.translations) return { translations: raw, keepLanguage: {} };
+    return { translations: raw.translations ?? {}, keepLanguage: raw.keepLanguage ?? {} };
+  } catch {
+    return { translations: {}, keepLanguage: {} };
+  }
+}
+function writeState(root2, state) {
+  fs11.mkdirSync(stateDir(root2), { recursive: true });
+  fs11.writeFileSync(stateFile(root2), JSON.stringify(state, null, 2) + "\n");
+}
+function fileStatus(root2, lang, rel) {
+  const source = readText2(path11.join(root2, rel));
+  const translation = readText2(translationPath(root2, lang, rel));
+  if (translation === null || source === null) return "missing";
+  const recorded = readState(root2).translations[lang]?.[rel];
+  if (!recorded) return "outdated";
+  const sourceChanged = hash(source) !== recorded.source;
+  const translationChanged = hash(translation) !== recorded.translation;
+  if (sourceChanged && translationChanged) return "conflict";
+  if (sourceChanged) return "outdated";
+  if (translationChanged) return "pending-sync";
+  return "synced";
+}
+function allStatuses(root2, lang) {
+  return flattenFiles(scanTree(root2)).map((f) => ({
+    path: f.path,
+    lang,
+    status: fileStatus(root2, lang, f.path),
+    translation: path11.relative(root2, translationPath(root2, lang, f.path))
+  }));
+}
+function foreignFiles(root2, sourceLang) {
+  const { keepLanguage: keepLanguage2 } = readState(root2);
+  const out = [];
+  for (const f of flattenFiles(scanTree(root2))) {
+    const text3 = readText2(path11.join(root2, f.path));
+    const detected = text3 ? detectLang(text3) : null;
+    if (detected && detected !== sourceLang && keepLanguage2[f.path] !== detected) out.push({ path: f.path, detected });
+  }
+  return out;
+}
+function syncReport(root2) {
+  const config = readConfig(root2);
+  const sourceLang = projectSourceLang(root2, config?.mainDoc);
+  const langs = (config?.langs ?? []).filter((l) => l !== sourceLang);
+  return {
+    sourceLang,
+    langs,
+    /** Language names by code: translate into these (codes added by hand have no built-in name). */
+    names: Object.fromEntries([sourceLang, ...langs].map((l) => [l, langName(l, config)])),
+    foreign: foreignFiles(root2, sourceLang),
+    files: langs.flatMap((l) => allStatuses(root2, l))
+  };
+}
+function markSynced(root2, lang, rel) {
+  const source = readText2(path11.join(root2, rel));
+  const translation = readText2(translationPath(root2, lang, rel));
+  if (source === null) throw new Error(`Source not found: ${rel}`);
+  if (translation === null) throw new Error(`Translation not found: ${path11.relative(root2, translationPath(root2, lang, rel))}`);
+  const state = readState(root2);
+  state.translations[lang] ??= {};
+  state.translations[lang][rel] = { source: hash(source), translation: hash(translation) };
+  writeState(root2, state);
+}
+function keepLanguage(root2, rel) {
+  const text3 = readText2(path11.join(root2, rel));
+  const detected = text3 ? detectLang(text3) : null;
+  if (!detected) throw new Error(`Could not detect the language of ${rel}`);
+  const state = readState(root2);
+  state.keepLanguage[rel] = detected;
+  writeState(root2, state);
+  return detected;
+}
+
+// src/core/wait.ts
+import fs12 from "fs";
+import path12 from "path";
+import YAML4 from "yaml";
+var waitsDir = (root2) => path12.join(stateDir(root2), "waits");
+var pidFile = (root2, rel) => path12.join(waitsDir(root2), `${encodeURIComponent(rel)}.pid`);
+var frontmatter = (text3) => {
+  try {
+    return YAML4.parse(/^---\r?\n([\s\S]*?)\r?\n---/.exec(text3)?.[1] ?? "", { logLevel: "error" }) ?? {};
+  } catch {
+    return {};
+  }
+};
+var isAlive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+};
+function waitingOn(root2) {
+  let names2 = [];
+  try {
+    names2 = fs12.readdirSync(waitsDir(root2)).filter((f) => f.endsWith(".pid"));
+  } catch {
+  }
+  return names2.flatMap((f) => {
+    const pid = Number(fs12.readFileSync(path12.join(waitsDir(root2), f), "utf8"));
+    return isAlive(pid) ? [decodeURIComponent(f.slice(0, -4))] : [];
+  });
+}
+function waitForAnswer(root2, rel) {
+  const abs = path12.join(root2, rel);
+  fs12.mkdirSync(waitsDir(root2), { recursive: true });
+  fs12.writeFileSync(pidFile(root2, rel), String(process.pid));
+  const cleanup = () => fs12.rmSync(pidFile(root2, rel), { force: true });
+  process.once("exit", cleanup);
+  for (const sig of ["SIGINT", "SIGTERM", "SIGHUP"]) process.once(sig, () => process.exit(130));
+  return new Promise((resolve) => {
+    const poll = () => {
+      let text3;
+      try {
+        text3 = fs12.readFileSync(abs, "utf8");
+      } catch {
+        return resolve("gone");
+      }
+      const fm = frontmatter(text3);
+      if (fm.type !== "proposal") return resolve("gone");
+      if (fm.status === "answered") return resolve("answered");
+      setTimeout(poll, 1500);
+    };
+    poll();
+  });
+}
+var COMMENT = /^\s*<!-- (comment|reply) by (.+?), (\d{4}-\d{2}-\d{2})(?:, on "((?:[^"\\]|\\.)*)")?:\s?([\s\S]*?)\s*-->\s*$/;
+function answerSummary(root2, rel) {
+  const text3 = fs12.readFileSync(path12.join(root2, rel), "utf8");
+  const fm = frontmatter(text3);
+  const body = text3.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, "");
+  const lines = body.split("\n");
+  const chosen = [];
+  const unanswered = [];
+  const comments = [];
+  const after = [];
+  let heading2 = "";
+  let question = "";
+  let group = null;
+  let inAfter = false;
+  let thread = [];
+  const closeGroup = () => {
+    if (group && !group.ticked) unanswered.push(group.label);
+    group = null;
+  };
+  const closeThread = () => {
+    const last = thread.at(-1);
+    if (last && last.author !== "AI") comments.push(`${last.author}${thread[0].quote ? ` on "${thread[0].quote}"` : ""}: ${last.text}`);
+    thread = [];
+  };
+  for (const line of lines) {
+    const c = COMMENT.exec(line);
+    if (c) {
+      if (c[1] === "comment") closeThread();
+      thread.push({ author: c[2], text: c[5].trim(), quote: c[4] ?? "" });
+      continue;
+    }
+    if (line.trim()) closeThread();
+    const h = /^#{1,6}\s+(.*)/.exec(line);
+    if (h) {
+      closeGroup();
+      heading2 = h[1].trim();
+      question = "";
+      inAfter = /^after your answer/i.test(heading2);
+      continue;
+    }
+    if (inAfter && line.trim()) after.push(line.trim().replace(/^([-*+]|\d+\.)\s+/, ""));
+    const q = /^\s*\d+\.\s+(.*\?)\s*$/.exec(line) ?? /^(\S.*[:?])\s*$/.exec(line);
+    if (q && !/^\s*[-*+] /.test(line)) {
+      closeGroup();
+      question = q[1].trim().replace(/:$/, "");
+    }
+    if (/^\s*<!--\s*choose:\s*one\s*-->/.test(line)) {
+      closeGroup();
+      group = { label: question || heading2, ticked: false };
+      continue;
+    }
+    const task = /^\s*[-*+] \[([ xX])\]\s*(.*)/.exec(line);
+    if (task) {
+      if (task[1] !== " ") {
+        chosen.push(`${question || heading2}: ${task[2].trim()}`);
+        if (group) group.ticked = true;
+      }
+    } else if (group && line.trim() && !/^\s/.test(line)) closeGroup();
+  }
+  closeGroup();
+  closeThread();
+  const section2 = (title, items) => items.length ? [`${title}:`, ...items.map((i) => `- ${i}`), ""] : [];
+  const affects = Array.isArray(fm.affects) ? fm.affects.map(String) : [];
+  return [
+    `Proposal ${rel} was answered.`,
+    "",
+    ...section2("Chosen", chosen),
+    ...section2("Not answered", unanswered),
+    ...section2("Comments waiting for your reply", comments),
+    ...section2("Affects", affects),
+    ...section2("After the answer, you planned to", after),
+    'Next: follow the markode-proposals skill ("When the user answers").'
+  ].join("\n");
+}
+
+// src/server/index.ts
+import fs15 from "fs";
+import http from "http";
+import path15 from "path";
+import { watch } from "chokidar";
+import open from "open";
+import pc from "picocolors";
+import { WebSocketServer } from "ws";
+
+// src/core/git.ts
+import { execFileSync } from "child_process";
+function git(root2, args2) {
+  try {
+    return execFileSync("git", ["-c", "core.quotepath=off", ...args2], { cwd: root2, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 32 * 1024 * 1024 });
+  } catch (err) {
+    return typeof err?.stdout === "string" && err.stdout ? err.stdout : null;
+  }
+}
+var isGitRepo = (root2) => git(root2, ["rev-parse", "--is-inside-work-tree"])?.trim() === "true";
+function gitStatuses(root2) {
+  const prefix = git(root2, ["rev-parse", "--show-prefix"])?.trim() ?? "";
+  const out = git(root2, ["status", "--porcelain=v1", "-z", "--untracked-files=all", "--", "."]);
+  const result = {};
+  if (!out) return result;
+  const parts = out.split("\0");
+  for (let i = 0; i < parts.length; i++) {
+    const entry = parts[i];
+    if (entry.length < 4) continue;
+    const code = entry.slice(0, 2);
+    let file = entry.slice(3);
+    if (code[0] === "R" || code[0] === "C") i++;
+    if (!file.toLowerCase().endsWith(".md")) continue;
+    if (prefix && file.startsWith(prefix)) file = file.slice(prefix.length);
+    if (file.startsWith(".markode/")) continue;
+    result[file] = code === "??" ? "U" : code.includes("D") ? "D" : code.includes("A") ? "A" : "M";
+  }
+  return result;
+}
+function gitDiff(root2, rel) {
+  const status = gitStatuses(root2)[rel];
+  if (status === "U") return git(root2, ["diff", "--no-index", "--", "/dev/null", rel]) ?? "";
+  const hasHead = git(root2, ["rev-parse", "--verify", "HEAD"]) !== null;
+  return git(root2, hasHead ? ["diff", "HEAD", "--", rel] : ["diff", "--cached", "--", rel]) ?? "";
+}
+
+// src/core/proposals.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import fs13 from "fs";
+import path13 from "path";
+var SKILL = path13.join(".claude", "skills", "markode-proposals");
+function proposalsState(root2) {
+  return { active: fs13.existsSync(path13.join(root2, SKILL, "SKILL.md")), layout: readConfig(root2)?.proposals ?? "general" };
+}
+var WHERE = {
+  general: "`docs/proposals/NNN-short-name.md` (NNN: the next number in that folder)",
+  structured: "`docs/proposals/<topic>/NNN-short-name.md`, one folder per topic (e.g. `sidebar`, `auth`); in a monorepo, a proposal for a single project goes in `<project>/docs/proposals/<topic>/` (e.g. `apps/web/docs/proposals/auth/`). Reuse an existing topic folder; ask the user before creating a new one"
+};
+function section(layout) {
+  return [
+    "## Proposals",
+    "",
+    "When an answer would be long, has options or a design to validate, or the user asks for one, write a",
+    "temporary proposal the user answers in markode instead of a chat answer (skill: `markode-proposals`).",
+    "",
+    `- Where: ${WHERE[layout]}.`,
+    "- After writing one, run `markode wait <path>` in the background: it returns when the user answers in markode.",
+    "- The user ticks options and comments (`<!-- comment by \u2026 -->`). When it is answered, reply to the comments,",
+    "  update every doc that depends on the decision (tasks, phases, architecture\u2026), then delete the proposal."
+  ].join("\n");
+}
+function mainDocs(root2, mainDoc) {
+  const doc = mainDoc ?? mainDocOf(root2);
+  return doc ? [path13.join(root2, doc)] : [];
+}
+function activateProposals(root2, layout, mainDoc) {
+  const dir = path13.join(root2, SKILL);
+  fs13.mkdirSync(dir, { recursive: true });
+  fs13.writeFileSync(path13.join(dir, "SKILL.md"), fill(fs13.readFileSync(path13.join(TEMPLATES_DIR, "proposals", "SKILL.md"), "utf8"), { where: WHERE[layout] }));
+  fs13.mkdirSync(path13.join(root2, "docs", "proposals"), { recursive: true });
+  for (const file of mainDocs(root2, mainDoc)) writeManagedBlock(file, section(layout), false, "proposals");
+  writeConfig(root2, { ...readConfig(root2) ?? { mainDoc, langs: [] }, proposals: layout });
+}
+function deactivateProposals(root2, mainDoc) {
+  fs13.rmSync(path13.join(root2, SKILL), { recursive: true, force: true });
+  for (const file of mainDocs(root2, mainDoc)) writeManagedBlock(file, null, false, "proposals");
+}
+function authorName(root2) {
+  try {
+    return execFileSync2("git", ["config", "user.name"], { cwd: root2, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+// src/core/skills.ts
+import fs14 from "fs";
+import os2 from "os";
+import path14 from "path";
+import YAML5 from "yaml";
+var SOURCE_DIRS = {
+  claude: [".claude", "skills"],
+  // Shared folder read by Codex, Copilot and Gemini CLI, and where `npx skills` installs.
+  agents: [".agents", "skills"],
+  codex: [".codex", "skills"],
+  gemini: [".gemini", "skills"],
+  copilot: [".copilot", "skills"],
+  cursor: [".cursor", "skills"]
+};
+var PROJECT_TARGETS = { claude: ".claude/skills", agents: ".agents/skills" };
+var sourceDir = (source) => path14.join(os2.homedir(), ...SOURCE_DIRS[source]);
+var display = (p3) => p3.startsWith(os2.homedir() + path14.sep) ? "~" + p3.slice(os2.homedir().length) : p3;
+function skillSources() {
+  return Object.keys(SOURCE_DIRS).map((id) => ({ id, path: display(sourceDir(id)), exists: fs14.existsSync(sourceDir(id)) }));
+}
+var tagsFile = () => path14.join(GLOBAL_DIR, "skills.json");
+function readTags() {
+  try {
+    return JSON.parse(fs14.readFileSync(tagsFile(), "utf8")).tags ?? {};
+  } catch {
+    return {};
+  }
+}
+function setSkillTags(name, tags) {
+  const all = readTags();
+  const clean = [...new Set(tags.map((t) => t.trim().toLowerCase()).filter(Boolean))];
+  if (clean.length) all[name] = clean;
+  else delete all[name];
+  fs14.mkdirSync(GLOBAL_DIR, { recursive: true });
+  fs14.writeFileSync(tagsFile(), JSON.stringify({ tags: all }, null, 2) + "\n");
+  return clean;
+}
+function findSkills(dir, source, managed, depth = 0) {
+  let entries;
+  try {
+    entries = fs14.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return entries.flatMap((e) => {
+    const abs = path14.join(dir, e.name);
+    let real;
+    try {
+      if (!fs14.statSync(abs).isDirectory()) return [];
+      real = fs14.realpathSync(abs);
+    } catch {
+      return [];
+    }
+    if (fs14.existsSync(path14.join(abs, "SKILL.md"))) return [{ dir: abs, real, source, managed }];
+    return depth < 2 ? findSkills(abs, source, managed || e.name === "synced" || e.name.startsWith("."), depth + 1) : [];
+  });
+}
+function frontmatter2(text3) {
+  const m = /^---\r?\n([\s\S]*?)\r?\n---/.exec(text3);
+  if (!m) return null;
+  try {
+    const data = YAML5.parse(m[1], { logLevel: "error" });
+    return data && typeof data === "object" ? data : null;
+  } catch {
+    return null;
+  }
+}
+function listFiles(dir) {
+  try {
+    return fs14.readdirSync(dir, { recursive: true, withFileTypes: true }).map((e) => ({ e, rel: path14.relative(dir, path14.join(e.parentPath ?? e.path ?? dir, e.name)).split(path14.sep).join("/") })).filter(({ e, rel }) => e.isFile() && rel !== "SKILL.md").map(({ rel }) => rel).sort().slice(0, 100);
+  } catch {
+    return [];
+  }
+}
+function listSkills(root2) {
+  const byReal = /* @__PURE__ */ new Map();
+  for (const source of Object.keys(SOURCE_DIRS)) {
+    for (const f of findSkills(sourceDir(source), source, false)) byReal.set(f.real, [...byReal.get(f.real) ?? [], f]);
+  }
+  const userTags = readTags();
+  const skills = [];
+  for (const [real, found] of byReal) {
+    const text3 = fs14.readFileSync(path14.join(real, "SKILL.md"), "utf8");
+    const fm = frontmatter2(text3);
+    const folder = path14.basename(found[0].dir);
+    const name = typeof fm?.name === "string" ? fm.name : folder;
+    const description = typeof fm?.description === "string" ? fm.description.trim() : "";
+    const issues = [];
+    if (!fm) issues.push("frontmatter");
+    else {
+      if (typeof fm.name !== "string" || !/^[a-z0-9]+(-[a-z0-9]+)*$/.test(fm.name) || fm.name.length > 64) issues.push("name");
+      else if (fm.name !== folder) issues.push("name-dir");
+      if (!description) issues.push("description");
+      else if (description.length > 1024) issues.push("description-long");
+    }
+    const declared = fm?.metadata?.tags;
+    const metaTags = Array.isArray(declared) ? declared.map(String) : typeof declared === "string" ? declared.split(",") : [];
+    skills.push({
+      key: real,
+      name,
+      folder,
+      description,
+      locations: found.map((f) => ({ source: f.source, path: display(f.dir) })),
+      managed: found.every((f) => f.managed),
+      files: listFiles(real),
+      tags: [.../* @__PURE__ */ new Set([...userTags[name] ?? [], ...metaTags.map((t) => t.trim().toLowerCase()).filter(Boolean)])],
+      issues,
+      installed: Object.keys(PROJECT_TARGETS).filter((t) => fs14.existsSync(path14.join(root2, PROJECT_TARGETS[t], folder, "SKILL.md")))
+    });
+  }
+  return skills.sort((a, b) => a.name.localeCompare(b.name));
+}
+function getSkill(root2, key) {
+  const skill = typeof key === "string" ? listSkills(root2).find((s) => s.key === key) : void 0;
+  if (!skill) throw Object.assign(new Error("Skill not found"), { code: "ENOENT" });
+  return skill;
+}
+function projectTargets(root2) {
+  const has2 = (p3) => fs14.existsSync(path14.join(root2, p3));
+  const out = [];
+  if (has2(".claude") || has2("CLAUDE.md")) out.push("claude");
+  if (has2(".agents") || has2("AGENTS.md") || has2(".codex") || has2(".gemini") || has2(".github/skills")) out.push("agents");
+  return out.length ? out : ["claude"];
+}
+function installSkill2(root2, skill, targets, overwrite) {
+  const dests = targets.map((t) => path14.join(root2, PROJECT_TARGETS[t], skill.folder));
+  const existing = dests.filter((d) => fs14.existsSync(d));
+  if (existing.length && !overwrite) return { conflict: existing.map((d) => path14.relative(root2, d).split(path14.sep).join("/")) };
+  for (const dest of dests) {
+    fs14.rmSync(dest, { recursive: true, force: true });
+    fs14.mkdirSync(path14.dirname(dest), { recursive: true });
+    fs14.cpSync(skill.key, dest, { recursive: true, dereference: true });
+  }
+  return { ok: true };
+}
+
+// src/server/index.ts
+var IMAGE_MIME = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".svg": "image/svg+xml",
+  ".bmp": "image/bmp",
+  ".ico": "image/x-icon"
+};
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript",
+  ".css": "text/css",
+  ".svg": "image/svg+xml",
+  ".json": "application/json",
+  ".woff2": "font/woff2"
+};
+var HttpError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
+async function readBody(req) {
+  let data = "";
+  for await (const chunk of req) data += chunk;
+  if (!data) return {};
+  if (!req.headers["content-type"]?.startsWith("application/json")) throw new HttpError(415, "Expected application/json");
+  return JSON.parse(data);
+}
+var LOCAL_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]"]);
+function isLocalRequest(req) {
+  const host = req.headers.host ?? "";
+  try {
+    if (!LOCAL_HOSTS.has(new URL(`http://${host}`).hostname)) return false;
+    return !req.headers.origin || new URL(req.headers.origin).host === host;
+  } catch {
+    return false;
+  }
+}
+async function startServer({ root: root2, port, open: openBrowser }) {
+  const config = () => readConfig(root2) ?? { mainDoc: null, langs: [] };
+  const sourceLang = () => projectSourceLang(root2, readConfig(root2)?.mainDoc);
+  const viewLang = (value) => isLangCode(value) && value !== sourceLang() && config().langs.includes(value) ? value : null;
+  const mdPath = (rel) => {
+    if (typeof rel !== "string" || !rel.toLowerCase().endsWith(".md")) throw new HttpError(400, "Expected a .md path");
+    safeResolve(root2, rel);
+    return rel;
+  };
+  const deletable = (rel) => {
+    if (typeof rel !== "string" || !rel.trim()) throw new HttpError(400, "Expected a path");
+    const abs = safeResolve(root2, rel);
+    if (abs === root2) throw new HttpError(400, "Refusing to delete the project root");
+    if (!fs15.existsSync(abs)) throw new HttpError(404, "Not found");
+    return abs;
+  };
+  const routes = {
+    "GET /api/info": () => {
+      const c = config();
+      return {
+        name: path15.basename(root2),
+        mainDoc: c.mainDoc ?? null,
+        sourceLang: sourceLang(),
+        langs: c.langs.filter((l) => l !== sourceLang()),
+        langNames: Object.fromEntries(c.langs.map((l) => [l, langName(l, c)])),
+        git: isGitRepo(root2),
+        proposals: proposalsState(root2),
+        author: authorName(root2),
+        unlinked: c.skipLink ? [] : missingMainDocs(root2)
+      };
+    },
+    "PUT /api/config": (_, body) => {
+      const c = config();
+      if (Array.isArray(body.langs)) c.langs = body.langs.filter(isLangCode);
+      if (body.langNames && typeof body.langNames === "object") {
+        for (const [code, name] of Object.entries(body.langNames))
+          if (isLangCode(code) && !isLang(code) && typeof name === "string" && name.trim()) c.langNames = { ...c.langNames, [code]: name.trim().slice(0, 40) };
+      }
+      if (isLang(body.sourceLang) && body.sourceLang !== sourceLang()) {
+        if (!c.mainDoc) throw new HttpError(400, "No main document configured; run `markode init`");
+        applyRulesToFile(path15.join(root2, c.mainDoc), void 0, body.sourceLang);
+      }
+      writeConfig(root2, c);
+      return { ...c, langs: c.langs.filter((l) => l !== sourceLang()) };
+    },
+    /** Add the CLAUDE.md / AGENTS.md a folder lacks, pointing to the other; or stop offering it. */
+    "POST /api/link": (_, body) => {
+      if (body.skip) return writeConfig(root2, { ...config(), skipLink: true }), { created: [] };
+      return { created: linkMainDocs(root2) };
+    },
+    "PUT /api/proposals": (_, body) => {
+      if (body.active) activateProposals(root2, body.layout === "structured" ? "structured" : "general", config().mainDoc);
+      else deactivateProposals(root2, config().mainDoc);
+      return proposalsState(root2);
+    },
+    /** Translation files behind their source, in every enabled language: work for `/markode translate`. */
+    "GET /api/translations": () => ({ pending: syncReport(root2).files.filter((f) => f.status !== "synced").length + foreignFiles(root2, sourceLang()).length }),
+    /** Proposals an agent is waiting on (`markode wait`): answering them wakes it up. */
+    "GET /api/waiting": () => ({ paths: waitingOn(root2) }),
+    "GET /api/settings": () => readSettings(),
+    "PUT /api/settings": (_, body) => writeSettings(body),
+    "GET /api/tree": (url2) => {
+      const l = viewLang(url2.searchParams.get("lang"));
+      const sync2 = l ? Object.fromEntries(allStatuses(root2, l).map((e) => [e.path, e.status])) : {};
+      const foreign = Object.fromEntries(foreignFiles(root2, sourceLang()).map((f) => [f.path, f.detected]));
+      return { tree: scanTree(root2), git: gitStatuses(root2), sync: sync2, foreign };
+    },
+    "POST /api/keep-language": (_, body) => ({ lang: keepLanguage(root2, mdPath(body.path)) }),
+    "GET /api/file": (url2) => {
+      const rel = mdPath(url2.searchParams.get("path"));
+      const l = viewLang(url2.searchParams.get("lang"));
+      const source = fs15.readFileSync(safeResolve(root2, rel), "utf8");
+      if (l) {
+        const tPath = translationPath(root2, l, rel);
+        if (fs15.existsSync(tPath)) return { path: rel, content: fs15.readFileSync(tPath, "utf8"), target: "translation", status: fileStatus(root2, l, rel) };
+        return { path: rel, content: source, target: "source", status: "missing" };
+      }
+      return { path: rel, content: source, target: "source", status: null };
+    },
+    "PUT /api/file": (_, body) => {
+      const rel = mdPath(body.path);
+      const l = viewLang(body.lang);
+      const file = body.target === "translation" && l ? translationPath(root2, l, rel) : safeResolve(root2, rel);
+      fs15.mkdirSync(path15.dirname(file), { recursive: true });
+      fs15.writeFileSync(file, String(body.content ?? ""));
+      return { ok: true, status: l ? fileStatus(root2, l, rel) : null };
+    },
+    "POST /api/file": (_, body) => {
+      const rel = mdPath(body.path);
+      const file = safeResolve(root2, rel);
+      if (fs15.existsSync(file)) throw new HttpError(409, "File already exists");
+      fs15.mkdirSync(path15.dirname(file), { recursive: true });
+      const title = path15.basename(rel, ".md").replace(/^\d+[-_]/, "").replace(/[-_]/g, " ");
+      fs15.writeFileSync(file, `# ${title.charAt(0).toUpperCase() + title.slice(1)}
+
+`);
+      return { ok: true, path: rel };
+    },
+    // Only a mkdir: nothing else is touched, so editors that have the project open are unaffected.
+    "POST /api/dir": (_, body) => {
+      if (typeof body.path !== "string" || !body.path.trim()) throw new HttpError(400, "Expected a path");
+      const dir = safeResolve(root2, body.path);
+      if (dir === root2) throw new HttpError(400, "Expected a path");
+      if (fs15.existsSync(dir)) throw new HttpError(409, "A file or folder with that name already exists");
+      fs15.mkdirSync(dir, { recursive: true });
+      return { ok: true, path: toPosix(path15.relative(root2, dir)) };
+    },
+    "GET /api/delete-preview": (url2) => {
+      const abs = deletable(url2.searchParams.get("path"));
+      if (!fs15.statSync(abs).isDirectory()) return { kind: "file", files: 1, md: 1 };
+      const files = fs15.readdirSync(abs, { recursive: true, withFileTypes: true }).filter((e) => e.isFile());
+      return { kind: "dir", files: files.length, md: files.filter((e) => e.name.toLowerCase().endsWith(".md")).length };
+    },
+    "DELETE /api/path": (url2) => {
+      const rel = toPosix(path15.relative(root2, deletable(url2.searchParams.get("path"))));
+      fs15.rmSync(safeResolve(root2, rel), { recursive: true });
+      for (const l of config().langs) fs15.rmSync(translationPath(root2, l, rel), { recursive: true, force: true });
+      return { ok: true };
+    },
+    "POST /api/ignore": (_, body) => {
+      safeResolve(root2, body.path);
+      setIgnored(root2, body.path, body.kind === "dir" ? "dir" : "file", !!body.ignored);
+      return { ok: true };
+    },
+    "GET /api/diff": (url2) => ({ diff: gitDiff(root2, mdPath(url2.searchParams.get("path"))) }),
+    "GET /api/dashboard": () => {
+      const sdd = summarizeSdd(root2);
+      const shown = sddPrefixes(sdd);
+      return { docs: summarize(root2).filter((d) => !shown.some((p3) => d.path.startsWith(p3))), sdd };
+    },
+    "GET /api/rules": () => {
+      const mainDoc = readConfig(root2)?.mainDoc;
+      const text3 = mainDoc && fs15.existsSync(path15.join(root2, mainDoc)) ? fs15.readFileSync(path15.join(root2, mainDoc), "utf8") : "";
+      return { rules: listRules(), applied: appliedRuleIds(text3), mainDoc: mainDoc ?? null };
+    },
+    "PUT /api/rules": (_, body) => saveRule(body),
+    "DELETE /api/rules": (url2) => {
+      deleteRule(url2.searchParams.get("id") ?? "");
+      return { ok: true };
+    },
+    // Global skills: reads and writes are limited to SKILL.md of discovered skill folders.
+    "GET /api/skills": () => ({ skills: listSkills(root2), sources: skillSources(), targets: projectTargets(root2) }),
+    "PUT /api/skills/tags": (_, body) => {
+      if (typeof body.name !== "string" || !Array.isArray(body.tags)) throw new HttpError(400, "Expected name and tags");
+      return { tags: setSkillTags(body.name, body.tags.map(String)) };
+    },
+    "GET /api/skills/file": (url2) => {
+      const skill = getSkill(root2, url2.searchParams.get("key"));
+      return { path: skill.key, content: fs15.readFileSync(path15.join(skill.key, "SKILL.md"), "utf8"), target: "source", status: null };
+    },
+    "PUT /api/skills/file": (_, body) => {
+      const skill = getSkill(root2, body.key);
+      if (skill.managed) throw new HttpError(403, "This skill is managed by the app that installed it");
+      fs15.writeFileSync(path15.join(skill.key, "SKILL.md"), String(body.content ?? ""));
+      return { ok: true, status: null };
+    },
+    "POST /api/skills/install": (_, body) => {
+      const targets = (Array.isArray(body.targets) ? body.targets : []).filter((t) => typeof t === "string" && t in PROJECT_TARGETS);
+      if (!targets.length) throw new HttpError(400, "Expected at least one target");
+      const result = installSkill2(root2, getSkill(root2, body.key), targets, !!body.overwrite);
+      if (result.conflict) throw new HttpError(409, result.conflict.join(", "));
+      return result;
+    },
+    "POST /api/rules/apply": (_, body) => {
+      const mainDoc = readConfig(root2)?.mainDoc;
+      if (!mainDoc) throw new HttpError(400, "No main document configured; run `markode init`");
+      applyRulesToFile(path15.join(root2, mainDoc), body.ids ?? []);
+      return { ok: true };
+    }
+  };
+  const server = http.createServer(async (req, res) => {
+    if (!isLocalRequest(req)) {
+      res.writeHead(403).end("Forbidden");
+      return;
+    }
+    const url2 = new URL(req.url ?? "/", "http://localhost");
+    const route = routes[`${req.method} ${url2.pathname}`];
+    if (route) {
+      try {
+        const result = await route(url2, req.method === "GET" || req.method === "DELETE" ? {} : await readBody(req));
+        res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify(result));
+      } catch (err) {
+        const status = err instanceof HttpError ? err.status : err.code === "ENOENT" ? 404 : 500;
+        res.writeHead(status, { "content-type": "application/json" }).end(JSON.stringify({ error: err.message }));
+      }
+      return;
+    }
+    if (req.method === "GET" && url2.pathname === "/api/asset") return serveAsset(url2.searchParams.get("path") ?? "", res);
+    serveStatic(url2.pathname, res);
+  });
+  function serveAsset(rel, res) {
+    let file;
+    try {
+      file = safeResolve(root2, rel);
+    } catch {
+      res.writeHead(404).end();
+      return;
+    }
+    const type = IMAGE_MIME[path15.extname(file).toLowerCase()];
+    if (!type || !fs15.existsSync(file) || !fs15.statSync(file).isFile()) {
+      res.writeHead(404).end();
+      return;
+    }
+    res.writeHead(200, { "content-type": type, "cache-control": "no-cache", "content-security-policy": "sandbox", "x-content-type-options": "nosniff" });
+    fs15.createReadStream(file).pipe(res);
+  }
+  const actualPort = await listen(server, port);
+  const wss = new WebSocketServer({ server, path: "/ws", verifyClient: ({ req }) => isLocalRequest(req) });
+  const broadcast = (msg) => {
+    const data = JSON.stringify(msg);
+    for (const client of wss.clients) client.send(data);
+  };
+  const skips = watchSkips(root2);
+  watch(root2, {
+    ignoreInitial: true,
+    // Unreadable folders (e.g. caches owned by another user) are skipped instead of failing.
+    ignorePermissionErrors: true,
+    ignored: (p3, stats) => {
+      const rel = toPosix(path15.relative(root2, p3));
+      if (rel === ".markode") return false;
+      if (rel.startsWith(".markode/")) return !rel.startsWith(".markode/i18n") && rel !== ".markode/state.json" && rel !== ".markode/config.json";
+      return skips(rel, stats ? stats.isDirectory() : void 0);
+    }
+  }).on("error", (err) => console.warn(pc.yellow(`  file watcher: ${err.message}`))).on("all", (event, file) => {
+    const abs = path15.resolve(file);
+    if (!abs.endsWith(".md") && !abs.endsWith(".json") && !abs.endsWith(".markodeignore") && event !== "addDir" && event !== "unlinkDir") return;
+    let rel = toPosix(path15.relative(root2, abs));
+    const i18n = toPosix(path15.relative(root2, path15.join(stateDir(root2), "i18n")));
+    if (rel.startsWith(i18n + "/")) rel = rel.split("/").slice(3).join("/");
+    broadcast({ type: "fs", event, path: rel });
+  });
+  const url = `http://localhost:${actualPort}`;
+  console.log(`
+  ${pc.bold("markode")} ${pc.dim("\u2192")} ${pc.cyan(url)}  ${pc.dim(root2)}
+`);
+  if (!fs15.existsSync(WEB_DIR)) console.log(pc.yellow("  Web UI not built: run `pnpm build`, or `pnpm dev` and open http://localhost:4320\n"));
+  else if (openBrowser) open(url).catch(() => {
+  });
+}
+function listen(server, port) {
+  return new Promise((resolve, reject) => {
+    server.once("error", (err) => {
+      if (err.code === "EADDRINUSE") resolve(listen(server, port + 1));
+      else reject(err);
+    });
+    server.listen(port, "127.0.0.1", () => resolve(port));
+  });
+}
+function serveStatic(pathname, res) {
+  let file = path15.join(WEB_DIR, path15.normalize(pathname).replace(/^(\.\.[/\\])+/, ""));
+  if (!file.startsWith(WEB_DIR) || !fs15.existsSync(file) || fs15.statSync(file).isDirectory()) file = path15.join(WEB_DIR, "index.html");
+  if (!fs15.existsSync(file)) {
+    res.writeHead(404).end("Web UI not built. Run `pnpm build`.");
+    return;
+  }
+  res.writeHead(200, { "content-type": MIME[path15.extname(file)] ?? "application/octet-stream" });
+  fs15.createReadStream(file).pipe(res);
+}
+
+// src/cli/init.ts
+import fs16 from "fs";
+import path16 from "path";
+import * as p from "@clack/prompts";
+import pc2 from "picocolors";
+function check(value) {
+  if (p.isCancel(value)) {
+    p.cancel("Cancelled.");
+    process.exit(0);
+  }
+  return value;
+}
+async function offerClaudeLink(root2, d) {
+  if (fs16.existsSync(path16.join(root2, "CLAUDE.md"))) return;
+  const link2 = d ? d.mainDoc === "CLAUDE.md" : check(await p.confirm({ message: "Claude Code reads CLAUDE.md, not AGENTS.md. Add a CLAUDE.md that imports AGENTS.md?", initialValue: true }));
+  if (link2 && linkAgentsDoc(root2)) p.log.success("Created CLAUDE.md (imports AGENTS.md)");
+}
+async function chooseMainDoc(root2, d) {
+  const existing = MAIN_DOCS.filter((d2) => fs16.existsSync(path16.join(root2, d2)) && !isPointer(fs16.readFileSync(path16.join(root2, d2), "utf8"), d2));
+  if (d) {
+    if (existing.length === 1 && existing[0] === "AGENTS.md") await offerClaudeLink(root2, d);
+    if (existing.length) return existing.includes(d.mainDoc) ? d.mainDoc : existing[0];
+    createMainDoc(root2, d.mainDoc);
+    p.log.success(`Created ${d.mainDoc}`);
+    return d.mainDoc;
+  }
+  if (existing.length === 2) {
+    return check(
+      await p.select({
+        message: "Both CLAUDE.md and AGENTS.md exist. Which one is the main document?",
+        options: existing.map((d2) => ({ value: d2, label: d2 }))
+      })
+    );
+  }
+  if (existing.length === 1) {
+    const choice2 = check(
+      await p.select({
+        message: `Found ${pc2.cyan(existing[0])}. Use it as the main document?`,
+        options: [
+          { value: existing[0], label: `Yes, use ${existing[0]}` },
+          ...MAIN_DOCS.filter((d2) => d2 !== existing[0]).map((d2) => ({ value: d2, label: `No, create ${d2}` }))
+        ]
+      })
+    );
+    createMainDoc(root2, choice2);
+    if (choice2 === "AGENTS.md") await offerClaudeLink(root2, d);
+    return choice2;
+  }
+  const choice = check(
+    await p.select({
+      message: "No CLAUDE.md or AGENTS.md found. Which one should I create?",
+      options: MAIN_DOCS.map((d2) => ({ value: d2, label: d2, hint: d2 === "CLAUDE.md" ? "Claude Code" : "other agents" }))
+    })
+  );
+  createMainDoc(root2, choice);
+  p.log.success(`Created ${choice}`);
+  return choice;
+}
+var WORKFLOW_OPTIONS = [
+  { value: "none", label: "None" },
+  { value: "markode", label: "markode method", hint: "one file per task; vision, architecture and phases as they are needed; per project in monorepos" },
+  { value: "openspec", label: "OpenSpec", hint: "specs + proposed changes, good for existing projects" },
+  { value: "speckit", label: "GitHub Spec Kit", hint: "constitution \u2192 spec \u2192 plan \u2192 tasks, per feature" }
+];
+var PROPOSALS_QUESTION = "The AI can write proposals you answer by ticking options and commenting. How should they be organized?";
+var PROPOSAL_OPTIONS = [
+  { value: "structured", label: "By topic and area", hint: "docs/proposals/auth/\u2026, services/docs/proposals/\u2026" },
+  { value: "general", label: "One folder", hint: "docs/proposals/" }
+];
+var MONOREPO_QUESTION = "How should the docs of a monorepo be organized?";
+var MONOREPO_OPTIONS = [
+  { value: "per-project", label: "One set per project", hint: "each project: its CLAUDE.md/AGENTS.md, architecture, tasks and proposals; the root main doc is the overview" },
+  { value: "single", label: "One docs/ for everything", hint: "at the root" }
+];
+var SOURCE_LANG_QUESTION = "Language you work in (every .md file is written in it)";
+var SOURCE_LANG_MARK = /<!-- markode:source-lang:\w+ -->/;
+var LANG_OPTIONS = LANGS.map((l) => ({ value: l, label: LANG_NAMES[l], hint: l === "en" ? "default" : void 0 }));
+var HIDE_QUESTION = "Hide the .markode/ folder in VS Code?";
+var ruleOptions = (rules) => rules.map((r) => ({ value: r.id, label: r.title, hint: r.body.split("\n")[0].replace(/^- /, "") }));
+async function chooseRules(message, rules, initial) {
+  const pick = check(
+    await p.select({
+      message,
+      options: [
+        { value: "none", label: "None", hint: "start from scratch; add your own later in the Rules tab" },
+        { value: "pick", label: "Choose rules", hint: "common rules for AI agents, plus the ones you create" }
+      ],
+      initialValue: initial.length ? "pick" : "none"
+    })
+  );
+  if (pick === "none") return [];
+  return check(await p.multiselect({ message: "Which rules?", options: ruleOptions(rules), initialValues: initial, required: false }));
+}
+var agentOptions = () => Object.keys(SDD_AGENTS).map((a) => ({ value: a, label: SDD_AGENTS[a].label }));
+var WORKFLOW_LABEL = { none: "None", markode: "markode", openspec: "OpenSpec", speckit: "GitHub Spec Kit" };
+var WORKFLOW_GUIDE = { none: "", markode: ".claude/skills/markode-method/SKILL.md", openspec: "openspec/README.md", speckit: "specs/README.md" };
+var canAsk = () => !!process.stdin.isTTY;
+async function chooseAreas(root2, d) {
+  const { dirs: candidates, unsure } = detectAreas(root2);
+  if (!candidates.length) return [];
+  if (unsure && canAsk()) {
+    const separate = check(
+      await p.confirm({
+        message: `${candidates.map((c) => `${c}/`).join(", ")} each have their own manifest. Are they separate projects (e.g. a front end and a back end)?`,
+        initialValue: true
+      })
+    );
+    if (!separate) return [];
+  }
+  if (d) {
+    const used2 = /* @__PURE__ */ new Set();
+    return d.monorepo === "single" ? [] : candidates.map((dir) => ({ dir, prefix: suggestPrefix(dir, used2) }));
+  }
+  p.log.info(`Monorepo detected: ${candidates.map((c) => `${c}/`).join(", ")}`);
+  const layout = check(await p.select({ message: MONOREPO_QUESTION, options: MONOREPO_OPTIONS }));
+  if (layout === "single") return [];
+  const dirs2 = check(
+    await p.multiselect({
+      message: "Which projects get their own docs?",
+      options: candidates.map((d2) => ({ value: d2, label: `${d2}/` })),
+      initialValues: candidates,
+      required: false
+    })
+  );
+  const used = /* @__PURE__ */ new Set();
+  const areas = dirs2.map((dir) => ({ dir, prefix: suggestPrefix(dir, used) }));
+  if (!areas.length) return areas;
+  const ok = check(await p.confirm({ message: `Task prefixes: ${areas.map((a) => `${a.dir} \u2192 ${a.prefix}`).join(", ")}, across projects \u2192 CORE. Use them?`, initialValue: true }));
+  if (ok) return areas;
+  for (const a of areas) {
+    a.prefix = check(
+      await p.text({
+        message: `Task prefix for ${a.dir}/`,
+        initialValue: a.prefix,
+        validate: (v) => /^[A-Z][A-Z0-9]{0,5}$/.test(v ?? "") && v !== "CORE" && !areas.some((o) => o !== a && o.prefix === v) ? void 0 : "Uppercase letters and digits, unique, not CORE"
+      })
+    );
+  }
+  return areas;
+}
+async function chooseKind(root2, dir) {
+  const guess = guessKind(path16.join(root2, dir));
+  if (!guess.unclear || !canAsk()) return guess.kind;
+  const where = dir ? `${dir}/` : "this project";
+  const seen = guess.signals.length ? `found: ${guess.signals.join(", ")}` : "no code yet";
+  return check(
+    await p.select({
+      message: `What kind of project is ${where}? (${seen})`,
+      options: Object.keys(KIND_LABEL).map((k) => ({ value: k, label: KIND_LABEL[k], hint: KIND_HINT[k] })),
+      initialValue: guess.kind
+    })
+  );
+}
+async function askProfile(root2, dir, kind, d) {
+  const base = detectProfile(path16.join(root2, dir), kind);
+  if (d || kind === "app") return base;
+  const where = dir ? ` (${dir}/)` : "";
+  if (kind === "library") return { kind, published: check(await p.confirm({ message: `Is the library${where} published (npm, PyPI\u2026)?`, initialValue: base.published })) };
+  if (kind === "mobile") {
+    const platforms = check(
+      await p.multiselect({
+        message: `Target platforms${where}`,
+        options: ["ios", "android", "web"].map((v) => ({ value: v, label: v === "ios" ? "iOS" : v === "android" ? "Android" : "Web" })),
+        initialValues: base.platforms,
+        required: false
+      })
+    );
+    return { kind, platforms };
+  }
+  if (kind === "data") {
+    const dataLocation = check(await p.text({ message: `Where does the data live${where}? (folder, bucket, database; empty if not decided)`, initialValue: base.dataLocation, defaultValue: "" }));
+    const experiments = check(
+      await p.select({
+        message: "How are experiments tracked?",
+        options: Object.keys(EXPERIMENTS_LABEL).map((v) => ({ value: v, label: EXPERIMENTS_LABEL[v].replace(/`/g, "") })),
+        initialValue: base.experiments
+      })
+    );
+    return { kind, dataLocation: dataLocation.trim(), experiments };
+  }
+  const environments = check(await p.text({ message: `Environments${where}`, initialValue: base.environments, defaultValue: base.environments }));
+  return { kind, environments: environments.trim() };
+}
+async function chooseContracts(root2, areas, d) {
+  if (!looksLikeMicroservices(root2, areas.length)) return null;
+  const found = findContracts(root2);
+  if (d && found || !canAsk()) return found;
+  const answer = check(
+    await p.text({
+      message: "Several services: where do their contracts (APIs, events) live? (e.g. proto/, an OpenAPI file; empty if none)",
+      initialValue: found ?? "",
+      defaultValue: ""
+    })
+  );
+  return answer.trim() || null;
+}
+async function chooseExisting(root2, d) {
+  const found = existingDocs(root2);
+  if (!found.length || d) return found;
+  return check(
+    await p.multiselect({
+      message: "These docs already exist. Which are the official ones? (the agent updates them instead of creating new ones)",
+      options: found.map((f) => ({ value: f, label: f })),
+      initialValues: found,
+      required: false
+    })
+  );
+}
+async function chooseWorkflow(root2, mainDoc, previous, d) {
+  const detected = detectWorkflow(root2);
+  if (detected) {
+    p.log.info(`${WORKFLOW_LABEL[detected]} found: markode shows it in the dashboard.`);
+    return { workflow: detected };
+  }
+  for (; ; ) {
+    const choice = d ? d.workflow : check(await p.select({ message: "Create a base structure for specs and planning?", options: WORKFLOW_OPTIONS, initialValue: previous ?? "none" }));
+    if (choice === "none") return { workflow: choice };
+    if (choice === "markode") {
+      const existing = await chooseExisting(root2, d);
+      const areas = await chooseAreas(root2, d);
+      for (const a of areas) a.profile = await askProfile(root2, a.dir, await chooseKind(root2, a.dir), d);
+      const contracts = await chooseContracts(root2, areas, d);
+      const profile = areas.length ? void 0 : await askProfile(root2, "", await chooseKind(root2, ""), d);
+      const created = scaffoldMethod(root2, mainDoc, areas);
+      installMethodSkills(root2);
+      const big = !areas.length && flattenFiles(scanTree(root2)).length > 40;
+      const layout = areas.length ? "structured" : !big || d ? "general" : check(await p.select({ message: PROPOSALS_QUESTION, options: PROPOSAL_OPTIONS }));
+      activateProposals(root2, layout, mainDoc);
+      if (created.length) p.log.success(`Created ${created.length} files: ${created.slice(0, 8).join(", ")}${created.length > 8 ? "\u2026" : ""}`);
+      p.log.info(`Docs grow when there is something to write. Skills: /markode-status, /markode-new-task, /markode-close-session.`);
+      return { workflow: choice, section: methodSection(areas, root2, { profile, contracts, existing }) };
+    }
+    let official = true;
+    if (choice === "speckit" && !hasUv() && d) {
+      p.log.warn("Spec Kit needs uv (Python) to install its AI commands, and uv was not found: creating the structure only.");
+      official = false;
+    } else if (choice === "speckit" && !hasUv()) {
+      const next = check(
+        await p.select({
+          message: "Spec Kit needs uv (Python) to install its AI commands, and uv was not found.",
+          options: [
+            { value: "back", label: "Choose another option" },
+            { value: "skeleton", label: "Create the structure only", hint: "the guide explains how to install Spec Kit later" }
+          ]
+        })
+      );
+      if (next === "back") continue;
+      official = false;
+    }
+    const initial = mainDoc === "AGENTS.md" ? "codex" : "claude";
+    const agents = !official ? [initial] : d ? choice === "speckit" ? [d.agents[0] ?? initial] : d.agents : choice === "openspec" ? check(await p.multiselect({ message: "Install the OpenSpec commands for which agents?", options: agentOptions(), initialValues: [initial], required: false })) : [check(await p.select({ message: "Install the Spec Kit commands for which agent?", options: agentOptions(), initialValue: initial }))];
+    const spin = p.spinner();
+    spin.start(official ? `Installing ${WORKFLOW_LABEL[choice]}\u2026` : "Creating the structure\u2026");
+    const res = installWorkflow(root2, choice, agents, official);
+    spin.stop(res.official ? `${WORKFLOW_LABEL[choice]} installed` : "Structure created");
+    if (official && !res.official) p.log.warn(`Couldn't run the ${WORKFLOW_LABEL[choice]} installer:
+${pc2.dim(res.error ?? "")}
+Created the structure only.`);
+    if (!res.official) p.log.info(`To add the AI commands later, see ${pc2.cyan(WORKFLOW_GUIDE[choice])}.`);
+    if (res.ignored.length) p.log.info(`Agent commands hidden in markode (${res.ignored.length} folders); the eye button in the sidebar shows them.`);
+    return { workflow: choice };
+  }
+}
+async function runInit(root2, d = null) {
+  p.intro(pc2.bgCyan(pc2.black(" markode ")));
+  if (d) p.log.info(`Using your defaults (${pc2.cyan(defaultsFile())}). To choose differently for this project: ${pc2.cyan("markode init --custom")}`);
+  const previous = readConfig(root2);
+  const mainDoc = await chooseMainDoc(root2, d);
+  const mainFile = path16.join(root2, mainDoc);
+  const { workflow, section: section2 } = await chooseWorkflow(root2, mainDoc, previous?.workflow, d);
+  applyWorkflowToFile(mainFile, workflow, section2);
+  const mainText = fs16.readFileSync(mainFile, "utf8");
+  const sourceLang = d ? SOURCE_LANG_MARK.test(mainText) ? sourceLangOf(mainText) : d.sourceLang : check(await p.select({ message: SOURCE_LANG_QUESTION, options: LANG_OPTIONS, initialValue: sourceLangOf(mainText) }));
+  const langs = (previous?.langs ?? []).filter((l) => l !== sourceLang);
+  const rules = listRules();
+  const applied = appliedRuleIds(mainText);
+  const selected = d ? [.../* @__PURE__ */ new Set([...applied, ...d.rules.filter((id) => rules.some((r) => r.id === id))])] : await chooseRules("Working rules for this project", rules, applied);
+  applyRulesToFile(mainFile, selected, sourceLang);
+  const subprojects = findSubprojects(scanTree(root2));
+  if (subprojects.length && selected.length) {
+    const targets = d ? d.rulesInSubprojects ? subprojects : [] : check(
+      await p.multiselect({
+        message: "Monorepo detected. Apply the same rules to these projects too?",
+        options: subprojects.map((s) => ({ value: s, label: s })),
+        required: false
+      })
+    );
+    for (const dir of targets) {
+      applyRulesToFile(contentDoc(path16.join(root2, dir)), selected, sourceLang);
+    }
+  }
+  ensureGitignore(root2);
+  if (!previous?.initializedAt) {
+    const hide = d ? d.hideInVsCode : check(await p.confirm({ message: HIDE_QUESTION, initialValue: true }));
+    if (hide && !hideInVsCode(root2)) p.log.warn('.vscode/settings.json has comments; add "**/.markode": true to files.exclude by hand.');
+  }
+  installSkill(root2);
+  const config = { mainDoc, langs, langNames: previous?.langNames, workflow, proposals: readConfig(root2)?.proposals, skipLink: previous?.skipLink, initializedAt: previous?.initializedAt ?? (/* @__PURE__ */ new Date()).toISOString() };
+  writeConfig(root2, config);
+  p.outro(`Ready. Skill installed in ${pc2.cyan(".claude/skills/markode")}. To review the docs in another language: ${pc2.cyan("markode translate")}`);
+  return config;
+}
+async function runSetup(quick = false) {
+  const previous = readDefaults() ?? BASE_DEFAULTS;
+  if (quick) {
+    const d2 = { ...previous, mode: "ask" };
+    writeDefaults(d2);
+    return d2;
+  }
+  p.intro(pc2.bgCyan(pc2.black(" markode setup ")));
+  const mode = check(
+    await p.select({
+      message: "How should markode set up your projects?",
+      options: [
+        { value: "defaults", label: "With my answers", hint: "asked now, once; every project uses them" },
+        { value: "ask", label: "Ask in each project" }
+      ],
+      initialValue: previous.mode === "ask" && !readDefaults() ? "defaults" : previous.mode
+    })
+  );
+  if (mode === "ask") {
+    const d2 = { ...previous, mode };
+    writeDefaults(d2);
+    p.outro(`Saved. Each project will ask its own questions. Change it with ${pc2.cyan("markode setup")}`);
+    return d2;
+  }
+  const mainDoc = check(
+    await p.select({
+      message: "Main document to create when a project has none",
+      options: MAIN_DOCS.map((d2) => ({ value: d2, label: d2, hint: d2 === "CLAUDE.md" ? "Claude Code" : "other agents" })),
+      initialValue: previous.mainDoc
+    })
+  );
+  const workflow = check(await p.select({ message: "Base structure for specs and planning", options: WORKFLOW_OPTIONS, initialValue: previous.workflow }));
+  let agents = previous.agents;
+  let monorepo = previous.monorepo;
+  if (workflow === "openspec")
+    agents = check(await p.multiselect({ message: "Install the OpenSpec commands for which agents?", options: agentOptions(), initialValues: previous.agents, required: false }));
+  if (workflow === "speckit") agents = [check(await p.select({ message: "Install the Spec Kit commands for which agent?", options: agentOptions(), initialValue: previous.agents[0] }))];
+  if (workflow === "markode") monorepo = check(await p.select({ message: MONOREPO_QUESTION, options: MONOREPO_OPTIONS, initialValue: previous.monorepo }));
+  const sourceLang = check(await p.select({ message: `${SOURCE_LANG_QUESTION}; projects that already declare one keep it`, options: LANG_OPTIONS, initialValue: previous.sourceLang }));
+  const rules = listRules();
+  const selected = await chooseRules("Working rules for your projects", rules, previous.rules.filter((id) => rules.some((r) => r.id === id)));
+  const rulesInSubprojects = selected.length ? check(await p.confirm({ message: "In monorepos, apply the rules to the subprojects too?", initialValue: previous.rulesInSubprojects })) : false;
+  const hideInVsCode2 = check(await p.confirm({ message: HIDE_QUESTION, initialValue: previous.hideInVsCode }));
+  const d = { mode, mainDoc, workflow, agents, monorepo, sourceLang, rules: selected, rulesInSubprojects, hideInVsCode: hideInVsCode2 };
+  writeDefaults(d);
+  p.outro(`Saved in ${pc2.cyan(defaultsFile())}. Change them with ${pc2.cyan("markode setup")}; for a single project: ${pc2.cyan("markode init --custom")}`);
+  return d;
+}
+
+// src/cli/translate.ts
+import * as p2 from "@clack/prompts";
+import pc3 from "picocolors";
+function check2(value) {
+  if (p2.isCancel(value)) {
+    p2.cancel("Cancelled.");
+    process.exit(0);
+  }
+  return value;
+}
+var OTHER = "__other__";
+async function runTranslate(root2) {
+  const config = readConfig(root2);
+  if (!config) {
+    console.log(`Run ${pc3.cyan("markode init")} first.`);
+    process.exitCode = 1;
+    return;
+  }
+  p2.intro(pc3.bgCyan(pc3.black(" markode translate ")));
+  const source = projectSourceLang(root2, config.mainDoc);
+  const custom = config.langs.filter((l) => !isLang(l));
+  const picked = check2(
+    await p2.multiselect({
+      message: `Languages to review the docs in (the files stay in ${langName(source)})`,
+      options: [
+        ...LANGS.filter((l) => l !== source).map((l) => ({ value: l, label: LANG_NAMES[l] })),
+        ...custom.map((l) => ({ value: l, label: `${langName(l, config)} (${l})`, hint: "interface in English" })),
+        { value: OTHER, label: "Another language\u2026", hint: "type it; the interface stays in English" }
+      ],
+      initialValues: config.langs.filter((l) => l !== source),
+      required: false
+    })
+  );
+  const langs = picked.filter((l) => l !== OTHER);
+  const names2 = { ...config.langNames ?? {} };
+  if (picked.includes(OTHER)) {
+    for (; ; ) {
+      const name = check2(await p2.text({ message: "Language name (as the AI should understand it)", placeholder: "Japanese", validate: (v) => v?.trim() ? void 0 : "Type a language" })).trim();
+      const code = check2(
+        await p2.text({
+          message: `Short code for ${name} (folder name of its translations)`,
+          initialValue: name.slice(0, 2).toLowerCase(),
+          validate: (v) => !isLangCode(v) ? "Two or three letters, e.g. ja or zh-tw" : v === source || langs.includes(v) ? "Already in the list" : void 0
+        })
+      ).toLowerCase();
+      langs.push(code);
+      names2[code] = name;
+      if (!check2(await p2.confirm({ message: "Add another language?", initialValue: false }))) break;
+    }
+  }
+  writeConfig(root2, { ...config, langs, langNames: names2 });
+  if (!langs.length) {
+    p2.outro("No translation languages: markode shows the docs in their source language only.");
+    return;
+  }
+  p2.outro(
+    [
+      `Translations: ${langs.map((l) => langName(l, { ...config, langNames: names2 })).join(", ")}.`,
+      `Ask your agent for ${pc3.cyan("/markode translate")} to translate the docs; then pick the language at the top of markode.`,
+      ...langs.some((l) => !isLang(l)) ? ["Menus stay in English for languages typed by hand."] : []
+    ].join("\n")
+  );
+}
+
+// src/cli/index.ts
+var HELP = `markode \u2014 visual editor for your project's Markdown
+
+Usage
+  markode                 init if needed, then open the editor
+  markode init            (re)run the project setup: main doc, specs structure, rules, languages
+  markode setup           choose how projects are set up: with your saved answers, or asking each time
+  markode serve           open the editor without running init
+  markode translate       choose languages to review the docs in (or: markode --translate)
+  markode check [--json]  what /markode sync fixes: answered proposals, phases vs tasks, projects table, broken links
+  markode wait <proposal> wait until the user answers a proposal in markode, then print the answer
+  markode link [--dry-run] where there is only CLAUDE.md or only AGENTS.md, add the other one pointing to it
+  markode link --skip     don't offer it again in this project
+
+For the agent's /markode translate:
+  markode translate --status [--json]                    translations + files not in the source language
+  markode translate --mark [--lang xx] <path...>|--all   record translations as in sync
+  markode translate --keep <path...>                     keep files in their current language
+
+Options
+  -v, --version  print the version
+  -D           first run: skip saving defaults; every project asks its own questions
+  --custom     init: ask every question for this project, ignoring your defaults
+  --port <n>   server port (default 4319)
+  --no-open    do not open the browser
+`;
+var args = process.argv.slice(2);
+var flag = (name) => args.includes(name);
+var option = (name) => {
+  const i = args.indexOf(name);
+  return i >= 0 ? args[i + 1] : void 0;
+};
+var command = args[0] && !args[0].startsWith("-") ? args[0] : "start";
+var root = process.env.MARKODE_ROOT ?? process.cwd();
+async function main() {
+  if (flag("--help") || flag("-h")) return console.log(HELP);
+  if (flag("--version") || flag("-v")) return console.log(JSON.parse(fs17.readFileSync(path17.join(PKG_ROOT, "package.json"), "utf8")).version);
+  const translation = flag("--status") || flag("--mark") || flag("--keep");
+  if ((command === "sync" || command === "translate") && translation) return sync();
+  if (command === "translate" || flag("--translate")) return runTranslate(root);
+  if (command === "check") return check3();
+  if (command === "wait") return wait();
+  if (command === "link") return link();
+  if (command === "setup") {
+    await runSetup(flag("-D"));
+    return;
+  }
+  if (command === "init") {
+    await runInit(root, flag("--custom") ? null : await defaults());
+    return;
+  }
+  if (command === "start" && !readConfig(root)?.initializedAt) {
+    if (process.stdin.isTTY) await runInit(root, flag("--custom") ? null : await defaults());
+    else if (readDefaults()?.mode === "defaults") await runInit(root, readDefaults());
+  }
+  const unlinked = command === "start" && process.stdout.isTTY && !readConfig(root)?.skipLink ? missingMainDocs(root) : [];
+  if (unlinked.length)
+    console.log(`Tip: Claude Code reads CLAUDE.md and other agents read AGENTS.md; ${unlinked.map((m) => m.path).join(", ")} missing. Run \`markode link\` (or \`markode link --skip\`).`);
+  if (command === "start" || command === "serve") {
+    await startServer({ root, port: Number(option("--port") ?? 4319), open: !flag("--no-open") });
+    return;
+  }
+  console.log(HELP);
+  process.exitCode = 1;
+}
+async function defaults() {
+  const d = readDefaults() ?? (process.stdin.isTTY ? await runSetup(flag("-D")) : null);
+  return d?.mode === "defaults" ? d : null;
+}
+function check3() {
+  const report = checkDocs(root);
+  if (flag("--json")) return console.log(JSON.stringify(report, null, 2));
+  const lines = [
+    ...report.proposals.map((p3) => `answered proposal  ${p3}`),
+    ...report.phases.map((p3) => `phase vs task      ${p3.phase}: ${p3.task} is ${p3.status || "without status"} but ${p3.ticked ? "ticked" : "not ticked"}`),
+    ...(report.projects?.missing ?? []).map((d) => `project not listed ${d}/`),
+    ...(report.projects?.gone ?? []).map((d) => `project gone       ${d}/`),
+    ...report.links.map((l) => `broken link        ${l.file}:${l.line} \u2192 ${l.target}`)
+  ];
+  console.log(lines.length ? lines.join("\n") : "Docs are consistent.");
+}
+function link() {
+  const config = readConfig(root);
+  if (flag("--skip")) {
+    writeConfig(root, { ...config ?? { mainDoc: null, langs: [] }, skipLink: true });
+    return console.log("markode won't offer to link CLAUDE.md and AGENTS.md in this project again.");
+  }
+  if (flag("--dry-run") && config?.skipLink) return console.log("Skipped: the user chose not to link the main docs.");
+  const missing = missingMainDocs(root);
+  if (!missing.length) return console.log("Every main doc has its CLAUDE.md and AGENTS.md (or neither).");
+  if (flag("--dry-run")) return console.log(missing.map((m) => `would create ${m.path} \u2192 ${m.pointsTo}`).join("\n"));
+  for (const p3 of linkMainDocs(root)) console.log(`created ${p3}`);
+}
+async function wait() {
+  const rel = args[1];
+  if (!rel || !fs17.existsSync(path17.join(root, rel))) {
+    console.error(`Usage: markode wait <proposal.md> (relative to ${root})`);
+    process.exitCode = 1;
+    return;
+  }
+  const result = await waitForAnswer(root, rel);
+  if (result === "gone") {
+    console.log(`${rel} was deleted or is no longer a proposal.`);
+    process.exit(0);
+  }
+  console.log(answerSummary(root, rel));
+  process.exit(0);
+}
+function sync() {
+  const report = syncReport(root);
+  const paths = (after) => args.slice(args.indexOf(after) + 1).filter((a, i, all) => !a.startsWith("--") && all[i - 1] !== "--lang");
+  if (flag("--keep")) {
+    for (const p3 of paths("--keep")) {
+      try {
+        console.log(`kept    ${p3} (${keepLanguage(root, p3)})`);
+      } catch (err) {
+        console.error(`skipped ${p3}: ${err.message}`);
+      }
+    }
+    return;
+  }
+  if (flag("--mark")) {
+    const only = option("--lang");
+    const langs = only && report.langs.includes(only) ? [only] : report.langs;
+    const files = flag("--all") ? [...new Set(report.files.map((f) => f.path))] : paths("--mark");
+    for (const p3 of files) {
+      for (const l of langs) {
+        try {
+          markSynced(root, l, p3);
+          console.log(`synced  ${l} ${p3}`);
+        } catch (err) {
+          if (!flag("--all")) console.error(`skipped ${l} ${p3}: ${err.message}`);
+        }
+      }
+    }
+    return;
+  }
+  if (flag("--json")) return console.log(JSON.stringify(report, null, 2));
+  console.log(`Source language: ${report.sourceLang}   Translations: ${report.langs.join(", ") || "none"}`);
+  if (report.foreign.length) {
+    console.log(`
+Not in ${report.sourceLang}:`);
+    for (const f of report.foreign) console.log(`  ${f.detected}  ${f.path}`);
+  }
+  const pending = report.files.filter((f) => f.status !== "synced");
+  if (pending.length) console.log("");
+  for (const e of pending) console.log(`${e.lang}  ${e.status.padEnd(13)} ${e.path}`);
+  if (!pending.length && !report.foreign.length) console.log("Everything in sync.");
+}
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});