thoth-agents 0.6.0 → 0.7.0

package/dist/{chunk-7YCSKK2X.js → chunk-W5TSNGEE.js}

@@ -16,7 +16,7 @@ import {
   savePiModelConfig,
   syncPiSpecialists,
   writePiManagedText
-} from "./chunk-U7FNFTM5.js";
+} from "./chunk-P3GDM5RH.js";
 import {
   ALL_AGENT_NAMES,
   CLAUDE_CODE_PROMPT_DIALECT,
@@ -24,6 +24,7 @@ import {
   CODEX_PROMPT_DIALECT,
   CONFIRMED_OPENAI_SUBAGENT_PRESET,
   DEFAULT_MODELS,
+  LEGACY_OPENAI_PRESET,
   PI_SPECIALIST_ROLES,
   SUBAGENT_NAMES,
   claudeCodeSubagentType,
@@ -47,7 +48,7 @@ import {
   updateOpenCodeMainConfig,
   writeConfig,
   writeLiteConfig
-} from "./chunk-OW6I7ZUU.js";
+} from "./chunk-QOIZYJ5C.js";
 
 // src/cli/codex-paths.ts
 import { homedir } from "os";
@@ -1759,6 +1760,22 @@ function resolveRoleTomlContent(options) {
   const installedContent = readFileSync4(options.targetPath, "utf8");
   const currentModel = parseRoleTomlModel(installedContent);
   const currentEffort = parseRoleTomlEffort(installedContent);
+  const legacy = LEGACY_OPENAI_PRESET[options.role];
+  if (currentModel === legacy.model && currentEffort === legacy.effort) {
+    options.nextState.models[key] = renderedModel;
+    if (configuredModel !== void 0) {
+      options.nextState.configuredModels ??= {};
+      options.nextState.configuredModels[key] = renderedModel;
+    }
+    if (configuredEffort !== void 0) {
+      options.nextState.configuredEfforts ??= {};
+      const renderedEffort = parseRoleTomlEffort(options.renderedContent);
+      if (renderedEffort !== void 0)
+        options.nextState.configuredEfforts[key] = renderedEffort;
+      else delete options.nextState.configuredEfforts[key];
+    }
+    return options.renderedContent;
+  }
   if (configuredModel !== void 0) {
     options.nextState.models[key] = renderedModel;
     options.nextState.configuredModels ??= {};
@@ -1782,7 +1799,10 @@ function resolveRoleTomlContent(options) {
     );
   }
   options.nextState.models[key] = renderedModel;
-  return replaceRoleTomlEffort(options.renderedContent, currentEffort);
+  return replaceRoleTomlEffort(
+    currentModel === void 0 ? options.renderedContent : replaceRoleTomlModel(options.renderedContent, currentModel),
+    currentEffort
+  );
 }
 function roleArtifactContent(role, artifacts) {
   const path = `.codex/agents/thoth-agents-${role}.toml`;
@@ -1827,6 +1847,7 @@ function buildCodexSetupPlan(config) {
         roleArtifactContent(target.role, render.artifacts)
       ),
       content: resolveRoleTomlContent({
+        role: target.role,
         renderedContent: roleArtifactContent(target.role, render.artifacts),
         targetPath: target.path,
         state: managedModelState2,
@@ -2150,7 +2171,7 @@ var CLAUDE_CODE_SUBAGENT_DEFAULT_MODELS = {
   worker: "sonnet"
 };
 var CLAUDE_CODE_SUBAGENT_DEFAULT_EFFORTS = {
-  explorer: "low",
+  explorer: "medium",
   designer: "medium",
   worker: "medium",
   librarian: "high",
@@ -8424,6 +8445,29 @@ function scanPiProjectInstalledIncumbents(options, configuredPackages) {
   }
   return incumbents;
 }
+function mergePiCodemodeSettings(current) {
+  const tools = current.defaultTools;
+  if (tools !== void 0 && (!Array.isArray(tools) || tools.some((tool) => typeof tool !== "string")))
+    throw new Error("Global Pi defaultTools must be an array of strings.");
+  if (current.codemode !== void 0 && !isRecord6(current.codemode))
+    throw new Error("Global Pi codemode must be a JSON object.");
+  const codemode = isRecord6(current.codemode) ? current.codemode : {};
+  let defaultTools = tools ?? ["+codemode"];
+  if (!defaultTools.some(
+    (tool) => ["codemode", "+codemode", "-codemode"].includes(tool)
+  )) {
+    const additive = defaultTools.length > 0 && defaultTools.every((tool) => /^[+-]/.test(tool));
+    defaultTools = [...defaultTools, additive ? "+codemode" : "codemode"];
+  }
+  return {
+    ...current,
+    defaultTools,
+    codemode: {
+      ...codemode,
+      ...codemode.mode === void 0 ? { mode: "on" } : {}
+    }
+  };
+}
 function mergePiSubagentsConfig(current) {
   return {
     ...current,
@@ -8520,10 +8564,13 @@ function buildPiSetupPlan(options = {}) {
   }
   let userPackages = [];
   let plannedQuestionRemovals = [];
+  let codemodeSettingsContent;
   let subagentsConfigContent;
   let mcpContent;
   try {
     const userSettings = readJsonObject(paths.settingsPath);
+    codemodeSettingsContent = `${JSON.stringify(mergePiCodemodeSettings(userSettings), null, 2)}
+`;
     const incumbentSource = configuredPackageSource(
       userSettings,
       isPiIncumbentDelegationSource
@@ -8649,6 +8696,14 @@ function buildPiSetupPlan(options = {}) {
       target: pkg.source,
       command: { command: "pi", args: ["install", pkg.source, "--no-approve"] }
     })),
+    ...codemodeSettingsContent === void 0 ? [] : [
+      {
+        kind: "settings",
+        description: "Fill absent global codemode defaults",
+        target: paths.settingsPath,
+        content: codemodeSettingsContent
+      }
+    ],
     ...subagentsConfigContent === void 0 ? [] : [
       {
         kind: "settings",
@@ -9320,7 +9375,8 @@ function applyPiSetup(plan) {
     for (const item of plan.items.filter(
       (candidate) => candidate.content !== void 0 && (candidate.kind === "settings" || candidate.kind === "mcp")
     )) {
-      const content = item.target === plan.paths.subagentsConfigPath ? `${JSON.stringify(mergePiSubagentsConfig(readJsonObject(item.target)), null, 2)}
+      const content = item.target === plan.paths.settingsPath ? `${JSON.stringify(mergePiCodemodeSettings(readJsonObject(item.target)), null, 2)}
+` : item.target === plan.paths.subagentsConfigPath ? `${JSON.stringify(mergePiSubagentsConfig(readJsonObject(item.target)), null, 2)}
 ` : item.target === plan.paths.mcpConfigPath ? `${JSON.stringify(mergePiGrepMcpConfig(readJsonObject(item.target)), null, 2)}
 ` : item.content ?? "";
       if (writePiManagedText(item.target, content)) changed.push(item.target);

package/dist/cli/index.js

@@ -4,7 +4,7 @@ import {
   getOpenCodeVersion,
   isOpenCodeInstalled,
   opencodeAdapter
-} from "../chunk-MRFCA3U2.js";
+} from "../chunk-3MHJGWS4.js";
 import {
   CODEX_ROLE_NAMES,
   REQUIRED_SKILLS,
@@ -59,11 +59,11 @@ import {
   normalizeEffortSelection,
   recordHarnessInstallCompletion,
   syncOpenCodeOwnedSkills
-} from "../chunk-7YCSKK2X.js";
+} from "../chunk-W5TSNGEE.js";
 import "../chunk-62L3ORXN.js";
 import {
   piAdapter
-} from "../chunk-U7FNFTM5.js";
+} from "../chunk-P3GDM5RH.js";
 import {
   ALL_AGENT_NAMES,
   detectCurrentConfig,
@@ -74,7 +74,7 @@ import {
   resolveExecutingPackageVersion,
   updateOpenCodeMainConfig,
   writeLiteConfig
-} from "../chunk-OW6I7ZUU.js";
+} from "../chunk-QOIZYJ5C.js";
 
 // src/cli/index.ts
 import { pathToFileURL } from "url";

package/dist/cli/pi-install.d.ts

@@ -141,6 +141,7 @@ export declare function getPiExternalPackageSpecs(options?: Pick<PiSetupOptions,
 export declare function inspectPiSetupPackage(packages: readonly PiConfiguredPackage[], spec: PiSetupPackageSpec, requireManagedSource?: boolean): PiExternalPackageEvidence;
 export declare function piIncumbentTodoRecovery(source: string, scope: PiConfiguredPackage['scope'], identityLimitation?: string, unmappedSource?: boolean): string;
 export declare function resolvePiPreservationPackages(output: string, options: PiSetupOptions): PiConfiguredPackage[];
+export declare function mergePiCodemodeSettings(current: Record<string, unknown>): Record<string, unknown>;
 export declare function mergePiSubagentsConfig(current: Record<string, unknown>): Record<string, unknown>;
 export declare function mergePiGrepMcpConfig(current: Record<string, unknown>): Record<string, unknown>;
 export declare function mergePiRootBlock(current: string, managedBlock: string): string;

package/dist/cli/tui/index.js

@@ -2,10 +2,10 @@ import {
   defaultTuiOperations,
   effortChoicesForModel,
   listOperationHarnesses
-} from "../../chunk-7YCSKK2X.js";
+} from "../../chunk-W5TSNGEE.js";
 import "../../chunk-62L3ORXN.js";
-import "../../chunk-U7FNFTM5.js";
-import "../../chunk-OW6I7ZUU.js";
+import "../../chunk-P3GDM5RH.js";
+import "../../chunk-QOIZYJ5C.js";
 
 // src/cli/tui/index.tsx
 import { render } from "ink";

package/dist/config/constants.d.ts

@@ -4,7 +4,8 @@ export declare const SUBAGENT_NAMES: readonly ["explorer", "librarian", "oracle"
 export declare const ORCHESTRATOR_NAME: "orchestrator";
 export declare const ALL_AGENT_NAMES: readonly BuiltinAgentName[];
 export declare const SUBAGENT_DELEGATION_RULES: Record<AgentName, readonly string[]>;
-export declare const CONFIRMED_OPENAI_SUBAGENT_PRESET: {
+/** Previous shipped defaults, retained only for upgrade comparison. */
+export declare const LEGACY_OPENAI_PRESET: {
     readonly explorer: {
         readonly model: "gpt-6-luna";
         readonly effort: "low";
@@ -25,10 +26,36 @@ export declare const CONFIRMED_OPENAI_SUBAGENT_PRESET: {
         readonly model: "gpt-6-luna";
         readonly effort: "max";
     };
+    readonly orchestrator: {
+        readonly model: "gpt-6-sol";
+        readonly effort: "xhigh";
+    };
+};
+export declare const CONFIRMED_OPENAI_SUBAGENT_PRESET: {
+    readonly explorer: {
+        readonly model: "gpt-6-luna";
+        readonly effort: "max";
+    };
+    readonly librarian: {
+        readonly model: "gpt-6-luna";
+        readonly effort: "max";
+    };
+    readonly oracle: {
+        readonly model: "gpt-6.1-sol";
+        readonly effort: "xhigh";
+    };
+    readonly designer: {
+        readonly model: "gpt-6-luna";
+        readonly effort: "max";
+    };
+    readonly worker: {
+        readonly model: "gpt-6-luna";
+        readonly effort: "max";
+    };
 };
 export declare const OPENCODE_OPENAI_ORCHESTRATOR_PRESET: {
-    readonly model: "gpt-6-sol";
-    readonly effort: "xhigh";
+    readonly model: "gpt-6.1-sol";
+    readonly effort: "high";
 };
 export declare const DEFAULT_MODELS: Record<AgentName, string | undefined>;
 export declare function getDefaultOpenCodeModel(name: BuiltinAgentName): string;

package/dist/config/schema.d.ts

@@ -54,6 +54,7 @@ export declare const AgentOverrideConfigSchema: z.ZodObject<{
         id: z.ZodString;
         variant: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>]>>]>>;
+    skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
     temperature: z.ZodOptional<z.ZodNumber>;
     steps: z.ZodOptional<z.ZodNumber>;
     variant: z.ZodCatch<z.ZodOptional<z.ZodString>>;
@@ -89,6 +90,7 @@ export declare const PresetSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
         id: z.ZodString;
         variant: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>]>>]>>;
+    skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
     temperature: z.ZodOptional<z.ZodNumber>;
     steps: z.ZodOptional<z.ZodNumber>;
     variant: z.ZodCatch<z.ZodOptional<z.ZodString>>;
@@ -180,6 +182,7 @@ export declare const PluginConfigSchema: z.ZodObject<{
             id: z.ZodString;
             variant: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>]>>]>>;
+        skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
         temperature: z.ZodOptional<z.ZodNumber>;
         steps: z.ZodOptional<z.ZodNumber>;
         variant: z.ZodCatch<z.ZodOptional<z.ZodString>>;
@@ -189,6 +192,7 @@ export declare const PluginConfigSchema: z.ZodObject<{
             id: z.ZodString;
             variant: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>]>>]>>;
+        skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
         temperature: z.ZodOptional<z.ZodNumber>;
         steps: z.ZodOptional<z.ZodNumber>;
         variant: z.ZodCatch<z.ZodOptional<z.ZodString>>;

package/dist/harness/adapters/claude-code.d.ts

@@ -13,7 +13,7 @@ export declare const CLAUDE_CODE_SUBAGENT_DEFAULT_MODELS: {
     readonly worker: "sonnet";
 };
 export declare const CLAUDE_CODE_SUBAGENT_DEFAULT_EFFORTS: {
-    readonly explorer: "low";
+    readonly explorer: "medium";
     readonly designer: "medium";
     readonly worker: "medium";
     readonly librarian: "high";

package/dist/harness/core/agent-pack.d.ts

@@ -1,3 +1,5 @@
+export type { OracleReview, OracleReviewKind, ResultCommon, SpecialistResult, SpecialistRole, } from './result-contract';
+export { getSpecialistResultFields, SPECIALIST_RESULT_CONTRACT, } from './result-contract';
 export type AgentRoleName = 'orchestrator' | 'explorer' | 'librarian' | 'oracle' | 'designer' | 'worker';
 export type AgentMutationMode = 'adaptive-root' | 'read-only' | 'write-capable';
 export type AgentDispatchMethod = 'root-coordinator' | 'task';
@@ -151,11 +153,13 @@ export declare const AGENT_RETURN_CONTRACT: {
     readonly explorer: readonly ["conclusion", "evidence", "verification", "risks", "openQuestions"];
     readonly librarian: readonly ["conclusion", "evidence", "verification", "risks", "openQuestions"];
     readonly oracle: readonly ["conclusion", "evidence", "verification", "risks", "openQuestions", "nextAction"];
-    readonly designer: readonly ["conclusion", "evidence", "verification", "risks", "openQuestions", "nextAction"];
-    readonly worker: readonly ["conclusion", "evidence", "verification", "risks", "openQuestions", "nextAction"];
+    readonly designer: readonly ["conclusion", "evidence", "verification", "risks", "openQuestions", "nextAction", "changedFiles"];
+    readonly worker: readonly ["conclusion", "evidence", "verification", "risks", "openQuestions", "nextAction", "changedFiles"];
 };
 export declare const VERIFICATION_PROTOCOL: readonly ["Completion reports identify changed files and verification evidence.", "Behavior changes receive the smallest sufficient automated check or a declared manual check.", "Visual changes receive designer-owned visual QA when applicable."];
 export declare const AGENT_PACK_CONTRACT: AgentPackContract;
 export declare function getAgentRole(name: AgentRoleName): AgentRoleContract;
+/** Keep non-gate returns independent of the Oracle validator contract. */
+export declare function renderSpecialistResultContract(role: Exclude<AgentRoleName, 'orchestrator'>): string;
 export declare function renderAgentRoutingDescription(role: AgentRoleContract): string;
 export declare function getAgentPackContract(): AgentPackContract;

package/dist/harness/core/result-contract.d.ts

@@ -0,0 +1,366 @@
+declare const common: {
+    readonly type: "object";
+    readonly properties: {
+        readonly schemaVersion: {
+            readonly type: "number";
+            readonly const: 1;
+        };
+        readonly role: {
+            readonly type: "string";
+            readonly enum: readonly ["oracle"];
+        };
+        readonly status: {
+            readonly type: "string";
+            readonly enum: readonly ["complete", "partial", "blocked", "failed"];
+        };
+        readonly conclusion: {
+            readonly type: "string";
+        };
+        readonly evidence: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly id: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly kind: {
+                        readonly type: "string";
+                    };
+                    readonly locator: {
+                        readonly type: "string";
+                    };
+                    readonly claim: {
+                        readonly type: "string";
+                    };
+                    readonly basis: {
+                        readonly type: "string";
+                        readonly enum: readonly ["observed", "inferred"];
+                    };
+                    readonly uncertainty: {
+                        readonly type: "string";
+                    };
+                };
+                readonly required: string[];
+                readonly additionalProperties: false;
+            };
+        };
+        readonly verification: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly check: {
+                        readonly type: "string";
+                    };
+                    readonly method: {
+                        readonly type: "string";
+                    };
+                    readonly outcome: {
+                        readonly type: "string";
+                        readonly enum: readonly ["pass", "fail", "not-run"];
+                    };
+                    readonly evidenceIds: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly reason: {
+                        readonly type: "string";
+                    };
+                };
+                readonly required: string[];
+                readonly additionalProperties: false;
+            };
+        };
+        readonly risks: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly description: {
+                        readonly type: "string";
+                    };
+                    readonly severity: {
+                        readonly type: "string";
+                        readonly enum: readonly ["low", "medium", "high", "critical"];
+                    };
+                    readonly blocking: {
+                        readonly type: "boolean";
+                    };
+                    readonly evidenceIds: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                    };
+                };
+                readonly required: string[];
+                readonly additionalProperties: false;
+            };
+        };
+        readonly openQuestions: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly question: {
+                        readonly type: "string";
+                    };
+                    readonly owner: {
+                        readonly type: "string";
+                    };
+                    readonly options: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly facts: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                    };
+                };
+                readonly required: string[];
+                readonly additionalProperties: false;
+            };
+        };
+    };
+    readonly required: string[];
+    readonly additionalProperties: false;
+};
+export declare const SPECIALIST_RESULT_CONTRACT: {
+    readonly schemaVersion: 1;
+    readonly fence: "thoth-result";
+    readonly common: {
+        readonly type: "object";
+        readonly properties: {
+            readonly schemaVersion: {
+                readonly type: "number";
+                readonly const: 1;
+            };
+            readonly role: {
+                readonly type: "string";
+                readonly enum: readonly ["oracle"];
+            };
+            readonly status: {
+                readonly type: "string";
+                readonly enum: readonly ["complete", "partial", "blocked", "failed"];
+            };
+            readonly conclusion: {
+                readonly type: "string";
+            };
+            readonly evidence: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly id: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly kind: {
+                            readonly type: "string";
+                        };
+                        readonly locator: {
+                            readonly type: "string";
+                        };
+                        readonly claim: {
+                            readonly type: "string";
+                        };
+                        readonly basis: {
+                            readonly type: "string";
+                            readonly enum: readonly ["observed", "inferred"];
+                        };
+                        readonly uncertainty: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly required: string[];
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly verification: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly check: {
+                            readonly type: "string";
+                        };
+                        readonly method: {
+                            readonly type: "string";
+                        };
+                        readonly outcome: {
+                            readonly type: "string";
+                            readonly enum: readonly ["pass", "fail", "not-run"];
+                        };
+                        readonly evidenceIds: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly reason: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly required: string[];
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly risks: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly description: {
+                            readonly type: "string";
+                        };
+                        readonly severity: {
+                            readonly type: "string";
+                            readonly enum: readonly ["low", "medium", "high", "critical"];
+                        };
+                        readonly blocking: {
+                            readonly type: "boolean";
+                        };
+                        readonly evidenceIds: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                        };
+                    };
+                    readonly required: string[];
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly openQuestions: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly question: {
+                            readonly type: "string";
+                        };
+                        readonly owner: {
+                            readonly type: "string";
+                        };
+                        readonly options: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly facts: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                        };
+                    };
+                    readonly required: string[];
+                    readonly additionalProperties: false;
+                };
+            };
+        };
+        readonly required: string[];
+        readonly additionalProperties: false;
+    };
+    readonly roles: {
+        readonly oracle: {
+            readonly type: "object";
+            readonly properties: {
+                readonly nextAction: {
+                    readonly type: readonly ["string", "null"];
+                };
+                readonly review: {
+                    readonly required: readonly ["kind", "verdict"];
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly kind: {
+                            readonly type: "string";
+                            readonly enum: readonly ["plan-review", "final-verification"];
+                        };
+                        readonly verdict: {
+                            readonly type: "string";
+                        };
+                        readonly reviewedRecord: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly reviewedRecordSha256: {
+                            readonly type: "string";
+                            readonly pattern: "^[a-f0-9]{64}$";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly required: string[];
+            readonly additionalProperties: false;
+        };
+    };
+    readonly reviewKinds: {
+        readonly 'plan-review': {
+            readonly verdicts: readonly ["OKAY", "REJECT"];
+        };
+        readonly 'final-verification': {
+            readonly verdicts: readonly ["PASS", "FAIL", "BLOCKED"];
+        };
+    };
+    readonly rules: {
+        readonly positiveVerdicts: readonly ["OKAY", "PASS"];
+        readonly positiveStatus: "complete";
+        readonly positiveAllowsBlockingRisks: false;
+        readonly evidenceIdUnique: true;
+        readonly evidenceReferences: readonly ["verification", "risks"];
+        readonly recordBindingReviewKind: "final-verification";
+        readonly recordBindingRequiredFields: readonly ["reviewedRecord", "reviewedRecordSha256"];
+        readonly recordBindingForbiddenUnderNoRecord: readonly ["reviewedRecord", "reviewedRecordSha256"];
+    };
+};
+export type SpecialistRole = keyof typeof SPECIALIST_RESULT_CONTRACT.roles;
+export type OracleReviewKind = keyof typeof SPECIALIST_RESULT_CONTRACT.reviewKinds;
+type SchemaValue<S> = S extends {
+    const: infer C;
+} ? C : S extends {
+    enum: readonly (infer E)[];
+} ? E : S extends {
+    type: 'object';
+    properties: infer P;
+    required: readonly string[];
+} ? {
+    [K in keyof P]: SchemaValue<P[K]>;
+} : S extends {
+    type: 'array';
+    items: infer I;
+} ? SchemaValue<I>[] : S extends {
+    type: 'string';
+} ? string : S extends {
+    type: 'number';
+} ? number : S extends {
+    type: 'boolean';
+} ? boolean : S extends {
+    type: readonly ['string', 'null'];
+} ? string | null : never;
+export type ResultCommon = SchemaValue<typeof common>;
+export type OracleReview = {
+    [K in OracleReviewKind]: {
+        kind: K;
+        verdict: (typeof SPECIALIST_RESULT_CONTRACT.reviewKinds)[K]['verdicts'][number];
+        reviewedRecord?: string;
+        reviewedRecordSha256?: string;
+    };
+}[OracleReviewKind];
+export type SpecialistResult = ResultCommon & {
+    nextAction: string | null;
+    review: OracleReview;
+};
+/** Required field names for compact role-specific prompt rendering. */
+export declare function getSpecialistResultFields(role: SpecialistRole): readonly string[];
+export {};