thoth-agents 0.3.10 → 0.3.11

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
     {
       "name": "thoth-agents",
       "description": "Adaptive root orchestration, six specialist subagents, and a runtime-autonomous Spec Kit-compatible SDD bundle.",
-      "version": "0.3.10",
+      "version": "0.3.11",
       "author": {
         "name": "thoth-agents maintainers"
       },

package/dist/{chunk-TKIDBRM3.js → chunk-CB3EBA7H.js}

@@ -10,11 +10,13 @@ import {
   createReadOnlySpecialistPromptSections,
   createWriteCapableSpecialistPromptSections,
   getAgentOverride,
+  getAgentRole,
   getModelFamilyPromptSection,
   getStepBudgetPromptSection,
   loadAgentPrompt,
+  renderAgentRoutingDescription,
   renderRolePrompt
-} from "./chunk-M2WF46BP.js";
+} from "./chunk-GIUU6FNE.js";
 
 // src/agents/deep.ts
 var DEEP_PROMPT = renderRolePrompt(
@@ -405,6 +407,7 @@ function createAgents(config) {
     const prompts = loadAgentPrompt(name, config?.preset);
     const model = getPrimaryModelForPrompt(override?.model) ?? DEFAULT_MODELS[name];
     const agent = factory(model, prompts.prompt, prompts.appendPrompt);
+    agent.description = renderAgentRoutingDescription(getAgentRole(name));
     agent.config.variant = CONFIRMED_OPENAI_SUBAGENT_PRESET[name].effort;
     return agent;
   });

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

