@h-rig/cli 0.0.6-alpha.9 → 0.0.6-alpha.91

package/dist/src/commands/plugin.js

@@ -1,14 +1,25 @@
 // @bun
 var __require = import.meta.require;
 
+// packages/cli/src/commands/plugin.ts
+import { existsSync as existsSync6 } from "fs";
+import { resolve as resolve4 } from "path";
+
 // packages/cli/src/runner.ts
 import { EventBus } from "@rig/runtime/control-plane/runtime/events";
-import { CliError } from "@rig/runtime/control-plane/errors";
+import { CliError as RuntimeCliError } from "@rig/runtime/control-plane/errors";
 import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
-import { PluginManager } from "@rig/runtime/control-plane/runtime/plugins";
-import { loadRuntimeContextFromEnv } from "@rig/runtime/control-plane/runtime/context";
 import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
-import { CliError as CliError2 } from "@rig/runtime/control-plane/errors";
+
+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;
@@ -17,7 +28,7 @@ function takeOption(args, option) {
     if (current === option) {
       const next = args[index + 1];
       if (!next || next.startsWith("-")) {
-        throw new CliError(`Missing value for ${option}`);
+        throw new CliError(`Missing value for ${option}`, 1, { hint: `Provide a value after ${option}, e.g. \`${option} <value>\`.` });
       }
       value = next;
       index += 1;
@@ -43,11 +54,493 @@ Usage: ${usage}`);
   return taskId;
 }
 
+// packages/runtime/src/control-plane/plugin-host-context.ts
+import { existsSync as existsSync5 } from "fs";
+import { resolve as resolvePath } from "path";
+import {
+  createPluginHost
+} from "@rig/core";
+import { loadConfig } from "@rig/core/load-config";
+
+// packages/runtime/src/control-plane/task-source.ts
+function createTaskSourceRegistry() {
+  const byId = new Map;
+  const order = [];
+  return {
+    register(s) {
+      if (byId.has(s.id))
+        throw new Error(`task source already registered: ${s.id}`);
+      byId.set(s.id, s);
+      order.push(s);
+    },
+    resolveById(id) {
+      const s = byId.get(id);
+      if (!s)
+        throw new Error(`task source not registered: ${id}`);
+      return s;
+    },
+    resolveByKind(kind) {
+      for (const s of order)
+        if (s.kind === kind)
+          return s;
+      throw new Error(`no task source registered for kind: ${kind}`);
+    },
+    list: () => order
+  };
+}
+
+// packages/runtime/src/control-plane/task-source-bootstrap.ts
+function formatRegisteredKinds(pluginHost) {
+  const kinds = pluginHost ? pluginHost.listExecutableTaskSources().map((source) => source.kind) : [];
+  return kinds.length > 0 ? kinds.join(", ") : "none";
+}
+function buildTaskSourceRegistry(config, pluginHost, context) {
+  const registry = createTaskSourceRegistry();
+  const taskSourceConfig = config.taskSource;
+  const factory = pluginHost?.resolveTaskSourceFactoryByKind(taskSourceConfig.kind);
+  if (!factory) {
+    throw new Error(`No task source factory registered for kind "${taskSourceConfig.kind}". ` + `Registered kinds: ${formatRegisteredKinds(pluginHost)}. ` + "Load a plugin that contributes an executable task source factory for this kind.");
+  }
+  registry.register(factory.factory(taskSourceConfig, context ? { ...context, rigConfig: config } : undefined));
+  return registry;
+}
+
+// packages/runtime/src/control-plane/repos/registry.ts
+function createRepoRegistry(entries) {
+  const map = new Map;
+  for (const e of entries) {
+    if (map.has(e.id))
+      throw new Error(`repo already registered: ${e.id}`);
+    map.set(e.id, { ...e });
+  }
+  const ordered = Array.from(map.values());
+  return {
+    getById: (id) => map.get(id),
+    list: () => ordered
+  };
+}
+var MANAGED_REPOS = new Map;
+function setManagedRepos(entries) {
+  const next = new Map;
+  for (const e of entries) {
+    if (next.has(e.id)) {
+      throw new Error(`managed repo already registered: ${e.id}`);
+    }
+    next.set(e.id, e);
+  }
+  MANAGED_REPOS = next;
+}
+function repoRegistrationToManagedEntry(reg) {
+  if (!reg.defaultBranch) {
+    return null;
+  }
+  return {
+    id: reg.id,
+    alias: reg.defaultPath ?? reg.id,
+    defaultBranch: reg.defaultBranch,
+    defaultRemoteUrl: reg.url,
+    remoteEnvVar: reg.remoteEnvVar,
+    checkoutEnvVar: reg.checkoutEnvVar
+  };
+}
+
+// packages/runtime/src/control-plane/agent-roles.ts
+function createAgentRoleRegistry(pluginRoles, configOverrides) {
+  const map = new Map;
+  for (const r of pluginRoles) {
+    if (map.has(r.id))
+      throw new Error(`agent role already registered: ${r.id}`);
+    const override = configOverrides?.[r.id];
+    const model = override?.model ?? r.defaultModel;
+    if (!model) {
+      throw new Error(`agent role "${r.id}" has no model \u2014 provide defaultModel in plugin or model in config.runtime.agentRoles.${r.id}`);
+    }
+    map.set(r.id, { ...r, model });
+  }
+  return {
+    resolve(id) {
+      const r = map.get(id);
+      if (!r)
+        throw new Error(`agent role not registered: ${id}`);
+      return r;
+    },
+    list: () => Array.from(map.values())
+  };
+}
+
+// packages/runtime/src/control-plane/task-fields.ts
+function createTaskFieldRegistry(extensions) {
+  const byId = new Map;
+  for (const e of extensions) {
+    if (byId.has(e.id))
+      throw new Error(`task field extension already registered: ${e.id}`);
+    byId.set(e.id, e);
+  }
+  return {
+    get: (id) => byId.get(id),
+    list: () => Array.from(byId.values()),
+    fieldNames: () => Array.from(byId.values()).map((e) => e.fieldName),
+    validateTaskFields(task) {
+      const errors = [];
+      for (const ext of byId.values()) {
+        let schema;
+        try {
+          schema = JSON.parse(ext.schemaJson);
+        } catch {
+          errors.push(`task field "${ext.id}": schemaJson is not valid JSON`);
+          continue;
+        }
+        const isRequired = typeof schema === "object" && schema !== null && schema.required === true;
+        if (!isRequired)
+          continue;
+        const value = task[ext.fieldName];
+        if (value === undefined || value === null || value === "") {
+          errors.push(`task field "${ext.fieldName}" (from extension "${ext.id}") is required but missing`);
+        }
+      }
+      return errors.length === 0 ? { ok: true } : { ok: false, errors };
+    }
+  };
+}
+
+// packages/runtime/src/control-plane/validators/runtime-registration.ts
+import { existsSync } from "fs";
+import { join } from "path";
+function createValidatorRegistry() {
+  const map = new Map;
+  const order = [];
+  const registry = {
+    register(v) {
+      if (map.has(v.id))
+        throw new Error(`validator already registered: ${v.id}`);
+      map.set(v.id, v);
+      order.push(v);
+    },
+    resolve(id) {
+      const v = map.get(id);
+      if (!v)
+        throw new Error(`validator not registered: ${id}`);
+      return v;
+    },
+    list: () => order
+  };
+  registerBuiltInValidators(registry);
+  return registry;
+}
+function registerBuiltInValidators(registry) {
+  registry.register({
+    id: "std:typecheck",
+    category: "custom",
+    description: "Runs the package typecheck script when present.",
+    run: async (ctx) => runStdTypecheck(ctx)
+  });
+}
+async function runStdTypecheck(ctx) {
+  const packageJsonPath = join(ctx.workspaceRoot, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return {
+      id: "std:typecheck",
+      passed: false,
+      summary: `package.json not found at ${packageJsonPath}`
+    };
+  }
+  const proc = Bun.spawn(["bun", "run", "typecheck"], {
+    cwd: ctx.workspaceRoot,
+    env: process.env,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    proc.exited,
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text()
+  ]);
+  const output = `${stdout}${stderr}`.trim();
+  return {
+    id: "std:typecheck",
+    passed: exitCode === 0,
+    summary: exitCode === 0 ? "typecheck passed" : "typecheck failed",
+    ...output ? { details: output.slice(0, 4000) } : {}
+  };
+}
+
+// packages/runtime/src/control-plane/native/scope-rules.ts
+var activeRules = null;
+function setScopeRules(rules) {
+  activeRules = rules ?? null;
+}
+
+// packages/runtime/src/control-plane/hook-materializer.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { resolveBunCliInvocation } from "@rig/hook-kit";
+var MARKER_PLUGIN = "_rigPlugin";
+var MARKER_HOOK_ID = "_rigHookId";
+function matcherToString(matcher) {
+  if (matcher.kind === "all")
+    return;
+  if (matcher.kind === "tool")
+    return matcher.name;
+  return matcher.pattern;
+}
+function isPluginOwned(cmd) {
+  return typeof cmd[MARKER_PLUGIN] === "string";
+}
+function shellQuote(value) {
+  return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+function resolveHookRunnerPath() {
+  const sibling = resolve(import.meta.dirname, "hook-runner.ts");
+  if (existsSync2(sibling)) {
+    return sibling;
+  }
+  return "$CLAUDE_PROJECT_DIR/node_modules/@rig/runtime/src/control-plane/hook-runner.ts";
+}
+function buildTypedHookShimCommand(pluginName, hook, projectRoot) {
+  const runnerPath = resolveHookRunnerPath();
+  const runnerArg = runnerPath.startsWith("$CLAUDE_PROJECT_DIR") ? `"${runnerPath}"` : shellQuote(runnerPath);
+  const bun = resolveBunCliInvocation();
+  const envPrefix = Object.entries(bun.env).map(([key, value]) => `${key}=${shellQuote(value)}`).join(" ");
+  const parts = [
+    envPrefix,
+    shellQuote(bun.command),
+    runnerArg,
+    "--plugin",
+    shellQuote(pluginName),
+    "--hook",
+    shellQuote(hook.id),
+    "--event",
+    shellQuote(hook.event),
+    "--project-root",
+    shellQuote(projectRoot)
+  ].filter(Boolean);
+  return parts.join(" ");
+}
+function materializeHooks(projectRoot, entries) {
+  const settingsPath = resolve(projectRoot, ".claude", "settings.json");
+  const existing = existsSync2(settingsPath) ? safeReadJson(settingsPath) : {};
+  const hooks = existing.hooks ?? {};
+  for (const event of Object.keys(hooks)) {
+    const groups = hooks[event] ?? [];
+    const cleaned = [];
+    for (const group of groups) {
+      const operatorHooks = group.hooks.filter((h) => !isPluginOwned(h));
+      if (operatorHooks.length > 0) {
+        cleaned.push({ ...group, hooks: operatorHooks });
+      }
+    }
+    if (cleaned.length > 0) {
+      hooks[event] = cleaned;
+    } else {
+      delete hooks[event];
+    }
+  }
+  for (const { pluginName, hook, typed } of entries) {
+    const command = hook.command ?? (typed ? buildTypedHookShimCommand(pluginName, hook, projectRoot) : undefined);
+    if (!command) {
+      continue;
+    }
+    const event = hook.event;
+    const matcherString = matcherToString(hook.matcher);
+    const groups = hooks[event] ??= [];
+    let group = groups.find((g) => g.matcher === matcherString);
+    if (!group) {
+      group = matcherString === undefined ? { hooks: [] } : { matcher: matcherString, hooks: [] };
+      groups.push(group);
+    }
+    group.hooks.push({
+      type: "command",
+      command,
+      [MARKER_PLUGIN]: pluginName,
+      [MARKER_HOOK_ID]: hook.id
+    });
+  }
+  const next = { ...existing };
+  if (Object.keys(hooks).length > 0) {
+    next.hooks = hooks;
+  } else {
+    delete next.hooks;
+  }
+  mkdirSync(dirname(settingsPath), { recursive: true });
+  writeFileSync(settingsPath, `${JSON.stringify(next, null, 2)}
+`, "utf-8");
+  return settingsPath;
+}
+function safeReadJson(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+// packages/runtime/src/control-plane/skill-materializer.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, readdirSync, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+import { loadSkill } from "@rig/skill-loader";
+var MARKER_FILENAME = ".rig-plugin";
+function skillDirName(id) {
+  return id.replace(/[^a-zA-Z0-9._-]+/g, "-");
+}
+async function materializeSkills(projectRoot, entries) {
+  const skillsRoot = resolve2(projectRoot, ".pi", "skills");
+  if (existsSync3(skillsRoot)) {
+    for (const name of readdirSync(skillsRoot)) {
+      const dir = resolve2(skillsRoot, name);
+      if (existsSync3(resolve2(dir, MARKER_FILENAME))) {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    }
+  }
+  const written = [];
+  for (const { pluginName, skill } of entries) {
+    const sourcePath = resolve2(projectRoot, skill.path);
+    if (!existsSync3(sourcePath)) {
+      console.warn(`[plugin-host] skill "${skill.id}" from plugin "${pluginName}" not materialized: ${sourcePath} does not exist`);
+      continue;
+    }
+    let body;
+    try {
+      await loadSkill(sourcePath);
+      body = readFileSync2(sourcePath, "utf-8");
+    } catch (err) {
+      console.warn(`[plugin-host] skill "${skill.id}" from plugin "${pluginName}" not materialized: ${err instanceof Error ? err.message : err}`);
+      continue;
+    }
+    const dir = resolve2(skillsRoot, skillDirName(skill.id));
+    mkdirSync2(dir, { recursive: true });
+    writeFileSync2(resolve2(dir, "SKILL.md"), body, "utf-8");
+    writeFileSync2(resolve2(dir, MARKER_FILENAME), `${JSON.stringify({ plugin: pluginName, skillId: skill.id }, null, 2)}
+`, "utf-8");
+    written.push({ id: skill.id, pluginName, directory: dir });
+  }
+  return written;
+}
+
+// packages/runtime/src/control-plane/pi-settings-materializer.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname2, resolve as resolve3 } from "path";
+var SETTINGS_RELATIVE_PATH = ".pi/settings.json";
+var MANAGED_RECORD_RELATIVE_PATH = ".rig/state/pi-managed-packages.json";
+function readJson(path, fallback) {
+  if (!existsSync4(path))
+    return fallback;
+  try {
+    return JSON.parse(readFileSync3(path, "utf-8"));
+  } catch {
+    return fallback;
+  }
+}
+function packageKey(entry) {
+  if (typeof entry === "string")
+    return entry;
+  if (entry && typeof entry === "object" && typeof entry.source === "string") {
+    return entry.source;
+  }
+  return JSON.stringify(entry);
+}
+function materializePiPackages(projectRoot, declaredPackages) {
+  const settingsPath = resolve3(projectRoot, SETTINGS_RELATIVE_PATH);
+  const managedRecordPath = resolve3(projectRoot, MANAGED_RECORD_RELATIVE_PATH);
+  const settings = readJson(settingsPath, {});
+  const previouslyManaged = new Set(readJson(managedRecordPath, []));
+  const existing = Array.isArray(settings.packages) ? settings.packages : [];
+  const operatorEntries = existing.filter((entry) => !previouslyManaged.has(packageKey(entry)));
+  const operatorKeys = new Set(operatorEntries.map(packageKey));
+  const managedToAdd = declaredPackages.filter((pkg) => !operatorKeys.has(pkg));
+  const nextPackages = [...operatorEntries, ...managedToAdd];
+  if (nextPackages.length > 0 || existsSync4(settingsPath)) {
+    const nextSettings = { ...settings };
+    if (nextPackages.length > 0) {
+      nextSettings.packages = nextPackages;
+    } else {
+      delete nextSettings.packages;
+    }
+    mkdirSync3(dirname2(settingsPath), { recursive: true });
+    writeFileSync3(settingsPath, `${JSON.stringify(nextSettings, null, 2)}
+`, "utf-8");
+  }
+  mkdirSync3(dirname2(managedRecordPath), { recursive: true });
+  writeFileSync3(managedRecordPath, `${JSON.stringify(managedToAdd, null, 2)}
+`, "utf-8");
+  return { settingsPath, packages: managedToAdd };
+}
+
+// packages/runtime/src/control-plane/plugin-host-context.ts
+async function buildPluginHostContext(projectRoot) {
+  let config;
+  try {
+    config = await loadConfig(projectRoot);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("no rig.config")) {
+      return null;
+    }
+    throw err;
+  }
+  const pluginHost = createPluginHost(config.plugins);
+  setScopeRules(config.workspace.scopeNormalization);
+  if (config.workspace.sandbox && !process.env.RIG_RUNTIME_SANDBOX?.trim()) {
+    process.env.RIG_RUNTIME_SANDBOX = config.workspace.sandbox;
+  }
+  const validatorRegistry = createValidatorRegistry();
+  for (const impl of pluginHost.listExecutableValidators()) {
+    validatorRegistry.register(impl);
+  }
+  const taskSourceRegistry = buildTaskSourceRegistry(config, pluginHost, { projectRoot });
+  const repoRegistry = createRepoRegistry(pluginHost.listRepoSources());
+  const managedEntries = pluginHost.listRepoSources().map(repoRegistrationToManagedEntry).filter((e) => e !== null);
+  setManagedRepos(managedEntries);
+  const configRoleOverrides = config.runtime?.agentRoles;
+  const agentRoleRegistry = createAgentRoleRegistry(pluginHost.listAgentRoles(), configRoleOverrides);
+  const taskFieldRegistry = createTaskFieldRegistry(pluginHost.listTaskFieldExtensions());
+  try {
+    const hookEntries = config.plugins.flatMap((plugin) => (plugin.contributes?.hooks ?? []).map((hook) => ({
+      pluginName: plugin.name,
+      hook,
+      typed: Boolean(plugin.__runtime?.hooks?.[hook.id])
+    })));
+    if (hookEntries.length > 0) {
+      materializeHooks(projectRoot, hookEntries);
+    }
+  } catch (err) {
+    console.warn(`[plugin-host] hook materialization failed: ${err instanceof Error ? err.message : err}`);
+  }
+  try {
+    const skillEntries = config.plugins.flatMap((plugin) => (plugin.contributes?.skills ?? []).map((skill) => ({
+      pluginName: plugin.name,
+      skill
+    })));
+    if (skillEntries.length > 0) {
+      await materializeSkills(projectRoot, skillEntries);
+    }
+  } catch (err) {
+    console.warn(`[plugin-host] skill materialization failed: ${err instanceof Error ? err.message : err}`);
+  }
+  try {
+    const piPackages = config.runtime?.pi?.packages ?? [];
+    if (piPackages.length > 0 || existsSync5(resolvePath(projectRoot, ".rig/state/pi-managed-packages.json"))) {
+      materializePiPackages(projectRoot, piPackages);
+    }
+  } catch (err) {
+    console.warn(`[plugin-host] Pi package materialization failed: ${err instanceof Error ? err.message : err}`);
+  }
+  return {
+    config,
+    pluginHost,
+    validatorRegistry,
+    taskSourceRegistry,
+    repoRegistry,
+    agentRoleRegistry,
+    taskFieldRegistry
+  };
+}
+
 // packages/cli/src/commands/_parsers.ts
 async function loadRigConfigOrNull(projectRoot) {
   try {
-    const { loadConfig } = await import("@rig/core/load-config");
-    return await loadConfig(projectRoot);
+    const { loadConfig: loadConfig2 } = await import("@rig/core/load-config");
+    return await loadConfig2(projectRoot);
   } catch {
     return null;
   }
@@ -58,8 +551,7 @@ async function executePlugin(context, args) {
   const [command = "list", ...rest] = args;
   switch (command) {
     case "list": {
-      requireNoExtraArgs(rest, "bun run rig plugin list");
-      const legacyPlugins = context.plugins.list();
+      requireNoExtraArgs(rest, "rig plugin list");
       const declarative = [];
       const config = await loadRigConfigOrNull(context.projectRoot);
       if (config && Array.isArray(config.plugins)) {
@@ -75,16 +567,16 @@ async function executePlugin(context, args) {
             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((c2) => c2.id)
+            cliCommands: (c.cliCommands ?? []).map((entry) => entry.id)
           });
         }
       }
       if (context.outputMode === "text") {
-        if (legacyPlugins.length === 0 && declarative.length === 0) {
-          console.log("No plugins loaded.");
-        }
-        if (declarative.length > 0) {
-          console.log("Declarative plugins (rig.config.ts):");
+        if (declarative.length === 0) {
+          const configExists = ["rig.config.ts", "rig.config.mts", "rig.config.json"].some((name) => existsSync6(resolve4(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 = [];
@@ -103,31 +595,45 @@ async function executePlugin(context, args) {
             if (p.taskFieldExtensions.length)
               lines.push(`    task-fields: ${p.taskFieldExtensions.join(", ")}`);
             if (p.cliCommands.length)
-              lines.push(`    cli-commands: ${p.cliCommands.join(", ")}`);
+              lines.push(`    cli-commands: ${p.cliCommands.join(", ")} (run with \`rig plugin run <id>\`)`);
             for (const line of lines)
               console.log(line);
           }
         }
-        if (legacyPlugins.length > 0) {
-          console.log("Legacy disk-scan plugins (rig/plugins/):");
-          for (const plugin of legacyPlugins) {
-            const validators = plugin.validators.length > 0 ? plugin.validators.join(", ") : "none";
-            console.log(`  ${plugin.name} (validators: ${validators})`);
-          }
-        }
       }
       return {
         ok: true,
         group: "plugin",
         command,
-        details: { declarative, legacy: legacyPlugins }
+        details: { declarative }
       };
     }
     case "validate": {
       const { value: task, rest: remaining } = takeOption(rest, "--task");
-      requireNoExtraArgs(remaining, "bun run rig plugin validate --task <beads-id>");
-      const taskId = requireTask(task, "bun run rig plugin validate --task <beads-id>");
-      const results = await context.plugins.runValidators(taskId);
+      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") {
@@ -144,7 +650,7 @@ async function executePlugin(context, args) {
         }
       }
       if (failed > 0) {
-        throw new CliError2(`Plugin validation failed for ${failed} validator(s).`, 2);
+        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,
@@ -158,10 +664,51 @@ async function executePlugin(context, args) {
         }
       };
     }
+    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 (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 CliError2(`Unknown plugin command: ${command}`);
+      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);
+  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>;