rigjs 4.0.18 → 4.1.0

package/lib/classes/cicd/CICD.ts

@@ -38,6 +38,23 @@ export interface DeployTarget {
 		original_regexp?: string;
 		final?: string;
 	} | undefined;
+	/**
+	 * Edge provider for `rig publish` (回源改写 + 刷缓存).
+	 * - 'cdn' (default): traditional Aliyun CDN, BatchSetCdnDomainConfig.
+	 * - 'esa': Aliyun ESA (Edge Security Acceleration), site-scoped rewrite rules.
+	 */
+	edge_provider?: 'cdn' | 'esa';
+	/**
+	 * ESA OpenAPI endpoint. Only used when edge_provider === 'esa'.
+	 * Defaults to 'esa.cn-hangzhou.aliyuncs.com'.
+	 */
+	esa_endpoint?: string;
+	/**
+	 * ESA site name (registrable zone, e.g. 'terncloud.com'). Only used when
+	 * edge_provider === 'esa'. If omitted, derived from the endpoint domain's
+	 * last two labels.
+	 */
+	esa_site_name?: string;
 }
 
 /**

package/lib/classes/cicd/Deploy/ESA.ts

@@ -0,0 +1,117 @@
+import ESAClient, {
+  ListSitesRequest,
+  CreateRewriteUrlRuleRequest,
+  PurgeCachesRequest,
+  PurgeCachesRequestContent,
+} from '@alicloud/esa20240910';
+import { $OpenApiUtil } from '@alicloud/openapi-core';
+import { DeployTarget } from '../CICD';
+
+/**
+ * ESA (Aliyun Edge Security Acceleration) deploy adapter — the ESA-flavoured
+ * counterpart of {@link ./CDN.ts}. Used by `rig publish` when the deploy target
+ * sets `edge_provider: 'esa'`.
+ *
+ * Differences from traditional CDN:
+ * - ESA config is **site-scoped**: every operation needs a numeric `siteId`,
+ *   resolved from the registrable zone (e.g. `terncloud.com`) via `ListSites`.
+ * - Back-to-origin rewrite uses `CreateRewriteUrlRule` (rule expression +
+ *   static/dynamic target URI), not CDN's regex `back_to_origin_url_rewrite`.
+ * - Cache refresh uses `PurgeCaches`, not `RefreshObjectCaches`.
+ *
+ * Credentials come from the DeployTarget (injected via `-p ak=...&as=...`),
+ * never hard-coded here.
+ */
+class ESA {
+  private client: ESAClient;
+  private siteIdCache: Map<string, number> = new Map();
+  private explicitSiteName?: string;
+
+  constructor(target: DeployTarget) {
+    const config = new $OpenApiUtil.Config({
+      accessKeyId: target.access_key,
+      accessKeySecret: target.access_secret,
+      endpoint: target.esa_endpoint || 'esa.cn-hangzhou.aliyuncs.com',
+    });
+    this.client = new ESAClient(config);
+    this.explicitSiteName = target.esa_site_name;
+  }
+
+  /**
+   * Registrable zone for a domain: `test-esa.terncloud.com` -> `terncloud.com`.
+   * (Good enough for normal `*.com` / `*.cn` zones; pass `esa_site_name`
+   * explicitly for multi-label public suffixes like `*.com.cn`.)
+   */
+  private siteNameFor(domain: string): string {
+    if (this.explicitSiteName) return this.explicitSiteName;
+    const parts = domain.split('.').filter(Boolean);
+    return parts.length <= 2 ? domain : parts.slice(-2).join('.');
+  }
+
+  /** Resolve (and cache) the numeric ESA siteId for a domain's zone. */
+  public async resolveSiteId(domain: string): Promise<number> {
+    const siteName = this.siteNameFor(domain);
+    const cached = this.siteIdCache.get(siteName);
+    if (cached) return cached;
+
+    const resp = await this.client.listSites(
+      new ListSitesRequest({ siteName, siteSearchType: 'exact' })
+    );
+    const sites = resp.body?.sites || [];
+    const site = sites.find((s) => s.siteName === siteName) || sites[0];
+    if (!site || site.siteId == null) {
+      throw new Error(
+        `ESA site not found for "${siteName}" (domain ${domain}). ` +
+          `Create the ESA site (zone) and bind the OSS origin in the ESA console/API first.`
+      );
+    }
+    this.siteIdCache.set(siteName, site.siteId);
+    return site.siteId;
+  }
+
+  /**
+   * Create a single back-to-origin URI rewrite rule.
+   * @param rule ESA rule expression. `true` matches all requests; otherwise a
+   *   conditional expression, e.g. `(http.request.uri.path.file_name ne "")`.
+   * @param rewriteUriType `static` (fixed `uri`) or `dynamic` (`uri` is an expression).
+   * @param uri target URI after rewrite (static path or dynamic expression).
+   * @param sequence rule priority (lower runs first).
+   */
+  public async setRewriteRule(
+    domain: string,
+    ruleName: string,
+    rule: string,
+    rewriteUriType: 'static' | 'dynamic',
+    uri: string,
+    sequence: number
+  ) {
+    const siteId = await this.resolveSiteId(domain);
+    const resp = await this.client.createRewriteUrlRule(
+      new CreateRewriteUrlRuleRequest({
+        siteId,
+        ruleName,
+        rule,
+        ruleEnable: 'on',
+        rewriteUriType,
+        uri,
+        sequence,
+      })
+    );
+    return resp.body;
+  }
+
+  /** Purge cached files by URL. */
+  public async purgeCache(domain: string, urls: string[]) {
+    const siteId = await this.resolveSiteId(domain);
+    const resp = await this.client.purgeCaches(
+      new PurgeCachesRequest({
+        siteId,
+        type: 'file',
+        content: new PurgeCachesRequestContent({ files: urls }),
+      })
+    );
+    return resp.body;
+  }
+}
+
+export default ESA;

