sortie-dogs 0.1.3 → 0.1.11

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)
@@ -77,6 +80,55 @@ OpenCode discovers the bridge automatically; no `plugin` entry in
 
 Selecting `dog-coordinator` directly also activates the workflow.
 
+## The write gate
+
+The write gate is opt-in per project. Without `operation-manifest.json` in the
+project root, the plugin stays passive and never denies a tool call. Creating
+that file is how a project opts in, so the coordinator can always create it.
+
+```json
+{
+  "version": "0.1.0",
+  "task_id": "add-requested-behavior",
+  "read": ["src/feature.ts", "test/feature.test.ts"],
+  "write": ["src/feature.ts", "test/feature.test.ts"],
+  "validation": ["npm test"]
+}
+```
+
+- `write` lists the only paths a bound worker may change. A listed directory
+  covers the files under it; every other entry is an exact path.
+- `validation` lists the exact commands a bound worker may run. Build and test
+  commands cannot be classified by path, so a command is allowed only when it
+  matches a declared entry exactly. Anything else is denied as unclassified.
+- `read` documents the intended reading scope; reads are never blocked.
+
+`dog-coordinator` owns this file. A worker binds to it once per candidate with
+`sortie_bind_write_gate`, and only after the coordinator's handoff has been
+inspected. Coordinator sessions are never gated.
+
+Optional settings in `.opencode/sortie-dogs.json`:
+
+```json
+{
+  "operationManifestPath": "operation-manifest.json",
+  "handoffPaths": ["handoff.json"],
+  "readOnlyTools": ["my_mcp_search"],
+  "dedicatedWorkerModel": { "model": "provider/model", "variant": "deep" }
+}
+```
+
+- `operationManifestPath` moves the manifest; the path is project-relative.
+- `handoffPaths` lists the handoff files the plugin inspects. A worker can only
+  bind after one of these files passes inspection, so an empty list disables
+  binding entirely.
+- `readOnlyTools` adds host-specific tool names that never change files, such as
+  MCP tools. Unknown tools are denied for a bound session by default.
+- `dedicatedWorkerModel` selects the single model every worker role resolves to.
+  It defaults to `openai/gpt-5.6-sol` with variant `xhigh`; declare your own when
+  that model is unavailable. Worker roles always resolve to this one target and
+  cannot be routed per role.
+
 ## Why Sortie-dogs
 
 - **Focused when invited, invisible otherwise.** Activate it with `/sortie` or
@@ -161,9 +213,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 +229,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 +238,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 +247,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/asset-version.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Version of the installable runtime assets. Kept in its own module so the plugin can compare an
+ * installed project marker without importing every asset body.
+ */
+export declare const RUNTIME_ASSET_VERSION = "0.2.0-card05";
+export type RuntimeAssetVersion = typeof RUNTIME_ASSET_VERSION;

package/dist/asset-version.js

@@ -0,0 +1,5 @@
+/**
+ * Version of the installable runtime assets. Kept in its own module so the plugin can compare an
+ * installed project marker without importing every asset body.
+ */
+export const RUNTIME_ASSET_VERSION = "0.2.0-card05";

package/dist/core/consultation.d.ts

@@ -0,0 +1,148 @@
+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;
+/**
+ * Sole consultation transport boundary. The host supplies this adapter; core passes only the
+ * provider-, model-, variant-, and transport-neutral request and result envelopes above.
+ */
+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

@@ -1,16 +1,51 @@
-import { type ModelCatalog, type ModelRoutingConfig } from "./model-routing.js";
+import { type ModelCatalog, type ModelRoutingConfig, type ModelTarget } from "./model-routing.js";
 export interface SortieDogsPluginOptions {
     operationManifestPath?: string;
     handoffPaths?: readonly string[];
+    /**
+     * Host-specific tool names that never change project files, such as MCP tools. Names accumulate
+     * across layers because each layer describes a different part of the same environment.
+     */
+    readOnlyTools?: readonly string[];
+    /**
+     * The single model every dedicated worker role resolves to. Worker routing stays fixed to one
+     * target; a host that cannot serve the shipped target declares its own here.
+     */
+    dedicatedWorkerModel?: ModelTarget;
     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";
     operationManifestPath: string;
     handoffPaths: readonly string[];
+    readOnlyTools: readonly string[];
+    dedicatedWorkerModel: ModelTarget;
     modelRouting: ModelRoutingConfig;
     modelCatalog: ModelCatalog;
+    consultation: ConsultationPolicy;
 }
 export type PluginConfiguration = ConfiguredPlugin | {
     kind: "invalid";
@@ -22,7 +57,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. */