skillwiki 0.9.29 → 0.9.31

package/dist/{chunk-T7XG3WFK.js → chunk-6G7RAAOS.js}

@@ -62,7 +62,8 @@ var ExitCode = {
   SYNC_LOCK_HELD: 48,
   LOG_APPEND_LOCK_HELD: 49,
   FLEET_MANIFEST_INVALID: 50,
-  SENSITIVE_CONTENT_DETECTED: 51
+  SENSITIVE_CONTENT_DETECTED: 51,
+  FLEET_SATELLITE_HEALTH_FAILED: 52
 };
 
 // ../shared/src/json-output.ts
@@ -1169,8 +1170,9 @@ var FRONTMATTER = /^---\n[\s\S]*?\n---\n?/;
 function stripFences(body) {
   return body.replace(FENCE2, "").replace(INLINE_CODE, "");
 }
+var TILDE_FENCE = /~~~[\s\S]*?~~~/g;
 function stripFencedBlocks(body) {
-  return body.replace(FENCE2, "");
+  return body.replace(FENCE2, "").replace(TILDE_FENCE, "");
 }
 function extractCitationMarkers(body) {
   const stripped = stripFences(body);
@@ -2292,25 +2294,6 @@ async function defaultRcloneRunner(args) {
   }
 }
 
-// src/commands/lint.ts
-import { existsSync as existsSync4 } from "fs";
-import { readFile as readFile12, readdir as readdir3 } from "fs/promises";
-import { createHash as createHash4 } from "crypto";
-import { join as join15, relative as relative3, sep as sep3 } from "path";
-
-// src/commands/sparse-community.ts
-async function runSparseCommunity(input) {
-  const scan = await scanVault(input.vault);
-  if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
-  const adjacency = await buildWikilinkAdjacency(scan.data.typedKnowledge);
-  const communities = findSparseCommunities(adjacency, {
-    minSize: input.minSize,
-    maxCohesion: input.maxCohesion
-  });
-  const humanHint = communities.length === 0 ? "no sparse communities" : communities.map((c) => `  cohesion ${c.cohesion} (${c.size} pages): ${c.action}`).join("\n");
-  return { exitCode: ExitCode.OK, result: ok({ communities, humanHint }) };
-}
-
 // src/utils/safe-write.ts
 import { open, readFile as readFile10, rename as rename3, unlink, writeFile as writeFile5 } from "fs/promises";
 import { randomBytes } from "crypto";
@@ -2386,6 +2369,101 @@ async function safeWritePage(absPath, newContent, opts = {}) {
   }
 }
 
