skillwiki 0.10.17 → 0.10.18

package/dist/{chunk-VOVXDN56.js → chunk-GNS2ZV5P.js}

@@ -867,6 +867,45 @@ async function runVaultSyncPullHelper(input) {
   });
 }
 
+// src/utils/snapshot-worktree.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join4, resolve } from "path";
+function readSkillWikiConfig(path) {
+  try {
+    return parseDotenvText(readFileSync2(path, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function readSnapshotProfile(path) {
+  const allowed = /* @__PURE__ */ new Set(["WIKI_GIT_WORKTREE", "SNAPSHOT_WORKTREE", "GIT_DIR"]);
+  const profile = {};
+  try {
+    for (const rawLine of readFileSync2(path, "utf8").split(/\r?\n/)) {
+      const line = rawLine.trim();
+      if (line.length === 0 || line.startsWith("#")) continue;
+      const eq = line.indexOf("=");
+      if (eq <= 0) continue;
+      const key = line.slice(0, eq).trim();
+      const value = line.slice(eq + 1).trim();
+      if (allowed.has(key) && value.length > 0) profile[key] = value;
+    }
+  } catch {
+  }
+  return profile;
+}
+function resolveConfiguredSnapshotWorktree(home) {
+  if (!home) return void 0;
+  const config = readSkillWikiConfig(join4(home, ".skillwiki", ".env"));
+  const explicit = config["vault_sync.snapshot_worktree"];
+  if (explicit) return resolve(explicit);
+  const snapshotProfile = config["vault_sync.snapshot_profile"];
+  if (!snapshotProfile) return void 0;
+  const profile = readSnapshotProfile(resolve(snapshotProfile));
+  const fromProfile = profile.WIKI_GIT_WORKTREE ?? profile.SNAPSHOT_WORKTREE ?? profile.GIT_DIR;
+  return fromProfile ? resolve(fromProfile) : void 0;
+}
+
 export {
   CONFIG_KEYS,
   isValidWikiProfileKey,
@@ -897,5 +936,6 @@ export {
   markJournalSuperseded,
   supersedeStaleReviewRequiredJournals,
   resolveVaultSyncPullHelper,
-  runVaultSyncPullHelper
+  runVaultSyncPullHelper,
+  resolveConfiguredSnapshotWorktree
 };

package/dist/{chunk-IVTI3BOH.js → chunk-IAPD6YTC.js}

@@ -29,11 +29,12 @@ import {
   parseDotenvFile,
   parseDotenvText,
   profileKey,
+  resolveConfiguredSnapshotWorktree,
   resolveVaultSyncPullHelper,
   satelliteGateFromFleetLoad,
   snapshotterAliasForLocalHost,
   writeDotenv
-} from "./chunk-VOVXDN56.js";
+} from "./chunk-GNS2ZV5P.js";
 import {
   CompoundSchema,
   ExitCode,
@@ -6482,8 +6483,6 @@ function readVaultSyncConfig(home) {
     let role;
     let serviceScope;
     let snapshotScript;
-    let snapshotProfile;
-    let snapshotWorktree;
     for (const line of content.split(/\r?\n/)) {
       const trimmed = line.trim();
       if (trimmed.length === 0 || trimmed.startsWith("#")) continue;
@@ -6496,37 +6495,15 @@ function readVaultSyncConfig(home) {
       if (k === "vault_sync.role") role = v;
       if (k === "vault_sync.service_scope") serviceScope = v;
       if (k === "vault_sync.snapshot_script") snapshotScript = v;
-      if (k === "vault_sync.snapshot_profile") snapshotProfile = v;
-      if (k === "vault_sync.snapshot_worktree") snapshotWorktree = v;
     }
-    return { installed, role, serviceScope, snapshotScript, snapshotProfile, snapshotWorktree };
+    return { installed, role, serviceScope, snapshotScript };
   } catch {
     return { installed: false };
   }
 }
-function readKeyFromEnvFile(path, keys) {
-  try {
-    const content = readFileSync10(path, "utf8");
-    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 key = trimmed.slice(0, eq).trim();
-      if (!keys.includes(key)) continue;
-      const value = trimmed.slice(eq + 1).trim();
-      if (value.length > 0) return value;
-    }
-  } catch {
-  }
-  return void 0;
-}
-function resolveSnapshotGitWorktree(config) {
-  if (config.snapshotWorktree) return config.snapshotWorktree;
-  if (config.snapshotProfile) {
-    const fromProfile = readKeyFromEnvFile(config.snapshotProfile, ["WIKI_GIT_WORKTREE", "SNAPSHOT_WORKTREE", "GIT_DIR"]);
-    if (fromProfile) return fromProfile;
-  }
+function resolveSnapshotGitWorktree(home) {
+  const configured = resolveConfiguredSnapshotWorktree(home);
+  if (configured) return configured;
   const defaultPath = "/root/wiki-git";
   return existsSync13(defaultPath) ? defaultPath : void 0;
 }
@@ -7126,7 +7103,7 @@ async function runDoctor(input) {
     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(vsConfig) ?? resolvedPath : resolvedPath;
+  const gitCheckPath = vsConfig.role === "snapshotter" ? resolveSnapshotGitWorktree(input.home) ?? resolvedPath : resolvedPath;
   checks.push(checkWikiPathExists(resolvedPath));
   checks.push(checkVaultStructure(resolvedPath));
   checks.push(checkObsidianTemplates(resolvedPath));

package/dist/{chunk-RNPDHSGX.js → chunk-QJPCCW4N.js}

@@ -6,9 +6,10 @@ import {
   hasActiveGitSequencer,
   hasUnmergedPaths,
   loadFleetManifestAndHost,
+  resolveConfiguredSnapshotWorktree,
   runVaultSyncPullHelper,
   supersedeStaleReviewRequiredJournals
-} from "./chunk-VOVXDN56.js";
+} from "./chunk-GNS2ZV5P.js";
 import {
   ExitCode,
   err,
@@ -16,7 +17,7 @@ import {
 } from "./chunk-Y6KRDGI2.js";
 
 // src/utils/managed-write-preflight.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync2 } from "fs";
 import { join as join2, resolve } from "path";
 
 // src/utils/managed-write-lock.ts
@@ -149,7 +150,8 @@ function releaseManagedWriteLock(handle) {
 
 // src/utils/managed-write-preflight.ts
 var DEFAULT_DEPS = {
-  converge: (input) => runVaultSyncPullHelper(input)
+  converge: (input) => runVaultSyncPullHelper(input),
+  resolveConfiguredSnapshotWorktree
 };
 function preflightBlocker(vault) {
   const unmerged = hasUnmergedPaths(vault);
@@ -171,19 +173,17 @@ function preflightBlocker(vault) {
   if (op) return { reason: "review-required", operation_id: op };
   return null;
 }
-function fleetManifestBytes(vault) {
-  const path = join2(vault, FLEET_REL_PATH);
-  if (!existsSync2(path)) return null;
-  return readFileSync2(path);
+function hasFleetManifest(vault) {
+  return existsSync2(join2(vault, FLEET_REL_PATH));
 }
 function isGitVault(vault) {
   return Boolean(git(vault, ["rev-parse", "--absolute-git-dir"]));
 }
 async function runManagedWritePreflight(input, deps = DEFAULT_DEPS) {
-  const vault = input.vault;
-  const convergenceVault = input.convergenceVault && resolve(input.convergenceVault) !== resolve(vault) ? resolve(input.convergenceVault) : void 0;
-  const gitVault = convergenceVault ?? vault;
-  const mutationBlocker = preflightBlocker(vault);
+  const mutationVault = resolve(input.vault);
+  let convergenceVault = input.convergenceVault && resolve(input.convergenceVault) !== mutationVault ? resolve(input.convergenceVault) : void 0;
+  let convergenceSource = convergenceVault ? "explicit" : "single-path";
+  const mutationBlocker = preflightBlocker(mutationVault);
   if (mutationBlocker) {
     return {
       exitCode: ExitCode.PREFLIGHT_FAILED,
@@ -194,46 +194,27 @@ async function runManagedWritePreflight(input, deps = DEFAULT_DEPS) {
       })
     };
   }
-  if (convergenceVault) {
-    if (!isGitVault(convergenceVault)) {
-      return {
-        exitCode: ExitCode.PREFLIGHT_FAILED,
-        result: err("PREFLIGHT_FAILED", {
-          reason: "convergence-vault-not-git",
-          convergence_vault: convergenceVault
-        })
-      };
-    }
-    const gitBlocker = preflightBlocker(convergenceVault);
-    if (gitBlocker) {
-      return {
-        exitCode: ExitCode.PREFLIGHT_FAILED,
-        result: err("PREFLIGHT_FAILED", {
-          reason: gitBlocker.reason,
-          operation_id: gitBlocker.operation_id,
-          unmerged_paths: gitBlocker.unmerged_paths,
-          convergence_vault: convergenceVault
-        })
-      };
-    }
-  }
   const fleet = await loadFleetManifestAndHost({
-    vault,
+    vault: mutationVault,
     hostId: input.hostId,
     env: input.env,
     home: input.home,
-    osHostname: input.osHostname
+    cwd: input.cwd,
+    osHostname: input.osHostname,
+    user: input.user
   });
-  const dualPathMeta = convergenceVault ? { convergence_vault: convergenceVault } : {};
   if (!fleet) {
-    const head = git(gitVault, ["rev-parse", "HEAD"]) || null;
+    const gitVault2 = isGitVault(mutationVault) ? mutationVault : null;
+    const head = gitVault2 ? git(gitVault2, ["rev-parse", "HEAD"]) || null : null;
     return {
       exitCode: ExitCode.OK,
       result: ok({
         mode: "standalone",
+        mutation_vault: mutationVault,
+        git_vault: gitVault2,
         base_oid: head,
         converged: false,
-        ...dualPathMeta
+        convergence_source: "single-path"
       })
     };
   }
@@ -247,27 +228,6 @@ async function runManagedWritePreflight(input, deps = DEFAULT_DEPS) {
       })
     };
   }
-  if (convergenceVault && fleetManifestBytes(convergenceVault)) {
-    const convergeFleetCtx = await loadFleetManifestAndHost({
-      vault: convergenceVault,
-      hostId: input.hostId ?? fleet.hostId,
-      env: input.env,
-      home: input.home,
-      osHostname: input.osHostname
-    });
-    if (!convergeFleetCtx || convergeFleetCtx.identityStatus !== "known" || convergeFleetCtx.hostId !== fleet.hostId) {
-      return {
-        exitCode: ExitCode.PREFLIGHT_FAILED,
-        result: err("PREFLIGHT_FAILED", {
-          reason: "convergence-vault-identity-mismatch",
-          host_id: fleet.hostId,
-          convergence_host_id: convergeFleetCtx?.hostId,
-          convergence_identity_status: convergeFleetCtx?.identityStatus,
-          convergence_vault: convergenceVault
-        })
-      };
-    }
-  }
   const host = fleet.manifest.hosts[fleet.hostId];
   if (!host) {
     return {
@@ -282,12 +242,101 @@ async function runManagedWritePreflight(input, deps = DEFAULT_DEPS) {
       result: ok({
         mode: "immutable-record",
         host_id: fleet.hostId,
+        mutation_vault: mutationVault,
+        git_vault: null,
         base_oid: null,
         converged: false,
-        ...dualPathMeta
+        ...convergenceVault ? { convergence_vault: convergenceVault } : {},
+        convergence_source: convergenceSource
       })
     };
   }
+  if (!convergenceVault && host.role === "snapshotter" && host.protected === true) {
+    const home = input.home ?? input.env?.HOME ?? process.env.HOME ?? "";
+    const configured = (deps.resolveConfiguredSnapshotWorktree ?? resolveConfiguredSnapshotWorktree)(home);
+    if (!configured) {
+      return {
+        exitCode: ExitCode.PREFLIGHT_FAILED,
+        result: err("PREFLIGHT_FAILED", {
+          reason: "convergence-vault-not-configured",
+          host_id: fleet.hostId,
+          mutation_vault: mutationVault
+        })
+      };
+    }
+    convergenceVault = resolve(configured);
+    convergenceSource = "configured";
+    if (convergenceVault === mutationVault) {
+      return {
+        exitCode: ExitCode.PREFLIGHT_FAILED,
+        result: err("PREFLIGHT_FAILED", {
+          reason: "convergence-vault-not-distinct",
+          host_id: fleet.hostId,
+          mutation_vault: mutationVault,
+          convergence_vault: convergenceVault
+        })
+      };
+    }
+  }
+  const gitVault = convergenceVault ?? mutationVault;
+  if (convergenceVault) {
+    if (!isGitVault(convergenceVault)) {
+      return {
+        exitCode: ExitCode.PREFLIGHT_FAILED,
+        result: err("PREFLIGHT_FAILED", {
+          reason: "convergence-vault-not-git",
+          convergence_vault: convergenceVault
+        })
+      };
+    }
+    const convergenceHasFleet = hasFleetManifest(convergenceVault);
+    if (convergenceSource === "configured" && !convergenceHasFleet) {
+      return {
+        exitCode: ExitCode.PREFLIGHT_FAILED,
+        result: err("PREFLIGHT_FAILED", {
+          reason: "convergence-vault-fleet-missing",
+          host_id: fleet.hostId,
+          convergence_vault: convergenceVault
+        })
+      };
+    }
+    const gitBlocker = preflightBlocker(convergenceVault);
+    if (gitBlocker) {
+      return {
+        exitCode: ExitCode.PREFLIGHT_FAILED,
+        result: err("PREFLIGHT_FAILED", {
+          reason: gitBlocker.reason,
+          operation_id: gitBlocker.operation_id,
+          unmerged_paths: gitBlocker.unmerged_paths,
+          convergence_vault: convergenceVault
+        })
+      };
+    }
+  }
+  if (convergenceVault && hasFleetManifest(convergenceVault)) {
+    const convergeFleetCtx = await loadFleetManifestAndHost({
+      vault: convergenceVault,
+      hostId: input.hostId ?? fleet.hostId,
+      env: input.env,
+      home: input.home,
+      cwd: input.cwd,
+      osHostname: input.osHostname,
+      user: input.user
+    });
+    if (!convergeFleetCtx || convergeFleetCtx.identityStatus !== "known" || convergeFleetCtx.hostId !== fleet.hostId) {
+      return {
+        exitCode: ExitCode.PREFLIGHT_FAILED,
+        result: err("PREFLIGHT_FAILED", {
+          reason: "convergence-vault-identity-mismatch",
+          host_id: fleet.hostId,
+          convergence_host_id: convergeFleetCtx?.hostId,
+          convergence_identity_status: convergeFleetCtx?.identityStatus,
+          convergence_vault: convergenceVault
+        })
+      };
+    }
+  }
+  const dualPathMeta = convergenceVault ? { convergence_vault: convergenceVault } : {};
   const converge = await deps.converge({
     vault: gitVault,
     lockToken: convergenceVault ? void 0 : input.lockToken,
@@ -313,37 +362,51 @@ async function runManagedWritePreflight(input, deps = DEFAULT_DEPS) {
     result: ok({
       mode: "git-writer",
       host_id: fleet.hostId,
+      mutation_vault: mutationVault,
+      git_vault: gitVault,
       base_oid: baseOid,
       converged: true,
       helper_path: converge.data.helper_path,
-      ...dualPathMeta
+      ...dualPathMeta,
+      convergence_source: convergenceSource
     })
   };
 }
 async function runManagedWriteTransaction(input, deps = DEFAULT_DEPS) {
-  const lock = acquireManagedWriteLock(input.vault, input.command);
+  const mutationVault = resolve(input.vault);
+  const lock = acquireManagedWriteLock(mutationVault, input.command);
   if (!lock.ok) {
     return { exitCode: ExitCode.SYNC_LOCK_HELD, result: lock };
   }
-  let handle = lock.data;
+  const handle = lock.data;
   try {
-    const preflight = await runManagedWritePreflight(
-      {
-        vault: input.vault,
-        command: input.command,
-        convergenceVault: input.convergenceVault,
-        hostId: input.hostId,
-        lockToken: handle.ownerToken,
-        env: input.env,
-        home: input.home,
-        osHostname: input.osHostname
-      },
-      deps
-    );
+    const preflightInput = {
+      vault: mutationVault,
+      command: input.command,
+      convergenceVault: input.convergenceVault,
+      hostId: input.hostId,
+      lockToken: handle.ownerToken,
+      env: input.env,
+      home: input.home,
+      cwd: input.cwd,
+      osHostname: input.osHostname,
+      user: input.user
+    };
+    const preflight = input.preflight ? await input.preflight(preflightInput) : await runManagedWritePreflight(preflightInput, deps);
     if (!preflight.result.ok) {
       return { exitCode: preflight.exitCode, result: preflight.result };
     }
     const receipt = preflight.result.data;
+    if (receipt.mutation_vault !== mutationVault) {
+      return {
+        exitCode: ExitCode.PREFLIGHT_FAILED,
+        result: err("PREFLIGHT_FAILED", {
+          reason: "mutation-vault-receipt-mismatch",
+          expected: mutationVault,
+          actual: receipt.mutation_vault
+        })
+      };
+    }
     if (receipt.mode === "immutable-record" && !input.allowImmutableRecord) {
       return {
         exitCode: ExitCode.PREFLIGHT_FAILED,
@@ -361,8 +424,6 @@ async function runManagedWriteTransaction(input, deps = DEFAULT_DEPS) {
 }
 
 export {
-  acquireManagedWriteLock,
-  releaseManagedWriteLock,
   runManagedWritePreflight,
   runManagedWriteTransaction
 };