thoth-agents 0.3.11 → 0.3.12

package/README.md

@@ -22,10 +22,13 @@ parallelism creates a net gain.
 
 The plugin ships the seven-role contract and thoth-owned SDD
 contracts that combine Spec Kit-grade traceability with OpenSpec-style durable
-deltas. Accelerated planning fast-forwards without routine pauses; structural
-`ready`/`closeout` gates and independent oracle review retain rigor. Root
-recommends Direct, Accelerated, or Full and the user selects the route. After
-`ready`, artifact-backed routes offer optional Oracle plan review or proceeding
+deltas. The root shapes substantive work into dependency-aware, conflict-free
+native waves and joins terminal native results before dependent synthesis.
+Accelerated planning fast-forwards without routine pauses; structural
+`ready`/`closeout` gates and proportional independent review retain rigor. Root
+recommends Direct, Accelerated, or Full after summarizing context; explicit
+answers win and the third answerless route question selects the recommendation.
+After `ready`, artifact-backed routes offer optional Oracle plan review or proceeding
 without it; every final verification remains mandatory. During
 installation, the CLI obtains four mandatory external skills
 from their canonical repositories with `npx skills add` and invokes the official
@@ -41,8 +44,9 @@ before the CLI installs external skills and requests provider-owned thoth-mem
 setup.
 
 Runtime guarantees still differ by harness. OpenCode is the default and most
-integrated path; Codex and Claude preserve their own trust, policy, plugin-cache,
-and permission semantics.
+integrated path; Codex and Claude preserve their own trust, policy, normal
+plugin-cache, and permission semantics. Codex installation has one bounded
+legacy-cache cleanup contract described below; Claude does not.
 
 ## Install
 
@@ -78,15 +82,23 @@ directly from the globally installed `thoth-sdd` skill; any legacy project
 
 ### Codex
 
-Preview, then run the combined native-plugin and global-layer installer:
+Close Codex, preview, then run the combined native-plugin and global-layer
+installer:
 
 ```bash
 npx thoth-agents@latest install --agent=codex --dry-run
 npx thoth-agents@latest install --agent=codex
 ```
 
-The CLI first uses Codex's native manager to register `EremesNG/thoth-agents`
-and install or enable `thoth-agents@thoth-agents`. It then writes the
+The CLI first uses Codex's native manager to register
+`https://github.com/EremesNG/thoth-plugins.git` as `thoth-plugins` and install
+or enable the executing version of `thoth-agents@thoth-plugins`. After that
+verification it removes only registered legacy IDs
+`thoth-agents@thoth-agents` and `thoth-agents@thoth-agents-codex`, their two
+marketplaces, and any still-orphaned exact thoth-agents roots that pass bounded
+path/provenance checks. It never deletes sibling or discovered paths. A lock or
+race retains the central plugin and asks you to keep Codex closed and retry;
+restart activates state but does not garbage-collect caches. The CLI then writes the
 orchestrator block to `~/.codex/AGENTS.md`, creates six custom-agent TOMLs under
 `~/.codex/agents/`, merges the managed feature into `~/.codex/config.toml`,
 installs the external skills, and invokes provider-owned thoth-mem setup.
@@ -104,16 +116,61 @@ into the repository.
 Review `/plugins` and `/hooks` after installation. Codex trust and
 higher-precedence instructions remain in force.
 
+#### Local Codex development
+
+Keep a personal marketplace entry in `~/.agents/plugins/marketplace.json`
+pointed at `./plugins/thoth-agents` relative to the home marketplace root:
+
+```json
+{
+  "name": "personal",
+  "plugins": [
+    {
+      "name": "thoth-agents",
+      "source": {
+        "source": "local",
+        "path": "./plugins/thoth-agents"
+      },
+      "policy": {
+        "installation": "AVAILABLE",
+        "authentication": "ON_INSTALL"
+      },
+      "category": "Productivity"
+    }
+  ]
+}
+```
+
+Then build and synchronize both required Codex layers from this checkout:
+
+```bash
+pnpm run setup:codex:local
+```
+
+The command replaces `~/plugins/thoth-agents` through a staged local copy,
+cache-busts the copied Codex and Claude manifest versions, and refreshes the
+managed global Codex root block, six standalone role TOMLs, model state, and
+feature configuration. It preserves the marketplace file and user model
+overrides. It does not install or remove plugins, install external skills, or
+invoke thoth-mem setup. Select the personal plugin in Codex and restart it after
+each synchronization. The command rejects a state where both
+`thoth-agents@thoth-plugins` and `thoth-agents@personal` are enabled.
+
 ### Claude Code
 
 Claude requires its two native marketplace steps before the plugin can expose
 agents or skills:
 
 ```bash
-claude plugin marketplace add EremesNG/thoth-agents --scope user
-claude plugin install thoth-agents@thoth-agents --scope user
+claude plugin marketplace add https://github.com/EremesNG/thoth-plugins.git --scope user
+claude plugin install thoth-agents@thoth-plugins --scope user
 ```
 
