skillwiki 0.6.1 → 0.7.0

package/dist/cli.js

@@ -8,7 +8,7 @@ import {
 } from "./chunk-TPS5XD2J.js";
 
 // src/cli.ts
-import { readFileSync as readFileSync11 } from "fs";
+import { readFileSync as readFileSync12 } from "fs";
 import { join as join41 } from "path";
 import { Command as Command2 } from "commander";
 
@@ -3489,9 +3489,10 @@ async function runConfigPath(input) {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync7, lstatSync, readlinkSync, readdirSync, statSync as statSync2 } from "fs";
+import { existsSync as existsSync7, lstatSync, readlinkSync, readdirSync, statSync as statSync2, readFileSync as readFileSync7 } from "fs";
 import { join as join24, resolve as resolve4 } from "path";
 import { execSync as execSync2 } from "child_process";
+import { platform as platform2 } from "os";
 
 // src/utils/auto-update.ts
 import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, existsSync as existsSync5, mkdirSync as mkdirSync2 } from "fs";
@@ -4209,12 +4210,12 @@ function checkRcloneFlagAudit(resolvedPath) {
   }
   return check("pass", "rclone_flags", "rclone VFS flags", `PID ${pid}: all critical flags at safe values`);
 }
-function checkRcloneVersion(resolvedPath) {
-  if (!resolvedPath) {
+function checkRcloneVersion(resolvedPath, vaultSyncInstalled) {
+  if (!resolvedPath && !vaultSyncInstalled) {
     return check("pass", "rclone_version", "rclone version", "No vault path \u2014 check skipped");
   }
-  const fuse = detectFuseMount(resolvedPath);
-  if (!fuse) {
+  const fuse = resolvedPath ? detectFuseMount(resolvedPath) : null;
+  if (!fuse && !vaultSyncInstalled) {
     return check("pass", "rclone_version", "rclone version", "local disk \u2014 check skipped");
   }
   const ver = getRcloneVersion();
@@ -4326,6 +4327,301 @@ function checkVfsCacheHealth(resolvedPath) {
     `${stats.files} files, ${(stats.bytesUsed / 1024 / 1024).toFixed(1)}MB \u2014 clean (0 errored, 0 pending)`
   );
 }
+function readVaultSyncConfig(home) {
+  try {
+    const content = readFileSync7(join24(home, ".skillwiki", ".env"), "utf8");
+    let installed = false;
+    let role;
+    for (const line of content.split(/\r?\n/)) {
+      const trimmed = line.trim();
+      if (trimmed.length === 0 || 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 (v.length === 0) continue;
+      if (k === "vault_sync.installed" && v === "true") installed = true;
+      if (k === "vault_sync.role") role = v;
+    }
+    return { installed, role };
+  } catch {
+    return { installed: false };
+  }
+}
+function vaultSyncChecks(input) {
+  const os = input.os ?? platform2();
+  const home = input.home;
+  if (!input.vaultSyncInstalled) {
+    const skip = (id, label) => check("pass", id, label, "vault-sync not installed \u2014 check skipped");
+    return [
+      skip("vault_sync_installed", "Vault sync installed"),
+      skip("vault_sync_jobs_enabled", "Vault sync jobs enabled"),
+      skip("vault_sync_last_push_age", "Vault sync last push recency"),
+      skip("vault_sync_last_fetch_status", "Vault sync last fetch status"),
+      skip("vault_sync_filter_present", "Vault sync filter file present"),
+      skip("vault_sync_snapshot_guard", "Snapshot script guard")
+    ];
+  }
+  const isMac = os === "darwin";
+  const logDir = input.logDir ?? (isMac ? join24(home, "Library", "Logs") : join24(home, ".local", "state", "vault-sync", "log"));
+  const shareDir = input.shareDir ?? (isMac ? join24(home, "Library", "Application Support", "vault-sync", "bin") : join24(home, ".local", "share", "vault-sync", "bin"));
+  const filterPath = input.filterPath ?? join24(home, ".config", "rclone", "wiki-push-filters.txt");
+  const snapshotPath = input.snapshotScriptPath ?? "/root/.hermes/scripts/wiki-snapshot-v3.sh";
+  const pushScriptPath = join24(shareDir, "wiki-push.sh");
+  const c1 = existsSync7(pushScriptPath) ? check("pass", "vault_sync_installed", "Vault sync installed", `Found: ${pushScriptPath}`) : check("error", "vault_sync_installed", "Vault sync installed", `Script not found at ${pushScriptPath} \u2014 run vault-sync-install`);
+  let c2;
+  try {
+    if (isMac) {
+      const uidStr = execSync2("id -u", {
+        encoding: "utf8",
+        timeout: 2e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      const uid = parseInt(uidStr, 10);
+      execSync2(`launchctl print gui/${uid}/com.karlchow.wiki-push`, {
+        encoding: "utf8",
+        timeout: 2e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      c2 = check(
+        "pass",
+        "vault_sync_jobs_enabled",
+        "Vault sync jobs enabled",
+        "launchd: com.karlchow.wiki-push loaded"
+      );
+    } else {
+      const out = execSync2("systemctl --user is-enabled wiki-push.timer", {
+        encoding: "utf8",
+        timeout: 2e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      if (out === "enabled") {
+        c2 = check(
+          "pass",
+          "vault_sync_jobs_enabled",
+          "Vault sync jobs enabled",
+          "systemd: wiki-push.timer enabled"
+        );
+      } else {
+        c2 = check(
+          "error",
+          "vault_sync_jobs_enabled",
+          "Vault sync jobs enabled",
+          `systemd: wiki-push.timer is ${out} \u2014 run vault-sync-install`
+        );
+      }
+    }
+  } catch {
+    c2 = check(
+      "error",
+      "vault_sync_jobs_enabled",
+      "Vault sync jobs enabled",
+      "Scheduler check failed \u2014 run vault-sync-install"
+    );
+  }
+  const logFile = join24(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[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 = existsSync7(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}`
+    );
+  }
+  const fetchLogFile = join24(logDir, "wiki-fetch.log");
+  let cFetch;
+  try {
+    const logContent = readFileSync7(fetchLogFile, "utf8");
+    const lines = logContent.trim().split("\n").filter(Boolean);
+    if (lines.length === 0) {
+      cFetch = check(
+        "warn",
+        "vault_sync_last_fetch_status",
+        "Vault sync last fetch status",
+        "Fetch log file is empty"
+      );
+    } else {
+      const lastLine = lines[lines.length - 1];
+      if (/fetch failed/i.test(lastLine)) {
+        cFetch = check(
+          "error",
+          "vault_sync_last_fetch_status",
+          "Vault sync last fetch status",
+          `Last fetch failed: ${lastLine.slice(0, 100)}`
+        );
+      } else if (/OK/.test(lastLine)) {
+        cFetch = check(
+          "pass",
+          "vault_sync_last_fetch_status",
+          "Vault sync last fetch status",
+          lastLine.slice(0, 100)
+        );
+      } else {
+        cFetch = check(
+          "warn",
+          "vault_sync_last_fetch_status",
+          "Vault sync last fetch status",
+          `Last fetch log entry: ${lastLine.slice(0, 80)}`
+        );
+      }
+    }
+  } catch {
+    cFetch = check(
+      "warn",
+      "vault_sync_last_fetch_status",
+      "Vault sync last fetch status",
+      `Fetch log not found at ${fetchLogFile}`
+    );
+  }
+  let c4;
+  try {
+    if (!existsSync7(filterPath)) {
+      c4 = check(
+        "error",
+        "vault_sync_filter_present",
+        "Vault sync filter file present",
+        `Filter file not found at ${filterPath}`
+      );
+    } else {
+      const content = readFileSync7(filterPath, "utf8");
+      const requiredExcludes = [
+        "remotely-save/data.json",
+        ".skillwiki/sync.lock",
+        ".claude/settings.local.json"
+      ];
+      const missing = requiredExcludes.filter((ex) => !content.includes(ex));
+      if (missing.length > 0) {
+        c4 = check(
+          "warn",
+          "vault_sync_filter_present",
+          "Vault sync filter file present",
+          `Missing required excludes: ${missing.join(", ")}`
+        );
+      } else {
+        c4 = check(
+          "pass",
+          "vault_sync_filter_present",
+          "Vault sync filter file present",
+          `Found with required excludes at ${filterPath}`
+        );
+      }
+    }
+  } catch {
+    c4 = check(
+      "error",
+      "vault_sync_filter_present",
+      "Vault sync filter file present",
+      `Cannot read filter file at ${filterPath}`
+    );
+  }
+  let c5;
+  if (input.vaultSyncRole !== "snapshotter") {
+    c5 = check(
+      "pass",
+      "vault_sync_snapshot_guard",
+      "Snapshot script guard",
+      "Not a snapshotter host \u2014 check skipped"
+    );
+  } else {
+    try {
+      if (!existsSync7(snapshotPath)) {
+        c5 = check(
+          "error",
+          "vault_sync_snapshot_guard",
+          "Snapshot script guard",
+          `Snapshot script not found at ${snapshotPath}`
+        );
+      } else {
+        const content = readFileSync7(snapshotPath, "utf8");
+        if (!content.includes("--max-delete")) {
+          c5 = check(
+            "error",
+            "vault_sync_snapshot_guard",
+            "Snapshot script guard",
+            `${snapshotPath} is missing --max-delete guard \u2014 dangerous without it`
+          );
+        } else {
+          c5 = check(
+            "pass",
+            "vault_sync_snapshot_guard",
+            "Snapshot script guard",
+            `--max-delete present in ${snapshotPath}`
+          );
+        }
+      }
+    } catch {
+      c5 = check(
+        "error",
+        "vault_sync_snapshot_guard",
+        "Snapshot script guard",
+        `Cannot read ${snapshotPath}`
+      );
+    }
+  }
+  return [c1, c2, c3, cFetch, c4, c5];
+}
 function findSkillMd(dir) {
   const results = [];
   let entries;
@@ -4360,6 +4656,7 @@ function findSkillNames(dir) {
 }
 async function runDoctor(input) {
   const checks = [];
+  const vsConfig = readVaultSyncConfig(input.home);
   checks.push(checkNodeVersion());
   checks.push(checkCliChannels(input.argv, input.home));
   checks.push(await checkConfigFile(input.home));
@@ -4380,13 +4677,18 @@ async function runDoctor(input) {
   checks.push(checkDotStoreClean(resolvedPath));
   checks.push(checkS3MountPerf(resolvedPath));
   checks.push(checkRcloneFlagAudit(resolvedPath));
-  checks.push(checkRcloneVersion(resolvedPath));
+  checks.push(checkRcloneVersion(resolvedPath, vsConfig.installed));
   checks.push(checkWriteTest(resolvedPath));
   checks.push(checkVfsCacheHealth(resolvedPath));
   checks.push(checkSkillsInstalled(input.home, input.cwd));
   checks.push(checkDuplicateSkills(input.home));
   checks.push(checkNpmUpdate(input.home, input.currentVersion));
   checks.push(checkPluginVersionDrift(input.home, input.currentVersion));
+  checks.push(...vaultSyncChecks({
+    home: input.home,
+    vaultSyncInstalled: vsConfig.installed,
+    vaultSyncRole: vsConfig.role
+  }));
   const summary = {
     pass: checks.filter((c) => c.status === "pass").length,
     info: checks.filter((c) => c.status === "info").length,
@@ -4909,7 +5211,7 @@ ${newBody}`;
 
 // src/commands/update.ts
 import { execSync as execSync3 } from "child_process";
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 import { join as join26 } from "path";
 function resolveGlobalSkillsRoot() {
   try {
@@ -4939,7 +5241,7 @@ async function refreshInstalledSkills(target) {
 }
 async function runUpdate(input) {
   const pkg2 = JSON.parse(
-    readFileSync7(new URL("../../package.json", import.meta.url), "utf8")
+    readFileSync8(new URL("../../package.json", import.meta.url), "utf8")
   );
   const currentVersion = pkg2.version;
   const tag = input.distTag ?? "latest";
@@ -5013,12 +5315,12 @@ async function runUpdate(input) {
 
 // src/commands/self-update.ts
 import { execSync as execSync4 } from "child_process";
-import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync9 } from "fs";
 import { join as join27 } from "path";
 var DEFAULT_SOURCE_ROOT_SUFFIX = "/Desktop/code/llm-wiki";
 async function runSelfUpdate(input) {
   const currentVersion = JSON.parse(
-    readFileSync8(new URL("../../package.json", import.meta.url), "utf8")
+    readFileSync9(new URL("../../package.json", import.meta.url), "utf8")
   ).version;
   const sourceRoot = input.sourceRoot ?? `${input.home}${DEFAULT_SOURCE_ROOT_SUFFIX}`;
   const localPkgPath = join27(sourceRoot, "packages", "cli", "package.json");
@@ -5029,7 +5331,7 @@ async function runSelfUpdate(input) {
     if (hasLocalSource) {
       source = "local";
       try {
-        availableVersion = JSON.parse(readFileSync8(localPkgPath, "utf8")).version ?? null;
+        availableVersion = JSON.parse(readFileSync9(localPkgPath, "utf8")).version ?? null;
       } catch {
         availableVersion = null;
       }
@@ -5087,7 +5389,7 @@ async function runSelfUpdate(input) {
     }
     const newVersion = (() => {
       try {
-        return JSON.parse(readFileSync8(localPkgPath, "utf8")).version ?? "unknown";
+        return JSON.parse(readFileSync9(localPkgPath, "utf8")).version ?? "unknown";
       } catch {
         return "unknown";
       }
@@ -6127,7 +6429,7 @@ import { existsSync as existsSync12 } from "fs";
 import { join as join34 } from "path";
 
 // src/utils/sync-lock.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync3, readFileSync as readFileSync9, renameSync, unlinkSync as unlinkSync4, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync3, readFileSync as readFileSync10, renameSync, unlinkSync as unlinkSync4, writeFileSync as writeFileSync5 } from "fs";
 import { join as join33 } from "path";
 import { createHash as createHash6 } from "crypto";
 function getSessionId() {
@@ -6142,7 +6444,7 @@ function readLock(vault) {
   const path = lockPath(vault);
   if (!existsSync11(path)) return null;
   try {
-    const raw = readFileSync9(path, "utf8");
+    const raw = readFileSync10(path, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -6206,6 +6508,15 @@ function releaseLock(vault, opts = {}) {
   }
   const sessionId = opts.sessionId ?? getSessionId();
   const existing = readLock(vault);
+  if (opts.force) {
+    try {
+      unlinkSync4(path);
+      const prior = existing && existing.session_id !== sessionId ? existing : void 0;
+      return { released: true, prior };
+    } catch {
+      return { released: false };
+    }
+  }
   if (!existing || existing.session_id !== sessionId) {
     return { released: false };
   }
@@ -6421,6 +6732,7 @@ async function runSyncPull(input) {
   let pulled = false;
   let conflicts = 0;
   let filesUpdated = 0;
+  let autoResolved = 0;
   try {
     const pullOutput = gitStrict(vault, ["pull", "--rebase", "origin", "HEAD"]);
     pulled = true;
@@ -6429,25 +6741,71 @@ async function runSyncPull(input) {
   } catch (e) {
     const errString = String(e);
     if (errString.includes("conflict")) {
-      const porcelain = git(vault, ["diff", "--name-only", "--diff-filter=U"]);
-      conflicts = porcelain ? porcelain.split("\n").filter((l) => l.trim().length > 0).length : 0;
+      let inConflict = true;
+      while (inConflict) {
+        const stoppedSha = git(vault, ["rev-parse", "--verify", "REBASE_HEAD"]);
+        let commitMsg = "";
+        if (stoppedSha) {
+          commitMsg = git(vault, ["log", "--format=%s", "-1", stoppedSha]);
+        }
+        const isArchiveOrSnapshot = commitMsg.startsWith("archive: moved") || commitMsg.startsWith("Snapshot ");
+        const conflictedFiles = git(vault, ["diff", "--name-only", "--diff-filter=U"]);
+        const conflictedList = conflictedFiles ? conflictedFiles.split("\n").filter((l) => l.trim().length > 0) : [];
+        if (conflictedList.length === 0) {
+          try {
+            gitStrict(vault, ["rebase", "--continue"]);
+            inConflict = true;
+          } catch {
+            inConflict = false;
+          }
+          continue;
+        }
+        if (isArchiveOrSnapshot) {
+          for (const f of conflictedList) {
+            try {
+              gitStrict(vault, ["checkout", "--ours", f]);
+              gitStrict(vault, ["add", f]);
+            } catch {
+            }
+          }
+          autoResolved += conflictedList.length;
+          try {
+            gitStrict(vault, ["rebase", "--continue"]);
+          } catch (continueErr) {
+            continue;
+          }
+        } else {
+          conflicts = conflictedList.length;
+          return {
+            exitCode: ExitCode.SYNC_PULL_FAILED,
+            result: ok({
+              fetched,
+              pulled: false,
+              files_updated: 0,
+              conflicts,
+              auto_resolved: 0,
+              lint_errors: 0,
+              lint_warnings: 0,
+              humanHint: `pull failed with ${conflicts} conflict(s) on non-archive commit "${commitMsg}" \u2014 resolve manually`
+            })
+          };
+        }
+      }
+      if (autoResolved > 0) {
+        const diffOutput = git(vault, ["diff", "--stat", "HEAD@{1}..HEAD"]);
+        if (diffOutput) {
+          const fileMatch = diffOutput.match(/(\d+) file[s]? changed/);
+          if (fileMatch) filesUpdated = parseInt(fileMatch[1], 10);
+        }
+        pulled = true;
+        conflicts = 0;
+      }
+    } else {
       return {
         exitCode: ExitCode.SYNC_PULL_FAILED,
-        result: ok({
-          fetched,
-          pulled: false,
-          files_updated: 0,
-          conflicts,
-          lint_errors: 0,
-          lint_warnings: 0,
-          humanHint: `pull failed with ${conflicts} conflict(s) \u2014 resolve manually`
-        })
+        result: err("GIT_PULL_FAILED", { message: errString })
       };
     }
-    return {
-      exitCode: ExitCode.SYNC_PULL_FAILED,
-      result: err("GIT_PULL_FAILED", { message: errString })
-    };
   }
   let lintErrors = 0;
   let lintWarnings = 0;
@@ -6459,6 +6817,7 @@ async function runSyncPull(input) {
   const hintParts = [];
   if (filesUpdated > 0) hintParts.push(`updated ${filesUpdated} file(s)`);
   else hintParts.push("already up to date");
+  if (autoResolved > 0) hintParts.push(`${autoResolved} conflict(s) auto-resolved`);
   if (lintErrors > 0) hintParts.push(`${lintErrors} lint error(s)`);
   if (lintWarnings > 0) hintParts.push(`${lintWarnings} lint warning(s)`);
   const exitCode = lintErrors > 0 ? ExitCode.LINT_HAS_ERRORS : lintWarnings > 0 ? ExitCode.LINT_HAS_WARNINGS : ExitCode.OK;
@@ -6469,6 +6828,7 @@ async function runSyncPull(input) {
       pulled,
       files_updated: filesUpdated,
       conflicts,
+      auto_resolved: autoResolved,
       lint_errors: lintErrors,
       lint_warnings: lintWarnings,
       humanHint: hintParts.join(", ")
@@ -6562,18 +6922,34 @@ function runSyncUnlock(input) {
       result: err("VAULT_PATH_INVALID", { path: vault })
     };
   }
-  const result = releaseLock(vault, { sessionId: input.sessionId });
+  const result = releaseLock(vault, { sessionId: input.sessionId, force: input.force });
+  let humanHint;
+  if (result.released && result.prior) {
+    humanHint = `lock force-released (was held by session ${result.prior.session_id}, PID ${result.prior.pid})`;
+  } else if (result.released) {
+    humanHint = "lock released";
+  } else {
+    humanHint = "lock not held by this session (no-op)";
+  }
+  const output = {
+    released: result.released,
+    humanHint
+  };
+  if (result.prior) {
+    output.prior = {
+      session_id: result.prior.session_id,
+      pid: result.prior.pid,
+      summary: result.prior.summary
+    };
+  }
   return {
     exitCode: ExitCode.OK,
-    result: ok({
-      released: result.released,
-      humanHint: result.released ? "lock released" : "lock not held by this session (no-op)"
-    })
+    result: ok(output)
   };
 }
 
 // src/commands/backup.ts
-import { statSync as statSync4, readdirSync as readdirSync2, readFileSync as readFileSync10, mkdirSync as mkdirSync4, writeFileSync as writeFileSync6 } from "fs";
+import { statSync as statSync4, readdirSync as readdirSync2, readFileSync as readFileSync11, mkdirSync as mkdirSync4, writeFileSync as writeFileSync6 } from "fs";
 import { join as join35, relative as relative3, dirname as dirname11 } from "path";
 import { PutObjectCommand, HeadObjectCommand, ListObjectsV2Command, GetObjectCommand, DeleteObjectsCommand } from "@aws-sdk/client-s3";
 
@@ -6640,7 +7016,7 @@ async function runBackupSync(input) {
       continue;
     }
     try {
-      const body = readFileSync10(absPath);
+      const body = readFileSync11(absPath);
       await client.send(new PutObjectCommand({ Bucket: input.bucket, Key: relPath, Body: body }));
       uploaded++;
     } catch {
@@ -7267,7 +7643,7 @@ async function postCommit(vault, exitCode) {
 }
 
 // src/cli.ts
-var pkg = JSON.parse(readFileSync11(new URL("../package.json", import.meta.url), "utf8"));
+var pkg = JSON.parse(readFileSync12(new URL("../package.json", import.meta.url), "utf8"));
 var program = new Command2();
 program.name("skillwiki").description("Deterministic helpers for CodeWiki skills").version(pkg.version);
 program.option("--human", "render terminal-readable output instead of JSON");
@@ -7537,10 +7913,10 @@ syncCmd.command("lock [vault]").description("acquire advisory lock on vault").op
     emit(runSyncLock({ vault: v.vault, summary: opts.summary, ttlMinutes: ttl, force: !!opts.force }));
   }
 });
-syncCmd.command("unlock [vault]").description("release advisory lock on vault").option("--wiki <name>", "wiki profile name").action(async (vault, opts) => {
+syncCmd.command("unlock [vault]").description("release advisory lock on vault").option("--force", "release lock regardless of holder", false).option("--wiki <name>", "wiki profile name").action(async (vault, opts) => {
   const v = await resolveVaultArg(vault, opts.wiki);
   if (!v.ok) emit({ exitCode: v.exitCode, result: v.payload });
-  else emit(runSyncUnlock({ vault: v.vault }));
+  else emit(runSyncUnlock({ vault: v.vault, force: !!opts.force }));
 });
 syncCmd.command("peers [vault]").description("list active locks and recent wiki-sync stashes").option("--wiki <name>", "wiki profile name").action(async (vault, opts) => {
   const v = await resolveVaultArg(vault, opts.wiki);

package/package.json

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

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

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