thoth-agents 0.3.9 → 0.3.11

package/dist/{chunk-2TLT6WWY.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",
@@ -802,6 +1065,9 @@ var OPENCODE_PROMPT_DIALECT = {
     progressTool: "todowrite",
     hostStatusSurface: "task_status",
     lifecycle: {
+      freshDelegation: "`task` without `task_id`",
+      sameAssignmentContinuation: "`task` with the prior `task_id`",
+      independentContext: "omitting `task_id` creates an isolated child session",
       statusAction: "wait, poll, and collect",
       terminalState: "terminal task_status result",
       nonterminalState: "nonterminal task_status result",
@@ -835,6 +1101,9 @@ var CODEX_PROMPT_DIALECT = {
     progressTool: "functions.update_plan",
     hostStatusSurface: "collaboration.list_agents",
     lifecycle: {
+      freshDelegation: '`collaboration.spawn_agent` with `fork_turns="none"`',
+      sameAssignmentContinuation: "`collaboration.followup_task` for the existing agent",
+      independentContext: '`fork_turns="none"` prevents parent-history inheritance',
       statusAction: "wait and inspect status",
       terminalState: "terminal mailbox completion or failure update",
       nonterminalState: "collaboration.wait_agent timeout or silence",
@@ -875,6 +1144,9 @@ var CLAUDE_CODE_PROMPT_DIALECT = {
     progressTool: "TodoWrite",
     hostStatusSurface: "TodoWrite",
     lifecycle: {
+      freshDelegation: "a normal `Agent` invocation",
+      sameAssignmentContinuation: "`SendMessage` to the prior agent ID",
+      independentContext: "do not use `fork` for independent work",
       statusAction: "wait, inspect, and collect",
       terminalState: "terminal TaskOutput result",
       nonterminalState: "nonterminal TaskOutput result",
@@ -902,166 +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.",
-    "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 = [
   {
@@ -1159,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",
@@ -1201,85 +1313,6 @@ var SDD_PHASES = [
     reason: "Transactionally sync declared durable deltas and close verified work with a dated audit trail."
   }
 ];
-var SDD_ARTIFACT_GRAPH = [
-  {
-    id: "spec",
-    path: "spec.md",
-    producedBy: "specify",
-    consumes: [],
-    requiredFor: ["accelerated", "full"]
-  },
-  {
-    id: "plan",
-    path: "plan.md",
-    producedBy: "plan",
-    consumes: ["spec"],
-    requiredFor: ["accelerated", "full"]
-  },
-  {
-    id: "tasks",
-    path: "tasks.md",
-    producedBy: "tasks",
-    consumes: ["spec", "plan"],
-    requiredFor: ["accelerated", "full"]
-  },
-  {
-    id: "requirements-checklist",
-    path: "checklists/requirements.md",
-    producedBy: "checklist",
-    consumes: ["spec"],
-    requiredFor: []
-  },
-  {
-    id: "research",
-    path: "research.md",
-    producedBy: "plan",
-    consumes: ["spec"],
-    requiredFor: []
-  },
-  {
-    id: "data-model",
-    path: "data-model.md",
-    producedBy: "plan",
-    consumes: ["spec"],
-    requiredFor: []
-  },
-  {
-    id: "contracts",
-    path: "contracts/",
-    producedBy: "plan",
-    consumes: ["spec"],
-    requiredFor: []
-  },
-  {
-    id: "quickstart",
-    path: "quickstart.md",
-    producedBy: "plan",
-    consumes: ["spec", "plan"],
-    requiredFor: []
-  },
-  {
-    id: "plan-review",
-    path: "plan-review.md",
-    producedBy: "plan-review",
-    consumes: ["spec", "plan", "tasks"],
-    requiredFor: []
-  },
-  {
-    id: "verify-report",
-    path: "verify-report.md",
-    producedBy: "verify",
-    consumes: ["spec", "plan", "tasks"],
-    requiredFor: ["accelerated", "full"]
-  },
-  {
-    id: "archive-report",
-    path: "archive-report.md",
-    producedBy: "archive",
-    consumes: ["spec", "plan", "tasks", "verify-report"],
-    requiredFor: ["accelerated", "full"]
-  }
-];
 var SDD_ROUTE_EXECUTION_POLICIES = [
   {
     route: "direct",
@@ -1326,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."
   ],
@@ -1372,20 +1405,6 @@ function getSddRouteExecutionPolicy(route) {
     validationGates: [...policy.validationGates]
   };
 }
-function getSddArtifactGraph() {
-  return SDD_ARTIFACT_GRAPH.map((artifact) => ({
-    ...artifact,
-    consumes: [...artifact.consumes],
-    requiredFor: [...artifact.requiredFor]
-  }));
-}
-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>
@@ -1422,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)
@@ -1479,15 +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");
-}
-function renderArtifactSummary() {
-  return getSddArtifactGraph().filter((artifact) => artifact.requiredFor.length === 0).map((artifact) => artifact.path).join(", ");
+  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();
@@ -1496,22 +1522,33 @@ 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.
 - Use \`{{progressTool}}\` only when the work genuinely has multiple dependent steps.
 </operating-model>
 
+<delegation-lifecycle>
+- A new objective, SDD phase, mutable surface, or independent judgment is a work boundary: start a fresh specialist using {{lifecycleFreshDelegation}}. Never treat completed agents as a reusable role pool.
+- Independent context: {{lifecycleIndependentContext}}.
+- Continue with {{lifecycleSameAssignmentContinuation}} only to steer, complete, or clarify the same bounded assignment; never to cross a work boundary.
+- {{lifecycleSameSessionProbe}} only collects the active nonterminal assignment and does not authorize later reuse.
+- Every Oracle plan review, verification round, and approval or PASS judgment uses a fresh Oracle instance. An existing Oracle session may only clarify its current findings.
+</delegation-lifecycle>
+
 <routing>
 ${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")}.
@@ -1527,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>
 
@@ -1541,29 +1579,20 @@ ${renderRoleDirectory()}
 </external-skills>
 
 <memory>
-- Load the installed \`thoth-mem\` skill for resume or prior work and provider-backed memory; 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; never invent identity or confirmed effects.
-- Follow the skill at verified compaction and a meaningful semantic boundary. Children receive only bounded MEMORY dispatch and never own root lifecycle.
-- \`openspec/\` remains canonical; do not mirror SDD phase artifacts into provider memory. A memory failure degrades memory only and does not block unrelated implementation or verification.
+- 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.
 </memory>
 
 <artifacts>
-- Preserve Spec Kit semantics inside ${workflow.artifactRoot}.
-- Accelerated and Full require spec.md, plan.md, tasks.md, verify-report.md, and archive-report.md; optional when useful: ${renderArtifactSummary()}.
-- Root owns openspec/ coordination and thoth-sdd gates; product work has one writer, and root alone moves [~] -> [x] after evidence.
-- ${roleTemplate("oracle")} returns read-only findings. Root persists verification; after PASS, archive syncs declared durable deltas and moves the change to openspec/changes/archive/YYYY-MM-DD-<feature>/.
+- 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.
 </artifacts>
 
-<execution>
-- Validate contracts and tests first; use test-first work for behavior. Root or one writer implements; do not delegate merely because an agent exists.
-- ${roleTemplate("oracle")} owns selected plan review and every verification; root and writers never self-approve.
-- Preserve unrelated working-tree changes. Never instruct an agent to discard them.
-- Report changed files, evidence, risks, and capability gaps truthfully.
-</execution>
-
 <delegation>
-- Dispatch through \`{{delegationTool}}\` with this envelope; use the same boundaries for non-SDD work.
-- Parallelize only independent work and await requested results before synthesis.
+- Use this envelope for all \`{{delegationTool}}\` delegation; parallelize only independent work and await results.
 - Child return fields: conclusion, evidence, verification, risks, openQuestions, nextAction.
 
 ${renderSddPhaseDispatchTemplate()}
@@ -1624,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(),
@@ -1673,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."
   ];
@@ -1741,6 +1774,15 @@ function renderRoleText(section, dialect) {
   ).replaceAll("{{userQuestionTool}}", dialect.tools.userQuestionTool).replaceAll("{{progressTool}}", dialect.tools.progressTool).replaceAll(
     "{{lifecycleStatusAction}}",
     dialect.tools.lifecycle.statusAction
+  ).replaceAll(
+    "{{lifecycleFreshDelegation}}",
+    dialect.tools.lifecycle.freshDelegation
+  ).replaceAll(
+    "{{lifecycleIndependentContext}}",
+    dialect.tools.lifecycle.independentContext
+  ).replaceAll(
+    "{{lifecycleSameAssignmentContinuation}}",
+    dialect.tools.lifecycle.sameAssignmentContinuation
   ).replaceAll(
     "{{lifecycleTerminalState}}",
     dialect.tools.lifecycle.terminalState
@@ -1889,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,