+The shared catalog name is `thoth-plugins`. Existing bare or host-specific
+thoth-agents marketplace identities remain manager-owned and are not removed
+automatically; rerunning the current installer adds the central identity and
+preserves legacy entries without updating or uninstalling them.
+
 Then install the mandatory external skills and invoke provider-owned thoth-mem
 setup:
 
@@ -193,7 +250,8 @@ correctness-critical work.
       <br>
       <i>Authoritative external research.</i>
       <br><br>
-      Gathers current authoritative external evidence and labels inference.
+      Gathers current, unfamiliar, version-sensitive, or externally sourced
+      evidence and labels inference; stable local facts do not trigger research.
       <br><br>
       <b>Mode:</b> <code>read-only</code>
     </td>
@@ -210,8 +268,8 @@ correctness-critical work.
       <br>
       <i>Independent analysis and verification.</i>
       <br><br>
-      Reviews plans when the user requests it and independently verifies every
-      implementation.
+      Reviews explicitly or bounded-default selected plans and independently verifies material
+      risk plus every Accelerated or Full final implementation.
       <br><br>
       <b>Mode:</b> <code>read-only</code>
     </td>
@@ -230,7 +288,8 @@ correctness-critical work.
       <br>
       <i>UI/UX ownership and visual quality.</i>
       <br><br>
-      Owns UI/UX choices, implementation, and visual verification.
+      Owns material UI/UX, interaction, accessibility, implementation, and visual
+      verification.
       <br><br>
       <b>Mode:</b> <code>write-capable</code>
     </td>
@@ -247,7 +306,8 @@ correctness-critical work.
       <br>
       <i>Fast bounded implementation.</i>
       <br><br>
-      Makes narrow, clear, low-risk edits within an explicit surface.
+      Makes known narrow, clear, low-risk edits within an isolated explicit
+      surface.
       <br><br>
       <b>Mode:</b> <code>write-capable</code>
     </td>
@@ -273,9 +333,13 @@ correctness-critical work.
 </table>
 
 Children do not delegate. Each mutable surface has one writer. Parallel work is
-limited to independent surfaces. The implementation writer never reviews or
-approves its own result: `oracle` owns every `verify`, including Direct and
-Accelerated work.
+limited to independent surfaces. The root marks input-ready lanes ready and
+upstream-dependent lanes blocked, dispatches every ready conflict-free lane in a
+native wave before waiting, and fans in only terminal native results. Every route
+verifies: trivial deterministic Direct work may use focused root checks; material
+risk in Direct and every Accelerated or Full final verify require a fresh
+read-only `oracle`. The implementation writer never reviews or approves its own
+result.
 
 ## SDD routes
 
@@ -287,28 +351,37 @@ Full:        explore -> specify -> plan -> tasks -> implement -> verify -> archi
 
 | Route | Use when | Artifacts |
 | --- | --- | --- |
-| Direct | Clear, bounded, low-risk work, including multi-file documentation/mechanical edits | None; oracle returns its verdict in-session. |
+| Direct | Clear, bounded, low-risk work, including multi-file documentation/mechanical edits | None; focused root checks cover trivial deterministic work, while material risk requires a fresh Oracle. |
 | Accelerated | Generic SDD request, partial clarity, moderate risk, multi-surface behavior, or architecture | Canonical artifacts with fast-forward specification/planning/tasks. |
 | Full | Material uncertainty, cross-cutting behavior/architecture, high contract risk, or high failure cost | Accelerated artifacts plus exploration and separate planning gates. |
 
 The root loads only the current phase contract from the bundled `thoth-sdd`
 skill. It owns specification, clarification, planning, requirements checklists,
 task decomposition, convergence, report persistence, and archive. `explorer`
-owns Full discovery; `oracle` owns user-selected plan review and every `verify`.
+owns broad or uncertain Full discovery; `oracle` owns explicitly or
+bounded-default selected plan review, plus final
+verification gates that require independent judgment.
 
 An explicitly named route is the user's selection and wins. Otherwise root
