@h-rig/core 0.0.6-alpha.141 → 0.0.6-alpha.143

package/dist/src/config.d.ts

@@ -0,0 +1,3 @@
+export { defineConfig, type RigConfigInput } from "./define-config";
+export { definePlugin } from "./define-plugin";
+export type { RegisteredValidator, RigPluginRuntime, RigPluginWithRuntime, RuntimeCliCommand, RuntimeCliContext, RuntimePanelProducer, TaskSourceFactoryContext, TaskSourceFactoryEntry, ValidatorContext, ValidatorResult, } from "./plugin-runtime";

package/dist/src/config.js

@@ -0,0 +1,136 @@
+// @bun
+// packages/core/src/define-config.ts
+import { Schema } from "effect";
+import { RigConfig } from "@rig/contracts";
+function normalizeWorkspaceConfig(raw) {
+  const workspace = raw && typeof raw === "object" && !Array.isArray(raw) ? { ...raw } : { mainRepo: "." };
+  workspace.checkout = workspace.checkout ?? workspace.isolation ?? "worktree";
+  workspace.isolation = workspace.isolation ?? workspace.checkout;
+  workspace.sandbox = workspace.sandbox ?? "enforce";
+  return workspace;
+}
+function applyConfigDefaults(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return raw;
+  const record = raw;
+  return {
+    ...record,
+    plugins: Array.isArray(record.plugins) ? record.plugins : [],
+    workspace: normalizeWorkspaceConfig(record.workspace)
+  };
+}
+function defineConfig(cfg) {
+  const runtimeByName = new Map;
+  const plugins = cfg.plugins ?? [];
+  for (const plugin of plugins) {
+    if (plugin?.__runtime) {
+      runtimeByName.set(plugin.name, plugin.__runtime);
+    }
+  }
+  const decoded = Schema.decodeUnknownSync(RigConfig)(applyConfigDefaults(cfg));
+  const decodedPlugins = decoded.plugins.map((p) => {
+    const runtime = runtimeByName.get(p.name);
+    if (!runtime)
+      return p;
+    return { ...p, __runtime: runtime };
+  });
+  return { ...decoded, plugins: decodedPlugins };
+}
+// packages/core/src/define-plugin.ts
+import { Schema as Schema2 } from "effect";
+import { RigPlugin } from "@rig/contracts";
+function definePlugin(meta, runtime) {
+  const validated = Schema2.decodeUnknownSync(RigPlugin)(meta);
+  if (!runtime) {
+    return validated;
+  }
+  const declaredValidators = new Map((validated.contributes?.validators ?? []).map((v) => [v.id, v]));
+  const runtimeValidators = new Map((runtime.validators ?? []).map((v) => [v.id, v]));
+  for (const v of runtimeValidators.values()) {
+    const metadata = declaredValidators.get(v.id);
+    if (!metadata) {
+      throw new Error(`definePlugin(${validated.name}): executable validator "${v.id}" has no matching metadata entry in contributes.validators`);
+    }
+    if (metadata.category !== v.category) {
+      throw new Error(`definePlugin(${validated.name}): executable validator "${v.id}" category "${v.category}" does not match metadata category "${metadata.category}"`);
+    }
+  }
+  if (runtime.validators) {
+    for (const v of declaredValidators.values()) {
+      if (!runtimeValidators.has(v.id)) {
+        throw new Error(`definePlugin(${validated.name}): validator metadata "${v.id}" has no runtime implementation`);
+      }
+    }
+  }
+  const declaredSources = new Map((validated.contributes?.taskSources ?? []).map((s) => [s.id, s]));
+  const runtimeSources = new Map((runtime.taskSources ?? []).map((s) => [s.id, s]));
+  for (const s of runtimeSources.values()) {
+    const metadata = declaredSources.get(s.id);
+    if (!metadata) {
+      throw new Error(`definePlugin(${validated.name}): executable task source "${s.id}" has no matching metadata entry in contributes.taskSources`);
+    }
+    if (metadata.kind !== s.kind) {
+      throw new Error(`definePlugin(${validated.name}): executable task source "${s.id}" kind "${s.kind}" does not match metadata kind "${metadata.kind}"`);
+    }
+  }
+  if (runtime.taskSources) {
+    for (const s of declaredSources.values()) {
+      if (!runtimeSources.has(s.id)) {
+        throw new Error(`definePlugin(${validated.name}): task source metadata "${s.id}" has no runtime implementation`);
+      }
+    }
+  }
+  const declaredHooks = new Map((validated.contributes?.hooks ?? []).map((h) => [h.id, h]));
+  for (const hookId of Object.keys(runtime.hooks ?? {})) {
+    const metadata = declaredHooks.get(hookId);
+    if (!metadata) {
+      throw new Error(`definePlugin(${validated.name}): typed hook "${hookId}" has no matching metadata entry in contributes.hooks`);
+    }
+    if (metadata.command) {
+      throw new Error(`definePlugin(${validated.name}): hook "${hookId}" has both a typed implementation and a command string \u2014 pick one`);
+    }
+  }
+  if (runtime.hooks) {
+    for (const h of declaredHooks.values()) {
+      if (!runtime.hooks[h.id] && !h.command) {
+        throw new Error(`definePlugin(${validated.name}): hook metadata "${h.id}" has no implementation (typed function or command)`);
+      }
+    }
+  }
+  const declaredCapabilities = new Map((validated.contributes?.capabilities ?? []).map((capability) => [capability.id, capability]));
+  for (const capability of runtime.featureCapabilities ?? []) {
+    if (!declaredCapabilities.has(capability.id)) {
+      throw new Error(`definePlugin(${validated.name}): executable capability "${capability.id}" has no matching metadata entry in contributes.capabilities`);
+    }
+  }
+  const declaredPanels = new Map((validated.contributes?.panels ?? []).map((panel) => [panel.id, panel]));
+  for (const panel of runtime.panels ?? []) {
+    const metadata = declaredPanels.get(panel.id);
+    if (!metadata) {
+      throw new Error(`definePlugin(${validated.name}): executable panel "${panel.id}" has no matching metadata entry in contributes.panels`);
+    }
+    if (metadata.slot !== panel.slot) {
+      throw new Error(`definePlugin(${validated.name}): executable panel "${panel.id}" slot "${panel.slot}" does not match metadata slot "${metadata.slot}"`);
+    }
+    if (metadata.capabilityId !== panel.capabilityId) {
+      throw new Error(`definePlugin(${validated.name}): executable panel "${panel.id}" capabilityId "${panel.capabilityId ?? "(none)"}" does not match metadata capabilityId "${metadata.capabilityId ?? "(none)"}"`);
+    }
+  }
+  const declaredBlockerClassifiers = new Map((validated.contributes?.blockerClassifiers ?? []).map((classifier) => [classifier.id, classifier]));
+  for (const classifier of runtime.blockerClassifiers ?? []) {
+    if (!declaredBlockerClassifiers.has(classifier.id)) {
+      throw new Error(`definePlugin(${validated.name}): executable blocker classifier "${classifier.id}" has no matching metadata entry in contributes.blockerClassifiers`);
+    }
+  }
+  const declaredCliCommands = new Map((validated.contributes?.cliCommands ?? []).map((command) => [command.id, command]));
+  for (const command of runtime.cliCommands ?? []) {
+    if (!declaredCliCommands.has(command.id)) {
+      throw new Error(`definePlugin(${validated.name}): executable cli command "${command.id}" has no matching metadata entry in contributes.cliCommands`);
+    }
+  }
+  return { ...validated, __runtime: runtime };
+}
+export {
+  definePlugin,
+  defineConfig
+};

