rigjs 4.0.13 → 4.0.15

package/lib/wiki/index.ts

@@ -1,6 +1,7 @@
 import wikiInit from './init';
 import wikiScan from './scan';
 import wikiSurvey from './survey';
+import wikiSync from './sync';
 import wikiFetch from './fetch';
 import wikiIngest from './ingest';
 import wikiQuery from './query';
@@ -20,8 +21,8 @@ import { registerDaemonCommands } from './daemon';
 export function registerWikiCommands(program: any): void {
   const wiki = program.command('wiki').description('Karpathy-style LLM Wiki ops (macOS only in v1)');
 
-  wiki.command('init <scope>')
-    .description('bootstrap a vault scoped to <scope>/ — an existing data subdir of the project. Metadata is auto-created at ./rig-wiki/.')
+  wiki.command('init [scope]')
+    .description('bootstrap a vault under ./rig-wiki/. With no <scope>, the vault covers the whole CWD; with <scope>, only that subdir is scanned. Hidden/.gitignored/binary files are filtered at walk time regardless.')
     .action(wikiInit);
 
   wiki.command('scan')
@@ -38,6 +39,13 @@ export function registerWikiCommands(program: any): void {
     .option('--json', 'machine-readable output')
     .action(wikiSurvey);
 
+  wiki.command('sync')
+    .description('one-shot wiki update: scan → ingest NEW + MODIFIED → prune wiki pages for DELETED sources')
+    .option('--dry-run', 'print scan diff and what would change without writing anything')
+    .option('--no-prune', 'skip the delete step (only ingest NEW + MODIFIED)')
+    .option('--json', 'machine-readable output')
+    .action(wikiSync);
+
   wiki.command('fetch <url>')
     .description('verbatim download URL into raw/YYYY-MM-DD-<slug>.md')
     .option('--slug <slug>', 'override the auto-derived slug')

package/lib/wiki/indexCmd.ts

@@ -7,7 +7,7 @@ interface IndexOpts { force?: boolean; }
 export default async function wikiIndex(opts: IndexOpts): Promise<void> {
   const t = requireVault();
   print.start(`qmd embed: ${t.name}`);
-  const res = await qmdEmbed(t.name, t.path, { force: !!opts.force });
+  const res = await qmdEmbed(t.name, t.path, t.root, { force: !!opts.force });
   if (res.ok) print.succeed(`qmd embed: ${t.name} done`);
   else {
     print.error(`qmd embed: ${t.name} failed: ${res.stderr.trim()}`);

package/lib/wiki/ingest.ts

@@ -112,7 +112,7 @@ export default async function wikiIngest(source: string, opts: IngestOpts): Prom
 
   // Real ingest — trigger incremental embed.
   print.info(`applied ${applied.length} file change${applied.length === 1 ? '' : 's'}; rejected ${rejected.length}.`);
-  const embedRes = await qmdEmbed(target.name, target.path);
+  const embedRes = await qmdEmbed(target.name, target.path, target.root);
   if (!embedRes.ok) {
     print.warn(`qmd embed failed after ingest: ${embedRes.stderr.trim().slice(0, 300)}`);
     print.warn('your wiki content is committed to disk; only the vector index is stale.');

package/lib/wiki/init.ts

@@ -109,10 +109,7 @@ cases.
 const SUBDIRS = ['sources', 'entities', 'concepts', 'synthesis', 'queries'];
 
 const GITIGNORE_TMPL = `# rig wiki — local-only artifacts (do not commit)
-# qmd vector cache (sqlite-vec, machine-specific, rebuildable)
-.qmd/index.sqlite*
-.qmd/*.sqlite-wal
-.qmd/*.sqlite-shm
+# (vector cache lives outside the vault at ~/.rig/<project>/wiki/)
 # auto-generated reports
 lint-report-*.md
 # daemon proposal queue (per-machine)
@@ -154,28 +151,30 @@ function defaultVaultConfig(scope: string, rootRel: string): VaultConfig {
 }
 
 export default function wikiInit(scope?: string): void {
-  if (!scope || !scope.trim()) {
-    print.error('rig wiki init requires a scope.');
-    print.info('usage: rig wiki init <scope>     (e.g. `rig wiki init personal` to ingest from ./personal/)');
-    print.info(`<scope> is an existing data subdir of the project. Vault metadata is auto-created at ./${VAULT_DIRNAME}/.`);
-    process.exit(1);
-  }
-
   const cwd = process.cwd();
   const vaultDir = path.join(cwd, VAULT_DIRNAME);
-  const scopeAbs = path.resolve(cwd, scope);
 
-  // The scope must already exist — pointing the wiki at a missing dir would
-  // hide what is almost certainly a typo.
-  if (!fs.existsSync(scopeAbs) || !fs.statSync(scopeAbs).isDirectory()) {
-    print.error(`scope dir not found: ${scope}`);
-    print.info(`expected an existing data subdir at ${shortPath(scopeAbs)}`);
-    process.exit(1);
-  }
-  // The scope can't be (or contain) the vault dir itself.
-  if (scopeAbs === vaultDir || vaultDir.startsWith(scopeAbs + path.sep)) {
-    print.error(`scope cannot be or contain the vault dir (${VAULT_DIRNAME}/).`);
-    process.exit(1);
+  // No-arg form: scope = the whole project (CWD). Vault scans up one level
+  // from `<CWD>/rig-wiki/` to reach CWD. Wiki name defaults to basename(CWD).
+  // Hidden segments, binary extensions, and .gitignored files are filtered
+  // by scan/survey at walk time — no scope restriction needed.
+  const hasScope = !!(scope && scope.trim());
+  const scopeAbs = hasScope ? path.resolve(cwd, scope!) : cwd;
+  const scopeName = hasScope ? scope!.trim() : path.basename(cwd);
+
+  if (hasScope) {
+    // The explicit scope must already exist — pointing the wiki at a missing
+    // dir would hide what is almost certainly a typo.
+    if (!fs.existsSync(scopeAbs) || !fs.statSync(scopeAbs).isDirectory()) {
+      print.error(`scope dir not found: ${scope}`);
+      print.info(`expected an existing data subdir at ${shortPath(scopeAbs)}`);
+      process.exit(1);
+    }
+    // The scope can't be (or contain) the vault dir itself.
+    if (scopeAbs === vaultDir || vaultDir.startsWith(scopeAbs + path.sep)) {
+      print.error(`scope cannot be or contain the vault dir (${VAULT_DIRNAME}/).`);
+      process.exit(1);
+    }
   }
 
   const guard = guardPath(vaultDir, cwd);
@@ -189,6 +188,7 @@ export default function wikiInit(scope?: string): void {
   // If the vault already has a config, it must already be scoped to the
   // same data dir — otherwise the user is trying to re-target an existing
   // vault, which we won't do silently. Manual config edit only.
+  // No-arg init resolves to the CWD itself, which equals `path.dirname(vaultDir)`.
   const cfgFile = vaultConfigPath(vaultDir);
   if (fs.existsSync(cfgFile)) {
     const existing = loadVaultConfig(vaultDir);
@@ -222,12 +222,13 @@ export default function wikiInit(scope?: string): void {
 
   if (!fs.existsSync(cfgFile)) {
     const rootRel = path.relative(vaultDir, scopeAbs);
-    saveVaultConfig(vaultDir, defaultVaultConfig(scope, rootRel));
+    saveVaultConfig(vaultDir, defaultVaultConfig(scopeName, rootRel));
   }
 
-  print.succeed(`vault initialized at ${shortPath(vaultDir)} (scope: ${scope})`);
+  const scopeLabel = hasScope ? `scope: ${scope}` : `scope: <project-wide, name "${scopeName}">`;
+  print.succeed(`vault initialized at ${shortPath(vaultDir)} (${scopeLabel})`);
   print.info(`next: edit ${shortPath(path.join(vaultDir, 'purpose.md'))} to describe what this wiki is for.`);
-  print.info(`then run \`rig wiki scan\` from anywhere inside ${shortPath(cwd)} to see what will be ingested.`);
+  print.info(`then run \`rig wiki sync\` from anywhere inside ${shortPath(cwd)} to ingest, update, and prune in one shot.`);
 }
 
 function writeIfMissing(file: string, content: string) {

package/lib/wiki/prune.ts

@@ -0,0 +1,145 @@
+// Prune wiki pages whose underlying source file has been deleted from the
+// scan root. Triggered by `rig wiki sync` (and exposed as a helper for
+// `rig wiki prune` if/when we add a standalone command).
+//
+// Three actions per deleted source path:
+//
+//   1. Delete `sources/<slug>.md` whose `source-path:` frontmatter resolves
+//      to the deleted file. The slug = basename of that wiki source page.
+//
+//   2. Scrub the deleted slug from every derived page's `sources: [...]`
+//      frontmatter array (entities/concepts/synthesis/queries). Pages that
+//      end up with an empty `sources: []` are left in place for `rig wiki
+//      lint` to surface as orphans — we don't auto-delete derived pages
+//      since they may carry the user's intellectual content distinct from
+//      any single source.
+//
+//   3. Drop the row from `state.db.source_sha` so future scans don't keep
+//      reporting the file as DELETED.
+
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+import { WikiEntry } from './config';
+import { deleteSourceSha } from './db';
+
+const DERIVED_DIRS = ['entities', 'concepts', 'synthesis', 'queries'];
+
+export interface PruneReport {
+  /** wiki-relative paths of source pages deleted */
+  deletedSourcePages: string[];
+  /** wiki-relative paths of derived pages whose sources[] lost the dropped slug */
+  scrubbedDerivedPages: string[];
+  /** root-relative paths of source_sha rows dropped */
+  shaRowsDropped: string[];
+}
+
+export function pruneDeletedSources(target: WikiEntry, deletedRelPaths: string[]): PruneReport {
+  const report: PruneReport = { deletedSourcePages: [], scrubbedDerivedPages: [], shaRowsDropped: [] };
+  if (deletedRelPaths.length === 0) return report;
+
+  const deletedSet = new Set(deletedRelPaths.map(normalizePath));
+  const sourcesDir = path.join(target.path, 'sources');
+  const droppedSlugs = new Set<string>();
+
+  // 1. sources/<slug>.md whose `source-path:` points at a deleted file
+  if (fs.existsSync(sourcesDir)) {
+    for (const file of fs.readdirSync(sourcesDir)) {
+      if (!file.endsWith('.md') || file === '.gitkeep') continue;
+      const abs = path.join(sourcesDir, file);
+      const fm = readFrontmatter(abs);
+      if (!fm) continue;
+      const rel = extractSourcePathRel(String(fm['source-path'] || ''));
+      if (rel && deletedSet.has(rel)) {
+        fs.rmSync(abs, { force: true });
+        report.deletedSourcePages.push(path.relative(target.path, abs));
+        droppedSlugs.add(path.basename(file, '.md'));
+      }
+    }
+  }
+
+  // 2. derived pages — strip dropped slugs from `sources: [...]`
+  if (droppedSlugs.size > 0) {
+    for (const sub of DERIVED_DIRS) {
+      const dir = path.join(target.path, sub);
+      if (!fs.existsSync(dir)) continue;
+      for (const file of fs.readdirSync(dir)) {
+        if (!file.endsWith('.md') || file === '.gitkeep') continue;
+        const abs = path.join(dir, file);
+        const content = fs.readFileSync(abs, 'utf8');
+        const next = scrubSlugsFromSourcesArray(content, droppedSlugs);
+        if (next !== content) {
+          fs.writeFileSync(abs, next, 'utf8');
+          report.scrubbedDerivedPages.push(path.relative(target.path, abs));
+        }
+      }
+    }
+  }
+
+  // 3. state.db cleanup
+  for (const p of deletedRelPaths) {
+    deleteSourceSha(target.name, p);
+    report.shaRowsDropped.push(p);
+  }
+
+  return report;
+}
+
+// ─── helpers ────────────────────────────────────────────────────────────
+
+function normalizePath(p: string): string {
+  return p.replace(/\\/g, '/');
+}
+
+function readFrontmatter(file: string): Record<string, unknown> | null {
+  let content: string;
+  try { content = fs.readFileSync(file, 'utf8'); } catch { return null; }
+  if (!content.startsWith('---\n')) return null;
+  const end = content.indexOf('\n---', 4);
+  if (end < 0) return null;
+  try {
+    const parsed = yaml.load(content.slice(4, end));
+    return parsed && typeof parsed === 'object' ? parsed as Record<string, unknown> : null;
+  } catch { return null; }
+}
+
+/**
+ * `source-path` can be:
+ *   - an obsidian:// URL:  `obsidian://open?vault=name&file=<encoded-path>`
+ *   - a plain root-relative path: `personal/work/foo.md`
+ * Returns the underlying root-relative path, or null if we can't extract one.
+ */
+function extractSourcePathRel(srcPath: string): string | null {
+  if (!srcPath) return null;
+  const m = srcPath.match(/[?&]file=([^&]+)/);
+  if (m) {
+    try { return normalizePath(decodeURIComponent(m[1])); }
+    catch { return normalizePath(m[1]); }
+  }
+  return normalizePath(srcPath);
+}
+
+/**
+ * Surgically rewrites the `sources: [a, b, c]` frontmatter line, removing
+ * any entries that appear in `slugs`. Leaves the rest of the frontmatter
+ * and body untouched. If no match, returns the content unchanged.
+ */
+function scrubSlugsFromSourcesArray(content: string, slugs: Set<string>): string {
+  if (!content.startsWith('---\n')) return content;
+  const end = content.indexOf('\n---', 4);
+  if (end < 0) return content;
+  const fm = content.slice(4, end);
+  const after = content.slice(end);
+
+  const m = fm.match(/^([ \t]*sources[ \t]*:[ \t]*)\[(.*?)\]/m);
+  if (!m) return content;
+
+  const items = m[2]
+    .split(',')
+    .map(s => s.trim().replace(/^['"]|['"]$/g, ''))
+    .filter(s => s && !slugs.has(s));
+
+  const newSources = `${m[1]}[${items.map(s => `'${s}'`).join(', ')}]`;
+  const newFm = fm.replace(m[0], newSources);
+  return '---\n' + newFm + after;
+}

package/lib/wiki/qmd.ts

@@ -9,8 +9,13 @@
 //   - Embed: Qwen3-Embedding-0.6B   (~610MB, sets QMD_EMBED_MODEL)
 //   - Rerank: Qwen3-Reranker-0.6B   (~610MB, sets QMD_RERANK_MODEL)
 //
-// Per-wiki SQLite DB lives at `~/.rig/cache/qmd/<wiki>.sqlite`. Model GGUFs
-// cache in `~/.cache/qmd/models/` (hardcoded inside qmd).
+// Per-wiki SQLite DB lives at `~/.rig/<project>/wiki/<wiki>.sqlite`, where
+// `<project>` is the `name` from the nearest `package.json` walking up from
+// the vault root (fallback: vault-root basename). The extra `wiki/` segment
+// reserves room for other per-project rig artifacts as siblings. Legacy
+// `~/.rig/cache/qmd/<wiki>.sqlite` is migrated lazily on first open.
+//
+// Model GGUFs still cache in `~/.cache/qmd/models/` (hardcoded inside qmd).
 //
 // Concurrency note: qmd's `setConfigSource` is module-global; serialize
 // store lifetimes by opening + closing inside each call.
@@ -71,10 +76,58 @@ function qmdVersion(): string {
   return 'unknown';
 }
 
-function dbPathFor(wikiName: string): string {
-  const dir = path.join(paths.cache, 'qmd');
+/**
+ * Resolve the project name for a vault: read the `name` field from the
+ * nearest `package.json` walking up from `vaultRoot`. Falls back to
+ * `basename(vaultRoot)` if no package.json with a usable name is found.
+ * Scoped names (`@scope/foo`) are flattened to `scope_foo`.
+ */
+function resolveProjectName(vaultRoot: string): string {
+  let dir = path.resolve(vaultRoot);
+  while (true) {
+    const pkg = path.join(dir, 'package.json');
+    if (fs.existsSync(pkg)) {
+      try {
+        const parsed = JSON.parse(fs.readFileSync(pkg, 'utf8'));
+        if (typeof parsed.name === 'string' && parsed.name.trim()) {
+          return sanitizeSegment(parsed.name.trim());
+        }
+      } catch { /* malformed package.json — keep walking */ }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return sanitizeSegment(path.basename(vaultRoot)) || 'unknown';
+}
+
+function sanitizeSegment(s: string): string {
+  // npm scoped names use `/`; flatten so we don't create unintended nesting.
+  // Also defang filesystem-hostile chars and leading dots.
+  return s
+    .replace(/^@/, '')
+    .replace(/[/\\]/g, '_')
+    .replace(/[<>:"|?*\x00-\x1f]/g, '_')
+    .replace(/^\.+/, '');
+}
+
+function dbPathFor(wikiName: string, vaultRoot: string): string {
+  const projectName = resolveProjectName(vaultRoot);
+  const dir = path.join(paths.home, projectName, 'wiki');
   fs.mkdirSync(dir, { recursive: true });
-  return path.join(dir, `${wikiName}.sqlite`);
+  const target = path.join(dir, `${wikiName}.sqlite`);
+  // One-shot migration from the legacy flat layout.
+  const legacy = path.join(paths.cache, 'qmd', `${wikiName}.sqlite`);
+  if (!fs.existsSync(target) && fs.existsSync(legacy)) {
+    for (const suffix of ['', '-wal', '-shm']) {
+      const src = legacy + suffix;
+      if (fs.existsSync(src)) {
+        try { fs.renameSync(src, target + suffix); }
+        catch { /* cross-device? leave the legacy file in place */ }
+      }
+    }
+  }
+  return target;
 }
 
 async function loadQmd(): Promise<{ createStore: any }> {
@@ -90,12 +143,13 @@ async function loadQmd(): Promise<{ createStore: any }> {
 export async function qmdEmbed(
   wikiName: string,
   dir: string,
+  vaultRoot: string,
   opts: { force?: boolean } = {}
 ): Promise<{ ok: boolean; stderr: string }> {
   try {
     const { createStore } = await loadQmd();
     const store = await createStore({
-      dbPath: dbPathFor(wikiName),
+      dbPath: dbPathFor(wikiName, vaultRoot),
       config: {
         collections: { [wikiName]: { path: dir, pattern: '**/*.md' } },
       },
@@ -134,6 +188,7 @@ export interface QmdHit {
 export async function qmdQuery(
   q: string,
   wikiName: string,
+  vaultRoot: string,
   opts: { limit?: number; candidateLimit?: number; rerank?: boolean } = {}
 ): Promise<QmdHit[] | null> {
   const limit = opts.limit ?? 10;
@@ -142,7 +197,7 @@ export async function qmdQuery(
 
   try {
     const { createStore } = await loadQmd();
-    const store = await createStore({ dbPath: dbPathFor(wikiName) });
+    const store = await createStore({ dbPath: dbPathFor(wikiName, vaultRoot) });
     try {
       const raw = await store.searchVector(q, { limit: candidateLimit, collection: wikiName });
       const candidates: QmdHit[] = Array.isArray(raw) ? raw.map(normalizeHit) : [];
@@ -191,8 +246,8 @@ function normalizeHit(h: any): QmdHit {
 }
 
 /** Wipe the per-wiki SQLite store on disk. Caller should then qmdEmbed. */
-export function qmdResetStore(wikiName: string): void {
-  const p = dbPathFor(wikiName);
+export function qmdResetStore(wikiName: string, vaultRoot: string): void {
+  const p = dbPathFor(wikiName, vaultRoot);
   for (const suffix of ['', '-wal', '-shm']) {
     const f = p + suffix;
     if (fs.existsSync(f)) fs.rmSync(f, { force: true });

package/lib/wiki/query.ts

@@ -30,7 +30,7 @@ export default async function wikiQuery(q: string, opts: QueryOpts): Promise<voi
   const target = requireVault();
 
   const limit = Math.max(1, Math.min(50, opts.limit || 10));
-  const hits = await qmdQuery(q, target.name, { limit, rerank: opts.rerank !== false });
+  const hits = await qmdQuery(q, target.name, target.root, { limit, rerank: opts.rerank !== false });
   if (hits === null) {
     print.error('qmd query failed. Run `rig wiki index` first to (re)build the vector store.');
     process.exit(1);

package/lib/wiki/rebuild.ts

@@ -2,7 +2,7 @@
 //
 // Use cases:
 //   1. New device: source markdown is checked out, but ~/.rig/state.db and
-//      ~/.rig/cache/qmd/<wiki>.sqlite are empty. Rebuild populates both.
+//      ~/.rig/<project>/wiki/<wiki>.sqlite are empty. Rebuild populates both.
 //   2. Switched embedding model: old vectors are now meaningless. Rebuild
 //      re-embeds against the current QMD_EMBED_MODEL.
 //   3. Local cache corruption: nuke and start over.
@@ -27,10 +27,10 @@ export default async function wikiRebuild(opts: RebuildOpts): Promise<void> {
   const del = db.prepare('DELETE FROM source_sha WHERE wiki = ?').run(t.name);
   print.info(`  cleared ${del.changes} source_sha rows for ${t.name}`);
 
-  qmdResetStore(t.name);
+  qmdResetStore(t.name, t.root);
 
   if (!opts.skipEmbed) {
-    const res = await qmdEmbed(t.name, t.path, { force: true });
+    const res = await qmdEmbed(t.name, t.path, t.root, { force: true });
     if (res.ok) print.info(`  qmd embed: ${t.name} done`);
     else {
       print.error(`  qmd embed: ${t.name} failed: ${res.stderr.trim()}`);

package/lib/wiki/sync.ts

@@ -0,0 +1,111 @@
+// `rig wiki sync` — one-shot wiki update.
+//
+//   1. scan: compute NEW / MODIFIED / DELETED against state.db.source_sha
+//      (hidden + .gitignored + binary-extension filters apply at walk time,
+//      and the gitignore check is multi-repo-aware so git submodules are
+//      respected — see `lib/wiki/gitignore.ts`).
+//   2. ingest each NEW + MODIFIED source via the existing `wikiIngest`
+//      code path. Sequential so Claude doesn't double-write the same wiki
+//      page from concurrent runs, and so token spend is bounded.
+//   3. prune the wiki pages whose underlying source files have been
+//      deleted: removes `sources/<slug>.md`, strips that slug from derived
+//      pages' `sources: [...]` frontmatter, drops the source_sha row.
+//
+// RAW DRIFT (a `raw/` file's bytes changed in place) is surfaced as an
+// error — we do NOT try to "fix" it via re-ingest. raw/ is immutable by
+// design; drift means something else (a copy-on-write filesystem,
+// accidental edit, etc.) and the user needs to look.
+
+import path from 'path';
+import print from '../print';
+import { requireVault } from './config';
+import { recordLastRun } from './db';
+import { scanOne, ScanReport } from './scan';
+import { pruneDeletedSources, PruneReport } from './prune';
+import { default as wikiIngest } from './ingest';
+
+interface SyncOpts {
+  json?: boolean;
+  dryRun?: boolean;
+  noPrune?: boolean;
+}
+
+export default async function wikiSync(opts: SyncOpts): Promise<void> {
+  const target = requireVault();
+
+  // Step 1: scan. We don't baseline yet — ingest+prune are the ground truth
+  // for what gets recorded, and baselining before would mark unprocessed
+  // files as "known" prematurely.
+  const scan: ScanReport = scanOne(target, false);
+
+  if (scan.rawDrift.length > 0) {
+    print.error(`RAW DRIFT detected — ${scan.rawDrift.length} file(s) in raw/ changed. raw/ is immutable; resolve manually before syncing.`);
+    for (const p of scan.rawDrift) {
+      // eslint-disable-next-line no-console
+      console.log(`  ${p}`);
+    }
+    recordLastRun(target.name, 'sync', 10);
+    process.exit(10);
+  }
+
+  const toIngest = [...scan.new, ...scan.modified];
+  print.info(`sync: ${target.name}  NEW ${scan.new.length}  MODIFIED ${scan.modified.length}  DELETED ${scan.deleted.length}  UNCHANGED ${scan.unchanged}`);
+
+  // Step 2: ingest NEW + MODIFIED (one Claude call per file).
+  let ingestOk = 0, ingestFail = 0;
+  for (const rel of toIngest) {
+    const abs = path.resolve(target.root, rel);
+    print.start(`ingest ${rel}`);
+    try {
+      await wikiIngest(abs, { dryRun: !!opts.dryRun });
+      ingestOk++;
+    } catch (e) {
+      ingestFail++;
+      print.error(`ingest ${rel} failed: ${(e as Error).message}`);
+    }
+  }
+
+  // Step 3: prune DELETED unless --no-prune / --dry-run.
+  let prune: PruneReport = { deletedSourcePages: [], scrubbedDerivedPages: [], shaRowsDropped: [] };
+  if (scan.deleted.length > 0 && !opts.noPrune && !opts.dryRun) {
+    prune = pruneDeletedSources(target, scan.deleted);
+  }
+
+  // Step 4: report.
+  if (opts.json) {
+    // eslint-disable-next-line no-console
+    console.log(JSON.stringify({
+      ok: ingestFail === 0,
+      code: ingestFail === 0 ? 0 : 1,
+      data: {
+        wiki: target.name,
+        scan,
+        ingested: { ok: ingestOk, failed: ingestFail },
+        pruned: prune,
+        dryRun: !!opts.dryRun,
+      },
+    }, null, 2));
+  } else {
+    print.succeed(`sync: ingested ${ingestOk} ok, ${ingestFail} failed.`);
+    if (prune.deletedSourcePages.length > 0) {
+      print.info(`pruned ${prune.deletedSourcePages.length} source page(s):`);
+      for (const p of prune.deletedSourcePages) {
+        // eslint-disable-next-line no-console
+        console.log(`  − ${p}`);
+      }
+    }
+    if (prune.scrubbedDerivedPages.length > 0) {
+      print.info(`scrubbed deleted-source refs from ${prune.scrubbedDerivedPages.length} derived page(s):`);
+      for (const p of prune.scrubbedDerivedPages) {
+        // eslint-disable-next-line no-console
+        console.log(`  ~ ${p}`);
+      }
+    }
+    if (opts.dryRun && scan.deleted.length > 0) {
+      print.info(`dry-run: ${scan.deleted.length} delete(s) NOT applied. Re-run without --dry-run to prune.`);
+    }
+  }
+
+  recordLastRun(target.name, 'sync', ingestFail === 0 ? 0 : 1);
+  if (ingestFail > 0) process.exit(1);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rigjs",
-  "version": "4.0.13",
-  "versionCode": 26052419,
+  "version": "4.0.15",
+  "versionCode": 26052422,
   "description": "A multi-repos dev tool based on yarn and git.Rigjs is intended to be the simplest way to develop,share and deliver codes between different developers or different projects.",
   "keywords": [
     "modular",