@h-rig/core 0.0.6-alpha.156 → 0.0.6-alpha.158

package/dist/src/{task-io.js → capability-loaders.js}

@@ -1,6 +1,6 @@
 // @bun
 // packages/core/src/project-plugins.ts
-import { existsSync as existsSync2, statSync as statSync2 } from "fs";
+import { existsSync as existsSync3, statSync as statSync2 } from "fs";
 import { resolve as resolve2 } from "path";
 
 // packages/core/src/plugin-host.ts
@@ -39,6 +39,7 @@ function createPluginHost(plugins) {
   const panels = [];
   const blockerClassifiers = [];
   const sessionExtensions = [];
+  const seedEntrypoints = [];
   const stages = [];
   const stageMutations = [];
   const stageExecutors = {};
@@ -71,6 +72,8 @@ function createPluginHost(plugins) {
       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) {
@@ -93,6 +96,7 @@ function createPluginHost(plugins) {
   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) {
@@ -102,6 +106,38 @@ function createPluginHost(plugins) {
     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);
@@ -116,6 +152,7 @@ function createPluginHost(plugins) {
   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);
@@ -133,6 +170,15 @@ function createPluginHost(plugins) {
       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),
@@ -166,27 +212,35 @@ function createPluginHost(plugins) {
     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, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync } from "fs";
+import { existsSync as existsSync2, mkdirSync, mkdtempSync, readFileSync as readFileSync2, readdirSync, rmSync, statSync } from "fs";
 import { isBuiltin } from "module";
-import { dirname, isAbsolute, join, relative, resolve } from "path";
+import { dirname, isAbsolute, join as join2, relative, resolve } from "path";
 import { pathToFileURL } from "url";
-import { Schema as Schema2 } from "effect";
-import { RigConfig as RigConfig2 } from "@rig/contracts";
+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 } : { mainRepo: "." };
-  workspace.checkout = workspace.checkout ?? workspace.isolation ?? "worktree";
-  workspace.isolation = workspace.isolation ?? workspace.checkout;
-  workspace.sandbox = workspace.sandbox ?? "enforce";
+  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) {
@@ -195,11 +249,69 @@ function applyConfigDefaults(raw) {
   const record = raw;
   return {
     ...record,
-    plugins: Array.isArray(record.plugins) ? record.plugins : [],
+    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"];
@@ -261,18 +373,18 @@ function exportTargetFromPackageJson(pkg, subpath) {
   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))
+  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 = join(storeDir, entry, "node_modules", packageName);
-      const packageJsonPath = join(candidateDir, "package.json");
-      if (!existsSync(packageJsonPath))
+      const candidateDir = join2(storeDir, entry, "node_modules", packageName);
+      const packageJsonPath = join2(candidateDir, "package.json");
+      if (!existsSync2(packageJsonPath))
         return null;
       try {
-        const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+        const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
         return {
           dir: candidateDir,
           sortKey: pkg.version?.trim() || entry
@@ -290,30 +402,30 @@ function resolvePackageDirFromBunStore(packageName, nodeModulesDir) {
   }
 }
 function resolveDirectoryModulePath(directoryPath) {
-  const packageJsonPath = join(directoryPath, "package.json");
-  if (existsSync(packageJsonPath)) {
+  const packageJsonPath = join2(directoryPath, "package.json");
+  if (existsSync2(packageJsonPath)) {
     try {
-      const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+      const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
       const target = exportTargetFromPackageJson(pkg, ".");
       if (target) {
-        const resolved = resolveModulePath(join(directoryPath, 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(join(directoryPath, candidate));
+    const resolved = resolveModulePath(join2(directoryPath, candidate));
     if (resolved)
       return resolved;
   }
   return null;
 }
 function resolveModulePath(candidatePath) {
-  if (!existsSync(candidatePath)) {
+  if (!existsSync2(candidatePath)) {
     for (const extension of [".ts", ".mts", ".tsx", ".js", ".mjs", ".cjs", ".json"]) {
       const withExtension = `${candidatePath}${extension}`;
-      if (existsSync(withExtension))
+      if (existsSync2(withExtension))
         return resolveModulePath(withExtension);
     }
     return null;
@@ -330,13 +442,13 @@ function resolveModulePath(candidatePath) {
   return null;
 }
 function resolvePackageExportFromDir(packageDir, subpath) {
-  const packageJsonPath = join(packageDir, "package.json");
-  if (existsSync(packageJsonPath)) {
+  const packageJsonPath = join2(packageDir, "package.json");
+  if (existsSync2(packageJsonPath)) {
     try {
-      const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+      const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
       const target = exportTargetFromPackageJson(pkg, subpath);
       if (target) {
-        const resolved = resolveModulePath(join(packageDir, target));
+        const resolved = resolveModulePath(join2(packageDir, target));
         if (resolved)
           return resolved;
       }
@@ -347,12 +459,12 @@ function resolvePackageExportFromDir(packageDir, subpath) {
   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`)
+      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)
@@ -387,32 +499,62 @@ 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);
+  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(["mupdf", "fastembed", "onnxruntime-node", "markit-ai"]);
+  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 && RUNTIME_ONLY_EXTERNAL_PACKAGES.has(packageImport.packageName))
+        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 packageImport?.packageName.startsWith("@oh-my-pi/") ? { path: projectPackagePath, external: true } : { path: projectPackagePath };
+          return { path: projectPackagePath };
         if (/^(?:node|bun):/.test(args.path) || isBuiltin(args.path))
           return;
         if (packageImport)
@@ -443,7 +585,7 @@ throw new Error(${JSON.stringify(`Failed to bundle ${configPath}: Could not reso
   const result = await bun.build({
     entrypoints: [configPath],
     target: "bun",
-    external: ["mupdf", "fastembed", "onnxruntime-node", "markit-ai"],
+    external: ["effect", "mupdf", "fastembed", "onnxruntime-node", "markit-ai"],
     format: "esm",
     throw: false,
     packages: "bundle",
@@ -454,11 +596,11 @@ 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 = join(configDir, ".rig", "tmp");
+  const bundleParentDir = join2(configDir, ".rig", "tmp");
   mkdirSync(bundleParentDir, { recursive: true });
-  const dir = mkdtempSync(join(bundleParentDir, "rig-config-bundle-"));
+  const dir = mkdtempSync(join2(bundleParentDir, "rig-config-bundle-"));
   try {
-    const bundledPath = join(dir, "rig.config.bundled.js");
+    const bundledPath = join2(dir, "rig.config.bundled.js");
     await bun.write(bundledPath, await result.outputs[0].text());
     return await import(pathToFileURL(bundledPath).href);
   } finally {
@@ -468,16 +610,20 @@ throw new Error(${JSON.stringify(`Failed to bundle ${configPath}: Could not reso
   }
 }
 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 = join(cwd, name);
-    if (existsSync(p)) {
+    const p = join2(cwd, name);
+    if (existsSync2(p)) {
       const mod = await enqueueRuntimeBundle(async () => {
         if (runningFromCompiledBinary()) {
           return importConfigViaRuntimeBundleUnserialized(p);
         }
-        const source = readFileSync(p, "utf8");
+        const source = readFileSync2(p, "utf8");
         const importsRigHostPackages = /(?:import\s+[^;]*?from\s*|import\s*\()\s*["']@rig\//.test(source);
-        if (importsRigHostPackages) {
+        if (importsRigHostPackages && !canImportRigWorkspacePackagesDirectly(source, cwd)) {
           return importConfigViaRuntimeBundleUnserialized(p);
         }
         try {
@@ -492,19 +638,23 @@ async function loadConfig(cwd) {
       return decodeExplicitPluginConfig(raw);
     }
   }
+  const declarativePath = findDeclarativeConfigPath(cwd);
+  if (declarativePath) {
+    return loadDeclarativeConfig(declarativePath);
+  }
   for (const name of JSON_NAMES) {
-    const p = join(cwd, name);
-    if (existsSync(p)) {
-      const raw = JSON.parse(readFileSync(p, "utf-8"));
+    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} found in ${cwd}`);
+  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 = Schema2.decodeUnknownSync(RigConfig2)({
+  const decoded = Schema3.decodeUnknownSync(RigConfig3)({
     ...withDefaults,
     plugins: explicitPlugins
   });
@@ -516,7 +666,7 @@ 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 (existsSync2(path))
+    if (existsSync3(path))
       return path;
   }
   return null;
@@ -554,154 +704,46 @@ function resolvePluginHost(projectRoot, options = {}) {
   return promise;
 }
 
-// packages/core/src/task-io.ts
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function taskText(value) {
-  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
-}
-function taskUrl(record) {
-  const metadata = record;
-  return taskText(metadata.url) ?? taskText(metadata.html_url) ?? taskText(metadata.webUrl);
-}
-function taskBody(record) {
-  const metadata = record;
-  return taskText(metadata.body) ?? taskText(metadata.description);
-}
-function taskTitle(record) {
-  const metadata = record;
-  return taskText(metadata.title) ?? taskText(metadata.name) ?? record.id;
-}
-function taskStringList(value) {
-  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.trim().length > 0) : [];
-}
-function taskDependencies(record) {
-  const raw = record;
-  const dependencies = taskStringList(raw.dependencies);
-  if (dependencies.length > 0)
-    return dependencies;
-  const deps = taskStringList(raw.deps);
-  return deps.length > 0 ? deps : null;
-}
-function taskParentChildDeps(record) {
-  const raw = record;
-  const parentChildDeps = taskStringList(raw.parentChildDeps);
-  if (parentChildDeps.length > 0)
-    return parentChildDeps;
-  const parents = taskStringList(raw.parents);
-  return parents.length > 0 ? parents : null;
-}
-function taskCreateInput(task) {
-  const deps = Array.isArray(task.dependencies) ? task.dependencies.filter((entry) => typeof entry === "string") : Array.isArray(task.deps) ? task.deps.filter((entry) => typeof entry === "string") : [];
-  const parents = Array.isArray(task.parents) ? task.parents.filter((entry) => typeof entry === "string") : [];
-  return {
-    title: taskText(task.title) ?? taskText(task.name) ?? "Untitled task",
-    body: taskText(task.body) ?? taskText(task.description) ?? "",
-    ...deps.length > 0 ? { deps } : {},
-    ...parents.length > 0 ? { parents } : {},
-    metadata: { ...task }
-  };
+// packages/core/src/capability-loaders.ts
+async function buildProjectPluginHost(projectRoot) {
+  try {
+    return (await resolvePluginHost(projectRoot)).host;
+  } catch {
+    return null;
+  }
 }
-function toRigTask(record, sourceKind) {
-  const dependencies = taskDependencies(record);
-  const parentChildDeps = taskParentChildDeps(record);
-  return {
-    ...record,
-    id: record.id,
-    title: taskTitle(record),
-    status: typeof record.status === "string" ? record.status : null,
-    source: sourceKind,
-    url: taskUrl(record),
-    body: taskBody(record),
-    ...dependencies ? { dependencies } : {},
-    ...parentChildDeps ? { parentChildDeps } : {}
-  };
+async function loadCapabilityForRoot(projectRoot, capability) {
+  const host = await buildProjectPluginHost(projectRoot);
+  return host ? capability.resolve(host) : null;
 }
-function normalizeTaskId(value) {
-  const trimmed = value?.trim();
-  if (!trimmed)
-    return;
-  return trimmed.startsWith("#") && /^#\d+$/.test(trimmed) ? trimmed.slice(1) : trimmed;
+async function requireCapabilityForRoot(projectRoot, capability, message) {
+  const resolved = await loadCapabilityForRoot(projectRoot, capability);
+  if (!resolved)
+    throw new Error(message);
+  return resolved;
 }
-function readTaskTitle(task) {
-  if (!task)
-    return null;
-  for (const key of ["title", "summary", "name"]) {
-    const value = task[key];
-    if (typeof value === "string" && value.trim())
-      return value.trim();
-  }
-  return null;
+var INSTALLED = new Map;
+function installCapability(capability, impl) {
+  INSTALLED.set(String(capability.id), impl);
 }
-async function loadTaskSource(projectRoot) {
-  const { config, host: pluginHost } = await resolvePluginHost(projectRoot);
-  const factory = pluginHost.resolveTaskSourceFactoryByKind(config.taskSource.kind);
-  if (!factory) {
-    const kinds = pluginHost.listExecutableTaskSources().map((entry) => entry.kind).join(", ") || "none";
-    throw new Error(`No task source factory registered for kind ${config.taskSource.kind}. Registered task sources: ${kinds}.`);
-  }
-  return { kind: config.taskSource.kind, source: factory.factory(config.taskSource, { projectRoot }) };
-}
-var defaultLoadTaskSource = loadTaskSource;
-async function listTasks(projectRoot, deps = {}) {
-  const { kind, source } = await (deps.loadTaskSource ?? loadTaskSource)(projectRoot);
-  return (await source.list()).map((task) => toRigTask(task, kind));
-}
-var listTasksFromSource = listTasks;
-async function getTask(projectRoot, taskId, deps = {}) {
-  const { kind, source } = await (deps.loadTaskSource ?? loadTaskSource)(projectRoot);
-  const task = source.get ? await source.get(taskId) ?? null : (await source.list()).find((entry) => entry.id === taskId) ?? null;
-  return task ? toRigTask(task, kind) : null;
-}
-var getTaskFromSource = getTask;
-async function listTasksForCommand(projectRoot, deps = {}) {
-  if (deps.listTasks)
-    return deps.listTasks(projectRoot);
-  if (deps.loadTaskSource) {
-    const { kind, source } = await deps.loadTaskSource(projectRoot);
-    return (await source.list()).map((task) => ({ ...toRigTask(task, kind), source: kind }));
-  }
-  return listTasks(projectRoot);
-}
-async function getTaskForCommand(projectRoot, taskId, deps = {}) {
-  if (deps.getTask)
-    return deps.getTask(projectRoot, taskId);
-  if (deps.loadTaskSource) {
-    const { kind, source } = await deps.loadTaskSource(projectRoot);
-    const task = source.get ? await source.get(taskId) : (await source.list()).find((entry) => entry.id === taskId);
-    return task ? toRigTask(task, kind) : null;
-  }
-  return getTask(projectRoot, taskId);
-}
-function getTaskCreator(source) {
-  const record = source;
-  if (typeof record.createTask === "function")
-    return record.createTask.bind(source);
-  if (typeof record.create === "function")
-    return (task) => record.create?.(taskCreateInput(task));
-  return null;
+function clearInstalledCapability(capability) {
+  INSTALLED.delete(String(capability.id));
+}
+function getInstalledCapability(capability) {
+  return INSTALLED.get(String(capability.id)) ?? null;
 }
-async function createTask(projectRoot, task, deps = {}) {
-  const { kind, source } = await (deps.loadTaskSource ?? loadTaskSource)(projectRoot);
-  const creator = getTaskCreator(source);
-  if (!creator)
-    throw new Error(`The configured ${kind} task source does not expose a task creation API.`);
-  const result = await creator(task);
-  const taskId = typeof result === "string" ? result : isRecord(result) && typeof result.id === "string" ? result.id : null;
-  return { taskId, source: kind, result };
+function requireInstalledCapability(capability, message) {
+  const impl = getInstalledCapability(capability);
+  if (!impl)
+    throw new Error(message);
+  return impl;
 }
 export {
-  readTaskTitle,
-  normalizeTaskId,
-  loadTaskSource,
-  listTasksFromSource,
-  listTasksForCommand,
-  listTasks,
-  getTaskFromSource,
-  getTaskForCommand,
-  getTaskCreator,
-  getTask,
-  defaultLoadTaskSource,
-  createTask
+  requireInstalledCapability,
+  requireCapabilityForRoot,
+  loadCapabilityForRoot,
+  installCapability,
+  getInstalledCapability,
+  clearInstalledCapability,
+  buildProjectPluginHost
 };