@@ -213,10 +213,10 @@ var ALL_AGENT_NAMES = [
 ];
 var CONFIRMED_OPENAI_SUBAGENT_PRESET = {
   explorer: { model: "gpt-5.6-luna", effort: "low" },
-  librarian: { model: "gpt-5.6-luna", effort: "xhigh" },
-  oracle: { model: "gpt-5.6-sol", effort: "xhigh" },
+  librarian: { model: "gpt-5.6-luna", effort: "high" },
+  oracle: { model: "gpt-5.6-sol", effort: "high" },
   designer: { model: "gpt-5.6-sol", effort: "medium" },
-  quick: { model: "gpt-5.6-luna", effort: "xhigh" },
+  quick: { model: "gpt-5.6-luna", effort: "low" },
   deep: { model: "gpt-5.6-sol", effort: "medium" }
 };
 var OPENCODE_OPENAI_ORCHESTRATOR_PRESET = {
@@ -735,6 +735,269 @@ function loadAgentPrompt(agentName, preset) {
   return result;
 }
 
+// src/harness/core/agent-pack.ts
+var AGENT_ROLES = [
+  {
+    name: "orchestrator",
+    mode: "adaptive-root",
+    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.",
+    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."],
+    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",
+      "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",
+      "consolidates summarized evidence returned by child agents"
+    ]
+  },
+  {
+    name: "explorer",
+    mode: "read-only",
+    dispatch: "task",
+    canMutateWorkspace: false,
+    scope: "local repository discovery",
+    responsibility: "Resolve broad or uncertain repository questions and return distilled evidence.",
+    useWhen: ["Repository ownership or behavior is broad or uncertain."],
+    doNotUseWhen: ["Not for implementation, edits, or known narrow questions."],
+    escalateWhen: [
+      "Send external evidence to librarian and mutation scope to root."
+    ],
+    toolGovernance: [
+      "uses read, search, and code-navigation tools only",
+      "does not mutate files or delegate further"
+    ],
+    verification: ["reports inspected paths, confidence, and remaining gaps"]
+  },
+  {
+    name: "librarian",
+    mode: "read-only",
+    dispatch: "task",
+    canMutateWorkspace: false,
+    scope: "authoritative external research with local confirmation when needed",
+    responsibility: "Gather current authoritative evidence and separate documented facts from inference.",
+    useWhen: ["Current authoritative external evidence is required."],
+    doNotUseWhen: ["Not for implementation, edits, or purely local discovery."],
+    escalateWhen: ["Report contradictory or insufficient sources to root."],
+    toolGovernance: [
+      "uses research and read-only local tools",
+      "does not mutate files or delegate further"
+    ],
+    verification: ["provides direct sources for substantive external claims"]
+  },
+  {
+    name: "oracle",
+    mode: "read-only",
+    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.",
+    useWhen: [
+      "Selected plan review, diagnosis, or final verification needs independent judgment."
+    ],
+    doNotUseWhen: [
+      "Not for implementation, mutation, persistence, or self-review."
+    ],
+    escalateWhen: ["Return blockers and remediation anchors to root."],
+    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"
+    ],
+    verification: ["separates observations, risks, and recommendations"]
+  },
+  {
+    name: "designer",
+    mode: "write-capable",
+    dispatch: "synchronous-task-only",
+    canMutateWorkspace: true,
+    scope: "UI/UX decisions, implementation, and visual verification",
+    responsibility: "Own user-facing implementation choices and visual quality for UI work.",
+    useWhen: [
+      "User-facing UI/UX, interaction, accessibility, or visual quality is material."
+    ],
+    doNotUseWhen: [
+      "Not for backend-only, non-visual, or correctness-heavy cross-cutting work."
+    ],
+    escalateWhen: [
+      "Escalate coupled contracts, migrations, or high risk to deep."
+    ],
+    toolGovernance: [
+      "may edit focused UI/UX files",
+      "owns screenshots and visual QA",
+      "does not delegate further"
+    ],
+    verification: ["includes visual verification when applicable"]
+  },
+  {
+    name: "quick",
+    mode: "write-capable",
+    dispatch: "synchronous-task-only",
+    canMutateWorkspace: true,
+    scope: "fast bounded implementation",
+    responsibility: "Implement narrow, clear, low-risk changes within an explicitly bounded surface.",
+    useWhen: ["Known narrow mechanical low-risk work has exact targets."],
+    doNotUseWhen: [
+      "Not for coupled contracts, migrations, broad discovery, concurrency, edge cases, or high risk."
+    ],
+    escalateWhen: [
+      "Escalate discovery, coupling, edge cases, or higher risk to deep."
+    ],
+    toolGovernance: [
+      "edits only bounded targets",
+      "escalates when discovery or correctness risk exceeds the assignment",
+      "does not delegate further"
+    ],
+    verification: ["runs the smallest sufficient focused check"]
+  },
+  {
+    name: "deep",
+    mode: "write-capable",
+    dispatch: "synchronous-task-only",
+    canMutateWorkspace: true,
+    scope: "correctness-critical implementation and verification",
+    responsibility: "Handle multi-file, edge-case-heavy, or high-risk implementation with full local context.",
+    useWhen: [
+      "Implementation is multi-file, edge-case-heavy, migration, concurrency, shared-contract, or high-risk."
+    ],
+    doNotUseWhen: ["Not for visual-only work or narrow known low-risk edits."],
+    escalateWhen: ["Return product or architecture choices to root."],
+    toolGovernance: [
+      "may edit implementation and tests within the assigned surface",
+      "validates shared behavior against related code and call sites",
+      "does not delegate further"
+    ],
+    verification: ["reports focused checks and relevant edge-case evidence"]
+  }
+];
+var ORCHESTRATION_POLICY = {
+  maxDelegationDepth: 1,
+  singleWriter: true,
+  implementationOwnership: {
+    eligibleOwners: ["orchestrator", "designer", "quick", "deep"],
+    routeIndependent: true,
+    delegationBenefits: [
+      "specialization",
+      "context isolation",
+      "independent bounded work",
+      "safe parallelism",
+      "quality, latency, or total-cost gain"
+    ],
+    rootContinuityBenefits: [
+      "short work",
+      "one ordered reasoning chain",
+      "frequent shared-state writes",
+      "already-loaded context",
+      "rediscovery and coordination cost"
+    ],
+    userDirection: "explicit safe user direction is an ownership input",
+    insufficientSignals: [
+      "SDD route name",
+      "file count alone",
+      "cheaper model price without end-to-end evidence"
+    ]
+  },
+  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.",
+    "Keep implementation in root when short work, one ordered reasoning chain, frequent shared-state writes, already-loaded context, rediscovery, or coordination cost outweigh delegation benefit.",
+    "Treat explicit safe user direction as an ownership input; route name, file count alone, or cheaper model price without end-to-end evidence cannot choose an owner.",
+    "After deciding to delegate implementation, select designer for UI/UX, quick for known narrow low-risk work, and deep for coupled or high-risk work.",
+    "Use one writer for each mutable surface and never parallelize overlapping writes.",
+    "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.",
+    "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."
+  ]
+};
+var AGENT_RETURN_CONTRACT = [
+  "conclusion",
+  "evidence",
+  "verification",
+  "risks",
+  "openQuestions",
+  "nextAction"
+];
+var VERIFICATION_PROTOCOL = [
+  "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."
+];
+var AGENT_PACK_CONTRACT = {
+  roles: [...AGENT_ROLES],
+  orchestrationPolicy: {
+    ...ORCHESTRATION_POLICY,
+    rules: [...ORCHESTRATION_POLICY.rules]
+  },
+  returnContract: [...AGENT_RETURN_CONTRACT],
+  verificationProtocol: [...VERIFICATION_PROTOCOL]
+};
+function getAgentRole(name) {
+  const role = AGENT_ROLES.find((candidate) => candidate.name === name);
+  if (!role) {
+    throw new Error(`Unknown agent role: ${name}`);
+  }
+  return role;
+}
+function renderAgentRoutingDescription(role) {
+  return [
+    role.responsibility,
+    `Use when: ${role.useWhen.join(" ")}`,
+    `Do not use when: ${role.doNotUseWhen.join(" ")}`,
+    `Escalate when: ${role.escalateWhen.join(" ")}`,
+    `Mutation: ${role.canMutateWorkspace ? `only the assigned ${role.scope} surface` : "read-only; never mutate the workspace"}.`,
+    `Verification: ${role.verification.join(" ")}`,
+    `Return: ${AGENT_RETURN_CONTRACT.join(", ")}.`
+  ].join(" ");
+}
+function getAgentPackContract() {
+  return {
+    roles: AGENT_PACK_CONTRACT.roles.map((role) => ({
+      ...role,
+      useWhen: [...role.useWhen],
+      doNotUseWhen: [...role.doNotUseWhen],
+      escalateWhen: [...role.escalateWhen],
+      writeScope: role.writeScope ? [...role.writeScope] : void 0,
+      toolGovernance: [...role.toolGovernance],
+      verification: [...role.verification]
+    })),
+    orchestrationPolicy: {
+      ...AGENT_PACK_CONTRACT.orchestrationPolicy,
+      implementationOwnership: {
+        ...AGENT_PACK_CONTRACT.orchestrationPolicy.implementationOwnership,
+        eligibleOwners: [
+          ...AGENT_PACK_CONTRACT.orchestrationPolicy.implementationOwnership.eligibleOwners
+        ],
+        delegationBenefits: [
+          ...AGENT_PACK_CONTRACT.orchestrationPolicy.implementationOwnership.delegationBenefits
+        ],
+        rootContinuityBenefits: [
+          ...AGENT_PACK_CONTRACT.orchestrationPolicy.implementationOwnership.rootContinuityBenefits
+        ],
+        insufficientSignals: [
+          ...AGENT_PACK_CONTRACT.orchestrationPolicy.implementationOwnership.insufficientSignals
+        ]
+      },
+      rules: [...AGENT_PACK_CONTRACT.orchestrationPolicy.rules]
+    },
+    returnContract: [...AGENT_PACK_CONTRACT.returnContract],
+    verificationProtocol: [...AGENT_PACK_CONTRACT.verificationProtocol]
+  };
+}
+
 // src/agents/prompt-dialects.ts
 var OPENCODE_CAPABILITIES = {
   agentDefinitions: "supported",
@@ -911,170 +1174,6 @@ var CLAUDE_CODE_PROMPT_DIALECT = {
   }
 };
 
