@h-rig/core 0.0.6-alpha.15 → 0.0.6-alpha.150

package/dist/src/load-config.d.ts

@@ -0,0 +1,2 @@
+import { RigConfig } from "@rig/contracts";
+export declare function loadConfig(cwd: string): Promise<RigConfig>;

package/dist/src/load-config.js

@@ -1,17 +1,321 @@
 // @bun
 // packages/core/src/load-config.ts
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync } from "fs";
+import { isBuiltin } from "module";
+import { dirname, isAbsolute, join, relative, resolve } from "path";
 import { pathToFileURL } from "url";
+import { Schema as Schema2 } from "effect";
+import { RigConfig as RigConfig2 } from "@rig/contracts";
+
+// packages/core/src/define-config.ts
 import { Schema } from "effect";
 import { RigConfig } from "@rig/contracts";
+function normalizeWorkspaceConfig(raw) {
+  const workspace = raw && typeof raw === "object" && !Array.isArray(raw) ? { ...raw } : { mainRepo: "." };
+  workspace.checkout = workspace.checkout ?? workspace.isolation ?? "worktree";
+  workspace.isolation = workspace.isolation ?? workspace.checkout;
+  workspace.sandbox = workspace.sandbox ?? "enforce";
+  return workspace;
+}
+function applyConfigDefaults(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return raw;
+  const record = raw;
+  return {
+    ...record,
+    plugins: Array.isArray(record.plugins) ? record.plugins : [],
+    workspace: normalizeWorkspaceConfig(record.workspace)
+  };
+}
+
+// packages/core/src/load-config.ts
 var TS_NAMES = ["rig.config.ts", "rig.config.mts"];
 var JSON_NAMES = ["rig.config.json"];
