rigjs 4.0.7 → 4.0.10

package/lib/wiki/ingest.ts

@@ -18,7 +18,7 @@ import crypto from 'crypto';
 import print from '../print';
 import { requireVault, loadRigConfig, WikiEntry } from './config';
 import { paths } from './paths';
-import { recordLastRun } from './db';
+import { recordLastRun, upsertSourceSha } from './db';
 import { qmdEmbed } from './qmd';
 import { adapters } from './agent/registry';
 import { guardPath, refusalMessage } from './pathGuard';
@@ -118,6 +118,18 @@ export default async function wikiIngest(source: string, opts: IngestOpts): Prom
     print.warn('your wiki content is committed to disk; only the vector index is stale.');
   }
 
+  // Baseline this source into state.db.source_sha so future `rig wiki scan`
+  // can detect MODIFIED on this exact file. Key by root-relative path to
+  // match what scan uses for lookups.
+  try {
+    const stat = fs.statSync(absSource);
+    const sha = crypto.createHash('sha256').update(fs.readFileSync(absSource)).digest('hex');
+    const relFromRoot = path.relative(target.root, absSource);
+    upsertSourceSha(target.name, relFromRoot, sha, stat.mtimeMs);
+  } catch (e) {
+    print.warn(`source_sha upsert failed: ${(e as Error).message}. Future scans may misreport this file as NEW.`);
+  }
+
   if (opts.json) {
     // eslint-disable-next-line no-console
     console.log(JSON.stringify({ ok: true, code: 0, data: { source: relSource, applied, rejected } }, null, 2));
@@ -223,21 +235,43 @@ function appendLog(wiki: WikiEntry, relSource: string, applied: string[], dryRun
 // ----------------------------------------------------------------------
 
 function buildPrompt(wiki: WikiEntry, sourceAbs: string): string {
-  const sourceRel = path.relative(wiki.path, sourceAbs);
   const sourceSha = crypto.createHash('sha256').update(fs.readFileSync(sourceAbs)).digest('hex');
   const today = new Date().toISOString();
 
+  // The Obsidian vault root is the parent of the rig-wiki/ metadata dir.
+  // The Obsidian vault NAME defaults to that dir's basename. All source-path
+  // references in generated pages use obsidian:// URLs so that links survive
+  // moves of the wiki dir and are clickable from inside Obsidian.
+  const obsidianRoot = path.dirname(wiki.path);
+  const obsidianVaultName = path.basename(obsidianRoot);
+  const sourceFromObsidianRoot = path.relative(obsidianRoot, sourceAbs);
+  const sourceObsidianUrl = obsidianUrl(obsidianVaultName, sourceFromObsidianRoot);
+  const ext = path.extname(sourceAbs).toLowerCase();
+  const isImage = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp'].includes(ext);
+  const isPdf = ext === '.pdf';
+  const isSpreadsheet = ['.xlsx', '.xls', '.ods', '.numbers'].includes(ext);
+
   return [
     `You are running INGEST for the rig wiki at \`${wiki.path}\`.`,
+    `This wiki lives inside an Obsidian vault rooted at \`${obsidianRoot}\` (Obsidian vault name: "${obsidianVaultName}").`,
+    `Use obsidian:// URLs — never raw file paths — to reference sources or any file in the vault.`,
+    ``,
+    `Source for this ingest: ${sourceObsidianUrl}`,
+    `Source filesystem path (for your Read tool only): ${sourceAbs}`,
     ``,
     `Step 1 — ANALYSIS (do NOT write files yet):`,
-    `  - Read \`purpose.md\`, \`schema.md\`, \`overview.md\`, \`index.md\`.`,
-    `  - Read the source: \`${sourceRel}\`.`,
+    `  - Read \`purpose.md\`, \`schema.md\`, \`overview.md\`, \`index.md\` from the wiki.`,
+    `  - Read the source. Notes by type:`,
+    `      · text / markdown / json / code → use the Read tool normally`,
+    isImage ? `      · this source is an IMAGE (${ext}) — Read it; you'll receive it as a visual input. Describe what's depicted, plus any visible text / numbers / structures.` : '',
+    isPdf ? `      · this source is a PDF — Read it; if it is >10 pages, read in chunks with the \`pages\` parameter.` : '',
+    isSpreadsheet ? `      · this source is a SPREADSHEET (${ext}) — the Read tool does NOT natively decode spreadsheets in v1. Try Read first; if it fails, write a stub source page with the obsidian:// link + filename + last-modified date, and append a \`reviews.md\` bullet asking the user to export it as CSV / JSON for re-ingest. Do NOT invent contents.` : '',
     `  - In your head, list: entities mentioned, concepts touched, contradictions vs existing pages, items that need human review.`,
     ``,
     `Step 2 — GENERATION (write files):`,
-    `  - Create \`sources/<slug>.md\` summarizing this source. \`<slug>\` = source basename minus YYYY-MM-DD prefix and extension, kebab-case.`,
-    `  - For each new or affected entity / concept / synthesis page, create or UPDATE the corresponding file under \`entities/\`, \`concepts/\`, \`synthesis/\` (at the vault root — there is no \`wiki/\` subdir).`,
+    `  - Write the source summary to \`sources/<slug>.md\`. \`<slug>\` = source basename minus YYYY-MM-DD prefix and extension, kebab-case.`,
+    `  - **If \`sources/<slug>.md\` already exists, UPDATE IT IN PLACE.** Do NOT create a sibling like \`<slug>-2.md\` or \`<slug>-updated.md\`. Re-ingest of the same source MUST overwrite its existing source page so any [[wikilinks]] pointing at \`[[<slug>]]\` keep working. Refresh \`last-updated\` and \`source-sha\` in the frontmatter; preserve \`ingested-at\` (the original first-ingest timestamp).`,
+    `  - For each new or affected entity / concept / synthesis page, create or UPDATE the corresponding file under \`entities/\`, \`concepts/\`, \`synthesis/\` (at the vault root — there is no \`wiki/\` subdir). Same in-place rule: never create \`-2.md\` siblings.`,
     `  - Update \`index.md\` and \`overview.md\` to reflect the new content.`,
     `  - If anything is unclear or contradictory, append a bullet to \`reviews.md\`. Do NOT silently merge contradictions.`,
     ``,
@@ -251,16 +285,26 @@ function buildPrompt(wiki: WikiEntry, sourceAbs: string): string {
     `Source pages additionally need:`,
     '```yaml',
     `source-sha: ${sourceSha}`,
-    `source-path: ${sourceRel}`,
+    `source-path: ${sourceObsidianUrl}`,
     '```',
     ``,
+    `Reference rules — IMPORTANT:`,
+    `  - To reference the original source file inside markdown body, use the obsidian:// URL: ${sourceObsidianUrl}`,
+    `  - To reference OTHER files in the same Obsidian vault, build URLs the same way: \`obsidian://open?vault=${obsidianVaultName}&file=<vault-relative-path>\`. URL-encode spaces / specials with encodeURI, keep forward slashes.`,
+    `  - To reference other wiki pages, use [[wikilink]] (slug only).`,
+    ``,
     `Hard rules — the host will REJECT any patch that violates these:`,
     `  - DO NOT modify \`raw/\`, \`purpose.md\`, or \`schema.md\`.`,
     `  - Use kebab-case slugs; no spaces; no date prefixes in page filenames.`,
-    `  - Link related pages with [[wikilink]]. Every wiki page should link to ≥1 other page.`,
+    `  - Every wiki page should link to ≥1 other page (via [[wikilink]] or obsidian:// URL).`,
     `  - For contradictions, write inline: \`> Contradiction: A vs B (see [[page-A]], [[page-B]])\`.`,
     ``,
     `Output: stdout is for status only. All content goes to files via the Write/Edit tools.`,
     `When done, print a single line: \`INGEST DONE: <slug>\`.`,
-  ].join('\n');
+  ].filter(Boolean).join('\n');
+}
+
+/** Build an Obsidian URL. encodeURI preserves `/`, encodes spaces and Unicode. */
+function obsidianUrl(vaultName: string, fileRel: string): string {
+  return `obsidian://open?vault=${encodeURIComponent(vaultName)}&file=${encodeURI(fileRel)}`;
 }

package/lib/wiki/init.ts

@@ -76,6 +76,34 @@ const SCHEMA_TMPL = `# Schema
 - never edit raw/, purpose.md, schema.md
 - raw/ file sha drift = error, not a re-ingest trigger
 - living-doc paths (in include[]) sha drift = MODIFIED, propose re-ingest
+
+## Ingestion policy
+
+This section is consumed by \`rig wiki survey\` to decide which files under
+the scan root are eligible to ingest. Edit the "Custom rules" subsection
+to add wiki-specific filters; the default rules below cover the obvious
+cases.
+
+### Default — INGESTIBLE
+- markdown / plain text: \`.md\` \`.markdown\` \`.txt\` \`.rst\`
+- documents: \`.pdf\` (Claude reads natively)
+- images of receipts / whiteboards / diagrams: \`.png\` \`.jpg\` \`.jpeg\` \`.webp\` \`.gif\`
+- structured text: \`.csv\` \`.tsv\` \`.json\` \`.yaml\` \`.yml\` \`.toml\` \`.html\` \`.xml\`
+
+### Default — NOT INGESTIBLE
+- compressed archives: \`.zip\` \`.tar\` \`.tar.gz\` \`.tgz\` \`.gz\` \`.bz2\` \`.xz\` \`.7z\` \`.rar\` \`.dmg\` \`.iso\`
+- binaries / native: \`.exe\` \`.dll\` \`.so\` \`.dylib\` \`.bin\` \`.o\` \`.a\` \`.lib\` \`.class\` \`.jar\` \`.pyc\` \`.node\` \`.wasm\`
+- AV: \`.mp4\` \`.mov\` \`.mkv\` \`.avi\` \`.webm\` \`.mp3\` \`.wav\` \`.flac\` \`.aac\` \`.ogg\`
+- design / proprietary: \`.psd\` \`.ai\` \`.fig\` \`.sketch\` \`.fla\` \`.indd\`
+- lockfiles + build artifacts: \`yarn.lock\` \`package-lock.json\` \`pnpm-lock.yaml\` \`*.lock\` \`*.min.js\` \`*.map\`
+- model weights / embeddings: \`.gguf\` \`.safetensors\` \`.bin\` \`.pt\` \`.onnx\` \`.h5\` \`.pkl\`
+- anything in hidden dirs (segment starts with \`.\`) or .gitignored — refused by the path guard
+
+### Custom rules (edit me)
+
+- (e.g.) skip files in \`personal/work/archive/\`
+- (e.g.) only English-language content
+- (e.g.) skip files larger than 5MB
 `;
 
 const SUBDIRS = ['sources', 'entities', 'concepts', 'synthesis', 'queries'];
@@ -98,17 +126,30 @@ proposals/
  * Defaults for a freshly-scoped vault. The user can edit
  * `<vault>/.rig/config.yml` afterwards.
  *
- * Hidden directories (segments starting with `.`) and `.gitignore`'d files
- * are skipped automatically by the scanner — no need to list them here.
+ * `include` defaults to `**` (everything) — rig wiki is multimodal: Claude
+ * Read tool handles markdown / code / json natively, images and PDFs are
+ * read as visual / document inputs. The user can tighten this per-vault.
+ *
+ * `exclude` defaults to common binary-archive extensions whose contents
+ * can't be ingested without unpacking. Hidden directories (segments starting
+ * with `.`) and `.gitignore`'d files are skipped automatically by the
+ * scanner — no need to list them.
  */
 function defaultVaultConfig(scope: string, rootRel: string): VaultConfig {
   return {
     name: scope,
     root: rootRel,
-    include: ['**/*.md'],
-    exclude: [],
+    include: ['**'],
+    exclude: [
+      '*.zip', '**/*.zip',
+      '*.tar', '**/*.tar',
+      '*.tar.gz', '**/*.tar.gz',
+      '*.tgz', '**/*.tgz',
+      '*.7z', '**/*.7z',
+      '*.rar', '**/*.rar',
+    ],
     schedule: { scan: '0 */6 * * *', lint: '0 3 * * *', ingest: null },
-    ingestRules: [{ match: 'raw/**/*.md', mode: 'auto-on-new' }],
+    ingestRules: [{ match: 'raw/**/*.*', mode: 'auto-on-new' }],
   };
 }
 

package/lib/wiki/survey.ts

@@ -0,0 +1,300 @@
+// `rig wiki survey` — schema-driven ingestion candidate triage.
+//
+// Walks the vault's scan root, skips obvious non-sources (hidden /
+// gitignored / binary extensions), then asks the configured agent
+// (Claude by default) to classify each remaining candidate against the
+// wiki's schema.md "Ingestion policy" section.
+//
+// Output:
+//   - default: human-readable table  path | decision | reason
+//   - --json:  { ok, code, data: { wiki, decisions: [{path, decision, reason}] } }
+//
+// --apply iterates over `decision === 'ingest'` and runs the same code
+// path as `rig wiki ingest <path>` for each, in series.
+
+import fs from 'fs';
+import path from 'path';
+import { spawnSync } from 'child_process';
+import print from '../print';
+import { requireVault, loadRigConfig, WikiEntry } from './config';
+import { isBinaryExtension } from './fileTypes';
+import { adapters } from './agent/registry';
+import { default as wikiIngest } from './ingest';
+
+interface SurveyOpts {
+  apply?: boolean;
+  json?: boolean;
+  limit?: number;       // cap candidates passed to the agent (cost/latency safety)
+  noAgent?: boolean;    // skip Claude classification — local rules only
+}
+
+type Decision = 'ingest' | 'skip' | 'unclear';
+
+interface SurveyRow {
+  path: string;          // root-relative
+  decision: Decision;
+  reason: string;
+  size: number;
+}
+
+const DEFAULT_LIMIT = 500;
+const AGENT_TIMEOUT_MS = 5 * 60 * 1000;
+
+export default async function wikiSurvey(opts: SurveyOpts): Promise<void> {
+  const target = requireVault();
+  const candidates = collectCandidates(target);
+
+  if (candidates.length === 0) {
+    print.info('no candidates under scan root.');
+    return;
+  }
+
+  const limit = Math.max(1, opts.limit ?? DEFAULT_LIMIT);
+  if (candidates.length > limit) {
+    print.warn(`${candidates.length} candidates found; capping to first ${limit}. Pass --limit <n> to override.`);
+  }
+  const truncated = candidates.slice(0, limit);
+
+  // Classify
+  let rows: SurveyRow[];
+  if (opts.noAgent) {
+    rows = truncated.map(c => ({ path: c.rel, decision: 'ingest' as Decision, reason: 'no-agent mode — accepts every non-binary candidate', size: c.size }));
+  } else {
+    rows = await classifyWithAgent(target, truncated);
+  }
+
+  if (opts.json) {
+    // eslint-disable-next-line no-console
+    console.log(JSON.stringify({
+      ok: true, code: 0,
+      data: { wiki: target.name, decisions: rows },
+    }, null, 2));
+  } else {
+    printTable(target, rows);
+  }
+
+  if (opts.apply) await applyIngest(target, rows);
+}
+
+interface Candidate { abs: string; rel: string; size: number; }
+
+function collectCandidates(entry: WikiEntry): Candidate[] {
+  const out: Candidate[] = [];
+  const root = entry.root;
+  const vaultRel = path.relative(root, entry.path) || path.basename(entry.path);
+  const stack = [root];
+  while (stack.length) {
+    const cur = stack.pop()!;
+    let entries: fs.Dirent[];
+    try { entries = fs.readdirSync(cur, { withFileTypes: true }); } catch { continue; }
+    for (const e of entries) {
+      if (e.name.startsWith('.')) continue;
+      const full = path.join(cur, e.name);
+      const rel = path.relative(root, full);
+      // Skip the vault dir itself (we don't ingest our own wiki pages)
+      if (rel === vaultRel || rel.startsWith(vaultRel + path.sep)) continue;
+      // Skip node_modules unconditionally — never useful as wiki sources
+      if (e.name === 'node_modules') continue;
+      if (e.isDirectory()) {
+        stack.push(full);
+      } else if (e.isFile() && !isBinaryExtension(full)) {
+        try {
+          const stat = fs.statSync(full);
+          out.push({ abs: full, rel, size: stat.size });
+        } catch { /* unreadable — skip */ }
+      }
+    }
+  }
+  // Gitignore filter via batch `git check-ignore --stdin -z` (best-effort,
+  // silent fallback outside a git repo)
+  const ignored = batchGitignored(root, out.map(c => c.abs));
+  return out.filter(c => !ignored.has(c.abs));
+}
+
+function batchGitignored(root: string, abs: string[]): Set<string> {
+  const ignored = new Set<string>();
+  if (abs.length === 0) return ignored;
+  const r = spawnSync('git', ['check-ignore', '--stdin', '-z'], {
+    cwd: root,
+    input: Buffer.from(abs.join('\0') + '\0'),
+  });
+  if (r.status === 128 || !r.stdout || r.stdout.length === 0) return ignored;
+  const lines = Buffer.isBuffer(r.stdout)
+    ? r.stdout.toString('utf8').split('\0')
+    : String(r.stdout).split('\0');
+  for (const line of lines) if (line) ignored.add(path.resolve(root, line));
+  return ignored;
+}
+
+async function classifyWithAgent(target: WikiEntry, candidates: Candidate[]): Promise<SurveyRow[]> {
+  const rig = loadRigConfig();
+  const which = rig.wiki?.defaultAgent || 'claude';
+  const adapter = adapters.find(a => a.name === which);
+  const detect = adapter ? await adapter.detect() : { installed: false };
+  if (!adapter || !detect.installed) {
+    print.warn(`${which} not available — falling back to local rules (every non-binary candidate accepted).`);
+    return candidates.map(c => ({ path: c.rel, decision: 'ingest', reason: `local-rules (${which} unavailable)`, size: c.size }));
+  }
+
+  const policy = readPolicySection(target);
+  const prompt = buildPrompt(policy, candidates);
+
+  print.start(`${which} survey (${candidates.length} candidates)`);
+  const res = await adapter.run({
+    prompt,
+    cwd: target.path,
+    allowWrite: false,
+    tools: [],
+    timeoutMs: AGENT_TIMEOUT_MS,
+  });
+
+  if (!res.ok) {
+    print.warn(`${which} survey failed (code ${res.exitCode}) — falling back to local rules.`);
+    return candidates.map(c => ({ path: c.rel, decision: 'unclear', reason: 'agent-failed', size: c.size }));
+  }
+
+  const parsed = parseJsonDecisions(res.stdout, candidates);
+  if (!parsed) {
+    print.warn(`could not parse ${which}'s JSON response — falling back.`);
+    return candidates.map(c => ({ path: c.rel, decision: 'unclear', reason: 'parse-failed', size: c.size }));
+  }
+  return parsed;
+}
+
+function readPolicySection(target: WikiEntry): string {
+  const schemaPath = path.join(target.path, 'schema.md');
+  let body = '';
+  try { body = fs.readFileSync(schemaPath, 'utf8'); } catch { /* missing schema — use empty policy */ }
+  // Extract the "## Ingestion policy" section to end-of-file or next H2.
+  const m = body.match(/##\s+Ingestion policy[\s\S]*?(?=\n##\s|\n$|$)/i);
+  if (m) return m[0];
+  // Fallback: hand-rolled default if the schema doesn't have the section.
+  return [
+    '## Ingestion policy (default — schema.md has no explicit section)',
+    'Ingest: markdown, plain text, PDF, images of documents/receipts,',
+    'structured text (csv/json/yaml). Skip: archives, binaries, AV, design,',
+    'model weights, lockfiles, anything under hidden/gitignored paths.',
+  ].join('\n');
+}
+
+function buildPrompt(policy: string, candidates: Candidate[]): string {
+  const list = candidates
+    .map((c, i) => `${i + 1}. ${c.rel}  (${humanSize(c.size)})`)
+    .join('\n');
+  return [
+    `You are triaging files for a rig wiki ingestion run.`,
+    ``,
+    `Below is the wiki's ingestion policy (extracted from schema.md):`,
+    ``,
+    `\`\`\``,
+    policy.trim(),
+    `\`\`\``,
+    ``,
+    `Below is the list of candidate files (already filtered for hidden /`,
+    `gitignored / known-binary extensions). For each candidate, decide:`,
+    ``,
+    `  - "ingest"  — matches the policy, should become a wiki source`,
+    `  - "skip"    — should not be ingested per the policy`,
+    `  - "unclear" — needs a human look (e.g. ambiguous filename)`,
+    ``,
+    `Output ONE JSON array. Each element MUST be:`,
+    ``,
+    `  {"i": <1-based-index>, "decision": "ingest"|"skip"|"unclear", "reason": "<≤80 chars>"}`,
+    ``,
+    `Output ONLY the JSON array. No prose, no markdown fences.`,
+    ``,
+    `Candidates:`,
+    list,
+  ].join('\n');
+}
+
+function parseJsonDecisions(stdout: string, candidates: Candidate[]): SurveyRow[] | null {
+  if (!stdout) return null;
+  // Find the first '[' and last ']' to handle stray prose from the model.
+  const start = stdout.indexOf('[');
+  const end = stdout.lastIndexOf(']');
+  if (start < 0 || end <= start) return null;
+  let parsed: unknown;
+  try { parsed = JSON.parse(stdout.slice(start, end + 1)); } catch { return null; }
+  if (!Array.isArray(parsed)) return null;
+
+  const byIndex = new Map<number, { decision: Decision; reason: string }>();
+  for (const item of parsed) {
+    if (!item || typeof item !== 'object') continue;
+    const o = item as Record<string, unknown>;
+    const i = typeof o.i === 'number' ? o.i : NaN;
+    const d = typeof o.decision === 'string' ? o.decision.toLowerCase() : '';
+    if (!isFinite(i) || (d !== 'ingest' && d !== 'skip' && d !== 'unclear')) continue;
+    byIndex.set(i, { decision: d as Decision, reason: typeof o.reason === 'string' ? o.reason : '' });
+  }
+
+  return candidates.map((c, idx) => {
+    const r = byIndex.get(idx + 1);
+    return r
+      ? { path: c.rel, decision: r.decision, reason: r.reason, size: c.size }
+      : { path: c.rel, decision: 'unclear', reason: 'no-decision-from-agent', size: c.size };
+  });
+}
+
+function printTable(target: WikiEntry, rows: SurveyRow[]): void {
+  print.info(`survey: ${target.name}  (${rows.length} candidate${rows.length === 1 ? '' : 's'})`);
+  const counts = rows.reduce((acc, r) => { acc[r.decision] = (acc[r.decision] || 0) + 1; return acc; }, {} as Record<string, number>);
+  // eslint-disable-next-line no-console
+  console.log(`  ingest ${counts.ingest || 0}   skip ${counts.skip || 0}   unclear ${counts.unclear || 0}\n`);
+
+  const widths = {
+    decision: 7,
+    path: Math.min(60, Math.max(4, ...rows.map(r => r.path.length))),
+    size: Math.max(4, ...rows.map(r => humanSize(r.size).length)),
+  };
+  // eslint-disable-next-line no-console
+  console.log(`  ${'DECISION'.padEnd(widths.decision)}  ${'SIZE'.padStart(widths.size)}  PATH`);
+  // eslint-disable-next-line no-console
+  console.log(`  ${'-'.repeat(widths.decision)}  ${'-'.repeat(widths.size)}  ${'-'.repeat(widths.path)}`);
+  for (const r of rows) {
+    // eslint-disable-next-line no-console
+    console.log(`  ${r.decision.padEnd(widths.decision)}  ${humanSize(r.size).padStart(widths.size)}  ${r.path}`);
+    if (r.decision !== 'ingest' && r.reason) {
+      // eslint-disable-next-line no-console
+      console.log(`  ${''.padEnd(widths.decision)}  ${''.padStart(widths.size)}    ↳ ${r.reason}`);
+    }
+  }
+  // eslint-disable-next-line no-console
+  console.log('');
+  if (!counts.ingest) {
+    print.info(`nothing tagged "ingest". Edit schema.md's "Ingestion policy" if this is wrong.`);
+  } else {
+    print.info(`re-run with --apply to ingest the ${counts.ingest} "ingest" candidate${counts.ingest === 1 ? '' : 's'}.`);
+  }
+}
+
+async function applyIngest(target: WikiEntry, rows: SurveyRow[]): Promise<void> {
+  const targets = rows.filter(r => r.decision === 'ingest');
+  if (targets.length === 0) {
+    print.info('nothing to apply (no "ingest" decisions).');
+    return;
+  }
+  print.info(`applying ${targets.length} ingest${targets.length === 1 ? '' : 's'} (in series)…`);
+  let okCount = 0, failCount = 0;
+  for (const r of targets) {
+    const absSource = path.resolve(target.root, r.path);
+    print.start(`ingest ${r.path}`);
+    try {
+      // wikiIngest reads CWD-resolved vault; it'll pick up the same target.
+      // It calls process.exit on error, so wrap defensively if needed.
+      await wikiIngest(absSource, { dryRun: false });
+      okCount++;
+    } catch (e) {
+      failCount++;
+      print.error(`ingest ${r.path} failed: ${(e as Error).message}`);
+    }
+  }
+  print.succeed(`survey --apply done: ${okCount} ok, ${failCount} failed.`);
+}
+
+function humanSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}K`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(1)}M`;
+  return `${(bytes / 1024 / 1024 / 1024).toFixed(1)}G`;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rigjs",
-  "version": "4.0.7",
-  "versionCode": 26052414,
+  "version": "4.0.10",
+  "versionCode": 26052415,
   "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",