skillwiki 0.10.26 → 0.10.28

package/dist/cli.js

@@ -6,82 +6,39 @@ import {
   DEFAULT_NO_DECISION_STREAK,
   GateError,
   SATELLITE_STALE_MS,
-  acquireLock,
-  acquireOwnedSyncLock,
-  appendLastOp,
-  applyRawStructuralMove,
-  assessSourceIdentity,
-  buildDegradedReasons,
-  buildRemoteObjectPath,
-  clearLastOp,
   configPath,
   evaluateDirtyVolumeGate,
   evaluateSatelliteRunHealth,
-  extractTaxonomy,
   findPlugin,
-  fixPathTooLong,
-  getCliSessionId,
-  getSessionId,
   isFailedRunStatus,
-  isValidRemoteDeleteCap,
   memoryAuthorityTiersRank,
-  mergeTaxonomyConflict,
-  normalizeRemoteRoot,
-  planAndMaybePruneRemoteObjects,
-  planRawStructuralMove,
-  probeRemoteHealth,
   readCliPackageJson,
-  readLastOp,
-  readLock,
   readSatelliteLatestRunFromText,
-  reconcileTaxonomyDocument,
-  releaseLock,
-  releaseOwnedSyncLock,
   renderIndexUpsert,
   renderProjectIndex,
-  resolveInitTimePath,
-  resolveRuntimePath,
-  rewriteRawSourceReferences,
-  runAudit,
   runConfigGet,
   runConfigList,
   runConfigPath,
   runConfigSet,
-  runDedup,
   runDoctor,
-  runFrontmatterFix,
   runGraphBuild,
-  runIndexCheck,
-  runIndexLinkFormat,
-  runLinks,
-  runLint,
   runLogAppend,
-  runLogRotate,
   runMemoryImport,
   runMemoryIndex,
   runMemoryRecall,
   runMemoryReview,
   runMemoryTopics,
   runObserve,
-  runOrphans,
-  runPagesize,
   runProjectIndex,
   runQuery,
   runSkillwikiMcpStdio,
-  runStale,
-  runSyncLintDelta,
-  runTagAudit,
-  runTopicMapCheck,
   runValidate,
   runWritePreflight,
-  safeWritePage,
   satelliteLatestRunPath,
   scanConflictMarkerBlocksInText,
-  snapshotMaintainedPageState,
   snapshotterHealthChecks,
-  taxonomyCommentForPage,
   upsertIndexEntry
-} from "./chunk-VXMHHXVP.js";
+} from "./chunk-W7NPTDIU.js";
 import {
   normalizeDistTag,
   readCache,
@@ -92,44 +49,89 @@ import {
 import {
   UNMANAGED_END,
   UNMANAGED_START,
-  assertTargetInsideVault,
-  atomicWriteText,
-  prepareTypedPage,
   renderRootIndex,
   writeRootIndexProjection
-} from "./chunk-QBZYEEBD.js";
+} from "./chunk-OJVIND5D.js";
 import {
+  VAULT_COMMIT_PATHSPEC,
   runManagedWritePreflight,
-  runManagedWriteTransaction
-} from "./chunk-BASWDOQB.js";
+  runManagedWriteTransaction,
+  runSyncLock,
+  runSyncPeers,
+  runSyncPull,
+  runSyncPush,
+  runSyncStatus,
+  runSyncUnlock,
+  stageVaultContentChanges
+} from "./chunk-NOXDRIHM.js";
 import {
   FLEET_REL_PATH,
+  acquireOwnedSyncLock,
+  appendLastOp,
+  applyRawStructuralMove,
+  assessSourceIdentity,
+  buildRemoteObjectPath,
   canSupersedeJournal,
+  clearLastOp,
+  extractTaxonomy,
+  getCliSessionId,
   git,
   gitStrict,
   hasActiveGitSequencer,
   hasUnmergedPaths,
+  isValidRemoteDeleteCap,
   isWorktreeClean,
   listJournalOpIds,
   listReviewRequiredOps,
   loadFleetManifest,
   loadFleetManifestAndHost,
   markJournalSuperseded,
+  mergeTaxonomyConflict,
+  normalizeRemoteRoot,
   parseDotenvFile,
   parseDotenvText,
   parseJournalEnv,
+  planAndMaybePruneRemoteObjects,
+  planRawStructuralMove,
   profileKey,
   readJournal,
+  readLastOp,
+  reconcileTaxonomyDocument,
+  releaseOwnedSyncLock,
   resolveConfiguredSnapshotWorktree,
   resolveFleetHostId,
+  resolveInitTimePath,
+  resolveRuntimePath,
+  rewriteRawSourceReferences,
+  runAudit,
+  runDedup,
   runFleetContext,
   runFleetValidate,
-  runVaultSyncPullHelper,
+  runFrontmatterFix,
+  runIndexCheck,
+  runIndexLinkFormat,
+  runLinks,
+  runLint,
+  runLogRotate,
+  runOrphans,
+  runPagesize,
+  runStale,
+  runSyncLintDelta,
+  runTagAudit,
+  runTopicMapCheck,
+  safeWritePage,
   serializeJournalEnv,
+  snapshotMaintainedPageState,
   snapshotterAliasForLocalHost,
   supersedeStaleReviewRequiredJournals,
+  taxonomyCommentForPage,
   writeDotenv
-} from "./chunk-PQG26AGJ.js";
+} from "./chunk-5XQWYC5K.js";
+import {
+  assertTargetInsideVault,
+  atomicWriteText,
+  prepareTypedPage
+} from "./chunk-UI4SOWI2.js";
 import {
   applySourceDisposition,
   decodeSourceActionApproval,
@@ -137,7 +139,7 @@ import {
   inventorySources,
   planSourceDisposition,
   runSourcesPending
-} from "./chunk-EQPU2BPM.js";
+} from "./chunk-23CR4YPL.js";
 import {
   authorizeRawOperation,
   buildSourceReferenceIndex,
@@ -153,15 +155,7 @@ import {
   resolveExistingRegularFileInsideVault,
   validateLogEvent,
   writeLogEvent
-} from "./chunk-QNTBNNEL.js";
-import {
-  extractFrontmatter,
-  readPage,
-  redactSensitiveContent,
-  scanSensitiveContent,
-  scanVault,
-  splitFrontmatter
-} from "./chunk-6ZDKTNLA.js";
+} from "./chunk-SGZPIGGX.js";
 import {
   ExitCode,
   MetaSchema,
@@ -169,12 +163,18 @@ import {
   TypedKnowledgeSchema,
   detectSchema,
   err,
+  extractFrontmatter,
   isBlockedHost,
-  ok
-} from "./chunk-C2DKFJFA.js";
+  ok,
+  readPage,
+  redactSensitiveContent,
+  scanSensitiveContent,
+  scanVault,
+  splitFrontmatter
+} from "./chunk-RQARJ6HB.js";
 
 // src/cli.ts
