skillwiki 0.9.5 → 0.9.7

package/dist/cli.js

@@ -2070,11 +2070,11 @@ async function runInit(input) {
     ].join("\n");
   });
   if (errTemplate) return errTemplate;
-  const err22 = await writeOrPreserve("log.md", async () => {
+  const err2 = await writeOrPreserve("log.md", async () => {
     const tpl = await readFile7(join11(input.templates, "log.md"), "utf8");
     return tpl.replace(/\{\{INIT_DATE\}\}/g, today).replace("{{DOMAIN}}", domain).replace("{{WIKI_LANG}}", canonicalLang);
   });
-  if (err22) return err22;
+  if (err2) return err2;
   const skipEnv = !!input.noEnv || explicitTarget && !input.profile && swDotenvHadPath && !input.force;
   let envWritten = "";
   if (!skipEnv) {
@@ -2788,8 +2788,8 @@ async function acquireLogLock(vault, opts = {}) {
       writeFileSync2(path, content, { flag: "wx" });
       return { ok: true };
     } catch (e) {
-      const err3 = e;
-      if (err3.code !== "EEXIST") throw err3;
+      const err2 = e;
+      if (err2.code !== "EEXIST") throw err2;
     }
     try {
       const age = Date.now() - statSync2(path).mtimeMs;
@@ -2867,7 +2867,7 @@ ${content}
 // src/commands/lint.ts
 import { existsSync as existsSync6 } from "fs";
 import { readFile as readFile17 } from "fs/promises";
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 import { join as join23 } from "path";
 
 // src/commands/sparse-community.ts
@@ -2922,11 +2922,28 @@ ${markdown_links.map((l) => `  line ${l.line}: ${l.text}`).join("\n")}`;
 }
 
 // src/commands/dedup.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, unlinkSync as unlinkSync3 } from "fs";
-import { join as join20 } from "path";
+import { createHash as createHash3 } from "crypto";
+import { execFile } from "child_process";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, unlinkSync as unlinkSync3 } from "fs";
+import { dirname as dirname7, join as join20, resolve as resolve4 } from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
 async function runDedup(input) {
+  if (input.canonicalPolicy && input.canonicalPolicy !== "scan-order" && input.canonicalPolicy !== "stable-path") {
+    return { exitCode: ExitCode.USAGE, result: err("USAGE", { message: "--canonical-policy must be stable-path or scan-order" }) };
+  }
+  if (input.remoteDelete && !input.remote) {
+    return { exitCode: ExitCode.USAGE, result: err("USAGE", { message: "--remote-delete requires --remote" }) };
+  }
+  if (input.remoteDelete && !input.apply && !input.manifestIn) {
+    return { exitCode: ExitCode.USAGE, result: err("USAGE", { message: "--remote-delete requires --apply or --manifest-in" }) };
+  }
   const scan = await scanVault(input.vault);
   if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
+  const manifestFromFile = input.manifestIn ? readManifest(input.manifestIn) : null;
+  if (manifestFromFile && !manifestFromFile.ok) {
+    return { exitCode: ExitCode.INVALID_FRONTMATTER, result: manifestFromFile };
+  }
   const hashMap = /* @__PURE__ */ new Map();
   let totalFiles = 0;
   for (const raw of scan.data.raw) {
@@ -2939,18 +2956,42 @@ async function runDedup(input) {
     if (existing) existing.push(raw.relPath);
     else hashMap.set(sha, [raw.relPath]);
   }
-  const duplicates = [...hashMap.entries()].filter(([, files]) => files.length > 1).map(([sha256, files]) => ({ sha256, files }));
+  const canonicalPolicy = input.canonicalPolicy ?? "stable-path";
+  const duplicates = [...hashMap.entries()].filter(([, files]) => files.length > 1).map(([sha256, files]) => ({ sha256, files: orderFiles(files, canonicalPolicy) }));
   const rewired = [];
   const removed = [];
-  if (input.apply && duplicates.length > 0) {
+  const unsafe = [];
+  const safeEntries = manifestFromFile?.ok ? manifestFromFile.data.entries : buildSafeEntries(input.vault, duplicates, unsafe);
+  const manifest = safeEntries.length > 0 ? {
+    version: 1,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    vault: resolve4(input.vault),
+    entries: safeEntries
+  } : void 0;
+  const remote = await planAndMaybePruneRemote(input, safeEntries);
+  if (!remote.ok) {
+    return {
+      exitCode: remote.error === "SYNC_PUSH_FAILED" ? ExitCode.SYNC_PUSH_FAILED : ExitCode.USAGE,
+      result: remote
+    };
+  }
+  if (input.manifestOut && manifest) {
+    try {
+      mkdirSync3(dirname7(input.manifestOut), { recursive: true });
+      writeFileSync3(input.manifestOut, `${JSON.stringify(manifest, null, 2)}
+`, "utf-8");
+    } catch (e) {
+      return { exitCode: ExitCode.WRITE_FAILED, result: err("WRITE_FAILED", { path: input.manifestOut, message: String(e) }) };
+    }
+  }
+  if (input.apply && safeEntries.length > 0) {
     const replacements = /* @__PURE__ */ new Map();
-    for (const group of duplicates) {
-      const canonical = group.files[0];
-      for (let i = 1; i < group.files.length; i++) {
-        replacements.set(group.files[i], canonical);
+    for (const entry of safeEntries) {
+      for (const duplicate of entry.duplicates) {
+        replacements.set(duplicate, entry.canonical);
       }
     }
-    for (const page of scan.data.typedKnowledge) {
+    for (const page of scan.data.allMarkdown.filter((p) => !p.relPath.startsWith("raw/"))) {
       const text = readFileSync3(join20(input.vault, page.relPath), "utf-8");
       let updated = text;
       let changed = false;
@@ -2973,7 +3014,7 @@ async function runDedup(input) {
         rewired.push(page.relPath);
       }
     }
-    for (const [oldPath] of replacements) {
+    for (const oldPath of replacements.keys()) {
       const fullPath = join20(input.vault, oldPath);
       try {
         unlinkSync3(fullPath);
@@ -2999,19 +3040,131 @@ async function runDedup(input) {
       hintLines.push(`rewired: ${rewired.length} pages`);
       hintLines.push(`removed: ${removed.length} raw files`);
     }
+    if (unsafe.length > 0) hintLines.push(`unsafe: ${unsafe.length} groups skipped`);
+    if (remote.data.plannedDeletes.length > 0) {
+      hintLines.push(`remote planned deletes: ${remote.data.plannedDeletes.length}`);
+      if (input.remoteDelete) hintLines.push(`remote deleted: ${remote.data.deleted.length}`);
+    }
   } else {
     hintLines.push("0 duplicates");
   }
   return {
     exitCode,
-    result: ok({ scanned: totalFiles, duplicates, rewired, removed, humanHint: hintLines.join("\n") })
+    result: ok({
+      scanned: totalFiles,
+      duplicates,
+      manifest,
+      unsafe,
+      remote: remote.data,
+      rewired,
+      removed,
+      humanHint: hintLines.join("\n")
+    })
   };
 }
+function orderFiles(files, policy) {
+  if (policy === "scan-order") return [...files];
+  return [...files].sort(compareStableRawPath);
+}
+function compareStableRawPath(a, b) {
+  return rawPathScore(a) - rawPathScore(b) || a.localeCompare(b);
+}
+function rawPathScore(relPath) {
+  const base = relPath.split("/").pop() ?? relPath;
+  const stem = base.replace(/\.md$/i, "");
+  let score = 0;
+  if (relPath.startsWith("raw/articles/obsidian-import/")) score += 1e5;
+  if (/\bdup(licate)?\b/i.test(stem)) score += 1e4;
+  if (/(?:-[0-9]+|-[0-9a-f]{6,}|[0-9a-f]{8})$/i.test(stem)) score += 1e3;
+  score += relPath.length;
+  return score;
+}
+function buildSafeEntries(vault, duplicates, unsafe) {
+  const entries = [];
+  for (const group of duplicates) {
+    const canonical = group.files[0];
+    if (!canonical) {
+      unsafe.push({ sha256: group.sha256, files: group.files, reason: "canonical_missing" });
+      continue;
+    }
+    const bodyHashes = /* @__PURE__ */ new Map();
+    for (const file of group.files) {
+      const bodyHash2 = hashRawBody(vault, file);
+      const existing = bodyHashes.get(bodyHash2);
+      if (existing) existing.push(file);
+      else bodyHashes.set(bodyHash2, [file]);
+    }
+    if (bodyHashes.size !== 1) {
+      unsafe.push({ sha256: group.sha256, files: group.files, reason: "body_hash_mismatch" });
+      continue;
+    }
+    const [bodyHash] = bodyHashes.keys();
+    entries.push({
+      sha256: group.sha256,
+      canonical,
+      duplicates: group.files.slice(1),
+      bodyHash
+    });
+  }
+  return entries;
+}
+function hashRawBody(vault, relPath) {
+  const text = readFileSync3(join20(vault, relPath), "utf-8");
+  const split = splitFrontmatter(text);
+  const body = split.ok ? split.data.body : text;
+  return createHash3("sha256").update(body).digest("hex");
+}
+function readManifest(path) {
+  try {
+    const parsed = JSON.parse(readFileSync3(path, "utf-8"));
+    if (parsed.version !== 1 || !Array.isArray(parsed.entries)) {
+      return err("INVALID_FRONTMATTER", { message: "dedup manifest must have version 1 and entries[]" });
+    }
+    return ok(parsed);
+  } catch (e) {
+    return err("INVALID_FRONTMATTER", { path, message: String(e) });
+  }
+}
+async function planAndMaybePruneRemote(input, entries) {
+  const remoteRoot = input.remote?.replace(/\/+$/, "");
+  const plannedDeletes = remoteRoot ? entries.flatMap((entry) => entry.duplicates.map((path) => `${remoteRoot}/${path}`)) : [];
+  const output = { plannedDeletes, deleted: [] };
+  if (!input.remoteDelete) return ok(output);
+  const maxDeletes = input.maxRemoteDeletes ?? 50;
+  if (!Number.isInteger(maxDeletes) || maxDeletes < 1) {
+    return err("USAGE", { message: "--max-remote-deletes must be a positive integer" });
+  }
+  if (plannedDeletes.length > maxDeletes) {
+    return err("USAGE", { message: `remote delete cap exceeded: ${plannedDeletes.length} > ${maxDeletes}` });
+  }
+  const runner = input.rcloneRunner ?? defaultRcloneRunner;
+  for (const path of plannedDeletes) {
+    const result = await runner(["deletefile", path]);
+    if (result.exitCode !== 0) {
+      output.failed = { path, stderr: result.stderr };
+      return err("SYNC_PUSH_FAILED", { path, stderr: result.stderr });
+    }
+    output.deleted.push(path);
+  }
+  return ok(output);
+}
+async function defaultRcloneRunner(args) {
+  try {
+    const result = await execFileAsync("rclone", args, { encoding: "utf-8" });
+    return { exitCode: 0, stdout: result.stdout, stderr: result.stderr };
+  } catch (e) {
+    return {
+      exitCode: typeof e?.code === "number" ? e.code : 1,
+      stdout: typeof e?.stdout === "string" ? e.stdout : "",
+      stderr: typeof e?.stderr === "string" ? e.stderr : String(e)
+    };
+  }
+}
 
 // src/utils/safe-write.ts
 import { open, readFile as readFile15, rename as rename5, unlink as unlink2, writeFile as writeFile9 } from "fs/promises";
 import { randomBytes } from "crypto";
-import { dirname as dirname7, basename, join as join21 } from "path";
+import { dirname as dirname8, basename, join as join21 } from "path";
 var DEFAULT_MIN_BODY_RATIO = 0.5;
 var DEFAULT_MIN_OLD_BODY_BYTES = 200;
 function bodyBytes(text) {
@@ -3058,7 +3211,7 @@ async function safeWritePage(absPath, newContent, opts = {}) {
   if (!isNew && oldContent === newContent) {
     return ok({ isNew: false, oldBodyBytes, newBodyBytes, bodyRatio, guardSkippedSmall });
   }
-  const dir = dirname7(absPath);
+  const dir = dirname8(absPath);
   const tmpName = `.${basename(absPath)}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
   const tmpPath = join21(dir, tmpName);
   try {
@@ -3084,7 +3237,7 @@ async function safeWritePage(absPath, newContent, opts = {}) {
 }
 
 // src/commands/raw-body-dedup.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 async function runRawBodyDedup(vault) {
   const scan = await scanVault(vault);
   if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
@@ -3095,7 +3248,7 @@ async function runRawBodyDedup(vault) {
     const split = splitFrontmatter(text);
     if (!split.ok) continue;
     totalFiles++;
-    const bodyHash = createHash3("sha256").update(split.data.body).digest("hex");
+    const bodyHash = createHash4("sha256").update(split.data.body).digest("hex");
     const fm = extractFrontmatter(text);
     let fmSha256 = null;
     if (fm.ok && typeof fm.data.sha256 === "string" && fm.data.sha256.length === 64) {
@@ -3126,7 +3279,7 @@ async function runRawBodyDedup(vault) {
 // src/commands/path-too-long.ts
 import { existsSync as existsSync5 } from "fs";
 import { mkdir as mkdir8, readFile as readFile16, rename as rename6, unlink as unlink3 } from "fs/promises";
-import { dirname as dirname8, join as join22, posix, resolve as resolve4 } from "path";
+import { dirname as dirname9, join as join22, posix, resolve as resolve5 } from "path";
 var MAX_PATH_LENGTH = 240;
 var WINDOWS_ABSOLUTE_PATH_LIMIT = 259;
 async function runPathTooLong(input) {
@@ -3161,7 +3314,7 @@ async function fixPathTooLong(input) {
       if (target.mode === "dedupe") {
         await unlink3(join22(input.vault, violation.relPath));
       } else {
-        await mkdir8(dirname8(join22(input.vault, target.relPath)), { recursive: true });
+        await mkdir8(dirname9(join22(input.vault, target.relPath)), { recursive: true });
         await rename6(join22(input.vault, violation.relPath), join22(input.vault, target.relPath));
       }
       fixed.push({ from: violation.relPath, to: target.relPath });
@@ -3213,7 +3366,7 @@ function findPathTooLongViolations(pages, maxLength) {
 }
 function maxFixPathLength(vault) {
   if (process.platform !== "win32") return MAX_PATH_LENGTH;
-  const root = resolve4(vault);
+  const root = resolve5(vault);
   const separatorBudget = root.endsWith("\\") || root.endsWith("/") ? 0 : 1;
   const absoluteSafeRelLength = WINDOWS_ABSOLUTE_PATH_LIMIT - root.length - separatorBudget;
   return Math.max(1, Math.min(MAX_PATH_LENGTH, absoluteSafeRelLength));
@@ -3332,7 +3485,7 @@ function buildCliSurface() {
   program2.command("status").option("--wiki <name>");
   program2.command("archive").option("--wiki <name>").option("--cascade").option("--apply");
   program2.command("drift").option("--apply").option("--new <date>").option("--wiki <name>");
-  program2.command("dedup").option("--apply").option("--wiki <name>");
+  program2.command("dedup").option("--apply").option("--canonical-policy <policy>").option("--manifest-out <path>").option("--manifest-in <path>").option("--remote <remote>").option("--remote-delete").option("--max-remote-deletes <n>").option("--wiki <name>");
   program2.command("migrate-citations").option("--dry-run").option("--wiki <name>");
   program2.command("frontmatter-fix").option("--dry-run").option("--wiki <name>");
   program2.command("update").option("--tag <tag>");
@@ -3584,7 +3737,7 @@ function recomputeRawSha256IfPresent(content) {
   const split = splitFrontmatter(content);
   if (!split.ok) return content;
   if (!/^sha256:\s*[0-9a-f]{64}$/m.test(split.data.rawFrontmatter)) return content;
-  const sha256 = createHash4("sha256").update(Buffer.from(split.data.body, "utf8")).digest("hex");
+  const sha256 = createHash5("sha256").update(Buffer.from(split.data.body, "utf8")).digest("hex");
   const rawFrontmatter = split.data.rawFrontmatter.replace(/^sha256:\s*[0-9a-f]{64}$/m, `sha256: ${sha256}`);
   return `---
 ${rawFrontmatter}
@@ -4351,13 +4504,13 @@ ${match.length === 0 ? "0 violations" : match.map((b) => `  ${b.kind}: ${b.items
 }
 
 // src/commands/health.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync4, readFileSync as readFileSync8, renameSync, writeFileSync as writeFileSync6 } from "fs";
-import { dirname as dirname10, join as join30, resolve as resolve6 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync5, readFileSync as readFileSync8, renameSync, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname11, join as join30, resolve as resolve7 } from "path";
 import { platform as platform3 } from "os";
 
 // src/commands/doctor.ts
 import { existsSync as existsSync11, lstatSync, readlinkSync, readdirSync as readdirSync2, statSync as statSync3, readFileSync as readFileSync7 } from "fs";
-import { join as join29, resolve as resolve5 } from "path";
+import { join as join29, resolve as resolve6 } from "path";
 import { execSync as execSync2 } from "child_process";
 import { platform as platform2 } from "os";
 
@@ -4423,8 +4576,8 @@ async function runConfigPath(input) {
 }
 
 // src/utils/auto-update.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, existsSync as existsSync8, mkdirSync as mkdirSync3 } from "fs";
-import { join as join25, dirname as dirname9 } from "path";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, existsSync as existsSync8, mkdirSync as mkdirSync4 } from "fs";
+import { join as join25, dirname as dirname10 } from "path";
 import { spawn } from "child_process";
 function cachePath(home) {
   return join25(home, ".skillwiki", CACHE_FILENAME);
@@ -4446,7 +4599,7 @@ function readCache(home) {
 }
 function writeCache(home, cache) {
   const p = cachePath(home);
-  mkdirSync3(dirname9(p), { recursive: true });
+  mkdirSync4(dirname10(p), { recursive: true });
   writeFileSync4(p, JSON.stringify(cache, null, 2));
 }
 function latestFromCache(home, currentVersion) {
@@ -5246,14 +5399,14 @@ function checkNodeVersion() {
 function detectCliChannels(argv, home) {
   const channels = [];
   if (argv.length >= 2 && argv[1].endsWith("cli.js")) {
-    const devPath = resolve5(argv[1]);
+    const devPath = resolve6(argv[1]);
     channels.push({ name: "dev", path: devPath, isDevLink: true });
   }
   try {
     const whichOut = execSync2("which skillwiki 2>/dev/null", { encoding: "utf8" }).trim();
     if (whichOut) {
       const isDev = isDevSymlink(whichOut);
-      if (!channels.some((c) => c.path === resolve5(whichOut))) {
+      if (!channels.some((c) => c.path === resolve6(whichOut))) {
         channels.push({ name: "npm", path: whichOut, isDevLink: isDev });
       }
     }
@@ -5276,7 +5429,7 @@ function isDevSymlink(binPath) {
   try {
     const st = lstatSync(binPath);
     if (st.isSymbolicLink()) {
-      const target = resolve5(binPath, "..", readlinkSync(binPath));
+      const target = resolve6(binPath, "..", readlinkSync(binPath));
       return target.includes("packages/cli") || target.includes("packages\\cli");
     }
   } catch {
@@ -6695,7 +6848,7 @@ function buildHumanHint(report) {
   return lines.join("\n");
 }
 function writeReport(out, report) {
-  mkdirSync4(dirname10(out), { recursive: true });
+  mkdirSync5(dirname11(out), { recursive: true });
   const tmp = `${out}.tmp-${process.pid}-${Date.now()}`;
   writeFileSync6(tmp, JSON.stringify(ok(report), null, 2) + "\n", "utf8");
   renameSync(tmp, out);
@@ -6797,7 +6950,7 @@ async function runHealth(input) {
   if (input.out) {
     baseReport.report_path = input.out;
   }
-  if (input.out && resolve6(input.out).startsWith(resolve6(input.vault) + "/")) {
+  if (input.out && resolve7(input.out).startsWith(resolve7(input.vault) + "/")) {
     baseReport.warnings.push({
       id: "report_inside_vault",
       message: "health report was written inside the vault; this may create sync churn"
@@ -6831,7 +6984,7 @@ async function runHealth(input) {
 
 // src/commands/archive.ts
 import { rename as rename7, mkdir as mkdir9, readFile as readFile21, writeFile as writeFile10 } from "fs/promises";
-import { join as join31, dirname as dirname11 } from "path";
+import { join as join31, dirname as dirname12 } from "path";
 function countWikilinks(body, slug) {
   const escaped = slug.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   const re = new RegExp(`\\[\\[${escaped}(?:[|#][^\\]]*)?\\]\\]`, "g");
@@ -6927,7 +7080,7 @@ ${fmRewritten}
       }
     }
   }
-  await mkdir9(dirname11(join31(input.vault, archivePath)), { recursive: true });
+  await mkdir9(dirname12(join31(input.vault, archivePath)), { recursive: true });
   let indexUpdated = false;
   if (!isRaw) {
     const indexPath = join31(input.vault, "index.md");
@@ -6966,7 +7119,7 @@ ${fmRewritten}
 }
 
 // src/commands/drift.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 
 // src/utils/fetch.ts
 async function controlledFetch(url, opts) {
@@ -7045,7 +7198,7 @@ async function runDrift(input) {
       });
       continue;
     }
-    const currentHash = createHash5("sha256").update(Buffer.from(resp.data.body, "utf8")).digest("hex");
+    const currentHash = createHash6("sha256").update(Buffer.from(resp.data.body, "utf8")).digest("hex");
     const identity = assessSourceIdentity({
       rawPath: raw.relPath,
       sourceUrl,
@@ -7648,7 +7801,7 @@ async function runTranscripts(input) {
 
 // src/commands/project-index.ts
 import { readdir as readdir6, readFile as readFile23, writeFile as writeFile11, mkdir as mkdir10 } from "fs/promises";
-import { join as join35, dirname as dirname12 } from "path";
+import { join as join35, dirname as dirname13 } from "path";
 var LAYER2_DIRS = ["entities", "concepts", "comparisons", "queries", "meta"];
 async function runProjectIndex(input) {
   const slug = input.slug;
@@ -7762,7 +7915,7 @@ Autogenerated by \`skillwiki project-index\` on ${today}.
   }
   if (input.apply) {
     try {
-      await mkdir10(dirname12(indexPath), { recursive: true });
+      await mkdir10(dirname13(indexPath), { recursive: true });
       await writeFile11(indexPath, body, "utf8");
     } catch (e) {
       return {
@@ -8079,7 +8232,7 @@ no compound entries found`;
 import { mkdir as mkdir12, writeFile as writeFile13 } from "fs/promises";
 import { existsSync as existsSync15, statSync as statSync4 } from "fs";
 import { join as join37 } from "path";
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 var ALLOWED_KINDS = /* @__PURE__ */ new Set(["note", "bug", "task", "idea", "session-log"]);
 function slugify2(text) {
   const words = text.trim().split(/\s+/).slice(0, 6).join("-").toLowerCase().replace(/[^a-z0-9-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
@@ -8123,7 +8276,7 @@ async function runObserve(input) {
   const body = `
 ${input.text.trim()}
 `;
-  const sha256 = createHash6("sha256").update(Buffer.from(body, "utf8")).digest("hex");
+  const sha256 = createHash7("sha256").update(Buffer.from(body, "utf8")).digest("hex");
   const frontmatterLines = [
     "---",
     "source_url:",
@@ -8522,7 +8675,7 @@ function dateFromPath(path) {
 // src/commands/ingest.ts
 import { readFile as readFile26, writeFile as writeFile15, mkdir as mkdir14 } from "fs/promises";
 import { join as join39 } from "path";
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 var ALLOWED_TYPES = /* @__PURE__ */ new Set(["entity", "concept", "comparison", "query"]);
 var TYPE_DIR = {
   entity: "entities",
@@ -8698,7 +8851,7 @@ async function runIngest(input) {
       })
     };
   }
-  const sha256 = createHash7("sha256").update(Buffer.from(sourceContent, "utf8")).digest("hex");
+  const sha256 = createHash8("sha256").update(Buffer.from(sourceContent, "utf8")).digest("hex");
   const today = todayIso();
   const slug = slugify3(input.title);
   const tags = input.tags && input.tags.length > 0 ? input.tags : [];
@@ -8980,9 +9133,9 @@ import { existsSync as existsSync17 } from "fs";
 import { join as join41 } from "path";
 
 // src/utils/sync-lock.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync5, readFileSync as readFileSync11, renameSync as renameSync2, unlinkSync as unlinkSync5, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync16, mkdirSync as mkdirSync6, readFileSync as readFileSync11, renameSync as renameSync2, unlinkSync as unlinkSync5, writeFileSync as writeFileSync7 } from "fs";
 import { join as join40 } from "path";
-import { createHash as createHash8 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 function getSessionId() {
   if (process.env.CLAUDE_SESSION_ID) return process.env.CLAUDE_SESSION_ID;
   if (process.env.SKILLWIKI_SESSION_ID) return process.env.SKILLWIKI_SESSION_ID;
@@ -9010,7 +9163,7 @@ function acquireLock(vault, opts = {}) {
   const path = lockPath(vault);
   const dir = join40(vault, ".skillwiki");
   if (!existsSync16(dir)) {
-    mkdirSync5(dir, { recursive: true });
+    mkdirSync6(dir, { recursive: true });
   }
   const sessionId = opts.sessionId ?? getSessionId();
   const summary = opts.summary ?? "skillwiki sync";
@@ -9032,8 +9185,8 @@ function acquireLock(vault, opts = {}) {
     writeFileSync7(path, content, { flag: "wx" });
     return { ok: true, lock };
   } catch (e) {
-    const err3 = e;
-    if (err3.code !== "EEXIST") throw err3;
+    const err2 = e;
+    if (err2.code !== "EEXIST") throw err2;
   }
   const existing = readLock(vault);
   if (!existing) {
@@ -9524,8 +9677,8 @@ function runSyncUnlock(input) {
 }
 
 // src/commands/backup.ts
-import { statSync as statSync5, readdirSync as readdirSync3, readFileSync as readFileSync12, mkdirSync as mkdirSync6, writeFileSync as writeFileSync8 } from "fs";
-import { join as join42, relative as relative4, dirname as dirname13 } from "path";
+import { statSync as statSync5, readdirSync as readdirSync3, readFileSync as readFileSync12, mkdirSync as mkdirSync7, writeFileSync as writeFileSync8 } from "fs";
+import { join as join42, relative as relative4, dirname as dirname14 } from "path";
 import { PutObjectCommand, HeadObjectCommand, ListObjectsV2Command, GetObjectCommand, DeleteObjectsCommand } from "@aws-sdk/client-s3";
 
 // src/utils/s3-client.ts
@@ -9661,7 +9814,7 @@ async function runBackupRestore(input) {
         const resp = await client.send(new GetObjectCommand({ Bucket: input.bucket, Key: obj.Key }));
         const body = await resp.Body?.transformToByteArray();
         if (body) {
-          mkdirSync6(dirname13(localPath), { recursive: true });
+          mkdirSync7(dirname14(localPath), { recursive: true });
           writeFileSync8(localPath, Buffer.from(body));
           downloaded++;
         }
@@ -10448,10 +10601,19 @@ program.command("drift [vault]").description("detect content drift in raw source
   if (!v.ok) emit({ exitCode: v.exitCode, result: v.payload });
   else emit(await runDrift({ vault: v.vault, apply: opts.apply, newSince: opts.new }), v.vault);
 });
-program.command("dedup [vault]").description("detect duplicate raw sources by sha256").option("--apply", "rewire citations and remove duplicate raw files", false).option("--wiki <name>", "wiki profile name").action(async (vault, opts) => {
+program.command("dedup [vault]").description("detect duplicate raw sources by sha256").option("--apply", "rewire citations and remove duplicate raw files", false).option("--canonical-policy <policy>", "canonical policy: stable-path or scan-order", "stable-path").option("--manifest-out <path>", "write raw dedup delete manifest before applying").option("--manifest-in <path>", "read existing raw dedup delete manifest for remote pruning").option("--remote <remote>", "rclone remote root, for example seaweed-wiki:cloud/wiki").option("--remote-delete", "delete manifest duplicate paths from the remote", false).option("--max-remote-deletes <n>", "maximum remote object deletes allowed", "50").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(await runDedup({ vault: v.vault, apply: opts.apply }), v.vault);
+  else emit(await runDedup({
+    vault: v.vault,
+    apply: opts.apply,
+    canonicalPolicy: opts.canonicalPolicy,
+    manifestOut: opts.manifestOut,
+    manifestIn: opts.manifestIn,
+    remote: opts.remote,
+    remoteDelete: !!opts.remoteDelete,
+    maxRemoteDeletes: Number.parseInt(opts.maxRemoteDeletes, 10)
+  }), v.vault);
 });
 program.command("migrate-citations [vault]").description("migrate ^[raw/...] markers to paragraph-end citations").option("--dry-run", "preview changes without writing", false).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.9.5",
+  "version": "0.9.7",
   "type": "module",
   "bin": {
     "skillwiki": "dist/cli.js"

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

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