package/dist/src/index.d.ts

@@ -4,7 +4,7 @@ export { defineConfig } from "./define-config";
 export { createPluginHost } from "./plugin-host";
 export type { PluginHost } from "./plugin-host";
 export { buildRigInitConfigSource, type RigInitConfigInput, } from "./rig-init-builder";
-export type { RegisteredValidator, RigPluginRuntime, RigPluginWithRuntime, TaskSourceFactoryContext, RuntimeCliCommand, RuntimeCliContext, TaskSourceFactoryEntry, ValidatorContext, ValidatorResult, } from "./plugin-runtime";
+export type { RegisteredValidator, RigPluginRuntime, RigPluginWithRuntime, TaskSourceFactoryContext, RuntimeCliCommand, RuntimeCliContext, RuntimePanelProducer, TaskSourceFactoryEntry, ValidatorContext, ValidatorResult, } from "./plugin-runtime";
 export { applyEngineEvent, applyEngineEvents, applyEngineEvent as applyRigEvent, pruneQueueEntries, type ApplyStatus, type EngineEventApplyResult, type EngineEventApplyResult as RigEventApplyResult, } from "./engineReadModelReducer";
 export { pickDefaultWorkspaceId, projectRunStatusForTaskGrouping, projectTaskStatusForGrouping, projectTaskStatusWithSessions, normalizeTaskAssigneeFilter, readTaskAssigneeLogins, selectAdhocRuns, selectAdhocRunsForWorkspace, selectApprovalsForRun, selectApprovalsForWorkspace, selectGraphsForWorkspace, selectPendingApprovals, selectPrimaryWorkspace, selectQueueForWorkspace, selectRun, selectRunsByTask, selectRunsForTask, selectRunsForWorkspace, selectTask, selectTasksByStatus, selectTasksByWorkspace, selectTasksForWorkspace, selectTasksGroupedByStatus, selectTasksAssignedTo, selectTasksAssignedToMe, selectUserInputsForRun, selectUserInputsForWorkspace, selectWorkspace, selectWorkspaces, type RigTaskSessionProjection, type RigTaskStatusGroup, type RigTaskStatusGroupingInput, } from "./rigSelectors";
 export { buildTaskReferenceIndex, computeTaskBlockingDepths, computeTaskDependencyBadges, disjointScope, isTaskTerminalStatus, rankReadyTasks, readTaskBlockingDependencyRefs, readTaskDependencyRefs, readTaskMetadataStringList, readTaskScope, readTaskSourceIssueId, resolveTaskReference, selectNextReadyTaskByPriority, selectRankedReadyTasks, type RankedReadyTask, type RankedReadyTaskOptions, type ReadyTaskSelectionMode, type TaskDependencyBadge, type TaskDependencyBadgeKind, type TaskDependencyBadgeSummary, type TaskDependencyProjection, type TaskScopeInput, } from "./taskGraph";