+// src/commands/frontmatter-fix.ts
+function isoToday() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function fixFrontmatter(rawFm) {
+  const additions = [];
+  if (!/^created:/m.test(rawFm)) additions.push(`created: ${isoToday()}`);
+  if (!/^updated:/m.test(rawFm)) additions.push(`updated: ${isoToday()}`);
+  if (!/^tags:/m.test(rawFm)) additions.push("tags: []");
+  if (!/^sources:/m.test(rawFm)) additions.push("sources: []");
+  if (!/^provenance:/m.test(rawFm)) additions.push("provenance: research");
+  if (additions.length === 0) return rawFm;
+  return rawFm.trimEnd() + "\n" + additions.join("\n") + "\n";
+}
+function removeOrphanTagsLines(body) {
+  return body.split("\n").filter((line) => !/^tags:\s*\[/.test(line.trim())).join("\n");
+}
+async function runFrontmatterFix(input) {
+  const scan = await scanVault(input.vault);
+  if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
+  const fixed = [];
+  const skipped = [];
+  let unchanged = 0;
+  for (const page of scan.data.typedKnowledge) {
+    const text = await readPage(page);
+    const split = splitFrontmatter(text);
+    if (!split.ok) {
+      skipped.push(page.relPath);
+      continue;
+    }
+    const { rawFrontmatter, body } = split.data;
+    const newFm = fixFrontmatter(rawFrontmatter);
+    const newBody = removeOrphanTagsLines(body);
+    const newText = `---
+${newFm}
+---
+${newBody}`;
+    if (newText === text) {
+      unchanged++;
+      continue;
+    }
+    if (!input.dryRun) {
+      const w = await safeWritePage(page.absPath, newText);
+      if (!w.ok) {
+        skipped.push(page.relPath);
+        continue;
+      }
+    }
+    fixed.push(page.relPath);
+  }
+  const exitCode = fixed.length > 0 ? ExitCode.MIGRATION_APPLIED : ExitCode.OK;
+  const hintLines = [`scanned: ${fixed.length + skipped.length + unchanged}`];
+  if (fixed.length > 0) hintLines.push(`fixed: ${fixed.length}`);
+  if (skipped.length > 0) hintLines.push(`skipped (parse error): ${skipped.length}`);
+  if (unchanged > 0) hintLines.push(`unchanged: ${unchanged}`);
+  if (input.dryRun && fixed.length > 0) hintLines.push("(dry run \u2014 no files written)");
+  if (!input.dryRun && fixed.length > 0) {
+    appendLastOp(input.vault, {
+      operation: "frontmatter-fix",
+      summary: `normalized frontmatter on ${fixed.length} page(s)`,
+      files: fixed,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  return {
+    exitCode,
+    result: ok({
+      scanned: fixed.length + skipped.length + unchanged,
+      fixed,
+      skipped,
+      unchanged,
+      humanHint: hintLines.join("\n")
+    })
+  };
+}
+
+// src/commands/lint.ts
+import { existsSync as existsSync4 } from "fs";
+import { readFile as readFile12, readdir as readdir3 } from "fs/promises";
+import { createHash as createHash4 } from "crypto";
+import { join as join15, relative as relative3, sep as sep3 } from "path";
+
+// src/commands/sparse-community.ts
+async function runSparseCommunity(input) {
+  const scan = await scanVault(input.vault);
+  if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
+  const adjacency = await buildWikilinkAdjacency(scan.data.typedKnowledge);
+  const communities = findSparseCommunities(adjacency, {
+    minSize: input.minSize,
+    maxCohesion: input.maxCohesion
+  });
+  const humanHint = communities.length === 0 ? "no sparse communities" : communities.map((c) => `  cohesion ${c.cohesion} (${c.size} pages): ${c.action}`).join("\n");
+  return { exitCode: ExitCode.OK, result: ok({ communities, humanHint }) };
+}
+
 // src/commands/raw-body-dedup.ts
 import { createHash as createHash3 } from "crypto";
 async function runRawBodyDedup(vault) {
@@ -2684,6 +2762,7 @@ function buildCliSurface() {
   const fleetCmd = program.commands.find((c) => c.name() === "fleet");
   fleetCmd.command("validate");
   fleetCmd.command("context").option("--file <path>").option("--host-id <id>");
+  fleetCmd.command("health").option("--file <path>").option("--host-id <id>").option("--json");
   const surface = /* @__PURE__ */ new Map();
   const rootFlags = new Set(program.options.map((o) => o.long ?? o.short).filter((f) => f != null));
   function walk2(cmd, prefix, parentFlags) {
@@ -2844,6 +2923,23 @@ function hasDuplicateFrontmatter(body) {
   }
   return false;
 }
+var CANONICAL_LOCAL_SOURCE_LABEL = /^\s*(?:>\s*)?(?:[-*+]\s*)?Source (?:file|inspected):/i;
+var LOCAL_ABSOLUTE_SOURCE_REF = /(?:file:\/\/(?:\/)?(?:Users|home)\/|\/(?:Users|home)\/)/;
+function hasCanonicalLocalSourceAssertion(body) {
+  const visibleBody = stripFencedBlocks(body);
+  return visibleBody.split(/\r?\n/).some(
+    (line) => CANONICAL_LOCAL_SOURCE_LABEL.test(line) && LOCAL_ABSOLUTE_SOURCE_REF.test(line)
+  );
+}
+function shouldCheckCanonicalLocalSourceAssertion(page) {
+  if (page.relPath.startsWith("raw/transcripts/")) return false;
+  if (/^projects\/[^/]+\/work\/[^/]+\/log\.md$/.test(page.relPath)) return false;
+  if (page.relPath.startsWith("raw/")) return true;
+  if (/^(entities|concepts|comparisons|queries|meta)\//.test(page.relPath)) return true;
+  if (/^projects\/[^/]+\/compound\//.test(page.relPath)) return true;
+  if (/^projects\/[^/]+\/work\/[^/]+\/(spec|plan)\.md$/.test(page.relPath)) return true;
+  return false;
+}
 function extractSourceEntries(rawFm) {
   const lines = rawFm.split(/\r?\n/);
   const sourcesLineIdx = lines.findIndex((l) => /^sources:/.test(l));
@@ -2862,7 +2958,7 @@ function extractSourceEntries(rawFm) {
   return entries;
 }
 var ERROR_ORDER = ["sensitive_content", "broken_wikilinks", "invalid_frontmatter", "raw_source_identity_conflict", "raw_dedup", "broken_sources", "tag_not_in_taxonomy", "path_too_long"];
-var WARNING_ORDER = ["raw_body_duplicate", "raw_subdirectory_duplicate", "file_source_url", "index_incomplete", "index_link_format", "stale_page", "page_too_large", "log_rotate_needed", "orphans", "compound_refs", "legacy_citation_style", "orphaned_citations", "duplicate_frontmatter", "work_item_health", "orphaned_project_pages", "missing_overview", "missing_diagram"];
+var WARNING_ORDER = ["raw_body_duplicate", "raw_subdirectory_duplicate", "file_source_url", "index_incomplete", "index_link_format", "stale_page", "page_too_large", "log_rotate_needed", "orphans", "compound_refs", "legacy_citation_style", "orphaned_citations", "duplicate_frontmatter", "frontmatter_yaml_invalid", "work_item_health", "orphaned_project_pages", "missing_overview", "missing_diagram"];
 var INFO_ORDER = ["bridges", "sparse_community", "page_structure", "topic_map_recommended", "frontmatter_wikilink", "wikilink_citation", "missing_tldr", "stale_sections", "cli_refs"];
 var KNOWN_BUCKETS = [...ERROR_ORDER, ...WARNING_ORDER, ...INFO_ORDER];
 var CLI_REFS_TYPED_DIRS = ["entities", "concepts", "comparisons", "queries", "meta"];
@@ -3082,6 +3178,20 @@ async function runLint(input) {
       }
     }
     if (sensitiveFlags.length > 0) buckets.sensitive_content = sensitiveFlags;
+    const fmYamlInvalid = [];
+    for (const page of scan.data.allMarkdown) {
+      try {
+        const text = await readPage(page);
+        const fm = extractFrontmatter(text);
+        if (!fm.ok && fm.error === "INVALID_FRONTMATTER") {
+          const detail = fm.detail;
+          const message = detail?.message ?? "invalid YAML";
+          fmYamlInvalid.push({ path: page.relPath, message });
+        }
+      } catch {
+      }
+    }
+    if (fmYamlInvalid.length > 0) buckets.frontmatter_yaml_invalid = fmYamlInvalid;
     const subDirDupes = [];
     const flatStems = /* @__PURE__ */ new Map();
     const deepFiles = [];
@@ -3104,14 +3214,18 @@ async function runLint(input) {
     if (subDirDupes.length > 0) {
       buckets.raw_subdirectory_duplicate = subDirDupes;
     }
-    const fileSourceUrlFlags = [];
+    const fileSourceUrlFlags = /* @__PURE__ */ new Set();
+    const fileSourceUrlFrontmatterFlags = /* @__PURE__ */ new Set();
     const rawIdentityConflicts = [];
+    const rawPageBodyByPath = /* @__PURE__ */ new Map();
     for (const raw of scan.data.raw) {
       const text = await readPage(raw);
       const split = splitFrontmatter(text);
       if (!split.ok) continue;
+      rawPageBodyByPath.set(raw.relPath, split.data.body);
       if (/^source_url:\s*file:\/\//m.test(split.data.rawFrontmatter)) {
-        fileSourceUrlFlags.push(raw.relPath);
+        fileSourceUrlFlags.add(raw.relPath);
+        fileSourceUrlFrontmatterFlags.add(raw.relPath);
       }
       const sourceUrl = split.data.rawFrontmatter.match(/^source_url:\s*(.+)$/m)?.[1]?.trim().replace(/^["']|["']$/g, "") ?? "";
       const assessment = assessSourceIdentity({
@@ -3130,7 +3244,26 @@ async function runLint(input) {
         });
       }
     }
-    if (fileSourceUrlFlags.length > 0) buckets.file_source_url = fileSourceUrlFlags;
+    const canonicalSourcePages = [
+      ...scan.data.raw,
+      ...scan.data.typedKnowledge,
+      ...scan.data.compound,
+      ...scan.data.workItems
+    ];
+    for (const page of canonicalSourcePages) {
+      if (!shouldCheckCanonicalLocalSourceAssertion(page)) continue;
+      let body = rawPageBodyByPath.get(page.relPath);
+      if (body === void 0) {
+        const text = await readPage(page);
+        const split = splitFrontmatter(text);
+        if (!split.ok) continue;
+        body = split.data.body;
+      }
+      if (hasCanonicalLocalSourceAssertion(body)) {
+        fileSourceUrlFlags.add(page.relPath);
+      }
+    }
+    if (fileSourceUrlFlags.size > 0) buckets.file_source_url = [...fileSourceUrlFlags];
     if (rawIdentityConflicts.length > 0) buckets.raw_source_identity_conflict = rawIdentityConflicts;
     const legacyPages = [];
     const orphanedPages = [];
@@ -3605,9 +3738,9 @@ ${newBody}`;
         else delete buckets.wikilink_citation;
       }
     }
-    if (shouldFix("file_source_url") && fileSourceUrlFlags.length > 0) {
+    if (shouldFix("file_source_url") && fileSourceUrlFrontmatterFlags.size > 0) {
       const FILE_FIXED = [];
-      for (const relPath of fileSourceUrlFlags) {
+      for (const relPath of fileSourceUrlFrontmatterFlags) {
         try {
           const absPath = `${input.vault}/${relPath}`;
           const raw = await readFile12(absPath, "utf8");
@@ -3638,9 +3771,26 @@ ${newBody}`;
       }
       fixed.push(...FILE_FIXED);
       if (FILE_FIXED.length > 0) {
-        const fixedSet = new Set(FILE_FIXED);
-        const remaining = fileSourceUrlFlags.filter((p) => !fixedSet.has(p));
-        if (remaining.length > 0) buckets.file_source_url = remaining;
+        const remaining = new Set(fileSourceUrlFlags);
+        for (const relPath of FILE_FIXED) {
+          try {
+            const page = scan.data.allMarkdown.find((p) => p.relPath === relPath);
+            if (!page) {
+              remaining.delete(relPath);
+              continue;
+            }
+            const text = await readPage(page);
+            const split = splitFrontmatter(text);
+            if (!split.ok) continue;
+            const stillHasFileSourceUrl = /^source_url:\s*file:\/\//m.test(split.data.rawFrontmatter);
+            const stillHasCanonicalBodyAssertion = shouldCheckCanonicalLocalSourceAssertion(page) && hasCanonicalLocalSourceAssertion(split.data.body);
+            if (!stillHasFileSourceUrl && !stillHasCanonicalBodyAssertion) {
+              remaining.delete(relPath);
+            }
+          } catch {
+          }
+        }
+        if (remaining.size > 0) buckets.file_source_url = [...remaining];
         else delete buckets.file_source_url;
       }
     }
@@ -3658,6 +3808,50 @@ ${newBody}`;
         else delete buckets.path_too_long;
       }
     }
+    if (shouldFix("frontmatter_yaml_invalid") && buckets.frontmatter_yaml_invalid) {
+      const invalidItems = buckets.frontmatter_yaml_invalid;
+      const remaining = [];
+      for (const item of invalidItems) {
+        const page = scan.data.allMarkdown.find((p) => p.relPath === item.path);
+        if (!page) {
+          unresolved.push(item.path);
+          remaining.push(item);
+          continue;
+        }
+        try {
+          const text = await readPage(page);
+          const split = splitFrontmatter(text);
+          if (!split.ok) {
+            unresolved.push(item.path);
+            remaining.push(item);
+            continue;
+          }
+          const newFm = fixFrontmatter(split.data.rawFrontmatter);
+          const newText = `---
+${newFm}
+---
+${split.data.body}`;
+          const recheck = extractFrontmatter(newText);
+          if (!recheck.ok) {
+            unresolved.push(item.path);
+            remaining.push(item);
+            continue;
+          }
+          const w = await safeWritePage(page.absPath, newText, { minBodyRatio: null });
+          if (!w.ok) {
+            unresolved.push(item.path);
+            remaining.push(item);
+            continue;
+          }
+          fixed.push(item.path);
+        } catch {
+          unresolved.push(item.path);
+          remaining.push(item);
+        }
+      }
+      if (remaining.length > 0) buckets.frontmatter_yaml_invalid = remaining;
+      else delete buckets.frontmatter_yaml_invalid;
+    }
   }
   const errorOut = ERROR_ORDER.flatMap((k) => buckets[k] ? [{ kind: k, items: buckets[k] }] : []);
   const warningOut = WARNING_ORDER.flatMap((k) => buckets[k] ? [{ kind: k, items: buckets[k] }] : []);
@@ -3905,7 +4099,7 @@ async function runFleetContext(input) {
       })
     };
   }
-  const resolved = await resolveHostId({
+  const resolved = await resolveFleetHostId({
     manifest: loaded.manifest,
     hostId: input.hostId,
     env,
@@ -3992,6 +4186,59 @@ async function runFleetContext(input) {
     })
   };
 }
+function fleetContextEnv(input) {
+  const env = input.env ?? process.env;
+  const home = input.home ?? env.HOME ?? "";
+  const osHostname = input.osHostname ?? safeEnvValue(env.HOSTNAME) ?? nodeHostname();
+  const vault = input.vault ?? safeEnvValue(env.WIKI_PATH);
+  const file = input.file ?? (vault ? join18(vault, FLEET_REL_PATH) : void 0);
+  return { env, home, osHostname, vault, file };
+}
+async function loadFleetManifestAndHost(input) {
+  const { env, home, osHostname, file } = fleetContextEnv(input);
+  if (!file) return null;
+  const loaded = await loadFleetManifest(file);
+  if (!loaded.ok) return null;
+  const resolved = await resolveFleetHostId({
+    manifest: loaded.manifest,
+    hostId: input.hostId,
+    env,
+    home,
+    osHostname
+  });
+  if (!resolved.hostId) {
+    return {
+      manifest: loaded.manifest,
+      hostId: void 0,
+      source: resolved.source,
+      warnings: ["host identity is unresolved"],
+      identityStatus: "unknown"
+    };
+  }
+  if (!loaded.manifest.hosts[resolved.hostId]) {
+    const source = resolved.source ?? "unknown";
+    return {
+      manifest: loaded.manifest,
+      hostId: resolved.hostId,
+      source: resolved.source,
+      warnings: [`resolved host id \`${resolved.hostId}\` from ${source} is not in fleet.yaml`],
+      identityStatus: "invalid"
+    };
+  }
+  return {
+    manifest: loaded.manifest,
+    hostId: resolved.hostId,
+    source: resolved.source,
+    warnings: [],
+    identityStatus: "known"
+  };
+}
+function satelliteGateFromFleetLoad(load) {
+  if (!load?.hostId) return { satelliteExpected: false };
+  const host = load.manifest.hosts[load.hostId];
+  if (!host) return { satelliteExpected: false };
+  return { satelliteExpected: host.maintenance?.skillwiki_satellite?.enabled === true };
+}
 async function loadFleetManifest(file) {
   let text;
   try {
@@ -4051,7 +4298,7 @@ function fleetWarnings(manifest) {
 function findSnapshotter(manifest) {
   return Object.entries(manifest.hosts).find(([, host]) => host.role === "snapshotter")?.[0];
 }
-async function resolveHostId(input) {
+async function resolveFleetHostId(input) {
   const trace = [];
   if (input.hostId) {
     trace.push({ source: "--host-id", status: "matched", value: input.hostId });
@@ -4242,8 +4489,8 @@ function safeUserName() {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync9, lstatSync, readlinkSync, readdirSync as readdirSync2, statSync, readFileSync as readFileSync6 } from "fs";
-import { join as join21, resolve as resolve5 } from "path";
+import { existsSync as existsSync10, lstatSync, readlinkSync, readdirSync as readdirSync2, statSync, readFileSync as readFileSync7 } from "fs";
+import { join as join22, resolve as resolve5 } from "path";
 import { execSync as execSync2 } from "child_process";
 import { platform as platform2 } from "os";
 
@@ -4365,11 +4612,66 @@ function parseTomlScalar(rawValue) {
   return value;
 }
 
+// src/utils/satellite-run-health.ts
+import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
+import { join as join20 } from "path";
+var SATELLITE_STALE_MS = 26 * 60 * 60 * 1e3;
+function satelliteLatestRunPath(vault) {
+  return join20(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 (!existsSync8(latestPath)) return null;
+  try {
+    return parseLatestRunFile(readFileSync5(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/utils/s3-mount-health.ts
 import { execSync } from "child_process";
 import { platform } from "os";
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, unlinkSync as unlinkSync3, readFileSync as readFile15 } from "fs";
-import { join as join20 } from "path";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, unlinkSync as unlinkSync3, readFileSync as readFile15 } from "fs";
+import { join as join21 } from "path";
 var OS = platform();
 function findRcloneMountPid() {
   try {
@@ -4453,7 +4755,7 @@ function extractRcloneFs(args) {
 function getRcloneArgs(pid) {
   try {
     if (OS === "linux") {
-      const raw = readFileSync5(`/proc/${pid}/cmdline`);
+      const raw = readFileSync6(`/proc/${pid}/cmdline`);
       return new TextDecoder().decode(raw).split("\0").filter(Boolean);
     } else {
       const out = execSync(`ps -o args= -p ${pid}`, {
@@ -4496,7 +4798,7 @@ function queryRcloneRC(rcAddr, fs) {
 function detectFuseMount(vaultPath) {
   try {
     if (OS === "linux") {
-      const mounts = readFileSync5("/proc/mounts", "utf8");
+      const mounts = readFileSync6("/proc/mounts", "utf8");
       let best = null;
       for (const line of mounts.split("\n")) {
         const parts = line.split(" ");
@@ -4527,7 +4829,7 @@ function detectFuseMount(vaultPath) {
   return null;
 }
 function writeTest(dir) {
-  const testFile = join20(dir, `.doctor-write-test-${process.pid}.tmp`);
+  const testFile = join21(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 {
@@ -4627,13 +4929,13 @@ function detectCliChannels(argv, home) {
   }
   const plugin = findPlugin(home);
   if (plugin) {
-    const pluginBin = join21(plugin.installPath, "bin", "skillwiki");
-    if (existsSync9(pluginBin)) {
+    const pluginBin = join22(plugin.installPath, "bin", "skillwiki");
+    if (existsSync10(pluginBin)) {
       channels.push({ name: "plugin", path: pluginBin, isDevLink: false });
     }
   }
-  const installBin = join21(home, ".claude", "skills", "bin", "skillwiki");
-  if (existsSync9(installBin)) {
+  const installBin = join22(home, ".claude", "skills", "bin", "skillwiki");
+  if (existsSync10(installBin)) {
     channels.push({ name: "install", path: installBin, isDevLink: false });
   }
   return channels;
@@ -4694,7 +4996,7 @@ function isDevSourceRun(argv) {
 }
 async function checkConfigFile(home) {
   const cfgPath = configPath(home);
-  if (!existsSync9(cfgPath)) {
+  if (!existsSync10(cfgPath)) {
     return check("warn", "config_file", "Config file exists", `${cfgPath} not found`);
   }
   try {
@@ -4709,7 +5011,7 @@ function checkWikiPathExists(resolvedPath) {
   if (resolvedPath === void 0) {
     return check("error", "wiki_path_exists", "Vault directory exists", "Cannot check \u2014 WIKI_PATH not resolved");
   }
-  if (existsSync9(resolvedPath) && statSync(resolvedPath).isDirectory()) {
+  if (existsSync10(resolvedPath) && statSync(resolvedPath).isDirectory()) {
     return check("pass", "wiki_path_exists", "Vault directory exists", resolvedPath);
   }
   return check("error", "wiki_path_exists", "Vault directory exists", `${resolvedPath} does not exist or is not a directory`);
@@ -4718,13 +5020,13 @@ function checkVaultStructure(resolvedPath) {
   if (resolvedPath === void 0) {
     return check("error", "vault_structure", "Vault structure valid", "Cannot check \u2014 WIKI_PATH not resolved");
   }
-  if (!existsSync9(resolvedPath)) {
+  if (!existsSync10(resolvedPath)) {
     return check("error", "vault_structure", "Vault structure valid", "Cannot check \u2014 vault directory does not exist");
   }
   const missing = [];
-  if (!existsSync9(join21(resolvedPath, "SCHEMA.md"))) missing.push("SCHEMA.md");
+  if (!existsSync10(join22(resolvedPath, "SCHEMA.md"))) missing.push("SCHEMA.md");
   for (const dir of ["raw", "entities", "concepts", "meta"]) {
-    if (!existsSync9(join21(resolvedPath, dir))) missing.push(dir + "/");
+    if (!existsSync10(join22(resolvedPath, dir))) missing.push(dir + "/");
   }
   if (missing.length === 0) {
     return check("pass", "vault_structure", "Vault structure valid", "All required files and directories present");
@@ -4732,8 +5034,8 @@ function checkVaultStructure(resolvedPath) {
   return check("warn", "vault_structure", "Vault structure valid", `Missing: ${missing.join(", ")} \u2014 run \`skillwiki init\` to add CodeWiki structure`);
 }
 function checkSkillsInstalled(home, cwd) {
-  const srcDir = cwd ? join21(cwd, "packages", "skills") : void 0;
-  if (srcDir && existsSync9(srcDir)) {
+  const srcDir = cwd ? join22(cwd, "packages", "skills") : void 0;
+  if (srcDir && existsSync10(srcDir)) {
     const found = findInstalledSkillMd(srcDir);
     if (found.length > 0) {
       return check("pass", "skills_installed", "Skills installed", `${found.length} SKILL.md file(s) found (source)`);
@@ -4746,8 +5048,8 @@ function checkSkillsInstalled(home, cwd) {
       return check("pass", "skills_installed", "Skills installed", `${found.length} SKILL.md file(s) found (plugin v${plugin.version})`);
     }
   }
-  const skillsDir = join21(home, ".claude", "skills");
-  if (existsSync9(skillsDir)) {
+  const skillsDir = join22(home, ".claude", "skills");
+  if (existsSync10(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)`);
@@ -4757,10 +5059,10 @@ function checkSkillsInstalled(home, cwd) {
 }
 function checkDuplicateSkills(home) {
   const plugin = findPlugin(home);
-  const skillsDir = join21(home, ".claude", "skills");
+  const skillsDir = join22(home, ".claude", "skills");
   const agentSkillDirs = [
-    { label: "~/.codex/skills/", path: join21(home, ".codex", "skills") },
-    { label: "~/.agents/skills/", path: join21(home, ".agents", "skills") }
+    { label: "~/.codex/skills/", path: join22(home, ".codex", "skills") },
+    { label: "~/.agents/skills/", path: join22(home, ".agents", "skills") }
   ];
   if (!plugin) {
     return check("pass", "skills_duplicate", "Skills not duplicated", "Single install channel");
@@ -4863,8 +5165,8 @@ async function checkProfiles(home) {
 }
 async function checkProjectLocalOverride(cwd) {
   const dir = cwd ?? process.cwd();
-  const envPath = join21(dir, ".skillwiki", ".env");
-  if (existsSync9(envPath)) {
+  const envPath = join22(dir, ".skillwiki", ".env");
+  if (existsSync10(envPath)) {
     return check("pass", "project_local", "Project-local config", `Found: ${envPath}`);
   }
   return check("pass", "project_local", "Project-local config", "None");
@@ -4873,7 +5175,7 @@ function checkVaultGitRemote(resolvedPath) {
   if (resolvedPath === void 0) {
     return check("error", "vault_git_remote", "Vault git remote", "Cannot check \u2014 WIKI_PATH not resolved");
   }
-  if (!existsSync9(join21(resolvedPath, ".git"))) {
+  if (!existsSync10(join22(resolvedPath, ".git"))) {
     return check("warn", "vault_git_remote", "Vault git remote", "Vault is not a git repository \u2014 sync features unavailable");
   }
   try {
@@ -4896,9 +5198,9 @@ function checkObsidianTemplates(resolvedPath) {
     return check("error", "obsidian_templates", "Obsidian templates", "Cannot check \u2014 WIKI_PATH not resolved");
   }
   const missing = [];
-  if (!existsSync9(join21(resolvedPath, "_Templates"))) missing.push("_Templates/");
-  if (!existsSync9(join21(resolvedPath, ".obsidian", "templates.json"))) missing.push(".obsidian/templates.json");
-  if (!existsSync9(join21(resolvedPath, ".obsidian", "app.json"))) missing.push(".obsidian/app.json");
+  if (!existsSync10(join22(resolvedPath, "_Templates"))) missing.push("_Templates/");
+  if (!existsSync10(join22(resolvedPath, ".obsidian", "templates.json"))) missing.push(".obsidian/templates.json");
+  if (!existsSync10(join22(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");
   }
@@ -4908,8 +5210,8 @@ function checkDotStoreClean(resolvedPath) {
   if (resolvedPath === void 0) {
     return check("error", "dsstore_clean", "No .DS_Store in raw/", "Cannot check \u2014 WIKI_PATH not resolved");
   }
-  const rawDir = join21(resolvedPath, "raw");
-  if (!existsSync9(rawDir)) {
+  const rawDir = join22(resolvedPath, "raw");
+  if (!existsSync10(rawDir)) {
     return check("pass", "dsstore_clean", "No .DS_Store in raw/", "raw/ directory not found \u2014 check skipped");
   }
   const found = [];
@@ -4924,7 +5226,7 @@ function checkDotStoreClean(resolvedPath) {
       if (entry.name === ".DS_Store") {
         found.push(rel ? `${rel}/.DS_Store` : ".DS_Store");
       } else if (entry.isDirectory()) {
-        walk2(join21(dir, entry.name), rel ? `${rel}/${entry.name}` : entry.name);
+        walk2(join22(dir, entry.name), rel ? `${rel}/${entry.name}` : entry.name);
       }
     }
   })(rawDir, "");
@@ -4937,7 +5239,7 @@ function checkSyncLastPush(resolvedPath) {
   if (resolvedPath === void 0) {
     return check("error", "sync_last_push", "Vault sync recency", "Cannot check \u2014 WIKI_PATH not resolved");
   }
-  if (!existsSync9(join21(resolvedPath, ".git"))) {
+  if (!existsSync10(join22(resolvedPath, ".git"))) {
     return check("pass", "sync_last_push", "Vault sync recency", "No git repo \u2014 sync check skipped");
   }
   let timestamp;
@@ -4985,7 +5287,7 @@ function checkVaultGitDirty(resolvedPath) {
   if (resolvedPath === void 0) {
     return check("pass", "vault_git_dirty", "Vault git dirty state", "No vault path \u2014 check skipped");
   }
-  if (!existsSync9(join21(resolvedPath, ".git"))) {
+  if (!existsSync10(join22(resolvedPath, ".git"))) {
     return check("pass", "vault_git_dirty", "Vault git dirty state", "No git repo \u2014 check skipped");
   }
   try {
@@ -5053,7 +5355,7 @@ function remoteMainHash(resolvedPath) {
 }
 function checkStaleRemoteMain(resolvedPath) {
   if (resolvedPath === void 0) return void 0;
-  if (!existsSync9(join21(resolvedPath, ".git"))) return void 0;
+  if (!existsSync10(join22(resolvedPath, ".git"))) return void 0;
   const localOrigin = gitRefHash(resolvedPath, "origin/main");
   if (!localOrigin) return void 0;
   const remoteMain = remoteMainHash(resolvedPath);
@@ -5069,7 +5371,7 @@ function checkVaultGitComparison(resolvedPath, id, label, range, nonZeroSuffix,
   if (resolvedPath === void 0) {
     return check("pass", id, label, "No vault path \u2014 check skipped");
   }
-  if (!existsSync9(join21(resolvedPath, ".git"))) {
+  if (!existsSync10(join22(resolvedPath, ".git"))) {
     return check("pass", id, label, "No git repo \u2014 check skipped");
   }
   if (!hasOriginMain(resolvedPath)) {
@@ -5089,11 +5391,84 @@ function checkVaultGitComparison(resolvedPath, id, label, range, nonZeroSuffix,
     return check("warn", id, label, "Could not compare HEAD with origin/main");
   }
 }
+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 (!existsSync10(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: () => platform2(),
+    systemctlIsActive: (unit) => {
+      try {
+        return execSync2(`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"}`
+  );
+}
 async function checkFleetIdentity(input) {
   if (!input.vaultPath) {
     return check("pass", "fleet_identity", "Fleet identity", "No vault path \u2014 check skipped");
   }
-  const r = await runFleetContext({
+  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,
@@ -5101,26 +5476,22 @@ async function checkFleetIdentity(input) {
     osHostname: process.env.HOSTNAME,
     user: process.env.USER
   });
-  if (!r.result.ok) {
-    return check("warn", "fleet_identity", "Fleet identity", "Could not evaluate fleet identity");
-  }
-  const data = r.result.data;
-  if (!data.manifest_loaded) {
+  if (!load) {
     return check("pass", "fleet_identity", "Fleet identity", "Fleet manifest unavailable \u2014 check skipped");
   }
-  if (data.identity_status === "known") {
-    return check("pass", "fleet_identity", "Fleet identity", `Resolved ${data.host_id ?? "unknown"} via ${data.source ?? "unknown"}`);
+  if (load.identityStatus === "known") {
+    return check("pass", "fleet_identity", "Fleet identity", `Resolved ${load.hostId ?? "unknown"} via ${load.source ?? "unknown"}`);
   }
-  const detail = data.warnings.length > 0 ? data.warnings.join("; ") : "Fleet identity is unresolved";
+  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" ? [
-    join21(home, "Library", "Logs", "wiki-pull.log"),
-    join21(home, ".local", "state", "vault-sync", "log", "wiki-pull.log")
+    join22(home, "Library", "Logs", "wiki-pull.log"),
+    join22(home, ".local", "state", "vault-sync", "log", "wiki-pull.log")
   ] : [
-    join21(home, ".local", "state", "vault-sync", "log", "wiki-pull.log"),
-    join21(home, "Library", "Logs", "wiki-pull.log")
+    join22(home, ".local", "state", "vault-sync", "log", "wiki-pull.log"),
+    join22(home, "Library", "Logs", "wiki-pull.log")
   ];
   return [...new Set(paths)];
 }
@@ -5132,12 +5503,12 @@ function isRecentLogLine(line, nowMs) {
   return nowMs - ts <= 24 * 60 * 60 * 1e3;
 }
 function checkVaultGitPullFailures(home) {
-  const path = pullLogPaths(home).find((p) => existsSync9(p));
+  const path = pullLogPaths(home).find((p) => existsSync10(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 lines = readFileSync7(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)
@@ -5160,8 +5531,8 @@ function checkS3MountPerf(resolvedPath) {
     return check("pass", "s3_mount_perf", "S3 mount performance", "local disk");
   }
   const mountPoint = fuse.mountPoint;
-  const conceptsDir = join21(resolvedPath, "concepts");
-  if (!existsSync9(conceptsDir)) {
+  const conceptsDir = join22(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();
@@ -5343,8 +5714,8 @@ function checkWriteTest(resolvedPath) {
   if (!fuse) {
     return check("pass", "s3_write_test", "S3 write test", "local disk \u2014 check skipped");
   }
-  const conceptsDir = join21(resolvedPath, "concepts");
-  if (!existsSync9(conceptsDir)) {
+  const conceptsDir = join22(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);
@@ -5430,7 +5801,7 @@ function checkVfsCacheHealth(resolvedPath) {
 }
 function readVaultSyncConfig(home) {
   try {
-    const content = readFileSync6(join21(home, ".skillwiki", ".env"), "utf8");
+    const content = readFileSync7(join22(home, ".skillwiki", ".env"), "utf8");
     let installed = false;
     let role;
     let serviceScope;
@@ -5459,7 +5830,7 @@ function readVaultSyncConfig(home) {
 }
 function readKeyFromEnvFile(path, keys) {
   try {
-    const content = readFileSync6(path, "utf8");
+    const content = readFileSync7(path, "utf8");
     for (const line of content.split(/\r?\n/)) {
       const trimmed = line.trim();
       if (trimmed.length === 0 || trimmed.startsWith("#")) continue;
@@ -5481,7 +5852,7 @@ function resolveSnapshotGitWorktree(config) {
     if (fromProfile) return fromProfile;
   }
   const defaultPath = "/root/wiki-git";
-  return existsSync9(defaultPath) ? defaultPath : void 0;
+  return existsSync10(defaultPath) ? defaultPath : void 0;
 }
 function vaultSyncChecks(input) {
   const os = input.os ?? platform2();
@@ -5498,16 +5869,16 @@ function vaultSyncChecks(input) {
     ];
   }
   const isMac = os === "darwin";
-  const logDir = input.logDir ?? (isMac ? join21(home, "Library", "Logs") : join21(home, ".local", "state", "vault-sync", "log"));
-  const shareDir = input.shareDir ?? (isMac ? join21(home, "Library", "Application Support", "vault-sync", "bin") : join21(home, ".local", "share", "vault-sync", "bin"));
-  const filterPath = input.filterPath ?? join21(home, ".config", "rclone", "wiki-push-filters.txt");
-  const packagedSnapshotPath = join21(shareDir, "wiki-snapshot.sh");
+  const logDir = input.logDir ?? (isMac ? join22(home, "Library", "Logs") : join22(home, ".local", "state", "vault-sync", "log"));
+  const shareDir = input.shareDir ?? (isMac ? join22(home, "Library", "Application Support", "vault-sync", "bin") : join22(home, ".local", "share", "vault-sync", "bin"));
+  const filterPath = input.filterPath ?? join22(home, ".config", "rclone", "wiki-push-filters.txt");
+  const packagedSnapshotPath = join22(shareDir, "wiki-snapshot.sh");
   const legacySnapshotPath = "/root/.hermes/scripts/wiki-snapshot-v3.sh";
-  const snapshotPath = input.snapshotScriptPath ?? (existsSync9(packagedSnapshotPath) ? packagedSnapshotPath : legacySnapshotPath);
+  const snapshotPath = input.snapshotScriptPath ?? (existsSync10(packagedSnapshotPath) ? packagedSnapshotPath : legacySnapshotPath);
   function snapshotLastStatusCheck() {
-    const snapshotLog = join21(logDir, "wiki-snapshot.log");
+    const snapshotLog = join22(logDir, "wiki-snapshot.log");
     try {
-      const logContent = readFileSync6(snapshotLog, "utf8");
+      const logContent = readFileSync7(snapshotLog, "utf8");
       const lines = logContent.trim().split("\n").filter(Boolean);
       if (lines.length === 0) {
         return check(
@@ -5552,14 +5923,14 @@ function vaultSyncChecks(input) {
     }
   }
   if (input.vaultSyncRole === "snapshotter") {
-    const c12 = existsSync9(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 = existsSync10(snapshotPath) ? check("pass", "vault_sync_installed", "Vault sync installed", `Found snapshot script: ${snapshotPath}`) : check("error", "vault_sync_installed", "Vault sync installed", `Snapshot script not found at ${snapshotPath}`);
     const serviceScope = input.vaultSyncServiceScope ?? "user";
-    const userTimerPath = join21(home, ".config", "systemd", "user", "wiki-snapshot.timer");
+    const userTimerPath = join22(home, ".config", "systemd", "user", "wiki-snapshot.timer");
     const systemTimerPath = "/etc/systemd/system/wiki-snapshot.timer";
     let c22;
-    if (serviceScope === "user" && existsSync9(userTimerPath)) {
+    if (serviceScope === "user" && existsSync10(userTimerPath)) {
       c22 = check("pass", "vault_sync_jobs_enabled", "Vault sync jobs enabled", `Found: ${userTimerPath}`);
-    } else if (serviceScope === "system" && existsSync9(systemTimerPath)) {
+    } else if (serviceScope === "system" && existsSync10(systemTimerPath)) {
       c22 = check("pass", "vault_sync_jobs_enabled", "Vault sync jobs enabled", `Found: ${systemTimerPath}`);
     } else if (os !== "linux") {
       c22 = check("warn", "vault_sync_jobs_enabled", "Vault sync jobs enabled", "Snapshotter scheduler is Linux-only and no wiki-snapshot.timer file was found");
@@ -5591,7 +5962,7 @@ function vaultSyncChecks(input) {
     );
     let c52;
     try {
-      if (!existsSync9(snapshotPath)) {
+      if (!existsSync10(snapshotPath)) {
         c52 = check(
           "error",
           "vault_sync_snapshot_guard",
@@ -5599,7 +5970,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",
@@ -5626,8 +5997,8 @@ function vaultSyncChecks(input) {
     }
     return [c12, c22, c32, cFetch2, c42, c52];
   }
-  const pushScriptPath = join21(shareDir, "wiki-push.sh");
-  const c1 = existsSync9(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 = join22(shareDir, "wiki-push.sh");
+  const c1 = existsSync10(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) {
@@ -5678,10 +6049,10 @@ function vaultSyncChecks(input) {
       "Scheduler check failed \u2014 run vault-sync-install"
     );
   }
-  const logFile = join21(logDir, "wiki-push.log");
+  const logFile = join22(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(
@@ -5737,7 +6108,7 @@ function vaultSyncChecks(input) {
       }
     }
   } catch {
-    c3 = existsSync9(logDir) ? check(
+    c3 = existsSync10(logDir) ? check(
       "warn",
       "vault_sync_last_push_age",
       "Vault sync last push recency",
@@ -5749,10 +6120,10 @@ function vaultSyncChecks(input) {
       `Log directory not found at ${logDir}`
     );
   }
-  const fetchLogFile = join21(logDir, "wiki-fetch.log");
+  const fetchLogFile = join22(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(
@@ -5796,7 +6167,7 @@ function vaultSyncChecks(input) {
   }
   let c4;
   try {
-    if (!existsSync9(filterPath)) {
+    if (!existsSync10(filterPath)) {
       c4 = check(
         "error",
         "vault_sync_filter_present",
@@ -5804,7 +6175,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",
@@ -5847,7 +6218,7 @@ function vaultSyncChecks(input) {
     );
   } else {
     try {
-      if (!existsSync9(snapshotPath)) {
+      if (!existsSync10(snapshotPath)) {
         c5 = check(
           "error",
           "vault_sync_snapshot_guard",
@@ -5855,7 +6226,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",
@@ -5893,15 +6264,15 @@ function findSkillMd(dir) {
   }
   for (const entry of entries) {
     if (entry.isFile() && entry.name === "SKILL.md") {
-      results.push(join21(dir, entry.name));
+      results.push(join22(dir, entry.name));
     } else if (entry.isDirectory()) {
-      results.push(...findSkillMd(join21(dir, entry.name)));
+      results.push(...findSkillMd(join22(dir, entry.name)));
     }
   }
   return results;
 }
 function findInstalledSkillMd(dir) {
-  const directSkills = findSkillNames(dir).map((name) => join21(dir, name, "SKILL.md"));
+  const directSkills = findSkillNames(dir).map((name) => join22(dir, name, "SKILL.md"));
   return directSkills.length > 0 ? directSkills : findSkillMd(dir);
 }
 function findSkillNames(dir) {
@@ -5913,7 +6284,7 @@ function findSkillNames(dir) {
     return results;
   }
   for (const entry of entries) {
-    if (entry.isDirectory() && existsSync9(join21(dir, entry.name, "SKILL.md"))) {
+    if (entry.isDirectory() && existsSync10(join22(dir, entry.name, "SKILL.md"))) {
       results.push(entry.name);
     }
   }
@@ -5957,7 +6328,7 @@ async function vaultMetrics(resolvedPath) {
   }
   let logLines = 0;
   try {
-    logLines = readFileSync6(join21(resolvedPath, "log.md"), "utf8").split("\n").length;
+    logLines = readFileSync7(join22(resolvedPath, "log.md"), "utf8").split("\n").length;
   } catch {
   }
   return [
@@ -5989,11 +6360,20 @@ async function runDoctor(input) {
   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
+    envValue: input.envValue,
+    fleetLoad
   }));
   checks.push(checkSyncLastPush(gitCheckPath));
   checks.push(checkVaultGitDirty(gitCheckPath));
@@ -6018,6 +6398,9 @@ async function runDoctor(input) {
     vaultSyncServiceScope: vsConfig.serviceScope,
     snapshotScriptPath: vsConfig.snapshotScript
   }));
+  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,
@@ -6042,7 +6425,7 @@ async function runDoctor(input) {
 }
 
 // src/utils/package-info.ts
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 function packageJsonCandidateUrls(baseUrl = import.meta.url) {
   return [
     new URL("../package.json", baseUrl),
@@ -6052,7 +6435,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(readFileSync8(url, "utf8"));
       if (typeof pkg.version === "string") {
         return { ...pkg, version: pkg.version };
       }
@@ -6064,11 +6447,11 @@ function readCliPackageJson(baseUrl = import.meta.url) {
 
 // src/commands/project-index.ts
 import { readdir as readdir4, readFile as readFile16, writeFile as writeFile6, mkdir as mkdir5 } from "fs/promises";
-import { join as join22, dirname as dirname8 } from "path";
+import { join as join23, dirname as dirname8 } from "path";
 var LAYER2_DIRS = ["entities", "concepts", "comparisons", "queries", "meta"];
 async function runProjectIndex(input) {
   const slug = input.slug;
-  const projectDir = join22(input.vault, "projects", slug);
+  const projectDir = join23(input.vault, "projects", slug);
   try {
     await readdir4(projectDir);
   } catch {
@@ -6079,12 +6462,12 @@ async function runProjectIndex(input) {
   }
   const wikilinkPattern = `[[${slug}]]`;
   const entries = [];
-  const compoundDir = join22(input.vault, "projects", slug, "compound");
+  const compoundDir = join23(input.vault, "projects", slug, "compound");
   try {
     const compoundFiles = await readdir4(compoundDir, { withFileTypes: true });
     for (const entry of compoundFiles) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const filePath = join22(compoundDir, entry.name);
+      const filePath = join23(compoundDir, entry.name);
       let text;
       try {
         text = await readFile16(filePath, "utf8");
@@ -6104,13 +6487,13 @@ async function runProjectIndex(input) {
   for (const dir of LAYER2_DIRS) {
     let files;
     try {
-      files = await readdir4(join22(input.vault, dir), { withFileTypes: true });
+      files = await readdir4(join23(input.vault, dir), { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of files) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const filePath = join22(input.vault, dir, entry.name);
+      const filePath = join23(input.vault, dir, entry.name);
       let text;
       try {
         text = await readFile16(filePath, "utf8");
@@ -6134,7 +6517,7 @@ async function runProjectIndex(input) {
     const tb = typeOrder[b.type] ?? 99;
     return ta !== tb ? ta - tb : a.title.localeCompare(b.title);
   });
-  const indexPath = join22(projectDir, "knowledge.md");
+  const indexPath = join23(projectDir, "knowledge.md");
   let existing = false;
   let stale = false;
   try {
@@ -6208,8 +6591,8 @@ ${entries.map((e) => `  ${e.type}: [[${e.page.replace(/\.md$/, "")}]] \u2014 ${e
 
 // src/commands/observe.ts
 import { mkdir as mkdir6, writeFile as writeFile7 } from "fs/promises";
-import { existsSync as existsSync10, statSync as statSync2 } from "fs";
-import { join as join23 } from "path";
+import { existsSync as existsSync11, statSync as statSync2 } from "fs";
+import { join as join24 } from "path";
 import { createHash as createHash5 } from "crypto";
 var ALLOWED_KINDS = /* @__PURE__ */ new Set(["note", "bug", "task", "idea", "session-log"]);
 function slugify(text) {
@@ -6232,13 +6615,13 @@ async function runObserve(input) {
       result: err("SCHEME_REJECTED", { message: "Text must not be empty" })
     };
   }
-  if (!existsSync10(input.vault) || !statSync2(input.vault).isDirectory()) {
+  if (!existsSync11(input.vault) || !statSync2(input.vault).isDirectory()) {
     return {
       exitCode: ExitCode.VAULT_PATH_INVALID,
       result: err("VAULT_PATH_INVALID", { path: input.vault })
     };
   }
-  const transcriptsDir = join23(input.vault, "raw", "transcripts");
+  const transcriptsDir = join24(input.vault, "raw", "transcripts");
   try {
     await mkdir6(transcriptsDir, { recursive: true });
   } catch {
@@ -6250,7 +6633,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 = join23(transcriptsDir, fileName);
+  const filePath = join24(transcriptsDir, fileName);
   const body = `
 ${input.text.trim()}
 `;
@@ -6292,7 +6675,7 @@ ${input.text.trim()}
 // src/commands/memory.ts
 import { createHash as createHash6 } from "crypto";
 import { mkdir as mkdir7, readFile as readFile17, readdir as readdir5, stat as stat5, writeFile as writeFile8 } from "fs/promises";
-import { basename as basename2, extname, join as join24, relative as relative4, sep as sep4 } from "path";
+import { basename as basename2, extname, join as join25, relative as relative4, sep as sep4 } from "path";
 async function runMemoryTopics(input) {
   const scan = await scanVault(input.vault);
   if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
@@ -6356,8 +6739,8 @@ async function runMemoryIndex(input) {
   }
   const generatedAt = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
   const relCachePath = memoryCacheRelPath(input.project);
-  const absCachePath = join24(input.vault, relCachePath);
-  await mkdir7(join24(input.vault, ".skillwiki", "memory", input.project), { recursive: true });
+  const absCachePath = join25(input.vault, relCachePath);
+  await mkdir7(join25(input.vault, ".skillwiki", "memory", input.project), { recursive: true });
   await writeFile8(absCachePath, `${JSON.stringify({
     generated_at: generatedAt,
     project: input.project,
@@ -6549,7 +6932,7 @@ async function buildMemoryIndexState(pages, project) {
 }
 async function checkMemoryIndex(vault, project, current) {
   const relCachePath = memoryCacheRelPath(project);
-  const cacheText = await readIfExists2(join24(vault, relCachePath));
+  const cacheText = await readIfExists2(join25(vault, relCachePath));
   if (!cacheText) {
     return {
       ok: true,
@@ -6958,7 +7341,7 @@ async function walkImportFiles(dir, out) {
   const entries = await readdir5(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name === ".git" || entry.name === "node_modules") continue;
-    const path = join24(dir, entry.name);
+    const path = join25(dir, entry.name);
     if (entry.isDirectory()) {
       await walkImportFiles(path, out);
     } else if (entry.isFile() && isImportCandidate(path)) {
@@ -7025,8 +7408,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 = join24(vault, relPath);
-  await mkdir7(join24(vault, "raw", "transcripts"), { recursive: true });
+  const absPath = join25(vault, relPath);
+  await mkdir7(join25(vault, "raw", "transcripts"), { recursive: true });
   await writeFile8(absPath, renderImportCapture(entry, content, project, today), "utf8");
   const validation = await runValidate({ file: absPath });
   return {
@@ -7042,7 +7425,7 @@ async function availableImportPath(vault, proposed) {
   const stem = proposed.slice(0, -ext.length);
   let candidate = proposed;
   let i = 2;
-  while (await readIfExists2(join24(vault, candidate))) {
+  while (await readIfExists2(join25(vault, candidate))) {
     candidate = `${stem}-${i}${ext}`;
     i++;
   }
@@ -7214,10 +7597,10 @@ function memoryCacheRelPath(project) {
 }
 async function readMemoryCache(vault, project) {
   if (project) {
-    const projectCache = await readIfExists2(join24(vault, memoryCacheRelPath(project)));
+    const projectCache = await readIfExists2(join25(vault, memoryCacheRelPath(project)));
     if (projectCache) return projectCache;
   }
-  return readIfExists2(join24(vault, ".skillwiki", "memory-topics.json"));
+  return readIfExists2(join25(vault, ".skillwiki", "memory-topics.json"));
 }
 function dedupePages(pages) {
   const seen = /* @__PURE__ */ new Set();
@@ -7304,7 +7687,7 @@ function slugify2(value) {
 
 // src/commands/query.ts
 import { readFile as readFile18, stat as stat6 } from "fs/promises";
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 var W_KEYWORD = 2;
 var W_SOURCE_OVERLAP = 4;
 var W_WIKILINK = 3;
@@ -7425,7 +7808,7 @@ function computeKeywordScore(terms, title, tags, body) {
   return score;
 }
 async function loadOrBuildGraph(vault) {
-  const graphPath = join25(vault, ".skillwiki", "graph.json");
+  const graphPath = join26(vault, ".skillwiki", "graph.json");
   let needsBuild = false;
   try {
     const fileStat = await stat6(graphPath);
@@ -7454,7 +7837,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { z as z2 } from "zod";
 
 // src/mcp/vault-resolve.ts
-import { join as join26, resolve as resolve7 } from "path";
+import { join as join27, resolve as resolve7 } from "path";
 
 // src/mcp/allowlist.ts
 import { resolve as resolve6, sep as sep5 } from "path";
@@ -7515,7 +7898,7 @@ async function resolveMcpVault(input) {
   return ok({ vault: vaultPath, source });
 }
 function defaultGraphOut(vault) {
-  return join26(vault, ".skillwiki", "graph.json");
+  return join27(vault, ".skillwiki", "graph.json");
 }
 
 // src/mcp/result-format.ts
@@ -7532,7 +7915,7 @@ function formatToolResult(payload) {
 // src/mcp/audit-log.ts
 import { appendFileSync, mkdirSync as mkdirSync4 } from "fs";
 import { homedir } from "os";
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 function auditEnabled() {
   const v = process.env.SKILLWIKI_MCP_AUDIT;
   if (v === "0" || v === "false") return false;
@@ -7544,7 +7927,7 @@ function auditSink() {
 function auditFilePath() {
   const custom = process.env.SKILLWIKI_MCP_AUDIT_FILE;
   if (custom && custom.length > 0) return custom;
-  return join27(homedir(), ".skillwiki", "mcp-audit.jsonl");
+  return join28(homedir(), ".skillwiki", "mcp-audit.jsonl");
 }
 function auditMcpToolCall(entry) {
   if (!auditEnabled()) return;
@@ -7554,7 +7937,7 @@ function auditMcpToolCall(entry) {
     return;
   }
   const path = auditFilePath();
-  mkdirSync4(join27(path, ".."), { recursive: true });
+  mkdirSync4(join28(path, ".."), { recursive: true });
   appendFileSync(path, line, "utf8");
 }
 async function runMcpToolHandler(tool, input, fn) {
@@ -7775,7 +8158,7 @@ function registerMcpMutatingTools(server) {
 
 // src/mcp/resources.ts
 import { readFile as readFile20 } from "fs/promises";
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 
 // src/mcp/lint-bucket.ts
@@ -7904,8 +8287,8 @@ async function fetchQueryPreview(input) {
 
 // src/mcp/graph-html.ts
 import { readFile as readFile19 } from "fs/promises";
-import { join as join28 } from "path";
-import { existsSync as existsSync11 } from "fs";
+import { join as join29 } from "path";
+import { existsSync as existsSync12 } from "fs";
 var TYPE_COLORS = {
   entities: "#e74c3c",
   concepts: "#27ae60",
@@ -7973,9 +8356,9 @@ ${nodeSvg}
   return { html, node_count: nodes.length, edge_count: edges.length, truncated };
 }
 async function fetchGraphHtmlReport(input) {
-  const graphPath = input.graphPath ?? join28(input.vault, ".skillwiki", "graph.json");
+  const graphPath = input.graphPath ?? join29(input.vault, ".skillwiki", "graph.json");
   const maxNodes = Math.min(Math.max(10, input.maxNodes ?? 120), 500);
-  if (!existsSync11(graphPath)) {
+  if (!existsSync12(graphPath)) {
     return {
       exitCode: ExitCode.FILE_NOT_FOUND,
       result: err("GRAPH_MISSING", { path: graphPath, hint: "Run skillwiki.graph_build first." })
@@ -8047,7 +8430,7 @@ async function fetchStaleSummary(input) {
 
 // src/mcp/resources.ts
 async function readVaultFile(vault, rel) {
-  return readFile20(join29(vault, rel), "utf8");
+  return readFile20(join30(vault, rel), "utf8");
 }
 async function tailLines(text, lines) {
   const parts = text.split(/\r?\n/);
@@ -8133,7 +8516,7 @@ function registerMcpResources(server) {
       if (!v.ok) {
         return { contents: [{ uri: uri.href, mimeType: "text/plain", text: JSON.stringify(v) }] };
       }
-      const path = join29(v.data.vault, ".skillwiki", "graph.json");
+      const path = join30(v.data.vault, ".skillwiki", "graph.json");
       try {
         const raw = await readFile20(path, "utf8");
         const graph = JSON.parse(raw);
@@ -8482,6 +8865,7 @@ export {
   runIndexLinkFormat,
   runDedup,
   safeWritePage,
+  runFrontmatterFix,
   fixPathTooLong,
   assessSourceIdentity,
   runLint,
@@ -8492,8 +8876,16 @@ export {
   runConfigPath,
   writeCache,
   triggerAutoUpdate,
+  FLEET_REL_PATH,
   runFleetValidate,
   runFleetContext,
+  loadFleetManifest,
+  resolveFleetHostId,
+  SATELLITE_STALE_MS,
+  satelliteLatestRunPath,
+  isFailedRunStatus,
+  readSatelliteLatestRunFromText,
+  evaluateSatelliteRunHealth,
   runDoctor,
   readCliPackageJson,
   runProjectIndex,