@h-rig/cli 0.0.6-alpha.94 → 0.0.6-alpha.96

package/dist/src/commands/plugin.js

@@ -1,714 +0,0 @@
-// @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 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/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: loadConfig2 } = await import("@rig/core/load-config");
-    return await loadConfig2(projectRoot);
-  } catch {
-    return null;
-  }
-}
-
-// packages/cli/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.id)
-          });
-        }
-      }
-      if (context.outputMode === "text") {
-        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 = [];
-            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-commands: ${p.cliCommands.join(", ")} (run with \`rig plugin run <id>\`)`);
-            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 (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);
-  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
-};