skillwiki 0.9.62 → 0.9.63

package/dist/cli.js

@@ -92,7 +92,7 @@ import {
   taxonomyCommentForPage,
   upsertIndexEntry,
   writeDotenv
-} from "./chunk-2PENIQ3A.js";
+} from "./chunk-TUFQZ5K4.js";
 import {
   normalizeDistTag,
   readCache,
@@ -102,7 +102,7 @@ import {
 } from "./chunk-7I2TPIV5.js";
 
 // src/cli.ts
-import { join as join25 } from "path";
+import { join as join27 } from "path";
 import { Command } from "commander";
 
 // src/utils/output.ts
@@ -1359,8 +1359,50 @@ async function runHealth(input) {
 }
 
 // src/commands/archive.ts
-import { rename as rename2, mkdir as mkdir5, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
-import { join as join8, dirname as dirname5 } from "path";
+import { rename as rename2, mkdir as mkdir6, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
+import { join as join9, dirname as dirname5 } from "path";
+
+// src/utils/delete-intent.ts
+import { mkdir as mkdir5, writeFile as writeFile4, readdir as readdir3, readFile as readFile5 } from "fs/promises";
+import { join as join8 } from "path";
+var DELETE_INTENT_SCHEMA = "vault-delete-intent/v1";
+var DELETE_INTENT_DIR = "meta/delete-intents";
+function normalizeVaultRelPath(path) {
+  const p = path.replace(/\\/g, "/").replace(/^\/+/, "");
+  if (!p || p.includes("..") || p.startsWith(".git/")) {
+    throw new Error(`invalid vault-relative path: ${path}`);
+  }
+  return p;
+}
+function pathToIntentFilename(path) {
+  const p = normalizeVaultRelPath(path);
+  return `${p.replace(/\//g, "__")}.json`;
+}
+function intentHostId() {
+  return process.env.SKILLWIKI_HOST_ID ?? process.env.AGENT_HOST_ID ?? "unknown";
+}
+function buildDeleteIntent(input) {
+  return {
+    schema: DELETE_INTENT_SCHEMA,
+    path: normalizeVaultRelPath(input.path),
+    action: input.action,
+    created: input.created ?? (/* @__PURE__ */ new Date()).toISOString(),
+    host: input.host ?? intentHostId(),
+    actor: input.actor,
+    reason: input.reason,
+    source: input.source,
+    expires: input.expires ?? null
+  };
+}
+async function writeDeleteIntent(vault, intent) {
+  const dir = join8(vault, DELETE_INTENT_DIR);
+  await mkdir5(dir, { recursive: true });
+  const rel = `${DELETE_INTENT_DIR}/${pathToIntentFilename(intent.path)}`;
+  await writeFile4(join8(vault, rel), JSON.stringify(intent, null, 2) + "\n", "utf8");
+  return rel;
+}
+
+// src/commands/archive.ts
 function countWikilinks(body, slug) {
   const escaped = slug.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   const re = new RegExp(`\\[\\[${escaped}(?:[|#][^\\]]*)?\\]\\]`, "g");
@@ -1394,7 +1436,7 @@ async function runArchive(input) {
   if (!relPath) return { exitCode: ExitCode.ARCHIVE_TARGET_NOT_FOUND, result: err("ARCHIVE_TARGET_NOT_FOUND", { page: input.page }) };
   if (relPath.startsWith("_archive/")) return { exitCode: ExitCode.ARCHIVE_ALREADY_ARCHIVED, result: err("ARCHIVE_ALREADY_ARCHIVED", { page: relPath }) };
   const slug = relPath.replace(/\.md$/, "").split("/").pop();
-  const archivePath = join8("_archive", relPath).replace(/\\/g, "/");
+  const archivePath = join9("_archive", relPath).replace(/\\/g, "/");
   const remoteRoot = normalizeRemoteRoot(input.remote);
   const remoteObjectPath = buildRemoteObjectPath(remoteRoot, relPath);
   let cascade;
@@ -1420,7 +1462,7 @@ async function runArchive(input) {
     const indexRefs = [];
     if (!isRaw) {
       try {
-        const idx = await readFile5(join8(input.vault, "index.md"), "utf8");
+        const idx = await readFile6(join9(input.vault, "index.md"), "utf8");
         idx.split("\n").forEach((line, i) => {
           if (line.includes(`[[${slug}]]`)) indexRefs.push({ line: i + 1, text: line });
         });
@@ -1447,8 +1489,8 @@ async function runArchive(input) {
   }
   if (input.cascade && input.apply && cascade) {
     for (const ref of cascade.source_array_refs) {
-      const absPath = join8(input.vault, ref.page);
-      const text = await readFile5(absPath, "utf8");
+      const absPath = join9(input.vault, ref.page);
+      const text = await readFile6(absPath, "utf8");
       const split = splitFrontmatter(text);
       if (!split.ok) continue;
       const before = split.data.rawFrontmatter;
@@ -1459,33 +1501,40 @@ async function runArchive(input) {
       );
       if (fmRewritten === before) continue;
       if (!arraysEqual(ref.sources_after, ref.sources_before)) {
-        await writeFile4(absPath, `---
+        await writeFile5(absPath, `---
 ${fmRewritten}
 ---${split.data.body}`, "utf8");
       }
     }
   }
-  await mkdir5(dirname5(join8(input.vault, archivePath)), { recursive: true });
+  await mkdir6(dirname5(join9(input.vault, archivePath)), { recursive: true });
   let indexUpdated = false;
   if (!isRaw) {
-    const indexPath = join8(input.vault, "index.md");
+    const indexPath = join9(input.vault, "index.md");
     try {
-      const idx = await readFile5(indexPath, "utf8");
+      const idx = await readFile6(indexPath, "utf8");
       const originalLines = idx.split("\n");
       const filtered = originalLines.filter((l) => !l.includes(`[[${slug}]]`));
       if (filtered.length !== originalLines.length) {
-        await writeFile4(indexPath, filtered.join("\n"), "utf8");
+        await writeFile5(indexPath, filtered.join("\n"), "utf8");
         indexUpdated = true;
       }
     } catch (e) {
       if (e instanceof Error && "code" in e && e.code !== "ENOENT") throw e;
     }
   }
-  await rename2(join8(input.vault, relPath), join8(input.vault, archivePath));
+  await rename2(join9(input.vault, relPath), join9(input.vault, archivePath));
+  const archiveIntent = buildDeleteIntent({
+    path: relPath,
+    action: "archive",
+    actor: "skillwiki-cli",
+    source: "cli"
+  });
+  const tombstonePath = await writeDeleteIntent(input.vault, archiveIntent);
   appendLastOp(input.vault, {
     operation: input.cascade ? "archive-cascade" : "archive",
-    summary: `moved ${relPath} to ${archivePath}${input.cascade ? ` (cascade: ${cascade?.source_array_refs.length ?? 0} source arrays updated)` : ""}`,
-    files: [relPath],
+    summary: `moved ${relPath} to ${archivePath}${input.cascade ? ` (cascade: ${cascade?.source_array_refs.length ?? 0} source arrays updated)` : ""}; tombstone ${tombstonePath}`,
+    files: [relPath, archivePath, tombstonePath],
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
   });
   let remote;
@@ -1514,6 +1563,106 @@ ${fmRewritten}
   };
 }
 
+// src/commands/remove.ts
+import { unlink as unlink2, readFile as readFile7, writeFile as writeFile6, access } from "fs/promises";
+import { join as join10 } from "path";
+async function pathExists(abs) {
+  try {
+    await access(abs);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runRemove(input) {
+  if (input.remoteDelete && !input.remote) {
+    return { exitCode: ExitCode.USAGE, result: err("USAGE", { message: "--remote-delete requires --remote" }) };
+  }
+  if (input.remoteDelete && !isValidRemoteDeleteCap(input.maxRemoteDeletes)) {
+    return { exitCode: ExitCode.USAGE, result: err("USAGE", { message: "--max-remote-deletes must be a positive integer" }) };
+  }
+  const scan = await scanVault(input.vault);
+  if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
+  const lookup = (pages) => {
+    if (input.page.includes("/")) return pages.find((p) => p.relPath === input.page)?.relPath;
+    return pages.find((p) => p.relPath.replace(/\.md$/, "").split("/").pop() === input.page)?.relPath;
+  };
+  let relPath = lookup(scan.data.typedKnowledge) ?? lookup(scan.data.raw) ?? null;
+  if (!relPath) {
+    try {
+      const candidate = normalizeVaultRelPath(input.page);
+      if (await pathExists(join10(input.vault, candidate))) {
+        relPath = candidate;
+      }
+    } catch {
+    }
+  }
+  if (!relPath) {
+    return {
+      exitCode: ExitCode.FILE_NOT_FOUND,
+      result: err("FILE_NOT_FOUND", { page: input.page })
+    };
+  }
+  if (relPath.startsWith("_archive/")) {
+    return {
+      exitCode: ExitCode.USAGE,
+      result: err("USAGE", { message: "refusing to remove path already under _archive/; use restore or leave archived" })
+    };
+  }
+  const remoteRoot = normalizeRemoteRoot(input.remote);
+  const remoteObjectPath = buildRemoteObjectPath(remoteRoot, relPath);
+  const slug = relPath.replace(/\.md$/, "").split("/").pop() ?? relPath;
+  let indexUpdated = false;
+  if (relPath.endsWith(".md") && !relPath.startsWith("raw/")) {
+    const indexPath = join10(input.vault, "index.md");
+    try {
+      const idx = await readFile7(indexPath, "utf8");
+      const originalLines = idx.split("\n");
+      const filtered = originalLines.filter((l) => !l.includes(`[[${slug}]]`));
+      if (filtered.length !== originalLines.length) {
+        await writeFile6(indexPath, filtered.join("\n"), "utf8");
+        indexUpdated = true;
+      }
+    } catch (e) {
+      if (e instanceof Error && "code" in e && e.code !== "ENOENT") throw e;
+    }
+  }
+  const intent = buildDeleteIntent({
+    path: relPath,
+    action: "remove",
+    actor: "skillwiki-cli",
+    source: "cli",
+    reason: input.reason
+  });
+  const tombstonePath = await writeDeleteIntent(input.vault, intent);
+  await unlink2(join10(input.vault, relPath));
+  appendLastOp(input.vault, {
+    operation: "remove",
+    summary: `removed ${relPath} (tombstone ${tombstonePath})`,
+    files: [relPath, tombstonePath],
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  let remote;
+  if (remoteObjectPath) {
+    const pruned = await planAndMaybePruneRemoteObjects([remoteObjectPath], input);
+    if (!pruned.ok) {
+      return { exitCode: ExitCode.SYNC_PUSH_FAILED, result: pruned };
+    }
+    remote = pruned.data;
+  }
+  const remoteNote = remote ? ` (remote ${input.remoteDelete ? `deleted ${remote.deleted.length}` : `planned ${remote.plannedDeletes.length}`})` : "";
+  return {
+    exitCode: ExitCode.OK,
+    result: ok({
+      removed: relPath,
+      tombstone_path: tombstonePath,
+      index_updated: indexUpdated,
+      ...remote ? { remote } : {},
+      humanHint: `removed ${relPath}; tombstone ${tombstonePath}${indexUpdated ? " (index updated)" : ""}${remoteNote}`
+    })
+  };
+}
+
 // src/commands/drift.ts
 import { createHash as createHash2 } from "crypto";
 
@@ -1825,14 +1974,14 @@ ${migratedBody}${newFooter}`;
 
 // src/commands/update.ts
 import { execSync } from "child_process";
-import { join as join9 } from "path";
+import { join as join11 } from "path";
 function resolveGlobalSkillsRoot() {
   try {
     const globalRoot = execSync("npm root -g", {
       encoding: "utf8",
       timeout: 5e3
     }).trim();
-    return join9(globalRoot, "skillwiki", "skills");
+    return join11(globalRoot, "skillwiki", "skills");
   } catch {
     return null;
   }
@@ -1860,7 +2009,7 @@ async function runUpdate(input) {
   const pkg2 = readCliPackageJson();
   const currentVersion = pkg2.version;
   const tag = normalizeDistTag(input.distTag);
-  const target = join9(input.home, ".claude", "skills");
+  const target = join11(input.home, ".claude", "skills");
   let latest;
   try {
     latest = execSync(`npm view skillwiki@${tag} version`, {
@@ -1938,13 +2087,13 @@ async function runUpdate(input) {
 // src/commands/self-update.ts
 import { execSync as execSync2 } from "child_process";
 import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-import { join as join10 } from "path";
+import { join as join12 } from "path";
 var DEFAULT_SOURCE_ROOT_SUFFIX = "/Desktop/code/llm-wiki";
 async function runSelfUpdate(input) {
   const currentVersion = readCliPackageJson().version;
   const sourceRoot = input.sourceRoot ?? `${input.home}${DEFAULT_SOURCE_ROOT_SUFFIX}`;
   const distTag = normalizeDistTag(input.distTag);
-  const localPkgPath = join10(sourceRoot, "packages", "cli", "package.json");
+  const localPkgPath = join12(sourceRoot, "packages", "cli", "package.json");
   const hasLocalSource = existsSync3(localPkgPath);
   if (input.check) {
     let availableVersion = null;
@@ -2076,21 +2225,21 @@ async function runSelfUpdate(input) {
 }
 
 // src/commands/transcripts.ts
-import { readdir as readdir3, stat as stat3, readFile as readFile6 } from "fs/promises";
-import { join as join11 } from "path";
+import { readdir as readdir4, stat as stat3, readFile as readFile8 } from "fs/promises";
+import { join as join13 } from "path";
 async function runTranscripts(input) {
-  const dir = join11(input.vault, "raw", "transcripts");
+  const dir = join13(input.vault, "raw", "transcripts");
   let entries;
   try {
-    entries = await readdir3(dir, { withFileTypes: true });
+    entries = await readdir4(dir, { withFileTypes: true });
   } catch {
     return { exitCode: ExitCode.VAULT_PATH_INVALID, result: { ok: false, error: "VAULT_PATH_INVALID", detail: `raw/transcripts/ not found: ${dir}` } };
   }
   const transcripts = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-    const filePath = join11(dir, entry.name);
-    const content = await readFile6(filePath, "utf8");
+    const filePath = join13(dir, entry.name);
+    const content = await readFile8(filePath, "utf8");
     const fm = extractFrontmatter(content);
     if (!fm.ok) continue;
     const ingested = typeof fm.data.ingested === "string" ? fm.data.ingested : "";
@@ -2107,10 +2256,10 @@ async function runTranscripts(input) {
 }
 
 // src/commands/compound.ts
-import { writeFile as writeFile5, mkdir as mkdir6, readdir as readdir4, unlink as unlink2 } from "fs/promises";
-import { join as join12 } from "path";
+import { writeFile as writeFile7, mkdir as mkdir7, readdir as readdir5, unlink as unlink3 } from "fs/promises";
+import { join as join14 } from "path";
 import { existsSync as existsSync4 } from "fs";
-import { readFile as readFile7 } from "fs/promises";
+import { readFile as readFile9 } from "fs/promises";
 var RETRO_HEADING_RE = /^## \[(\d{4}-\d{2}-\d{2})(?:\s+[^\]]+)?\] retro \| loop cycle(?: (\d+))?: (.+)$/;
 var FIELD_RE = {
   improve: /^-\s+\*?\*?Improve:?\*?\*?\s*(.+)$/m,
@@ -2208,17 +2357,17 @@ function extractRetroFields(date, cycleName, block) {
   };
 }
 async function runCompound(input) {
-  const logPath = join12(input.vault, "log.md");
+  const logPath = join14(input.vault, "log.md");
   let logText;
   try {
-    logText = await readFile7(logPath, "utf8");
+    logText = await readFile9(logPath, "utf8");
   } catch {
     return { exitCode: ExitCode.FILE_NOT_FOUND, result: err("FILE_NOT_FOUND", { path: logPath }) };
   }
   const entries = parseRetroEntries(logText);
   const promoted = [];
   const skipped = [];
-  const compoundDir = join12(input.vault, "projects", input.project, "compound");
+  const compoundDir = join14(input.vault, "projects", input.project, "compound");
   for (const entry of entries) {
     const generalizeValue = entry.generalize.trim();
     if (!/^yes/i.test(generalizeValue)) {
@@ -2226,7 +2375,7 @@ async function runCompound(input) {
       continue;
     }
     const slug = slugify(entry.cycleName);
-    const compoundPath = join12(compoundDir, `${slug}.md`);
+    const compoundPath = join14(compoundDir, `${slug}.md`);
     if (existsSync4(compoundPath)) {
       skipped.push(entry.date);
       continue;
@@ -2266,9 +2415,9 @@ async function runCompound(input) {
     const content = frontmatter + "\n" + body;
     if (!input.dryRun) {
       if (!existsSync4(compoundDir)) {
-        await mkdir6(compoundDir, { recursive: true });
+        await mkdir7(compoundDir, { recursive: true });
       }
-      await writeFile5(compoundPath, content, "utf8");
+      await writeFile7(compoundPath, content, "utf8");
     }
     promoted.push(`${slug}.md`);
   }
@@ -2287,7 +2436,7 @@ async function runCompound(input) {
   };
 }
 async function runCompoundDelete(input) {
-  const projectDir = join12(input.vault, "projects", input.project);
+  const projectDir = join14(input.vault, "projects", input.project);
   if (!existsSync4(projectDir)) {
     return {
       exitCode: ExitCode.PROJECT_NOT_FOUND,
@@ -2295,7 +2444,7 @@ async function runCompoundDelete(input) {
     };
   }
   const entryName = input.entry.replace(/\.md$/, "");
-  const compoundPath = join12(projectDir, "compound", `${entryName}.md`);
+  const compoundPath = join14(projectDir, "compound", `${entryName}.md`);
   if (!existsSync4(compoundPath)) {
     return {
       exitCode: ExitCode.FILE_NOT_FOUND,
@@ -2303,7 +2452,7 @@ async function runCompoundDelete(input) {
     };
   }
   try {
-    await unlink2(compoundPath);
+    await unlink3(compoundPath);
   } catch (e) {
     return {
       exitCode: ExitCode.WRITE_FAILED,
@@ -2329,7 +2478,7 @@ knowledge.md regenerated`
   };
 }
 async function runCompoundList(input) {
-  const compoundDir = join12(input.vault, "projects", input.project, "compound");
+  const compoundDir = join14(input.vault, "projects", input.project, "compound");
   if (!existsSync4(compoundDir)) {
     return {
       exitCode: ExitCode.OK,
@@ -2344,7 +2493,7 @@ no compound directory found`
   }
   let dirents;
   try {
-    dirents = await readdir4(compoundDir, { withFileTypes: true });
+    dirents = await readdir5(compoundDir, { withFileTypes: true });
   } catch {
     return {
       exitCode: ExitCode.OK,
@@ -2360,10 +2509,10 @@ could not read compound directory`
   const entries = [];
   for (const dirent of dirents) {
     if (!dirent.isFile() || !dirent.name.endsWith(".md")) continue;
-    const filePath = join12(compoundDir, dirent.name);
+    const filePath = join14(compoundDir, dirent.name);
     let text;
     try {
-      text = await readFile7(filePath, "utf8");
+      text = await readFile9(filePath, "utf8");
     } catch {
       continue;
     }
@@ -2392,8 +2541,8 @@ no compound entries found`;
 }
 
 // src/commands/session-brief.ts
-import { mkdir as mkdir7, readFile as readFile8, writeFile as writeFile6 } from "fs/promises";
-import { join as join13, relative, sep } from "path";
+import { mkdir as mkdir8, readFile as readFile10, writeFile as writeFile8 } from "fs/promises";
+import { join as join15, relative, sep } from "path";
 var MAX_WORDS = 900;
 async function runSessionBrief(input) {
   const scan = await scanVault(input.vault);
@@ -2493,7 +2642,7 @@ async function resolveProject(input) {
   const envProject = input.env?.SKILLWIKI_PROJECT;
   if (envProject) return envProject;
   const cwd = input.cwd ?? process.cwd();
-  const projectDotenv = await readProjectSlug(join13(cwd, ".skillwiki", ".env"));
+  const projectDotenv = await readProjectSlug(join15(cwd, ".skillwiki", ".env"));
   if (projectDotenv) return projectDotenv;
   const inferred = inferProjectFromPath(input.vault, cwd);
   if (inferred) return inferred;
@@ -2502,7 +2651,7 @@ async function resolveProject(input) {
 async function readProjectSlug(file) {
   let text;
   try {
-    text = await readFile8(file, "utf8");
+    text = await readFile10(file, "utf8");
   } catch {
     return void 0;
   }
@@ -2579,7 +2728,7 @@ async function loadTrendDigests(typedPages) {
   return out;
 }
 async function loadSessionPins(vault, project) {
-  const text = await readIfExists(join13(vault, "meta", "session-pins.md"));
+  const text = await readIfExists(join15(vault, "meta", "session-pins.md"));
   if (!text) return [];
   const fm = extractFrontmatter(text);
   if (!fm.ok) return [];
@@ -2696,7 +2845,7 @@ function satelliteHealthWarnings(warning) {
   return warning ? [warning] : [];
 }
 async function loadHealthWarnings(vault) {
-  const text = await readIfExists(join13(vault, ".skillwiki", "health.json"));
+  const text = await readIfExists(join15(vault, ".skillwiki", "health.json"));
   if (!text) return [];
   try {
     const parsed = JSON.parse(text);
@@ -2709,7 +2858,7 @@ async function loadHealthWarnings(vault) {
   }
 }
 async function loadMemoryTopics(vault, project) {
-  const text = await readIfExists(join13(vault, ".skillwiki", "memory", project, "topics.json"));
+  const text = await readIfExists(join15(vault, ".skillwiki", "memory", project, "topics.json"));
   if (!text) return [];
   try {
     const parsed = JSON.parse(text);
@@ -2726,18 +2875,18 @@ async function loadMemoryTopics(vault, project) {
   }
 }
 async function writeBriefArtifacts(vault, input) {
-  const metaPath = join13(vault, "meta", "latest-session-brief.md");
-  const cacheMdPath = join13(vault, ".skillwiki", "session-brief.md");
-  const cacheJsonPath = join13(vault, ".skillwiki", "session-brief.json");
-  await mkdir7(join13(vault, "meta"), { recursive: true });
-  await mkdir7(join13(vault, ".skillwiki"), { recursive: true });
+  const metaPath = join15(vault, "meta", "latest-session-brief.md");
+  const cacheMdPath = join15(vault, ".skillwiki", "session-brief.md");
+  const cacheJsonPath = join15(vault, ".skillwiki", "session-brief.json");
+  await mkdir8(join15(vault, "meta"), { recursive: true });
+  await mkdir8(join15(vault, ".skillwiki"), { recursive: true });
   const committed = renderCommittedBrief(input);
   const previousComparable = comparableBrief(await readIfExists(metaPath));
   const nextComparable = comparableBrief(committed);
   const materialChange = previousComparable !== nextComparable;
-  await writeFile6(metaPath, committed, "utf8");
-  await writeFile6(cacheMdPath, input.brief, "utf8");
-  await writeFile6(cacheJsonPath, `${JSON.stringify({
+  await writeFile8(metaPath, committed, "utf8");
+  await writeFile8(cacheMdPath, input.brief, "utf8");
+  await writeFile8(cacheJsonPath, `${JSON.stringify({
     project: input.project,
     brief: input.brief,
     word_count: input.wordCount,
@@ -2791,7 +2940,7 @@ function renderCommittedBrief(input) {
   ].filter((line) => line !== "").join("\n");
 }
 async function ensureIndexEntry(vault) {
-  const indexPath = join13(vault, "index.md");
+  const indexPath = join15(vault, "index.md");
   let text = await readIfExists(indexPath);
   if (!text) return false;
   if (text.includes("[[meta/latest-session-brief]]")) return false;
@@ -2806,21 +2955,21 @@ async function ensureIndexEntry(vault) {
     while (insertAt < lines.length && !lines[insertAt].startsWith("## ")) insertAt++;
     lines.splice(insertAt, 0, entry);
   }
-  await writeFile6(indexPath, lines.join("\n"), "utf8");
+  await writeFile8(indexPath, lines.join("\n"), "utf8");
   return true;
 }
 async function appendMaterialLog(vault, today) {
-  const logPath = join13(vault, "log.md");
+  const logPath = join15(vault, "log.md");
   const text = await readIfExists(logPath);
   if (!text) return false;
   const entry = `
 ## [${today}] session-brief | refreshed: meta/latest-session-brief.md`;
-  await writeFile6(logPath, text.trimEnd() + entry + "\n", "utf8");
+  await writeFile8(logPath, text.trimEnd() + entry + "\n", "utf8");
   return true;
 }
 async function readIfExists(path) {
   try {
-    return await readFile8(path, "utf8");
+    return await readFile10(path, "utf8");
   } catch {
     return "";
   }
@@ -2862,15 +3011,15 @@ function dateFromPath(path) {
 }
 
 // src/commands/ingest.ts
-import { readFile as readFile10, open, unlink as unlink3, mkdir as mkdir8 } from "fs/promises";
-import { join as join15 } from "path";
+import { readFile as readFile12, open, unlink as unlink4, mkdir as mkdir9 } from "fs/promises";
+import { join as join17 } from "path";
 import { createHash as createHash4 } from "crypto";
 
 // src/commands/page-publish.ts
 import { createHash as createHash3 } from "crypto";
 import { realpathSync } from "fs";
-import { readFile as readFile9 } from "fs/promises";
-import { join as join14, resolve as resolve3 } from "path";
+import { readFile as readFile11 } from "fs/promises";
+import { join as join16, resolve as resolve3 } from "path";
 var DEFAULT_DEPS = { afterStage: async () => void 0 };
 function errorExitCode(error) {
   switch (error) {
@@ -2930,7 +3079,7 @@ function preparePagePublicationFromContent(input) {
 async function preparePagePublication(input) {
   let content;
   try {
-    content = await readFile9(input.draftPath, "utf8");
+    content = await readFile11(input.draftPath, "utf8");
   } catch (error) {
     return err("FILE_NOT_FOUND", { path: input.draftPath, message: String(error) });
   }
@@ -3001,10 +3150,10 @@ async function runLockedPrimaryStages(input, vault, deps) {
       ExitCode.VAULT_PATH_INVALID
     );
   }
-  const schemaPath = join14(vault, "SCHEMA.md");
+  const schemaPath = join16(vault, "SCHEMA.md");
   let schemaText;
   try {
-    schemaText = await readFile9(schemaPath, "utf8");
+    schemaText = await readFile11(schemaPath, "utf8");
   } catch (error) {
     return lockedFailure("schema", state, err("WRITE_FAILED", { message: String(error) }));
   }
@@ -3034,8 +3183,8 @@ async function runLockedPrimaryStages(input, vault, deps) {
   let visibleSchema;
   try {
     [visible, visibleSchema] = await Promise.all([
-      readFile9(input.targetPath, "utf8"),
-      readFile9(schemaPath, "utf8")
+      readFile11(input.targetPath, "utf8"),
+      readFile11(schemaPath, "utf8")
     ]);
   } catch (error) {
     return lockedFailure("verify", state, err("WRITE_FAILED", { message: String(error) }));
@@ -3117,17 +3266,17 @@ function renderPublicationLog(input, added) {
 }
 async function readPageChanged(targetPath, content) {
   try {
-    return ok(await readFile9(targetPath, "utf8") !== content);
+    return ok(await readFile11(targetPath, "utf8") !== content);
   } catch (error) {
     if (error.code === "ENOENT") return ok(true);
     return err("WRITE_FAILED", { path: targetPath, message: String(error) });
   }
 }
 async function previewPreparedPagePublication(input, vault) {
-  const schemaPath = join14(vault, "SCHEMA.md");
+  const schemaPath = join16(vault, "SCHEMA.md");
   let schemaText;
   try {
-    schemaText = await readFile9(schemaPath, "utf8");
+    schemaText = await readFile11(schemaPath, "utf8");
   } catch (error) {
     const result = err("FILE_NOT_FOUND", { path: schemaPath, message: String(error) });
     return { exitCode: ExitCode.FILE_NOT_FOUND, result };
@@ -3139,10 +3288,10 @@ async function previewPreparedPagePublication(input, vault) {
   if (!reconciled.ok) return { exitCode: errorExitCode(reconciled.error), result: reconciled };
   const pageChanged = await readPageChanged(input.targetPath, input.page.content);
   if (!pageChanged.ok) return { exitCode: errorExitCode(pageChanged.error), result: pageChanged };
-  const indexPath = join14(vault, "index.md");
+  const indexPath = join16(vault, "index.md");
   let indexText;
   try {
-    indexText = await readFile9(indexPath, "utf8");
+    indexText = await readFile11(indexPath, "utf8");
   } catch (error) {
     const result = err("FILE_NOT_FOUND", { path: indexPath, message: String(error) });
     return { exitCode: ExitCode.FILE_NOT_FOUND, result };
@@ -3153,10 +3302,10 @@ async function previewPreparedPagePublication(input, vault) {
     type: input.page.type
   });
   if (!index.ok) return { exitCode: errorExitCode(index.error), result: index };
-  const logPath = join14(vault, "log.md");
+  const logPath = join16(vault, "log.md");
   let logText;
   try {
-    logText = await readFile9(logPath, "utf8");
+    logText = await readFile11(logPath, "utf8");
   } catch (error) {
     const result = err("FILE_NOT_FOUND", { path: logPath, message: String(error) });
     return { exitCode: ExitCode.FILE_NOT_FOUND, result };
@@ -3352,7 +3501,7 @@ function buildTypedContent(title, ingested, type, tags, rawRelPath, provenance)
 }
 async function resolveRawCapture(input) {
   try {
-    const existing = await readFile10(input.path, "utf8");
+    const existing = await readFile12(input.path, "utf8");
     const frontmatter = extractFrontmatter(existing);
     if (!frontmatter.ok) {
       return err("INGEST_VALIDATION_FAILED", {
@@ -3401,7 +3550,7 @@ async function writeResolvedRaw(input) {
     return written.ok ? ok({ changed: written.data.changed, capture: resolved.data }) : written;
   } finally {
     try {
-      await unlink3(lock.data);
+      await unlink4(lock.data);
     } catch {
     }
   }
@@ -3491,7 +3640,7 @@ async function runIngest(input) {
     sourceContent = fetchResult.data.body;
   } else {
     try {
-      sourceContent = await readFile10(input.source, "utf8");
+      sourceContent = await readFile12(input.source, "utf8");
     } catch {
       return {
         exitCode: ExitCode.FILE_NOT_FOUND,
@@ -3516,7 +3665,7 @@ async function runIngest(input) {
   const rawRelPath = `raw/articles/${slug}.md`;
   const typedDir = TYPE_DIR[input.type] ?? `${input.type}s`;
   const typedRelPath = `${typedDir}/${slug}.md`;
-  const rawAbsPath = join15(input.vault, rawRelPath);
+  const rawAbsPath = join17(input.vault, rawRelPath);
   const identity = assessSourceIdentity({
     rawPath: rawRelPath,
     sourceUrl: sourceUrl ?? void 0,
@@ -3560,11 +3709,11 @@ async function runIngest(input) {
   );
   if (!input.dryRun) {
     try {
-      await mkdir8(join15(input.vault, typedDir), { recursive: true });
+      await mkdir9(join17(input.vault, typedDir), { recursive: true });
     } catch (error) {
       return {
         exitCode: ExitCode.WRITE_FAILED,
-        result: err("WRITE_FAILED", { path: join15(input.vault, typedDir), message: String(error) })
+        result: err("WRITE_FAILED", { path: join17(input.vault, typedDir), message: String(error) })
       };
     }
   }
@@ -3611,11 +3760,11 @@ async function runIngest(input) {
     };
   }
   try {
-    await mkdir8(join15(input.vault, "raw", "articles"), { recursive: true });
+    await mkdir9(join17(input.vault, "raw", "articles"), { recursive: true });
   } catch (error) {
     return {
       exitCode: ExitCode.WRITE_FAILED,
-      result: err("WRITE_FAILED", { path: join15(input.vault, "raw", "articles"), message: String(error) })
+      result: err("WRITE_FAILED", { path: join17(input.vault, "raw", "articles"), message: String(error) })
     };
   }
   const rawWrite = await writeResolvedRaw({
@@ -3843,8 +3992,8 @@ ${body}`;
 }
 
 // src/commands/tag-reconcile.ts
-import { readFile as readFile11 } from "fs/promises";
-import { join as join16, posix } from "path";
+import { readFile as readFile13 } from "fs/promises";
+import { join as join18, posix } from "path";
 var TYPED_TARGET_RE = /^(entities|concepts|comparisons|queries|meta)\/[a-z0-9][a-z0-9./_-]*\.md$/;
 function errorExitCode2(error) {
   switch (error) {
@@ -3887,7 +4036,7 @@ function asTagArray(frontmatter, path) {
 async function readTagsFromFile(path) {
   let text;
   try {
-    text = await readFile11(path, "utf8");
+    text = await readFile13(path, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") {
       return { exitCode: ExitCode.FILE_NOT_FOUND, result: err("FILE_NOT_FOUND", { path }) };
@@ -3908,7 +4057,7 @@ async function resolveRequestedTags(input, page) {
       result: err("INVALID_FRONTMATTER", { message: "explicit tags must be an array of strings" })
     };
   }
-  const source = input.from ?? (explicit.length === 0 ? join16(input.vault, page) : void 0);
+  const source = input.from ?? (explicit.length === 0 ? join18(input.vault, page) : void 0);
   if (!source) return { exitCode: ExitCode.OK, result: ok({ tags: [...new Set(explicit)].sort() }) };
   const sourced = await readTagsFromFile(source);
   if (!sourced.result.ok) return { exitCode: sourced.exitCode, result: sourced.result };
@@ -3919,7 +4068,7 @@ async function resolveRequestedTags(input, page) {
 }
 async function readSchema(schemaPath) {
   try {
-    return { exitCode: ExitCode.OK, result: ok(await readFile11(schemaPath, "utf8")) };
+    return { exitCode: ExitCode.OK, result: ok(await readFile13(schemaPath, "utf8")) };
   } catch (error) {
     if (error.code === "ENOENT") {
       return { exitCode: ExitCode.FILE_NOT_FOUND, result: err("FILE_NOT_FOUND", { path: schemaPath }) };
@@ -3947,7 +4096,7 @@ function previewResult(page, tags, reconciled, dryRun, filesChanged) {
   };
 }
 async function reconcileTagsWhileLocked(input, page, tags, comment) {
-  const schemaPath = join16(input.vault, "SCHEMA.md");
+  const schemaPath = join18(input.vault, "SCHEMA.md");
   const current = await readSchema(schemaPath);
   if (!current.result.ok) return { exitCode: current.exitCode, result: current.result };
   const next = reconcileTaxonomyDocument(current.result.data, { tags, comment });
@@ -3958,7 +4107,7 @@ async function reconcileTagsWhileLocked(input, page, tags, comment) {
   }
   let verifiedText;
   try {
-    verifiedText = await readFile11(schemaPath, "utf8");
+    verifiedText = await readFile13(schemaPath, "utf8");
   } catch (error) {
     return {
       exitCode: ExitCode.WRITE_FAILED,
@@ -3984,7 +4133,7 @@ async function runTagReconcile(input) {
   const comment = taxonomyCommentForPage(page.data, date, input.reason);
   if (!comment.ok) return { exitCode: ExitCode.SCHEME_REJECTED, result: comment };
   if (!input.write) {
-    const schema = await readSchema(join16(input.vault, "SCHEMA.md"));
+    const schema = await readSchema(join18(input.vault, "SCHEMA.md"));
     if (!schema.result.ok) return { exitCode: schema.exitCode, result: schema.result };
     const preview = reconcileTaxonomyDocument(schema.result.data, { tags, comment: comment.data });
     return previewResult(page.data, tags, preview, true, []);
@@ -4037,7 +4186,7 @@ async function runTagReconcile(input) {
 
 // src/commands/sync.ts
 import { existsSync as existsSync5 } from "fs";
-import { join as join17 } from "path";
+import { join as join19 } from "path";
 import { execFileSync as execFileSync2 } from "child_process";
 
 // src/utils/git.ts
@@ -4104,7 +4253,7 @@ function refHasPath(vault, ref, path) {
 function runSyncStatus(input) {
   const vault = input.vault;
   const includeStashes = input.includeStashes ?? false;
-  if (!existsSync5(join17(vault, ".git"))) {
+  if (!existsSync5(join19(vault, ".git"))) {
     return {
       exitCode: ExitCode.VAULT_PATH_INVALID,
       result: ok({
@@ -4211,7 +4360,7 @@ function runSyncStatus(input) {
 }
 async function runSyncPush(input) {
   const vault = input.vault;
-  if (!existsSync5(join17(vault, ".git"))) {
+  if (!existsSync5(join19(vault, ".git"))) {
     return {
       exitCode: ExitCode.VAULT_PATH_INVALID,
       result: err("NOT_A_GIT_REPO", { path: vault })
@@ -4371,7 +4520,7 @@ function enableGitLongPathsOnWindows(vault) {
 }
 async function runSyncPull(input) {
   const vault = input.vault;
-  if (!existsSync5(join17(vault, ".git"))) {
+  if (!existsSync5(join19(vault, ".git"))) {
     return {
       exitCode: ExitCode.VAULT_PATH_INVALID,
       result: err("NOT_A_GIT_REPO", { path: vault })
@@ -4612,7 +4761,7 @@ function runSyncUnlock(input) {
 
 // src/commands/backup.ts
 import { statSync as statSync2, readdirSync, readFileSync as readFileSync4, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join18, relative as relative2, dirname as dirname6 } from "path";
+import { join as join20, relative as relative2, dirname as dirname6 } from "path";
 import { PutObjectCommand, HeadObjectCommand, ListObjectsV2Command, GetObjectCommand, DeleteObjectsCommand } from "@aws-sdk/client-s3";
 
 // src/utils/s3-client.ts
@@ -4636,7 +4785,7 @@ var SKIP_DIRS = /* @__PURE__ */ new Set([".git", ".obsidian", "_archive", "node_
 function* walkMarkdown(dir, base) {
   for (const entry of readdirSync(dir, { withFileTypes: true })) {
     if (SKIP_DIRS.has(entry.name)) continue;
-    const full = join18(dir, entry.name);
+    const full = join20(dir, entry.name);
     if (entry.isDirectory()) {
       yield* walkMarkdown(full, base);
     } else if (entry.name.endsWith(".md")) {
@@ -4659,7 +4808,7 @@ async function runBackupSync(input) {
   let failed = 0;
   const files = [...walkMarkdown(input.vault, input.vault)];
   for (const relPath of files) {
-    const absPath = join18(input.vault, relPath);
+    const absPath = join20(input.vault, relPath);
     const localStat = statSync2(absPath);
     let needsUpload = true;
     try {
@@ -4735,7 +4884,7 @@ async function runBackupRestore(input) {
     const objects = list.Contents ?? [];
     for (const obj of objects) {
       if (!obj.Key) continue;
-      const localPath = join18(target, obj.Key);
+      const localPath = join20(target, obj.Key);
       try {
         const localStat = statSync2(localPath);
         if (obj.LastModified && localStat.mtime > obj.LastModified) {
@@ -4782,8 +4931,8 @@ async function runBackupRestore(input) {
 
 // src/commands/status.ts
 import { existsSync as existsSync6, statSync as statSync3 } from "fs";
-import { readFile as readFile12 } from "fs/promises";
-import { join as join19 } from "path";
+import { readFile as readFile14 } from "fs/promises";
+import { join as join21 } from "path";
 async function runStatus(input) {
   if (!existsSync6(input.vault)) {
     return { exitCode: ExitCode.VAULT_PATH_INVALID, result: err("VAULT_PATH_INVALID", { vault: input.vault }) };
@@ -4810,7 +4959,7 @@ async function runStatus(input) {
   const compound = scan.data.compound.length;
   let schemaVersion = "v1";
   try {
-    const schemaContent = await readFile12(join19(input.vault, "SCHEMA.md"), "utf8");
+    const schemaContent = await readFile14(join21(input.vault, "SCHEMA.md"), "utf8");
     const versionMatch = schemaContent.match(/version:\s*["']?([^"'\s\n]+)/i);
     if (versionMatch) schemaVersion = versionMatch[1];
   } catch {
@@ -4870,8 +5019,8 @@ async function runStatus(input) {
 }
 
 // src/commands/seed.ts
-import { mkdir as mkdir9, writeFile as writeFile7, stat as stat4 } from "fs/promises";
-import { join as join20 } from "path";
+import { mkdir as mkdir10, writeFile as writeFile9, stat as stat4 } from "fs/promises";
+import { join as join22 } from "path";
 var TODAY = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
 var EXAMPLE_PAGES = {
   "entities/example-project.md": `---
@@ -4940,30 +5089,30 @@ Real sources are immutable after ingestion \u2014 never edit them.
 `;
 async function runSeed(input) {
   try {
-    await stat4(join20(input.vault, "SCHEMA.md"));
+    await stat4(join22(input.vault, "SCHEMA.md"));
   } catch {
     return { exitCode: ExitCode.VAULT_PATH_INVALID, result: err("VAULT_PATH_INVALID", { root: input.vault, reason: "SCHEMA.md missing \u2014 run `skillwiki init` first" }) };
   }
   const created = [];
   const skipped = [];
   for (const [relPath, content] of Object.entries(EXAMPLE_PAGES)) {
-    const absPath = join20(input.vault, relPath);
+    const absPath = join22(input.vault, relPath);
     try {
       await stat4(absPath);
       skipped.push(relPath);
     } catch {
-      await mkdir9(join20(absPath, ".."), { recursive: true });
-      await writeFile7(absPath, content, "utf8");
+      await mkdir10(join22(absPath, ".."), { recursive: true });
+      await writeFile9(absPath, content, "utf8");
       created.push(relPath);
     }
   }
-  const rawPath = join20(input.vault, "raw", "articles", "example-source.md");
+  const rawPath = join22(input.vault, "raw", "articles", "example-source.md");
   try {
     await stat4(rawPath);
     skipped.push("raw/articles/example-source.md");
   } catch {
-    await mkdir9(join20(rawPath, ".."), { recursive: true });
-    await writeFile7(rawPath, EXAMPLE_RAW, "utf8");
+    await mkdir10(join22(rawPath, ".."), { recursive: true });
+    await writeFile9(rawPath, EXAMPLE_RAW, "utf8");
     created.push("raw/articles/example-source.md");
   }
   if (created.length > 0) {
@@ -4985,9 +5134,9 @@ async function runSeed(input) {
 }
 
 // src/commands/canvas.ts
-import { readFile as readFile13, writeFile as writeFile8 } from "fs/promises";
+import { readFile as readFile15, writeFile as writeFile10 } from "fs/promises";
 import { existsSync as existsSync7 } from "fs";
-import { join as join21 } from "path";
+import { join as join23 } from "path";
 var NODE_WIDTH = 240;
 var NODE_HEIGHT = 60;
 var COLUMN_SPACING = 400;
@@ -5065,7 +5214,7 @@ function buildCanvasEdges(adjacency) {
   return edges;
 }
 async function runCanvasGenerate(input) {
-  const graphPath = input.graphPath ?? join21(input.vault, ".skillwiki", "graph.json");
+  const graphPath = input.graphPath ?? join23(input.vault, ".skillwiki", "graph.json");
   if (!existsSync7(graphPath)) {
     return {
       exitCode: ExitCode.FILE_NOT_FOUND,
@@ -5077,7 +5226,7 @@ async function runCanvasGenerate(input) {
   }
   let raw;
   try {
-    raw = await readFile13(graphPath, "utf8");
+    raw = await readFile15(graphPath, "utf8");
   } catch (e) {
     return {
       exitCode: ExitCode.FILE_NOT_FOUND,
@@ -5103,9 +5252,9 @@ async function runCanvasGenerate(input) {
   const nodes = buildCanvasNodes(paths);
   const edges = buildCanvasEdges(graph.adjacency);
   const canvas = { nodes, edges };
-  const outPath = join21(input.vault, "vault-graph.canvas");
+  const outPath = join23(input.vault, "vault-graph.canvas");
   try {
-    await writeFile8(outPath, JSON.stringify(canvas, null, 2));
+    await writeFile10(outPath, JSON.stringify(canvas, null, 2));
   } catch (e) {
     return {
       exitCode: ExitCode.WRITE_FAILED,
@@ -5128,7 +5277,7 @@ written: ${outPath}`
 import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
 import { execSync as nodeExecSync } from "child_process";
 import { hostname as nodeHostname, platform as nodePlatform } from "os";
-import { join as join22 } from "path";
+import { join as join24 } from "path";
 var SSH_TIMEOUT_MS = 15e3;
 var TIMER_UNIT = "agent-memory-trends.timer";
 var SERVICE_UNIT = "agent-memory-trends.service";
@@ -5358,7 +5507,7 @@ async function runFleetHealth(input) {
   const home = input.home ?? env.HOME ?? "";
   const osHostname = input.osHostname ?? env.HOSTNAME ?? nodeHostname();
   const vault = input.vault ?? env.WIKI_PATH;
-  const file = input.file ?? (vault ? join22(vault, FLEET_REL_PATH) : void 0);
+  const file = input.file ?? (vault ? join24(vault, FLEET_REL_PATH) : void 0);
   if (!file) {
     return {
       exitCode: ExitCode.NO_VAULT_CONFIGURED,
@@ -5443,14 +5592,14 @@ async function runFleetHealth(input) {
 
 // src/utils/auto-commit.ts
 import { existsSync as existsSync9 } from "fs";
-import { join as join23 } from "path";
+import { join as join25 } from "path";
 async function postCommit(vault, exitCode) {
   if (exitCode !== 0) return;
   const home = process.env.HOME ?? "";
   const dotenv = await parseDotenvFile(configPath(home));
   const autoCommit = process.env.AUTO_COMMIT ?? dotenv["AUTO_COMMIT"];
   if (autoCommit === "false") return;
-  if (!existsSync9(join23(vault, ".git"))) return;
+  if (!existsSync9(join25(vault, ".git"))) return;
   const lastOps = readLastOp(vault);
   if (lastOps.length === 0) return;
   const porcelain = git(vault, ["status", "--porcelain", "--", ...VAULT_COMMIT_PATHSPEC]);
@@ -5475,7 +5624,7 @@ async function postCommit(vault, exitCode) {
 
 // src/utils/protected-vault-write-guard.ts
 import { readFileSync as readFileSync6 } from "fs";
-import { join as join24, resolve as resolvePath } from "path";
+import { join as join26, resolve as resolvePath } from "path";
 async function guardProtectedVaultWrite(input) {
   const env = input.env ?? process.env;
   const home = input.home ?? process.env.HOME ?? "";
@@ -5541,7 +5690,7 @@ async function resolveLiveVaultPath(input) {
   return resolved.ok ? resolved.data.path : void 0;
 }
 function resolveSnapshotWorktree(home) {
-  const skillwikiEnv = join24(home, ".skillwiki", ".env");
+  const skillwikiEnv = join26(home, ".skillwiki", ".env");
   const explicitWorktree = readEnvKey(skillwikiEnv, ["vault_sync.snapshot_worktree"]);
   if (explicitWorktree) return explicitWorktree;
   const snapshotProfile = readEnvKey(skillwikiEnv, ["vault_sync.snapshot_profile"]);
@@ -5611,7 +5760,7 @@ program.command("validate <file>").description("validate vault page frontmatter
   emit(await runValidate({ file, apply: !!opts.apply, vault }), vault);
 });
 program.command("graph").description("graph subcommands").command("build <vault>").option("--out <path>", "graph output path (default: <vault>/.skillwiki/graph.json)").option("--wiki <name>", "wiki profile name").action(async (vault, opts) => {
-  const out = opts.out ?? join25(vault, ".skillwiki", "graph.json");
+  const out = opts.out ?? join27(vault, ".skillwiki", "graph.json");
   return emitGuardedVaultWrite(vault, "graph build", () => runGraphBuild({ vault, out }));
 });
 var canvasCmd = program.command("canvas").description("manage Obsidian canvas files");
@@ -5910,6 +6059,22 @@ program.command("archive <page> [vault]").description("archive a typed-knowledge
     })
   );
 });
+program.command("remove <page> [vault]").description("remove a vault path and write a delete-intent tombstone").option("--wiki <name>", "wiki profile name").option("--remote <remote>", "rclone remote root to prune the live path, for example seaweed-wiki:cloud/wiki").option("--remote-delete", "delete the live path from the remote after local remove", false).option("--max-remote-deletes <n>", "maximum remote object deletes allowed", "1").option("--reason <text>", "stored on the delete-intent tombstone").action(async (page, vault, opts) => {
+  const v = await resolveVaultArg(vault, opts.wiki);
+  if (!v.ok) emit({ exitCode: v.exitCode, result: v.payload });
+  else return emitGuardedVaultWrite(
+    v.vault,
+    "remove",
+    () => runRemove({
+      vault: v.vault,
+      page,
+      remote: opts.remote,
+      remoteDelete: !!opts.remoteDelete,
+      maxRemoteDeletes: Number.parseInt(opts.maxRemoteDeletes, 10),
+      reason: opts.reason
+    })
+  );
+});
 program.command("drift [vault]").description("detect content drift in raw sources").option("--apply", "update sha256 in drifted sources").option("--new <date>", "list raw files ingested on/after this date (YYYY-MM-DD)").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 });