rigjs 3.0.32 → 4.0.2

package/lib/crew/board.ts

@@ -0,0 +1,123 @@
+import path from 'path';
+import print from '../print';
+import { requireCrew, shortPath } from './config';
+import { scanTasks, openInboxTasks, summarize, taskProgress, CrewTask } from './task';
+import { rootPath, writeText, readText } from './vault';
+import { writeCrewState } from './state';
+import { roleDefinitionsForCrew } from './role';
+
+interface BoardOpts { crew?: string; }
+
+export default function crewBoard(opts: BoardOpts): void {
+  const crew = requireCrew(opts.crew);
+  const tasks = scanTasks(crew);
+  const inbox = openInboxTasks(crew);
+  const summary = summarize(tasks);
+  const dashboard = renderDashboard(crew, tasks, inbox);
+  const file = rootPath(crew, 'Team-Dashboard.md');
+  writeText(file, dashboard);
+  writeCrewState(crew, tasks);
+  print.succeed(`crew dashboard refreshed: ${shortPath(file)}`);
+  print.info(`tasks: ${summary.done}/${summary.total} done, inbox: ${inbox.length} open`);
+}
+
+function renderDashboard(crew: ReturnType<typeof requireCrew>, tasks: CrewTask[], inbox: CrewTask[]): string {
+  const summary = summarize(tasks);
+  const health = summary.blocked > 0 ? 'At Risk' : 'On Track';
+  const goal = currentGoal(rootPath(crew, 'Current-Goal.md'));
+  return [
+    '# Team Dashboard',
+    '',
+    `Last updated: ${new Date().toISOString()}`,
+    '',
+    '## Lead Brief',
+    '',
+    `Current Goal: ${goal || '_No current goal yet_'}`,
+    `Overall: ${taskProgress(tasks)}% (${summary.done}/${summary.total})`,
+    `Health: ${health}`,
+    `Next Agent Action: ${inbox.length > 0 ? 'Read `rig crew inbox` and surface only needed decisions to the human.' : 'Run `rig crew` to continue the next Lead tick.'}`,
+    '',
+    '## Needs Your Attention',
+    '',
+    inboxTable(inbox),
+    '',
+    '## Project Progress',
+    '',
+    projectTable(crew, tasks),
+    '',
+    '## Role Progress',
+    '',
+    roleTable(crew, tasks),
+    '',
+    '## Blockers',
+    '',
+    blockersTable(tasks),
+    '',
+    '## Active Tasks',
+    '',
+    activeTable(tasks),
+    '',
+  ].join('\n');
+}
+
+function currentGoal(file: string): string {
+  const lines = readText(file)
+    .split(/\r?\n/)
+    .map(l => l.trim())
+    .filter(l => l && l.charAt(0) !== '#');
+  return lines.length ? lines[lines.length - 1].replace(/^\-\s*/, '') : '';
+}
+
+function inboxTable(tasks: CrewTask[]): string {
+  if (tasks.length === 0) return '_No open inbox items._';
+  const rows = tasks.map(t => `| ${t.id || '-'} | ${t.fields.type || '-'} | ${cleanTaskText(t.text)} | ${t.fields.priority || '-'} |`);
+  return ['| ID | Type | Item | Priority |', '|---|---|---|---|'].concat(rows).join('\n');
+}
+
+function projectTable(crew: ReturnType<typeof requireCrew>, tasks: CrewTask[]): string {
+  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 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)} |`;
+  });
+  return ['| Project | Owner | Executor | Health | Open | Blocked | Path |', '|---|---|---|---|---:|---:|---|'].concat(rows).join('\n');
+}
+
+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 s = summarize(scoped);
+    return `| ${role.title} | ${taskProgress(scoped)}% | ${s.doing} | ${s.blocked} | ${s.open} |`;
+  });
+  return ['| Role | Progress | WIP | Blocked | Open |', '|---|---:|---:|---:|---:|'].concat(rows).join('\n');
+}
+
+function blockersTable(tasks: CrewTask[]): string {
+  const blocked = tasks.filter(t => (t.fields.status || '').toLowerCase() === 'blocked');
+  if (blocked.length === 0) return '_No blockers._';
+  const rows = blocked.slice(0, 20).map(t => `| ${t.id || '-'} | ${t.fields.owner || t.scope} | ${cleanTaskText(t.text)} | ${relFile(t)} |`);
+  return ['| ID | Owner | Blocker | File |', '|---|---|---|---|'].concat(rows).join('\n');
+}
+
+function activeTable(tasks: CrewTask[]): string {
+  const active = tasks.filter(t => !t.done && t.scope !== 'inbox').slice(0, 20);
+  if (active.length === 0) return '_No active tasks._';
+  const rows = active.map(t => `| ${t.id || '-'} | ${t.fields.project || '-'} | ${t.fields.owner || displayScope(t.scope)} | ${t.fields.status || 'pending'} | ${cleanTaskText(t.text)} |`);
+  return ['| ID | Project | Owner | Status | Task |', '|---|---|---|---|---|'].concat(rows).join('\n');
+}
+
+function displayScope(scope: string): string {
+  return scope.startsWith('role:') ? scope.slice('role:'.length) : scope;
+}
+
+function cleanTaskText(text: string): string {
+  return text.replace(/\[[A-Za-z0-9_-]+::\s*[^\]]+\]/g, '').trim().replace(/\|/g, '\\|');
+}
+
+function relFile(t: CrewTask): string {
+  return path.basename(t.file) + ':' + t.line;
+}

package/lib/crew/config.ts

@@ -0,0 +1,109 @@
+import fs from 'fs';
+import path from 'path';
+import { crewPaths } from './paths';
+import { BUILTIN_ROLE_NAMES, loadGlobalRoleNames, normalizeRoleNames } from './role';
+
+export type CrewRole = string;
+export type CrewExecutor = 'claude' | 'codex' | 'pi';
+
+export interface CrewProject {
+  name: string;
+  path: string;
+  owner: string;
+  defaultExecutor?: CrewExecutor;
+  canWriteCode?: boolean;
+  defaultTestCommand?: string;
+}
+
+export interface CrewEntry {
+  name: string;
+  vault: string;
+  root: string;
+  defaultExecutor?: CrewExecutor;
+  mode?: 'leader-first';
+  dashboard?: string;
+  state?: { backend?: 'sqlite' | 'json' };
+  roles?: CrewRole[];
+  projects?: CrewProject[];
+}
+
+export interface CrewConfig {
+  defaultCrew?: string;
+  crews: CrewEntry[];
+}
+
+export const DEFAULT_ROLES: CrewRole[] = BUILTIN_ROLE_NAMES;
+export const DEFAULT_CREW_ROOT = 'rig-agents';
+
+const DEFAULT_CONFIG: CrewConfig = { crews: [] };
+
+export function ensureCrewHome(): void {
+  fs.mkdirSync(crewPaths.home, { recursive: true });
+  fs.mkdirSync(crewPaths.crewDir, { recursive: true });
+  fs.mkdirSync(crewPaths.rolesDir, { recursive: true });
+}
+
+export function loadCrewConfig(): CrewConfig {
+  ensureCrewHome();
+  if (!fs.existsSync(crewPaths.config)) return { ...DEFAULT_CONFIG };
+  try {
+    const cfg = JSON.parse(fs.readFileSync(crewPaths.config, 'utf8')) as CrewConfig;
+    if (!Array.isArray(cfg.crews)) cfg.crews = [];
+    return cfg;
+  } catch (e: any) {
+    throw new Error(`failed to parse ${crewPaths.config}: ${e.message}`);
+  }
+}
+
+export function saveCrewConfig(cfg: CrewConfig): void {
+  ensureCrewHome();
+  fs.writeFileSync(crewPaths.config, JSON.stringify(cfg, null, 2) + '\n', 'utf8');
+}
+
+export function upsertCrew(entry: CrewEntry): CrewConfig {
+  const cfg = loadCrewConfig();
+  const i = cfg.crews.findIndex(c => c.name === entry.name);
+  if (i >= 0) cfg.crews[i] = entry;
+  else cfg.crews.push(entry);
+  if (!cfg.defaultCrew) cfg.defaultCrew = entry.name;
+  saveCrewConfig(cfg);
+  return cfg;
+}
+
+export function resolveCrew(name?: string): CrewEntry | undefined {
+  const cfg = loadCrewConfig();
+  if (name) return cfg.crews.find(c => c.name === name);
+  if (cfg.defaultCrew) {
+    const found = cfg.crews.find(c => c.name === cfg.defaultCrew);
+    if (found) return found;
+  }
+  if (cfg.crews.length === 1) return cfg.crews[0];
+  const cwd = process.cwd();
+  return cfg.crews.find(c => cwd === c.vault || cwd.startsWith(c.vault + path.sep));
+}
+
+export function normalizeCrew(entry: CrewEntry): CrewEntry {
+  return {
+    ...entry,
+    root: entry.root || DEFAULT_CREW_ROOT,
+    dashboard: entry.dashboard || path.join(entry.root || DEFAULT_CREW_ROOT, 'Team-Dashboard.md'),
+    defaultExecutor: entry.defaultExecutor || 'claude',
+    mode: entry.mode || 'leader-first',
+    state: entry.state || { backend: 'json' },
+    roles: normalizeRoleNames([...(entry.roles || DEFAULT_ROLES), ...loadGlobalRoleNames()]),
+    projects: entry.projects || [],
+  };
+}
+
+export function requireCrew(name?: string): CrewEntry {
+  const crew = resolveCrew(name);
+  if (!crew) {
+    throw new Error('no crew configured. Run `rig crew init --vault <path>` first.');
+  }
+  return normalizeCrew(crew);
+}
+
+export function shortPath(p: string): string {
+  const home = process.env.HOME || '';
+  return home && p.startsWith(home) ? '~' + p.slice(home.length) : p;
+}

package/lib/crew/doctor.ts

@@ -0,0 +1,40 @@
+import fs from 'fs';
+import path from 'path';
+import print from '../print';
+import { requireCrew, shortPath } from './config';
+import { crewPaths } from './paths';
+import { rootPath } from './vault';
+import { loadCustomRoleDefinitions } from './role';
+
+interface DoctorOpts { crew?: string; }
+
+export default function crewDoctor(opts: DoctorOpts): void {
+  const crew = requireCrew(opts.crew);
+  const checks: { name: string; ok: boolean; detail: string }[] = [];
+  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, '')) });
+  checks.push({ name: 'current goal', ok: fs.existsSync(rootPath(crew, 'Current-Goal.md')), detail: path.join(crew.root, 'Current-Goal.md') });
+  checks.push({ name: 'inbox', ok: fs.existsSync(rootPath(crew, 'Inbox.md')), detail: path.join(crew.root, 'Inbox.md') });
+  checks.push({ name: 'vault CLAUDE.md', ok: fs.existsSync(path.join(crew.vault, 'CLAUDE.md')), detail: 'CLAUDE.md' });
+  checks.push({ name: 'vault AGENTS.md', ok: fs.existsSync(path.join(crew.vault, 'AGENTS.md')), detail: 'AGENTS.md' });
+  checks.push({ name: 'user RIG.md', ok: fs.existsSync(crewPaths.userRules), detail: shortPath(crewPaths.userRules) });
+  checks.push({ name: 'roles dir', ok: fs.existsSync(crewPaths.rolesDir), detail: shortPath(crewPaths.rolesDir) });
+  checks.push({ name: 'role registry', ok: fs.existsSync(rootPath(crew, 'Shared/Roles.md')), detail: path.join(crew.root, 'Shared/Roles.md') });
+  for (const role of loadCustomRoleDefinitions()) {
+    checks.push({ name: `role ${role.name} prompt`, ok: !!role.promptPath && fs.existsSync(role.promptPath), detail: role.promptPath ? shortPath(role.promptPath) : '-' });
+  }
+  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} path`, ok: fs.existsSync(project.path), detail: shortPath(project.path) });
+  }
+
+  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})`); }
+  }
+  if (failed > 0) process.exitCode = 1;
+}

package/lib/crew/inbox.ts

@@ -0,0 +1,29 @@
+import print from '../print';
+import { requireCrew } from './config';
+import { openInboxTasks } from './task';
+
+interface InboxOpts { crew?: string; json?: boolean; }
+
+export default function crewInbox(opts: InboxOpts): void {
+  const crew = requireCrew(opts.crew);
+  const items = openInboxTasks(crew);
+  if (opts.json) {
+    // eslint-disable-next-line no-console
+    console.log(JSON.stringify({ ok: true, data: items }, null, 2));
+    return;
+  }
+  if (items.length === 0) {
+    print.info('inbox is empty.');
+    return;
+  }
+  print.info(`open inbox items: ${items.length}`);
+  for (const t of items) {
+    // eslint-disable-next-line no-console
+    console.log(`- ${t.id || 'NO-ID'} ${clean(t.text)} (${t.fields.priority || 'no priority'})`);
+  }
+}
+
+function clean(text: string): string {
+  return text.replace(/\[[A-Za-z0-9_-]+::\s*[^\]]+\]/g, '').trim();
+}
+

package/lib/crew/index.ts

@@ -0,0 +1,108 @@
+import crewInit from './init';
+import crewStatus from './status';
+import crewBoard from './board';
+import crewInbox from './inbox';
+import crewSync from './sync';
+import crewDoctor from './doctor';
+import crewAsk from './ask';
+import crewStub from './stub';
+import { projectAdd, projectList, projectStatus } from './project';
+import { roleAdd, roleList, roleShow } from './roleCommand';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function registerCrewCommands(program: any): void {
+  const crew = program.command('crew [message...]')
+    .description('Leader-first multi-agent workspace over an Obsidian vault')
+    .option('-c, --crew <name>', 'target crew name')
+    .action((message: string[] | undefined, opts: { crew?: string }) => crewAsk(message, opts));
+
+  crew.command('init')
+    .description('initialize a crew vault')
+    .requiredOption('--vault <path>', 'Obsidian vault path')
+    .option('-n, --as <name>', 'crew name')
+    .option('--root <path>', 'root folder inside the vault (default: Agents)')
+    .option('--allow-project-vault', 'allow a vault path under projects/<submodule>')
+    .action(crewInit);
+
+  crew.command('ask <message...>')
+    .description('send a message to the Lead (MVP appends to Current-Goal.md)')
+    .option('-c, --crew <name>', 'target crew name')
+    .action(crewAsk);
+
+  crew.command('status')
+    .description('show crew progress summary')
+    .option('-c, --crew <name>', 'target crew name')
+    .option('--json', 'machine-readable output')
+    .action(crewStatus);
+
+  crew.command('inbox')
+    .description('show open user attention items')
+    .option('-c, --crew <name>', 'target crew name')
+    .option('--json', 'machine-readable output')
+    .action(crewInbox);
+
+  crew.command('board')
+    .description('refresh Agents/Team-Dashboard.md')
+    .option('-c, --crew <name>', 'target crew name')
+    .action(crewBoard);
+
+  crew.command('sync')
+    .description('scan Markdown tasks and update crew state cache')
+    .option('-c, --crew <name>', 'target crew name')
+    .action(crewSync);
+
+  crew.command('doctor')
+    .description('check crew config, vault, rules, and project wiring')
+    .option('-c, --crew <name>', 'target crew name')
+    .action(crewDoctor);
+
+  const project = crew.command('project').description('manage project owners');
+  project.command('add <name>')
+    .description('register a project owner')
+    .requiredOption('--path <path>', 'project path')
+    .option('--owner <name>', 'owner alias (default: maintainer:<name>)')
+    .option('--executor <name>', 'claude | codex | pi (default: crew defaultExecutor)')
+    .option('--test-command <cmd>', 'default focused test command')
+    .option('--no-write', 'mark owner as read-only')
+    .option('-c, --crew <name>', 'target crew name')
+    .action(projectAdd);
+  project.command('list')
+    .description('list registered projects')
+    .option('-c, --crew <name>', 'target crew name')
+    .action(projectList);
+  project.command('status <name>')
+    .description('show one project status')
+    .option('-c, --crew <name>', 'target crew name')
+    .action(projectStatus);
+
+  const role = crew.command('role').description('manage global crew roles');
+  role.command('add <name>')
+    .description('add or update a global role from a markdown description')
+    .requiredOption('--from <file>', 'role description markdown file')
+    .option('--title <title>', 'display title')
+    .option('--summary <text>', 'short description')
+    .option('--agent <name>', 'agent/subagent name to use for this role')
+    .option('--executor <name>', 'claude | codex | pi')
+    .option('--force', 'update an existing custom role')
+    .option('-c, --crew <name>', 'also materialize role files in this crew vault')
+    .action(roleAdd);
+  role.command('list')
+    .description('list built-in and custom roles')
+    .option('-c, --crew <name>', 'target crew name')
+    .action(roleList);
+  role.command('show <name>')
+    .description('show one role definition')
+    .option('-c, --crew <name>', 'target crew name')
+    .action(roleShow);
+
+  crew.command('plan').description('planned: Lead refine + decompose').action(crewStub('plan'));
+  crew.command('refine').description('planned: update Shared/Spec.md').action(crewStub('refine'));
+  crew.command('decompose').description('planned: split Spec into owner/role tasks').action(crewStub('decompose'));
+  crew.command('run [target]').description('planned: run owner/role work').action(crewStub('run'));
+  crew.command('research <topic...>').description('planned: ask Researcher to write a report').action(crewStub('research'));
+  crew.command('report').description('planned: generate Lead report').action(crewStub('report'));
+
+  const pm = crew.command('pm').description('PM tools');
+  pm.command('prd').description('planned: generate/update PRD').action(crewStub('pm prd'));
+  pm.command('review <file>').description('planned: review PRD/Spec').action(crewStub('pm review'));
+}

package/lib/crew/init.ts

@@ -0,0 +1,113 @@
+import fs from 'fs';
+import path from 'path';
+import print from '../print';
+import { CrewEntry, DEFAULT_CREW_ROOT, DEFAULT_ROLES, loadCrewConfig, saveCrewConfig, normalizeCrew, shortPath } from './config';
+import { ensureCrewVault } from './vault';
+import { crewPaths } from './paths';
+
+interface InitOpts {
+  vault: string;
+  as?: string;
+  root?: string;
+  allowProjectVault?: boolean;
+}
+
+export default function crewInit(opts: InitOpts): void {
+  if (!opts.vault) {
+    print.error('missing --vault <path>');
+    process.exit(1);
+  }
+  const vault = path.resolve(opts.vault);
+  if (isUnderProjects(vault) && !opts.allowProjectVault) {
+    print.error('refusing to initialize a crew vault under projects/<submodule>. Pass --allow-project-vault only if you understand the data exposure risk.');
+    process.exit(1);
+  }
+  fs.mkdirSync(vault, { recursive: true });
+  const name = opts.as || path.basename(vault) || 'personal';
+  const cfg = loadCrewConfig();
+  const idx = cfg.crews.findIndex(c => c.name === name);
+  const existing = idx >= 0 ? normalizeCrew(cfg.crews[idx]) : undefined;
+  const root = opts.root || existing?.root || DEFAULT_CREW_ROOT;
+  const entry: CrewEntry = normalizeCrew({
+    name,
+    vault,
+    root,
+    defaultExecutor: existing?.defaultExecutor || 'claude',
+    mode: 'leader-first',
+    dashboard: path.join(root, 'Team-Dashboard.md'),
+    state: existing?.state || { backend: 'json' },
+    roles: existing?.roles || DEFAULT_ROLES,
+    projects: existing?.projects || [],
+  });
+
+  if (idx >= 0) cfg.crews[idx] = entry;
+  else cfg.crews.push(entry);
+  if (!cfg.defaultCrew) cfg.defaultCrew = name;
+  saveCrewConfig(cfg);
+  writeUserRulesIfMissing();
+  ensureCrewVault(entry);
+  print.succeed(`crew "${name}" initialized at ${shortPath(vault)}`);
+  print.info(`agent next: use \`rig crew "<user request>"\` or update ${path.join(root, 'Current-Goal.md')} when coordinating this Vault`);
+}
+
+function isUnderProjects(p: string): boolean {
+  const workspaceRoot = findOvermindRoot(process.cwd()) || findOvermindRoot(p);
+  if (!workspaceRoot) return false;
+  const projectsDir = path.join(workspaceRoot, 'projects');
+  return p === projectsDir || p.startsWith(projectsDir + path.sep);
+}
+
+function findOvermindRoot(start: string): string | undefined {
+  let dir = path.resolve(start);
+  while (true) {
+    if (fs.existsSync(path.join(dir, 'AGENTS.md')) && fs.existsSync(path.join(dir, 'projects'))) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) return undefined;
+    dir = parent;
+  }
+}
+
+function writeUserRulesIfMissing(): void {
+  if (fs.existsSync(crewPaths.userRules)) return;
+  fs.writeFileSync(crewPaths.userRules, `# RIG User Rules
+
+## Credential Sources
+
+- Default credential doc: <path-to-private-keychain-or-env-doc>
+- Prefer env vars or system keychain for actual passwords.
+- Never copy passwords, cookies, auth storage, production traces, or real user data into project repos.
+
+## Account Aliases
+
+| Alias | Source | Usage |
+|---|---|---|
+| \`<project>.staging.viewer\` | <env/keychain/doc section> | Read-only staging E2E |
+| \`<project>.production.readonly\` | <env/keychain/doc section> | Production read-only reproduction, \`@prod-readonly\` only |
+
+## Research Output Policy
+
+- Default research report directory: <crew-root>/Researcher/Reports
+- Resolve relative paths from the current crew Vault root.
+- If the user requests an explicit output directory, use that directory unless it is inside a project submodule or contains secrets.
+- If neither the user request nor this section gives a clear destination, ask Lead to create an Inbox question instead of guessing.
+
+| Scope | Directory | Notes |
+|---|---|---|
+| default | <crew-root>/Researcher/Reports | General research reports |
+| project:<name> | <crew-root>/Projects/<name>/Research | Project-specific research notes |
+
+## Production Rules
+
+- Production tests are opt-in only.
+- Use read-only test accounts only.
+- Do not create, update, delete, pay, publish, deploy, or message real users.
+
+## Frontend Testing Rules
+
+- Default to PRD-scoped Playwright E2E for frontend/UI behavior.
+- Do not add frontend unit tests by default.
+- Do not add frontend integration tests by default.
+- Do not run full historical E2E unless risk requires it.
+- Always report what was run and what was intentionally skipped.
+`, 'utf8');
+}

