rigjs 4.0.5 → 4.0.7

package/lib/wiki/init.ts

@@ -1,8 +1,31 @@
 import fs from 'fs';
 import path from 'path';
+import os from 'os';
 import print from '../print';
 import { guardPath, refusalMessage } from './pathGuard';
-import { saveVaultConfig, VaultConfig } from './config';
+import { saveVaultConfig, loadVaultConfig, VaultConfig } from './config';
+import { vaultConfigPath } from './paths';
+
+/**
+ * `rig wiki init <scope>`
+ *
+ * The user runs this from a project root. The CWD is treated as the project
+ * (the conceptual "vault"); `<scope>` names a data subdir under it that the
+ * wiki should ingest from (e.g. `personal` for `<project>/personal/`).
+ *
+ * Vault metadata always lives at `<CWD>/rig-wiki/` (fixed name). The scope
+ * is recorded in `<CWD>/rig-wiki/.rig/config.yml` as the scan root, so the
+ * user's data dir stays untouched.
+ *
+ *   $ cd overmind
+ *   $ rig wiki init personal
+ *   ⇒ creates overmind/rig-wiki/ with templates + .rig/config.yml
+ *   ⇒ config.yml.root = "../personal", config.yml.name = "personal"
+ *
+ * Idempotent for the same scope. Errors if rig-wiki/ already exists with a
+ * different scope (manual `.rig/config.yml` edit required to switch).
+ */
+const VAULT_DIRNAME = 'rig-wiki';
 
 const PURPOSE_TMPL = `# Purpose
 
@@ -19,7 +42,8 @@ const SCHEMA_TMPL = `# Schema
 
 ## Layers
 - raw/, purpose.md, schema.md: read-only for LLM
-- wiki/, index.md, overview.md, log.md, reviews.md: LLM is sole author
+- index.md, overview.md, log.md, reviews.md, sources/, entities/, concepts/,
+  synthesis/, queries/: LLM is sole author
 
 ## Page types
 - sources/<slug>.md     : 1-source summary
@@ -37,7 +61,7 @@ const SCHEMA_TMPL = `# Schema
 - last-updated: <ISO>
 
 ## Naming
-- kebab-case; no spaces; no dates in wiki/ filenames
+- kebab-case; no spaces; no dates in page filenames
 - raw/ filenames keep YYYY-MM-DD prefix
 
 ## Linking
@@ -56,12 +80,6 @@ const SCHEMA_TMPL = `# Schema
 
 const SUBDIRS = ['sources', 'entities', 'concepts', 'synthesis', 'queries'];
 
