@h-rig/core 0.0.6-alpha.176 → 0.0.6-alpha.177

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

@@ -20,12 +20,11 @@
  * NOTE: registries are instantiated here. The validatorRegistry is consumed
  * by CLI/harness validation and completion verification. Task dispatch and
  * closeout read/update the configured plugin task source directly, with
- * materialized task-config kept only as an explicit compatibility export.
+ * materialized compatibility data kept behind plugin-owned seams.
  */
-import type { RepoRegistry, RigConfig } from "@rig/contracts";
+import type { AgentRoleRegistry, RepoRegistry, RigConfig } from "@rig/contracts";
 import type { PluginHost } from "./plugin-host";
 import { type TaskFieldRegistry, type TaskSourceRegistry } from "./plugin-host-registries";
-import type { AgentRoleRegistry } from "@rig/contracts";
 import { type ValidatorRegistry } from "./validator-registry";
 /** All registries populated from the declarative RigPlugin contributions. */
 export interface PluginHostContext {

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

@@ -225,7 +225,7 @@ function createPluginHost(plugins) {
 // 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 { basename, 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";
@@ -292,8 +292,11 @@ function parseDeclarativeFile(path) {
 }
 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;
+  const standardSection = data.standard && typeof data.standard === "object" && !Array.isArray(data.standard) ? data.standard : null;
+  if (standardSection?.enabled !== true && standardSection?.enabled !== false) {
+    throw new Error(`Declarative config ${path} must explicitly set [standard] enabled = true or false.`);
+  }
+  const useStandard = standardSection.enabled === true;
   let plugins = [];
   if (useStandard) {
     const resolver = getStandardPluginsResolver();
@@ -335,19 +338,27 @@ function packageNameAndSubpath(specifier) {
 function exportTargetFromEntry(entry) {
   if (typeof entry === "string")
     return entry;
-  if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+  if (Array.isArray(entry)) {
+    for (const candidate of entry) {
+      const target = exportTargetFromEntry(candidate);
+      if (target)
+        return target;
+    }
+    return null;
+  }
+  if (entry && typeof entry === "object") {
     const conditions = entry;
-    for (const key of ["bun", "import", "default", "require"]) {
-      if (typeof conditions[key] === "string")
-        return conditions[key];
+    for (const key of ["bun", "node", "import", "default", "require"]) {
+      const target = exportTargetFromEntry(conditions[key]);
+      if (target)
+        return target;
     }
   }
   return null;
 }
 function patternExportTarget(record, subpath) {
-  for (const [pattern, entry] of Object.entries(record)) {
-    if (!pattern.includes("*"))
-      continue;
+  const entries = Object.entries(record).filter(([pattern]) => pattern.includes("*")).sort(([a], [b]) => b.replace("*", "").length - a.replace("*", "").length);
+  for (const [pattern, entry] of entries) {
     const [prefix = "", suffix = ""] = pattern.split("*");
     if (!subpath.startsWith(prefix) || !subpath.endsWith(suffix))
       continue;
@@ -372,6 +383,49 @@ function exportTargetFromPackageJson(pkg, subpath) {
     return target;
   return subpath === "." && typeof pkg.module === "string" ? pkg.module : subpath === "." && typeof pkg.main === "string" ? pkg.main : null;
 }
+function patternImportTarget(record, specifier) {
+  for (const [pattern, entry] of Object.entries(record)) {
+    if (!pattern.includes("*"))
+      continue;
+    const [prefix = "", suffix = ""] = pattern.split("*");
+    if (!specifier.startsWith(prefix) || !specifier.endsWith(suffix))
+      continue;
+    const replacement = specifier.slice(prefix.length, specifier.length - suffix.length);
+    const target = exportTargetFromEntry(entry);
+    if (target)
+      return target.replace("*", replacement);
+  }
+  return null;
+}
+function resolvePackagePrivateImport(specifier, importer, projectRoot) {
+  if (!specifier.startsWith("#") || !importer || !isAbsolute(importer))
+    return null;
+  let dir = dirname(importer);
+  const stop = resolve(projectRoot);
+  while (isWithinDir(dir, stop)) {
+    const packageJsonPath = join2(dir, "package.json");
+    if (existsSync2(packageJsonPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
+        const imports = pkg.imports;
+        if (imports && typeof imports === "object" && !Array.isArray(imports)) {
+          const record = imports;
+          const target = exportTargetFromEntry(record[specifier]) ?? patternImportTarget(record, specifier);
+          if (target)
+            return resolveModulePath(join2(dir, target));
+        }
+      } catch {
+        return null;
+      }
+      return null;
+    }
+    const parent = dirname(dir);
+    if (parent === dir)
+      return null;
+    dir = parent;
+  }
+  return null;
+}
 function resolvePackageDirFromBunStore(packageName, nodeModulesDir) {
   const storeDir = join2(nodeModulesDir, ".bun");
   if (!existsSync2(storeDir))
@@ -446,8 +500,15 @@ function resolvePackageExportFromDir(packageDir, subpath) {
   if (existsSync2(packageJsonPath)) {
     try {
       const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
-      const target = exportTargetFromPackageJson(pkg, subpath);
-      if (target) {
+      const targets = [
+        exportTargetFromPackageJson(pkg, subpath),
+        ...subpath === "." ? [typeof pkg.module === "string" ? pkg.module : null, typeof pkg.main === "string" ? pkg.main : null] : []
+      ];
+      const seen = new Set;
+      for (const target of targets) {
+        if (!target || seen.has(target))
+          continue;
+        seen.add(target);
         const resolved = resolveModulePath(join2(packageDir, target));
         if (resolved)
           return resolved;
@@ -535,10 +596,17 @@ async function importConfigViaRuntimeBundleUnserialized(configPath) {
   }
   const RUNTIME_ONLY_EXTERNAL_PACKAGES = new Set(["effect", "mupdf", "fastembed", "onnxruntime-node", "markit-ai"]);
   const configDir = dirname(configPath);
+  const configProjectRoot = basename(configDir) === ".rig" ? dirname(configDir) : configDir;
   const UNRESOLVED_NAMESPACE = "rig-config-unresolved";
+  const ABSOLUTE_EXTERNAL_NAMESPACE = "rig-config-absolute-external";
   const unresolvedLocalPlugin = {
     name: "rig-config-unresolved-local",
     setup(build) {
+      build.onLoad({ filter: /[\\/]@oh-my-pi[\\/]pi-coding-agent[\\/]src[\\/]export[\\/]html[\\/](?:template\.css|template\.html|template\.js|tool-views\.generated\.js)$/ }, (args) => ({
+        loader: "js",
+        contents: `export default ${JSON.stringify(readFileSync2(args.path, "utf8"))};
+`
+      }));
       build.onLoad({ filter: /\.(?:html|txt)$/ }, (args) => ({
         loader: "js",
         contents: `export default ${JSON.stringify(readFileSync2(args.path, "utf8"))};
@@ -548,32 +616,77 @@ async function importConfigViaRuntimeBundleUnserialized(configPath) {
         const directFilePath = resolvedFilePath(args.path, configDir);
         if (directFilePath)
           return { path: directFilePath };
+        if (args.path.startsWith("#")) {
+          const packagePrivatePath = resolvePackagePrivateImport(args.path, args.importer, configProjectRoot);
+          if (packagePrivatePath)
+            return { path: packagePrivatePath };
+          try {
+            const parent2 = args.importer && isAbsolute(args.importer) ? dirname(args.importer) : configProjectRoot;
+            const resolved = bun.resolveSync?.(args.path, parent2);
+            const filePath = resolvedFilePath(resolved, configProjectRoot);
+            if (filePath)
+              return { path: filePath };
+          } catch {}
+          return;
+        }
         const packageImport = packageNameAndSubpath(args.path);
-        if (packageImport && (packageImport.packageName.startsWith("@rig/") || RUNTIME_ONLY_EXTERNAL_PACKAGES.has(packageImport.packageName))) {
-          return { path: args.path, external: true };
+        if (packageImport?.packageName === "uhyphen" && packageImport.subpath === ".") {
+          const uhyphenPath = resolveProjectPackageImport("uhyphen", configProjectRoot);
+          if (uhyphenPath)
+            return { path: uhyphenPath };
+        }
+        if (packageImport && packageImport.packageName !== "uhyphen") {
+          try {
+            const parent2 = args.importer && isAbsolute(args.importer) ? dirname(args.importer) : configProjectRoot;
+            const resolved = bun.resolveSync?.(args.path, parent2);
+            const filePath = resolvedFilePath(resolved, configProjectRoot);
+            if (filePath)
+              return { path: filePath };
+          } catch {}
         }
-        const projectPackagePath = resolveProjectPackageImport(args.path, configDir);
+        const projectPackagePath = packageImport ? resolveProjectPackageImport(args.path, configProjectRoot) : null;
         if (projectPackagePath)
           return { path: projectPackagePath };
+        if (packageImport && (packageImport.packageName.startsWith("@rig/") || RUNTIME_ONLY_EXTERNAL_PACKAGES.has(packageImport.packageName))) {
+          return { path: args.path, external: true };
+        }
         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];
+        const importerDir = args.importer && isAbsolute(args.importer) ? dirname(args.importer) : null;
+        if (args.path.startsWith(".") && importerDir) {
+          const fromImporter = resolveModulePath(resolve(importerDir, args.path));
+          if (fromImporter)
+            return { path: fromImporter };
+          if (/[\\/]node_modules[\\/]/.test(args.importer ?? ""))
+            return;
+        }
+        const parentCandidates = args.path.startsWith(".") ? [importerDir, configDir].filter((value) => Boolean(value)) : [importerDir ?? configDir];
         for (const parent2 of parentCandidates) {
-          const filePath = resolvedFilePath(resolve(parent2, args.path), configDir);
+          const filePath = resolvedFilePath(resolve(parent2, args.path), configProjectRoot);
           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);
+          const filePath = resolvedFilePath(resolved, configProjectRoot);
           if (filePath)
             return { path: filePath };
         } catch {}
         return { path: args.path, namespace: UNRESOLVED_NAMESPACE };
       });
+      build.onLoad({ filter: /.*/, namespace: ABSOLUTE_EXTERNAL_NAMESPACE }, (args) => {
+        const href = pathToFileURL(args.path).href;
+        return {
+          loader: "js",
+          contents: `export * from ${JSON.stringify(href)};
+const mod = await import(${JSON.stringify(href)});
+export default (mod && "default" in mod) ? mod.default : mod;
+`
+        };
+      });
       build.onLoad({ filter: /.*/, namespace: UNRESOLVED_NAMESPACE }, (args) => ({
         loader: "js",
         contents: `module.exports = {};
@@ -585,7 +698,6 @@ throw new Error(${JSON.stringify(`Failed to bundle ${configPath}: Could not reso
   const result = await bun.build({
     entrypoints: [configPath],
     target: "bun",
-    external: ["effect", "mupdf", "fastembed", "onnxruntime-node", "markit-ai"],
     format: "esm",
     throw: false,
     packages: "bundle",
@@ -596,7 +708,7 @@ throw new Error(${JSON.stringify(`Failed to bundle ${configPath}: Could not reso
 `);
     throw new Error(`Failed to bundle ${configPath}: ${detail || "unknown bundler error"}`);
   }
-  const bundleParentDir = join2(configDir, ".rig", "tmp");
+  const bundleParentDir = join2(configProjectRoot, ".rig", "tmp");
   mkdirSync(bundleParentDir, { recursive: true });
   const dir = mkdtempSync(join2(bundleParentDir, "rig-config-bundle-"));
   try {
@@ -790,8 +902,17 @@ function createTaskFieldRegistry(extensions) {
 // packages/core/src/plugin-host-context.ts
 import {
   MANAGED_REPO_SERVICE_CAPABILITY,
+  REPO_CHANGE_SET,
+  REPO_NATIVE_GIT,
+  RUNTIME_SECRETS,
   SESSION_ASSET_MATERIALIZER,
-  TASK_DATA_SERVICE_CAPABILITY,
+  SESSION_HOOK_MATERIALIZER,
+  TASK_ARTIFACTS,
+  TASK_STATE_STORE,
+  TASK_TRACKER_READINESS_POLICY,
+  TASK_TRACKER_RECONCILIATION_POLICY,
+  TASK_TRACKER_REPO_LOCATOR,
+  TASK_TRACKER_STATE,
   TOOL_MATERIALIZER
 } from "@rig/contracts";
 
@@ -945,277 +1066,19 @@ function setScopeRules(rules) {
   scopeRulesState().rules = rules ?? null;
 }
 
-// packages/core/src/hook-materializer.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync } from "fs";
-import { dirname as dirname2, resolve as resolve4 } from "path";
-
-// packages/core/src/hook-runtime.ts
-import { appendFileSync, existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync3, realpathSync, writeSync } from "fs";
-import { resolve as resolve3 } from "path";
-import { RIG_DEFINITION_DIRNAME, RIG_STATE_DIRNAME } from "@rig/contracts";
-function bunRuntime() {
-  const runtime = globalThis;
-  return runtime.Bun;
-}
-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_STATE_DIR = BUILD_CONFIG.AGENT_STATE_DIR ?? "";
-var BAKED_BUN_PATH = BUILD_CONFIG.AGENT_BUN_PATH ?? "";
-var BAKED_TASK_CONFIG = BUILD_CONFIG.AGENT_TASK_CONFIG ?? "";
-var BAKED_POLICY_CONTENT = BUILD_CONFIG.AGENT_POLICY_CONTENT ?? "";
-var BAKED_TASK_SCOPES = BUILD_CONFIG.AGENT_TASK_SCOPES ?? "";
-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 bunWhich = bunRuntime()?.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);
-  mkdirSync3(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 RepoChangeSetCap = defineCapability(REPO_CHANGE_SET);
+var RepoNativeGitCap = defineCapability(REPO_NATIVE_GIT);
+var RuntimeSecretsCap = defineCapability(RUNTIME_SECRETS);
 var SessionAssetMaterializerCap = defineCapability(SESSION_ASSET_MATERIALIZER);
-var TaskDataCap = defineCapability(TASK_DATA_SERVICE_CAPABILITY);
+var SessionHookMaterializerCap = defineCapability(SESSION_HOOK_MATERIALIZER);
+var TaskArtifactsCap = defineCapability(TASK_ARTIFACTS);
+var TaskStateStoreCap = defineCapability(TASK_STATE_STORE);
+var TaskTrackerReadinessPolicyCap = defineCapability(TASK_TRACKER_READINESS_POLICY);
+var TaskTrackerReconciliationPolicyCap = defineCapability(TASK_TRACKER_RECONCILIATION_POLICY);
+var TaskTrackerRepoLocatorCap = defineCapability(TASK_TRACKER_REPO_LOCATOR);
+var TaskTrackerStateCap = defineCapability(TASK_TRACKER_STATE);
 var ToolMaterializerCap = defineCapability(TOOL_MATERIALIZER);
 async function buildPluginHostContext(projectRoot) {
   let config;
@@ -1238,10 +1101,20 @@ async function buildPluginHostContext(projectRoot) {
     validatorRegistry.register(impl);
   }
   const taskSourceRegistry = buildTaskSourceRegistry(config, pluginHost, { projectRoot });
-  const taskDataService = await TaskDataCap.resolve(pluginHost);
-  if (taskDataService) {
-    installCapability(TaskDataCap, taskDataService);
-  }
+  async function installIfResolved(capability) {
+    const impl = await capability.resolve(pluginHost);
+    if (impl)
+      installCapability(capability, impl);
+  }
+  await installIfResolved(RepoChangeSetCap);
+  await installIfResolved(RepoNativeGitCap);
+  await installIfResolved(RuntimeSecretsCap);
+  await installIfResolved(TaskArtifactsCap);
+  await installIfResolved(TaskStateStoreCap);
+  await installIfResolved(TaskTrackerReadinessPolicyCap);
+  await installIfResolved(TaskTrackerReconciliationPolicyCap);
+  await installIfResolved(TaskTrackerRepoLocatorCap);
+  await installIfResolved(TaskTrackerStateCap);
   const toolMaterializer = await ToolMaterializerCap.resolve(pluginHost);
   if (toolMaterializer) {
     installCapability(ToolMaterializerCap, toolMaterializer);
@@ -1268,7 +1141,10 @@ async function buildPluginHostContext(projectRoot) {
       typed: Boolean(hook.handler)
     })));
     if (hookEntries.length > 0) {
-      materializeSessionHookAdapters(projectRoot, hookEntries, defaultAgentSessionHookAdapters());
+      const sessionHookMaterializer = await SessionHookMaterializerCap.resolve(pluginHost);
+      if (sessionHookMaterializer) {
+        await sessionHookMaterializer.materializeSessionHooks(projectRoot, hookEntries);
+      }
     }
   } catch (err) {
     console.warn(`[plugin-host] hook materialization failed: ${err instanceof Error ? err.message : err}`);