thoth-agents 0.2.11 → 0.3.1

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

@@ -1,187 +1,420 @@
 import type { AgentRoleName } from './agent-pack';
-export type SddPipelineType = 'direct' | 'accelerated' | 'full';
-export type SddPhaseId = 'requirements-interview' | 'init' | 'explore' | 'proposal' | 'spec' | 'clarify' | 'design' | 'tasks' | 'plan-review' | 'implementation-confirmation' | 'apply' | 'verify' | 'archive';
+import type { MemoryDispatchContract } from './memory-governance';
+export type SddRoute = 'direct' | 'accelerated' | 'full';
+export type SddIntent = 'documentation' | 'mechanical' | 'behavior' | 'architecture';
+export type SddScope = 'local' | 'multi-file' | 'cross-cutting';
+export type SddClarity = 'clear' | 'partial' | 'uncertain';
+export type SddRisk = 'low' | 'medium' | 'high';
+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;
+    scope: SddScope;
+    clarity: SddClarity;
+    contractRisk: SddRisk;
+    failureCost: SddRisk;
+    requestedRoute?: SddRoute;
+    sddRequested?: boolean;
+}
+export interface SddRoutingDecision {
+    route: SddRoute;
+    requiresUserInput: boolean;
+    reasons: string[];
+}
+export type SddPhaseId = 'explore' | 'specify' | 'clarify' | 'plan' | 'checklist' | 'tasks' | 'analyze' | 'implement' | 'verify' | 'converge' | 'archive';
+export type SddPhaseActivation = 'required' | 'conditional';
 export interface SddPhaseContract {
     id: SddPhaseId;
     order: number;
-    requiredFor: SddPipelineType[];
+    availableFor: SddRoute[];
+    requiredFor: SddRoute[];
+    activation: SddPhaseActivation;
     prerequisites: SddPhaseId[];
     producesArtifact: boolean;
-    gate?: 'oracle-review' | 'user-confirmation' | 'iterative-verify';
-    maxRounds?: number;
-    owner: 'orchestrator' | 'read-only-agent' | 'write-capable-agent' | 'oracle' | 'user';
-    artifactSkill?: string;
-    artifactMeaning?: string;
+    defaultAgentRole: AgentRoleName;
+    eligibleAgentRoles: AgentRoleName[];
+    reason: string;
     condition?: string;
-    defaultAgentRole?: AgentRoleName;
-    alternateAgentRoles?: AgentRoleName[];
-    alternateAgentCondition?: string;
-    supportingAgentRoles?: AgentRoleName[];
-    persistenceAgentRole?: AgentRoleName;
-    delegationReason?: string;
-    handoffHints?: string[];
+}
+export interface SddPhaseProtocol {
+    id: SddPhaseId;
+    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' | 'verify-report' | 'archive-report';
+export interface SddArtifactContract {
+    id: SddArtifactId;
+    path: string;
+    producedBy: SddPhaseId;
+    consumes: SddArtifactId[];
+    requiredFor: SddRoute[];
 }
 export interface SddWorkflowContract {
+    artifactRoot: string;
     phases: SddPhaseContract[];
+    routePolicies: SddRouteExecutionPolicy[];
     routingRules: string[];
     artifactRules: string[];
     verificationRules: string[];
 }
-export declare const FULL_SDD_PHASE_ORDER: readonly ["requirements-interview", "explore", "proposal", "spec", "clarify", "design", "tasks", "plan-review", "implementation-confirmation", "apply", "verify", "archive"];
-export declare const SDD_VERIFY_MAX_ROUNDS = 3;
+export interface SddRouteExecutionPolicy {
+    route: SddRoute;
+    planningMode: SddPlanningMode;
+    validationGates: SddValidationGate[];
+    optionalArtifactsByDefault: boolean;
+    routineUserPauses: boolean;
+    artifactRevisionPolicy: SddArtifactRevisionPolicy;
+}
 export declare const SDD_PHASES: readonly [{
-    readonly id: "requirements-interview";
+    readonly id: "explore";
     readonly order: 0;
-    readonly requiredFor: ["direct", "accelerated", "full"];
+    readonly availableFor: ["full"];
+    readonly requiredFor: ["full"];
+    readonly activation: "required";
     readonly prerequisites: [];
     readonly producesArtifact: false;
-    readonly owner: "orchestrator";
-    readonly delegationReason: "Root-owned requirements discovery, scope calibration, and route approval.";
+    readonly defaultAgentRole: "explorer";
+    readonly eligibleAgentRoles: ["explorer"];
+    readonly reason: "Resolve broad repository uncertainty before requirements are fixed.";
 }, {
-    readonly id: "init";
+    readonly id: "specify";
     readonly order: 1;
-    readonly requiredFor: [];
-    readonly prerequisites: ["requirements-interview"];
+    readonly availableFor: ["accelerated", "full"];
+    readonly requiredFor: ["accelerated", "full"];
+    readonly activation: "required";
+    readonly prerequisites: ["explore"];
     readonly producesArtifact: true;
-    readonly owner: "write-capable-agent";
-    readonly artifactSkill: "sdd-init";
-    readonly condition: "Only when OpenSpec persistence is selected and openspec/ is missing or stale (partial structure or missing mechanism sections).";
-    readonly defaultAgentRole: "quick";
-    readonly supportingAgentRoles: ["explorer"];
-    readonly delegationReason: "Fast mechanical bootstrap, with explorer supplying repository facts when needed.";
+    readonly defaultAgentRole: "orchestrator";
+    readonly eligibleAgentRoles: ["orchestrator"];
+    readonly reason: "Define the user-visible requirements and acceptance contract.";
 }, {
-    readonly id: "explore";
+    readonly id: "clarify";
     readonly order: 2;
-    readonly requiredFor: ["accelerated", "full"];
-    readonly prerequisites: ["requirements-interview"];
+    readonly availableFor: ["accelerated", "full"];
+    readonly requiredFor: [];
+    readonly activation: "conditional";
+    readonly prerequisites: ["specify"];
     readonly producesArtifact: false;
-    readonly owner: "read-only-agent";
-    readonly defaultAgentRole: "explorer";
-    readonly supportingAgentRoles: ["librarian"];
-    readonly delegationReason: "Read-only repository discovery before artifact-producing SDD phases.";
+    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 id: "proposal";
+    readonly id: "plan";
     readonly order: 3;
+    readonly availableFor: ["accelerated", "full"];
     readonly requiredFor: ["accelerated", "full"];
-    readonly prerequisites: ["requirements-interview", "explore"];
+    readonly activation: "required";
+    readonly prerequisites: ["specify"];
     readonly producesArtifact: true;
-    readonly owner: "write-capable-agent";
-    readonly artifactSkill: "sdd-propose";
-    readonly defaultAgentRole: "deep";
-    readonly supportingAgentRoles: ["oracle"];
-    readonly delegationReason: "Structured technical reasoning and trade-off synthesis before implementation.";
-    readonly handoffHints: ["Preserve accepted scope and explicit non-goals downstream.", "Carry deferred or discovery affected areas forward as follow-up."];
+    readonly defaultAgentRole: "orchestrator";
+    readonly eligibleAgentRoles: ["orchestrator"];
+    readonly reason: "Translate requirements into an executable technical approach.";
 }, {
-    readonly id: "spec";
+    readonly id: "checklist";
     readonly order: 4;
-    readonly requiredFor: ["full"];
-    readonly prerequisites: ["proposal"];
-    readonly producesArtifact: true;
-    readonly owner: "write-capable-agent";
-    readonly artifactSkill: "sdd-spec";
-    readonly defaultAgentRole: "deep";
-    readonly supportingAgentRoles: ["oracle"];
-    readonly delegationReason: "High-quality requirement contract work where ambiguity propagates downstream.";
-    readonly handoffHints: ["Preserve recorded Assumptions and any [NEEDS CLARIFICATION] resolutions.", "Keep the requirements-quality checklist resolved before tasks."];
-}, {
-    readonly id: "clarify";
-    readonly order: 5;
-    readonly requiredFor: ["full"];
-    readonly prerequisites: ["spec"];
-    readonly producesArtifact: false;
-    readonly owner: "write-capable-agent";
-    readonly artifactSkill: "sdd-clarify";
-    readonly defaultAgentRole: "deep";
-    readonly supportingAgentRoles: ["oracle"];
-    readonly delegationReason: "Resolve residual spec ambiguity in place before design consumes it.";
-    readonly handoffHints: ["Preserve clarified resolutions written back into the spec.", "Keep the requirements-quality checklist re-validated before design."];
-}, {
-    readonly id: "design";
-    readonly order: 6;
-    readonly requiredFor: ["full"];
-    readonly prerequisites: ["proposal", "clarify"];
+    readonly availableFor: ["accelerated", "full"];
+    readonly requiredFor: [];
+    readonly activation: "conditional";
+    readonly prerequisites: ["specify", "plan"];
     readonly producesArtifact: true;
-    readonly owner: "write-capable-agent";
-    readonly artifactSkill: "sdd-design";
-    readonly artifactMeaning: "technical-solution-design";
-    readonly defaultAgentRole: "deep";
-    readonly supportingAgentRoles: ["designer"];
-    readonly delegationReason: "Technical architecture and file-change design; designer only supports UI/UX concerns.";
-    readonly handoffHints: ["Preserve coverage decisions and architecture constraints in tasks.", "Honor the Constitution Check outcome recorded during design."];
+    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 id: "tasks";
-    readonly order: 7;
-    readonly requiredFor: ["accelerated", "full"];
-    readonly prerequisites: ["proposal", "spec", "design"];
-    readonly producesArtifact: true;
-    readonly owner: "write-capable-agent";
-    readonly artifactSkill: "sdd-tasks";
-    readonly defaultAgentRole: "quick";
-    readonly alternateAgentRoles: ["deep"];
-    readonly alternateAgentCondition: "Only when the task plan is complex.";
-    readonly delegationReason: "Mechanical conversion of settled design into dependency-ordered execution tasks.";
-}, {
-    readonly id: "plan-review";
-    readonly order: 8;
+    readonly order: 5;
+    readonly availableFor: ["accelerated", "full"];
     readonly requiredFor: ["accelerated", "full"];
-    readonly prerequisites: ["tasks"];
+    readonly activation: "required";
+    readonly prerequisites: ["specify", "plan"];
     readonly producesArtifact: true;
-    readonly gate: "oracle-review";
-    readonly owner: "oracle";
-    readonly artifactSkill: "plan-reviewer";
-    readonly artifactMeaning: "durable-plan-review-result";
-    readonly defaultAgentRole: "oracle";
-    readonly persistenceAgentRole: "quick";
-    readonly delegationReason: "Independent read-only executability review of tasks before implementation; quick persists the durable review artifact when writes are required.";
+    readonly defaultAgentRole: "orchestrator";
+    readonly eligibleAgentRoles: ["orchestrator"];
+    readonly reason: "Produce dependency-ordered implementation slices with verification.";
 }, {
-    readonly id: "implementation-confirmation";
-    readonly order: 9;
-    readonly requiredFor: ["accelerated", "full"];
-    readonly prerequisites: ["plan-review"];
+    readonly id: "analyze";
+    readonly order: 6;
+    readonly availableFor: ["full"];
+    readonly requiredFor: ["full"];
+    readonly activation: "required";
+    readonly prerequisites: ["specify", "plan", "tasks"];
     readonly producesArtifact: false;
-    readonly gate: "user-confirmation";
-    readonly owner: "user";
-    readonly delegationReason: "Human approval gate after reviewed tasks and before workspace implementation.";
+    readonly defaultAgentRole: "oracle";
+    readonly eligibleAgentRoles: ["oracle"];
+    readonly reason: "Independently check cross-artifact consistency before high-risk implementation.";
 }, {
-    readonly id: "apply";
-    readonly order: 10;
+    readonly id: "implement";
+    readonly order: 7;
+    readonly availableFor: ["direct", "accelerated", "full"];
     readonly requiredFor: ["direct", "accelerated", "full"];
-    readonly prerequisites: ["implementation-confirmation"];
+    readonly activation: "required";
+    readonly prerequisites: ["tasks", "analyze"];
     readonly producesArtifact: false;
-    readonly owner: "write-capable-agent";
-    readonly defaultAgentRole: "deep";
-    readonly alternateAgentRoles: ["quick", "designer"];
-    readonly delegationReason: "Correctness-heavy implementation by default; quick handles mechanical batches and designer owns UI/visual work.";
+    readonly defaultAgentRole: "orchestrator";
+    readonly eligibleAgentRoles: ["orchestrator", "designer", "quick", "deep"];
+    readonly reason: "Let the adaptive root act directly or route the settled work to one writer.";
 }, {
     readonly id: "verify";
-    readonly order: 11;
-    readonly requiredFor: ["accelerated", "full"];
-    readonly prerequisites: ["apply"];
+    readonly order: 8;
+    readonly availableFor: ["direct", "accelerated", "full"];
+    readonly requiredFor: ["direct", "accelerated", "full"];
+    readonly activation: "required";
+    readonly prerequisites: ["implement"];
     readonly producesArtifact: true;
-    readonly gate: "iterative-verify";
-    readonly maxRounds: 3;
-    readonly owner: "oracle";
-    readonly artifactSkill: "sdd-verify";
     readonly defaultAgentRole: "oracle";
-    readonly persistenceAgentRole: "quick";
-    readonly delegationReason: "Independent verification review; quick persists the report when the selected store requires writes.";
+    readonly eligibleAgentRoles: ["oracle"];
+    readonly reason: "Independently judge the result against requirements, contracts, and focused checks.";
+}, {
+    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 id: "archive";
-    readonly order: 12;
+    readonly order: 10;
+    readonly availableFor: ["accelerated", "full"];
     readonly requiredFor: ["accelerated", "full"];
+    readonly activation: "required";
     readonly prerequisites: ["verify"];
     readonly producesArtifact: true;
-    readonly owner: "write-capable-agent";
-    readonly artifactSkill: "sdd-archive";
-    readonly defaultAgentRole: "quick";
-    readonly delegationReason: "Mechanical closeout, summary, and archive movement after verification passes.";
+    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: "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: false;
+    readonly artifactRevisionPolicy: "revalidate-affected-downstream";
+}, {
+    readonly route: "full";
+    readonly planningMode: "gated";
+    readonly validationGates: ["specify", "plan", "tasks", "ready", "closeout"];
+    readonly optionalArtifactsByDefault: false;
+    readonly routineUserPauses: false;
+    readonly artifactRevisionPolicy: "revalidate-affected-downstream";
+}];
+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 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.", "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.", "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 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 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 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 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: ["Pass spec.md, plan.md, tasks.md, dependencies, and verification commands to analyze or implement."];
+}, {
+    readonly id: "analyze";
+    readonly objective: "Perform read-only cross-artifact consistency and readiness analysis before full SDD implementation.";
+    readonly requiredInputs: ["spec.md", "plan.md", "tasks.md", "Project constitution"];
+    readonly instructions: ["Detect contradictions, ambiguity, duplication, scope drift, orphan tasks, and uncovered requirements.", "Challenge artifact completeness, requirement correctness, and cross-artifact coherence as separate review dimensions.", "Require task coverage for every FR and buildable SC; assess outcome SC as measurable verification targets without manufacturing implementation tasks.", "Report requirement coverage as a percentage and classify findings as CRITICAL, HIGH, MEDIUM, or LOW.", "Treat constitution violations and baseline requirements with zero task coverage as blocking."];
+    readonly allowedWrites: ["None; analysis is read-only and returns its report in-session."];
+    readonly outputSchema: ["findings table with stable IDs and severity", "requirement coverage percentage", "constitution alignment", "readiness verdict: ready | blocked"];
+    readonly doneWhen: ["Every high-signal cross-artifact inconsistency has a severity and remediation anchor."];
+    readonly blockingConditions: ["Any unresolved CRITICAL finding or constitution violation blocks implementation."];
+    readonly handoff: ["On ready, pass the reviewed artifact set and cautions to implement; on blocked, return findings to the owning coordination phase."];
+}, {
+    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"];
+    readonly instructions: ["The root marks selected artifact-backed tasks [~] before dispatch and marks them [x] only after task-specific evidence is verified.", "Use test-first or TDD execution for behavior changes and preserve one writer per mutable surface.", "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 to verify."];
+}, {
+    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: ["Oracle must be independent from the implementation writer; self-review never satisfies this phase.", "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 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 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."];
 }];
 export declare const SDD_WORKFLOW_CONTRACT: SddWorkflowContract;