-// What lives inside the wiki dir but must not enter git / Obsidian Sync:
-// - qmd's project-local vector cache (sqlite-vec, non-deterministic, rebuilds
-//   locally with `rig wiki index` / `rig wiki rebuild`)
-// - lint reports (auto-regenerated)
-// - daemon proposal diffs (transient, per-machine)
-// - editor scratch
 const GITIGNORE_TMPL = `# rig wiki — local-only artifacts (do not commit)
 # qmd vector cache (sqlite-vec, machine-specific, rebuildable)
 .qmd/index.sqlite*
@@ -76,59 +94,99 @@ 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.');
-    print.info('usage: rig wiki init <subdir>     (e.g. `rig wiki init knowledge` / `rig wiki init harness/llm-wiki`)');
-    print.info('refusing to default to CWD — that would litter the project root with wiki templates.');
+/**
+ * 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.
+ */
+function defaultVaultConfig(scope: string, rootRel: string): VaultConfig {
+  return {
+    name: scope,
+    root: rootRel,
+    include: ['**/*.md'],
+    exclude: [],
+    schedule: { scan: '0 */6 * * *', lint: '0 3 * * *', ingest: null },
+    ingestRules: [{ match: 'raw/**/*.md', mode: 'auto-on-new' }],
+  };
+}
+
+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);
   }
-  const root = path.resolve(givenPath);
-  const guard = guardPath(root, process.cwd());
+  // 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);
   if (!guard.ok) {
-    print.error('refusing to initialize a wiki at a hidden or gitignored path.');
+    print.error(`refusing to initialize the vault at a hidden or gitignored path.`);
     // eslint-disable-next-line no-console
-    console.error(refusalMessage(root, guard));
+    console.error(refusalMessage(vaultDir, guard));
     process.exit(1);
   }
-  fs.mkdirSync(root, { recursive: true });
 
-  writeIfMissing(path.join(root, 'purpose.md'), PURPOSE_TMPL);
-  writeIfMissing(path.join(root, 'schema.md'), SCHEMA_TMPL);
-  writeIfMissing(path.join(root, 'index.md'), '# Index\n');
-  writeIfMissing(path.join(root, 'overview.md'), '# Overview\n');
-  writeIfMissing(path.join(root, 'log.md'), '# Log\n');
-  writeIfMissing(path.join(root, 'reviews.md'), '# Reviews\n');
-  writeIfMissing(path.join(root, '.gitignore'), GITIGNORE_TMPL);
+  // 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.
+  const cfgFile = vaultConfigPath(vaultDir);
+  if (fs.existsSync(cfgFile)) {
+    const existing = loadVaultConfig(vaultDir);
+    const existingRootAbs = existing?.root
+      ? path.resolve(vaultDir, existing.root)
+      : path.dirname(vaultDir);
+    if (existingRootAbs !== scopeAbs) {
+      print.error(`vault already initialized at ${shortPath(vaultDir)} for scope "${existing?.name ?? '?'}" (root: ${existing?.root ?? '..'}).`);
+      print.info(`to switch scopes, edit ${shortPath(cfgFile)} (name + root) by hand.`);
+      process.exit(1);
+    }
+  }
+
+  fs.mkdirSync(vaultDir, { recursive: true });
+  writeIfMissing(path.join(vaultDir, 'purpose.md'), PURPOSE_TMPL);
+  writeIfMissing(path.join(vaultDir, 'schema.md'), SCHEMA_TMPL);
+  writeIfMissing(path.join(vaultDir, 'index.md'), '# Index\n');
+  writeIfMissing(path.join(vaultDir, 'overview.md'), '# Overview\n');
+  writeIfMissing(path.join(vaultDir, 'log.md'), '# Log\n');
+  writeIfMissing(path.join(vaultDir, 'reviews.md'), '# Reviews\n');
+  writeIfMissing(path.join(vaultDir, '.gitignore'), GITIGNORE_TMPL);
 
-  fs.mkdirSync(path.join(root, 'raw'), { recursive: true });
-  writeIfMissing(path.join(root, 'raw', '.gitkeep'), '');
+  fs.mkdirSync(path.join(vaultDir, 'raw'), { recursive: true });
+  writeIfMissing(path.join(vaultDir, 'raw', '.gitkeep'), '');
 
   for (const sub of SUBDIRS) {
-    const d = path.join(root, 'wiki', sub);
+    const d = path.join(vaultDir, sub);
     fs.mkdirSync(d, { recursive: true });
     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)));
+  if (!fs.existsSync(cfgFile)) {
+    const rootRel = path.relative(vaultDir, scopeAbs);
+    saveVaultConfig(vaultDir, defaultVaultConfig(scope, rootRel));
   }
 
-  print.succeed(`wiki initialized at ${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.');
+  print.succeed(`vault initialized at ${shortPath(vaultDir)} (scope: ${scope})`);
+  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.`);
 }
 
 function writeIfMissing(file: string, content: string) {
@@ -136,7 +194,8 @@ function writeIfMissing(file: string, content: string) {
   fs.writeFileSync(file, content, 'utf8');
 }
 
-function shortPath(p: string) {
-  const home = process.env.HOME || '';
-  return home && p.startsWith(home) ? '~' + p.slice(home.length) : p;
+function shortPath(p: string): string {
+  const home = os.homedir();
+  if (p.startsWith(home + path.sep)) return '~' + p.slice(home.length);
+  return p;
 }

package/lib/wiki/installSkill.ts

@@ -1,5 +1,6 @@
 import fs from 'fs';
 import path from 'path';
+import os from 'os';
 import print from '../print';
 import { paths } from './paths';
 
@@ -10,8 +11,6 @@ const BUNDLED_SKILLS = [
 
 /** Find rig's package root by walking up from built/ or lib/. */
 function findRigRoot(): string | undefined {
-  // Walk up from `built/index.js` (prod) or `lib/wiki/installSkill.ts` (dev)
-  // looking for the rigjs package root.
   let dir = __dirname;
   for (let i = 0; i < 10; i++) {
     const pkg = path.join(dir, 'package.json');
@@ -28,8 +27,19 @@ function findRigRoot(): string | undefined {
   return undefined;
 }
 
-interface InstallOpts { force?: boolean; }
+interface InstallOpts { force?: boolean; project?: boolean; }
 
+/**
+ * Install bundled skills (rig-wiki, rig-crew) as symlinks.
+ *
+ * Default (global): link into `~/.claude/skills/<name>/SKILL.md`. Affects
+ * every project that uses Claude Code on this machine.
+ *
+ * `--project` (project-level override for overmind-style monorepos):
+ * link into BOTH `<cwd>/.claude/skills/<name>/SKILL.md` (Claude Code) AND
+ * `<cwd>/.agents/skills/<name>/SKILL.md` (Codex). When the user is inside
+ * the project, the project-local skill files override the global ones.
+ */
 export default function wikiInstallSkill(opts: InstallOpts): void {
   const root = findRigRoot();
   if (!root) {
@@ -37,45 +47,77 @@ export default function wikiInstallSkill(opts: InstallOpts): void {
     process.exit(1);
   }
 
-  if (!fs.existsSync(paths.claudeSkillsDir)) {
-    print.error(`Claude Code skills dir not found: ${paths.claudeSkillsDir}`);
-    print.info('install Claude Code first, then re-run `rig wiki install-skill`.');
-    process.exit(1);
-  }
+  const targetRoots = resolveTargetRoots(opts);
+  for (const tr of targetRoots) {
+    if (!fs.existsSync(tr.parent)) {
+      // Project-level install creates the dirs on demand (parent is <cwd>).
+      // Global install requires the dir to already exist — that's how we
+      // detect "Claude Code is installed on this machine".
+      if (tr.kind === 'global') {
+        print.error(`${tr.label} dir not found: ${tr.parent}`);
+        print.info(`install ${tr.label} first, then re-run \`rig wiki install-skill\`.`);
+        process.exit(1);
+      }
+    }
 
