skillwiki 0.10.51 → 0.10.53

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

@@ -35,7 +35,7 @@ import {
   snapshotterAliasForLocalHost,
   toUndirectedWeighted,
   writeDotenv
-} from "./chunk-UPQ6XJSV.js";
+} from "./chunk-TZXWZ75D.js";
 import {
   atomicWriteText,
   prepareTypedPage
@@ -2673,6 +2673,30 @@ import { existsSync as existsSync12, readFileSync as readFileSync7 } from "fs";
 import { join as join15 } from "path";
 import { execSync as execSync5 } from "child_process";
 import { platform as platform3 } from "os";
+function readPushResultState(stateFile) {
+  if (!existsSync12(stateFile)) return { exists: false };
+  try {
+    const content = readFileSync7(stateFile, "utf8");
+    let result;
+    let reason;
+    let timestamp;
+    for (const line of content.split(/\r?\n/)) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const eq = trimmed.indexOf("=");
+      if (eq <= 0) continue;
+      const k = trimmed.slice(0, eq).trim();
+      const v = trimmed.slice(eq + 1).trim();
+      if (k === "result") result = v;
+      else if (k === "reason") reason = v;
+      else if (k === "timestamp") timestamp = v;
+    }
+    const malformed = result !== "ok" && result !== "refused";
+    return { exists: true, result, reason, timestamp, malformed };
+  } catch {
+    return { exists: true, malformed: true };
+  }
+}
 function readVaultSyncConfig(home) {
   try {
     const content = readFileSync7(join15(home, ".skillwiki", ".env"), "utf8");
@@ -2749,6 +2773,86 @@ function ageMinutes(nowMs, tsMs) {
   if (tsMs == null) return null;
   return Math.floor((nowMs - tsMs) / 6e4);
 }
+function checkPushAgeFromTimestamp(ts) {
+  const lastPush = new Date(ts).getTime();
+  if (isNaN(lastPush)) {
+    return check(
+      "warn",
+      "vault_sync_last_push_age",
+      "Vault sync last push recency",
+      `Unparseable push timestamp: ${ts}`
+    );
+  }
+  const ageSec = (Date.now() - lastPush) / 1e3;
+  if (ageSec <= 180) {
+    return check(
+      "pass",
+      "vault_sync_last_push_age",
+      "Vault sync last push recency",
+      `Last push ${ageSec.toFixed(0)}s ago`
+    );
+  }
+  return check(
+    "warn",
+    "vault_sync_last_push_age",
+    "Vault sync last push recency",
+    `Last push ${Math.round(ageSec)}s ago (>3 min)`
+  );
+}
+function checkPushAgeFromLog(logDir, logFile) {
+  try {
+    const logContent = readFileSync7(logFile, "utf8");
+    const lines = logContent.trim().split("\n").filter(Boolean);
+    if (lines.length === 0) {
+      return check(
+        "warn",
+        "vault_sync_last_push_age",
+        "Vault sync last push recency",
+        "Log file is empty"
+      );
+    }
+    const journalRe = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z) (OK push|FAIL)/;
+    let lastLine;
+    let match = null;
+    for (let i = lines.length - 1; i >= 0; i--) {
+      match = lines[i].match(journalRe);
+      if (match) {
+        lastLine = lines[i];
+        break;
+      }
+    }
+    if (!lastLine || !match) {
+      const tail = lines[lines.length - 1];
+      return check(
+        "warn",
+        "vault_sync_last_push_age",
+        "Vault sync last push recency",
+        `Last log entry: ${tail.slice(0, 80)}`
+      );
+    }
+    if (match[2] === "FAIL") {
+      return check(
+        "error",
+        "vault_sync_last_push_age",
+        "Vault sync last push recency",
+        `Last push failed: ${lastLine}`
+      );
+    }
+    return checkPushAgeFromTimestamp(match[1]);
+  } catch {
+    return existsSync12(logDir) ? check(
+      "warn",
+      "vault_sync_last_push_age",
+      "Vault sync last push recency",
+      `Log file not found at ${logFile}`
+    ) : check(
+      "error",
+      "vault_sync_last_push_age",
+      "Vault sync last push recency",
+      `Log directory not found at ${logDir}`
+    );
+  }
+}
 function snapshotterHealthChecks(scope, logDir, env) {
   const fixture = loadSnapshotFixture(env);
   const cadence = fixture ? fixture.cadence_minutes : parseInt(env.VS_SNAPSHOT_CADENCE_MINUTES ?? "30", 10) || 30;
@@ -2861,6 +2965,7 @@ function vaultSyncChecks(input) {
       skip("vault_sync_jobs_enabled", "Vault sync jobs enabled"),
       skip("vault_sync_snapshot_service_result", "Vault sync snapshot service result"),
       skip("vault_sync_last_push_age", "Vault sync last push recency"),
+      skip("vault_sync_last_push_result", "Vault sync last push result"),
       skip("vault_sync_snapshot_consecutive_failures", "Vault sync snapshot consecutive failures"),
       skip("vault_sync_last_fetch_status", "Vault sync last fetch status"),
       skip("vault_sync_filter_present", "Vault sync filter file present"),
@@ -2869,6 +2974,7 @@ function vaultSyncChecks(input) {
   }
   const isMac = os === "darwin";
   const logDir = input.logDir ?? (isMac ? join15(home, "Library", "Logs") : join15(home, ".local", "state", "vault-sync", "log"));
+  const cacheDir = input.cacheDir ?? (isMac ? join15(home, "Library", "Caches", "vault-sync") : join15(home, ".cache", "vault-sync"));
   const shareDir = input.shareDir ?? (isMac ? join15(home, "Library", "Application Support", "vault-sync", "bin") : join15(home, ".local", "share", "vault-sync", "bin"));
   const filterPath = input.filterPath ?? join15(home, ".config", "rclone", "wiki-push-filters.txt");
   const packagedSnapshotPath = join15(shareDir, "wiki-snapshot.sh");
@@ -2979,75 +3085,56 @@ function vaultSyncChecks(input) {
       "Scheduler check failed \u2014 run vault-sync-install"
     );
   }
+  const stateFile = join15(cacheDir, "wiki-push-result.state");
+  const pushState = readPushResultState(stateFile);
   const logFile = join15(logDir, "wiki-push.log");
   let c3;
-  try {
-    const logContent = readFileSync7(logFile, "utf8");
-    const lines = logContent.trim().split("\n").filter(Boolean);
-    if (lines.length === 0) {
-      c3 = check(
-        "warn",
-        "vault_sync_last_push_age",
-        "Vault sync last push recency",
-        "Log file is empty"
-      );
-    } else {
-      const lastLine = [...lines].reverse().find((line) => /FAIL|OK push/.test(line)) ?? lines[lines.length - 1];
-      if (/FAIL/.test(lastLine)) {
-        c3 = check(
-          "error",
-          "vault_sync_last_push_age",
-          "Vault sync last push recency",
-          `Last push failed: ${lastLine}`
-        );
-      } else if (/OK push/.test(lastLine)) {
-        const tsMatch = lastLine.match(/^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z)/);
-        if (tsMatch) {
-          const lastPush = new Date(tsMatch[1]).getTime();
-          const ageSec = (Date.now() - lastPush) / 1e3;
-          if (ageSec <= 180) {
-            c3 = check(
-              "pass",
-              "vault_sync_last_push_age",
-              "Vault sync last push recency",
-              `Last push ${ageSec.toFixed(0)}s ago`
-            );
-          } else {
-            c3 = check(
-              "warn",
-              "vault_sync_last_push_age",
-              "Vault sync last push recency",
-              `Last push ${Math.round(ageSec)}s ago (>3 min)`
-            );
-          }
-        } else {
-          c3 = check(
-            "warn",
-            "vault_sync_last_push_age",
-            "Vault sync last push recency",
-            `Unparseable push line: ${lastLine.slice(0, 80)}`
-          );
-        }
-      } else {
-        c3 = check(
-          "warn",
-          "vault_sync_last_push_age",
-          "Vault sync last push recency",
-          `Last log entry: ${lastLine.slice(0, 80)}`
-        );
-      }
-    }
-  } catch {
-    c3 = existsSync12(logDir) ? check(
-      "warn",
+  if (pushState.exists && !pushState.malformed && pushState.result === "refused") {
+    const reasonSuffix = pushState.reason ? `: ${pushState.reason}` : "";
+    c3 = check(
+      "error",
       "vault_sync_last_push_age",
       "Vault sync last push recency",
-      `Log file not found at ${logFile}`
-    ) : check(
-      "error",
+      `Last push refused${reasonSuffix}`
+    );
+  } else if (pushState.exists && !pushState.malformed && pushState.result === "ok") {
+    c3 = pushState.timestamp ? checkPushAgeFromTimestamp(pushState.timestamp) : check(
+      "warn",
       "vault_sync_last_push_age",
       "Vault sync last push recency",
-      `Log directory not found at ${logDir}`
+      "State file missing timestamp"
+    );
+  } else {
+    c3 = checkPushAgeFromLog(logDir, logFile);
+  }
+  let cPushResult;
+  if (!pushState.exists) {
+    cPushResult = check(
+      "warn",
+      "vault_sync_last_push_result",
+      "Vault sync last push result",
+      `no push result state file (push may not have run yet): ${stateFile}`
+    );
+  } else if (pushState.malformed) {
+    cPushResult = check(
+      "warn",
+      "vault_sync_last_push_result",
+      "Vault sync last push result",
+      `malformed state file: ${stateFile}`
+    );
+  } else if (pushState.result === "ok") {
+    cPushResult = check(
+      "pass",
+      "vault_sync_last_push_result",
+      "Vault sync last push result",
+      `result=ok timestamp=${pushState.timestamp ?? ""}`
+    );
+  } else {
+    cPushResult = check(
+      "error",
+      "vault_sync_last_push_result",
+      "Vault sync last push result",
+      `result=refused reason=${pushState.reason ?? ""} timestamp=${pushState.timestamp ?? ""}`
     );
   }
   const fetchLogFile = join15(logDir, "wiki-fetch.log");
@@ -3182,7 +3269,7 @@ function vaultSyncChecks(input) {
       );
     }
   }
-  return [c1, c2, c3, cFetch, c4, c5];
+  return [c1, c2, c3, cPushResult, cFetch, c4, c5];
 }
 function checkVaultSyncPullHelper(home, env) {
   const path = resolveVaultSyncPullHelper({

package/dist/{chunk-UPQ6XJSV.js → chunk-TZXWZ75D.js}

@@ -607,7 +607,7 @@ function safeUserName() {
 // src/commands/sync.ts
 import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
 import { join as join17 } from "path";
-import { execFileSync as execFileSync3 } from "child_process";
+import { execFileSync as execFileSync4 } from "child_process";
 
 // src/utils/last-op.ts
 import { readFileSync, writeFileSync, mkdirSync, unlinkSync, existsSync } from "fs";
@@ -5037,6 +5037,41 @@ var LINT_RULES = [
   cycleTrapsRule
 ];
 
+// src/utils/git-archive.ts
+import { execFileSync } from "child_process";
+import { rmSync } from "fs";
+function extractGitTree(vault, ref, destDir) {
+  if (process.platform === "win32") {
+    const zipPath = `${destDir}.zip`;
+    execFileSync("git", ["archive", "--format=zip", `--output=${zipPath}`, ref], {
+      cwd: vault,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    try {
+      execFileSync("tar", ["-xf", zipPath], {
+        cwd: destDir,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } finally {
+      try {
+        rmSync(zipPath, { force: true });
+      } catch {
+      }
+    }
+    return;
+  }
+  const archive = execFileSync("git", ["archive", "--format=tar", ref], {
+    cwd: vault,
+    stdio: ["pipe", "pipe", "pipe"],
+    maxBuffer: 256 * 1024 * 1024
+  });
+  execFileSync("tar", ["-xf", "-"], {
+    cwd: destDir,
+    input: archive,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+}
+
 // src/lint/runner.ts
 var LintRunner = class {
   rules;
@@ -5183,10 +5218,10 @@ function runLint(input) {
   return defaultLintRunner.run(input);
 }
 async function runSyncLintDelta(input) {
-  const { mkdtempSync, rmSync, existsSync: fsExists } = await import("fs");
+  const { mkdtempSync, rmSync: rmSync2, existsSync: fsExists } = await import("fs");
   const { join: pathJoin } = await import("path");
   const { tmpdir } = await import("os");
-  const { execFileSync: execFileSync4 } = await import("child_process");
+  const { execFileSync: execFileSync5 } = await import("child_process");
   const vault = input.vault;
   const baseRef = input.baseRef ?? "origin/main";
   const days = input.days ?? 90;
@@ -5199,7 +5234,7 @@ async function runSyncLintDelta(input) {
     };
   }
   try {
-    execFileSync4("git", ["rev-parse", "--verify", baseRef], {
+    execFileSync5("git", ["rev-parse", "--verify", baseRef], {
       cwd: vault,
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -5229,16 +5264,7 @@ async function runSyncLintDelta(input) {
   const fullFps = collectLintErrorFingerprints(fullOutput);
   const tmpRoot = mkdtempSync(pathJoin(tmpdir(), "skillwiki-lint-delta-"));
   try {
-    const archive = execFileSync4("git", ["archive", "--format=tar", baseRef], {
-      cwd: vault,
-      stdio: ["pipe", "pipe", "pipe"],
-      maxBuffer: 256 * 1024 * 1024
-    });
-    execFileSync4("tar", ["-xf", "-"], {
-      cwd: tmpRoot,
-      input: archive,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
+    extractGitTree(vault, baseRef, tmpRoot);
     if (!fsExists(pathJoin(tmpRoot, "SCHEMA.md"))) {
     }
     const baseLint = await runLint({ vault: tmpRoot, days, lines, logThreshold });
@@ -5293,23 +5319,23 @@ async function runSyncLintDelta(input) {
     };
   } finally {
     try {
-      rmSync(tmpRoot, { recursive: true, force: true });
+      rmSync2(tmpRoot, { recursive: true, force: true });
     } catch {
     }
   }
 }
 
 // src/utils/git.ts
-import { execFileSync } from "child_process";
+import { execFileSync as execFileSync2 } from "child_process";
 function git(cwd, args) {
   try {
-    return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    return execFileSync2("git", args, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
   } catch {
     return "";
   }
 }
 function gitStrict(cwd, args) {
-  return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+  return execFileSync2("git", args, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
 }
 
 // src/utils/sync-lock.ts
@@ -5494,9 +5520,9 @@ function stageVaultContentChanges(vault) {
 // src/utils/remote-health.ts
 import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
 import { join as join15 } from "path";
-import { execFileSync as execFileSync2 } from "child_process";
+import { execFileSync as execFileSync3 } from "child_process";
 var REMOTE_PROBE_TIMEOUT_MS = 3e3;
-var defaultExec = (file, args, cwd) => execFileSync2(file, args, {
+var defaultExec = (file, args, cwd) => execFileSync3(file, args, {
   cwd,
   encoding: "utf8",
   stdio: ["pipe", "pipe", "pipe"],
@@ -5716,7 +5742,7 @@ function isTrackedNotePath(path) {
 }
 function refHasPath(vault, ref, path) {
   try {
-    execFileSync3("git", ["cat-file", "-e", `${ref}:${path}`], {
+    execFileSync4("git", ["cat-file", "-e", `${ref}:${path}`], {
       cwd: vault,
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -6103,6 +6129,7 @@ function collectManagedWriterAncestorPids(startPid, readStatus = readProcStatus)
   return ids;
 }
 function readProcStatus(pid) {
+  if (process.platform !== "linux") return null;
   try {
     return readFileSync5(`/proc/${pid}/status`, "utf8");
   } catch {
@@ -6145,12 +6172,12 @@ function classifyManagedWriterProcesses(snapshot, currentPid = process.pid, ance
 function managedWriterSnapshot() {
   try {
     if (process.platform === "win32") {
-      return execFileSync3("tasklist", ["/FO", "CSV", "/NH"], {
+      return execFileSync4("tasklist", ["/FO", "CSV", "/NH"], {
         encoding: "utf8",
         stdio: ["pipe", "pipe", "pipe"]
       });
     }
-    return execFileSync3("ps", ["-axo", "pid=,command="], {
+    return execFileSync4("ps", ["-axo", "pid=,command="], {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -6688,10 +6715,25 @@ function resolveConfiguredSnapshotWorktree(home) {
 }
 
 // src/utils/managed-write-preflight.ts
+var DEFAULT_MANAGED_WRITE_WAIT_MS = 24e4;
+var MANAGED_WRITE_POLL_INTERVAL_MS = 2e3;
+function resolveManagedWriteWaitMs(env) {
+  const raw = env?.SKILLWIKI_MANAGED_WRITE_WAIT_MS ?? process.env.SKILLWIKI_MANAGED_WRITE_WAIT_MS;
+  if (!raw) return DEFAULT_MANAGED_WRITE_WAIT_MS;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) return DEFAULT_MANAGED_WRITE_WAIT_MS;
+  return parsed;
+}
 var DEFAULT_DEPS = {
   converge: (input) => runVaultSyncPullHelper(input),
   resolveConfiguredSnapshotWorktree,
-  syncPeers: runSyncPeers
+  syncPeers: runSyncPeers,
+  sleepMs: (ms) => new Promise((resolve7) => setTimeout(resolve7, ms)),
+  nowMs: () => Date.now(),
+  logHeartbeat: (message) => {
+    process.stderr.write(`${message}
+`);
+  }
 };
 var SAFE_MANAGED_WRITER_KINDS = new Set(MANAGED_WRITER_KINDS);
 var SAFE_STASH_AUDIT_CLASSIFICATIONS = new Set(STASH_AUDIT_CLASSIFICATIONS);
@@ -6764,48 +6806,91 @@ function peerCheckFailure(reason, detail = {}) {
     result: err("PREFLIGHT_FAILED", { reason, ...detail })
   };
 }
-function runManagedWritePeerGate(vault, mode, deps) {
+function evaluateManagedWritePeerGate(vault, mode, deps) {
   try {
     const check = (deps.syncPeers ?? DEFAULT_DEPS.syncPeers)({ vault });
     if (check.exitCode !== ExitCode.OK || !check.result.ok) {
-      return peerCheckFailure("peer-check-failed");
+      return { status: "block", failure: peerCheckFailure("peer-check-failed") };
     }
     const validated = validateSyncPeersOutput(check.result.data);
     if (!validated) {
-      return peerCheckFailure("peer-check-failed");
+      return { status: "block", failure: peerCheckFailure("peer-check-failed") };
     }
     const { output: peerOutput, foreignLockCount, recentPeerStashCount } = validated;
     const nonWriterBlockingSignal = foreignLockCount > 0 || recentPeerStashCount > 0;
     const writerOnly = peerOutput.managed_writers.blocking && !nonWriterBlockingSignal;
-    if (mode !== "git-writer" && writerOnly) return null;
+    if (mode !== "git-writer" && writerOnly) return { status: "pass" };
     const managedWriterBlocking = mode === "git-writer" && peerOutput.managed_writers.blocking;
     const hasKnownBlockingSignal = foreignLockCount > 0 || managedWriterBlocking || recentPeerStashCount > 0;
     if (!peerOutput.blocking) {
-      return hasKnownBlockingSignal ? peerCheckFailure("peer-check-failed") : null;
+      return hasKnownBlockingSignal ? { status: "block", failure: peerCheckFailure("peer-check-failed") } : { status: "pass" };
     }
     if (managedWriterBlocking) {
-      return peerCheckFailure("live-writer-overlap", {
-        managed_writer_count: peerOutput.managed_writers.count,
-        managed_writer_kinds: peerOutput.managed_writers.kinds.slice(0, 8),
-        blocking: true
-      });
+      return {
+        status: "overlap",
+        count: peerOutput.managed_writers.count,
+        kinds: peerOutput.managed_writers.kinds.slice(0, 8)
+      };
     }
     if (foreignLockCount > 0) {
-      return peerCheckFailure("peer-lock", {
-        foreign_lock_count: foreignLockCount,
-        blocking: true
-      });
+      return {
+        status: "block",
+        failure: peerCheckFailure("peer-lock", {
+          foreign_lock_count: foreignLockCount,
+          blocking: true
+        })
+      };
     }
     if (recentPeerStashCount > 0) {
-      return peerCheckFailure("recent-peer-stash", {
-        recent_peer_stash_count: recentPeerStashCount,
-        stash_classification: "recent_known_peer_stash",
-        blocking: true
-      });
+      return {
+        status: "block",
+        failure: peerCheckFailure("recent-peer-stash", {
+          recent_peer_stash_count: recentPeerStashCount,
+          stash_classification: "recent_known_peer_stash",
+          blocking: true
+        })
+      };
     }
-    return peerCheckFailure("peer-blocked", { blocking: true });
+    return {
+      status: "block",
+      failure: peerCheckFailure("peer-blocked", { blocking: true })
+    };
   } catch {
-    return peerCheckFailure("peer-check-failed");
+    return { status: "block", failure: peerCheckFailure("peer-check-failed") };
+  }
+}
+async function runManagedWritePeerGate(vault, mode, deps = DEFAULT_DEPS, env) {
+  const now = deps.nowMs ?? DEFAULT_DEPS.nowMs;
+  const sleep = deps.sleepMs ?? DEFAULT_DEPS.sleepMs;
+  const logHeartbeat = deps.logHeartbeat ?? DEFAULT_DEPS.logHeartbeat;
+  const waitMs = resolveManagedWriteWaitMs(env);
+  const initial = evaluateManagedWritePeerGate(vault, mode, deps);
+  if (initial.status === "pass") return null;
+  if (initial.status === "block") return initial.failure;
+  const startedAt = now();
+  const deadline = startedAt + waitMs;
+  let lastOverlap = initial;
+  for (; ; ) {
+    const t = now();
+    const elapsed = Math.max(0, t - startedAt);
+    const remainingMs = Math.max(0, deadline - t);
+    const remainingSec = Math.ceil(remainingMs / 1e3);
+    const writerKindDesc = lastOverlap.kinds.length > 0 ? lastOverlap.kinds.join(", ") : "unknown";
+    logHeartbeat(`skillwiki: waiting for live vault writer (${writerKindDesc}), ${remainingSec}s left`);
+    if (t >= deadline) {
+      return peerCheckFailure("live-writer-overlap", {
+        managed_writer_count: lastOverlap.count,
+        managed_writer_kinds: lastOverlap.kinds,
+        blocking: true,
+        waited_ms: elapsed
+      });
+    }
+    const nextSleepMs = Math.min(MANAGED_WRITE_POLL_INTERVAL_MS, remainingMs);
+    await sleep(nextSleepMs);
+    const check = evaluateManagedWritePeerGate(vault, mode, deps);
+    if (check.status === "pass") return null;
+    if (check.status === "block") return check.failure;
+    lastOverlap = check;
   }
 }
 function preflightBlocker(vault) {
@@ -7081,7 +7166,7 @@ async function runManagedWriteTransaction(input, deps = DEFAULT_DEPS) {
         })
       };
     }
-    const peerGate = runManagedWritePeerGate(mutationVault, receipt.mode, deps);
+    const peerGate = await runManagedWritePeerGate(mutationVault, receipt.mode, deps, input.env);
     if (peerGate) return peerGate;
     return await input.mutate(receipt);
   } finally {
@@ -7103,6 +7188,7 @@ export {
   louvain,
   communityCohesion,
   extractIssuePage,
+  extractGitTree,
   runLinks,
   extractTaxonomy,
   taxonomyCommentForPage,
@@ -7180,6 +7266,10 @@ export {
   markJournalSuperseded,
   supersedeStaleReviewRequiredJournals,
   resolveConfiguredSnapshotWorktree,
+  DEFAULT_MANAGED_WRITE_WAIT_MS,
+  MANAGED_WRITE_POLL_INTERVAL_MS,
+  resolveManagedWriteWaitMs,
+  runManagedWritePeerGate,
   runManagedWritePreflight,
   runManagedWriteTransaction
 };

package/dist/cli.js

@@ -50,7 +50,7 @@ import {
   snapshotterHealthChecks,
   upsertIndexEntry,
   vectorIndexStatus
-} from "./chunk-3IBRZTLF.js";
+} from "./chunk-NPHWECWR.js";
 import {
   normalizeDistTag,
   readCache,
@@ -79,6 +79,7 @@ import {
   collectClaimedTranscripts,
   defaultLintRunner,
   extractBodyWikilinks,
+  extractGitTree,
   extractIssuePage,
   extractTaxonomy,
   getCliSessionId,
@@ -145,7 +146,7 @@ import {
   supersedeStaleReviewRequiredJournals,
   taxonomyCommentForPage,
   writeDotenv
-} from "./chunk-UPQ6XJSV.js";
+} from "./chunk-TZXWZ75D.js";
 import {
   assertTargetInsideVault,
   atomicWriteText,
@@ -549,16 +550,7 @@ async function runEval(input) {
     }
     const tmpRoot = mkdtempSync(join2(tmpdir(), "skillwiki-eval-delta-"));
     try {
-      const archive = execFileSync("git", ["archive", "--format=tar", baseRef], {
-        cwd: vaultPath,
-        stdio: ["pipe", "pipe", "pipe"],
-        maxBuffer: 256 * 1024 * 1024
-      });
-      execFileSync("tar", ["-xf", "-"], {
-        cwd: tmpRoot,
-        input: archive,
-        stdio: ["pipe", "pipe", "pipe"]
-      });
+      extractGitTree(vaultPath, baseRef, tmpRoot);
       const baseAggRes = await aggregateVault(tmpRoot, topLimit);
       if (!baseAggRes.ok) {
         return {
@@ -3049,11 +3041,12 @@ function classifyLog(path, id, label, okPattern) {
   if (!existsSync6(path)) return { id, label, status: "warn", detail: `log file missing: ${path}` };
   const lines = readFileSync10(path, "utf8").split(/\r?\n/).filter(Boolean);
   if (lines.length === 0) return { id, label, status: "warn", detail: `log file empty: ${path}` };
+  const journalFailRe = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z (FAIL|ERROR)\b/;
   const statusLine = [...lines].reverse().find(
-    (line) => /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z /.test(line) && (okPattern.test(line) || /\bFAIL\b|\bERROR\b/i.test(line))
+    (line) => /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z /.test(line) && (okPattern.test(line) || journalFailRe.test(line))
   );
   const last = statusLine ?? lines[lines.length - 1];
-  if (/\bFAIL\b|\bERROR\b/i.test(last)) return { id, label, status: "error", detail: last.slice(0, 120) };
+  if (journalFailRe.test(last)) return { id, label, status: "error", detail: last.slice(0, 120) };
   if (okPattern.test(last)) return { id, label, status: "pass", detail: last.slice(0, 120) };
   return { id, label, status: "warn", detail: last.slice(0, 120) };
 }
@@ -10076,7 +10069,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-7GDFRPUT.js");
+  const { runManagedWriteTransaction: runManagedWriteTransaction2 } = await import("./managed-write-preflight-SERVDSY6.js");
   const run = await runManagedWriteTransaction2({
     vault,
     command,

package/dist/managed-write-preflight-SERVDSY6.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import {
+  DEFAULT_MANAGED_WRITE_WAIT_MS,
+  MANAGED_WRITE_POLL_INTERVAL_MS,
+  resolveManagedWriteWaitMs,
+  runManagedWritePeerGate,
+  runManagedWritePreflight,
+  runManagedWriteTransaction
+} from "./chunk-TZXWZ75D.js";
+import "./chunk-74OSLCXE.js";
+import "./chunk-GAHMWLWU.js";
+import "./chunk-IJ7DD7QZ.js";
+export {
+  DEFAULT_MANAGED_WRITE_WAIT_MS,
+  MANAGED_WRITE_POLL_INTERVAL_MS,
+  resolveManagedWriteWaitMs,
+  runManagedWritePeerGate,
+  runManagedWritePreflight,
+  runManagedWriteTransaction
+};

package/dist/skillwiki-mcp.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import {
   runSkillwikiMcpStdio
-} from "./chunk-3IBRZTLF.js";
+} from "./chunk-NPHWECWR.js";
 import "./chunk-7I2TPIV5.js";
 import "./chunk-O3HCB7R2.js";
-import "./chunk-UPQ6XJSV.js";
+import "./chunk-TZXWZ75D.js";
 import "./chunk-74OSLCXE.js";
 import "./chunk-HBQTTYXZ.js";
 import "./chunk-GAHMWLWU.js";

package/package.json

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

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

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

package/skills/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "skillwiki",
-  "version": "0.10.51",
+  "version": "0.10.53",
   "description": "Project-aware Karpathy-style knowledge base for Codex with 20 prompt-only skills backed by the deterministic skillwiki CLI.",
   "author": {
     "name": "karlorz",

package/skills/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skillwiki/skills",
-  "version": "0.10.51",
+  "version": "0.10.53",
   "private": true,
   "files": [
     "wiki-*",

package/dist/managed-write-preflight-7GDFRPUT.js

@@ -1,12 +0,0 @@
-#!/usr/bin/env node
-import {
-  runManagedWritePreflight,
-  runManagedWriteTransaction
-} from "./chunk-UPQ6XJSV.js";
-import "./chunk-74OSLCXE.js";
-import "./chunk-GAHMWLWU.js";
-import "./chunk-IJ7DD7QZ.js";
-export {
-  runManagedWritePreflight,
-  runManagedWriteTransaction
-};