@h-rig/cli-surface-plugin 0.0.6-alpha.146

package/dist/src/commands/plugin.js

@@ -0,0 +1,238 @@
+// @bun
+var __require = import.meta.require;
+
+// packages/cli-surface-plugin/src/commands/plugin.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+
+// packages/cli-surface-plugin/src/runner.ts
+import { EventBus } from "@rig/runtime/control-plane/runtime/events";
+import { CliError as RuntimeCliError } from "@rig/runtime/control-plane/errors";
+import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
+import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
+
+class CliError extends RuntimeCliError {
+  hint;
+  constructor(message, exitCode = 1, options = {}) {
+    super(message, exitCode);
+    if (options.hint?.trim()) {
+      this.hint = options.hint.trim();
+    }
+  }
+}
+function takeOption(args, option) {
+  const rest = [];
+  let value;
+  for (let index = 0;index < args.length; index += 1) {
+    const current = args[index];
+    if (current === option) {
+      const next = args[index + 1];
+      if (!next || next.startsWith("-")) {
+        throw new CliError(`Missing value for ${option}`, 1, { hint: `Provide a value after ${option}, e.g. \`${option} <value>\`.` });
+      }
+      value = next;
+      index += 1;
+      continue;
+    }
+    if (current !== undefined) {
+      rest.push(current);
+    }
+  }
+  return { value, rest };
+}
+function requireNoExtraArgs(args, usage) {
+  if (args.length > 0) {
+    throw new CliError(`Unexpected arguments: ${args.join(" ")}
+Usage: ${usage}`);
+  }
+}
+function requireTask(taskId, usage) {
+  if (!taskId) {
+    throw new CliError(`Missing --task option.
+Usage: ${usage}`);
+  }
+  return taskId;
+}
+
+// packages/cli-surface-plugin/src/commands/plugin.ts
+import { buildPluginHostContext } from "@rig/runtime/control-plane/plugin-host-context";
+
+// packages/cli-surface-plugin/src/commands/_parsers.ts
+async function loadRigConfigOrNull(projectRoot) {
+  try {
+    const { loadConfig } = await import("@rig/core/load-config");
+    return await loadConfig(projectRoot);
+  } catch {
+    return null;
+  }
+}
+
+// packages/cli-surface-plugin/src/commands/plugin.ts
+async function executePlugin(context, args) {
+  const [command = "list", ...rest] = args;
+  switch (command) {
+    case "list": {
+      requireNoExtraArgs(rest, "rig plugin list");
+      const declarative = [];
+      const config = await loadRigConfigOrNull(context.projectRoot);
+      if (config && Array.isArray(config.plugins)) {
+        for (const plugin of config.plugins) {
+          const c = plugin.contributes ?? {};
+          declarative.push({
+            name: plugin.name,
+            version: plugin.version,
+            validators: (c.validators ?? []).map((v) => v.id),
+            hooks: (c.hooks ?? []).map((h) => h.id),
+            agentRoles: (c.agentRoles ?? []).map((r) => r.id),
+            repoSources: (c.repoSources ?? []).map((r) => r.id),
+            taskSources: (c.taskSources ?? []).map((s) => s.id),
+            skills: (c.skills ?? []).map((s) => s.id),
+            taskFieldExtensions: (c.taskFieldSchemas ?? []).map((f) => f.id),
+            cliCommands: (c.cliCommands ?? []).map((entry) => entry.family ?? entry.id)
+          });
+        }
+      }
+      if (context.outputMode === "text") {
+        if (declarative.length === 0) {
+          const configExists = ["rig.config.ts", "rig.config.mts", "rig.config.json"].some((name) => existsSync(resolve(context.projectRoot, name)));
+          console.log(configExists ? "rig.config found but no plugins could be loaded. If the config imports @rig/* packages, run `bun install` in this project first." : "No plugins loaded. Declare plugins in rig.config.ts.");
+        } else {
+          console.log("Plugins (rig.config.ts):");
+          for (const p of declarative) {
+            console.log(`  ${p.name}@${p.version}`);
+            const lines = [];
+            if (p.validators.length)
+              lines.push(`    validators: ${p.validators.join(", ")}`);
+            if (p.hooks.length)
+              lines.push(`    hooks: ${p.hooks.join(", ")}`);
+            if (p.agentRoles.length)
+              lines.push(`    agent-roles: ${p.agentRoles.join(", ")}`);
+            if (p.repoSources.length)
+              lines.push(`    repo-sources: ${p.repoSources.join(", ")}`);
+            if (p.taskSources.length)
+              lines.push(`    task-sources: ${p.taskSources.join(", ")}`);
+            if (p.skills.length)
+              lines.push(`    skills: ${p.skills.join(", ")}`);
+            if (p.taskFieldExtensions.length)
+              lines.push(`    task-fields: ${p.taskFieldExtensions.join(", ")}`);
+            if (p.cliCommands.length)
+              lines.push(`    cli-families: ${p.cliCommands.join(", ")}`);
+            for (const line of lines)
+              console.log(line);
+          }
+        }
+      }
+      return {
+        ok: true,
+        group: "plugin",
+        command,
+        details: { declarative }
+      };
+    }
+    case "validate": {
+      const { value: task, rest: remaining } = takeOption(rest, "--task");
+      requireNoExtraArgs(remaining, "rig plugin validate --task <task-id>");
+      const taskId = requireTask(task, "rig plugin validate --task <task-id>");
+      const hostCtx = await buildPluginHostContext(context.projectRoot);
+      if (!hostCtx) {
+        throw new CliError(`No rig.config found at ${context.projectRoot}. Run \`rig init\` to set up plugins.`, 2);
+      }
+      const validators = hostCtx.validatorRegistry.list();
+      const results = [];
+      for (const validator of validators) {
+        try {
+          results.push(await validator.run({
+            taskId,
+            workspaceRoot: context.projectRoot,
+            scope: []
+          }));
+        } catch (error) {
+          results.push({
+            id: validator.id,
+            passed: false,
+            summary: `${validator.id} failed unexpectedly`,
+            details: `${error}`
+          });
+        }
+      }
+      const passed = results.filter((result) => result.passed).length;
+      const failed = results.length - passed;
+      if (context.outputMode === "text") {
+        if (results.length === 0) {
+          console.log("No plugin validators registered.");
+        } else {
+          for (const result of results) {
+            const icon = result.passed ? "PASS" : "FAIL";
+            console.log(`[${icon}] ${result.id}: ${result.summary}`);
+            if (result.details && !result.passed) {
+              console.log(result.details);
+            }
+          }
+        }
+      }
+      if (failed > 0) {
+        throw new CliError(`Plugin validation failed for ${failed} validator(s).`, 2, { hint: "Fix the reported validators, then re-run `rig plugin validate --task <id>`." });
+      }
+      return {
+        ok: true,
+        group: "plugin",
+        command,
+        details: {
+          taskId,
+          passed,
+          failed,
+          results
+        }
+      };
+    }
+    case "run": {
+      const [commandId, ...commandArgs] = rest;
+      if (!commandId) {
+        throw new CliError("Usage: rig plugin run <command-id> [args...]", 1, { hint: "Run `rig plugin list` to see plugin-contributed command ids." });
+      }
+      const hostCtx = await buildPluginHostContext(context.projectRoot);
+      if (!hostCtx) {
+        throw new CliError(`No rig.config found at ${context.projectRoot}. Run \`rig init\` to set up plugins.`, 2);
+      }
+      const registration = resolvePluginCliCommand(hostCtx.pluginHost.listCliCommands(), commandId);
+      if (!registration) {
+        const available = hostCtx.pluginHost.listCliCommands().map((entry) => entry.id);
+        throw new CliError(available.length > 0 ? `Unknown plugin command "${commandId}". Available: ${available.join(", ")}` : `No plugin CLI commands are registered. Plugins contribute them via contributes.cliCommands.`, 2);
+      }
+      if (!registration.command) {
+        throw new CliError(`Plugin CLI family "${registration.id}" is an in-process command; invoke it as \`rig ${registration.family ?? registration.id}\`, not through \`rig plugin run\`.`, 1);
+      }
+      if (context.dryRun) {
+        if (context.outputMode === "text") {
+          console.log(`[dry-run] ${registration.command}${commandArgs.length ? ` ${commandArgs.join(" ")}` : ""}`);
+        }
+        return { ok: true, group: "plugin", command, details: { id: registration.id, dryRun: true } };
+      }
+      const proc = Bun.spawn(["bash", "-c", `${registration.command} "$@"`, registration.id, ...commandArgs], {
+        cwd: context.projectRoot,
+        env: process.env,
+        stdin: "inherit",
+        stdout: "inherit",
+        stderr: "inherit"
+      });
+      const exitCode = await proc.exited;
+      if (exitCode !== 0) {
+        throw new CliError(`Plugin command "${registration.id}" exited with code ${exitCode}.`, exitCode, { hint: "Run `rig plugin list` to inspect the contributing plugin, or re-run with --json for details." });
+      }
+      return { ok: true, group: "plugin", command, details: { id: registration.id, exitCode } };
+    }
+    default:
+      throw new CliError(`Unknown plugin command: ${command}`, 1, { hint: "Run `rig plugin --help` \u2014 commands are list|validate|run." });
+  }
+}
+function resolvePluginCliCommand(commands, requested) {
+  const exact = commands.find((entry) => entry.id === requested || entry.family === requested || (entry.aliases ?? []).includes(requested));
+  if (exact)
+    return exact;
+  const byLocalPart = commands.filter((entry) => entry.id.split(":").slice(1).join(":") === requested);
+  return byLocalPart.length === 1 ? byLocalPart[0] : undefined;
+}
+export {
+  resolvePluginCliCommand,
+  executePlugin
+};

