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

package/dist/src/baked-secrets.d.ts

@@ -1,6 +1,3 @@
-export type RuntimeSecretKey = "ANTHROPIC_API_KEY" | "OPENAI_API_KEY" | "OPENROUTER_API_KEY" | "AI_REVIEW_MODE" | "AI_REVIEW_PROVIDER" | "GREPTILE_API_BASE" | "GREPTILE_REMOTE" | "GREPTILE_REPOSITORY" | "GREPTILE_CONTEXT_BRANCH" | "GREPTILE_DEFAULT_BRANCH" | "GREPTILE_API_KEY" | "GREPTILE_GITHUB_TOKEN" | "GREPTILE_POLL_ATTEMPTS" | "GREPTILE_POLL_INTERVAL_MS" | "GH_TOKEN" | "GITHUB_TOKEN" | "GITHUB_SSH_KEY" | "AWS_ACCESS_KEY_ID" | "AWS_SECRET_ACCESS_KEY" | "AWS_REGION" | "LINEAR_API_KEY" | "LINEAR_WEBHOOK_SECRET";
-export type RuntimeSecrets = Partial<Record<RuntimeSecretKey, string>>;
-export declare const BAKED_RUNTIME_SECRETS: RuntimeSecrets;
-export declare function resolveRuntimeSecrets(env: Record<string, string | undefined>, baked?: RuntimeSecrets): RuntimeSecrets;
-export declare function loadDotEnvSecrets(projectRoot: string, env?: Record<string, string | undefined>): RuntimeSecrets;
-export declare function secretDefinesFromEnv(env?: Record<string, string | undefined>, projectRoot?: string): Record<string, string>;
+export type RuntimeConfigValues = Record<string, string>;
+export declare function resolveRuntimeConfigValues(env: Record<string, string | undefined>, keys: Iterable<string>, baked?: Record<string, string | undefined>): RuntimeConfigValues;
+export declare function loadDotEnvValues(projectRoot: string, keys: Iterable<string>, env?: Record<string, string | undefined>): RuntimeConfigValues;

package/dist/src/baked-secrets.js

@@ -2,37 +2,10 @@
 // packages/core/src/baked-secrets.ts
 import { existsSync, readFileSync } from "fs";
 import { resolve } from "path";
