thoth-agents 0.3.11 → 0.4.0

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

@@ -0,0 +1,131 @@
+import { type PiPackageReceipt, type PiPackageReceiptOptions } from './pi-package-receipt';
+import { type PiPathOptions, type PiPaths } from './pi-paths';
+export declare const PI_MINIMUM_VERSION = "0.84.4";
+export declare const PI_NODE_MINIMUM = "22.19.0";
+export declare const PI_COMMAND_TIMEOUT_MS = 120000;
+export declare const PI_PACKAGE_SPECS: readonly [{
+    readonly id: "delegation";
+    readonly source: "npm:pi-subagents-j0k3r@1.5.9";
+    readonly packageName: "pi-subagents-j0k3r";
+    readonly version: "1.5.9";
+}, {
+    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:@juicesharp/rpiv-ask-user-question@2.9.0";
+    readonly packageName: "@juicesharp/rpiv-ask-user-question";
+    readonly version: "2.9.0";
+}, {
+    readonly id: "todo";
+    readonly source: "npm:@juicesharp/rpiv-todo@2.9.0";
+    readonly packageName: "@juicesharp/rpiv-todo";
+    readonly version: "2.9.0";
+}];
+export declare const PI_GREP_MCP_ENTRY: {
+    readonly url: "https://mcp.grep.app";
+    readonly protocolVersion: "legacy";
+    readonly lifecycle: "lazy";
+};
+export interface PiCommandResult {
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+    error?: unknown;
+}
+export type PiCommandExecutor = (command: string, args: readonly string[]) => PiCommandResult;
+export interface PiSetupOptions extends PiPathOptions {
+    dryRun?: boolean;
+    commandExecutor?: PiCommandExecutor;
+    expectedVersion?: string;
+    packageRoot?: string;
+    firstPartySource?: string;
+    receiptOptions?: PiPackageReceiptOptions;
+    verifyFirstParty?: (input: {
+        source: string;
+        installSource: string;
+        version: string;
+        packageRoot: string;
+    }) => {
+        success: true;
+        receipt: PiPackageReceipt;
+    } | {
+        success: false;
+        error: string;
+    };
+}
+export interface PiSetupPlanItem {
+    kind: 'preflight' | 'package' | 'root' | 'agent' | 'mcp';
+    description: string;
+    target: string;
+    command?: {
+        command: string;
+        args: string[];
+    };
+    content?: string;
+}
+export interface PiSetupPlan {
+    dryRun: boolean;
+    ready: boolean;
+    paths: PiPaths;
+    items: PiSetupPlanItem[];
+    blockers: string[];
+    diagnostics: string[];
+    disclaimers: string[];
+    options: PiSetupOptions;
+}
+export interface PiApplyResult {
+    success: boolean;
+    changed: string[];
+    diagnostics: string[];
+    error?: string;
+    failedStep?: string;
+    installedPackages: string[];
+    receiptCommitted?: boolean;
+    rollbackFailed?: boolean;
+    manualRecovery?: string;
+    configuredPackageRoot?: string;
+}
+export declare function getPiFirstPartySource(version: string): string;
+export declare function verifyPiFirstPartyPackage(input: {
+    source: string;
+    installSource: string;
+    version: string;
+    packageRoot: string;
+}): {
+    success: true;
+    receipt: PiPackageReceipt;
+} | {
+    success: false;
+    error: string;
+};
+export declare function mergePiGrepMcpConfig(current: Record<string, unknown>): Record<string, unknown>;
+export declare function mergePiRootBlock(current: string, managedBlock: string): string;
+export declare function buildPiSetupPlan(options?: PiSetupOptions): PiSetupPlan;
+export declare function formatPiSetupPlan(plan: PiSetupPlan): string;
+export declare function isVersionAtLeast(actual: string, expected: string): boolean;
+export declare function hasExactInstalledPiPackage(output: string, source: string): boolean;
+export interface PiConfiguredPackage {
+    scope: 'user' | 'project';
+    source: string;
+    installedPath?: string;
+    packageName?: string;
+    packageVersion?: string;
+}
+export declare function parsePiPackageList(output: string): PiConfiguredPackage[];
+export declare function isThothPackageLocation(candidate: PiConfiguredPackage, knownSource?: string): boolean;
+export declare function getPiFirstPartyPackages(packages: readonly PiConfiguredPackage[], knownSource?: string): PiConfiguredPackage[];
+export declare function writePiManagedText(path: string, content: string): boolean;
+export declare function applyPiSetup(plan: PiSetupPlan): PiApplyResult;

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

