sortie-dogs 0.1.3 → 0.1.4

package/README.md

@@ -2,6 +2,9 @@
 
 **Give OpenCode a task; get a bounded, validated implementation loop instead of an open-ended agent run.**
 
+> **Project status: Experimental / unsupported.** No stability, compatibility,
+> or support guarantees are provided. Mk2A2 remains the canonical internal workflow.
+
 [![npm](https://img.shields.io/npm/v/sortie-dogs)](https://www.npmjs.com/package/sortie-dogs)
 [![license](https://img.shields.io/npm/l/sortie-dogs)](LICENSE)
 [![Node.js](https://img.shields.io/node/v/sortie-dogs)](https://www.npmjs.com/package/sortie-dogs)
@@ -161,9 +164,9 @@ scout evidence, and fewer unnecessary context or tool turns can reduce token
 use while preserving quality. Project-local routing can override either
 default.
 
-The `implementation`, `remediation`, and `blocker-resolution` roles always use
-the dedicated Sol worker; user configuration cannot replace those routes. For
-other explicitly routed roles, resolution is deterministic: Sortie-dogs tries
+The `implementation`, `remediation`, `blocker-resolution`, and `dog-advisor`
+roles always use dedicated Sol `xhigh`; user configuration cannot replace those
+routes. For other explicitly routed roles, resolution is deterministic: Sortie-dogs tries
 the preferred target, then ordered fallbacks. Roles without either a built-in
 default or an explicit route keep OpenCode's already selected model.
 
@@ -177,8 +180,7 @@ default or an explicit route keep OpenCode's already selected model.
       "preferred": { "model": "openai/gpt-5.6-luna", "variant": "xhigh" }
     },
     "dog-advisor": {
-      "preferred": { "model": "fable/opus", "variant": "thinking" },
-      "fallback": [{ "model": "provider/general" }]
+      "preferred": { "model": "openai/gpt-5.6-sol", "variant": "xhigh" }
     },
     "dog-reviewer": {
       "preferred": { "model": "fable/opus", "variant": "thinking" },
@@ -187,6 +189,7 @@ default or an explicit route keep OpenCode's already selected model.
   },
   "modelCatalog": {
     "project": [
+      { "model": "openai/gpt-5.6-sol", "variants": ["xhigh"] },
       { "model": "openai/gpt-5.6-luna", "variants": ["xhigh"] },
       { "model": "fable/opus", "variants": ["thinking"] },
       { "model": "provider/general" }
@@ -195,12 +198,14 @@ default or an explicit route keep OpenCode's already selected model.
 }
 ```
 
-Save project configuration as `.opencode/sortie-dogs.json`. `modelCatalog`
+Save project configuration as `.opencode/sortie-dogs.json`. The `dog-advisor`
+entry above shows the built-in effective route and is not user-overridable.
+`modelCatalog`
 declares provider models and named variants that are actually available;
 Sortie-dogs does not invent, probe, or translate variants. Resolution tries the
 preferred target and then its fallbacks, rejecting an explicitly routed role
-when no candidate appears in the catalog. The advisor and reviewer routes above
-are optional secondary examples; omit them when they are not needed.
+when no candidate appears in the catalog. The advisor route is authoritative; the
+reviewer route remains an optional secondary example.
 
 `dog-advisor` accepts bounded Strategy or SourceReview consultation from the
 coordinator. `dog-reviewer` independently checks high-risk candidates after

package/dist/core/consultation.d.ts

@@ -0,0 +1,145 @@
+export declare const CONSULTATION_CAPABILITIES: readonly ["strategy", "sourceReview"];
+export type ConsultationCapability = typeof CONSULTATION_CAPABILITIES[number];
+export declare const CONSULTATION_ROLE_POLICY: Readonly<{
+    readonly strategy: "dog-advisor";
+    readonly sourceReview: "dog-reviewer";
+}>;
+export declare const STRATEGY_TRIGGERS: readonly ["architecture-choice", "cross-boundary-tradeoff", "material-uncertainty"];
+export type StrategyTrigger = typeof STRATEGY_TRIGGERS[number];
+export interface StrategyTriggerInput {
+    readonly candidateId: string;
+    readonly trigger?: StrategyTrigger;
+    readonly callsForCandidate: number;
+    readonly decisionAlreadyRecorded?: boolean;
+    readonly mechanicalChange?: boolean;
+    readonly sameTaskResume?: boolean;
+}
+/** Strategy is advisory, bounded to one call, and excluded when no design decision remains. */
+export declare function shouldConsultStrategy(input: StrategyTriggerInput): boolean;
+export declare const SOURCE_REVIEW_RISK_TAGS: readonly ["security", "credential", "permission", "network", "public-api", "storage-compatibility", "package", "build", "release", "migration", "concurrency", "process-io", "write-gate", "authorization"];
+export type SourceReviewRiskTag = typeof SOURCE_REVIEW_RISK_TAGS[number];
+export declare function isSourceReviewRiskTag(value: unknown): value is SourceReviewRiskTag;
+export declare function requiresSourceReview(riskTags: readonly SourceReviewRiskTag[]): boolean;
+export type SourceReviewRequirement = "SKIP_LOW_RISK" | "WAIT_CANONICAL_VALIDATION" | "REVIEW_REQUIRED" | "REVIEW_TOO_LATE" | "RISK_TAGS_INVALID";
+export interface SourceReviewRequirementInput {
+    readonly riskTags: unknown;
+    readonly canonicalValidationExit?: number;
+    readonly stagingStarted: boolean;
+}
+/** Places required review strictly after canonical PASS and before staging. */
+export declare function evaluateSourceReviewRequirement(input: SourceReviewRequirementInput): SourceReviewRequirement;
+export type ReviewAvailability = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly code: "REVIEW_UNAVAILABLE";
+};
+export declare function evaluateReviewAvailability(required: boolean, available: boolean): ReviewAvailability;
+export interface StrategyConsultationRequest {
+    readonly requestId: string;
+    readonly candidateId: string;
+    readonly capability: "strategy";
+    readonly agent: string;
+    readonly question: string;
+    readonly constraints: readonly string[];
+    readonly options: readonly string[];
+}
+export interface ReviewArtifact {
+    readonly schemaVersion: 1;
+    readonly candidateId: string;
+    readonly sourceFingerprint: string;
+    readonly acceptance: readonly string[];
+    readonly manifest: readonly string[];
+    readonly riskTags: readonly SourceReviewRiskTag[];
+    readonly riskBearingHunks: readonly string[];
+    readonly validation: {
+        readonly command: string;
+        readonly exit: 0;
+        readonly fingerprint: string;
+    };
+    readonly invariants: readonly string[];
+}
+export interface SourceReviewConsultationRequest {
+    readonly requestId: string;
+    readonly candidateId: string;
+    readonly capability: "sourceReview";
+    readonly agent: string;
+    readonly artifact: ReviewArtifact;
+}
+export type ConsultationRequest = StrategyConsultationRequest | SourceReviewConsultationRequest;
+export interface StrategyConsultationResult {
+    readonly requestId: string;
+    readonly candidateId: string;
+    readonly capability: "strategy";
+    readonly status: "completed";
+    readonly recommendation: string;
+    readonly considerations: readonly string[];
+}
+export interface UnavailableConsultationResult {
+    readonly requestId: string;
+    readonly candidateId: string;
+    readonly capability: ConsultationCapability;
+    readonly status: "unavailable";
+}
+export type ReviewVerdictKind = "PASS" | "MUST_FIX" | "BLOCKED";
+export type ReviewFindingSeverity = "major" | "medium";
+export interface ReviewFinding {
+    readonly severity: ReviewFindingSeverity;
+    readonly path: string;
+    readonly evidence: string;
+    readonly requiredFix: string;
+}
+export interface ReviewVerdict {
+    readonly verdict: ReviewVerdictKind;
+    readonly sourceFingerprint: string;
+    readonly findings: readonly ReviewFinding[];
+}
+export interface SourceReviewConsultationResult {
+    readonly requestId: string;
+    readonly candidateId: string;
+    readonly capability: "sourceReview";
+    readonly status: "completed";
+    readonly review: ReviewVerdict;
+}
+export type ConsultationResult = StrategyConsultationResult | SourceReviewConsultationResult | UnavailableConsultationResult;
+/** Host-owned adapters implement transport. Core never executes commands or selects providers. */
+export interface ConsultationAdapter {
+    consult(request: ConsultationRequest): Promise<ConsultationResult>;
+}
+export declare const MAX_REVIEW_ARTIFACT_BYTES = 30720;
+export type ValidationResult<T> = {
+    readonly ok: true;
+    readonly value: T;
+    readonly bytes?: number;
+} | {
+    readonly ok: false;
+    readonly code: string;
+};
+/** Strict bounded schema; unknown fields and opaque/raw payloads are rejected. */
+export declare function validateReviewArtifact(value: unknown, maxBytes?: number): ValidationResult<ReviewArtifact>;
+export declare function validateReviewVerdict(value: unknown): ValidationResult<ReviewVerdict>;
+export interface ReviewGateInput {
+    readonly phase: "initial" | "verification";
+    readonly candidateId: string;
+    readonly currentSourceFingerprint: string;
+    readonly artifact: unknown;
+    readonly verdict: unknown;
+    readonly reviewedFingerprints: readonly string[];
+    /** The configured budget applies independently to each explicit review phase. */
+    readonly maxCallsPerCandidate: number;
+    readonly callsForPhase: number;
+    readonly initialVerdict?: ReviewVerdictKind;
+    readonly initialArtifact?: unknown;
+    readonly remediationApplied?: boolean;
+    readonly maxArtifactBytes?: number;
+}
+export type ReviewGateResult = {
+    readonly ok: true;
+    readonly permitStage: boolean;
+    readonly verdict: ReviewVerdictKind;
+} | {
+    readonly ok: false;
+    readonly code: string;
+};
+/** Enforces one initial review and, only after remediation, one verification review. */
+export declare function evaluateReviewGate(input: ReviewGateInput): ReviewGateResult;

package/dist/core/consultation.js

@@ -0,0 +1,207 @@
+export const CONSULTATION_CAPABILITIES = ["strategy", "sourceReview"];
+export const CONSULTATION_ROLE_POLICY = Object.freeze({
+    strategy: "dog-advisor",
+    sourceReview: "dog-reviewer",
+});
+export const STRATEGY_TRIGGERS = [
+    "architecture-choice",
+    "cross-boundary-tradeoff",
+    "material-uncertainty",
+];
+/** Strategy is advisory, bounded to one call, and excluded when no design decision remains. */
+export function shouldConsultStrategy(input) {
+    return input.candidateId.length > 0 &&
+        input.trigger !== undefined &&
+        input.callsForCandidate < 1 &&
+        input.decisionAlreadyRecorded !== true &&
+        input.mechanicalChange !== true &&
+        input.sameTaskResume !== true;
+}
+export const SOURCE_REVIEW_RISK_TAGS = [
+    "security",
+    "credential",
+    "permission",
+    "network",
+    "public-api",
+    "storage-compatibility",
+    "package",
+    "build",
+    "release",
+    "migration",
+    "concurrency",
+    "process-io",
+    "write-gate",
+    "authorization",
+];
+const riskTagSet = new Set(SOURCE_REVIEW_RISK_TAGS);
+export function isSourceReviewRiskTag(value) {
+    return typeof value === "string" && riskTagSet.has(value);
+}
+export function requiresSourceReview(riskTags) {
+    return riskTags.length > 0;
+}
+/** Places required review strictly after canonical PASS and before staging. */
+export function evaluateSourceReviewRequirement(input) {
+    if (!Array.isArray(input.riskTags))
+        return "RISK_TAGS_INVALID";
+    const riskTags = [...input.riskTags];
+    if (!riskTags.every(isSourceReviewRiskTag))
+        return "RISK_TAGS_INVALID";
+    if (!requiresSourceReview(riskTags))
+        return "SKIP_LOW_RISK";
+    if (input.canonicalValidationExit !== 0)
+        return "WAIT_CANONICAL_VALIDATION";
+    return input.stagingStarted ? "REVIEW_TOO_LATE" : "REVIEW_REQUIRED";
+}
+export function evaluateReviewAvailability(required, available) {
+    return required && !available ? { ok: false, code: "REVIEW_UNAVAILABLE" } : { ok: true };
+}
+export const MAX_REVIEW_ARTIFACT_BYTES = 30_720;
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function hasExactKeys(value, keys) {
+    const actual = Object.keys(value).sort();
+    const expected = [...keys].sort();
+    return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.length > 0;
+}
+function isStringList(value) {
+    return Array.isArray(value) && value.every(isNonEmptyString);
+}
+/** Strict bounded schema; unknown fields and opaque/raw payloads are rejected. */
+export function validateReviewArtifact(value, maxBytes = MAX_REVIEW_ARTIFACT_BYTES) {
+    let bytes;
+    try {
+        const serialized = JSON.stringify(value);
+        if (serialized === undefined)
+            return { ok: false, code: "ARTIFACT_NOT_JSON" };
+        bytes = Buffer.byteLength(serialized, "utf8");
+    }
+    catch {
+        return { ok: false, code: "ARTIFACT_NOT_JSON" };
+    }
+    if (!Number.isInteger(maxBytes) || maxBytes <= 0 || maxBytes > MAX_REVIEW_ARTIFACT_BYTES) {
+        return { ok: false, code: "ARTIFACT_LIMIT_INVALID" };
+    }
+    if (bytes > maxBytes)
+        return { ok: false, code: "ARTIFACT_TOO_LARGE" };
+    if (!isRecord(value) || !hasExactKeys(value, [
+        "schemaVersion",
+        "candidateId",
+        "sourceFingerprint",
+        "acceptance",
+        "manifest",
+        "riskTags",
+        "riskBearingHunks",
+        "validation",
+        "invariants",
+    ]))
+        return { ok: false, code: "ARTIFACT_SCHEMA_INVALID" };
+    if (value.schemaVersion !== 1 ||
+        !isNonEmptyString(value.candidateId) ||
+        !isNonEmptyString(value.sourceFingerprint) ||
+        !isStringList(value.acceptance) ||
+        !isStringList(value.manifest) ||
+        !Array.isArray(value.riskTags) ||
+        !value.riskTags.every(isSourceReviewRiskTag) ||
+        !isStringList(value.riskBearingHunks) ||
+        !isRecord(value.validation) ||
+        !hasExactKeys(value.validation, ["command", "exit", "fingerprint"]) ||
+        !isNonEmptyString(value.validation.command) ||
+        value.validation.exit !== 0 ||
+        !isNonEmptyString(value.validation.fingerprint) ||
+        !isStringList(value.invariants))
+        return { ok: false, code: "ARTIFACT_SCHEMA_INVALID" };
+    return { ok: true, value: value, bytes };
+}
+export function validateReviewVerdict(value) {
+    if (!isRecord(value) || !hasExactKeys(value, ["verdict", "sourceFingerprint", "findings"])) {
+        return { ok: false, code: "VERDICT_SCHEMA_INVALID" };
+    }
+    if (!["PASS", "MUST_FIX", "BLOCKED"].includes(value.verdict) ||
+        !isNonEmptyString(value.sourceFingerprint) ||
+        !Array.isArray(value.findings))
+        return { ok: false, code: "VERDICT_SCHEMA_INVALID" };
+    for (const finding of value.findings) {
+        if (!isRecord(finding) ||
+            !hasExactKeys(finding, ["severity", "path", "evidence", "requiredFix"]) ||
+            (finding.severity !== "major" && finding.severity !== "medium") ||
+            !isNonEmptyString(finding.path) ||
+            !isNonEmptyString(finding.evidence) ||
+            !isNonEmptyString(finding.requiredFix))
+            return { ok: false, code: "VERDICT_SCHEMA_INVALID" };
+    }
+    if (value.verdict === "PASS" && value.findings.length !== 0) {
+        return { ok: false, code: "PASS_WITH_FINDINGS" };
+    }
+    if (value.verdict !== "PASS" && value.findings.length === 0) {
+        return { ok: false, code: "NON_PASS_WITHOUT_FINDINGS" };
+    }
+    return { ok: true, value: value };
+}
+/** Enforces one initial review and, only after remediation, one verification review. */
+export function evaluateReviewGate(input) {
+    if (!Number.isInteger(input.maxCallsPerCandidate) ||
+        input.maxCallsPerCandidate <= 0 ||
+        !Number.isInteger(input.callsForPhase) ||
+        input.callsForPhase < 0)
+        return { ok: false, code: "REVIEW_BUDGET_INVALID" };
+    if (input.callsForPhase >= input.maxCallsPerCandidate) {
+        return { ok: false, code: "REVIEW_BUDGET_EXHAUSTED" };
+    }
+    const artifact = validateReviewArtifact(input.artifact, input.maxArtifactBytes);
+    if (!artifact.ok)
+        return artifact;
+    const verdict = validateReviewVerdict(input.verdict);
+    if (!verdict.ok)
+        return verdict;
+    if (artifact.value.candidateId !== input.candidateId)
+        return { ok: false, code: "CANDIDATE_MISMATCH" };
+    if (artifact.value.sourceFingerprint !== input.currentSourceFingerprint) {
+        return { ok: false, code: "STALE_FINGERPRINT" };
+    }
+    if (verdict.value.sourceFingerprint !== artifact.value.sourceFingerprint) {
+        return { ok: false, code: "FINGERPRINT_MISMATCH" };
+    }
+    if (input.reviewedFingerprints.includes(artifact.value.sourceFingerprint)) {
+        return { ok: false, code: "FINGERPRINT_REUSED" };
+    }
+    if (input.phase === "initial") {
+        if (input.reviewedFingerprints.length !== 0)
+            return { ok: false, code: "REVIEW_LIMIT_REACHED" };
+    }
+    else if (input.reviewedFingerprints.length !== 1 ||
+        input.initialVerdict !== "MUST_FIX" ||
+        input.remediationApplied !== true) {
+        return { ok: false, code: "VERIFICATION_NOT_ALLOWED" };
+    }
+    else {
+        const initialArtifact = validateReviewArtifact(input.initialArtifact, input.maxArtifactBytes);
+        if (!initialArtifact.ok)
+            return { ok: false, code: "INITIAL_ARTIFACT_INVALID" };
+        if (!sameReviewScope(initialArtifact.value, artifact.value)) {
+            return { ok: false, code: "REVIEW_SCOPE_MISMATCH" };
+        }
+    }
+    return {
+        ok: true,
+        permitStage: verdict.value.verdict === "PASS",
+        verdict: verdict.value.verdict,
+    };
+}
+function sameStringList(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function sameReviewScope(initial, verification) {
+    return initial.schemaVersion === verification.schemaVersion &&
+        initial.candidateId === verification.candidateId &&
+        sameStringList(initial.acceptance, verification.acceptance) &&
+        sameStringList(initial.manifest, verification.manifest) &&
+        sameStringList(initial.riskTags, verification.riskTags) &&
+        sameStringList(initial.riskBearingHunks, verification.riskBearingHunks) &&
+        sameStringList(initial.invariants, verification.invariants) &&
+        initial.validation.command === verification.validation.command;
+}

package/dist/index.d.ts

@@ -2,4 +2,6 @@ export { lintHandoff } from "./core/validate-semantics.js";
 export { initializeProject, ProjectInitializationError, } from "./core/initialize.js";
 export type { InitializationStatus, InitializeProjectResult, ProjectInitializationErrorCode, } from "./core/initialize.js";
 export { SortieDogsPlugin } from "./plugin/index.js";
+export { CONSULTATION_CAPABILITIES, CONSULTATION_ROLE_POLICY, MAX_REVIEW_ARTIFACT_BYTES, SOURCE_REVIEW_RISK_TAGS, STRATEGY_TRIGGERS, evaluateReviewAvailability, evaluateReviewGate, evaluateSourceReviewRequirement, isSourceReviewRiskTag, requiresSourceReview, shouldConsultStrategy, validateReviewArtifact, validateReviewVerdict, } from "./core/consultation.js";
+export type { ConsultationAdapter, ConsultationCapability, ConsultationRequest, ConsultationResult, ReviewArtifact, ReviewAvailability, ReviewFinding, ReviewFindingSeverity, ReviewGateInput, ReviewGateResult, ReviewVerdict, ReviewVerdictKind, SourceReviewConsultationRequest, SourceReviewConsultationResult, SourceReviewRequirement, SourceReviewRequirementInput, SourceReviewRiskTag, StrategyConsultationRequest, StrategyConsultationResult, StrategyTrigger, StrategyTriggerInput, UnavailableConsultationResult, ValidationResult, } from "./core/consultation.js";
 export type * from "./core/types.js";

package/dist/index.js

@@ -1,3 +1,4 @@
 export { lintHandoff } from "./core/validate-semantics.js";
 export { initializeProject, ProjectInitializationError, } from "./core/initialize.js";
 export { SortieDogsPlugin } from "./plugin/index.js";
+export { CONSULTATION_CAPABILITIES, CONSULTATION_ROLE_POLICY, MAX_REVIEW_ARTIFACT_BYTES, SOURCE_REVIEW_RISK_TAGS, STRATEGY_TRIGGERS, evaluateReviewAvailability, evaluateReviewGate, evaluateSourceReviewRequirement, isSourceReviewRiskTag, requiresSourceReview, shouldConsultStrategy, validateReviewArtifact, validateReviewVerdict, } from "./core/consultation.js";

package/dist/plugin/config.d.ts

@@ -4,6 +4,28 @@ export interface SortieDogsPluginOptions {
     handoffPaths?: readonly string[];
     modelRouting?: ModelRoutingConfig;
     modelCatalog?: ModelCatalog;
+    consultation?: ConsultationPolicyInput;
+}
+export interface ConsultationPolicyInput {
+    readonly strategy?: Partial<StrategyConsultationPolicy>;
+    readonly sourceReview?: Partial<SourceReviewConsultationPolicy>;
+}
+export interface StrategyConsultationPolicy {
+    readonly agent: string;
+    readonly required: boolean;
+    readonly maxCallsPerCandidate: number;
+}
+export interface SourceReviewConsultationPolicy {
+    readonly agent: string;
+    readonly requiredPolicy: "risk-based";
+    readonly unavailable: "block-required-only";
+    /** Maximum calls in each explicit initial or verification phase. */
+    readonly maxCallsPerCandidate: number;
+    readonly maxArtifactBytes: number;
+}
+export interface ConsultationPolicy {
+    readonly strategy: StrategyConsultationPolicy;
+    readonly sourceReview: SourceReviewConsultationPolicy;
 }
 export interface ConfiguredPlugin {
     kind: "configured";
@@ -11,6 +33,7 @@ export interface ConfiguredPlugin {
     handoffPaths: readonly string[];
     modelRouting: ModelRoutingConfig;
     modelCatalog: ModelCatalog;
+    consultation: ConsultationPolicy;
 }
 export type PluginConfiguration = ConfiguredPlugin | {
     kind: "invalid";
@@ -22,7 +45,9 @@ export interface ConfiguredPluginSources extends ConfiguredPlugin {
 export type PluginConfigurationSources = ConfiguredPluginSources | {
     kind: "invalid";
 };
-export declare const DEFAULT_PLUGIN_OPTIONS: Readonly<Required<SortieDogsPluginOptions>>;
+export declare const DEFAULT_PLUGIN_OPTIONS: Readonly<Omit<Required<SortieDogsPluginOptions>, "consultation"> & {
+    consultation: ConsultationPolicy;
+}>;
 /** Merge defaults, optional project/env configuration, then the host override. */
 export declare function resolvePluginConfiguration(...values: readonly unknown[]): PluginConfiguration;
 /** Resolve the plugin's fixed source boundaries: project-local first, environment and host global. */

package/dist/plugin/config.js

@@ -1,9 +1,24 @@
-import { BUILT_IN_MODEL_CATALOG, DEDICATED_SOL_ROUTING, RECOMMENDED_LUNA_ROUTING, isDedicatedSolRole, parseModelRoutingConfig, } from "./model-routing.js";
+import { BUILT_IN_MODEL_CATALOG, FIXED_MODEL_ROUTING, RECOMMENDED_LUNA_ROUTING, isFixedModelRole, parseModelRoutingConfig, } from "./model-routing.js";
+import { CONSULTATION_ROLE_POLICY } from "../core/consultation.js";
 export const DEFAULT_PLUGIN_OPTIONS = {
     operationManifestPath: "operation-manifest.json",
     handoffPaths: ["handoff.json"],
     modelRouting: RECOMMENDED_LUNA_ROUTING,
     modelCatalog: BUILT_IN_MODEL_CATALOG,
+    consultation: Object.freeze({
+        strategy: Object.freeze({
+            agent: CONSULTATION_ROLE_POLICY.strategy,
+            required: false,
+            maxCallsPerCandidate: 1,
+        }),
+        sourceReview: Object.freeze({
+            agent: CONSULTATION_ROLE_POLICY.sourceReview,
+            requiredPolicy: "risk-based",
+            unavailable: "block-required-only",
+            maxCallsPerCandidate: 1,
+            maxArtifactBytes: 30_720,
+        }),
+    }),
 };
 function isRecord(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -11,6 +26,73 @@ function isRecord(value) {
 function nonEmptyString(value) {
     return typeof value === "string" && value.length > 0;
 }
+function positiveInteger(value) {
+    return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+function parseConsultationPolicy(value) {
+    if (!isRecord(value) || Object.keys(value).some((key) => key !== "strategy" && key !== "sourceReview")) {
+        return undefined;
+    }
+    let strategy;
+    if (value.strategy !== undefined) {
+        if (!isRecord(value.strategy) || Object.keys(value.strategy).some((key) => key !== "agent" && key !== "required" && key !== "maxCallsPerCandidate"))
+            return undefined;
+        if (value.strategy.agent !== undefined &&
+            value.strategy.agent !== CONSULTATION_ROLE_POLICY.strategy)
+            return undefined;
+        if (value.strategy.required !== undefined && typeof value.strategy.required !== "boolean")
+            return undefined;
+        if (value.strategy.maxCallsPerCandidate !== undefined && !positiveInteger(value.strategy.maxCallsPerCandidate)) {
+            return undefined;
+        }
+        strategy = Object.freeze({
+            ...(value.strategy.agent === undefined ? {} : { agent: value.strategy.agent }),
+            ...(value.strategy.required === undefined ? {} : { required: value.strategy.required }),
+            ...(value.strategy.maxCallsPerCandidate === undefined
+                ? {}
+                : { maxCallsPerCandidate: value.strategy.maxCallsPerCandidate }),
+        });
+    }
+    let sourceReview;
+    if (value.sourceReview !== undefined) {
+        if (!isRecord(value.sourceReview) || Object.keys(value.sourceReview).some((key) => !["agent", "requiredPolicy", "unavailable", "maxCallsPerCandidate", "maxArtifactBytes"].includes(key)))
+            return undefined;
+        if (value.sourceReview.agent !== undefined &&
+            value.sourceReview.agent !== CONSULTATION_ROLE_POLICY.sourceReview)
+            return undefined;
+        if (value.sourceReview.requiredPolicy !== undefined && value.sourceReview.requiredPolicy !== "risk-based") {
+            return undefined;
+        }
+        if (value.sourceReview.unavailable !== undefined && value.sourceReview.unavailable !== "block-required-only") {
+            return undefined;
+        }
+        if (value.sourceReview.maxCallsPerCandidate !== undefined &&
+            !positiveInteger(value.sourceReview.maxCallsPerCandidate))
+            return undefined;
+        if (value.sourceReview.maxArtifactBytes !== undefined &&
+            (!positiveInteger(value.sourceReview.maxArtifactBytes) || value.sourceReview.maxArtifactBytes > 30_720))
+            return undefined;
+        sourceReview = Object.freeze({
+            ...(value.sourceReview.agent === undefined ? {} : { agent: value.sourceReview.agent }),
+            ...(value.sourceReview.requiredPolicy === undefined
+                ? {}
+                : { requiredPolicy: value.sourceReview.requiredPolicy }),
+            ...(value.sourceReview.unavailable === undefined
+                ? {}
+                : { unavailable: value.sourceReview.unavailable }),
+            ...(value.sourceReview.maxCallsPerCandidate === undefined
+                ? {}
+                : { maxCallsPerCandidate: value.sourceReview.maxCallsPerCandidate }),
+            ...(value.sourceReview.maxArtifactBytes === undefined
+                ? {}
+                : { maxArtifactBytes: value.sourceReview.maxArtifactBytes }),
+        });
+    }
+    return Object.freeze({
+        ...(strategy === undefined ? {} : { strategy }),
+        ...(sourceReview === undefined ? {} : { sourceReview }),
+    });
+}
 function parseCatalogModels(value) {
     if (!Array.isArray(value))
         return undefined;
@@ -74,7 +156,7 @@ function parseLayer(value) {
         return {};
     if (!isRecord(value))
         return undefined;
-    if (Object.keys(value).some((key) => key !== "operationManifestPath" && key !== "handoffPaths" && key !== "modelRouting" && key !== "modelCatalog")) {
+    if (Object.keys(value).some((key) => !["operationManifestPath", "handoffPaths", "modelRouting", "modelCatalog", "consultation"].includes(key))) {
         return undefined;
     }
     const manifestPath = value.operationManifestPath;
@@ -85,6 +167,9 @@ function parseLayer(value) {
     const modelCatalog = value.modelCatalog === undefined
         ? undefined
         : parseModelCatalog(value.modelCatalog);
+    const consultation = value.consultation === undefined
+        ? undefined
+        : parseConsultationPolicy(value.consultation);
     if (manifestPath !== undefined && (typeof manifestPath !== "string" || manifestPath.length === 0)) {
         return undefined;
     }
@@ -96,11 +181,14 @@ function parseLayer(value) {
         return undefined;
     if (value.modelCatalog !== undefined && modelCatalog === undefined)
         return undefined;
+    if (value.consultation !== undefined && consultation === undefined)
+        return undefined;
     return {
         operationManifestPath: manifestPath,
         handoffPaths: handoffPaths,
         modelRouting,
         modelCatalog,
+        consultation,
     };
 }
 /** Merge defaults, optional project/env configuration, then the host override. */
@@ -109,6 +197,7 @@ export function resolvePluginConfiguration(...values) {
     let handoffPaths = DEFAULT_PLUGIN_OPTIONS.handoffPaths;
     let modelRouting = DEFAULT_PLUGIN_OPTIONS.modelRouting;
     let modelCatalog = DEFAULT_PLUGIN_OPTIONS.modelCatalog;
+    let consultation = DEFAULT_PLUGIN_OPTIONS.consultation;
     for (const value of values) {
         const layer = parseLayer(value);
         if (layer === undefined)
@@ -129,7 +218,17 @@ export function resolvePluginConfiguration(...values) {
                 }),
             };
         }
+        if (layer.consultation !== undefined) {
+            consultation = Object.freeze({
+                strategy: Object.freeze({ ...consultation.strategy, ...(layer.consultation.strategy ?? {}) }),
+                sourceReview: Object.freeze({ ...consultation.sourceReview, ...(layer.consultation.sourceReview ?? {}) }),
+            });
+        }
     }
+    modelRouting = {
+        ...Object.fromEntries(Object.entries(modelRouting).filter(([role]) => !isFixedModelRole(role))),
+        ...FIXED_MODEL_ROUTING,
+    };
     const hasRouting = Object.keys(modelRouting).length > 0;
     const hasCatalogEntries = (modelCatalog.project?.length ?? 0) + (modelCatalog.global?.length ?? 0) > 0;
     if (hasRouting && !hasCatalogEntries)
@@ -140,6 +239,7 @@ export function resolvePluginConfiguration(...values) {
         handoffPaths,
         modelRouting,
         modelCatalog,
+        consultation,
     };
 }
 /** Resolve the plugin's fixed source boundaries: project-local first, environment and host global. */
@@ -157,17 +257,17 @@ export function resolvePluginConfigurationSources(projectValue, environmentValue
         ...RECOMMENDED_LUNA_ROUTING,
         ...(environmentLayer.modelRouting ?? {}),
         ...(hostLayer.modelRouting ?? {}),
-    }).filter(([role]) => !isDedicatedSolRole(role)));
+    }).filter(([role]) => !isFixedModelRole(role)));
     const modelRouting = {
         ...Object.fromEntries(Object.entries(configured.modelRouting)
-            .filter(([role]) => !isDedicatedSolRole(role))),
-        ...DEDICATED_SOL_ROUTING,
+            .filter(([role]) => !isFixedModelRole(role))),
+        ...FIXED_MODEL_ROUTING,
     };
     return {
         ...configured,
         modelRouting,
-        // Mk2A2 worker policy is authoritative over every configurable layer.
-        localModelRouting: { ...(projectLayer.modelRouting ?? {}), ...DEDICATED_SOL_ROUTING },
+        // Dedicated worker policy is authoritative over every configurable layer.
+        localModelRouting: { ...(projectLayer.modelRouting ?? {}), ...FIXED_MODEL_ROUTING },
         globalModelRouting,
     };
 }