package/lib/crew/ask.ts

@@ -10,14 +10,14 @@ export default function crewAsk(messageParts: string[] | string | undefined, opt
   const crew = requireCrew(opts.crew);
   const message = Array.isArray(messageParts) ? messageParts.join(' ') : (messageParts || '');
   if (!message.trim()) {
-    print.info('no message supplied; running a lightweight Lead tick.');
-    print.info('MVP Lead tick only refreshes status. LLM delegation will be added in a later phase.');
+    print.info('no message supplied; running a lightweight Orchestrator tick.');
+    print.info('MVP Orchestrator tick only refreshes status. LLM delegation will be added in a later phase.');
     crewBoard({ crew: crew.name });
     return;
   }
   const file = rootPath(crew, 'Current-Goal.md');
   fs.appendFileSync(file, `\n- ${new Date().toISOString()} ${message.trim()}\n`, 'utf8');
-  appendLog(crew, `Lead input: ${message.trim()}`);
+  appendLog(crew, `Orchestrator input: ${message.trim()}`);
   print.succeed(`added goal input to ${file}`);
   crewBoard({ crew: crew.name });
 }

package/lib/crew/board.ts

@@ -1,7 +1,7 @@
 import path from 'path';
 import print from '../print';
 import { requireCrew, shortPath } from './config';
-import { scanTasks, openInboxTasks, summarize, taskProgress, CrewTask } from './task';
+import { scanTasks, openPendingQuestions, summarize, taskProgress, CrewTask } from './task';
 import { rootPath, writeText, readText } from './vault';
 import { writeCrewState } from './state';
 import { roleDefinitionsForCrew } from './role';
@@ -11,35 +11,35 @@ 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 pending = openPendingQuestions(crew);
   const summary = summarize(tasks);
-  const dashboard = renderDashboard(crew, tasks, inbox);
-  const file = rootPath(crew, 'Team-Dashboard.md');
+  const dashboard = renderDashboard(crew, tasks, pending);
+  const file = rootPath(crew, '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`);
+  print.info(`tasks: ${summary.done}/${summary.total} done, pending questions: ${pending.length} open`);
 }
 