@@ -0,0 +1,12 @@
+export interface PiLegacyMigrationOptions {
+    packageRoot: string;
+    piRoot: string;
+    dryRun?: boolean;
+}
+export interface PiLegacyMigrationResult {
+    success: boolean;
+    changed: string[];
+    manualActions: string[];
+    error?: string;
+}
+export declare function migrateLegacyPiResources(options: PiLegacyMigrationOptions): PiLegacyMigrationResult;

package/dist/cli/pi-native-probe.d.ts

@@ -0,0 +1,34 @@
+export type PiNativeObservationState = 'observed-at-install' | 'unobserved' | 'unavailable';
+export interface PiNativeProbeCommandResult {
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+    error?: unknown;
+}
+export type PiNativeProbeExecutor = (command: string, args: readonly string[], env: Readonly<Record<string, string | undefined>>) => PiNativeProbeCommandResult;
+export interface PiNativeProbeOptions {
+    extensionPath: string;
+    packageRoot?: string;
+    piHome?: string;
+    manifestSha256: string;
+    extensionSha256: string;
+    commandExecutor?: PiNativeProbeExecutor;
+    piCommand?: string;
+    probePrompt?: string;
+}
+export interface PiNativeProbeResult {
+    state: PiNativeObservationState;
+    basis: string[];
+    command: {
+        command: string;
+        args: string[];
+    };
+    discoveredSkills?: Array<{
+        name: string;
+        location: string;
+    }>;
+    materializedSpecialists?: string[];
+    orchestratorChild?: boolean;
+    sessionStartCount?: number;
+}
+export declare function observePiNativeRoot(options: PiNativeProbeOptions): PiNativeProbeResult;

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

@@ -0,0 +1,59 @@
+export declare const PI_PACKAGE_RECEIPT_SCHEMA_VERSION: 1;
+export interface PiPackageReceipt {
+    schemaVersion: typeof PI_PACKAGE_RECEIPT_SCHEMA_VERSION;
+    owner: 'thoth-agents';
+    scope: 'user';
+    packageName: 'thoth-agents';
+    source: string;
+    installSource: string;
+    version: string;
+    manifestSha256: string;
+    extensionSha256: string;
+}
+export interface PiPackageReceiptOptions {
+    configRoot?: string;
+    homeDir?: string;
+    env?: Readonly<Record<string, string | undefined>>;
+}
+export type PiPackageReceiptReadResult = {
+    status: 'missing';
+    path: string;
+} | {
+    status: 'invalid';
+    path: string;
+    error: string;
+} | {
+    status: 'valid';
+    path: string;
+    receipt: PiPackageReceipt;
+};
+export type PiPackageOwnershipState = 'missing' | 'configured-unowned' | 'owned-missing' | 'owned-current' | 'conflicting';
+export declare function piPackagePathsEqual(left: string, right: string): boolean;
+export declare function getPiPackageReceiptPath(options?: PiPackageReceiptOptions): string;
+export declare function readPiPackageReceipt(options?: PiPackageReceiptOptions): PiPackageReceiptReadResult;
+export declare function writePiPackageReceipt(receipt: PiPackageReceipt, options?: PiPackageReceiptOptions): {
+    success: true;
+    path: string;
+} | {
+    success: false;
+    path: string;
+    error: string;
+};
+export declare function classifyPiPackageOwnership(input: {
+    receipt: PiPackageReceiptReadResult;
+    globalPackages: readonly {
+        source: string;
+        installedPath?: string;
+        packageName?: string;
+        packageVersion?: string;
+    }[];
+    projectPackages: readonly {
+        source: string;
+        installedPath?: string;
+        packageName?: string;
+        packageVersion?: string;
+    }[];
+}): {
+    state: PiPackageOwnershipState;
+    reason?: string;
+};

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

@@ -0,0 +1,20 @@
+export interface PiPathOptions {
+    homeDir?: string;
+    cwd?: string;
+    env?: Readonly<Record<string, string | undefined>>;
+}
+export interface PiPaths {
+    homeDir: string;
+    piRoot: string;
+    defaultPiRoot: string;
+    customPiRoot: boolean;
+    skillsDestinationCompatible: boolean;
+    appendSystemPath: string;
+    agentsRoot: string;
+    alternateAgentsRoot: string;
+    ownedSkillsRoot: string;
+    mcpConfigPath: string;
+    projectAgentRoots: string[];
+    projectMcpPaths: string[];
+}
+export declare function resolvePiPaths(options?: PiPathOptions): PiPaths;

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