-import { join as join39 } from "path";
+import { join as join38 } from "path";
 import { Command } from "commander";
 
 // src/utils/output.ts
@@ -3348,7 +3348,7 @@ ${fmRewritten}
   }
   let indexUpdated = false;
   if (!isRaw) {
-    const { renderRootIndex: renderRootIndex2, writeRootIndexProjection: writeRootIndexProjection2 } = await import("./index-projection-FRWTZB5Y.js");
+    const { renderRootIndex: renderRootIndex2, writeRootIndexProjection: writeRootIndexProjection2 } = await import("./index-projection-64WW36N3.js");
     const before = await readFile7(join18(input.vault, "index.md"), "utf8").catch(() => "");
     const fullTarget = relPath.replace(/\.md$/, "");
     const bare = fullTarget.split("/").pop() ?? fullTarget;
@@ -3468,7 +3468,7 @@ async function runRemove(input) {
   if (relPath.endsWith(".md") && !relPath.startsWith("raw/")) {
     const { readFile: readFile20 } = await import("fs/promises");
     const { join: pathJoin } = await import("path");
-    const { renderRootIndex: renderRootIndex2, writeRootIndexProjection: writeRootIndexProjection2 } = await import("./index-projection-FRWTZB5Y.js");
+    const { renderRootIndex: renderRootIndex2, writeRootIndexProjection: writeRootIndexProjection2 } = await import("./index-projection-64WW36N3.js");
     const before = await readFile20(pathJoin(input.vault, "index.md"), "utf8").catch(() => "");
     const fullTarget = relPath.replace(/\.md$/, "");
     const bare = fullTarget.split("/").pop() ?? fullTarget;
@@ -7793,602 +7793,6 @@ async function runProjectPagePublish(input, deps = DEFAULT_DEPS3) {
   return publishPrepared(prepared.data, input.vault, deps, input.journalHome);
 }
 
-// src/commands/sync.ts
-import { existsSync as existsSync9 } from "fs";
-import { join as join30 } from "path";
-import { execFileSync as execFileSync3 } from "child_process";
-
-// src/utils/vault-git-pathspec.ts
-var VAULT_GENERATED_COMMIT_PATHS = [
-  ".skillwiki/last-op.json",
-  ".skillwiki/memory",
-  ".skillwiki/memory-topics.json"
-];
-var VAULT_GENERATED_COMMIT_EXCLUDES = [
-  ...VAULT_GENERATED_COMMIT_PATHS.map((path) => `:!${path}`)
-];
-var VAULT_COMMIT_PATHSPEC = [".", ...VAULT_GENERATED_COMMIT_EXCLUDES];
-function stageVaultContentChanges(vault) {
-  gitStrict(vault, ["add", "-A", "--", "."]);
-  for (const generatedPath of VAULT_GENERATED_COMMIT_PATHS) {
-    try {
-      gitStrict(vault, ["reset", "HEAD", "--", generatedPath]);
-    } catch (_e) {
-    }
-  }
-}
-
-// src/commands/sync.ts
-function parseDirtyPaths(porcelain) {
-  if (!porcelain) return [];
-  return porcelain.split("\n").map((line) => line.trimEnd()).filter((line) => line.length >= 4).map((line) => {
-    const payload = line.length >= 3 && line[2] === " " ? line.slice(3) : line.length >= 2 && line[1] === " " ? line.slice(2) : line;
-    const arrow = payload.lastIndexOf(" -> ");
-    return arrow >= 0 ? payload.slice(arrow + 4) : payload;
-  }).filter((path) => path.length > 0);
-}
-function splitNonEmptyLines(text) {
-  if (!text) return [];
-  return text.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
-}
-function isTrackedNotePath(path) {
-  if (!path.endsWith(".md")) return false;
-  return !/^\.(skillwiki|claude|obsidian|antigravitycli|playwright-cli)\//.test(path);
-}
-function refHasPath(vault, ref, path) {
-  try {
-    execFileSync3("git", ["cat-file", "-e", `${ref}:${path}`], {
-      cwd: vault,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function runSyncStatus(input) {
-  const vault = input.vault;
-  const includeStashes = input.includeStashes ?? false;
-  if (!existsSync9(join30(vault, ".git"))) {
-    return {
-      exitCode: ExitCode.VAULT_PATH_INVALID,
-      result: ok({
-        is_git_repo: false,
-        dirty: 0,
-        ahead: 0,
-        behind: 0,
-        unpromoted_note_paths: 0,
-        unpromoted_note_examples: [],
-        last_commit: "never",
-        status: "not_a_repo",
-        humanHint: "not a git repository"
-      })
-    };
-  }
-  enableGitLongPathsOnWindows(vault);
-  const porcelain = git(vault, ["status", "--porcelain"]);
-  const dirty = porcelain ? porcelain.split("\n").filter((l) => l.trim().length > 0).length : 0;
-  const dirtyPaths = parseDirtyPaths(porcelain);
-  const untrackedPaths = splitNonEmptyLines(git(vault, ["ls-files", "--others", "--exclude-standard"]));
-  const revOutput = git(vault, ["rev-list", "--left-right", "--count", "origin/HEAD...HEAD"]);
-  let ahead = 0;
-  let behind = 0;
-  if (revOutput) {
-    const parts = revOutput.split(/\s+/);
-    behind = parseInt(parts[0], 10) || 0;
-    ahead = parseInt(parts[1], 10) || 0;
-  }
-  const tsRaw = git(vault, ["log", "-1", "--format=%ct"]);
-  let last_commit;
-  if (tsRaw) {
-    const ts = parseInt(tsRaw, 10);
-    if (!isNaN(ts) && ts > 0) {
-      last_commit = new Date(ts * 1e3).toISOString();
-    } else {
-      last_commit = "never";
-    }
-  } else {
-    last_commit = "never";
-  }
-  const remoteRef = git(vault, ["rev-parse", "--verify", "origin/main"]) ? "origin/main" : git(vault, ["rev-parse", "--verify", "origin/HEAD"]) ? "origin/HEAD" : "HEAD";
-  const unpromotedNoteAll = Array.from(/* @__PURE__ */ new Set([...dirtyPaths, ...untrackedPaths])).filter(isTrackedNotePath).filter((path) => !refHasPath(vault, remoteRef, path));
-  const unpromotedNoteExamples = unpromotedNoteAll.slice(0, 5);
-  const unpromotedNotePaths = unpromotedNoteAll.length;
-  let status;
-  if (dirty > 0) {
-    status = "dirty";
-  } else if (ahead > 0) {
-    status = "ahead";
-  } else if (behind > 0) {
-    status = "behind";
-  } else {
-    status = "clean";
-  }
-  const hintLines = [
-    `status: ${status}`,
-    `dirty: ${dirty}`,
-    `ahead: ${ahead}`,
-    `behind: ${behind}`,
-    `unpromoted_note_paths: ${unpromotedNotePaths}`,
-    `last_commit: ${last_commit}`
-  ];
-  const exitCode = status === "clean" ? ExitCode.OK : ExitCode.LINT_HAS_WARNINGS;
-  let stashes;
-  if (includeStashes) {
-    stashes = enumerateStashes(vault);
-  }
-  const output = {
-    is_git_repo: true,
-    dirty,
-    ahead,
-    behind,
-    unpromoted_note_paths: unpromotedNotePaths,
-    unpromoted_note_examples: unpromotedNoteExamples,
-    last_commit,
-    status,
-    humanHint: hintLines.join("\n")
-  };
-  if (stashes !== void 0) {
-    output.stashes = stashes;
-  }
-  if (input.includeRemoteHealth) {
-    const home = input.home ?? process.env.HOME ?? "";
-    const remote_health = probeRemoteHealth({
-      vaultPath: vault,
-      home,
-      s3Remote: input.s3Remote,
-      snapshotterAlias: input.snapshotterAlias,
-      checkSnapshotter: input.checkSnapshotter,
-      exec: input.execProbe
-    });
-    output.remote_health = remote_health;
-    const degraded = buildDegradedReasons(remote_health);
-    if (degraded.length > 0) {
-      output.degraded_reasons = degraded;
-      hintLines.push(`degraded_reasons: ${degraded.join(", ")}`);
-      output.humanHint = hintLines.join("\n");
-    }
-  }
-  return {
-    exitCode,
-    result: ok(output)
-  };
-}
-async function runSyncPush(input) {
-  const vault = input.vault;
-  if (!existsSync9(join30(vault, ".git"))) {
-    return {
-      exitCode: ExitCode.VAULT_PATH_INVALID,
-      result: err("NOT_A_GIT_REPO", { path: vault })
-    };
-  }
-  enableGitLongPathsOnWindows(vault);
-  let pathFixes = 0;
-  const pathFix = await fixPathTooLong({ vault });
-  if (pathFix.result.ok && pathFix.result.data.fixed.length > 0) {
-    pathFixes = pathFix.result.data.fixed.length;
-    appendLastOp(vault, {
-      operation: "lint-fix",
-      summary: `fixed ${pathFixes} long path(s)`,
-      files: pathFix.result.data.fixed.flatMap((f) => [f.from, f.to]),
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    });
-  }
-  const porcelain = git(vault, ["status", "--porcelain"]);
-  const dirtyFiles = porcelain ? porcelain.split("\n").filter((l) => l.trim().length > 0) : [];
-  if (dirtyFiles.length === 0) {
-    return {
-      exitCode: ExitCode.OK,
-      result: ok({
-        files_committed: 0,
-        commit_message: "",
-        pushed: false,
-        path_fixes: pathFixes,
-        humanHint: "nothing to commit, working tree clean"
-      })
-    };
-  }
-  let delta = { full_errors: 0, base_errors: 0, new_errors: 0, resolved_errors: 0 };
-  const preferredBase = git(vault, ["rev-parse", "--verify", "origin/main"]) ? "origin/main" : git(vault, ["rev-parse", "--verify", "origin/HEAD"]) ? "origin/HEAD" : "";
-  if (preferredBase) {
-    const deltaResult = await runSyncLintDelta({ vault, baseRef: preferredBase });
-    if (!deltaResult.result.ok) {
-      return {
-        exitCode: ExitCode.LINT_HAS_ERRORS,
-        result: err("LINT_DELTA_UNAVAILABLE", {
-          message: "lint-delta evidence missing or failed \u2014 fail closed",
-          detail: deltaResult.result
-        })
-      };
-    }
-    delta = deltaResult.result.data;
-    if (delta.new_errors > 0) {
-      return {
-        exitCode: ExitCode.LINT_HAS_ERRORS,
-        result: err("LINT_NEW_ERRORS_BLOCK_PUSH", {
-          full_errors: delta.full_errors,
-          base_errors: delta.base_errors,
-          new_errors: delta.new_errors,
-          resolved_errors: delta.resolved_errors,
-          new_fingerprints: deltaResult.result.data.new_fingerprints
-        })
-      };
-    }
-  } else {
-    const lintResult = await runLint({ vault, days: 90, lines: 200, logThreshold: 500 });
-    if (lintResult.result.ok) {
-      const fullErrors = lintResult.result.data.summary.errors;
-      delta = { full_errors: fullErrors, base_errors: 0, new_errors: fullErrors, resolved_errors: 0 };
-      if (fullErrors > 0) {
-        const buckets = "by_severity" in lintResult.result.data ? lintResult.result.data.by_severity.error : [];
-        return {
-          exitCode: ExitCode.LINT_HAS_ERRORS,
-          result: err("LINT_ERRORS_BLOCK_PUSH", {
-            errors: fullErrors,
-            buckets,
-            message: "no origin base ref for delta; absolute lint errors block push"
-          })
-        };
-      }
-    } else {
-      delta = { full_errors: 0, base_errors: 0, new_errors: 0, resolved_errors: 0 };
-    }
-  }
-  try {
-    stageVaultContentChanges(vault);
-  } catch (e) {
-    return {
-      exitCode: ExitCode.SYNC_PUSH_FAILED,
-      result: err("GIT_ADD_FAILED", { message: String(e) })
-    };
-  }
-  const lastOps = readLastOp(vault);
-  let commitMessage;
-  if (lastOps.length > 0) {
-    commitMessage = lastOps.map((op) => `${op.operation}: ${op.summary} (${op.files.length} files)`).join("; ");
-  } else {
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
-    commitMessage = `sync: vault update ${timestamp}`;
-  }
-  try {
-    gitStrict(vault, ["commit", "-m", commitMessage]);
-  } catch (e) {
-    return {
-      exitCode: ExitCode.SYNC_PUSH_FAILED,
-      result: err("GIT_COMMIT_FAILED", { message: String(e) })
-    };
-  }
-  clearLastOp(vault);
-  let pushed = false;
-  try {
-    gitStrict(vault, ["push", "origin", "HEAD"]);
-    pushed = true;
-  } catch (e) {
-    return {
-      exitCode: ExitCode.SYNC_PUSH_FAILED,
-      result: ok({
-        files_committed: dirtyFiles.length,
-        commit_message: commitMessage,
-        pushed: false,
-        path_fixes: pathFixes,
-        humanHint: `committed ${dirtyFiles.length} file(s)${pathFixes > 0 ? ` after ${pathFixes} long-path fix(es)` : ""} but push failed: ${String(e)}`
-      })
-    };
-  }
-  const inheritedNote = delta.full_errors > 0 ? `; lint full=${delta.full_errors} base=${delta.base_errors} new=${delta.new_errors} resolved=${delta.resolved_errors} (inherited debt only)` : `; lint full=0 new=0`;
-  return {
-    exitCode: ExitCode.OK,
-    result: ok({
-      files_committed: dirtyFiles.length,
-      commit_message: commitMessage,
-      pushed,
-      path_fixes: pathFixes,
-      lint_full_errors: delta.full_errors,
-      lint_base_errors: delta.base_errors,
-      lint_new_errors: delta.new_errors,
-      lint_resolved_errors: delta.resolved_errors,
-      humanHint: `committed and pushed ${dirtyFiles.length} file(s)${pathFixes > 0 ? ` after ${pathFixes} long-path fix(es)` : ""}${inheritedNote}`
-    })
-  };
-}
-function enumerateStashes(vault, nowMs = Date.now()) {
-  const output = git(vault, ["log", "--format=%gd%x09%H%x09%s%x09%ct", "-g", "stash"]);
-  if (!output) return [];
-  const stashes = [];
-  const lines = output.split("\n").filter((l) => l.trim().length > 0);
-  for (const line of lines) {
-    const parts = line.split("	");
-    if (parts.length < 4) continue;
-    const ref = parts[0];
-    const oid = parts[1];
-    const message = parts[2];
-    const ctStr = parts[3];
-    const ct = parseInt(ctStr, 10);
-    if (isNaN(ct)) continue;
-    const age_minutes = Math.floor((nowMs - ct * 1e3) / (60 * 1e3));
-    stashes.push({ ref, oid, message, age_minutes });
-  }
-  return stashes;
-}
-function enableGitLongPathsOnWindows(vault) {
-  if (process.platform !== "win32") return;
-  git(vault, ["config", "core.longpaths", "true"]);
-}
-async function runSyncPull(input) {
-  const vault = input.vault;
-  if (!existsSync9(join30(vault, ".git"))) {
-    return {
-      exitCode: ExitCode.VAULT_PATH_INVALID,
-      result: err("NOT_A_GIT_REPO", { path: vault })
-    };
-  }
-  enableGitLongPathsOnWindows(vault);
-  const remoteUrl = git(vault, ["remote", "get-url", "origin"]);
-  if (!remoteUrl) {
-    return {
-      exitCode: ExitCode.SYNC_PULL_FAILED,
-      result: err("GIT_PULL_FAILED", { message: "no remote configured (origin)" })
-    };
-  }
-  const helper = await runVaultSyncPullHelper({ vault, remote: "origin", branch: "main" });
-  if (!helper.ok) {
-    if (helper.error === "PREFLIGHT_FAILED") {
-      return {
-        exitCode: ExitCode.PREFLIGHT_FAILED,
-        result: err("PREFLIGHT_FAILED", helper.detail)
-      };
-    }
-    return {
-      exitCode: ExitCode.SYNC_PULL_FAILED,
-      result: err("GIT_PULL_FAILED", helper.detail)
-    };
-  }
-  const fetched = true;
-  const pulled = helper.data.changed;
-  const conflicts = 0;
-  const autoResolved = 0;
-  let filesUpdated = 0;
-  if (helper.data.changed) {
-    const diffOutput = git(vault, ["diff", "--stat", `${helper.data.before_oid}..${helper.data.after_oid}`]);
-    if (diffOutput) {
-      const fileMatch = diffOutput.match(/(\d+) file[s]? changed/);
-      if (fileMatch) filesUpdated = parseInt(fileMatch[1], 10);
-    }
-  }
-  const pathFix = await fixPathTooLong({ vault });
-  const pathFixCount = pathFix.result.ok ? pathFix.result.data.fixed.length : 0;
-  let lintErrors = 0;
-  let lintWarnings = 0;
-  const lintResult = await runLint({ vault, days: 90, lines: 200, logThreshold: 500 });
-  if (lintResult.result.ok) {
-    lintErrors = lintResult.result.data.summary.errors;
-    lintWarnings = lintResult.result.data.summary.warnings;
-  }
-  const hintParts = [];
-  if (filesUpdated > 0) hintParts.push(`updated ${filesUpdated} file(s)`);
-  else hintParts.push(pulled ? "pulled via vault-sync helper" : "already up to date");
-  if (pathFixCount > 0) hintParts.push(`${pathFixCount} long path(s) fixed`);
-  if (lintErrors > 0) hintParts.push(`${lintErrors} lint error(s)`);
-  if (lintWarnings > 0) hintParts.push(`${lintWarnings} lint warning(s)`);
-  const exitCode = lintErrors > 0 ? ExitCode.LINT_HAS_ERRORS : lintWarnings > 0 ? ExitCode.LINT_HAS_WARNINGS : ExitCode.OK;
-  return {
-    exitCode,
-    result: ok({
-      fetched,
-      pulled,
-      files_updated: filesUpdated,
-      conflicts,
-      auto_resolved: autoResolved,
-      lint_errors: lintErrors,
-      lint_warnings: lintWarnings,
-      humanHint: hintParts.join(", ")
-    })
-  };
-}
-var STASH_RECENT_MINUTES = 120;
-var MANAGED_WRITER_PATTERNS = [
-  ["wiki-push", /(?:^|[\s/\\])wiki-push(?:\.[a-z0-9_-]+)?(?:\s|$)/i],
-  ["rclone", /(?:^|[\s/\\])rclone(?:\.[a-z0-9_-]+)?(?:\s|$)/i],
-  ["vault-sync", /(?:^|[\s/\\])vault-sync(?:\.[a-z0-9_-]+)?(?:\s|$)/i]
-];
-function classifyStash(ageMinutes, sessionId, currentSession) {
-  if (sessionId && sessionId === currentSession) return "self_or_local_recovery_stash";
-  if (sessionId && ageMinutes <= STASH_RECENT_MINUTES) return "recent_known_peer_stash";
-  if (ageMinutes > STASH_RECENT_MINUTES) return "stale_stash_backlog";
-  return "unknown_stash_ownership";
-}
-function classifyManagedWriterProcesses(snapshot, currentPid = process.pid) {
-  const kinds = /* @__PURE__ */ new Set();
-  let count2 = 0;
-  for (const line of snapshot.split(/\r?\n/)) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    let pid;
-    let processName = "";
-    const csvMatch = trimmed.match(/^"([^"]*)","(\d+)"(?:,|$)/);
-    if (csvMatch) {
-      processName = csvMatch[1];
-      pid = Number(csvMatch[2]);
-    } else {
-      const pidMatch = trimmed.match(/^(\d+)\s+(.*)$/);
-      if (!pidMatch) continue;
-      pid = Number(pidMatch[1]);
-      processName = pidMatch[2];
-    }
-    if (pid === currentPid) continue;
-    const kind = MANAGED_WRITER_PATTERNS.find(([, pattern]) => pattern.test(processName))?.[0];
-    if (!kind) continue;
-    count2 += 1;
-    kinds.add(kind);
-  }
-  return { count: count2, kinds: [...kinds].sort(), blocking: count2 > 0 };
-}
-function managedWriterSnapshot() {
-  try {
-    if (process.platform === "win32") {
-      return execFileSync3("tasklist", ["/FO", "CSV", "/NH"], {
-        encoding: "utf8",
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-    }
-    return execFileSync3("ps", ["-axo", "pid=,command="], {
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-  } catch {
-    return "";
-  }
-}
-function runSyncPeers(input) {
-  const vault = input.vault;
-  const currentSession = input.sessionId ?? getSessionId();
-  const locks = [];
-  const existingLock = readLock(vault);
-  if (existingLock) {
-    const self = existingLock.session_id === currentSession;
-    locks.push({ ...existingLock, is_self: self });
-  }
-  const allStashes = enumerateStashes(vault, input.nowMs);
-  const stashes = [];
-  const wikiSyncAudit = [];
-  const otherStashAudit = [];
-  for (const stash of allStashes) {
-    let actualMessage = stash.message;
-    const prefixMatch = stash.message.match(/^On [^:]+:\s*(.*)/);
-    if (prefixMatch) {
-      actualMessage = prefixMatch[1];
-    }
-    const match = actualMessage.match(/^wiki-sync:([^:]+):([^:]+):(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z):(.*)$/);
-    if (match) {
-      const session_id = match[1];
-      const cwd_hash = match[2];
-      const timestamp = match[3];
-      const summary = match[4];
-      stashes.push({
-        ref: stash.ref,
-        oid: stash.oid,
-        session_id,
-        cwd_hash,
-        timestamp,
-        summary,
-        age_minutes: stash.age_minutes
-      });
-      wikiSyncAudit.push({
-        ref: stash.ref,
-        oid: stash.oid,
-        age_minutes: stash.age_minutes,
-        classification: classifyStash(stash.age_minutes, session_id, currentSession),
-        format: "wiki-sync",
-        session_id
-      });
-      continue;
-    }
-    const vaultSyncMatch = actualMessage.match(/^vault-sync\s+op=([^\s]+)(?:\s+.*)?$/i);
-    const operationId2 = vaultSyncMatch?.[1];
-    const manualPeer = /^peer$/i.test(actualMessage.trim());
-    const format = operationId2 ? "vault-sync" : manualPeer ? "manual" : "unknown";
-    const classification = operationId2 ? stash.age_minutes <= STASH_RECENT_MINUTES ? "recent_known_peer_stash" : "stale_stash_backlog" : "unknown_stash_ownership";
-    otherStashAudit.push({
-      ref: stash.ref,
-      oid: stash.oid,
-      age_minutes: stash.age_minutes,
-      classification,
-      format,
-      ...operationId2 ? { operation_id: operationId2 } : {}
-    });
-  }
-  const stashAudit = [...wikiSyncAudit, ...otherStashAudit];
-  const managedWriters = classifyManagedWriterProcesses(
-    input.processSnapshot ?? managedWriterSnapshot()
-  );
-  const hintParts = [];
-  if (locks.length > 0) hintParts.push(`${locks.length} lock(s)`);
-  if (stashes.length > 0) hintParts.push(`${stashes.length} wiki-sync stash(es)`);
-  if (managedWriters.count > 0) hintParts.push(`${managedWriters.count} live writer overlap(s)`);
-  if (stashAudit.length > 0) hintParts.push(`${stashAudit.length} stash audit item(s)`);
-  const blocking = locks.some((lock) => !lock.is_self) || managedWriters.blocking || stashAudit.some((entry) => entry.classification === "recent_known_peer_stash");
-  const humanHint = hintParts.length > 0 ? hintParts.join(", ") : "no peers detected";
-  return {
-    exitCode: ExitCode.OK,
-    result: ok({
-      locks,
-      stashes,
-      stash_audit: stashAudit,
-      managed_writers: managedWriters,
-      blocking,
-      humanHint
-    })
-  };
-}
-function runSyncLock(input) {
-  const vault = input.vault;
-  if (!existsSync9(vault)) {
-    return {
-      exitCode: ExitCode.VAULT_PATH_INVALID,
-      result: err("VAULT_PATH_INVALID", { path: vault })
-    };
-  }
-  const result = acquireLock(vault, {
-    sessionId: input.sessionId,
-    summary: input.summary,
-    ttlMinutes: input.ttlMinutes,
-    force: input.force
-  });
-  if (result.ok) {
-    return {
-      exitCode: ExitCode.OK,
-      result: ok({
-        acquired: true,
-        lock: result.lock,
-        humanHint: `lock acquired for ${result.lock.summary} (expires ${result.lock.expires})`
-      })
-    };
-  } else {
-    return {
-      exitCode: ExitCode.SYNC_LOCK_HELD,
-      result: ok({
-        acquired: false,
-        lock: result.held,
-        held_by: result.held,
-        humanHint: `lock held by session ${result.held.session_id} (PID ${result.held.pid}) for ${result.held.summary}`
-      })
-    };
-  }
-}
-function runSyncUnlock(input) {
-  const vault = input.vault;
-  if (!existsSync9(vault)) {
-    return {
-      exitCode: ExitCode.VAULT_PATH_INVALID,
-      result: err("VAULT_PATH_INVALID", { path: vault })
-    };
-  }
-  const result = releaseLock(vault, { sessionId: input.sessionId, force: input.force });
-  let humanHint;
-  if (result.released && result.prior) {
-    humanHint = `lock force-released (was held by session ${result.prior.session_id}, PID ${result.prior.pid})`;
-  } else if (result.released) {
-    humanHint = "lock released";
-  } else {
-    humanHint = "lock not held by this session (no-op)";
-  }
-  const output = {
-    released: result.released,
-    humanHint
-  };
-  if (result.prior) {
-    output.prior = {
-      session_id: result.prior.session_id,
-      pid: result.prior.pid,
-      summary: result.prior.summary
-    };
-  }
-  return {
-    exitCode: ExitCode.OK,
-    result: ok(output)
-  };
-}
-
 // src/commands/sync-journal.ts
 function runSyncJournalList(input) {
   const byPhase = {};
@@ -8434,11 +7838,11 @@ function runSyncJournalClearStale(input) {
 }
 
 // src/commands/snapshot-maintenance.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync4, appendFileSync } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, appendFileSync } from "fs";
 import { createHash as createHash5 } from "crypto";
 import { execSync as execSync3, spawn } from "child_process";
 import { platform as platform2 } from "os";
-import { join as join31, resolve as resolvePath2 } from "path";
+import { join as join30, resolve as resolvePath2 } from "path";
 var MAINTENANCE_SCHEMA_VERSION = 1;
 var MAINTENANCE_COMMAND = "snapshot-maintenance journal clear-stale";
 function canonicalize(p) {
@@ -8501,7 +7905,7 @@ async function runSnapshotMaintenanceDryRun(input) {
     audit(makeAuditEvent(input, fleetLoad.hostId, now, "refusal", "MAINTENANCE_WRONG_WORKTREE"));
     return { exitCode: ExitCode.PROTECTED_SNAPSHOTTER_WRITE_BLOCKED, result: refusalErr("MAINTENANCE_WRONG_WORKTREE", `requested path '${requested}' is not the configured snapshot worktree '${canonicalize(configuredWorktree)}'`) };
   }
-  if (!existsSync10(requested) || !existsSync10(join31(requested, ".git"))) {
+  if (!existsSync9(requested) || !existsSync9(join30(requested, ".git"))) {
     audit(makeAuditEvent(input, fleetLoad.hostId, now, "refusal", "MAINTENANCE_MISSING_GIT_REPO"));
     return { exitCode: ExitCode.PROTECTED_SNAPSHOTTER_WRITE_BLOCKED, result: refusalErr("MAINTENANCE_MISSING_GIT_REPO", `snapshot worktree is not a git repository: ${requested}`) };
   }
@@ -8581,14 +7985,14 @@ async function resolveLiveVault(input) {
   return resolved.ok ? canonicalize(resolved.data.path) : void 0;
 }
 function snapshotMaintenanceAuditLogPath(home) {
-  const stateDir = platform2() === "darwin" ? join31(home, "Library", "Application Support", "vault-sync") : join31(home, ".local", "state", "vault-sync");
-  return join31(stateDir, "snapshot-maintenance-audit.jsonl");
+  const stateDir = platform2() === "darwin" ? join30(home, "Library", "Application Support", "vault-sync") : join30(home, ".local", "state", "vault-sync");
+  return join30(stateDir, "snapshot-maintenance-audit.jsonl");
 }
 function defaultAuditSink(home) {
   return (event) => {
     try {
       const logPath = snapshotMaintenanceAuditLogPath(home);
-      mkdirSync4(join31(logPath, ".."), { recursive: true });
+      mkdirSync4(join30(logPath, ".."), { recursive: true });
       appendFileSync(logPath, JSON.stringify(event) + "\n", { encoding: "utf8" });
     } catch {
     }
@@ -8749,7 +8153,7 @@ function releaseSnapshotFlock(handle) {
 
 // src/commands/backup.ts
 import { statSync as statSync2, readdirSync as readdirSync2, readFileSync as readFileSync15, mkdirSync as mkdirSync5, writeFileSync as writeFileSync6 } from "fs";
-import { join as join32, relative as relative3, dirname as dirname10 } from "path";
+import { join as join31, relative as relative3, dirname as dirname10 } from "path";
 import { PutObjectCommand, HeadObjectCommand, ListObjectsV2Command, GetObjectCommand, DeleteObjectsCommand } from "@aws-sdk/client-s3";
 
 // src/utils/s3-client.ts
@@ -8773,7 +8177,7 @@ var SKIP_DIRS = /* @__PURE__ */ new Set([".git", ".obsidian", "_archive", "node_
 function* walkMarkdown(dir, base) {
   for (const entry of readdirSync2(dir, { withFileTypes: true })) {
     if (SKIP_DIRS.has(entry.name)) continue;
-    const full = join32(dir, entry.name);
+    const full = join31(dir, entry.name);
     if (entry.isDirectory()) {
       yield* walkMarkdown(full, base);
     } else if (entry.name.endsWith(".md")) {
@@ -8796,7 +8200,7 @@ async function runBackupSync(input) {
   let failed = 0;
   const files = [...walkMarkdown(input.vault, input.vault)];
   for (const relPath of files) {
-    const absPath = join32(input.vault, relPath);
+    const absPath = join31(input.vault, relPath);
     const localStat = statSync2(absPath);
     let needsUpload = true;
     try {
@@ -8872,7 +8276,7 @@ async function runBackupRestore(input) {
     const objects = list.Contents ?? [];
     for (const obj of objects) {
       if (!obj.Key) continue;
-      const localPath = join32(target, obj.Key);
+      const localPath = join31(target, obj.Key);
       try {
         const localStat = statSync2(localPath);
         if (obj.LastModified && localStat.mtime > obj.LastModified) {
@@ -8918,11 +8322,11 @@ async function runBackupRestore(input) {
 }
 
 // src/commands/status.ts
-import { existsSync as existsSync11, statSync as statSync3 } from "fs";
+import { existsSync as existsSync10, statSync as statSync3 } from "fs";
 import { readFile as readFile16 } from "fs/promises";
-import { join as join33 } from "path";
+import { join as join32 } from "path";
 async function runStatus(input) {
-  if (!existsSync11(input.vault)) {
+  if (!existsSync10(input.vault)) {
     return { exitCode: ExitCode.VAULT_PATH_INVALID, result: err("VAULT_PATH_INVALID", { vault: input.vault }) };
   }
   const scan = await scanVault(input.vault);
@@ -8947,7 +8351,7 @@ async function runStatus(input) {
   const compound = scan.data.compound.length;
   let schemaVersion = "v1";
   try {
-    const schemaContent = await readFile16(join33(input.vault, "SCHEMA.md"), "utf8");
+    const schemaContent = await readFile16(join32(input.vault, "SCHEMA.md"), "utf8");
     const versionMatch = schemaContent.match(/version:\s*["']?([^"'\s\n]+)/i);
     if (versionMatch) schemaVersion = versionMatch[1];
   } catch {
@@ -9008,7 +8412,7 @@ async function runStatus(input) {
 
 // src/commands/seed.ts
 import { mkdir as mkdir12, writeFile as writeFile8, stat as stat4 } from "fs/promises";
-import { join as join34 } from "path";
+import { join as join33 } from "path";
 var TODAY = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
 var EXAMPLE_PAGES = {
   "entities/example-project.md": `---
@@ -9077,29 +8481,29 @@ Real sources are immutable after ingestion \u2014 never edit them.
 `;
 async function runSeed(input) {
   try {
-    await stat4(join34(input.vault, "SCHEMA.md"));
+    await stat4(join33(input.vault, "SCHEMA.md"));
   } catch {
     return { exitCode: ExitCode.VAULT_PATH_INVALID, result: err("VAULT_PATH_INVALID", { root: input.vault, reason: "SCHEMA.md missing \u2014 run `skillwiki init` first" }) };
   }
   const created = [];
   const skipped = [];
   for (const [relPath, content] of Object.entries(EXAMPLE_PAGES)) {
-    const absPath = join34(input.vault, relPath);
+    const absPath = join33(input.vault, relPath);
     try {
       await stat4(absPath);
       skipped.push(relPath);
     } catch {
-      await mkdir12(join34(absPath, ".."), { recursive: true });
+      await mkdir12(join33(absPath, ".."), { recursive: true });
       await writeFile8(absPath, content, "utf8");
       created.push(relPath);
     }
   }
-  const rawPath = join34(input.vault, "raw", "articles", "example-source.md");
+  const rawPath = join33(input.vault, "raw", "articles", "example-source.md");
   try {
     await stat4(rawPath);
     skipped.push("raw/articles/example-source.md");
   } catch {
-    await mkdir12(join34(rawPath, ".."), { recursive: true });
+    await mkdir12(join33(rawPath, ".."), { recursive: true });
     await writeFile8(rawPath, EXAMPLE_RAW, "utf8");
     created.push("raw/articles/example-source.md");
   }
@@ -9123,8 +8527,8 @@ async function runSeed(input) {
 
 // src/commands/canvas.ts
 import { readFile as readFile17, writeFile as writeFile9 } from "fs/promises";
-import { existsSync as existsSync12 } from "fs";
-import { join as join35 } from "path";
+import { existsSync as existsSync11 } from "fs";
+import { join as join34 } from "path";
 var NODE_WIDTH = 240;
 var NODE_HEIGHT = 60;
 var COLUMN_SPACING = 400;
@@ -9202,8 +8606,8 @@ function buildCanvasEdges(adjacency) {
   return edges;
 }
 async function runCanvasGenerate(input) {
-  const graphPath = input.graphPath ?? join35(input.vault, ".skillwiki", "graph.json");
-  if (!existsSync12(graphPath)) {
+  const graphPath = input.graphPath ?? join34(input.vault, ".skillwiki", "graph.json");
+  if (!existsSync11(graphPath)) {
     return {
       exitCode: ExitCode.FILE_NOT_FOUND,
       result: err("FILE_NOT_FOUND", {
@@ -9240,7 +8644,7 @@ async function runCanvasGenerate(input) {
   const nodes = buildCanvasNodes(paths);
   const edges = buildCanvasEdges(graph.adjacency);
   const canvas = { nodes, edges };
-  const outPath = join35(input.vault, "vault-graph.canvas");
+  const outPath = join34(input.vault, "vault-graph.canvas");
   try {
     await writeFile9(outPath, JSON.stringify(canvas, null, 2));
   } catch (e) {
@@ -9279,7 +8683,7 @@ import { readFile as readFile19, unlink as unlink5 } from "fs/promises";
 
 // src/utils/raw-asset-reference-index.ts
 import { readdir as readdir7, readFile as readFile18 } from "fs/promises";
-import { join as join36, relative as relative4, sep as sep3 } from "path";
+import { join as join35, relative as relative4, sep as sep3 } from "path";
 var PREVIEW_EXTENSIONS = /* @__PURE__ */ new Set(["png", "jpg", "jpeg", "gif", "webp", "svg", "bmp", "avif", "pdf", "mp3", "wav", "m4a", "mp4", "webm"]);
 async function walkFiles(root, dir = root) {
   let entries;
@@ -9290,7 +8694,7 @@ async function walkFiles(root, dir = root) {
   }
   const out = [];
   for (const entry of entries) {
-    const path = join36(dir, entry.name);
+    const path = join35(dir, entry.name);
     if (entry.isDirectory()) out.push(...await walkFiles(root, path));
     else if (entry.isFile()) out.push(relative4(root, path).split(sep3).join("/"));
   }
@@ -9306,7 +8710,7 @@ function addInbound(map, target, source) {
   map.set(target, refs);
 }
 async function buildRawAssetReferenceIndex(vault) {
-  const assetRoot = join36(vault, "raw", "assets");
+  const assetRoot = join35(vault, "raw", "assets");
   const relativeAssets = await walkFiles(assetRoot);
   const assets = relativeAssets.map((path) => `raw/assets/${path}`).sort((a, b) => a.localeCompare(b));
   const assetSet = new Set(assets);
@@ -9503,10 +8907,10 @@ async function runSourceDisposal(input) {
 }
 
 // src/commands/fleet-health.ts
-import { existsSync as existsSync13, readFileSync as readFileSync16 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync16 } from "fs";
 import { execSync as nodeExecSync } from "child_process";
 import { hostname as nodeHostname, platform as nodePlatform } from "os";
-import { join as join37 } from "path";
+import { join as join36 } from "path";
 var SSH_TIMEOUT_MS = 15e3;
 var TIMER_UNIT = "agent-memory-trends.timer";
 var SERVICE_UNIT = "agent-memory-trends.service";
@@ -9603,7 +9007,7 @@ function applyServiceFailedOverlay(run, serviceFailed) {
 function probeLocal(vaultPath, deps) {
   const latestPath = satelliteLatestRunPath(vaultPath);
   let parsed = null;
-  if (existsSync13(latestPath)) {
+  if (existsSync12(latestPath)) {
     try {
       const wire = readSatelliteLatestRunFromText(readFileSync16(latestPath, "utf8"));
       if (wire) {
@@ -9736,7 +9140,7 @@ async function runFleetHealth(input) {
   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 ? join37(vault, FLEET_REL_PATH) : void 0);
+  const file = input.file ?? (vault ? join36(vault, FLEET_REL_PATH) : void 0);
   if (!file) {
     return {
       exitCode: ExitCode.NO_VAULT_CONFIGURED,
@@ -9820,15 +9224,15 @@ async function runFleetHealth(input) {
 }
 
 // src/utils/auto-commit.ts
-import { existsSync as existsSync14 } from "fs";
-import { join as join38 } from "path";
+import { existsSync as existsSync13 } from "fs";
+import { join as join37 } 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 (!existsSync14(join38(vault, ".git"))) return;
+  if (!existsSync13(join37(vault, ".git"))) return;
   const lastOps = readLastOp(vault);
   if (lastOps.length === 0) return;
   const porcelain = git(vault, ["status", "--porcelain", "--", ...VAULT_COMMIT_PATHSPEC]);
@@ -9852,9 +9256,9 @@ async function postCommit(vault, exitCode) {
 }
 
 // src/commands/write-preflight.ts
-import { existsSync as existsSync15, readFileSync as readFileSync17, statSync as statSync4 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync17, statSync as statSync4 } from "fs";
 async function runWritePreflightCommand(input) {
-  if (!existsSync15(input.vault) || !statSync4(input.vault).isDirectory()) {
+  if (!existsSync14(input.vault) || !statSync4(input.vault).isDirectory()) {
     return {
       exitCode: ExitCode.VAULT_PATH_INVALID,
       result: err(GateError.VAULT_PATH_INVALID, { path: input.vault })
@@ -9862,7 +9266,7 @@ async function runWritePreflightCommand(input) {
   }
   let priorText = input.priorArtifactText;
   if (input.priorArtifactFile) {
-    if (!existsSync15(input.priorArtifactFile)) {
+    if (!existsSync14(input.priorArtifactFile)) {
       return {
         exitCode: ExitCode.FILE_NOT_FOUND,
         result: err("FILE_NOT_FOUND", { path: input.priorArtifactFile })
@@ -9982,7 +9386,7 @@ async function emitManagedVaultWrite(vault, command, mutate, opts) {
   if (dirty) {
     return emit(dirty, void 0, { postCommit: false });
   }
-  const { runManagedWriteTransaction: runManagedWriteTransaction2 } = await import("./managed-write-preflight-4LPVMP42.js");
+  const { runManagedWriteTransaction: runManagedWriteTransaction2 } = await import("./managed-write-preflight-2FU5F56H.js");
   const run = await runManagedWriteTransaction2({
     vault,
     command,
@@ -10012,7 +9416,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 ?? join39(vault, ".skillwiki", "graph.json");
+  const out = opts.out ?? join38(vault, ".skillwiki", "graph.json");
   return emitGuardedVaultWrite(vault, "graph build", () => runGraphBuild({ vault, out }));
 });
 var canvasCmd = program.command("canvas").description("manage Obsidian canvas files");