-recommends one of all three routes and waits for the user's choice. A generic
-request to use SDD sets Accelerated as the minimum recommendation. Accelerated
-writes `spec.md -> plan.md -> tasks.md` in one uninterrupted root pass and does
-not pause for routine approval between those planning phases.
+summarizes the relevant context, scope, clarity, risk, and why one of the three
+routes is recommended before asking. Any explicit answer wins. After at most
+three total answerless native results, the third selects the recommended route.
+A generic request to use SDD sets Accelerated as the minimum recommendation.
+Accelerated writes `spec.md -> plan.md -> tasks.md` in one uninterrupted root
+pass and does not pause for routine approval between those planning phases.
 
 Conditional phases remain deliberately narrow:
 
 - `clarify` runs only for a material ambiguity and updates canonical `spec.md`;
 - `checklist` audits high-risk requirement quality with `CHK###` taxonomy and a
   separate revalidation pass;
-- `plan-review` is offered after `ready` on Accelerated and Full; the user chooses
-  `Review plan with Oracle (Recommended)` or `Proceed without review`;
+- `plan-review` is offered after `ready` on Accelerated and Full; any explicit
+  answer wins, while the third answerless result selects
+  `Review plan with Oracle (Recommended)`. Same-intent rejections are repaired
+  and revalidated before fresh Oracle rounds until approval or a material human
+  blocker. After approval, root summarizes the plan before asking
+  `Implement (Recommended)` or `Stop`; the third answerless result selects
+  implementation, while an explicit answer always wins;
 - `converge` appends tasks only after failed artifact-backed verification; and
 - `architectural-grilling` runs before specification only when explicitly
   requested or a material human-owned decision remains unresolved.
@@ -323,6 +396,16 @@ Handled failures roll back within the active process; forced process or OS
 termination is not crash-atomic. See
 [SDD Pipeline](docs/sdd-pipeline.md).
 
+The role decision is semantic and route-independent: `librarian` handles current
+or external facts (for example, checking the current official API), `designer`
+handles material user-facing UI/UX or accessibility, and `quick` handles a known
+narrow low-risk isolated edit. `deep` handles coupled or high-risk work, while
+`explorer` handles broad local uncertainty. Native harness execution and
+lifecycle are the sole authority for role selection, fan-out/fan-in,
+status/wait, steering, cancellation, and terminal results; an unavailable
+primitive is reported and followed by a truthful sequential fallback. No
+additional thoth coordination mechanism is involved.
+
 ## Skills
 
 Every harness package includes the workflow contracts owned by thoth-agents:
@@ -362,10 +445,11 @@ diagnostics, manual actions, and receipt paths remain visible for recovery.
 | Codex | The CLI installs the native plugin and manages global `AGENTS.md`, six agent TOMLs, config, external skills, and thoth-mem setup; `$thoth-init` only initializes per-repository SDD governance. Runtime role matching and some permissions remain instruction-level. |
 | Claude Code | Run both native marketplace commands before the CLI installs external skills and requests thoth-mem setup. The native manager owns cache files; fine-grained path restrictions remain instruction-level. |
 
-Codex and Claude marketplace manifests are versioned in
-`.agents/plugins/marketplace.json` and `.claude-plugin/marketplace.json`. The
-two catalogs resolve to the same generated `plugin/` bundle. Build and npm
-version lifecycle commands keep that shared bundle synchronized.
+Codex and Claude marketplace manifests are versioned in the separate
+`EremesNG/thoth-plugins` repository. Both central entries resolve to this
+repository's generated `plugin/` bundle at an immutable version tag. Build and
+npm version lifecycle commands keep that bundle synchronized; release commands
+publish only the new thoth-agents pin after the product tag is visible remotely.
 
 ## Models and provider boundaries
 
@@ -429,8 +513,10 @@ edit, preview and apply remain limited to the dirty roles. In OpenCode, both
 `Apply` and `Apply changes` materialize the complete effective roster and
 activate the named `agents` preset.
 
-It does not bypass native marketplace trust or edit manager-owned caches
-directly; Codex and Claude own their native manager mutations.
+It does not bypass native marketplace trust. Codex and Claude own normal native
+manager mutations; the Codex installer additionally owns only the fixed,
+twice-validated thoth-agents legacy-root fallback. Claude cache state is never
+edited directly.
 
 ## Documentation
 

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

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

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

@@ -743,24 +743,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 +807,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 +912,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 +950,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 +1023,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],
@@ -1260,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",
@@ -1283,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",
@@ -1347,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; 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."
@@ -1508,12 +1550,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, 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();
@@ -1526,7 +1576,7 @@ 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.
@@ -1544,51 +1594,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>