@@ -0,0 +1,15 @@
+export declare const PI_SPECIALIST_NAMES: ("thoth-explorer" | "thoth-librarian" | "thoth-oracle" | "thoth-designer" | "thoth-quick" | "thoth-deep")[];
+export interface PiSpecialistSyncOptions {
+    packageRoot: string;
+    piRoot: string;
+    dryRun?: boolean;
+    projectRoots?: readonly string[];
+}
+export interface PiSpecialistSyncResult {
+    success: boolean;
+    changed: string[];
+    conflicts: string[];
+    diagnostics: string[];
+    error?: string;
+}
+export declare function syncPiSpecialists(options: PiSpecialistSyncOptions): PiSpecialistSyncResult;

package/dist/cli/skills.d.ts

@@ -1,5 +1,5 @@
 import { type NpxCommand, type NpxCommandOptions } from './npx-command';
-export type SkillInstallHarness = 'opencode' | 'codex' | 'claude';
+export type SkillInstallHarness = 'opencode' | 'codex' | 'claude' | 'pi';
 /** An external skill required by every supported thoth-agents harness. */
 export interface RequiredSkill {
     name: string;

package/dist/cli/tui/index.js

@@ -2,8 +2,10 @@ import {
   defaultTuiOperations,
   effortChoicesForModel,
   listOperationHarnesses
-} from "../../chunk-ZEAAWBF2.js";
-import "../../chunk-GIUU6FNE.js";
+} from "../../chunk-WJ2YMM2E.js";
+import "../../chunk-62L3ORXN.js";
+import "../../chunk-SECDI3TL.js";
+import "../../chunk-Q6SDM4KP.js";
 
 // src/cli/tui/index.tsx
 import { render } from "ink";
