skillwiki 0.10.52 → 0.10.54

package/dist/{chunk-VRK5DOC5.js → chunk-EHUFPORA.js}

@@ -6715,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);
@@ -6791,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) {
@@ -7108,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 {
@@ -7183,6 +7241,7 @@ export {
   resolveFleetHostId,
   git,
   gitStrict,
+  VAULT_GENERATED_COMMIT_PATHS,
   VAULT_COMMIT_PATHSPEC,
   stageVaultContentChanges,
   resolveWikiS3Remote,
@@ -7208,6 +7267,10 @@ export {
   markJournalSuperseded,
   supersedeStaleReviewRequiredJournals,
   resolveConfiguredSnapshotWorktree,
+  DEFAULT_MANAGED_WRITE_WAIT_MS,
+  MANAGED_WRITE_POLL_INTERVAL_MS,
+  resolveManagedWriteWaitMs,
+  runManagedWritePeerGate,
   runManagedWritePreflight,
   runManagedWriteTransaction
 };

package/dist/{chunk-JTAZUR2W.js → chunk-Q23OSECM.js}

@@ -35,7 +35,7 @@ import {
   snapshotterAliasForLocalHost,
   toUndirectedWeighted,
   writeDotenv
-} from "./chunk-VRK5DOC5.js";
+} from "./chunk-EHUFPORA.js";
 import {
   atomicWriteText,
   prepareTypedPage
@@ -325,10 +325,14 @@ async function runLogAppend(input) {
   }
   if (outcome.result.ok && outcome.result.data.appended && input.recordLastOp !== false) {
     try {
+      const files = ["log.md"];
+      if (eventPath) {
+        files.push(eventPath);
+      }
       appendLastOp(input.vault, {
         operation: "log-append",
         summary: `appended log entry (${outcome.result.data.entries_before}->${outcome.result.data.entries_after})`,
-        files: ["log.md"],
+        files,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
     } catch (error) {
@@ -2673,6 +2677,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 +2777,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 +2969,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 +2978,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 +3089,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 +3273,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/cli.js

@@ -50,7 +50,7 @@ import {
   snapshotterHealthChecks,
   upsertIndexEntry,
   vectorIndexStatus
-} from "./chunk-JTAZUR2W.js";
+} from "./chunk-Q23OSECM.js";
 import {
   normalizeDistTag,
   readCache,
@@ -68,6 +68,7 @@ import {
   FLEET_REL_PATH,
   REDACTED_MALFORMED_REFERENCE,
   VAULT_COMMIT_PATHSPEC,
+  VAULT_GENERATED_COMMIT_PATHS,
   acquireOwnedSyncLock,
   appendLastOp,
   applyRawStructuralMove,
@@ -146,7 +147,7 @@ import {
   supersedeStaleReviewRequiredJournals,
   taxonomyCommentForPage,
   writeDotenv
-} from "./chunk-VRK5DOC5.js";
+} from "./chunk-EHUFPORA.js";
 import {
   assertTargetInsideVault,
   atomicWriteText,
@@ -3041,11 +3042,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) };
 }
@@ -9900,7 +9902,21 @@ async function runFleetHealth(input) {
 
 // src/utils/auto-commit.ts
 import { existsSync as existsSync14 } from "fs";
-import { join as join41 } from "path";
+import { isAbsolute, join as join41, normalize } from "path";
+function isValidLastOpPath(file) {
+  if (!file || typeof file !== "string") return false;
+  const trimmed = file.trim();
+  if (trimmed.length === 0) return false;
+  if (isAbsolute(trimmed)) return false;
+  const normalized = normalize(trimmed).replace(/\\/g, "/");
+  if (normalized.startsWith("../") || normalized === ".." || normalized.includes("/../")) return false;
+  for (const generatedPath of VAULT_GENERATED_COMMIT_PATHS) {
+    if (normalized === generatedPath || normalized.startsWith(`${generatedPath}/`)) {
+      return false;
+    }
+  }
+  return true;
+}
 async function postCommit(vault, exitCode) {
   if (exitCode !== 0) return;
   const home = process.env.HOME ?? "";
@@ -9912,16 +9928,31 @@ async function postCommit(vault, exitCode) {
   if (lastOps.length === 0) return;
   const porcelain = git(vault, ["status", "--porcelain", "--", ...VAULT_COMMIT_PATHSPEC]);
   if (!porcelain || porcelain.trim().length === 0) return;
-  try {
-    stageVaultContentChanges(vault);
-  } catch (e) {
-    process.stderr.write(`auto-commit: git add failed: ${String(e)}
+  const rawFiles = lastOps.flatMap((op) => op.files ?? []);
+  const candidateFiles = Array.from(new Set(rawFiles)).filter(isValidLastOpPath);
+  if (candidateFiles.length === 0) {
+    try {
+      stageVaultContentChanges(vault);
+    } catch (e) {
+      process.stderr.write(`auto-commit: stage vault content failed: ${String(e)}
 `);
-    return;
+      return;
+    }
+  } else {
+    try {
+      gitStrict(vault, ["add", "--", ...candidateFiles]);
+    } catch (e) {
+      process.stderr.write(`auto-commit: git add failed: ${String(e)}
+`);
+      return;
+    }
   }
+  const staged = git(vault, ["diff", "--cached", "--name-only"]);
+  if (!staged || staged.trim().length === 0) return;
   const commitMessage = lastOps.map((op) => `${op.operation}: ${op.summary} (${op.files.length} files)`).join("; ");
   try {
-    gitStrict(vault, ["commit", "-m", commitMessage]);
+    const commitArgs = candidateFiles.length === 0 ? ["commit", "-m", commitMessage] : ["commit", "-m", commitMessage, "--", ...candidateFiles];
+    gitStrict(vault, commitArgs);
   } catch (e) {
     process.stderr.write(`auto-commit: git commit failed: ${String(e)}
 `);
@@ -10068,7 +10099,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-WIW5L22Q.js");
+  const { runManagedWriteTransaction: runManagedWriteTransaction2 } = await import("./managed-write-preflight-CMVCRXRG.js");
   const run = await runManagedWriteTransaction2({
     vault,
     command,

package/dist/managed-write-preflight-CMVCRXRG.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-EHUFPORA.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-JTAZUR2W.js";
+} from "./chunk-Q23OSECM.js";
 import "./chunk-7I2TPIV5.js";
 import "./chunk-O3HCB7R2.js";
-import "./chunk-VRK5DOC5.js";
+import "./chunk-EHUFPORA.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.52",
+  "version": "0.10.54",
   "type": "module",
   "bin": {
     "skillwiki": "dist/cli.js",

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

@@ -1,6 +1,6 @@
 {
   "name": "skillwiki",
-  "version": "0.10.52",
+  "version": "0.10.54",
   "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.52",
+  "version": "0.10.54",
   "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.52",
+  "version": "0.10.54",
   "private": true,
   "files": [
     "wiki-*",

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

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