package/lib/crew/paths.ts

@@ -0,0 +1,13 @@
+import os from 'os';
+import path from 'path';
+
+export const RIG_HOME = process.env.RIG_HOME || path.join(os.homedir(), '.rig');
+
+export const crewPaths = {
+  home: RIG_HOME,
+  crewDir: path.join(RIG_HOME, 'crew'),
+  rolesDir: path.join(RIG_HOME, 'crew', 'roles'),
+  config: path.join(RIG_HOME, 'crew.config.json'),
+  state: path.join(RIG_HOME, 'crew-state.json'),
+  userRules: path.join(RIG_HOME, 'RIG.md'),
+};

package/lib/crew/project.ts

@@ -0,0 +1,84 @@
+import path from 'path';
+import print from '../print';
+import { loadCrewConfig, saveCrewConfig, requireCrew, normalizeCrew, CrewProject, shortPath } from './config';
+import { ensureProject } from './vault';
+import { scanTasks, summarize } from './task';
+import { CrewExecutor } from './config';
+
+interface ProjectOpts {
+  crew?: string;
+  path?: string;
+  owner?: string;
+  executor?: string;
+  testCommand?: string;
+  noWrite?: boolean;
+}
+
+export function projectAdd(name: string, opts: ProjectOpts): void {
+  const cfg = loadCrewConfig();
+  const crew = requireCrew(opts.crew);
+  if (!opts.path) {
+    print.error('missing --path <path>');
+    process.exit(1);
+  }
+  const project: CrewProject = {
+    name,
+    path: path.resolve(opts.path),
+    owner: opts.owner || `maintainer:${name}`,
+    defaultExecutor: parseExecutor(opts.executor || crew.defaultExecutor || 'claude'),
+    canWriteCode: !opts.noWrite,
+    defaultTestCommand: opts.testCommand,
+  };
+  const crewIndex = cfg.crews.findIndex(c => c.name === crew.name);
+  const entry = normalizeCrew(cfg.crews[crewIndex]);
+  const projects = entry.projects || [];
+  const i = projects.findIndex(p => p.name === name);
+  if (i >= 0) projects[i] = project;
+  else projects.push(project);
+  entry.projects = projects;
+  cfg.crews[crewIndex] = entry;
+  saveCrewConfig(cfg);
+  ensureProject(entry, project);
+  print.succeed(`project "${name}" registered: ${shortPath(project.path)}`);
+}
+
+export function projectList(opts: ProjectOpts): void {
+  const crew = requireCrew(opts.crew);
+  const projects = crew.projects || [];
+  if (projects.length === 0) {
+    print.info('no projects registered. Use `rig crew project add <name> --path <path>`.');
+    return;
+  }
+  // eslint-disable-next-line no-console
+  console.log('NAME  OWNER  EXECUTOR  CAN WRITE  TEST COMMAND  PATH');
+  // eslint-disable-next-line no-console
+  console.log('----  -----  --------  ---------  ------------  ----');
+  for (const p of projects) {
+    // eslint-disable-next-line no-console
+    console.log(`${p.name}  ${p.owner}  ${p.defaultExecutor || crew.defaultExecutor || 'claude'}  ${p.canWriteCode === false ? 'no' : 'yes'}  ${p.defaultTestCommand || '-'}  ${shortPath(p.path)}`);
+  }
+}
+
+export function projectStatus(name: string, opts: ProjectOpts): void {
+  const crew = requireCrew(opts.crew);
+  const project = (crew.projects || []).find(p => p.name === name);
+  if (!project) {
+    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 s = summarize(tasks);
+  print.info(`project: ${name} (${project.owner})`);
+  // eslint-disable-next-line no-console
+  console.log(`path: ${shortPath(project.path)}`);
+  // eslint-disable-next-line no-console
+  console.log(`executor: ${project.defaultExecutor || crew.defaultExecutor || 'claude'}`);
+  // eslint-disable-next-line no-console
+  console.log(`tasks: ${s.done}/${s.total} done, ${s.open} open, ${s.blocked} blocked`);
+}
+
+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);
+}