thoth-agents 0.3.11 → 0.4.0

package/dist/agents/prompt-dialects.d.ts

@@ -15,8 +15,9 @@ export interface ToolNomenclature {
     delegationTool: string;
     backgroundDelegationTool?: string;
     backgroundStatusTool?: string;
+    backgroundWaitInstruction?: string;
     userQuestionTool: string;
-    progressTool: string;
+    progressTool?: string;
     hostStatusSurface?: string;
     lifecycle: LifecycleNomenclature;
     roleReference(role: AgentPromptRole): string;
@@ -34,6 +35,7 @@ export interface HarnessPromptDialect {
 }
 export declare const CODEX_PROMPT_CAPABILITIES: HarnessCapabilities;
 export declare const CLAUDE_CODE_PROMPT_CAPABILITIES: HarnessCapabilities;
+export declare const PI_PROMPT_CAPABILITIES: HarnessCapabilities;
 export declare const OPENCODE_PROMPT_DIALECT: HarnessPromptDialect;
 export declare const CODEX_PROMPT_DIALECT: HarnessPromptDialect;
 /**
@@ -44,5 +46,6 @@ export declare const CODEX_PROMPT_DIALECT: HarnessPromptDialect;
 export declare const CLAUDE_CODE_SUBAGENT_NAMESPACE = "thoth-agents";
 export declare function claudeCodeSubagentType(role: AgentPromptRole): string;
 export declare const CLAUDE_CODE_PROMPT_DIALECT: HarnessPromptDialect;
+export declare const PI_PROMPT_DIALECT: HarnessPromptDialect;
 export declare function getPromptDialect(harness: HarnessId): HarnessPromptDialect;
 export declare function getPromptDialect(harness: string): HarnessPromptDialect;

package/dist/agents/prompt-sections.d.ts

@@ -8,6 +8,7 @@ export type WriteCapableAgentRole = 'designer' | 'quick' | 'deep';
 export interface QuestionProtocolSection {
     kind: 'question-protocol';
     toolConcept: 'userQuestion';
+    audience: 'root' | 'child';
 }
 export interface SubagentRulesSection {
     kind: 'subagent-rules';
@@ -39,7 +40,7 @@ export type RolePromptSection = PromptSection;
 export interface PromptSectionRenderer<TSection extends PromptSection> {
     render(section: TSection, dialect: HarnessPromptDialect): string;
 }
-export declare function createQuestionProtocolSection(): QuestionProtocolSection;
+export declare function createQuestionProtocolSection(audience?: 'root' | 'child'): QuestionProtocolSection;
 export declare function createSubagentRulesSection(memoryAccess?: SemanticMemoryAccess): SubagentRulesSection;
 export declare function createReasoningDisciplineSection(): ReasoningDisciplineSection;
 export declare function createResponseBudgetSection(): ResponseBudgetSection;

package/dist/{chunk-CB3EBA7H.js → chunk-5EBXGMOK.js}

@@ -16,7 +16,7 @@ import {
   loadAgentPrompt,
   renderAgentRoutingDescription,
   renderRolePrompt
-} from "./chunk-GIUU6FNE.js";
+} from "./chunk-Q6SDM4KP.js";
 
 // src/agents/deep.ts
 var DEEP_PROMPT = renderRolePrompt(

package/dist/chunk-62L3ORXN.js

@@ -0,0 +1,30 @@
+// src/mcp/context7.ts
+var CONTEXT7_MCP_URL = "https://mcp.context7.com/mcp";
+var context7 = {
+  type: "remote",
+  url: CONTEXT7_MCP_URL,
+  headers: process.env.CONTEXT7_API_KEY ? { CONTEXT7_API_KEY: process.env.CONTEXT7_API_KEY } : void 0,
+  oauth: false
+};
+
+// src/mcp/exa.ts
+var exa = {
+  type: "local",
+  command: ["npx", "-y", "exa-mcp-server"]
+};
+
+// src/mcp/grep-app.ts
+var GREP_APP_MCP_URL = "https://mcp.grep.app";
+var grep_app = {
+  type: "remote",
+  url: GREP_APP_MCP_URL,
+  oauth: false
+};
+
+export {
+  CONTEXT7_MCP_URL,
+  context7,
+  exa,
+  GREP_APP_MCP_URL,
+  grep_app
+};

package/dist/{chunk-GIUU6FNE.js → chunk-Q6SDM4KP.js}

@@ -1,22 +1,3 @@
-// src/config/loader.ts
-import * as fs from "fs";
-import * as path from "path";
-
-// src/cli/config-io.ts
-import {
-  copyFileSync,
-  existsSync as existsSync3,
-  readFileSync as readFileSync2,
-  renameSync,
-  statSync,
-  writeFileSync
-} from "fs";
-
-// src/cli/package-version.ts
-import { readFileSync } from "fs";
-import { dirname as dirname2, join as join2 } from "path";
-import { fileURLToPath } from "url";
-
 // src/cli/package-root.ts
 import { existsSync } from "fs";
 import { dirname, join, parse } from "path";
@@ -38,7 +19,24 @@ function findPackageRoot(startDir) {
   }
 }
 
+// src/config/loader.ts
+import * as fs from "fs";
+import * as path from "path";
+
+// src/cli/config-io.ts
+import {
+  copyFileSync,
+  existsSync as existsSync3,
+  readFileSync as readFileSync2,
+  renameSync,
+  statSync,
+  writeFileSync
+} from "fs";
+
 // src/cli/package-version.ts
+import { readFileSync } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+import { fileURLToPath } from "url";
 var EXPECTED_PACKAGE_NAME = "thoth-agents";
 var SEMVER_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*))*))?(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/;
 function isValidPackageVersion(version) {
@@ -743,24 +741,27 @@ var AGENT_ROLES = [
     dispatch: "root-coordinator",
     canMutateWorkspace: true,
     scope: "requirements, SDD coordination, routing, bounded implementation, decisions, and synthesis",
-    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.",
+    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.",
     useWhen: [
       "Coordinate requirements, governed artifacts, routing, and synthesis.",
       "Implement an accepted mutable surface in any route when accumulated context and continuity outweigh delegation overhead."
     ],
-    doNotUseWhen: ["Not for independent plan review or final verification."],
+    doNotUseWhen: [
+      "Not for independent plan review or Oracle-required final verification."
+    ],
     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."
     ],
     toolGovernance: [
-      "may inspect and edit the accepted bounded implementation surface in every route, but every verification is delegated to oracle",
+      "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"
     ],
     verification: [
-      "delegates selected plan-review and every verify phase to oracle; plan review stays optional and final verification stays mandatory",
+      "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"
     ]
   },
@@ -804,9 +805,9 @@ var AGENT_ROLES = [
     dispatch: "synchronous-task-only",
     canMutateWorkspace: false,
     scope: "diagnosis, architecture, optional plan review, and independent verification",
-    responsibility: "Independently review plans when the user requests it and perform every implementation verification, exposing correctness risks and judging whether results satisfy their contracts.",
+    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.",
     useWhen: [
-      "Selected plan review, diagnosis, or final verification needs independent judgment."
+      "Selected plan review, persistent diagnosis, material architecture or security risk, contradictory evidence, high failure cost, or artifact-backed final verification needs independent judgment."
     ],
     doNotUseWhen: [
       "Not for implementation, mutation, persistence, or self-review."
@@ -909,6 +910,34 @@ var ORCHESTRATION_POLICY = {
       "cheaper model price without end-to-end evidence"
     ]
   },
+  taskShaping: {
+    steps: [
+      "bound-work",
+      "map-dependencies",
+      "assign-ownership",
+      "select-specialists",
+      "mark-ready-and-blocked",
+      "dispatch-ready-wave",
+      "wait-for-terminal-evidence",
+      "reconcile-and-verify"
+    ],
+    nativeAuthority: true,
+    boundedWidth: true,
+    decisions: {
+      dependency: "block a lane until every concrete upstream output exists",
+      ownershipConflict: "serialize overlapping mutable surfaces or assign one writer",
+      readyWave: "dispatch all independent conflict-free ready lanes before waiting",
+      terminalEvidence: "silence, timeout, and malformed status remain nonterminal",
+      degradation: "report an unavailable native primitive and use a truthful sequential fallback"
+    }
+  },
+  specialistDirectory: AGENT_ROLES.filter(
+    (role) => role.name !== "orchestrator"
+  ).map((role) => ({
+    role: role.name,
+    selectWhen: role.useWhen.join(" "),
+    rejectWhen: role.doNotUseWhen.join(" ")
+  })),
   rules: [
     "Direct, Accelerated, Full, and no-artifact execution govern artifacts and gates, not implementation ownership.",
     "Root or a specialist may implement in every route; delegate only when specialization, context isolation, independent bounded work, or safe parallelism creates a demonstrated quality, latency, or total-cost net gain.",
@@ -919,6 +948,7 @@ var ORCHESTRATION_POLICY = {
     "A fresh subagent instance is the default when the objective, SDD phase, mutable surface, or independent judgment changes.",
     "Continue an existing subagent only to steer, complete, or clarify the same bounded assignment; completed agents are not a reusable role pool.",
     "Every Oracle plan review, verification round, and approval or PASS judgment uses a fresh Oracle instance; reuse is limited to clarifying current findings.",
+    "Final verification is mandatory: root owns trivial deterministic Direct checks; a fresh Oracle owns Accelerated, Full, and material-risk Direct judgment.",
     "Wait and status operations collect only the active nonterminal assignment and do not authorize later reuse.",
     "Child agents return distilled evidence instead of raw logs or file dumps."
   ]
@@ -991,6 +1021,16 @@ function getAgentPackContract() {
           ...AGENT_PACK_CONTRACT.orchestrationPolicy.implementationOwnership.insufficientSignals
         ]
       },
+      taskShaping: {
+        ...AGENT_PACK_CONTRACT.orchestrationPolicy.taskShaping,
+        steps: [...AGENT_PACK_CONTRACT.orchestrationPolicy.taskShaping.steps],
+        decisions: {
+          ...AGENT_PACK_CONTRACT.orchestrationPolicy.taskShaping.decisions
+        }
+      },
+      specialistDirectory: AGENT_PACK_CONTRACT.orchestrationPolicy.specialistDirectory.map(
+        (decision) => ({ ...decision })
+      ),
       rules: [...AGENT_PACK_CONTRACT.orchestrationPolicy.rules]
     },
     returnContract: [...AGENT_PACK_CONTRACT.returnContract],
@@ -998,6 +1038,22 @@ function getAgentPackContract() {
   };
 }
 
+// src/harness/pi-specialists.ts
+var PI_SPECIALIST_ROLES = [
+  "explorer",
+  "librarian",
+  "oracle",
+  "designer",
+  "quick",
+  "deep"
+];
+function isPiSpecialistRole(role) {
+  return PI_SPECIALIST_ROLES.some((candidate) => candidate === role);
+}
+function piSpecialistName(role) {
+  return `thoth-${role}`;
+}
+
 // src/agents/prompt-dialects.ts
 var OPENCODE_CAPABILITIES = {
   agentDefinitions: "supported",
@@ -1032,6 +1088,17 @@ var CLAUDE_CODE_PROMPT_CAPABILITIES = {
   parentContextInjection: "supported",
   memoryGovernanceEnforcement: "instruction-only"
 };
+var PI_PROMPT_CAPABILITIES = {
+  agentDefinitions: "supported",
+  delegatedExecution: "supported",
+  parallelDelegation: "supported",
+  runtimeHooks: "conditional",
+  mcpConfiguration: "adapter-backed",
+  skillPackaging: "supported",
+  rolePermissions: "supported",
+  parentContextInjection: "supported",
+  memoryGovernanceEnforcement: "instruction-only"
+};
 function supportedCapabilityProfile(capabilities) {
   return {
     capabilities,
@@ -1055,6 +1122,11 @@ function claudeCodeCapabilityDisclosure(capability) {
   }
   return `${capability}: ${status} in Claude Code; installed provider guidance owns provider-dependent enforcement and mechanics.`;
 }
+function piCapabilityDisclosure(capability) {
+  const status = PI_PROMPT_CAPABILITIES[capability];
+  if (status === "supported") return void 0;
+  return `${capability}: ${status} in Pi; Pi extensions run with the invoking user's system permissions, and child tool allowlists are role controls rather than an OS, filesystem, process, network, or credential sandbox.`;
+}
 var OPENCODE_PROMPT_DIALECT = {
   harness: "opencode",
   tools: {
@@ -1173,6 +1245,45 @@ var CLAUDE_CODE_PROMPT_DIALECT = {
     return role === "orchestrator" ? "main-thread orchestrator" : claudeCodeSubagentType(role);
   }
 };
+var PI_PROMPT_DIALECT = {
+  harness: "pi",
+  tools: {
+    delegationTool: "subagent_run",
+    backgroundDelegationTool: "subagent_run",
+    backgroundStatusTool: "subagent_status / subagent_result / subagent_list_tasks",
+    backgroundWaitInstruction: "For background tasks, respond and wait for the automatic completion notification. Do not sleep, poll status, or fetch results merely to wait; use `subagent_status`, `subagent_result`, or `subagent_list_tasks` only for an explicitly needed intermediate status or stored result.",
+    userQuestionTool: "ask_user_question",
+    progressTool: "todo",
+    hostStatusSurface: "subagent_list_tasks",
+    lifecycle: {
+      freshDelegation: "`subagent_run` with one exact canonical `agent` and no deprecated batch input",
+      sameAssignmentContinuation: "`subagent_status`, `subagent_result`, or `subagent_list_tasks`; use `subagent_send_message` only when the active SDK confirms live steering, and `subagent_continue` only when continuation is explicitly enabled",
+      independentContext: "a new objective, phase, mutable surface, or independent judgment starts a fresh `subagent_run` task",
+      statusAction: "inspect status, collect terminal results, or cancel",
+      terminalState: "a terminal completion notification or terminal subagent_result outcome",
+      nonterminalState: "running, queued, timed-out, malformed, or merely message-accepted state",
+      sameSessionProbe: "subagent_status for the current parent-owned task ID",
+      enforcement: "runtime-supported"
+    },
+    roleReference: (role) => role === "orchestrator" ? "the ambient Pi root" : `subagent_run(agent: "${piSpecialistName(role)}")`
+  },
+  capabilities: {
+    capabilities: PI_PROMPT_CAPABILITIES,
+    renderCapabilityDisclosure: piCapabilityDisclosure
+  },
+  dispatchLabel(method) {
+    switch (method) {
+      case "root-coordinator":
+        return "ambient Pi root session coordinator";
+      case "task":
+      case "synchronous-task-only":
+        return "single-agent subagent_run";
+    }
+  },
+  renderRoleInvocation(role) {
+    return role === "orchestrator" ? "ambient Pi root" : `subagent_run(agent: "${piSpecialistName(role)}")`;
+  }
+};
 
 // src/harness/core/sdd.ts
 var SDD_PHASES = [
@@ -1260,8 +1371,8 @@ var SDD_PHASES = [
     producesArtifact: true,
     defaultAgentRole: "oracle",
     eligibleAgentRoles: ["oracle"],
-    reason: "Offer independent blocker-only plan review when the user selects it after planning passes ready.",
-    condition: "Activate only after ready when the user chooses Review plan with Oracle (Recommended)."
+    reason: "Offer independent blocker-only plan review after explicit or bounded recommended-default selection once planning passes ready.",
+    condition: "Activate after ready when review is selected explicitly or by the bounded recommended default after three answerless attempts."
   },
   {
     id: "implement",
@@ -1283,9 +1394,9 @@ var SDD_PHASES = [
     activation: "required",
     prerequisites: ["implement"],
     producesArtifact: true,
-    defaultAgentRole: "oracle",
-    eligibleAgentRoles: ["oracle"],
-    reason: "Independently judge the result against requirements, contracts, and focused checks."
+    defaultAgentRole: "adaptive-verification",
+    eligibleAgentRoles: ["orchestrator", "oracle"],
+    reason: "Keep verification mandatory while selecting root for trivial deterministic Direct checks and a fresh Oracle for material-risk Direct or artifact-backed judgment."
   },
   {
     id: "converge",
@@ -1347,25 +1458,25 @@ var SDD_WORKFLOW_CONTRACT = {
     validationGates: [...policy.validationGates]
   })),
   routingRules: [
-    "The root recommends direct, accelerated, or full from risk evidence, but the user selects the route; an explicitly requested route already counts as selection.",
+    "The root summarizes context and recommends direct, accelerated, or full from risk evidence; an explicit answer wins, while the third answerless route question selects the displayed recommendation, and an explicitly requested route already counts as selection.",
     "Direct work is the default for clear, bounded, low-risk changes; documentation and mechanical work may remain direct across multiple files.",
     "Accelerated SDD is used for multi-surface behavior, architecture, partial clarity, moderate risk, or broad non-behavioral coordination.",
-    "Accelerated planning fast-forwards specify, plan, and tasks without pauses between those artifacts, then offers the user optional oracle plan review after ready.",
+    "Accelerated planning fast-forwards specify, plan, and tasks without pauses between those artifacts, then offers optional oracle plan review after ready; an explicit answer wins and the third answerless review question selects Review plan with Oracle (Recommended).",
     "Full SDD is used for unresolved scope, cross-cutting behavior or architecture, high contract risk, or high failure cost.",
     "Use architectural-grilling before specification only when the user explicitly requests it or material product or architecture decisions remain human-owned and unresolved; never require it merely because the route is Full.",
-    "Route selection and the post-ready plan-review choice are explicit user decisions; other input is requested only when a material unresolved decision changes the result."
+    "Route selection and the post-ready plan-review choice resolve through an explicit answer or their bounded recommended fallback; other input is requested only when a material unresolved decision changes the result."
   ],
   artifactRules: [
     "Spec Kit artifact semantics are preserved inside the governed openspec store.",
     "Accelerated and full routes require spec.md, plan.md, tasks.md, verify-report.md, and archive-report.md.",
     "Research, data model, contracts, quickstart, requirements checklist, and plan-review.md are optional and created only when useful or selected.",
-    "The adaptive root writes coordination artifacts after loading the matching bundled phase contract; Accelerated and Full implementation selects designer, quick, or deep, while Direct permits one isolated low-risk root micro-action.",
+    "The adaptive root writes coordination artifacts after loading the matching bundled phase contract; every route selects root, designer, quick, or deep from task shape, explicit direction, and demonstrated net gain.",
     "After oracle PASS, archive transactionally synchronizes only explicitly declared durable ADDED, MODIFIED, REMOVED, and RENAMED requirement deltas into openspec/specs; INTERNAL requirements and undeclared prose never update permanent specifications.",
     "Archive stages and backs up writes so handled failures roll back within the active process; forced process or operating-system termination is not crash-atomic."
   ],
   verificationRules: [
-    "Every route delegates focused verification to read-only oracle; the implementation writer never verifies its own work.",
-    "Accelerated and Full offer read-only oracle plan review after ready; it runs only when the user selects it and never replaces final verification.",
+    "Every route requires final verification; trivial deterministic Direct checks are root-owned, while materially risky Direct and every Accelerated or Full final verification use a fresh read-only oracle, and no implementation writer self-approves.",
+    "Accelerated and Full offer read-only oracle plan review after ready; it runs when selected explicitly or by the bounded recommended fallback and never replaces final verification.",
     "Accelerated and full verification persists verify-report.md with a pass or fail verdict and requirement compliance matrix.",
     "An artifact-backed fail verdict routes through append-only convergence, implementation, and verification again; direct work returns straight to implementation.",
     "A pass verdict is required before accelerated or full work can archive."
@@ -1448,8 +1559,8 @@ function getRequiredSddPhaseOrder(route) {
 }
 
 // src/agents/prompt-sections.ts
-function createQuestionProtocolSection() {
-  return { kind: "question-protocol", toolConcept: "userQuestion" };
+function createQuestionProtocolSection(audience = "root") {
+  return { kind: "question-protocol", toolConcept: "userQuestion", audience };
 }
 function createSubagentRulesSection(memoryAccess = "dispatch-scoped") {
   return {
@@ -1508,12 +1619,20 @@ function renderImplementationOwnershipPolicy(policy) {
 - Only after deciding delegation creates net gain: use ${roleTemplate("designer")} for UI/UX, ${roleTemplate("quick")} for known narrow low-risk work, and ${roleTemplate("deep")} for coupled or high-risk work.
 </implementation-ownership>`;
 }
-function renderRoleDirectory() {
-  return [
-    `- ${roleTemplate("explorer")}: uncertain local discovery; read-only.`,
-    `- ${roleTemplate("librarian")}: external evidence; read-only.`,
-    `- ${roleTemplate("oracle")}: review/verify; read-only, never implementer.`
-  ].join("\n");
+function renderRoleDirectory(directory) {
+  return directory.map(
+    ({ role, selectWhen, rejectWhen }) => `- ${roleTemplate(role)}: Select when ${selectWhen} Reject when ${rejectWhen}`
+  ).join("\n");
+}
+function renderTaskShapingPolicy(policy) {
+  return `<task-shaping>
+${policy.steps.join(" -> ")}
+- ${policy.decisions.dependency}; bind each lane to output, mutable ownership, specialist fit, and verification input.
+- ${policy.decisions.ownershipConflict}; avoid duplicate evidence work.
+- ${policy.decisions.readyWave} through \`{{backgroundDelegationTool}}\` within native capacity{{backgroundWaitInstruction}}
+- Fan in only from {{lifecycleTerminalState}}; {{lifecycleNonterminalState}}, ${policy.decisions.terminalEvidence}.
+- Reconcile against intent, dependencies, ownership, conflicts, and verification before synthesis; native execution remains authoritative; ${policy.decisions.degradation}.
+</task-shaping>`;
 }
 function createOrchestratorPromptSections() {
   const workflow = getSddWorkflowContract();
@@ -1526,13 +1645,13 @@ You are the adaptive root for thoth-agents. Keep requirements, decisions, owners
 </role>
 
 <operating-model>
-- Handle bounded implementation directly in any route when continuity outweighs delegation overhead; never self-verify.
+- Handle bounded implementation directly in any route when continuity outweighs delegation overhead; never self-approve.
 - The maximum delegation depth is ${policy.maxDelegationDepth}; children never delegate.
 - Keep one writer per mutable surface; parallelize only non-overlapping work.
 - Keep prompts bounded; request distilled evidence, not raw logs or full files.
 - Preserve unrelated changes; report changed files, evidence, risks, and capability gaps.
 - Use \`{{userQuestionTool}}\` only when a material unresolved choice changes the result. Continue all safe non-blocked work first.
-- Use \`{{progressTool}}\` only when the work genuinely has multiple dependent steps.
+- {{progressInstruction}}
 </operating-model>
 
 <delegation-lifecycle>
@@ -1544,51 +1663,46 @@ You are the adaptive root for thoth-agents. Keep requirements, decisions, owners
 </delegation-lifecycle>
 
 <routing>
-${renderRoleDirectory()}
+${renderRoleDirectory(policy.specialistDirectory)}
 </routing>
 
 ${renderImplementationOwnershipPolicy(policy.implementationOwnership)}
 
+${renderTaskShapingPolicy(policy.taskShaping)}
+
 <sdd-routing>
-- An explicitly requested route wins: no duplicate route-selection prompt. Otherwise assess and recommend one route, ask with \`{{userQuestionTool}}\`, and wait for the user to select Direct, Accelerated, or Full. The recommendation is not the decision. The user's selected route wins; explain risk without overriding it. A generic SDD request sets Accelerated as the minimum unless Full risk applies.
-- Direct: clear, bounded, low-risk work. ${renderSddRoute("direct")}.
-- Documentation or mechanical work may remain Direct across multiple files when it is clear and low risk.
-- Accelerated SDD: multi-surface behavior, architecture, partial clarity, or moderate risk. ${renderSddRoute("accelerated")}.
-- For Accelerated, run specify -> plan -> tasks in one uninterrupted root pass. Do not pause between those planning artifacts; ask only for a material unresolved decision.
-- Its thoth-sdd validator gates are ${accelerated.validationGates.join(" -> ")}; optional artifacts are off by default.
-- Full SDD: uncertain scope, cross-cutting behavior or architecture, high contract risk, or high failure cost. ${renderSddRoute("full")}.
-- Full gates are ${full.validationGates.join(" -> ")}; checklist remains conditional.
-- After \`ready\` on Accelerated/Full, ask with \`{{userQuestionTool}}\`: \`Review plan with Oracle (Recommended)\` or \`Proceed without review\`. Skipping plan review means no pre-implementation Oracle review. If selected, load \`plan-reviewer\`, delegate read-only review, and accept only \`[OKAY]\` or \`[REJECT]\` with at most 3 actionable blockers. After \`[OKAY]\`, summarize and ask whether to implement or stop. Plan review never replaces mandatory final Oracle verify.
+- An explicitly requested route wins: no duplicate route-selection prompt. Otherwise assess and recommend one route; summarize the relevant request context, assessed scope, clarity, risk, and why the recommendation fits before asking with \`{{userQuestionTool}}\` for Direct, Accelerated, or Full. On an answerless result, make at most three total attempts. After the third answerless result, treat the recommended route as selected. Any explicit user answer wins. A generic SDD request sets Accelerated as the minimum unless Full risk applies.
+- Direct is clear, bounded, low-risk: ${renderSddRoute("direct")}. Documentation or mechanical work may remain Direct across multiple files when clear and low risk.
+- Accelerated SDD covers multi-surface behavior, architecture, partial clarity, or moderate risk: ${renderSddRoute("accelerated")}; run specify -> plan -> tasks in one uninterrupted root pass. Do not pause between those planning artifacts except for a material unresolved decision. Gates: ${accelerated.validationGates.join(" -> ")}.
+- Full SDD covers uncertainty, cross-cutting behavior/architecture, high contract risk, or high failure cost: ${renderSddRoute("full")}. Gates: ${full.validationGates.join(" -> ")}; checklist conditional.
+- After \`ready\` on Accelerated/Full, ask with \`{{userQuestionTool}}\`: \`Review plan with Oracle (Recommended)\` or \`Proceed without review\`. Any explicit \`Proceed without review\` answer wins. If the review question returns answerless, retry to that limit. After the third answerless result, treat \`Review plan with Oracle (Recommended)\` as selected. For review, load \`plan-reviewer\`; accept only \`[OKAY]\`/\`[REJECT]\` with at most 3 actionable blockers. On \`[REJECT]\`, repair same-intent planning artifacts, revalidate affected gates, and use fresh Oracle rounds until \`[OKAY]\` or a human-owned blocker. On \`[OKAY]\`, summarize the approved scope, approach, ownership, verification, and material risks before asking with \`{{userQuestionTool}}\`: \`Implement (Recommended)\` or \`Stop\`. Reuse the answerless limit. After the third answerless result, treat implementation as selected. Any explicit \`Stop\` answer wins; \`[OKAY]\` alone does not authorize implementation. Plan review never replaces mandatory final Oracle verify.
+- Bounded fallbacks are only for route, plan-review, and implementation questions; never for secrets, destructive/security-sensitive actions, or material human-owned decisions.
 - Happy path: verify -> archive. Artifact-backed failure loop: verify fail -> converge -> implement -> verify. Direct failure loop: verify fail -> implement -> verify.
-- Conditional phases: clarify for material ambiguity; checklist for requirement risk; plan-review by user choice; converge for verification defects.
-- When implementation discoveries refine the same intent, update the canonical artifact and revalidate only affected downstream artifacts. Split a new change when the intent changes.
-- Load the bundled \`thoth-sdd\` skill only after selecting Accelerated or Full, then read only the reference for the current phase.
-- Root owns specify, clarify, plan, checklist, tasks, converge, and archive coordination; these phases are not delegated merely to change prompts.
-- Record owner, net-gain rationale, surface, requirements, and checks before implement or dispatch.
-- Delegate each user-selected plan review and every verify phase to ${roleTemplate("oracle")}. The implementation writer must never review itself.
+- Same-intent discoveries update the artifact and revalidate only affected downstream artifacts; new intent starts a change.
+- After Accelerated/Full selection, load the bundled \`thoth-sdd\` skill and read only the reference for the current phase. Run thoth-sdd validator. Root owns specify, clarify, plan, checklist, tasks, converge, and archive; do not delegate just to change prompts. Record owner, rationale, surface, requirements, and checks before implementation.
+- Final verification is mandatory. Use a fresh ${roleTemplate("oracle")} for Accelerated/Full and materially risky Direct work. Root may run focused verification only for trivial deterministic Direct work; no implementation writer may approve its own work.
 </sdd-routing>
 
 <external-skills>
 - Use bundled \`thoth-constitution\` for constitution lifecycle and \`thoth-archive\` for verified artifact-backed closeout.
 - Use the installed mandatory \`tdd\` skill for behavior changes and \`simplify\` after implementation without changing behavior.
-- During an SDD, never invoke the thoth-agents CLI, \`npx skills add\`, or a network fetch. A missing local contract means incomplete installation.
+- During SDD, never invoke the thoth-agents CLI, \`npx skills add\`, or network; a missing contract means incomplete installation.
 - Use progressive-context-router only for repository instruction or context-router work.
 - Use architectural-grilling before specification only when the user explicitly asks to be grilled or material human-owned product or architecture decisions remain unresolved.
-- Do not invoke it merely because the route is Full. While grilling, ask one material question per turn and await explicit closure.
-- Feed accepted decisions forward; spec.md and plan.md remain canonical instead of creating a duplicate blueprint artifact by default.
+- Do not invoke it merely because the route is Full; while grilling, ask one material question per turn.
+- Feed decisions forward; spec.md and plan.md remain canonical, without a duplicate blueprint by default.
 </external-skills>
 
 <memory>
-- Load the installed \`thoth-mem\` skill for resume or prior work; never invent its protocol.
-- Preserve a durable decision, root cause, convention, or discovery only when reusable. Root owns the stable root session ID, project, lifecycle, real-user intent, and authorization.
-- Follow the skill at verified compaction or a meaningful semantic boundary; children receive only bounded MEMORY and never own root lifecycle.
-- \`openspec/\` remains canonical; do not mirror SDD phase artifacts. A memory failure does not block unrelated work.
+- For resume/prior work, load the installed \`thoth-mem\` skill; never invent its protocol.
+- Preserve only a reusable decision, root cause, convention, or discovery. Root owns the stable root session ID, project, lifecycle, real-user intent, and authorization.
+- Follow it at verified compaction or a meaningful semantic boundary; children get bounded MEMORY, never root lifecycle.
+- \`openspec/\` remains canonical; do not mirror SDD artifacts. A memory failure does not block unrelated work.
 </memory>
 
 <artifacts>
-- In ${workflow.artifactRoot}, Accelerated and Full require spec.md, plan.md, tasks.md, verify-report.md, and archive-report.md.
-- Root owns openspec/ gates and task state, moves [~] -> [x] after evidence, and keeps one product writer.
-- ${roleTemplate("oracle")} returns read-only findings; root persists verification and archives declared durable deltas after PASS.
+- Accelerated/Full require ${workflow.artifactRoot}{spec.md,plan.md,tasks.md,verify-report.md,archive-report.md}.
+- Root owns gates/task state, moves [~] -> [x] on evidence, and keeps one product writer. ${roleTemplate("oracle")} returns read-only findings; root persists verification and archives declared deltas after PASS.
 </artifacts>
 
 <delegation>
@@ -1667,7 +1781,7 @@ ${role.responsibility}
 - ${ROLE_SPECIFIC_RULES[roleName].join("\n- ")}
 </rules>`),
     createSubagentRulesSection(),
-    createQuestionProtocolSection(),
+    createQuestionProtocolSection("child"),
     roleText(`<return-contract>
 Return a compact result with these fields:
 - conclusion
@@ -1700,14 +1814,19 @@ function createRolePromptSections(role) {
       );
   }
 }
-function renderQuestionProtocol(_section, dialect) {
+function renderQuestionProtocol(section, dialect) {
+  if (section.audience === "child" && dialect.harness === "pi") {
+    return `<questions>
+Do not open a user dialog. Continue safe non-blocked work, then escalate the unresolved question to the root through openQuestions with the material choices and a recommended default.
+</questions>`;
+  }
   return `<questions>
 Use \`${dialect.tools.userQuestionTool}\` only for a blocking material choice, destructive or security-sensitive action, or missing secret. Do safe non-blocked work first and ask one targeted question with a recommended default.
 </questions>`;
 }
 function renderSubagentRules(section, dialect) {
   const rules = [
-    `- Do not delegate further or call \`${dialect.tools.progressTool}\`; root owns progress.`,
+    dialect.tools.progressTool ? `- Do not delegate further or call \`${dialect.tools.progressTool}\`; root owns progress.` : "- Do not delegate further; root owns progress.",
     "- Use terminating checks; avoid watch processes and indefinite waits.",
     "- Never discard or overwrite unrelated working-tree changes."
   ];
@@ -1765,13 +1884,19 @@ function renderModelFamily(section) {
 </model-profile>`;
 }
 function renderRoleText(section, dialect) {
-  return section.template.replaceAll("{{delegationTool}}", dialect.tools.delegationTool).replaceAll(
+  return section.template.replaceAll(
+    "{{backgroundWaitInstruction}}",
+    dialect.tools.backgroundWaitInstruction ? `. ${dialect.tools.backgroundWaitInstruction}` : ", then use `{{backgroundStatusTool}}`."
+  ).replaceAll("{{delegationTool}}", dialect.tools.delegationTool).replaceAll(
     "{{backgroundDelegationTool}}",
     dialect.tools.backgroundDelegationTool ?? dialect.tools.delegationTool
   ).replaceAll(
     "{{backgroundStatusTool}}",
     dialect.tools.backgroundStatusTool ?? dialect.tools.hostStatusSurface ?? ""
-  ).replaceAll("{{userQuestionTool}}", dialect.tools.userQuestionTool).replaceAll("{{progressTool}}", dialect.tools.progressTool).replaceAll(
+  ).replaceAll("{{userQuestionTool}}", dialect.tools.userQuestionTool).replaceAll(
+    "{{progressInstruction}}",
+    dialect.tools.progressTool ? `Use \`${dialect.tools.progressTool}\` only when the work genuinely has multiple dependent steps.` : "Keep written progress notes when the work genuinely has multiple dependent steps; no native planning tool is configured."
+  ).replaceAll(
     "{{lifecycleStatusAction}}",
     dialect.tools.lifecycle.statusAction
   ).replaceAll(
@@ -1880,29 +2005,6 @@ function composeAgentPrompt({
   );
 }
 
-// src/mcp/context7.ts
-var CONTEXT7_MCP_URL = "https://mcp.context7.com/mcp";
-var context7 = {
-  type: "remote",
-  url: CONTEXT7_MCP_URL,
-  headers: process.env.CONTEXT7_API_KEY ? { CONTEXT7_API_KEY: process.env.CONTEXT7_API_KEY } : void 0,
-  oauth: false
-};
-
-// src/mcp/exa.ts
-var exa = {
-  type: "local",
-  command: ["npx", "-y", "exa-mcp-server"]
-};
-
-// src/mcp/grep-app.ts
-var GREP_APP_MCP_URL = "https://mcp.grep.app";
-var grep_app = {
-  type: "remote",
-  url: GREP_APP_MCP_URL,
-  oauth: false
-};
-
 export {
   SUBAGENT_NAMES,
   ALL_AGENT_NAMES,
@@ -1934,11 +2036,16 @@ export {
   getAgentRole,
   renderAgentRoutingDescription,
   getAgentPackContract,
+  PI_SPECIALIST_ROLES,
+  isPiSpecialistRole,
+  piSpecialistName,
+  PI_PROMPT_CAPABILITIES,
   OPENCODE_PROMPT_DIALECT,
   CODEX_PROMPT_DIALECT,
   CLAUDE_CODE_SUBAGENT_NAMESPACE,
   claudeCodeSubagentType,
   CLAUDE_CODE_PROMPT_DIALECT,
+  PI_PROMPT_DIALECT,
   createStepBudgetSection,
   createModelFamilySection,
   createOrchestratorPromptSections,
@@ -1950,10 +2057,5 @@ export {
   appendPromptSections,
   getStepBudgetPromptSection,
   getModelFamilyPromptSection,
-  composeAgentPrompt,
-  CONTEXT7_MCP_URL,
-  context7,
-  exa,
-  GREP_APP_MCP_URL,
-  grep_app
+  composeAgentPrompt
 };