rigjs 4.0.2 → 4.0.4

package/lib/wiki/README.md

@@ -13,7 +13,7 @@ Convention: **one file per subcommand**, plus a small set of shared infra files
 | `index.ts` | Commander wiring. Builds the `rig wiki` subtree and attaches every action. Imported once from `lib/rig/index.ts`. |
 | `paths.ts` | Centralized filesystem paths (`~/.rig/`, launchd plist, Claude skills dir). Override with `RIG_HOME`. Also exports the launchd label. |
 | `platform.ts` | `requireMacOS()` — hard-exits with code 32 on non-Darwin platforms. v1 is macOS-only by decision; see roadmap P5. |
-| `config.ts` | JSON5 read/write for `~/.rig/config.json5` (`RigConfig`) and `~/.rig/wiki.config.json5` (`WikiConfig`). `resolveWiki()` picks the target wiki for a command (flag → CWD walk → undefined). |
+| `config.ts` | YAML read/write for `~/.rig/config.yml` (`RigConfig`, rig-global prefs) and `~/.rig/wikis.yml` (`Registry`, discovery-only path list). Per-vault settings live at `<vault>/.rig/config.yml` (`VaultConfig`). `loadWikiConfig()` composes the registry + each vault's config into the consumer-facing `WikiEntry[]`. `resolveWiki()` picks the target wiki for a command (flag → CWD walk → undefined). |
 | `db.ts` | Lazy-loaded `better-sqlite3` singleton. WAL mode. Idempotent migrations on every open. Exposes `getDb()`, `recordLastRun()`, `getLastRun()`. |
 | `qmd.ts` | Detects `qmd` on PATH, wraps `qmd query --json` and `qmd embed`. All callers must handle `installed=false` gracefully — qmd is optional. |
 
@@ -23,9 +23,9 @@ Convention: **one file per subcommand**, plus a small set of shared infra files
 
 | File | Subcommand | What it does |
 |---|---|---|
-| `init.ts` | `rig wiki init [path]` | Bootstraps a fresh wiki dir: `purpose.md` + `schema.md` from templates, empty `index.md` / `overview.md` / `log.md` / `reviews.md`, `raw/` + five `wiki/<sub>/` dirs. Idempotent — never overwrites existing files. Does **not** register. |
-| `register.ts` | `rig wiki register [path]` | Adds (or `--force`-replaces) an entry in `~/.rig/wiki.config.json5`. Auto-detects path (`harness/llm-wiki` / `wiki`) walking up from CWD. Also writes a `wiki:` block back to the project's `package.rig.json5` for bidirectional consistency. |
-| `unregister.ts` | `rig wiki unregister <nameOrPath>` | Removes the entry. Disk wiki content is untouched. |
+| `init.ts` | `rig wiki init [path]` | Bootstraps a fresh wiki dir: `purpose.md` + `schema.md` from templates, empty `index.md` / `overview.md` / `log.md` / `reviews.md`, `raw/` + five `wiki/<sub>/` dirs, and seeds `<vault>/.rig/config.yml` with default include / exclude / schedule. Idempotent — never overwrites existing files. Does **not** register. |
+| `register.ts` | `rig wiki register [path]` | Ensures `<vault>/.rig/config.yml` exists (seeding defaults if absent), applies `--as <slug>` to its `name`, then appends the vault's absolute path to `~/.rig/wikis.yml`. Auto-detects the vault by walking up from CWD looking for `purpose.md`. |
+| `unregister.ts` | `rig wiki unregister <nameOrPath>` | Drops the vault path from `~/.rig/wikis.yml`. `<vault>/.rig/config.yml` and disk content are untouched. |
 | `list.ts` | `rig wiki list` | Prints a table: name, path, page count, last scan / ingest / lint. Banner row shows detected agent CLI, qmd status. |
 | `scan.ts` | `rig wiki scan [path]` | Walks `include` globs + `raw/`, sha256-compares against the `source_sha` table in `state.db`. Emits NEW / MODIFIED / DELETED / RAW DRIFT report. Returns exit code 10 if any RAW DRIFT (raw/ files are immutable). No agent calls. |
 | `fetch.ts` | `rig wiki fetch <url>` | (stub — P1) Agent-as-fetcher. Will WebFetch the URL via Claude adapter and write `raw/YYYY-MM-DD-<slug>.md` verbatim with frontmatter. **Never** summarizes. |
