@h-rig/core 0.0.6-alpha.16 → 0.0.6-alpha.160

package/dist/src/plugin-host-context.js

@@ -0,0 +1,1276 @@
+// @bun
+// packages/core/src/project-plugins.ts
+import { existsSync as existsSync3, statSync as statSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+
+// packages/core/src/plugin-host.ts
+function indexById(contributions, kind) {
+  const map = new Map;
+  const registrant = new Map;
+  for (const { item, pluginName } of contributions) {
+    if (map.has(item.id)) {
+      throw new Error(`duplicate ${kind} id "${item.id}": registered by plugins "${registrant.get(item.id)}" and "${pluginName}"`);
+    }
+    map.set(item.id, item);
+    registrant.set(item.id, pluginName);
+  }
+  return map;
+}
+function assertUniquePluginNames(plugins) {
+  const seen = new Set;
+  for (const plugin of plugins) {
+    if (seen.has(plugin.name)) {
+      throw new Error(`duplicate plugin name "${plugin.name}"`);
+    }
+    seen.add(plugin.name);
+  }
+}
+function createPluginHost(plugins) {
+  assertUniquePluginNames(plugins);
+  const validators = [];
+  const hooks = [];
+  const skills = [];
+  const repoSources = [];
+  const agentRoles = [];
+  const taskFieldExtensions = [];
+  const taskSources = [];
+  const cliCommands = [];
+  const capabilities = [];
+  const panels = [];
+  const blockerClassifiers = [];
+  const sessionExtensions = [];
+  const seedEntrypoints = [];
+  const stages = [];
+  const stageMutations = [];
+  const stageExecutors = {};
+  for (const plugin of plugins) {
+    const c = plugin.contributes;
+    if (!c)
+      continue;
+    const pluginName = plugin.name;
+    if (c.validators)
+      validators.push(...c.validators.map((item) => ({ item, pluginName })));
+    if (c.hooks)
+      hooks.push(...c.hooks.map((item) => ({ item, pluginName })));
+    if (c.skills)
+      skills.push(...c.skills.map((item) => ({ item, pluginName })));
+    if (c.repoSources)
+      repoSources.push(...c.repoSources.map((item) => ({ item, pluginName })));
+    if (c.agentRoles)
+      agentRoles.push(...c.agentRoles.map((item) => ({ item, pluginName })));
+    if (c.taskFieldSchemas)
+      taskFieldExtensions.push(...c.taskFieldSchemas.map((item) => ({ item, pluginName })));
+    if (c.taskSources)
+      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.sessionExtensions)
+      sessionExtensions.push(...c.sessionExtensions.map((item) => ({ item, pluginName })));
+    if (c.seedEntrypoints)
+      seedEntrypoints.push(...c.seedEntrypoints.map((item) => ({ item, pluginName })));
+    if (c.stageMutations)
+      stageMutations.push(...c.stageMutations.map((item) => ({ item, pluginName })));
+    if (c.stages) {
+      for (const stage of c.stages) {
+        stages.push({ item: stage, pluginName });
+        if (stage.run)
+          stageExecutors[stage.id] = stage.run;
+      }
+    }
+  }
+  const validatorMap = indexById(validators, "validator");
+  const hookMap = indexById(hooks, "hook");
+  const skillMap = indexById(skills, "skill");
+  const repoSourceMap = indexById(repoSources, "repoSource");
+  const agentRoleMap = indexById(agentRoles, "agentRole");
+  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");
+  indexById(sessionExtensions, "sessionExtension");
+  indexById(seedEntrypoints, "seedEntrypoint");
+  const taskSourceFactoryByKind = new Map;
+  const taskSourceKindRegistrant = new Map;
+  for (const { item, pluginName } of taskSources) {
+    if (taskSourceFactoryByKind.has(item.kind)) {
+      throw new Error(`duplicate task source kind "${item.kind}": registered by plugins "${taskSourceKindRegistrant.get(item.kind)}" and "${pluginName}"`);
+    }
+    taskSourceFactoryByKind.set(item.kind, item);
+    taskSourceKindRegistrant.set(item.kind, pluginName);
+  }
+  const seedEntrypointByBasename = new Map;
+  const seedEntrypointByWorkerArg = new Map;
+  let insidePtySeedEntrypoint;
+  const registerSeedEntrypointSelector = (map, selectorKind, selector, contribution) => {
+    const existing = map.get(selector);
+    if (existing) {
+      throw new Error(`duplicate seed entrypoint ${selectorKind} "${selector}": registered by entrypoint "${existing.item.id}" from plugin "${existing.pluginName}" and entrypoint "${contribution.item.id}" from plugin "${contribution.pluginName}"`);
+    }
+    map.set(selector, contribution);
+  };
+  for (const contribution of seedEntrypoints) {
+    const entrypoint = contribution.item;
+    let selectorCount = 0;
+    if (entrypoint.basename) {
+      selectorCount += 1;
+      registerSeedEntrypointSelector(seedEntrypointByBasename, "basename", entrypoint.basename, contribution);
+    }
+    if (entrypoint.workerArg) {
+      selectorCount += 1;
+      registerSeedEntrypointSelector(seedEntrypointByWorkerArg, "workerArg", entrypoint.workerArg, contribution);
+    }
+    if (entrypoint.insidePty) {
+      selectorCount += 1;
+      if (insidePtySeedEntrypoint) {
+        throw new Error(`duplicate seed entrypoint inside-pty selector: registered by entrypoint "${insidePtySeedEntrypoint.item.id}" from plugin "${insidePtySeedEntrypoint.pluginName}" and entrypoint "${entrypoint.id}" from plugin "${contribution.pluginName}"`);
+      }
+      insidePtySeedEntrypoint = contribution;
+    }
+    if (selectorCount === 0) {
+      throw new Error(`seed entrypoint "${entrypoint.id}" from plugin "${contribution.pluginName}" must declare at least one selector (basename, workerArg, or insidePty)`);
+    }
+  }
+  const allValidators = validators.map((c) => c.item);
+  const allHooks = hooks.map((c) => c.item);
+  const allSkills = skills.map((c) => c.item);
+  const allRepoSources = repoSources.map((c) => c.item);
+  const allAgentRoles = agentRoles.map((c) => c.item);
+  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 allSessionExtensions = sessionExtensions.map((c) => c.item);
+  const allSeedEntrypoints = seedEntrypoints.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 cliCommands) {
+    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);
+    }
+  }
+  let defaultRootCliCommand;
+  for (const contribution of cliCommands) {
+    if (!contribution.item.rootDefault)
+      continue;
+    if (defaultRootCliCommand) {
+      throw new Error(`duplicate default root CLI command registered by command "${defaultRootCliCommand.item.id}" from plugin "${defaultRootCliCommand.pluginName}" and command "${contribution.item.id}" from plugin "${contribution.pluginName}"`);
+    }
+    defaultRootCliCommand = contribution;
+  }
+  return {
+    getValidator: (id) => validatorMap.get(id),
+    getHook: (id) => hookMap.get(id),
+    getSkill: (id) => skillMap.get(id),
+    getRepoSource: (id) => repoSourceMap.get(id),
+    getAgentRole: (id) => agentRoleMap.get(id),
+    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,
+    listRepoSources: () => allRepoSources,
+    listAgentRoles: () => allAgentRoles,
+    listTaskFieldExtensions: () => allTaskFieldExtensions,
+    listTaskSources: () => allTaskSources,
+    listCliCommands: () => allCliCommands,
+    listCapabilities: () => allCapabilities,
+    listPanels: () => allPanels,
+    listBlockerClassifiers: () => allBlockerClassifiers,
+    listStages: () => allStages,
+    listStageMutations: () => allStageMutations,
+    listStageExecutors: () => stageExecutors,
+    listExecutableValidators: () => allValidators.filter((v) => typeof v.run === "function"),
+    listExecutableTaskSources: () => allTaskSources,
+    listExecutableCapabilities: () => allCapabilities.filter((c) => typeof c.run === "function"),
+    listExecutablePanels: () => allPanels.filter((p) => typeof p.produce === "function"),
+    listExecutableBlockerClassifiers: () => allBlockerClassifiers,
+    listExecutableCliCommands: () => allCliCommands,
+    listSessionExtensions: () => allSessionExtensions,
+    listSeedEntrypoints: () => allSeedEntrypoints,
+    resolveSeedEntrypointByBasename: (value) => seedEntrypointByBasename.get(value)?.item,
+    resolveSeedEntrypointByWorkerArg: (value) => seedEntrypointByWorkerArg.get(value)?.item,
+    resolveInsidePtySeedEntrypoint: () => insidePtySeedEntrypoint?.item,
+    resolveExecutableCliCommand: (requested) => executableCliCommandByName.get(requested)?.item,
+    resolveDefaultRootCliCommand: () => defaultRootCliCommand?.item,
+    resolveTaskSourceFactoryByKind: (kind) => taskSourceFactoryByKind.get(kind)
+  };
+}
+
+// packages/core/src/load-config.ts
+import { existsSync as existsSync2, mkdirSync, mkdtempSync, readFileSync as readFileSync2, readdirSync, rmSync, statSync } from "fs";
+import { isBuiltin } from "module";
+import { dirname, isAbsolute, join as join2, relative, resolve } from "path";
+import { pathToFileURL } from "url";
+import { Schema as Schema3 } from "effect";
+import { RigConfig as RigConfig3 } 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 } : {};
+  if (workspace.mainRepo === undefined)
+    workspace.mainRepo = ".";
+  if (workspace.checkout === undefined && workspace.isolation !== undefined)
+    workspace.checkout = workspace.isolation;
+  if (workspace.isolation === undefined && workspace.checkout !== undefined)
+    workspace.isolation = workspace.checkout;
+  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.flat() : [],
+    workspace: normalizeWorkspaceConfig(record.workspace)
+  };
+}
+
+// packages/core/src/declarative-config.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { parse as parseToml } from "smol-toml";
+import { Schema as Schema2 } from "effect";
+import { RigConfig as RigConfig2 } from "@rig/contracts";
+
+// packages/core/src/embedded-plugins.ts
+var registered = null;
+function getStandardPluginsResolver() {
+  return registered;
+}
+var bakedProjectConfig = null;
+function getEmbeddedProjectConfig() {
+  return bakedProjectConfig;
+}
+
+// packages/core/src/declarative-config.ts
+var DECLARATIVE_CONFIG_NAMES = ["rigfig.toml", "rigfig.json"];
+function findDeclarativeConfigPath(cwd) {
+  const dir = join(cwd, ".rig");
+  for (const name of DECLARATIVE_CONFIG_NAMES) {
+    const candidate = join(dir, name);
+    if (existsSync(candidate))
+      return candidate;
+  }
+  return null;
+}
+function parseDeclarativeFile(path) {
+  const raw = readFileSync(path, "utf8");
+  const parsed = path.endsWith(".json") ? JSON.parse(raw) : parseToml(raw);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Declarative config ${path} must parse to an object.`);
+  }
+  return parsed;
+}
+function loadDeclarativeConfig(path) {
+  const data = parseDeclarativeFile(path);
+  const standardSection = data.standard && typeof data.standard === "object" && !Array.isArray(data.standard) ? data.standard : {};
+  const useStandard = standardSection.enabled !== false;
+  let plugins = [];
+  if (useStandard) {
+    const resolver = getStandardPluginsResolver();
+    if (!resolver) {
+      throw new Error(`Declarative config ${path} needs the embedded standard plugins, but none were registered. ` + `This is a seed/boot wiring error (the binary entrypoint must import the standard-plugin registration).`);
+    }
+    plugins = resolver(data);
+  }
+  const { standard: _standardDirective, ...configFields } = data;
+  const withDefaults = applyConfigDefaults({ ...configFields, plugins });
+  const explicitPlugins = Array.isArray(withDefaults.plugins) ? [...withDefaults.plugins] : [];
+  const decoded = Schema2.decodeUnknownSync(RigConfig2)({
+    ...withDefaults,
+    plugins: explicitPlugins
+  });
+  return { ...decoded, plugins: explicitPlugins };
+}
+
+// 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 = join2(nodeModulesDir, ".bun");
+  if (!existsSync2(storeDir))
+    return null;
+  const encoded = packageName.replace("/", "+");
+  try {
+    const candidates = readdirSync(storeDir).filter((entry) => entry.startsWith(`${encoded}@`)).map((entry) => {
+      const candidateDir = join2(storeDir, entry, "node_modules", packageName);
+      const packageJsonPath = join2(candidateDir, "package.json");
+      if (!existsSync2(packageJsonPath))
+        return null;
+      try {
+        const pkg = JSON.parse(readFileSync2(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 = join2(directoryPath, "package.json");
+  if (existsSync2(packageJsonPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
+      const target = exportTargetFromPackageJson(pkg, ".");
+      if (target) {
+        const resolved = resolveModulePath(join2(directoryPath, target));
+        if (resolved)
+          return resolved;
+      }
+    } catch {}
+  }
+  for (const candidate of ["index.js", "index.mjs", "index.cjs", "index.ts", "index.json"]) {
+    const resolved = resolveModulePath(join2(directoryPath, candidate));
+    if (resolved)
+      return resolved;
+  }
+  return null;
+}
+function resolveModulePath(candidatePath) {
+  if (!existsSync2(candidatePath)) {
+    for (const extension of [".ts", ".mts", ".tsx", ".js", ".mjs", ".cjs", ".json"]) {
+      const withExtension = `${candidatePath}${extension}`;
+      if (existsSync2(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 = join2(packageDir, "package.json");
+  if (existsSync2(packageJsonPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
+      const target = exportTargetFromPackageJson(pkg, subpath);
+      if (target) {
+        const resolved = resolveModulePath(join2(packageDir, target));
+        if (resolved)
+          return resolved;
+      }
+    } catch {
+      return null;
+    }
+  }
+  if (subpath !== ".") {
+    const legacySubpath = subpath.replace(/^\.\//, "");
+    for (const candidate of [
+      join2(packageDir, legacySubpath),
+      join2(packageDir, `${legacySubpath}.js`),
+      join2(packageDir, `${legacySubpath}.mjs`),
+      join2(packageDir, `${legacySubpath}.cjs`),
+      join2(packageDir, `${legacySubpath}.ts`),
+      join2(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 = join2(configDir, "node_modules");
+  const directPackageDir = join2(nodeModulesDir, parsed.packageName);
+  const packageDir = existsSync2(join2(directPackageDir, "package.json")) ? directPackageDir : resolvePackageDirFromBunStore(parsed.packageName, nodeModulesDir);
+  return packageDir ? resolvePackageExportFromDir(packageDir, parsed.subpath) : null;
+}
+function canImportRigWorkspacePackagesDirectly(source, configDir) {
+  const packageNames = new Set;
+  for (const match of source.matchAll(/(?:from\s*|import\s*\(\s*|import\s*)["'](@rig\/[^"']+)["']/g)) {
+    const parsed = packageNameAndSubpath(match[1] ?? "");
+    if (parsed?.packageName)
+      packageNames.add(parsed.packageName);
+  }
+  if (packageNames.size === 0)
+    return false;
+  for (const packageName of packageNames) {
+    const shortName = packageName.replace(/^@rig\//, "");
+    const manifestPath = join2(configDir, "packages", shortName, "package.json");
+    if (!existsSync2(manifestPath))
+      return false;
+    try {
+      const parsed = JSON.parse(readFileSync2(manifestPath, "utf8"));
+      if (parsed.name !== packageName)
+        return false;
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+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(["effect", "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.onLoad({ filter: /\.(?:html|txt)$/ }, (args) => ({
+        loader: "js",
+        contents: `export default ${JSON.stringify(readFileSync2(args.path, "utf8"))};
+`
+      }));
+      build.onResolve({ filter: /.*/ }, (args) => {
+        const directFilePath = resolvedFilePath(args.path, configDir);
+        if (directFilePath)
+          return { path: directFilePath };
+        const packageImport = packageNameAndSubpath(args.path);
+        if (packageImport && (packageImport.packageName.startsWith("@rig/") || RUNTIME_ONLY_EXTERNAL_PACKAGES.has(packageImport.packageName))) {
+          return { path: args.path, external: true };
+        }
+        const projectPackagePath = resolveProjectPackageImport(args.path, configDir);
+        if (projectPackagePath)
+          return { 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: ["effect", "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 = join2(configDir, ".rig", "tmp");
+  mkdirSync(bundleParentDir, { recursive: true });
+  const dir = mkdtempSync(join2(bundleParentDir, "rig-config-bundle-"));
+  try {
+    const bundledPath = join2(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) {
+  const baked = getEmbeddedProjectConfig();
+  if (baked && resolve(baked.projectRoot) === resolve(cwd)) {
+    return decodeExplicitPluginConfig(baked.raw);
+  }
+  for (const name of TS_NAMES) {
+    const p = join2(cwd, name);
+    if (existsSync2(p)) {
+      const mod = await enqueueRuntimeBundle(async () => {
+        if (runningFromCompiledBinary()) {
+          return importConfigViaRuntimeBundleUnserialized(p);
+        }
+        const source = readFileSync2(p, "utf8");
+        const importsRigHostPackages = /(?:import\s+[^;]*?from\s*|import\s*\()\s*["']@rig\//.test(source);
+        if (importsRigHostPackages && !canImportRigWorkspacePackagesDirectly(source, cwd)) {
+          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 decodeExplicitPluginConfig(raw);
+    }
+  }
+  const declarativePath = findDeclarativeConfigPath(cwd);
+  if (declarativePath) {
+    return loadDeclarativeConfig(declarativePath);
+  }
+  for (const name of JSON_NAMES) {
+    const p = join2(cwd, name);
+    if (existsSync2(p)) {
+      const raw = JSON.parse(readFileSync2(p, "utf-8"));
+      return decodeExplicitPluginConfig(raw);
+    }
+  }
+  throw new Error(`no rig.config.{ts,mts,json} or .rig/rigfig.{toml,json} found in ${cwd}`);
+}
+function decodeExplicitPluginConfig(raw) {
+  const withDefaults = applyConfigDefaults(raw);
+  const explicitPlugins = Array.isArray(withDefaults.plugins) ? [...withDefaults.plugins] : [];
+  const decoded = Schema3.decodeUnknownSync(RigConfig3)({
+    ...withDefaults,
+    plugins: explicitPlugins
+  });
+  return { ...decoded, plugins: explicitPlugins };
+}
+
+// packages/core/src/project-plugins.ts
+var RIG_CONFIG_FILENAMES = ["rig.config.ts", "rig.config.mts", "rig.config.json"];
+function findProjectConfigPath(projectRoot) {
+  for (const name of RIG_CONFIG_FILENAMES) {
+    const path = resolve2(projectRoot, name);
+    if (existsSync3(path))
+      return path;
+  }
+  return null;
+}
+var pluginHostCache = new Map;
+function configFileMtimeMs(normalizedRoot) {
+  const path = findProjectConfigPath(normalizedRoot);
+  if (!path)
+    return 0;
+  try {
+    return statSync2(path).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+function resolvePluginHost(projectRoot, options = {}) {
+  const normalizedRoot = resolve2(projectRoot);
+  const build = (load) => load(normalizedRoot).then((config) => ({
+    host: createPluginHost(config.plugins),
+    config
+  }));
+  if (options.load)
+    return build(options.load);
+  const mtimeMs = configFileMtimeMs(normalizedRoot);
+  const cached = pluginHostCache.get(normalizedRoot);
+  if (cached && cached.mtimeMs === mtimeMs)
+    return cached.promise;
+  const promise = build(loadConfig);
+  promise.catch(() => {
+    if (pluginHostCache.get(normalizedRoot)?.promise === promise) {
+      pluginHostCache.delete(normalizedRoot);
+    }
+  });
+  pluginHostCache.set(normalizedRoot, { mtimeMs, promise });
+  return promise;
+}
+
+// packages/core/src/plugin-host-registries.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
+  };
+}
+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;
+}
+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/core/src/plugin-host-context.ts
+import {
+  MANAGED_REPO_SERVICE_CAPABILITY,
+  SESSION_ASSET_MATERIALIZER,
+  TASK_DATA_SERVICE_CAPABILITY,
+  TOOL_MATERIALIZER
+} from "@rig/contracts";
+
+// packages/core/src/capability.ts
+import { resolveCapability } from "@rig/kernel-seed";
+
+class CapabilityProviderMissingError extends Error {
+  capabilityId;
+  name = "CapabilityProviderMissingError";
+  constructor(capabilityId) {
+    super(`No provider resolved for capability "${capabilityId}"`);
+    this.capabilityId = capabilityId;
+  }
+}
+function isFactory(impl) {
+  return typeof impl === "function";
+}
+function defineCapability(id) {
+  const idString = String(id);
+  const tag = idString;
+  async function resolve3(host) {
+    const providers = host.listExecutableCapabilities().filter((c) => c.id === idString && typeof c.run === "function").map((c) => ({
+      name: c.id,
+      provides: [c.id],
+      capabilityProviders: { [c.id]: c.run }
+    }));
+    const resolution = resolveCapability(providers, tag);
+    const run = resolution?.value;
+    if (!run)
+      return null;
+    return await run(undefined);
+  }
+  return {
+    id,
+    provide(impl, opts) {
+      return {
+        id: idString,
+        title: opts?.title ?? idString,
+        ...opts?.description !== undefined ? { description: opts.description } : {},
+        run: isFactory(impl) ? () => impl() : () => impl
+      };
+    },
+    resolve: resolve3,
+    async require(host) {
+      const value = await resolve3(host);
+      if (value === null)
+        throw new CapabilityProviderMissingError(idString);
+      return value;
+    }
+  };
+}
+
+// packages/core/src/capability-loaders.ts
+var INSTALLED = new Map;
+function installCapability(capability, impl) {
+  INSTALLED.set(String(capability.id), impl);
+}
+
+// packages/core/src/agent-role-registry.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/core/src/validator-registry.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join3 } 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 = join3(ctx.workspaceRoot, "package.json");
+  if (!existsSync4(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/core/src/scope-rules.ts
+var SCOPE_RULES_KEY = Symbol.for("rig.scope-normalization-rules");
+function scopeRulesState() {
+  const global = globalThis;
+  return global[SCOPE_RULES_KEY] ??= { rules: null };
+}
+function setScopeRules(rules) {
+  scopeRulesState().rules = rules ?? null;
+}
+
+// packages/core/src/hook-materializer.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync } from "fs";
+import { dirname as dirname2, resolve as resolve4 } from "path";
+
+// packages/core/src/hook-runtime.ts
+import { existsSync as existsSync5, readFileSync as readFileSync3, realpathSync, writeSync } from "fs";
+import { resolve as resolve3 } from "path";
+import { RIG_DEFINITION_DIRNAME, RIG_STATE_DIRNAME } from "@rig/contracts";
+function normalizeBuildConfig(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  return Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === "string"));
+}
+function readBuildConfigForCoreHooks() {
+  if (typeof __RIG_BUILD_CONFIG__ !== "undefined") {
+    return normalizeBuildConfig(__RIG_BUILD_CONFIG__);
+  }
+  const raw = process.env.RIG_BUILD_CONFIG_JSON?.trim();
+  if (!raw) {
+    return {};
+  }
+  try {
+    return normalizeBuildConfig(JSON.parse(raw));
+  } catch {
+    return {};
+  }
+}
+var BUILD_CONFIG = readBuildConfigForCoreHooks();
+var BAKED_PROJECT_ROOT = BUILD_CONFIG.AGENT_PROJECT_ROOT ?? "";
+var BAKED_TASK_ID = BUILD_CONFIG.AGENT_TASK_ID ?? "";
+var BAKED_BUN_PATH = BUILD_CONFIG.AGENT_BUN_PATH ?? "";
+function normalizeExecutablePath(candidate) {
+  if (!candidate) {
+    return "";
+  }
+  const normalized = resolve3(candidate);
+  if (!existsSync5(normalized)) {
+    return "";
+  }
+  try {
+    return realpathSync(normalized);
+  } catch {
+    return normalized;
+  }
+}
+function looksLikeRuntimeGateway(candidate) {
+  const normalized = resolve3(candidate).replace(/\\/g, "/");
+  return normalized.includes("/.rig/bin/") || normalized.endsWith("/rig-shell") || normalized.endsWith("/rig-agent");
+}
+function resolveBunBinaryPath() {
+  const explicit = normalizeExecutablePath(process.env.RIG_BUN_PATH?.trim());
+  if (explicit) {
+    return explicit;
+  }
+  const bunGlobal = globalThis.Bun;
+  const bunWhich = bunGlobal?.which?.("bun");
+  const pathBun = normalizeExecutablePath(bunWhich?.trim());
+  if (pathBun && !looksLikeRuntimeGateway(pathBun)) {
+    return pathBun;
+  }
+  const home = process.env.HOME?.trim();
+  const fallbackCandidates = [
+    home ? resolve3(home, ".bun/bin/bun") : "",
+    "/opt/homebrew/bin/bun",
+    "/usr/local/bin/bun",
+    "/usr/bin/bun"
+  ];
+  for (const candidate of fallbackCandidates) {
+    const normalized = normalizeExecutablePath(candidate);
+    if (normalized) {
+      return normalized;
+    }
+  }
+  const execPath = normalizeExecutablePath(process.execPath?.trim());
+  if (execPath && !looksLikeRuntimeGateway(execPath)) {
+    return execPath;
+  }
+  throw new Error("bun not found in PATH");
+}
+function resolveBunCliInvocation() {
+  if (BAKED_BUN_PATH) {
+    return {
+      command: BAKED_BUN_PATH,
+      env: {}
+    };
+  }
+  if (process.env.RIG_BUN_PATH?.trim()) {
+    return {
+      command: process.env.RIG_BUN_PATH.trim(),
+      env: {}
+    };
+  }
+  try {
+    const systemBun = resolveBunBinaryPath();
+    return {
+      command: systemBun,
+      env: {}
+    };
+  } catch {}
+  if (process.execPath?.trim()) {
+    return {
+      command: process.execPath,
+      env: { BUN_BE_BUN: "1" }
+    };
+  }
+  return { command: "bun", env: {} };
+}
+
+// packages/core/src/hook-materializer.ts
+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 = resolve4(import.meta.dirname, "hook-runner.ts");
+  if (existsSync6(sibling)) {
+    return sibling;
+  }
+  return "$CLAUDE_PROJECT_DIR/node_modules/@rig/core/src/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 createPiNoopSessionHookAdapter() {
+  return {
+    id: "pi",
+    materialize() {
+      return {
+        adapterId: "pi",
+        status: "skipped",
+        reason: "Pi sessions do not consume Claude Code settings hooks."
+      };
+    }
+  };
+}
+function createClaudeCodeSessionHookAdapter() {
+  return {
+    id: "claude-code",
+    materialize(projectRoot, entries) {
+      return writeClaudeCodeHookSettings(projectRoot, entries);
+    }
+  };
+}
+function defaultAgentSessionHookAdapters(env = process.env) {
+  if (env.RIG_AGENT_SESSION_HOOK_ADAPTER === "claude-code") {
+    return [createClaudeCodeSessionHookAdapter()];
+  }
+  if (env.RIG_AGENT_SESSION_HOOK_ADAPTER === "pi" || typeof env.PI_CODING_AGENT_SESSION_DIR === "string" && env.PI_CODING_AGENT_SESSION_DIR.trim().length > 0 || env.RIG_RUN_PROCESS === "1") {
+    return [createPiNoopSessionHookAdapter()];
+  }
+  return [createClaudeCodeSessionHookAdapter()];
+}
+function materializeSessionHookAdapters(projectRoot, entries, adapters = [createClaudeCodeSessionHookAdapter()]) {
+  return adapters.map((adapter) => adapter.materialize(projectRoot, entries));
+}
+function applyClaudeCodeSessionHooksToSettings(existing, entries, projectRoot, options = {}) {
+  const hooks = typeof existing.hooks === "object" && existing.hooks !== null && !Array.isArray(existing.hooks) ? existing.hooks : {};
+  const replacePluginOwned = options.replacePluginOwned ?? true;
+  if (replacePluginOwned) {
+    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];
+      }
+    }
+  }
+  const materializedEvents = new Set;
+  for (const { pluginName, hook, typed } of entries) {
+    const command = hook.command ?? (typed ? buildTypedHookShimCommand(pluginName, hook, projectRoot) : undefined);
+    if (!command) {
+      continue;
+    }
+    const event = hook.event;
+    materializedEvents.add(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);
+    }
+    const alreadyPresent = group.hooks.some((candidate) => candidate[MARKER_PLUGIN] === pluginName && candidate[MARKER_HOOK_ID] === hook.id);
+    if (alreadyPresent) {
+      continue;
+    }
+    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;
+  }
+  return { settings: next, events: [...materializedEvents].sort() };
+}
+function writeClaudeCodeHookSettings(projectRoot, entries) {
+  const settingsPath = resolve4(projectRoot, ".claude", "settings.json");
+  const existing = existsSync6(settingsPath) ? safeReadJson(settingsPath) : {};
+  const { settings, events } = applyClaudeCodeSessionHooksToSettings(existing, entries, projectRoot);
+  mkdirSync2(dirname2(settingsPath), { recursive: true });
+  writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
+`, "utf-8");
+  return {
+    adapterId: "claude-code",
+    status: "materialized",
+    path: settingsPath,
+    events
+  };
+}
+function safeReadJson(path) {
+  try {
+    return JSON.parse(readFileSync4(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+// packages/core/src/plugin-host-context.ts
+var ManagedRepoCap = defineCapability(MANAGED_REPO_SERVICE_CAPABILITY);
+var SessionAssetMaterializerCap = defineCapability(SESSION_ASSET_MATERIALIZER);
+var TaskDataCap = defineCapability(TASK_DATA_SERVICE_CAPABILITY);
+var ToolMaterializerCap = defineCapability(TOOL_MATERIALIZER);
+async function buildPluginHostContext(projectRoot) {
+  let config;
+  let pluginHost;
+  try {
+    ({ config, host: pluginHost } = await resolvePluginHost(projectRoot));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("no rig.config")) {
+      return null;
+    }
+    throw err;
+  }
+  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 taskDataService = await TaskDataCap.resolve(pluginHost);
+  if (taskDataService) {
+    installCapability(TaskDataCap, taskDataService);
+  }
+  const toolMaterializer = await ToolMaterializerCap.resolve(pluginHost);
+  if (toolMaterializer) {
+    installCapability(ToolMaterializerCap, toolMaterializer);
+  }
+  const managedRepoService = await ManagedRepoCap.resolve(pluginHost);
+  let repoRegistry;
+  if (managedRepoService) {
+    installCapability(ManagedRepoCap, managedRepoService);
+    repoRegistry = managedRepoService.createRepoRegistry(pluginHost.listRepoSources());
+    const managedEntries = pluginHost.listRepoSources().map((reg) => managedRepoService.repoRegistrationToManagedEntry(reg)).filter((e) => e !== null);
+    managedRepoService.setManagedRepos(managedEntries);
+  } else {
+    repoRegistry = { getById: () => {
+      return;
+    }, list: () => [] };
+  }
+  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(hook.handler)
+    })));
+    if (hookEntries.length > 0) {
+      materializeSessionHookAdapters(projectRoot, hookEntries, defaultAgentSessionHookAdapters());
+    }
+  } catch (err) {
+    console.warn(`[plugin-host] hook materialization failed: ${err instanceof Error ? err.message : err}`);
+  }
+  const sessionAssetMaterializer = await SessionAssetMaterializerCap.resolve(pluginHost);
+  if (sessionAssetMaterializer) {
+    await sessionAssetMaterializer.materializeSessionAssets(projectRoot, config);
+  }
+  return {
+    config,
+    pluginHost,
+    validatorRegistry,
+    taskSourceRegistry,
+    repoRegistry,
+    agentRoleRegistry,
+    taskFieldRegistry
+  };
+}
+export {
+  buildPluginHostContext
+};