rigjs 4.0.7 → 4.0.10

package/lib/crew/board.ts

@@ -78,7 +78,7 @@ function projectTable(crew: ReturnType<typeof requireCrew>, tasks: CrewTask[]):
   const projects = crew.projects || [];
   if (projects.length === 0) return '_No projects registered yet._';
   const rows = projects.map(p => {
-    const scoped = tasks.filter(t => t.scope !== 'inbox' && (t.scope === `project:${p.name}` || t.fields.project === p.name));
+    const scoped = tasks.filter(t => t.scope !== 'inbox' && (t.scope === `project:${p.name}` || t.scope.startsWith(`project:${p.name}:`) || t.fields.project === p.name));
     const s = summarize(scoped);
     const health = s.blocked > 0 ? 'At Risk' : 'On Track';
     return `| ${p.name} | ${p.owner} | ${p.defaultExecutor || crew.defaultExecutor || 'claude'} | ${health} | ${s.open} | ${s.blocked} | ${shortPath(p.path)} |`;
@@ -89,7 +89,7 @@ function projectTable(crew: ReturnType<typeof requireCrew>, tasks: CrewTask[]):
 function roleTable(crew: ReturnType<typeof requireCrew>, tasks: CrewTask[]): string {
   const roles = roleDefinitionsForCrew(crew);
   const rows = roles.map(role => {
-    const scoped = tasks.filter(t => t.scope === `role:${role.name}` || t.fields.role === role.name || t.fields.owner === role.name);
+    const scoped = tasks.filter(t => t.scope === `legacy-role:${role.name}` || t.scope.includes(`:role:${role.name}`) || t.fields.role === role.name || t.fields.owner === role.name);
     const s = summarize(scoped);
     return `| ${role.title} | ${taskProgress(scoped)}% | ${s.doing} | ${s.blocked} | ${s.open} |`;
   });
@@ -111,7 +111,12 @@ function activeTable(tasks: CrewTask[]): string {
 }
 
 function displayScope(scope: string): string {
-  return scope.startsWith('role:') ? scope.slice('role:'.length) : scope;
+  if (scope.startsWith('legacy-role:')) return scope.slice('legacy-role:'.length);
+  const projectRole = scope.match(/^project:([^:]+):role:([^:]+)/);
+  if (projectRole) return `${projectRole[1]}/${projectRole[2]}`;
+  const projectTasklist = scope.match(/^project:([^:]+):tasklist/);
+  if (projectTasklist) return projectTasklist[1];
+  return scope;
 }
 
 function cleanTaskText(text: string): string {

package/lib/crew/doctor.ts

@@ -10,7 +10,7 @@ interface DoctorOpts { crew?: string; }
 
 export default function crewDoctor(opts: DoctorOpts): void {
   const crew = requireCrew(opts.crew);
-  const checks: { name: string; ok: boolean; detail: string }[] = [];
+  const checks: { name: string; ok: boolean; detail: string; fatal?: boolean }[] = [];
   checks.push({ name: 'crew config', ok: fs.existsSync(crewPaths.config), detail: shortPath(crewPaths.config) });
   checks.push({ name: 'vault', ok: fs.existsSync(crew.vault), detail: shortPath(crew.vault) });
   checks.push({ name: 'crew root', ok: fs.existsSync(rootPath(crew, '')), detail: shortPath(rootPath(crew, '')) });
@@ -27,14 +27,18 @@ export default function crewDoctor(opts: DoctorOpts): void {
   for (const project of crew.projects || []) {
     const rig = path.join(project.path, 'RIG.md');
     const rigLower = path.join(project.path, 'rig.md');
-    checks.push({ name: `project ${project.name} RIG.md`, ok: fs.existsSync(rig) || fs.existsSync(rigLower), detail: shortPath(rig) });
+    checks.push({ name: `project ${project.name} RIG.md`, ok: fs.existsSync(rig) || fs.existsSync(rigLower), detail: shortPath(rig), fatal: false });
     checks.push({ name: `project ${project.name} path`, ok: fs.existsSync(project.path), detail: shortPath(project.path) });
+    checks.push({ name: `project ${project.name} agent tasks`, ok: fs.existsSync(rootPath(crew, path.join('Projects', project.name, 'Agents'))), detail: path.join(crew.root, 'Projects', project.name, 'Agents') });
   }
 
   let failed = 0;
   for (const c of checks) {
     if (c.ok) print.succeed(`${c.name}: ${c.detail}`);
-    else { failed++; print.warn(`${c.name}: missing (${c.detail})`); }
+    else {
+      if (c.fatal !== false) failed++;
+      print.warn(`${c.name}: missing (${c.detail})`);
+    }
   }
   if (failed > 0) process.exitCode = 1;
 }

package/lib/crew/index.ts

@@ -6,7 +6,7 @@ import crewSync from './sync';
 import crewDoctor from './doctor';
 import crewAsk from './ask';
 import crewStub from './stub';
-import { projectAdd, projectList, projectStatus } from './project';
+import { projectAdd, projectList, projectStatus, projectSync } from './project';
 import { roleAdd, roleList, roleShow } from './roleCommand';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -66,6 +66,16 @@ export function registerCrewCommands(program: any): void {
     .option('--no-write', 'mark owner as read-only')
     .option('-c, --crew <name>', 'target crew name')
     .action(projectAdd);
+  project.command('sync')
+    .description('sync project owners from the vault projects/ directory')
+    .option('--from <path>', 'projects directory, relative to the vault (default: projects)')
+    .option('--executor <name>', 'default executor for newly discovered projects')
+    .option('--test-command <cmd>', 'default focused test command for newly discovered projects')
+    .option('--no-write', 'mark newly discovered owners as read-only')
+    .option('--keep-missing', 'keep projects that disappeared from the scanned directory')
+    .option('--no-archive-missing', 'do not archive stale rig-agents project folders')
+    .option('-c, --crew <name>', 'target crew name')
+    .action(projectSync);
   project.command('list')
     .description('list registered projects')
     .option('-c, --crew <name>', 'target crew name')

package/lib/crew/project.ts

@@ -1,7 +1,8 @@
+import fs from 'fs';
 import path from 'path';
 import print from '../print';
 import { loadCrewConfig, saveCrewConfig, requireCrew, normalizeCrew, CrewProject, shortPath } from './config';
-import { ensureProject } from './vault';
+import { ensureProject, rootPath } from './vault';
 import { scanTasks, summarize } from './task';
 import { CrewExecutor } from './config';
 
@@ -12,6 +13,9 @@ interface ProjectOpts {
   executor?: string;
   testCommand?: string;
   noWrite?: boolean;
+  from?: string;
+  keepMissing?: boolean;
+  archiveMissing?: boolean;
 }
 
 export function projectAdd(name: string, opts: ProjectOpts): void {
@@ -66,7 +70,7 @@ export function projectStatus(name: string, opts: ProjectOpts): void {
     print.error(`unknown project: ${name}`);
     process.exit(1);
   }
-  const tasks = scanTasks(crew).filter(t => t.scope !== 'inbox' && (t.scope === `project:${name}` || t.fields.project === name));
+  const tasks = scanTasks(crew).filter(t => t.scope !== 'inbox' && (t.scope === `project:${name}` || t.scope.startsWith(`project:${name}:`) || t.fields.project === name));
   const s = summarize(tasks);
   print.info(`project: ${name} (${project.owner})`);
   // eslint-disable-next-line no-console
@@ -77,8 +81,90 @@ export function projectStatus(name: string, opts: ProjectOpts): void {
   console.log(`tasks: ${s.done}/${s.total} done, ${s.open} open, ${s.blocked} blocked`);
 }
 
+export function projectSync(opts: ProjectOpts): void {
+  const cfg = loadCrewConfig();
+  const crew = requireCrew(opts.crew);
+  const crewIndex = cfg.crews.findIndex(c => c.name === crew.name);
+  const entry = normalizeCrew(cfg.crews[crewIndex]);
+  const scanRoot = path.resolve(entry.vault, opts.from || 'projects');
+  if (!fs.existsSync(scanRoot)) {
+    print.error(`projects directory not found: ${shortPath(scanRoot)}`);
+    process.exit(1);
+  }
+
+  const found = fs.readdirSync(scanRoot, { withFileTypes: true })
+    .filter(d => d.isDirectory() && !d.name.startsWith('.') && !d.name.startsWith('_'))
+    .map(d => ({ name: d.name, path: path.join(scanRoot, d.name) }))
+    .sort((a, b) => a.name.localeCompare(b.name));
+
+  const existing = new Map((entry.projects || []).map(p => [p.name, p]));
+  const seen = new Set(found.map(p => p.name));
+  const next: CrewProject[] = [];
+  const added: string[] = [];
+  const updated: string[] = [];
+  const removed: CrewProject[] = [];
+
+  for (const item of found) {
+    const old = existing.get(item.name);
+    if (old) {
+      const project = { ...old, path: item.path };
+      next.push(project);
+      updated.push(item.name);
+    } else {
+      const project: CrewProject = {
+        name: item.name,
+        path: item.path,
+        owner: `maintainer:${item.name}`,
+        defaultExecutor: parseExecutor(opts.executor || entry.defaultExecutor || 'claude'),
+        canWriteCode: !opts.noWrite,
+        defaultTestCommand: opts.testCommand,
+      };
+      next.push(project);
+      added.push(item.name);
+    }
+  }
+
+  for (const project of entry.projects || []) {
+    if (seen.has(project.name)) continue;
+    if (!isInside(project.path, scanRoot)) {
+      next.push(project);
+      continue;
+    }
+    if (opts.keepMissing) next.push(project);
+    else removed.push(project);
+  }
+
+  entry.projects = next;
+  cfg.crews[crewIndex] = entry;
+  saveCrewConfig(cfg);
+
+  for (const project of next) ensureProject(entry, project);
+  if (!opts.keepMissing && opts.archiveMissing !== false) {
+    for (const project of removed) archiveProjectFolder(entry, project.name);
+  }
+
+  print.succeed(`project registry synced from ${shortPath(scanRoot)}`);
+  print.info(`added: ${added.length ? added.join(', ') : '-'}`);
+  print.info(`updated: ${updated.length ? updated.join(', ') : '-'}`);
+  print.info(`removed: ${removed.length ? removed.map(p => p.name).join(', ') : '-'}`);
+}
+
 function parseExecutor(value: string): CrewExecutor {
   if (value === 'claude' || value === 'codex' || value === 'pi') return value;
   print.error(`unknown executor: ${value}. Expected claude, codex, or pi.`);
   process.exit(1);
 }
+
+function isInside(child: string, parent: string): boolean {
+  const rel = path.relative(path.resolve(parent), path.resolve(child));
+  return rel === '' || (!!rel && !rel.startsWith('..') && !path.isAbsolute(rel));
+}
+
+function archiveProjectFolder(crew: ReturnType<typeof normalizeCrew>, name: string): void {
+  const from = rootPath(crew, path.join('Projects', name));
+  if (!fs.existsSync(from)) return;
+  const stamp = new Date().toISOString().replace(/[-:]/g, '').replace(/\..+$/, '').replace('T', '-');
+  const to = rootPath(crew, path.join('Projects', '_Archived', `${name}-${stamp}`));
+  fs.mkdirSync(path.dirname(to), { recursive: true });
+  fs.renameSync(from, to);
+}

package/lib/crew/role.ts

@@ -17,12 +17,12 @@ export interface CrewRoleDefinition {
 export const BUILTIN_ROLE_NAMES = ['lead', 'designer', 'pm', 'coder', 'tester', 'researcher'];
 
 const BUILTIN_ROLES: CrewRoleDefinition[] = [
-  { name: 'lead', title: 'Lead', folder: 'Lead', description: 'Primary user-facing coordinator.', builtIn: true },
-  { name: 'designer', title: 'Designer', folder: 'Designer', description: 'Interaction, UX, information architecture, and visual review.', builtIn: true },
-  { name: 'pm', title: 'PM', folder: 'PM', description: 'PRD generation, requirements review, scope, and acceptance criteria.', builtIn: true },
-  { name: 'coder', title: 'Coder', folder: 'Coder', description: 'Implementation work when no project owner is more specific.', builtIn: true },
-  { name: 'tester', title: 'Tester', folder: 'Tester', description: 'Verification, test planning, and PRD-scoped E2E checks.', builtIn: true },
-  { name: 'researcher', title: 'Researcher', folder: 'Researcher', description: 'Source-backed research and durable reports.', builtIn: true },
+  { name: 'lead', title: 'Lead', folder: 'Lead', description: 'Coordinates goals, project owners, roles, Inbox decisions, and dashboard status.', builtIn: true },
+  { name: 'designer', title: 'Designer', folder: 'Designer', description: 'Reviews user flows, interaction details, information architecture, and visual fit.', builtIn: true },
+  { name: 'pm', title: 'PM', folder: 'PM', description: 'Turns goals into PRDs, scope boundaries, acceptance criteria, and open questions.', builtIn: true },
+  { name: 'coder', title: 'Coder', folder: 'Coder', description: 'Implements project-scoped code tasks assigned by a Project Owner or Lead.', builtIn: true },
+  { name: 'tester', title: 'Tester', folder: 'Tester', description: 'Plans and runs verification, defaulting frontend work to PRD-scoped Playwright E2E.', builtIn: true },
+  { name: 'researcher', title: 'Researcher', folder: 'Researcher', description: 'Produces source-backed research reports and keeps a lightweight research index.', builtIn: true },
 ];
 
 export function normalizeRoleName(input: string): string {

package/lib/crew/task.ts

@@ -1,8 +1,8 @@
 import fs from 'fs';
 import path from 'path';
 import { CrewEntry } from './config';
-import { rootPath } from './vault';
-import { roleDefinitionsForCrew } from './role';
+import { projectAgentFolder, rootPath } from './vault';
+import { normalizeRoleName, roleDefinitionsForCrew } from './role';
 
 export interface CrewTask {
   id?: string;
@@ -76,17 +76,66 @@ function parseTaskLine(line: string): Omit<CrewTask, 'file' | 'line' | 'scope'>
 function taskFiles(crew: CrewEntry): { file: string; scope: string }[] {
   const files = [
     { file: rootPath(crew, 'Inbox.md'), scope: 'inbox' },
-    ...roleDefinitionsForCrew(crew).map(role => ({
-      file: rootPath(crew, path.join(role.folder, 'Tasks.md')),
-      scope: `role:${role.name}`,
-    })),
   ];
+  const roles = roleDefinitionsForCrew(crew);
+
+  // Backward compatibility: old crew roots may still contain global role
+  // task files. New init writes role descriptions only and scopes concrete
+  // work under Projects/<project>/Agents/<role>/Tasks.md.
+  for (const role of roles) {
+    const legacy = rootPath(crew, path.join(role.folder, 'Tasks.md'));
+    if (fs.existsSync(legacy)) files.push({ file: legacy, scope: `legacy-role:${role.name}` });
+  }
+
   const projectsDir = rootPath(crew, 'Projects');
-  if (fs.existsSync(projectsDir)) {
-    for (const name of fs.readdirSync(projectsDir)) {
-      const file = path.join(projectsDir, name, 'Tasks.md');
-      if (fs.existsSync(file)) files.push({ file, scope: `project:${name}` });
+  const projectNames = configuredProjectNames(crew, projectsDir);
+  for (const name of projectNames) {
+    const base = path.join(projectsDir, name);
+    const file = path.join(base, 'Tasks.md');
+    if (fs.existsSync(file)) files.push({ file, scope: `project:${name}` });
+    files.push(...tasklistFiles(path.join(base, 'Tasklists', 'active'), `project:${name}:tasklist`));
+
+    const seenRoleFolders = new Set<string>();
+    for (const role of roles) {
+      const folder = projectAgentFolder(role);
+      seenRoleFolders.add(folder);
+      const roleFile = path.join(base, 'Agents', folder, 'Tasks.md');
+      if (fs.existsSync(roleFile)) files.push({ file: roleFile, scope: `project:${name}:role:${role.name}` });
+      files.push(...tasklistFiles(path.join(base, 'Agents', folder, 'Tasklists', 'active'), `project:${name}:role:${role.name}:tasklist`));
+    }
+
+    const agentsDir = path.join(base, 'Agents');
+    if (fs.existsSync(agentsDir)) {
+      for (const entry of fs.readdirSync(agentsDir, { withFileTypes: true })) {
+        if (!entry.isDirectory() || seenRoleFolders.has(entry.name)) continue;
+        const roleFile = path.join(agentsDir, entry.name, 'Tasks.md');
+        const roleName = normalizeRoleName(entry.name);
+        if (fs.existsSync(roleFile)) files.push({ file: roleFile, scope: `project:${name}:role:${roleName}` });
+        files.push(...tasklistFiles(path.join(agentsDir, entry.name, 'Tasklists', 'active'), `project:${name}:role:${roleName}:tasklist`));
+      }
     }
   }
   return files.filter(item => fs.existsSync(item.file));
 }
+
+function configuredProjectNames(crew: CrewEntry, projectsDir: string): string[] {
+  if (crew.projects && crew.projects.length > 0) return crew.projects.map(p => p.name);
+  if (!fs.existsSync(projectsDir)) return [];
+  return fs.readdirSync(projectsDir, { withFileTypes: true })
+    .filter(entry => entry.isDirectory() && !entry.name.startsWith('_') && !entry.name.startsWith('.'))
+    .map(entry => entry.name);
+}
+
+function tasklistFiles(dir: string, scope: string): { file: string; scope: string }[] {
+  if (!fs.existsSync(dir)) return [];
+  const files: { file: string; scope: string }[] = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...tasklistFiles(full, scope));
+    } else if (entry.isFile() && entry.name.endsWith('.md')) {
+      files.push({ file: full, scope });
+    }
+  }
+  return files.sort((a, b) => a.file.localeCompare(b.file));
+}

package/lib/crew/vault.ts

@@ -46,9 +46,12 @@ export function ensureProject(crew: CrewEntry, project: CrewProject): void {
   ensureDir(base);
   writeProjectOwnerFile(path.join(base, 'Owner.md'), project);
   writeIfMissing(path.join(base, 'Context.md'), `# ${project.name} Context\n\n`);
-  writeIfMissing(path.join(base, 'Tasks.md'), `# ${project.name} Tasks\n\n`);
+  writeIfMissing(path.join(base, 'Tasks.md'), renderProjectTasksFile(project));
+  ensureTasklists(base);
   writeIfMissing(path.join(base, 'Decisions.md'), `# ${project.name} Decisions\n\n`);
   writeIfMissing(path.join(base, 'Test-Plan.md'), `# ${project.name} Test Plan\n\n`);
+  ensureDir(path.join(base, 'Agents'));
+  for (const role of roleDefinitionsForCrew(crew)) ensureProjectAgentTasks(base, project, role);
   ensureDir(path.join(base, 'PRDs'));
   writeIfMissing(path.join(base, 'PRDs', '.gitkeep'), '');
   ensureDir(path.join(base, 'Reports'));
@@ -77,17 +80,11 @@ function ensureRole(crew: CrewEntry, role: CrewRoleDefinition): void {
   const folder = role.folder;
   const base = rootPath(crew, folder);
   ensureDir(base);
-  writeIfMissing(path.join(base, 'Tasks.md'), `# ${folder} Tasks\n\n`);
-  writeIfMissing(path.join(base, 'Notes.md'), `# ${folder} Notes\n\n`);
+  writeIfMissing(path.join(base, 'Role.md'), renderRoleFile(role));
   if (role.name === 'lead') {
     ensureDir(path.join(base, 'Reports'));
     writeIfMissing(path.join(base, 'Reports', '.gitkeep'), '');
   }
-  if (role.name === 'pm') {
-    ensureDir(path.join(base, 'PRDs'));
-    writeIfMissing(path.join(base, 'PRDs', '.gitkeep'), '');
-    writeIfMissing(path.join(base, 'Reviews.md'), '# PM Reviews\n\n');
-  }
   if (role.name === 'researcher') {
     ensureDir(path.join(base, 'Reports'));
     writeIfMissing(path.join(base, 'Reports', '.gitkeep'), '');
@@ -96,7 +93,6 @@ function ensureRole(crew: CrewEntry, role: CrewRoleDefinition): void {
   if (!role.builtIn) {
     ensureDir(path.join(base, 'Reports'));
     writeIfMissing(path.join(base, 'Reports', '.gitkeep'), '');
-    writeIfMissing(path.join(base, 'Role.md'), renderRoleFile(role));
   }
 }
 
@@ -146,16 +142,68 @@ function renderRoleFile(role: CrewRoleDefinition): string {
   return [
     `# ${role.title}`,
     '',
-    `Role: ${role.name}`,
-    `Agent: ${role.agent || '-'}`,
-    `Executor: ${role.defaultExecutor || '-'}`,
-    `Prompt: ${role.promptPath || '-'}`,
+    `Role: \`${role.name}\``,
+    `Agent: \`${role.agent || '-'}\``,
+    `Default executor: \`${role.defaultExecutor || '-'}\``,
+    `Prompt: \`${role.promptPath || '-'}\``,
+    '',
+    '## Purpose',
     '',
     role.description || '',
     '',
+    '## Task Location',
+    '',
+    'This role is reusable across projects. Do not keep normal project work here.',
+    'Assign concrete work under `Projects/<project>/Agents/<role>/Tasks.md`, or under `Projects/<project>/Tasks.md` for project-owner work.',
+    '',
+    'Users may edit this file to tune the role.',
+    '',
   ].join('\n');
 }
 
+function ensureProjectAgentTasks(base: string, project: CrewProject, role: CrewRoleDefinition): void {
+  const dir = path.join(base, 'Agents', projectAgentFolder(role));
+  ensureDir(dir);
+  writeIfMissing(path.join(dir, 'Tasks.md'), renderProjectAgentTasksFile(project, role));
+  ensureTasklists(dir);
+}
+
+export function projectAgentFolder(role: CrewRoleDefinition): string {
+  if (role.builtIn && !role.folder.includes(path.sep)) return role.folder;
+  return role.name;
+}
+
+function renderProjectTasksFile(project: CrewProject): string {
+  return [
+    `# ${project.name} Project Tasks`,
+    '',
+    'Keep this file short: current project-owner tasks and cross-role coordination only.',
+    'For larger plans, split current work into `Tasklists/active/<feature-or-iteration>.md`.',
+    'Move completed or stale batches to `Tasklists/archive/YYYY-MM.md`; archive files are not scanned for the active dashboard.',
+    'Role-specific current work belongs in `Agents/<role>/Tasks.md` or `Agents/<role>/Tasklists/active/*.md`.',
+    '',
+  ].join('\n');
+}
+
+function renderProjectAgentTasksFile(project: CrewProject, role: CrewRoleDefinition): string {
+  return [
+    `# ${project.name} ${role.title} Tasks`,
+    '',
+    `Use this file for the short current ${role.title} queue scoped to \`${project.name}\`.`,
+    'For larger batches, split current work into `Tasklists/active/<feature-or-iteration>.md`.',
+    'Move completed or stale batches to `Tasklists/archive/YYYY-MM.md`; archive files are not scanned for the active dashboard.',
+    `Default inline fields: [project:: ${project.name}] [role:: ${role.name}] [owner:: ${project.owner || `maintainer:${project.name}`}] [status:: pending]`,
+    '',
+  ].join('\n');
+}
+
+function ensureTasklists(base: string): void {
+  ensureDir(path.join(base, 'Tasklists', 'active'));
+  writeIfMissing(path.join(base, 'Tasklists', 'active', '.gitkeep'), '');
+  ensureDir(path.join(base, 'Tasklists', 'archive'));
+  writeIfMissing(path.join(base, 'Tasklists', 'archive', '.gitkeep'), '');
+}
+
 function crewPathForHome(): string {
   return process.env.RIG_HOME || path.join(process.env.HOME || '', '.rig');
 }
@@ -204,8 +252,10 @@ function renderVaultAgentInstructions(crew: CrewEntry): string {
     `- Dashboard: \`${root}/Team-Dashboard.md\``,
     `- Inbox: \`${root}/Inbox.md\``,
     `- Role registry: \`${root}/Shared/Roles.md\``,
+    `- Reusable role descriptions: \`${root}/<role>/Role.md\` and \`${root}/Roles/<custom-role>/Role.md\``,
     `- Project owner memory: \`${root}/Projects/<project>/\``,
-    `- Custom role workspaces: \`${root}/Roles/<role>/\``,
+    `- Project-scoped agent tasks: \`${root}/Projects/<project>/Agents/<role>/Tasks.md\``,
+    `- Large active task batches: \`${root}/Projects/<project>/Tasklists/active/*.md\` and \`${root}/Projects/<project>/Agents/<role>/Tasklists/active/*.md\`. Keep \`Tasks.md\` short; archived tasklists are not part of the active dashboard.`,
     '- Vault-local scratch projects belong under `tmp/<project>/`.',
     '- User-level rules, test accounts, custom roles, and research output policy live under `~/.rig/`.',
     '- Coordinate through Vault files; do not start or assume a separate multi-agent runtime inside a project repo.',
@@ -217,10 +267,10 @@ function renderVaultAgentInstructions(crew: CrewEntry): string {
     '0. Do not treat `rig crew` as a human-facing command workflow. If you can run the command or update the Vault files yourself, do it instead of asking the human to run it.',
     '1. If the user asks for planning, multi-agent coordination, PRD, research, testing strategy, project owner work, role routing, reports, or broad project changes, hand the request to Crew Lead first.',
     `2. Preferred handoff: run \`rig crew "<user request>"\`, then read \`${root}/Team-Dashboard.md\`, \`${root}/Inbox.md\`, and \`${root}/Shared/Roles.md\`.`,
-    `3. Maintain status awareness before and after work by checking \`${root}/Team-Dashboard.md\`, \`${root}/Inbox.md\`, \`${root}/Shared/Roles.md\`, role \`Tasks.md\`, and project \`Tasks.md\` files.`,
-    `4. If the CLI is unavailable, append the request to \`${root}/Current-Goal.md\` and create/update a Lead task in \`${root}/Lead/Tasks.md\`; then refresh the dashboard when possible.`,
+    `3. Maintain status awareness before and after work by checking \`${root}/Team-Dashboard.md\`, \`${root}/Inbox.md\`, \`${root}/Shared/Roles.md\`, project \`Tasks.md\`, project agent \`Agents/<role>/Tasks.md\`, and active tasklists.`,
+    `4. If the CLI is unavailable, append the request to \`${root}/Current-Goal.md\`; when a project is known, route small/current work to \`${root}/Projects/<project>/Tasks.md\` or \`${root}/Projects/<project>/Agents/<role>/Tasks.md\`, and route larger batches to \`Tasklists/active/<feature-or-iteration>.md\`; then refresh the dashboard when possible.`,
     '5. Treat Crew Lead as the default orchestrator prompt/protocol, not as a required Claude/Codex subagent. Subagents may be used as optional executors for specific roles, but Vault files are the source of truth.',
-    '6. Lead communicates with other roles through Markdown tasks and delegation packets, not private chat state. Use `[role:: <role>]`, `[owner:: <owner>]`, `[project:: <project>]`, `[executor:: <executor>]`, and status fields in the relevant `Tasks.md`.',
+    '6. Lead communicates with other roles through Markdown tasks and delegation packets, not private chat state. Use `[role:: <role>]`, `[owner:: <owner>]`, `[project:: <project>]`, `[executor:: <executor>]`, and status fields in the relevant project-scoped `Tasks.md`.',
     `7. Worker results must be written back to the relevant role/project files under \`${root}/\`; user-facing questions go to \`${root}/Inbox.md\` for Lead to surface.`,
     '',
     AGENT_RULES_END,

package/lib/wiki/config.ts

@@ -109,7 +109,11 @@ function composeEntry(vaultPath: string, vault: VaultConfig): WikiEntry {
     name: vault.name || path.basename(vaultPath),
     path: vaultPath,
     root,
-    include: vault.include ?? ['**/*.md'],
+    // Default: walk everything visible. Binary extensions, hidden dirs,
+    // and .gitignored content are filtered at walk time by scan.ts /
+    // surveyed by `rig wiki survey`. include/exclude in vault config
+    // remain available as escape hatches for power users.
+    include: vault.include ?? ['**/*'],
     exclude: vault.exclude ?? [],
     schedule: vault.schedule ?? DEFAULT_SCHEDULE,
     ingestRules: vault.ingestRules ?? [{ match: 'raw/**/*.md', mode: 'auto-on-new' }],

package/lib/wiki/db.ts

@@ -69,3 +69,32 @@ export function getLastRun(wiki: string, op: string): { ts: number; exit_code: n
     .prepare('SELECT ts, exit_code FROM last_run WHERE wiki = ? AND op = ?')
     .get(wiki, op) as { ts: number; exit_code: number } | undefined;
 }
+
+/**
+ * Upsert one source-sha row. Path is the **root-relative** path (same key
+ * `scan` uses), so subsequent `scan` runs can detect drift via the same map.
+ */
+export function upsertSourceSha(wiki: string, relPath: string, sha: string, mtimeMs: number): void {
+  getDb().prepare(
+    `INSERT INTO source_sha (wiki, path, sha, mtime) VALUES (?, ?, ?, ?)
+     ON CONFLICT(wiki, path) DO UPDATE SET sha = excluded.sha, mtime = excluded.mtime`
+  ).run(wiki, relPath, sha, Math.floor(mtimeMs));
+}
+
+/** Bulk-upsert variant for `scan --baseline`. Uses a single transaction. */
+export function upsertSourceShasBulk(wiki: string, rows: { path: string; sha: string; mtimeMs: number }[]): void {
+  if (rows.length === 0) return;
+  const db = getDb();
+  const stmt = db.prepare(
+    `INSERT INTO source_sha (wiki, path, sha, mtime) VALUES (?, ?, ?, ?)
+     ON CONFLICT(wiki, path) DO UPDATE SET sha = excluded.sha, mtime = excluded.mtime`
+  );
+  const tx = db.transaction((items: { path: string; sha: string; mtimeMs: number }[]) => {
+    for (const r of items) stmt.run(wiki, r.path, r.sha, Math.floor(r.mtimeMs));
+  });
+  tx(rows);
+}
+
+export function deleteSourceSha(wiki: string, relPath: string): void {
+  getDb().prepare('DELETE FROM source_sha WHERE wiki = ? AND path = ?').run(wiki, relPath);
+}

package/lib/wiki/fileTypes.ts

@@ -0,0 +1,52 @@
+// Default file-type filters shared by `scan` and `survey`. Anything in
+// BINARY_EXTENSIONS is excluded BEFORE we even consider asking the agent
+// about it — these are categorically not wiki sources.
+//
+// The wiki's own schema.md "Ingestion policy" section drives further
+// (LLM-applied) filtering inside `rig wiki survey`. This file is just
+// the hard floor.
+
+import path from 'path';
+
+// Extensions matched by simple basename suffix. Lowercase, leading dot.
+const BINARY_EXTENSIONS: ReadonlySet<string> = new Set([
+  // archives
+  '.zip', '.tar', '.tgz', '.gz', '.bz2', '.xz', '.7z', '.rar', '.dmg', '.iso',
+  // binaries / native modules
+  '.exe', '.dll', '.so', '.dylib', '.bin', '.o', '.a', '.lib',
+  '.class', '.jar', '.pyc', '.pyo', '.node', '.wasm',
+  // audio / video
+  '.mp4', '.mov', '.mkv', '.avi', '.webm', '.wmv', '.flv',
+  '.mp3', '.wav', '.flac', '.aac', '.ogg', '.m4a', '.opus',
+  // design / proprietary
+  '.psd', '.ai', '.fig', '.sketch', '.fla', '.indd', '.xd',
+  // model weights / embeddings
+  '.gguf', '.safetensors', '.pt', '.pth', '.onnx', '.h5', '.pkl', '.npz', '.tflite',
+  // build / lock / source-map artifacts (handled by .min.js / .lock suffix too)
+  '.map', '.tsbuildinfo',
+  // misc
+  '.ds_store', '.pyd', '.swp', '.swo',
+]);
+
+// Filename patterns matched by exact basename or known suffix combos.
+function isBinaryByName(basename: string): boolean {
+  const lower = basename.toLowerCase();
+  // multi-segment archives
+  if (lower.endsWith('.tar.gz') || lower.endsWith('.tar.bz2') || lower.endsWith('.tar.xz')) return true;
+  // minified js / source maps
+  if (lower.endsWith('.min.js') || lower.endsWith('.min.css') || lower.endsWith('.bundle.js')) return true;
+  // lockfiles
+  if (lower === 'yarn.lock' || lower === 'package-lock.json' || lower === 'pnpm-lock.yaml' || lower === 'cargo.lock' || lower === 'composer.lock' || lower === 'gemfile.lock') return true;
+  if (lower.endsWith('.lock')) return true;
+  return false;
+}
+
+/**
+ * True if the file should be skipped as a wiki source on extension /
+ * filename grounds alone. Cheap, deterministic, no I/O.
+ */
+export function isBinaryExtension(filePath: string): boolean {
+  const ext = path.extname(filePath).toLowerCase();
+  if (ext && BINARY_EXTENSIONS.has(ext)) return true;
+  return isBinaryByName(path.basename(filePath));
+}

package/lib/wiki/index.ts

@@ -1,5 +1,6 @@
 import wikiInit from './init';
 import wikiScan from './scan';
+import wikiSurvey from './survey';
 import wikiFetch from './fetch';
 import wikiIngest from './ingest';
 import wikiQuery from './query';
@@ -25,9 +26,18 @@ export function registerWikiCommands(program: any): void {
 
   wiki.command('scan')
     .description('compute NEW/MODIFIED/DELETED/RAW DRIFT report for the vault resolved from CWD')
+    .option('-b, --baseline', 'commit current shas into state.db so future scans can detect drift (no wiki content changed)')
     .option('--json', 'machine-readable output')
     .action(wikiScan);
 
+  wiki.command('survey')
+    .description('triage candidate files via schema.md "Ingestion policy" — agent decides ingest/skip/unclear per file')
+    .option('-a, --apply', 'auto-ingest every "ingest" decision (sequential)')
+    .option('-l, --limit <n>', `cap candidates passed to the agent (default 500)`, (v) => parseInt(v, 10))
+    .option('--no-agent', 'skip agent classification; accept every non-binary candidate (local rules only)')
+    .option('--json', 'machine-readable output')
+    .action(wikiSurvey);
+
   wiki.command('fetch <url>')
     .description('verbatim download URL into raw/YYYY-MM-DD-<slug>.md')
     .option('--slug <slug>', 'override the auto-derived slug')