skillwiki 0.9.28 → 0.9.30

package/dist/cli.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 import {
   ExitCode,
+  FLEET_REL_PATH,
+  SATELLITE_STALE_MS,
   TypedKnowledgeSchema,
   appendLastOp,
   assessSourceIdentity,
@@ -8,11 +10,15 @@ import {
   configPath,
   detectSchema,
   err,
+  evaluateSatelliteRunHealth,
   extractCitationMarkers,
   extractFrontmatter,
   extractTaxonomy,
+  findPlugin,
   fixPathTooLong,
   isBlockedHost,
+  isFailedRunStatus,
+  loadFleetManifest,
   ok,
   parseDotenvFile,
   parseDotenvText,
@@ -20,6 +26,8 @@ import {
   readCliPackageJson,
   readLastOp,
   readPage,
+  readSatelliteLatestRunFromText,
+  resolveFleetHostId,
   resolveInitTimePath,
   resolveRuntimePath,
   runAudit,
@@ -31,6 +39,7 @@ import {
   runDoctor,
   runFleetContext,
   runFleetValidate,
+  runFrontmatterFix,
   runGraphBuild,
   runIndexCheck,
   runIndexLinkFormat,
@@ -53,19 +62,20 @@ import {
   runTopicMapCheck,
   runValidate,
   safeWritePage,
+  satelliteLatestRunPath,
   scanSensitiveContent,
   scanVault,
   splitFrontmatter,
   triggerAutoUpdate,
   writeCache,
   writeDotenv
-} from "./chunk-IP3RKVMF.js";
+} from "./chunk-JENSKJP6.js";
 import {
   normalizeDistTag
 } from "./chunk-E6UWZ3S3.js";
 
 // src/cli.ts
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 import { Command } from "commander";
 
 // src/utils/output.ts
@@ -297,6 +307,28 @@ async function runInstall(input) {
   if (entries.length === 0) {
     return { exitCode: ExitCode.PREFLIGHT_FAILED, result: err("PREFLIGHT_FAILED", { reason: "no skills found" }) };
   }
+  const defaultTarget = join2(input.home, ".claude", "skills");
+  const isDefaultTarget = resolve(input.target) === resolve(defaultTarget);
+  const plugin = input.force || !isDefaultTarget ? null : findPlugin(input.home);
+  if (plugin) {
+    const manifest_path2 = join2(input.target, "wiki-manifest.json");
+    const hintLines2 = [
+      `deferred to plugin: skillwiki@llm-wiki v${plugin.version}`,
+      `plugin provides skills at ${plugin.installPath}`,
+      `use --force to install CLI copies into ${input.target} anyway`
+    ];
+    return {
+      exitCode: ExitCode.OK,
+      result: ok({
+        installed: [],
+        backed_up: [],
+        manifest_path: manifest_path2,
+        version_warnings: [],
+        deferred_to_plugin: true,
+        humanHint: hintLines2.join("\n")
+      })
+    };
+  }
   const installed = [];
   const backed_up = [];
   const version_warnings = [];
@@ -377,7 +409,7 @@ async function runInstall(input) {
     for (const w of version_warnings) hintLines.push(`  ${w}`);
   }
   const exitCode = version_warnings.length > 0 ? ExitCode.SKILL_VERSION_MISMATCH : ExitCode.OK;
-  return { exitCode, result: ok({ installed, backed_up, manifest_path, version_warnings, humanHint: hintLines.join("\n") }) };
+  return { exitCode, result: ok({ installed, backed_up, manifest_path, version_warnings, deferred_to_plugin: false, humanHint: hintLines.join("\n") }) };
 }
 
 // src/commands/path.ts
@@ -1737,82 +1769,6 @@ ${migratedBody}${newFooter}`;
   };
 }
 
-// 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/update.ts
 import { execSync } from "child_process";
 import { join as join11 } from "path";
@@ -1827,19 +1783,23 @@ function resolveGlobalSkillsRoot() {
     return null;
   }
 }
-async function refreshInstalledSkills(target) {
+async function refreshInstalledSkills(home, target) {
   const skillsRoot = resolveGlobalSkillsRoot();
   if (!skillsRoot) {
-    return { warnings: ["could not locate global skillwiki installation for skill refresh"], refreshed: false };
+    return { warnings: ["could not locate global skillwiki installation for skill refresh"], refreshed: false, deferred_to_plugin: false };
   }
   try {
-    const result = await runInstall({ skillsRoot, target, dryRun: false, symlink: false });
+    const result = await runInstall({ skillsRoot, target, dryRun: false, symlink: false, home, force: false });
     if (result.result.ok) {
-      return { warnings: result.result.data.version_warnings, refreshed: true };
+      return {
+        warnings: result.result.data.version_warnings,
+        refreshed: !result.result.data.deferred_to_plugin,
+        deferred_to_plugin: result.result.data.deferred_to_plugin
+      };
     }
-    return { warnings: [`skill refresh failed: ${result.result.error}`], refreshed: false };
+    return { warnings: [`skill refresh failed: ${result.result.error}`], refreshed: false, deferred_to_plugin: false };
   } catch (e) {
-    return { warnings: [`skill refresh error: ${String(e)}`], refreshed: false };
+    return { warnings: [`skill refresh error: ${String(e)}`], refreshed: false, deferred_to_plugin: false };
   }
 }
 async function runUpdate(input) {
@@ -1875,6 +1835,7 @@ async function runUpdate(input) {
         wasAlreadyLatest: true,
         version_warnings: [],
         skills_refreshed: false,
+        deferred_to_plugin: false,
         humanHint: `Already on npm@${tag}: v${currentVersion}`
       })
     };
@@ -1891,12 +1852,13 @@ async function runUpdate(input) {
     };
   }
   writeCache(input.home, { ...cache, updateAppliedAt: Date.now() });
-  const installResult = await refreshInstalledSkills(target);
+  const installResult = await refreshInstalledSkills(input.home, target);
   const version_warnings = installResult.warnings;
   const skills_refreshed = installResult.refreshed;
+  const deferred_to_plugin = installResult.deferred_to_plugin;
   const hintLines = [
     `Updated skillwiki ${currentVersion} \u2192 ${latest} via npm@${tag}`,
-    `skills refreshed: ${skills_refreshed}`
+    deferred_to_plugin ? `skills deferred to plugin channel (skillwiki@llm-wiki)` : `skills refreshed: ${skills_refreshed}`
   ];
   if (version_warnings.length > 0) {
     hintLines.push(`version warnings: ${version_warnings.length}`);
@@ -1910,6 +1872,7 @@ async function runUpdate(input) {
       wasAlreadyLatest: false,
       version_warnings,
       skills_refreshed,
+      deferred_to_plugin,
       humanHint: hintLines.join("\n")
     })
   };
@@ -2388,7 +2351,10 @@ async function runSessionBrief(input) {
     const transcripts = await loadTranscriptInfo(scan.data.raw);
     const workItems = await loadWorkItems(scan.data.workItems);
     const digests = await loadTrendDigests(scan.data.typedKnowledge);
-    const healthWarnings = await loadHealthWarnings(input.vault);
+    const healthWarnings = [
+      ...await loadHealthWarnings(input.vault),
+      ...satelliteHealthWarnings(await loadSatelliteHealth(input.vault))
+    ];
     const memoryTopics = project ? await loadMemoryTopics(input.vault, project) : [];
     const latestLogs = newest(transcripts.filter((t) => t.kind === "session-log"), 3);
     const unclaimedCaptures = newest(transcripts.filter((t) => {
@@ -2598,6 +2564,31 @@ function appendTextSection(lines, title, items, empty) {
   }
   lines.push("");
 }
+async function loadSatelliteHealth(vaultPath) {
+  const health = evaluateSatelliteRunHealth(vaultPath, /* @__PURE__ */ new Date());
+  if (!health.failed && !health.stale) {
+    const runPath2 = satelliteLatestRunPath(vaultPath);
+    const hasRun = await readIfExists(runPath2);
+    if (!hasRun) return null;
+  }
+  if (health.failed) {
+    const fc = health.failureClass && health.failureClass.length > 0 ? health.failureClass : "unknown";
+    return `agent-memory-trends: last run failed (${fc})`;
+  }
+  if (health.stale && health.finishedAt) {
+    const finishedMs = Date.parse(health.finishedAt);
+    if (!Number.isNaN(finishedMs)) {
+      const ageHours = (Date.now() - finishedMs) / (60 * 60 * 1e3);
+      const hoursRounded = Math.floor(ageHours);
+      const datePart = health.finishedAt.slice(0, 10);
+      return `agent-memory-trends: no run in ${hoursRounded}h (last: ${datePart})`;
+    }
+  }
+  return null;
+}
+function satelliteHealthWarnings(warning) {
+  return warning ? [warning] : [];
+}
 async function loadHealthWarnings(vault) {
   const text = await readIfExists(join15(vault, ".skillwiki", "health.json"));
   if (!text) return [];
@@ -4326,16 +4317,333 @@ written: ${outPath}`
   };
 }
 
-// src/utils/auto-commit.ts
-import { existsSync as existsSync10 } from "fs";
+// src/commands/fleet-health.ts
+import { existsSync as existsSync10, readFileSync as readFileSync6 } from "fs";
+import { execSync as nodeExecSync } from "child_process";
+import { hostname as nodeHostname, platform as nodePlatform } from "os";
 import { join as join23 } from "path";
+var SSH_TIMEOUT_MS = 15e3;
+var TIMER_UNIT = "agent-memory-trends.timer";
+var SERVICE_UNIT = "agent-memory-trends.service";
+var SYSTEMD_SERVICE_FAILED_CLASS = "SYSTEMD_SERVICE_FAILED";
+function defaultDeps() {
+  return {
+    platform: () => nodePlatform(),
+    execSync: nodeExecSync
+  };
+}
+function formatAgeHours(finishedAt) {
+  if (!finishedAt) return "never";
+  const ts = Date.parse(finishedAt);
+  if (!Number.isFinite(ts)) return "unknown";
+  const hours = Math.floor((Date.now() - ts) / (60 * 60 * 1e3));
+  if (hours < 1) return "<1h";
+  return `${hours}h`;
+}
+function deriveRunFields(parsed) {
+  if (!parsed) {
+    return {
+      last_run_status: "unknown",
+      last_run_age: "never",
+      failure_class: "-",
+      runUnhealthy: false
+    };
+  }
+  const finishedAt = parsed.finished_at;
+  const age = formatAgeHours(finishedAt);
+  const fc = parsed.failure_class != null && String(parsed.failure_class).length > 0 ? String(parsed.failure_class) : "-";
+  if (isFailedRunStatus(parsed.status ?? "")) {
+    return {
+      last_run_status: "fail",
+      last_run_age: age,
+      failure_class: fc === "-" ? "fail" : fc,
+      runUnhealthy: true
+    };
+  }
+  if (finishedAt) {
+    const ts = Date.parse(finishedAt);
+    if (Number.isFinite(ts) && Date.now() - ts > SATELLITE_STALE_MS) {
+      return {
+        last_run_status: "success",
+        last_run_age: age,
+        failure_class: "-",
+        runUnhealthy: true
+      };
+    }
+  }
+  if (parsed.status === "success" || parsed.status === "ok") {
+    return {
+      last_run_status: "success",
+      last_run_age: age,
+      failure_class: "-",
+      runUnhealthy: false
+    };
+  }
+  return {
+    last_run_status: parsed.status ? "unknown" : "none",
+    last_run_age: age,
+    failure_class: "-",
+    runUnhealthy: false
+  };
+}
+function systemctlPropLocal(deps, unit, prop) {
+  if (deps.platform() !== "linux") return null;
+  try {
+    return deps.execSync(`systemctl ${prop} ${unit}`, {
+      encoding: "utf8",
+      timeout: 2e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function systemctlIsActiveLocal(deps, unit) {
+  const out = systemctlPropLocal(deps, unit, "is-active");
+  if (out === null) return "unknown";
+  return out === "active" ? "active" : "inactive";
+}
+function systemctlIsFailedLocal(deps, unit) {
+  return systemctlPropLocal(deps, unit, "is-failed") === "failed";
+}
+function applyServiceFailedOverlay(run, serviceFailed) {
+  if (!serviceFailed) return run;
+  return {
+    ...run,
+    last_run_status: "fail",
+    failure_class: run.failure_class === "-" ? SYSTEMD_SERVICE_FAILED_CLASS : run.failure_class,
+    runUnhealthy: true
+  };
+}
+function probeLocal(vaultPath, deps) {
+  const latestPath = satelliteLatestRunPath(vaultPath);
+  let parsed = null;
+  if (existsSync10(latestPath)) {
+    try {
+      const wire = readSatelliteLatestRunFromText(readFileSync6(latestPath, "utf8"));
+      if (wire) {
+        parsed = {
+          status: wire.status,
+          finished_at: wire.finishedAt,
+          failure_class: wire.failureClass ?? null
+        };
+      }
+    } catch {
+      parsed = null;
+    }
+  }
+  const timer = systemctlIsActiveLocal(deps, TIMER_UNIT);
+  const serviceFailed = systemctlIsFailedLocal(deps, SERVICE_UNIT);
+  const run = applyServiceFailedOverlay(deriveRunFields(parsed), serviceFailed);
+  const timerBad = deps.platform() === "linux" && timer === "inactive";
+  return {
+    timer,
+    last_run_status: run.last_run_status,
+    last_run_age: run.last_run_age,
+    failure_class: run.failure_class,
+    reachable: "yes",
+    runUnhealthy: run.runUnhealthy,
+    timerBad
+  };
+}
+function probeRemote(sshAlias, vaultPath, deps) {
+  const latest = satelliteLatestRunPath(vaultPath);
+  const remoteCmd = [
+    `cat ${shellQuote2(latest)} 2>/dev/null || true`,
+    "echo __SW_TIMER__",
+    `systemctl is-active ${TIMER_UNIT} 2>/dev/null || echo inactive`,
+    "echo __SW_FAILED__",
+    `systemctl is-failed ${SERVICE_UNIT} 2>/dev/null || echo unknown`
+  ].join("\n");
+  const sshCmd = `ssh -o ConnectTimeout=10 ${sshAlias} ${shellQuote2(remoteCmd)}`;
+  try {
+    const out = deps.execSync(sshCmd, {
+      encoding: "utf8",
+      timeout: SSH_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const timerMarker = "__SW_TIMER__";
+    const failedMarker = "__SW_FAILED__";
+    const timerIdx = out.indexOf(timerMarker);
+    const jsonPart = timerIdx >= 0 ? out.slice(0, timerIdx) : out;
+    const afterTimer = timerIdx >= 0 ? out.slice(timerIdx + timerMarker.length) : "";
+    const failedIdx = afterTimer.indexOf(failedMarker);
+    const timerRaw = failedIdx >= 0 ? afterTimer.slice(0, failedIdx) : afterTimer;
+    const failedRaw = failedIdx >= 0 ? afterTimer.slice(failedIdx + failedMarker.length) : "";
+    const jsonText = jsonPart.trim();
+    const parsed = jsonText.startsWith("{") ? (() => {
+      const wire = readSatelliteLatestRunFromText(jsonText);
+      if (!wire) return null;
+      return {
+        status: wire.status,
+        finished_at: wire.finishedAt,
+        failure_class: wire.failureClass ?? null
+      };
+    })() : null;
+    const timerLine = timerRaw.trim().split("\n")[0]?.trim() ?? "unknown";
+    let timer = "unknown";
+    if (timerLine === "active") timer = "active";
+    else if (timerLine === "inactive") timer = "inactive";
+    const failedLine = failedRaw.trim().split("\n")[0]?.trim() ?? "unknown";
+    const serviceFailed = failedLine === "failed";
+    const run = applyServiceFailedOverlay(deriveRunFields(parsed), serviceFailed);
+    const timerBad = timer === "inactive";
+    return {
+      timer,
+      last_run_status: run.last_run_status,
+      last_run_age: run.last_run_age,
+      failure_class: run.failure_class,
+      reachable: "yes",
+      runUnhealthy: run.runUnhealthy,
+      timerBad
+    };
+  } catch {
+    return {
+      timer: "unknown",
+      last_run_status: "unknown",
+      last_run_age: "never",
+      failure_class: "-",
+      reachable: "no",
+      runUnhealthy: true,
+      timerBad: true
+    };
+  }
+}
+function shellQuote2(s) {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+function satelliteHosts(manifest) {
+  const out = [];
+  for (const [id, host] of Object.entries(manifest.hosts)) {
+    const sat = host.maintenance?.skillwiki_satellite;
+    if (sat?.enabled === true) {
+      out.push({ id, vaultPath: sat.vault_path, sshAlias: sat.ssh_alias, host });
+    }
+  }
+  return out.sort((a, b) => a.id.localeCompare(b.id));
+}
+function hasDeclaredSshAccess(host, localHostId, satelliteAlias) {
+  const profile = host.access?.from?.[localHostId];
+  if (!profile) return false;
+  if (profile.status !== "configured" && profile.status !== "local") return false;
+  const aliases = profile.ssh_aliases ?? [];
+  return aliases.includes(satelliteAlias);
+}
+function formatTable(rows) {
+  if (rows.length === 0) return "no satellite hosts configured";
+  const header = "host | timer | last_run_status | last_run_age | failure_class | reachable";
+  const lines = rows.map(
+    (r) => `${r.host} | ${r.timer} | ${r.last_run_status} | ${r.last_run_age} | ${r.failure_class} | ${r.reachable}`
+  );
+  return [header, ...lines].join("\n");
+}
+function rowHealthy(reachable, timer, runUnhealthy, timerBad, platform2) {
+  if (reachable === "no-access") return true;
+  if (reachable === "no") return false;
+  if (runUnhealthy) return false;
+  if (platform2 === "linux" && timerBad) return false;
+  if (platform2 === "linux" && timer === "inactive") return false;
+  return true;
+}
+async function runFleetHealth(input) {
+  const deps = input.deps ?? defaultDeps();
+  const env = input.env ?? process.env;
+  const home = input.home ?? env.HOME ?? "";
+  const osHostname = input.osHostname ?? env.HOSTNAME ?? nodeHostname();
+  const vault = input.vault ?? env.WIKI_PATH;
+  const file = input.file ?? (vault ? join23(vault, FLEET_REL_PATH) : void 0);
+  if (!file) {
+    return {
+      exitCode: ExitCode.NO_VAULT_CONFIGURED,
+      result: err("NO_VAULT_CONFIGURED", { message: "vault path or --file required" })
+    };
+  }
+  const loaded = await loadFleetManifest(file);
+  if (!loaded.ok) {
+    if (loaded.error === "FILE_NOT_FOUND") {
+      return { exitCode: ExitCode.FILE_NOT_FOUND, result: err("FILE_NOT_FOUND", { path: file }) };
+    }
+    return {
+      exitCode: ExitCode.FLEET_MANIFEST_INVALID,
+      result: err("INVALID_FLEET_MANIFEST", { path: file })
+    };
+  }
+  const resolved = await resolveFleetHostId({
+    manifest: loaded.manifest,
+    hostId: input.hostId,
+    env,
+    home,
+    osHostname
+  });
+  const localHostId = resolved.hostId;
+  const targets = satelliteHosts(loaded.manifest);
+  if (targets.length === 0) {
+    const humanHint2 = "no satellite hosts configured";
+    return {
+      exitCode: ExitCode.OK,
+      result: ok({ hosts: [], humanHint: humanHint2 })
+    };
+  }
+  const rows = [];
+  for (const t of targets) {
+    const isLocal = localHostId === t.id;
+    if (isLocal) {
+      const p = probeLocal(t.vaultPath, deps);
+      const healthy = rowHealthy(p.reachable, p.timer, p.runUnhealthy, p.timerBad, deps.platform());
+      rows.push({
+        host: t.id,
+        timer: p.timer,
+        last_run_status: p.last_run_status,
+        last_run_age: p.last_run_age,
+        failure_class: p.failure_class,
+        reachable: p.reachable,
+        healthy
+      });
+    } else {
+      if (!hasDeclaredSshAccess(t.host, localHostId, t.sshAlias)) {
+        rows.push({
+          host: t.id,
+          timer: "unknown",
+          last_run_status: "unknown",
+          last_run_age: "never",
+          failure_class: "-",
+          reachable: "no-access",
+          healthy: true
+        });
+        continue;
+      }
+      const p = probeRemote(t.sshAlias, t.vaultPath, deps);
+      const healthy = rowHealthy(p.reachable, p.timer, p.runUnhealthy, p.timerBad, "linux");
+      rows.push({
+        host: t.id,
+        timer: p.timer,
+        last_run_status: p.last_run_status,
+        last_run_age: p.last_run_age,
+        failure_class: p.failure_class,
+        reachable: p.reachable,
+        healthy
+      });
+    }
+  }
+  const allHealthy = rows.every((r) => r.healthy);
+  const humanHint = formatTable(rows);
+  const exitCode = allHealthy ? ExitCode.OK : ExitCode.FLEET_SATELLITE_HEALTH_FAILED;
+  return {
+    exitCode,
+    result: ok({ hosts: rows, humanHint })
+  };
+}
+
+// src/utils/auto-commit.ts
+import { existsSync as existsSync11 } from "fs";
+import { join as join24 } from "path";
 async function postCommit(vault, exitCode) {
   if (exitCode !== 0) return;
   const home = process.env.HOME ?? "";
   const dotenv = await parseDotenvFile(configPath(home));
   const autoCommit = process.env.AUTO_COMMIT ?? dotenv["AUTO_COMMIT"];
   if (autoCommit === "false") return;
-  if (!existsSync10(join23(vault, ".git"))) return;
+  if (!existsSync11(join24(vault, ".git"))) return;
   const lastOps = readLastOp(vault);
   if (lastOps.length === 0) return;
   const porcelain = git(vault, ["status", "--porcelain", "--", ...VAULT_COMMIT_PATHSPEC]);
@@ -4381,7 +4689,7 @@ program.command("validate <file>").description("validate vault page frontmatter
   emit(await runValidate({ file, apply: !!opts.apply, vault }), vault);
 });
 program.command("graph").description("graph subcommands").command("build <vault>").option("--out <path>", "graph output path (default: <vault>/.skillwiki/graph.json)").option("--wiki <name>", "wiki profile name").action(async (vault, opts) => {
-  const out = opts.out ?? join24(vault, ".skillwiki", "graph.json");
+  const out = opts.out ?? join25(vault, ".skillwiki", "graph.json");
   emit(await runGraphBuild({ vault, out }), vault);
 });
 var canvasCmd = program.command("canvas").description("manage Obsidian canvas files");
@@ -4407,9 +4715,9 @@ program.command("orphans [vault]").description("find pages not referenced by any
   wiki: opts.wiki
 })));
 program.command("audit <file>").description("audit citation markers and source provenance for a vault page").action(async (file) => emit(await runAudit({ file })));
-program.command("install").description("install skillwiki SKILL.md files into ~/.claude/skills/").option("--target <dir>", "target install directory", `${process.env.HOME ?? ""}/.claude/skills/`).option("--dry-run", "preview only", false).option("--skills-root <dir>", "source skills directory (defaults to packaged)").option("--symlink", "create symlinks instead of copies (dev mode \u2014 edits to source are immediately visible)", false).action(async (opts) => {
+program.command("install").description("install skillwiki SKILL.md files into ~/.claude/skills/").option("--target <dir>", "target install directory", `${process.env.HOME ?? ""}/.claude/skills/`).option("--dry-run", "preview only", false).option("--skills-root <dir>", "source skills directory (defaults to packaged)").option("--symlink", "create symlinks instead of copies (dev mode \u2014 edits to source are immediately visible)", false).option("--force", "install CLI copies even when the skillwiki@llm-wiki plugin channel is active", false).action(async (opts) => {
   const skillsRoot = opts.skillsRoot ?? new URL("../skills/", import.meta.url).pathname;
-  emit(await runInstall({ skillsRoot, target: opts.target, dryRun: !!opts.dryRun, symlink: !!opts.symlink }));
+  emit(await runInstall({ skillsRoot, target: opts.target, dryRun: !!opts.dryRun, symlink: !!opts.symlink, home: process.env.HOME ?? "", force: !!opts.force }));
 });
 program.command("path").description("show the resolved vault path").option("--vault <dir>", "explicit vault override (runtime)").option("--target <dir>", "explicit target override (init-time)").option("--wiki <name>", "wiki profile name").option("--init-time", "use init-time chain instead of runtime", false).option("--explain", "include resolution chain in output", false).action(async (opts) => {
   const initTime = !!opts.initTime;
@@ -4830,6 +5138,20 @@ fleetCmd.command("context [vault]").description("render compact Runtime Host Con
     user: process.env.USER
   }));
 });
+fleetCmd.command("health [vault]").description("read-only health probe for skillwiki satellite hosts").option("--file <path>", "fleet manifest path").option("--host-id <id>", "explicit current fleet host id").option("--json", "emit JSON result").action(async (vault, opts) => {
+  const r = await runFleetHealth({
+    vault,
+    file: opts.file,
+    hostId: opts.hostId,
+    json: !!opts.json,
+    env: process.env,
+    home: process.env.HOME ?? "",
+    cwd: process.cwd(),
+    osHostname: process.env.HOSTNAME,
+    user: process.env.USER
+  });
+  emit(r, vault);
+});
 program.command("mcp").description("start stdio Model Context Protocol server (read-only vault tools)").action(async () => {
   await runSkillwikiMcpStdio();
 });

package/dist/skillwiki-mcp.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   runSkillwikiMcpStdio
-} from "./chunk-IP3RKVMF.js";
+} from "./chunk-JENSKJP6.js";
 import "./chunk-E6UWZ3S3.js";
 
 // src/mcp-entry.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skillwiki",
-  "version": "0.9.28",
+  "version": "0.9.30",
   "type": "module",
   "bin": {
     "skillwiki": "dist/cli.js",

package/skills/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "skillwiki",
-  "version": "0.9.28",
+  "version": "0.9.30",
   "skills": "./",
   "description": "Project-aware Karpathy-style knowledge base for Claude Code: 18 prompt-only skills (wiki-*, proj-*, using-skillwiki) backed by the deterministic `skillwiki` CLI.",
   "author": {