thoth-agents 0.3.10 → 0.3.12

package/dist/{chunk-M2WF46BP.js → chunk-DX4U3AD3.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,311 @@ 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, 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 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 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: [
+      "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"
+    ]
+  },
+  {
+    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 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, 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."
+    ],
+    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"
+    ]
+  },
+  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.",
+    "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.",
+    "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."
+  ]
+};
+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
+        ]
+      },
+      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],
+    verificationProtocol: [...AGENT_PACK_CONTRACT.verificationProtocol]
+  };
+}
+
 // src/agents/prompt-dialects.ts
 var OPENCODE_CAPABILITIES = {
   agentDefinitions: "supported",
@@ -911,170 +1216,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 = [
   {
@@ -1161,8 +1302,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",
@@ -1172,9 +1313,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",
@@ -1184,9 +1325,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",
@@ -1248,25 +1389,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; implementation ownership stays with the root or one writer role.",
+    "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."
@@ -1306,13 +1447,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 +1483,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 +1537,33 @@ function roleTemplate(role) {
   return `{{role.${role}}}`;
 }
 function renderSddRoute(route) {
-  return getRequiredSddPhaseOrder(route).map(
-    (phase) => `${phase} (${roleTemplate(getSddPhaseOwner(route, phase))})`
-  ).join(" -> ");
-}
-function renderRoleDirectory() {
-  return getAgentPackContract().roles.filter((role) => role.name !== "orchestrator").map((role) => `- ${roleTemplate(role.name)}: ${role.responsibility}`).join("\n");
+  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(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, then use \`{{backgroundStatusTool}}\`.
+- 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();
@@ -1420,13 +1572,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-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.
@@ -1442,48 +1594,46 @@ You are the adaptive root for thoth-agents. Keep requirements, decisions, execut
 </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.
-- 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>
@@ -1548,13 +1698,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 +1752,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 +1976,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,