mdrules 0.2.0 → 0.2.3

package/dist/cli.js

@@ -41,7 +41,7 @@ function safeResolve(root2, 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 };
+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 {
@@ -57,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 = {
@@ -86,18 +116,18 @@ 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, text3) {
   const m = text3.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
@@ -106,21 +136,22 @@ function parseRule(id, text3) {
 }
 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()}`;
+  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`), text3);
+  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 section2 = extractSection(docText);
@@ -143,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;
   }
@@ -169,34 +200,34 @@ ${r.body}`).join("\n\n");
 function applyRules(docText, rules, sourceLang = sourceLangOf(docText)) {
   const section2 = renderSection(rules, sourceLang);
   const existing = extractSection(docText);
-  if (existing) return docText.replace(existing, section2);
+  if (existing) return docText.replace(existing, () => section2);
   return docText.replace(/\s*$/, "") + "\n\n" + section2 + "\n";
 }
 function applyRulesToFile(file, ids, sourceLang) {
-  const text3 = fs2.existsSync(file) ? fs2.readFileSync(file, "utf8") : "";
+  const text3 = fs3.existsSync(file) ? fs3.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);
-  fs2.writeFileSync(file, applyRules(text3, rules, sourceLang ?? sourceLangOf(text3)));
+  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 [];
   }
@@ -205,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");
@@ -222,15 +253,15 @@ 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 + "/");
@@ -250,7 +281,7 @@ function scanTree(root2) {
 }
 function isEmptyDir(abs) {
   try {
-    return fs3.readdirSync(abs).length === 0;
+    return fs4.readdirSync(abs).length === 0;
   } catch {
     return false;
   }
@@ -279,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 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 {
@@ -299,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];
@@ -320,14 +351,14 @@ 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 text3 = readText(path4.join(root2, f.path));
+    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 });
   }
@@ -347,17 +378,17 @@ function syncReport(root2) {
   };
 }
 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 text3 = readText(path4.join(root2, rel));
+  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);
@@ -367,17 +398,17 @@ function keepLanguage(root2, rel) {
 }
 
 // src/server/index.ts
-import fs10 from "fs";
+import fs11 from "fs";
 import http from "http";
-import path10 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(text3) {
   const m = text3.match(/^---\r?\n([\s\S]*?)\r?\n---/);
@@ -391,7 +422,7 @@ function parseFrontmatter(text3) {
 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) => {
-    const text3 = fs5.readFileSync(path5.join(root2, f.path), "utf8");
+    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);
@@ -451,66 +482,66 @@ function gitDiff(root2, rel) {
 
 // src/core/proposals.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import fs8 from "fs";
-import path8 from "path";
+import fs9 from "fs";
+import path9 from "path";
 
 // src/core/scaffold.ts
-import fs6 from "fs";
-import path6 from "path";
+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 fs6.readdirSync(src, { withFileTypes: true })) {
-    const from = path6.join(src, e.name);
-    const to = path6.join(dest, fill(e.name, vars));
+  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()) {
-      fs6.mkdirSync(to, { recursive: true });
+      fs7.mkdirSync(to, { recursive: true });
       copyTree(from, to, vars, created, root2);
-    } else if (!fs6.existsSync(to)) {
-      fs6.writeFileSync(to, fill(fs6.readFileSync(from, "utf8"), vars));
-      created.push(toPosix(path6.relative(root2, to)));
+    } 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 = path6.join(root2, name);
-  if (fs6.existsSync(file)) return;
-  const text3 = fs6.readFileSync(path6.join(TEMPLATES_DIR, "main.md"), "utf8");
-  fs6.writeFileSync(file, fill(text3, { name: path6.basename(root2), date: today() }));
+  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 = path6.join(root2, ".claude", "skills", "mdrules");
-  fs6.mkdirSync(dir, { recursive: true });
-  fs6.copyFileSync(path6.join(TEMPLATES_DIR, "skill", "SKILL.md"), path6.join(dir, "SKILL.md"));
+  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 = path6.join(root2, ".gitignore");
-  const text3 = fs6.existsSync(file) ? fs6.readFileSync(file, "utf8") : "";
+  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;
-  fs6.writeFileSync(file, text3 + (text3 && !text3.endsWith("\n") ? "\n" : "") + ".mdrules/\n");
+  fs7.writeFileSync(file, text3 + (text3 && !text3.endsWith("\n") ? "\n" : "") + ".mdrules/\n");
 }
 function hideInVsCode(root2) {
-  const file = path6.join(root2, ".vscode", "settings.json");
+  const file = path7.join(root2, ".vscode", "settings.json");
   let settings = {};
-  if (fs6.existsSync(file)) {
+  if (fs7.existsSync(file)) {
     try {
-      settings = JSON.parse(fs6.readFileSync(file, "utf8"));
+      settings = JSON.parse(fs7.readFileSync(file, "utf8"));
     } catch {
       return false;
     }
   }
   settings["files.exclude"] = { ...settings["files.exclude"] ?? {}, "**/.mdrules": true };
-  fs6.mkdirSync(path6.dirname(file), { recursive: true });
-  fs6.writeFileSync(file, JSON.stringify(settings, null, 2) + "\n");
+  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 fs7 from "fs";
-import path7 from "path";
+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" },
@@ -521,8 +552,8 @@ var SDD_AGENTS = {
 var OPENSPEC_PKG = "@fission-ai/openspec@latest";
 var SPECKIT_SRC = "git+https://github.com/github/spec-kit.git";
 function detectWorkflow(root2) {
-  if (fs7.existsSync(path7.join(root2, "openspec"))) return "openspec";
-  if (fs7.existsSync(path7.join(root2, ".specify"))) return "speckit";
+  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;
@@ -546,11 +577,11 @@ function installWorkflow(root2, workflow, agents, official) {
     else result.error = (run.error?.message ?? `${run.stderr ?? ""}
 ${run.stdout ?? ""}`).trim().split("\n").slice(-6).join("\n");
   }
-  copyTree(path7.join(TEMPLATES_DIR, "sdd", workflow), root2, { date: today2() }, result.created, root2);
+  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(path7.posix.dirname(f.path));
+    dirs2.add(path8.posix.dirname(f.path));
   }
   for (const dir of dirs2) setIgnored(root2, dir, "dir", true);
   result.ignored = [...dirs2].sort();
@@ -584,33 +615,33 @@ function applyWorkflowToFile(file, workflow, text3) {
 function writeManagedBlock(file, body, top = false, name = "workflow") {
   const START2 = `<!-- mdrules:${name}:start -->`;
   const END2 = `<!-- mdrules:${name}:end -->`;
-  const text3 = fs7.readFileSync(file, "utf8");
+  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) fs7.writeFileSync(file, text3.replace(new RegExp(`\\n*${escapeRe(existing)}\\n?`), "\n"));
+    if (existing) fs8.writeFileSync(file, text3.replace(new RegExp(`\\n*${escapeRe(existing)}\\n?`), "\n"));
     return;
   }
   const section2 = `${START2}
 ${body}
 ${END2}`;
-  if (existing) return fs7.writeFileSync(file, text3.replace(existing, section2));
+  if (existing) return fs8.writeFileSync(file, text3.replace(existing, () => section2));
   const title = top ? /^# .*\n/m.exec(text3) : null;
-  if (title) return fs7.writeFileSync(file, text3.slice(0, title.index + title[0].length) + "\n" + section2 + "\n" + text3.slice(title.index + title[0].length));
-  fs7.writeFileSync(file, text3.replace(/\s*$/, "") + "\n\n" + section2 + "\n");
+  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 fs7.readdirSync(abs, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name).sort();
+    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 fs7.readFileSync(abs, "utf8");
+    return fs8.readFileSync(abs, "utf8");
   } catch {
     return null;
   }
@@ -619,52 +650,52 @@ var progress = (text3) => ({ done: text3?.match(/^\s*[-*+] \[[xX]\]/gm)?.length
 var heading = (text3) => text3?.match(/^#\s+(.+)$/m)?.[1].trim() ?? null;
 var countSpecs = (abs) => {
   try {
-    return fs7.readdirSync(abs, { recursive: true }).filter((f) => String(f).endsWith("spec.md")).length;
+    return fs8.readdirSync(abs, { recursive: true }).filter((f) => String(f).endsWith("spec.md")).length;
   } catch {
     return 0;
   }
 };
 function summarizeSdd(root2) {
   const out = {};
-  const os3 = path7.join(root2, "openspec");
-  if (fs7.existsSync(os3)) {
-    const rel = (...p3) => toPosix(path7.join("openspec", ...p3));
+  const os3 = path8.join(root2, "openspec");
+  if (fs8.existsSync(os3)) {
+    const rel = (...p3) => toPosix(path8.join("openspec", ...p3));
     out.openspec = {
-      changes: dirs(path7.join(os3, "changes")).filter((id) => id !== "archive").map((id) => {
-        const dir = path7.join(os3, "changes", id);
-        const proposal = read(path7.join(dir, "proposal.md"));
-        const tasks = read(path7.join(dir, "tasks.md"));
+      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: fs7.existsSync(path7.join(dir, "design.md")), tasks: tasks !== null, specs: countSpecs(path7.join(dir, "specs")) },
+          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(path7.join(os3, "specs")).filter((id) => fs7.existsSync(path7.join(os3, "specs", id, "spec.md"))).map((id) => ({ id, path: rel("specs", id, "spec.md") })),
-      archived: dirs(path7.join(os3, "changes", "archive")).reverse().slice(0, 12).map((id) => {
-        const file = ["proposal.md", "tasks.md"].find((f) => fs7.existsSync(path7.join(os3, "changes", "archive", id, f)));
+      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 (fs7.existsSync(path7.join(root2, ".specify"))) {
-    const constitution = read(path7.join(root2, ".specify", "memory", "constitution.md"));
+  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(path7.join(root2, "specs")).map((id) => {
-        const dir = path7.join(root2, "specs", id);
-        const spec = read(path7.join(dir, "spec.md"));
-        const tasks = read(path7.join(dir, "tasks.md"));
+      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(path7.join("specs", id, spec !== null ? "spec.md" : "plan.md")),
-          artifacts: { spec: spec !== null, plan: fs7.existsSync(path7.join(dir, "plan.md")), tasks: tasks !== null },
+          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)
         };
       })
@@ -677,9 +708,9 @@ function sddPrefixes(summary) {
 }
 
 // src/core/proposals.ts
-var SKILL = path8.join(".claude", "skills", "mdrules-proposals");
+var SKILL = path9.join(".claude", "skills", "mdrules-proposals");
 function proposalsState(root2) {
-  return { active: fs8.existsSync(path8.join(root2, SKILL, "SKILL.md")), layout: readConfig(root2)?.proposals ?? "general" };
+  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)",
@@ -698,19 +729,19 @@ function section(layout) {
   ].join("\n");
 }
 function mainDocs(root2, mainDoc) {
-  const doc = mainDoc ?? MAIN_DOCS.find((d) => fs8.existsSync(path8.join(root2, d)));
-  return doc ? [path8.join(root2, doc)] : [];
+  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 = path8.join(root2, SKILL);
-  fs8.mkdirSync(dir, { recursive: true });
-  fs8.writeFileSync(path8.join(dir, "SKILL.md"), fill(fs8.readFileSync(path8.join(TEMPLATES_DIR, "proposals", "SKILL.md"), "utf8"), { where: WHERE[layout] }));
-  fs8.mkdirSync(path8.join(root2, "docs", "proposals"), { recursive: true });
+  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) {
-  fs8.rmSync(path8.join(root2, SKILL), { recursive: true, force: true });
+  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) {
@@ -722,9 +753,9 @@ function authorName(root2) {
 }
 
 // src/core/skills.ts
-import fs9 from "fs";
+import fs10 from "fs";
 import os2 from "os";
-import path9 from "path";
+import path10 from "path";
 import YAML3 from "yaml";
 var SOURCE_DIRS = {
   claude: [".claude", "skills"],
@@ -736,15 +767,15 @@ var SOURCE_DIRS = {
   cursor: [".cursor", "skills"]
 };
 var PROJECT_TARGETS = { claude: ".claude/skills", agents: ".agents/skills" };
-var sourceDir = (source) => path9.join(os2.homedir(), ...SOURCE_DIRS[source]);
-var display = (p3) => p3.startsWith(os2.homedir() + path9.sep) ? "~" + p3.slice(os2.homedir().length) : p3;
+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: fs9.existsSync(sourceDir(id)) }));
+  return Object.keys(SOURCE_DIRS).map((id) => ({ id, path: display(sourceDir(id)), exists: fs10.existsSync(sourceDir(id)) }));
 }
-var tagsFile = () => path9.join(GLOBAL_DIR, "skills.json");
+var tagsFile = () => path10.join(GLOBAL_DIR, "skills.json");
 function readTags() {
   try {
-    return JSON.parse(fs9.readFileSync(tagsFile(), "utf8")).tags ?? {};
+    return JSON.parse(fs10.readFileSync(tagsFile(), "utf8")).tags ?? {};
   } catch {
     return {};
   }
@@ -754,27 +785,27 @@ function setSkillTags(name, tags) {
   const clean = [...new Set(tags.map((t) => t.trim().toLowerCase()).filter(Boolean))];
   if (clean.length) all[name] = clean;
   else delete all[name];
-  fs9.mkdirSync(GLOBAL_DIR, { recursive: true });
-  fs9.writeFileSync(tagsFile(), JSON.stringify({ tags: all }, null, 2) + "\n");
+  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 = fs9.readdirSync(dir, { withFileTypes: true });
+    entries = fs10.readdirSync(dir, { withFileTypes: true });
   } catch {
     return [];
   }
   return entries.flatMap((e) => {
-    const abs = path9.join(dir, e.name);
+    const abs = path10.join(dir, e.name);
     let real;
     try {
-      if (!fs9.statSync(abs).isDirectory()) return [];
-      real = fs9.realpathSync(abs);
+      if (!fs10.statSync(abs).isDirectory()) return [];
+      real = fs10.realpathSync(abs);
     } catch {
       return [];
     }
-    if (fs9.existsSync(path9.join(abs, "SKILL.md"))) return [{ dir: abs, real, source, managed }];
+    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) : [];
   });
 }
@@ -790,7 +821,7 @@ function frontmatter(text3) {
 }
 function listFiles(dir) {
   try {
-    return fs9.readdirSync(dir, { recursive: true, withFileTypes: true }).map((e) => ({ e, rel: path9.relative(dir, path9.join(e.parentPath ?? e.path ?? dir, e.name)).split(path9.sep).join("/") })).filter(({ e, rel }) => e.isFile() && rel !== "SKILL.md").map(({ rel }) => rel).sort().slice(0, 100);
+    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 [];
   }
@@ -803,9 +834,9 @@ function listSkills(root2) {
   const userTags = readTags();
   const skills = [];
   for (const [real, found] of byReal) {
-    const text3 = fs9.readFileSync(path9.join(real, "SKILL.md"), "utf8");
+    const text3 = fs10.readFileSync(path10.join(real, "SKILL.md"), "utf8");
     const fm = frontmatter(text3);
-    const folder = path9.basename(found[0].dir);
+    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 = [];
@@ -828,7 +859,7 @@ function listSkills(root2) {
       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) => fs9.existsSync(path9.join(root2, PROJECT_TARGETS[t], folder, "SKILL.md")))
+      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));
@@ -839,20 +870,20 @@ function getSkill(root2, key) {
   return skill;
 }
 function projectTargets(root2) {
-  const has2 = (p3) => fs9.existsSync(path9.join(root2, p3));
+  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) => path9.join(root2, PROJECT_TARGETS[t], skill.folder));
-  const existing = dests.filter((d) => fs9.existsSync(d));
-  if (existing.length && !overwrite) return { conflict: existing.map((d) => path9.relative(root2, d).split(path9.sep).join("/")) };
+  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) {
-    fs9.rmSync(dest, { recursive: true, force: true });
-    fs9.mkdirSync(path9.dirname(dest), { recursive: true });
-    fs9.cpSync(skill.key, dest, { recursive: true, dereference: true });
+    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 };
 }
@@ -914,14 +945,14 @@ 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 (!fs10.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: path10.basename(root2),
+        name: path11.basename(root2),
         mainDoc: c.mainDoc ?? null,
         sourceLang: sourceLang(),
         langs: c.langs.filter((l) => l !== sourceLang()),
@@ -936,7 +967,7 @@ async function startServer({ root: root2, port, open: openBrowser }) {
       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(path10.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()) };
@@ -958,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 = fs10.readFileSync(safeResolve(root2, rel), "utf8");
+      const source = fs11.readFileSync(safeResolve(root2, rel), "utf8");
       if (l) {
         const tPath = translationPath(root2, l, rel);
-        if (fs10.existsSync(tPath)) return { path: rel, content: fs10.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 };
@@ -970,17 +1001,17 @@ 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);
-      fs10.mkdirSync(path10.dirname(file), { recursive: true });
-      fs10.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 (fs10.existsSync(file)) throw new HttpError(409, "File already exists");
-      fs10.mkdirSync(path10.dirname(file), { recursive: true });
-      const title = path10.basename(rel, ".md").replace(/^\d+[-_]/, "").replace(/[-_]/g, " ");
-      fs10.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 };
@@ -990,20 +1021,20 @@ async function startServer({ root: root2, port, open: openBrowser }) {
       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 (fs10.existsSync(dir)) throw new HttpError(409, "A file or folder with that name already exists");
-      fs10.mkdirSync(dir, { recursive: true });
-      return { ok: true, path: toPosix(path10.relative(root2, dir)) };
+      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 (!fs10.statSync(abs).isDirectory()) return { kind: "file", files: 1, md: 1 };
-      const files = fs10.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(path10.relative(root2, deletable(url2.searchParams.get("path"))));
-      fs10.rmSync(safeResolve(root2, rel), { recursive: true });
-      for (const l of config().langs) fs10.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) => {
@@ -1019,7 +1050,7 @@ async function startServer({ root: root2, port, open: openBrowser }) {
     },
     "GET /api/rules": () => {
       const mainDoc = readConfig(root2)?.mainDoc;
-      const text3 = mainDoc && fs10.existsSync(path10.join(root2, mainDoc)) ? fs10.readFileSync(path10.join(root2, mainDoc), "utf8") : "";
+      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),
@@ -1035,12 +1066,12 @@ async function startServer({ root: root2, port, open: openBrowser }) {
     },
     "GET /api/skills/file": (url2) => {
       const skill = getSkill(root2, url2.searchParams.get("key"));
-      return { path: skill.key, content: fs10.readFileSync(path10.join(skill.key, "SKILL.md"), "utf8"), target: "source", status: null };
+      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");
-      fs10.writeFileSync(path10.join(skill.key, "SKILL.md"), String(body.content ?? ""));
+      fs11.writeFileSync(path11.join(skill.key, "SKILL.md"), String(body.content ?? ""));
       return { ok: true, status: null };
     },
     "POST /api/skills/install": (_, body) => {
@@ -1053,7 +1084,7 @@ async function startServer({ root: root2, port, open: openBrowser }) {
     "POST /api/rules/apply": (_, body) => {
       const mainDoc = readConfig(root2)?.mainDoc;
       if (!mainDoc) throw new HttpError(400, "No main document configured; run `mdrules init`");
-      applyRulesToFile(path10.join(root2, mainDoc), body.ids ?? []);
+      applyRulesToFile(path11.join(root2, mainDoc), body.ids ?? []);
       return { ok: true };
     }
   };
@@ -1085,13 +1116,13 @@ async function startServer({ root: root2, port, open: openBrowser }) {
       res.writeHead(404).end();
       return;
     }
-    const type = IMAGE_MIME[path10.extname(file).toLowerCase()];
-    if (!type || !fs10.existsSync(file) || !fs10.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" });
-    fs10.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) });
@@ -1105,16 +1136,16 @@ async function startServer({ root: root2, port, open: openBrowser }) {
     // Unreadable folders (e.g. caches owned by another user) are skipped instead of failing.
     ignorePermissionErrors: true,
     ignored: (p3, stats) => {
-      const rel = toPosix(path10.relative(root2, p3));
+      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 = path10.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(path10.relative(root2, abs));
-    const i18n = toPosix(path10.relative(root2, path10.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 });
   });
@@ -1122,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 (!fs10.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(() => {
   });
 }
@@ -1136,41 +1167,41 @@ function listen(server, port) {
   });
 }
 function serveStatic(pathname, res) {
-  let file = path10.join(WEB_DIR, path10.normalize(pathname).replace(/^(\.\.[/\\])+/, ""));
-  if (!file.startsWith(WEB_DIR) || !fs10.existsSync(file) || fs10.statSync(file).isDirectory()) file = path10.join(WEB_DIR, "index.html");
-  if (!fs10.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[path10.extname(file)] ?? "application/octet-stream" });
-  fs10.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 fs12 from "fs";
-import path12 from "path";
+import fs13 from "fs";
+import path13 from "path";
 import * as p from "@clack/prompts";
 import pc2 from "picocolors";
 
 // src/core/method.ts
-import fs11 from "fs";
-import path11 from "path";
+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(fs11.readFileSync(path11.join(root2, "pnpm-workspace.yaml"), "utf8"), { logLevel: "error" });
+    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(fs11.readFileSync(path11.join(root2, "package.json"), "utf8")).workspaces;
+    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) && fs11.statSync(path11.join(root2, d), { throwIfNoEntry: false })?.isDirectory()).sort();
+  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();
 }
 var KNOWN_PREFIXES = {
   apps: "APP",
@@ -1201,17 +1232,17 @@ function suggestPrefix(dir, used) {
 var rootPrefix = (areas) => areas.length ? "CORE" : "T";
 function scaffoldMethod(root2, mainDoc, areas) {
   const created = [];
-  const name = path11.basename(root2);
-  copyTree(path11.join(TEMPLATES_DIR, "method", "root"), root2, { date: today(), name, prefix: rootPrefix(areas), area: areas.length ? "core" : name }, 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 = path11.join(root2, a.dir);
-    copyTree(path11.join(TEMPLATES_DIR, "method", "area"), dir, vars, created, root2);
-    let doc = MAIN_DOCS.map((d) => path11.join(dir, d)).find((f) => fs11.existsSync(f));
+    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 = path11.join(dir, mainDoc);
-      fs11.writeFileSync(doc, fill(fs11.readFileSync(path11.join(TEMPLATES_DIR, "method", "area-main.md"), "utf8"), vars));
-      created.push(path11.posix.join(a.dir, mainDoc));
+      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);
   }
@@ -1266,11 +1297,11 @@ function methodSection(areas) {
   ].join("\n");
 }
 function installMethodSkills(root2) {
-  const src = path11.join(TEMPLATES_DIR, "method", "skills");
-  for (const name of fs11.readdirSync(src)) {
-    const dest = path11.join(root2, ".claude", "skills", name);
-    fs11.mkdirSync(dest, { recursive: true });
-    fs11.copyFileSync(path11.join(src, name, "SKILL.md"), path11.join(dest, "SKILL.md"));
+  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"));
   }
 }
 
@@ -1282,13 +1313,19 @@ function check(value) {
   }
   return value;
 }
-async function chooseMainDoc(root2) {
-  const existing = MAIN_DOCS.filter((d) => fs12.existsSync(path12.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 }))
       })
     );
   }
@@ -1298,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}` }))
         ]
       })
     );
