skillwiki 0.10.4 → 0.10.6

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/{chunk-Z3WS45PL.js → chunk-NJFCTMYZ.js}

@@ -6999,6 +6999,61 @@ ${input.text.trim()}
 import { createHash as createHash7 } from "crypto";
 import { mkdir as mkdir6, readFile as readFile16, readdir as readdir4, stat as stat5, writeFile as writeFile5 } from "fs/promises";
 import { basename as basename2, extname, join as join26, relative as relative3, sep as sep3 } from "path";
+
+// src/utils/memory-authority.ts
+var TIER_RANK = {
+  "accepted-decision": 0,
+  "operational-guidance": 1,
+  proposed: 2,
+  exploratory: 3,
+  unclassified: 4
+};
+function memoryAuthorityTiersRank(tier) {
+  if (!tier) return TIER_RANK.unclassified;
+  const key = String(tier).toLowerCase();
+  return TIER_RANK[key] ?? TIER_RANK.unclassified;
+}
+function classifyMemoryAuthority(source) {
+  const kind = (source.memory_kind ?? "").toLowerCase();
+  const policy = (source.memory_policy ?? "").toLowerCase();
+  const status = (source.memory_status ?? "").toLowerCase();
+  if (kind === "decision-context" && policy === "operational" && status === "active") {
+    return "accepted-decision";
+  }
+  if (policy === "operational" && status === "active") {
+    return "operational-guidance";
+  }
+  if (["proposed", "draft", "pending"].includes(status) || ["proposed", "hypothesis", "research"].includes(policy)) {
+    return "proposed";
+  }
+  if (policy === "exploratory") {
+    return "exploratory";
+  }
+  return "unclassified";
+}
+function isProjectLocal(source, project) {
+  if (!project) return false;
+  if (typeof source.path === "string" && source.path.startsWith(`projects/${project}/`)) {
+    return true;
+  }
+  const scope = (source.memory_scope || "project").toLowerCase();
+  if (scope !== "project") return false;
+  return !source.project || source.project === project;
+}
+function compareMemoryAuthority(a, b, options = {}) {
+  const tierDiff = memoryAuthorityTiersRank(classifyMemoryAuthority(a)) - memoryAuthorityTiersRank(classifyMemoryAuthority(b));
+  if (tierDiff !== 0) return tierDiff;
+  if (options.preferProjectWithinTiers && options.project) {
+    const aLocal = Number(isProjectLocal(a, options.project));
+    const bLocal = Number(isProjectLocal(b, options.project));
+    if (aLocal !== bLocal) return bLocal - aLocal;
+  }
+  const updatedDiff = b.updated.localeCompare(a.updated);
+  if (updatedDiff !== 0) return updatedDiff;
+  return a.path.localeCompare(b.path);
+}
+
+// src/commands/memory.ts
 async function runMemoryTopics(input) {
   const scan = await scanVault(input.vault);
   if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
@@ -7825,12 +7880,16 @@ function normalizeTopics(value) {
     const paths = stringArray(item.paths);
     if (!name || !summary || !updated || paths.length === 0) continue;
     const project = stringField(item.project);
+    const authority_tier = stringField(item.authority_tier);
+    const lead_path = stringField(item.lead_path);
     topics.push({
       name,
       summary,
       ...project ? { project } : {},
       updated,
-      paths
+      paths,
+      ...authority_tier ? { authority_tier } : {},
+      ...lead_path ? { lead_path } : {}
     });
   }
   return topics;
@@ -7870,10 +7929,14 @@ function normalizeLimit(value) {
   return Math.floor(value);
 }
 function compareTopics(a, b) {
+  if (a.authority_tier || b.authority_tier) {
+    const tr = memoryAuthorityTiersRank(a.authority_tier) - memoryAuthorityTiersRank(b.authority_tier);
+    if (tr !== 0) return tr;
+  }
   return b.updated.localeCompare(a.updated) || a.name.localeCompare(b.name);
 }
 function compareSources(a, b) {
-  return b.updated.localeCompare(a.updated) || a.path.localeCompare(b.path);
+  return compareMemoryAuthority(a, b);
 }
 function normalizeRecallScope(value) {
   if (!value) return void 0;
@@ -7891,8 +7954,13 @@ function recallScopeMatches(source, project, scope) {
   return source.memory_scope === scope;
 }
 function compareRecallSources(a, b, project, scope) {
-  if (scope !== "all") return compareSources(a, b);
-  return b.updated.localeCompare(a.updated) || Number(isProjectMemorySource(b, project)) - Number(isProjectMemorySource(a, project)) || a.path.localeCompare(b.path);
+  if (scope === "all") {
+    return compareMemoryAuthority(a, b, {
+      project,
+      preferProjectWithinTiers: true
+    });
+  }
+  return compareSources(a, b);
 }
 function isProjectMemorySource(source, project) {
   const scope = source.memory_scope || "project";
@@ -7972,12 +8040,17 @@ function buildTopics(project, sources) {
   }
   return [...byTopic.entries()].map(([name, topicSources]) => {
     const sorted = [...topicSources].sort(compareSources);
+    const lead = sorted[0];
     return {
       name,
       project,
-      summary: sorted[0]?.summary ?? "",
-      updated: sorted[0]?.updated ?? "",
-      paths: sorted.map((source) => source.path)
+      summary: lead?.summary ?? "",
+      updated: lead?.updated ?? "",
+      paths: sorted.map((source) => source.path),
+      ...lead ? {
+        authority_tier: classifyMemoryAuthority(lead),
+        lead_path: lead.path
+      } : {}
     };
   }).sort((a, b) => a.name.localeCompare(b.name));
 }
@@ -9213,6 +9286,7 @@ export {
   runDoctor,
   readCliPackageJson,
   runObserve,
+  memoryAuthorityTiersRank,
   runMemoryTopics,
   runMemoryIndex,
   runMemoryRecall,

package/dist/cli.js

@@ -18,6 +18,7 @@ import {
   getSessionId,
   isFailedRunStatus,
   isValidRemoteDeleteCap,
+  memoryAuthorityTiersRank,
   mergeTaxonomyConflict,
   normalizeRemoteRoot,
   planAndMaybePruneRemoteObjects,
@@ -68,7 +69,7 @@ import {
   satelliteLatestRunPath,
   taxonomyCommentForPage,
   upsertIndexEntry
-} from "./chunk-Z3WS45PL.js";
+} from "./chunk-NJFCTMYZ.js";
 import {
   normalizeDistTag,
   readCache,
@@ -94,7 +95,7 @@ import {
   releaseManagedWriteLock,
   runManagedWritePreflight,
   runManagedWriteTransaction
-} from "./chunk-GEKJG4F7.js";
+} from "./chunk-4KGCTQM3.js";
 import {
   FLEET_REL_PATH,
   git,
@@ -3909,13 +3910,21 @@ async function loadMemoryTopics(vault, project) {
   try {
     const parsed = JSON.parse(text);
     if (!Array.isArray(parsed.topics)) return [];
-    return parsed.topics.filter((topic) => typeof topic === "object" && topic !== null && !Array.isArray(topic)).map((topic) => ({
-      name: stringField(topic.name),
-      summary: stringField(topic.summary),
-      project: stringField(topic.project) || void 0,
-      updated: stringField(topic.updated),
-      paths: Array.isArray(topic.paths) ? topic.paths.filter((path) => typeof path === "string") : []
-    })).filter((topic) => topic.name && topic.summary && topic.updated && topic.paths.length > 0).sort((a, b) => b.updated.localeCompare(a.updated) || a.name.localeCompare(b.name)).slice(0, 5);
+    return parsed.topics.filter((topic) => typeof topic === "object" && topic !== null && !Array.isArray(topic)).map((topic) => {
+      const authority_tier = stringField(topic.authority_tier);
+      const lead_path = stringField(topic.lead_path);
+      return {
+        name: stringField(topic.name),
+        summary: stringField(topic.summary),
+        project: stringField(topic.project) || void 0,
+        updated: stringField(topic.updated),
+        paths: Array.isArray(topic.paths) ? topic.paths.filter((path) => typeof path === "string") : [],
+        ...authority_tier ? { authority_tier } : {},
+        ...lead_path ? { lead_path } : {}
+      };
+    }).filter((topic) => topic.name && topic.summary && topic.updated && topic.paths.length > 0).sort(
+      (a, b) => memoryAuthorityTiersRank(a.authority_tier) - memoryAuthorityTiersRank(b.authority_tier) || b.updated.localeCompare(a.updated) || a.name.localeCompare(b.name)
+    ).slice(0, 5);
   } catch {
     return [];
   }
@@ -6749,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-Z3WS45PL.js";
+} from "./chunk-NJFCTMYZ.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.4",
+  "version": "0.10.6",
   "type": "module",
   "bin": {
     "skillwiki": "dist/cli.js",

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

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