@@ -51,7 +51,7 @@ One adapter per agent CLI. Only Claude Code is implemented in v1; others are stu
 | `codex.ts` | Stub. Detection works; `run()` throws. Open questions on codex's permission flags live in `doc/architecture/agents.md §4`. |
 | `pi.ts` | Stub. Same shape as codex. Upstream CLI name not yet fixed. |
 | `list.ts` | `rig wiki agent list` — iterates `adapters`, calls `detect()`, prints a table. Marks the default agent with `*`. |
-| `use.ts` | `rig wiki agent use <name>` — writes `~/.rig/config.json5` `wiki.defaultAgent`. Rejects un-implemented adapters with exit code 20. |
+| `use.ts` | `rig wiki agent use <name>` — writes `~/.rig/config.yml` `wiki.defaultAgent`. Rejects un-implemented adapters with exit code 20. |
 
 ---
 
@@ -66,7 +66,7 @@ One adapter per agent CLI. Only Claude Code is implemented in v1; others are stu
 | `stop.ts` | `launchctl bootout` only. |
 | `status.ts` | `launchctl print gui/<uid>/<label>`, parses `state=` and `pid=`. |
 | `logs.ts` | Tails `~/.rig/logs/wiki-daemon.log` (with optional `-f`). |
-| `runner.ts` | **The launchd entry.** `launchctl` invokes `node <rigjs>/built/index.js wiki daemon runner`. v1: heartbeat-only loop that logs every 10 min and reloads `wiki.config.json5`. P2 will add cron-based scan/lint scheduling and `auto-on-new` ingest rules. |
+| `runner.ts` | **The launchd entry.** `launchctl` invokes `node <rigjs>/built/index.js wiki daemon runner`. v1: heartbeat-only loop that logs every 10 min and reloads `~/.rig/wikis.yml` + each vault's `.rig/config.yml`. P2 will add cron-based scan/lint scheduling and `auto-on-new` ingest rules. |
 
 ---
 

package/lib/wiki/config.ts

@@ -1,7 +1,20 @@
 import fs from 'fs';
 import path from 'path';