-// src/harness/core/agent-pack.ts
-var AGENT_ROLES = [
-  {
-    name: "orchestrator",
-    mode: "adaptive-root",
-    dispatch: "root-coordinator",
-    canMutateWorkspace: true,
-    scope: "requirements, SDD coordination, routing, bounded direct work, decisions, and synthesis",
-    responsibility: "Keep the task coherent, own sequential specification, planning, task, convergence, and archive coordination, act directly when work is clear and bounded, and delegate only for net gain.",
-    toolGovernance: [
-      "may inspect and edit bounded direct work, 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"
-    ],
-    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"
-    ]
-  },
-  {
-    name: "explorer",
-    mode: "read-only",
-    dispatch: "task",
-    canMutateWorkspace: false,
-    scope: "local repository discovery",
-    responsibility: "Resolve broad or uncertain repository questions and return distilled evidence.",
-    toolGovernance: [
-      "uses read, search, and code-navigation tools only",
-      "does not mutate files or delegate further"
-    ],
-    verification: ["reports inspected paths, confidence, and remaining gaps"]
-  },
-  {
-    name: "librarian",
-    mode: "read-only",
-    dispatch: "task",
-    canMutateWorkspace: false,
-    scope: "authoritative external research with local confirmation when needed",
-    responsibility: "Gather current authoritative evidence and separate documented facts from inference.",
-    toolGovernance: [
-      "uses research and read-only local tools",
-      "does not mutate files or delegate further"
-    ],
-    verification: ["provides direct sources for substantive external claims"]
-  },
-  {
-    name: "oracle",
-    mode: "read-only",
-    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.",
-    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"
-    ],
-    verification: ["separates observations, risks, and recommendations"]
-  },
-  {
-    name: "designer",
-    mode: "write-capable",
-    dispatch: "synchronous-task-only",
-    canMutateWorkspace: true,
-    scope: "UI/UX decisions, implementation, and visual verification",
-    responsibility: "Own user-facing implementation choices and visual quality for UI work.",
-    toolGovernance: [
-      "may edit focused UI/UX files",
-      "owns screenshots and visual QA",
-      "does not delegate further"
-    ],
-    verification: ["includes visual verification when applicable"]
-  },
-  {
-    name: "quick",
-    mode: "write-capable",
-    dispatch: "synchronous-task-only",
-    canMutateWorkspace: true,
-    scope: "fast bounded implementation",
-    responsibility: "Implement narrow, clear, low-risk changes within an explicitly bounded surface.",
-    toolGovernance: [
-      "edits only bounded targets",
-      "escalates when discovery or correctness risk exceeds the assignment",
-      "does not delegate further"
-    ],
-    verification: ["runs the smallest sufficient focused check"]
-  },
-  {
-    name: "deep",
-    mode: "write-capable",
-    dispatch: "synchronous-task-only",
-    canMutateWorkspace: true,
-    scope: "correctness-critical implementation and verification",
-    responsibility: "Handle multi-file, edge-case-heavy, or high-risk implementation with full local context.",
-    toolGovernance: [
-      "may edit implementation and tests within the assigned surface",
-      "validates shared behavior against related code and call sites",
-      "does not delegate further"
-    ],
-    verification: ["reports focused checks and relevant edge-case evidence"]
-  }
-];
-var ORCHESTRATION_POLICY = {
-  maxDelegationDepth: 1,
-  singleWriter: true,
-  rules: [
-    "The root performs bounded direct work when scope and intent are clear.",
-    "Delegate only when specialization, context isolation, or independent parallel work creates a net gain.",
-    "Prefer child agents for read-heavy exploration, research, analysis, and verification.",
-    "Use one writer for each mutable surface and never parallelize overlapping writes.",
-    "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.",
-    "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."
-  ]
-};
-var AGENT_RETURN_CONTRACT = [
-  "conclusion",
-  "evidence",
-  "verification",
-  "risks",
-  "openQuestions",
-  "nextAction"
-];
-var VERIFICATION_PROTOCOL = [
-  "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."
-];
-var AGENT_PACK_CONTRACT = {
-  roles: [...AGENT_ROLES],
-  orchestrationPolicy: {
-    ...ORCHESTRATION_POLICY,
-    rules: [...ORCHESTRATION_POLICY.rules]
-  },
-  returnContract: [...AGENT_RETURN_CONTRACT],
-  verificationProtocol: [...VERIFICATION_PROTOCOL]
-};
-function getAgentRole(name) {
-  const role = AGENT_ROLES.find((candidate) => candidate.name === name);
-  if (!role) {
-    throw new Error(`Unknown agent role: ${name}`);
-  }
-  return role;
-}
-function getAgentPackContract() {
-  return {
-    roles: AGENT_PACK_CONTRACT.roles.map((role) => ({
-      ...role,
-      writeScope: role.writeScope ? [...role.writeScope] : void 0,
-      toolGovernance: [...role.toolGovernance],
-      verification: [...role.verification]
-    })),
-    orchestrationPolicy: {
-      ...AGENT_PACK_CONTRACT.orchestrationPolicy,
-      rules: [...AGENT_PACK_CONTRACT.orchestrationPolicy.rules]
-    },
-    returnContract: [...AGENT_PACK_CONTRACT.returnContract],
-    verificationProtocol: [...AGENT_PACK_CONTRACT.verificationProtocol]
-  };
-}
-
 // src/harness/core/sdd.ts
 var SDD_PHASES = [
   {
@@ -1172,9 +1271,9 @@ var SDD_PHASES = [
     activation: "required",
     prerequisites: ["tasks"],
     producesArtifact: false,
-    defaultAgentRole: "orchestrator",
+    defaultAgentRole: "adaptive-implementation",
     eligibleAgentRoles: ["orchestrator", "designer", "quick", "deep"],
-    reason: "Let the adaptive root act directly or route the settled work to one writer."
+    reason: "Choose root, designer, quick, or deep from task-shaped net gain independently from the SDD route."
   },
   {
     id: "verify",
@@ -1260,7 +1359,7 @@ var SDD_WORKFLOW_CONTRACT = {
     "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; implementation ownership stays with the root or one writer role.",
+    "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.",
     "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."
   ],
@@ -1306,13 +1405,6 @@ function getSddRouteExecutionPolicy(route) {
     validationGates: [...policy.validationGates]
   };
 }
-function getSddPhase(id) {
-  const phase = SDD_PHASES.find((candidate) => candidate.id === id);
-  if (!phase) {
-    throw new Error(`Unknown SDD phase: ${id}`);
-  }
-  return clonePhase(phase);
-}
 function renderSddPhaseDispatchTemplate() {
   return `## PHASE
 phase=<phase-id>
@@ -1349,9 +1441,6 @@ authorization=<none|recall|observe>
 context:
 <bounded recalled context or - none>`;
 }
-function getSddPhaseOwner(_route, phaseId) {
-  return getSddPhase(phaseId).defaultAgentRole;
-}
 function getRequiredSddPhaseOrder(route) {
   return SDD_PHASES.filter(
     (phase) => phase.requiredFor.includes(route)
@@ -1406,12 +1495,25 @@ function roleTemplate(role) {
   return `{{role.${role}}}`;
 }
 function renderSddRoute(route) {
-  return getRequiredSddPhaseOrder(route).map(
-    (phase) => `${phase} (${roleTemplate(getSddPhaseOwner(route, phase))})`
-  ).join(" -> ");
+  return getRequiredSddPhaseOrder(route).join(" -> ");
+}
+function renderImplementationOwnershipPolicy(policy) {
+  return `<implementation-ownership>
+- SDD routes govern artifacts and gates, not implementation ownership.
+- Eligible owners in every route: ${policy.eligibleOwners.map((owner) => roleTemplate(owner)).join(", ")}.
+- Delegation benefits: ${policy.delegationBenefits.join("; ")}.
+- Root continuity benefits: ${policy.rootContinuityBenefits.join("; ")}.
+- Explicit safe user direction is an ownership input.
+- Insufficient signals: ${policy.insufficientSignals.join("; ")}.
+- 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 getAgentPackContract().roles.filter((role) => role.name !== "orchestrator").map((role) => `- ${roleTemplate(role.name)}: ${role.responsibility}`).join("\n");
+  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 createOrchestratorPromptSections() {
   const workflow = getSddWorkflowContract();
@@ -1420,13 +1522,13 @@ function createOrchestratorPromptSections() {
   const full = getSddRouteExecutionPolicy("full");
   return [
     roleText(`<role>
-You are the adaptive root for thoth-agents. Keep requirements, decisions, execution ownership, and final synthesis in this thread.
+You are the adaptive root for thoth-agents. Keep requirements, decisions, ownership, and synthesis here.
 </role>
 
 <operating-model>
-- Handle bounded direct work when intent and risk are clear; never verify your own implementation.
-- Delegate only for net gain from specialization, context isolation, review, or safe parallelism. The maximum delegation depth is ${policy.maxDelegationDepth}; children never delegate.
-- Maintain one writer for each mutable surface. Parallelize only independent work with no overlapping writes.
+- Handle bounded implementation directly in any route when continuity outweighs delegation overhead; never self-verify.
+- 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.
@@ -1445,6 +1547,8 @@ You are the adaptive root for thoth-agents. Keep requirements, decisions, execut
 ${renderRoleDirectory()}
 </routing>
 
+${renderImplementationOwnershipPolicy(policy.implementationOwnership)}
+
 <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")}.
@@ -1460,6 +1564,7 @@ ${renderRoleDirectory()}
 - 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.
 </sdd-routing>
 
@@ -1548,13 +1653,18 @@ You are ${roleName}.
 
 <responsibility>
 ${role.responsibility}
-</responsibility>`),
+</responsibility>
+
+<routing-contract>
+- Use when: ${role.useWhen.join(" ")}
+- Do not use when: ${role.doNotUseWhen.join(" ")}
+- Escalate when: ${role.escalateWhen.join(" ")}
+- Verification: ${role.verification.join(" ")}
+</routing-contract>`),
     createReasoningDisciplineSection(),
     roleText(`<rules>
-- Do not delegate further or manage root progress.
 - ${modeRules.join("\n- ")}
 - ${ROLE_SPECIFIC_RULES[roleName].join("\n- ")}
-- Ask only when a local blocking decision cannot be resolved from the assignment and evidence.
 </rules>`),
     createSubagentRulesSection(),
     createQuestionProtocolSection(),
@@ -1597,8 +1707,7 @@ Use \`${dialect.tools.userQuestionTool}\` only for a blocking material choice, d
 }
 function renderSubagentRules(section, dialect) {
   const rules = [
-    `- Do not delegate further or call \`${dialect.tools.progressTool}\`.`,
-    `- Use \`${dialect.tools.userQuestionTool}\` only for a local blocking choice.`,
+    `- Do not delegate further or call \`${dialect.tools.progressTool}\`; root owns progress.`,
     "- Use terminating checks; avoid watch processes and indefinite waits.",
     "- Never discard or overwrite unrelated working-tree changes."
   ];
@@ -1822,12 +1931,14 @@ export {
   loadAgentPrompt,
   getAgentOverride,
   getPrimaryModelId,
+  getAgentRole,
+  renderAgentRoutingDescription,
+  getAgentPackContract,
   OPENCODE_PROMPT_DIALECT,
   CODEX_PROMPT_DIALECT,
   CLAUDE_CODE_SUBAGENT_NAMESPACE,
   claudeCodeSubagentType,
   CLAUDE_CODE_PROMPT_DIALECT,
-  getAgentPackContract,
   createStepBudgetSection,
   createModelFamilySection,
   createOrchestratorPromptSections,