+function isModuleResolutionError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes("Cannot find module") || message.includes("Could not resolve");
+}
+function runningFromCompiledBinary() {
+  return import.meta.url.includes("$bunfs");
+}
+function packageNameAndSubpath(specifier) {
+  if (specifier.startsWith(".") || specifier.startsWith("/") || /^[a-zA-Z]+:/.test(specifier))
+    return null;
+  const parts = specifier.split("/");
+  const packageName = specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+  if (!packageName)
+    return null;
+  const rest = parts.slice(specifier.startsWith("@") ? 2 : 1).join("/");
+  return { packageName, subpath: rest ? `./${rest}` : "." };
+}
+function exportTargetFromEntry(entry) {
+  if (typeof entry === "string")
+    return entry;
+  if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+    const conditions = entry;
+    for (const key of ["bun", "import", "default", "require"]) {
+      if (typeof conditions[key] === "string")
+        return conditions[key];
+    }
+  }
+  return null;
+}
+function patternExportTarget(record, subpath) {
+  for (const [pattern, entry] of Object.entries(record)) {
+    if (!pattern.includes("*"))
+      continue;
+    const [prefix = "", suffix = ""] = pattern.split("*");
+    if (!subpath.startsWith(prefix) || !subpath.endsWith(suffix))
+      continue;
+    const replacement = subpath.slice(prefix.length, subpath.length - suffix.length);
+    const target = exportTargetFromEntry(entry);
+    if (target)
+      return target.replace("*", replacement);
+  }
+  return null;
+}
+function exportTargetFromPackageJson(pkg, subpath) {
+  const exportsField = pkg.exports;
+  const target = (() => {
+    if (typeof exportsField === "string" && subpath === ".")
+      return exportsField;
+    if (!exportsField || typeof exportsField !== "object" || Array.isArray(exportsField))
+      return null;
+    const record = exportsField;
+    return exportTargetFromEntry(record[subpath] ?? (subpath === "." ? record["."] : undefined)) ?? patternExportTarget(record, subpath);
+  })();
+  if (target)
+    return target;
+  return subpath === "." && typeof pkg.module === "string" ? pkg.module : subpath === "." && typeof pkg.main === "string" ? pkg.main : null;
+}
+function resolvePackageDirFromBunStore(packageName, nodeModulesDir) {
+  const storeDir = join(nodeModulesDir, ".bun");
+  if (!existsSync(storeDir))
+    return null;
+  const encoded = packageName.replace("/", "+");
+  try {
+    const candidates = readdirSync(storeDir).filter((entry) => entry.startsWith(`${encoded}@`)).map((entry) => {
+      const candidateDir = join(storeDir, entry, "node_modules", packageName);
+      const packageJsonPath = join(candidateDir, "package.json");
+      if (!existsSync(packageJsonPath))
+        return null;
+      try {
+        const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+        return {
+          dir: candidateDir,
+          sortKey: pkg.version?.trim() || entry
+        };
+      } catch {
+        return {
+          dir: candidateDir,
+          sortKey: entry
+        };
+      }
+    }).filter((candidate) => candidate !== null).sort((a, b) => b.sortKey.localeCompare(a.sortKey, undefined, { numeric: true, sensitivity: "base" }));
+    return candidates[0]?.dir ?? null;
+  } catch {
+    return null;
+  }
+}
+function resolveDirectoryModulePath(directoryPath) {
+  const packageJsonPath = join(directoryPath, "package.json");
+  if (existsSync(packageJsonPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+      const target = exportTargetFromPackageJson(pkg, ".");
+      if (target) {
+        const resolved = resolveModulePath(join(directoryPath, target));
+        if (resolved)
+          return resolved;
+      }
+    } catch {}
+  }
+  for (const candidate of ["index.js", "index.mjs", "index.cjs", "index.ts", "index.json"]) {
+    const resolved = resolveModulePath(join(directoryPath, candidate));
+    if (resolved)
+      return resolved;
+  }
+  return null;
+}
+function resolveModulePath(candidatePath) {
+  if (!existsSync(candidatePath)) {
+    for (const extension of [".ts", ".mts", ".tsx", ".js", ".mjs", ".cjs", ".json"]) {
+      const withExtension = `${candidatePath}${extension}`;
+      if (existsSync(withExtension))
+        return resolveModulePath(withExtension);
+    }
+    return null;
+  }
+  try {
+    const stat = statSync(candidatePath);
+    if (stat.isFile())
+      return candidatePath;
+    if (stat.isDirectory())
+      return resolveDirectoryModulePath(candidatePath);
+  } catch {
+    return null;
+  }
+  return null;
+}
+function resolvePackageExportFromDir(packageDir, subpath) {
+  const packageJsonPath = join(packageDir, "package.json");
+  if (existsSync(packageJsonPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+      const target = exportTargetFromPackageJson(pkg, subpath);
+      if (target) {
+        const resolved = resolveModulePath(join(packageDir, target));
+        if (resolved)
+          return resolved;
+      }
+    } catch {
+      return null;
+    }
+  }
+  if (subpath !== ".") {
+    const legacySubpath = subpath.replace(/^\.\//, "");
+    for (const candidate of [
+      join(packageDir, legacySubpath),
+      join(packageDir, `${legacySubpath}.js`),
+      join(packageDir, `${legacySubpath}.mjs`),
+      join(packageDir, `${legacySubpath}.cjs`),
+      join(packageDir, `${legacySubpath}.ts`),
+      join(packageDir, `${legacySubpath}.json`)
+    ]) {
+      const resolved = resolveModulePath(candidate);
+      if (resolved)
+        return resolved;
+    }
+  }
+  return subpath === "." ? resolveDirectoryModulePath(packageDir) : null;
+}
+var runtimeBundleQueue = Promise.resolve();
+function enqueueRuntimeBundle(operation) {
+  const next = runtimeBundleQueue.then(operation, operation);
+  runtimeBundleQueue = next.then(() => {
+    return;
+  }, () => {
+    return;
+  });
+  return next;
+}
+function isWithinDir(candidatePath, rootPath) {
+  const rel = relative(resolve(rootPath), resolve(candidatePath));
+  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+function resolvedFilePath(path, rootPath) {
+  if (!path || !isAbsolute(path))
+    return null;
+  const resolved = resolveModulePath(path);
+  if (!resolved)
+    return null;
+  return rootPath && !isWithinDir(resolved, rootPath) ? null : resolved;
+}
+function resolveProjectPackageImport(specifier, configDir) {
+  const parsed = packageNameAndSubpath(specifier);
+  if (!parsed)
+    return null;
+  const nodeModulesDir = join(configDir, "node_modules");
+  const directPackageDir = join(nodeModulesDir, parsed.packageName);
+  const packageDir = existsSync(join(directPackageDir, "package.json")) ? directPackageDir : resolvePackageDirFromBunStore(parsed.packageName, nodeModulesDir);
+  return packageDir ? resolvePackageExportFromDir(packageDir, parsed.subpath) : null;
+}
+async function importConfigViaRuntimeBundleUnserialized(configPath) {
+  const bun = globalThis.Bun;
+  if (!bun?.build) {
+    throw new Error(`Failed to import ${configPath}: bare imports could not be resolved and no Bun.build runtime bundler is available.`);
+  }
+  const RUNTIME_ONLY_EXTERNAL_PACKAGES = new Set(["mupdf", "fastembed", "onnxruntime-node", "markit-ai"]);
+  const configDir = dirname(configPath);
+  const UNRESOLVED_NAMESPACE = "rig-config-unresolved";
+  const unresolvedLocalPlugin = {
+    name: "rig-config-unresolved-local",
+    setup(build) {
+      build.onResolve({ filter: /.*/ }, (args) => {
+        const directFilePath = resolvedFilePath(args.path, configDir);
+        if (directFilePath)
+          return { path: directFilePath };
+        const packageImport = packageNameAndSubpath(args.path);
+        if (packageImport && RUNTIME_ONLY_EXTERNAL_PACKAGES.has(packageImport.packageName))
+          return { path: args.path, external: true };
+        const projectPackagePath = resolveProjectPackageImport(args.path, configDir);
+        if (projectPackagePath)
+          return packageImport?.packageName.startsWith("@oh-my-pi/") ? { path: projectPackagePath, external: true } : { path: projectPackagePath };
+        if (/^(?:node|bun):/.test(args.path) || isBuiltin(args.path))
+          return;
+        if (packageImport)
+          return { path: args.path, external: true };
+        const parentCandidates = args.path.startsWith(".") ? [args.importer && isAbsolute(args.importer) ? dirname(args.importer) : null, configDir].filter((value) => Boolean(value)) : [args.importer && isAbsolute(args.importer) ? dirname(args.importer) : configDir];
+        for (const parent2 of parentCandidates) {
+          const filePath = resolvedFilePath(resolve(parent2, args.path), configDir);
+          if (filePath)
+            return { path: filePath };
+        }
+        const parent = parentCandidates[0] ?? configDir;
+        try {
+          const resolved = bun.resolveSync?.(args.path, parent) ?? resolve(parent, args.path);
+          const filePath = resolvedFilePath(resolved, configDir);
+          if (filePath)
+            return { path: filePath };
+        } catch {}
+        return { path: args.path, namespace: UNRESOLVED_NAMESPACE };
+      });
+      build.onLoad({ filter: /.*/, namespace: UNRESOLVED_NAMESPACE }, (args) => ({
+        loader: "js",
+        contents: `module.exports = {};
+throw new Error(${JSON.stringify(`Failed to bundle ${configPath}: Could not resolve local import "${args.path}". Maybe you need to fix a relative import in rig.config.ts or install project deps.`)});
+`
+      }));
+    }
+  };
+  const result = await bun.build({
+    entrypoints: [configPath],
+    target: "bun",
+    external: ["mupdf", "fastembed", "onnxruntime-node", "markit-ai"],
+    format: "esm",
+    throw: false,
+    packages: "bundle",
+    plugins: [unresolvedLocalPlugin]
+  });
+  if (!result.success || !result.outputs[0]) {
+    const detail = result.logs.map((log) => String(log)).join(`
+`);
+    throw new Error(`Failed to bundle ${configPath}: ${detail || "unknown bundler error"}`);
+  }
+  const bundleParentDir = join(configDir, ".rig", "tmp");
+  mkdirSync(bundleParentDir, { recursive: true });
+  const dir = mkdtempSync(join(bundleParentDir, "rig-config-bundle-"));
+  try {
+    const bundledPath = join(dir, "rig.config.bundled.js");
+    await bun.write(bundledPath, await result.outputs[0].text());
+    return await import(pathToFileURL(bundledPath).href);
+  } finally {
+    try {
+      rmSync(dir, { recursive: true, force: true });
+    } catch {}
+  }
+}
 async function loadConfig(cwd) {
   for (const name of TS_NAMES) {
     const p = join(cwd, name);
     if (existsSync(p)) {
-      const mod = await import(pathToFileURL(p).href);
+      const mod = await enqueueRuntimeBundle(async () => {
+        if (runningFromCompiledBinary()) {
+          return importConfigViaRuntimeBundleUnserialized(p);
+        }
+        const source = readFileSync(p, "utf8");
+        const importsRigHostPackages = /(?:import\s+[^;]*?from\s*|import\s*\()\s*["']@rig\//.test(source);
+        if (importsRigHostPackages) {
+          return importConfigViaRuntimeBundleUnserialized(p);
+        }
+        try {
+          return await import(pathToFileURL(p).href);
+        } catch (error) {
+          if (!isModuleResolutionError(error))
+            throw error;
+          return importConfigViaRuntimeBundleUnserialized(p);
+        }
+      });
       const raw = mod.default ?? mod.config;
       return decodePreservingRuntime(raw);
     }
@@ -35,7 +339,7 @@ function decodePreservingRuntime(raw) {
       }
     }
   }
-  const decoded = Schema.decodeUnknownSync(RigConfig)(raw);
+  const decoded = Schema2.decodeUnknownSync(RigConfig2)(applyConfigDefaults(raw));
   const plugins = decoded.plugins.map((p) => {
     const runtime = runtimeByName.get(p.name);
     if (!runtime)

package/dist/src/plugin-host.d.ts

@@ -0,0 +1,65 @@
+import type { BlockerClassifierRegistration, CliCommandRegistration, HookRegistration, PanelRegistration, ProductCapabilityRegistration, RepoSourceRegistration, AgentRoleRegistration, SkillRegistration, Stage, StageMutation, StageRun, TaskFieldExtension, TaskSourceRegistration, ValidatorRegistration } from "@rig/contracts";
+import type { RegisteredValidator, RigPluginWithRuntime, RuntimeBlockerClassifier, RuntimeCliCommand, RuntimeFeatureCapability, RuntimePanelProducer, TaskSourceFactoryEntry } from "./plugin-runtime";
+export interface PluginHost {
+    getValidator(id: string): ValidatorRegistration | undefined;
+    getHook(id: string): HookRegistration | undefined;
+    getSkill(id: string): SkillRegistration | undefined;
+    getRepoSource(id: string): RepoSourceRegistration | undefined;
+    getAgentRole(id: string): AgentRoleRegistration | undefined;
+    getTaskFieldExtension(id: string): TaskFieldExtension | undefined;
+    getTaskSource(id: string): TaskSourceRegistration | undefined;
+    getCliCommand(id: string): CliCommandRegistration | undefined;
+    getCapability(id: string): ProductCapabilityRegistration | undefined;
+    getPanel(id: string): PanelRegistration | undefined;
+    getBlockerClassifier(id: string): BlockerClassifierRegistration | undefined;
+    listValidators(): readonly ValidatorRegistration[];
+    listHooks(): readonly HookRegistration[];
+    listSkills(): readonly SkillRegistration[];
+    listRepoSources(): readonly RepoSourceRegistration[];
+    listAgentRoles(): readonly AgentRoleRegistration[];
+    listTaskFieldExtensions(): readonly TaskFieldExtension[];
+    listTaskSources(): readonly TaskSourceRegistration[];
+    listCliCommands(): readonly CliCommandRegistration[];
+    listCapabilities(): readonly ProductCapabilityRegistration[];
+    listPanels(): readonly PanelRegistration[];
+    listBlockerClassifiers(): readonly BlockerClassifierRegistration[];
+    listStages(): readonly Stage[];
+    /**
+     * Stage mutations contributed by all loaded plugins, flattened in load order.
+     * The kernel resolves these (+ the default-lifecycle stages) into the run
+     * pipeline — this is the wire that makes "every plugin mutates the lifecycle"
+     * real (drift pre-merge gate, closure observer, reclassify observer).
+     */
+    listStageMutations(): readonly StageMutation[];
+    /**
+     * Executable stage implementations contributed by plugins (`runtime.stages`),
+     * merged by stage id. The kernel's stage runner uses these to execute
+     * plugin-contributed stages inserted via stageMutations.
+     */
+    listStageExecutors(): Readonly<Record<string, StageRun>>;
+    /**
+     * Executable validators contributed by plugins. Only validators whose
+     * metadata appears in `listValidators()` and whose plugin shipped a runtime
+     * implementation via `definePlugin(meta, { validators: [...] })` appear here.
+     * Validators registered metadata-only (no run() implementation) are absent.
+     */
+    listExecutableValidators(): readonly RegisteredValidator[];
+    /**
+     * Executable task source factories contributed by plugins. Used by the
+     * runtime's `buildTaskSourceRegistry` to instantiate non-standard task
+     * source kinds (Linear, Jira, custom) declared by plugins.
+     */
+    listExecutableTaskSources(): readonly TaskSourceFactoryEntry[];
+    listExecutableCapabilities(): readonly RuntimeFeatureCapability[];
+    listExecutablePanels(): readonly RuntimePanelProducer[];
+    listExecutableBlockerClassifiers(): readonly RuntimeBlockerClassifier[];
+    listExecutableCliCommands(): readonly RuntimeCliCommand[];
+    resolveExecutableCliCommand(requested: string): RuntimeCliCommand | undefined;
+    /**
+     * Look up an executable task source factory by its `kind` (the value in
+     * `config.taskSource.kind`). Returns undefined when no plugin provides
+     * a factory for that kind.
+     */
+    resolveTaskSourceFactoryByKind(kind: string): TaskSourceFactoryEntry | undefined;
+}
+export declare function createPluginHost(plugins: readonly RigPluginWithRuntime[]): PluginHost;

package/dist/src/plugin-host.js

@@ -58,6 +58,59 @@ function assertRuntimeMatchesMetadata(plugin) {
       }
     }
   }
+  const declaredHooks = new Map((plugin.contributes?.hooks ?? []).map((hook) => [hook.id, hook]));
+  const runtimeHooks = plugin.__runtime?.hooks;
+  for (const hookId of Object.keys(runtimeHooks ?? {})) {
+    const metadata = declaredHooks.get(hookId);
+    if (!metadata) {
+      throw new Error(`plugin "${plugin.name}" typed hook "${hookId}" has no matching metadata entry in contributes.hooks`);
+    }
+    if (metadata.command) {
+      throw new Error(`plugin "${plugin.name}" hook "${hookId}" has both a typed implementation and a command string \u2014 pick one`);
+    }
+  }
+  if (runtimeHooks) {
+    for (const hook of declaredHooks.values()) {
+      if (!runtimeHooks[hook.id] && !hook.command) {
+        throw new Error(`plugin "${plugin.name}" hook metadata "${hook.id}" has no implementation (typed function or command)`);
+      }
+    }
+  }
+  const declaredCapabilities = new Map((plugin.contributes?.capabilities ?? []).map((capability) => [capability.id, capability]));
+  const runtimeCapabilities = new Map((plugin.__runtime?.featureCapabilities ?? []).map((capability) => [capability.id, capability]));
+  for (const capability of runtimeCapabilities.values()) {
+    if (!declaredCapabilities.has(capability.id)) {
+      throw new Error(`plugin "${plugin.name}" executable capability "${capability.id}" has no matching metadata entry in contributes.capabilities`);
+    }
+  }
+  const declaredPanels = new Map((plugin.contributes?.panels ?? []).map((panel) => [panel.id, panel]));
+  const runtimePanels = new Map((plugin.__runtime?.panels ?? []).map((panel) => [panel.id, panel]));
+  for (const panel of runtimePanels.values()) {
+    const metadata = declaredPanels.get(panel.id);
+    if (!metadata) {
+      throw new Error(`plugin "${plugin.name}" executable panel "${panel.id}" has no matching metadata entry in contributes.panels`);
+    }
+    if (metadata.slot !== panel.slot) {
+      throw new Error(`plugin "${plugin.name}" executable panel "${panel.id}" slot "${panel.slot}" does not match metadata slot "${metadata.slot}"`);
+    }
+    if (metadata.capabilityId !== panel.capabilityId) {
+      throw new Error(`plugin "${plugin.name}" executable panel "${panel.id}" capabilityId "${panel.capabilityId ?? "(none)"}" does not match metadata capabilityId "${metadata.capabilityId ?? "(none)"}"`);
+    }
+  }
+  const declaredBlockerClassifiers = new Map((plugin.contributes?.blockerClassifiers ?? []).map((classifier) => [classifier.id, classifier]));
+  const runtimeBlockerClassifiers = new Map((plugin.__runtime?.blockerClassifiers ?? []).map((classifier) => [classifier.id, classifier]));
+  for (const classifier of runtimeBlockerClassifiers.values()) {
+    if (!declaredBlockerClassifiers.has(classifier.id)) {
+      throw new Error(`plugin "${plugin.name}" executable blocker classifier "${classifier.id}" has no matching metadata entry in contributes.blockerClassifiers`);
+    }
+  }
+  const declaredCliCommands = new Map((plugin.contributes?.cliCommands ?? []).map((command) => [command.id, command]));
+  const runtimeCliCommands = new Map((plugin.__runtime?.cliCommands ?? []).map((command) => [command.id, command]));
+  for (const command of runtimeCliCommands.values()) {
+    if (!declaredCliCommands.has(command.id)) {
+      throw new Error(`plugin "${plugin.name}" executable cli command "${command.id}" has no matching metadata entry in contributes.cliCommands`);
+    }
+  }
 }
 function createPluginHost(plugins) {
   assertUniquePluginNames(plugins);
@@ -72,8 +125,18 @@ function createPluginHost(plugins) {
   const taskFieldExtensions = [];
   const taskSources = [];
   const cliCommands = [];
+  const capabilities = [];
+  const panels = [];
+  const blockerClassifiers = [];
+  const stages = [];
+  const stageMutations = [];
+  const stageExecutors = {};
   const executableValidators = [];
   const executableTaskSources = [];
+  const executableCapabilities = [];
+  const executablePanels = [];
+  const executableBlockerClassifiers = [];
+  const executableCliCommands = [];
   for (const plugin of plugins) {
     const c = plugin.contributes;
     if (!c)
@@ -85,6 +148,18 @@ function createPluginHost(plugins) {
     if (plugin.__runtime?.taskSources) {
       executableTaskSources.push(...plugin.__runtime.taskSources.map((item) => ({ item, pluginName })));
     }
+    if (plugin.__runtime?.featureCapabilities) {
+      executableCapabilities.push(...plugin.__runtime.featureCapabilities.map((item) => ({ item, pluginName })));
+    }
+    if (plugin.__runtime?.panels) {
+      executablePanels.push(...plugin.__runtime.panels.map((item) => ({ item, pluginName })));
+    }
+    if (plugin.__runtime?.blockerClassifiers) {
+      executableBlockerClassifiers.push(...plugin.__runtime.blockerClassifiers.map((item) => ({ item, pluginName })));
+    }
+    if (plugin.__runtime?.cliCommands) {
+      executableCliCommands.push(...plugin.__runtime.cliCommands.map((item) => ({ item, pluginName })));
+    }
     if (c.validators)
       validators.push(...c.validators.map((item) => ({ item, pluginName })));
     if (c.hooks)
@@ -101,9 +176,25 @@ function createPluginHost(plugins) {
       taskSources.push(...c.taskSources.map((item) => ({ item, pluginName })));
     if (c.cliCommands)
       cliCommands.push(...c.cliCommands.map((item) => ({ item, pluginName })));
+    if (c.capabilities)
+      capabilities.push(...c.capabilities.map((item) => ({ item, pluginName })));
+    if (c.panels)
+      panels.push(...c.panels.map((item) => ({ item, pluginName })));
+    if (c.blockerClassifiers)
+      blockerClassifiers.push(...c.blockerClassifiers.map((item) => ({ item, pluginName })));
+    if (c.stages)
+      stages.push(...c.stages.map((item) => ({ item, pluginName })));
+    if (c.stageMutations)
+      stageMutations.push(...c.stageMutations.map((item) => ({ item, pluginName })));
+    if (plugin.__runtime?.stages)
+      Object.assign(stageExecutors, plugin.__runtime.stages);
   }
   indexById(executableValidators, "executableValidator");
   indexById(executableTaskSources, "executableTaskSource");
+  indexById(executableCapabilities, "executableCapability");
+  indexById(executablePanels, "executablePanel");
+  indexById(executableBlockerClassifiers, "executableBlockerClassifier");
+  indexById(executableCliCommands, "executableCliCommand");
   const taskSourceFactoryByKind = new Map;
   const taskSourceKindRegistrant = new Map;
   for (const { item, pluginName } of executableTaskSources) {
@@ -121,6 +212,9 @@ function createPluginHost(plugins) {
   const taskFieldExtMap = indexById(taskFieldExtensions, "taskFieldExtension");
   const taskSourceMap = indexById(taskSources, "taskSource");
   const cliCommandMap = indexById(cliCommands, "cliCommand");
+  const capabilityMap = indexById(capabilities, "capability");
+  const panelMap = indexById(panels, "panel");
+  const blockerClassifierMap = indexById(blockerClassifiers, "blockerClassifier");
   const allValidators = validators.map((c) => c.item);
   const allHooks = hooks.map((c) => c.item);
   const allSkills = skills.map((c) => c.item);
@@ -129,8 +223,34 @@ function createPluginHost(plugins) {
   const allTaskFieldExtensions = taskFieldExtensions.map((c) => c.item);
   const allTaskSources = taskSources.map((c) => c.item);
   const allCliCommands = cliCommands.map((c) => c.item);
+  const allStageMutations = stageMutations.map((c) => c.item);
+  const allStages = stages.map((c) => c.item);
+  const allCapabilities = capabilities.map((c) => c.item);
+  const allPanels = panels.map((c) => c.item);
+  const allBlockerClassifiers = blockerClassifiers.map((c) => c.item);
   const allExecutableValidators = executableValidators.map((c) => c.item);
   const allExecutableTaskSources = executableTaskSources.map((c) => c.item);
+  const allExecutableCapabilities = executableCapabilities.map((c) => c.item);
+  const allExecutablePanels = executablePanels.map((c) => c.item);
+  const allExecutableBlockerClassifiers = executableBlockerClassifiers.map((c) => c.item);
+  const allExecutableCliCommands = executableCliCommands.map((c) => c.item);
+  const executableCliCommandByName = new Map;
+  const registerExecutableCliCommandSelector = (selector, contribution) => {
+    const existing = executableCliCommandByName.get(selector);
+    if (existing && existing.item.id !== contribution.item.id) {
+      throw new Error(`duplicate executable CLI selector "${selector}" registered by command "${existing.item.id}" from plugin "${existing.pluginName}" and command "${contribution.item.id}" from plugin "${contribution.pluginName}"`);
+    }
+    executableCliCommandByName.set(selector, contribution);
+  };
+  for (const contribution of executableCliCommands) {
+    const command = contribution.item;
+    const family = command.family ?? command.id;
+    registerExecutableCliCommandSelector(command.id, contribution);
+    registerExecutableCliCommandSelector(family, contribution);
+    for (const alias of command.aliases ?? []) {
+      registerExecutableCliCommandSelector(alias, contribution);
+    }
+  }
   return {
     getValidator: (id) => validatorMap.get(id),
     getHook: (id) => hookMap.get(id),
@@ -140,6 +260,9 @@ function createPluginHost(plugins) {
     getTaskFieldExtension: (id) => taskFieldExtMap.get(id),
     getTaskSource: (id) => taskSourceMap.get(id),
     getCliCommand: (id) => cliCommandMap.get(id),
+    getCapability: (id) => capabilityMap.get(id),
+    getPanel: (id) => panelMap.get(id),
+    getBlockerClassifier: (id) => blockerClassifierMap.get(id),
     listValidators: () => allValidators,
     listHooks: () => allHooks,
     listSkills: () => allSkills,
@@ -148,8 +271,19 @@ function createPluginHost(plugins) {
     listTaskFieldExtensions: () => allTaskFieldExtensions,
     listTaskSources: () => allTaskSources,
     listCliCommands: () => allCliCommands,
+    listCapabilities: () => allCapabilities,
+    listPanels: () => allPanels,
+    listBlockerClassifiers: () => allBlockerClassifiers,
+    listStages: () => allStages,
+    listStageMutations: () => allStageMutations,
+    listStageExecutors: () => stageExecutors,
     listExecutableValidators: () => allExecutableValidators,
     listExecutableTaskSources: () => allExecutableTaskSources,
+    listExecutableCapabilities: () => allExecutableCapabilities,
+    listExecutablePanels: () => allExecutablePanels,
+    listExecutableBlockerClassifiers: () => allExecutableBlockerClassifiers,
+    listExecutableCliCommands: () => allExecutableCliCommands,
+    resolveExecutableCliCommand: (requested) => executableCliCommandByName.get(requested)?.item,
     resolveTaskSourceFactoryByKind: (kind) => taskSourceFactoryByKind.get(kind)
   };
 }