skillwiki 0.10.49 → 0.10.51

package/dist/{chunk-F7LXKP4T.js → chunk-3IBRZTLF.js}

@@ -6,7 +6,7 @@ import {
 import {
   renderRootIndex,
   writeRootIndexProjection
-} from "./chunk-GAU4D25O.js";
+} from "./chunk-O3HCB7R2.js";
 import {
   CONFIG_KEYS,
   acquireOwnedSyncLock,
@@ -35,15 +35,28 @@ import {
   snapshotterAliasForLocalHost,
   toUndirectedWeighted,
   writeDotenv
-} from "./chunk-FXASPB3C.js";
+} from "./chunk-UPQ6XJSV.js";
 import {
   atomicWriteText,
   prepareTypedPage
-} from "./chunk-UHZBOOMK.js";
+} from "./chunk-74OSLCXE.js";
+import {
+  applySourceCompileClaim,
+  applySourceCompilePublished,
+  applySourceCompileRelease,
+  applySourceReview,
+  listCompileStatus,
+  listSourceReviews,
+  planSourceCompileClaim,
+  planSourceCompilePublished,
+  planSourceCompileRelease,
+  planSourceReview,
+  runSourcesPending
+} from "./chunk-HBQTTYXZ.js";
 import {
   eventPathFor,
   writeLogEvent
-} from "./chunk-PLUHIOCQ.js";
+} from "./chunk-GAHMWLWU.js";
 import {
   CompoundSchema,
   ExitCode,
@@ -64,7 +77,7 @@ import {
   scanVault,
   splitFrontmatter,
   systemdPropertyFor
-} from "./chunk-EVQASYII.js";
+} from "./chunk-IJ7DD7QZ.js";
 
 // src/commands/log-append.ts
 import { readFile, stat } from "fs/promises";
@@ -1056,11 +1069,13 @@ async function runConfigPath(input) {
   return { exitCode: ExitCode.OK, result: ok({ path: filePath, exists: existsSync2(filePath), humanHint: filePath }) };
 }
 
-// src/commands/doctor.ts
-import { existsSync as existsSync7, lstatSync, readlinkSync, readdirSync as readdirSync3, statSync as statSync2, readFileSync as readFileSync6 } from "fs";
-import { join as join10, resolve as resolve2 } from "path";
-import { execSync as execSync2 } from "child_process";
-import { platform as platform2 } from "os";
+// src/doctor/runner.ts
+import { existsSync as existsSync17 } from "fs";
+
+// src/doctor/probes/environment.ts
+import { existsSync as existsSync4, lstatSync, readlinkSync } from "fs";
+import { resolve as resolve2, join as join7 } from "path";
+import { execSync } from "child_process";
 
 // src/utils/plugin-registry.ts
 import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync2 } from "fs";
@@ -1180,1179 +1195,950 @@ function parseTomlScalar(rawValue) {
   return value;
 }
 
-// src/utils/conflict-markers.ts
-import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
-import { join as join7 } 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;
-    }
+// src/doctor/probes/helpers.ts
+function check(status, id, label, detail) {
+  return { id, label, status, detail };
+}
+
+// src/doctor/probes/environment.ts
+function checkNodeVersion() {
+  const major = parseInt(process.version.slice(1).split(".")[0], 10);
+  if (major >= 20) {
+    return check("pass", "node_version", "Node.js version", `v${major} >= 20`);
   }
-  return findings;
+  return check("error", "node_version", "Node.js version", `Node.js v${major} is below minimum v20`);
 }
