skillwiki 0.9.51 → 0.9.55

package/dist/{chunk-O3WK7GBV.js → chunk-4BT3HY4K.js}

@@ -1823,9 +1823,9 @@ async function runStale(input) {
       if (input.project && !project.includes(input.project)) return null;
       let inferred = false;
       if (input.forceScan && !kind) {
-        const basename3 = t.relPath.split("/").pop();
-        if (!LOOP_CYCLE_PATTERN.test(basename3)) {
-          const m = basename3.match(KIND_FROM_FILENAME);
+        const basename4 = t.relPath.split("/").pop();
+        if (!LOOP_CYCLE_PATTERN.test(basename4)) {
+          const m = basename4.match(KIND_FROM_FILENAME);
           if (m) {
             kind = m[1];
             inferred = true;
@@ -2852,7 +2852,7 @@ function buildCliSurface() {
   program.command("lint").option("--days <n>").option("--lines <n>").option("--log-threshold <n>").option("--fix").option("--only <bucket>").option("--summary").option("--examples <n>").option("--wiki <name>");
   program.command("config");
   program.command("health").option("--wiki <name>").option("--sync <mode>").option("--no-fail").option("--out <path>").option("--examples <n>");
-  program.command("doctor");
+  program.command("doctor").option("--check-snapshotter");
   program.command("status").option("--wiki <name>");
   program.command("archive").option("--wiki <name>").option("--cascade").option("--apply").option("--remote <remote>").option("--remote-delete").option("--max-remote-deletes <n>");
   program.command("drift").option("--apply").option("--new <date>").option("--wiki <name>");
@@ -2887,7 +2887,7 @@ function buildCliSurface() {
   compoundCmd.command("list").requiredOption("--project <slug>").option("--wiki <name>");
   compoundCmd.command("delete").requiredOption("--project <slug>").option("--wiki <name>");
   const syncCmd = program.commands.find((c) => c.name() === "sync");
-  syncCmd.command("status").option("--wiki <name>").option("--include-stashes");
+  syncCmd.command("status").option("--wiki <name>").option("--include-stashes").option("--include-remote-health").option("--check-snapshotter");
   syncCmd.command("push").option("--wiki <name>");
   syncCmd.command("pull").option("--wiki <name>");
   syncCmd.command("lock").option("--summary <text>").option("--ttl-minutes <n>").option("--force").option("--wiki <name>");
@@ -3100,7 +3100,7 @@ function extractSourceEntries(rawFm) {
   }
   return entries;
 }
-var ERROR_ORDER = ["sensitive_content", "broken_wikilinks", "invalid_frontmatter", "raw_source_identity_conflict", "raw_dedup", "broken_sources", "tag_not_in_taxonomy", "path_too_long"];
+var ERROR_ORDER = ["sensitive_content", "conflict_markers", "broken_wikilinks", "invalid_frontmatter", "raw_source_identity_conflict", "raw_dedup", "broken_sources", "tag_not_in_taxonomy", "path_too_long"];
 var WARNING_ORDER = ["raw_body_duplicate", "raw_subdirectory_duplicate", "file_source_url", "index_incomplete", "index_link_format", "stale_page", "page_too_large", "log_rotate_needed", "orphans", "compound_refs", "legacy_citation_style", "orphaned_citations", "duplicate_frontmatter", "frontmatter_yaml_invalid", "work_item_health", "orphaned_project_pages", "missing_overview", "missing_diagram"];
 var INFO_ORDER = ["bridges", "sparse_community", "page_structure", "topic_map_recommended", "frontmatter_wikilink", "wikilink_citation", "missing_tldr", "stale_sections", "cli_refs"];
 var KNOWN_BUCKETS = [...ERROR_ORDER, ...WARNING_ORDER, ...INFO_ORDER];
@@ -3448,6 +3448,38 @@ async function runFileSourceUrlOnly(input) {
   const match = remaining.size > 0 ? [{ kind: "file_source_url", items: [...remaining] }] : [];
   return outputForOnlyBucket(input, match, fixed, unresolved, readVault);
 }
+function scanConflictMarkerBlocks(path, text) {
+  const findings = [];
+  const lines = text.split(/\r?\n/);
+  let inFence = false;
+  let openLine = 0;
+  let sawSeparator = false;
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i];
+    if (line.startsWith("```") || line.startsWith("~~~")) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence) continue;
+    if (line.startsWith("<<<<<<< ")) {
+      openLine = i + 1;
+      sawSeparator = false;
+      continue;
+    }
+    if (line === "=======" && openLine > 0) {
+      sawSeparator = true;
+      continue;
+    }
+    if (line.startsWith(">>>>>>> ")) {
+      if (openLine > 0 && sawSeparator) {
+        findings.push({ path, line: openLine, message: "complete Git conflict-marker block" });
+      }
+      openLine = 0;
+      sawSeparator = false;
+    }
+  }
+  return findings;
+}
 async function runLint(input) {
   if (input.only && !KNOWN_BUCKETS.includes(input.only)) {
     return {
@@ -3545,10 +3577,12 @@ async function runLint(input) {
   {
     const allPageResults = await mapWithConcurrency(scan.allMarkdown, vaultIoConcurrency(), async (page) => {
       const sensitiveFlags2 = [];
+      const conflictMarkers2 = [];
       let fmYamlInvalid2 = null;
       try {
         const text = await readPageCached(page, pageTextCache);
         sensitiveFlags2.push(...scanSensitiveContent(text, { file: page.relPath }));
+        conflictMarkers2.push(...scanConflictMarkerBlocks(page.relPath, text));
         const fm = extractFrontmatter(text);
         if (!fm.ok && fm.error === "INVALID_FRONTMATTER") {
           const detail = fm.detail;
@@ -3557,10 +3591,12 @@ async function runLint(input) {
         }
       } catch {
       }
-      return { sensitiveFlags: sensitiveFlags2, fmYamlInvalid: fmYamlInvalid2 };
+      return { sensitiveFlags: sensitiveFlags2, conflictMarkers: conflictMarkers2, fmYamlInvalid: fmYamlInvalid2 };
     });
     const sensitiveFlags = allPageResults.flatMap((result) => result.sensitiveFlags);
     if (sensitiveFlags.length > 0) buckets.sensitive_content = sensitiveFlags;
+    const conflictMarkers = allPageResults.flatMap((result) => result.conflictMarkers);
+    if (conflictMarkers.length > 0) buckets.conflict_markers = conflictMarkers;
     const fmYamlInvalid = allPageResults.map((result) => result.fmYamlInvalid).filter((item) => item !== null);
     if (fmYamlInvalid.length > 0) buckets.frontmatter_yaml_invalid = fmYamlInvalid;
     const subDirDupes = [];
@@ -4538,6 +4574,15 @@ async function loadFleetManifestAndHost(input) {
     identityStatus: "known"
   };
 }
+function snapshotterAliasForLocalHost(fleetLoad) {
+  if (!fleetLoad?.manifest || !fleetLoad.hostId) return void 0;
+  const snapshotterId = Object.entries(fleetLoad.manifest.hosts).find(([, h]) => h.role === "snapshotter")?.[0];
+  if (!snapshotterId) return void 0;
+  const profile = fleetLoad.manifest.hosts[snapshotterId]?.access?.from?.[fleetLoad.hostId];
+  if (!profile || profile.status !== "configured" && profile.status !== "local") return void 0;
+  const aliases = profile.ssh_aliases ?? [];
+  return aliases.length > 0 ? aliases[0] : void 0;
+}
 function satelliteGateFromFleetLoad(load) {
   if (!load?.hostId) return { satelliteExpected: false };
   const host = load.manifest.hosts[load.hostId];
@@ -4794,8 +4839,8 @@ function safeUserName() {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync11, lstatSync, readlinkSync, readdirSync as readdirSync2, statSync, readFileSync as readFileSync8 } from "fs";
-import { join as join22, resolve as resolve5 } from "path";
+import { existsSync as existsSync13, lstatSync, readlinkSync, readdirSync as readdirSync3, statSync, readFileSync as readFileSync10 } from "fs";
+import { join as join24, resolve as resolve5 } from "path";
 import { execSync as execSync2 } from "child_process";
 import { platform as platform2 } from "os";
 
@@ -4917,12 +4962,180 @@ function parseTomlScalar(rawValue) {
   return value;
 }
 
-// src/utils/satellite-run-health.ts
-import { existsSync as existsSync9, readFileSync as readFileSync6 } from "fs";
+// src/utils/conflict-markers.ts
+import { existsSync as existsSync9, readdirSync as readdirSync2, readFileSync as readFileSync6 } from "fs";
 import { join as join20 } from "path";
+function scanConflictMarkerBlocksInText(relPath, text) {
+  const findings = [];
+  const lines = text.split(/\r?\n/);
+  let inFence = false;
+  let openLine = 0;
+  let sawSeparator = false;
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i];
+    if (line.startsWith("```") || line.startsWith("~~~")) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence) continue;
+    if (line.startsWith("<<<<<<< ")) {
+      openLine = i + 1;
+      sawSeparator = false;
+      continue;
+    }
+    if (line === "=======" && openLine > 0) {
+      sawSeparator = true;
+      continue;
+    }
+    if (line.startsWith(">>>>>>> ")) {
+      if (openLine > 0 && sawSeparator) {
+        findings.push({ path: relPath, line: openLine });
+      }
+      openLine = 0;
+      sawSeparator = false;
+    }
+  }
+  return findings;
+}
+var PRUNE_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  ".obsidian",
+  ".skillwiki",
+  ".claude",
+  ".antigravitycli",
+  ".playwright-cli"
+]);
+function walkMarkdownFiles2(root, dir, rel, out) {
+  let entries;
+  try {
+    entries = readdirSync2(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (PRUNE_DIRS.has(entry.name)) continue;
+      walkMarkdownFiles2(root, join20(dir, entry.name), rel ? `${rel}/${entry.name}` : entry.name, out);
+    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+      out.push(rel ? `${rel}/${entry.name}` : entry.name);
+    }
+  }
+}
+function scanVaultConflictMarkers(vaultRoot) {
+  if (!existsSync9(vaultRoot)) return [];
+  const relPaths = [];
+  walkMarkdownFiles2(vaultRoot, vaultRoot, "", relPaths);
+  const all = [];
+  for (const rel of relPaths) {
+    let text;
+    try {
+      text = readFileSync6(join20(vaultRoot, rel), "utf8");
+    } catch {
+      continue;
+    }
+    all.push(...scanConflictMarkerBlocksInText(rel, text));
+  }
+  return all;
+}
+
+// src/utils/remote-health.ts
+import { existsSync as existsSync10, readFileSync as readFileSync7 } from "fs";
+import { join as join21 } from "path";
+import { execFileSync } from "child_process";
+var REMOTE_PROBE_TIMEOUT_MS = 3e3;
+var defaultExec = (file, args, cwd) => execFileSync(file, args, {
+  cwd,
+  encoding: "utf8",
+  stdio: ["pipe", "pipe", "pipe"],
+  timeout: REMOTE_PROBE_TIMEOUT_MS
+}).trim();
+var DEFAULT_WIKI_S3_REMOTE = "seaweed-wiki:cloud/wiki";
+function readWikiS3RemoteConfigured(home) {
+  try {
+    const content = readFileSync7(join21(home, ".skillwiki", ".env"), "utf8");
+    for (const line of content.split(/\r?\n/)) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const eq = trimmed.indexOf("=");
+      if (eq <= 0) continue;
+      const k = trimmed.slice(0, eq).trim();
+      const v = trimmed.slice(eq + 1).trim();
+      if (k === "WIKI_REMOTE" && v.length > 0) return v;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function readWikiS3RemoteFromEnv(home) {
+  return readWikiS3RemoteConfigured(home) ?? DEFAULT_WIKI_S3_REMOTE;
+}
+function probeGithubReachability(vaultPath, exec = defaultExec) {
+  if (!existsSync10(join21(vaultPath, ".git"))) return "unknown";
+  try {
+    exec("git", ["remote", "get-url", "origin"], vaultPath);
+  } catch {
+    return "unknown";
+  }
+  try {
+    const out = exec("git", ["ls-remote", "origin", "refs/heads/main"], vaultPath);
+    if (out.length > 0) return "ok";
+    return "unreachable";
+  } catch {
+    return "unreachable";
+  }
+}
+function probeS3Reachability(remote, exec = defaultExec) {
+  if (!remote) return "unknown";
+  try {
+    exec("rclone", ["lsf", remote, "--max-depth", "1", "--files-only"]);
+    return "ok";
+  } catch {
+    return "unreachable";
+  }
+}
+function probeSnapshotterSsh(sshAlias2, exec = defaultExec) {
+  if (!sshAlias2) return "unknown";
+  try {
+    exec("ssh", [
+      "-o",
+      "BatchMode=yes",
+      "-o",
+      "ConnectTimeout=3",
+      "-o",
+      "StrictHostKeyChecking=accept-new",
+      sshAlias2,
+      "true"
+    ]);
+    return "ok";
+  } catch {
+    return "unreachable";
+  }
+}
+function buildDegradedReasons(health) {
+  const reasons = [];
+  if (health.github === "unreachable") reasons.push("github_remote_unreachable");
+  if (health.s3 === "unreachable") reasons.push("s3_remote_unreachable");
+  if (health.snapshotter === "unreachable") reasons.push("snapshotter_host_unreachable");
+  return reasons;
+}
+function probeRemoteHealth(input) {
+  const exec = input.exec ?? defaultExec;
+  const github = probeGithubReachability(input.vaultPath, exec);
+  const s3Remote = input.s3Remote ?? readWikiS3RemoteFromEnv(input.home);
+  const s3 = probeS3Reachability(s3Remote, exec);
+  let snapshotter = "not_checked";
+  if (input.checkSnapshotter && input.snapshotterAlias) {
+    snapshotter = probeSnapshotterSsh(input.snapshotterAlias, exec);
+  }
+  return { github, s3, snapshotter };
+}
+
+// src/utils/satellite-run-health.ts
+import { existsSync as existsSync11, readFileSync as readFileSync8 } from "fs";
+import { join as join22 } from "path";
 var SATELLITE_STALE_MS = 26 * 60 * 60 * 1e3;
 function satelliteLatestRunPath(vault) {
-  return join20(vault, ".skillwiki", "agent-memory-trends", "latest-run.json");
+  return join22(vault, ".skillwiki", "agent-memory-trends", "latest-run.json");
 }
 function isFailedRunStatus(status) {
   return status === "fail" || status === "failure";
@@ -4944,9 +5157,9 @@ function readSatelliteLatestRunFromText(text) {
 }
 function readSatelliteLatestRun(vault) {
   const latestPath = satelliteLatestRunPath(vault);
-  if (!existsSync9(latestPath)) return null;
+  if (!existsSync11(latestPath)) return null;
   try {
-    return parseLatestRunFile(readFileSync6(latestPath, "utf8"));
+    return parseLatestRunFile(readFileSync8(latestPath, "utf8"));
   } catch {
     return null;
   }
@@ -4975,8 +5188,8 @@ function evaluateSatelliteRunHealth(vault, now) {
 // src/utils/s3-mount-health.ts
 import { execSync } from "child_process";
 import { platform } from "os";
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync4, unlinkSync as unlinkSync3, readFileSync as readFile15 } from "fs";
-import { join as join21 } from "path";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync4, unlinkSync as unlinkSync3, readFileSync as readFile15 } from "fs";
+import { join as join23 } from "path";
 var OS = platform();
 function findRcloneMountPid() {
   try {
@@ -5060,7 +5273,7 @@ function extractRcloneFs(args) {
 function getRcloneArgs(pid) {
   try {
     if (OS === "linux") {
-      const raw = readFileSync7(`/proc/${pid}/cmdline`);
+      const raw = readFileSync9(`/proc/${pid}/cmdline`);
       return new TextDecoder().decode(raw).split("\0").filter(Boolean);
     } else {
       const out = execSync(`ps -o args= -p ${pid}`, {
@@ -5103,7 +5316,7 @@ function queryRcloneRC(rcAddr, fs) {
 function detectFuseMount(vaultPath) {
   try {
     if (OS === "linux") {
-      const mounts = readFileSync7("/proc/mounts", "utf8");
+      const mounts = readFileSync9("/proc/mounts", "utf8");
       let best = null;
       for (const line of mounts.split("\n")) {
         const parts = line.split(" ");
@@ -5134,7 +5347,7 @@ function detectFuseMount(vaultPath) {
   return null;
 }
 function writeTest(dir) {
-  const testFile = join21(dir, `.doctor-write-test-${process.pid}.tmp`);
+  const testFile = join23(dir, `.doctor-write-test-${process.pid}.tmp`);
   const payload = `skillwiki doctor write test \u2014 ${Date.now()} \u2014 ${Math.random().toString(36).slice(2)}`;
   const start = Date.now();
   try {
@@ -5234,13 +5447,13 @@ function detectCliChannels(argv, home) {
   }
   const plugin = findPlugin(home);
   if (plugin) {
-    const pluginBin = join22(plugin.installPath, "bin", "skillwiki");
-    if (existsSync11(pluginBin)) {
+    const pluginBin = join24(plugin.installPath, "bin", "skillwiki");
+    if (existsSync13(pluginBin)) {
       channels.push({ name: "plugin", path: pluginBin, isDevLink: false });
     }
   }
-  const installBin = join22(home, ".claude", "skills", "bin", "skillwiki");
-  if (existsSync11(installBin)) {
+  const installBin = join24(home, ".claude", "skills", "bin", "skillwiki");
+  if (existsSync13(installBin)) {
     channels.push({ name: "install", path: installBin, isDevLink: false });
   }
   return channels;
@@ -5301,7 +5514,7 @@ function isDevSourceRun(argv) {
 }
 async function checkConfigFile(home) {
   const cfgPath = configPath(home);
-  if (!existsSync11(cfgPath)) {
+  if (!existsSync13(cfgPath)) {
     return check("warn", "config_file", "Config file exists", `${cfgPath} not found`);
   }
   try {
@@ -5316,7 +5529,7 @@ function checkWikiPathExists(resolvedPath) {
   if (resolvedPath === void 0) {
     return check("error", "wiki_path_exists", "Vault directory exists", "Cannot check \u2014 WIKI_PATH not resolved");
   }
-  if (existsSync11(resolvedPath) && statSync(resolvedPath).isDirectory()) {
+  if (existsSync13(resolvedPath) && statSync(resolvedPath).isDirectory()) {
     return check("pass", "wiki_path_exists", "Vault directory exists", resolvedPath);
   }
   return check("error", "wiki_path_exists", "Vault directory exists", `${resolvedPath} does not exist or is not a directory`);
@@ -5325,13 +5538,13 @@ function checkVaultStructure(resolvedPath) {
   if (resolvedPath === void 0) {
     return check("error", "vault_structure", "Vault structure valid", "Cannot check \u2014 WIKI_PATH not resolved");
   }
-  if (!existsSync11(resolvedPath)) {
+  if (!existsSync13(resolvedPath)) {
     return check("error", "vault_structure", "Vault structure valid", "Cannot check \u2014 vault directory does not exist");
   }
   const missing = [];
-  if (!existsSync11(join22(resolvedPath, "SCHEMA.md"))) missing.push("SCHEMA.md");
+  if (!existsSync13(join24(resolvedPath, "SCHEMA.md"))) missing.push("SCHEMA.md");
   for (const dir of ["raw", "entities", "concepts", "meta"]) {
-    if (!existsSync11(join22(resolvedPath, dir))) missing.push(dir + "/");
+    if (!existsSync13(join24(resolvedPath, dir))) missing.push(dir + "/");
   }
   if (missing.length === 0) {
     return check("pass", "vault_structure", "Vault structure valid", "All required files and directories present");
@@ -5339,8 +5552,8 @@ function checkVaultStructure(resolvedPath) {
   return check("warn", "vault_structure", "Vault structure valid", `Missing: ${missing.join(", ")} \u2014 run \`skillwiki init\` to add CodeWiki structure`);
 }
 function checkSkillsInstalled(home, cwd) {
-  const srcDir = cwd ? join22(cwd, "packages", "skills") : void 0;
-  if (srcDir && existsSync11(srcDir)) {
+  const srcDir = cwd ? join24(cwd, "packages", "skills") : void 0;
+  if (srcDir && existsSync13(srcDir)) {
     const found = findInstalledSkillMd(srcDir);
     if (found.length > 0) {
       return check("pass", "skills_installed", "Skills installed", `${found.length} SKILL.md file(s) found (source)`);
@@ -5353,8 +5566,8 @@ function checkSkillsInstalled(home, cwd) {
       return check("pass", "skills_installed", "Skills installed", `${found.length} SKILL.md file(s) found (plugin v${plugin.version})`);
     }
   }
-  const skillsDir = join22(home, ".claude", "skills");
-  if (existsSync11(skillsDir)) {
+  const skillsDir = join24(home, ".claude", "skills");
+  if (existsSync13(skillsDir)) {
     const found = findInstalledSkillMd(skillsDir);
     if (found.length > 0) {
       return check("pass", "skills_installed", "Skills installed", `${found.length} SKILL.md file(s) found (CLI install)`);
@@ -5364,10 +5577,10 @@ function checkSkillsInstalled(home, cwd) {
 }
 function checkDuplicateSkills(home) {
   const plugin = findPlugin(home);
-  const skillsDir = join22(home, ".claude", "skills");
+  const skillsDir = join24(home, ".claude", "skills");
   const agentSkillDirs = [
-    { label: "~/.codex/skills/", path: join22(home, ".codex", "skills") },
-    { label: "~/.agents/skills/", path: join22(home, ".agents", "skills") }
+    { label: "~/.codex/skills/", path: join24(home, ".codex", "skills") },
+    { label: "~/.agents/skills/", path: join24(home, ".agents", "skills") }
   ];
   if (!plugin) {
     return check("pass", "skills_duplicate", "Skills not duplicated", "Single install channel");
@@ -5470,8 +5683,8 @@ async function checkProfiles(home) {
 }
 async function checkProjectLocalOverride(cwd) {
   const dir = cwd ?? process.cwd();
-  const envPath = join22(dir, ".skillwiki", ".env");
-  if (existsSync11(envPath)) {
+  const envPath = join24(dir, ".skillwiki", ".env");
+  if (existsSync13(envPath)) {
     return check("pass", "project_local", "Project-local config", `Found: ${envPath}`);
   }
   return check("pass", "project_local", "Project-local config", "None");
@@ -5480,7 +5693,7 @@ function checkVaultGitRemote(resolvedPath) {
   if (resolvedPath === void 0) {
     return check("error", "vault_git_remote", "Vault git remote", "Cannot check \u2014 WIKI_PATH not resolved");
   }
-  if (!existsSync11(join22(resolvedPath, ".git"))) {
+  if (!existsSync13(join24(resolvedPath, ".git"))) {
     return check("warn", "vault_git_remote", "Vault git remote", "Vault is not a git repository \u2014 sync features unavailable");
   }
   try {
@@ -5503,9 +5716,9 @@ function checkObsidianTemplates(resolvedPath) {
     return check("error", "obsidian_templates", "Obsidian templates", "Cannot check \u2014 WIKI_PATH not resolved");
   }
   const missing = [];
-  if (!existsSync11(join22(resolvedPath, "_Templates"))) missing.push("_Templates/");
-  if (!existsSync11(join22(resolvedPath, ".obsidian", "templates.json"))) missing.push(".obsidian/templates.json");
-  if (!existsSync11(join22(resolvedPath, ".obsidian", "app.json"))) missing.push(".obsidian/app.json");
+  if (!existsSync13(join24(resolvedPath, "_Templates"))) missing.push("_Templates/");
+  if (!existsSync13(join24(resolvedPath, ".obsidian", "templates.json"))) missing.push(".obsidian/templates.json");
+  if (!existsSync13(join24(resolvedPath, ".obsidian", "app.json"))) missing.push(".obsidian/app.json");
   if (missing.length === 0) {
     return check("pass", "obsidian_templates", "Obsidian templates", "Template folder and config present");
   }
@@ -5515,15 +5728,15 @@ function checkDotStoreClean(resolvedPath) {
   if (resolvedPath === void 0) {
     return check("error", "dsstore_clean", "No .DS_Store in raw/", "Cannot check \u2014 WIKI_PATH not resolved");
   }
-  const rawDir = join22(resolvedPath, "raw");
-  if (!existsSync11(rawDir)) {
+  const rawDir = join24(resolvedPath, "raw");
+  if (!existsSync13(rawDir)) {
     return check("pass", "dsstore_clean", "No .DS_Store in raw/", "raw/ directory not found \u2014 check skipped");
   }
   const found = [];
   (function walk2(dir, rel) {
     let entries;
     try {
-      entries = readdirSync2(dir, { withFileTypes: true });
+      entries = readdirSync3(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -5531,7 +5744,7 @@ function checkDotStoreClean(resolvedPath) {
       if (entry.name === ".DS_Store") {
         found.push(rel ? `${rel}/.DS_Store` : ".DS_Store");
       } else if (entry.isDirectory()) {
-        walk2(join22(dir, entry.name), rel ? `${rel}/${entry.name}` : entry.name);
+        walk2(join24(dir, entry.name), rel ? `${rel}/${entry.name}` : entry.name);
       }
     }
   })(rawDir, "");
@@ -5540,11 +5753,29 @@ function checkDotStoreClean(resolvedPath) {
   }
   return check("info", "dsstore_clean", "No .DS_Store in raw/", `${found.length} .DS_Store file(s) found \u2014 remove with: find ${rawDir} -name .DS_Store -delete`);
 }
+function checkVaultConflictMarkers(resolvedPath) {
+  if (resolvedPath === void 0) {
+    return check("pass", "vault_conflict_markers", "Vault conflict markers", "No vault path \u2014 check skipped");
+  }
+  const findings = scanVaultConflictMarkers(resolvedPath);
+  if (findings.length === 0) {
+    return check("pass", "vault_conflict_markers", "Vault conflict markers", "No complete conflict-marker blocks");
+  }
+  const first = findings[0];
+  const n = findings.length;
+  const fileWord = n === 1 ? "file" : "files";
+  return check(
+    "error",
+    "vault_conflict_markers",
+    "Vault conflict markers",
+    `${n} ${fileWord}, first: ${first.path}:${first.line}`
+  );
+}
 function checkSyncLastPush(resolvedPath) {
   if (resolvedPath === void 0) {
     return check("error", "sync_last_push", "Vault sync recency", "Cannot check \u2014 WIKI_PATH not resolved");
   }
-  if (!existsSync11(join22(resolvedPath, ".git"))) {
+  if (!existsSync13(join24(resolvedPath, ".git"))) {
     return check("pass", "sync_last_push", "Vault sync recency", "No git repo \u2014 sync check skipped");
   }
   let timestamp;
@@ -5592,7 +5823,7 @@ function checkVaultGitDirty(resolvedPath) {
   if (resolvedPath === void 0) {
     return check("pass", "vault_git_dirty", "Vault git dirty state", "No vault path \u2014 check skipped");
   }
-  if (!existsSync11(join22(resolvedPath, ".git"))) {
+  if (!existsSync13(join24(resolvedPath, ".git"))) {
     return check("pass", "vault_git_dirty", "Vault git dirty state", "No git repo \u2014 check skipped");
   }
   try {
@@ -5660,7 +5891,7 @@ function remoteMainHash(resolvedPath) {
 }
 function checkStaleRemoteMain(resolvedPath) {
   if (resolvedPath === void 0) return void 0;
-  if (!existsSync11(join22(resolvedPath, ".git"))) return void 0;
+  if (!existsSync13(join24(resolvedPath, ".git"))) return void 0;
   const localOrigin = gitRefHash(resolvedPath, "origin/main");
   if (!localOrigin) return void 0;
   const remoteMain = remoteMainHash(resolvedPath);
@@ -5672,11 +5903,101 @@ function checkStaleRemoteMain(resolvedPath) {
     `Remote main differs from local origin/main (${remoteMain.slice(0, 8)} != ${localOrigin.slice(0, 8)}) \u2014 run git fetch before trusting behind count`
   );
 }
+function checkVaultLocalGit(resolvedPath) {
+  if (resolvedPath === void 0) {
+    return check("warn", "vault_local_git", "Vault local git", "Cannot check \u2014 WIKI_PATH not resolved");
+  }
+  if (!existsSync13(join24(resolvedPath, ".git"))) {
+    return check("warn", "vault_local_git", "Vault local git", "Not a git repository - sync features unavailable");
+  }
+  try {
+    execSync2("git rev-parse --git-dir", {
+      cwd: resolvedPath,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 2e3
+    });
+    return check("pass", "vault_local_git", "Vault local git", "Git metadata readable");
+  } catch {
+    return check("error", "vault_local_git", "Vault local git", "Git metadata unreadable \u2014 local vault may be corrupt");
+  }
+}
+function checkVaultGithubRemote(resolvedPath, exec) {
+  if (resolvedPath === void 0) {
+    return check("pass", "vault_github_remote", "Vault GitHub remote", "No vault path \u2014 check skipped");
+  }
+  if (!existsSync13(join24(resolvedPath, ".git"))) {
+    return check("pass", "vault_github_remote", "Vault GitHub remote", "No git repo \u2014 check skipped");
+  }
+  const state = probeGithubReachability(resolvedPath, exec);
+  if (state === "ok") {
+    return check("pass", "vault_github_remote", "Vault GitHub remote", "git ls-remote origin main succeeded");
+  }
+  if (state === "unreachable") {
+    return check("warn", "vault_github_remote", "Vault GitHub remote", "GitHub unreachable (ls-remote failed) \u2014 local vault still usable");
+  }
+  return check("pass", "vault_github_remote", "Vault GitHub remote", "No origin remote \u2014 network probe skipped");
+}
+function checkVaultS3Remote(home, exec) {
+  const remote = readWikiS3RemoteConfigured(home);
+  if (!remote) {
+    return check("pass", "vault_s3_remote", "Vault S3 remote", "S3 remote not configured \u2014 check skipped");
+  }
+  const state = probeS3Reachability(remote, exec);
+  if (state === "ok") {
+    return check("pass", "vault_s3_remote", "Vault S3 remote", `rclone lsf ${remote} succeeded`);
+  }
+  if (state === "unreachable") {
+    return check("warn", "vault_s3_remote", "Vault S3 remote", `S3 remote unreachable (${remote}) \u2014 local/GitHub work may continue`);
+  }
+  return check("pass", "vault_s3_remote", "Vault S3 remote", "S3 remote not configured \u2014 check skipped");
+}
+function checkVaultSnapshotterReachable(fleetLoad, checkSnapshotter, exec) {
+  if (!checkSnapshotter) {
+    return check("pass", "vault_snapshotter_reachable", "Vault snapshotter host", "Snapshotter SSH probe not requested \u2014 check skipped");
+  }
+  const alias = snapshotterAliasForLocalHost(fleetLoad);
+  if (!alias) {
+    return check("pass", "vault_snapshotter_reachable", "Vault snapshotter host", "No declared SSH alias from this host \u2014 check skipped");
+  }
+  const state = probeSnapshotterSsh(alias, exec);
+  if (state === "ok") {
+    return check("pass", "vault_snapshotter_reachable", "Vault snapshotter host", `SSH reachable via ${alias}`);
+  }
+  return check("warn", "vault_snapshotter_reachable", "Vault snapshotter host", `Snapshotter unreachable via ${alias} \u2014 not a local vault corruption signal`);
+}
+function checkVaultPromotionLag(resolvedPath) {
+  if (resolvedPath === void 0) {
+    return check("pass", "vault_promotion_lag", "Vault promotion lag", "No vault path \u2014 check skipped");
+  }
+  if (!existsSync13(join24(resolvedPath, ".git"))) {
+    return check("pass", "vault_promotion_lag", "Vault promotion lag", "No git repo \u2014 check skipped");
+  }
+  try {
+    const out = execSync2("git log -1 --format=%ct origin/main", {
+      cwd: resolvedPath,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 2e3
+    }).trim();
+    const ts = parseInt(out, 10);
+    if (!Number.isFinite(ts) || ts <= 0) {
+      return check("pass", "vault_promotion_lag", "Vault promotion lag", "origin/main timestamp unavailable \u2014 check skipped");
+    }
+    const ageHours = Math.floor((Date.now() / 1e3 - ts) / 3600);
+    if (ageHours > 48) {
+      return check("warn", "vault_promotion_lag", "Vault promotion lag", `Local origin/main snapshot is ${ageHours}h old \u2014 verify snapshotter/GitHub when online`);
+    }
+    return check("pass", "vault_promotion_lag", "Vault promotion lag", `origin/main age ${ageHours}h`);
+  } catch {
+    return check("pass", "vault_promotion_lag", "Vault promotion lag", "Could not read origin/main \u2014 check skipped");
+  }
+}
 function checkVaultGitComparison(resolvedPath, id, label, range, nonZeroSuffix, zeroDetail) {
   if (resolvedPath === void 0) {
     return check("pass", id, label, "No vault path \u2014 check skipped");
   }
-  if (!existsSync11(join22(resolvedPath, ".git"))) {
+  if (!existsSync13(join24(resolvedPath, ".git"))) {
     return check("pass", id, label, "No git repo \u2014 check skipped");
   }
   if (!hasOriginMain(resolvedPath)) {
@@ -5704,7 +6025,7 @@ function checkSatelliteLastRun(vaultPath, satelliteExpected) {
     return check("pass", "satellite_job_last_run", "Satellite job last run", "No vault path \u2014 check skipped");
   }
   const latestPath = satelliteLatestRunPath(vaultPath);
-  if (!existsSync11(latestPath)) {
+  if (!existsSync13(latestPath)) {
     return check("pass", "satellite_job_last_run", "Satellite job last run", "No latest-run.json \u2014 satellite has not run yet");
   }
   try {
@@ -5792,11 +6113,11 @@ async function checkFleetIdentity(input) {
 }
 function pullLogPaths(home) {
   const paths = platform2() === "darwin" ? [
-    join22(home, "Library", "Logs", "wiki-pull.log"),
-    join22(home, ".local", "state", "vault-sync", "log", "wiki-pull.log")
+    join24(home, "Library", "Logs", "wiki-pull.log"),
+    join24(home, ".local", "state", "vault-sync", "log", "wiki-pull.log")
   ] : [
-    join22(home, ".local", "state", "vault-sync", "log", "wiki-pull.log"),
-    join22(home, "Library", "Logs", "wiki-pull.log")
+    join24(home, ".local", "state", "vault-sync", "log", "wiki-pull.log"),
+    join24(home, "Library", "Logs", "wiki-pull.log")
   ];
   return [...new Set(paths)];
 }
@@ -5808,12 +6129,12 @@ function isRecentLogLine(line, nowMs) {
   return nowMs - ts <= 24 * 60 * 60 * 1e3;
 }
 function checkVaultGitPullFailures(home) {
-  const path = pullLogPaths(home).find((p) => existsSync11(p));
+  const path = pullLogPaths(home).find((p) => existsSync13(p));
   if (!path) {
     return check("pass", "vault_git_pull_failures", "Vault pull failures", "No wiki-pull.log found \u2014 check skipped");
   }
   try {
-    const lines = readFileSync8(path, "utf8").split(/\r?\n/).filter(Boolean);
+    const lines = readFileSync10(path, "utf8").split(/\r?\n/).filter(Boolean);
     const now = Date.now();
     const failures = lines.filter(
       (line) => isRecentLogLine(line, now) && /(pre-push pull failed|FAIL .*pull|FAIL .*rebase|cannot pull with rebase|unstaged changes)/i.test(line)
@@ -5836,8 +6157,8 @@ function checkS3MountPerf(resolvedPath) {
     return check("pass", "s3_mount_perf", "S3 mount performance", "local disk");
   }
   const mountPoint = fuse.mountPoint;
-  const conceptsDir = join22(resolvedPath, "concepts");
-  if (!existsSync11(conceptsDir)) {
+  const conceptsDir = join24(resolvedPath, "concepts");
+  if (!existsSync13(conceptsDir)) {
     return check("pass", "s3_mount_perf", "S3 mount performance", `S3 FUSE mount (${mountPoint}), no concepts/ to benchmark`);
   }
   const start = Date.now();
@@ -6019,8 +6340,8 @@ function checkWriteTest(resolvedPath) {
   if (!fuse) {
     return check("pass", "s3_write_test", "S3 write test", "local disk \u2014 check skipped");
   }
-  const conceptsDir = join22(resolvedPath, "concepts");
-  if (!existsSync11(conceptsDir)) {
+  const conceptsDir = join24(resolvedPath, "concepts");
+  if (!existsSync13(conceptsDir)) {
     return check("pass", "s3_write_test", "S3 write test", "no concepts/ dir to test \u2014 check skipped");
   }
   const result = writeTest(conceptsDir);
@@ -6106,7 +6427,7 @@ function checkVfsCacheHealth(resolvedPath) {
 }
 function readVaultSyncConfig(home) {
   try {
-    const content = readFileSync8(join22(home, ".skillwiki", ".env"), "utf8");
+    const content = readFileSync10(join24(home, ".skillwiki", ".env"), "utf8");
     let installed = false;
     let role;
     let serviceScope;
@@ -6135,7 +6456,7 @@ function readVaultSyncConfig(home) {
 }
 function readKeyFromEnvFile(path, keys) {
   try {
-    const content = readFileSync8(path, "utf8");
+    const content = readFileSync10(path, "utf8");
     for (const line of content.split(/\r?\n/)) {
       const trimmed = line.trim();
       if (trimmed.length === 0 || trimmed.startsWith("#")) continue;
@@ -6157,7 +6478,7 @@ function resolveSnapshotGitWorktree(config) {
     if (fromProfile) return fromProfile;
   }
   const defaultPath = "/root/wiki-git";
-  return existsSync11(defaultPath) ? defaultPath : void 0;
+  return existsSync13(defaultPath) ? defaultPath : void 0;
 }
 function vaultSyncChecks(input) {
   const os = input.os ?? platform2();
@@ -6174,16 +6495,16 @@ function vaultSyncChecks(input) {
     ];
   }
   const isMac = os === "darwin";
-  const logDir = input.logDir ?? (isMac ? join22(home, "Library", "Logs") : join22(home, ".local", "state", "vault-sync", "log"));
-  const shareDir = input.shareDir ?? (isMac ? join22(home, "Library", "Application Support", "vault-sync", "bin") : join22(home, ".local", "share", "vault-sync", "bin"));
-  const filterPath = input.filterPath ?? join22(home, ".config", "rclone", "wiki-push-filters.txt");
-  const packagedSnapshotPath = join22(shareDir, "wiki-snapshot.sh");
+  const logDir = input.logDir ?? (isMac ? join24(home, "Library", "Logs") : join24(home, ".local", "state", "vault-sync", "log"));
+  const shareDir = input.shareDir ?? (isMac ? join24(home, "Library", "Application Support", "vault-sync", "bin") : join24(home, ".local", "share", "vault-sync", "bin"));
+  const filterPath = input.filterPath ?? join24(home, ".config", "rclone", "wiki-push-filters.txt");
+  const packagedSnapshotPath = join24(shareDir, "wiki-snapshot.sh");
   const legacySnapshotPath = "/root/.hermes/scripts/wiki-snapshot-v3.sh";
-  const snapshotPath = input.snapshotScriptPath ?? (existsSync11(packagedSnapshotPath) ? packagedSnapshotPath : legacySnapshotPath);
+  const snapshotPath = input.snapshotScriptPath ?? (existsSync13(packagedSnapshotPath) ? packagedSnapshotPath : legacySnapshotPath);
   function snapshotLastStatusCheck() {
-    const snapshotLog = join22(logDir, "wiki-snapshot.log");
+    const snapshotLog = join24(logDir, "wiki-snapshot.log");
     try {
-      const logContent = readFileSync8(snapshotLog, "utf8");
+      const logContent = readFileSync10(snapshotLog, "utf8");
       const lines = logContent.trim().split("\n").filter(Boolean);
       if (lines.length === 0) {
         return check(
@@ -6228,14 +6549,14 @@ function vaultSyncChecks(input) {
     }
   }
   if (input.vaultSyncRole === "snapshotter") {
-    const c12 = existsSync11(snapshotPath) ? check("pass", "vault_sync_installed", "Vault sync installed", `Found snapshot script: ${snapshotPath}`) : check("error", "vault_sync_installed", "Vault sync installed", `Snapshot script not found at ${snapshotPath}`);
+    const c12 = existsSync13(snapshotPath) ? check("pass", "vault_sync_installed", "Vault sync installed", `Found snapshot script: ${snapshotPath}`) : check("error", "vault_sync_installed", "Vault sync installed", `Snapshot script not found at ${snapshotPath}`);
     const serviceScope = input.vaultSyncServiceScope ?? "user";
-    const userTimerPath = join22(home, ".config", "systemd", "user", "wiki-snapshot.timer");
+    const userTimerPath = join24(home, ".config", "systemd", "user", "wiki-snapshot.timer");
     const systemTimerPath = "/etc/systemd/system/wiki-snapshot.timer";
     let c22;
-    if (serviceScope === "user" && existsSync11(userTimerPath)) {
+    if (serviceScope === "user" && existsSync13(userTimerPath)) {
       c22 = check("pass", "vault_sync_jobs_enabled", "Vault sync jobs enabled", `Found: ${userTimerPath}`);
-    } else if (serviceScope === "system" && existsSync11(systemTimerPath)) {
+    } else if (serviceScope === "system" && existsSync13(systemTimerPath)) {
       c22 = check("pass", "vault_sync_jobs_enabled", "Vault sync jobs enabled", `Found: ${systemTimerPath}`);
     } else if (os !== "linux") {
       c22 = check("warn", "vault_sync_jobs_enabled", "Vault sync jobs enabled", "Snapshotter scheduler is Linux-only and no wiki-snapshot.timer file was found");
@@ -6267,7 +6588,7 @@ function vaultSyncChecks(input) {
     );
     let c52;
     try {
-      if (!existsSync11(snapshotPath)) {
+      if (!existsSync13(snapshotPath)) {
         c52 = check(
           "error",
           "vault_sync_snapshot_guard",
@@ -6275,7 +6596,7 @@ function vaultSyncChecks(input) {
           `Snapshot script not found at ${snapshotPath}`
         );
       } else {
-        const content = readFileSync8(snapshotPath, "utf8");
+        const content = readFileSync10(snapshotPath, "utf8");
         if (!content.includes("--max-delete")) {
           c52 = check(
             "error",
@@ -6302,8 +6623,8 @@ function vaultSyncChecks(input) {
     }
     return [c12, c22, c32, cFetch2, c42, c52];
   }
-  const pushScriptPath = join22(shareDir, "wiki-push.sh");
-  const c1 = existsSync11(pushScriptPath) ? check("pass", "vault_sync_installed", "Vault sync installed", `Found: ${pushScriptPath}`) : check("error", "vault_sync_installed", "Vault sync installed", `Script not found at ${pushScriptPath} \u2014 run vault-sync-install`);
+  const pushScriptPath = join24(shareDir, "wiki-push.sh");
+  const c1 = existsSync13(pushScriptPath) ? check("pass", "vault_sync_installed", "Vault sync installed", `Found: ${pushScriptPath}`) : check("error", "vault_sync_installed", "Vault sync installed", `Script not found at ${pushScriptPath} \u2014 run vault-sync-install`);
   let c2;
   try {
     if (isMac) {
@@ -6354,10 +6675,10 @@ function vaultSyncChecks(input) {
       "Scheduler check failed \u2014 run vault-sync-install"
     );
   }
-  const logFile = join22(logDir, "wiki-push.log");
+  const logFile = join24(logDir, "wiki-push.log");
   let c3;
   try {
-    const logContent = readFileSync8(logFile, "utf8");
+    const logContent = readFileSync10(logFile, "utf8");
     const lines = logContent.trim().split("\n").filter(Boolean);
     if (lines.length === 0) {
       c3 = check(
@@ -6413,7 +6734,7 @@ function vaultSyncChecks(input) {
       }
     }
   } catch {
-    c3 = existsSync11(logDir) ? check(
+    c3 = existsSync13(logDir) ? check(
       "warn",
       "vault_sync_last_push_age",
       "Vault sync last push recency",
@@ -6425,10 +6746,10 @@ function vaultSyncChecks(input) {
       `Log directory not found at ${logDir}`
     );
   }
-  const fetchLogFile = join22(logDir, "wiki-fetch.log");
+  const fetchLogFile = join24(logDir, "wiki-fetch.log");
   let cFetch;
   try {
-    const logContent = readFileSync8(fetchLogFile, "utf8");
+    const logContent = readFileSync10(fetchLogFile, "utf8");
     const lines = logContent.trim().split("\n").filter(Boolean);
     if (lines.length === 0) {
       cFetch = check(
@@ -6472,7 +6793,7 @@ function vaultSyncChecks(input) {
   }
   let c4;
   try {
-    if (!existsSync11(filterPath)) {
+    if (!existsSync13(filterPath)) {
       c4 = check(
         "error",
         "vault_sync_filter_present",
@@ -6480,7 +6801,7 @@ function vaultSyncChecks(input) {
         `Filter file not found at ${filterPath}`
       );
     } else {
-      const content = readFileSync8(filterPath, "utf8");
+      const content = readFileSync10(filterPath, "utf8");
       const requiredExcludes = [
         "remotely-save/data.json",
         ".skillwiki/sync.lock",
@@ -6523,7 +6844,7 @@ function vaultSyncChecks(input) {
     );
   } else {
     try {
-      if (!existsSync11(snapshotPath)) {
+      if (!existsSync13(snapshotPath)) {
         c5 = check(
           "error",
           "vault_sync_snapshot_guard",
@@ -6531,7 +6852,7 @@ function vaultSyncChecks(input) {
           `Snapshot script not found at ${snapshotPath}`
         );
       } else {
-        const content = readFileSync8(snapshotPath, "utf8");
+        const content = readFileSync10(snapshotPath, "utf8");
         if (!content.includes("--max-delete")) {
           c5 = check(
             "error",
@@ -6563,33 +6884,33 @@ function findSkillMd(dir) {
   const results = [];
   let entries;
   try {
-    entries = readdirSync2(dir, { withFileTypes: true });
+    entries = readdirSync3(dir, { withFileTypes: true });
   } catch {
     return results;
   }
   for (const entry of entries) {
     if (entry.isFile() && entry.name === "SKILL.md") {
-      results.push(join22(dir, entry.name));
+      results.push(join24(dir, entry.name));
     } else if (entry.isDirectory()) {
-      results.push(...findSkillMd(join22(dir, entry.name)));
+      results.push(...findSkillMd(join24(dir, entry.name)));
     }
   }
   return results;
 }
 function findInstalledSkillMd(dir) {
-  const directSkills = findSkillNames(dir).map((name) => join22(dir, name, "SKILL.md"));
+  const directSkills = findSkillNames(dir).map((name) => join24(dir, name, "SKILL.md"));
   return directSkills.length > 0 ? directSkills : findSkillMd(dir);
 }
 function findSkillNames(dir) {
   const results = [];
   let entries;
   try {
-    entries = readdirSync2(dir, { withFileTypes: true });
+    entries = readdirSync3(dir, { withFileTypes: true });
   } catch {
     return results;
   }
   for (const entry of entries) {
-    if (entry.isDirectory() && existsSync11(join22(dir, entry.name, "SKILL.md"))) {
+    if (entry.isDirectory() && existsSync13(join24(dir, entry.name, "SKILL.md"))) {
       results.push(entry.name);
     }
   }
@@ -6633,7 +6954,7 @@ async function vaultMetrics(resolvedPath) {
   }
   let logLines = 0;
   try {
-    logLines = readFileSync8(join22(resolvedPath, "log.md"), "utf8").split("\n").length;
+    logLines = readFileSync10(join24(resolvedPath, "log.md"), "utf8").split("\n").length;
   } catch {
   }
   return [
@@ -6690,7 +7011,13 @@ async function runDoctor(input) {
   checks.push(checkVaultGitAhead(gitCheckPath));
   checks.push(checkVaultGitBehind(gitCheckPath));
   checks.push(checkVaultGitPullFailures(input.home));
+  checks.push(checkVaultLocalGit(gitCheckPath));
+  checks.push(checkVaultGithubRemote(gitCheckPath, input.execProbe));
+  checks.push(checkVaultS3Remote(input.home, input.execProbe));
+  checks.push(checkVaultSnapshotterReachable(fleetLoad, input.checkSnapshotter, input.execProbe));
+  checks.push(checkVaultPromotionLag(gitCheckPath));
   checks.push(checkDotStoreClean(resolvedPath));
+  checks.push(checkVaultConflictMarkers(resolvedPath));
   checks.push(checkS3MountPerf(resolvedPath));
   checks.push(checkS3MountFreshness(resolvedPath));
   checks.push(checkRcloneFlagAudit(resolvedPath));
@@ -6735,7 +7062,7 @@ async function runDoctor(input) {
 }
 
 // src/utils/package-info.ts
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync11 } from "fs";
 function packageJsonCandidateUrls(baseUrl = import.meta.url) {
   return [
     new URL("../package.json", baseUrl),
@@ -6745,7 +7072,7 @@ function packageJsonCandidateUrls(baseUrl = import.meta.url) {
 function readCliPackageJson(baseUrl = import.meta.url) {
   for (const url of packageJsonCandidateUrls(baseUrl)) {
     try {
-      const pkg = JSON.parse(readFileSync9(url, "utf8"));
+      const pkg = JSON.parse(readFileSync11(url, "utf8"));
       if (typeof pkg.version === "string") {
         return { ...pkg, version: pkg.version };
       }
@@ -6757,11 +7084,49 @@ function readCliPackageJson(baseUrl = import.meta.url) {
 
 // src/commands/project-index.ts
 import { readdir as readdir4, readFile as readFile16, writeFile as writeFile6, mkdir as mkdir5 } from "fs/promises";
-import { join as join23, dirname as dirname8 } from "path";
+import { join as join25, dirname as dirname8, basename as basename2 } from "path";
 var LAYER2_DIRS = ["entities", "concepts", "comparisons", "queries", "meta"];
+var PROJECT_LOCAL_DIRS = ["requirements", "work", "architecture", "history"];
+async function scanMarkdownTree(rootAbs, rootRel) {
+  const found = [];
+  let entries;
+  try {
+    entries = await readdir4(rootAbs, { withFileTypes: true });
+  } catch {
+    return found;
+  }
+  for (const entry of entries) {
+    const abs = join25(rootAbs, entry.name);
+    const rel = `${rootRel}/${entry.name}`;
+    if (entry.isDirectory()) {
+      found.push(...await scanMarkdownTree(abs, rel));
+    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+      found.push(rel);
+    }
+  }
+  return found;
+}
+function projectLocalType(slug, page, data) {
+  if (page.startsWith(`projects/${slug}/requirements/`)) return "requirement";
+  if (page.startsWith(`projects/${slug}/work/`)) {
+    if (typeof data.kind === "string") return data.kind;
+    const name = basename2(page, ".md");
+    if (name === "spec" || name === "plan" || name === "retro") return name;
+    return "work";
+  }
+  if (page.startsWith(`projects/${slug}/architecture/`)) {
+    return typeof data.type === "string" ? data.type : "architecture";
+  }
+  if (page.startsWith(`projects/${slug}/history/`)) {
+    if (typeof data.kind === "string") return data.kind;
+    if (typeof data.type === "string") return data.type;
+    return "history";
+  }
+  return typeof data.type === "string" ? data.type : "project";
+}
 async function runProjectIndex(input) {
   const slug = input.slug;
-  const projectDir = join23(input.vault, "projects", slug);
+  const projectDir = join25(input.vault, "projects", slug);
   try {
     await readdir4(projectDir);
   } catch {
@@ -6772,12 +7137,12 @@ async function runProjectIndex(input) {
   }
   const wikilinkPattern = `[[${slug}]]`;
   const entries = [];
-  const compoundDir = join23(input.vault, "projects", slug, "compound");
+  const compoundDir = join25(input.vault, "projects", slug, "compound");
   try {
     const compoundFiles = await readdir4(compoundDir, { withFileTypes: true });
     for (const entry of compoundFiles) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const filePath = join23(compoundDir, entry.name);
+      const filePath = join25(compoundDir, entry.name);
       let text;
       try {
         text = await readFile16(filePath, "utf8");
@@ -6797,13 +7162,13 @@ async function runProjectIndex(input) {
   for (const dir of LAYER2_DIRS) {
     let files;
     try {
-      files = await readdir4(join23(input.vault, dir), { withFileTypes: true });
+      files = await readdir4(join25(input.vault, dir), { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of files) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const filePath = join23(input.vault, dir, entry.name);
+      const filePath = join25(input.vault, dir, entry.name);
       let text;
       try {
         text = await readFile16(filePath, "utf8");
@@ -6821,13 +7186,34 @@ async function runProjectIndex(input) {
       });
     }
   }
-  const typeOrder = { entity: 0, concept: 1, comparison: 2, query: 3, summary: 4, meta: 5, pattern: 6, gotcha: 7, lesson: 8, antipattern: 9, compound: 10 };
+  for (const dir of PROJECT_LOCAL_DIRS) {
+    const rootAbs = join25(projectDir, dir);
+    const rootRel = `projects/${slug}/${dir}`;
+    const pages = await scanMarkdownTree(rootAbs, rootRel);
+    for (const page of pages) {
+      const filePath = join25(input.vault, page);
+      let text;
+      try {
+        text = await readFile16(filePath, "utf8");
+      } catch {
+        continue;
+      }
+      const fm = extractFrontmatter(text);
+      if (!fm.ok) continue;
+      entries.push({
+        page,
+        type: projectLocalType(slug, page, fm.data),
+        title: typeof fm.data.title === "string" ? fm.data.title : basename2(page, ".md")
+      });
+    }
+  }
+  const typeOrder = { entity: 0, concept: 1, comparison: 2, query: 3, summary: 4, meta: 5, requirement: 6, spec: 7, plan: 8, retro: 9, architecture: 10, pattern: 11, gotcha: 12, lesson: 13, antipattern: 14, compound: 15, work: 16, history: 17 };
   entries.sort((a, b) => {
     const ta = typeOrder[a.type] ?? 99;
     const tb = typeOrder[b.type] ?? 99;
     return ta !== tb ? ta - tb : a.title.localeCompare(b.title);
   });
-  const indexPath = join23(projectDir, "knowledge.md");
+  const indexPath = join25(projectDir, "knowledge.md");
   let existing = false;
   let stale = false;
   try {
@@ -6901,8 +7287,8 @@ ${entries.map((e) => `  ${e.type}: [[${e.page.replace(/\.md$/, "")}]] \u2014 ${e
 
 // src/commands/observe.ts
 import { mkdir as mkdir6, writeFile as writeFile7 } from "fs/promises";
-import { existsSync as existsSync12, statSync as statSync2 } from "fs";
-import { join as join24 } from "path";
+import { existsSync as existsSync14, statSync as statSync2 } from "fs";
+import { join as join26 } from "path";
 import { createHash as createHash5 } from "crypto";
 var ALLOWED_KINDS = /* @__PURE__ */ new Set(["note", "bug", "task", "idea", "session-log"]);
 function slugify(text) {
@@ -6925,13 +7311,13 @@ async function runObserve(input) {
       result: err("SCHEME_REJECTED", { message: "Text must not be empty" })
     };
   }
-  if (!existsSync12(input.vault) || !statSync2(input.vault).isDirectory()) {
+  if (!existsSync14(input.vault) || !statSync2(input.vault).isDirectory()) {
     return {
       exitCode: ExitCode.VAULT_PATH_INVALID,
       result: err("VAULT_PATH_INVALID", { path: input.vault })
     };
   }
-  const transcriptsDir = join24(input.vault, "raw", "transcripts");
+  const transcriptsDir = join26(input.vault, "raw", "transcripts");
   try {
     await mkdir6(transcriptsDir, { recursive: true });
   } catch {
@@ -6943,7 +7329,7 @@ async function runObserve(input) {
   const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   const slug = slugify(input.text);
   const fileName = `${today}-observation-${slug}.md`;
-  const filePath = join24(transcriptsDir, fileName);
+  const filePath = join26(transcriptsDir, fileName);
   const body = `
 ${input.text.trim()}
 `;
@@ -6985,7 +7371,7 @@ ${input.text.trim()}
 // src/commands/memory.ts
 import { createHash as createHash6 } from "crypto";
 import { mkdir as mkdir7, readFile as readFile17, readdir as readdir5, stat as stat5, writeFile as writeFile8 } from "fs/promises";
-import { basename as basename2, extname, join as join25, relative as relative4, sep as sep4 } from "path";
+import { basename as basename3, extname, join as join27, relative as relative4, sep as sep4 } from "path";
 async function runMemoryTopics(input) {
   const scan = await scanVault(input.vault);
   if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
@@ -7049,8 +7435,8 @@ async function runMemoryIndex(input) {
   }
   const generatedAt = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
   const relCachePath = memoryCacheRelPath(input.project);
-  const absCachePath = join25(input.vault, relCachePath);
-  await mkdir7(join25(input.vault, ".skillwiki", "memory", input.project), { recursive: true });
+  const absCachePath = join27(input.vault, relCachePath);
+  await mkdir7(join27(input.vault, ".skillwiki", "memory", input.project), { recursive: true });
   await writeFile8(absCachePath, `${JSON.stringify({
     generated_at: generatedAt,
     project: input.project,
@@ -7242,7 +7628,7 @@ async function buildMemoryIndexState(pages, project) {
 }
 async function checkMemoryIndex(vault, project, current) {
   const relCachePath = memoryCacheRelPath(project);
-  const cacheText = await readIfExists2(join25(vault, relCachePath));
+  const cacheText = await readIfExists2(join27(vault, relCachePath));
   if (!cacheText) {
     return {
       ok: true,
@@ -7651,7 +8037,7 @@ async function walkImportFiles(dir, out) {
   const entries = await readdir5(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name === ".git" || entry.name === "node_modules") continue;
-    const path = join25(dir, entry.name);
+    const path = join27(dir, entry.name);
     if (entry.isDirectory()) {
       await walkImportFiles(path, out);
     } else if (entry.isFile() && isImportCandidate(path)) {
@@ -7700,7 +8086,7 @@ async function buildImportEntry(file, sourceRoot, project, today, maxBytes) {
   }
   const redacted = redactSensitiveContent(extracted, { file });
   const privacy = redacted.findings.length > 0 ? "sensitive" : "local";
-  const sourceSlug = slugify2(basename2(file, extname(file)));
+  const sourceSlug = slugify2(basename3(file, extname(file)));
   const relSource = relative4(sourceRoot, file).split(sep4).join("/");
   const entry = {
     ...baseEntry,
@@ -7718,8 +8104,8 @@ async function writeImportCapture(vault, entry, today) {
   const content = hiddenString(entry, "__content");
   const project = hiddenString(entry, "__project");
   const relPath = await availableImportPath(vault, entry.proposed_path);
-  const absPath = join25(vault, relPath);
-  await mkdir7(join25(vault, "raw", "transcripts"), { recursive: true });
+  const absPath = join27(vault, relPath);
+  await mkdir7(join27(vault, "raw", "transcripts"), { recursive: true });
   await writeFile8(absPath, renderImportCapture(entry, content, project, today), "utf8");
   const validation = await runValidate({ file: absPath });
   return {
@@ -7735,7 +8121,7 @@ async function availableImportPath(vault, proposed) {
   const stem = proposed.slice(0, -ext.length);
   let candidate = proposed;
   let i = 2;
-  while (await readIfExists2(join25(vault, candidate))) {
+  while (await readIfExists2(join27(vault, candidate))) {
     candidate = `${stem}-${i}${ext}`;
     i++;
   }
@@ -7759,7 +8145,7 @@ function renderImportCapture(entry, content, project, today) {
     `source_paths: ["${entry.source_path.replaceAll('"', '\\"')}"]`,
     "---",
     "",
-    `# Imported Memory: ${basename2(entry.source_path, extname(entry.source_path))}`,
+    `# Imported Memory: ${basename3(entry.source_path, extname(entry.source_path))}`,
     "",
     `Source kind: ${entry.source_kind}`,
     "",
@@ -7774,7 +8160,7 @@ function hiddenString(entry, key) {
 }
 function classifyImportSource(file) {
   const rel = file.split(sep4).join("/");
-  const name = basename2(file);
+  const name = basename3(file);
   if (rel.includes("/.codex/memories/")) return "codex-memory";
   if (rel.includes("/.codex/rules/")) return "codex-rule";
   if (rel.includes("/.claude/") && name === "napkin.md") return "napkin";
@@ -7907,10 +8293,10 @@ function memoryCacheRelPath(project) {
 }
 async function readMemoryCache(vault, project) {
   if (project) {
-    const projectCache = await readIfExists2(join25(vault, memoryCacheRelPath(project)));
+    const projectCache = await readIfExists2(join27(vault, memoryCacheRelPath(project)));
     if (projectCache) return projectCache;
   }
-  return readIfExists2(join25(vault, ".skillwiki", "memory-topics.json"));
+  return readIfExists2(join27(vault, ".skillwiki", "memory-topics.json"));
 }
 function dedupePages(pages) {
   const seen = /* @__PURE__ */ new Set();
@@ -7997,7 +8383,7 @@ function slugify2(value) {
 
 // src/commands/query.ts
 import { readFile as readFile18, stat as stat6 } from "fs/promises";
-import { join as join26 } from "path";
+import { join as join28 } from "path";
 var W_KEYWORD = 2;
 var W_SOURCE_OVERLAP = 4;
 var W_WIKILINK = 3;
@@ -8118,7 +8504,7 @@ function computeKeywordScore(terms, title, tags, body) {
   return score;
 }
 async function loadOrBuildGraph(vault) {
-  const graphPath = join26(vault, ".skillwiki", "graph.json");
+  const graphPath = join28(vault, ".skillwiki", "graph.json");
   let needsBuild = false;
   try {
     const fileStat = await stat6(graphPath);
@@ -8147,7 +8533,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { z as z2 } from "zod";
 
 // src/mcp/vault-resolve.ts
-import { join as join27, resolve as resolve7 } from "path";
+import { join as join29, resolve as resolve7 } from "path";
 
 // src/mcp/allowlist.ts
 import { resolve as resolve6, sep as sep5 } from "path";
@@ -8209,7 +8595,7 @@ async function resolveMcpVault(input) {
   return ok({ vault: vaultPath, source });
 }
 function defaultGraphOut(vault) {
-  return join27(vault, ".skillwiki", "graph.json");
+  return join29(vault, ".skillwiki", "graph.json");
 }
 
 // src/mcp/result-format.ts
@@ -8226,7 +8612,7 @@ function formatToolResult(payload) {
 // src/mcp/audit-log.ts
 import { appendFileSync, mkdirSync as mkdirSync4 } from "fs";
 import { homedir } from "os";
-import { join as join28 } from "path";
+import { join as join30 } from "path";
 function auditEnabled() {
   const v = process.env.SKILLWIKI_MCP_AUDIT;
   if (v === "0" || v === "false") return false;
@@ -8238,7 +8624,7 @@ function auditSink() {
 function auditFilePath() {
   const custom = process.env.SKILLWIKI_MCP_AUDIT_FILE;
   if (custom && custom.length > 0) return custom;
-  return join28(homedir(), ".skillwiki", "mcp-audit.jsonl");
+  return join30(homedir(), ".skillwiki", "mcp-audit.jsonl");
 }
 function auditMcpToolCall(entry) {
   if (!auditEnabled()) return;
@@ -8248,7 +8634,7 @@ function auditMcpToolCall(entry) {
     return;
   }
   const path = auditFilePath();
-  mkdirSync4(join28(path, ".."), { recursive: true });
+  mkdirSync4(join30(path, ".."), { recursive: true });
   appendFileSync(path, line, "utf8");
 }
 async function runMcpToolHandler(tool, input, fn) {
@@ -8469,7 +8855,7 @@ function registerMcpMutatingTools(server) {
 
 // src/mcp/resources.ts
 import { readFile as readFile20 } from "fs/promises";
-import { join as join30 } from "path";
+import { join as join32 } from "path";
 import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 
 // src/mcp/lint-bucket.ts
@@ -8598,8 +8984,8 @@ async function fetchQueryPreview(input) {
 
 // src/mcp/graph-html.ts
 import { readFile as readFile19 } from "fs/promises";
-import { join as join29 } from "path";
-import { existsSync as existsSync13 } from "fs";
+import { join as join31 } from "path";
+import { existsSync as existsSync15 } from "fs";
 var TYPE_COLORS = {
   entities: "#e74c3c",
   concepts: "#27ae60",
@@ -8667,9 +9053,9 @@ ${nodeSvg}
   return { html, node_count: nodes.length, edge_count: edges.length, truncated };
 }
 async function fetchGraphHtmlReport(input) {
-  const graphPath = input.graphPath ?? join29(input.vault, ".skillwiki", "graph.json");
+  const graphPath = input.graphPath ?? join31(input.vault, ".skillwiki", "graph.json");
   const maxNodes = Math.min(Math.max(10, input.maxNodes ?? 120), 500);
-  if (!existsSync13(graphPath)) {
+  if (!existsSync15(graphPath)) {
     return {
       exitCode: ExitCode.FILE_NOT_FOUND,
       result: err("GRAPH_MISSING", { path: graphPath, hint: "Run skillwiki.graph_build first." })
@@ -8741,7 +9127,7 @@ async function fetchStaleSummary(input) {
 
 // src/mcp/resources.ts
 async function readVaultFile(vault, rel) {
-  return readFile20(join30(vault, rel), "utf8");
+  return readFile20(join32(vault, rel), "utf8");
 }
 async function tailLines(text, lines) {
   const parts = text.split(/\r?\n/);
@@ -8827,7 +9213,7 @@ function registerMcpResources(server) {
       if (!v.ok) {
         return { contents: [{ uri: uri.href, mimeType: "text/plain", text: JSON.stringify(v) }] };
       }
-      const path = join30(v.data.vault, ".skillwiki", "graph.json");
+      const path = join32(v.data.vault, ".skillwiki", "graph.json");
       try {
         const raw = await readFile20(path, "utf8");
         const graph = JSON.parse(raw);
@@ -9192,10 +9578,13 @@ export {
   runConfigPath,
   writeCache,
   triggerAutoUpdate,
+  buildDegradedReasons,
+  probeRemoteHealth,
   FLEET_REL_PATH,
   runFleetValidate,
   runFleetContext,
   loadFleetManifestAndHost,
+  snapshotterAliasForLocalHost,
   loadFleetManifest,
   resolveFleetHostId,
   SATELLITE_STALE_MS,