@@ -1308,22 +1345,43 @@ 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;
 }
+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) {
+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: "Monorepo detected. Which folders are areas with their own docs and tasks? (none: one docs/ for everything)",
-      options: candidates.map((d) => ({ value: d, label: `${d}/` })),
+      options: candidates.map((d2) => ({ value: d2, label: `${d2}/` })),
       initialValues: candidates,
       required: false
     })
@@ -1344,47 +1402,31 @@ async function chooseAreas(root2) {
   }
   return areas;
 }
-async function chooseWorkflow(root2, mainDoc, previous) {
+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 = check(
-      await p.select({
-        message: "Create a base structure for specs and planning?",
-        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" }
-        ],
-        initialValue: previous ?? "none"
-      })
-    );
+    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);
+      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 ? check(
-        await p.select({
-          message: "The AI can write proposals you answer by ticking options and commenting. How should they be organized?",
-          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/" }
-          ]
-        })
-      ) : "general";
+      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()) {
+    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.",
@@ -1398,8 +1440,7 @@ async function chooseWorkflow(root2, mainDoc, previous) {
       official = false;
     }
     const initial = mainDoc === "AGENTS.md" ? "codex" : "claude";
-    const agentOptions = Object.keys(SDD_AGENTS).map((a) => ({ value: a, label: SDD_AGENTS[a].label }));
-    const agents = !official ? [initial] : 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 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);
@@ -1412,36 +1453,24 @@ Created the structure only.`);
     return { workflow: choice };
   }
 }
-async function runInit(root2) {
+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);
-  const mainFile = path12.join(root2, mainDoc);
-  const { workflow, section: section2 } = await chooseWorkflow(root2, mainDoc, previous?.workflow);
+  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 = fs12.readFileSync(mainFile, "utf8");
-  const sourceLang = check(
-    await p.select({
-      message: "Language you work in (every .md file is written in it)",
-      options: LANGS.map((l) => ({ value: l, label: LANG_NAMES[l], hint: l === "en" ? "default" : void 0 })),
-      initialValue: sourceLangOf(mainText)
-    })
-  );
+  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 })),
@@ -1449,13 +1478,13 @@ async function runInit(root2) {
       })
     );
     for (const dir of targets) {
-      const doc = MAIN_DOCS.find((d) => fs12.existsSync(path12.join(root2, dir, d)));
-      applyRulesToFile(path12.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);
@@ -1464,6 +1493,54 @@ async function runInit(root2) {
   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";
@@ -1534,7 +1611,8 @@ 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, specs structure, rules, languages
+  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
@@ -1542,6 +1620,8 @@ Usage
   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
 `;
@@ -1557,12 +1637,17 @@ 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") });
@@ -1571,6 +1656,10 @@ 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");