@h-rig/core 0.0.6-alpha.157 → 0.0.6-alpha.159

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

@@ -0,0 +1,31 @@
+import type { RegisteredTaskSource, RigConfig, TaskFieldExtension } from "@rig/contracts";
+import type { PluginHost } from "./plugin-host";
+import type { TaskSourceFactoryContext } from "./plugin-runtime";
+export interface TaskSourceRegistry {
+    register(s: RegisteredTaskSource): void;
+    resolveById(id: string): RegisteredTaskSource;
+    resolveByKind(kind: string): RegisteredTaskSource;
+    list(): readonly RegisteredTaskSource[];
+}
+export declare function createTaskSourceRegistry(): TaskSourceRegistry;
+/**
+ * Instantiate the task-source adapter selected by `config.taskSource.kind`
+ * from executable task-source factories contributed by loaded plugins.
+ *
+ * First-party adapters are not special-cased here: projects that use the
+ * standard GitHub Issues or files sources get those factories by loading
+ * `standard()` in `rig.config.ts`, exactly like any third-party adapter.
+ */
+export declare function buildTaskSourceRegistry(config: RigConfig, pluginHost?: PluginHost, context?: TaskSourceFactoryContext): TaskSourceRegistry;
+export interface TaskFieldRegistry {
+    get(id: string): TaskFieldExtension | undefined;
+    list(): readonly TaskFieldExtension[];
+    fieldNames(): readonly string[];
+    validateTaskFields(task: Record<string, unknown>): {
+        ok: true;
+    } | {
+        ok: false;
+        errors: string[];
+    };
+}
+export declare function createTaskFieldRegistry(extensions: readonly TaskFieldExtension[]): TaskFieldRegistry;

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

@@ -0,0 +1,79 @@
+// @bun
+// packages/core/src/plugin-host-registries.ts
+function createTaskSourceRegistry() {
+  const byId = new Map;
+  const order = [];
+  return {
+    register(s) {
+      if (byId.has(s.id))
+        throw new Error(`task source already registered: ${s.id}`);
+      byId.set(s.id, s);
+      order.push(s);
+    },
+    resolveById(id) {
+      const s = byId.get(id);
+      if (!s)
+        throw new Error(`task source not registered: ${id}`);
+      return s;
+    },
+    resolveByKind(kind) {
+      for (const s of order)
+        if (s.kind === kind)
+          return s;
+      throw new Error(`no task source registered for kind: ${kind}`);
+    },
+    list: () => order
+  };
+}
+function formatRegisteredKinds(pluginHost) {
+  const kinds = pluginHost ? pluginHost.listExecutableTaskSources().map((source) => source.kind) : [];
+  return kinds.length > 0 ? kinds.join(", ") : "none";
+}
+function buildTaskSourceRegistry(config, pluginHost, context) {
+  const registry = createTaskSourceRegistry();
+  const taskSourceConfig = config.taskSource;
+  const factory = pluginHost?.resolveTaskSourceFactoryByKind(taskSourceConfig.kind);
+  if (!factory) {
+    throw new Error(`No task source factory registered for kind "${taskSourceConfig.kind}". ` + `Registered kinds: ${formatRegisteredKinds(pluginHost)}. ` + "Load a plugin that contributes an executable task source factory for this kind.");
+  }
+  registry.register(factory.factory(taskSourceConfig, context ? { ...context, rigConfig: config } : undefined));
+  return registry;
+}
+function createTaskFieldRegistry(extensions) {
+  const byId = new Map;
+  for (const e of extensions) {
+    if (byId.has(e.id))
+      throw new Error(`task field extension already registered: ${e.id}`);
+    byId.set(e.id, e);
+  }
+  return {
+    get: (id) => byId.get(id),
+    list: () => Array.from(byId.values()),
+    fieldNames: () => Array.from(byId.values()).map((e) => e.fieldName),
+    validateTaskFields(task) {
+      const errors = [];
+      for (const ext of byId.values()) {
+        let schema;
+        try {
+          schema = JSON.parse(ext.schemaJson);
+        } catch {
+          errors.push(`task field "${ext.id}": schemaJson is not valid JSON`);
+          continue;
+        }
+        const isRequired = typeof schema === "object" && schema !== null && schema.required === true;
+        if (!isRequired)
+          continue;
+        const value = task[ext.fieldName];
+        if (value === undefined || value === null || value === "") {
+          errors.push(`task field "${ext.fieldName}" (from extension "${ext.id}") is required but missing`);
+        }
+      }
+      return errors.length === 0 ? { ok: true } : { ok: false, errors };
+    }
+  };
+}
+export {
+  createTaskSourceRegistry,
+  createTaskFieldRegistry,
+  buildTaskSourceRegistry
+};

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