-import JSON5 from 'json5';
-import { paths } from './paths';
+import yaml from 'js-yaml';
+import { paths, vaultConfigPath } from './paths';
+
+/**
+ * Two-layer config model.
+ *
+ *   ~/.rig/config.yml       — rig-global preferences (agent / qmd / logRotate).
+ *   ~/.rig/wikis.yml        — registry: list of absolute vault paths only.
+ *   <vault>/.rig/config.yml — per-vault settings (name, include, exclude,
+ *                             schedule, ingestRules, optional scan root).
+ *
+ * A `WikiEntry` is the composed view returned to consumers (registry path
+ * + vault config + defaults). Nothing about a wiki's identity or scope lives
+ * outside the vault itself; the global registry is just a discovery list.
+ */
 
 export interface RigConfig {
   wiki?: {
@@ -11,89 +24,155 @@ export interface RigConfig {
   };
 }
 
-export interface WikiEntry {
+/** Per-vault config persisted at `<vault>/.rig/config.yml`. */
+export interface VaultConfig {
   name: string;
-  path: string;            // absolute path to wiki dir
-  project?: string;        // absolute path to project root
+  /** Scan root relative to the vault. Default: `..` (vault's parent dir). */
+  root?: string;
   include?: string[];
   exclude?: string[];
   schedule?: { scan?: string; lint?: string; ingest?: string | null };
   ingestRules?: { match: string; mode: 'auto-on-new' | 'propose-only' }[];
 }
 
+/** Global registry persisted at `~/.rig/wikis.yml`. */
+export interface Registry {
+  wikis: string[]; // absolute vault paths
+}
+
+/** Composed view used by all wiki commands. */
+export interface WikiEntry {
+  name: string;
+  /** Absolute path to the vault dir. */
+  path: string;
+  /** Absolute path to the scan root (resolved from VaultConfig.root). */
+  root: string;
+  include: string[];
+  exclude: string[];
+  schedule?: { scan?: string; lint?: string; ingest?: string | null };
+  ingestRules?: { match: string; mode: 'auto-on-new' | 'propose-only' }[];
+}
+
 export interface WikiConfig {
-  defaults?: {
-    schedule?: { scan?: string; lint?: string; ingest?: string | null };
-  };
   wikis: WikiEntry[];
 }
 
-const DEFAULT_CONFIG: RigConfig = {
+const DEFAULT_RIG_CONFIG: RigConfig = {
   wiki: { defaultAgent: 'claude', qmd: { enabled: 'auto' }, logRotateMB: 50 },
 };
 
-const DEFAULT_WIKI_CONFIG: WikiConfig = {
-  defaults: { schedule: { scan: '0 */6 * * *', lint: '0 3 * * *', ingest: null } },
-  wikis: [],
-};
+const DEFAULT_SCHEDULE = { scan: '0 */6 * * *', lint: '0 3 * * *', ingest: null };
 
-function ensureHomeDir() {
+function ensureHomeDir(): void {
   fs.mkdirSync(paths.home, { recursive: true });
   fs.mkdirSync(paths.locks, { recursive: true });
   fs.mkdirSync(paths.logs, { recursive: true });
   fs.mkdirSync(paths.cache, { recursive: true });
 }
 
-function readJson5<T>(file: string, fallback: T): T {
+function readYaml<T>(file: string, fallback: T): T {
   if (!fs.existsSync(file)) return fallback;
   try {
-    return JSON5.parse(fs.readFileSync(file, 'utf8')) as T;
+    const parsed = yaml.load(fs.readFileSync(file, 'utf8'));
+    return (parsed ?? fallback) as T;
   } catch (e: any) {
     throw new Error(`failed to parse ${file}: ${e.message}`);
   }
 }
 
-function writeJson5(file: string, data: unknown) {
-  fs.writeFileSync(file, JSON5.stringify(data, null, 2) + '\n', 'utf8');
+function writeYaml(file: string, data: unknown): void {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, yaml.dump(data, { lineWidth: 100, noRefs: true }), 'utf8');
 }
 
+// ─────────────────────────── rig-global config ───────────────────────────
+
 export function loadRigConfig(): RigConfig {
   ensureHomeDir();
-  return { ...DEFAULT_CONFIG, ...readJson5<RigConfig>(paths.config, DEFAULT_CONFIG) };
+  return { ...DEFAULT_RIG_CONFIG, ...readYaml<RigConfig>(paths.config, DEFAULT_RIG_CONFIG) };
 }
 
-export function saveRigConfig(cfg: RigConfig) {
+export function saveRigConfig(cfg: RigConfig): void {
   ensureHomeDir();
-  writeJson5(paths.config, cfg);
+  writeYaml(paths.config, cfg);
 }
 
-export function loadWikiConfig(): WikiConfig {
+// ─────────────────────────── registry (paths only) ───────────────────────
+
+export function loadRegistry(): Registry {
   ensureHomeDir();
-  const cfg = readJson5<WikiConfig>(paths.wikiConfig, DEFAULT_WIKI_CONFIG);
-  // backwards-compat: ensure wikis array exists
-  if (!Array.isArray(cfg.wikis)) cfg.wikis = [];
-  return { ...DEFAULT_WIKI_CONFIG, ...cfg };
+  const reg = readYaml<Registry>(paths.registry, { wikis: [] });
+  if (!Array.isArray(reg.wikis)) reg.wikis = [];
+  return reg;
 }
 
-export function saveWikiConfig(cfg: WikiConfig) {
+export function saveRegistry(reg: Registry): void {
   ensureHomeDir();
-  writeJson5(paths.wikiConfig, cfg);
+  writeYaml(paths.registry, { wikis: reg.wikis });
+}
+
+// ─────────────────────────── per-vault config ────────────────────────────
+
+export function loadVaultConfig(vaultDir: string): VaultConfig | null {
+  const file = vaultConfigPath(vaultDir);
+  if (!fs.existsSync(file)) return null;
+  return readYaml<VaultConfig | null>(file, null);
 }
 
-/** Find a wiki entry by name OR by absolute path. */
-export function findWiki(cfg: WikiConfig, nameOrPath: string): WikiEntry | undefined {
-  return cfg.wikis.find(w => w.name === nameOrPath || w.path === path.resolve(nameOrPath));
+export function saveVaultConfig(vaultDir: string, cfg: VaultConfig): void {
+  writeYaml(vaultConfigPath(vaultDir), cfg);
+}
+
+// ───────────────────────────── composed view ─────────────────────────────
+
+const HARDCODED_EXCLUDES = ['node_modules/**', '.git/**'];
+
+function composeEntry(vaultPath: string): WikiEntry | null {
+  const vault = loadVaultConfig(vaultPath);
+  if (!vault) return null;
+  const rootRel = vault.root ?? '..';
+  const root = path.resolve(vaultPath, rootRel);
+  const vaultBasename = path.basename(vaultPath);
+  return {
+    name: vault.name,
+    path: vaultPath,
+    root,
+    include: vault.include ?? ['**/*.md'],
+    exclude: vault.exclude ?? [`${vaultBasename}/**`, ...HARDCODED_EXCLUDES],
+    schedule: vault.schedule ?? DEFAULT_SCHEDULE,
+    ingestRules: vault.ingestRules ?? [{ match: 'raw/**/*.md', mode: 'auto-on-new' }],
+  };
+}
+
+/**
+ * Compose the list of registered wikis. Reads the registry and, for each
+ * recorded path, loads the vault's own `.rig/config.yml`. Paths whose vault
+ * config is missing or malformed are skipped silently (the user can re-run
+ * `rig wiki register <path>` to repair).
+ */
+export function loadWikiConfig(): WikiConfig {
+  const reg = loadRegistry();
+  const wikis: WikiEntry[] = [];
+  for (const p of reg.wikis) {
+    const entry = composeEntry(p);
+    if (entry) wikis.push(entry);
+  }
+  return { wikis };
 }
 
 /**
  * Resolve target wiki for a command:
- * 1. If `--wiki <name>` provided, look up by name.
- * 2. Else walk up from CWD; first match wins (by `project` or `path` prefix).
- * 3. Return undefined if nothing matches.
+ *   1. If `--wiki <name>` provided, look up by name.
+ *   2. Otherwise walk up from CWD; first match wins (by vault `path` or `root`).
+ *   3. Return undefined if nothing matches.
  */
 export function resolveWiki(cfg: WikiConfig, wikiFlag?: string): WikiEntry | undefined {
   if (wikiFlag) return cfg.wikis.find(w => w.name === wikiFlag);
   const cwd = process.cwd();
-  return cfg.wikis.find(w => cwd === w.path || cwd.startsWith(w.path + path.sep) ||
-                              (w.project && (cwd === w.project || cwd.startsWith(w.project + path.sep))));
+  return cfg.wikis.find(w =>
+    cwd === w.path ||
+    cwd.startsWith(w.path + path.sep) ||
+    cwd === w.root ||
+    cwd.startsWith(w.root + path.sep),
+  );
 }

package/lib/wiki/index.ts

@@ -27,13 +27,13 @@ export function registerWikiCommands(program: any): void {
     .action(wikiInit);
 
   wiki.command('register [path]')
-    .description('register a wiki into ~/.rig/wiki.config.json5')
+    .description('register a vault into ~/.rig/wikis.yml (settings live in <vault>/.rig/config.yml)')
     .option('-n, --as <slug>', 'override the wiki name (`--name` would clash with commander)')
     .option('-f, --force', 'overwrite an existing entry with the same name')
     .action(wikiRegister);
 
   wiki.command('unregister <nameOrPath>')
-    .description('remove a wiki from ~/.rig/wiki.config.json5 (disk untouched)')
+    .description('remove a vault from ~/.rig/wikis.yml (vault contents on disk untouched)')
     .action(wikiUnregister);
 
   wiki.command('list')

package/lib/wiki/ingest.ts

@@ -45,7 +45,7 @@ export default async function wikiIngest(source: string, opts: IngestOpts): Prom
     print.error(`source not found: ${source}`);
     process.exit(1);
   }
-  const guard = guardPath(absSource, target.project || target.path);
+  const guard = guardPath(absSource, target.root || target.path);
   if (!guard.ok) {
     print.error('refusing to ingest from a hidden or gitignored path.');
     // eslint-disable-next-line no-console

package/lib/wiki/init.ts

@@ -2,6 +2,7 @@ import fs from 'fs';
 import path from 'path';
 import print from '../print';
 import { guardPath, refusalMessage } from './pathGuard';
+import { saveVaultConfig, VaultConfig } from './config';
 
 const PURPOSE_TMPL = `# Purpose
 
@@ -75,6 +76,15 @@ proposals/
 *.swp
 `;
 
+const DEFAULT_VAULT_CONFIG = (vaultBasename: string): VaultConfig => ({
+  name: vaultBasename,
+  root: '..',
+  include: ['**/*.md'],
+  exclude: [`${vaultBasename}/**`, 'node_modules/**', '.git/**'],
+  schedule: { scan: '0 */6 * * *', lint: '0 3 * * *', ingest: null },
+  ingestRules: [{ match: 'raw/**/*.md', mode: 'auto-on-new' }],
+});
+
 export default function wikiInit(givenPath?: string): void {
   if (!givenPath || !givenPath.trim()) {
     print.error('rig wiki init requires a target subdirectory.');
@@ -109,8 +119,15 @@ export default function wikiInit(givenPath?: string): void {
     writeIfMissing(path.join(d, '.gitkeep'), '');
   }
 
+  // Seed `<vault>/.rig/config.yml` with sensible defaults. Idempotent: if the
+  // user has already authored one, leave it alone.
+  const vaultCfgFile = path.join(root, '.rig', 'config.yml');
+  if (!fs.existsSync(vaultCfgFile)) {
+    saveVaultConfig(root, DEFAULT_VAULT_CONFIG(path.basename(root)));
+  }
+
   print.succeed(`wiki initialized at ${root}`);
-  print.info(`next: edit purpose.md + schema.md, then \`rig wiki register ${shortPath(root)}\``);
+  print.info(`next: edit purpose.md + schema.md (and .rig/config.yml if scope differs from defaults), then \`rig wiki register ${shortPath(root)}\``);
   print.info('on a new device, after cloning, run `rig wiki rebuild` to refresh local caches.');
 }
 

package/lib/wiki/paths.ts

@@ -5,8 +5,8 @@ export const RIG_HOME = process.env.RIG_HOME || path.join(os.homedir(), '.rig');
 
 export const paths = {
   home: RIG_HOME,
-  config: path.join(RIG_HOME, 'config.json5'),
-  wikiConfig: path.join(RIG_HOME, 'wiki.config.json5'),
+  config: path.join(RIG_HOME, 'config.yml'),
+  registry: path.join(RIG_HOME, 'wikis.yml'),
   stateDb: path.join(RIG_HOME, 'state.db'),
   locks: path.join(RIG_HOME, 'locks'),
   logs: path.join(RIG_HOME, 'logs'),
@@ -24,6 +24,11 @@ export function wikiLogDir(wikiName: string) {
   return path.join(paths.logs, 'wikis', wikiName);
 }
 
+/** Per-vault config path: `<vault>/.rig/config.yml`. */
+export function vaultConfigPath(vaultDir: string) {
+  return path.join(vaultDir, '.rig', 'config.yml');
+}
+
 export function wikiLockFile(wikiName: string) {
   return path.join(paths.locks, `${wikiName}.lock`);
 }

package/lib/wiki/register.ts

@@ -1,58 +1,82 @@
 import fs from 'fs';
 import path from 'path';
-import JSON5 from 'json5';
 import print from '../print';
-import { loadWikiConfig, saveWikiConfig, WikiEntry } from './config';
+import {
+  loadRegistry,
+  saveRegistry,
+  loadVaultConfig,
+  saveVaultConfig,
+  VaultConfig,
+} from './config';
 
 interface RegisterOpts {
   as?: string;
   force?: boolean;
 }
 
+/**
+ * `rig wiki register [path]`
+ *
+ *   1. Resolve the vault dir (explicit arg, or walk up from CWD looking for
+ *      a directory that already has `purpose.md`).
+ *   2. Ensure `<vault>/.rig/config.yml` exists. Create it from defaults if
+ *      missing; otherwise keep whatever the user authored.
+ *   3. Apply the optional `--as <slug>` override to the vault config's name.
+ *   4. Append the absolute vault path to `~/.rig/wikis.yml` (the
+ *      discovery-only registry). No-op if already present.
+ */
 export default function wikiRegister(givenPath: string | undefined, opts: RegisterOpts): void {
-  const wikiPath = path.resolve(givenPath || detectWikiPath(process.cwd()) || process.cwd());
-  if (!fs.existsSync(wikiPath)) {
-    print.error(`path does not exist: ${wikiPath}`);
+  const vaultPath = path.resolve(givenPath || detectVaultPath(process.cwd()) || process.cwd());
+  if (!fs.existsSync(vaultPath)) {
+    print.error(`path does not exist: ${vaultPath}`);
     process.exit(1);
   }
-  const project = detectProjectRoot(wikiPath);
-  const name = (opts.as || detectName(project, wikiPath)).trim();
-  if (!name) {
-    print.error('failed to derive a wiki name; pass --name <n>');
+  if (!fs.existsSync(path.join(vaultPath, 'purpose.md'))) {
+    print.error(`not a wiki vault (no purpose.md): ${vaultPath}`);
+    print.info(`run \`rig wiki init ${shortPath(vaultPath)}\` first.`);
     process.exit(1);
   }
 
-  const cfg = loadWikiConfig();
-  const existing = cfg.wikis.findIndex(w => w.name === name);
-  if (existing >= 0 && !opts.force) {
-    print.error(`wiki "${name}" already registered at ${cfg.wikis[existing].path}; pass --force to overwrite`);
+  // Load or seed the per-vault config.
+  let vault = loadVaultConfig(vaultPath);
+  if (!vault) {
+    vault = defaultVaultConfig(path.basename(vaultPath));
+  }
+  const desiredName = (opts.as || vault.name || path.basename(vaultPath)).trim();
+  if (!desiredName) {
+    print.error('failed to derive a wiki name; pass --as <slug>');
     process.exit(1);
   }
 
-  const entry: WikiEntry = {
-    name,
-    path: wikiPath,
-    project: project || undefined,
-    include: ['**/*.md'],
-    exclude: [`${path.basename(wikiPath)}/**`, 'node_modules/**', '.git/**'],
-    schedule: { scan: '0 */6 * * *', lint: '0 3 * * *' },
-    ingestRules: [{ match: 'raw/**/*.md', mode: 'auto-on-new' }],
-  };
+  // Name collision in the registry — surfaced by composing the registry.
+  const reg = loadRegistry();
+  for (const existingPath of reg.wikis) {
+    if (existingPath === vaultPath) continue;
+    const other = loadVaultConfig(existingPath);
+    if (other && other.name === desiredName) {
+      if (!opts.force) {
+        print.error(`wiki "${desiredName}" already registered at ${existingPath}; pass --force to overwrite`);
+        process.exit(1);
+      }
+      // --force: drop the old entry, the new one wins.
+      reg.wikis = reg.wikis.filter(p => p !== existingPath);
+    }
+  }
 
-  if (existing >= 0) cfg.wikis[existing] = entry;
-  else cfg.wikis.push(entry);
-  saveWikiConfig(cfg);
+  vault.name = desiredName;
+  saveVaultConfig(vaultPath, vault);
 
-  // bidirectional: also write to project's package.rig.json5 if present
-  if (project) writeProjectWikiBlock(project, name, wikiPath);
+  if (!reg.wikis.includes(vaultPath)) reg.wikis.push(vaultPath);
+  saveRegistry(reg);
 
-  print.succeed(`registered wiki "${name}" -> ${wikiPath}`);
+  print.succeed(`registered wiki "${desiredName}" -> ${vaultPath}`);
 }
 
-function detectWikiPath(start: string): string | undefined {
+function detectVaultPath(start: string): string | undefined {
   const candidates = ['harness/llm-wiki', 'wiki'];
   let dir = start;
   while (true) {
+    if (fs.existsSync(path.join(dir, 'purpose.md'))) return dir;
     for (const c of candidates) {
       const cand = path.join(dir, c);
       if (fs.existsSync(path.join(cand, 'purpose.md'))) return cand;
@@ -63,32 +87,18 @@ function detectWikiPath(start: string): string | undefined {
   }
 }
 
-function detectProjectRoot(wikiPath: string): string | undefined {
-  let dir = wikiPath;
-  while (true) {
-    if (fs.existsSync(path.join(dir, 'package.json'))) return dir;
-    const parent = path.dirname(dir);
-    if (parent === dir) return undefined;
-    dir = parent;
-  }
-}
-
-function detectName(project: string | undefined, wikiPath: string): string {
-  if (project) {
-    try {
-      const pkg = JSON.parse(fs.readFileSync(path.join(project, 'package.json'), 'utf8'));
-      if (pkg && typeof pkg.name === 'string') return pkg.name.replace(/^@.*\//, '');
-    } catch { /* fall through */ }
-  }
-  return path.basename(path.dirname(wikiPath));
+function defaultVaultConfig(vaultBasename: string): VaultConfig {
+  return {
+    name: vaultBasename,
+    root: '..',
+    include: ['**/*.md'],
+    exclude: [`${vaultBasename}/**`, 'node_modules/**', '.git/**'],
+    schedule: { scan: '0 */6 * * *', lint: '0 3 * * *', ingest: null },
+    ingestRules: [{ match: 'raw/**/*.md', mode: 'auto-on-new' }],
+  };
 }
 
-function writeProjectWikiBlock(project: string, name: string, wikiPath: string): void {
-  const file = path.join(project, 'package.rig.json5');
-  let cfg: Record<string, unknown> = {};
-  if (fs.existsSync(file)) {
-    try { cfg = JSON5.parse(fs.readFileSync(file, 'utf8')); } catch { cfg = {}; }
-  }
-  cfg.wiki = { name, path: path.relative(project, wikiPath) };
-  fs.writeFileSync(file, JSON5.stringify(cfg, null, 2) + '\n', 'utf8');
+function shortPath(p: string): string {
+  const home = process.env.HOME || '';
+  return home && p.startsWith(home) ? '~' + p.slice(home.length) : p;
 }

package/lib/wiki/unregister.ts

@@ -1,16 +1,28 @@
 import path from 'path';
 import print from '../print';
-import { loadWikiConfig, saveWikiConfig } from './config';
+import { loadRegistry, saveRegistry, loadVaultConfig } from './config';
 
+/**
+ * `rig wiki unregister <nameOrPath>` — drop a vault path from
+ * `~/.rig/wikis.yml`. The vault's own `<vault>/.rig/config.yml` (and the
+ * rest of its on-disk contents) is left untouched.
+ */
 export default function wikiUnregister(nameOrPath: string): void {
-  const cfg = loadWikiConfig();
-  const target = path.resolve(nameOrPath);
-  const before = cfg.wikis.length;
-  cfg.wikis = cfg.wikis.filter(w => w.name !== nameOrPath && w.path !== target);
-  if (cfg.wikis.length === before) {
+  const reg = loadRegistry();
+  const targetAbs = path.resolve(nameOrPath);
+  const before = reg.wikis.length;
+
+  reg.wikis = reg.wikis.filter(p => {
+    if (p === targetAbs) return false;
+    const v = loadVaultConfig(p);
+    if (v && v.name === nameOrPath) return false;
+    return true;
+  });
+
+  if (reg.wikis.length === before) {
     print.error(`no registered wiki matches "${nameOrPath}"`);
     process.exit(1);
   }
-  saveWikiConfig(cfg);
+  saveRegistry(reg);
   print.succeed(`unregistered "${nameOrPath}" (disk contents untouched)`);
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rigjs",
-  "version": "4.0.2",
-  "versionCode": 26052409,
+  "version": "4.0.4",
+  "versionCode": 26052411,
   "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",
@@ -79,6 +79,7 @@
     "dayjs": "^1.11.0",
     "dotenv": "^16.0.3",
     "inquirer": "7.3.3",
+    "js-yaml": "^4.1.1",
     "json5": "2.1.3",
     "ora": "^5.1.0",
     "semver": "^7.3.7",
@@ -87,6 +88,7 @@
   },
   "devDependencies": {
     "@types/jest": "^28.1.1",
+    "@types/js-yaml": "^4.0.9",
     "@types/node": "^17.0.21",
     "esbuild": "0.28.0",
     "jest": "^27.5.1",