rigjs 4.0.7 → 4.0.8

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/ingest.ts

@@ -223,16 +223,37 @@ 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):`,
@@ -251,16 +272,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

@@ -98,17 +98,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rigjs",
-  "version": "4.0.7",
+  "version": "4.0.8",
   "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": [