-  for (const skill of BUNDLED_SKILLS) {
-    const src = path.join(root, skill.file);
-    if (!fs.existsSync(src)) {
-      print.warn(`skipping ${skill.name}: ${skill.file} not found inside rigjs install`);
-      continue;
+    for (const skill of BUNDLED_SKILLS) {
+      const src = path.join(root, skill.file);
+      if (!fs.existsSync(src)) {
+        print.warn(`skipping ${skill.name}: ${skill.file} not found inside rigjs install`);
+        continue;
+      }
+      linkSkill(skill.name, src, tr.parent, opts);
     }
-    linkSkill(skill.name, src, opts);
   }
 
-  print.info('restart Claude Code to pick up new or updated skills.');
+  if (opts.project) {
+    print.info('project-local skills will override global ones when this project is the cwd.');
+  } else {
+    print.info('restart Claude Code to pick up new or updated skills.');
+  }
+}
+
+interface TargetRoot {
+  /** `<parent>/<skill-name>/SKILL.md` is the resulting symlink. */
+  parent: string;
+  kind: 'global' | 'project';
+  label: string;
 }
 
-function linkSkill(name: string, src: string, opts: InstallOpts): void {
-  const targetDir = path.join(paths.claudeSkillsDir, name);
+function resolveTargetRoots(opts: InstallOpts): TargetRoot[] {
+  if (opts.project) {
+    const cwd = process.cwd();
+    return [
+      { parent: path.join(cwd, '.claude', 'skills'), kind: 'project', label: 'Claude Code project skills' },
+      { parent: path.join(cwd, '.agents', 'skills'), kind: 'project', label: 'Codex project skills' },
+    ];
+  }
+  return [
+    { parent: paths.claudeSkillsDir, kind: 'global', label: 'Claude Code skills' },
+  ];
+}
+
+function linkSkill(name: string, src: string, parentDir: string, opts: InstallOpts): void {
+  const targetDir = path.join(parentDir, name);
   const target = path.join(targetDir, 'SKILL.md');
   fs.mkdirSync(targetDir, { recursive: true });
 
   if (fs.existsSync(target) || isBrokenSymlink(target)) {
     const existing = safeReadlink(target);
     if (existing === src) {
-      print.info(`already linked: ${target}`);
+      print.info(`already linked: ${shortPath(target)}`);
       return;
     }
     if (!opts.force) {
       const what = existing ? `symlink -> ${existing}` : 'a regular file';
-      print.error(`${target} exists as ${what}. Pass --force to replace.`);
+      print.error(`${shortPath(target)} exists as ${what}. Pass --force to replace.`);
       process.exit(1);
     }
     fs.rmSync(target, { force: true });
   }
 
   fs.symlinkSync(src, target);
-  print.succeed(`linked ${target} -> ${src}`);
+  print.succeed(`linked ${shortPath(target)} -> ${shortPath(src)}`);
 }
 
 function safeReadlink(p: string): string | null {
@@ -90,3 +132,9 @@ function isBrokenSymlink(p: string): boolean {
     try { return Boolean(fs.readlinkSync(p)); } catch { return false; }
   }
 }
+
+function shortPath(p: string): string {
+  const home = os.homedir();
+  if (p.startsWith(home + path.sep)) return '~' + p.slice(home.length);
+  return p;
+}

package/lib/wiki/lint.ts

@@ -16,13 +16,13 @@ import fs from 'fs';
 import path from 'path';
 import crypto from 'crypto';
 import print from '../print';
-import { loadWikiConfig, resolveWiki, WikiEntry } from './config';
+import { requireVault, WikiEntry } from './config';
 import { recordLastRun } from './db';
 
-interface LintOpts { wiki?: string; all?: boolean; json?: boolean; }
+interface LintOpts { json?: boolean; }
 
 interface PageMeta {
-  rel: string;          // wiki-relative path, e.g. "wiki/sources/foo.md"
+  rel: string;          // vault-relative path, e.g. "sources/foo.md"
   slug: string;         // filename without ext
   sub: string;          // "sources" | "entities" | "concepts" | "synthesis" | "queries"
   frontmatter: Record<string, unknown> | null;
@@ -44,34 +44,24 @@ const SOURCE_EXTRA_KEYS = ['source-sha', 'source-path'] as const;
 const WIKI_SUBDIRS = ['sources', 'entities', 'concepts', 'synthesis', 'queries'] as const;
 
 export default async function wikiLint(opts: LintOpts): Promise<void> {
-  const cfg = loadWikiConfig();
-  const targets: WikiEntry[] = opts.all
-    ? cfg.wikis
-    : [resolveWiki(cfg, opts.wiki)].filter(Boolean) as WikiEntry[];
-  if (targets.length === 0) {
-    print.error('no wiki resolved. Pass --wiki <name>, --all, or run from inside a registered project.');
-    process.exit(1);
-  }
-
-  let severeFound = false;
-  const reports: { wiki: string; findings: Findings }[] = [];
-  for (const t of targets) {
-    const findings = lintOne(t);
-    reports.push({ wiki: t.name, findings });
-    const sev =
-      findings.missingFrontmatter.length +
-      findings.missingRequiredKey.length +
-      findings.brokenWikilinks.length +
-      findings.missingRawSource.length;
-    if (sev > 0) severeFound = true;
-    if (!opts.json) printSummary(t.name, findings);
-    writeReport(t, findings);
-    recordLastRun(t.name, 'lint', sev > 0 ? 11 : 0);
-  }
+  const target = requireVault();
+  const findings = lintOne(target);
+  const sev =
+    findings.missingFrontmatter.length +
+    findings.missingRequiredKey.length +
+    findings.brokenWikilinks.length +
+    findings.missingRawSource.length;
+  const severeFound = sev > 0;
+  if (!opts.json) printSummary(target.name, findings);
+  writeReport(target, findings);
+  recordLastRun(target.name, 'lint', severeFound ? 11 : 0);
 
   if (opts.json) {
     // eslint-disable-next-line no-console
-    console.log(JSON.stringify({ ok: !severeFound, code: severeFound ? 11 : 0, data: reports }, null, 2));
+    console.log(JSON.stringify({
+      ok: !severeFound, code: severeFound ? 11 : 0,
+      data: [{ wiki: target.name, findings }],
+    }, null, 2));
   }
   if (severeFound) process.exit(11);
 }
@@ -89,7 +79,7 @@ function lintOne(wiki: WikiEntry): Findings {
 
   const pages: PageMeta[] = [];
   for (const sub of WIKI_SUBDIRS) {
-    const dir = path.join(wiki.path, 'wiki', sub);
+    const dir = path.join(wiki.path, sub);
     if (!fs.existsSync(dir)) continue;
     for (const name of fs.readdirSync(dir)) {
       if (!name.endsWith('.md') || name === '.gitkeep') continue;

package/lib/wiki/paths.ts

@@ -6,7 +6,6 @@ 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.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'),

package/lib/wiki/query.ts

@@ -10,12 +10,11 @@
 
 import path from 'path';
 import print from '../print';
-import { loadWikiConfig, resolveWiki, loadRigConfig, WikiEntry } from './config';
+import { requireVault, loadRigConfig, WikiEntry } from './config';
 import { qmdQuery, QmdHit } from './qmd';
 import { adapters } from './agent/registry';
 
 interface QueryOpts {
-  wiki?: string;
   json?: boolean;
   limit?: number;
   synth?: boolean;
@@ -28,12 +27,7 @@ export default async function wikiQuery(q: string, opts: QueryOpts): Promise<voi
     print.error('empty query.');
     process.exit(1);
   }
-  const cfg = loadWikiConfig();
-  const target = resolveWiki(cfg, opts.wiki);
-  if (!target) {
-    print.error('no wiki resolved. Pass --wiki <name> or run from inside a registered project.');
-    process.exit(1);
-  }
+  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 });
@@ -78,13 +72,15 @@ function printHits(wiki: WikiEntry, q: string, hits: QmdHit[]): void {
   console.log('');
 }
 
-// "/abs/.../wiki/sources/foo.md" → "foo". Outside wiki/<sub>/ → null so the
-// caller falls back to printing the literal path.
+// "/abs/<vault>/sources/foo.md" → "foo". For paths outside the page-tree
+// subdirs returns null so the caller falls back to the literal path.
+const PAGE_SUBDIRS = ['sources', 'entities', 'concepts', 'synthesis', 'queries'];
 function toWikilink(wiki: WikiEntry, filePath: string): string | null {
   try {
     const abs = path.isAbsolute(filePath) ? filePath : path.resolve(wiki.path, filePath);
-    const wikiRoot = path.join(wiki.path, 'wiki') + path.sep;
-    if (!abs.startsWith(wikiRoot)) return null;
+    const rel = path.relative(wiki.path, abs);
+    const first = rel.split(path.sep)[0];
+    if (!PAGE_SUBDIRS.includes(first)) return null;
     return path.basename(abs, path.extname(abs));
   } catch { return null; }
 }

package/lib/wiki/rebuild.ts

@@ -13,44 +13,33 @@
 //   - full re-embed (Qwen3-Embedding by default)
 
 import print from '../print';
-import { loadWikiConfig, resolveWiki, WikiEntry } from './config';
+import { requireVault } from './config';
 import { getDb, recordLastRun } from './db';
 import { qmdEmbed, qmdResetStore } from './qmd';
 
-interface RebuildOpts { wiki?: string; all?: boolean; skipEmbed?: boolean; }
+interface RebuildOpts { skipEmbed?: boolean; }
 
 export default async function wikiRebuild(opts: RebuildOpts): Promise<void> {
-  const cfg = loadWikiConfig();
-  const targets: WikiEntry[] = opts.all
-    ? cfg.wikis
-    : [resolveWiki(cfg, opts.wiki)].filter(Boolean) as WikiEntry[];
-  if (targets.length === 0) {
-    print.error('no wiki resolved. Pass --wiki <name>, --all, or run from inside a registered project.');
-    process.exit(1);
-  }
-
+  const t = requireVault();
   const db = getDb();
-  for (const t of targets) {
-    print.start(`rebuild: ${t.name}`);
-    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);
+  print.start(`rebuild: ${t.name}`);
+  const del = db.prepare('DELETE FROM source_sha WHERE wiki = ?').run(t.name);
+  print.info(`  cleared ${del.changes} source_sha rows for ${t.name}`);
 
-    if (!opts.skipEmbed) {
-      const res = await qmdEmbed(t.name, t.path, { force: true });
-      if (res.ok) print.info(`  qmd embed: ${t.name} done`);
-      else {
-        print.error(`  qmd embed: ${t.name} failed: ${res.stderr.trim()}`);
-        recordLastRun(t.name, 'rebuild', 1);
-        process.exitCode = 1;
-        continue;
-      }
-    }
+  qmdResetStore(t.name);
 
-    recordLastRun(t.name, 'rebuild', 0);
-    print.succeed(`rebuilt: ${t.name}`);
+  if (!opts.skipEmbed) {
+    const res = await qmdEmbed(t.name, t.path, { force: true });
+    if (res.ok) print.info(`  qmd embed: ${t.name} done`);
+    else {
+      print.error(`  qmd embed: ${t.name} failed: ${res.stderr.trim()}`);
+      recordLastRun(t.name, 'rebuild', 1);
+      process.exit(1);
+    }
   }
 
+  recordLastRun(t.name, 'rebuild', 0);
+  print.succeed(`rebuilt: ${t.name}`);
   print.info('next: run `rig wiki scan` to baseline the new sha index.');
 }

package/lib/wiki/uninstallSkill.ts

@@ -1,30 +1,50 @@
 import fs from 'fs';
 import path from 'path';
+import os from 'os';
 import print from '../print';
 import { paths } from './paths';
 
-export default function wikiUninstallSkill(): void {
-  const targetDir = path.join(paths.claudeSkillsDir, 'rig-wiki');
-  const target = path.join(targetDir, 'SKILL.md');
+const BUNDLED_SKILLS = ['rig-wiki', 'rig-crew'];
 
-  let removed = false;
-  if (fs.existsSync(target) || isBrokenSymlink(target)) {
-    fs.rmSync(target, { force: true });
-    print.succeed(`removed ${target}`);
-    removed = true;
-  }
+interface UninstallOpts { project?: boolean; }
+
+/**
+ * Remove bundled-skill symlinks. Mirrors `installSkill` flags:
+ *   default       — `~/.claude/skills/<name>/SKILL.md`
+ *   `--project`   — both `<cwd>/.claude/skills/<name>/SKILL.md`
+ *                   and `<cwd>/.agents/skills/<name>/SKILL.md`
+ */
+export default function wikiUninstallSkill(opts: UninstallOpts): void {
+  const parents = opts.project
+    ? [
+        path.join(process.cwd(), '.claude', 'skills'),
+        path.join(process.cwd(), '.agents', 'skills'),
+      ]
+    : [paths.claudeSkillsDir];
 
-  // Clean the rig-wiki/ dir if we left it empty.
-  if (fs.existsSync(targetDir)) {
-    try {
-      if (fs.readdirSync(targetDir).length === 0) {
-        fs.rmdirSync(targetDir);
-        print.info(`removed empty dir ${targetDir}`);
+  let removed = 0;
+  for (const parent of parents) {
+    for (const name of BUNDLED_SKILLS) {
+      const targetDir = path.join(parent, name);
+      const target = path.join(targetDir, 'SKILL.md');
+
+      if (fs.existsSync(target) || isBrokenSymlink(target)) {
+        fs.rmSync(target, { force: true });
+        print.succeed(`removed ${shortPath(target)}`);
+        removed++;
       }
-    } catch { /* non-fatal */ }
+
+      if (fs.existsSync(targetDir)) {
+        try {
+          if (fs.readdirSync(targetDir).length === 0) {
+            fs.rmdirSync(targetDir);
+          }
+        } catch { /* non-fatal */ }
+      }
+    }
   }
 
-  if (!removed) print.info(`nothing to remove at ${target}`);
+  if (removed === 0) print.info('nothing to remove.');
 }
 
 function isBrokenSymlink(p: string): boolean {
@@ -35,3 +55,9 @@ function isBrokenSymlink(p: string): boolean {
     try { return Boolean(fs.readlinkSync(p)); } catch { return false; }
   }
 }
+
+function shortPath(p: string): string {
+  const home = os.homedir();
+  if (p.startsWith(home + path.sep)) return '~' + p.slice(home.length);
+  return p;
+}

package/package.json

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