skillwiki 0.10.5 → 0.10.7

package/dist/{chunk-NJFCTMYZ.js → chunk-45SMQAWC.js}

@@ -5604,7 +5604,8 @@ function hasOriginMain(resolvedPath) {
     execSync2("git rev-parse --verify --quiet origin/main", {
       cwd: resolvedPath,
       encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"]
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 2e3
     });
     return true;
   } catch {
@@ -5622,7 +5623,8 @@ function checkVaultGitDirty(resolvedPath) {
     const lines = execSync2("git status --porcelain", {
       cwd: resolvedPath,
       encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"]
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 5e3
     }).trim().split("\n").filter(Boolean);
     if (lines.length > 0) {
       return check("warn", "vault_git_dirty", "Vault git dirty state", `${lines.length} dirty file(s) in vault worktree`);
@@ -5799,7 +5801,8 @@ function checkVaultGitComparison(resolvedPath, id, label, range, nonZeroSuffix,
     const count = parseInt(execSync2(`git rev-list --count ${range}`, {
       cwd: resolvedPath,
       encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"]
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 5e3
     }).trim(), 10);
     if (count > 0) {
       return check("warn", id, label, `${count} commit(s) ${nonZeroSuffix}`);
@@ -6745,6 +6748,9 @@ function findSkillNames(dir) {
   return results;
 }
 var METRIC_TYPES = ["entities", "concepts", "comparisons", "queries", "meta"];
+function doctorReadOnlyScanRoot(resolvedPath) {
+  return resolveReadOnlyVaultRoot(resolvedPath).root;
+}
 async function vaultMetrics(resolvedPath) {
   const ids = [
     ["vault_metric_pages", "Vault pages by type"],
@@ -6755,7 +6761,8 @@ async function vaultMetrics(resolvedPath) {
   ];
   const noVault = () => ids.map(([id, label]) => check("info", id, label, "no vault configured"));
   if (!resolvedPath) return noVault();
-  const scan = await scanVault(resolvedPath);
+  const scanRoot = doctorReadOnlyScanRoot(resolvedPath);
+  const scan = await scanVault(scanRoot);
   if (!scan.ok) return noVault();
   const tk = scan.data.typedKnowledge;
   const perType = METRIC_TYPES.map((d) => `${d} ${tk.filter((p) => p.relPath.startsWith(d + "/")).length}`).join(", ");
@@ -6782,7 +6789,7 @@ async function vaultMetrics(resolvedPath) {
   }
   let logLines = 0;
   try {
-    logLines = readFileSync10(join24(resolvedPath, "log.md"), "utf8").split("\n").length;
+    logLines = readFileSync10(join24(scanRoot, "log.md"), "utf8").split("\n").length;
   } catch {
   }
   return [
@@ -6844,8 +6851,9 @@ async function runDoctor(input) {
   checks.push(checkVaultS3Remote(input.home, input.execProbe, input.env ?? process.env));
   checks.push(checkVaultSnapshotterReachable(fleetLoad, input.checkSnapshotter, input.execProbe));
   checks.push(checkVaultPromotionLag(gitCheckPath));
-  checks.push(checkDotStoreClean(resolvedPath));
-  checks.push(checkVaultConflictMarkers(resolvedPath));
+  const readOnlyScanRoot = resolvedPath ? doctorReadOnlyScanRoot(resolvedPath) : void 0;
+  checks.push(checkDotStoreClean(readOnlyScanRoot));
+  checks.push(checkVaultConflictMarkers(readOnlyScanRoot));
   checks.push(checkS3MountPerf(resolvedPath));
   checks.push(checkS3MountFreshness(resolvedPath));
   checks.push(checkRcloneFlagAudit(resolvedPath));

package/dist/{chunk-GEKJG4F7.js → chunk-4KGCTQM3.js}

@@ -16,20 +16,90 @@ import {
 } from "./chunk-C5OLZRRM.js";
 
 // src/utils/managed-write-preflight.ts
-import { existsSync, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { join as join2, resolve } from "path";
 
 // src/utils/managed-write-lock.ts
 import { randomBytes } from "crypto";
-import { mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
 import { dirname, join } from "path";
 function managedWriteLockPath(vault) {
   const gitPath = git(vault, ["rev-parse", "--git-path", "vault-sync/managed-write.lock"]);
   if (gitPath) return gitPath.startsWith("/") ? gitPath : join(vault, gitPath);
   return join(vault, ".skillwiki", "managed-write.lock");
 }
-function acquireManagedWriteLock(vault, command) {
+function readLockRecord(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function isManagedWriteLockOwnerAlive(pid) {
+  if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (error.code === "EPERM") return true;
+    return false;
+  }
+}
+function hasUnsafeGitState(vault) {
+  const gitDirRaw = git(vault, ["rev-parse", "--git-dir"]);
+  if (!gitDirRaw) return true;
+  const gitDir = gitDirRaw.startsWith("/") ? gitDirRaw : join(vault, gitDirRaw);
+  for (const rel of ["rebase-merge", "rebase-apply"]) {
+    if (existsSync(join(gitDir, rel))) return true;
+  }
+  for (const rel of ["MERGE_HEAD", "CHERRY_PICK_HEAD", "REVERT_HEAD"]) {
+    if (existsSync(join(gitDir, rel))) return true;
+  }
+  const unmerged = git(vault, ["ls-files", "-u"]);
+  return Boolean(unmerged && unmerged.trim().length > 0);
+}
+function reclaimDeadManagedWriteLockOwner(vault) {
   const path = managedWriteLockPath(vault);
+  if (!existsSync(path)) return ok({ reclaimed: false });
+  const record = readLockRecord(path);
+  if (!record) {
+    return err("SYNC_LOCK_HELD", { path, message: "managed-write lock unreadable" });
+  }
+  if (isManagedWriteLockOwnerAlive(record.pid)) {
+    return err("SYNC_LOCK_HELD", { path, message: "managed-write lock owner is alive" });
+  }
+  if (hasUnsafeGitState(vault)) {
+    return err("SYNC_LOCK_HELD", {
+      path,
+      message: "managed-write lock not reclaimed: unsafe git state"
+    });
+  }
+  try {
+    const recoveryDir = join(dirname(path), "recovery");
+    mkdirSync(recoveryDir, { recursive: true });
+    const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
+    const recoveryPath = join(recoveryDir, `stale-managed-write-lock-${stamp}-${process.pid}.json`);
+    const meta = {
+      recovered_at: (/* @__PURE__ */ new Date()).toISOString(),
+      recovery_reason: "owner_pid_dead",
+      owner_pid_alive: false,
+      lock: record
+    };
+    writeFileSync(recoveryPath, `${JSON.stringify(meta, null, 2)}
+`, { flag: "wx" });
+    unlinkSync(path);
+    return ok({ reclaimed: true, recoveryPath });
+  } catch (error) {
+    return err("WRITE_FAILED", { path, message: String(error) });
+  }
+}
+function tryCreateLock(path, command) {
   const ownerToken = randomBytes(16).toString("hex");
   const acquired = (/* @__PURE__ */ new Date()).toISOString();
   try {
@@ -40,12 +110,27 @@ function acquireManagedWriteLock(vault, command) {
 `,
       { flag: "wx" }
     );
-    return ok({ vault, path, ownerToken, acquired });
+    return ok({ vault: "", path, ownerToken, acquired });
   } catch (error) {
     if (error.code === "EEXIST") return err("SYNC_LOCK_HELD", { path });
     return err("WRITE_FAILED", { path, message: String(error) });
   }
 }
+function acquireManagedWriteLock(vault, command) {
+  const path = managedWriteLockPath(vault);
+  const first = tryCreateLock(path, command);
+  if (first.ok) {
+    return ok({ ...first.data, vault });
+  }
+  if (first.error !== "SYNC_LOCK_HELD") return first;
+  const reclaimed = reclaimDeadManagedWriteLockOwner(vault);
+  if (!reclaimed.ok || !reclaimed.data.reclaimed) {
+    return err("SYNC_LOCK_HELD", { path });
+  }
+  const second = tryCreateLock(path, command);
+  if (second.ok) return ok({ ...second.data, vault });
+  return second.ok === false ? second : err("SYNC_LOCK_HELD", { path });
+}
 function releaseManagedWriteLock(handle) {
   try {
     const parsed = JSON.parse(readFileSync(handle.path, "utf8"));
@@ -85,7 +170,7 @@ function preflightBlocker(vault) {
 }
 function fleetManifestBytes(vault) {
   const path = join2(vault, FLEET_REL_PATH);
-  if (!existsSync(path)) return null;
+  if (!existsSync2(path)) return null;
   return readFileSync2(path);
 }
 function isGitVault(vault) {

package/dist/cli.js

@@ -69,7 +69,7 @@ import {
   satelliteLatestRunPath,
   taxonomyCommentForPage,
   upsertIndexEntry
-} from "./chunk-NJFCTMYZ.js";
+} from "./chunk-45SMQAWC.js";
 import {
   normalizeDistTag,
   readCache,
@@ -95,7 +95,7 @@ import {
   releaseManagedWriteLock,
   runManagedWritePreflight,
   runManagedWriteTransaction
-} from "./chunk-GEKJG4F7.js";
+} from "./chunk-4KGCTQM3.js";
 import {
   FLEET_REL_PATH,
   git,
@@ -6758,7 +6758,7 @@ async function emitManagedVaultWrite(vault, command, mutate, opts) {
   if (guard.blocked) {
     return emit({ exitCode: guard.exitCode, result: guard.result }, void 0, { postCommit: false });
   }
-  const { runManagedWriteTransaction: runManagedWriteTransaction2 } = await import("./managed-write-preflight-DGIE2FE2.js");
+  const { runManagedWriteTransaction: runManagedWriteTransaction2 } = await import("./managed-write-preflight-57DQZI2N.js");
   const run = await runManagedWriteTransaction2({
     vault,
     command,

package/dist/{managed-write-preflight-DGIE2FE2.js → managed-write-preflight-57DQZI2N.js}

@@ -2,7 +2,7 @@
 import {
   runManagedWritePreflight,
   runManagedWriteTransaction
-} from "./chunk-GEKJG4F7.js";
+} from "./chunk-4KGCTQM3.js";
 import "./chunk-R6BKJWVC.js";
 import "./chunk-C5OLZRRM.js";
 export {

package/dist/skillwiki-mcp.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   runSkillwikiMcpStdio
-} from "./chunk-NJFCTMYZ.js";
+} from "./chunk-45SMQAWC.js";
 import "./chunk-7I2TPIV5.js";
 import "./chunk-U34B2XQJ.js";
 import "./chunk-R6BKJWVC.js";

package/dist/vault-sync/scripts/lib/managed-write-lock.sh

@@ -1,6 +1,13 @@
 #!/bin/bash
 # managed-write-lock.sh — shared CLI/shell managed-write lock (Bash 3.2).
 # Source from vault-sync scripts. Lock path: git --git-path vault-sync/managed-write.lock
+#
+# Lifecycle:
+# - Acquire uses noclobber create so concurrent live owners fail closed.
+# - Release only removes the lock when this shell owns the token.
+# - On acquire contention, a lock whose owner PID is dead may be reclaimed after
+#   preserving the old lock record under vault-sync/recovery/ — never by age alone,
+#   never while rebase/unmerged paths exist, never while a live PID holds it.
 
 VAULT_SYNC_MANAGED_LOCK_PATH=""
 VAULT_SYNC_MANAGED_LOCK_TOKEN_OWNED=""
@@ -23,11 +30,134 @@ vault_sync_managed_lock_read_token() {
   sed -n 's/.*"owner_token"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' "$path" | head -1
 }
 
+vault_sync_managed_lock_read_pid() {
+  local path="$1"
+  [ -f "$path" ] || return 1
+  sed -n 's/.*"pid"[[:space:]]*:[[:space:]]*\([0-9][0-9]*\).*/\1/p' "$path" | head -1
+}
+
+# Returns 0 when PID appears alive, 1 when dead/unknown/missing.
+vault_sync_managed_lock_pid_alive() {
+  local pid="$1"
+  case "$pid" in
+    ""|*[!0-9]*) return 1 ;;
+  esac
+  # kill -0 succeeds if the process exists (or is not owned but present).
+  if kill -0 "$pid" 2>/dev/null; then
+    return 0
+  fi
+  return 1
+}
+
+# Returns 0 when it is safe to reclaim a dead-owner lock for this repo.
+vault_sync_managed_lock_safe_to_reclaim() {
+  local repo="${1:-.}"
+  local git_dir unmerged review_op
+
+  git_dir="$(git -C "$repo" rev-parse --git-dir 2>/dev/null)" || return 1
+  case "$git_dir" in
+    /*) ;;
+    *) git_dir="$repo/$git_dir" ;;
+  esac
+
+  # Never reclaim during an active/leftover sequencer.
+  if [ -d "$git_dir/rebase-merge" ] || [ -d "$git_dir/rebase-apply" ] \
+    || [ -d "$git_dir/MERGE_HEAD" ] || [ -f "$git_dir/CHERRY_PICK_HEAD" ] \
+    || [ -f "$git_dir/REVERT_HEAD" ]; then
+    return 1
+  fi
+
+  unmerged="$(git -C "$repo" ls-files -u 2>/dev/null | head -1 || true)"
+  if [ -n "$unmerged" ]; then
+    return 1
+  fi
+
+  # When journal helpers are loaded, refuse reclaim while review-required handoff
+  # journals exist. Standalone lock tests may not source the journal library.
+  if command -v vault_sync_op_find_review_required >/dev/null 2>&1; then
+    review_op="$(vault_sync_op_find_review_required "$repo" 2>/dev/null || true)"
+    if [ -n "$review_op" ]; then
+      return 1
+    fi
+  fi
+
+  return 0
+}
+
+# Preserve the current lock file under vault-sync/recovery/ then remove it.
+# Returns 0 when the live lock path is gone (preserved or already absent).
+vault_sync_managed_lock_preserve_and_clear() {
+  local path="$1"
+  local reason="${2:-owner_pid_dead}"
+  local rec_dir rec_path ts body
+
+  [ -n "$path" ] || return 1
+  if [ ! -f "$path" ]; then
+    return 0
+  fi
+
+  rec_dir="$(dirname "$path")/recovery"
+  mkdir -p "$rec_dir" || return 1
+  ts="$(date -u +%Y%m%dT%H%MZ 2>/dev/null || date +%Y%m%dT%H%M)"
+  rec_path="$rec_dir/stale-managed-write-lock-${ts}-$$.json"
+  body="$(cat "$path" 2>/dev/null || true)"
+  if [ -n "$body" ]; then
+    # Best-effort structured recovery record; fall back to raw bytes.
+    if command -v python3 >/dev/null 2>&1; then
+      REASON="$reason" BODY="$body" REC="$rec_path" python3 - <<'PY' 2>/dev/null || printf '%s\n' "$body" >"$rec_path"
+import json, os, time
+raw = os.environ.get("BODY", "").strip()
+try:
+    lock = json.loads(raw)
+except Exception:
+    lock = {"raw": raw}
+meta = {
+    "recovered_at": time.strftime("%Y-%m-%dT%H:%MZ", time.gmtime()),
+    "recovery_reason": os.environ.get("REASON", "owner_pid_dead"),
+    "owner_pid_alive": False,
+    "lock": lock,
+}
+open(os.environ["REC"], "w", encoding="utf-8").write(json.dumps(meta, indent=2) + "\n")
+PY
+    else
+      printf '%s\n' "$body" >"$rec_path"
+    fi
+  fi
+
+  rm -f -- "$path"
+  [ ! -f "$path" ]
+}
+
+# If the lock path exists with a dead owner and reclaim is safe, preserve+clear.
+# Returns 0 when lock path is free (reclaimed or never present), 1 when still held.
+vault_sync_managed_lock_reclaim_dead_owner() {
+  local repo="${1:-.}"
+  local path pid
+
+  path="$(vault_sync_managed_lock_path "$repo")" || return 1
+  if [ ! -f "$path" ]; then
+    return 0
+  fi
+
+  pid="$(vault_sync_managed_lock_read_pid "$path" || true)"
+  if vault_sync_managed_lock_pid_alive "$pid"; then
+    return 1
+  fi
+
+  if ! vault_sync_managed_lock_safe_to_reclaim "$repo"; then
+    return 1
+  fi
+
+  vault_sync_managed_lock_preserve_and_clear "$path" "owner_pid_dead" || return 1
+  return 0
+}
+
 # Acquire or adopt managed-write lock. Returns 0 on success, 1 on contention/mismatch.
 vault_sync_managed_lock_acquire() {
   local repo="${1:-.}"
   local command="${2:-wiki-pull}"
-  local path token now inherited
+  local path token now inherited attempt
+
   path="$(vault_sync_managed_lock_path "$repo")" || return 1
   VAULT_SYNC_MANAGED_LOCK_PATH="$path"
   mkdir -p "$(dirname "$path")" || return 1
@@ -46,16 +176,29 @@ vault_sync_managed_lock_acquire() {
     return 1
   fi
 
-  token="$(od -An -N16 -tx1 /dev/urandom 2>/dev/null | tr -d ' \n')"
-  [ -n "$token" ] || token="$$-$(date +%s)"
-  now="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
-  if ( set -o noclobber; printf '{"pid":%s,"owner_token":"%s","acquired":"%s","command":"%s"}\n' \
-      "$$" "$token" "$now" "$command" >"$path" ) 2>/dev/null; then
-    VAULT_SYNC_MANAGED_LOCK_TOKEN_OWNED="$token"
-    VAULT_SYNC_MANAGED_LOCK_ACQUIRED="$now"
-    VAULT_SYNC_MANAGED_LOCK_OWNS_RELEASE=1
-    return 0
-  fi
+  attempt=0
+  while [ "$attempt" -lt 2 ]; do
+    attempt=$((attempt + 1))
+    token="$(od -An -N16 -tx1 /dev/urandom 2>/dev/null | tr -d ' \n')"
+    [ -n "$token" ] || token="$$-$(date +%s)"
+    now="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+    if ( set -o noclobber; printf '{"pid":%s,"owner_token":"%s","acquired":"%s","command":"%s"}\n' \
+        "$$" "$token" "$now" "$command" >"$path" ) 2>/dev/null; then
+      VAULT_SYNC_MANAGED_LOCK_TOKEN_OWNED="$token"
+      VAULT_SYNC_MANAGED_LOCK_ACQUIRED="$now"
+      VAULT_SYNC_MANAGED_LOCK_OWNS_RELEASE=1
+      return 0
+    fi
+
+    # Contention: only the first pass may reclaim a dead owner, then retry once.
+    if [ "$attempt" -eq 1 ]; then
+      if vault_sync_managed_lock_reclaim_dead_owner "$repo"; then
+        continue
+      fi
+    fi
+    return 1
+  done
+
   return 1
 }
 

package/dist/vault-sync/scripts/wiki-pull-with-auto-resolve.sh

@@ -71,7 +71,16 @@ release_pull_lock() {
 }
 
 # Always release cooperative lock and owned managed-write lock on exit.
-trap 'release_pull_lock; vault_sync_managed_lock_release' EXIT
+# INT/TERM re-enter via EXIT so SIGKILL-only gaps are handled by dead-owner
+# reclaim on the next acquire (see managed-write-lock.sh).
+vault_sync_pull_cleanup() {
+  release_pull_lock
+  vault_sync_managed_lock_release || true
+}
+trap vault_sync_pull_cleanup EXIT
+trap 'exit 130' INT
+trap 'exit 143' TERM
+trap 'exit 129' HUP
 
 acquire_pull_lock() {
   local lock_rc=0

package/package.json

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

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

@@ -1,6 +1,6 @@
 {
   "name": "skillwiki",
-  "version": "0.10.5",
+  "version": "0.10.7",
   "skills": "./",
   "description": "Project-aware Karpathy-style knowledge base for Claude Code: 19 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.5",
+  "version": "0.10.7",
   "description": "Project-aware Karpathy-style knowledge base for Codex with 19 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.5",
+  "version": "0.10.7",
   "private": true,
   "files": [
     "wiki-*",