-var PRUNE_DIRS = /* @__PURE__ */ new Set([
-  ".git",
-  ".obsidian",
-  ".skillwiki",
-  ".claude",
-  ".antigravitycli",
-  ".playwright-cli"
-]);
-function walkMarkdownFiles(root, dir, rel, out) {
-  let entries;
+function detectCliChannels(argv, home) {
+  const channels = [];
+  if (argv.length >= 2 && argv[1].endsWith("cli.js")) {
+    const devPath = resolve2(argv[1]);
+    channels.push({ name: "dev", path: devPath, isDevLink: true });
+  }
   try {
-    entries = readdirSync2(dir, { withFileTypes: true });
+    const whichOut = execSync("which skillwiki 2>/dev/null", { encoding: "utf8" }).trim();
+    if (whichOut) {
+      const isDev = isDevSymlink(whichOut);
+      if (!channels.some((c) => c.path === resolve2(whichOut))) {
+        channels.push({ name: "npm", path: whichOut, isDevLink: isDev });
+      }
+    }
   } catch {
-    return;
   }
-  for (const entry of entries) {
-    if (entry.isDirectory()) {
-      if (PRUNE_DIRS.has(entry.name)) continue;
-      walkMarkdownFiles(root, join7(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);
+  const plugin = findPlugin(home);
+  if (plugin) {
+    const pluginBin = join7(plugin.installPath, "bin", "skillwiki");
+    if (existsSync4(pluginBin)) {
+      channels.push({ name: "plugin", path: pluginBin, isDevLink: false });
     }
   }
-}
-function scanVaultConflictMarkers(vaultRoot) {
-  if (!existsSync4(vaultRoot)) return [];
-  const relPaths = [];
-  walkMarkdownFiles(vaultRoot, vaultRoot, "", relPaths);
-  const all = [];
-  for (const rel of relPaths) {
-    let text;
-    try {
-      text = readFileSync3(join7(vaultRoot, rel), "utf8");
-    } catch {
-      continue;
-    }
-    all.push(...scanConflictMarkerBlocksInText(rel, text));
+  const installBin = join7(home, ".claude", "skills", "bin", "skillwiki");
+  if (existsSync4(installBin)) {
+    channels.push({ name: "install", path: installBin, isDevLink: false });
   }
-  return all;
-}
-
-// src/utils/satellite-run-health.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
-import { join as join8 } from "path";
-var SATELLITE_STALE_MS = 26 * 60 * 60 * 1e3;
-function satelliteLatestRunPath(vault) {
-  return join8(vault, ".skillwiki", "agent-memory-trends", "latest-run.json");
-}
-function isFailedRunStatus(status) {
-  return status === "fail" || status === "failure";
+  return channels;
 }
-function parseLatestRunFile(text) {
+function isDevSymlink(binPath) {
   try {
-    const parsed = JSON.parse(text);
-    const status = typeof parsed.status === "string" ? parsed.status : "";
-    if (!status) return null;
-    const finishedAt = typeof parsed.finished_at === "string" && parsed.finished_at.length > 0 ? parsed.finished_at : void 0;
-    const failureClass = parsed.failure_class != null && String(parsed.failure_class).length > 0 ? String(parsed.failure_class) : void 0;
-    return { status, finishedAt, failureClass };
+    const st = lstatSync(binPath);
+    if (st.isSymbolicLink()) {
+      const target = resolve2(binPath, "..", readlinkSync(binPath));
+      return target.includes("packages/cli") || target.includes("packages\\cli");
+    }
   } catch {
-    return null;
   }
+  return false;
 }
-function readSatelliteLatestRunFromText(text) {
-  return parseLatestRunFile(text);
-}
-function readSatelliteLatestRun(vault) {
-  const latestPath = satelliteLatestRunPath(vault);
-  if (!existsSync5(latestPath)) return null;
-  try {
-    return parseLatestRunFile(readFileSync4(latestPath, "utf8"));
-  } catch {
-    return null;
+function checkCliChannels(argv, home) {
+  const channels = detectCliChannels(argv, home);
+  if (channels.length === 0) {
+    return check("warn", "cli_channels", "CLI channels", "skillwiki not found on any channel");
   }
-}
-function evaluateSatelliteRunHealth(vault, now) {
-  const run = readSatelliteLatestRun(vault);
-  if (!run) {
-    return { failed: false, stale: false };
+  if (channels.length === 1) {
+    const ch = channels[0];
+    const label = ch.isDevLink ? `${ch.name} (dev source)` : ch.name;
+    return check("pass", "cli_channels", "CLI channels", `Single channel: ${label}`);
   }
-  const failed = isFailedRunStatus(run.status);
-  let stale = false;
-  if (!failed && run.finishedAt) {
-    const ts = Date.parse(run.finishedAt);
-    if (Number.isFinite(ts) && now.getTime() - ts > SATELLITE_STALE_MS) {
-      stale = true;
+  const devChannels = channels.filter((c) => c.isDevLink);
+  const prodChannels = channels.filter((c) => !c.isDevLink);
+  if (devChannels.length > 0 && prodChannels.length > 0) {
+    const hasInstall2 = prodChannels.some((c) => c.name === "install");
+    if (!hasInstall2) {
+      const devNames2 = devChannels.map((c) => `${c.name}(dev)`);
+      const prodNames2 = prodChannels.map((c) => c.name);
+      return check("pass", "cli_channels", "CLI channels", `${channels.length} channels: ${[...devNames2, ...prodNames2].join(", ")} \u2014 dev source with installed production channels`);
     }
+    const devNames = devChannels.map((c) => `${c.name}(dev)`);
+    const prodNames = prodChannels.map((c) => c.name);
+    return check(
+      "warn",
+      "cli_channels",
+      "CLI channels",
+      `${channels.length} channels: ${[...devNames, ...prodNames].join(", ")} \u2014 dev and prod binaries overlap; dev repo should use project-local settings only`
+    );
   }
-  return {
-    failed,
-    stale,
-    failureClass: run.failureClass,
-    finishedAt: run.finishedAt
-  };
+  const names = channels.map((c) => c.name);
+  const hasInstall = channels.some((c) => c.name === "install");
+  if (hasInstall) {
+    return check(
+      "warn",
+      "cli_channels",
+      "CLI channels",
+      `${channels.length} channels: ${names.join(", ")} \u2014 remove unused install with: rm ~/.claude/skills/bin/skillwiki`
+    );
+  }
+  return check("pass", "cli_channels", "CLI channels", `${channels.length} channels: ${names.join(", ")}`);
 }
-
-// src/utils/s3-mount-health.ts
-import { execSync } from "child_process";
-import { platform } from "os";
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2, readFileSync as readFile6 } from "fs";
-import { join as join9 } from "path";
-var OS = platform();
-function findRcloneMountPid() {
+async function checkConfigFile(home) {
+  const cfgPath = configPath(home);
+  if (!existsSync4(cfgPath)) {
+    return check("warn", "config_file", "Config file exists", `${cfgPath} not found`);
+  }
   try {
-    const out = execSync("pgrep -f 'rclone.*mount'", {
-      encoding: "utf8",
-      timeout: 2e3,
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    const pids = out.split("\n").filter(Boolean);
-    if (pids.length === 0) return null;
-    return parseInt(pids[0], 10);
-  } catch {
-    try {
-      const out = execSync("ps aux", { encoding: "utf8", timeout: 2e3, stdio: ["pipe", "pipe", "pipe"] });
-      for (const line of out.split("\n")) {
-        if (line.includes("rclone") && line.includes("mount") && !line.includes("grep")) {
-          const parts = line.trim().split(/\s+/);
-          if (parts.length >= 2) return parseInt(parts[1], 10);
-        }
-      }
-    } catch {
-    }
-    return null;
+    const map = await parseDotenvFile(cfgPath);
+    const keys = Object.keys(map);
+    return check("pass", "config_file", "Config file exists", `Found with keys: ${keys.length > 0 ? keys.join(", ") : "(none set)"}`);
+  } catch (e) {
+    return check("warn", "config_file", "Config file exists", `Failed to parse ${cfgPath}: ${String(e)}`);
   }
 }
-function parseRcloneFlags(pid) {
-  const flags = /* @__PURE__ */ new Map();
-  try {
-    const args = getRcloneArgs(pid);
-    for (let i = 0; i < args.length; i++) {
-      const arg = args[i];
-      if (arg.startsWith("--") && arg.includes("=")) {
-        const eq = arg.indexOf("=");
-        flags.set(arg.slice(0, eq), arg.slice(eq + 1));
-      } else if (arg.startsWith("--")) {
-        const next = args[i + 1];
-        if (next && !next.startsWith("-")) {
-          flags.set(arg, next);
-          i++;
-        } else {
-          flags.set(arg, "");
-        }
-      }
+async function checkProfiles(home) {
+  const map = await parseDotenvFile(configPath(home));
+  const profiles = [];
+  for (const key of Object.keys(map)) {
+    if (key.startsWith("WIKI_") && key.endsWith("_PATH") && key !== "WIKI_PATH") {
+      const name = key.slice(5, -5).toLowerCase().replace(/_/g, "-");
+      profiles.push(name);
     }
-  } catch {
   }
-  return flags;
-}
-function getRcloneVersion() {
-  try {
-    const out = execSync("rclone version", {
-      encoding: "utf8",
-      timeout: 3e3,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    const match = out.match(/rclone\s+v(\d+)\.(\d+)\.(\d+)/i);
-    if (!match) return null;
-    return {
-      major: parseInt(match[1], 10),
-      minor: parseInt(match[2], 10),
-      patch: parseInt(match[3], 10),
-      raw: out.split("\n")[0].trim()
-    };
-  } catch {
-    return null;
+  if (profiles.length === 0) {
+    return check("pass", "wiki_profiles", "Wiki profiles", "No named profiles configured");
   }
+  const defaultProfile = map["WIKI_DEFAULT"] ?? "(none)";
+  return check(
+    "pass",
+    "wiki_profiles",
+    "Wiki profiles",
+    `${profiles.length} profile(s): ${profiles.join(", ")}; default: ${defaultProfile}`
+  );
 }
-function extractRcloneFs(args) {
-  let foundMount = false;
-  for (const arg of args) {
-    if (arg === "mount") {
-      foundMount = true;
-      continue;
-    }
-    if (foundMount && arg.includes(":") && !arg.startsWith("-") && !arg.startsWith("/")) {
-      return arg;
-    }
+async function checkProjectLocalOverride(cwd) {
+  const dir = cwd ?? process.cwd();
+  const envPath = join7(dir, ".skillwiki", ".env");
+  if (existsSync4(envPath)) {
+    return check("pass", "project_local", "Project-local config", `Found: ${envPath}`);
   }
-  return null;
+  return check("pass", "project_local", "Project-local config", "None");
 }
-function getRcloneArgs(pid) {
-  try {
-    if (OS === "linux") {
-      const raw = readFileSync5(`/proc/${pid}/cmdline`);
-      return new TextDecoder().decode(raw).split("\0").filter(Boolean);
-    } else {
-      const out = execSync(`ps -o args= -p ${pid}`, {
-        encoding: "utf8",
-        timeout: 2e3,
-        stdio: ["pipe", "pipe", "pipe"]
-      }).trim();
-      return out.split(/\s+/);
-    }
-  } catch {
-    return [];
+function checkWikiPathSet(ctx) {
+  if (ctx.resolvedPath) {
+    return check("pass", "wiki_path_set", "WIKI_PATH configured", `Resolved via ${ctx.wikiPathSource ?? "unknown"}: ${ctx.resolvedPath}`);
   }
+  return check("error", "wiki_path_set", "WIKI_PATH configured", "No vault configured. Run `skillwiki init` or pass --vault.");
 }
-function queryRcloneRC(rcAddr, fs) {
-  try {
-    const payload = JSON.stringify({ fs });
-    const out = execSync(
-      `curl -s --max-time 3 -X POST "http://${rcAddr}/vfs/stats" -H "Content-Type: application/json" -d '${payload}' 2>/dev/null`,
-      { encoding: "utf8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }
-    );
-    if (!out.trim()) return null;
-    const data = JSON.parse(out);
-    if (data.status && data.status >= 400) {
-      return { error: data.error || `RC error (status ${data.status})`, erroredFiles: 0, uploadsInProgress: 0, uploadsQueued: 0, outOfSpace: false, bytesUsed: 0, files: 0, totalSize: "unknown" };
-    }
-    const dc = data.diskCache || {};
-    return {
-      erroredFiles: dc.erroredFiles ?? 0,
-      uploadsInProgress: dc.uploadsInProgress ?? 0,
-      uploadsQueued: dc.uploadsQueued ?? 0,
-      outOfSpace: dc.outOfSpace ?? false,
-      bytesUsed: dc.bytesUsed ?? 0,
-      files: dc.files ?? 0,
-      totalSize: data.totalSize || "unknown"
-    };
-  } catch {
-    return { error: "RC endpoint unreachable", erroredFiles: 0, uploadsInProgress: 0, uploadsQueued: 0, outOfSpace: false, bytesUsed: 0, files: 0, totalSize: "unknown" };
+var environmentProbe = {
+  id: "environment",
+  async run(ctx) {
+    return [
+      checkNodeVersion(),
+      checkCliChannels(ctx.input.argv, ctx.input.home),
+      await checkConfigFile(ctx.input.home),
+      await checkProfiles(ctx.input.home),
+      await checkProjectLocalOverride(ctx.input.cwd),
+      checkWikiPathSet(ctx)
+    ];
   }
-}
-function detectFuseMount(vaultPath) {
-  try {
-    if (OS === "linux") {
-      const mounts = readFileSync5("/proc/mounts", "utf8");
-      let best = null;
-      for (const line of mounts.split("\n")) {
-        const parts = line.split(" ");
-        if (parts.length < 3) continue;
-        const point = parts[1];
-        const fs = parts[2];
-        if (vaultPath.startsWith(point) && (!best || point.length > best.point.length)) {
-          best = { point, fs };
-        }
-      }
-      if (best && best.fs.includes("fuse")) return { mountPoint: best.point, fsType: best.fs };
-    } else if (OS === "darwin") {
-      const out = execSync("mount", { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
-      let best = null;
-      for (const line of out.split("\n")) {
-        const match = line.match(/^(\S+) on (\S+) \((.*?)\)/);
-        if (!match) continue;
-        const point = match[2];
-        const opts = match[3];
-        if (opts.includes("fuse") && vaultPath.startsWith(point) && (!best || point.length > best.point.length)) {
-          best = { point, fsType: `fuse.${match[1].split(":")[0] || "unknown"}` };
-        }
-      }
-      if (best) return { mountPoint: best.point, fsType: best.fsType };
-    }
-  } catch {
+};
+
+// src/doctor/probes/vault-structure.ts
+import { existsSync as existsSync5, statSync as statSync2 } from "fs";
+import { join as join8 } from "path";
+function checkWikiPathExists(resolvedPath) {
+  if (resolvedPath === void 0) {
+    return check("error", "wiki_path_exists", "Vault directory exists", "Cannot check \u2014 WIKI_PATH not resolved");
   }
-  return null;
+  if (existsSync5(resolvedPath) && statSync2(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`);
 }
-function writeTest(dir) {
-  const testFile = join9(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 {
-    writeFileSync2(testFile, payload, "utf8");
-  } catch (e) {
-    return { success: false, writeMs: Date.now() - start, readMs: 0, size: 0, error: `write failed: ${e.message}` };
+function checkVaultStructure(resolvedPath) {
+  if (resolvedPath === void 0) {
+    return check("error", "vault_structure", "Vault structure valid", "Cannot check \u2014 WIKI_PATH not resolved");
   }
-  const writeMs = Date.now() - start;
-  const readStart = Date.now();
-  try {
-    const back = readFile6(testFile, "utf8");
-    const readMs = Date.now() - readStart;
-    if (back !== payload) {
-      try {
-        unlinkSync2(testFile);
-      } catch {
-      }
-      return { success: false, writeMs, readMs, size: Buffer.byteLength(payload, "utf8"), error: "content mismatch \u2014 wrote and read-back differ" };
-    }
-  } catch (e) {
-    try {
-      unlinkSync2(testFile);
-    } catch {
-    }
-    return { success: false, writeMs, readMs: Date.now() - readStart, size: 0, error: `read failed: ${e.message}` };
+  if (!existsSync5(resolvedPath)) {
+    return check("error", "vault_structure", "Vault structure valid", "Cannot check \u2014 vault directory does not exist");
   }
-  try {
-    unlinkSync2(testFile);
-  } catch {
+  const missing = [];
+  if (!existsSync5(join8(resolvedPath, "SCHEMA.md"))) missing.push("SCHEMA.md");
+  for (const dir of ["raw", "entities", "concepts", "meta"]) {
+    if (!existsSync5(join8(resolvedPath, dir))) missing.push(dir + "/");
   }
-  return { success: true, writeMs, readMs: Date.now() - readStart, size: Buffer.byteLength(payload, "utf8") };
+  if (missing.length === 0) {
+    return check("pass", "vault_structure", "Vault structure valid", "All required files and directories present");
+  }
+  return check("warn", "vault_structure", "Vault structure valid", `Missing: ${missing.join(", ")} \u2014 run \`skillwiki init\` to add CodeWiki structure`);
 }
-var DURATION_UNIT_SECONDS = {
-  ms: 1 / 1e3,
-  s: 1,
-  m: 60,
-  h: 3600,
-  d: 86400,
-  w: 604800
-};
-function parseDurationSeconds(raw) {
-  const input = raw.trim().toLowerCase();
-  if (!input) return null;
-  if (/^\d+(?:\.\d+)?$/.test(input)) {
-    const num = parseFloat(input);
-    return Number.isFinite(num) ? num : null;
+function checkObsidianTemplates(resolvedPath) {
+  if (resolvedPath === void 0) {
+    return check("error", "obsidian_templates", "Obsidian templates", "Cannot check \u2014 WIKI_PATH not resolved");
   }
-  const re = /(\d+(?:\.\d+)?)(ms|s|m|h|d|w)/g;
-  let total = 0;
-  let consumed = 0;
-  for (const match of input.matchAll(re)) {
-    const full = match[0];
-    const value = parseFloat(match[1]);
-    const unit = match[2];
-    if (!Number.isFinite(value)) return null;
-    const factor = DURATION_UNIT_SECONDS[unit];
-    if (factor === void 0) return null;
-    total += value * factor;
-    consumed += full.length;
+  const missing = [];
+  if (!existsSync5(join8(resolvedPath, "_Templates"))) missing.push("_Templates/");
+  if (!existsSync5(join8(resolvedPath, ".obsidian", "templates.json"))) missing.push(".obsidian/templates.json");
+  if (!existsSync5(join8(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");
   }
-  if (consumed !== input.length) return null;
-  return total;
+  return check("warn", "obsidian_templates", "Obsidian templates", `Missing: ${missing.join(", ")} \u2014 run \`skillwiki init\` to create`);
 }
-var FLAG_THRESHOLDS = {
-  "--vfs-write-back": { min: 15, unit: "s", label: "VFS write-back window" },
-  "--vfs-write-wait": { min: 10, unit: "s", label: "VFS write-wait" },
-  "--vfs-cache-max-age": { min: 24, unit: "h", label: "VFS cache max age" }
+var vaultStructureProbe = {
+  id: "vault_structure",
+  run(ctx) {
+    return [
+      checkWikiPathExists(ctx.resolvedPath),
+      checkVaultStructure(ctx.resolvedPath),
+      checkObsidianTemplates(ctx.resolvedPath)
+    ];
+  }
 };
-var MIN_RCLONE_VERSION = { major: 1, minor: 65, patch: 0 };
 
-// src/commands/doctor.ts
-function check(status, id, label, detail) {
-  return { id, label, status, detail };
-}
-function checkNodeVersion() {
-  const major = parseInt(process.version.slice(1).split(".")[0], 10);
-  if (major >= 20) {
-    return check("pass", "node_version", "Node.js version", `v${major} >= 20`);
+// src/doctor/probes/git-fleet.ts
+import { existsSync as existsSync6, readFileSync as readFileSync3 } from "fs";
+import { join as join9 } from "path";
+import { execSync as execSync2 } from "child_process";
+import { platform } from "os";
+function checkVaultGitRemote(resolvedPath) {
+  if (resolvedPath === void 0) {
+    return check("error", "vault_git_remote", "Vault git remote", "Cannot check \u2014 WIKI_PATH not resolved");
   }
-  return check("error", "node_version", "Node.js version", `Node.js v${major} is below minimum v20`);
-}
-function detectCliChannels(argv, home) {
-  const channels = [];
-  if (argv.length >= 2 && argv[1].endsWith("cli.js")) {
-    const devPath = resolve2(argv[1]);
-    channels.push({ name: "dev", path: devPath, isDevLink: true });
+  if (!existsSync6(join9(resolvedPath, ".git"))) {
+    return check("warn", "vault_git_remote", "Vault git remote", "Vault is not a git repository \u2014 sync features unavailable");
   }
   try {
-    const whichOut = execSync2("which skillwiki 2>/dev/null", { encoding: "utf8" }).trim();
-    if (whichOut) {
-      const isDev = isDevSymlink(whichOut);
-      if (!channels.some((c) => c.path === resolve2(whichOut))) {
-        channels.push({ name: "npm", path: whichOut, isDevLink: isDev });
-      }
+    const remote = execSync2("git remote", { cwd: resolvedPath, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    if (!remote) {
+      return check("warn", "vault_git_remote", "Vault git remote", "No remote configured \u2014 push/pull unavailable");
+    }
+    let branch = "(no commits yet)";
+    try {
+      branch = execSync2("git rev-parse --abbrev-ref HEAD", { cwd: resolvedPath, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    } catch {
     }
+    return check("pass", "vault_git_remote", "Vault git remote", `Remote: ${remote.split("\n")[0]}, branch: ${branch}`);
   } catch {
+    return check("warn", "vault_git_remote", "Vault git remote", "Could not read git remote info");
   }
-  const plugin = findPlugin(home);
-  if (plugin) {
-    const pluginBin = join10(plugin.installPath, "bin", "skillwiki");
-    if (existsSync7(pluginBin)) {
-      channels.push({ name: "plugin", path: pluginBin, isDevLink: false });
-    }
+}
+async function checkFleetIdentity(input) {
+  if (!input.vaultPath) {
+    return check("pass", "fleet_identity", "Fleet identity", "No vault path \u2014 check skipped");
   }
-  const installBin = join10(home, ".claude", "skills", "bin", "skillwiki");
-  if (existsSync7(installBin)) {
-    channels.push({ name: "install", path: installBin, isDevLink: false });
+  const load = input.fleetLoad !== void 0 ? input.fleetLoad : await loadFleetManifestAndHost({
+    vault: input.vaultPath,
+    env: { ...process.env, WIKI_PATH: input.envValue ?? input.vaultPath },
+    home: input.home,
+    cwd: input.cwd ?? process.cwd(),
+    osHostname: process.env.HOSTNAME,
+    user: process.env.USER
+  });
+  if (!load) {
+    return check("pass", "fleet_identity", "Fleet identity", "Fleet manifest unavailable \u2014 check skipped");
   }
-  return channels;
-}
-function isDevSymlink(binPath) {
-  try {
-    const st = lstatSync(binPath);
-    if (st.isSymbolicLink()) {
-      const target = resolve2(binPath, "..", readlinkSync(binPath));
-      return target.includes("packages/cli") || target.includes("packages\\cli");
-    }
-  } catch {
+  if (load.identityStatus === "known") {
+    return check("pass", "fleet_identity", "Fleet identity", `Resolved ${load.hostId ?? "unknown"} via ${load.source ?? "unknown"}`);
   }
-  return false;
+  const detail = load.warnings.length > 0 ? load.warnings.join("; ") : "Fleet identity is unresolved";
+  return check("warn", "fleet_identity", "Fleet identity", detail);
 }
-function checkCliChannels(argv, home) {
-  const channels = detectCliChannels(argv, home);
-  if (channels.length === 0) {
-    return check("warn", "cli_channels", "CLI channels", "skillwiki not found on any channel");
+function checkSyncLastPush(resolvedPath) {
+  if (resolvedPath === void 0) {
+    return check("error", "sync_last_push", "Vault sync recency", "Cannot check \u2014 WIKI_PATH not resolved");
   }
-  if (channels.length === 1) {
-    const ch = channels[0];
-    const label = ch.isDevLink ? `${ch.name} (dev source)` : ch.name;
-    return check("pass", "cli_channels", "CLI channels", `Single channel: ${label}`);
+  if (!existsSync6(join9(resolvedPath, ".git"))) {
+    return check("pass", "sync_last_push", "Vault sync recency", "No git repo \u2014 sync check skipped");
   }
-  const devChannels = channels.filter((c) => c.isDevLink);
-  const prodChannels = channels.filter((c) => !c.isDevLink);
-  if (devChannels.length > 0 && prodChannels.length > 0) {
-    const hasInstall2 = prodChannels.some((c) => c.name === "install");
-    if (!hasInstall2) {
-      const devNames2 = devChannels.map((c) => `${c.name}(dev)`);
-      const prodNames2 = prodChannels.map((c) => c.name);
-      return check("pass", "cli_channels", "CLI channels", `${channels.length} channels: ${[...devNames2, ...prodNames2].join(", ")} \u2014 dev source with installed production channels`);
+  let timestamp;
+  try {
+    const out = execSync2("git log -1 --format=%ct origin/HEAD", {
+      cwd: resolvedPath,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    timestamp = parseInt(out, 10);
+  } catch {
+    try {
+      const out = execSync2("git log -1 --format=%ct HEAD", {
+        cwd: resolvedPath,
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      timestamp = parseInt(out, 10);
+    } catch {
     }
-    const devNames = devChannels.map((c) => `${c.name}(dev)`);
-    const prodNames = prodChannels.map((c) => c.name);
-    return check(
-      "warn",
-      "cli_channels",
-      "CLI channels",
-      `${channels.length} channels: ${[...devNames, ...prodNames].join(", ")} \u2014 dev and prod binaries overlap; dev repo should use project-local settings only`
-    );
-  }
-  const names = channels.map((c) => c.name);
-  const hasInstall = channels.some((c) => c.name === "install");
-  if (hasInstall) {
-    return check(
-      "warn",
-      "cli_channels",
-      "CLI channels",
-      `${channels.length} channels: ${names.join(", ")} \u2014 remove unused install with: rm ~/.claude/skills/bin/skillwiki`
-    );
   }
-  return check("pass", "cli_channels", "CLI channels", `${channels.length} channels: ${names.join(", ")}`);
-}
-function isDevSourceRun(argv) {
-  return argv.length >= 2 && argv[1].endsWith("cli.js");
-}
-async function checkConfigFile(home) {
-  const cfgPath = configPath(home);
-  if (!existsSync7(cfgPath)) {
-    return check("warn", "config_file", "Config file exists", `${cfgPath} not found`);
+  if (timestamp === void 0 || isNaN(timestamp)) {
+    return check("warn", "sync_last_push", "Vault sync recency", "No commits found \u2014 consider running `skillwiki sync status`");
   }
-  try {
-    const map = await parseDotenvFile(cfgPath);
-    const keys = Object.keys(map);
-    return check("pass", "config_file", "Config file exists", `Found with keys: ${keys.length > 0 ? keys.join(", ") : "(none set)"}`);
-  } catch (e) {
-    return check("warn", "config_file", "Config file exists", `Failed to parse ${cfgPath}: ${String(e)}`);
+  const daysSince = Math.floor((Date.now() / 1e3 - timestamp) / 86400);
+  const dateStr = new Date(timestamp * 1e3).toISOString().slice(0, 10);
+  if (daysSince > 7) {
+    return check("warn", "sync_last_push", "Vault sync recency", `Last push was ${daysSince} days ago \u2014 consider running \`skillwiki sync status\``);
   }
+  return check("pass", "sync_last_push", "Vault sync recency", `Last push: ${dateStr} (${daysSince} day(s) ago)`);
 }
-function checkWikiPathExists(resolvedPath) {
-  if (resolvedPath === void 0) {
-    return check("error", "wiki_path_exists", "Vault directory exists", "Cannot check \u2014 WIKI_PATH not resolved");
-  }
-  if (existsSync7(resolvedPath) && statSync2(resolvedPath).isDirectory()) {
-    return check("pass", "wiki_path_exists", "Vault directory exists", resolvedPath);
+function hasOriginMain(resolvedPath) {
+  try {
+    execSync2("git rev-parse --verify --quiet origin/main", {
+      cwd: resolvedPath,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 2e3
+    });
+    return true;
+  } catch {
+    return false;
   }
-  return check("error", "wiki_path_exists", "Vault directory exists", `${resolvedPath} does not exist or is not a directory`);
 }
-function checkVaultStructure(resolvedPath) {
+function checkVaultGitDirty(resolvedPath) {
   if (resolvedPath === void 0) {
-    return check("error", "vault_structure", "Vault structure valid", "Cannot check \u2014 WIKI_PATH not resolved");
-  }
-  if (!existsSync7(resolvedPath)) {
-    return check("error", "vault_structure", "Vault structure valid", "Cannot check \u2014 vault directory does not exist");
-  }
-  const missing = [];
-  if (!existsSync7(join10(resolvedPath, "SCHEMA.md"))) missing.push("SCHEMA.md");
-  for (const dir of ["raw", "entities", "concepts", "meta"]) {
-    if (!existsSync7(join10(resolvedPath, dir))) missing.push(dir + "/");
-  }
-  if (missing.length === 0) {
-    return check("pass", "vault_structure", "Vault structure valid", "All required files and directories present");
-  }
-  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 ? join10(cwd, "packages", "skills") : void 0;
-  if (srcDir && existsSync7(srcDir)) {
-    const found = findInstalledSkillMd(srcDir);
-    if (found.length > 0) {
-      return check("pass", "skills_installed", "Skills installed", `${found.length} SKILL.md file(s) found (source)`);
-    }
+    return check("pass", "vault_git_dirty", "Vault git dirty state", "No vault path \u2014 check skipped");
   }
-  const plugin = findPlugin(home);
-  if (plugin) {
-    const found = findInstalledSkillMd(plugin.installPath);
-    if (found.length > 0) {
-      return check("pass", "skills_installed", "Skills installed", `${found.length} SKILL.md file(s) found (plugin v${plugin.version})`);
-    }
+  if (!existsSync6(join9(resolvedPath, ".git"))) {
+    return check("pass", "vault_git_dirty", "Vault git dirty state", "No git repo \u2014 check skipped");
   }
-  const skillsDir = join10(home, ".claude", "skills");
-  if (existsSync7(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)`);
+  try {
+    const lines = execSync2("git status --porcelain", {
+      cwd: resolvedPath,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 5e3
+    }).trim().split("\n").filter(Boolean);
+    if (lines.length > 0) {
+      return check("warn", "vault_git_dirty", "Vault git dirty state", `${lines.length} dirty file(s) in vault worktree`);
     }
+    return check("pass", "vault_git_dirty", "Vault git dirty state", "Clean worktree");
+  } catch {
+    return check("warn", "vault_git_dirty", "Vault git dirty state", "Could not read git status");
   }
-  return check("warn", "skills_installed", "Skills installed", "No SKILL.md files found");
 }
-function checkDuplicateSkills(home) {
-  const plugin = findPlugin(home);
-  const skillsDir = join10(home, ".claude", "skills");
-  const agentSkillDirs = [
-    { label: "~/.codex/skills/", path: join10(home, ".codex", "skills") },
-    { label: "~/.agents/skills/", path: join10(home, ".agents", "skills") }
-  ];
-  if (!plugin) {
-    return check("pass", "skills_duplicate", "Skills not duplicated", "Single install channel");
-  }
-  const pluginSkills = findSkillNames(plugin.installPath);
-  const cliSkills = findSkillNames(skillsDir);
-  const cliDuplicates = cliSkills.filter((name) => pluginSkills.includes(name));
-  const agentDuplicates = [];
-  for (const { label, path } of agentSkillDirs) {
-    const overlap = findSkillNames(path).filter((name) => pluginSkills.includes(name));
-    if (overlap.length > 0) {
-      agentDuplicates.push({ dir: label, names: overlap });
-    }
-  }
-  if (cliDuplicates.length === 0 && agentDuplicates.length === 0) {
-    return check("pass", "skills_duplicate", "Skills not duplicated", "No overlap between plugin and other channels");
-  }
-  const parts = [];
-  if (cliDuplicates.length > 0) {
-    parts.push(`${cliDuplicates.length} skill(s) in both plugin and ~/.claude/skills/ \u2014 remove CLI copies: rm -r ~/.claude/skills/{${cliDuplicates.slice(0, 3).join(",")}${cliDuplicates.length > 3 ? ",\u2026" : ""}}`);
-  }
-  for (const { dir, names } of agentDuplicates) {
-    parts.push(`${names.length} stale skill(s) in ${dir} \u2014 plugin provides: ${names.slice(0, 3).join(", ")}${names.length > 3 ? ", \u2026" : ""}`);
+function gitRefHash(resolvedPath, ref) {
+  try {
+    const out = execSync2(`git rev-parse --verify ${ref}`, {
+      cwd: resolvedPath,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 2e3
+    }).trim();
+    return out || void 0;
+  } catch {
+    return void 0;
   }
-  const status = cliDuplicates.length > 0 ? "warn" : "info";
-  return check(status, "skills_duplicate", "Skills not duplicated", parts.join("; "));
 }
-var GROK_ACTIVATION_REFERENCE = "Read @~/.grok/skillwiki.md for SkillWiki activation context.";
-var STALE_GROK_ACTIVATION_REFERENCE = "Read @skillwiki.md";
-var ACTIVATION_FIX_HINT = "run `npm run install:activation` from the llm-wiki repo";
-function findGrokActivationTemplate(home, cwd) {
-  if (cwd) {
-    const src = join10(cwd, "packages", "skills", "using-skillwiki", "activation.md");
-    if (existsSync7(src)) return src;
-  }
-  const pluginsRoot = join10(home, ".grok", "installed-plugins");
-  if (!existsSync7(pluginsRoot)) return void 0;
-  let entries;
+function remoteMainHash(resolvedPath) {
   try {
-    entries = readdirSync3(pluginsRoot, { withFileTypes: true });
+    const out = execSync2("git ls-remote origin refs/heads/main", {
+      cwd: resolvedPath,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 3e3
+    }).trim();
+    const hash = out.split(/\s+/)[0];
+    return /^[0-9a-f]{40}$/i.test(hash) ? hash : void 0;
   } catch {
     return void 0;
   }
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    const root = join10(pluginsRoot, entry.name);
-    for (const rel of ["using-skillwiki/activation.md", "skills/using-skillwiki/activation.md"]) {
-      const candidate = join10(root, rel);
-      if (existsSync7(candidate)) return candidate;
-    }
-  }
-  return void 0;
 }
-function checkGrokActivation(home, cwd) {
-  const grokDir = join10(home, ".grok");
-  if (!existsSync7(grokDir)) {
-    return check("pass", "activation_grok", "Grok activation", "Not a Grok host");
+function checkStaleRemoteMain(resolvedPath) {
+  if (resolvedPath === void 0) return void 0;
+  if (!existsSync6(join9(resolvedPath, ".git"))) return void 0;
+  const localOrigin = gitRefHash(resolvedPath, "origin/main");
+  if (!localOrigin) return void 0;
+  const remoteMain = remoteMainHash(resolvedPath);
+  if (!remoteMain || remoteMain === localOrigin) return void 0;
+  return check(
+    "warn",
+    "vault_git_behind",
+    "Vault commits behind",
+    `Remote main differs from local origin/main (${remoteMain.slice(0, 8)} != ${localOrigin.slice(0, 8)}) \u2014 run git fetch before trusting behind count`
+  );
+}
+function checkVaultGitComparison(resolvedPath, id, label, range, nonZeroSuffix, zeroDetail) {
+  if (resolvedPath === void 0) {
+    return check("pass", id, label, "No vault path \u2014 check skipped");
   }
-  const activationPath = join10(grokDir, "skillwiki.md");
-  const agentsPath = join10(grokDir, "AGENTS.md");
-  const hasActivation = existsSync7(activationPath);
-  const issues = [];
-  if (!hasActivation) {
-    issues.push("~/.grok/skillwiki.md missing");
+  if (!existsSync6(join9(resolvedPath, ".git"))) {
+    return check("pass", id, label, "No git repo \u2014 check skipped");
   }
-  if (!existsSync7(agentsPath)) {
-    issues.push("~/.grok/AGENTS.md missing");
-  } else {
-    const agents = readFileSync6(agentsPath, "utf8");
-    const hasBegin = agents.includes("<!-- skillwiki:begin -->");
-    const hasExpected = agents.includes(GROK_ACTIVATION_REFERENCE);
-    const hasStale = agents.includes(STALE_GROK_ACTIVATION_REFERENCE);
-    if (!hasBegin) {
-      issues.push("AGENTS.md marker missing");
-    } else if (hasStale && !hasExpected) {
-      issues.push("AGENTS.md marker is stale (@skillwiki.md)");
-    } else if (!hasExpected) {
-      issues.push("AGENTS.md marker is stale");
-    }
+  if (!hasOriginMain(resolvedPath)) {
+    return check("pass", id, label, "origin/main unavailable \u2014 check skipped");
   }
-  if (hasActivation) {
-    const template = findGrokActivationTemplate(home, cwd);
-    if (template) {
-      try {
-        const installed = readFileSync6(activationPath, "utf8");
-        const expected = readFileSync6(template, "utf8");
-        if (installed !== expected) {
-          issues.push("~/.grok/skillwiki.md differs from template");
-        }
-      } catch {
-      }
+  try {
+    const count = parseInt(execSync2(`git rev-list --count ${range}`, {
+      cwd: resolvedPath,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 5e3
+    }).trim(), 10);
+    if (count > 0) {
+      return check("warn", id, label, `${count} commit(s) ${nonZeroSuffix}`);
     }
+    return check("pass", id, label, zeroDetail);
+  } catch {
+    return check("warn", id, label, "Could not compare HEAD with origin/main");
   }
-  if (issues.length > 0) {
-    return check(
-      "warn",
-      "activation_grok",
-      "Grok activation",
-      `${issues.join("; ")} \u2014 ${ACTIVATION_FIX_HINT}`
-    );
-  }
-  return check("pass", "activation_grok", "Grok activation", "Marker and compact file are current");
 }
-function checkNpmUpdate(home, currentVersion) {
-  const { hasUpdate, latest, distTag } = latestFromCache(home, currentVersion);
-  if (!latest) {
-    return check("pass", "npm_update", "npm CLI version", `v${currentVersion} (${distTag}: no cache yet)`);
-  }
-  if (hasUpdate) {
-    return check("warn", "npm_update", "npm CLI version", `v${currentVersion} \u2014 ${distTag} update available: v${latest}. Run \`skillwiki update --tag ${distTag}\`.`);
-  }
-  return check("pass", "npm_update", "npm CLI version", `v${currentVersion} (${distTag}: v${latest})`);
+function checkVaultGitAhead(resolvedPath) {
+  return checkVaultGitComparison(
+    resolvedPath,
+    "vault_git_ahead",
+    "Vault commits ahead",
+    "origin/main..HEAD",
+    "ahead of origin/main",
+    "0 commits ahead of origin/main"
+  );
 }
-function checkPluginVersionDrift(home, currentVersion, devSourceRun) {
-  const plugins = findPluginInstallations(home);
-  if (plugins.length === 0) {
-    return check("pass", "plugin_version_drift", "Plugin/CLI version", "Plugin not installed \u2014 CLI only");
-  }
-  const drifted = plugins.filter((plugin) => plugin.version !== currentVersion);
-  if (drifted.length === 0) {
-    if (plugins.length === 1 && plugins[0].channel === "claude") {
-      return check("pass", "plugin_version_drift", "Plugin/CLI version", `Both at v${currentVersion}`);
-    }
-    if (plugins.length === 1) {
-      return check("pass", "plugin_version_drift", "Plugin/CLI version", `${plugins[0].label} plugin and CLI both at v${currentVersion}`);
-    }
-    const labels = plugins.map((plugin) => `${plugin.label} plugin`).join(", ");
-    return check("pass", "plugin_version_drift", "Plugin/CLI version", `${labels}, and CLI all at v${currentVersion}`);
-  }
-  if (devSourceRun && drifted.every((plugin) => semverGt(currentVersion, plugin.version))) {
-    const details2 = drifted.map((plugin) => `${plugin.label} plugin v${plugin.version}`).join(", ");
-    return check("info", "plugin_version_drift", "Plugin/CLI version", `Dev source v${currentVersion} is ahead of installed ${details2}`);
-  }
-  const details = drifted.map((plugin) => {
-    const updateCmd = pluginUpdateCommand(plugin, currentVersion);
-    return `${plugin.label} plugin v${plugin.version} \u2260 CLI v${currentVersion} \u2014 run \`${updateCmd}\``;
-  });
-  return check(
-    "warn",
-    "plugin_version_drift",
-    "Plugin/CLI version",
-    details.join("; ")
+function checkVaultGitBehind(resolvedPath) {
+  const staleRemote = checkStaleRemoteMain(resolvedPath);
+  if (staleRemote) return staleRemote;
+  return checkVaultGitComparison(
+    resolvedPath,
+    "vault_git_behind",
+    "Vault commits behind",
+    "HEAD..origin/main",
+    "behind origin/main",
+    "0 commits behind origin/main"
   );
 }
-function pluginUpdateCommand(plugin, currentVersion) {
-  if (semverGt(plugin.version, currentVersion)) {
-    return "npm install -g skillwiki@latest";
-  }
-  if (plugin.channel === "claude") {
-    return "claude plugin update skillwiki@llm-wiki";
-  }
-  if (plugin.sourceType === "git") {
-    return "codex plugin marketplace upgrade llm-wiki && codex plugin remove skillwiki@llm-wiki && codex plugin add skillwiki@llm-wiki";
-  }
-  return "codex plugin remove skillwiki@llm-wiki && codex plugin add skillwiki@llm-wiki";
+function pullLogPaths(home) {
+  const paths = platform() === "darwin" ? [
+    join9(home, "Library", "Logs", "wiki-pull.log"),
+    join9(home, ".local", "state", "vault-sync", "log", "wiki-pull.log")
+  ] : [
+    join9(home, ".local", "state", "vault-sync", "log", "wiki-pull.log"),
+    join9(home, "Library", "Logs", "wiki-pull.log")
+  ];
+  return [...new Set(paths)];
 }
-async function checkProfiles(home) {
-  const map = await parseDotenvFile(configPath(home));
-  const profiles = [];
-  for (const key of Object.keys(map)) {
-    if (key.startsWith("WIKI_") && key.endsWith("_PATH") && key !== "WIKI_PATH") {
-      const name = key.slice(5, -5).toLowerCase().replace(/_/g, "-");
-      profiles.push(name);
-    }
-  }
-  if (profiles.length === 0) {
-    return check("pass", "wiki_profiles", "Wiki profiles", "No named profiles configured");
-  }
-  const defaultProfile = map["WIKI_DEFAULT"] ?? "(none)";
-  return check(
-    "pass",
-    "wiki_profiles",
-    "Wiki profiles",
-    `${profiles.length} profile(s): ${profiles.join(", ")}; default: ${defaultProfile}`
-  );
+function isRecentLogLine(line, nowMs) {
+  const match = line.match(/^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z)/);
+  if (!match) return true;
+  const ts = Date.parse(match[1]);
+  if (!Number.isFinite(ts)) return true;
+  return nowMs - ts <= 24 * 60 * 60 * 1e3;
 }
-async function checkProjectLocalOverride(cwd) {
-  const dir = cwd ?? process.cwd();
-  const envPath = join10(dir, ".skillwiki", ".env");
-  if (existsSync7(envPath)) {
-    return check("pass", "project_local", "Project-local config", `Found: ${envPath}`);
+function checkVaultGitPullFailures(home) {
+  const path = pullLogPaths(home).find((p) => existsSync6(p));
+  if (!path) {
+    return check("pass", "vault_git_pull_failures", "Vault pull failures", "No wiki-pull.log found \u2014 check skipped");
+  }
+  try {
+    const lines = readFileSync3(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)
+    );
+    if (failures.length > 0) {
+      const sample = failures.slice(-2).map((line) => line.slice(0, 100)).join(" | ");
+      return check("warn", "vault_git_pull_failures", "Vault pull failures", `${failures.length} recent pull failure(s): ${sample}`);
+    }
+    return check("pass", "vault_git_pull_failures", "Vault pull failures", "No recent pull failures logged");
+  } catch {
+    return check("warn", "vault_git_pull_failures", "Vault pull failures", `Could not read ${path}`);
   }
-  return check("pass", "project_local", "Project-local config", "None");
 }
-function checkVaultGitRemote(resolvedPath) {
+function checkVaultLocalGit(resolvedPath) {
   if (resolvedPath === void 0) {
-    return check("error", "vault_git_remote", "Vault git remote", "Cannot check \u2014 WIKI_PATH not resolved");
+    return check("warn", "vault_local_git", "Vault local git", "Cannot check \u2014 WIKI_PATH not resolved");
   }
-  if (!existsSync7(join10(resolvedPath, ".git"))) {
-    return check("warn", "vault_git_remote", "Vault git remote", "Vault is not a git repository \u2014 sync features unavailable");
+  if (!existsSync6(join9(resolvedPath, ".git"))) {
+    return check("warn", "vault_local_git", "Vault local git", "Not a git repository - sync features unavailable");
   }
   try {
-    const remote = execSync2("git remote", { cwd: resolvedPath, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    if (!remote) {
-      return check("warn", "vault_git_remote", "Vault git remote", "No remote configured \u2014 push/pull unavailable");
-    }
-    let branch = "(no commits yet)";
-    try {
-      branch = execSync2("git rev-parse --abbrev-ref HEAD", { cwd: resolvedPath, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    } catch {
-    }
-    return check("pass", "vault_git_remote", "Vault git remote", `Remote: ${remote.split("\n")[0]}, branch: ${branch}`);
+    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("warn", "vault_git_remote", "Vault git remote", "Could not read git remote info");
+    return check("error", "vault_local_git", "Vault local git", "Git metadata unreadable \u2014 local vault may be corrupt");
   }
 }
-function checkObsidianTemplates(resolvedPath) {
+function checkVaultGithubRemote(resolvedPath, exec) {
   if (resolvedPath === void 0) {
-    return check("error", "obsidian_templates", "Obsidian templates", "Cannot check \u2014 WIKI_PATH not resolved");
+    return check("pass", "vault_github_remote", "Vault GitHub remote", "No vault path \u2014 check skipped");
   }
-  const missing = [];
-  if (!existsSync7(join10(resolvedPath, "_Templates"))) missing.push("_Templates/");
-  if (!existsSync7(join10(resolvedPath, ".obsidian", "templates.json"))) missing.push(".obsidian/templates.json");
-  if (!existsSync7(join10(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");
+  if (!existsSync6(join9(resolvedPath, ".git"))) {
+    return check("pass", "vault_github_remote", "Vault GitHub remote", "No git repo \u2014 check skipped");
   }
-  return check("warn", "obsidian_templates", "Obsidian templates", `Missing: ${missing.join(", ")} \u2014 run \`skillwiki init\` to create`);
+  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 checkDotStoreClean(resolvedPath) {
-  if (resolvedPath === void 0) {
-    return check("error", "dsstore_clean", "No .DS_Store in raw/", "Cannot check \u2014 WIKI_PATH not resolved");
+function checkVaultS3Remote(home, exec, env) {
+  const remote = resolveWikiS3Remote({ home, env });
+  if (!remote) {
+    return check("pass", "vault_s3_remote", "Vault S3 remote", "S3 remote not configured \u2014 check skipped");
   }
-  const rawDir = join10(resolvedPath, "raw");
-  if (!existsSync7(rawDir)) {
-    return check("pass", "dsstore_clean", "No .DS_Store in raw/", "raw/ directory not found \u2014 check skipped");
+  const state = probeS3Reachability(remote, exec);
+  if (state === "ok") {
+    return check("pass", "vault_s3_remote", "Vault S3 remote", `rclone lsf ${remote} succeeded`);
   }
-  const found = [];
-  (function walk(dir, rel) {
-    let entries;
-    try {
-      entries = readdirSync3(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      if (entry.name === ".DS_Store") {
-        found.push(rel ? `${rel}/.DS_Store` : ".DS_Store");
-      } else if (entry.isDirectory()) {
-        walk(join10(dir, entry.name), rel ? `${rel}/${entry.name}` : entry.name);
-      }
-    }
-  })(rawDir, "");
-  if (found.length === 0) {
-    return check("pass", "dsstore_clean", "No .DS_Store in raw/", "No .DS_Store files found");
+  if (state === "unreachable") {
+    return check("warn", "vault_s3_remote", "Vault S3 remote", `S3 remote unreachable (${remote}) \u2014 local/GitHub work may continue`);
   }
-  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`);
+  return check("pass", "vault_s3_remote", "Vault S3 remote", "S3 remote not configured \u2014 check skipped");
 }
-function checkVaultConflictMarkers(resolvedPath) {
-  if (resolvedPath === void 0) {
-    return check("pass", "vault_conflict_markers", "Vault conflict markers", "No vault path \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 findings = scanVaultConflictMarkers(resolvedPath);
-  if (findings.length === 0) {
-    return check("pass", "vault_conflict_markers", "Vault conflict markers", "No complete conflict-marker blocks");
+  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 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}`
-  );
+  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 checkSyncLastPush(resolvedPath) {
+function checkVaultPromotionLag(resolvedPath) {
   if (resolvedPath === void 0) {
-    return check("error", "sync_last_push", "Vault sync recency", "Cannot check \u2014 WIKI_PATH not resolved");
+    return check("pass", "vault_promotion_lag", "Vault promotion lag", "No vault path \u2014 check skipped");
   }
-  if (!existsSync7(join10(resolvedPath, ".git"))) {
-    return check("pass", "sync_last_push", "Vault sync recency", "No git repo \u2014 sync check skipped");
+  if (!existsSync6(join9(resolvedPath, ".git"))) {
+    return check("pass", "vault_promotion_lag", "Vault promotion lag", "No git repo \u2014 check skipped");
   }
-  let timestamp;
   try {
-    const out = execSync2("git log -1 --format=%ct origin/HEAD", {
+    const out = execSync2("git log -1 --format=%ct origin/main", {
       cwd: resolvedPath,
       encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"]
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 2e3
     }).trim();
-    timestamp = parseInt(out, 10);
-  } catch {
-    try {
-      const out = execSync2("git log -1 --format=%ct HEAD", {
-        cwd: resolvedPath,
-        encoding: "utf8",
-        stdio: ["pipe", "pipe", "pipe"]
-      }).trim();
-      timestamp = parseInt(out, 10);
-    } catch {
+    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");
   }
-  if (timestamp === void 0 || isNaN(timestamp)) {
-    return check("warn", "sync_last_push", "Vault sync recency", "No commits found \u2014 consider running `skillwiki sync status`");
+}
+var gitFleetProbe = {
+  id: "git_fleet",
+  async run(ctx) {
+    return [
+      checkVaultGitRemote(ctx.gitCheckPath),
+      await checkFleetIdentity({
+        vaultPath: ctx.resolvedPath,
+        home: ctx.input.home,
+        cwd: ctx.input.cwd,
+        envValue: ctx.input.envValue,
+        fleetLoad: ctx.fleetLoad
+      }),
+      checkSyncLastPush(ctx.gitCheckPath),
+      checkVaultGitDirty(ctx.gitCheckPath),
+      checkVaultGitAhead(ctx.gitCheckPath),
+      checkVaultGitBehind(ctx.gitCheckPath),
+      checkVaultGitPullFailures(ctx.input.home),
+      checkVaultLocalGit(ctx.gitCheckPath),
+      checkVaultGithubRemote(ctx.gitCheckPath, ctx.input.execProbe),
+      checkVaultS3Remote(ctx.input.home, ctx.input.execProbe, ctx.input.env ?? process.env),
+      checkVaultSnapshotterReachable(ctx.fleetLoad, ctx.input.checkSnapshotter, ctx.input.execProbe),
+      checkVaultPromotionLag(ctx.gitCheckPath)
+    ];
   }
-  const daysSince = Math.floor((Date.now() / 1e3 - timestamp) / 86400);
-  const dateStr = new Date(timestamp * 1e3).toISOString().slice(0, 10);
-  if (daysSince > 7) {
-    return check("warn", "sync_last_push", "Vault sync recency", `Last push was ${daysSince} days ago \u2014 consider running \`skillwiki sync status\``);
+};
+
+// src/doctor/probes/hygiene.ts
+import { existsSync as existsSync8, readdirSync as readdirSync3 } from "fs";
+import { join as join11 } from "path";
+
+// src/utils/conflict-markers.ts
+import { existsSync as existsSync7, readdirSync as readdirSync2, readFileSync as readFileSync4 } from "fs";
+import { join as join10 } 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 check("pass", "sync_last_push", "Vault sync recency", `Last push: ${dateStr} (${daysSince} day(s) ago)`);
+  return findings;
 }
-function hasOriginMain(resolvedPath) {
+var PRUNE_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  ".obsidian",
+  ".skillwiki",
+  ".claude",
+  ".antigravitycli",
+  ".playwright-cli"
+]);
+function walkMarkdownFiles(root, dir, rel, out) {
+  let entries;
   try {
-    execSync2("git rev-parse --verify --quiet origin/main", {
-      cwd: resolvedPath,
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 2e3
-    });
-    return true;
+    entries = readdirSync2(dir, { withFileTypes: true });
   } catch {
-    return false;
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (PRUNE_DIRS.has(entry.name)) continue;
+      walkMarkdownFiles(root, join10(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 checkVaultGitDirty(resolvedPath) {
+function scanVaultConflictMarkers(vaultRoot) {
+  if (!existsSync7(vaultRoot)) return [];
+  const relPaths = [];
+  walkMarkdownFiles(vaultRoot, vaultRoot, "", relPaths);
+  const all = [];
+  for (const rel of relPaths) {
+    let text;
+    try {
+      text = readFileSync4(join10(vaultRoot, rel), "utf8");
+    } catch {
+      continue;
+    }
+    all.push(...scanConflictMarkerBlocksInText(rel, text));
+  }
+  return all;
+}
+
+// src/doctor/probes/hygiene.ts
+function checkDotStoreClean(resolvedPath) {
   if (resolvedPath === void 0) {
-    return check("pass", "vault_git_dirty", "Vault git dirty state", "No vault path \u2014 check skipped");
+    return check("error", "dsstore_clean", "No .DS_Store in raw/", "Cannot check \u2014 WIKI_PATH not resolved");
   }
-  if (!existsSync7(join10(resolvedPath, ".git"))) {
-    return check("pass", "vault_git_dirty", "Vault git dirty state", "No git repo \u2014 check skipped");
+  const rawDir = join11(resolvedPath, "raw");
+  if (!existsSync8(rawDir)) {
+    return check("pass", "dsstore_clean", "No .DS_Store in raw/", "raw/ directory not found \u2014 check skipped");
   }
-  try {
-    const lines = execSync2("git status --porcelain", {
-      cwd: resolvedPath,
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 5e3
-    }).trim().split("\n").filter(Boolean);
-    if (lines.length > 0) {
-      return check("warn", "vault_git_dirty", "Vault git dirty state", `${lines.length} dirty file(s) in vault worktree`);
+  const found = [];
+  (function walk(dir, rel) {
+    let entries;
+    try {
+      entries = readdirSync3(dir, { withFileTypes: true });
+    } catch {
+      return;
     }
-    return check("pass", "vault_git_dirty", "Vault git dirty state", "Clean worktree");
-  } catch {
-    return check("warn", "vault_git_dirty", "Vault git dirty state", "Could not read git status");
+    for (const entry of entries) {
+      if (entry.name === ".DS_Store") {
+        found.push(rel ? `${rel}/.DS_Store` : ".DS_Store");
+      } else if (entry.isDirectory()) {
+        walk(join11(dir, entry.name), rel ? `${rel}/${entry.name}` : entry.name);
+      }
+    }
+  })(rawDir, "");
+  if (found.length === 0) {
+    return check("pass", "dsstore_clean", "No .DS_Store in raw/", "No .DS_Store files found");
   }
+  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 checkVaultGitAhead(resolvedPath) {
-  return checkVaultGitComparison(
-    resolvedPath,
-    "vault_git_ahead",
-    "Vault commits ahead",
-    "origin/main..HEAD",
-    "ahead of origin/main",
-    "0 commits ahead of origin/main"
-  );
-}
-function checkVaultGitBehind(resolvedPath) {
-  const staleRemote = checkStaleRemoteMain(resolvedPath);
-  if (staleRemote) return staleRemote;
-  return checkVaultGitComparison(
-    resolvedPath,
-    "vault_git_behind",
-    "Vault commits behind",
-    "HEAD..origin/main",
-    "behind origin/main",
-    "0 commits behind origin/main"
+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 gitRefHash(resolvedPath, ref) {
+var hygieneProbe = {
+  id: "hygiene",
+  run(ctx) {
+    return [
+      checkDotStoreClean(ctx.readOnlyScanRoot),
+      checkVaultConflictMarkers(ctx.readOnlyScanRoot)
+    ];
+  }
+};
+
+// src/doctor/probes/s3-mount-health.ts
+import { existsSync as existsSync10 } from "fs";
+import { join as join13 } from "path";
+import { execSync as execSync4 } from "child_process";
+
+// src/utils/s3-mount-health.ts
+import { execSync as execSync3 } from "child_process";
+import { platform as platform2 } from "os";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2, readFileSync as readFile6 } from "fs";
+import { join as join12 } from "path";
+var OS = platform2();
+function findRcloneMountPid() {
   try {
-    const out = execSync2(`git rev-parse --verify ${ref}`, {
-      cwd: resolvedPath,
+    const out = execSync3("pgrep -f 'rclone.*mount'", {
       encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 2e3
+      timeout: 2e3,
+      stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    return out || void 0;
+    const pids = out.split("\n").filter(Boolean);
+    if (pids.length === 0) return null;
+    return parseInt(pids[0], 10);
   } catch {
-    return void 0;
+    try {
+      const out = execSync3("ps aux", { encoding: "utf8", timeout: 2e3, stdio: ["pipe", "pipe", "pipe"] });
+      for (const line of out.split("\n")) {
+        if (line.includes("rclone") && line.includes("mount") && !line.includes("grep")) {
+          const parts = line.trim().split(/\s+/);
+          if (parts.length >= 2) return parseInt(parts[1], 10);
+        }
+      }
+    } catch {
+    }
+    return null;
   }
 }
-function remoteMainHash(resolvedPath) {
+function parseRcloneFlags(pid) {
+  const flags = /* @__PURE__ */ new Map();
   try {
-    const out = execSync2("git ls-remote origin refs/heads/main", {
-      cwd: resolvedPath,
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 3e3
-    }).trim();
-    const hash = out.split(/\s+/)[0];
-    return /^[0-9a-f]{40}$/i.test(hash) ? hash : void 0;
+    const args = getRcloneArgs(pid);
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+      if (arg.startsWith("--") && arg.includes("=")) {
+        const eq = arg.indexOf("=");
+        flags.set(arg.slice(0, eq), arg.slice(eq + 1));
+      } else if (arg.startsWith("--")) {
+        const next = args[i + 1];
+        if (next && !next.startsWith("-")) {
+          flags.set(arg, next);
+          i++;
+        } else {
+          flags.set(arg, "");
+        }
+      }
+    }
   } catch {
-    return void 0;
   }
+  return flags;
 }
-function checkStaleRemoteMain(resolvedPath) {
-  if (resolvedPath === void 0) return void 0;
-  if (!existsSync7(join10(resolvedPath, ".git"))) return void 0;
-  const localOrigin = gitRefHash(resolvedPath, "origin/main");
-  if (!localOrigin) return void 0;
-  const remoteMain = remoteMainHash(resolvedPath);
-  if (!remoteMain || remoteMain === localOrigin) return void 0;
-  return check(
-    "warn",
-    "vault_git_behind",
-    "Vault commits behind",
-    `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 (!existsSync7(join10(resolvedPath, ".git"))) {
-    return check("warn", "vault_local_git", "Vault local git", "Not a git repository - sync features unavailable");
-  }
+function getRcloneVersion() {
   try {
-    execSync2("git rev-parse --git-dir", {
-      cwd: resolvedPath,
+    const out = execSync3("rclone version", {
       encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 2e3
+      timeout: 3e3,
+      stdio: ["pipe", "pipe", "pipe"]
     });
-    return check("pass", "vault_local_git", "Vault local git", "Git metadata readable");
+    const match = out.match(/rclone\s+v(\d+)\.(\d+)\.(\d+)/i);
+    if (!match) return null;
+    return {
+      major: parseInt(match[1], 10),
+      minor: parseInt(match[2], 10),
+      patch: parseInt(match[3], 10),
+      raw: out.split("\n")[0].trim()
+    };
   } 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 (!existsSync7(join10(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, env) {
-  const remote = resolveWikiS3Remote({ home, env });
-  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 null;
   }
-  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}`);
+function extractRcloneFs(args) {
+  let foundMount = false;
+  for (const arg of args) {
+    if (arg === "mount") {
+      foundMount = true;
+      continue;
+    }
+    if (foundMount && arg.includes(":") && !arg.startsWith("-") && !arg.startsWith("/")) {
+      return arg;
+    }
   }
-  return check("warn", "vault_snapshotter_reachable", "Vault snapshotter host", `Snapshotter unreachable via ${alias} \u2014 not a local vault corruption signal`);
+  return null;
 }
-function checkVaultPromotionLag(resolvedPath) {
-  if (resolvedPath === void 0) {
-    return check("pass", "vault_promotion_lag", "Vault promotion lag", "No vault path \u2014 check skipped");
-  }
-  if (!existsSync7(join10(resolvedPath, ".git"))) {
-    return check("pass", "vault_promotion_lag", "Vault promotion lag", "No git repo \u2014 check skipped");
-  }
+function getRcloneArgs(pid) {
   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`);
+    if (OS === "linux") {
+      const raw = readFileSync5(`/proc/${pid}/cmdline`);
+      return new TextDecoder().decode(raw).split("\0").filter(Boolean);
+    } else {
+      const out = execSync3(`ps -o args= -p ${pid}`, {
+        encoding: "utf8",
+        timeout: 2e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      return out.split(/\s+/);
     }
-    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");
+    return [];
   }
 }
-function checkVaultGitComparison(resolvedPath, id, label, range, nonZeroSuffix, zeroDetail) {
-  if (resolvedPath === void 0) {
-    return check("pass", id, label, "No vault path \u2014 check skipped");
-  }
-  if (!existsSync7(join10(resolvedPath, ".git"))) {
-    return check("pass", id, label, "No git repo \u2014 check skipped");
-  }
-  if (!hasOriginMain(resolvedPath)) {
-    return check("pass", id, label, "origin/main unavailable \u2014 check skipped");
-  }
+function queryRcloneRC(rcAddr, fs) {
   try {
-    const count = parseInt(execSync2(`git rev-list --count ${range}`, {
-      cwd: resolvedPath,
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 5e3
-    }).trim(), 10);
-    if (count > 0) {
-      return check("warn", id, label, `${count} commit(s) ${nonZeroSuffix}`);
+    const payload = JSON.stringify({ fs });
+    const out = execSync3(
+      `curl -s --max-time 3 -X POST "http://${rcAddr}/vfs/stats" -H "Content-Type: application/json" -d '${payload}' 2>/dev/null`,
+      { encoding: "utf8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }
+    );
+    if (!out.trim()) return null;
+    const data = JSON.parse(out);
+    if (data.status && data.status >= 400) {
+      return { error: data.error || `RC error (status ${data.status})`, erroredFiles: 0, uploadsInProgress: 0, uploadsQueued: 0, outOfSpace: false, bytesUsed: 0, files: 0, totalSize: "unknown" };
     }
-    return check("pass", id, label, zeroDetail);
+    const dc = data.diskCache || {};
+    return {
+      erroredFiles: dc.erroredFiles ?? 0,
+      uploadsInProgress: dc.uploadsInProgress ?? 0,
+      uploadsQueued: dc.uploadsQueued ?? 0,
+      outOfSpace: dc.outOfSpace ?? false,
+      bytesUsed: dc.bytesUsed ?? 0,
+      files: dc.files ?? 0,
+      totalSize: data.totalSize || "unknown"
+    };
   } catch {
-    return check("warn", id, label, "Could not compare HEAD with origin/main");
+    return { error: "RC endpoint unreachable", erroredFiles: 0, uploadsInProgress: 0, uploadsQueued: 0, outOfSpace: false, bytesUsed: 0, files: 0, totalSize: "unknown" };
   }
 }
-function checkSatelliteLastRun(vaultPath, satelliteExpected) {
-  if (!satelliteExpected) {
-    return check("pass", "satellite_job_last_run", "Satellite job last run", "Satellite job not expected on this host");
-  }
-  if (vaultPath === void 0) {
-    return check("pass", "satellite_job_last_run", "Satellite job last run", "No vault path \u2014 check skipped");
-  }
-  const latestPath = satelliteLatestRunPath(vaultPath);
-  if (!existsSync7(latestPath)) {
-    return check("pass", "satellite_job_last_run", "Satellite job last run", "No latest-run.json \u2014 satellite has not run yet");
-  }
+function detectFuseMount(vaultPath) {
   try {
-    const health = evaluateSatelliteRunHealth(vaultPath, /* @__PURE__ */ new Date());
-    if (health.failed) {
-      const fc = health.failureClass;
-      const detail = fc ? `Last satellite run failed (failure_class: ${fc})` : "Last satellite run failed";
-      return check("error", "satellite_job_last_run", "Satellite job last run", detail);
-    }
-    if (health.stale && health.finishedAt) {
-      return check(
-        "warn",
-        "satellite_job_last_run",
-        "Satellite job last run",
-        `Last run finished_at is older than 26h (${health.finishedAt})`
-      );
+    if (OS === "linux") {
+      const mounts = readFileSync5("/proc/mounts", "utf8");
+      let best = null;
+      for (const line of mounts.split("\n")) {
+        const parts = line.split(" ");
+        if (parts.length < 3) continue;
+        const point = parts[1];
+        const fs = parts[2];
+        if (vaultPath.startsWith(point) && (!best || point.length > best.point.length)) {
+          best = { point, fs };
+        }
+      }
+      if (best && best.fs.includes("fuse")) return { mountPoint: best.point, fsType: best.fs };
+    } else if (OS === "darwin") {
+      const out = execSync3("mount", { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
+      let best = null;
+      for (const line of out.split("\n")) {
+        const match = line.match(/^(\S+) on (\S+) \((.*?)\)/);
+        if (!match) continue;
+        const point = match[2];
+        const opts = match[3];
+        if (opts.includes("fuse") && vaultPath.startsWith(point) && (!best || point.length > best.point.length)) {
+          best = { point, fsType: `fuse.${match[1].split(":")[0] || "unknown"}` };
+        }
+      }
+      if (best) return { mountPoint: best.point, fsType: best.fsType };
     }
-    return check(
-      "pass",
-      "satellite_job_last_run",
-      "Satellite job last run",
-      health.finishedAt ? `Last run ok (finished_at ${health.finishedAt})` : "Last run ok"
-    );
   } catch {
-    return check("warn", "satellite_job_last_run", "Satellite job last run", `Could not read ${latestPath}`);
   }
+  return null;
 }
-function defaultSatelliteTimerDeps() {
-  return {
-    platform: () => platform2(),
-    systemctlIsActive: (unit) => {
+function writeTest(dir) {
+  const testFile = join12(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 {
+    writeFileSync2(testFile, payload, "utf8");
+  } catch (e) {
+    return { success: false, writeMs: Date.now() - start, readMs: 0, size: 0, error: `write failed: ${e.message}` };
+  }
+  const writeMs = Date.now() - start;
+  const readStart = Date.now();
+  try {
+    const back = readFile6(testFile, "utf8");
+    const readMs = Date.now() - readStart;
+    if (back !== payload) {
       try {
-        return execSync2(`systemctl is-active ${unit}`, {
-          encoding: "utf8",
-          timeout: 2e3,
-          stdio: ["pipe", "pipe", "pipe"]
-        }).trim();
+        unlinkSync2(testFile);
       } catch {
-        return void 0;
       }
+      return { success: false, writeMs, readMs, size: Buffer.byteLength(payload, "utf8"), error: "content mismatch \u2014 wrote and read-back differ" };
     }
-  };
-}
-function checkSatelliteTimer(satelliteExpected, deps = defaultSatelliteTimerDeps()) {
-  if (!satelliteExpected) {
-    return check("pass", "satellite_job_timer", "Satellite job timer", "Satellite job not expected on this host");
-  }
-  if (deps.platform() !== "linux") {
-    return check("pass", "satellite_job_timer", "Satellite job timer", "Timer check skipped \u2014 Linux only");
-  }
-  const out = deps.systemctlIsActive("agent-memory-trends.timer");
-  if (out === void 0) {
-    return check("pass", "satellite_job_timer", "Satellite job timer", "systemctl unavailable");
+  } catch (e) {
+    try {
+      unlinkSync2(testFile);
+    } catch {
+    }
+    return { success: false, writeMs, readMs: Date.now() - readStart, size: 0, error: `read failed: ${e.message}` };
   }
-  if (out === "active") {
-    return check("pass", "satellite_job_timer", "Satellite job timer", "systemd: agent-memory-trends.timer active");
+  try {
+    unlinkSync2(testFile);
+  } catch {
   }
-  return check(
-    "error",
-    "satellite_job_timer",
-    "Satellite job timer",
-    `systemd: agent-memory-trends.timer is ${out || "not active"}`
-  );
+  return { success: true, writeMs, readMs: Date.now() - readStart, size: Buffer.byteLength(payload, "utf8") };
 }
-async function checkFleetIdentity(input) {
-  if (!input.vaultPath) {
-    return check("pass", "fleet_identity", "Fleet identity", "No vault path \u2014 check skipped");
+var DURATION_UNIT_SECONDS = {
+  ms: 1 / 1e3,
+  s: 1,
+  m: 60,
+  h: 3600,
+  d: 86400,
+  w: 604800
+};
+function parseDurationSeconds(raw) {
+  const input = raw.trim().toLowerCase();
+  if (!input) return null;
+  if (/^\d+(?:\.\d+)?$/.test(input)) {
+    const num = parseFloat(input);
+    return Number.isFinite(num) ? num : null;
   }
-  const load = input.fleetLoad !== void 0 ? input.fleetLoad : await loadFleetManifestAndHost({
-    vault: input.vaultPath,
-    env: { ...process.env, WIKI_PATH: input.envValue ?? input.vaultPath },
-    home: input.home,
-    cwd: input.cwd ?? process.cwd(),
-    osHostname: process.env.HOSTNAME,
-    user: process.env.USER
-  });
-  if (!load) {
-    return check("pass", "fleet_identity", "Fleet identity", "Fleet manifest unavailable \u2014 check skipped");
-  }
-  if (load.identityStatus === "known") {
-    return check("pass", "fleet_identity", "Fleet identity", `Resolved ${load.hostId ?? "unknown"} via ${load.source ?? "unknown"}`);
-  }
-  const detail = load.warnings.length > 0 ? load.warnings.join("; ") : "Fleet identity is unresolved";
-  return check("warn", "fleet_identity", "Fleet identity", detail);
-}
-function pullLogPaths(home) {
-  const paths = platform2() === "darwin" ? [
-    join10(home, "Library", "Logs", "wiki-pull.log"),
-    join10(home, ".local", "state", "vault-sync", "log", "wiki-pull.log")
-  ] : [
-    join10(home, ".local", "state", "vault-sync", "log", "wiki-pull.log"),
-    join10(home, "Library", "Logs", "wiki-pull.log")
-  ];
-  return [...new Set(paths)];
-}
-function isRecentLogLine(line, nowMs) {
-  const match = line.match(/^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z)/);
-  if (!match) return true;
-  const ts = Date.parse(match[1]);
-  if (!Number.isFinite(ts)) return true;
-  return nowMs - ts <= 24 * 60 * 60 * 1e3;
-}
-function checkVaultGitPullFailures(home) {
-  const path = pullLogPaths(home).find((p) => existsSync7(p));
-  if (!path) {
-    return check("pass", "vault_git_pull_failures", "Vault pull failures", "No wiki-pull.log found \u2014 check skipped");
-  }
-  try {
-    const lines = readFileSync6(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)
-    );
-    if (failures.length > 0) {
-      const sample = failures.slice(-2).map((line) => line.slice(0, 100)).join(" | ");
-      return check("warn", "vault_git_pull_failures", "Vault pull failures", `${failures.length} recent pull failure(s): ${sample}`);
-    }
-    return check("pass", "vault_git_pull_failures", "Vault pull failures", "No recent pull failures logged");
-  } catch {
-    return check("warn", "vault_git_pull_failures", "Vault pull failures", `Could not read ${path}`);
+  const re = /(\d+(?:\.\d+)?)(ms|s|m|h|d|w)/g;
+  let total = 0;
+  let consumed = 0;
+  for (const match of input.matchAll(re)) {
+    const full = match[0];
+    const value = parseFloat(match[1]);
+    const unit = match[2];
+    if (!Number.isFinite(value)) return null;
+    const factor = DURATION_UNIT_SECONDS[unit];
+    if (factor === void 0) return null;
+    total += value * factor;
+    consumed += full.length;
   }
+  if (consumed !== input.length) return null;
+  return total;
 }
+var FLAG_THRESHOLDS = {
+  "--vfs-write-back": { min: 15, unit: "s", label: "VFS write-back window" },
+  "--vfs-write-wait": { min: 10, unit: "s", label: "VFS write-wait" },
+  "--vfs-cache-max-age": { min: 24, unit: "h", label: "VFS cache max age" }
+};
+var MIN_RCLONE_VERSION = { major: 1, minor: 65, patch: 0 };
+
+// src/doctor/probes/s3-mount-health.ts
 function checkS3MountPerf(resolvedPath) {
   if (resolvedPath === void 0) {
     return check("pass", "s3_mount_perf", "S3 mount performance", "No vault path \u2014 check skipped");
@@ -2362,14 +2148,14 @@ function checkS3MountPerf(resolvedPath) {
     return check("pass", "s3_mount_perf", "S3 mount performance", "local disk");
   }
   const mountPoint = fuse.mountPoint;
-  const conceptsDir = join10(resolvedPath, "concepts");
-  if (!existsSync7(conceptsDir)) {
+  const conceptsDir = join13(resolvedPath, "concepts");
+  if (!existsSync10(conceptsDir)) {
     return check("pass", "s3_mount_perf", "S3 mount performance", `S3 FUSE mount (${mountPoint}), no concepts/ to benchmark`);
   }
   const start = Date.now();
   let timedOut = false;
   try {
-    execSync2(`rg -l "." "${conceptsDir}"`, {
+    execSync4(`rg -l "." "${conceptsDir}"`, {
       timeout: 5e3,
       encoding: "utf8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -2545,8 +2331,8 @@ function checkWriteTest(resolvedPath) {
   if (!fuse) {
     return check("pass", "s3_write_test", "S3 write test", "local disk \u2014 check skipped");
   }
-  const conceptsDir = join10(resolvedPath, "concepts");
-  if (!existsSync7(conceptsDir)) {
+  const conceptsDir = join13(resolvedPath, "concepts");
+  if (!existsSync10(conceptsDir)) {
     return check("pass", "s3_write_test", "S3 write test", "no concepts/ dir to test \u2014 check skipped");
   }
   const result = writeTest(conceptsDir);
@@ -2630,139 +2416,354 @@ function checkVfsCacheHealth(resolvedPath) {
     `${stats.files} files, ${(stats.bytesUsed / 1024 / 1024).toFixed(1)}MB \u2014 clean (0 errored, 0 pending)`
   );
 }
-function checkVaultSyncPullHelper(home, env) {
-  const path = resolveVaultSyncPullHelper({
-    vault: "",
-    home,
-    env
-  });
-  if (path) {
-    return check("pass", "vault_sync_pull_helper", "Vault-sync pull helper", `Resolved: ${path}`);
-  }
-  return check(
-    "error",
-    "vault_sync_pull_helper",
-    "Vault-sync pull helper",
-    "Not found \u2014 install skillwiki@0.10.1+, redeploy vault-sync, or set SKILLWIKI_VAULT_SYNC_PULL_HELPER"
-  );
-}
-function checkVaultSyncReviewRequiredJournals(vaultPath) {
-  if (!vaultPath || !existsSync7(join10(vaultPath, ".git"))) {
-    return check("pass", "vault_sync_review_required_journals", "Review-required journals", "No git vault \u2014 check skipped");
+var s3MountHealthProbe = {
+  id: "s3_mount_health",
+  run(ctx) {
+    return [
+      checkS3MountPerf(ctx.resolvedPath),
+      checkS3MountFreshness(ctx.resolvedPath),
+      checkRcloneFlagAudit(ctx.resolvedPath),
+      checkRcloneVersion(ctx.resolvedPath, ctx.vsConfig.installed),
+      checkWriteTest(ctx.resolvedPath),
+      checkVfsCacheHealth(ctx.resolvedPath)
+    ];
   }
+};
+
+// src/doctor/probes/skills-plugins.ts
+import { existsSync as existsSync11, readdirSync as readdirSync4, readFileSync as readFileSync6 } from "fs";
+import { join as join14 } from "path";
+function findSkillMd(dir) {
+  const results = [];
+  let entries;
   try {
-    const ops = listReviewRequiredOps(vaultPath);
-    if (ops.length === 0) {
-      return check("pass", "vault_sync_review_required_journals", "Review-required journals", "None");
-    }
-    const sample = ops[0]?.opId ?? "?";
-    return check(
-      "warn",
-      "vault_sync_review_required_journals",
-      "Review-required journals",
-      `${ops.length} handoff(s); oldest/sample: ${sample} \u2014 if worktree clean: skillwiki sync journal clear-stale --dry-run`
-    );
+    entries = readdirSync4(dir, { withFileTypes: true });
   } catch {
-    return check("pass", "vault_sync_review_required_journals", "Review-required journals", "Could not read journals \u2014 check skipped");
+    return results;
+  }
+  for (const entry of entries) {
+    if (entry.isFile() && entry.name === "SKILL.md") {
+      results.push(join14(dir, entry.name));
+    } else if (entry.isDirectory()) {
+      results.push(...findSkillMd(join14(dir, entry.name)));
+    }
   }
+  return results;
 }
-function readVaultSyncConfig(home) {
+function findSkillNames(dir) {
+  const results = [];
+  let entries;
   try {
-    const content = readFileSync6(join10(home, ".skillwiki", ".env"), "utf8");
-    let installed = false;
-    let role;
-    let serviceScope;
-    let snapshotScript;
-    for (const line of content.split(/\r?\n/)) {
-      const trimmed = line.trim();
-      if (trimmed.length === 0 || 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 (v.length === 0) continue;
-      if (k === "vault_sync.installed" && v === "true") installed = true;
-      if (k === "vault_sync.role") role = v;
-      if (k === "vault_sync.service_scope") serviceScope = v;
-      if (k === "vault_sync.snapshot_script") snapshotScript = v;
-    }
-    return { installed, role, serviceScope, snapshotScript };
+    entries = readdirSync4(dir, { withFileTypes: true });
   } catch {
-    return { installed: false };
+    return results;
   }
+  for (const entry of entries) {
+    if (entry.isDirectory() && existsSync11(join14(dir, entry.name, "SKILL.md"))) {
+      results.push(entry.name);
+    }
+  }
+  return results;
 }
-function resolveSnapshotGitWorktree(home) {
-  const configured = resolveConfiguredSnapshotWorktree(home);
-  if (configured) return configured;
-  const defaultPath = "/root/wiki-git";
-  return existsSync7(defaultPath) ? defaultPath : void 0;
-}
-function normalizeSystemdValue(raw) {
-  if (raw == null) return void 0;
-  const v = raw.trim();
-  if (!v || v === "n/a" || v === "N/A") return void 0;
-  return v;
+function findInstalledSkillMd(dir) {
+  const directSkills = findSkillNames(dir).map((name) => join14(dir, name, "SKILL.md"));
+  return directSkills.length > 0 ? directSkills : findSkillMd(dir);
 }
-function hasCompletedRunEvidence(...timestamps) {
-  return timestamps.some((t) => normalizeSystemdValue(t ?? void 0) != null);
+function checkSkillsInstalled(home, cwd) {
+  const srcDir = cwd ? join14(cwd, "packages", "skills") : void 0;
+  if (srcDir && existsSync11(srcDir)) {
+    const found = findInstalledSkillMd(srcDir);
+    if (found.length > 0) {
+      return check("pass", "skills_installed", "Skills installed", `${found.length} SKILL.md file(s) found (source)`);
+    }
+  }
+  const plugin = findPlugin(home);
+  if (plugin) {
+    const found = findInstalledSkillMd(plugin.installPath);
+    if (found.length > 0) {
+      return check("pass", "skills_installed", "Skills installed", `${found.length} SKILL.md file(s) found (plugin v${plugin.version})`);
+    }
+  }
+  const skillsDir = join14(home, ".claude", "skills");
+  if (existsSync11(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)`);
+    }
+  }
+  return check("warn", "skills_installed", "Skills installed", "No SKILL.md files found");
 }
-function loadSnapshotFixture(env) {
-  const path = env.VS_SNAPSHOT_HEALTH_FIXTURE;
-  if (!path || !existsSync7(path)) return null;
-  try {
-    return JSON.parse(readFileSync6(path, "utf8"));
-  } catch {
-    return null;
+function checkDuplicateSkills(home) {
+  const plugin = findPlugin(home);
+  const skillsDir = join14(home, ".claude", "skills");
+  const agentSkillDirs = [
+    { label: "~/.codex/skills/", path: join14(home, ".codex", "skills") },
+    { label: "~/.agents/skills/", path: join14(home, ".agents", "skills") }
+  ];
+  if (!plugin) {
+    return check("pass", "skills_duplicate", "Skills not duplicated", "Single install channel");
+  }
+  const pluginSkills = findSkillNames(plugin.installPath);
+  const cliSkills = findSkillNames(skillsDir);
+  const cliDuplicates = cliSkills.filter((name) => pluginSkills.includes(name));
+  const agentDuplicates = [];
+  for (const { label, path } of agentSkillDirs) {
+    const overlap = findSkillNames(path).filter((name) => pluginSkills.includes(name));
+    if (overlap.length > 0) {
+      agentDuplicates.push({ dir: label, names: overlap });
+    }
+  }
+  if (cliDuplicates.length === 0 && agentDuplicates.length === 0) {
+    return check("pass", "skills_duplicate", "Skills not duplicated", "No overlap between plugin and other channels");
+  }
+  const parts = [];
+  if (cliDuplicates.length > 0) {
+    parts.push(`${cliDuplicates.length} skill(s) in both plugin and ~/.claude/skills/ \u2014 remove CLI copies: rm -r ~/.claude/skills/{${cliDuplicates.slice(0, 3).join(",")}${cliDuplicates.length > 3 ? ",\u2026" : ""}}`);
+  }
+  for (const { dir, names } of agentDuplicates) {
+    parts.push(`${names.length} stale skill(s) in ${dir} \u2014 plugin provides: ${names.slice(0, 3).join(", ")}${names.length > 3 ? ", \u2026" : ""}`);
   }
+  const status = cliDuplicates.length > 0 ? "warn" : "info";
+  return check(status, "skills_duplicate", "Skills not duplicated", parts.join("; "));
 }
-function systemctlShowProperty(scope, unit, prop) {
+var GROK_ACTIVATION_REFERENCE = "Read @~/.grok/skillwiki.md for SkillWiki activation context.";
+var STALE_GROK_ACTIVATION_REFERENCE = "Read @skillwiki.md";
+var ACTIVATION_FIX_HINT = "run `npm run install:activation` from the llm-wiki repo";
+function findGrokActivationTemplate(home, cwd) {
+  if (cwd) {
+    const src = join14(cwd, "packages", "skills", "using-skillwiki", "activation.md");
+    if (existsSync11(src)) return src;
+  }
+  const pluginsRoot = join14(home, ".grok", "installed-plugins");
+  if (!existsSync11(pluginsRoot)) return void 0;
+  let entries;
   try {
-    const cmd = scope === "system" ? `systemctl show ${unit} --property=${prop} --value` : `systemctl --user show ${unit} --property=${prop} --value`;
-    const out = execSync2(cmd, {
-      encoding: "utf8",
-      timeout: 2e3,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    return normalizeSystemdValue(out);
+    entries = readdirSync4(pluginsRoot, { withFileTypes: true });
   } catch {
     return void 0;
   }
-}
-function snapshotProp(kind, prop, fixture, scope) {
-  if (fixture) {
-    const bag = fixture[kind];
-    const v = bag[prop];
-    return v == null ? void 0 : String(v);
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const root = join14(pluginsRoot, entry.name);
+    for (const rel of ["using-skillwiki/activation.md", "skills/using-skillwiki/activation.md"]) {
+      const candidate = join14(root, rel);
+      if (existsSync11(candidate)) return candidate;
+    }
   }
-  const unit = kind === "timer" ? "wiki-snapshot.timer" : "wiki-snapshot.service";
-  const liveProp = systemdPropertyFor(prop);
-  if (!liveProp) return void 0;
-  return systemctlShowProperty(scope, unit, liveProp);
-}
-function parseIsoToMs(ts) {
-  if (!ts || ts === "MISSING") return null;
-  const ms = Date.parse(ts);
-  return Number.isFinite(ms) ? ms : null;
-}
-function ageMinutes(nowMs, tsMs) {
-  if (tsMs == null) return null;
-  return Math.floor((nowMs - tsMs) / 6e4);
+  return void 0;
 }
-function snapshotterHealthChecks(scope, logDir, env) {
-  const fixture = loadSnapshotFixture(env);
-  const cadence = fixture ? fixture.cadence_minutes : parseInt(env.VS_SNAPSHOT_CADENCE_MINUTES ?? "30", 10) || 30;
-  const timeout = fixture ? fixture.service_timeout_seconds : parseInt(env.VS_SNAPSHOT_SERVICE_TIMEOUT_SECONDS ?? "900", 10) || 900;
-  const injectedNowMs = env.VS_SNAPSHOT_HEALTH_NOW ? Date.parse(env.VS_SNAPSHOT_HEALTH_NOW) : Number.NaN;
-  const nowMs = fixture ? Date.parse(fixture.now) : Number.isFinite(injectedNowMs) ? injectedNowMs : Date.now();
-  const warnAge = cadence * 2 + 15;
-  const errorAge = cadence * 4 + 15;
-  const tUnitfile = snapshotProp("timer", "unit_file_state", fixture, scope);
-  const tActive = snapshotProp("timer", "active_state", fixture, scope);
-  const tNext = snapshotProp("timer", "next_elapse", fixture, scope);
-  let jobs;
-  if (tUnitfile == null && tActive == null) {
-    jobs = check("warn", "vault_sync_jobs_enabled", "Vault sync jobs enabled", "wiki-snapshot.timer properties unavailable (read-only)");
-  } else if (tUnitfile === "enabled" && tActive === "active" && tNext) {
+function checkGrokActivation(home, cwd) {
+  const grokDir = join14(home, ".grok");
+  if (!existsSync11(grokDir)) {
+    return check("pass", "activation_grok", "Grok activation", "Not a Grok host");
+  }
+  const activationPath = join14(grokDir, "skillwiki.md");
+  const agentsPath = join14(grokDir, "AGENTS.md");
+  const hasActivation = existsSync11(activationPath);
+  const issues = [];
+  if (!hasActivation) {
+    issues.push("~/.grok/skillwiki.md missing");
+  }
+  if (!existsSync11(agentsPath)) {
+    issues.push("~/.grok/AGENTS.md missing");
+  } else {
+    const agents = readFileSync6(agentsPath, "utf8");
+    const hasBegin = agents.includes("<!-- skillwiki:begin -->");
+    const hasExpected = agents.includes(GROK_ACTIVATION_REFERENCE);
+    const hasStale = agents.includes(STALE_GROK_ACTIVATION_REFERENCE);
+    if (!hasBegin) {
+      issues.push("AGENTS.md marker missing");
+    } else if (hasStale && !hasExpected) {
+      issues.push("AGENTS.md marker is stale (@skillwiki.md)");
+    } else if (!hasExpected) {
+      issues.push("AGENTS.md marker is stale");
+    }
+  }
+  if (hasActivation) {
+    const template = findGrokActivationTemplate(home, cwd);
+    if (template) {
+      try {
+        const installed = readFileSync6(activationPath, "utf8");
+        const expected = readFileSync6(template, "utf8");
+        if (installed !== expected) {
+          issues.push("~/.grok/skillwiki.md differs from template");
+        }
+      } catch {
+      }
+    }
+  }
+  if (issues.length > 0) {
+    return check(
+      "warn",
+      "activation_grok",
+      "Grok activation",
+      `${issues.join("; ")} \u2014 ${ACTIVATION_FIX_HINT}`
+    );
+  }
+  return check("pass", "activation_grok", "Grok activation", "Marker and compact file are current");
+}
+function checkNpmUpdate(home, currentVersion) {
+  const { hasUpdate, latest, distTag } = latestFromCache(home, currentVersion);
+  if (!latest) {
+    return check("pass", "npm_update", "npm CLI version", `v${currentVersion} (${distTag}: no cache yet)`);
+  }
+  if (hasUpdate) {
+    return check("warn", "npm_update", "npm CLI version", `v${currentVersion} \u2014 ${distTag} update available: v${latest}. Run \`skillwiki update --tag ${distTag}\`.`);
+  }
+  return check("pass", "npm_update", "npm CLI version", `v${currentVersion} (${distTag}: v${latest})`);
+}
+function pluginUpdateCommand(plugin, currentVersion) {
+  if (semverGt(plugin.version, currentVersion)) {
+    return "npm install -g skillwiki@latest";
+  }
+  if (plugin.channel === "claude") {
+    return "claude plugin update skillwiki@llm-wiki";
+  }
+  if (plugin.sourceType === "git") {
+    return "codex plugin marketplace upgrade llm-wiki && codex plugin remove skillwiki@llm-wiki && codex plugin add skillwiki@llm-wiki";
+  }
+  return "codex plugin remove skillwiki@llm-wiki && codex plugin add skillwiki@llm-wiki";
+}
+function checkPluginVersionDrift(home, currentVersion, devSourceRun) {
+  const plugins = findPluginInstallations(home);
+  if (plugins.length === 0) {
+    return check("pass", "plugin_version_drift", "Plugin/CLI version", "Plugin not installed \u2014 CLI only");
+  }
+  const drifted = plugins.filter((plugin) => plugin.version !== currentVersion);
+  if (drifted.length === 0) {
+    if (plugins.length === 1 && plugins[0].channel === "claude") {
+      return check("pass", "plugin_version_drift", "Plugin/CLI version", `Both at v${currentVersion}`);
+    }
+    if (plugins.length === 1) {
+      return check("pass", "plugin_version_drift", "Plugin/CLI version", `${plugins[0].label} plugin and CLI both at v${currentVersion}`);
+    }
+    const labels = plugins.map((plugin) => `${plugin.label} plugin`).join(", ");
+    return check("pass", "plugin_version_drift", "Plugin/CLI version", `${labels}, and CLI all at v${currentVersion}`);
+  }
+  if (devSourceRun && drifted.every((plugin) => semverGt(currentVersion, plugin.version))) {
+    const details2 = drifted.map((plugin) => `${plugin.label} plugin v${plugin.version}`).join(", ");
+    return check("info", "plugin_version_drift", "Plugin/CLI version", `Dev source v${currentVersion} is ahead of installed ${details2}`);
+  }
+  const details = drifted.map((plugin) => {
+    const updateCmd = pluginUpdateCommand(plugin, currentVersion);
+    return `${plugin.label} plugin v${plugin.version} \u2260 CLI v${currentVersion} \u2014 run \`${updateCmd}\``;
+  });
+  return check(
+    "warn",
+    "plugin_version_drift",
+    "Plugin/CLI version",
+    details.join("; ")
+  );
+}
+var skillsPluginsProbe = {
+  id: "skills_plugins",
+  run(ctx) {
+    return [
+      checkSkillsInstalled(ctx.input.home, ctx.input.cwd),
+      checkDuplicateSkills(ctx.input.home),
+      checkGrokActivation(ctx.input.home, ctx.input.cwd),
+      checkNpmUpdate(ctx.input.home, ctx.input.currentVersion),
+      checkPluginVersionDrift(ctx.input.home, ctx.input.currentVersion, ctx.devSourceRun)
+    ];
+  }
+};
+
+// src/doctor/probes/vault-sync.ts
+import { existsSync as existsSync12, readFileSync as readFileSync7 } from "fs";
+import { join as join15 } from "path";
+import { execSync as execSync5 } from "child_process";
+import { platform as platform3 } from "os";
+function readVaultSyncConfig(home) {
+  try {
+    const content = readFileSync7(join15(home, ".skillwiki", ".env"), "utf8");
+    let installed = false;
+    let role;
+    let serviceScope;
+    let snapshotScript;
+    for (const line of content.split(/\r?\n/)) {
+      const trimmed = line.trim();
+      if (trimmed.length === 0 || 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 (v.length === 0) continue;
+      if (k === "vault_sync.installed" && v === "true") installed = true;
+      if (k === "vault_sync.role") role = v;
+      if (k === "vault_sync.service_scope") serviceScope = v;
+      if (k === "vault_sync.snapshot_script") snapshotScript = v;
+    }
+    return { installed, role, serviceScope, snapshotScript };
+  } catch {
+    return { installed: false };
+  }
+}
+function normalizeSystemdValue(raw) {
+  if (raw == null) return void 0;
+  const v = raw.trim();
+  if (!v || v === "n/a" || v === "N/A") return void 0;
+  return v;
+}
+function hasCompletedRunEvidence(...timestamps) {
+  return timestamps.some((t) => normalizeSystemdValue(t ?? void 0) != null);
+}
+function loadSnapshotFixture(env) {
+  const path = env.VS_SNAPSHOT_HEALTH_FIXTURE;
+  if (!path || !existsSync12(path)) return null;
+  try {
+    return JSON.parse(readFileSync7(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function systemctlShowProperty(scope, unit, prop) {
+  try {
+    const cmd = scope === "system" ? `systemctl show ${unit} --property=${prop} --value` : `systemctl --user show ${unit} --property=${prop} --value`;
+    const out = execSync5(cmd, {
+      encoding: "utf8",
+      timeout: 2e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return normalizeSystemdValue(out);
+  } catch {
+    return void 0;
+  }
+}
+function snapshotProp(kind, prop, fixture, scope) {
+  if (fixture) {
+    const bag = fixture[kind];
+    const v = bag[prop];
+    return v == null ? void 0 : String(v);
+  }
+  const unit = kind === "timer" ? "wiki-snapshot.timer" : "wiki-snapshot.service";
+  const liveProp = systemdPropertyFor(prop);
+  if (!liveProp) return void 0;
+  return systemctlShowProperty(scope, unit, liveProp);
+}
+function parseIsoToMs(ts) {
+  if (!ts || ts === "MISSING") return null;
+  const ms = Date.parse(ts);
+  return Number.isFinite(ms) ? ms : null;
+}
+function ageMinutes(nowMs, tsMs) {
+  if (tsMs == null) return null;
+  return Math.floor((nowMs - tsMs) / 6e4);
+}
+function snapshotterHealthChecks(scope, logDir, env) {
+  const fixture = loadSnapshotFixture(env);
+  const cadence = fixture ? fixture.cadence_minutes : parseInt(env.VS_SNAPSHOT_CADENCE_MINUTES ?? "30", 10) || 30;
+  const timeout = fixture ? fixture.service_timeout_seconds : parseInt(env.VS_SNAPSHOT_SERVICE_TIMEOUT_SECONDS ?? "900", 10) || 900;
+  const injectedNowMs = env.VS_SNAPSHOT_HEALTH_NOW ? Date.parse(env.VS_SNAPSHOT_HEALTH_NOW) : Number.NaN;
+  const nowMs = fixture ? Date.parse(fixture.now) : Number.isFinite(injectedNowMs) ? injectedNowMs : Date.now();
+  const warnAge = cadence * 2 + 15;
+  const errorAge = cadence * 4 + 15;
+  const tUnitfile = snapshotProp("timer", "unit_file_state", fixture, scope);
+  const tActive = snapshotProp("timer", "active_state", fixture, scope);
+  const tNext = snapshotProp("timer", "next_elapse", fixture, scope);
+  let jobs;
+  if (tUnitfile == null && tActive == null) {
+    jobs = check("warn", "vault_sync_jobs_enabled", "Vault sync jobs enabled", "wiki-snapshot.timer properties unavailable (read-only)");
+  } else if (tUnitfile === "enabled" && tActive === "active" && tNext) {
     jobs = check("pass", "vault_sync_jobs_enabled", "Vault sync jobs enabled", `wiki-snapshot.timer enabled+active, next=${tNext} (${scope})`);
   } else {
     jobs = check("error", "vault_sync_jobs_enabled", "Vault sync jobs enabled", `wiki-snapshot.timer not eligible: unit_file_state=${tUnitfile ?? "missing"} active_state=${tActive ?? "missing"} next_elapse=${tNext ?? "missing"} (${scope})`);
@@ -2797,7 +2798,7 @@ function snapshotterHealthChecks(scope, logDir, env) {
   let completionOutcome = "unknown";
   const logRecords = fixture ? fixture.log_records : (() => {
     try {
-      const content = readFileSync6(join10(logDir, "wiki-snapshot.log"), "utf8");
+      const content = readFileSync7(join15(logDir, "wiki-snapshot.log"), "utf8");
       return content.split(/\r?\n/).filter(Boolean);
     } catch {
       return [];
@@ -2851,7 +2852,7 @@ function snapshotterHealthChecks(scope, logDir, env) {
   return [jobs, serviceResult, freshness, consecutiveFailures];
 }
 function vaultSyncChecks(input) {
-  const os = input.os ?? platform2();
+  const os = input.os ?? platform3();
   const home = input.home;
   if (!input.vaultSyncInstalled) {
     const skip = (id, label) => check("pass", id, label, "vault-sync not installed \u2014 check skipped");
@@ -2867,14 +2868,14 @@ function vaultSyncChecks(input) {
     ];
   }
   const isMac = os === "darwin";
-  const logDir = input.logDir ?? (isMac ? join10(home, "Library", "Logs") : join10(home, ".local", "state", "vault-sync", "log"));
-  const shareDir = input.shareDir ?? (isMac ? join10(home, "Library", "Application Support", "vault-sync", "bin") : join10(home, ".local", "share", "vault-sync", "bin"));
-  const filterPath = input.filterPath ?? join10(home, ".config", "rclone", "wiki-push-filters.txt");
-  const packagedSnapshotPath = join10(shareDir, "wiki-snapshot.sh");
+  const logDir = input.logDir ?? (isMac ? join15(home, "Library", "Logs") : join15(home, ".local", "state", "vault-sync", "log"));
+  const shareDir = input.shareDir ?? (isMac ? join15(home, "Library", "Application Support", "vault-sync", "bin") : join15(home, ".local", "share", "vault-sync", "bin"));
+  const filterPath = input.filterPath ?? join15(home, ".config", "rclone", "wiki-push-filters.txt");
+  const packagedSnapshotPath = join15(shareDir, "wiki-snapshot.sh");
   const legacySnapshotPath = "/root/.hermes/scripts/wiki-snapshot-v3.sh";
-  const snapshotPath = input.snapshotScriptPath ?? (existsSync7(packagedSnapshotPath) ? packagedSnapshotPath : legacySnapshotPath);
+  const snapshotPath = input.snapshotScriptPath ?? (existsSync12(packagedSnapshotPath) ? packagedSnapshotPath : legacySnapshotPath);
   if (input.vaultSyncRole === "snapshotter") {
-    const c12 = existsSync7(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 = existsSync12(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 healthChecks = snapshotterHealthChecks(serviceScope, logDir, input.env ?? process.env);
     const cFetch2 = check(
@@ -2891,7 +2892,7 @@ function vaultSyncChecks(input) {
     );
     let c52;
     try {
-      if (!existsSync7(snapshotPath)) {
+      if (!existsSync12(snapshotPath)) {
         c52 = check(
           "error",
           "vault_sync_snapshot_guard",
@@ -2899,7 +2900,7 @@ function vaultSyncChecks(input) {
           `Snapshot script not found at ${snapshotPath}`
         );
       } else {
-        const content = readFileSync6(snapshotPath, "utf8");
+        const content = readFileSync7(snapshotPath, "utf8");
         if (!content.includes("--max-delete")) {
           c52 = check(
             "error",
@@ -2926,18 +2927,18 @@ function vaultSyncChecks(input) {
     }
     return [c12, ...healthChecks, cFetch2, c42, c52];
   }
-  const pushScriptPath = join10(shareDir, "wiki-push.sh");
-  const c1 = existsSync7(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 = join15(shareDir, "wiki-push.sh");
+  const c1 = existsSync12(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) {
-      const uidStr = execSync2("id -u", {
+      const uidStr = execSync5("id -u", {
         encoding: "utf8",
         timeout: 2e3,
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
       const uid = parseInt(uidStr, 10);
-      execSync2(`launchctl print gui/${uid}/com.karlchow.wiki-push`, {
+      execSync5(`launchctl print gui/${uid}/com.karlchow.wiki-push`, {
         encoding: "utf8",
         timeout: 2e3,
         stdio: ["pipe", "ignore", "ignore"]
@@ -2949,7 +2950,7 @@ function vaultSyncChecks(input) {
         "launchd: com.karlchow.wiki-push loaded"
       );
     } else {
-      const out = execSync2("systemctl --user is-enabled wiki-push.timer", {
+      const out = execSync5("systemctl --user is-enabled wiki-push.timer", {
         encoding: "utf8",
         timeout: 2e3,
         stdio: ["pipe", "pipe", "pipe"]
@@ -2978,10 +2979,10 @@ function vaultSyncChecks(input) {
       "Scheduler check failed \u2014 run vault-sync-install"
     );
   }
-  const logFile = join10(logDir, "wiki-push.log");
+  const logFile = join15(logDir, "wiki-push.log");
   let c3;
   try {
-    const logContent = readFileSync6(logFile, "utf8");
+    const logContent = readFileSync7(logFile, "utf8");
     const lines = logContent.trim().split("\n").filter(Boolean);
     if (lines.length === 0) {
       c3 = check(
@@ -3037,7 +3038,7 @@ function vaultSyncChecks(input) {
       }
     }
   } catch {
-    c3 = existsSync7(logDir) ? check(
+    c3 = existsSync12(logDir) ? check(
       "warn",
       "vault_sync_last_push_age",
       "Vault sync last push recency",
@@ -3049,10 +3050,10 @@ function vaultSyncChecks(input) {
       `Log directory not found at ${logDir}`
     );
   }
-  const fetchLogFile = join10(logDir, "wiki-fetch.log");
+  const fetchLogFile = join15(logDir, "wiki-fetch.log");
   let cFetch;
   try {
-    const logContent = readFileSync6(fetchLogFile, "utf8");
+    const logContent = readFileSync7(fetchLogFile, "utf8");
     const lines = logContent.trim().split("\n").filter(Boolean);
     if (lines.length === 0) {
       cFetch = check(
@@ -3096,7 +3097,7 @@ function vaultSyncChecks(input) {
   }
   let c4;
   try {
-    if (!existsSync7(filterPath)) {
+    if (!existsSync12(filterPath)) {
       c4 = check(
         "error",
         "vault_sync_filter_present",
@@ -3104,7 +3105,7 @@ function vaultSyncChecks(input) {
         `Filter file not found at ${filterPath}`
       );
     } else {
-      const content = readFileSync6(filterPath, "utf8");
+      const content = readFileSync7(filterPath, "utf8");
       const requiredExcludes = [
         "remotely-save/data.json",
         ".skillwiki/sync.lock",
@@ -3147,7 +3148,7 @@ function vaultSyncChecks(input) {
     );
   } else {
     try {
-      if (!existsSync7(snapshotPath)) {
+      if (!existsSync12(snapshotPath)) {
         c5 = check(
           "error",
           "vault_sync_snapshot_guard",
@@ -3155,7 +3156,7 @@ function vaultSyncChecks(input) {
           `Snapshot script not found at ${snapshotPath}`
         );
       } else {
-        const content = readFileSync6(snapshotPath, "utf8");
+        const content = readFileSync7(snapshotPath, "utf8");
         if (!content.includes("--max-delete")) {
           c5 = check(
             "error",
@@ -3183,199 +3184,633 @@ function vaultSyncChecks(input) {
   }
   return [c1, c2, c3, cFetch, c4, c5];
 }
-function findSkillMd(dir) {
-  const results = [];
-  let entries;
+function checkVaultSyncPullHelper(home, env) {
+  const path = resolveVaultSyncPullHelper({
+    vault: "",
+    home,
+    env
+  });
+  if (path) {
+    return check("pass", "vault_sync_pull_helper", "Vault-sync pull helper", `Resolved: ${path}`);
+  }
+  return check(
+    "error",
+    "vault_sync_pull_helper",
+    "Vault-sync pull helper",
+    "Not found \u2014 install skillwiki@0.10.1+, redeploy vault-sync, or set SKILLWIKI_VAULT_SYNC_PULL_HELPER"
+  );
+}
+function checkVaultSyncReviewRequiredJournals(vaultPath) {
+  if (!vaultPath || !existsSync12(join15(vaultPath, ".git"))) {
+    return check("pass", "vault_sync_review_required_journals", "Review-required journals", "No git vault \u2014 check skipped");
+  }
   try {
-    entries = readdirSync3(dir, { withFileTypes: true });
+    const ops = listReviewRequiredOps(vaultPath);
+    if (ops.length === 0) {
+      return check("pass", "vault_sync_review_required_journals", "Review-required journals", "None");
+    }
+    const sample = ops[0]?.opId ?? "?";
+    return check(
+      "warn",
+      "vault_sync_review_required_journals",
+      "Review-required journals",
+      `${ops.length} handoff(s); oldest/sample: ${sample} \u2014 if worktree clean: skillwiki sync journal clear-stale --dry-run`
+    );
   } catch {
-    return results;
+    return check("pass", "vault_sync_review_required_journals", "Review-required journals", "Could not read journals \u2014 check skipped");
+  }
+}
+var vaultSyncProbe = {
+  id: "vault_sync",
+  run(ctx) {
+    const checks = [];
+    checks.push(...vaultSyncChecks({
+      home: ctx.input.home,
+      vaultSyncInstalled: ctx.vsConfig.installed,
+      vaultSyncRole: ctx.vsConfig.role,
+      vaultSyncServiceScope: ctx.vsConfig.serviceScope,
+      snapshotScriptPath: ctx.vsConfig.snapshotScript,
+      env: ctx.input.env ?? process.env
+    }));
+    checks.push(checkVaultSyncPullHelper(ctx.input.home, ctx.input.env ?? process.env));
+    checks.push(checkVaultSyncReviewRequiredJournals(ctx.resolvedPath));
+    return checks;
+  }
+};
+
+// src/doctor/probes/satellite.ts
+import { existsSync as existsSync14 } from "fs";
+import { execSync as execSync6 } from "child_process";
+import { platform as platform4 } from "os";
+
+// src/utils/satellite-run-health.ts
+import { existsSync as existsSync13, readFileSync as readFileSync8 } from "fs";
+import { join as join16 } from "path";
+var SATELLITE_STALE_MS = 26 * 60 * 60 * 1e3;
+function satelliteLatestRunPath(vault) {
+  return join16(vault, ".skillwiki", "agent-memory-trends", "latest-run.json");
+}
+function isFailedRunStatus(status) {
+  return status === "fail" || status === "failure";
+}
+function parseLatestRunFile(text) {
+  try {
+    const parsed = JSON.parse(text);
+    const status = typeof parsed.status === "string" ? parsed.status : "";
+    if (!status) return null;
+    const finishedAt = typeof parsed.finished_at === "string" && parsed.finished_at.length > 0 ? parsed.finished_at : void 0;
+    const failureClass = parsed.failure_class != null && String(parsed.failure_class).length > 0 ? String(parsed.failure_class) : void 0;
+    return { status, finishedAt, failureClass };
+  } catch {
+    return null;
+  }
+}
+function readSatelliteLatestRunFromText(text) {
+  return parseLatestRunFile(text);
+}
+function readSatelliteLatestRun(vault) {
+  const latestPath = satelliteLatestRunPath(vault);
+  if (!existsSync13(latestPath)) return null;
+  try {
+    return parseLatestRunFile(readFileSync8(latestPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function evaluateSatelliteRunHealth(vault, now) {
+  const run = readSatelliteLatestRun(vault);
+  if (!run) {
+    return { failed: false, stale: false };
+  }
+  const failed = isFailedRunStatus(run.status);
+  let stale = false;
+  if (!failed && run.finishedAt) {
+    const ts = Date.parse(run.finishedAt);
+    if (Number.isFinite(ts) && now.getTime() - ts > SATELLITE_STALE_MS) {
+      stale = true;
+    }
+  }
+  return {
+    failed,
+    stale,
+    failureClass: run.failureClass,
+    finishedAt: run.finishedAt
+  };
+}
+
+// src/doctor/probes/satellite.ts
+function checkSatelliteLastRun(vaultPath, satelliteExpected) {
+  if (!satelliteExpected) {
+    return check("pass", "satellite_job_last_run", "Satellite job last run", "Satellite job not expected on this host");
+  }
+  if (vaultPath === void 0) {
+    return check("pass", "satellite_job_last_run", "Satellite job last run", "No vault path \u2014 check skipped");
+  }
+  const latestPath = satelliteLatestRunPath(vaultPath);
+  if (!existsSync14(latestPath)) {
+    return check("pass", "satellite_job_last_run", "Satellite job last run", "No latest-run.json \u2014 satellite has not run yet");
+  }
+  try {
+    const health = evaluateSatelliteRunHealth(vaultPath, /* @__PURE__ */ new Date());
+    if (health.failed) {
+      const fc = health.failureClass;
+      const detail = fc ? `Last satellite run failed (failure_class: ${fc})` : "Last satellite run failed";
+      return check("error", "satellite_job_last_run", "Satellite job last run", detail);
+    }
+    if (health.stale && health.finishedAt) {
+      return check(
+        "warn",
+        "satellite_job_last_run",
+        "Satellite job last run",
+        `Last run finished_at is older than 26h (${health.finishedAt})`
+      );
+    }
+    return check(
+      "pass",
+      "satellite_job_last_run",
+      "Satellite job last run",
+      health.finishedAt ? `Last run ok (finished_at ${health.finishedAt})` : "Last run ok"
+    );
+  } catch {
+    return check("warn", "satellite_job_last_run", "Satellite job last run", `Could not read ${latestPath}`);
+  }
+}
+function defaultSatelliteTimerDeps() {
+  return {
+    platform: () => platform4(),
+    systemctlIsActive: (unit) => {
+      try {
+        return execSync6(`systemctl is-active ${unit}`, {
+          encoding: "utf8",
+          timeout: 2e3,
+          stdio: ["pipe", "pipe", "pipe"]
+        }).trim();
+      } catch {
+        return void 0;
+      }
+    }
+  };
+}
+function checkSatelliteTimer(satelliteExpected, deps = defaultSatelliteTimerDeps()) {
+  if (!satelliteExpected) {
+    return check("pass", "satellite_job_timer", "Satellite job timer", "Satellite job not expected on this host");
+  }
+  if (deps.platform() !== "linux") {
+    return check("pass", "satellite_job_timer", "Satellite job timer", "Timer check skipped \u2014 Linux only");
+  }
+  const out = deps.systemctlIsActive("agent-memory-trends.timer");
+  if (out === void 0) {
+    return check("pass", "satellite_job_timer", "Satellite job timer", "systemctl unavailable");
+  }
+  if (out === "active") {
+    return check("pass", "satellite_job_timer", "Satellite job timer", "systemd: agent-memory-trends.timer active");
+  }
+  return check(
+    "error",
+    "satellite_job_timer",
+    "Satellite job timer",
+    `systemd: agent-memory-trends.timer is ${out || "not active"}`
+  );
+}
+var satelliteProbe = {
+  id: "satellite",
+  run(ctx) {
+    return [
+      checkSatelliteLastRun(ctx.resolvedPath, ctx.satelliteGate.satelliteExpected),
+      checkSatelliteTimer(ctx.satelliteGate.satelliteExpected)
+    ];
+  }
+};
+
+// src/doctor/probes/metrics.ts
+import { readFileSync as readFileSync9 } from "fs";
+import { join as join17 } from "path";
+var METRIC_TYPES = ["entities", "concepts", "comparisons", "queries", "meta"];
+function doctorReadOnlyScanRoot(resolvedPath) {
+  return resolveReadOnlyVaultRoot(resolvedPath).root;
+}
+async function vaultMetrics(resolvedPath) {
+  const ids = [
+    ["vault_metric_pages", "Vault pages by type"],
+    ["vault_metric_orphans", "Vault orphan rate"],
+    ["vault_metric_bridges", "Vault bridge count"],
+    ["vault_metric_cohesion", "Mean community cohesion"],
+    ["vault_metric_log_size", "Vault log size"]
+  ];
+  const noVault = () => ids.map(([id, label]) => check("info", id, label, "no vault configured"));
+  if (!resolvedPath) return noVault();
+  const scanRoot = doctorReadOnlyScanRoot(resolvedPath);
+  const scan = await scanVault(scanRoot);
+  if (!scan.ok) return noVault();
+  const tk = scan.data.typedKnowledge;
+  const typedCount = tk.length;
+  const perType = METRIC_TYPES.map((d) => `${d} ${tk.filter((p) => p.relPath.startsWith(d + "/")).length}`).join(", ");
+  const adj = await buildWikilinkAdjacency(tk, void 0, scan.data.allMarkdown);
+  const g = toUndirectedWeighted(adj);
+  const nodes = [...g.keys()];
+  const total = nodes.length;
+  const orphanCount = nodes.filter((n) => g.get(n).size === 0).length;
+  const orphanRate = total > 0 ? Math.round(orphanCount / total * 1e3) / 10 : 0;
+  const comm = louvain(g);
+  const groups = /* @__PURE__ */ new Map();
+  for (const [node, c] of comm) {
+    const arr = groups.get(c);
+    if (arr) arr.push(node);
+    else groups.set(c, [node]);
+  }
+  const cohesions = [...groups.values()].filter((m) => m.length >= 2).map((m) => communityCohesion(m, g));
+  const meanCohesion = cohesions.length > 0 ? Math.round(cohesions.reduce((a, b) => a + b, 0) / cohesions.length * 1e3) / 1e3 : 0;
+  let bridges = 0;
+  for (const n of nodes) {
+    const nbrComms = /* @__PURE__ */ new Set();
+    for (const nb of g.get(n).keys()) nbrComms.add(comm.get(nb));
+    if (nbrComms.size >= 3) bridges++;
+  }
+  let logLines = 0;
+  try {
+    logLines = readFileSync9(join17(scanRoot, "log.md"), "utf8").split("\n").length;
+  } catch {
+  }
+  return [
+    check("info", "vault_metric_pages", "Vault pages by type", `${total} graph node(s) (${typedCount} typed; ${perType})`),
+    check("info", "vault_metric_orphans", "Vault orphan rate", `${orphanRate}% (${orphanCount}/${total} degree-0)`),
+    check("info", "vault_metric_bridges", "Vault bridge count", `${bridges} page(s) link >= 3 communities`),
+    check("info", "vault_metric_cohesion", "Mean community cohesion", `${meanCohesion} across ${cohesions.length} communities (size >= 2)`),
+    check("info", "vault_metric_log_size", "Vault log size", `${logLines} lines`)
+  ];
+}
+var metricsProbe = {
+  id: "metrics",
+  async run(ctx) {
+    return await vaultMetrics(ctx.resolvedPath);
+  }
+};
+
+// src/doctor/probes/fuse-staleness.ts
+import { platform as platform5 } from "os";
+var MAX_DIR_CACHE_TIME_SECONDS2 = 15 * 60;
+function defaultFuseStalenessDeps() {
+  return {
+    platform: () => platform5(),
+    detectFuseMount: (vp) => detectFuseMount(vp),
+    findRcloneMountPid: () => findRcloneMountPid(),
+    parseRcloneFlags: (pid) => parseRcloneFlags(pid),
+    getRcloneArgs: (pid) => getRcloneArgs(pid),
+    queryRcloneRC: (rcAddr, fs) => queryRcloneRC(rcAddr, fs)
+  };
+}
+function formatDurationForHumans2(seconds) {
+  if (!Number.isFinite(seconds)) return `${seconds}s`;
+  if (seconds >= 3600) return `${(seconds / 3600).toFixed(1)}h`;
+  if (seconds >= 60) return `${(seconds / 60).toFixed(1)}m`;
+  if (seconds >= 1) return `${seconds.toFixed(1)}s`;
+  return `${Math.round(seconds * 1e3)}ms`;
+}
+function checkFuseStaleness(resolvedPath, deps = {}) {
+  const resolvedDeps = { ...defaultFuseStalenessDeps(), ...deps };
+  const os = resolvedDeps.platform();
+  if (os !== "linux") {
+    return check(
+      "pass",
+      "fuse_staleness",
+      "FUSE visibility freshness",
+      `Non-Linux host (${os}) \u2014 check skipped`
+    );
+  }
+  if (!resolvedPath) {
+    return check(
+      "pass",
+      "fuse_staleness",
+      "FUSE visibility freshness",
+      "No vault path \u2014 check skipped"
+    );
+  }
+  const fuse = resolvedDeps.detectFuseMount(resolvedPath);
+  if (!fuse) {
+    return check(
+      "pass",
+      "fuse_staleness",
+      "FUSE visibility freshness",
+      "local disk (non-FUSE) \u2014 check skipped"
+    );
+  }
+  const pid = resolvedDeps.findRcloneMountPid();
+  if (pid === null) {
+    return check(
+      "warn",
+      "fuse_staleness",
+      "FUSE visibility freshness",
+      `S3 FUSE mount (${fuse.mountPoint}) but no rclone process found \u2014 cannot audit dir-cache freshness`
+    );
+  }
+  const flags = resolvedDeps.parseRcloneFlags(pid);
+  const rawDirCache = flags.get("--dir-cache-time");
+  let dirCachePassed = true;
+  let dirCacheDetail = "";
+  if (!rawDirCache) {
+    dirCacheDetail = "PID " + pid + ": --dir-cache-time not set (rclone default 5m, within <=15m SLA)";
+  } else {
+    const seconds = parseDurationSeconds(rawDirCache);
+    if (seconds === null) {
+      return check(
+        "warn",
+        "fuse_staleness",
+        "FUSE visibility freshness",
+        `PID ${pid}: could not parse --dir-cache-time=${rawDirCache}`
+      );
+    }
+    if (seconds > MAX_DIR_CACHE_TIME_SECONDS2) {
+      dirCachePassed = false;
+      dirCacheDetail = `PID ${pid}: --dir-cache-time=${rawDirCache} (${formatDurationForHumans2(seconds)}) exceeds 15m SLA \u2014 external changes may remain invisible`;
+    } else {
+      dirCacheDetail = `PID ${pid}: --dir-cache-time=${rawDirCache} (${formatDurationForHumans2(seconds)}), within <=15m SLA`;
+    }
+  }
+  if (!dirCachePassed) {
+    return check("warn", "fuse_staleness", "FUSE visibility freshness", dirCacheDetail);
+  }
+  if (flags.has("--rc")) {
+    const rcAddr = flags.get("--rc-addr") || "127.0.0.1:5572";
+    const args = resolvedDeps.getRcloneArgs(pid);
+    const fs = extractRcloneFs(args) || "unknown:";
+    const stats = resolvedDeps.queryRcloneRC(rcAddr, fs);
+    if (stats) {
+      if (stats.error) {
+        return check("warn", "fuse_staleness", "FUSE visibility freshness", `${dirCacheDetail}; RC query error: ${stats.error}`);
+      }
+      const issues = [];
+      if (stats.uploadsInProgress > 0) issues.push(`${stats.uploadsInProgress} upload(s) in progress`);
+      if (stats.uploadsQueued > 10) issues.push(`${stats.uploadsQueued} upload(s) queued (backlog)`);
+      if (stats.erroredFiles > 0) issues.push(`${stats.erroredFiles} errored file(s)`);
+      if (stats.outOfSpace) issues.push("cache disk full");
+      if (issues.length > 0) {
+        return check(
+          "warn",
+          "fuse_staleness",
+          "FUSE visibility freshness",
+          `${dirCacheDetail}; VFS cache degradation: ${issues.join(", ")}`
+        );
+      }
+    }
+  }
+  return check("pass", "fuse_staleness", "FUSE visibility freshness", dirCacheDetail);
+}
+var fuseStalenessProbe = {
+  id: "fuse_staleness",
+  run(ctx) {
+    return [checkFuseStaleness(ctx.resolvedPath)];
+  }
+};
+
+// src/doctor/probes/activation-marker.ts
+import { existsSync as existsSync15, readFileSync as readFileSync10, readdirSync as readdirSync5 } from "fs";
+import { join as join18 } from "path";
+var GROK_ACTIVATION_REFERENCE2 = "Read @~/.grok/skillwiki.md for SkillWiki activation context.";
+var STALE_GROK_ACTIVATION_REFERENCE2 = "Read @skillwiki.md";
+var ACTIVATION_FIX_HINT2 = "run `npm run install:activation` from the llm-wiki repo";
+function findGrokActivationTemplate2(home, cwd) {
+  if (cwd) {
+    const src = join18(cwd, "packages", "skills", "using-skillwiki", "activation.md");
+    if (existsSync15(src)) return src;
+    const directSrc = join18(cwd, "skills", "using-skillwiki", "activation.md");
+    if (existsSync15(directSrc)) return directSrc;
+  }
+  const pluginsRoot = join18(home, ".grok", "installed-plugins");
+  if (!existsSync15(pluginsRoot)) return void 0;
+  let entries;
+  try {
+    entries = readdirSync5(pluginsRoot, { withFileTypes: true });
+  } catch {
+    return void 0;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const root = join18(pluginsRoot, entry.name);
+    for (const rel of ["using-skillwiki/activation.md", "skills/using-skillwiki/activation.md"]) {
+      const candidate = join18(root, rel);
+      if (existsSync15(candidate)) return candidate;
+    }
+  }
+  return void 0;
+}
+function checkActivationMarker(home, cwd) {
+  const grokDir = join18(home, ".grok");
+  if (!existsSync15(grokDir)) {
+    return check("pass", "activation_marker", "Activation marker", "Not a Grok host \u2014 check skipped");
+  }
+  const activationPath = join18(grokDir, "skillwiki.md");
+  const agentsPath = join18(grokDir, "AGENTS.md");
+  const hasActivation = existsSync15(activationPath);
+  const issues = [];
+  if (!hasActivation) {
+    issues.push("~/.grok/skillwiki.md missing");
+  }
+  if (!existsSync15(agentsPath)) {
+    issues.push("~/.grok/AGENTS.md missing");
+  } else {
+    try {
+      const agents = readFileSync10(agentsPath, "utf8");
+      const hasBegin = agents.includes("<!-- skillwiki:begin -->");
+      const hasExpected = agents.includes(GROK_ACTIVATION_REFERENCE2);
+      const hasStale = agents.includes(STALE_GROK_ACTIVATION_REFERENCE2);
+      if (!hasBegin) {
+        issues.push("AGENTS.md marker missing");
+      } else if (hasStale && !hasExpected) {
+        issues.push("AGENTS.md marker is stale (@skillwiki.md)");
+      } else if (!hasExpected) {
+        issues.push("AGENTS.md marker is stale");
+      }
+    } catch {
+      issues.push("could not read ~/.grok/AGENTS.md");
+    }
+  }
+  if (hasActivation) {
+    const template = findGrokActivationTemplate2(home, cwd);
+    if (template) {
+      try {
+        const installed = readFileSync10(activationPath, "utf8");
+        const expected = readFileSync10(template, "utf8");
+        if (installed !== expected) {
+          issues.push("~/.grok/skillwiki.md differs from template");
+        }
+      } catch {
+      }
+    }
+  }
+  if (issues.length > 0) {
+    return check(
+      "warn",
+      "activation_marker",
+      "Activation marker",
+      `${issues.join("; ")} \u2014 ${ACTIVATION_FIX_HINT2}`
+    );
+  }
+  return check("pass", "activation_marker", "Activation marker", "Marker and compact file match home-path contract");
+}
+var activationMarkerProbe = {
+  id: "activation_marker",
+  run(ctx) {
+    return [checkActivationMarker(ctx.input.home, ctx.input.cwd)];
+  }
+};
+
+// src/doctor/probes/ds-store-noise.ts
+import { existsSync as existsSync16, readdirSync as readdirSync6 } from "fs";
+import { join as join19 } from "path";
+var VAULT_TRACKED_DIRS = ["raw", "entities", "concepts", "comparisons", "queries", "meta", "_archive", "_Templates"];
+function checkDsStoreNoise(resolvedPath) {
+  if (resolvedPath === void 0) {
+    return check("pass", "ds_store_noise", "No .DS_Store noise", "No vault path \u2014 check skipped");
+  }
+  if (!existsSync16(resolvedPath)) {
+    return check("pass", "ds_store_noise", "No .DS_Store noise", "Vault directory does not exist \u2014 check skipped");
+  }
+  const found = [];
+  function walk(dir, rel) {
+    let entries;
+    try {
+      entries = readdirSync6(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name === ".DS_Store") {
+        found.push(rel ? `${rel}/.DS_Store` : ".DS_Store");
+      } else if (entry.isDirectory()) {
+        if (entry.name === ".git" || entry.name === "node_modules") continue;
+        walk(join19(dir, entry.name), rel ? `${rel}/${entry.name}` : entry.name);
+      }
+    }
   }
-  for (const entry of entries) {
-    if (entry.isFile() && entry.name === "SKILL.md") {
-      results.push(join10(dir, entry.name));
-    } else if (entry.isDirectory()) {
-      results.push(...findSkillMd(join10(dir, entry.name)));
+  let scannedAny = false;
+  for (const sub of VAULT_TRACKED_DIRS) {
+    const subDir = join19(resolvedPath, sub);
+    if (existsSync16(subDir)) {
+      scannedAny = true;
+      walk(subDir, sub);
     }
   }
-  return results;
-}
-function findInstalledSkillMd(dir) {
-  const directSkills = findSkillNames(dir).map((name) => join10(dir, name, "SKILL.md"));
-  return directSkills.length > 0 ? directSkills : findSkillMd(dir);
-}
-function findSkillNames(dir) {
-  const results = [];
-  let entries;
-  try {
-    entries = readdirSync3(dir, { withFileTypes: true });
-  } catch {
-    return results;
+  if (!scannedAny) {
+    walk(resolvedPath, "");
   }
-  for (const entry of entries) {
-    if (entry.isDirectory() && existsSync7(join10(dir, entry.name, "SKILL.md"))) {
-      results.push(entry.name);
-    }
+  if (found.length === 0) {
+    return check("pass", "ds_store_noise", "No .DS_Store noise", "No .DS_Store files found in vault");
   }
-  return results;
+  const examples = found.slice(0, 3).join(", ");
+  const more = found.length > 3 ? ", \u2026" : "";
+  return check(
+    "warn",
+    "ds_store_noise",
+    "No .DS_Store noise",
+    `${found.length} .DS_Store file(s) found (${examples}${more}) \u2014 remove with: find ${resolvedPath} -name .DS_Store -delete`
+  );
 }
-var METRIC_TYPES = ["entities", "concepts", "comparisons", "queries", "meta"];
-function doctorReadOnlyScanRoot(resolvedPath) {
-  return resolveReadOnlyVaultRoot(resolvedPath).root;
+var dsStoreNoiseProbe = {
+  id: "ds_store_noise",
+  run(ctx) {
+    return [checkDsStoreNoise(ctx.readOnlyScanRoot ?? ctx.resolvedPath)];
+  }
+};
+
+// src/doctor/probes/index.ts
+var DOCTOR_PROBES = [
+  environmentProbe,
+  vaultStructureProbe,
+  gitFleetProbe,
+  hygieneProbe,
+  s3MountHealthProbe,
+  skillsPluginsProbe,
+  vaultSyncProbe,
+  satelliteProbe,
+  metricsProbe,
+  fuseStalenessProbe,
+  activationMarkerProbe,
+  dsStoreNoiseProbe
+];
+
+// src/doctor/runner.ts
+function isDevSourceRun(argv) {
+  return argv.length >= 2 && argv[1].endsWith("cli.js");
 }
-async function vaultMetrics(resolvedPath) {
-  const ids = [
-    ["vault_metric_pages", "Vault pages by type"],
-    ["vault_metric_orphans", "Vault orphan rate"],
-    ["vault_metric_bridges", "Vault bridge count"],
-    ["vault_metric_cohesion", "Mean community cohesion"],
-    ["vault_metric_log_size", "Vault log size"]
-  ];
-  const noVault = () => ids.map(([id, label]) => check("info", id, label, "no vault configured"));
-  if (!resolvedPath) return noVault();
-  const scanRoot = doctorReadOnlyScanRoot(resolvedPath);
-  const scan = await scanVault(scanRoot);
-  if (!scan.ok) return noVault();
-  const tk = scan.data.typedKnowledge;
-  const typedCount = tk.length;
-  const perType = METRIC_TYPES.map((d) => `${d} ${tk.filter((p) => p.relPath.startsWith(d + "/")).length}`).join(", ");
-  const adj = await buildWikilinkAdjacency(tk, void 0, scan.data.allMarkdown);
-  const g = toUndirectedWeighted(adj);
-  const nodes = [...g.keys()];
-  const total = nodes.length;
-  const orphanCount = nodes.filter((n) => g.get(n).size === 0).length;
-  const orphanRate = total > 0 ? Math.round(orphanCount / total * 1e3) / 10 : 0;
-  const comm = louvain(g);
-  const groups = /* @__PURE__ */ new Map();
-  for (const [node, c] of comm) {
-    const arr = groups.get(c);
-    if (arr) arr.push(node);
-    else groups.set(c, [node]);
+function resolveSnapshotGitWorktree(home) {
+  const configured = resolveConfiguredSnapshotWorktree(home);
+  if (configured) return configured;
+  const defaultPath = "/root/wiki-git";
+  return existsSync17(defaultPath) ? defaultPath : void 0;
+}
+var DoctorRunner = class {
+  probes;
+  constructor(probes = DOCTOR_PROBES) {
+    this.probes = probes;
   }
-  const cohesions = [...groups.values()].filter((m) => m.length >= 2).map((m) => communityCohesion(m, g));
-  const meanCohesion = cohesions.length > 0 ? Math.round(cohesions.reduce((a, b) => a + b, 0) / cohesions.length * 1e3) / 1e3 : 0;
-  let bridges = 0;
-  for (const n of nodes) {
-    const nbrComms = /* @__PURE__ */ new Set();
-    for (const nb of g.get(n).keys()) nbrComms.add(comm.get(nb));
-    if (nbrComms.size >= 3) bridges++;
+  getRegisteredProbes() {
+    return this.probes;
   }
-  let logLines = 0;
-  try {
-    logLines = readFileSync6(join10(scanRoot, "log.md"), "utf8").split("\n").length;
-  } catch {
+  async run(input) {
+    const devSourceRun = isDevSourceRun(input.argv);
+    const vsConfig = readVaultSyncConfig(input.home);
+    const resolved = await resolveRuntimePath({
+      flag: void 0,
+      envValue: input.envValue,
+      home: input.home,
+      cwd: input.cwd
+    });
+    const resolvedPath = resolved.ok ? resolved.data.path : void 0;
+    const gitCheckPath = vsConfig.role === "snapshotter" ? resolveSnapshotGitWorktree(input.home) ?? resolvedPath : resolvedPath;
+    const fleetLoad = resolvedPath ? await loadFleetManifestAndHost({
+      vault: resolvedPath,
+      env: { ...process.env, WIKI_PATH: input.envValue ?? resolvedPath },
+      home: input.home,
+      cwd: input.cwd,
+      osHostname: process.env.HOSTNAME,
+      user: process.env.USER
+    }) : null;
+    const satelliteGate = satelliteGateFromFleetLoad(fleetLoad);
+    const readOnlyScanRoot = resolvedPath ? doctorReadOnlyScanRoot(resolvedPath) : void 0;
+    const ctx = {
+      input,
+      devSourceRun,
+      vsConfig,
+      resolvedPath,
+      wikiPathSource: resolved.ok ? resolved.data.source : void 0,
+      gitCheckPath,
+      fleetLoad,
+      readOnlyScanRoot,
+      satelliteGate
+    };
+    const checks = [];
+    for (const probe of this.probes) {
+      const probeChecks = await probe.run(ctx);
+      checks.push(...probeChecks);
+    }
+    const summary = {
+      pass: checks.filter((c) => c.status === "pass").length,
+      info: checks.filter((c) => c.status === "info").length,
+      warn: checks.filter((c) => c.status === "warn").length,
+      error: checks.filter((c) => c.status === "error").length
+    };
+    const exitCode = summary.error > 0 ? ExitCode.DOCTOR_HAS_ERRORS : summary.warn > 0 ? ExitCode.DOCTOR_HAS_WARNINGS : ExitCode.OK;
+    const statusIcon = { pass: "\u2713", info: "i", warn: "\u26A0", error: "\u2717" };
+    const lines = checks.map((c) => {
+      const icon = statusIcon[c.status];
+      const padded = c.label.padEnd(24);
+      return `  ${icon} ${padded} ${c.detail}`;
+    });
+    lines.push("");
+    const summaryParts = [`${summary.pass} pass`];
+    if (summary.info > 0) summaryParts.push(`${summary.info} info`);
+    summaryParts.push(`${summary.warn} warn`, `${summary.error} error`);
+    lines.push(summaryParts.join(" \xB7 "));
+    const humanHint = lines.join("\n");
+    return { exitCode, result: ok({ checks, summary, humanHint }) };
   }
-  return [
-    check("info", "vault_metric_pages", "Vault pages by type", `${total} graph node(s) (${typedCount} typed; ${perType})`),
-    check("info", "vault_metric_orphans", "Vault orphan rate", `${orphanRate}% (${orphanCount}/${total} degree-0)`),
-    check("info", "vault_metric_bridges", "Vault bridge count", `${bridges} page(s) link >= 3 communities`),
-    check("info", "vault_metric_cohesion", "Mean community cohesion", `${meanCohesion} across ${cohesions.length} communities (size >= 2)`),
-    check("info", "vault_metric_log_size", "Vault log size", `${logLines} lines`)
-  ];
-}
+};
 async function runDoctor(input) {
-  const checks = [];
-  const devSourceRun = isDevSourceRun(input.argv);
-  const vsConfig = readVaultSyncConfig(input.home);
-  checks.push(checkNodeVersion());
-  checks.push(checkCliChannels(input.argv, input.home));
-  checks.push(await checkConfigFile(input.home));
-  checks.push(await checkProfiles(input.home));
-  checks.push(await checkProjectLocalOverride(input.cwd));
-  const resolved = await resolveRuntimePath({
-    flag: void 0,
-    envValue: input.envValue,
-    home: input.home,
-    cwd: input.cwd
-  });
-  if (resolved.ok) {
-    checks.push(check("pass", "wiki_path_set", "WIKI_PATH configured", `Resolved via ${resolved.data.source}: ${resolved.data.path}`));
-  } else {
-    checks.push(check("error", "wiki_path_set", "WIKI_PATH configured", "No vault configured. Run `skillwiki init` or pass --vault."));
-  }
-  const resolvedPath = resolved.ok ? resolved.data.path : void 0;
-  const gitCheckPath = vsConfig.role === "snapshotter" ? resolveSnapshotGitWorktree(input.home) ?? resolvedPath : resolvedPath;
-  checks.push(checkWikiPathExists(resolvedPath));
-  checks.push(checkVaultStructure(resolvedPath));
-  checks.push(checkObsidianTemplates(resolvedPath));
-  checks.push(checkVaultGitRemote(gitCheckPath));
-  const fleetLoad = resolvedPath ? await loadFleetManifestAndHost({
-    vault: resolvedPath,
-    env: { ...process.env, WIKI_PATH: input.envValue ?? resolvedPath },
-    home: input.home,
-    cwd: input.cwd,
-    osHostname: process.env.HOSTNAME,
-    user: process.env.USER
-  }) : null;
-  checks.push(await checkFleetIdentity({
-    vaultPath: resolvedPath,
-    home: input.home,
-    cwd: input.cwd,
-    envValue: input.envValue,
-    fleetLoad
-  }));
-  checks.push(checkSyncLastPush(gitCheckPath));
-  checks.push(checkVaultGitDirty(gitCheckPath));
-  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, input.env ?? process.env));
-  checks.push(checkVaultSnapshotterReachable(fleetLoad, input.checkSnapshotter, input.execProbe));
-  checks.push(checkVaultPromotionLag(gitCheckPath));
-  const readOnlyScanRoot = resolvedPath ? doctorReadOnlyScanRoot(resolvedPath) : void 0;
-  checks.push(checkDotStoreClean(readOnlyScanRoot));
-  checks.push(checkVaultConflictMarkers(readOnlyScanRoot));
-  checks.push(checkS3MountPerf(resolvedPath));
-  checks.push(checkS3MountFreshness(resolvedPath));
-  checks.push(checkRcloneFlagAudit(resolvedPath));
-  checks.push(checkRcloneVersion(resolvedPath, vsConfig.installed));
-  checks.push(checkWriteTest(resolvedPath));
-  checks.push(checkVfsCacheHealth(resolvedPath));
-  checks.push(checkSkillsInstalled(input.home, input.cwd));
-  checks.push(checkDuplicateSkills(input.home));
-  checks.push(checkGrokActivation(input.home, input.cwd));
-  checks.push(checkNpmUpdate(input.home, input.currentVersion));
-  checks.push(checkPluginVersionDrift(input.home, input.currentVersion, devSourceRun));
-  checks.push(...vaultSyncChecks({
-    home: input.home,
-    vaultSyncInstalled: vsConfig.installed,
-    vaultSyncRole: vsConfig.role,
-    vaultSyncServiceScope: vsConfig.serviceScope,
-    snapshotScriptPath: vsConfig.snapshotScript,
-    env: input.env ?? process.env
-  }));
-  checks.push(checkVaultSyncPullHelper(input.home, input.env ?? process.env));
-  checks.push(checkVaultSyncReviewRequiredJournals(resolvedPath));
-  const satelliteGate = satelliteGateFromFleetLoad(fleetLoad);
-  checks.push(checkSatelliteLastRun(resolvedPath, satelliteGate.satelliteExpected));
-  checks.push(checkSatelliteTimer(satelliteGate.satelliteExpected));
-  checks.push(...await vaultMetrics(resolvedPath));
-  const summary = {
-    pass: checks.filter((c) => c.status === "pass").length,
-    info: checks.filter((c) => c.status === "info").length,
-    warn: checks.filter((c) => c.status === "warn").length,
-    error: checks.filter((c) => c.status === "error").length
-  };
-  const exitCode = summary.error > 0 ? ExitCode.DOCTOR_HAS_ERRORS : summary.warn > 0 ? ExitCode.DOCTOR_HAS_WARNINGS : ExitCode.OK;
-  const statusIcon = { pass: "\u2713", info: "i", warn: "\u26A0", error: "\u2717" };
-  const lines = checks.map((c) => {
-    const icon = statusIcon[c.status];
-    const padded = c.label.padEnd(24);
-    return `  ${icon} ${padded} ${c.detail}`;
-  });
-  lines.push("");
-  const summaryParts = [`${summary.pass} pass`];
-  if (summary.info > 0) summaryParts.push(`${summary.info} info`);
-  summaryParts.push(`${summary.warn} warn`, `${summary.error} error`);
-  lines.push(summaryParts.join(" \xB7 "));
-  const humanHint = lines.join("\n");
-  return { exitCode, result: ok({ checks, summary, humanHint }) };
+  return new DoctorRunner().run(input);
 }
 
 // src/utils/package-info.ts
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync11 } from "fs";
 function packageJsonCandidateUrls(baseUrl = import.meta.url) {
   return [
     new URL("../package.json", baseUrl),
@@ -3385,7 +3820,7 @@ function packageJsonCandidateUrls(baseUrl = import.meta.url) {
 function readCliPackageJson(baseUrl = import.meta.url) {
   for (const url of packageJsonCandidateUrls(baseUrl)) {
     try {
-      const pkg = JSON.parse(readFileSync7(url, "utf8"));
+      const pkg = JSON.parse(readFileSync11(url, "utf8"));
       if (typeof pkg.version === "string") {
         return { ...pkg, version: pkg.version };
       }
@@ -3397,8 +3832,8 @@ function readCliPackageJson(baseUrl = import.meta.url) {
 
 // src/utils/vault-write-gates.ts
 import { execFileSync } from "child_process";
-import { existsSync as existsSync8, readdirSync as readdirSync4, readFileSync as readFileSync8, statSync as statSync3 } from "fs";
-import { join as join11, relative as relative2 } from "path";
+import { existsSync as existsSync18, readdirSync as readdirSync7, readFileSync as readFileSync12, statSync as statSync3 } from "fs";
+import { join as join20, relative as relative2 } from "path";
 var DEFAULT_DIRTY_VOLUME_THRESHOLD = 50;
 var DEFAULT_CAPTURE_BUDGET = 20;
 var DEFAULT_NO_DECISION_STREAK = 3;
@@ -3460,7 +3895,7 @@ function measureDirtyVolume(vault) {
     is_git_repo: false,
     ...extra
   });
-  if (!existsSync8(vault) || !statSync3(vault).isDirectory()) {
+  if (!existsSync18(vault) || !statSync3(vault).isDirectory()) {
     return empty();
   }
   const gitDir = git(vault, ["rev-parse", "--absolute-git-dir"]);
@@ -3498,8 +3933,8 @@ function measureDirtyVolume(vault) {
     if (!rel) continue;
     if (code === "??") {
       untracked += 1;
-      const abs = join11(vault, rel);
-      if (existsSync8(abs) && statSync3(abs).isDirectory()) {
+      const abs = join20(vault, rel);
+      if (existsSync18(abs) && statSync3(abs).isDirectory()) {
         const files = listFilesRecursive(abs);
         expanded += files.length;
         addBucket(rel, files.length);
@@ -3529,13 +3964,13 @@ function listFilesRecursive(dir) {
   const out = [];
   let entries;
   try {
-    entries = readdirSync4(dir);
+    entries = readdirSync7(dir);
   } catch {
     return out;
   }
   for (const name of entries) {
     if (name === ".git") continue;
-    const p = join11(dir, name);
+    const p = join20(dir, name);
     try {
       const st = statSync3(p);
       if (st.isDirectory()) out.push(...listFilesRecursive(p));
@@ -3630,7 +4065,7 @@ var CAPTURE_HYGIENE_CONTRACT = `After each productive cycle (or when daily captu
 function listProjectDayCaptures(vault, project, day) {
   const found = [];
   const slug = project.replace(/^\[\[/, "").replace(/\]\]$/, "").trim();
-  if (!slug || !existsSync8(vault)) return found;
+  if (!slug || !existsSync18(vault)) return found;
   const consider = (abs, rel) => {
     if (!rel.endsWith(".md")) return;
     const base = rel.split(/[/\\]/).pop() ?? "";
@@ -3647,7 +4082,7 @@ function listProjectDayCaptures(vault, project, day) {
     }
     if (norm.startsWith("raw/transcripts/")) {
       try {
-        const body = readFileSync8(abs, "utf8");
+        const body = readFileSync12(abs, "utf8");
         if (body.includes(`project: ${slug}`) || body.includes(`project: "[[${slug}]]"`) || body.includes(`project: [[${slug}]]`)) {
           found.push(norm);
         } else if (base.includes(slug)) {
@@ -3658,15 +4093,15 @@ function listProjectDayCaptures(vault, project, day) {
     }
   };
   const walk = (dir, relBase) => {
-    if (!existsSync8(dir)) return;
+    if (!existsSync18(dir)) return;
     let entries;
     try {
-      entries = readdirSync4(dir);
+      entries = readdirSync7(dir);
     } catch {
       return;
     }
     for (const name of entries) {
-      const abs = join11(dir, name);
+      const abs = join20(dir, name);
       const rel = relBase ? `${relBase}/${name}` : name;
       try {
         const st = statSync3(abs);
@@ -3676,16 +4111,16 @@ function listProjectDayCaptures(vault, project, day) {
       }
     }
   };
-  walk(join11(vault, "raw", "transcripts"), "raw/transcripts");
-  walk(join11(vault, "projects", slug, "raw", "transcripts"), `projects/${slug}/raw/transcripts`);
-  walk(join11(vault, "projects", slug, "requirements"), `projects/${slug}/requirements`);
-  const workRoot = join11(vault, "projects", slug, "work");
-  if (existsSync8(workRoot)) {
+  walk(join20(vault, "raw", "transcripts"), "raw/transcripts");
+  walk(join20(vault, "projects", slug, "raw", "transcripts"), `projects/${slug}/raw/transcripts`);
+  walk(join20(vault, "projects", slug, "requirements"), `projects/${slug}/requirements`);
+  const workRoot = join20(vault, "projects", slug, "work");
+  if (existsSync18(workRoot)) {
     try {
-      for (const name of readdirSync4(workRoot)) {
+      for (const name of readdirSync7(workRoot)) {
         if (!name.startsWith(day)) continue;
         if (!/investigate|pilot-q|research|cycle|dev-loop/.test(name)) continue;
-        const abs = join11(workRoot, name);
+        const abs = join20(workRoot, name);
         if (statSync3(abs).isDirectory()) {
           for (const f of listFilesRecursive(abs)) {
             const rel = relative2(vault, f).replace(/\\/g, "/");
@@ -3730,7 +4165,7 @@ function evaluateCaptureBudget(input) {
   return { allowed: true, reason: "under_budget", report };
 }
 function runWritePreflight(input) {
-  if (!input.vault || !existsSync8(input.vault)) {
+  if (!input.vault || !existsSync18(input.vault)) {
     return err(GateError.VAULT_PATH_INVALID, { path: input.vault });
   }
   const want = new Set(input.checks ?? ["all"]);
@@ -3790,8 +4225,8 @@ function runWritePreflight(input) {
 
 // src/commands/observe.ts
 import { mkdir as mkdir3, writeFile as writeFile2 } from "fs/promises";
-import { existsSync as existsSync9, statSync as statSync4 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync19, statSync as statSync4 } from "fs";
+import { join as join21 } from "path";
 import { createHash as createHash2 } from "crypto";
 var ALLOWED_KINDS = /* @__PURE__ */ new Set(["note", "bug", "task", "idea", "session-log"]);
 function slugify(text) {
@@ -3814,7 +4249,7 @@ async function runObserve(input) {
       result: err("SCHEME_REJECTED", { message: "Text must not be empty" })
     };
   }
-  if (!existsSync9(input.vault) || !statSync4(input.vault).isDirectory()) {
+  if (!existsSync19(input.vault) || !statSync4(input.vault).isDirectory()) {
     return {
       exitCode: ExitCode.VAULT_PATH_INVALID,
       result: err("VAULT_PATH_INVALID", { path: input.vault })
@@ -3840,7 +4275,7 @@ async function runObserve(input) {
       };
     }
   }
-  const transcriptsDir = join12(input.vault, "raw", "transcripts");
+  const transcriptsDir = join21(input.vault, "raw", "transcripts");
   try {
     await mkdir3(transcriptsDir, { recursive: true });
   } catch {
@@ -3852,7 +4287,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 = join12(transcriptsDir, fileName);
+  const filePath = join21(transcriptsDir, fileName);
   const body = `
 ${input.text.trim()}
 `;
@@ -3894,7 +4329,7 @@ ${input.text.trim()}
 // src/commands/memory.ts
 import { createHash as createHash3 } from "crypto";
 import { mkdir as mkdir4, readFile as readFile7, readdir as readdir2, stat as stat2, writeFile as writeFile3 } from "fs/promises";
-import { basename as basename2, extname, join as join13, relative as relative3, sep as sep2 } from "path";
+import { basename as basename2, extname, join as join22, relative as relative3, sep as sep2 } from "path";
 
 // src/utils/memory-authority.ts
 var TIER_RANK = {
@@ -4013,8 +4448,8 @@ async function runMemoryIndex(input) {
   }
   const generatedAt = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
   const relCachePath = memoryCacheRelPath(input.project);
-  const absCachePath = join13(input.vault, relCachePath);
-  await mkdir4(join13(input.vault, ".skillwiki", "memory", input.project), { recursive: true });
+  const absCachePath = join22(input.vault, relCachePath);
+  await mkdir4(join22(input.vault, ".skillwiki", "memory", input.project), { recursive: true });
   await writeFile3(absCachePath, `${JSON.stringify({
     generated_at: generatedAt,
     project: input.project,
@@ -4206,7 +4641,7 @@ async function buildMemoryIndexState(pages, project) {
 }
 async function checkMemoryIndex(vault, project, current) {
   const relCachePath = memoryCacheRelPath(project);
-  const cacheText = await readIfExists(join13(vault, relCachePath));
+  const cacheText = await readIfExists(join22(vault, relCachePath));
   if (!cacheText) {
     return {
       ok: true,
@@ -4615,7 +5050,7 @@ async function walkImportFiles(dir, out) {
   const entries = await readdir2(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name === ".git" || entry.name === "node_modules") continue;
-    const path = join13(dir, entry.name);
+    const path = join22(dir, entry.name);
     if (entry.isDirectory()) {
       await walkImportFiles(path, out);
     } else if (entry.isFile() && isImportCandidate(path)) {
@@ -4682,8 +5117,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 = join13(vault, relPath);
-  await mkdir4(join13(vault, "raw", "transcripts"), { recursive: true });
+  const absPath = join22(vault, relPath);
+  await mkdir4(join22(vault, "raw", "transcripts"), { recursive: true });
   await writeFile3(absPath, renderImportCapture(entry, content, project, today), "utf8");
   const validation = await runValidate({ file: absPath });
   return {
@@ -4699,7 +5134,7 @@ async function availableImportPath(vault, proposed) {
   const stem = proposed.slice(0, -ext.length);
   let candidate = proposed;
   let i = 2;
-  while (await readIfExists(join13(vault, candidate))) {
+  while (await readIfExists(join22(vault, candidate))) {
     candidate = `${stem}-${i}${ext}`;
     i++;
   }
@@ -4884,10 +5319,10 @@ function memoryCacheRelPath(project) {
 }
 async function readMemoryCache(vault, project) {
   if (project) {
-    const projectCache = await readIfExists(join13(vault, memoryCacheRelPath(project)));
+    const projectCache = await readIfExists(join22(vault, memoryCacheRelPath(project)));
     if (projectCache) return projectCache;
   }
-  return readIfExists(join13(vault, ".skillwiki", "memory-topics.json"));
+  return readIfExists(join22(vault, ".skillwiki", "memory-topics.json"));
 }
 function dedupePages(pages) {
   const seen = /* @__PURE__ */ new Set();
@@ -4978,8 +5413,310 @@ function slugify2(value) {
 }
 
 // src/commands/query.ts
-import { readFile as readFile8, stat as stat3 } from "fs/promises";
-import { join as join14 } from "path";
+import { readFile as readFile9, stat as stat4 } from "fs/promises";
+import { join as join24 } from "path";
+
+// src/utils/rrf.ts
+var RRF_K = 60;
+function fuseRankings(lists, k = RRF_K) {
+  const scores = /* @__PURE__ */ new Map();
+  for (const list of lists) {
+    list.forEach((id, index) => {
+      scores.set(id, (scores.get(id) ?? 0) + 1 / (k + index + 1));
+    });
+  }
+  return [...scores.entries()].map(([id, score]) => ({ id, score })).sort((a, b) => b.score - a.score || a.id.localeCompare(b.id));
+}
+
+// src/utils/vector-index.ts
+import { mkdir as mkdir5, readFile as readFile8, stat as stat3 } from "fs/promises";
+import { join as join23 } from "path";
+import { existsSync as existsSync20 } from "fs";
+var VECTOR_INDEX_REL = ".skillwiki/vectors/index.json";
+var VECTOR_INDEX_SCHEMA = "skillwiki-tfidf-index/v1";
+function tokenize(text) {
+  return text.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 1);
+}
+function extractPageTokens(text) {
+  const fm = extractFrontmatter(text);
+  const split = splitFrontmatter(text);
+  const title = fm.ok ? String(fm.data.title ?? "") : "";
+  const body = split.ok ? split.data.body : text;
+  return tokenize(`${title} ${body}`);
+}
+function vectorIndexPath(vault) {
+  return join23(vault, ...VECTOR_INDEX_REL.split("/"));
+}
+function termFreq(tokens) {
+  const tf = /* @__PURE__ */ new Map();
+  for (const token of tokens) tf.set(token, (tf.get(token) ?? 0) + 1);
+  return tf;
+}
+function toTfIdf(tf, df, docs) {
+  const out = {};
+  for (const [term, count] of tf) {
+    const appears = df[term] ?? 0;
+    if (appears === 0) continue;
+    out[term] = count / Math.max(1, tf.size) * Math.log((docs + 1) / appears);
+  }
+  return out;
+}
+function cosine(a, b) {
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  for (const value of Object.values(a)) na += value * value;
+  for (const value of Object.values(b)) nb += value * value;
+  if (na === 0 || nb === 0) return 0;
+  const shorter = Object.keys(a).length < Object.keys(b).length ? a : b;
+  const longer = shorter === a ? b : a;
+  for (const [term, value] of Object.entries(shorter)) {
+    const other = longer[term];
+    if (other) dot += value * other;
+  }
+  return dot / Math.sqrt(na * nb);
+}
+async function buildVectorIndex(vault, now = (/* @__PURE__ */ new Date()).toISOString()) {
+  const scan = await scanVault(vault);
+  if (!scan.ok) return scan;
+  const tokenized = [];
+  for (const page of scan.data.typedKnowledge) {
+    const text = await readPage(page);
+    tokenized.push({ path: page.relPath, tokens: extractPageTokens(text) });
+  }
+  const df = {};
+  for (const doc of tokenized) {
+    for (const term of new Set(doc.tokens)) df[term] = (df[term] ?? 0) + 1;
+  }
+  const docs = {};
+  for (const doc of tokenized) {
+    docs[doc.path] = toTfIdf(termFreq(doc.tokens), df, tokenized.length);
+  }
+  const index = {
+    schema: VECTOR_INDEX_SCHEMA,
+    built_at: now,
+    page_count: tokenized.length,
+    df,
+    docs
+  };
+  const dest = vectorIndexPath(vault);
+  await mkdir5(join23(vault, ".skillwiki", "vectors"), { recursive: true });
+  await atomicWriteText(dest, `${JSON.stringify(index)}
+`);
+  return ok(index);
+}
+async function loadVectorIndex(vault) {
+  try {
+    const raw = await readFile8(vectorIndexPath(vault), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.schema !== VECTOR_INDEX_SCHEMA || typeof parsed.docs !== "object" || parsed.docs === null) {
+      return err("HYBRID_INDEX_INVALID", { path: VECTOR_INDEX_REL });
+    }
+    return ok(parsed);
+  } catch {
+    return err("HYBRID_INDEX_MISSING", { path: VECTOR_INDEX_REL, message: "run skillwiki vectors rebuild" });
+  }
+}
+async function vectorIndexStatus(vault) {
+  const path = vectorIndexPath(vault);
+  try {
+    const fileStat = await stat3(path);
+    const loaded = await loadVectorIndex(vault);
+    if (!loaded.ok) return ok({ path: VECTOR_INDEX_REL, present: false });
+    return ok({
+      path: VECTOR_INDEX_REL,
+      present: true,
+      page_count: loaded.data.page_count,
+      built_at: loaded.data.built_at,
+      age_hours: (Date.now() - fileStat.mtimeMs) / 36e5
+    });
+  } catch {
+    return ok({ path: VECTOR_INDEX_REL, present: false });
+  }
+}
+function rankVectorIndex(index, query) {
+  const q = toTfIdf(termFreq(tokenize(query)), index.df, Math.max(1, index.page_count));
+  return Object.entries(index.docs).map(([path, vector]) => ({ path, score: cosine(q, vector) })).filter((row) => row.score > 0).sort((a, b) => b.score - a.score || a.path.localeCompare(b.path)).map((row) => row.path);
+}
+async function reindexPageInVectorIndex(vault, pageRelPath, now = (/* @__PURE__ */ new Date()).toISOString()) {
+  const normalizedPage = pageRelPath.split(/\\|\//).join("/");
+  if (!normalizedPage.endsWith(".md")) {
+    return err("USAGE", { message: `Page must be a .md file: ${pageRelPath}` });
+  }
+  const absPath = join23(vault, ...normalizedPage.split("/"));
+  let text;
+  try {
+    text = await readFile8(absPath, "utf8");
+  } catch {
+    return err("FILE_NOT_FOUND", { path: normalizedPage });
+  }
+  const loaded = await loadVectorIndex(vault);
+  if (!loaded.ok) return loaded;
+  const index = loaded.data;
+  const tokens = extractPageTokens(text);
+  const newTf = termFreq(tokens);
+  const newTerms = new Set(newTf.keys());
+  const oldDoc = index.docs[normalizedPage];
+  const oldTerms = oldDoc ? new Set(Object.keys(oldDoc)) : /* @__PURE__ */ new Set();
+  const isNewPage = !oldDoc;
+  const newPageCount = isNewPage ? index.page_count + 1 : index.page_count;
+  const termsAdded = [];
+  const termsRemoved = [];
+  for (const t of newTerms) {
+    if (!oldTerms.has(t)) termsAdded.push(t);
+  }
+  for (const t of oldTerms) {
+    if (!newTerms.has(t)) termsRemoved.push(t);
+  }
+  const dfChangedTerms = /* @__PURE__ */ new Set();
+  for (const t of termsAdded) {
+    index.df[t] = (index.df[t] ?? 0) + 1;
+    dfChangedTerms.add(t);
+  }
+  for (const t of termsRemoved) {
+    const nextDf = (index.df[t] ?? 1) - 1;
+    if (nextDf <= 0) {
+      delete index.df[t];
+    } else {
+      index.df[t] = nextDf;
+    }
+    dfChangedTerms.add(t);
+  }
+  index.page_count = newPageCount;
+  index.built_at = now;
+  index.docs[normalizedPage] = toTfIdf(newTf, index.df, index.page_count);
+  if (isNewPage) {
+    const oldDocsTotal = newPageCount - 1;
+    for (const [docPath, docVector] of Object.entries(index.docs)) {
+      if (docPath === normalizedPage) continue;
+      const updatedVector = {};
+      for (const [term, oldScore] of Object.entries(docVector)) {
+        const dfVal = index.df[term];
+        if (!dfVal || dfVal <= 0) continue;
+        const oldDf = termsAdded.includes(term) ? index.df[term] - 1 : index.df[term];
+        const oldIdf = Math.log((oldDocsTotal + 1) / oldDf);
+        const newIdf = Math.log((newPageCount + 1) / dfVal);
+        updatedVector[term] = oldIdf !== 0 ? oldScore * (newIdf / oldIdf) : 0;
+      }
+      index.docs[docPath] = updatedVector;
+    }
+  } else if (dfChangedTerms.size > 0) {
+    for (const [docPath, docVector] of Object.entries(index.docs)) {
+      if (docPath === normalizedPage) continue;
+      let touched = false;
+      for (const t of Object.keys(docVector)) {
+        if (dfChangedTerms.has(t)) {
+          touched = true;
+          break;
+        }
+      }
+      if (!touched) continue;
+      const updatedVector = {};
+      for (const [term, oldScore] of Object.entries(docVector)) {
+        const dfVal = index.df[term];
+        if (!dfVal || dfVal <= 0) continue;
+        if (dfChangedTerms.has(term)) {
+          const oldDf = termsAdded.includes(term) ? dfVal - 1 : termsRemoved.includes(term) ? dfVal + 1 : dfVal;
+          const oldIdf = Math.log((newPageCount + 1) / oldDf);
+          const newIdf = Math.log((newPageCount + 1) / dfVal);
+          updatedVector[term] = oldIdf !== 0 ? oldScore * (newIdf / oldIdf) : 0;
+        } else {
+          updatedVector[term] = oldScore;
+        }
+      }
+      index.docs[docPath] = updatedVector;
+    }
+  }
+  const dest = vectorIndexPath(vault);
+  await mkdir5(join23(vault, ".skillwiki", "vectors"), { recursive: true });
+  await atomicWriteText(dest, `${JSON.stringify(index)}
+`);
+  return ok({
+    path: VECTOR_INDEX_REL,
+    page: normalizedPage,
+    terms_added: termsAdded.length,
+    terms_removed: termsRemoved.length,
+    page_count: index.page_count
+  });
+}
+async function pruneVectorIndex(vault, opts) {
+  const loaded = await loadVectorIndex(vault);
+  if (!loaded.ok) return loaded;
+  const index = loaded.data;
+  const orphans = [];
+  for (const docKey of Object.keys(index.docs)) {
+    const normalizedKey = docKey.split(/\\|\//).join("/");
+    const absPath = join23(vault, ...normalizedKey.split("/"));
+    if (!existsSync20(absPath)) {
+      orphans.push(normalizedKey);
+    }
+  }
+  if (orphans.length === 0) {
+    return ok({
+      path: VECTOR_INDEX_REL,
+      orphans: [],
+      removed: 0,
+      page_count: index.page_count,
+      terms_pruned: 0
+    });
+  }
+  const oldPageCount = index.page_count;
+  const newPageCount = Math.max(0, oldPageCount - orphans.length);
+  let termsPrunedCount = 0;
+  for (const orphanKey of orphans) {
+    const orphanDoc = index.docs[orphanKey] ?? {};
+    for (const term of Object.keys(orphanDoc)) {
+      const nextDf = (index.df[term] ?? 1) - 1;
+      if (nextDf <= 0) {
+        delete index.df[term];
+        termsPrunedCount++;
+      } else {
+        index.df[term] = nextDf;
+      }
+    }
+    delete index.docs[orphanKey];
+  }
+  index.page_count = newPageCount;
+  const now = opts?.now ?? (/* @__PURE__ */ new Date()).toISOString();
+  index.built_at = now;
+  const scan = await scanVault(vault);
+  if (!scan.ok) return scan;
+  const remainingPagesByRel = /* @__PURE__ */ new Map();
+  for (const p of scan.data.typedKnowledge) {
+    remainingPagesByRel.set(p.relPath, p);
+  }
+  for (const docKey of Object.keys(index.docs)) {
+    const page = remainingPagesByRel.get(docKey);
+    if (page) {
+      const text = await readPage(page);
+      const tokens = extractPageTokens(text);
+      index.docs[docKey] = toTfIdf(termFreq(tokens), index.df, newPageCount);
+    } else {
+      try {
+        const text = await readFile8(join23(vault, ...docKey.split("/")), "utf8");
+        const tokens = extractPageTokens(text);
+        index.docs[docKey] = toTfIdf(termFreq(tokens), index.df, newPageCount);
+      } catch {
+        delete index.docs[docKey];
+      }
+    }
+  }
+  if (!opts?.dryRun) {
+    const dest = vectorIndexPath(vault);
+    await mkdir5(join23(vault, ".skillwiki", "vectors"), { recursive: true });
+    await atomicWriteText(dest, `${JSON.stringify(index)}
+`);
+  }
+  return ok({
+    path: VECTOR_INDEX_REL,
+    orphans,
+    removed: orphans.length,
+    page_count: newPageCount,
+    terms_pruned: termsPrunedCount
+  });
+}
+
+// src/commands/query.ts
 var W_KEYWORD = 2;
 var W_SOURCE_OVERLAP = 4;
 var W_WIKILINK = 3;
@@ -5007,7 +5744,7 @@ async function runQuery(input) {
   const scan = await scanVault(input.vault);
   if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
   const limit = input.limit ?? 10;
-  const queryTerms = tokenize(input.text);
+  const queryTerms = tokenize2(input.text);
   if (queryTerms.length === 0) {
     return {
       exitCode: ExitCode.OK,
@@ -5052,7 +5789,7 @@ async function runQuery(input) {
   }
   const suppressRepetitiveHistoricalCycles = historicalCyclePageCount >= 3 && hasDirectOperationalSeed;
   const structuralSeedPaths = suppressRepetitiveHistoricalCycles ? operationalSeedPaths : seedPaths;
-  const results = pages.map((page) => {
+  const structural = pages.map((page) => {
     const sourceOverlap = scoreSourceOverlap(page, pages, structuralSeedPaths);
     const wikilink = scoreWikilink(page.relPath, structuralSeedPaths, graph);
     const aa = scoreAdamicAdar(page.relPath, structuralSeedPaths, graph);
@@ -5067,11 +5804,31 @@ async function runQuery(input) {
       title: page.title,
       type: page.type
     };
-  }).filter((r) => r.score > 0).sort((a, b) => b.score - a.score || a.path.localeCompare(b.path)).slice(0, limit);
+  }).filter((r) => r.score > 0).sort((a, b) => b.score - a.score || a.path.localeCompare(b.path));
+  let results = structural.slice(0, limit);
+  let hybridMeta;
+  if (input.hybrid) {
+    const index = await loadVectorIndex(input.vault);
+    if (!index.ok) return { exitCode: ExitCode.USAGE, result: index };
+    const byPath = new Map(pages.map((page) => [page.relPath, page]));
+    const fused = fuseRankings([structural.map((row) => row.path), rankVectorIndex(index.data, input.text)]);
+    results = fused.slice(0, limit).map((row) => {
+      const existing = structural.find((item) => item.path === row.id);
+      if (existing) return { ...existing, score: Math.round(row.score * 1e3) / 1e3 };
+      const page = byPath.get(row.id);
+      return {
+        path: row.id,
+        score: Math.round(row.score * 1e3) / 1e3,
+        title: page?.title ?? "",
+        type: page?.type ?? ""
+      };
+    });
+    hybridMeta = { used: true, rrf_k: RRF_K };
+  }
   let pendingSources;
   if (input.includePending) {
-    const { runSourcesPending } = await import("./sources-CMV5DKS5.js");
-    const pending = await runSourcesPending({
+    const { runSourcesPending: runSourcesPending2 } = await import("./sources-BFYEFTS4.js");
+    const pending = await runSourcesPending2({
       vault: input.vault,
       match: input.text,
       limit: input.limit ?? 10
@@ -5090,6 +5847,7 @@ ${pendingSources.length} matching pending source(s)` : "no matching pages found"
       results,
       ...pendingSources ? { pending_sources: pendingSources } : {},
       ...rankingGuardrails ? { ranking_guardrails: rankingGuardrails } : {},
+      ...hybridMeta ? { hybrid: hybridMeta } : {},
       humanHint
     })
   };
@@ -5133,7 +5891,7 @@ function scoreTypeAffinity(pageType, queryTerms) {
 function isHistoricalCyclePage(relPath, title) {
   return HISTORICAL_CYCLE_RE.test(`${relPath} ${title}`);
 }
-function tokenize(text) {
+function tokenize2(text) {
   return text.toLowerCase().split(/\s+/).filter((t) => t.length > 0);
 }
 function computeKeywordScore(terms, title, tags, body) {
@@ -5149,10 +5907,10 @@ function computeKeywordScore(terms, title, tags, body) {
   return score;
 }
 async function loadOrBuildGraph(vault) {
-  const graphPath = join14(vault, ".skillwiki", "graph.json");
+  const graphPath = join24(vault, ".skillwiki", "graph.json");
   let needsBuild = false;
   try {
-    const fileStat = await stat3(graphPath);
+    const fileStat = await stat4(graphPath);
     const ageHours = (Date.now() - fileStat.mtimeMs) / (1e3 * 60 * 60);
     if (ageHours > 24) needsBuild = true;
   } catch {
@@ -5163,13 +5921,73 @@ async function loadOrBuildGraph(vault) {
     if (buildResult.exitCode !== 0) return null;
   }
   try {
-    const raw = await readFile8(graphPath, "utf8");
+    const raw = await readFile9(graphPath, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
 
+// src/commands/source-compile.ts
+function writeGuard(approve) {
+  if (!approve) return { ok: false, error: "APPROVAL_INVALID", detail: { message: "--write requires --approve" } };
+  return null;
+}
+async function runSourceCompileClaim(input) {
+  if (!input.write) {
+    const plan = await planSourceCompileClaim(input);
+    return { exitCode: plan.ok ? ExitCode.OK : ExitCode.USAGE, result: plan };
+  }
+  const missing = writeGuard(input.approve);
+  if (missing) return { exitCode: ExitCode.USAGE, result: missing };
+  const applied = await applySourceCompileClaim({ ...input, approve: input.approve });
+  if (!applied.ok) return { exitCode: ExitCode.USAGE, result: applied };
+  return { exitCode: ExitCode.OK, result: ok({ ...applied.data, humanHint: `claimed ${input.rawPath}` }) };
+}
+async function runSourceCompileRelease(input) {
+  if (!input.write) {
+    const plan = await planSourceCompileRelease(input);
+    return { exitCode: plan.ok ? ExitCode.OK : ExitCode.USAGE, result: plan };
+  }
+  const missing = writeGuard(input.approve);
+  if (missing) return { exitCode: ExitCode.USAGE, result: missing };
+  const applied = await applySourceCompileRelease({ ...input, approve: input.approve });
+  if (!applied.ok) return { exitCode: ExitCode.USAGE, result: applied };
+  return { exitCode: ExitCode.OK, result: ok({ ...applied.data, humanHint: `released ${input.rawPath}` }) };
+}
+async function runSourceCompilePublished(input) {
+  if (!input.write) {
+    const plan = await planSourceCompilePublished(input);
+    return { exitCode: plan.ok ? ExitCode.OK : ExitCode.USAGE, result: plan };
+  }
+  const missing = writeGuard(input.approve);
+  if (missing) return { exitCode: ExitCode.USAGE, result: missing };
+  const applied = await applySourceCompilePublished({ ...input, approve: input.approve });
+  if (!applied.ok) return { exitCode: ExitCode.USAGE, result: applied };
+  return { exitCode: ExitCode.OK, result: ok({ ...applied.data, humanHint: `published compile turn for ${input.rawPath}` }) };
+}
+async function runSourceReview(input) {
+  if (!input.write) {
+    const plan = await planSourceReview(input);
+    return { exitCode: plan.ok ? ExitCode.OK : ExitCode.USAGE, result: plan };
+  }
+  const missing = writeGuard(input.approve);
+  if (missing) return { exitCode: ExitCode.USAGE, result: missing };
+  const applied = await applySourceReview({ ...input, approve: input.approve });
+  if (!applied.ok) return { exitCode: ExitCode.USAGE, result: applied };
+  return { exitCode: ExitCode.OK, result: ok({ ...applied.data, humanHint: `${input.status} review for ${input.rawPath}` }) };
+}
+async function runSourceCompileStatus(input) {
+  const listed = await listCompileStatus(input);
+  if (!listed.ok) return { exitCode: ExitCode.USAGE, result: listed };
+  return { exitCode: ExitCode.OK, result: ok({ ...listed.data, humanHint: listed.data.items.length ? `${listed.data.items.length} compile turns` : "no active compile turns" }) };
+}
+async function runSourceReviews(input) {
+  const listed = await listSourceReviews(input);
+  if (!listed.ok) return { exitCode: ExitCode.USAGE, result: listed };
+  return { exitCode: ExitCode.OK, result: ok({ ...listed.data, humanHint: listed.data.items.length ? `${listed.data.items.length} open reviews` : "no open reviews" }) };
+}
+
 // src/mcp/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -5178,7 +5996,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { z } from "zod";
 
 // src/mcp/vault-resolve.ts
-import { join as join15, resolve as resolve4 } from "path";
+import { join as join25, resolve as resolve4 } from "path";
 
 // src/mcp/allowlist.ts
 import { resolve as resolve3, sep as sep3 } from "path";
@@ -5240,7 +6058,7 @@ async function resolveMcpVault(input) {
   return ok({ vault: vaultPath, source });
 }
 function defaultGraphOut(vault) {
-  return join15(vault, ".skillwiki", "graph.json");
+  return join25(vault, ".skillwiki", "graph.json");
 }
 
 // src/mcp/result-format.ts
@@ -5257,7 +6075,7 @@ function formatToolResult(payload) {
 // src/mcp/audit-log.ts
 import { appendFileSync, mkdirSync as mkdirSync2 } from "fs";
 import { homedir } from "os";
-import { join as join16 } from "path";
+import { join as join26 } from "path";
 function auditEnabled() {
   const v = process.env.SKILLWIKI_MCP_AUDIT;
   if (v === "0" || v === "false") return false;
@@ -5269,7 +6087,7 @@ function auditSink() {
 function auditFilePath() {
   const custom = process.env.SKILLWIKI_MCP_AUDIT_FILE;
   if (custom && custom.length > 0) return custom;
-  return join16(homedir(), ".skillwiki", "mcp-audit.jsonl");
+  return join26(homedir(), ".skillwiki", "mcp-audit.jsonl");
 }
 function auditMcpToolCall(entry) {
   if (!auditEnabled()) return;
@@ -5279,7 +6097,7 @@ function auditMcpToolCall(entry) {
     return;
   }
   const path = auditFilePath();
-  mkdirSync2(join16(path, ".."), { recursive: true });
+  mkdirSync2(join26(path, ".."), { recursive: true });
   appendFileSync(path, line, "utf8");
 }
 async function runMcpToolHandler(tool, input, fn) {
@@ -5448,6 +6266,59 @@ function registerMcpTools(server) {
       return formatToolResult(r);
     })
   );
+  server.registerTool(
+    "skillwiki.sources_pending",
+    {
+      description: "List captured raw articles/papers awaiting typed integration (read-only).",
+      inputSchema: z.object({
+        ...vaultFields,
+        match: z.string().optional().describe("Literal title, URL, or path match"),
+        scope: z.enum(["articles", "papers", "all"]).optional(),
+        limit: z.number().int().positive().optional().describe("Max items (default 50)"),
+        includeIntegrated: z.boolean().optional()
+      })
+    },
+    async ({ vault, wiki, match, scope, limit, includeIntegrated }) => runMcpToolHandler("skillwiki.sources_pending", { vault, wiki }, async () => {
+      const v = await resolveMcpVault({ vault, wiki });
+      if (!v.ok) return formatToolResult({ exitCode: 25, result: v });
+      const r = await runSourcesPending({
+        vault: v.data.vault,
+        match,
+        scope,
+        limit,
+        includeIntegrated
+      });
+      return formatToolResult(r);
+    })
+  );
+  server.registerTool(
+    "skillwiki.compile_status",
+    {
+      description: "List compiling and review-open pending compile-turns (read-only).",
+      inputSchema: z.object({
+        ...vaultFields
+      })
+    },
+    async ({ vault, wiki }) => runMcpToolHandler("skillwiki.compile_status", { vault, wiki }, async () => {
+      const v = await resolveMcpVault({ vault, wiki });
+      if (!v.ok) return formatToolResult({ exitCode: 25, result: v });
+      return formatToolResult(await runSourceCompileStatus({ vault: v.data.vault }));
+    })
+  );
+  server.registerTool(
+    "skillwiki.reviews",
+    {
+      description: "List open or needs-fix post-compile reviews (read-only).",
+      inputSchema: z.object({
+        ...vaultFields
+      })
+    },
+    async ({ vault, wiki }) => runMcpToolHandler("skillwiki.reviews", { vault, wiki }, async () => {
+      const v = await resolveMcpVault({ vault, wiki });
+      if (!v.ok) return formatToolResult({ exitCode: 25, result: v });
+      return formatToolResult(await runSourceReviews({ vault: v.data.vault }));
+    })
+  );
 }
 
 // src/mcp/mutating-tools.ts
@@ -5499,8 +6370,8 @@ function registerMcpMutatingTools(server) {
 }
 
 // src/mcp/resources.ts
-import { readFile as readFile10 } from "fs/promises";
-import { join as join18 } from "path";
+import { readFile as readFile11 } from "fs/promises";
+import { join as join28 } from "path";
 import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 
 // src/mcp/lint-bucket.ts
@@ -5531,7 +6402,8 @@ var WARNING_KINDS = /* @__PURE__ */ new Set([
   "work_item_health",
   "orphaned_project_pages",
   "missing_overview",
-  "missing_diagram"
+  "missing_diagram",
+  "cycle_traps"
 ]);
 function bucketSeverity(kind) {
   if (ERROR_KINDS.has(kind)) return "error";
@@ -5628,9 +6500,9 @@ async function fetchQueryPreview(input) {
 }
 
 // src/mcp/graph-html.ts
-import { readFile as readFile9 } from "fs/promises";
-import { join as join17 } from "path";
-import { existsSync as existsSync10 } from "fs";
+import { readFile as readFile10 } from "fs/promises";
+import { join as join27 } from "path";
+import { existsSync as existsSync21 } from "fs";
 var TYPE_COLORS = {
   entities: "#e74c3c",
   concepts: "#27ae60",
@@ -5698,9 +6570,9 @@ ${nodeSvg}
   return { html, node_count: nodes.length, edge_count: edges.length, truncated };
 }
 async function fetchGraphHtmlReport(input) {
-  const graphPath = input.graphPath ?? join17(input.vault, ".skillwiki", "graph.json");
+  const graphPath = input.graphPath ?? join27(input.vault, ".skillwiki", "graph.json");
   const maxNodes = Math.min(Math.max(10, input.maxNodes ?? 120), 500);
-  if (!existsSync10(graphPath)) {
+  if (!existsSync21(graphPath)) {
     return {
       exitCode: ExitCode.FILE_NOT_FOUND,
       result: err("GRAPH_MISSING", { path: graphPath, hint: "Run skillwiki.graph_build first." })
@@ -5708,7 +6580,7 @@ async function fetchGraphHtmlReport(input) {
   }
   let raw;
   try {
-    raw = await readFile9(graphPath, "utf8");
+    raw = await readFile10(graphPath, "utf8");
   } catch (e) {
     return {
       exitCode: ExitCode.FILE_NOT_FOUND,
@@ -5772,7 +6644,7 @@ async function fetchStaleSummary(input) {
 
 // src/mcp/resources.ts
 async function readVaultFile(vault, rel) {
-  return readFile10(join18(vault, rel), "utf8");
+  return readFile11(join28(vault, rel), "utf8");
 }
 async function tailLines(text, lines) {
   const parts = text.split(/\r?\n/);
@@ -5858,9 +6730,9 @@ function registerMcpResources(server) {
       if (!v.ok) {
         return { contents: [{ uri: uri.href, mimeType: "text/plain", text: JSON.stringify(v) }] };
       }
-      const path = join18(v.data.vault, ".skillwiki", "graph.json");
+      const path = join28(v.data.vault, ".skillwiki", "graph.json");
       try {
-        const raw = await readFile10(path, "utf8");
+        const raw = await readFile11(path, "utf8");
         const graph = JSON.parse(raw);
         const adjacency = graph.adjacency ?? {};
         const nodes = Object.keys(adjacency);
@@ -6148,6 +7020,35 @@ function registerMcpPrompts(server) {
       ]
     })
   );
+  server.registerPrompt(
+    "skillwiki-pending-review",
+    {
+      description: "Inspect pending sources and compile reviews without mutating the vault",
+      argsSchema: {
+        match: z3.string().optional().describe("Optional title/URL/path filter")
+      }
+    },
+    ({ match }) => ({
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: [
+              "List pending raw sources and open compile reviews.",
+              match ? `Filter: ${match}` : "No extra filter.",
+              "",
+              "1. Call skillwiki.sources_pending (read-only).",
+              "2. Call skillwiki.compile_status and skillwiki.reviews.",
+              "3. Summarize what an attended session should compile next.",
+              "",
+              "Do not call mutating tools. Compile claim/publish stays on the interactive CLI."
+            ].join("\n")
+          }
+        }
+      ]
+    })
+  );
 }
 
 // src/mcp/server.ts
@@ -6185,13 +7086,13 @@ export {
   runConfigSet,
   runConfigList,
   runConfigPath,
+  detectFuseMount,
+  snapshotterHealthChecks,
   SATELLITE_STALE_MS,
   satelliteLatestRunPath,
   isFailedRunStatus,
   readSatelliteLatestRunFromText,
   evaluateSatelliteRunHealth,
-  detectFuseMount,
-  snapshotterHealthChecks,
   runDoctor,
   readCliPackageJson,
   DEFAULT_DIRTY_VOLUME_THRESHOLD,
@@ -6208,6 +7109,16 @@ export {
   runMemoryRecall,
   runMemoryReview,
   runMemoryImport,
+  buildVectorIndex,
+  vectorIndexStatus,
+  reindexPageInVectorIndex,
+  pruneVectorIndex,
   runQuery,
+  runSourceCompileClaim,
+  runSourceCompileRelease,
+  runSourceCompilePublished,
+  runSourceReview,
+  runSourceCompileStatus,
+  runSourceReviews,
   runSkillwikiMcpStdio
 };