package/dist/src/commands/profile-and-review.d.ts

@@ -0,0 +1,4 @@
+import { type RunnerContext } from "../runner";
+import type { CommandOutcome } from "@rig/runtime";
+export declare function executeProfile(context: RunnerContext, args: string[]): Promise<CommandOutcome>;
+export declare function executeReview(context: RunnerContext, args: string[]): Promise<CommandOutcome>;

package/dist/src/commands/profile-and-review.js

@@ -0,0 +1,223 @@
+// @bun
+// packages/cli-surface-plugin/src/commands/profile-and-review.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+
+// packages/cli-surface-plugin/src/runner.ts
+import { EventBus } from "@rig/runtime/control-plane/runtime/events";
+import { CliError as RuntimeCliError } from "@rig/runtime/control-plane/errors";
+import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
+import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
+
+class CliError extends RuntimeCliError {
+  hint;
+  constructor(message, exitCode = 1, options = {}) {
+    super(message, exitCode);
+    if (options.hint?.trim()) {
+      this.hint = options.hint.trim();
+    }
+  }
+}
+function takeOption(args, option) {
+  const rest = [];
+  let value;
+  for (let index = 0;index < args.length; index += 1) {
+    const current = args[index];
+    if (current === option) {
+      const next = args[index + 1];
+      if (!next || next.startsWith("-")) {
+        throw new CliError(`Missing value for ${option}`, 1, { hint: `Provide a value after ${option}, e.g. \`${option} <value>\`.` });
+      }
+      value = next;
+      index += 1;
+      continue;
+    }
+    if (current !== undefined) {
+      rest.push(current);
+    }
+  }
+  return { value, rest };
+}
+function requireNoExtraArgs(args, usage) {
+  if (args.length > 0) {
+    throw new CliError(`Unexpected arguments: ${args.join(" ")}
+Usage: ${usage}`);
+  }
+}
+
+// packages/cli-surface-plugin/src/withMutedConsole.ts
+function isPromise(value) {
+  if (typeof value !== "object" && typeof value !== "function") {
+    return false;
+  }
+  return value !== null && typeof value.then === "function";
+}
+function withMutedConsole(mute, fn) {
+  if (!mute) {
+    return fn();
+  }
+  const originalLog = console.log;
+  const originalWarn = console.warn;
+  const originalInfo = console.info;
+  const restore = () => {
+    console.log = originalLog;
+    console.warn = originalWarn;
+    console.info = originalInfo;
+  };
+  console.log = () => {};
+  console.warn = () => {};
+  console.info = () => {};
+  try {
+    const result = fn();
+    if (isPromise(result)) {
+      return result.finally(restore);
+    }
+    restore();
+    return result;
+  } catch (error) {
+    restore();
+    throw error;
+  } finally {
+    if (console.log === originalLog) {
+      restore();
+    }
+  }
+}
+
+// packages/cli-surface-plugin/src/commands/_paths.ts
+import { resolve } from "path";
+import { resolveMonorepoRoot } from "@rig/runtime/layout";
+function resolveControlPlaneHostStateRoot(projectRoot) {
+  return resolve(projectRoot, ".rig");
+}
+function resolveControlPlaneHostStateDir(projectRoot) {
+  return resolve(resolveControlPlaneHostStateRoot(projectRoot), "state");
+}
+
+// packages/cli-surface-plugin/src/commands/profile-and-review.ts
+var DEFAULT_AGENT_PROFILE = {
+  model: "pi",
+  runtime: "pi",
+  agent_plugin: "pi",
+  updated_at: new Date().toISOString()
+};
+function agentProfilePath(projectRoot) {
+  return `${resolveControlPlaneHostStateDir(projectRoot)}/agent-profile.json`;
+}
+function reviewProfilePath(projectRoot) {
+  return `${resolveControlPlaneHostStateDir(projectRoot)}/review-profile.json`;
+}
+function readJson(path) {
+  if (!existsSync(path))
+    return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function showProfile(projectRoot) {
+  const profile = { ...DEFAULT_AGENT_PROFILE, ...readJson(agentProfilePath(projectRoot)), model: "pi", runtime: "pi", agent_plugin: "pi" };
+  console.log("Execution Profile:");
+  console.log(`  model:        ${profile.model}`);
+  console.log(`  runtime:      ${profile.runtime}`);
+  console.log(`  plugin:       ${profile.agent_plugin}`);
+}
+async function setProfile(projectRoot) {
+  mkdirSync(resolveControlPlaneHostStateDir(projectRoot), { recursive: true });
+  writeFileSync(agentProfilePath(projectRoot), `${JSON.stringify({ ...DEFAULT_AGENT_PROFILE, updated_at: new Date().toISOString() }, null, 2)}
+`, "utf8");
+  await showProfile(projectRoot);
+}
+async function showReviewProfile(projectRoot) {
+  const parsed = readJson(reviewProfilePath(projectRoot));
+  const profile = {
+    mode: parsed?.mode === "off" || parsed?.mode === "required" || parsed?.mode === "advisory" ? parsed.mode : "advisory",
+    provider: "greptile",
+    updated_at: typeof parsed?.updated_at === "string" ? parsed.updated_at : new Date().toISOString()
+  };
+  console.log("AI Review Profile:");
+  console.log(`  mode:      ${profile.mode}`);
+  console.log(`  provider:  ${profile.provider}`);
+  console.log(`  file:      ${reviewProfilePath(projectRoot)}`);
+}
+async function setReviewProfile(projectRoot, mode, provider) {
+  if (mode !== "off" && mode !== "advisory" && mode !== "required") {
+    throw new Error(`Invalid mode: ${mode}. Use off|advisory|required.`);
+  }
+  if (provider && provider !== "greptile") {
+    throw new Error(`Invalid provider: ${provider}. Supported: greptile.`);
+  }
+  mkdirSync(resolveControlPlaneHostStateDir(projectRoot), { recursive: true });
+  writeFileSync(reviewProfilePath(projectRoot), `${JSON.stringify({ mode, provider: "greptile", updated_at: new Date().toISOString() }, null, 2)}
+`, "utf8");
+  await showReviewProfile(projectRoot);
+}
+async function executeProfile(context, args) {
+  const [command = "show", ...rest] = args;
+  switch (command) {
+    case "show":
+      requireNoExtraArgs(rest, "rig profile show");
+      await withMutedConsole(context.outputMode === "json", () => showProfile(context.projectRoot));
+      return { ok: true, group: "profile", command };
+    case "set": {
+      let pending = rest;
+      const presetResult = takeOption(pending, "--preset");
+      pending = presetResult.rest;
+      const modelResult = takeOption(pending, "--model");
+      pending = modelResult.rest;
+      const runtimeResult = takeOption(pending, "--runtime");
+      pending = runtimeResult.rest;
+      const pluginResult = takeOption(pending, "--plugin");
+      pending = pluginResult.rest;
+      requireNoExtraArgs(pending, "rig profile set [--model ...] [--runtime ...] [--plugin ...]");
+      if (!presetResult.value && !modelResult.value && !runtimeResult.value && !pluginResult.value && rest.length === 0) {
+        throw new CliError("Provide at least one of --model, --runtime, or --plugin.", 1, {
+          hint: "Example: `rig profile set --model pi`. See current values with `rig profile show`."
+        });
+      }
+      await withMutedConsole(context.outputMode === "json", () => setProfile(context.projectRoot));
+      return { ok: true, group: "profile", command, details: { lockedTo: "pi" } };
+    }
+    default:
+      throw new CliError(`Unknown profile command: ${command}`, 1, { hint: "Run `rig profile --help` \u2014 commands are show|set." });
+  }
+}
+async function executeReview(context, args) {
+  const [command = "show", ...rest] = args;
+  switch (command) {
+    case "show":
+      requireNoExtraArgs(rest, "rig review show");
+      await withMutedConsole(context.outputMode === "json", () => showReviewProfile(context.projectRoot));
+      return { ok: true, group: "review", command };
+    case "set": {
+      let pending = rest;
+      const modeResult = takeOption(pending, "--mode");
+      pending = modeResult.rest;
+      const providerResult = takeOption(pending, "--provider");
+      pending = providerResult.rest;
+      const positionalMode = pending[0];
+      if (modeResult.value && positionalMode) {
+        throw new CliError("Usage: rig review set <off|advisory|required> [--provider greptile]", 1, {
+          hint: "Pass the mode positionally, or use --mode as a compatibility alias, but not both."
+        });
+      }
+      requireNoExtraArgs(positionalMode ? pending.slice(1) : pending, "rig review set <off|advisory|required> [--provider greptile]");
+      const mode = modeResult.value ?? positionalMode;
+      if (!mode) {
+        throw new CliError("Usage: rig review set <off|advisory|required> [--provider greptile]", 1);
+      }
+      try {
+        await withMutedConsole(context.outputMode === "json", () => setReviewProfile(context.projectRoot, mode, providerResult.value));
+      } catch (error) {
+        throw new CliError(error instanceof Error ? error.message : String(error), 2);
+      }
+      return { ok: true, group: "review", command, details: { mode, provider: "greptile" } };
+    }
+    default:
+      throw new CliError(`Unknown review command: ${command}`, 1, { hint: "Run `rig review --help` \u2014 commands are show|set." });
+  }
+}
+export {
+  executeReview,
+  executeProfile
+};

package/dist/src/commands/queue.d.ts

@@ -0,0 +1,3 @@
+import { type RunnerContext } from "../runner";
+import type { CommandOutcome } from "@rig/runtime/control-plane/runtime/types";
+export declare function executeQueue(context: RunnerContext, args: string[]): Promise<CommandOutcome>;

package/dist/src/commands/queue.js

@@ -0,0 +1,197 @@
+// @bun
+// packages/cli-surface-plugin/src/runner.ts
+import { EventBus } from "@rig/runtime/control-plane/runtime/events";
+import { CliError as RuntimeCliError } from "@rig/runtime/control-plane/errors";
+import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
+import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
+
+class CliError extends RuntimeCliError {
+  hint;
+  constructor(message, exitCode = 1, options = {}) {
+    super(message, exitCode);
+    if (options.hint?.trim()) {
+      this.hint = options.hint.trim();
+    }
+  }
+}
+function takeFlag(args, flag) {
+  const rest = [];
+  let value = false;
+  for (const arg of args) {
+    if (arg === flag) {
+      value = true;
+      continue;
+    }
+    rest.push(arg);
+  }
+  return { value, rest };
+}
+function takeOption(args, option) {
+  const rest = [];
+  let value;
+  for (let index = 0;index < args.length; index += 1) {
+    const current = args[index];
+    if (current === option) {
+      const next = args[index + 1];
+      if (!next || next.startsWith("-")) {
+        throw new CliError(`Missing value for ${option}`, 1, { hint: `Provide a value after ${option}, e.g. \`${option} <value>\`.` });
+      }
+      value = next;
+      index += 1;
+      continue;
+    }
+    if (current !== undefined) {
+      rest.push(current);
+    }
+  }
+  return { value, rest };
+}
+function requireNoExtraArgs(args, usage) {
+  if (args.length > 0) {
+    throw new CliError(`Unexpected arguments: ${args.join(" ")}
+Usage: ${usage}`);
+  }
+}
+
+// packages/cli-surface-plugin/src/commands/queue.ts
+import { runPriorityQueue } from "@rig/runtime/control-plane/runtime/queue";
+
+// packages/cli-surface-plugin/src/commands/_parsers.ts
+function parsePositiveInt(value, option, fallback) {
+  if (!value) {
+    return fallback;
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new CliError(`Invalid ${option} value: ${value}`, 1, { hint: `Pass a positive integer, e.g. \`${option} 10\`.` });
+  }
+  return parsed;
+}
+function parseAction(value) {
+  if (!value || value === "validate") {
+    return "validate";
+  }
+  if (value === "verify") {
+    return "verify";
+  }
+  if (value === "pipeline") {
+    return "pipeline";
+  }
+  throw new CliError(`Invalid --action value: ${value}. Use validate, verify, or pipeline.`);
+}
+function parseIsolationMode(value, allowOff) {
+  if (!value) {
+    return "worktree";
+  }
+  if (value === "worktree") {
+    return value;
+  }
+  if (allowOff && value === "off") {
+    return value;
+  }
+  throw new CliError(`Invalid isolation mode: ${value}. Use ${allowOff ? "off|" : ""}worktree.`);
+}
+
+// packages/cli-surface-plugin/src/commands/queue.ts
+import { ensureProjectMainFreshBeforeRun } from "@rig/runtime/control-plane/project-main-pre-run-sync";
+async function runProjectMainSyncPreflight(context, options) {
+  if (context.dryRun) {
+    if (context.outputMode === "text" && !options.disabled) {
+      console.log("[dry-run] project-rig pre-run sync check");
+    }
+    return;
+  }
+  const result = await ensureProjectMainFreshBeforeRun({
+    projectRoot: context.projectRoot,
+    disabled: options.disabled,
+    runBootstrap: async () => {
+      const bootstrap = await context.runCommand(["bun", "run", "bootstrap"]);
+      if (bootstrap.exitCode !== 0) {
+        throw new CliError(bootstrap.stderr || bootstrap.stdout || "bun run bootstrap failed during project pre-run sync", bootstrap.exitCode || 1);
+      }
+    }
+  });
+  if (context.outputMode !== "text") {
+    return;
+  }
+  switch (result.status) {
+    case "disabled":
+      console.log("Project pre-run sync skipped (--skip-project-sync).");
+      break;
+    case "skipped_not_main":
+      console.log(`Project pre-run sync skipped (current branch: ${result.branch}).`);
+      break;
+    case "up_to_date":
+      break;
+    case "local_ahead":
+      console.log(`Project pre-run sync skipped (local main ahead by ${result.localAhead} commit(s)).`);
+      break;
+    case "updated":
+      console.log(`Project pre-run sync updated local main from origin/main (+${result.remoteAhead}) and bootstrapped.`);
+      break;
+  }
+}
+async function executeQueue(context, args) {
+  const [command = "run", ...rest] = args;
+  switch (command) {
+    case "run": {
+      let pending = rest;
+      const workersResult = takeOption(pending, "--workers");
+      pending = workersResult.rest;
+      const maxTasksResult = takeOption(pending, "--max-tasks");
+      pending = maxTasksResult.rest;
+      const actionResult = takeOption(pending, "--action");
+      pending = actionResult.rest;
+      const isolationResult = takeOption(pending, "--isolation");
+      pending = isolationResult.rest;
+      const noRuntimeReuseResult = takeFlag(pending, "--no-runtime-reuse");
+      pending = noRuntimeReuseResult.rest;
+      const failFastResult = takeFlag(pending, "--fail-fast");
+      pending = failFastResult.rest;
+      const skipProjectSyncResult = takeFlag(pending, "--skip-project-sync");
+      pending = skipProjectSyncResult.rest;
+      requireNoExtraArgs(pending, "rig queue run [--workers <n>] [--max-tasks <n>] [--action validate|verify|pipeline] [--isolation off|worktree] [--no-runtime-reuse] [--fail-fast] [--skip-project-sync]");
+      const workers = parsePositiveInt(workersResult.value, "--workers", 2);
+      const maxTasks = parsePositiveInt(maxTasksResult.value, "--max-tasks", 10);
+      const action = parseAction(actionResult.value);
+      const isolation = parseIsolationMode(isolationResult.value, true);
+      const reuseRuntime = !noRuntimeReuseResult.value;
+      await runProjectMainSyncPreflight(context, { disabled: skipProjectSyncResult.value });
+      const summary = await runPriorityQueue(context, {
+        workers,
+        maxTasks,
+        action,
+        isolation,
+        reuseRuntime,
+        failFast: failFastResult.value
+      });
+      if (context.outputMode === "text") {
+        console.log(`Processed: ${summary.processed}`);
+        console.log(`Succeeded: ${summary.succeeded}`);
+        console.log(`Failed: ${summary.failed}`);
+      }
+      if (summary.failed > 0) {
+        throw new CliError(`Queue finished with ${summary.failed} failed task(s).`, 3, { hint: "Inspect the failures with `rig inspect failures`, then re-run `rig queue run`." });
+      }
+      return {
+        ok: true,
+        group: "queue",
+        command,
+        details: {
+          workers,
+          maxTasks,
+          action,
+          isolation,
+          reuseRuntime,
+          failFast: failFastResult.value,
+          summary
+        }
+      };
+    }
+    default:
+      throw new CliError(`Unknown queue command: ${command}`, 1, { hint: "Run `rig queue --help` \u2014 the primary command is `rig queue run`." });
+  }
+}
+export {
+  executeQueue
+};

package/dist/src/commands/remote.d.ts

@@ -0,0 +1,3 @@
+import { type RunnerContext } from "../runner";
+import type { CommandOutcome } from "@rig/runtime";
+export declare function executeRemote(context: RunnerContext, args: string[]): Promise<CommandOutcome>;