@@ -190,7 +192,7 @@ function ModelScreen({
   actions
 }) {
   return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx4(Text4, { color: theme.dim, children: harness === "codex" ? "Codex writes generated subagent model lines only." : harness === "claude" ? "Claude Code writes subagent frontmatter model lines (sonnet, opus, haiku, inherit)." : "OpenCode writes role model overrides in thoth-agents config." }),
+    /* @__PURE__ */ jsx4(Text4, { color: theme.dim, children: harness === "codex" ? "Codex writes generated subagent model lines only." : harness === "claude" ? "Claude Code writes subagent frontmatter model lines (sonnet, opus, haiku, inherit)." : harness === "pi" ? "Pi writes model and effort only in thoth-agents-owned specialist frontmatter; the ambient root model remains Pi-owned." : "OpenCode writes role model overrides in thoth-agents config." }),
     harness === "codex" ? CODEX_MODEL_CATALOG_NOTE.map((note) => /* @__PURE__ */ jsx4(Text4, { color: theme.dim, children: note }, note)) : null,
     roles.map((role, index) => /* @__PURE__ */ jsxs4(
       Text4,
@@ -792,6 +794,12 @@ function buildHarnessItems() {
     { id: "back", action: "back", label: "Back", detail: "Return" }
   ];
 }
+function harnessDisplayName(harness) {
+  if (harness === "codex") return "Codex";
+  if (harness === "claude") return "Claude Code";
+  if (harness === "pi") return "Pi";
+  return "OpenCode";
+}
 function moveSelection(current, direction, items) {
   let next = current;
   for (let index = 0; index < items.length; index += 1) {
@@ -1361,7 +1369,7 @@ function App({
       /* @__PURE__ */ jsx8(
         Header,
         {
-          title: `${modelHarness === "codex" ? "Codex" : modelHarness === "claude" ? "Claude Code" : "OpenCode"} Models`,
+          title: `${harnessDisplayName(modelHarness)} Models`,
           subtitle: "Enter edits a role. Dirty rows are marked with *."
         }
       ),

package/dist/cli/tui/operations.d.ts

@@ -17,5 +17,6 @@ export declare const opencodeModelRoles: ModelRoleInput[];
 export declare const codexModelRoles: ModelRoleInput[];
 export declare function getCodexModelRoles(source?: CodexOperationContext): ModelRoleInput[];
 export declare function getClaudeCodeModelRoles(_source?: ClaudeCodeOperationContext): ModelRoleInput[];
+export declare function getPiModelRoles(): ModelRoleInput[];
 export declare function getOpenCodeModelRoles(): ModelRoleInput[];
 export declare const defaultTuiOperations: TuiOperations;

package/dist/cli/types.d.ts

@@ -1,8 +1,9 @@
 export type BooleanArg = 'yes' | 'no';
-export type InstallAgent = 'opencode' | 'codex' | 'claude';
+export type InstallAgent = 'opencode' | 'codex' | 'claude' | 'pi';
 export interface InstallArgs {
     tui: boolean;
     agent?: InstallAgent;
+    localPackageRoot?: string;
     tmux?: BooleanArg;
     dryRun?: boolean;
     reset?: boolean;
@@ -12,7 +13,7 @@ export interface GenerateArgs {
     dryRun?: boolean;
     outputRoot?: string;
 }
-export type OperationHarnessArg = 'opencode' | 'codex' | 'claude';
+export type OperationHarnessArg = 'opencode' | 'codex' | 'claude' | 'pi';
 export interface CliModelRoleArg {
     role: string;
     model?: string;
@@ -53,6 +54,7 @@ export interface OpenCodeConfig {
 export interface InstallConfig {
     agent: InstallAgent;
     hasTmux: boolean;
+    localPackageRoot?: string;
     dryRun?: boolean;
     reset: boolean;
 }

package/dist/harness/adapters/pi.d.ts

@@ -0,0 +1,8 @@
+import { type PluginConfig } from '../../config';
+import type { HarnessAdapter, HarnessCapabilities, HarnessRenderContext } from '../types';
+export interface PiRenderContext extends HarnessRenderContext {
+    config?: PluginConfig;
+}
+export declare const PI_CAPABILITIES: HarnessCapabilities;
+export declare function renderPiRootInstructions(config?: PluginConfig): string;
+export declare const piAdapter: HarnessAdapter;

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

@@ -19,8 +19,28 @@ export interface OrchestrationPolicy {
     maxDelegationDepth: number;
     singleWriter: boolean;
     implementationOwnership: ImplementationOwnershipPolicy;
+    taskShaping: TaskShapingPolicy;
+    specialistDirectory: SpecialistDecision[];
     rules: string[];
 }
+export type TaskShapingStep = 'bound-work' | 'map-dependencies' | 'assign-ownership' | 'select-specialists' | 'mark-ready-and-blocked' | 'dispatch-ready-wave' | 'wait-for-terminal-evidence' | 'reconcile-and-verify';
+export interface TaskShapingPolicy {
+    steps: TaskShapingStep[];
+    nativeAuthority: boolean;
+    boundedWidth: boolean;
+    decisions: {
+        dependency: string;
+        ownershipConflict: string;
+        readyWave: string;
+        terminalEvidence: string;
+        degradation: string;
+    };
+}
+export interface SpecialistDecision {
+    role: Exclude<AgentRoleName, 'orchestrator'>;
+    selectWhen: string;
+    rejectWhen: string;
+}
 export type ImplementationOwner = 'orchestrator' | 'designer' | 'quick' | 'deep';
 export interface ImplementationOwnershipPolicy {
     eligibleOwners: ImplementationOwner[];
@@ -43,12 +63,12 @@ export declare const AGENT_ROLES: readonly [{
     readonly dispatch: "root-coordinator";
     readonly canMutateWorkspace: true;
     readonly scope: "requirements, SDD coordination, routing, bounded implementation, decisions, and synthesis";
-    readonly responsibility: "Keep requirements, decisions, sequential SDD coordination, and final synthesis in the root thread; evaluate implementation ownership independently in every route and implement directly or delegate according to explicit user direction and demonstrated net gain.";
+    readonly responsibility: "Keep requirements, decisions, sequential SDD coordination, and final synthesis in the root thread; evaluate implementation ownership independently in every route, implement directly or delegate by demonstrated net gain, and run focused verification for trivial deterministic Direct work.";
     readonly useWhen: ["Coordinate requirements, governed artifacts, routing, and synthesis.", "Implement an accepted mutable surface in any route when accumulated context and continuity outweigh delegation overhead."];
-    readonly doNotUseWhen: ["Not for independent plan review or final verification."];
+    readonly doNotUseWhen: ["Not for independent plan review or Oracle-required final verification."];
     readonly escalateWhen: ["Delegate implementation when specialization, context isolation, or independent bounded work creates a demonstrated net gain; then select designer, quick, or deep by task shape."];
-    readonly toolGovernance: ["may inspect and edit the accepted bounded implementation surface in every route, but every verification is delegated to oracle", "loads the matching thoth-sdd phase contract on demand instead of carrying every phase protocol in its prompt", "owns governed coordination writes under openspec/ and uses append-only tasks.md updates during convergence", "delegates independent or specialist work only when it produces a net gain", "keeps requirements, decisions, and final synthesis in the root thread"];
-    readonly verification: ["delegates selected plan-review and every verify phase to oracle; plan review stays optional and final verification stays mandatory", "consolidates summarized evidence returned by child agents"];
+    readonly toolGovernance: ["may inspect and edit the accepted bounded implementation surface in every route and may verify trivial deterministic Direct work without self-approval", "loads the matching thoth-sdd phase contract on demand instead of carrying every phase protocol in its prompt", "owns governed coordination writes under openspec/ and uses append-only tasks.md updates during convergence", "delegates independent or specialist work only when it produces a net gain", "keeps requirements, decisions, and final synthesis in the root thread"];
+    readonly verification: ["runs focused checks for trivial deterministic Direct work while final verification remains mandatory", "delegates selected plan review plus Accelerated, Full, and material-risk Direct final verification to a fresh oracle", "consolidates summarized evidence returned by child agents"];
 }, {
     readonly name: "explorer";
     readonly mode: "read-only";
@@ -79,8 +99,8 @@ export declare const AGENT_ROLES: readonly [{
     readonly dispatch: "synchronous-task-only";
     readonly canMutateWorkspace: false;
     readonly scope: "diagnosis, architecture, optional plan review, and independent verification";
-    readonly responsibility: "Independently review plans when the user requests it and perform every implementation verification, exposing correctness risks and judging whether results satisfy their contracts.";
-    readonly useWhen: ["Selected plan review, diagnosis, or final verification needs independent judgment."];
+    readonly responsibility: "Independently review plans when the user requests it and provide independent judgment for artifact-backed or material-risk final verification, exposing correctness risks and judging whether results satisfy their contracts.";
+    readonly useWhen: ["Selected plan review, persistent diagnosis, material architecture or security risk, contradictory evidence, high failure cost, or artifact-backed final verification needs independent judgment."];
     readonly doNotUseWhen: ["Not for implementation, mutation, persistence, or self-review."];
     readonly escalateWhen: ["Return blockers and remediation anchors to root."];
     readonly toolGovernance: ["performs read-only analysis and independent review and is never the implementer of the work it judges", "does not implement, persist artifacts, or delegate further"];

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

@@ -5,6 +5,14 @@ export type SddIntent = 'documentation' | 'mechanical' | 'behavior' | 'architect
 export type SddScope = 'local' | 'multi-file' | 'cross-cutting';
 export type SddClarity = 'clear' | 'partial' | 'uncertain';
 export type SddRisk = 'low' | 'medium' | 'high';
+export type SddFinalVerificationRisk = 'trivial-deterministic' | 'architecture' | 'security' | 'cross-cutting-regression' | 'persistent-diagnosis' | 'contradictory-evidence' | 'high-failure-cost' | 'material-uncertainty';
+export type SddFinalVerificationOwner = 'orchestrator' | 'oracle';
+export interface SddFinalVerificationDecision {
+    verificationRequired: true;
+    owner: SddFinalVerificationOwner;
+    oracleRequired: boolean;
+    freshOracleRequired: boolean;
+}
 export type SddPlanningMode = 'none' | 'fast-forward' | 'gated';
 export type SddValidationGate = 'specify' | 'plan' | 'tasks' | 'checklist' | 'ready' | 'closeout';
 export type SddArtifactRevisionPolicy = 'none' | 'revalidate-affected-downstream';
@@ -24,7 +32,7 @@ export interface SddRoutingDecision {
 }
 export type SddPhaseId = 'explore' | 'specify' | 'clarify' | 'plan' | 'checklist' | 'tasks' | 'plan-review' | 'implement' | 'verify' | 'converge' | 'archive';
 export type SddPhaseActivation = 'required' | 'conditional';
-export type SddPhaseOwner = AgentRoleName | 'adaptive-implementation';
+export type SddPhaseOwner = AgentRoleName | 'adaptive-implementation' | 'adaptive-verification';
 export interface SddPhaseContract {
     id: SddPhaseId;
     order: number;
@@ -161,8 +169,8 @@ export declare const SDD_PHASES: readonly [{
     readonly producesArtifact: true;
     readonly defaultAgentRole: "oracle";
     readonly eligibleAgentRoles: ["oracle"];
-    readonly reason: "Offer independent blocker-only plan review when the user selects it after planning passes ready.";
-    readonly condition: "Activate only after ready when the user chooses Review plan with Oracle (Recommended).";
+    readonly reason: "Offer independent blocker-only plan review after explicit or bounded recommended-default selection once planning passes ready.";
+    readonly condition: "Activate after ready when review is selected explicitly or by the bounded recommended default after three answerless attempts.";
 }, {
     readonly id: "implement";
     readonly order: 7;
@@ -182,9 +190,9 @@ export declare const SDD_PHASES: readonly [{
     readonly activation: "required";
     readonly prerequisites: ["implement"];
     readonly producesArtifact: true;
-    readonly defaultAgentRole: "oracle";
-    readonly eligibleAgentRoles: ["oracle"];
-    readonly reason: "Independently judge the result against requirements, contracts, and focused checks.";
+    readonly defaultAgentRole: "adaptive-verification";
+    readonly eligibleAgentRoles: ["orchestrator", "oracle"];
+    readonly reason: "Keep verification mandatory while selecting root for trivial deterministic Direct checks and a fresh Oracle for material-risk Direct or artifact-backed judgment.";
 }, {
     readonly id: "converge";
     readonly order: 9;
@@ -357,17 +365,17 @@ export declare const SDD_PHASE_PROTOCOLS: readonly [{
     readonly outputSchema: ["tasks.md path", "requirement coverage", "dependency order"];
     readonly doneWhen: ["Every FR and buildable SC has executable task coverage and every task has a verification step."];
     readonly blockingConditions: ["A task requires an unresolved requirement, architecture choice, or hidden prerequisite."];
-    readonly handoff: ["After ready, pass spec.md, plan.md, tasks.md, dependencies, and verification commands to the user-selected plan-review path or implement."];
+    readonly handoff: ["After ready, pass spec.md, plan.md, tasks.md, dependencies, and verification commands to the explicitly or bounded-default selected plan-review path, or implement when the user explicitly proceeds without review."];
 }, {
     readonly id: "plan-review";
-    readonly objective: "Perform the user-selected read-only blocker review before Accelerated or Full implementation.";
-    readonly requiredInputs: ["spec.md", "plan.md", "tasks.md", "Optional active requirements checklist", "Project constitution", "Explicit user choice to review after the ready gate"];
-    readonly instructions: ["Load the bundled plan-reviewer skill and review executability, completeness, correctness, and coherence without redesigning the plan.", "Require task coverage for every FR and buildable SC; assess outcome SC as measurable verification targets without manufacturing implementation tasks.", "Return exact [OKAY] or [REJECT] semantics, default to [OKAY], and report at most three true blockers with the smallest fixes.", "Provide the reviewed artifact set so root can persist plan-review.md with SHA-256 freshness evidence; Oracle never writes it.", "Keep plan-review approval separate from implementation confirmation and mandatory final verify."];
+    readonly objective: "Perform the explicitly or recommended-default selected read-only blocker review before Accelerated or Full implementation.";
+    readonly requiredInputs: ["spec.md", "plan.md", "tasks.md", "Optional active requirements checklist", "Project constitution", "Review selection after the ready gate, from an explicit answer or the bounded recommended fallback"];
+    readonly instructions: ["At the ready gate, make at most three total attempts when the native review question returns answerless; after the third answerless result, treat Review plan with Oracle (Recommended) as selected, while any explicit Proceed without review answer wins.", "Load the bundled plan-reviewer skill and review executability, completeness, correctness, and coherence without redesigning the plan.", "Require task coverage for every FR and buildable SC; assess outcome SC as measurable verification targets without manufacturing implementation tasks.", "For every declared parallel group, independently assess semantic independence, each lane path union and owner, real cross-lane data flow, prerequisites and barrier, and whether native capacity supports dispatch-before-wait waves with refill; require a truthful sequential fallback when concurrency is unavailable or unproven.", "Return exact [OKAY] or [REJECT] semantics, default to [OKAY], and report at most three true blockers with the smallest fixes.", "After [REJECT], root must repair actionable same-intent planning artifacts, revalidate affected gates, and start a fresh Oracle approval round until [OKAY]; stop instead on a material human-owned blocker.", "Provide the reviewed artifact set so root can persist plan-review.md with SHA-256 freshness evidence; Oracle never writes it.", "Keep plan-review approval separate from implementation confirmation and mandatory final verify."];
     readonly allowedWrites: ["None; Oracle is read-only. Root persists plan-review.md when review runs."];
-    readonly outputSchema: ["status: [OKAY] or [REJECT]", "zero to three blocker findings with smallest fixes", "non-blocking cautions", "requirement coverage percentage", "constitution alignment", "reviewed artifact freshness manifest input"];
+    readonly outputSchema: ["status: [OKAY] or [REJECT]", "zero to three blocker findings with smallest fixes", "non-blocking cautions", "requirement coverage percentage", "parallel executability disposition when tasks declare groups or an evidence-backed None reason", "constitution alignment", "reviewed artifact freshness manifest input"];
     readonly doneWhen: ["Oracle has returned an exact status and every true blocker has a concrete remediation anchor."];
     readonly blockingConditions: ["[REJECT] blocks the review path until root repairs planning blockers, the user explicitly proceeds without review, or an explicit override is recorded."];
-    readonly handoff: ["On [OKAY], root persists review evidence, presents the approved-plan overview, and asks whether to implement or stop.", "A plan-review result never satisfies mandatory final verify."];
+    readonly handoff: ["On [OKAY], root persists review evidence and summarizes the approved scope, approach, ownership, verification, and material risks before asking Implement (Recommended) or Stop.", "For an answerless implementation question, root makes at most three total attempts; after the third answerless result, implementation counts as selected, while any explicit Stop answer wins.", "[OKAY] alone does not authorize implementation before that explicit choice or bounded fallback resolves.", "A plan-review result never satisfies mandatory final verify."];
 }, {
     readonly id: "implement";
     readonly objective: "Execute the accepted task slice with one writer and focused verification.";
@@ -377,12 +385,12 @@ export declare const SDD_PHASE_PROTOCOLS: readonly [{
     readonly outputSchema: ["status: completed | partial | failed", "per-task outcome", "files changed", "executed verification and results", "deviations, issues, and remaining work"];
     readonly doneWhen: ["The assigned task slice is complete and its focused checks pass with concrete evidence."];
     readonly blockingConditions: ["A task needs scope expansion, a material unresolved decision, or fails repeatedly without a safe bounded recovery."];
-    readonly handoff: ["Pass changed files, per-task evidence, deviations, and verification results to a fresh Oracle for independent verify."];
+    readonly handoff: ["Pass changed files, per-task evidence, deviations, and verification results into the route- and risk-aware final-verification decision."];
 }, {
     readonly id: "verify";
     readonly objective: "Judge the implementation against accepted requirements using executed evidence.";
     readonly requiredInputs: ["Implemented change or task results", "spec.md, plan.md, and tasks.md for artifact-backed routes", "Changed files and project verification commands"];
-    readonly instructions: ["Oracle must be independent from the implementation writer; self-review never satisfies this phase.", "Run or inspect the smallest sufficient executed checks; static confidence alone is not evidence.", "Judge completeness, correctness, and coherence independently so a passing test cannot hide missing or contradictory scope.", "Build a compliance matrix from every accepted requirement to code and executed checks.", "Record every outcome SC as PASS with concrete observed evidence or RISK with an explicit residual-risk entry.", "For accelerated and full routes, the root persists the read-only oracle result as verify-report.md."];
+    readonly instructions: ["Trivial deterministic Direct work may use root-owned focused verification; materially risky Direct plus Accelerated and Full final verification use a fresh independent Oracle, and no implementation writer self-approves.", "Run or inspect the smallest sufficient executed checks; static confidence alone is not evidence.", "Judge completeness, correctness, and coherence independently so a passing test cannot hide missing or contradictory scope.", "Build a compliance matrix from every accepted requirement to code and executed checks.", "Record every outcome SC as PASS with concrete observed evidence or RISK with an explicit residual-risk entry.", "For accelerated and full routes, the root persists the read-only oracle result as verify-report.md."];
     readonly allowedWrites: ["Root persistence only: openspec/changes/<feature>/verify-report.md for accelerated and full routes"];
     readonly outputSchema: ["verdict: pass | fail", "compliance matrix", "executed checks and results", "critical issues with remediation anchors", "warnings and residual risks"];
     readonly doneWhen: ["Every accepted requirement is represented in the compliance matrix and the verdict matches the evidence."];
@@ -419,7 +427,11 @@ export declare function getSddPhaseProtocol(id: SddPhaseId): SddPhaseProtocol;
 export declare function getSddPhaseProtocolsForRole(role: AgentRoleName): SddPhaseProtocol[];
 export declare function renderSddPhaseDispatchEnvelope(input: SddPhaseDispatchInput): string;
 export declare function renderSddPhaseDispatchTemplate(): string;
-export declare function getSddPhaseOwner(_route: SddRoute, phaseId: SddPhaseId): SddPhaseOwner;
+export declare function getSddFinalVerificationDecision({ route, risk, }: {
+    route: SddRoute;
+    risk: SddFinalVerificationRisk;
+}): SddFinalVerificationDecision;
+export declare function getSddPhaseOwner(route: SddRoute, phaseId: SddPhaseId, verificationRisk?: SddFinalVerificationRisk): SddPhaseOwner;
 export declare function getRequiredSddPhaseOrder(route: SddRoute): SddPhaseId[];
 export declare function canEnterSddPhase({ route, completed, target, }: {
     route: SddRoute;

package/dist/harness/pi-specialists.d.ts

@@ -0,0 +1,6 @@
+import type { AgentRoleName } from './core/agent-pack';
+export type PiSpecialistRole = Exclude<AgentRoleName, 'orchestrator'>;
+export type PiSpecialistName = `thoth-${PiSpecialistRole}`;
+export declare const PI_SPECIALIST_ROLES: readonly PiSpecialistRole[];
+export declare function isPiSpecialistRole(role: string): role is PiSpecialistRole;
+export declare function piSpecialistName(role: PiSpecialistRole): PiSpecialistName;

package/dist/harness/types.d.ts

@@ -1,8 +1,8 @@
-export type HarnessId = 'opencode' | 'codex' | 'claude';
+export type HarnessId = 'opencode' | 'codex' | 'claude' | 'pi';
 export type HarnessArtifactKind = 'agent-config' | 'harness-config' | 'mcp-config' | 'skill' | 'hook-config' | 'manifest' | 'documentation';
 export type HarnessDiagnosticSeverity = 'info' | 'warning' | 'error';
 export type HarnessDiagnosticCode = 'harness.unsupported' | 'harness.capability_gap' | 'harness.surface_unvalidated' | 'harness.artifact_skipped' | (string & {});
-export type HarnessCapabilityStatus = 'supported' | 'unsupported' | 'instruction-only' | 'unknown';
+export type HarnessCapabilityStatus = 'supported' | 'conditional' | 'adapter-backed' | 'provider-dependent' | 'degraded' | 'unsupported' | 'instruction-only' | 'unknown';
 export type ProviderCapabilityState = 'supported' | 'degraded' | 'unsupported';
 export type ProviderCapabilityEvidenceSource = 'provider' | 'harness' | 'none';
 /**

package/dist/harness/writers/codex-plugin-package.d.ts

@@ -11,6 +11,7 @@ export interface CodexPluginPackageAsset {
     sourcePath?: string;
 }
 export interface CodexPluginHookDefinition extends CodexHookValidationInput {
+    matcher?: string;
     handler: CodexHookValidationInput['handler'] & {
         command?: unknown;
     };

package/dist/harness/writers/pi-agent.d.ts

@@ -0,0 +1,16 @@
+import type { AgentRoleContract } from '../core/agent-pack';
+import { type PiSpecialistRole } from '../pi-specialists';
+export declare const PI_MANAGED_OWNER = "thoth-agents";
+export declare const PI_ROOT_START = "<!-- thoth-agents:pi-root:start -->";
+export declare const PI_ROOT_END = "<!-- thoth-agents:pi-root:end -->";
+export interface PiAgentDefinitionInput {
+    role: AgentRoleContract & {
+        name: PiSpecialistRole;
+    };
+    description: string;
+    instructions: string;
+    model?: string;
+    effort?: string;
+}
+export declare function renderPiAgentDefinition(input: PiAgentDefinitionInput): string;
+export declare function renderPiRootBlock(instructions: string): string;

package/dist/index.js

@@ -3,16 +3,18 @@ import {
   renderOpenCodeAgentConfigs,
   spawn,
   spawnSync
-} from "./chunk-CB3EBA7H.js";
+} from "./chunk-5EBXGMOK.js";
 import {
-  POLL_INTERVAL_BACKGROUND_MS,
   context7,
   exa,
+  grep_app
+} from "./chunk-62L3ORXN.js";
+import {
+  POLL_INTERVAL_BACKGROUND_MS,
   getOpenCodeConfigPaths,
-  grep_app,
   loadPluginConfig,
   stripJsonComments
-} from "./chunk-GIUU6FNE.js";
+} from "./chunk-Q6SDM4KP.js";
 
 // src/index.ts
 import { fileURLToPath as fileURLToPath3 } from "url";

package/dist/pi.d.ts

@@ -0,0 +1,11 @@
+type PiHandler = (event: Record<string, unknown>, context?: unknown) => unknown;
+export interface PiExtensionApi {
+    on(event: 'before_agent_start' | 'session_start', handler: PiHandler): void;
+}
+export interface PiExtensionOptions {
+    packageRoot?: string;
+    piRoot?: string;
+}
+export declare function injectPiRoot(systemPrompt: string): string;
+export default function thothAgentsPiExtension(pi: PiExtensionApi, options?: PiExtensionOptions): void;
+export {};