-var BAKED_RUNTIME_SECRETS = {
-  ANTHROPIC_API_KEY: typeof RIG_BAKED_ANTHROPIC_API_KEY !== "undefined" ? RIG_BAKED_ANTHROPIC_API_KEY : "",
-  OPENAI_API_KEY: typeof RIG_BAKED_OPENAI_API_KEY !== "undefined" ? RIG_BAKED_OPENAI_API_KEY : "",
-  OPENROUTER_API_KEY: typeof RIG_BAKED_OPENROUTER_API_KEY !== "undefined" ? RIG_BAKED_OPENROUTER_API_KEY : "",
-  AI_REVIEW_MODE: typeof RIG_BAKED_AI_REVIEW_MODE !== "undefined" ? RIG_BAKED_AI_REVIEW_MODE : "",
-  AI_REVIEW_PROVIDER: typeof RIG_BAKED_AI_REVIEW_PROVIDER !== "undefined" ? RIG_BAKED_AI_REVIEW_PROVIDER : "",
-  GREPTILE_API_BASE: typeof RIG_BAKED_GREPTILE_API_BASE !== "undefined" ? RIG_BAKED_GREPTILE_API_BASE : "",
-  GREPTILE_REMOTE: typeof RIG_BAKED_GREPTILE_REMOTE !== "undefined" ? RIG_BAKED_GREPTILE_REMOTE : "",
-  GREPTILE_REPOSITORY: typeof RIG_BAKED_GREPTILE_REPOSITORY !== "undefined" ? RIG_BAKED_GREPTILE_REPOSITORY : "",
-  GREPTILE_CONTEXT_BRANCH: typeof RIG_BAKED_GREPTILE_CONTEXT_BRANCH !== "undefined" ? RIG_BAKED_GREPTILE_CONTEXT_BRANCH : "",
-  GREPTILE_DEFAULT_BRANCH: typeof RIG_BAKED_GREPTILE_DEFAULT_BRANCH !== "undefined" ? RIG_BAKED_GREPTILE_DEFAULT_BRANCH : "",
-  GREPTILE_API_KEY: typeof RIG_BAKED_GREPTILE_API_KEY !== "undefined" ? RIG_BAKED_GREPTILE_API_KEY : "",
-  GREPTILE_GITHUB_TOKEN: typeof RIG_BAKED_GREPTILE_GITHUB_TOKEN !== "undefined" ? RIG_BAKED_GREPTILE_GITHUB_TOKEN : "",
-  GREPTILE_POLL_ATTEMPTS: typeof RIG_BAKED_GREPTILE_POLL_ATTEMPTS !== "undefined" ? RIG_BAKED_GREPTILE_POLL_ATTEMPTS : "",
-  GREPTILE_POLL_INTERVAL_MS: typeof RIG_BAKED_GREPTILE_POLL_INTERVAL_MS !== "undefined" ? RIG_BAKED_GREPTILE_POLL_INTERVAL_MS : "",
-  GH_TOKEN: typeof RIG_BAKED_GITHUB_TOKEN !== "undefined" ? RIG_BAKED_GITHUB_TOKEN : "",
-  GITHUB_TOKEN: typeof RIG_BAKED_GITHUB_TOKEN !== "undefined" ? RIG_BAKED_GITHUB_TOKEN : "",
-  GITHUB_SSH_KEY: typeof RIG_BAKED_GITHUB_SSH_KEY !== "undefined" ? RIG_BAKED_GITHUB_SSH_KEY : "",
-  AWS_ACCESS_KEY_ID: typeof RIG_BAKED_AWS_ACCESS_KEY_ID !== "undefined" ? RIG_BAKED_AWS_ACCESS_KEY_ID : "",
-  AWS_SECRET_ACCESS_KEY: typeof RIG_BAKED_AWS_SECRET_ACCESS_KEY !== "undefined" ? RIG_BAKED_AWS_SECRET_ACCESS_KEY : "",
-  AWS_REGION: typeof RIG_BAKED_AWS_REGION !== "undefined" ? RIG_BAKED_AWS_REGION : "",
-  LINEAR_API_KEY: typeof RIG_BAKED_LINEAR_API_KEY !== "undefined" ? RIG_BAKED_LINEAR_API_KEY : "",
-  LINEAR_WEBHOOK_SECRET: typeof RIG_BAKED_LINEAR_WEBHOOK_SECRET !== "undefined" ? RIG_BAKED_LINEAR_WEBHOOK_SECRET : ""
-};
-function resolveRuntimeSecrets(env, baked = BAKED_RUNTIME_SECRETS) {
+function resolveRuntimeConfigValues(env, keys, baked = {}) {
   const resolved = {};
-  const keys = new Set([
-    ...Object.keys(BAKED_RUNTIME_SECRETS),
-    ...Object.keys(baked)
-  ]);
-  for (const key of keys) {
+  const allKeys = new Set([...keys, ...Object.keys(baked)]);
+  for (const key of allKeys) {
     const envValue = env[key]?.trim();
     const bakedValue = baked[key]?.trim();
     if (envValue) {
@@ -43,11 +16,12 @@ function resolveRuntimeSecrets(env, baked = BAKED_RUNTIME_SECRETS) {
   }
   return resolved;
 }
-function loadDotEnvSecrets(projectRoot, env = process.env) {
+function loadDotEnvValues(projectRoot, keys, env = process.env) {
   const dotenvPath = resolve(projectRoot, ".env");
   if (!existsSync(dotenvPath)) {
     return {};
   }
+  const allowedKeys = new Set(keys);
   const parsed = {};
   const lines = readFileSync(dotenvPath, "utf-8").split(/\r?\n/);
   for (const rawLine of lines) {
@@ -59,8 +33,8 @@ function loadDotEnvSecrets(projectRoot, env = process.env) {
     if (!exportMatch) {
       continue;
     }
-    const key = exportMatch[1];
-    if (!(key in BAKED_RUNTIME_SECRETS)) {
+    const key = exportMatch[1] ?? "";
+    if (!allowedKeys.has(key)) {
       continue;
     }
     const value = expandShellValue(exportMatch[2] ?? "", { ...env, ...parsed });
@@ -70,36 +44,6 @@ function loadDotEnvSecrets(projectRoot, env = process.env) {
   }
   return parsed;
 }
-function secretDefinesFromEnv(env = process.env, projectRoot) {
-  const dotenvSecrets = projectRoot ? loadDotEnvSecrets(projectRoot, env) : {};
-  const resolved = resolveRuntimeSecrets(env, {
-    ...BAKED_RUNTIME_SECRETS,
-    ...dotenvSecrets
-  });
-  return {
-    RIG_BAKED_ANTHROPIC_API_KEY: resolved.ANTHROPIC_API_KEY || "",
-    RIG_BAKED_OPENAI_API_KEY: resolved.OPENAI_API_KEY || "",
-    RIG_BAKED_OPENROUTER_API_KEY: resolved.OPENROUTER_API_KEY || "",
-    RIG_BAKED_AI_REVIEW_MODE: resolved.AI_REVIEW_MODE || "",
-    RIG_BAKED_AI_REVIEW_PROVIDER: resolved.AI_REVIEW_PROVIDER || "",
-    RIG_BAKED_GREPTILE_API_BASE: resolved.GREPTILE_API_BASE || "",
-    RIG_BAKED_GREPTILE_REMOTE: resolved.GREPTILE_REMOTE || "",
-    RIG_BAKED_GREPTILE_REPOSITORY: resolved.GREPTILE_REPOSITORY || "",
-    RIG_BAKED_GREPTILE_CONTEXT_BRANCH: resolved.GREPTILE_CONTEXT_BRANCH || "",
-    RIG_BAKED_GREPTILE_DEFAULT_BRANCH: resolved.GREPTILE_DEFAULT_BRANCH || "",
-    RIG_BAKED_GREPTILE_API_KEY: resolved.GREPTILE_API_KEY || "",
-    RIG_BAKED_GREPTILE_GITHUB_TOKEN: resolved.GREPTILE_GITHUB_TOKEN || "",
-    RIG_BAKED_GREPTILE_POLL_ATTEMPTS: resolved.GREPTILE_POLL_ATTEMPTS || "",
-    RIG_BAKED_GREPTILE_POLL_INTERVAL_MS: resolved.GREPTILE_POLL_INTERVAL_MS || "",
-    RIG_BAKED_GITHUB_TOKEN: resolved.GITHUB_TOKEN || resolved.GH_TOKEN || "",
-    RIG_BAKED_GITHUB_SSH_KEY: resolved.GITHUB_SSH_KEY || "",
-    RIG_BAKED_AWS_ACCESS_KEY_ID: resolved.AWS_ACCESS_KEY_ID || "",
-    RIG_BAKED_AWS_SECRET_ACCESS_KEY: resolved.AWS_SECRET_ACCESS_KEY || "",
-    RIG_BAKED_AWS_REGION: resolved.AWS_REGION || "",
-    RIG_BAKED_LINEAR_API_KEY: resolved.LINEAR_API_KEY || "",
-    RIG_BAKED_LINEAR_WEBHOOK_SECRET: resolved.LINEAR_WEBHOOK_SECRET || ""
-  };
-}
 function expandShellValue(rawValue, env) {
   let value = rawValue.trim();
   if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
@@ -114,8 +58,6 @@ function expandShellValue(rawValue, env) {
   });
 }
 export {
-  secretDefinesFromEnv,
-  resolveRuntimeSecrets,
-  loadDotEnvSecrets,
-  BAKED_RUNTIME_SECRETS
+  resolveRuntimeConfigValues,
+  loadDotEnvValues
 };

package/dist/src/capability-loaders.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 };
         }
-        const projectPackagePath = resolveProjectPackageImport(args.path, configDir);
+        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 = 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 {

package/dist/src/declarative-config.js

@@ -57,8 +57,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();

package/dist/src/harness-paths.d.ts

@@ -1,18 +1,9 @@
 export declare function resolveHarnessPaths(projectRoot: string): {
     harnessRoot: string;
     stateDir: string;
-    artifactsDir: string;
     logsDir: string;
     binDir: string;
     hooksDir: string;
     validationDir: string;
-    taskConfigPath: string;
-    sessionPath: string;
     monorepoRoot: string;
-    tsApiTestsDir: string;
-    taskRepoCommitsPath: string;
-    baseRepoPinsPath: string;
-    failedApproachesPath: string;
-    agentProfilePath: string;
-    reviewProfilePath: string;
 };

package/dist/src/harness-paths.js

@@ -5,7 +5,6 @@ import { resolve as resolve3 } from "path";
 // packages/core/src/layout.ts
 import { resolve as resolve2 } from "path";
 import {
-  RIG_ARTIFACTS_DIRNAME,
   RIG_DEFINITION_DIRNAME,
   RIG_STATE_DIRNAME
 } from "@rig/contracts";
@@ -51,7 +50,6 @@ function resolveRuntimeWorkspaceLayout(workspaceDir) {
     rigRoot,
     stateDir,
     logsDir,
-    artifactsRoot: resolve2(root, RIG_ARTIFACTS_DIRNAME),
     runtimeDir,
     homeDir: resolve2(rigRoot, "home"),
     tmpDir: resolve2(rigRoot, "tmp"),
@@ -83,9 +81,7 @@ function resolveRigLayout(projectRoot) {
     definitionRoot,
     runtimeWorkspaceRoot,
     stateRoot: runtimeLayout.rigRoot,
-    artifactsRoot: runtimeLayout.artifactsRoot,
     configPath: resolve2(definitionRoot, "config.sh"),
-    taskConfigPath: resolve2(runtimeWorkspaceRoot, ".rig", "task-config.json"),
     policyDir,
     policyFile: resolve2(policyDir, "policy.json"),
     pluginsDir: resolve2(definitionRoot, "plugins"),
@@ -114,26 +110,15 @@ function resolveHarnessPaths(projectRoot) {
   const layout = hasRuntimeWorkspace ? resolveRigLayout(projectRoot) : null;
   const stateDir = layout?.stateDir ?? resolve3(stateRoot, "state");
   const logsDir = layout?.logsDir ?? resolve3(stateRoot, "logs");
-  const artifactsDir = layout?.artifactsRoot ?? resolve3(monorepoRoot, "artifacts");
-  const taskConfigPath = layout?.taskConfigPath ?? resolve3(monorepoRoot, ".rig", "task-config.json");
   const binDir = layout?.binDir ?? resolve3(stateRoot, "bin");
   return {
     harnessRoot,
     stateDir: process.env.RIG_STATE_DIR || stateDir,
-    artifactsDir,
     logsDir: process.env.RIG_LOGS_DIR || logsDir,
     binDir,
     hooksDir: resolve3(harnessRoot, "hooks"),
     validationDir: resolve3(harnessRoot, "validation"),
-    taskConfigPath,
-    sessionPath: process.env.RIG_SESSION_FILE || resolve3(stateRoot, "session", "session.json"),
-    monorepoRoot,
-    tsApiTestsDir: process.env.TS_API_TESTS_DIR || resolve3(monorepoRoot, "TSAPITests"),
-    taskRepoCommitsPath: resolve3(stateDir, "task-repo-commits.json"),
-    baseRepoPinsPath: resolve3(stateDir, "base-repo-pins.json"),
-    failedApproachesPath: resolve3(stateDir, "failed_approaches.md"),
-    agentProfilePath: resolve3(stateDir, "agent-profile.json"),
-    reviewProfilePath: resolve3(stateDir, "review-profile.json")
+    monorepoRoot
   };
 }
 export {

package/dist/src/hook-materializer.d.ts

@@ -1,72 +1,21 @@
-import type { HookEvent, HookRegistration } from "@rig/contracts";
-export interface PluginHookEntry {
-    /** The plugin that owns this hook. Used as the `_rigPlugin` marker. */
-    pluginName: string;
-    /** The plugin's hook registration. Either `command` must be set or the
-     *  entry must be marked `typed`; hooks with neither (pure metadata) are
-     *  skipped during materialization. */
-    hook: HookRegistration;
-    /** True when the plugin ships a typed implementation for this hook via
-     *  definePlugin runtime fields (`{ hooks: { [id]: fn } }`). The
-     *  materializer then writes a shim command that routes the invocation
-     *  through `control-plane/hook-runner.ts` instead of requiring a raw
-     *  `command` string. */
-    typed?: boolean;
-}
+import type { HookRegistration } from "@rig/contracts";
+export type { PluginHookEntry } from "@rig/contracts";
 /**
  * Resolve the path to the typed-hook runner entrypoint.
  *
- * Workspace/dev checkouts (and consumer projects with `@rig/runtime` in
+ * Workspace/dev checkouts (and consumer projects with `@rig/core` in
  * node_modules of THIS process) resolve the sibling source file directly.
- * When that file isn't on disk (e.g. running from a compiled binary whose
- * modules live under the virtual $bunfs root), fall back to the consumer
- * project's own node_modules via `$CLAUDE_PROJECT_DIR` — Claude Code expands
- * that variable when it runs the hook command.
+ * When that file isn't on disk (for example a compiled/virtualized runtime),
+ * fall back to the consumer project's own node_modules via
+ * `$CLAUDE_PROJECT_DIR`; Claude Code expands that variable when it runs the
+ * hook command.
  */
 export declare function resolveHookRunnerPath(): string;
 /**
  * Build the shell shim command for a typed hook. The command invokes the
- * hook-runner, which loads the project's rig config, finds the plugin's
- * typed implementation, and bridges stdin/stdout to the hook protocol.
+ * hook-runner, which loads the project's rig config, finds the plugin's typed
+ * implementation, and bridges stdin/stdout to the hook protocol.
  * `--event` is informational (the runner trusts the metadata registration);
  * `--plugin`/`--hook`/`--project-root` are the runner's actual inputs.
  */
 export declare function buildTypedHookShimCommand(pluginName: string, hook: HookRegistration, projectRoot: string): string;
-export type SessionHookAdapterResult = {
-    readonly adapterId: "claude-code";
-    readonly status: "materialized";
-    readonly path: string;
-    readonly events: readonly HookEvent[];
-} | {
-    readonly adapterId: "pi";
-    readonly status: "skipped";
-    readonly reason: string;
-};
-export interface AgentSessionHookAdapter {
-    readonly id: "claude-code" | "pi";
-    materialize(projectRoot: string, entries: readonly PluginHookEntry[]): SessionHookAdapterResult;
-}
-export declare function createPiNoopSessionHookAdapter(): AgentSessionHookAdapter;
-export declare function createClaudeCodeSessionHookAdapter(): AgentSessionHookAdapter;
-export type AgentSessionHookAdapterEnv = Record<string, string | undefined>;
-export declare function defaultAgentSessionHookAdapters(env?: AgentSessionHookAdapterEnv): readonly AgentSessionHookAdapter[];
-export declare function materializeSessionHookAdapters(projectRoot: string, entries: readonly PluginHookEntry[], adapters?: readonly AgentSessionHookAdapter[]): readonly SessionHookAdapterResult[];
-/**
- * Materialize plugin-contributed hooks into `.claude/settings.json` via the
- * Claude Code session-hook adapter.
- *
- * Removes any previously-materialized plugin entries (marked with
- * `_rigPlugin`) before re-inserting the current set. Operator-authored
- * entries (without the marker) are preserved untouched. The function is
- * idempotent — running it twice with the same input is a no-op.
- *
- * @returns the absolute path to the settings file that was written.
- */
-export declare function materializeHooks(projectRoot: string, entries: readonly PluginHookEntry[]): string;
-export type ApplyClaudeCodeSessionHooksOptions = {
-    readonly replacePluginOwned?: boolean;
-};
-export declare function applyClaudeCodeSessionHooksToSettings(existing: Record<string, unknown>, entries: readonly PluginHookEntry[], projectRoot: string, options?: ApplyClaudeCodeSessionHooksOptions): {
-    readonly settings: Record<string, unknown>;
-    readonly events: readonly HookEvent[];
-};