thoth-agents 0.5.1 → 0.7.0

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

@@ -1,13 +1,18 @@
+import { type PiExternalPackageEvidence, type PiExternalPackageSpec } from './pi-external-package';
 import { type PiPackageReceipt, type PiPackageReceiptOptions } from './pi-package-receipt';
 import { type PiPathOptions, type PiPaths } from './pi-paths';
 export declare const PI_MINIMUM_VERSION = "0.99.0";
 export declare const PI_NODE_MINIMUM = "22.19.0";
 export declare const PI_COMMAND_TIMEOUT_MS = 120000;
+export interface PiSetupPackageSpec extends PiExternalPackageSpec {
+    id: string;
+    preserveUserCopy?: boolean;
+}
 export declare const PI_PACKAGE_SPECS: readonly [{
     readonly id: "delegation";
-    readonly source: "npm:@thoth-agents/pi-subagents@>=0.1.0";
+    readonly source: "npm:@thoth-agents/pi-subagents@>=0.3.0";
     readonly packageName: "@thoth-agents/pi-subagents";
-    readonly version: "0.1.0";
+    readonly version: "0.3.0";
 }, {
     readonly id: "context7";
     readonly source: "npm:@upstash/context7-pi@>=0.1.2";
@@ -25,14 +30,32 @@ export declare const PI_PACKAGE_SPECS: readonly [{
     readonly version: "2.32.1";
 }, {
     readonly id: "ask-user-question";
-    readonly source: "npm:@thoth-agents/pi-questions-user@>=0.1.0";
+    readonly source: "npm:@thoth-agents/pi-questions-user@>=0.3.0";
     readonly packageName: "@thoth-agents/pi-questions-user";
-    readonly version: "0.1.0";
+    readonly version: "0.3.0";
 }, {
     readonly id: "todo";
-    readonly source: "npm:@thoth-agents/pi-todo@>=0.1.0";
+    readonly source: "npm:@thoth-agents/pi-todo@>=0.3.0";
     readonly packageName: "@thoth-agents/pi-todo";
-    readonly version: "0.1.0";
+    readonly version: "0.3.0";
+}, {
+    readonly id: "theme";
+    readonly source: "npm:@thoth-agents/pi-thoth-theme@>=0.3.0";
+    readonly packageName: "@thoth-agents/pi-thoth-theme";
+    readonly version: "0.3.0";
+    readonly preserveUserCopy: true;
+}, {
+    readonly id: "background-tasks";
+    readonly source: "npm:@thoth-agents/pi-background-tasks@>=0.3.0";
+    readonly packageName: "@thoth-agents/pi-background-tasks";
+    readonly version: "0.3.0";
+    readonly preserveUserCopy: true;
+}, {
+    readonly id: "sidebar";
+    readonly source: "npm:@thoth-agents/pi-sidebar@>=0.3.0";
+    readonly packageName: "@thoth-agents/pi-sidebar";
+    readonly version: "0.3.0";
+    readonly preserveUserCopy: true;
 }];
 export declare const PI_GREP_MCP_ENTRY: {
     readonly url: "https://mcp.grep.app";
@@ -114,68 +137,11 @@ export declare function verifyPiFirstPartyPackage(input: {
     error: string;
 };
 export declare function isPiIncumbentDelegationSource(source: string): boolean;
-export declare function getPiExternalPackageSpecs(options?: Pick<PiSetupOptions, 'runtimePackageRoot'>): readonly [{
-    readonly id: "delegation";
-    readonly source: "npm:@thoth-agents/pi-subagents@>=0.1.0";
-    readonly packageName: "@thoth-agents/pi-subagents";
-    readonly version: "0.1.0";
-}, {
-    readonly id: "context7";
-    readonly source: "npm:@upstash/context7-pi@>=0.1.2";
-    readonly packageName: "@upstash/context7-pi";
-    readonly version: "0.1.2";
-}, {
-    readonly id: "web-access";
-    readonly source: "npm:pi-web-access@>=0.27.0";
-    readonly packageName: "pi-web-access";
-    readonly version: "0.27.0";
-}, {
-    readonly id: "grep-adapter";
-    readonly source: "npm:pi-mcp-adapter@>=2.32.1";
-    readonly packageName: "pi-mcp-adapter";
-    readonly version: "2.32.1";
-}, {
-    readonly id: "ask-user-question";
-    readonly source: "npm:@thoth-agents/pi-questions-user@>=0.1.0";
-    readonly packageName: "@thoth-agents/pi-questions-user";
-    readonly version: "0.1.0";
-}, {
-    readonly id: "todo";
-    readonly source: "npm:@thoth-agents/pi-todo@>=0.1.0";
-    readonly packageName: "@thoth-agents/pi-todo";
-    readonly version: "0.1.0";
-}] | ({
-    readonly id: "context7";
-    readonly source: "npm:@upstash/context7-pi@>=0.1.2";
-    readonly packageName: "@upstash/context7-pi";
-    readonly version: "0.1.2";
-} | {
-    readonly id: "web-access";
-    readonly source: "npm:pi-web-access@>=0.27.0";
-    readonly packageName: "pi-web-access";
-    readonly version: "0.27.0";
-} | {
-    readonly id: "grep-adapter";
-    readonly source: "npm:pi-mcp-adapter@>=2.32.1";
-    readonly packageName: "pi-mcp-adapter";
-    readonly version: "2.32.1";
-} | {
-    readonly id: "ask-user-question";
-    readonly source: "npm:@thoth-agents/pi-questions-user@>=0.1.0";
-    readonly packageName: "@thoth-agents/pi-questions-user";
-    readonly version: "0.1.0";
-} | {
-    readonly id: "todo";
-    readonly source: "npm:@thoth-agents/pi-todo@>=0.1.0";
-    readonly packageName: "@thoth-agents/pi-todo";
-    readonly version: "0.1.0";
-} | {
-    source: string;
-    id: "delegation";
-    packageName: "@thoth-agents/pi-subagents";
-    version: "0.1.0";
-})[];
+export declare function getPiExternalPackageSpecs(options?: Pick<PiSetupOptions, 'runtimePackageRoot'>): readonly PiSetupPackageSpec[];
+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;
@@ -190,6 +156,8 @@ export interface PiConfiguredPackage {
     packageName?: string;
     packageVersion?: string;
     identityLimitation?: string;
+    /** Scoped settings explicitly disable extensions and select only resources. */
+    resourceOnly?: boolean;
     /** Directory-only evidence; source is a display path, not a removal source. */
     unmappedSource?: boolean;
 }

package/dist/cli/pi-tool-config.d.ts

@@ -30,3 +30,22 @@ export declare function validatePiSpecialistTools(tools: readonly string[]): voi
 export declare function readPiSpecialistToolOverrides(content: string): PiSpecialistToolOverrides;
 export declare function readPiToolConfig(piRoot: string, roles?: readonly PiSpecialistRole[]): PiToolConfigSnapshot;
 export declare function savePiToolConfig(snapshot: PiToolConfigSnapshot, roles: readonly PiToolRoleInput[]): PiToolSaveResult;
+/** Structural pi-subagents v1 adapter; root has no dependency on its runtime. */
+export declare function createPiToolsPanelAdapter(piRoot: string): {
+    version: 1;
+    appliesTo(target: {
+        role: string;
+        filePath: string;
+        scope: "global" | "project";
+    }, content: string): boolean;
+    validate(target: {
+        role: string;
+        filePath: string;
+        scope: "global" | "project";
+    }, content: string): void;
+    defaultTools(target: {
+        role: string;
+        filePath: string;
+        scope: "global" | "project";
+    }, content: string): string[];
+};

package/dist/cli/tui/index.js

@@ -2,10 +2,10 @@ import {
   defaultTuiOperations,
   effortChoicesForModel,
   listOperationHarnesses
-} from "../../chunk-VUNYH263.js";
+} from "../../chunk-W5TSNGEE.js";
 import "../../chunk-62L3ORXN.js";
-import "../../chunk-V7HSGRMB.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 {};

package/dist/harness/core/sdd.d.ts

@@ -227,7 +227,7 @@ export declare const SDD_PHASE_PROTOCOLS: readonly [{
     readonly id: "plan-review";
     readonly objective: "Offer optional independent blocker review after the ready plan.";
     readonly requiredInputs: ["Ready substantial record", "Selected review disposition"];
-    readonly instructions: ["At ready, first show the user a concise plan summary (goal, acceptance, units, risks), then always offer “Review plan with Oracle (Recommended)” or “Implement directly without review”; record the plan-review choice as EXPLICIT_REVIEW for an explicit review answer, EXPLICIT_SKIP for an explicit direct answer, or DEFAULT_REVIEW_AFTER_3 only when the third confirmed empty return selects review. Keep selection provenance separate from implementation authorization; silence never means EXPLICIT_SKIP.", "For every orchestrator choice with a meaningful safe recommendation, after its first and second confirmed empty native returns repeat the same question and do no dependent work; after the third confirmed empty native return choose the recommendation. Explicit answers and Stop win. Pending, unavailable, failed, interrupted or host-prohibited questions do not count. If higher-priority host or tool rules prevent asking or repeating, obey them and report the limitation rather than claiming three returns or an explicit selection.", "Never fabricate facts or secrets; recommend safe deferral when needed information or material intent is unresolved, and keep dependent work blocked.", "Review scope, approach, risks, and acceptance coverage without redesigning settled intent.", "Return actionable blockers and cautions; a pass is not implementation authorization or final verification.", "After [OKAY], preserve the separate Implement (Recommended) / Stop authorization decision; honor applicable prior explicit authorization, and let explicit Stop supersede it.", "A plan review does not substitute for fresh final verification."];
+    readonly instructions: ["At ready, first show the user a concise plan summary (goal, acceptance, units, risks), then always offer “Review plan with Oracle (Recommended)” or “Proceed without review”; record the plan-review choice as EXPLICIT_REVIEW for an explicit review answer, EXPLICIT_SKIP for an explicit direct answer, or DEFAULT_REVIEW_AFTER_3 only when the third confirmed empty return selects review. Keep selection provenance separate from implementation authorization; silence never means EXPLICIT_SKIP.", "For every orchestrator choice with a meaningful safe recommendation, after its first and second confirmed empty native returns repeat the same question and do no dependent work; after the third confirmed empty native return choose the recommendation. Explicit answers and Stop win. Pending, unavailable, failed, interrupted or host-prohibited questions do not count. If higher-priority host or tool rules prevent asking or repeating, obey them and report the limitation rather than claiming three returns or an explicit selection.", "Never fabricate facts or secrets; recommend safe deferral when needed information or material intent is unresolved, and keep dependent work blocked.", "Review scope, approach, risks, and acceptance coverage without redesigning settled intent.", "Return actionable blockers and cautions; a pass is not implementation authorization or final verification.", "After [OKAY], preserve the separate Implement (Recommended) / Stop authorization decision; honor applicable prior explicit authorization, and let explicit Stop supersede it.", "A plan review does not substitute for fresh final verification."];
     readonly outputSchema: ["status", "blockers", "cautions"];
     readonly doneWhen: ["The selected review has a current, evidence-backed disposition."];
     readonly blockingConditions: ["A blocking finding remains unresolved."];