rigjs 4.0.18 → 4.1.0

package/lib/crew/init.ts

@@ -34,7 +34,7 @@ export default function crewInit(opts: InitOpts): void {
     root,
     defaultExecutor: existing?.defaultExecutor || 'claude',
     mode: 'leader-first',
-    dashboard: path.join(root, 'Team-Dashboard.md'),
+    dashboard: path.join(root, 'Dashboard.md'),
     state: existing?.state || { backend: 'json' },
     roles: existing?.roles || DEFAULT_ROLES,
     projects: existing?.projects || [],
@@ -47,7 +47,7 @@ export default function crewInit(opts: InitOpts): void {
   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`);
+  print.info(`agent next: use \`rig orchestrate "<user request>"\` or update ${path.join(root, 'Current-Goal.md')} when coordinating this Vault`);
 }
 
 function isUnderProjects(p: string): boolean {
@@ -89,7 +89,7 @@ function writeUserRulesIfMissing(): void {
 - 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.
+- If neither the user request nor this section gives a clear destination, ask the Orchestrator to create a Pending-Questions entry instead of guessing.
 
 | Scope | Directory | Notes |
 |---|---|---|

package/lib/crew/{inbox.ts → pendingQuestions.ts}

@@ -1,22 +1,22 @@
 import print from '../print';
 import { requireCrew } from './config';
-import { openInboxTasks } from './task';
+import { openPendingQuestions } from './task';
 
-interface InboxOpts { crew?: string; json?: boolean; }
+interface PendingQuestionsOpts { crew?: string; json?: boolean; }
 
-export default function crewInbox(opts: InboxOpts): void {
+export default function crewPendingQuestions(opts: PendingQuestionsOpts): void {
   const crew = requireCrew(opts.crew);
-  const items = openInboxTasks(crew);
+  const items = openPendingQuestions(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.');
+    print.info('no open pending questions.');
     return;
   }
-  print.info(`open inbox items: ${items.length}`);
+  print.info(`open pending questions: ${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'})`);
@@ -26,4 +26,3 @@ export default function crewInbox(opts: InboxOpts): void {
 function clean(text: string): string {
   return text.replace(/\[[A-Za-z0-9_-]+::\s*[^\]]+\]/g, '').trim();
 }
-

package/lib/crew/project.ts

@@ -70,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.scope.startsWith(`project:${name}:`) || t.fields.project === name));
+  const tasks = scanTasks(crew).filter(t => t.scope !== 'pending' && (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

package/lib/crew/role.ts

@@ -14,13 +14,13 @@ export interface CrewRoleDefinition {
   builtIn?: boolean;
 }
 
-export const BUILTIN_ROLE_NAMES = ['lead', 'designer', 'pm', 'coder', 'tester', 'researcher'];
+export const BUILTIN_ROLE_NAMES = ['orchestrator', 'designer', 'pm', 'coder', 'tester', 'researcher'];
 
 const BUILTIN_ROLES: CrewRoleDefinition[] = [
-  { name: 'lead', title: 'Lead', folder: 'Lead', description: 'Coordinates goals, project owners, roles, Inbox decisions, and dashboard status.', builtIn: true },
+  { name: 'orchestrator', title: 'Orchestrator', folder: 'Orchestrator', description: 'Orchestrates across and within projects: selects projects, sequences cross-project dependencies, dispatches engines, manages pending questions and the dashboard. As project manager, decomposes analysis into tasks, schedules, dispatches develop/verify, tracks status, and drives merges.', 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: 'coder', title: 'Coder', folder: 'Coder', description: 'Implements project-scoped code tasks assigned by a Project Owner or the Orchestrator.', 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 },
 ];

package/lib/crew/runtime.test.ts

@@ -0,0 +1,160 @@
+import os from 'os';
+import fs from 'fs';
+import path from 'path';
+import { runCommand, buildEngineInvocation, createTaskWorktree, removeTaskWorktree, runParallel, dispatchTask } from './runtime';
+
+const NODE = process.execPath; // verify mechanics with a harmless command, not real engines
+
+describe('runCommand', () => {
+  it('captures stdout and exit code 0 on success', async () => {
+    const r = await runCommand(NODE, ['-e', 'process.stdout.write("hi")']);
+    expect(r.stdout).toBe('hi');
+    expect(r.code).toBe(0);
+    expect(r.timedOut).toBe(false);
+  });
+
+  it('captures stderr and non-zero exit code on failure', async () => {
+    const r = await runCommand(NODE, ['-e', 'process.stderr.write("boom"); process.exit(3)']);
+    expect(r.stderr).toContain('boom');
+    expect(r.code).toBe(3);
+  });
+
+  it('enforces a timeout (kills the process, marks timedOut)', async () => {
+    const r = await runCommand(NODE, ['-e', 'setTimeout(()=>{}, 10000)'], { timeoutMs: 200 });
+    expect(r.timedOut).toBe(true);
+    expect(r.code).toBeNull(); // killed by signal, no exit code
+  });
+
+  it('runs in the given cwd', async () => {
+    const tmp = os.tmpdir();
+    const r = await runCommand(NODE, ['-e', 'process.stdout.write(process.cwd())'], { cwd: tmp });
+    // macOS /tmp is a symlink to /private/tmp; just assert it resolved somewhere under tmp's basename
+    expect(r.stdout.length).toBeGreaterThan(0);
+    expect(r.code).toBe(0);
+  });
+
+  it('pipes stdin input', async () => {
+    const r = await runCommand(
+      NODE,
+      ['-e', 'let d="";process.stdin.on("data",c=>d+=c);process.stdin.on("end",()=>process.stdout.write(d.toUpperCase()))'],
+      { input: 'hi' },
+    );
+    expect(r.stdout).toBe('HI');
+  });
+
+  it('rejects when the binary does not exist', async () => {
+    await expect(runCommand('definitely-not-a-real-binary-xyz', [])).rejects.toThrow();
+  });
+
+  it('caps captured output at maxOutputBytes and flags truncated', async () => {
+    const r = await runCommand(NODE, ['-e', 'process.stdout.write("x".repeat(5000))'], { maxOutputBytes: 100 });
+    expect(r.truncated).toBe(true);
+    expect(r.stdout.length).toBe(100);
+    expect(r.code).toBe(0);
+  });
+
+  it('does not flag truncated for small output', async () => {
+    const r = await runCommand(NODE, ['-e', 'process.stdout.write("hi")']);
+    expect(r.truncated).toBe(false);
+  });
+
+  it('closes child stdin by default so stdin-reading children get EOF (no hang)', async () => {
+    // Without closing stdin, a child that reads until "end" never fires it and hangs
+    // (this is the codex-exec hang found in the dual-engine smoke).
+    const r = await runCommand(
+      NODE,
+      ['-e', 'let d="";process.stdin.on("data",c=>d+=c);process.stdin.on("end",()=>process.stdout.write("EOF:"+d.length))'],
+      { timeoutMs: 5000 },
+    );
+    expect(r.stdout).toBe('EOF:0');
+    expect(r.timedOut).toBe(false);
+    expect(r.code).toBe(0);
+  });
+});
+
+describe('buildEngineInvocation', () => {
+  it('maps claude to headless print mode', () => {
+    expect(buildEngineInvocation('claude', 'do X')).toEqual({ cmd: 'claude', args: ['-p', 'do X'] });
+  });
+  it('maps codex to exec', () => {
+    expect(buildEngineInvocation('codex', 'do X')).toEqual({ cmd: 'codex', args: ['exec', 'do X'] });
+  });
+  it('throws for pi (not yet implemented)', () => {
+    expect(() => buildEngineInvocation('pi' as any, 'x')).toThrow(/not implemented/);
+  });
+  it('throws for unknown engine', () => {
+    expect(() => buildEngineInvocation('gpt' as any, 'x')).toThrow(/unknown engine/);
+  });
+});
+
+describe('worktree lifecycle', () => {
+  let repo: string;
+
+  beforeAll(async () => {
+    repo = fs.mkdtempSync(path.join(os.tmpdir(), 'rig-wt-'));
+    await runCommand('git', ['init', '-q'], { cwd: repo });
+    fs.writeFileSync(path.join(repo, 'f.txt'), 'hello');
+    await runCommand('git', ['-c', 'user.email=t@t', '-c', 'user.name=t', 'add', '-A'], { cwd: repo });
+    await runCommand('git', ['-c', 'user.email=t@t', '-c', 'user.name=t', 'commit', '-q', '-m', 'init'], { cwd: repo });
+  });
+
+  afterAll(() => {
+    try { fs.rmSync(repo, { recursive: true, force: true }); } catch { /* best-effort */ }
+  });
+
+  it('creates and removes a task worktree on a task/<id> branch', async () => {
+    const wt = await createTaskWorktree(repo, 'demo-001');
+    expect(wt.branch).toBe('task/demo-001');
+    expect(fs.existsSync(wt.path)).toBe(true);
+    const br = await runCommand('git', ['branch', '--list', 'task/demo-001'], { cwd: repo });
+    expect(br.stdout).toContain('task/demo-001');
+    await removeTaskWorktree(repo, wt.path, { force: true });
+    expect(fs.existsSync(wt.path)).toBe(false);
+  });
+
+  it('throws when the worktree/branch already exists', async () => {
+    const wt = await createTaskWorktree(repo, 'dup-001');
+    await expect(createTaskWorktree(repo, 'dup-001')).rejects.toThrow(/worktree add failed/);
+    await removeTaskWorktree(repo, wt.path, { force: true });
+  });
+
+  it('dispatchTask runs the invocation inside the task worktree (kept on success)', async () => {
+    const inv = { cmd: process.execPath, args: ['-e', 'process.stdout.write(process.cwd())'] };
+    const { worktree, result } = await dispatchTask(repo, 'disp-001', inv);
+    expect(result.code).toBe(0);
+    // ran inside the worktree (cwd echoed); realpath to dodge macOS /var symlink
+    expect(fs.realpathSync(result.stdout.trim())).toBe(fs.realpathSync(worktree.path));
+    expect(fs.existsSync(worktree.path)).toBe(true); // kept until merge
+    await removeTaskWorktree(repo, worktree.path, { force: true });
+  });
+
+  it('dispatchTask removes the worktree on spawn failure', async () => {
+    await expect(dispatchTask(repo, 'disp-fail', { cmd: 'definitely-not-a-real-binary-xyz', args: [] }))
+      .rejects.toThrow();
+    expect(fs.existsSync(path.join(repo, '.worktrees', 'task-disp-fail'))).toBe(false);
+  });
+});
+
+describe('runParallel', () => {
+  it('preserves order and returns all results', async () => {
+    const out = await runParallel([1, 2, 3, 4, 5], async n => n * 2, 2);
+    expect(out).toEqual([2, 4, 6, 8, 10]);
+  });
+
+  it('never exceeds the concurrency limit', async () => {
+    let active = 0;
+    let maxActive = 0;
+    await runParallel(
+      Array.from({ length: 8 }, (_, i) => i),
+      async () => {
+        active++;
+        maxActive = Math.max(maxActive, active);
+        await new Promise(r => setTimeout(r, 15));
+        active--;
+      },
+      3,
+    );
+    expect(maxActive).toBeLessThanOrEqual(3);
+    expect(maxActive).toBeGreaterThan(1); // actually ran concurrently
+  });
+});

package/lib/crew/runtime.ts

@@ -0,0 +1,192 @@
+import { spawn } from 'child_process';
+import path from 'path';
+import { Engine } from './engine';
+
+// Agent runtime — engine-agnostic process primitives (design §2.2 "agent runtime").
+// This module is the foundational layer the dispatcher builds on: spawn a CLI
+// engine in a task worktree, capture its output, enforce a timeout. Engine-specific
+// behaviour (claude/codex flags) is isolated in `buildEngineInvocation` and verified
+// against the real CLIs in the dual-engine smoke; the mechanics here are verified
+// with harmless commands (echo / node -e / sleep) — see runtime.test.ts.
+
+export interface RunResult {
+  stdout: string;
+  stderr: string;
+  code: number | null;
+  signal: NodeJS.Signals | null;
+  timedOut: boolean;
+  /** True when stdout or stderr hit maxOutputBytes and was truncated. */
+  truncated: boolean;
+  durationMs: number;
+}
+
+export interface RunOptions {
+  cwd?: string;
+  /** Hard timeout in ms; <=0 or undefined disables it. On timeout: SIGTERM, then SIGKILL after a grace period. */
+  timeoutMs?: number;
+  /** Sent to stdin then closed. */
+  input?: string;
+  env?: NodeJS.ProcessEnv;
+  /** Per-stream capture cap in bytes (default 10MB). Guards against an agentic engine emitting unbounded output. */
+  maxOutputBytes?: number;
+}
+
+const KILL_GRACE_MS = 2000;
+const MAX_OUTPUT_BYTES_DEFAULT = 10_000_000;
+
+/**
+ * Spawn a command, capture stdout/stderr, enforce an optional timeout.
+ * Resolves with a RunResult (even on non-zero exit / timeout); rejects only when
+ * the process cannot be spawned at all (e.g. binary not found).
+ */
+export function runCommand(cmd: string, args: string[], opts: RunOptions = {}): Promise<RunResult> {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+    let settled = false;
+    let stdout = '';
+    let stderr = '';
+    let timedOut = false;
+    let truncated = false;
+    let killTimer: NodeJS.Timeout | undefined;
+    let graceTimer: NodeJS.Timeout | undefined;
+    const maxBytes = opts.maxOutputBytes && opts.maxOutputBytes > 0 ? opts.maxOutputBytes : MAX_OUTPUT_BYTES_DEFAULT;
+
+    const child = spawn(cmd, args, { cwd: opts.cwd, env: opts.env || process.env });
+
+    if (opts.timeoutMs && opts.timeoutMs > 0) {
+      killTimer = setTimeout(() => {
+        timedOut = true;
+        child.kill('SIGTERM');
+        graceTimer = setTimeout(() => child.kill('SIGKILL'), KILL_GRACE_MS);
+      }, opts.timeoutMs);
+    }
+
+    child.stdout?.on('data', d => {
+      if (stdout.length >= maxBytes) { truncated = true; return; }
+      stdout += d.toString();
+      if (stdout.length > maxBytes) { stdout = stdout.slice(0, maxBytes); truncated = true; }
+    });
+    child.stderr?.on('data', d => {
+      if (stderr.length >= maxBytes) { truncated = true; return; }
+      stderr += d.toString();
+      if (stderr.length > maxBytes) { stderr = stderr.slice(0, maxBytes); truncated = true; }
+    });
+
+    child.on('error', err => {
+      if (settled) return;
+      settled = true;
+      if (killTimer) clearTimeout(killTimer);
+      if (graceTimer) clearTimeout(graceTimer);
+      reject(err);
+    });
+
+    child.on('close', (code, signal) => {
+      if (settled) return;
+      settled = true;
+      if (killTimer) clearTimeout(killTimer);
+      if (graceTimer) clearTimeout(graceTimer);
+      resolve({ stdout, stderr, code, signal, timedOut, truncated, durationMs: Date.now() - start });
+    });
+
+    // Always close stdin (with input if given, empty otherwise). Engines like
+    // `codex exec` block forever waiting for stdin EOF if it's left open; closing
+    // it makes them proceed with the prompt arg. (Found in the dual-engine smoke.)
+    if (opts.input != null) child.stdin?.write(opts.input);
+    child.stdin?.end();
+  });
+}
+
+export interface Invocation { cmd: string; args: string[]; }
+
+/**
+ * Map an engine + prompt to a one-shot, non-interactive CLI invocation (design §2.2).
+ * Exact flags are verified against the real CLIs in the dual-engine smoke; keep the
+ * mapping here so the dispatcher stays engine-agnostic.
+ */
+export function buildEngineInvocation(engine: Engine, prompt: string): Invocation {
+  switch (engine) {
+    case 'claude': return { cmd: 'claude', args: ['-p', prompt] };
+    case 'codex': return { cmd: 'codex', args: ['exec', prompt] };
+    case 'pi': throw new Error('pi engine invocation is not implemented yet');
+    default: throw new Error(`unknown engine: ${engine as string}`);
+  }
+}
+
+// --- Worktree lifecycle (design §2.2 "worktree 隔离") ---
+// Each dispatched task runs in its own git worktree on a `task/<id>` branch, so
+// parallel engines never collide in one working tree. Created before dispatch,
+// removed after merge/abandon.
+
+export interface Worktree { path: string; branch: string; }
+
+/** `git worktree add <dir> -b task/<taskId> <base>` in `repoDir`. */
+export async function createTaskWorktree(
+  repoDir: string,
+  taskId: string,
+  opts: { base?: string; worktreeDir?: string } = {},
+): Promise<Worktree> {
+  const branch = `task/${taskId}`;
+  const wtDir = opts.worktreeDir || path.join(repoDir, '.worktrees', `task-${taskId}`);
+  const base = opts.base || 'HEAD';
+  const r = await runCommand('git', ['worktree', 'add', wtDir, '-b', branch, base], { cwd: repoDir });
+  if (r.code !== 0) throw new Error(`git worktree add failed (${r.code}): ${(r.stderr || r.stdout).trim()}`);
+  return { path: wtDir, branch };
+}
+
+/** `git worktree remove <path> [--force]` in `repoDir`. */
+export async function removeTaskWorktree(
+  repoDir: string,
+  worktreePath: string,
+  opts: { force?: boolean } = {},
+): Promise<void> {
+  const args = ['worktree', 'remove', worktreePath];
+  if (opts.force) args.push('--force');
+  const r = await runCommand('git', args, { cwd: repoDir });
+  if (r.code !== 0) throw new Error(`git worktree remove failed (${r.code}): ${(r.stderr || r.stdout).trim()}`);
+}
+
+// --- Dispatch + parallel scheduling (design §2.2 "并行调度") ---
+
+/** Run `worker` over `items` with at most `limit` concurrent; results keep input order. */
+export async function runParallel<T, R>(
+  items: T[],
+  worker: (item: T, index: number) => Promise<R>,
+  limit = 4,
+): Promise<R[]> {
+  const results: R[] = new Array(items.length);
+  let next = 0;
+  const lim = Math.max(1, limit);
+  async function runner(): Promise<void> {
+    for (;;) {
+      const i = next++;
+      if (i >= items.length) return;
+      results[i] = await worker(items[i], i);
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(lim, items.length) }, () => runner()));
+  return results;
+}
+
+export interface DispatchResult { worktree: Worktree; result: RunResult; }
+
+/**
+ * Create a task worktree, run `invocation` inside it, return its worktree + RunResult.
+ * On success the worktree is KEPT (the work lives there until merge/abandon); on spawn
+ * failure it is removed so no orphan worktree is left. The engine→invocation mapping is
+ * the caller's job (`buildEngineInvocation`), keeping dispatch engine-agnostic.
+ */
+export async function dispatchTask(
+  repoDir: string,
+  taskId: string,
+  invocation: Invocation,
+  opts: { base?: string; timeoutMs?: number } = {},
+): Promise<DispatchResult> {
+  const worktree = await createTaskWorktree(repoDir, taskId, { base: opts.base });
+  try {
+    const result = await runCommand(invocation.cmd, invocation.args, { cwd: worktree.path, timeoutMs: opts.timeoutMs });
+    return { worktree, result };
+  } catch (err) {
+    try { await removeTaskWorktree(repoDir, worktree.path, { force: true }); } catch { /* best-effort */ }
+    throw err;
+  }
+}

package/lib/crew/status.ts

@@ -1,6 +1,6 @@
 import print from '../print';
 import { requireCrew, shortPath } from './config';
-import { scanTasks, openInboxTasks, summarize } from './task';
+import { scanTasks, openPendingQuestions, summarize } from './task';
 import { writeCrewState } from './state';
 
 interface StatusOpts { crew?: string; json?: boolean; }
@@ -8,12 +8,12 @@ interface StatusOpts { crew?: string; json?: boolean; }
 export default function crewStatus(opts: StatusOpts): void {
   const crew = requireCrew(opts.crew);
   const tasks = scanTasks(crew);
-  const inbox = openInboxTasks(crew);
+  const pending = openPendingQuestions(crew);
   const s = summarize(tasks);
   writeCrewState(crew, tasks);
   if (opts.json) {
     // eslint-disable-next-line no-console
-    console.log(JSON.stringify({ ok: true, crew: crew.name, vault: crew.vault, summary: s, inbox: inbox.length }, null, 2));
+    console.log(JSON.stringify({ ok: true, crew: crew.name, vault: crew.vault, summary: s, pendingQuestions: pending.length }, null, 2));
     return;
   }
   print.info(`crew: ${crew.name}`);
@@ -22,6 +22,6 @@ export default function crewStatus(opts: StatusOpts): void {
   // eslint-disable-next-line no-console
   console.log(`tasks: ${s.done}/${s.total} done, ${s.open} open, ${s.blocked} blocked, ${s.doing} doing`);
   // eslint-disable-next-line no-console
-  console.log(`inbox: ${inbox.length} open`);
+  console.log(`pending questions: ${pending.length} open`);
 }
 

package/lib/crew/stub.ts

@@ -2,8 +2,8 @@ import print from '../print';
 
 export default function crewStub(name: string): () => void {
   return () => {
-    print.warn(`rig crew ${name} is not implemented yet.`);
-    print.info('Current MVP supports init, status, inbox, board, sync, doctor, ask, and project add/list/status.');
+    print.warn(`rig orchestrate ${name} is not implemented yet.`);
+    print.info('Current MVP supports init, status, pending-questions, board, sync, doctor, ask, and project add/list/status.');
   };
 }
 

package/lib/crew/task.ts

@@ -51,8 +51,8 @@ export function summarize(tasks: CrewTask[]): CrewSummary {
   return { total: tasks.length, done, open: tasks.length - done, blocked, doing };
 }
 
-export function openInboxTasks(crew: CrewEntry): CrewTask[] {
-  return parseTasks(rootPath(crew, 'Inbox.md'), 'inbox').filter(t => !t.done);
+export function openPendingQuestions(crew: CrewEntry): CrewTask[] {
+  return parseTasks(rootPath(crew, 'Pending-Questions.md'), 'pending').filter(t => !t.done);
 }
 
 export function taskProgress(tasks: CrewTask[]): number {
@@ -75,7 +75,7 @@ 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' },
+    { file: rootPath(crew, 'Pending-Questions.md'), scope: 'pending' },
   ];
   const roles = roleDefinitionsForCrew(crew);
 

package/lib/crew/vault.ts

@@ -21,8 +21,8 @@ export function ensureCrewVault(crew: CrewEntry): void {
   writeIfMissing(crewPath(crew, 'tmp/.gitkeep'), '');
   fs.mkdirSync(crewRoot(crew), { recursive: true });
   writeIfMissing(rootPath(crew, 'Current-Goal.md'), '# Current Goal\n\n');
-  writeIfMissing(rootPath(crew, 'Team-Dashboard.md'), '# Team Dashboard\n\nCoding agents can run `rig crew board` to refresh this dashboard.\n');
-  writeIfMissing(rootPath(crew, 'Inbox.md'), '# Crew Inbox\n\n## Open\n\n## Resolved\n');
+  writeIfMissing(rootPath(crew, 'Dashboard.md'), '# Dashboard\n\nCoding agents can run `rig orchestrate board` to refresh this dashboard.\n');
+  writeIfMissing(rootPath(crew, 'Pending-Questions.md'), '# Pending Questions\n\nSystem→user questions the Orchestrator needs answered. Answer via the overmind `inbox/` (or reply in chat); the Orchestrator then resolves the matching item here.\n\n## Open\n\n## Resolved\n');
 
   ensureDir(rootPath(crew, 'Shared'));
   writeIfMissing(rootPath(crew, 'Shared/Spec.md'), '# Spec\n\n');
@@ -82,7 +82,7 @@ function ensureRole(crew: CrewEntry, role: CrewRoleDefinition): void {
   const base = rootPath(crew, folder);
   ensureDir(base);
   writeIfMissing(path.join(base, 'Role.md'), renderRoleFile(role));
-  if (role.name === 'lead') {
+  if (role.name === 'orchestrator') {
     ensureDir(path.join(base, 'Reports'));
     writeIfMissing(path.join(base, 'Reports', '.gitkeep'), '');
   }
@@ -267,15 +267,15 @@ function renderVaultAgentInstructions(crew: CrewEntry): string {
     AGENT_RULES_START,
     '## Rig Crew',
     '',
-    'This Vault uses `rig crew` as an agent-facing coordination layer. Humans talk to the current Claude/Codex coding session; the coding agent uses `rig crew` and Vault files to communicate with Crew Lead and coordinate other roles.',
+    'This Vault uses `rig orchestrate` (alias: `rig crew`) as an agent-facing coordination layer. Humans talk to the current Claude/Codex coding session; the coding agent uses `rig orchestrate` and Vault files to communicate with the Orchestrator and coordinate other roles.',
     '',
     `- Crew root: \`${root}\``,
-    `- Dashboard: \`${root}/Team-Dashboard.md\``,
-    `- Inbox: \`${root}/Inbox.md\``,
+    `- Dashboard: \`${root}/Dashboard.md\``,
+    `- Pending questions (system→user): \`${root}/Pending-Questions.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>/\``,
-    `- Per-project pending questions (待补充资料): \`${root}/Projects/<project>/Pending-Questions.md\` — managed by \`rig crew pending\``,
+    `- Per-project pending questions (待补充资料): \`${root}/Projects/<project>/Pending-Questions.md\` — managed by \`rig orchestrate pending\``,
     `- 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>/`.',
@@ -286,14 +286,14 @@ function renderVaultAgentInstructions(crew: CrewEntry): string {
     '',
     'Default collaboration protocol for coding agents:',
     '',
-    '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\`, project \`Tasks.md\`, project agent \`Agents/<role>/Tasks.md\`, and active tasklists.`,
+    '0. Do not treat `rig orchestrate` 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 the Orchestrator first.',
+    `2. Preferred handoff: run \`rig orchestrate "<user request>"\`, then read \`${root}/Dashboard.md\`, \`${root}/Pending-Questions.md\`, and \`${root}/Shared/Roles.md\`.`,
+    `3. Maintain status awareness before and after work by checking \`${root}/Dashboard.md\`, \`${root}/Pending-Questions.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 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.`,
+    '5. Treat the Orchestrator as the default orchestration 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. The Orchestrator 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}/Pending-Questions.md\` for the Orchestrator to surface.`,
     `8. Whenever a project is blocked by missing user-supplied material (API key, screenshot, vendor decision, sample data), record it with \`rig crew pending add ...\` rather than silently asking the human; when the user supplies it, the agent itself calls \`rig crew pending answer <id> --note "<summary>"\` and continues. Check \`rig crew pending --project <name>\` before starting any new tick on that project.`,
     '',
     AGENT_RULES_END,

package/lib/init/index.ts

@@ -6,7 +6,19 @@
  */
 import print from '../print';
 import fs from 'fs';
-import axios from 'axios';
+
+const PACKAGE_RIG_TEMPLATE = `{
+  // package.rig.json5 — rig configuration
+  // Field reference: see the rig-package / rig-cicd skills.
+  dependencies: {
+    // 'lib-name': {
+    //   source: 'git@github.com:org/repo.git', // git ssh url
+    //   version: '1.0.0',                      // git tag (semver)
+    //   dev: false                             // true => clone into rig_dev/ and develop locally
+    // }
+  }
+}
+`;
 
 export default async () => {
   try {
@@ -19,11 +31,9 @@ export default async () => {
     if (fs.existsSync('package.rig.json5')) {
       print.info('package.rig.json5 already exists~');
     } else {
-      //创建package.rig.json5
+      //创建package.rig.json5 — 本地模板,留空 dependencies,无示例库引用
       print.info('create package.rig.json5');
-      const resPackageRigJSON5 = await axios.get('https://gist.githubusercontent.com/FlashHand/ea156ac4930b05832ad7c568f7f00cdd/raw/48a4321ccf1b0339a15f6454336f289b8b5bad58/package.rig.json5');
-      const packageRigJSON5 = resPackageRigJSON5.data;
-      fs.writeFileSync('./package.rig.json5', packageRigJSON5);
+      fs.writeFileSync('./package.rig.json5', PACKAGE_RIG_TEMPLATE);
     }
     //检查是否存在rig_helper.js
     // if (fs.existsSync(`${process.cwd()}/rig_helper.js`)) {
@@ -95,8 +105,7 @@ export default async () => {
         postinstall: "rig postinstall",
       },
       devDependencies: {
-        json5: '2.2.1',
-        "rig-helper": '^1.0.2'
+        json5: '2.2.1'
       }
     }
     pkgJSON.private = inserted.private;
@@ -125,11 +134,9 @@ export default async () => {
     }
     if (pkgJSON.devDependencies) {
       pkgJSON.devDependencies.json5 = inserted.devDependencies.json5;
-      pkgJSON.devDependencies["rig-helper"] = inserted.devDependencies["rig-helper"];
     } else {
       pkgJSON.devDependencies = inserted.devDependencies;
     }
-    //检查是否存在rig-helper
     fs.writeFileSync('package.json', JSON.stringify(pkgJSON, null, 2));
     print.succeed('rig init succeed');
   } catch (e) {