thoth-agents 0.4.2 → 0.5.0

package/dist/harness/core/sdd.d.ts

@@ -1,48 +1,48 @@
-import type { AgentRoleName } from './agent-pack';
-import type { MemoryDispatchContract } from './memory-governance';
-export type SddRoute = 'direct' | 'accelerated' | 'full';
+export type SddUnderstandingPhaseId = 'explore' | 'specify' | 'clarify';
+export type SddClassification = 'small' | 'substantial';
 export type SddIntent = 'documentation' | 'mechanical' | 'behavior' | 'architecture';
-export type SddScope = 'local' | 'multi-file' | 'cross-cutting';
-export type SddClarity = 'clear' | 'partial' | 'uncertain';
+export type SddScope = 'local' | 'coordinated' | 'cross-cutting';
+export type SddUncertainty = 'low' | 'medium' | 'high';
 export type SddRisk = 'low' | 'medium' | 'high';
-export type SddFinalVerificationRisk = 'trivial-deterministic' | 'architecture' | 'security' | 'cross-cutting-regression' | 'persistent-diagnosis' | 'contradictory-evidence' | 'high-failure-cost' | 'material-uncertainty';
-export type SddFinalVerificationOwner = 'orchestrator' | 'oracle';
-export interface SddFinalVerificationDecision {
-    verificationRequired: true;
-    owner: SddFinalVerificationOwner;
-    oracleRequired: boolean;
-    freshOracleRequired: boolean;
+export type SddClarificationOutcome = 'not-needed' | 'resolved' | 'unresolved';
+export type SddPhaseId = SddUnderstandingPhaseId | 'plan' | 'checklist' | 'tasks' | 'plan-review' | 'implement' | 'verify' | 'converge' | 'archive';
+export type SddPhaseActivation = 'required' | 'conditional';
+export type SddVerificationOwner = 'orchestrator' | 'oracle';
+export interface SddUnderstandingPhaseContract {
+    id: SddUnderstandingPhaseId;
+    order: number;
+    requiredForClassification: true;
+    artifactRequired: false;
+    agentRequired: false;
+    interviewRequired: false;
+    objective: string;
+}
+export interface SddUnderstandingEvidence {
+    completed: readonly SddUnderstandingPhaseId[];
+    clarification: SddClarificationOutcome;
 }
-export type SddPlanningMode = 'none' | 'fast-forward' | 'gated';
-export type SddValidationGate = 'specify' | 'plan' | 'tasks' | 'checklist' | 'ready' | 'closeout';
-export type SddArtifactRevisionPolicy = 'none' | 'revalidate-affected-downstream';
-export interface SddRoutingInput {
-    intent: SddIntent;
+export interface SddChangeClassificationInput {
     scope: SddScope;
-    clarity: SddClarity;
-    contractRisk: SddRisk;
-    failureCost: SddRisk;
-    requestedRoute?: SddRoute;
-    sddRequested?: boolean;
+    uncertainty: SddUncertainty;
+    risk: SddRisk;
+    understanding: SddUnderstandingEvidence;
 }
-export interface SddRoutingDecision {
-    route: SddRoute;
-    requiresUserInput: boolean;
+export interface SddClassificationDecision {
+    classification: SddClassification;
+    scope: SddScope;
+    uncertainty: SddUncertainty;
+    risk: SddRisk;
+    planningRequired: boolean;
+    recordRequired: boolean;
+    independentVerificationRequired: boolean;
     reasons: string[];
 }
-export type SddPhaseId = 'explore' | 'specify' | 'clarify' | 'plan' | 'checklist' | 'tasks' | 'plan-review' | 'implement' | 'verify' | 'converge' | 'archive';
-export type SddPhaseActivation = 'required' | 'conditional';
-export type SddPhaseOwner = AgentRoleName | 'adaptive-implementation' | 'adaptive-verification';
 export interface SddPhaseContract {
     id: SddPhaseId;
     order: number;
-    availableFor: SddRoute[];
-    requiredFor: SddRoute[];
     activation: SddPhaseActivation;
     prerequisites: SddPhaseId[];
     producesArtifact: boolean;
-    defaultAgentRole: SddPhaseOwner;
-    eligibleAgentRoles: AgentRoleName[];
     reason: string;
     condition?: string;
 }
@@ -51,390 +51,230 @@ export interface SddPhaseProtocol {
     objective: string;
     requiredInputs: string[];
     instructions: string[];
-    allowedWrites: string[];
     outputSchema: string[];
     doneWhen: string[];
     blockingConditions: string[];
-    handoff: string[];
-}
-export interface SddPhaseDispatchInput {
-    phase: SddPhaseId;
-    route: SddRoute;
-    changeName: string;
-    inputArtifacts?: string[];
-    requirements?: string[];
-    boundaries?: string[];
-    verification?: string[];
-    memory: MemoryDispatchContract;
 }
-export type SddArtifactId = 'spec' | 'plan' | 'tasks' | 'requirements-checklist' | 'research' | 'data-model' | 'contracts' | 'quickstart' | 'plan-review' | 'verify-report' | 'archive-report';
-export interface SddArtifactContract {
-    id: SddArtifactId;
-    path: string;
-    producedBy: SddPhaseId;
-    consumes: SddArtifactId[];
-    requiredFor: SddRoute[];
+export interface SddFinalVerificationDecision {
+    verificationRequired: true;
+    independent: boolean;
+    owner: SddVerificationOwner;
 }
 export interface SddWorkflowContract {
-    artifactRoot: string;
+    recordRoot: string;
+    recordPath: string;
+    understandingPhases: SddUnderstandingPhaseContract[];
     phases: SddPhaseContract[];
-    routePolicies: SddRouteExecutionPolicy[];
-    routingRules: string[];
+    classificationRules: string[];
     artifactRules: string[];
     verificationRules: string[];
 }
-export interface SddRouteExecutionPolicy {
-    route: SddRoute;
-    planningMode: SddPlanningMode;
-    validationGates: SddValidationGate[];
-    optionalArtifactsByDefault: boolean;
-    routineUserPauses: boolean;
-    artifactRevisionPolicy: SddArtifactRevisionPolicy;
-}
+export declare const SDD_UNDERSTANDING_PHASES: readonly [{
+    readonly id: "explore";
+    readonly order: 0;
+    readonly requiredForClassification: true;
+    readonly artifactRequired: false;
+    readonly agentRequired: false;
+    readonly interviewRequired: false;
+    readonly objective: "Inspect proportionally to understand current behavior, constraints, and uncertainty.";
+}, {
+    readonly id: "specify";
+    readonly order: 1;
+    readonly requiredForClassification: true;
+    readonly artifactRequired: false;
+    readonly agentRequired: false;
+    readonly interviewRequired: false;
+    readonly objective: "State the intended outcome, non-goals, and observable acceptance proportionally.";
+}, {
+    readonly id: "clarify";
+    readonly order: 2;
+    readonly requiredForClassification: true;
+    readonly artifactRequired: false;
+    readonly agentRequired: false;
+    readonly interviewRequired: false;
+    readonly objective: "Resolve material uncertainty with evidence or a safe assumption; ask only when needed.";
+}];
 export declare const SDD_PHASES: readonly [{
     readonly id: "explore";
     readonly order: 0;
-    readonly availableFor: ["full"];
-    readonly requiredFor: ["full"];
     readonly activation: "required";
     readonly prerequisites: [];
     readonly producesArtifact: false;
-    readonly defaultAgentRole: "explorer";
-    readonly eligibleAgentRoles: ["explorer"];
-    readonly reason: "Resolve broad repository uncertainty before requirements are fixed.";
+    readonly reason: "Every change begins with proportionate repository and intent discovery.";
 }, {
     readonly id: "specify";
     readonly order: 1;
-    readonly availableFor: ["accelerated", "full"];
-    readonly requiredFor: ["accelerated", "full"];
     readonly activation: "required";
     readonly prerequisites: ["explore"];
-    readonly producesArtifact: true;
-    readonly defaultAgentRole: "orchestrator";
-    readonly eligibleAgentRoles: ["orchestrator"];
-    readonly reason: "Define the user-visible requirements and acceptance contract.";
+    readonly producesArtifact: false;
+    readonly reason: "Settle outcome and acceptance before risk-aware classification.";
 }, {
     readonly id: "clarify";
     readonly order: 2;
-    readonly availableFor: ["accelerated", "full"];
-    readonly requiredFor: [];
-    readonly activation: "conditional";
+    readonly activation: "required";
     readonly prerequisites: ["specify"];
     readonly producesArtifact: false;
-    readonly defaultAgentRole: "orchestrator";
-    readonly eligibleAgentRoles: ["orchestrator"];
-    readonly reason: "Resolve only material ambiguity that would change the solution.";
-    readonly condition: "Activate when unresolved decisions cannot be handled by a safe local assumption.";
+    readonly reason: "Material uncertainty must be resolved or explicitly block classification.";
 }, {
     readonly id: "plan";
     readonly order: 3;
-    readonly availableFor: ["accelerated", "full"];
-    readonly requiredFor: ["accelerated", "full"];
     readonly activation: "required";
-    readonly prerequisites: ["specify"];
+    readonly prerequisites: ["explore", "specify", "clarify"];
     readonly producesArtifact: true;
-    readonly defaultAgentRole: "orchestrator";
-    readonly eligibleAgentRoles: ["orchestrator"];
-    readonly reason: "Translate requirements into an executable technical approach.";
+    readonly reason: "Substantial changes need a decision-ready technical approach in the sole record.";
 }, {
     readonly id: "checklist";
     readonly order: 4;
-    readonly availableFor: ["accelerated", "full"];
-    readonly requiredFor: [];
     readonly activation: "conditional";
-    readonly prerequisites: ["specify", "plan"];
+    readonly prerequisites: ["plan"];
     readonly producesArtifact: true;
-    readonly defaultAgentRole: "orchestrator";
-    readonly eligibleAgentRoles: ["orchestrator"];
-    readonly reason: "Audit requirement quality when risk justifies an explicit checklist.";
-    readonly condition: "Activate for high-risk, compliance-sensitive, or ambiguity-prone requirements.";
+    readonly reason: "Audit acceptance only when risk or ambiguity justifies it.";
+    readonly condition: "Use for elevated risk, compliance, or acceptance ambiguity.";
 }, {
     readonly id: "tasks";
     readonly order: 5;
-    readonly availableFor: ["accelerated", "full"];
-    readonly requiredFor: ["accelerated", "full"];
     readonly activation: "required";
-    readonly prerequisites: ["specify", "plan"];
+    readonly prerequisites: ["plan"];
     readonly producesArtifact: true;
-    readonly defaultAgentRole: "orchestrator";
-    readonly eligibleAgentRoles: ["orchestrator"];
-    readonly reason: "Produce dependency-ordered implementation slices with verification.";
+    readonly reason: "Shape useful implementation slices and acceptance coverage.";
 }, {
     readonly id: "plan-review";
     readonly order: 6;
-    readonly availableFor: ["accelerated", "full"];
-    readonly requiredFor: [];
     readonly activation: "conditional";
     readonly prerequisites: ["tasks"];
     readonly producesArtifact: true;
-    readonly defaultAgentRole: "oracle";
-    readonly eligibleAgentRoles: ["oracle"];
-    readonly reason: "Offer independent blocker-only plan review after explicit or bounded recommended-default selection once planning passes ready.";
-    readonly condition: "Activate after ready when review is selected explicitly or by the bounded recommended default after three answerless attempts.";
+    readonly reason: "Offer optional independent plan review after readiness.";
+    readonly condition: "Run only when selected; it never authorizes implementation.";
 }, {
     readonly id: "implement";
     readonly order: 7;
-    readonly availableFor: ["direct", "accelerated", "full"];
-    readonly requiredFor: ["direct", "accelerated", "full"];
     readonly activation: "required";
-    readonly prerequisites: ["tasks"];
+    readonly prerequisites: ["clarify"];
     readonly producesArtifact: false;
-    readonly defaultAgentRole: "adaptive-implementation";
-    readonly eligibleAgentRoles: ["orchestrator", "designer", "quick", "deep"];
-    readonly reason: "Choose root, designer, quick, or deep from task-shaped net gain independently from the SDD route.";
+    readonly reason: "Implement within accepted intent using one writer and focused checks.";
 }, {
     readonly id: "verify";
     readonly order: 8;
-    readonly availableFor: ["direct", "accelerated", "full"];
-    readonly requiredFor: ["direct", "accelerated", "full"];
     readonly activation: "required";
     readonly prerequisites: ["implement"];
     readonly producesArtifact: true;
-    readonly defaultAgentRole: "adaptive-verification";
-    readonly eligibleAgentRoles: ["orchestrator", "oracle"];
-    readonly reason: "Keep verification mandatory while selecting root for trivial deterministic Direct checks and a fresh Oracle for material-risk Direct or artifact-backed judgment.";
+    readonly reason: "Verify actual outcomes and residual risk independently when required.";
 }, {
     readonly id: "converge";
     readonly order: 9;
-    readonly availableFor: ["accelerated", "full"];
-    readonly requiredFor: [];
     readonly activation: "conditional";
     readonly prerequisites: ["verify"];
     readonly producesArtifact: true;
-    readonly defaultAgentRole: "orchestrator";
-    readonly eligibleAgentRoles: ["orchestrator"];
-    readonly reason: "Append traceable remaining work to tasks.md before another implementation loop.";
-    readonly condition: "Activate only when verification finds actionable defects.";
+    readonly reason: "Record bounded corrective work only when verification finds actionable gaps.";
+    readonly condition: "Use only for actionable defects within settled intent.";
 }, {
     readonly id: "archive";
     readonly order: 10;
-    readonly availableFor: ["accelerated", "full"];
-    readonly requiredFor: ["accelerated", "full"];
     readonly activation: "required";
     readonly prerequisites: ["verify"];
     readonly producesArtifact: true;
-    readonly defaultAgentRole: "orchestrator";
-    readonly eligibleAgentRoles: ["orchestrator"];
-    readonly reason: "Transactionally sync declared durable deltas and close verified work with a dated audit trail.";
-}];
-export declare const SDD_ARTIFACT_GRAPH: readonly [{
-    readonly id: "spec";
-    readonly path: "spec.md";
-    readonly producedBy: "specify";
-    readonly consumes: [];
-    readonly requiredFor: ["accelerated", "full"];
-}, {
-    readonly id: "plan";
-    readonly path: "plan.md";
-    readonly producedBy: "plan";
-    readonly consumes: ["spec"];
-    readonly requiredFor: ["accelerated", "full"];
-}, {
-    readonly id: "tasks";
-    readonly path: "tasks.md";
-    readonly producedBy: "tasks";
-    readonly consumes: ["spec", "plan"];
-    readonly requiredFor: ["accelerated", "full"];
-}, {
-    readonly id: "requirements-checklist";
-    readonly path: "checklists/requirements.md";
-    readonly producedBy: "checklist";
-    readonly consumes: ["spec"];
-    readonly requiredFor: [];
-}, {
-    readonly id: "research";
-    readonly path: "research.md";
-    readonly producedBy: "plan";
-    readonly consumes: ["spec"];
-    readonly requiredFor: [];
-}, {
-    readonly id: "data-model";
-    readonly path: "data-model.md";
-    readonly producedBy: "plan";
-    readonly consumes: ["spec"];
-    readonly requiredFor: [];
-}, {
-    readonly id: "contracts";
-    readonly path: "contracts/";
-    readonly producedBy: "plan";
-    readonly consumes: ["spec"];
-    readonly requiredFor: [];
-}, {
-    readonly id: "quickstart";
-    readonly path: "quickstart.md";
-    readonly producedBy: "plan";
-    readonly consumes: ["spec", "plan"];
-    readonly requiredFor: [];
-}, {
-    readonly id: "plan-review";
-    readonly path: "plan-review.md";
-    readonly producedBy: "plan-review";
-    readonly consumes: ["spec", "plan", "tasks"];
-    readonly requiredFor: [];
-}, {
-    readonly id: "verify-report";
-    readonly path: "verify-report.md";
-    readonly producedBy: "verify";
-    readonly consumes: ["spec", "plan", "tasks"];
-    readonly requiredFor: ["accelerated", "full"];
-}, {
-    readonly id: "archive-report";
-    readonly path: "archive-report.md";
-    readonly producedBy: "archive";
-    readonly consumes: ["spec", "plan", "tasks", "verify-report"];
-    readonly requiredFor: ["accelerated", "full"];
-}];
-export declare const SDD_ROUTE_EXECUTION_POLICIES: readonly [{
-    readonly route: "direct";
-    readonly planningMode: "none";
-    readonly validationGates: [];
-    readonly optionalArtifactsByDefault: false;
-    readonly routineUserPauses: false;
-    readonly artifactRevisionPolicy: "none";
-}, {
-    readonly route: "accelerated";
-    readonly planningMode: "fast-forward";
-    readonly validationGates: ["specify", "ready", "closeout"];
-    readonly optionalArtifactsByDefault: false;
-    readonly routineUserPauses: true;
-    readonly artifactRevisionPolicy: "revalidate-affected-downstream";
-}, {
-    readonly route: "full";
-    readonly planningMode: "gated";
-    readonly validationGates: ["specify", "plan", "tasks", "ready", "closeout"];
-    readonly optionalArtifactsByDefault: false;
-    readonly routineUserPauses: true;
-    readonly artifactRevisionPolicy: "revalidate-affected-downstream";
+    readonly reason: "Fail closed on incomplete work or verification, then transactionally archive.";
 }];
 export declare const SDD_PHASE_PROTOCOLS: readonly [{
     readonly id: "explore";
-    readonly objective: "Resolve repository uncertainty before requirements are fixed.";
-    readonly requiredInputs: ["User request and known scope", "Repository instructions and relevant starting anchors", "Questions that materially affect specification"];
-    readonly instructions: ["Inspect only enough repository context to make downstream requirements decision-ready.", "Separate confirmed behavior, constraints, assumptions, and unresolved material decisions.", "Return distilled evidence instead of raw searches or full-file content."];
-    readonly allowedWrites: ["None; exploration is read-only."];
-    readonly outputSchema: ["relevant paths and symbols", "current behavior and constraints", "material uncertainties and safe assumptions", "recommended specification anchors"];
-    readonly doneWhen: ["The root can dispatch specification without repeating repository discovery."];
-    readonly blockingConditions: ["A material product choice remains human-owned and cannot be safely assumed."];
-    readonly handoff: ["The root passes the relevant paths, constraints, accepted assumptions, and unresolved decisions to specify."];
+    readonly objective: "Understand current behavior and constraints in proportion to the request.";
+    readonly requiredInputs: ["User intent and known repository context"];
+    readonly instructions: ["Inspect repository evidence in proportion to the request to identify behavior, constraints, risks, and safe assumptions.", "Root owns completing understanding and acceptance; specific discovery ownership determines who gathers evidence, even when generic guidance permits direct exploration.", "Give each evidence assignment one precise question and result. Independent questions may run in parallel within native capacity; dependent questions wait until the upstream output is accepted by root. Do not duplicate discovery.", "Complete this phase before specifying. No document, agent, or interview is forced in this phase."];
+    readonly outputSchema: ["confirmed facts", "constraints", "safe assumptions", "material uncertainty"];
+    readonly doneWhen: ["The next step can state intended outcomes without repeating discovery."];
+    readonly blockingConditions: ["A material human-owned decision cannot safely be inferred."];
 }, {
     readonly id: "specify";
-    readonly objective: "Create a testable, implementation-neutral feature contract in spec.md.";
-    readonly requiredInputs: ["User intent and accepted scope", "Explore handoff when the route is full", "Project constitution and existing public contracts when relevant"];
-    readonly instructions: ["Record intent and scope as Why, Impact, and Affected capabilities before prescribing any contract.", "Define prioritized independent stories and map each story to its FR-### and SC-### contracts with Covers metadata.", "Inspect each affected canonical capability before choosing durable metadata: ADDED is only for genuinely new behavior; MODIFIED and REMOVED preserve exact existing titles; RENAMED names the exact previous title; only ADDED is valid when the capability is absent.", "Give every normative MUST or SHALL requirement a descriptive title and declare it INTERNAL or as an ADDED, MODIFIED, REMOVED, or RENAMED durable capability delta; treat an ADDED warning on an existing capability as a required semantic-overlap review.", "Classify every success criterion as buildable or outcome; both remain measurable, but only buildable criteria require implementation task coverage.", "Capture assumptions, acceptance scenarios, edge cases, dependencies, and explicit non-goals.", "Use a clarification marker only when no safe default exists and the answer materially changes scope or behavior."];
-    readonly allowedWrites: ["openspec/changes/<feature>/spec.md"];
-    readonly outputSchema: ["spec.md path", "requirements summary", "open clarifications"];
-    readonly doneWhen: ["Every accepted FR and SC is testable, materially unambiguous, mapped to a story, and implementation-neutral."];
-    readonly blockingConditions: ["A material unresolved choice prevents a truthful acceptance contract."];
-    readonly handoff: ["Pass accepted scope, requirements, assumptions, and clarification decisions to plan."];
+    readonly objective: "State the intended outcome and observable acceptance proportionally.";
+    readonly requiredInputs: ["User intent", "Explore findings and constraints"];
+    readonly instructions: ["Define outcomes, non-goals, and meaningful edge cases in concise working notes.", "Do not persist a document before classification; only substantial work creates the one ID-named record.", "No document, agent, or interview is forced in this phase."];
+    readonly outputSchema: ["intent", "non-goals", "observable acceptance"];
+    readonly doneWhen: ["Acceptance expresses the requested outcome without material ambiguity."];
+    readonly blockingConditions: ["Acceptance depends on an unresolved material human decision."];
 }, {
     readonly id: "clarify";
-    readonly objective: "Resolve only material ambiguity and write accepted answers back into spec.md.";
-    readonly requiredInputs: ["spec.md", "The unresolved material decision"];
-    readonly instructions: ["Ask a targeted question only when repository evidence and safe assumptions cannot resolve it.", "Update the canonical specification with the accepted decision instead of creating a parallel answer document."];
-    readonly allowedWrites: ["openspec/changes/<feature>/spec.md"];
-    readonly outputSchema: ["resolved decision", "updated spec anchor", "remaining risks"];
-    readonly doneWhen: ["The material ambiguity is resolved in the canonical spec."];
-    readonly blockingConditions: ["The required human decision has not been provided."];
-    readonly handoff: ["Pass the updated spec and accepted decision to plan."];
+    readonly objective: "Resolve material ambiguity without imposing routine interviews.";
+    readonly requiredInputs: ["Explore evidence", "Specified outcome", "Any material uncertainty"];
+    readonly instructions: ["Use evidence or a safe bounded assumption when it preserves user intent.", "Ask only for a material human-owned decision that cannot safely be inferred; no interview is forced.", "An unresolved material clarification blocks classification.", "No document, agent, or interview is forced in this phase."];
+    readonly outputSchema: ["resolved decision or none-needed disposition", "remaining material blockers"];
+    readonly doneWhen: ["No material intent remains unresolved."];
+    readonly blockingConditions: ["The required human clarification has not been provided."];
 }, {
     readonly id: "plan";
-    readonly objective: "Translate the accepted specification into an executable technical approach.";
-    readonly requiredInputs: ["spec.md", "Relevant repository evidence and constraints", "Project constitution"];
-    readonly instructions: ["Make each technical choice traceable to a requirement or repository constraint.", "Name affected components, interfaces, files, risks, migrations, and verification strategy.", "Create research, data model, contracts, or quickstart artifacts only when they reduce implementation risk.", "Read active constitution principles for the plan; do not amend or run constitution lifecycle validation unless an explicit constitution amendment is itself in scope."];
-    readonly allowedWrites: ["openspec/changes/<feature>/plan.md", "Optional research.md, data-model.md, contracts/, and quickstart.md under the same change"];
-    readonly outputSchema: ["plan.md path", "technical decisions", "affected surfaces"];
-    readonly doneWhen: ["A competent implementer can execute the plan without guessing about critical architecture or constraints."];
-    readonly blockingConditions: ["The plan contradicts spec.md, the constitution, or confirmed repository constraints."];
-    readonly handoff: ["Pass the accepted plan, affected surfaces, dependencies, and verification strategy to tasks."];
+    readonly objective: "Plan substantial work in its one persistent record.";
+    readonly requiredInputs: ["Settled understanding", "Substantial classification", "Accepted outcomes"];
+    readonly instructions: ["Substantial classification only creates the `.thoth/changes/<id>/<id>.md` record.", "Capture interfaces, mutable surfaces, durable deltas, dependencies, risks, and verification seams.", "Plan each useful work unit with concrete inputs, outputs, and dependencies.", "Record each unit's owner, owned writes, interface boundaries, focused checks with PASS evidence, and return milestone and stop condition.", "Validate the plan before tasks exist; tasks are checked later for acceptance coverage."];
+    readonly outputSchema: ["technical approach", "affected interfaces", "risks", "verification seams"];
+    readonly doneWhen: ["A competent implementer can proceed without guessing at critical constraints."];
+    readonly blockingConditions: ["The approach contradicts accepted intent or unresolved material choices remain."];
 }, {
     readonly id: "checklist";
-    readonly objective: "Audit requirement quality when risk justifies an explicit checklist.";
-    readonly requiredInputs: ["spec.md", "Risk or compliance reason for the audit"];
-    readonly instructions: ["Evaluate requirement completeness, clarity, consistency, measurability, and scenario coverage.", "Record the risk or ambiguity activation reason and add only the applicable security, accessibility, compliance, performance, migration, or domain lenses.", "Record checked revalidation after requirement-affecting changes, or an evidence-backed no-op when nothing relevant changed.", "Do not turn the checklist into implementation tests or QA execution steps."];
-    readonly allowedWrites: ["openspec/changes/<feature>/checklists/requirements.md"];
-    readonly outputSchema: ["checklist path", "passed items", "unresolved requirement gaps"];
-    readonly doneWhen: ["Every checklist item has an evidence-backed state."];
-    readonly blockingConditions: ["A high-risk requirement gap remains unresolved before task generation."];
-    readonly handoff: ["Pass unresolved gaps back to specify; otherwise pass readiness to tasks."];
+    readonly objective: "Audit acceptance only when risk warrants a focused review.";
+    readonly requiredInputs: ["Substantial record", "Risk or ambiguity rationale"];
+    readonly instructions: ["Assess completeness, consistency, measurability, and relevant domain coverage in the same record.", "Correct material gaps without creating a second checklist artifact."];
+    readonly outputSchema: ["activation rationale", "resolved or remaining acceptance gaps"];
+    readonly doneWhen: ["Material acceptance gaps have an evidence-backed disposition."];
+    readonly blockingConditions: ["A material high-risk acceptance gap remains unresolved."];
 }, {
     readonly id: "tasks";
-    readonly objective: "Produce dependency-ordered, independently verifiable implementation slices.";
-    readonly requiredInputs: ["spec.md", "plan.md", "Optional planning support artifacts"];
-    readonly instructions: ["Cover every FR and buildable SC with concrete tasks, exact paths, dependencies, and verification; outcome SC remain verification targets but do not require fake implementation tasks.", "Put test-first work before its corresponding implementation when behavior changes.", "Mark [P] only for proven non-overlapping mutable surfaces; otherwise state why no safe parallel work exists.", "Do not create ceremonial tasks for trivial edits or combine unrelated mutable surfaces."];
-    readonly allowedWrites: ["openspec/changes/<feature>/tasks.md"];
-    readonly outputSchema: ["tasks.md path", "requirement coverage", "dependency order"];
-    readonly doneWhen: ["Every FR and buildable SC has executable task coverage and every task has a verification step."];
-    readonly blockingConditions: ["A task requires an unresolved requirement, architecture choice, or hidden prerequisite."];
-    readonly handoff: ["After ready, pass spec.md, plan.md, tasks.md, dependencies, and verification commands to the explicitly or bounded-default selected plan-review path, or implement when the user explicitly proceeds without review."];
+    readonly objective: "Record useful implementation slices and acceptance coverage.";
+    readonly requiredInputs: ["Accepted outcomes", "Validated plan", "Known dependencies"];
+    readonly instructions: ["Record one task row per outcome in the same ID-named record; each row names one independently acceptable outcome.", "Use the validator-compatible `- [ ] AC-n: ...` row with indented details and name concrete inputs, outputs, dependencies, owner, owned writes, interface boundaries, focused checks with PASS evidence, a meaningful return milestone, and a stop condition for each unit.", "Write `none` for owned writes on read-only work.", "Split phases with separately acceptable outcomes before dispatch; keep tiny cohesive mechanical work together and do not split mechanically by file or test step.", "Independent, precise Explorer questions may run in parallel within native capacity. Dependent questions wait for accepted evidence; root accepts producer outputs before consumers start, and discovery is not duplicated.", "Cover every accepted outcome with concrete work; test-first for behavior changes.", "Tasks and ready gates enforce coverage; the plan gate does not depend on tasks."];
+    readonly outputSchema: ["pending work", "acceptance coverage", "dependency order"];
+    readonly doneWhen: ["Each outcome has an executable task or bounded implementation seam."];
+    readonly blockingConditions: ["A task depends on unresolved material intent or hidden prerequisites."];
 }, {
     readonly id: "plan-review";
-    readonly objective: "Perform the explicitly or recommended-default selected read-only blocker review before Accelerated or Full implementation.";
-    readonly requiredInputs: ["spec.md", "plan.md", "tasks.md", "Optional active requirements checklist", "Project constitution", "Review selection after the ready gate, from an explicit answer or the bounded recommended fallback"];
-    readonly instructions: ["At the ready gate, make at most three total attempts when the native review question returns answerless; after the third answerless result, treat Review plan with Oracle (Recommended) as selected, while any explicit Proceed without review answer wins.", "Load the bundled plan-reviewer skill and review executability, completeness, correctness, and coherence without redesigning the plan.", "Require task coverage for every FR and buildable SC; assess outcome SC as measurable verification targets without manufacturing implementation tasks.", "For every declared parallel group, independently assess semantic independence, each lane path union and owner, real cross-lane data flow, prerequisites and barrier, and whether native capacity supports dispatch-before-wait waves with refill; require a truthful sequential fallback when concurrency is unavailable or unproven.", "Return exact [OKAY] or [REJECT] semantics, default to [OKAY], and report at most three true blockers with the smallest fixes.", "After [REJECT], root must repair actionable same-intent planning artifacts, revalidate affected gates, and start a fresh Oracle approval round until [OKAY]; stop instead on a material human-owned blocker.", "Provide the reviewed artifact set so root can persist plan-review.md with SHA-256 freshness evidence; Oracle never writes it.", "Keep plan-review approval separate from implementation confirmation and mandatory final verify."];
-    readonly allowedWrites: ["None; Oracle is read-only. Root persists plan-review.md when review runs."];
-    readonly outputSchema: ["status: [OKAY] or [REJECT]", "zero to three blocker findings with smallest fixes", "non-blocking cautions", "requirement coverage percentage", "parallel executability disposition when tasks declare groups or an evidence-backed None reason", "constitution alignment", "reviewed artifact freshness manifest input"];
-    readonly doneWhen: ["Oracle has returned an exact status and every true blocker has a concrete remediation anchor."];
-    readonly blockingConditions: ["[REJECT] blocks the review path until root repairs planning blockers, the user explicitly proceeds without review, or an explicit override is recorded."];
-    readonly handoff: ["On [OKAY], root persists review evidence and summarizes the approved scope, approach, ownership, verification, and material risks before asking Implement (Recommended) or Stop.", "For an answerless implementation question, root makes at most three total attempts; after the third answerless result, implementation counts as selected, while any explicit Stop answer wins.", "[OKAY] alone does not authorize implementation before that explicit choice or bounded fallback resolves.", "A plan-review result never satisfies mandatory final verify."];
+    readonly objective: "Offer optional independent blocker review after the ready plan.";
+    readonly requiredInputs: ["Ready substantial record", "Selected review disposition"];
+    readonly instructions: ["At ready, first show the user a concise plan summary (goal, acceptance, units, risks), then always offer “Review plan with Oracle (Recommended)” or “Implement directly without review”; record the plan-review choice as EXPLICIT_REVIEW for an explicit review answer, EXPLICIT_SKIP for an explicit direct answer, or DEFAULT_REVIEW_AFTER_3 only when the third confirmed empty return selects review. Keep selection provenance separate from implementation authorization; silence never means EXPLICIT_SKIP.", "For every orchestrator choice with a meaningful safe recommendation, after its first and second confirmed empty native returns repeat the same question and do no dependent work; after the third confirmed empty native return choose the recommendation. Explicit answers and Stop win. Pending, unavailable, failed, interrupted or host-prohibited questions do not count. If higher-priority host or tool rules prevent asking or repeating, obey them and report the limitation rather than claiming three returns or an explicit selection.", "Never fabricate facts or secrets; recommend safe deferral when needed information or material intent is unresolved, and keep dependent work blocked.", "Review scope, approach, risks, and acceptance coverage without redesigning settled intent.", "Return actionable blockers and cautions; a pass is not implementation authorization or final verification.", "After [OKAY], preserve the separate Implement (Recommended) / Stop authorization decision; honor applicable prior explicit authorization, and let explicit Stop supersede it.", "A plan review does not substitute for fresh final verification."];
+    readonly outputSchema: ["status", "blockers", "cautions"];
+    readonly doneWhen: ["The selected review has a current, evidence-backed disposition."];
+    readonly blockingConditions: ["A blocking finding remains unresolved."];
 }, {
     readonly id: "implement";
-    readonly objective: "Execute the accepted task slice with one writer and focused verification.";
-    readonly requiredInputs: ["User request or assigned tasks.md slice", "Accepted spec.md and plan.md when present", "Exact implementation boundaries and verification commands", "Implementation owner decision (orchestrator, designer, quick, or deep), exact mutable surface, requirement anchors, and task-shape/net-gain rationale"];
-    readonly instructions: ["The root marks selected artifact-backed tasks [~] before implementation and marks them [x] only after task-specific evidence is verified; Direct or no-artifact work has no task state.", "The SDD route governs artifacts and gates, not implementation ownership; choose root or a specialist from explicit safe user direction and demonstrated task-shaped net gain.", "When root owns implementation, retain the accepted mutable surface with no child dispatch; when a specialist owns implementation, send one bounded dispatch with the exact surface, requirements, and verification.", "Use test-first or TDD execution for behavior changes and preserve one writer per mutable surface.", "Balance specialization, context isolation, independent work, quality, latency, and total cost against sequential dependency, shared mutable state, accumulated context, rediscovery, and coordination overhead.", "Only after deciding delegation creates net gain, select designer for user-facing UI/UX, quick for known narrow low-risk work, and deep for coupled multi-file, edge-case-heavy, migration, concurrency, shared-contract, or high-risk work.", "Record the owner decision, rationale, exact mutable surface, requirement anchors, and verification before implementation or dispatch.", "Proven independent surfaces may use separate writers with non-overlapping files; overlapping or compatibility-coupled surfaces use one deep writer and ordered handoffs.", "Quick and designer must escalate before expanding into deep-risk or compatibility-coupled scope.", "Edit only the assigned implementation surface and report justified deviations from the accepted plan.", "When evidence refines the same intent, return it to root so canonical artifacts are updated and only affected downstream artifacts and gates are revalidated.", "Start a new change instead of expanding the active one when the intent changes."];
-    readonly allowedWrites: ["Assigned product and test files", "Root only: task checkbox transitions in openspec/changes/<feature>/tasks.md; child writers must not edit task state."];
-    readonly outputSchema: ["status: completed | partial | failed", "per-task outcome", "files changed", "executed verification and results", "deviations, issues, and remaining work"];
-    readonly doneWhen: ["The assigned task slice is complete and its focused checks pass with concrete evidence."];
-    readonly blockingConditions: ["A task needs scope expansion, a material unresolved decision, or fails repeatedly without a safe bounded recovery."];
-    readonly handoff: ["Pass changed files, per-task evidence, deviations, and verification results into the route- and risk-aware final-verification decision."];
+    readonly objective: "Implement the accepted small request or authorized substantial slice.";
+    readonly requiredInputs: ["Settled user intent or authorized record", "Exact mutable boundaries", "Focused checks"];
+    readonly instructions: ["Use one writer per mutable surface and choose an owner from task shape.", "Work only from accepted inputs and named dependencies within the assigned outcome and interface boundaries.", "Return bounded progress for root acceptance before dependent work starts.", "Use test-first (TDD); observe red before green for behavior changes, then verify call sites, shared contracts, and edge cases.", "Stop on a missing interface, ownership conflict, or new independent outcome.", "Return completed bounded progress and the smallest blocker for root reassessment before expansion.", "Do not create process tooling, reports, evidence generators, or temporary artifacts."];
+    readonly outputSchema: ["outcome", "changed files", "checks", "residual risks"];
+    readonly doneWhen: ["The assigned outcome is implemented and focused checks have run."];
+    readonly blockingConditions: ["Scope, risk, or material intent changes before safe completion."];
 }, {
     readonly id: "verify";
-    readonly objective: "Judge the implementation against accepted requirements using executed evidence.";
-    readonly requiredInputs: ["Implemented change or task results", "spec.md, plan.md, and tasks.md for artifact-backed routes", "Changed files and project verification commands"];
-    readonly instructions: ["Trivial deterministic Direct work may use root-owned focused verification; materially risky Direct plus Accelerated and Full final verification use a fresh independent Oracle, and no implementation writer self-approves.", "Run or inspect the smallest sufficient executed checks; static confidence alone is not evidence.", "Judge completeness, correctness, and coherence independently so a passing test cannot hide missing or contradictory scope.", "Build a compliance matrix from every accepted requirement to code and executed checks.", "Record every outcome SC as PASS with concrete observed evidence or RISK with an explicit residual-risk entry.", "For accelerated and full routes, the root persists the read-only oracle result as verify-report.md."];
-    readonly allowedWrites: ["Root persistence only: openspec/changes/<feature>/verify-report.md for accelerated and full routes"];
-    readonly outputSchema: ["verdict: pass | fail", "compliance matrix", "executed checks and results", "critical issues with remediation anchors", "warnings and residual risks"];
-    readonly doneWhen: ["Every accepted requirement is represented in the compliance matrix and the verdict matches the evidence."];
-    readonly blockingConditions: ["Missing required evidence, incomplete tasks, failed checks, or unresolved critical issues force a fail verdict."];
-    readonly handoff: ["On fail, hand off actionable findings to converge; on pass, hand off the accepted verify-report.md to archive for artifact-backed routes."];
+    readonly objective: "Verify actual outcomes with independence proportional to risk.";
+    readonly requiredInputs: ["Accepted outcomes", "Actual change and executed checks"];
+    readonly instructions: ["Judge the actual diff, executed checks, and residual risks; verify completeness, correctness, coherence, and behavior.", "Substantial or materially risky work requires a fresh independent Oracle; no writer self-approves.", "For substantial work, record acceptance evidence, checks, source digests, and reviewed-record digest in the same record."];
+    readonly outputSchema: ["verdict", "acceptance evidence", "checks", "residual risks"];
+    readonly doneWhen: ["Every accepted outcome has evidence or an explicit residual risk."];
+    readonly blockingConditions: ["A failed check, missing evidence, or critical issue remains."];
 }, {
     readonly id: "converge";
-    readonly objective: "Convert verified implementation gaps into traceable remaining tasks without editing product code.";
-    readonly requiredInputs: ["Failed verify result and remediation anchors", "spec.md, plan.md, and tasks.md", "Current maximum task and phase identifiers"];
-    readonly instructions: ["Use an append-only update: add one new Convergence phase to tasks.md and never rewrite, renumber, reorder, or delete existing tasks.", "Classify each gap as missing, partial, contradicts, or unrequested; append one traceable task per actionable gap, ordered by severity and linked to its source requirement.", "Must not edit product code; implementation belongs to the next implement pass.", "If there is no actionable gap, leave tasks.md byte-for-byte unchanged."];
-    readonly allowedWrites: ["Append-only changes to openspec/changes/<feature>/tasks.md"];
-    readonly outputSchema: ["outcome: tasks-appended | converged", "appended task IDs and source requirements", "next implementation scope"];
-    readonly doneWhen: ["Every actionable verification gap is represented by a new traceable task, or the implementation is confirmed converged."];
-    readonly blockingConditions: ["The verify findings lack enough evidence or source anchors to create truthful tasks."];
-    readonly handoff: ["On tasks-appended, return to implement and then verify; on converged, re-run verify before archive."];
+    readonly objective: "Turn actionable verification gaps into bounded corrective work.";
+    readonly requiredInputs: ["Failed verification", "Settled intent"];
+    readonly instructions: ["Record acceptance-linked follow-up in the same record when one exists.", "If scope or risk changes materially, reopen understanding and classification.", "Do not create a separate convergence report."];
+    readonly outputSchema: ["bounded follow-up", "verification seam"];
+    readonly doneWhen: ["Each actionable gap has a safe next action or the work is confirmed converged."];
+    readonly blockingConditions: ["Findings lack evidence or require material new intent."];
 }, {
     readonly id: "archive";
-    readonly objective: "Close a verified artifact-backed change with a durable audit trail.";
-    readonly requiredInputs: ["Completed spec.md, plan.md, and tasks.md", "verify-report.md with verdict pass", "Change name and current date"];
-    readonly instructions: ["Confirm all tasks are complete, verify-report.md records pass, and there are no unresolved critical issues.", "Create archive-report.md with verification lineage, completed scope, residual warnings, and final archive path.", "After oracle pass, transactionally synchronize only explicitly declared durable deltas from spec.md into openspec/specs.", "Stage and back up canonical writes so handled failures roll back within the active process; this is not crash-atomic across forced process or operating-system termination.", "Move the complete change to openspec/changes/archive/YYYY-MM-DD-<feature>/.", "An INTERNAL requirement never updates openspec/specs; undeclared prose is never merged."];
-    readonly allowedWrites: ["openspec/changes/<feature>/archive-report.md", "Declared durable requirement updates under openspec/specs/", "Move openspec/changes/<feature>/ to openspec/changes/archive/YYYY-MM-DD-<feature>/"];
-    readonly outputSchema: ["status: archived | blocked", "archive path", "canonical specifications updated", "audit summary and verification lineage"];
-    readonly doneWhen: ["Declared durable deltas are transactionally synchronized, the audit report records the result, and the complete change directory is present at the dated archive path."];
-    readonly blockingConditions: ["Archive is blocked unless all tasks are complete, verify-report.md has verdict pass, and no unresolved critical issue remains."];
-    readonly handoff: ["Return the archive path and audit summary to the root for final synthesis."];
+    readonly objective: "Transactionally apply declared deltas and archive a verified record.";
+    readonly requiredInputs: ["Complete substantial record", "Fresh independent pass", "Current archive date"];
+    readonly instructions: ["Fail-closed behavior blocks incomplete tasks, acceptance evidence, authorization, or independent verification.", "Apply only declared durable deltas transactionally and preserve unaffected specifications.", "Move `.thoth/changes/<id>/<id>.md` to `.thoth/changes/archive/YYYY-MM-DD-<id>/<id>.md`; keep the filename stable."];
+    readonly outputSchema: ["archive path", "updated specifications", "residual risks"];
+    readonly doneWhen: ["Declared deltas and verified record are archived without collisions or history loss."];
+    readonly blockingConditions: ["A closeout gate fails, destination collides, or a symlinked ancestor exists."];
 }];
-export declare const SDD_WORKFLOW_CONTRACT: SddWorkflowContract;
-export declare function classifySddRoute(input: SddRoutingInput): SddRoutingDecision;
+export declare function classifySddChange(input: SddChangeClassificationInput): SddClassificationDecision;
 export declare function getSddWorkflowContract(): SddWorkflowContract;
-export declare function getSddRouteExecutionPolicy(route: SddRoute): SddRouteExecutionPolicy;
-export declare function getSddArtifactGraph(): SddArtifactContract[];
 export declare function getSddPhase(id: SddPhaseId): SddPhaseContract;
 export declare function getSddPhaseProtocol(id: SddPhaseId): SddPhaseProtocol;
-export declare function getSddPhaseProtocolsForRole(role: AgentRoleName): SddPhaseProtocol[];
-export declare function renderSddPhaseDispatchEnvelope(input: SddPhaseDispatchInput): string;
-export declare function renderSddPhaseDispatchTemplate(): string;
-export declare function getSddFinalVerificationDecision({ route, risk, }: {
-    route: SddRoute;
-    risk: SddFinalVerificationRisk;
-}): SddFinalVerificationDecision;
-export declare function getSddPhaseOwner(route: SddRoute, phaseId: SddPhaseId, verificationRisk?: SddFinalVerificationRisk): SddPhaseOwner;
-export declare function getRequiredSddPhaseOrder(route: SddRoute): SddPhaseId[];
-export declare function canEnterSddPhase({ route, completed, target, }: {
-    route: SddRoute;
+export declare function getSddRequiredPhaseOrder(classification: Pick<SddClassificationDecision, 'classification'>): SddPhaseId[];
+export declare function canEnterSddPhase({ classification, completed, target, }: {
+    classification: Pick<SddClassificationDecision, 'classification'>;
     completed: readonly SddPhaseId[];
     target: SddPhaseId;
 }): boolean;
+export declare function getSddFinalVerificationDecision({ classification, risk, }: {
+    classification: SddClassification;
+    risk: SddRisk;
+}): SddFinalVerificationDecision;