mdrules 0.1.1 → 0.2.3

package/dist/cli.js

@@ -9,6 +9,8 @@ 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 PKG_ROOT = (() => {
   let dir = path.dirname(fileURLToPath(import.meta.url));
@@ -24,7 +26,7 @@ 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(isLang), initializedAt: raw.initializedAt };
+    return { mainDoc: raw.mainDoc ?? null, langs: langs.filter(isLangCode), langNames: raw.langNames, workflow: raw.workflow, proposals: raw.proposals, initializedAt: raw.initializedAt };
   } catch {
     return null;
   }
@@ -38,8 +40,8 @@ function safeResolve(root2, rel) {
   if (abs !== root2 && !abs.startsWith(root2 + path.sep)) throw new Error(`Path outside project: ${rel}`);
   return abs;
 }
-var toPosix = (p2) => p2.split(path.sep).join("/");
-var DEFAULT_SETTINGS = { font: "inter", size: 15, lineHeight: 1.65, padding: 28, width: "full", wrap: true };
+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 {
@@ -55,10 +57,40 @@ function writeSettings(patch) {
   return next;
 }
 
+// src/core/defaults.ts
+import fs2 from "fs";
+import path2 from "path";
+var BASE_DEFAULTS = {
+  mode: "ask",
+  mainDoc: "CLAUDE.md",
+  workflow: "none",
+  agents: ["claude"],
+  proposals: "structured",
+  sourceLang: "en",
+  rules: [],
+  rulesInSubprojects: false,
+  hideInVsCode: true
+};
+var defaultsFile = () => path2.join(GLOBAL_DIR, "defaults.json");
+function readDefaults() {
+  try {
+    const saved = { ...BASE_DEFAULTS, ...JSON.parse(fs2.readFileSync(defaultsFile(), "utf8")) };
+    if (!isLang(saved.sourceLang)) saved.sourceLang = BASE_DEFAULTS.sourceLang;
+    if (!MAIN_DOCS.includes(saved.mainDoc)) saved.mainDoc = BASE_DEFAULTS.mainDoc;
+    return saved;
+  } catch {
+    return null;
+  }
+}
+function writeDefaults(defaults2) {
+  fs2.mkdirSync(GLOBAL_DIR, { recursive: true });
+  fs2.writeFileSync(defaultsFile(), JSON.stringify(defaults2, null, 2) + "\n");
+}
+
 // src/core/i18n.ts
 import crypto from "crypto";
-import fs4 from "fs";
-import path4 from "path";
+import fs5 from "fs";
+import path5 from "path";
 
 // src/core/langdetect.ts
 var STOPWORDS = {
@@ -84,56 +116,57 @@ function detectLang(md) {
 }
 
 // src/core/rules.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs3 from "fs";
+import path3 from "path";
 import YAML from "yaml";
-var rulesDir = () => path2.join(GLOBAL_DIR, "rules");
+var rulesDir = () => path3.join(GLOBAL_DIR, "rules");
 var START = "<!-- mdrules:rules:start -->";
 var END = "<!-- mdrules:rules:end -->";
 var slugify = (s) => s.toLowerCase().normalize("NFD").replace(/[̀-ͯ]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 function seedRules() {
-  if (fs2.existsSync(rulesDir())) return;
-  fs2.mkdirSync(rulesDir(), { recursive: true });
-  const src = path2.join(TEMPLATES_DIR, "rules");
-  for (const f of fs2.readdirSync(src)) fs2.copyFileSync(path2.join(src, f), path2.join(rulesDir(), f));
+  if (fs3.existsSync(rulesDir())) return;
+  fs3.mkdirSync(rulesDir(), { recursive: true });
+  const src = path3.join(TEMPLATES_DIR, "rules");
+  for (const f of fs3.readdirSync(src)) fs3.copyFileSync(path3.join(src, f), path3.join(rulesDir(), f));
 }
-function parseRule(id, text) {
-  const m = text.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-  const meta = m ? YAML.parse(m[1]) ?? {} : {};
-  return { id, title: meta.title ?? id, body: (m ? m[2] : text).trim() };
+function parseRule(id, text3) {
+  const m = text3.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  const meta = m ? YAML.parse(m[1], { logLevel: "error" }) ?? {} : {};
+  return { id, title: meta.title ?? id, body: (m ? m[2] : text3).trim() };
 }
 function listRules() {
   seedRules();
-  return fs2.readdirSync(rulesDir()).filter((f) => f.endsWith(".md")).map((f) => parseRule(f.slice(0, -3), fs2.readFileSync(path2.join(rulesDir(), f), "utf8"))).sort((a, b) => a.title.localeCompare(b.title));
+  return fs3.readdirSync(rulesDir()).filter((f) => f.endsWith(".md")).map((f) => parseRule(f.slice(0, -3), fs3.readFileSync(path3.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()}`;
-  const text = `---
+  if (!/^[\w-]+$/.test(id)) throw new Error(`Invalid rule id: ${id}`);
+  const text3 = `---
 ${YAML.stringify({ title: rule.title }).trim()}
 ---
 ${rule.body.trim()}
 `;
-  fs2.writeFileSync(path2.join(rulesDir(), `${id}.md`), text);
+  fs3.writeFileSync(path3.join(rulesDir(), `${id}.md`), text3);
   return { id, title: rule.title, body: rule.body.trim() };
 }
 function deleteRule(id) {
-  fs2.rmSync(path2.join(rulesDir(), `${path2.basename(id)}.md`), { force: true });
+  fs3.rmSync(path3.join(rulesDir(), `${path3.basename(id)}.md`), { force: true });
 }
 function appliedRuleIds(docText) {
-  const section = extractSection(docText);
-  if (!section) return [];
-  return [...section.matchAll(/<!-- rule:([\w-]+) -->/g)].map((m) => m[1]);
+  const section2 = extractSection(docText);
+  if (!section2) return [];
+  return [...section2.matchAll(/<!-- rule:([\w-]+) -->/g)].map((m) => m[1]);
 }
-function extractSection(text) {
-  const s = text.indexOf(START);
-  const e = text.indexOf(END);
-  return s >= 0 && e > s ? text.slice(s, e + END.length) : null;
+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 section = extractSection(docText) ?? "";
+  const section2 = extractSection(docText) ?? "";
   const out = {};
-  for (const m of section.matchAll(/<!-- rule:([\w-]+) -->\n([\s\S]*?)(?=\n+<!-- (?:rule:|mdrules:rules:end))/g)) out[m[1]] = { id: m[1], title: m[1], body: m[2].trim() };
+  for (const m of section2.matchAll(/<!-- rule:([\w-]+) -->\n([\s\S]*?)(?=\n+<!-- (?:rule:|mdrules:rules:end))/g)) out[m[1]] = { id: m[1], title: m[1], body: m[2].trim() };
   return out;
 }
 function sourceLangOf(docText) {
@@ -141,10 +174,10 @@ function sourceLangOf(docText) {
   return m && isLang(m[1]) ? m[1] : DEFAULT_SOURCE;
 }
 function projectSourceLang(root2, mainDoc) {
-  const doc = mainDoc ?? MAIN_DOCS.find((d) => fs2.existsSync(path2.join(root2, d)));
+  const doc = mainDoc ?? MAIN_DOCS.find((d) => fs3.existsSync(path3.join(root2, d)));
   if (!doc) return DEFAULT_SOURCE;
   try {
-    return sourceLangOf(fs2.readFileSync(path2.join(root2, doc), "utf8"));
+    return sourceLangOf(fs3.readFileSync(path3.join(root2, doc), "utf8"));
   } catch {
     return DEFAULT_SOURCE;
   }
@@ -165,36 +198,36 @@ ${r.body}`).join("\n\n");
   ].join("\n");
 }
 function applyRules(docText, rules, sourceLang = sourceLangOf(docText)) {
-  const section = renderSection(rules, sourceLang);
+  const section2 = renderSection(rules, sourceLang);
   const existing = extractSection(docText);
-  if (existing) return docText.replace(existing, section);
-  return docText.replace(/\s*$/, "") + "\n\n" + section + "\n";
+  if (existing) return docText.replace(existing, () => section2);
+  return docText.replace(/\s*$/, "") + "\n\n" + section2 + "\n";
 }
 function applyRulesToFile(file, ids, sourceLang) {
-  const text = fs2.existsSync(file) ? fs2.readFileSync(file, "utf8") : "";
+  const text3 = fs3.existsSync(file) ? fs3.readFileSync(file, "utf8") : "";
   const all = listRules();
-  const written = writtenRules(text);
-  const rules = (ids ?? appliedRuleIds(text)).map((id) => all.find((r) => r.id === id) ?? written[id]).filter((r) => !!r);
-  fs2.writeFileSync(file, applyRules(text, rules, sourceLang ?? sourceLangOf(text)));
+  const written = writtenRules(text3);
+  const rules = (ids ?? appliedRuleIds(text3)).map((id) => all.find((r) => r.id === id) ?? written[id]).filter((r) => !!r);
+  fs3.writeFileSync(file, applyRules(text3, rules, sourceLang ?? sourceLangOf(text3)));
 }
 
 // src/core/scan.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
 import ignore from "ignore";
 var ALWAYS_SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", ".mdrules", "dist", "build", ".next", ".turbo", "coverage", ".venv"]);
 var IGNORE_FILE = ".mdrulesignore";
 function loadIgnore(root2, file) {
   const ig = ignore();
   try {
-    ig.add(fs3.readFileSync(path3.join(root2, file), "utf8"));
+    ig.add(fs4.readFileSync(path4.join(root2, file), "utf8"));
   } catch {
   }
   return ig;
 }
 function readIgnoreList(root2) {
   try {
-    return fs3.readFileSync(path3.join(root2, IGNORE_FILE), "utf8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+    return fs4.readFileSync(path4.join(root2, IGNORE_FILE), "utf8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
   } catch {
     return [];
   }
@@ -203,7 +236,7 @@ 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);
-  fs3.writeFileSync(path3.join(root2, IGNORE_FILE), lines.length ? lines.join("\n") + "\n" : "");
+  fs4.writeFileSync(path4.join(root2, IGNORE_FILE), lines.length ? lines.join("\n") + "\n" : "");
 }
 function watchSkips(root2) {
   const gitIgnore = loadIgnore(root2, ".gitignore");
@@ -220,20 +253,20 @@ function scanTree(root2) {
   function walk(dirAbs, parentIgnored) {
     let entries;
     try {
-      entries = fs3.readdirSync(dirAbs, { withFileTypes: true });
+      entries = fs4.readdirSync(dirAbs, { withFileTypes: true });
     } catch {
       return [];
     }
     const nodes = [];
     for (const e of entries) {
       if (ALWAYS_SKIP.has(e.name)) continue;
-      const abs = path3.join(dirAbs, e.name);
-      const rel = toPosix(path3.relative(root2, abs));
+      const abs = path4.join(dirAbs, e.name);
+      const rel = toPosix(path4.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) continue;
+        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")) {
@@ -246,9 +279,16 @@ function scanTree(root2) {
   }
   return walk(root2, false);
 }
+function isEmptyDir(abs) {
+  try {
+    return fs4.readdirSync(abs).length === 0;
+  } catch {
+    return false;
+  }
+}
+var collator = new Intl.Collator(void 0, { numeric: true, sensitivity: "base" });
 function compareNodes(a, b) {
-  const rank = (n) => n.kind === "file" && MAIN_DOCS.includes(n.name) ? 0 : n.kind === "dir" ? 1 : 2;
-  return rank(a) - rank(b) || a.name.localeCompare(b.name);
+  return (a.kind === "dir" ? 0 : 1) - (b.kind === "dir" ? 0 : 1) || collator.compare(a.name, b.name);
 }
 function flattenFiles(nodes, includeIgnored = false) {
   const out = [];
@@ -270,19 +310,19 @@ function findSubprojects(nodes) {
 }
 
 // src/core/i18n.ts
-var stateFile = (root2) => path4.join(stateDir(root2), "state.json");
-var translationPath = (root2, lang, rel) => path4.join(stateDir(root2), "i18n", lang, rel);
-var hash = (text) => crypto.createHash("sha1").update(text).digest("hex").slice(0, 12);
+var stateFile = (root2) => path5.join(stateDir(root2), "state.json");
+var translationPath = (root2, lang, rel) => path5.join(stateDir(root2), "i18n", lang, rel);
+var hash = (text3) => crypto.createHash("sha1").update(text3).digest("hex").slice(0, 12);
 var readText = (abs) => {
   try {
-    return fs4.readFileSync(abs, "utf8");
+    return fs5.readFileSync(abs, "utf8");
   } catch {
     return null;
   }
 };
 function readState(root2) {
   try {
-    const raw = JSON.parse(fs4.readFileSync(stateFile(root2), "utf8"));
+    const raw = JSON.parse(fs5.readFileSync(stateFile(root2), "utf8"));
     if (!raw.translations) return { translations: raw, keepLanguage: {} };
     return { translations: raw.translations ?? {}, keepLanguage: raw.keepLanguage ?? {} };
   } catch {
@@ -290,11 +330,11 @@ function readState(root2) {
   }
 }
 function writeState(root2, state) {
-  fs4.mkdirSync(stateDir(root2), { recursive: true });
-  fs4.writeFileSync(stateFile(root2), JSON.stringify(state, null, 2) + "\n");
+  fs5.mkdirSync(stateDir(root2), { recursive: true });
+  fs5.writeFileSync(stateFile(root2), JSON.stringify(state, null, 2) + "\n");
 }
 function fileStatus(root2, lang, rel) {
-  const source = readText(path4.join(root2, rel));
+  const source = readText(path5.join(root2, rel));
   const translation = readText(translationPath(root2, lang, rel));
   if (translation === null || source === null) return "missing";
   const recorded = readState(root2).translations[lang]?.[rel];
@@ -311,15 +351,15 @@ function allStatuses(root2, lang) {
     path: f.path,
     lang,
     status: fileStatus(root2, lang, f.path),
-    translation: path4.relative(root2, translationPath(root2, lang, f.path))
+    translation: path5.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 text = readText(path4.join(root2, f.path));
-    const detected = text ? detectLang(text) : null;
+    const text3 = readText(path5.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;
@@ -331,23 +371,25 @@ function syncReport(root2) {
   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 = readText(path4.join(root2, rel));
+  const source = readText(path5.join(root2, rel));
   const translation = readText(translationPath(root2, lang, rel));
   if (source === null) throw new Error(`Source not found: ${rel}`);
-  if (translation === null) throw new Error(`Translation not found: ${path4.relative(root2, translationPath(root2, lang, rel))}`);
+  if (translation === null) throw new Error(`Translation not found: ${path5.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 text = readText(path4.join(root2, rel));
-  const detected = text ? detectLang(text) : null;
+  const text3 = readText(path5.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;
@@ -356,41 +398,47 @@ function keepLanguage(root2, rel) {
 }
 
 // src/server/index.ts
-import fs6 from "fs";
+import fs11 from "fs";
 import http from "http";
-import path6 from "path";
+import path11 from "path";
 import { watch } from "chokidar";
 import open from "open";
 import pc from "picocolors";
 import { WebSocketServer } from "ws";
 
 // src/core/dashboard.ts
-import fs5 from "fs";
-import path5 from "path";
+import fs6 from "fs";
+import path6 from "path";
 import YAML2 from "yaml";
-function parseFrontmatter(text) {
-  const m = text.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+function parseFrontmatter(text3) {
+  const m = text3.match(/^---\r?\n([\s\S]*?)\r?\n---/);
   if (!m) return {};
   try {
-    return YAML2.parse(m[1]) ?? {};
+    return YAML2.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)).map((f) => {
-    const text = fs5.readFileSync(path5.join(root2, f.path), "utf8");
-    const meta = parseFrontmatter(text);
-    const total = text.match(/^\s*[-*+] \[[ xX]\]/gm)?.length ?? 0;
-    const done = text.match(/^\s*[-*+] \[[xX]\]/gm)?.length ?? 0;
-    const heading = text.match(/^#\s+(.+)$/m)?.[1];
+  return flattenFiles(scanTree(root2)).flatMap((f) => {
+    const text3 = fs6.readFileSync(path6.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: meta.title ?? heading ?? f.name.replace(/\.md$/i, ""),
-      type: meta.type ?? null,
-      status: meta.status ?? null,
+      title: title ?? f.name.replace(/\.md$/i, ""),
+      type: asText(meta.type),
+      status: asText(meta.status),
       phase: typeof meta.phase === "number" ? meta.phase : null,
-      updated: meta.updated ? String(meta.updated instanceof Date ? meta.updated.toISOString().slice(0, 10) : meta.updated) : null,
+      updated: asText(meta.updated),
+      id,
+      area: asText(meta.area),
       tasks: { done, total }
     };
   });
@@ -432,6 +480,414 @@ function gitDiff(root2, rel) {
   return git(root2, hasHead ? ["diff", "HEAD", "--", rel] : ["diff", "--cached", "--", rel]) ?? "";
 }
 
+// src/core/proposals.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import fs9 from "fs";
+import path9 from "path";
+
+// src/core/scaffold.ts
+import fs7 from "fs";
+import path7 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 fs7.readdirSync(src, { withFileTypes: true })) {
+    const from = path7.join(src, e.name);
+    const to = path7.join(dest, fill(e.name, vars));
+    if (e.isDirectory()) {
+      fs7.mkdirSync(to, { recursive: true });
+      copyTree(from, to, vars, created, root2);
+    } else if (!fs7.existsSync(to)) {
+      fs7.writeFileSync(to, fill(fs7.readFileSync(from, "utf8"), vars));
+      created.push(toPosix(path7.relative(root2, to)));
+    }
+  }
+}
+function createMainDoc(root2, name) {
+  const file = path7.join(root2, name);
+  if (fs7.existsSync(file)) return;
+  const text3 = fs7.readFileSync(path7.join(TEMPLATES_DIR, "main.md"), "utf8");
+  fs7.writeFileSync(file, fill(text3, { name: path7.basename(root2), date: today() }));
+}
+function installSkill(root2) {
+  const dir = path7.join(root2, ".claude", "skills", "mdrules");
+  fs7.mkdirSync(dir, { recursive: true });
+  fs7.copyFileSync(path7.join(TEMPLATES_DIR, "skill", "SKILL.md"), path7.join(dir, "SKILL.md"));
+}
+function ensureGitignore(root2) {
+  const file = path7.join(root2, ".gitignore");
+  const text3 = fs7.existsSync(file) ? fs7.readFileSync(file, "utf8") : "";
+  if (text3.split("\n").some((l) => [".mdrules", ".mdrules/", "/.mdrules", "/.mdrules/"].includes(l.trim()))) return;
+  fs7.writeFileSync(file, text3 + (text3 && !text3.endsWith("\n") ? "\n" : "") + ".mdrules/\n");
+}
+function hideInVsCode(root2) {
+  const file = path7.join(root2, ".vscode", "settings.json");
+  let settings = {};
+  if (fs7.existsSync(file)) {
+    try {
+      settings = JSON.parse(fs7.readFileSync(file, "utf8"));
+    } catch {
+      return false;
+    }
+  }
+  settings["files.exclude"] = { ...settings["files.exclude"] ?? {}, "**/.mdrules": true };
+  fs7.mkdirSync(path7.dirname(file), { recursive: true });
+  fs7.writeFileSync(file, JSON.stringify(settings, null, 2) + "\n");
+  return true;
+}
+
+// src/core/sdd.ts
+import { spawnSync } from "child_process";
+import fs8 from "fs";
+import path8 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 (fs8.existsSync(path8.join(root2, "openspec"))) return "openspec";
+  if (fs8.existsSync(path8.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(path8.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(path8.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 === "mdrules" ? null : WORKFLOW_TEXT[workflow]));
+}
+function writeManagedBlock(file, body, top = false, name = "workflow") {
+  const START2 = `<!-- mdrules:${name}:start -->`;
+  const END2 = `<!-- mdrules:${name}:end -->`;
+  const text3 = fs8.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) fs8.writeFileSync(file, text3.replace(new RegExp(`\\n*${escapeRe(existing)}\\n?`), "\n"));
+    return;
+  }
+  const section2 = `${START2}
+${body}
+${END2}`;
+  if (existing) return fs8.writeFileSync(file, text3.replace(existing, () => section2));
+  const title = top ? /^# .*\n/m.exec(text3) : null;
+  if (title) return fs8.writeFileSync(file, text3.slice(0, title.index + title[0].length) + "\n" + section2 + "\n" + text3.slice(title.index + title[0].length));
+  fs8.writeFileSync(file, text3.replace(/\s*$/, "") + "\n\n" + section2 + "\n");
+}
+var escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var dirs = (abs) => {
+  try {
+    return fs8.readdirSync(abs, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name).sort();
+  } catch {
+    return [];
+  }
+};
+var read = (abs) => {
+  try {
+    return fs8.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 fs8.readdirSync(abs, { recursive: true }).filter((f) => String(f).endsWith("spec.md")).length;
+  } catch {
+    return 0;
+  }
+};
+function summarizeSdd(root2) {
+  const out = {};
+  const os3 = path8.join(root2, "openspec");
+  if (fs8.existsSync(os3)) {
+    const rel = (...p3) => toPosix(path8.join("openspec", ...p3));
+    out.openspec = {
+      changes: dirs(path8.join(os3, "changes")).filter((id) => id !== "archive").map((id) => {
+        const dir = path8.join(os3, "changes", id);
+        const proposal = read(path8.join(dir, "proposal.md"));
+        const tasks = read(path8.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: fs8.existsSync(path8.join(dir, "design.md")), tasks: tasks !== null, specs: countSpecs(path8.join(dir, "specs")) },
+          tasks: progress(tasks)
+        };
+      }),
+      specs: dirs(path8.join(os3, "specs")).filter((id) => fs8.existsSync(path8.join(os3, "specs", id, "spec.md"))).map((id) => ({ id, path: rel("specs", id, "spec.md") })),
+      archived: dirs(path8.join(os3, "changes", "archive")).reverse().slice(0, 12).map((id) => {
+        const file = ["proposal.md", "tasks.md"].find((f) => fs8.existsSync(path8.join(os3, "changes", "archive", id, f)));
+        return { id, path: file ? rel("changes", "archive", id, file) : "" };
+      })
+    };
+  }
+  if (fs8.existsSync(path8.join(root2, ".specify"))) {
+    const constitution = read(path8.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(path8.join(root2, "specs")).map((id) => {
+        const dir = path8.join(root2, "specs", id);
+        const spec = read(path8.join(dir, "spec.md"));
+        const tasks = read(path8.join(dir, "tasks.md"));
+        return {
+          id,
+          // "Feature Specification: Login" → "Login"
+          title: heading(spec)?.replace(/^feature specification:\s*/i, "") ?? id,
+          path: toPosix(path8.join("specs", id, spec !== null ? "spec.md" : "plan.md")),
+          artifacts: { spec: spec !== null, plan: fs8.existsSync(path8.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/proposals.ts
+var SKILL = path9.join(".claude", "skills", "mdrules-proposals");
+function proposalsState(root2) {
+  return { active: fs9.existsSync(path9.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 area goes in `<area>/docs/proposals/<topic>/`. 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 mdrules instead of a chat answer (skill: `mdrules-proposals`).",
+    "",
+    `- Where: ${WHERE[layout]}.`,
+    "- The user ticks options and comments (`<!-- comment by \u2026 -->`). When they say 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 ?? MAIN_DOCS.find((d) => fs9.existsSync(path9.join(root2, d)));
+  return doc ? [path9.join(root2, doc)] : [];
+}
+function activateProposals(root2, layout, mainDoc) {
+  const dir = path9.join(root2, SKILL);
+  fs9.mkdirSync(dir, { recursive: true });
+  fs9.writeFileSync(path9.join(dir, "SKILL.md"), fill(fs9.readFileSync(path9.join(TEMPLATES_DIR, "proposals", "SKILL.md"), "utf8"), { where: WHERE[layout] }));
+  fs9.mkdirSync(path9.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) {
+  fs9.rmSync(path9.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 fs10 from "fs";
+import os2 from "os";
+import path10 from "path";
+import YAML3 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) => path10.join(os2.homedir(), ...SOURCE_DIRS[source]);
+var display = (p3) => p3.startsWith(os2.homedir() + path10.sep) ? "~" + p3.slice(os2.homedir().length) : p3;
+function skillSources() {
+  return Object.keys(SOURCE_DIRS).map((id) => ({ id, path: display(sourceDir(id)), exists: fs10.existsSync(sourceDir(id)) }));
+}
+var tagsFile = () => path10.join(GLOBAL_DIR, "skills.json");
+function readTags() {
+  try {
+    return JSON.parse(fs10.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];
+  fs10.mkdirSync(GLOBAL_DIR, { recursive: true });
+  fs10.writeFileSync(tagsFile(), JSON.stringify({ tags: all }, null, 2) + "\n");
+  return clean;
+}
+function findSkills(dir, source, managed, depth = 0) {
+  let entries;
+  try {
+    entries = fs10.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return entries.flatMap((e) => {
+    const abs = path10.join(dir, e.name);
+    let real;
+    try {
+      if (!fs10.statSync(abs).isDirectory()) return [];
+      real = fs10.realpathSync(abs);
+    } catch {
+      return [];
+    }
+    if (fs10.existsSync(path10.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 frontmatter(text3) {
+  const m = /^---\r?\n([\s\S]*?)\r?\n---/.exec(text3);
+  if (!m) return null;
+  try {
+    const data = YAML3.parse(m[1], { logLevel: "error" });
+    return data && typeof data === "object" ? data : null;
+  } catch {
+    return null;
+  }
+}
+function listFiles(dir) {
+  try {
+    return fs10.readdirSync(dir, { recursive: true, withFileTypes: true }).map((e) => ({ e, rel: path10.relative(dir, path10.join(e.parentPath ?? e.path ?? dir, e.name)).split(path10.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 = fs10.readFileSync(path10.join(real, "SKILL.md"), "utf8");
+    const fm = frontmatter(text3);
+    const folder = path10.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) => fs10.existsSync(path10.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) => fs10.existsSync(path10.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) => path10.join(root2, PROJECT_TARGETS[t], skill.folder));
+  const existing = dests.filter((d) => fs10.existsSync(d));
+  if (existing.length && !overwrite) return { conflict: existing.map((d) => path10.relative(root2, d).split(path10.sep).join("/")) };
+  for (const dest of dests) {
+    fs10.rmSync(dest, { recursive: true, force: true });
+    fs10.mkdirSync(path10.dirname(dest), { recursive: true });
+    fs10.cpSync(skill.key, dest, { recursive: true, dereference: true });
+  }
+  return { ok: true };
+}
+
 // src/server/index.ts
 var IMAGE_MIME = {
   ".png": "image/png",
@@ -479,7 +935,7 @@ function isLocalRequest(req) {
 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) => isLang(value) && value !== sourceLang() && config().langs.includes(value) ? value : null;
+  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);
@@ -489,24 +945,38 @@ async function startServer({ root: root2, port, open: openBrowser }) {
     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 (!fs6.existsSync(abs)) throw new HttpError(404, "Not found");
+    if (!fs11.existsSync(abs)) throw new HttpError(404, "Not found");
     return abs;
   };
   const routes = {
     "GET /api/info": () => {
       const c = config();
-      return { name: path6.basename(root2), mainDoc: c.mainDoc ?? null, sourceLang: sourceLang(), langs: c.langs.filter((l) => l !== sourceLang()), git: isGitRepo(root2) };
+      return {
+        name: path11.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)
+      };
     },
     "PUT /api/config": (_, body) => {
       const c = config();
-      if (Array.isArray(body.langs)) c.langs = body.langs.filter(isLang);
+      if (Array.isArray(body.langs)) c.langs = body.langs.filter(isLangCode);
       if (isLang(body.sourceLang) && body.sourceLang !== sourceLang()) {
         if (!c.mainDoc) throw new HttpError(400, "No main document configured; run `mdrules init`");
-        applyRulesToFile(path6.join(root2, c.mainDoc), void 0, body.sourceLang);
+        applyRulesToFile(path11.join(root2, c.mainDoc), void 0, body.sourceLang);
       }
       writeConfig(root2, c);
       return { ...c, langs: c.langs.filter((l) => l !== sourceLang()) };
     },
+    "PUT /api/proposals": (_, body) => {
+      if (body.active) activateProposals(root2, body.layout === "structured" ? "structured" : "general", config().mainDoc);
+      else deactivateProposals(root2, config().mainDoc);
+      return proposalsState(root2);
+    },
     "GET /api/settings": () => readSettings(),
     "PUT /api/settings": (_, body) => writeSettings(body),
     "GET /api/tree": (url2) => {
@@ -519,10 +989,10 @@ async function startServer({ root: root2, port, open: openBrowser }) {
     "GET /api/file": (url2) => {
       const rel = mdPath(url2.searchParams.get("path"));
       const l = viewLang(url2.searchParams.get("lang"));
-      const source = fs6.readFileSync(safeResolve(root2, rel), "utf8");
+      const source = fs11.readFileSync(safeResolve(root2, rel), "utf8");
       if (l) {
         const tPath = translationPath(root2, l, rel);
-        if (fs6.existsSync(tPath)) return { path: rel, content: fs6.readFileSync(tPath, "utf8"), target: "translation", status: fileStatus(root2, l, rel) };
+        if (fs11.existsSync(tPath)) return { path: rel, content: fs11.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 };
@@ -531,31 +1001,40 @@ async function startServer({ root: root2, port, open: openBrowser }) {
       const rel = mdPath(body.path);
       const l = viewLang(body.lang);
       const file = body.target === "translation" && l ? translationPath(root2, l, rel) : safeResolve(root2, rel);
-      fs6.mkdirSync(path6.dirname(file), { recursive: true });
-      fs6.writeFileSync(file, String(body.content ?? ""));
+      fs11.mkdirSync(path11.dirname(file), { recursive: true });
+      fs11.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 (fs6.existsSync(file)) throw new HttpError(409, "File already exists");
-      fs6.mkdirSync(path6.dirname(file), { recursive: true });
-      const title = path6.basename(rel, ".md").replace(/^\d+[-_]/, "").replace(/[-_]/g, " ");
-      fs6.writeFileSync(file, `# ${title.charAt(0).toUpperCase() + title.slice(1)}
+      if (fs11.existsSync(file)) throw new HttpError(409, "File already exists");
+      fs11.mkdirSync(path11.dirname(file), { recursive: true });
+      const title = path11.basename(rel, ".md").replace(/^\d+[-_]/, "").replace(/[-_]/g, " ");
+      fs11.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 (fs11.existsSync(dir)) throw new HttpError(409, "A file or folder with that name already exists");
+      fs11.mkdirSync(dir, { recursive: true });
+      return { ok: true, path: toPosix(path11.relative(root2, dir)) };
+    },
     "GET /api/delete-preview": (url2) => {
       const abs = deletable(url2.searchParams.get("path"));
-      if (!fs6.statSync(abs).isDirectory()) return { kind: "file", files: 1, md: 1 };
-      const files = fs6.readdirSync(abs, { recursive: true, withFileTypes: true }).filter((e) => e.isFile());
+      if (!fs11.statSync(abs).isDirectory()) return { kind: "file", files: 1, md: 1 };
+      const files = fs11.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(path6.relative(root2, deletable(url2.searchParams.get("path"))));
-      fs6.rmSync(safeResolve(root2, rel), { recursive: true });
-      for (const l of config().langs) fs6.rmSync(translationPath(root2, l, rel), { recursive: true, force: true });
+      const rel = toPosix(path11.relative(root2, deletable(url2.searchParams.get("path"))));
+      fs11.rmSync(safeResolve(root2, rel), { recursive: true });
+      for (const l of config().langs) fs11.rmSync(translationPath(root2, l, rel), { recursive: true, force: true });
       return { ok: true };
     },
     "POST /api/ignore": (_, body) => {
@@ -564,21 +1043,48 @@ async function startServer({ root: root2, port, open: openBrowser }) {
       return { ok: true };
     },
     "GET /api/diff": (url2) => ({ diff: gitDiff(root2, mdPath(url2.searchParams.get("path"))) }),
-    "GET /api/dashboard": () => ({ docs: summarize(root2) }),
+    "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 text = mainDoc && fs6.existsSync(path6.join(root2, mainDoc)) ? fs6.readFileSync(path6.join(root2, mainDoc), "utf8") : "";
-      return { rules: listRules(), applied: appliedRuleIds(text), mainDoc: mainDoc ?? null };
+      const text3 = mainDoc && fs11.existsSync(path11.join(root2, mainDoc)) ? fs11.readFileSync(path11.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: fs11.readFileSync(path11.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");
+      fs11.writeFileSync(path11.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 `mdrules init`");
-      applyRulesToFile(path6.join(root2, mainDoc), body.ids ?? []);
+      applyRulesToFile(path11.join(root2, mainDoc), body.ids ?? []);
       return { ok: true };
     }
   };
@@ -610,13 +1116,13 @@ async function startServer({ root: root2, port, open: openBrowser }) {
       res.writeHead(404).end();
       return;
     }
-    const type = IMAGE_MIME[path6.extname(file).toLowerCase()];
-    if (!type || !fs6.existsSync(file) || !fs6.statSync(file).isFile()) {
+    const type = IMAGE_MIME[path11.extname(file).toLowerCase()];
+    if (!type || !fs11.existsSync(file) || !fs11.statSync(file).isFile()) {
       res.writeHead(404).end();
       return;
     }
-    res.writeHead(200, { "content-type": type, "cache-control": "no-cache" });
-    fs6.createReadStream(file).pipe(res);
+    res.writeHead(200, { "content-type": type, "cache-control": "no-cache", "content-security-policy": "sandbox", "x-content-type-options": "nosniff" });
+    fs11.createReadStream(file).pipe(res);
   }
   const actualPort = await listen(server, port);
   const wss = new WebSocketServer({ server, path: "/ws", verifyClient: ({ req }) => isLocalRequest(req) });
@@ -629,17 +1135,17 @@ async function startServer({ root: root2, port, open: openBrowser }) {
     ignoreInitial: true,
     // Unreadable folders (e.g. caches owned by another user) are skipped instead of failing.
     ignorePermissionErrors: true,
-    ignored: (p2, stats) => {
-      const rel = toPosix(path6.relative(root2, p2));
+    ignored: (p3, stats) => {
+      const rel = toPosix(path11.relative(root2, p3));
       if (rel === ".mdrules") return false;
       if (rel.startsWith(".mdrules/")) return !rel.startsWith(".mdrules/i18n") && rel !== ".mdrules/state.json" && rel !== ".mdrules/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 = path6.resolve(file);
+    const abs = path11.resolve(file);
     if (!abs.endsWith(".md") && !abs.endsWith(".json") && !abs.endsWith(".mdrulesignore") && event !== "addDir" && event !== "unlinkDir") return;
-    let rel = toPosix(path6.relative(root2, abs));
-    const i18n = toPosix(path6.relative(root2, path6.join(stateDir(root2), "i18n")));
+    let rel = toPosix(path11.relative(root2, abs));
+    const i18n = toPosix(path11.relative(root2, path11.join(stateDir(root2), "i18n")));
     if (rel.startsWith(i18n + "/")) rel = rel.split("/").slice(3).join("/");
     broadcast({ type: "fs", event, path: rel });
   });
@@ -647,7 +1153,7 @@ async function startServer({ root: root2, port, open: openBrowser }) {
   console.log(`
   ${pc.bold("mdrules")} ${pc.dim("\u2192")} ${pc.cyan(url)}  ${pc.dim(root2)}
 `);
-  if (!fs6.existsSync(WEB_DIR)) console.log(pc.yellow("  Web UI not built: run `pnpm build`, or `pnpm dev` and open http://localhost:4320\n"));
+  if (!fs11.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(() => {
   });
 }
@@ -661,79 +1167,142 @@ function listen(server, port) {
   });
 }
 function serveStatic(pathname, res) {
-  let file = path6.join(WEB_DIR, path6.normalize(pathname).replace(/^(\.\.[/\\])+/, ""));
-  if (!file.startsWith(WEB_DIR) || !fs6.existsSync(file) || fs6.statSync(file).isDirectory()) file = path6.join(WEB_DIR, "index.html");
-  if (!fs6.existsSync(file)) {
+  let file = path11.join(WEB_DIR, path11.normalize(pathname).replace(/^(\.\.[/\\])+/, ""));
+  if (!file.startsWith(WEB_DIR) || !fs11.existsSync(file) || fs11.statSync(file).isDirectory()) file = path11.join(WEB_DIR, "index.html");
+  if (!fs11.existsSync(file)) {
     res.writeHead(404).end("Web UI not built. Run `pnpm build`.");
     return;
   }
-  res.writeHead(200, { "content-type": MIME[path6.extname(file)] ?? "application/octet-stream" });
-  fs6.createReadStream(file).pipe(res);
+  res.writeHead(200, { "content-type": MIME[path11.extname(file)] ?? "application/octet-stream" });
+  fs11.createReadStream(file).pipe(res);
 }
 
 // src/cli/init.ts
-import fs8 from "fs";
-import path8 from "path";
+import fs13 from "fs";
+import path13 from "path";
 import * as p from "@clack/prompts";
 import pc2 from "picocolors";
 
-// src/core/scaffold.ts
-import fs7 from "fs";
-import path7 from "path";
-var today = () => (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-function fill(text, vars) {
-  return text.replace(/\{\{(\w+)\}\}/g, (_, k) => vars[k] ?? "");
-}
-function copyTree(src, dest, vars, created, root2) {
-  for (const e of fs7.readdirSync(src, { withFileTypes: true })) {
-    const from = path7.join(src, e.name);
-    const to = path7.join(dest, e.name);
-    if (e.isDirectory()) {
-      fs7.mkdirSync(to, { recursive: true });
-      copyTree(from, to, vars, created, root2);
-    } else if (!fs7.existsSync(to)) {
-      fs7.writeFileSync(to, fill(fs7.readFileSync(from, "utf8"), vars));
-      created.push(toPosix(path7.relative(root2, to)));
-    }
+// src/core/method.ts
+import fs12 from "fs";
+import path12 from "path";
+import YAML4 from "yaml";
+var SKIP = /* @__PURE__ */ new Set(["docs", "node_modules", "dist", "build", "coverage", "tmp"]);
+function detectAreas(root2) {
+  const globs = [];
+  try {
+    const ws = YAML4.parse(fs12.readFileSync(path12.join(root2, "pnpm-workspace.yaml"), "utf8"), { logLevel: "error" });
+    if (Array.isArray(ws?.packages)) globs.push(...ws.packages);
+  } catch {
   }
+  try {
+    const ws = JSON.parse(fs12.readFileSync(path12.join(root2, "package.json"), "utf8")).workspaces;
+    globs.push(...Array.isArray(ws) ? ws : Array.isArray(ws?.packages) ? ws.packages : []);
+  } catch {
+  }
+  const tops = [...globs.map((g) => String(g).replace(/^\.\//, "").split("/")[0]), ...findSubprojects(scanTree(root2)).map((p3) => p3.split("/")[0])];
+  return [...new Set(tops)].filter((d) => d && !d.includes("*") && !d.startsWith(".") && !d.startsWith("!") && !SKIP.has(d) && fs12.statSync(path12.join(root2, d), { throwIfNoEntry: false })?.isDirectory()).sort();
 }
-function scaffoldDocs(root2) {
+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) {
+  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 = [];
-  fs7.mkdirSync(path7.join(root2, "docs"), { recursive: true });
-  copyTree(path7.join(TEMPLATES_DIR, "docs"), path7.join(root2, "docs"), { date: today() }, created, root2);
+  const name = path12.basename(root2);
+  copyTree(path12.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 };
+    const dir = path12.join(root2, a.dir);
+    copyTree(path12.join(TEMPLATES_DIR, "method", "area"), dir, vars, created, root2);
+    let doc = MAIN_DOCS.map((d) => path12.join(dir, d)).find((f) => fs12.existsSync(f));
+    if (!doc) {
+      doc = path12.join(dir, mainDoc);
+      fs12.writeFileSync(doc, fill(fs12.readFileSync(path12.join(TEMPLATES_DIR, "method", "area-main.md"), "utf8"), vars));
+      created.push(path12.posix.join(a.dir, mainDoc));
+    }
+    writeManagedBlock(doc, areaBlock(a), true);
+  }
   return created;
 }
-function createMainDoc(root2, name) {
-  const file = path7.join(root2, name);
-  if (fs7.existsSync(file)) return;
-  const text = fs7.readFileSync(path7.join(TEMPLATES_DIR, "main.md"), "utf8");
-  fs7.writeFileSync(file, fill(text, { name: path7.basename(root2), date: today() }));
-}
-function installSkill(root2) {
-  const dir = path7.join(root2, ".claude", "skills", "mdrules");
-  fs7.mkdirSync(dir, { recursive: true });
-  fs7.copyFileSync(path7.join(TEMPLATES_DIR, "skill", "SKILL.md"), path7.join(dir, "SKILL.md"));
+function areaBlock(a) {
+  return [
+    `- Tasks: prefix \`${a.prefix}\` \xB7 index in \`docs/TASKS.md\` \xB7 one file per task in \`docs/tasks/\``,
+    "- Area architecture: `docs/ARCHITECTURE.md` \xB7 cross-cutting: `../docs/architecture/`"
+  ].join("\n");
 }
-function ensureGitignore(root2) {
-  const file = path7.join(root2, ".gitignore");
-  const text = fs7.existsSync(file) ? fs7.readFileSync(file, "utf8") : "";
-  if (text.split("\n").some((l) => [".mdrules", ".mdrules/", "/.mdrules", "/.mdrules/"].includes(l.trim()))) return;
-  fs7.writeFileSync(file, text + (text && !text.endsWith("\n") ? "\n" : "") + ".mdrules/\n");
+function methodSection(areas) {
+  const taskDirs = ["docs/tasks", ...areas.map((a) => `${a.dir}/docs/tasks`)].join(" ");
+  const map = areas.length ? [
+    "",
+    "### Map",
+    "",
+    "| Folder | Docs | Task prefix |",
+    "|---|---|---|",
+    ...areas.map((a) => `| \`${a.dir}/\` | \`${a.dir}/docs/\` (architecture, tasks) | ${a.prefix} |`),
+    `| \`docs/\` | vision, cross-cutting architecture, phases and cross-area tasks | ${rootPrefix(areas)} |`
+  ] : [];
+  return [
+    "## Workflow (mdrules method)",
+    "",
+    "How we work: `docs/README.md`. Vision: `docs/vision.md` \xB7 architecture: `docs/architecture/` \xB7 phases: `docs/phases/` \xB7 tasks: `docs/TASKS.md`.",
+    ...map,
+    "",
+    "### Session start",
+    "",
+    `1. Find tasks in progress: \`grep -rl "^status: in-progress" --include=*.md ${taskDirs}\`.`,
+    '2. Open the one with the most recent `updated`, read its "Next step" and tell the user in one line where we left off.',
+    "3. If there are none, ask the user what to work on.",
+    "",
+    "### During the session",
+    "",
+    `- Read only what the task needs: its file, ${areas.length ? "the `CLAUDE.md`/`AGENTS.md` and `docs/` of its area, " : ""}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 (`/mdrules-new-task`).",
+    `- One task = one file in ${areas.length ? "`<area>/docs/tasks/`; cross-area tasks in `docs/tasks/`" : "`docs/tasks/`"}. \`TASKS.md\` is only an index; each phase lists its tasks.`,
+    "- At the end of a session: `/mdrules-close-session`.",
+    "",
+    "### Documentation without redundancy",
+    "",
+    "- Each fact lives in one place; everything else links to it.",
+    areas.length ? "- A decision affecting one area goes in `<area>/docs/ARCHITECTURE.md`; several areas, 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 hideInVsCode(root2) {
-  const file = path7.join(root2, ".vscode", "settings.json");
-  let settings = {};
-  if (fs7.existsSync(file)) {
-    try {
-      settings = JSON.parse(fs7.readFileSync(file, "utf8"));
-    } catch {
-      return false;
-    }
+function installMethodSkills(root2) {
+  const src = path12.join(TEMPLATES_DIR, "method", "skills");
+  for (const name of fs12.readdirSync(src)) {
+    const dest = path12.join(root2, ".claude", "skills", name);
+    fs12.mkdirSync(dest, { recursive: true });
+    fs12.copyFileSync(path12.join(src, name, "SKILL.md"), path12.join(dest, "SKILL.md"));
   }
-  settings["files.exclude"] = { ...settings["files.exclude"] ?? {}, "**/.mdrules": true };
-  fs7.mkdirSync(path7.dirname(file), { recursive: true });
-  fs7.writeFileSync(file, JSON.stringify(settings, null, 2) + "\n");
-  return true;
 }
 
 // src/cli/init.ts
@@ -744,13 +1313,19 @@ function check(value) {
   }
   return value;
 }
-async function chooseMainDoc(root2) {
-  const existing = MAIN_DOCS.filter((d) => fs8.existsSync(path8.join(root2, d)));
+async function chooseMainDoc(root2, d) {
+  const existing = MAIN_DOCS.filter((d2) => fs13.existsSync(path13.join(root2, d2)));
+  if (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((d) => ({ value: d, label: d }))
+        options: existing.map((d2) => ({ value: d2, label: d2 }))
       })
     );
   }
@@ -760,7 +1335,7 @@ async function chooseMainDoc(root2) {
         message: `Found ${pc2.cyan(existing[0])}. Use it as the main document?`,
         options: [
           { value: existing[0], label: `Yes, use ${existing[0]}` },
-          ...MAIN_DOCS.filter((d) => d !== existing[0]).map((d) => ({ value: d, label: `No, create ${d}` }))
+          ...MAIN_DOCS.filter((d2) => d2 !== existing[0]).map((d2) => ({ value: d2, label: `No, create ${d2}` }))
         ]
       })
     );
@@ -770,52 +1345,132 @@ async function chooseMainDoc(root2) {
   const choice = check(
     await p.select({
       message: "No CLAUDE.md or AGENTS.md found. Which one should I create?",
-      options: MAIN_DOCS.map((d) => ({ value: d, label: d, hint: d === "CLAUDE.md" ? "Claude Code" : "other agents" }))
+      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;
 }
-async function runInit(root2) {
-  p.intro(pc2.bgCyan(pc2.black(" mdrules ")));
-  const previous = readConfig(root2);
-  const mainDoc = await chooseMainDoc(root2);
-  const mainFile = path8.join(root2, mainDoc);
-  if (!fs8.existsSync(path8.join(root2, "docs"))) {
-    const create = check(await p.confirm({ message: "Create the base /docs structure?", initialValue: true }));
-    if (create) p.log.success(`Created ${scaffoldDocs(root2).join(", ")}`);
-  }
-  const mainText = fs8.readFileSync(mainFile, "utf8");
-  const sourceLang = check(
-    await p.select({
-      message: "Source language of the .md files (what the AI reads and writes)",
-      options: LANGS.map((l) => ({ value: l, label: LANG_NAMES[l], hint: l === "en" ? "default" : void 0 })),
-      initialValue: sourceLangOf(mainText)
-    })
-  );
-  const langs = check(
+var WORKFLOW_OPTIONS = [
+  { value: "none", label: "None" },
+  { value: "mdrules", label: "mdrules method", hint: "vision, architecture, phases and one file per task; per area 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 SOURCE_LANG_QUESTION = "Language you work in (every .md file is written in it)";
+var SOURCE_LANG_MARK = /<!-- mdrules: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 .mdrules/ folder in VS Code?";
+var ruleOptions = (rules) => rules.map((r) => ({ value: r.id, label: r.title, hint: r.body.split("\n")[0].replace(/^- /, "") }));
+var agentOptions = () => Object.keys(SDD_AGENTS).map((a) => ({ value: a, label: SDD_AGENTS[a].label }));
+var WORKFLOW_LABEL = { none: "None", mdrules: "mdrules", openspec: "OpenSpec", speckit: "GitHub Spec Kit" };
+var WORKFLOW_GUIDE = { none: "", mdrules: "docs/README.md", openspec: "openspec/README.md", speckit: "specs/README.md" };
+async function chooseAreas(root2, d) {
+  const candidates = detectAreas(root2);
+  if (!candidates.length) return [];
+  if (d) {
+    const used2 = /* @__PURE__ */ new Set();
+    return candidates.map((dir) => ({ dir, prefix: suggestPrefix(dir, used2) }));
+  }
+  const dirs2 = check(
     await p.multiselect({
-      message: "Translation languages (view and edit docs in them; the source files never change language)",
-      options: LANGS.filter((l) => l !== sourceLang).map((l) => ({ value: l, label: LANG_NAMES[l] })),
-      initialValues: (previous?.langs ?? []).filter((l) => l !== sourceLang),
+      message: "Monorepo detected. Which folders are areas with their own docs and tasks? (none: one docs/ for everything)",
+      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(", ")}, cross-area \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 chooseWorkflow(root2, mainDoc, previous, d) {
+  const detected = detectWorkflow(root2);
+  if (detected) {
+    p.log.info(`${WORKFLOW_LABEL[detected]} found: mdrules 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 === "mdrules") {
+      const areas = await chooseAreas(root2, d);
+      const created = scaffoldMethod(root2, mainDoc, areas);
+      installMethodSkills(root2);
+      const big = areas.length > 0 || flattenFiles(scanTree(root2)).length > 40;
+      const layout = !big ? "general" : d ? d.proposals : 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(`How it works: ${pc2.cyan("docs/README.md")}. Skills: /mdrules-new-task, /mdrules-close-session.`);
+      return { workflow: choice, section: methodSection(areas) };
+    }
+    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 mdrules (${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(" mdrules ")));
+  if (d) p.log.info(`Using your defaults (${pc2.cyan(defaultsFile())}). To choose differently for this project: ${pc2.cyan("mdrules init --custom")}`);
+  const previous = readConfig(root2);
+  const mainDoc = await chooseMainDoc(root2, d);
+  const mainFile = path13.join(root2, mainDoc);
+  const { workflow, section: section2 } = await chooseWorkflow(root2, mainDoc, previous?.workflow, d);
+  applyWorkflowToFile(mainFile, workflow, section2);
+  const mainText = fs13.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 = check(
-    await p.multiselect({
-      message: "Which working rules apply to this project?",
-      options: rules.map((r) => ({ value: r.id, label: r.title, hint: r.body.split("\n")[0].replace(/^- /, "") })),
-      initialValues: applied,
-      required: false
-    })
-  );
+  const selected = d ? [.../* @__PURE__ */ new Set([...applied, ...d.rules.filter((id) => rules.some((r) => r.id === id))])] : check(await p.multiselect({ message: "Which working rules apply to this project?", options: ruleOptions(rules), initialValues: applied, required: false }));
   applyRulesToFile(mainFile, selected, sourceLang);
   const subprojects = findSubprojects(scanTree(root2));
   if (subprojects.length && selected.length) {
-    const targets = check(
+    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 })),
@@ -823,34 +1478,150 @@ async function runInit(root2) {
       })
     );
     for (const dir of targets) {
-      const doc = MAIN_DOCS.find((d) => fs8.existsSync(path8.join(root2, dir, d)));
-      applyRulesToFile(path8.join(root2, dir, doc), selected, sourceLang);
+      const doc = MAIN_DOCS.find((d2) => fs13.existsSync(path13.join(root2, dir, d2)));
+      applyRulesToFile(path13.join(root2, dir, doc), selected, sourceLang);
     }
   }
   ensureGitignore(root2);
   if (!previous) {
-    const hide = check(await p.confirm({ message: "Hide the .mdrules/ folder in VS Code?", initialValue: true }));
+    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 "**/.mdrules": true to files.exclude by hand.');
   }
   installSkill(root2);
-  const config = { mainDoc, langs, initializedAt: previous?.initializedAt ?? (/* @__PURE__ */ new Date()).toISOString() };
+  const config = { mainDoc, langs, langNames: previous?.langNames, workflow, proposals: readConfig(root2)?.proposals, initializedAt: previous?.initializedAt ?? (/* @__PURE__ */ new Date()).toISOString() };
   writeConfig(root2, config);
-  p.outro(`Ready. Skill installed in ${pc2.cyan(".claude/skills/mdrules")}`);
+  p.outro(`Ready. Skill installed in ${pc2.cyan(".claude/skills/mdrules")}. To review the docs in another language: ${pc2.cyan("mdrules 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(" mdrules setup ")));
+  const mode = check(
+    await p.select({
+      message: "How should mdrules 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("mdrules 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 proposals = previous.proposals;
+  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 === "mdrules") proposals = check(await p.select({ message: `${PROPOSALS_QUESTION} (big projects and monorepos)`, options: PROPOSAL_OPTIONS, initialValue: previous.proposals }));
+  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 = check(await p.multiselect({ message: "Working rules to apply", options: ruleOptions(rules), initialValues: previous.rules.filter((id) => rules.some((r) => r.id === id)), required: false }));
+  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, proposals, sourceLang, rules: selected, rulesInSubprojects, hideInVsCode: hideInVsCode2 };
+  writeDefaults(d);
+  p.outro(`Saved in ${pc2.cyan(defaultsFile())}. Change them with ${pc2.cyan("mdrules setup")}; for a single project: ${pc2.cyan("mdrules 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("mdrules init")} first.`);
+    process.exitCode = 1;
+    return;
+  }
+  p2.intro(pc3.bgCyan(pc3.black(" mdrules 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 names = { ...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);
+      names[code] = name;
+      if (!check2(await p2.confirm({ message: "Add another language?", initialValue: false }))) break;
+    }
+  }
+  writeConfig(root2, { ...config, langs, langNames: names });
+  if (!langs.length) {
+    p2.outro("No translation languages: mdrules shows the docs in their source language only.");
+    return;
+  }
+  p2.outro(
+    [
+      `Translations: ${langs.map((l) => langName(l, { ...config, langNames: names })).join(", ")}.`,
+      `Ask your agent for ${pc3.cyan("/mdrules sync")} to translate the docs; then pick the language at the top of mdrules.`,
+      ...langs.some((l) => !isLang(l)) ? ["Menus stay in English for languages typed by hand."] : []
+    ].join("\n")
+  );
+}
 
 // src/cli/index.ts
 var HELP = `mdrules \u2014 visual editor for your project's Markdown
 
 Usage
   mdrules                 init if needed, then open the editor
-  mdrules init            (re)run the setup: main doc, docs/, rules, language
+  mdrules init            (re)run the project setup: main doc, specs structure, rules, languages
+  mdrules setup           choose how projects are set up: with your saved answers, or asking each time
   mdrules serve           open the editor without running init
+  mdrules translate       choose languages to review the docs in (or: mdrules --translate)
   mdrules sync --status [--json]                    translations + files not in the source language
   mdrules sync --mark [--lang xx] <path...>|--all   record translations as in sync
   mdrules sync --keep <path...>                     keep files in their current language
 
 Options
+  -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
 `;
@@ -865,12 +1636,18 @@ var root = process.env.MDRULES_ROOT ?? process.cwd();
 async function main() {
   if (flag("--help") || flag("-h")) return console.log(HELP);
   if (command === "sync") return sync();
+  if (command === "translate" || flag("--translate")) return runTranslate(root);
+  if (command === "setup") {
+    await runSetup(flag("-D"));
+    return;
+  }
   if (command === "init") {
-    await runInit(root);
+    await runInit(root, flag("--custom") ? null : await defaults());
     return;
   }
   if (command === "start" && !readConfig(root)) {
-    if (process.stdin.isTTY) await runInit(root);
+    if (process.stdin.isTTY) await runInit(root, flag("--custom") ? null : await defaults());
+    else if (readDefaults()?.mode === "defaults") await runInit(root, readDefaults());
   }
   if (command === "start" || command === "serve") {
     await startServer({ root, port: Number(option("--port") ?? 4319), open: !flag("--no-open") });
@@ -879,30 +1656,34 @@ async function main() {
   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 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 p2 of paths("--keep")) {
+    for (const p3 of paths("--keep")) {
       try {
-        console.log(`kept    ${p2} (${keepLanguage(root, p2)})`);
+        console.log(`kept    ${p3} (${keepLanguage(root, p3)})`);
       } catch (err) {
-        console.error(`skipped ${p2}: ${err.message}`);
+        console.error(`skipped ${p3}: ${err.message}`);
       }
     }
     return;
   }
   if (flag("--mark")) {
     const only = option("--lang");
-    const langs = only && isLang(only) ? [only] : report.langs;
+    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 p2 of files) {
+    for (const p3 of files) {
       for (const l of langs) {
         try {
-          markSynced(root, l, p2);
-          console.log(`synced  ${l} ${p2}`);
+          markSynced(root, l, p3);
+          console.log(`synced  ${l} ${p3}`);
         } catch (err) {
-          if (!flag("--all")) console.error(`skipped ${l} ${p2}: ${err.message}`);
+          if (!flag("--all")) console.error(`skipped ${l} ${p3}: ${err.message}`);
         }
       }
     }