@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-32IYXIE5.js

@@ -0,0 +1,873 @@
+import {
+  DEFAULT_REVIEW_POLICY,
+  parseReviewPolicy,
+  reviewPolicyFromLegacy
+} from "./chunk-7RMARDVH.js";
+import {
+  resolveRoleSlotModel,
+  retiredModelRoleReplacement
+} from "./chunk-HXIIEMGF.js";
+import {
+  loadBuildConfigFile,
+  loadProviderRegistryForCwd,
+  resolveDefaultProvider,
+  resolveProviderModel,
+  resolveProviderReasoningEffort
+} from "./chunk-C3DH3NCY.js";
+import {
+  loadActiveProfileStrict
+} from "./chunk-M4BUEXXF.js";
+import {
+  isFamilyAlias
+} from "./chunk-FAZBRHGG.js";
+import {
+  RolesConfigSchema,
+  selectedBuildConfigCandidate
+} from "./chunk-FKCG7K6H.js";
+import {
+  ProviderRegistry
+} from "./chunk-QJ6OEH4K.js";
+import {
+  getConfigPaths,
+  projectConfigAliasesUserConfig
+} from "./chunk-35J4NE6S.js";
+
+// src/core/config/execution-roles.ts
+var EXECUTION_ROLE_NAMES = ["orchestrator", "executor", "reviewer"];
+var DEFAULT_REVIEWER_THRESHOLD = "high";
+var DEFAULT_EXECUTOR_SUBAGENTS = "off";
+var DEFAULT_EXECUTOR_TRANSPORT = "auto";
+function attachOrchestratorModelFallback(role, fallbackModelRole, registry, cwd) {
+  if (!fallbackModelRole || !role.provider) return role;
+  if (roleSourceRank(role.provider.source) < roleSourceRank(fallbackModelRole.source)) {
+    return role;
+  }
+  const fallbackModel = resolveRoleSlotModel(role.provider.value, fallbackModelRole, {
+    cwd,
+    registry,
+    configPath: "roles.orchestrator.fallbackModelRole"
+  });
+  if (!fallbackModel) {
+    throw new Error(
+      `roles.orchestrator.fallbackModelRole '${fallbackModelRole.value}' has no model mapping for provider '${role.provider.value}'`
+    );
+  }
+  if (!role.model) {
+    throw new Error(
+      "roles.orchestrator.fallbackModelRole requires the primary model/modelRole to resolve"
+    );
+  }
+  const canonicalize = (model) => {
+    try {
+      return ProviderRegistry.resolveModel(role.provider.value, model, registry).toLowerCase();
+    } catch {
+      return model.trim().toLowerCase();
+    }
+  };
+  if (canonicalize(role.model.value) === canonicalize(fallbackModel.value)) {
+    if (retiredModelRoleReplacement(fallbackModelRole.value)) return role;
+    throw new Error(
+      `roles.orchestrator fallback resolves to the primary model '${fallbackModel.value}'; configure a distinct fallbackModelRole`
+    );
+  }
+  const { role: _role, ...fallback } = fallbackModel;
+  return { ...role, fallbackModelRole, fallbackModel: fallback };
+}
+function buildReviewAssurance(sameAsExecutor) {
+  return {
+    executorSeparation: sameAsExecutor ? "same-as-executor" : "separated",
+    invocationSeparation: "required-fresh-readonly",
+    invocationSeparationVerified: false
+  };
+}
+function collectRolesLayers(cwd) {
+  const paths = getConfigPaths(cwd);
+  const layers = [];
+  const activeProfile = loadActiveProfileStrict();
+  if (activeProfile?.roles) {
+    const parsedRoles = RolesConfigSchema.safeParse(activeProfile.roles);
+    if (!parsedRoles.success) {
+      const issues = parsedRoles.error.issues.map((issue) => `${issue.path.join(".") || "roles"}: ${issue.message}`).join("; ");
+      throw new Error(`Invalid roles in active profile "${activeProfile.name}": ${issues}`);
+    }
+    layers.push({
+      roles: parsedRoles.data,
+      source: "profile",
+      sourcePath: `profile:${activeProfile.name}#roles`
+    });
+  }
+  const projectPath = selectedBuildConfigCandidate(paths.projectConfigFile);
+  const projectConfig = projectConfigAliasesUserConfig(cwd) ? null : loadBuildConfigFile(projectPath);
+  if (projectConfig?.roles) {
+    layers.push({
+      roles: projectConfig.roles,
+      source: "project",
+      sourcePath: `${projectPath}#roles`
+    });
+  }
+  const userPath = selectedBuildConfigCandidate(paths.userConfigFile);
+  const userConfig = loadBuildConfigFile(userPath);
+  if (userConfig?.roles) {
+    layers.push({
+      roles: userConfig.roles,
+      source: "user-config",
+      sourcePath: `${userPath}#roles`
+    });
+  }
+  return layers;
+}
+function reviewPolicyLayers(layers) {
+  const rank = (source) => {
+    if (source === "project") return 0;
+    if (source === "profile") return 1;
+    if (source === "user-config") return 2;
+    return 3;
+  };
+  return [...layers].sort((left, right) => rank(left.source) - rank(right.source));
+}
+function resolveAtomicReviewPolicy(layers, cli) {
+  if (cli?.reviewPolicy) {
+    return {
+      value: cli.reviewPolicy,
+      source: "cli",
+      sourcePath: "cli:--review"
+    };
+  }
+  if (cli?.reviewerGate) {
+    return {
+      value: reviewPolicyFromLegacy(cli.reviewerGate, DEFAULT_REVIEWER_THRESHOLD),
+      source: "cli",
+      sourcePath: "cli:--reviewer-gate"
+    };
+  }
+  for (const layer of reviewPolicyLayers(layers)) {
+    const reviewer = layer.roles ? reviewerOf(layer.roles) : void 0;
+    if (!reviewer) continue;
+    if (reviewer.policy) {
+      return {
+        value: reviewer.policy,
+        source: layer.source,
+        sourcePath: `${layer.sourcePath}.reviewer.policy`
+      };
+    }
+    if (reviewer.gate) {
+      return {
+        value: reviewPolicyFromLegacy(
+          reviewer.gate,
+          reviewer.threshold ?? DEFAULT_REVIEWER_THRESHOLD
+        ),
+        source: layer.source,
+        sourcePath: `${layer.sourcePath}.reviewer.gate`
+      };
+    }
+  }
+  return { value: DEFAULT_REVIEW_POLICY, source: "fallback" };
+}
+function resolveLegacyThresholdMigrationNotice(layers) {
+  const ordered = reviewPolicyLayers(layers);
+  const policyOwnerIndex = ordered.findIndex((layer) => {
+    const reviewer = layer.roles ? reviewerOf(layer.roles) : void 0;
+    return Boolean(reviewer?.policy || reviewer?.gate);
+  });
+  if (policyOwnerIndex === 0) return void 0;
+  const searchEnd = policyOwnerIndex === -1 ? ordered.length : policyOwnerIndex;
+  const ignored = ordered.slice(0, searchEnd).find((layer) => {
+    const reviewer = layer.roles ? reviewerOf(layer.roles) : void 0;
+    return Boolean(reviewer?.threshold && !reviewer.policy && !reviewer.gate);
+  });
+  if (!ignored) return void 0;
+  return `Ignoring legacy roles.reviewer.threshold from ${ignored.sourcePath}; review policy is atomic. Set roles.reviewer.policy in that layer, for example repair:medium.`;
+}
+function pickFromLayers(layers, pick, field, key) {
+  for (const layer of layers) {
+    if (!layer.roles) continue;
+    const value = pick(layer.roles);
+    if (value !== void 0) {
+      return {
+        value,
+        source: layer.source,
+        sourcePath: `${layer.sourcePath}.${field}.${key}`
+      };
+    }
+  }
+  return void 0;
+}
+function orchestratorOf(roles) {
+  return roles.orchestrator;
+}
+function executorOf(roles) {
+  return roles.executor;
+}
+function reviewerOf(roles) {
+  return roles.reviewer;
+}
+function exactModelOwners(model, registry) {
+  const needle = model.trim();
+  if (!needle) return [];
+  return Object.values(registry.providers).filter((provider) => {
+    if (!provider.enabled) return false;
+    const exactClaims = /* @__PURE__ */ new Set([
+      provider.models.default,
+      ...provider.models.available.map((entry) => entry.id),
+      ...Object.keys(provider.models.mappings),
+      ...Object.values(provider.models.mappings),
+      ...Object.values(provider.models.roles ?? {})
+    ]);
+    return exactClaims.has(needle) || isFamilyAlias(provider.id, needle, registry);
+  }).map((provider) => provider.id);
+}
+var ROLE_SOURCE_RANK = {
+  cli: 0,
+  env: 1,
+  "env-legacy": 1,
+  runtime: 2,
+  profile: 3,
+  project: 4,
+  "user-config": 5,
+  registry: 6,
+  fallback: 7
+};
+function roleSourceRank(source) {
+  return ROLE_SOURCE_RANK[source] ?? 99;
+}
+function inferProviderFromModelOwnership(role, explicitModel, registry, displacedProvider) {
+  const owners = exactModelOwners(explicitModel.value, registry);
+  if (owners.length !== 1) {
+    const reason = owners.length === 0 ? "is not an exact model, alias, default, or role entry for any enabled provider" : `is claimed by multiple enabled providers (${owners.join(", ")})`;
+    const suffix = displacedProvider ? ` and cannot override the lower-precedence provider "${displacedProvider}"; specify a provider explicitly.` : "; specify a provider explicitly.";
+    throw new Error(`Explicit ${role} model "${explicitModel.value}" ${reason}${suffix}`);
+  }
+  const owner = owners[0];
+  return {
+    value: owner,
+    // When the model DISPLACED a lower-precedence provider, the effective
+    // provider inherits the model's precedence (so downstream layering — e.g.
+    // dropping a stale lower-layer fallbackModelRole — sees it correctly). When
+    // no provider was configured at all, the provider is a pure registry
+    // derivation of the model's ownership.
+    source: displacedProvider ? explicitModel.source : "registry",
+    sourcePath: displacedProvider ? `providers.yaml#providers.${owner}.models (exact ownership of ${explicitModel.sourcePath ?? explicitModel.source}; overrides lower-precedence provider "${displacedProvider}")` : `providers.yaml#providers.${owner}.models (exact ownership of ${explicitModel.sourcePath ?? explicitModel.source})`
+  };
+}
+function bindExplicitModelProvider(params) {
+  const { role, explicitModel, provider, registry } = params;
+  if (!explicitModel) return { provider, explicitModel: void 0 };
+  if (!explicitModel.value.trim() || explicitModel.value.trim() !== explicitModel.value) {
+    throw new Error(
+      `Explicit ${role} model must be a non-empty model identifier without surrounding whitespace.`
+    );
+  }
+  if (!provider) {
+    return {
+      provider: inferProviderFromModelOwnership(role, explicitModel, registry),
+      explicitModel
+    };
+  }
+  try {
+    ProviderRegistry.resolveModel(provider.value, explicitModel.value, registry);
+    return { provider, explicitModel };
+  } catch (error) {
+    const providerRank = roleSourceRank(provider.source);
+    const modelRank = roleSourceRank(explicitModel.source);
+    if (providerRank < modelRank) {
+      return { provider, explicitModel: void 0 };
+    }
+    if (modelRank < providerRank) {
+      return {
+        provider: inferProviderFromModelOwnership(role, explicitModel, registry, provider.value),
+        explicitModel
+      };
+    }
+    throw new Error(
+      `Explicit ${role} model "${explicitModel.value}" is not valid for provider "${provider.value}": ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function resolveRoleModel(params) {
+  const { field, provider, explicitModel, modelRole, cwd, registry } = params;
+  if (explicitModel) {
+    return { model: explicitModel };
+  }
+  if (!modelRole) {
+    return { model: resolveProviderModel(provider, void 0, cwd) };
+  }
+  const roleModel = resolveRoleSlotModel(provider, modelRole, {
+    cwd,
+    registry,
+    configPath: `roles.${field}.modelRole`,
+    modelKey: `roles.${field}.model`
+  });
+  if (roleModel) {
+    const { role, ...model } = roleModel;
+    return { model, modelRole, fastSlot: role === "fast" };
+  }
+  return {
+    model: resolveProviderModel(provider, void 0, cwd),
+    modelRole
+  };
+}
+function resolveReasoningEffortField(layers, cliValue, field, cliPath, pick) {
+  if (cliValue !== void 0) {
+    return { value: cliValue, source: "cli", sourcePath: cliPath };
+  }
+  return pickFromLayers(layers, pick, field, "reasoningEffort");
+}
+function resolveOrchestratorRole(layers, cli, cwd, effective, registry) {
+  let provider;
+  if (cli?.orchestratorProvider) {
+    provider = {
+      value: cli.orchestratorProvider,
+      source: "cli",
+      sourcePath: "cli:--orchestrator-provider"
+    };
+  } else if (effective?.provider) {
+    provider = {
+      value: effective.provider,
+      source: "runtime",
+      sourcePath: effective.sourcePath
+    };
+  } else {
+    provider = pickFromLayers(
+      layers,
+      (r) => orchestratorOf(r)?.provider,
+      "orchestrator",
+      "provider"
+    );
+  }
+  const explicitModel = cli?.orchestratorModel ? {
+    value: cli.orchestratorModel,
+    source: "cli",
+    sourcePath: "cli:--orchestrator-model"
+  } : effective?.model ? {
+    value: effective.model,
+    source: "runtime",
+    sourcePath: effective.sourcePath
+  } : pickFromLayers(layers, (r) => orchestratorOf(r)?.model, "orchestrator", "model");
+  const modelRole = cli?.orchestratorModelRole ? {
+    value: cli.orchestratorModelRole,
+    source: "cli",
+    sourcePath: "cli:--orchestrator-model-role"
+  } : pickFromLayers(layers, (r) => orchestratorOf(r)?.modelRole, "orchestrator", "modelRole");
+  const fallbackModelRole = pickFromLayers(
+    layers,
+    (r) => orchestratorOf(r)?.fallbackModelRole,
+    "orchestrator",
+    "fallbackModelRole"
+  );
+  const reasoningEffort = resolveReasoningEffortField(
+    layers,
+    cli?.orchestratorReasoningEffort,
+    "orchestrator",
+    "cli:--orchestrator-reasoning-effort",
+    (r) => orchestratorOf(r)?.reasoningEffort
+  );
+  const orchestratorBinding = bindExplicitModelProvider({
+    role: "orchestrator",
+    explicitModel,
+    provider,
+    registry
+  });
+  provider = orchestratorBinding.provider;
+  const boundModel = orchestratorBinding.explicitModel;
+  if (!provider) {
+    return {
+      ...reasoningEffort ? { reasoningEffort } : {}
+    };
+  }
+  if (boundModel) {
+    return attachOrchestratorModelFallback(
+      {
+        provider,
+        model: boundModel,
+        ...reasoningEffort ? { reasoningEffort } : {}
+      },
+      fallbackModelRole,
+      registry,
+      cwd
+    );
+  }
+  if (modelRole) {
+    const roleModel = resolveRoleSlotModel(provider.value, modelRole, {
+      cwd,
+      registry,
+      configPath: "roles.orchestrator.modelRole",
+      modelKey: "roles.orchestrator.model"
+    });
+    if (roleModel) {
+      const { role: _role, ...model } = roleModel;
+      return attachOrchestratorModelFallback(
+        {
+          provider,
+          model,
+          modelRole,
+          ...reasoningEffort ? { reasoningEffort } : {}
+        },
+        fallbackModelRole,
+        registry,
+        cwd
+      );
+    }
+    return attachOrchestratorModelFallback(
+      {
+        provider,
+        modelRole,
+        ...reasoningEffort ? { reasoningEffort } : {}
+      },
+      fallbackModelRole,
+      registry,
+      cwd
+    );
+  }
+  return attachOrchestratorModelFallback(
+    {
+      provider,
+      model: resolveProviderModel(provider.value, void 0, cwd),
+      ...reasoningEffort ? { reasoningEffort } : {}
+    },
+    fallbackModelRole,
+    registry,
+    cwd
+  );
+}
+function resolveExecutorRole(layers, cli, cwd, registry) {
+  const explicitModel = cli?.executorModel ? { value: cli.executorModel, source: "cli", sourcePath: "cli:--executor-model" } : pickFromLayers(layers, (r) => executorOf(r)?.model, "executor", "model");
+  let configuredProvider;
+  if (cli?.executorProvider) {
+    configuredProvider = {
+      value: cli.executorProvider,
+      source: "cli",
+      sourcePath: "cli:--executor-provider"
+    };
+  } else {
+    configuredProvider = pickFromLayers(
+      layers,
+      (r) => executorOf(r)?.provider,
+      "executor",
+      "provider"
+    );
+  }
+  const executorBinding = bindExplicitModelProvider({
+    role: "executor",
+    explicitModel,
+    provider: configuredProvider,
+    registry
+  });
+  const provider = executorBinding.provider ?? resolveDefaultProvider(void 0, cwd);
+  const boundModel = executorBinding.explicitModel;
+  const modelRole = cli?.executorModelRole ? { value: cli.executorModelRole, source: "cli", sourcePath: "cli:--executor-model-role" } : pickFromLayers(layers, (r) => executorOf(r)?.modelRole, "executor", "modelRole");
+  const {
+    model,
+    modelRole: usedModelRole,
+    fastSlot
+  } = resolveRoleModel({
+    field: "executor",
+    provider: provider.value,
+    explicitModel: boundModel,
+    modelRole,
+    cwd,
+    registry
+  });
+  const subagents = cli?.executorSubagents !== void 0 ? { value: cli.executorSubagents, source: "cli", sourcePath: "cli:--executor-subagents" } : pickFromLayers(layers, (r) => executorOf(r)?.subagents, "executor", "subagents") ?? {
+    value: DEFAULT_EXECUTOR_SUBAGENTS,
+    source: "fallback"
+  };
+  const transport = cli?.executorTransport ? { value: cli.executorTransport, source: "cli", sourcePath: "cli:--executor-transport" } : pickFromLayers(layers, (r) => executorOf(r)?.transport, "executor", "transport") ?? {
+    value: DEFAULT_EXECUTOR_TRANSPORT,
+    source: "fallback"
+  };
+  const reasoningEffort = resolveReasoningEffortField(
+    layers,
+    cli?.executorReasoningEffort,
+    "executor",
+    "cli:--executor-reasoning-effort",
+    (r) => executorOf(r)?.reasoningEffort
+  ) ?? // A fast model runs at its own default effort; the provider-wide effort is not its.
+  (fastSlot ? void 0 : resolveProviderReasoningEffort(provider.value, void 0, cwd));
+  return {
+    provider,
+    model,
+    modelRole: usedModelRole,
+    subagents,
+    transport,
+    ...reasoningEffort ? { reasoningEffort } : {}
+  };
+}
+function providerInExecutorExcludes(providerId, excludes) {
+  const key = providerId.trim().toLowerCase();
+  if (!key) return false;
+  return excludes.some((id) => id.trim().toLowerCase() === key);
+}
+function resolveReviewerRole(layers, cli, cwd, executorProvider, additionalExecutorExcludes, registry, eligibility) {
+  const policy = resolveAtomicReviewPolicy(layers, cli);
+  const policyNotice = resolveLegacyThresholdMigrationNotice(layers);
+  const parsedPolicy = parseReviewPolicy(policy.value);
+  if (!parsedPolicy) {
+    throw new Error(`Invalid resolved review policy '${String(policy.value)}'`);
+  }
+  const gateValue = parsedPolicy.action === "off" ? "off" : parsedPolicy.action === "advisory" ? "advisory" : "high-severity-blocks";
+  const thresholdValue = parsedPolicy.level ?? DEFAULT_REVIEWER_THRESHOLD;
+  const gate = {
+    value: gateValue,
+    source: policy.source,
+    ...policy.sourcePath ? { sourcePath: policy.sourcePath } : {}
+  };
+  const threshold = {
+    value: thresholdValue,
+    source: policy.source,
+    ...policy.sourcePath ? { sourcePath: policy.sourcePath } : {}
+  };
+  let explicitModel = cli?.reviewerModel ? { value: cli.reviewerModel, source: "cli", sourcePath: "cli:--reviewer-model" } : pickFromLayers(layers, (r) => reviewerOf(r)?.model, "reviewer", "model");
+  let explicitProvider = cli?.reviewerProvider ? {
+    value: cli.reviewerProvider,
+    source: "cli",
+    sourcePath: "cli:--reviewer-provider"
+  } : pickFromLayers(layers, (r) => reviewerOf(r)?.provider, "reviewer", "provider");
+  const reviewerBinding = bindExplicitModelProvider({
+    role: "reviewer",
+    explicitModel,
+    provider: explicitProvider,
+    registry
+  });
+  explicitProvider = reviewerBinding.provider;
+  explicitModel = reviewerBinding.explicitModel;
+  const explicitModelRole = cli?.reviewerModelRole ? {
+    value: cli.reviewerModelRole,
+    source: "cli",
+    sourcePath: "cli:--reviewer-model-role"
+  } : pickFromLayers(layers, (r) => reviewerOf(r)?.modelRole, "reviewer", "modelRole");
+  const providerPreference = cli?.reviewerProviderPreference ? {
+    value: cli.reviewerProviderPreference,
+    source: "cli",
+    sourcePath: "cli:--reviewer-provider-preference"
+  } : pickFromLayers(
+    layers,
+    (r) => reviewerOf(r)?.providerPreference,
+    "reviewer",
+    "providerPreference"
+  );
+  const reasoningEffort = resolveReasoningEffortField(
+    layers,
+    cli?.reviewerReasoningEffort,
+    "reviewer",
+    "cli:--reviewer-reasoning-effort",
+    (r) => reviewerOf(r)?.reasoningEffort
+  );
+  const preferenceAttachment = providerPreference ? { providerPreference } : {};
+  const effortAttachment = reasoningEffort ? { reasoningEffort } : {};
+  const reviewerExcludes = dedupeProviderIds([executorProvider, ...additionalExecutorExcludes]);
+  if (explicitProvider) {
+    const { model: model2, modelRole: usedModelRole2 } = resolveRoleModel({
+      field: "reviewer",
+      provider: explicitProvider.value,
+      explicitModel,
+      modelRole: explicitModelRole,
+      cwd,
+      registry
+    });
+    const sameAsExecutor = providerInExecutorExcludes(explicitProvider.value, reviewerExcludes);
+    return {
+      reviewer: {
+        provider: explicitProvider,
+        bindingSource: "explicit",
+        model: model2,
+        modelRole: usedModelRole2,
+        policy,
+        ...policyNotice ? { policyNotice } : {},
+        gate,
+        threshold,
+        ...preferenceAttachment,
+        ...effortAttachment
+      },
+      sameAsExecutor,
+      reviewerExcludes
+    };
+  }
+  let picked = void 0;
+  const crossProvider = ProviderRegistry.resolveReviewerModel(
+    reviewerExcludes,
+    {
+      roleChain: explicitModelRole ? [explicitModelRole.value] : [],
+      providerPreference: providerPreference?.value,
+      eligibleProviders: eligibility.eligibleReviewerProviders,
+      preferenceProviders: eligibility.installedReviewerProviders,
+      roleModel: (p, role) => {
+        const configured = role === explicitModelRole?.value ? explicitModelRole : void 0;
+        picked = resolveRoleSlotModel(
+          p,
+          configured ?? {
+            value: role,
+            source: "registry",
+            sourcePath: "cross-provider reviewer rule"
+          },
+          configured ? {
+            cwd,
+            registry,
+            configPath: "roles.reviewer.modelRole",
+            modelKey: "roles.reviewer.model"
+          } : { cwd, registry }
+        );
+        return picked?.value;
+      }
+    },
+    registry
+  );
+  if (crossProvider && picked) {
+    const selectedFromPreference = providerPreference?.value.some(
+      (provider) => provider.trim().toLowerCase() === crossProvider.provider.toLowerCase()
+    ) ?? false;
+    const { role: _role, ...pickedModel } = picked;
+    return {
+      reviewer: {
+        bindingSource: "automatic-independent",
+        provider: {
+          value: crossProvider.provider,
+          source: selectedFromPreference && providerPreference ? providerPreference.source : "registry",
+          sourcePath: selectedFromPreference && providerPreference ? providerPreference.sourcePath : `providers.yaml#providers.${crossProvider.provider}.models.roles (cross-provider reviewer rule)`
+        },
+        model: explicitModel ?? pickedModel,
+        modelRole: explicitModelRole,
+        policy,
+        ...policyNotice ? { policyNotice } : {},
+        gate,
+        threshold,
+        ...preferenceAttachment,
+        ...effortAttachment
+      },
+      // Cross-provider rule excludes executor providers, so selection is separated.
+      sameAsExecutor: false,
+      reviewerExcludes
+    };
+  }
+  const { model, modelRole: usedModelRole } = resolveRoleModel({
+    field: "reviewer",
+    provider: executorProvider,
+    explicitModel,
+    modelRole: explicitModelRole,
+    cwd,
+    registry
+  });
+  return {
+    reviewer: {
+      bindingSource: "automatic-fallback-executor",
+      provider: {
+        value: executorProvider,
+        source: "fallback",
+        sourcePath: "roles.reviewer (same-as-executor fallback: no executor-independent reviewer provider)"
+      },
+      model,
+      modelRole: usedModelRole,
+      policy,
+      ...policyNotice ? { policyNotice } : {},
+      gate,
+      threshold,
+      ...preferenceAttachment,
+      ...effortAttachment
+    },
+    sameAsExecutor: true,
+    reviewerExcludes
+  };
+}
+function dedupeProviderIds(ids) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const id of ids) {
+    const trimmed = id.trim();
+    if (!trimmed) continue;
+    const key = trimmed.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(trimmed);
+  }
+  return out;
+}
+function resolveExecutionRoles(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const cli = options.cli;
+  const layers = collectRolesLayers(cwd);
+  const registry = loadProviderRegistryForCwd(cwd);
+  const orchestrator = resolveOrchestratorRole(
+    layers,
+    cli,
+    cwd,
+    options.effectiveOrchestrator,
+    registry
+  );
+  const executor = resolveExecutorRole(layers, cli, cwd, registry);
+  const additionalExecutorExcludes = options.additionalReviewerExcludes ?? [];
+  const { reviewer, sameAsExecutor, reviewerExcludes } = resolveReviewerRole(
+    layers,
+    cli,
+    cwd,
+    executor.provider.value,
+    additionalExecutorExcludes,
+    registry,
+    options
+  );
+  const reviewAssurance = buildReviewAssurance(sameAsExecutor);
+  return {
+    orchestrator,
+    executor,
+    reviewer,
+    reviewAssurance,
+    // Compatibility alias — see ResolvedExecutionRoles.sameVendorReview docs.
+    sameVendorReview: sameAsExecutor,
+    reviewerExcludes
+  };
+}
+function resolveExecutorRoleTarget(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const executor = resolveExecutorRole(
+    collectRolesLayers(cwd),
+    void 0,
+    cwd,
+    loadProviderRegistryForCwd(cwd)
+  );
+  const providerOverride = options.providerOverride?.trim();
+  if (!providerOverride) return executor;
+  const provider = {
+    value: providerOverride,
+    source: "cli",
+    sourcePath: "cli:--provider"
+  };
+  if (providerOverride.toLowerCase() === executor.provider.value.trim().toLowerCase()) {
+    return { ...executor, provider };
+  }
+  return {
+    ...executor,
+    provider,
+    model: resolveProviderModel(providerOverride, void 0, cwd),
+    modelRole: void 0,
+    reasoningEffort: resolveProviderReasoningEffort(providerOverride, void 0, cwd)
+  };
+}
+var VALID_GATES = /* @__PURE__ */ new Set([
+  "off",
+  "advisory",
+  "high-severity-blocks"
+]);
+var VALID_EXECUTOR_TRANSPORTS = /* @__PURE__ */ new Set([
+  "auto",
+  "headless",
+  "tmux-exec"
+]);
+function isKnownProvider(providerId, knownProviderIds) {
+  if (knownProviderIds) return knownProviderIds.has(providerId);
+  try {
+    return ProviderRegistry.getAllProviderIds().includes(providerId);
+  } catch {
+    return true;
+  }
+}
+function validateRolesConfig(raw, knownProviderIds) {
+  const errors = [];
+  const knownProviders = knownProviderIds ? new Set(knownProviderIds) : void 0;
+  if (raw === void 0 || raw === null || typeof raw !== "object") {
+    return errors;
+  }
+  const roles = raw;
+  const orchestrator = roles.orchestrator;
+  if (orchestrator && typeof orchestrator === "object") {
+    const provider = orchestrator.provider;
+    if (typeof provider === "string" && provider.trim() !== "" && !isKnownProvider(provider)) {
+      errors.push({
+        code: "unknown_orchestrator_provider",
+        message: `roles.orchestrator.provider '${provider}' is not a known provider`,
+        path: ["roles", "orchestrator", "provider"]
+      });
+    }
+  }
+  const executor = roles.executor;
+  if (executor && typeof executor === "object") {
+    const provider = executor.provider;
+    if (typeof provider === "string" && provider.trim() !== "" && !isKnownProvider(provider, knownProviders)) {
+      errors.push({
+        code: "unknown_executor_provider",
+        message: `roles.executor.provider '${provider}' is not a known provider`,
+        path: ["roles", "executor", "provider"]
+      });
+    }
+    const subagents = executor.subagents;
+    if (subagents !== void 0 && !isValidSubagents(subagents)) {
+      errors.push({
+        code: "invalid_executor_subagents",
+        message: `roles.executor.subagents '${String(subagents)}' must be a positive integer, 'advisory', or 'off'`,
+        path: ["roles", "executor", "subagents"]
+      });
+    }
+    const transport = executor.transport;
+    if (transport !== void 0 && !(typeof transport === "string" && VALID_EXECUTOR_TRANSPORTS.has(transport))) {
+      errors.push({
+        code: "invalid_executor_transport",
+        message: `roles.executor.transport '${String(transport)}' must be one of: auto, headless, tmux-exec`,
+        path: ["roles", "executor", "transport"]
+      });
+    }
+  }
+  const reviewer = roles.reviewer;
+  if (reviewer && typeof reviewer === "object") {
+    const policy = reviewer.policy;
+    if (policy !== void 0 && !parseReviewPolicy(policy)) {
+      errors.push({
+        code: "invalid_reviewer_policy",
+        message: `roles.reviewer.policy '${String(policy)}' must be one of: off, advisory, block:critical|high|medium|low, repair:critical|high|medium|low`,
+        path: ["roles", "reviewer", "policy"]
+      });
+    }
+    const provider = reviewer.provider;
+    if (typeof provider === "string" && provider.trim() !== "" && !isKnownProvider(provider, knownProviders)) {
+      errors.push({
+        code: "unknown_reviewer_provider",
+        message: `roles.reviewer.provider '${provider}' is not a known provider`,
+        path: ["roles", "reviewer", "provider"]
+      });
+    }
+    const gate = reviewer.gate;
+    if (gate !== void 0 && !(typeof gate === "string" && VALID_GATES.has(gate))) {
+      errors.push({
+        code: "invalid_reviewer_gate",
+        message: `roles.reviewer.gate '${String(gate)}' must be one of: off, advisory, high-severity-blocks`,
+        path: ["roles", "reviewer", "gate"]
+      });
+    }
+    const threshold = reviewer.threshold;
+    if (threshold !== void 0 && !(typeof threshold === "string" && ["critical", "high", "medium", "low"].includes(threshold))) {
+      errors.push({
+        code: "invalid_reviewer_threshold",
+        message: `roles.reviewer.threshold '${String(threshold)}' must be one of: critical, high, medium, low`,
+        path: ["roles", "reviewer", "threshold"]
+      });
+    }
+    const preference = reviewer.providerPreference;
+    if (Array.isArray(preference)) {
+      preference.forEach((entry, index) => {
+        if (typeof entry === "string" && entry.trim() !== "" && !isKnownProvider(entry)) {
+          errors.push({
+            code: "unknown_reviewer_preference_provider",
+            message: `roles.reviewer.providerPreference[${index}] '${entry}' is not a known provider`,
+            path: ["roles", "reviewer", "providerPreference", String(index)]
+          });
+        }
+      });
+    }
+  }
+  return errors;
+}
+function isValidSubagents(value) {
+  if (value === "advisory" || value === "off") return true;
+  if (typeof value === "number") {
+    return Number.isInteger(value) && value > 0;
+  }
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value);
+    return Number.isInteger(parsed) && parsed > 0;
+  }
+  return false;
+}
+
+export {
+  EXECUTION_ROLE_NAMES,
+  resolveExecutionRoles,
+  resolveExecutorRoleTarget,
+  validateRolesConfig
+};
+//# sourceMappingURL=chunk-32IYXIE5.js.map