@@ -1,5 +1,5 @@
 import type { AgentRoleRegistration, BlockerClassifierRegistration, CliCommandRegistration, HookRegistration, PanelRegistration, ProductCapabilityRegistration, RepoSourceRegistration, SkillRegistration, Stage, StageMutation, StageRun, TaskFieldExtension, TaskSourceRegistration, ValidatorRegistration } from "@rig/contracts";
-import type { BlockerClassifierEntry, CliCommand, FeatureCapability, Panel, RigPlugin, SessionExtensionEntry, TaskSource, Validator } from "./plugin-runtime";
+import type { BlockerClassifierEntry, CliCommand, FeatureCapability, Panel, RigPlugin, SessionExtensionEntry, SeedEntrypoint, TaskSource, Validator } from "./plugin-runtime";
 export interface PluginHost {
     getValidator(id: string): ValidatorRegistration | undefined;
     getHook(id: string): HookRegistration | undefined;
@@ -61,7 +61,12 @@ export interface PluginHost {
      * rather than injected directly by a leaf.
      */
     listSessionExtensions(): readonly SessionExtensionEntry[];
+    listSeedEntrypoints(): readonly SeedEntrypoint[];
+    resolveSeedEntrypointByBasename(basename: string): SeedEntrypoint | undefined;
+    resolveSeedEntrypointByWorkerArg(workerArg: string): SeedEntrypoint | undefined;
+    resolveInsidePtySeedEntrypoint(): SeedEntrypoint | undefined;
     resolveExecutableCliCommand(requested: string): CliCommand | undefined;
+    resolveDefaultRootCliCommand(): CliCommand | undefined;
     /**
      * Look up an executable task source factory by its `kind` (the value in
      * `config.taskSource.kind`). Returns undefined when no plugin provides

package/dist/src/plugin-host.js

@@ -35,6 +35,7 @@ function createPluginHost(plugins) {
   const panels = [];
   const blockerClassifiers = [];
   const sessionExtensions = [];
+  const seedEntrypoints = [];
   const stages = [];
   const stageMutations = [];
   const stageExecutors = {};
@@ -67,6 +68,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) {
@@ -89,6 +92,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) {
@@ -98,6 +102,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);
@@ -112,6 +148,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);
@@ -129,6 +166,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),
@@ -162,7 +208,12 @@ 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)
   };
 }

package/dist/src/plugin-runtime.d.ts

@@ -1,4 +1,4 @@
-import type { AgentRoleRegistration, BlockerClassifierRegistration, CapabilityReplacementSpec, CapabilityTag, CliCommandRegistration, HookImplementation, HookRegistration, PanelRegistration, ProductCapabilityRegistration, RegisteredTaskSource, RepoSourceRegistration, RigConfig, SessionExtensionRegistration, SkillRegistration, Stage, StageMutation, StageRun, TaskFieldExtension, TaskSourceConfig, TaskSourceRegistration, ValidatorRegistration } from "@rig/contracts";
+import type { AgentRoleRegistration, BlockerClassifierRegistration, CapabilityReplacementSpec, CapabilityTag, CliCommandRegistration, HookImplementation, HookRegistration, PanelRegistration, ProductCapabilityRegistration, RegisteredTaskSource, RepoSourceRegistration, RigConfig, SeedEntrypointRegistration, SessionExtensionRegistration, SkillRegistration, Stage, StageMutation, StageRun, TaskFieldExtension, TaskSourceConfig, TaskSourceRegistration, ValidatorRegistration } from "@rig/contracts";
 export interface ValidatorResult {
     id: string;
     passed: boolean;
@@ -41,11 +41,8 @@ export interface TaskSourceFactoryContext {
 export interface TaskSource extends TaskSourceRegistration {
     factory(config: TaskSourceConfig, context?: TaskSourceFactoryContext): RegisteredTaskSource;
 }
-export interface FeatureCapability extends ProductCapabilityRegistration {
-    run?: (input: unknown) => Promise<unknown> | unknown;
-}
+export type FeatureCapability = ProductCapabilityRegistration;
 /** @deprecated single-channel rename — use {@link FeatureCapability}. */
-export type RuntimeFeatureCapability = FeatureCapability;
 export interface Panel extends PanelRegistration {
     produce?: (context?: unknown) => Promise<unknown> | unknown;
 }
@@ -53,7 +50,6 @@ export interface BlockerClassifierEntry extends BlockerClassifierRegistration {
     classify(input: unknown): Promise<unknown> | unknown;
 }
 /** @deprecated single-channel rename — use {@link BlockerClassifierEntry}. */
-export type RuntimeBlockerClassifier = BlockerClassifierEntry;
 export interface RuntimeCliContext {
     projectRoot: string;
     outputMode?: string;
@@ -91,11 +87,51 @@ export type SessionExtensionInstall = (api: any) => void | Promise<void>;
 export interface SessionExtensionEntry extends SessionExtensionRegistration {
     install: SessionExtensionInstall;
 }
+export type SeedEntrypointRunResult = boolean | void | number;
+export interface SeedEntrypointContext {
+    argv: readonly string[];
+    execPath?: string;
+    basename?: string;
+    workerArg?: string;
+    parentPort?: unknown;
+}
+export interface SeedEntrypoint extends SeedEntrypointRegistration {
+    run(context: SeedEntrypointContext): Promise<SeedEntrypointRunResult> | SeedEntrypointRunResult;
+}
 /**
  * Single-channel contributions. Fn-bearing kinds carry their executable fn on
  * the same entry as their metadata; metadata-only kinds (skills, repoSources,
  * agentRoles, taskFieldSchemas, stageMutations) are pure registrations.
  */
+/** Context handed to a plugin when it default-fills its config fragment. */
+export interface ConfigDefaultsContext {
+    /** Absolute path to the project root being configured. */
+    readonly projectRoot: string;
+    /**
+     * Explicit `owner/repo` slug when a caller already knows it (the init wizard,
+     * a setup flow). When absent, a plugin that needs the repo identity derives it
+     * from its own domain (e.g. the github plugin reads the git remote). This is
+     * the single override seam so autocreate and the wizard share one composer.
+     */
+    readonly repoSlug?: string;
+}
+/**
+ * A plugin's contribution to the declarative `.rig/rigfig.toml`.
+ *
+ * Plugins are the things that ENRICH the config: each one owns the config
+ * properties IT needs and default-fills them with its OWN domain logic — the
+ * github plugin detects owner/repo from the git remote and fills the github
+ * task source + workspace id; the pr plugin fills `[pr]`; planning fills
+ * `[planning]`; and so on. The autocreate/init composer deep-merges every
+ * active plugin's fragment (in plugin order) into the written config. Returning
+ * null (or a plugin omitting `config`) contributes nothing.
+ *
+ * `defaults` is a fn — it rides on the authored RigPlugin and is ignored by the
+ * serializable manifest Schema, like every other executable contribution entry.
+ */
+export interface PluginConfigContribution {
+    defaults(context: ConfigDefaultsContext): Record<string, unknown> | null;
+}
 export interface PluginContributes {
     validators?: readonly Validator[];
     hooks?: readonly Hook[];
@@ -111,6 +147,9 @@ export interface PluginContributes {
     panels?: readonly Panel[];
     blockerClassifiers?: readonly BlockerClassifierEntry[];
     sessionExtensions?: readonly SessionExtensionEntry[];
+    seedEntrypoints?: readonly SeedEntrypoint[];
+    /** Declarative config defaults this plugin contributes to `.rig/rigfig.toml`. */
+    config?: PluginConfigContribution;
 }
 /**
  * The authored plugin object. Validated against the `RigPlugin` metadata schema

package/dist/src/profile-ops.d.ts

@@ -0,0 +1,9 @@
+export declare function showProfile(projectRoot: string, compact?: boolean): Promise<void>;
+export declare function setProfile(projectRoot: string, options: {
+    model?: string;
+    runtime?: string;
+    plugin?: string;
+    preset?: string;
+}): Promise<void>;
+export declare function showReviewProfile(projectRoot: string): Promise<void>;
+export declare function setReviewProfile(projectRoot: string, mode: string, provider?: string): Promise<void>;

package/dist/src/profile-ops.js

@@ -0,0 +1,252 @@
+// @bun
+// packages/core/src/profile-ops.ts
+import { existsSync as existsSync2, mkdirSync, writeFileSync } from "fs";
+
+// packages/core/src/harness-paths.ts
+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";
+
+// packages/core/src/checkout-root.ts
+import { dirname, resolve } from "path";
+import { existsSync } from "fs";
+function findNearestGitCheckoutRoot(startDir) {
+  let current = resolve(startDir);
+  for (;; ) {
+    if (existsSync(resolve(current, ".git")))
+      return current;
+    const parent = dirname(current);
+    if (parent === current)
+      return null;
+    current = parent;
+  }
+}
+function resolveCheckoutRoot(projectRoot) {
+  const normalizedProjectRoot = resolve(projectRoot);
+  const explicit = process.env.MONOREPO_ROOT?.trim();
+  if (explicit) {
+    const explicitRoot = resolve(explicit);
+    const gitRoot = findNearestGitCheckoutRoot(explicitRoot);
+    if (gitRoot)
+      return gitRoot;
+    throw new Error(`MONOREPO_ROOT points to ${explicitRoot}, but no git checkout was found there or above it.`);
+  }
+  return findNearestGitCheckoutRoot(normalizedProjectRoot) ?? normalizedProjectRoot;
+}
+
+// packages/core/src/layout.ts
+var resolveMonorepoRoot = resolveCheckoutRoot;
+function resolveRuntimeWorkspaceLayout(workspaceDir) {
+  const root = resolve2(workspaceDir);
+  const rigRoot = resolve2(root, ".rig");
+  const logsDir = resolve2(rigRoot, "logs");
+  const stateDir = resolve2(rigRoot, "state");
+  const runtimeDir = resolve2(rigRoot, "runtime");
+  const binDir = resolve2(rigRoot, "bin");
+  return {
+    workspaceDir: root,
+    rigRoot,
+    stateDir,
+    logsDir,
+    artifactsRoot: resolve2(root, RIG_ARTIFACTS_DIRNAME),
+    runtimeDir,
+    homeDir: resolve2(rigRoot, "home"),
+    tmpDir: resolve2(rigRoot, "tmp"),
+    cacheDir: resolve2(rigRoot, "cache"),
+    sessionDir: resolve2(rigRoot, "session"),
+    binDir,
+    distDir: resolve2(rigRoot, "dist"),
+    pluginBinDir: resolve2(binDir, "plugins"),
+    contextPath: resolve2(rigRoot, "runtime-context.json"),
+    controlPlaneEventsFile: resolve2(logsDir, "control-plane.events.jsonl")
+  };
+}
+function resolveActiveRuntimeWorkspaceRoot(_monorepoRoot) {
+  const explicit = process.env.RIG_TASK_WORKSPACE?.trim();
+  if (!explicit) {
+    throw new Error("No active runtime workspace. Set RIG_TASK_WORKSPACE or provision a task runtime first.");
+  }
+  return resolve2(explicit);
+}
+function resolveRigLayout(projectRoot) {
+  const monorepoRoot = resolveMonorepoRoot(projectRoot);
+  const definitionRoot = resolve2(projectRoot, RIG_DEFINITION_DIRNAME);
+  const runtimeWorkspaceRoot = resolveActiveRuntimeWorkspaceRoot(monorepoRoot);
+  const runtimeLayout = resolveRuntimeWorkspaceLayout(runtimeWorkspaceRoot);
+  const policyDir = resolve2(definitionRoot, "policy");
+  return {
+    projectRoot,
+    monorepoRoot,
+    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"),
+    hooksDir: resolve2(definitionRoot, "hooks"),
+    toolsDir: resolve2(definitionRoot, "tools"),
+    templatesDir: resolve2(definitionRoot, "templates"),
+    validationDir: resolve2(definitionRoot, "validation"),
+    stateDir: runtimeLayout.stateDir,
+    logsDir: runtimeLayout.logsDir,
+    notificationsDir: resolve2(definitionRoot, "notifications"),
+    runtimeDir: runtimeLayout.runtimeDir,
+    distDir: runtimeLayout.distDir,
+    binDir: runtimeLayout.binDir,
+    pluginBinDir: runtimeLayout.pluginBinDir,
+    keybindingsPath: resolve2(definitionRoot, "keybindings.json"),
+    controlPlaneEventsFile: runtimeLayout.controlPlaneEventsFile
+  };
+}
+
+// packages/core/src/harness-paths.ts
+function resolveHarnessPaths(projectRoot) {
+  const hasRuntimeWorkspace = Boolean(process.env.RIG_TASK_WORKSPACE?.trim());
+  const monorepoRoot = resolveCheckoutRoot(projectRoot);
+  const harnessRoot = resolve3(projectRoot, "rig");
+  const stateRoot = resolve3(projectRoot, ".rig");
+  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")
+  };
+}
+
+// packages/core/src/profile-ops.ts
+var DEFAULTS = {
+  model: "pi",
+  runtime: "pi",
+  plugin: "pi",
+  reviewMode: parseEnvOrDefault(process.env.AI_REVIEW_MODE, ["off", "advisory", "required"], "advisory"),
+  reviewProvider: parseEnvOrDefault(process.env.AI_REVIEW_PROVIDER, ["greptile", "github"], "github")
+};
+function parseEnvOrDefault(value, allowed, fallback) {
+  if (!value) {
+    return fallback;
+  }
+  return allowed.includes(value) ? value : fallback;
+}
+async function readProfileFile(path) {
+  if (!existsSync2(path)) {
+    return null;
+  }
+  try {
+    return await Bun.file(path).json();
+  } catch {
+    return null;
+  }
+}
+async function showProfile(projectRoot, compact = false) {
+  const paths = resolveHarnessPaths(projectRoot);
+  const profile = await loadProfile(paths.agentProfilePath);
+  if (compact) {
+    console.log(`model=${profile.model} runtime=${profile.runtime} plugin=${profile.agent_plugin}`);
+    return;
+  }
+  console.log("Execution Profile:");
+  console.log(`  model:        ${profile.model}`);
+  console.log(`  runtime:      ${profile.runtime}`);
+  console.log(`  plugin:       ${profile.agent_plugin}`);
+}
+async function setProfile(projectRoot, options) {
+  const invalid = [options.model, options.runtime, options.plugin, options.preset].filter((value) => typeof value === "string" && value.trim().length > 0 && value.trim() !== "pi");
+  if (invalid.length > 0) {
+    throw new Error("Only the Pi runtime profile is supported by this Rig substrate.");
+  }
+  const paths = resolveHarnessPaths(projectRoot);
+  mkdirSync(paths.stateDir, { recursive: true });
+  const next = {
+    model: "pi",
+    runtime: "pi",
+    agent_plugin: "pi",
+    updated_at: new Date().toISOString()
+  };
+  writeFileSync(paths.agentProfilePath, `${JSON.stringify(next, null, 2)}
+`, "utf-8");
+  await showProfile(projectRoot, false);
+}
+async function showReviewProfile(projectRoot) {
+  const paths = resolveHarnessPaths(projectRoot);
+  const profile = await loadReviewProfile(paths.reviewProfilePath);
+  console.log("AI Review Profile:");
+  console.log(`  mode:      ${profile.mode}`);
+  console.log(`  provider:  ${profile.provider}`);
+  console.log(`  file:      ${paths.reviewProfilePath}`);
+}
+async function setReviewProfile(projectRoot, mode, provider) {
+  if (mode !== "off" && mode !== "advisory" && mode !== "required") {
+    throw new Error(`Invalid mode: ${mode}. Use off|advisory|required.`);
+  }
+  const resolvedProvider = provider || DEFAULTS.reviewProvider;
+  if (resolvedProvider !== "greptile" && resolvedProvider !== "github") {
+    throw new Error(`Invalid provider: ${resolvedProvider}. Supported: github|greptile.`);
+  }
+  const paths = resolveHarnessPaths(projectRoot);
+  mkdirSync(paths.stateDir, { recursive: true });
+  const next = {
+    mode,
+    provider: resolvedProvider,
+    updated_at: new Date().toISOString()
+  };
+  writeFileSync(paths.reviewProfilePath, `${JSON.stringify(next, null, 2)}
+`, "utf-8");
+  await showReviewProfile(projectRoot);
+}
+async function loadProfile(path) {
+  const parsed = await readProfileFile(path);
+  return {
+    model: "pi",
+    runtime: "pi",
+    agent_plugin: "pi",
+    updated_at: parsed?.updated_at || new Date().toISOString()
+  };
+}
+async function loadReviewProfile(path) {
+  const parsed = await readProfileFile(path);
+  if (parsed) {
+    return {
+      mode: parsed.mode || DEFAULTS.reviewMode,
+      provider: parsed.provider || DEFAULTS.reviewProvider,
+      updated_at: parsed.updated_at || new Date().toISOString()
+    };
+  }
+  return {
+    mode: DEFAULTS.reviewMode,
+    provider: DEFAULTS.reviewProvider,
+    updated_at: new Date().toISOString()
+  };
+}
+export {
+  showReviewProfile,
+  showProfile,
+  setReviewProfile,
+  setProfile
+};

package/dist/src/project-plugins.d.ts

@@ -9,19 +9,11 @@ export type ProjectConfigPresence = {
     readonly status: "missing";
     readonly path: null;
 };
-export type ProjectPluginResolutionWarningCode = never;
-export type ProjectPluginResolutionWarning = {
-    readonly code: ProjectPluginResolutionWarningCode;
-    readonly level: "warning" | "info";
-    readonly message: string;
-};
 export type ProjectPluginResolution = {
     readonly mode: ProjectPluginResolutionMode;
     readonly projectRoot: string;
-    readonly surfaceName: string;
     readonly configPresence: ProjectConfigPresence;
     readonly config: RigConfig | null;
-    readonly warnings: readonly ProjectPluginResolutionWarning[];
     readonly plugins: readonly RigPlugin[];
 };
 export type ProjectPluginHostResult = {
@@ -31,15 +23,12 @@ export type ProjectPluginHostResult = {
 export type LoadProjectConfig = (projectRoot: string) => Promise<RigConfig>;
 export type LoadProjectPluginSetOptions = {
     readonly mode?: ProjectPluginResolutionMode;
-    readonly surfaceName?: string;
     readonly load?: LoadProjectConfig;
 };
-export type ProjectPluginResolutionOptions = Omit<LoadProjectPluginSetOptions, "mode" | "surfaceName"> & {
+export type ProjectPluginResolutionOptions = Omit<LoadProjectPluginSetOptions, "mode"> & {
     readonly projectRoot: string;
     readonly mode: ProjectPluginResolutionMode;
-    readonly surfaceName: string;
 };
-export declare function projectPluginResolutionWarningMessages(resolved: Pick<ProjectPluginResolution, "warnings">): readonly string[];
 export declare function loadProjectPluginSet(options: ProjectPluginResolutionOptions): Promise<ProjectPluginResolution>;
 export declare function loadProjectPluginSet(projectRoot: string, options?: LoadProjectPluginSetOptions): Promise<ProjectPluginResolution>;
 export type ResolvedPluginHost = {
@@ -62,5 +51,13 @@ export type ResolvePluginHostOptions = {
  * cannot poison the canonical on-disk host other consumers read.
  */
 export declare function resolvePluginHost(projectRoot: string, options?: ResolvePluginHostOptions): Promise<ResolvedPluginHost>;
+/**
+ * Resolve the plugin host for a project root, returning the host plus the full
+ * resolution shape. This delegates to the single cached `resolvePluginHost`
+ * memo so every consumer in a process SHARES one resolved host for a root
+ * instead of re-evaluating rig.config.ts and constructing an independent host
+ * (architecture-reference §18: one resolved host per process/root). Graceful
+ * missing-config degradation and the custom-`load` bypass are preserved.
+ */
 export declare function createProjectPluginHost(options: ProjectPluginResolutionOptions): Promise<ProjectPluginHostResult>;
 export declare function createProjectPluginHost(projectRoot: string, options?: LoadProjectPluginSetOptions): Promise<ProjectPluginHostResult>;