-function renderDashboard(crew: ReturnType<typeof requireCrew>, tasks: CrewTask[], inbox: CrewTask[]): string {
+function renderDashboard(crew: ReturnType<typeof requireCrew>, tasks: CrewTask[], pending: 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',
+    '# Dashboard',
     '',
     `Last updated: ${new Date().toISOString()}`,
     '',
-    '## Lead Brief',
+    '## Orchestrator 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.'}`,
+    `Next Agent Action: ${pending.length > 0 ? 'Read `rig orchestrate pending-questions` and surface only needed decisions to the human.' : 'Run `rig orchestrate` to continue the next Orchestrator tick.'}`,
     '',
     '## Needs Your Attention',
     '',
-    inboxTable(inbox),
+    pendingTable(pending),
     '',
     '## Project Progress',
     '',
@@ -68,8 +68,8 @@ function currentGoal(file: string): string {
   return lines.length ? lines[lines.length - 1].replace(/^\-\s*/, '') : '';
 }
 
-function inboxTable(tasks: CrewTask[]): string {
-  if (tasks.length === 0) return '_No open inbox items._';
+function pendingTable(tasks: CrewTask[]): string {
+  if (tasks.length === 0) return '_No open pending questions._';
   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');
 }
@@ -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.scope.startsWith(`project:${p.name}:`) || t.fields.project === p.name));
+    const scoped = tasks.filter(t => t.scope !== 'pending' && (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)} |`;
@@ -104,7 +104,7 @@ function blockersTable(tasks: CrewTask[]): string {
 }
 
 function activeTable(tasks: CrewTask[]): string {
-  const active = tasks.filter(t => !t.done && t.scope !== 'inbox').slice(0, 20);
+  const active = tasks.filter(t => !t.done && t.scope !== 'pending').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');

package/lib/crew/config.ts

@@ -33,7 +33,7 @@ export interface CrewConfig {
 }
 
 export const DEFAULT_ROLES: CrewRole[] = BUILTIN_ROLE_NAMES;
-export const DEFAULT_CREW_ROOT = 'rig-agents';
+export const DEFAULT_CREW_ROOT = 'rig-crew';
 
 const DEFAULT_CONFIG: CrewConfig = { crews: [] };
 
@@ -86,7 +86,7 @@ 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'),
+    dashboard: entry.dashboard || path.join(entry.root || DEFAULT_CREW_ROOT, 'Dashboard.md'),
     defaultExecutor: entry.defaultExecutor || 'claude',
     mode: entry.mode || 'leader-first',
     state: entry.state || { backend: 'json' },

package/lib/crew/dispatchCommand.ts

@@ -0,0 +1,58 @@
+import print from '../print';
+import { requireCrew, shortPath } from './config';
+import { resolveEngine } from './engine';
+import { buildEngineInvocation, dispatchTask } from './runtime';
+
+interface DispatchOpts {
+  crew?: string;
+  prompt: string;
+  engine?: string;
+  task?: string;
+  timeout?: string;
+}
+
+/**
+ * `rig orchestrate dispatch <project>` — MVP manual dispatch: resolve the engine for
+ * <project>, run the prompt in a fresh `task/<id>` worktree of that project, print the
+ * result. The full orchestrate loop (read task files → dispatch → verify → merge) builds
+ * on this primitive; this command exposes it for manual use / debugging.
+ */
+export default async function crewDispatch(project: string, opts: DispatchOpts): Promise<void> {
+  const crew = requireCrew(opts.crew);
+  const proj = (crew.projects || []).find(p => p.name === project);
+  if (!proj) {
+    print.error(`unknown project: ${project}. Register it with \`rig orchestrate project add\` first.`);
+    process.exit(1);
+  }
+  let engine: string;
+  try {
+    const res = resolveEngine({ explicit: opts.engine, project: proj, crew });
+    if (!res.engine) {
+      print.error(`engine unresolved — ${res.detail}.`);
+      process.exit(1);
+    }
+    engine = res.engine;
+    print.info(`engine: ${res.engine} (source: ${res.source})`);
+  } catch (e: any) {
+    print.error(e.message);
+    process.exit(1);
+    return;
+  }
+
+  const taskId = opts.task || `adhoc-${Date.now()}`;
+  const timeoutMs = opts.timeout ? Number(opts.timeout) : 600000;
+  const inv = buildEngineInvocation(engine as any, opts.prompt);
+  print.info(`dispatching → ${proj.name} (${shortPath(proj.path)}) on branch task/${taskId} …`);
+
+  try {
+    const { worktree, result } = await dispatchTask(proj.path, taskId, inv, { timeoutMs });
+    print.info(`exit=${result.code} timedOut=${result.timedOut} truncated=${result.truncated} ${Math.round(result.durationMs / 1000)}s`);
+    print.info(`worktree: ${shortPath(worktree.path)} (branch task/${taskId}) — remove with \`git -C ${shortPath(proj.path)} worktree remove --force ${shortPath(worktree.path)}\``);
+    // eslint-disable-next-line no-console
+    console.log(result.stdout.slice(0, 4000));
+    if (result.code !== 0) process.exitCode = 1;
+  } catch (e: any) {
+    print.error(`dispatch failed: ${e.message}`);
+    process.exit(1);
+  }
+}

package/lib/crew/doctor.ts

@@ -15,7 +15,7 @@ export default function crewDoctor(opts: DoctorOpts): void {
   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: 'pending questions', ok: fs.existsSync(rootPath(crew, 'Pending-Questions.md')), detail: path.join(crew.root, 'Pending-Questions.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) });

package/lib/crew/engine.test.ts

@@ -0,0 +1,73 @@
+import { detectHostEngine, resolveEngine, isEngine } from './engine';
+
+describe('isEngine', () => {
+  it('accepts the three valid engines', () => {
+    expect(isEngine('claude')).toBe(true);
+    expect(isEngine('codex')).toBe(true);
+    expect(isEngine('pi')).toBe(true);
+  });
+  it('rejects anything else', () => {
+    expect(isEngine('gpt')).toBe(false);
+    expect(isEngine('')).toBe(false);
+    expect(isEngine(undefined)).toBe(false);
+  });
+});
+
+describe('detectHostEngine', () => {
+  it('detects claude from CLAUDECODE', () => {
+    expect(detectHostEngine({ CLAUDECODE: '1' })).toBe('claude');
+  });
+  it('detects claude from CLAUDE_CODE_* and AI_AGENT', () => {
+    expect(detectHostEngine({ CLAUDE_CODE_ENTRYPOINT: 'cli' })).toBe('claude');
+    expect(detectHostEngine({ AI_AGENT: 'claude-code' })).toBe('claude');
+  });
+  it('detects codex from CODEX_* / AI_AGENT', () => {
+    expect(detectHostEngine({ CODEX_SANDBOX: '1' })).toBe('codex');
+    expect(detectHostEngine({ AI_AGENT: 'codex' })).toBe('codex');
+  });
+  it('returns null when neither present', () => {
+    expect(detectHostEngine({ PATH: '/usr/bin' })).toBeNull();
+  });
+  it('returns null when ambiguous (both)', () => {
+    expect(detectHostEngine({ CLAUDECODE: '1', CODEX_SANDBOX: '1' })).toBeNull();
+  });
+});
+
+describe('resolveEngine — 5-level order (design §2.2)', () => {
+  const noHost = { PATH: '/usr/bin' };
+
+  it('1. explicit wins over everything', () => {
+    const r = resolveEngine({ explicit: 'codex', project: { defaultExecutor: 'claude' }, crew: { defaultExecutor: 'claude' }, env: { CLAUDECODE: '1' } });
+    expect(r).toEqual({ engine: 'codex', source: 'explicit' });
+  });
+
+  it('throws on invalid explicit engine', () => {
+    expect(() => resolveEngine({ explicit: 'gpt' })).toThrow(/invalid engine/);
+  });
+
+  it('2. project default beats crew + host', () => {
+    const r = resolveEngine({ project: { defaultExecutor: 'codex' }, crew: { defaultExecutor: 'claude' }, env: { CLAUDECODE: '1' } });
+    expect(r).toEqual({ engine: 'codex', source: 'project' });
+  });
+
+  it('3. crew default beats host', () => {
+    const r = resolveEngine({ crew: { defaultExecutor: 'codex' }, env: { CLAUDECODE: '1' } });
+    expect(r).toEqual({ engine: 'codex', source: 'crew' });
+  });
+
+  it('4. host self-detect when no config default', () => {
+    const r = resolveEngine({ crew: { defaultExecutor: undefined }, env: { CLAUDECODE: '1' } });
+    expect(r).toEqual({ engine: 'claude', source: 'host' });
+  });
+
+  it('5. unresolved when nothing resolves', () => {
+    const r = resolveEngine({ env: noHost });
+    expect(r.engine).toBeNull();
+    expect(r.source).toBe('unresolved');
+  });
+
+  it('skips invalid config values (treated as unset), falls through to host', () => {
+    const r = resolveEngine({ project: { defaultExecutor: 'bogus' }, crew: { defaultExecutor: 'also-bad' }, env: { CODEX_SANDBOX: '1' } });
+    expect(r).toEqual({ engine: 'codex', source: 'host' });
+  });
+});

package/lib/crew/engine.ts

@@ -0,0 +1,103 @@
+import print from '../print';
+import { requireCrew } from './config';
+
+export type Engine = 'claude' | 'codex' | 'pi';
+const VALID_ENGINES: Engine[] = ['claude', 'codex', 'pi'];
+
+export type EngineSource = 'explicit' | 'project' | 'crew' | 'host' | 'unresolved';
+
+export interface EngineResolution {
+  engine: Engine | null;
+  source: EngineSource;
+  detail?: string;
+}
+
+export function isEngine(v: unknown): v is Engine {
+  return typeof v === 'string' && (VALID_ENGINES as string[]).includes(v);
+}
+
+/**
+ * Host engine self-detection from the environment (design §2.2).
+ * - claude: `CLAUDECODE`, any `CLAUDE_CODE*`, or `AI_AGENT` containing "claude"
+ * - codex:  any `CODEX*`, or `AI_AGENT` containing "codex"
+ * Returns null when neither is present, or both are (ambiguous → caller asks).
+ */
+export function detectHostEngine(env: NodeJS.ProcessEnv = process.env): Engine | null {
+  const keys = Object.keys(env);
+  const ai = (env.AI_AGENT || '').toLowerCase();
+  const claude = !!env.CLAUDECODE || keys.some(k => k.startsWith('CLAUDE_CODE')) || ai.includes('claude');
+  const codex = keys.some(k => k.startsWith('CODEX')) || ai.includes('codex');
+  if (claude && !codex) return 'claude';
+  if (codex && !claude) return 'codex';
+  return null;
+}
+
+/**
+ * 5-level engine resolution (design §2.2). Highest priority first:
+ * 1. explicit  — task `engine:` field / conversation directive (override)
+ * 2. project   — project config `defaultExecutor`
+ * 3. crew      — crew config `defaultExecutor`
+ * 4. host      — host self-detection (`detectHostEngine`)
+ * 5. unresolved — caller raises a pending question; agent never invents an engine
+ *
+ * An invalid explicit value throws; invalid project/crew values are skipped
+ * (treated as unset) so a typo in config can't silently pin the wrong engine.
+ */
+export function resolveEngine(opts: {
+  explicit?: string | null;
+  project?: { defaultExecutor?: string } | null;
+  crew?: { defaultExecutor?: string } | null;
+  env?: NodeJS.ProcessEnv;
+}): EngineResolution {
+  const { explicit, project, crew, env } = opts;
+  if (explicit != null && explicit !== '') {
+    if (!isEngine(explicit)) {
+      throw new Error(`invalid engine "${explicit}". Use one of: ${VALID_ENGINES.join(', ')}.`);
+    }
+    return { engine: explicit, source: 'explicit' };
+  }
+  if (project && isEngine(project.defaultExecutor)) {
+    return { engine: project.defaultExecutor as Engine, source: 'project' };
+  }
+  if (crew && isEngine(crew.defaultExecutor)) {
+    return { engine: crew.defaultExecutor as Engine, source: 'crew' };
+  }
+  const host = detectHostEngine(env);
+  if (host) return { engine: host, source: 'host' };
+  return {
+    engine: null,
+    source: 'unresolved',
+    detail: 'no explicit/project/crew engine and host undetected — raise a pending question instead of guessing',
+  };
+}
+
+interface EngineOpts { crew?: string; project?: string; engine?: string; json?: boolean; }
+
+/** `rig orchestrate engine` — debug view of which engine resolves and why. */
+export default function crewEngine(opts: EngineOpts): void {
+  const crew = requireCrew(opts.crew);
+  const project = opts.project ? (crew.projects || []).find(p => p.name === opts.project) : undefined;
+  if (opts.project && !project) {
+    print.error(`unknown project: ${opts.project}`);
+    process.exit(1);
+  }
+  let res: EngineResolution;
+  try {
+    res = resolveEngine({ explicit: opts.engine, project, crew });
+  } catch (e: any) {
+    print.error(e.message);
+    process.exit(1);
+    return;
+  }
+  if (opts.json) {
+    // eslint-disable-next-line no-console
+    console.log(JSON.stringify({ ok: res.engine != null, engine: res.engine, source: res.source, project: opts.project || null, detail: res.detail }, null, 2));
+    return;
+  }
+  if (res.engine == null) {
+    print.warn(`engine unresolved — ${res.detail}.`);
+    process.exitCode = 1;
+    return;
+  }
+  print.info(`engine: ${res.engine}  (source: ${res.source}${opts.project ? `, project: ${opts.project}` : ''})`);
+}

package/lib/crew/index.ts

@@ -1,9 +1,11 @@
 import crewInit from './init';
 import crewStatus from './status';
 import crewBoard from './board';
-import crewInbox from './inbox';
+import crewPendingQuestions from './pendingQuestions';
 import crewSync from './sync';
 import crewDoctor from './doctor';
+import crewEngine from './engine';
+import crewDispatch from './dispatchCommand';
 import crewAsk from './ask';
 import crewStub from './stub';
 import { projectAdd, projectList, projectStatus, projectSync } from './project';
@@ -12,52 +14,71 @@ import { pendingAdd, pendingAnswer, pendingList, pendingRemove } from './pending
 
 // 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')
+  const orchestrate = program.command('orchestrate [message...]')
+    .alias('crew')
+    .description('Orchestrator-first multi-agent workspace over an Obsidian vault (alias: crew)')
     .option('-c, --crew <name>', 'target crew name')
     .action((message: string[] | undefined, opts: { crew?: string }) => crewAsk(message, opts));
 
-  crew.command('init')
+  orchestrate.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('--root <path>', 'root folder inside the vault (default: rig-crew)')
     .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)')
+  orchestrate.command('ask <message...>')
+    .description('send a message to the Orchestrator (MVP appends to Current-Goal.md)')
     .option('-c, --crew <name>', 'target crew name')
     .action(crewAsk);
 
-  crew.command('status')
+  orchestrate.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')
+  orchestrate.command('pending-questions')
+    .alias('inbox')
+    .description('show open system→user pending questions (alias: inbox)')
     .option('-c, --crew <name>', 'target crew name')
     .option('--json', 'machine-readable output')
-    .action(crewInbox);
+    .action(crewPendingQuestions);
 
-  crew.command('board')
-    .description('refresh Agents/Team-Dashboard.md')
+  orchestrate.command('board')
+    .description('refresh Dashboard.md')
     .option('-c, --crew <name>', 'target crew name')
     .action(crewBoard);
 
-  crew.command('sync')
+  orchestrate.command('sync')
     .description('scan Markdown tasks and update crew state cache')
     .option('-c, --crew <name>', 'target crew name')
     .action(crewSync);
 
-  crew.command('doctor')
+  orchestrate.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');
+  orchestrate.command('engine')
+    .description('show which execution engine resolves and why (5-level order; debug)')
+    .option('-c, --crew <name>', 'target crew name')
+    .option('-p, --project <name>', 'resolve as if dispatching for this project')
+    .option('--engine <engine>', 'explicit task-level engine override (claude | codex | pi)')
+    .option('--json', 'machine-readable output')
+    .action(crewEngine);
+
+  orchestrate.command('dispatch <project>')
+    .description('run a prompt via the resolved engine in a fresh task/<id> worktree of <project> (MVP runtime)')
+    .requiredOption('--prompt <text>', 'prompt for the engine')
+    .option('--engine <engine>', 'engine override (claude | codex | pi); else resolved from project/crew/host')
+    .option('--task <id>', 'task id for the worktree branch (default: adhoc-<ts>)')
+    .option('--timeout <ms>', 'timeout in ms (default 600000)')
+    .option('-c, --crew <name>', 'target crew name')
+    .action(crewDispatch);
+
+  const project = orchestrate.command('project').description('manage project owners');
   project.command('add <name>')
     .description('register a project owner')
     .requiredOption('--path <path>', 'project path')
@@ -86,7 +107,7 @@ export function registerCrewCommands(program: any): void {
     .option('-c, --crew <name>', 'target crew name')
     .action(projectStatus);
 
-  const role = crew.command('role').description('manage global crew roles');
+  const role = orchestrate.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')
@@ -106,10 +127,10 @@ export function registerCrewCommands(program: any): void {
     .option('-c, --crew <name>', 'target crew name')
     .action(roleShow);
 
-  const pending = crew.command('pending')
+  const pending = orchestrate.command('pending')
     .description('list and manage materials the user must supply (per project)');
   pending.command('list', { isDefault: true })
-    .description('list pending questions (default action; runs when `crew pending` is used without a subcommand)')
+    .description('list pending questions (default action; runs when `orchestrate pending` is used without a subcommand)')
     .option('--crew <name>', 'target crew name')
     .option('-p, --project <name>', 'limit to one project')
     .option('--all', 'include resolved questions')
@@ -122,7 +143,7 @@ export function registerCrewCommands(program: any): void {
     .option('--why <text>', 'why this information is needed')
     .option('--need <text>', 'what to provide (file path, value, decision, etc.)')
     .option('--priority <level>', 'high | medium | low')
-    .option('--asked-by <role>', 'role or person who raised the question (default: lead)')
+    .option('--asked-by <role>', 'role or person who raised the question (default: orchestrator)')
     .action((title: string[], opts: { crew?: string; project?: string; why?: string; need?: string; priority?: string; askedBy?: string }) => pendingAdd(title, opts));
   pending.command('answer <id>')
     .description('mark a pending question as resolved')
@@ -136,14 +157,14 @@ export function registerCrewCommands(program: any): void {
     .option('-p, --project <name>', 'limit to one project')
     .action(pendingRemove);
 
-  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'));
+  orchestrate.command('plan').description('planned: Orchestrator refine + decompose').action(crewStub('plan'));
+  orchestrate.command('refine').description('planned: update Shared/Spec.md').action(crewStub('refine'));
+  orchestrate.command('decompose').description('planned: split Spec into owner/role tasks').action(crewStub('decompose'));
+  orchestrate.command('run [target]').description('planned: run owner/role work').action(crewStub('run'));
+  orchestrate.command('research <topic...>').description('planned: ask Researcher to write a report').action(crewStub('research'));
+  orchestrate.command('report').description('planned: generate Orchestrator report').action(crewStub('report'));
 
-  const pm = crew.command('pm').description('PM tools');
+  const pm = orchestrate.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'));
 }