+export declare function classifySddRoute(input: SddRoutingInput): SddRoutingDecision;
 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 getRequiredSddPhaseOrder(pipeline: SddPipelineType): SddPhaseId[];
-export declare function canEnterSddPhase({ pipeline, completed, target, }: {
-    pipeline: SddPipelineType;
+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 getSddPhaseOwner(_route: SddRoute, phaseId: SddPhaseId): AgentRoleName;
+export declare function getRequiredSddPhaseOrder(route: SddRoute): SddPhaseId[];
+export declare function canEnterSddPhase({ route, completed, target, }: {
+    route: SddRoute;
     completed: readonly SddPhaseId[];
     target: SddPhaseId;
 }): boolean;

package/dist/harness/generate-integration-packages.d.ts

@@ -0,0 +1,20 @@
+import type { HarnessDiagnostic } from './types';
+export interface GenerateIntegrationPackagesOptions {
+    projectRoot: string;
+}
+export interface GenerateIntegrationPackagesResult {
+    written: string[];
+    diagnostics: HarnessDiagnostic[];
+}
+export type IntegrationDiagnosticLevel = 'info' | 'warning' | 'capability-gap' | 'error';
+export interface IntegrationDiagnosticReport {
+    level: IntegrationDiagnosticLevel;
+    code: string;
+    message: string;
+    fallback?: HarnessDiagnostic['fallback'];
+    fatal: boolean;
+}
+export declare function prepareIntegrationDiagnostics(diagnostics: readonly HarnessDiagnostic[]): IntegrationDiagnosticReport[];
+export declare function formatIntegrationDiagnostic(diagnostic: IntegrationDiagnosticReport): string;
+export declare function getIntegrationDiagnosticExitCode(diagnostics: readonly IntegrationDiagnosticReport[]): 0 | 1;
+export declare function generateIntegrationPackages({ projectRoot, }: GenerateIntegrationPackagesOptions): GenerateIntegrationPackagesResult;

package/dist/harness/opencode-init-command.d.ts

@@ -0,0 +1,11 @@
+export interface OpenCodeInitCommandOptions {
+    projectRoot: string;
+    packageRoot: string;
+}
+export interface OpenCodeInitCommand {
+    template: string;
+    description: string;
+    agent: 'orchestrator';
+    subtask: false;
+}
+export declare function createOpenCodeInitCommand({ projectRoot, packageRoot, }: OpenCodeInitCommandOptions): OpenCodeInitCommand;

package/dist/harness/types.d.ts

@@ -3,6 +3,20 @@ export type HarnessArtifactKind = 'agent-config' | 'harness-config' | 'mcp-confi
 export type HarnessDiagnosticSeverity = 'info' | 'warning' | 'error';
 export type HarnessDiagnosticCode = 'harness.unsupported' | 'harness.capability_gap' | 'harness.surface_unvalidated' | 'harness.artifact_skipped' | (string & {});
 export type HarnessCapabilityStatus = 'supported' | 'unsupported' | 'instruction-only' | 'unknown';
+export type ProviderCapabilityState = 'supported' | 'degraded' | 'unsupported';
+export type ProviderCapabilityEvidenceSource = 'provider' | 'harness' | 'none';
+/**
+ * Ephemeral evidence supplied by a caller after a documented provider or
+ * harness surface has evaluated a provider-dependent outcome.
+ */
+export interface ProviderCapabilityEvidence {
+    state: ProviderCapabilityState;
+    source: ProviderCapabilityEvidenceSource;
+    basis: string[];
+}
+export interface ProviderEvidenceInput {
+    providerEvidence?: ProviderCapabilityEvidence;
+}
 export interface HarnessCapabilities {
     agentDefinitions: HarnessCapabilityStatus;
     delegatedExecution: HarnessCapabilityStatus;
@@ -19,7 +33,6 @@ export interface HarnessRenderOptions {
     overwrite?: boolean;
     targetHarness?: HarnessId;
     outputRoot?: string;
-    codexSkillOutputModes?: readonly ('plugin-package' | 'repo-local-fallback')[];
 }
 export interface HarnessArtifact {
     path: string;