package/dist/src/index.js

@@ -420,9 +420,9 @@ function createPluginHost(plugins) {
 }
 // packages/core/src/rig-init-builder.ts
 function buildRigInitConfigSource(input) {
-  const lines = [`import { defineConfig } from "@rig/core";`];
+  const lines = [`import { defineConfig } from "@rig/core/config";`];
   if (input.useStandardPlugin) {
-    lines.push(`import { standardProjectPlugins } from "@rig/standard-plugin/bundle";`);
+    lines.push(`import { standardPlugins } from "@rig/standard-plugin/bundle";`);
     if (input.taskSource.kind === "github-issues") {
       lines.push(`import { createStateGitHubCredentialProvider } from "@rig/standard-plugin";`);
     }
@@ -431,15 +431,15 @@ function buildRigInitConfigSource(input) {
   const projectRepo = input.projectRepo ?? (input.taskSource.kind === "github-issues" ? `${input.taskSource.owner}/${input.taskSource.repo}` : undefined);
   lines.push(projectRepo ? `  project: { name: ${JSON.stringify(input.projectName)}, repo: ${JSON.stringify(projectRepo)} },` : `  project: { name: ${JSON.stringify(input.projectName)} },`);
   if (input.useStandardPlugin && input.taskSource.kind === "github-issues") {
-    lines.push(`  plugins: [...standardProjectPlugins({`);
-    lines.push(`    standard: {`);
+    lines.push(`  plugins: [...standardPlugins({`);
+    lines.push(`    taskSources: {`);
     lines.push(`      githubCredentialProvider: createStateGitHubCredentialProvider(),`);
     lines.push(`      githubWorkspaceId: ${JSON.stringify(`${input.taskSource.owner}/${input.taskSource.repo}`)},`);
     lines.push(`      githubUserId: process.env.RIG_GITHUB_USER_ID ?? "server-selected-user",`);
     lines.push(`    },`);
     lines.push(`  })],`);
   } else {
-    lines.push(`  plugins: [${input.useStandardPlugin ? "...standardProjectPlugins()" : ""}],`);
+    lines.push(`  plugins: [${input.useStandardPlugin ? "...standardPlugins()" : ""}],`);
   }
   if (input.taskSource.kind === "github-issues") {
     lines.push(`  taskSource: {`);

package/dist/src/load-config.js

@@ -3,7 +3,7 @@
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync } from "fs";
 import { isBuiltin } from "module";
 import { dirname, isAbsolute, join, relative, resolve } from "path";
-import { fileURLToPath, pathToFileURL } from "url";
+import { pathToFileURL } from "url";
 import { Schema as Schema2 } from "effect";
 import { RigConfig as RigConfig2 } from "@rig/contracts";
 
@@ -88,35 +88,6 @@ function exportTargetFromPackageJson(pkg, subpath) {
     return target;
   return subpath === "." && typeof pkg.module === "string" ? pkg.module : subpath === "." && typeof pkg.main === "string" ? pkg.main : null;
 }
-function resolvePackageDirFromBunStore(packageName, nodeModulesDir) {
-  const storeDir = join(nodeModulesDir, ".bun");
-  if (!existsSync(storeDir))
-    return null;
-  const encoded = packageName.replace("/", "+");
-  try {
-    const candidates = readdirSync(storeDir).filter((entry) => entry.startsWith(`${encoded}@`)).map((entry) => {
-      const candidateDir = join(storeDir, entry, "node_modules", packageName);
-      const packageJsonPath = join(candidateDir, "package.json");
-      if (!existsSync(packageJsonPath))
-        return null;
-      try {
-        const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-        return {
-          dir: candidateDir,
-          sortKey: pkg.version?.trim() || entry
-        };
-      } catch {
-        return {
-          dir: candidateDir,
-          sortKey: entry
-        };
-      }
-    }).filter((candidate) => candidate !== null).sort((a, b) => b.sortKey.localeCompare(a.sortKey, undefined, { numeric: true, sensitivity: "base" }));
-    return candidates[0]?.dir ?? null;
-  } catch {
-    return null;
-  }
-}
 function resolveDirectoryModulePath(directoryPath) {
   const packageJsonPath = join(directoryPath, "package.json");
   if (existsSync(packageJsonPath)) {
@@ -138,8 +109,14 @@ function resolveDirectoryModulePath(directoryPath) {
   return null;
 }
 function resolveModulePath(candidatePath) {
-  if (!existsSync(candidatePath))
+  if (!existsSync(candidatePath)) {
+    for (const extension of [".ts", ".mts", ".tsx", ".js", ".mjs", ".cjs", ".json"]) {
+      const withExtension = `${candidatePath}${extension}`;
+      if (existsSync(withExtension))
+        return resolveModulePath(withExtension);
+    }
     return null;
+  }
   try {
     const stat = statSync(candidatePath);
     if (stat.isFile())
@@ -151,68 +128,6 @@ function resolveModulePath(candidatePath) {
   }
   return null;
 }
-function resolvePackageExportFromDir(packageDir, subpath) {
-  const packageJsonPath = join(packageDir, "package.json");
-  if (existsSync(packageJsonPath)) {
-    try {
-      const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-      const target = exportTargetFromPackageJson(pkg, subpath);
-      if (target) {
-        const resolved = resolveModulePath(join(packageDir, target));
-        if (resolved)
-          return resolved;
-      }
-    } catch {
-      return null;
-    }
-  }
-  if (subpath !== ".") {
-    const legacySubpath = subpath.replace(/^\.\//, "");
-    for (const candidate of [
-      join(packageDir, legacySubpath),
-      join(packageDir, `${legacySubpath}.js`),
-      join(packageDir, `${legacySubpath}.mjs`),
-      join(packageDir, `${legacySubpath}.cjs`),
-      join(packageDir, `${legacySubpath}.ts`),
-      join(packageDir, `${legacySubpath}.json`)
-    ]) {
-      const resolved = resolveModulePath(candidate);
-      if (resolved)
-        return resolved;
-    }
-  }
-  return subpath === "." ? resolveDirectoryModulePath(packageDir) : null;
-}
-function resolveBarePackageExport(specifier, parentDir, ceilingDir) {
-  const parsed = packageNameAndSubpath(specifier);
-  if (!parsed)
-    return null;
-  const packageNames = parsed.packageName.startsWith("@rig/") ? [parsed.packageName, parsed.packageName.replace(/^@rig\//, "@h-rig/")] : [parsed.packageName];
-  const ceiling = ceilingDir ? resolve(ceilingDir) : null;
-  let current = resolve(parentDir);
-  while (true) {
-    const nodeModulesDir = join(current, "node_modules");
-    for (const packageName of packageNames) {
-      const directPackageDir = join(nodeModulesDir, packageName);
-      const resolvedDirect = resolvePackageExportFromDir(directPackageDir, parsed.subpath);
-      if (resolvedDirect)
-        return resolvedDirect;
-      const bunStorePackageDir = resolvePackageDirFromBunStore(packageName, nodeModulesDir);
-      if (bunStorePackageDir) {
-        const resolvedFromStore = resolvePackageExportFromDir(bunStorePackageDir, parsed.subpath);
-        if (resolvedFromStore)
-          return resolvedFromStore;
-      }
-    }
-    if (ceiling && current === ceiling)
-      break;
-    const next = dirname(current);
-    if (next === current)
-      break;
-    current = next;
-  }
-  return null;
-}
 var runtimeBundleQueue = Promise.resolve();
 function enqueueRuntimeBundle(operation) {
   const next = runtimeBundleQueue.then(operation, operation);
@@ -235,70 +150,41 @@ function resolvedFilePath(path, rootPath) {
     return null;
   return rootPath && !isWithinDir(resolved, rootPath) ? null : resolved;
 }
-var RUNTIME_BUNDLE_EXTERNALS = [];
-function shouldDeferToRuntimeExternal(specifier) {
-  return RUNTIME_BUNDLE_EXTERNALS.includes(specifier);
-}
 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 hostDir = (() => {
-    try {
-      return dirname(fileURLToPath(import.meta.url));
-    } catch {
-      return process.cwd();
-    }
-  })();
   const configDir = dirname(configPath);
   const UNRESOLVED_NAMESPACE = "rig-config-unresolved";
-  const hostResolverPlugin = {
-    name: "rig-host-package-resolver",
+  const unresolvedLocalPlugin = {
+    name: "rig-config-unresolved-local",
     setup(build) {
-      build.onResolve({ filter: /^@rig\// }, (args) => {
-        const candidates = [
-          { specifier: args.path, parent: hostDir },
-          { specifier: args.path.replace(/^@rig\//, "@h-rig/"), parent: hostDir },
-          { specifier: args.path, parent: configDir, root: configDir }
-        ];
-        for (const candidate of candidates) {
-          try {
-            const resolved = resolvedFilePath(bun.resolveSync?.(candidate.specifier, candidate.parent) ?? resolveBarePackageExport(candidate.specifier, candidate.parent, candidate.root), candidate.root);
-            if (resolved)
-              return { path: resolved };
-          } catch {
-            const resolved = resolvedFilePath(resolveBarePackageExport(candidate.specifier, candidate.parent, candidate.root), candidate.root);
-            if (resolved)
-              return { path: resolved };
-          }
-        }
-        return;
-      });
       build.onResolve({ filter: /.*/ }, (args) => {
-        const parent = args.importer ? dirname(args.importer) : configDir;
-        if (/^(?:node|bun):/.test(args.path) || isBuiltin(args.path) || shouldDeferToRuntimeExternal(args.path))
+        const directFilePath = resolvedFilePath(args.path, configDir);
+        if (directFilePath)
+          return { path: directFilePath };
+        if (/^(?:node|bun):/.test(args.path) || isBuiltin(args.path) || packageNameAndSubpath(args.path))
           return;
-        const projectScoped = isWithinDir(parent, configDir);
-        try {
-          const resolved = bun.resolveSync?.(args.path, parent) ?? resolveBarePackageExport(args.path, parent, projectScoped ? configDir : undefined);
-          const filePath = resolvedFilePath(resolved, projectScoped ? configDir : undefined);
+        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 };
-          if (resolved)
-            return { path: args.path, namespace: UNRESOLVED_NAMESPACE };
-        } catch {
-          const resolved = resolvedFilePath(resolveBarePackageExport(args.path, parent, projectScoped ? configDir : undefined), projectScoped ? configDir : undefined);
-          if (resolved)
-            return { path: resolved };
-          return { path: args.path, namespace: UNRESOLVED_NAMESPACE };
         }
-        return;
+        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: "${args.path}". Maybe you need to "bun install"?`)});
+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.`)});
 `
       }));
     }
@@ -308,8 +194,8 @@ throw new Error(${JSON.stringify(`Failed to bundle ${configPath}: Could not reso
     target: "bun",
     format: "esm",
     throw: false,
-    external: [...RUNTIME_BUNDLE_EXTERNALS],
-    plugins: [hostResolverPlugin]
+    packages: "external",
+    plugins: [unresolvedLocalPlugin]
   });
   if (!result.success || !result.outputs[0]) {
     const detail = result.logs.map((log) => String(log)).join(`

package/dist/src/rig-init-builder.js

@@ -1,9 +1,9 @@
 // @bun
 // packages/core/src/rig-init-builder.ts
 function buildRigInitConfigSource(input) {
-  const lines = [`import { defineConfig } from "@rig/core";`];
+  const lines = [`import { defineConfig } from "@rig/core/config";`];
   if (input.useStandardPlugin) {
-    lines.push(`import { standardProjectPlugins } from "@rig/standard-plugin/bundle";`);
+    lines.push(`import { standardPlugins } from "@rig/standard-plugin/bundle";`);
     if (input.taskSource.kind === "github-issues") {
       lines.push(`import { createStateGitHubCredentialProvider } from "@rig/standard-plugin";`);
     }
@@ -12,15 +12,15 @@ function buildRigInitConfigSource(input) {
   const projectRepo = input.projectRepo ?? (input.taskSource.kind === "github-issues" ? `${input.taskSource.owner}/${input.taskSource.repo}` : undefined);
   lines.push(projectRepo ? `  project: { name: ${JSON.stringify(input.projectName)}, repo: ${JSON.stringify(projectRepo)} },` : `  project: { name: ${JSON.stringify(input.projectName)} },`);
   if (input.useStandardPlugin && input.taskSource.kind === "github-issues") {
-    lines.push(`  plugins: [...standardProjectPlugins({`);
-    lines.push(`    standard: {`);
+    lines.push(`  plugins: [...standardPlugins({`);
+    lines.push(`    taskSources: {`);
     lines.push(`      githubCredentialProvider: createStateGitHubCredentialProvider(),`);
     lines.push(`      githubWorkspaceId: ${JSON.stringify(`${input.taskSource.owner}/${input.taskSource.repo}`)},`);
     lines.push(`      githubUserId: process.env.RIG_GITHUB_USER_ID ?? "server-selected-user",`);
     lines.push(`    },`);
     lines.push(`  })],`);
   } else {
-    lines.push(`  plugins: [${input.useStandardPlugin ? "...standardProjectPlugins()" : ""}],`);
+    lines.push(`  plugins: [${input.useStandardPlugin ? "...standardPlugins()" : ""}],`);
   }
   if (input.taskSource.kind === "github-issues") {
     lines.push(`  taskSource: {`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@h-rig/core",
-  "version": "0.0.6-alpha.141",
+  "version": "0.0.6-alpha.143",
   "type": "module",
   "description": "Config and plugin composition library for Rig's OMP extension ecosystem; not a product host/runtime.",
   "license": "UNLICENSED",
@@ -17,6 +17,10 @@
       "types": "./dist/src/load-config.d.ts",
       "import": "./dist/src/load-config.js"
     },
+    "./config": {
+      "types": "./dist/src/config.d.ts",
+      "import": "./dist/src/config.js"
+    },
     "./task-graph": {
       "types": "./dist/src/taskGraph.d.ts",
       "import": "./dist/src/taskGraph.js"
@@ -45,7 +49,7 @@
   "module": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",
   "dependencies": {
-    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.141",
+    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.143",
     "effect": "4.0.0-beta.90"
   }
 }