sdd-agent-platform 0.4.1 → 0.5.0

package/packages/core/dist/stage-collaboration.d.ts

@@ -0,0 +1,736 @@
+import type { RuntimeProjectionEnvelope, RuntimeRef, RuntimeScope, SddStage } from './contracts.js';
+import { STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION } from './contracts.js';
+import type { LifecycleRiskDecision } from './risk/contracts.js';
+import type { WorkflowHandoff } from './stage-runtime/contracts.js';
+import { type RuntimeProjectionEnvelopeWriteResult } from './storage/runtime-store.js';
+import type { RegisteredStageArtifact } from './stage-artifacts.js';
+import type { RegisteredStageCollaborationContract } from './stage-collaboration-contracts.js';
+import type { SpecRuntimeCloseBoundaryFacts } from './spec-manager-contracts.js';
+export type StageCollaborationIntensity = 'noop' | 'lightweight' | 'team-required' | 'scout-first' | 'blocked';
+export type StageCollaborationHealth = 'no-op' | 'needs_clarification' | 'ready_for_plan' | 'ready_for_tasks' | 'ready_for_execute' | 'ready_for_ship' | 'ship_ready' | 'rejected' | 'blocked';
+export type SpecProposalItemKind = 'advisory_finding' | 'blocking_ambiguity' | 'capability_suggestion' | 'handoff_proposal';
+export type SpecStageWorkOrderOutputKind = 'scout_context' | 'spec_review' | 'manager_closure_request';
+export type SpecProposalAuthorityAttempt = 'stage_pass' | 'risk_decision' | 'gate_pass' | 'ship_ready' | 'truth_alignment_approved';
+export type RuntimeProposalRejectionReason = 'missing_refs' | 'missing_required_review' | 'unsupported_stage' | 'authority_violation' | 'blocked_lifecycle' | 'invalid_proposal';
+export type RuntimeNextActionReasonCode = 'authority_violation' | 'graph_illegal' | 'scope_unresolved' | 'ambiguous_target' | 'missing_canonical_artifact' | 'stale_upstream' | 'missing_handoff' | 'missing_required_review' | 'unresolved_conflict' | 'unresolved_ambiguity' | 'insufficient_evidence' | 'manager_rework_required' | 'human_required' | 'stage_ready' | 'handoff_ready' | 'report_only';
+export type RuntimeNextActionKind = 'reject_proposal' | 'refresh_upstream_stage' | 'collect_required_review' | 'resolve_ambiguity' | 'request_manager_rework' | 'ask_user_clarification' | 'commit_stage_closure' | 'create_handoff' | 'report_status';
+export type RuntimeNextActionScope = 'global' | 'stage' | 'human' | 'runtime';
+export type RuntimeNextActionOwner = 'orchestrator' | 'stage-manager' | 'user' | 'runtime';
+export type SpecStageManagerId = 'spec-manager';
+export type SpecStageAgentId = 'spec-reviewer' | 'scout';
+export type SpecStageCapabilityDomain = 'norm_discovery' | 'uncertainty_resolution' | 'context_curation' | 'solution-design' | 'frontend-engineering' | 'security-engineering' | 'ui-ux-product-design';
+export type PlanStageManagerId = 'plan-manager';
+export type PlanStageAgentId = 'plan-scout' | 'plan-review-agent';
+export type PlanScoutDomain = 'architecture-runtime' | 'backend-api' | 'frontend-ui' | 'database-migration' | 'security' | 'performance' | 'testing-validation';
+export type PlanStageCapabilityDomain = PlanScoutDomain | 'plan-strategy' | 'plan-pressure-review';
+export type SpecStageParticipantKind = 'agent' | 'subagent' | 'skill' | 'material-pack';
+export type SpecStageCollaborationTopology = 'none' | 'single-agent' | 'team-lite' | 'parallel-research' | 'team-required';
+export interface RuntimeNextActionPriority {
+    reasonRank: number;
+    upstreamDistance: number;
+    actionRank: number;
+    stableOrder: number;
+}
+export interface RuntimeNextAction {
+    contract: typeof STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION;
+    actionId: string;
+    stage: SddStage;
+    scope: RuntimeScope;
+    kind: RuntimeNextActionKind;
+    owner: RuntimeNextActionOwner;
+    actionScope: RuntimeNextActionScope;
+    reasonCode: RuntimeNextActionReasonCode;
+    priority: RuntimeNextActionPriority;
+    requiredInputs: string[];
+    blockedBy: RuntimeRef[];
+    createdAt: string;
+}
+export declare const SPEC_STAGE_MANAGER = "spec-manager";
+export declare const SPEC_STAGE_REVIEW_AGENT = "spec-reviewer";
+export declare const SPEC_STAGE_SCOUT_AGENT = "scout";
+export declare const SPEC_STAGE_AGENT_TEAM: SpecStageAgentId[];
+export declare const SPEC_STAGE_REQUIRED_CAPABILITIES: SpecStageCapabilityDomain[];
+export declare const SPEC_STAGE_OPTIONAL_CAPABILITIES: SpecStageCapabilityDomain[];
+export declare const SPEC_STAGE_MATERIAL_PACKS: readonly ["project-norms", "uncertainty-map", "baseline-solution-design", "baseline-frontend-engineering", "baseline-security-engineering", "baseline-ui-ux-product-design"];
+export declare const STAGE_COLLABORATION_RUNTIME_PRODUCER_VERSION = "phase9.1-stage-collaboration-runtime-v1";
+export declare const SPEC_COLLABORATION_ADJUDICATION_PROJECTION_TYPE = "phase9_1_spec_collaboration_adjudication";
+export declare const PLAN_COLLABORATION_ADJUDICATION_PROJECTION_TYPE = "phase9_2_plan_collaboration_adjudication";
+export declare const PLAN_STAGE_MANAGER = "plan-manager";
+export declare const PLAN_STAGE_SCOUT_AGENT = "plan-scout";
+export declare const PLAN_STAGE_REVIEW_AGENT = "plan-review-agent";
+export declare const PLAN_STAGE_AGENT_TEAM: PlanStageAgentId[];
+export declare const PLAN_SCOUT_DOMAINS: PlanScoutDomain[];
+export declare const PLAN_STAGE_REQUIRED_CAPABILITIES: PlanStageCapabilityDomain[];
+export declare const PLAN_STAGE_OPTIONAL_CAPABILITIES: PlanStageCapabilityDomain[];
+export declare const PLAN_STAGE_MATERIAL_PACKS: readonly ["project-norms", "plan-section-rubric", "plan-scout-domain-packs"];
+export declare const TASKS_COLLABORATION_ADJUDICATION_PROJECTION_TYPE = "phase9_3_tasks_collaboration_adjudication";
+export declare const TASKS_STAGE_MANAGER = "tasks-manager";
+export declare const TASKS_STAGE_REVIEW_AGENT = "task-review-agent";
+export declare const TASKS_STAGE_SLICER_AGENT = "task-slicer";
+export declare const EXECUTE_IMPLEMENTER_AGENT = "implementer";
+export declare const EXECUTE_CODE_REVIEW_AGENT = "code-reviewer";
+export declare const EXECUTE_DEBUGGER_AGENT = "debugger";
+export declare const EXECUTE_TEST_RUNNER_AGENT = "test-runner";
+export declare const EXECUTE_VALIDATOR_AGENT = "validator";
+export declare const EXECUTE_TEST_REVIEW_AGENT = "test-reviewer";
+export declare const EXECUTE_COLLABORATION_ADJUDICATION_PROJECTION_TYPE = "phase10_execute_collaboration_adjudication";
+export declare const EXECUTE_EVIDENCE_JUDGMENT_VALIDATOR_AGENT = "evidence-validator";
+export declare const EXECUTE_EVIDENCE_JUDGMENT_REVIEW_AGENT = "evidence-reviewer";
+export declare const TRUTH_ALIGNMENT_PROJECTION_TYPE = "phase9_12_truth_alignment";
+export declare const TRUTH_ALIGNMENT_CONTRACT = "sdd-truth-alignment-v1";
+export declare const SHIP_COLLABORATION_ADJUDICATION_PROJECTION_TYPE = "phase9_9_ship_collaboration_adjudication";
+export declare const SHIP_STAGE_MANAGER = "ship-manager";
+export declare const SHIP_STAGE_VALIDATOR_AGENT = "ship-validator";
+export declare const SHIP_STAGE_REVIEW_AGENT = "release-reviewer";
+export interface SpecStageCollaborationParticipant {
+    id: string;
+    kind: SpecStageParticipantKind;
+    role: string;
+    required: boolean;
+    capabilityDomain?: SpecStageCapabilityDomain | PlanStageCapabilityDomain;
+    parallelGroup: string | null;
+}
+export interface SpecStageCollaborationPlan {
+    topology: SpecStageCollaborationTopology;
+    participants: SpecStageCollaborationParticipant[];
+    maxParallelism: number;
+    fanIn: 'runtime_adjudication';
+}
+export interface StageCollaborationProfile {
+    contract: typeof STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION;
+    stage: SddStage;
+    scope: RuntimeScope;
+    lifecycleProfile: LifecycleRiskDecision['profile'];
+    intensity: StageCollaborationIntensity;
+    required: boolean;
+    requiresStageClosure: boolean;
+    allowedProposalKinds: SpecProposalItemKind[];
+    stageManager: SpecStageManagerId | null;
+    agentTeam: SpecStageAgentId[];
+    requiredCapabilities: SpecStageCapabilityDomain[];
+    optionalCapabilities: SpecStageCapabilityDomain[];
+    materialPackIds: string[];
+    collaborationPlan: SpecStageCollaborationPlan;
+    inputRefs: RuntimeRef[];
+    reasons: string[];
+    generatedAt: string;
+}
+export interface SpecStageWorkOrder {
+    contract: typeof STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION;
+    workOrderId: string;
+    stage: 'spec';
+    scope: RuntimeScope;
+    profileRef: RuntimeRef;
+    authorityCeiling: 'proposal_input';
+    requiredOutputKinds: SpecStageWorkOrderOutputKind[];
+    forbiddenActions: SpecProposalAuthorityAttempt[];
+    inputRefs: RuntimeRef[];
+    stageManager: SpecStageManagerId;
+    agentTeam: SpecStageAgentId[];
+    requiredCapabilities: SpecStageCapabilityDomain[];
+    optionalCapabilities: SpecStageCapabilityDomain[];
+    materialPackIds: string[];
+    collaborationPlan: SpecStageCollaborationPlan;
+    generatedAt: string;
+}
+export interface SpecDocumentCandidate {
+    contract: typeof STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION;
+    candidateId: string;
+    stage: 'spec';
+    scope: RuntimeScope;
+    producedBy: SpecStageManagerId | SpecStageAgentId | 'fixture' | 'host-adapter';
+    inputRefs: RuntimeRef[];
+    evidenceRefs: RuntimeRef[];
+    acceptedItems: Array<{
+        id: string;
+        kind: SpecProposalItemKind;
+        summary: string;
+        refs: RuntimeRef[];
+    }>;
+    generatedAt: string;
+}
+export interface SpecReviewResult {
+    contract: typeof STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION;
+    reviewId: string;
+    stage: 'spec';
+    scope: RuntimeScope;
+    reviewer: typeof SPEC_STAGE_REVIEW_AGENT;
+    candidateRef: RuntimeRef;
+    verdict: 'approved' | 'changes_requested' | 'blocked';
+    findings: string[];
+    evidenceRefs: RuntimeRef[];
+    generatedAt: string;
+}
+export interface CapabilityFinding {
+    contract: typeof STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION;
+    findingId: string;
+    stage: 'spec';
+    scope: RuntimeScope;
+    capabilityDomain: SpecStageCapabilityDomain;
+    summary: string;
+    refs: RuntimeRef[];
+    generatedAt: string;
+}
+export interface SpecManagerCoordinationRecord {
+    contract: typeof STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION;
+    coordinationId: string;
+    stage: 'spec';
+    scope: RuntimeScope;
+    stageManager: typeof SPEC_STAGE_MANAGER;
+    workOrderRef: RuntimeRef;
+    agentTeamRefs: RuntimeRef[];
+    recommendation: 'close_stage' | 'request_clarification' | 'reject' | 'blocked';
+    generatedAt: string;
+}
+export interface StageClosureRequest {
+    contract: typeof STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION;
+    closureRequestId: string;
+    stage: 'spec' | 'plan' | 'tasks';
+    scope: RuntimeScope;
+    submittedBy: typeof SPEC_STAGE_MANAGER | typeof PLAN_STAGE_MANAGER | typeof TASKS_STAGE_MANAGER | 'fixture' | 'host-adapter';
+    workOrderRef: RuntimeRef;
+    coordinationRef: RuntimeRef | null;
+    candidateRef: RuntimeRef | null;
+    reviewRefs: RuntimeRef[];
+    capabilityFindingRefs: RuntimeRef[];
+    evidenceRefs: RuntimeRef[];
+    candidate: SpecDocumentCandidate | null;
+    reviewResults: SpecReviewResult[];
+    capabilityFindings: CapabilityFinding[];
+    unresolvedAmbiguityIds: string[];
+    authorityAttempts: SpecProposalAuthorityAttempt[];
+    managerRecommendation: 'close_stage' | 'request_clarification' | 'reject' | 'blocked';
+    runtimeCloseBoundaryFacts: SpecRuntimeCloseBoundaryFacts | PlanRuntimeCloseBoundaryFacts | TasksRuntimeCloseBoundaryFacts | null;
+    generatedAt: string;
+}
+export interface ClarificationGate {
+    contract: typeof STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION;
+    gateId: string;
+    stage: 'spec';
+    scope: RuntimeScope;
+    status: 'needs_clarification' | 'answered';
+    questions: string[];
+    blockingItemIds: string[];
+    requiredResponder: 'user' | 'project-owner';
+    createdAt: string;
+    answeredAt?: string;
+    answerRefs: RuntimeRef[];
+}
+export interface SpecDecisionRecord {
+    contract: typeof STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION;
+    decisionId: string;
+    stage: 'spec';
+    scope: RuntimeScope;
+    source: 'stage-closure-request' | 'clarification-answer' | 'runtime-noop';
+    acceptedItemIds: string[];
+    answerRefs: RuntimeRef[];
+    decisionRefs: RuntimeRef[];
+    mustNotAssume: string[];
+    createdAt: string;
+}
+export interface RuntimeProposalRejection {
+    contract: typeof STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION;
+    rejectionId: string;
+    stage: SddStage;
+    scope: RuntimeScope;
+    closureRequestId: string | null;
+    reasonCode: RuntimeProposalRejectionReason;
+    explanation: string;
+    requiredNextAction: string;
+    retryAllowed: boolean;
+    retryBudgetRemaining: number;
+    fallbackRoute: 'ask-user' | 'revise-proposal' | 'runtime-blocked' | 'skip-spec';
+    createdAt: string;
+}
+export interface StageRuntimeDecision {
+    contract: typeof STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION;
+    decisionId: string;
+    stage: SddStage;
+    scope: RuntimeScope;
+    status: 'skipped' | 'completed' | 'blocked' | 'rejected';
+    health: StageCollaborationHealth;
+    acceptedDecisionRefs: RuntimeRef[];
+    advisoryRefs: RuntimeRef[];
+    capabilityRefs: RuntimeRef[];
+    blockingReasons: string[];
+    createdAt: string;
+}
+export interface StageHandoffPacket {
+    contract: typeof STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION;
+    handoffId: string;
+    scope: RuntimeScope;
+    fromStage: SddStage;
+    toStage: SddStage;
+    status: 'proposed' | 'blocked';
+    acceptedSpecDecisionRefs: RuntimeRef[];
+    advisoryRefs: RuntimeRef[];
+    capabilityRefs: RuntimeRef[];
+    unresolvedRisks: string[];
+    mustNotAssume: string[];
+    recommendedNextStageRoles: string[];
+    createdAt: string;
+}
+export interface RuntimeAdjudicationResult {
+    contract: typeof STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION;
+    adjudicationId: string;
+    stage: 'spec';
+    scope: RuntimeScope;
+    health: StageCollaborationHealth;
+    acceptedItemIds: string[];
+    clarificationGate: ClarificationGate | null;
+    specDecisionRecord: SpecDecisionRecord | null;
+    stageDecision: StageRuntimeDecision | null;
+    handoffPacket: StageHandoffPacket | null;
+    rejection: RuntimeProposalRejection | null;
+    nextActions: RuntimeNextAction[];
+    closureRefs?: SpecCollaborationClosureRefs;
+    createdAt: string;
+}
+export type SpecArtifactAcceptanceStatus = 'accepted' | 'not_required_noop' | 'not_accepted_needs_clarification' | 'not_accepted_rejected' | 'not_accepted_blocked' | 'not_accepted_missing_spec' | 'not_accepted_starter_spec' | 'not_accepted_hash_mismatch' | 'not_accepted_wrong_ref';
+export interface SpecCollaborationClosureRefs {
+    runRef: RuntimeRef;
+    acceptedSpecRef: RuntimeRef | null;
+    specAcceptanceStatus: SpecArtifactAcceptanceStatus;
+    specHash: string | null;
+    specContractHash: string | null;
+    artifactRefs: RuntimeRef[];
+    collaborationContractRef: RuntimeRef | null;
+    lifecycleRiskProjectionRef: RuntimeRef;
+    adjudicationProjectionRef: RuntimeRef;
+    stageRunProjectionRef?: RuntimeRef;
+    workflowHandoffProjectionRef?: RuntimeRef;
+    reasons: string[];
+}
+export interface SpecOutputCloseRequest {
+    finalSpecRef?: string;
+    sectionCloseDeclaration: string;
+    reviewSignal: string;
+    blockingBeforePlanCount: number;
+}
+export interface PlanOutputCloseRequest {
+    finalPlanRef?: string;
+    planCloseQualityEvidence: string;
+    reviewSignal: string;
+    blockingBeforeTasksCount: number;
+}
+export interface PlanRuntimeCloseBoundaryFacts {
+    contract: 'sdd-plan-runtime-close-boundary-facts-v1';
+    scope: RuntimeScope;
+    acceptedSpecRef: RuntimeRef;
+    finalPlanRef: RuntimeRef;
+    finalPlanHash: string;
+    templateContract: 'sdd-plan-doc-v3';
+    blockingBeforeTasksCount: 0;
+    planCloseQualityEvidence: 'present';
+    reviewSignal: 'present';
+    runtimeTruthOwner: 'Runtime Kernel';
+}
+export interface SpecCollaborationClosureInput {
+    decision: LifecycleRiskDecision;
+    coordination?: SpecManagerCoordinationRecord | null;
+    closureRequest?: StageClosureRequest | null;
+    answerRefs?: RuntimeRef[];
+    outputCloseRequest?: SpecOutputCloseRequest;
+    artifactRefs?: string[];
+    collaborationContractRefs?: string[];
+    generatedAt?: string;
+    runId?: string;
+}
+export interface SpecCollaborationClosureResult {
+    runId: string;
+    branch: string;
+    profile: StageCollaborationProfile;
+    workOrder: SpecStageWorkOrder | null;
+    coordination: SpecManagerCoordinationRecord | null;
+    candidate: SpecDocumentCandidate | null;
+    reviews: SpecReviewResult[];
+    capabilityFindings: CapabilityFinding[];
+    closureRequest: StageClosureRequest | null;
+    adjudication: RuntimeAdjudicationResult;
+    projectionRef: RuntimeRef;
+    artifactRefs: RuntimeRef[];
+    registeredArtifacts: RegisteredStageArtifact[];
+    registeredCollaborationContracts: RegisteredStageCollaborationContract[];
+    acceptedSpecRef: RuntimeRef | null;
+}
+export type PlanArtifactAcceptanceStatus = 'accepted' | 'not_required_noop' | 'not_accepted_rejected' | 'not_accepted_blocked' | 'not_accepted_missing_plan' | 'not_accepted_starter_plan' | 'not_accepted_hash_mismatch' | 'not_accepted_wrong_ref' | 'not_accepted_missing_review' | 'not_accepted_missing_upstream';
+export interface PlanStageWorkOrder {
+    contract: typeof STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION;
+    workOrderId: string;
+    stage: 'plan';
+    scope: RuntimeScope;
+    profileRef: RuntimeRef;
+    authorityCeiling: 'proposal_input';
+    requiredOutputKinds: Array<'plan_context' | 'plan_review' | 'manager_closure_request'>;
+    forbiddenActions: SpecProposalAuthorityAttempt[];
+    inputRefs: RuntimeRef[];
+    stageManager: typeof PLAN_STAGE_MANAGER;
+    agentTeam: PlanStageAgentId[];
+    planScoutDomains: PlanScoutDomain[];
+    requiredCapabilities: PlanStageCapabilityDomain[];
+    optionalCapabilities: PlanStageCapabilityDomain[];
+    materialPackIds: string[];
+    collaborationPlan: SpecStageCollaborationPlan;
+    generatedAt: string;
+}
+export interface PlanCollaborationClosureRefs {
+    runRef: RuntimeRef;
+    acceptedPlanRef: RuntimeRef | null;
+    planAcceptanceStatus: PlanArtifactAcceptanceStatus;
+    planHash: string | null;
+    planContractHash: string | null;
+    acceptedSpecHandoffRef: RuntimeRef | null;
+    artifactRefs: RuntimeRef[];
+    collaborationContractRef: RuntimeRef | null;
+    lifecycleRiskProjectionRef: RuntimeRef;
+    adjudicationProjectionRef: RuntimeRef;
+    stageRunProjectionRef: RuntimeRef;
+    workflowHandoffProjectionRef?: RuntimeRef;
+    reasons: string[];
+}
+export interface PlanCollaborationAdjudicationResult {
+    contract: typeof STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION;
+    adjudicationId: string;
+    stage: 'plan';
+    scope: RuntimeScope;
+    health: StageCollaborationHealth;
+    stageDecision: StageRuntimeDecision;
+    handoffPacket: WorkflowHandoff | null;
+    rejection: RuntimeProposalRejection | null;
+    nextActions: RuntimeNextAction[];
+    closureRefs: PlanCollaborationClosureRefs;
+    createdAt: string;
+}
+export interface PlanCollaborationClosureInput {
+    decision: LifecycleRiskDecision;
+    artifactRefs?: string[];
+    collaborationContractRefs?: string[];
+    outputCloseRequest?: PlanOutputCloseRequest;
+    generatedAt?: string;
+    runId?: string;
+}
+export interface PlanCollaborationClosureResult {
+    runId: string;
+    branch: string;
+    workOrder: PlanStageWorkOrder | null;
+    adjudication: PlanCollaborationAdjudicationResult;
+    projectionRef: RuntimeRef;
+    artifactRefs: RuntimeRef[];
+    registeredArtifacts: RegisteredStageArtifact[];
+    registeredCollaborationContracts: RegisteredStageCollaborationContract[];
+    acceptedPlanRef: RuntimeRef | null;
+}
+export interface TasksOutputCloseRequest {
+    finalTasksRef?: string;
+    dependencyGraphStatus: string;
+    validationSignalsStatus: string;
+    reviewSignal: string;
+    blockingBeforeExecuteCount: number;
+}
+export interface TasksRuntimeCloseBoundaryFacts {
+    contract: 'sdd-tasks-runtime-close-boundary-facts-v1';
+    scope: RuntimeScope;
+    acceptedSpecRef: RuntimeRef;
+    acceptedPlanRef: RuntimeRef;
+    finalTasksRef: RuntimeRef;
+    finalTasksHash: string;
+    templateContract: 'sdd-tasks-doc-v2';
+    taskUnitCount: number;
+    blockingBeforeExecuteCount: 0;
+    dependencyGraphStatus: 'present';
+    validationSignalsStatus: 'present';
+    reviewSignal: 'present';
+    runtimeTruthOwner: 'Runtime Kernel';
+}
+export type TasksArtifactAcceptanceStatus = 'accepted' | 'not_required_noop' | 'not_accepted_rejected' | 'not_accepted_blocked' | 'not_accepted_missing_tasks' | 'not_accepted_starter_tasks' | 'not_accepted_hash_mismatch' | 'not_accepted_wrong_ref' | 'not_accepted_missing_review' | 'not_accepted_invalid_task_ids' | 'not_accepted_duplicate_task_ids' | 'not_accepted_missing_upstream';
+export interface TasksStageWorkOrder {
+    contract: typeof STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION;
+    workOrderId: string;
+    stage: 'tasks';
+    scope: RuntimeScope;
+    profileRef: RuntimeRef;
+    authorityCeiling: 'proposal_input';
+    requiredOutputKinds: Array<'tasks_context' | 'tasks_review' | 'manager_closure_request'>;
+    forbiddenActions: SpecProposalAuthorityAttempt[];
+    inputRefs: RuntimeRef[];
+    stageManager: typeof TASKS_STAGE_MANAGER;
+    agentTeam: Array<typeof TASKS_STAGE_REVIEW_AGENT | typeof TASKS_STAGE_SLICER_AGENT>;
+    requiredCapabilities: string[];
+    optionalCapabilities: string[];
+    materialPackIds: string[];
+    generatedAt: string;
+}
+export interface TasksCollaborationClosureRefs {
+    runRef: RuntimeRef;
+    acceptedTasksRef: RuntimeRef | null;
+    tasksAcceptanceStatus: TasksArtifactAcceptanceStatus;
+    tasksHash: string | null;
+    tasksContractHash: string | null;
+    acceptedPlanHandoffRef: RuntimeRef | null;
+    artifactRefs: RuntimeRef[];
+    collaborationContractRef: RuntimeRef | null;
+    lifecycleRiskProjectionRef: RuntimeRef;
+    adjudicationProjectionRef: RuntimeRef;
+    stageRunProjectionRef: RuntimeRef;
+    workflowHandoffProjectionRef?: RuntimeRef;
+    reasons: string[];
+}
+export interface TasksCollaborationAdjudicationResult {
+    contract: typeof STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION;
+    adjudicationId: string;
+    stage: 'tasks';
+    scope: RuntimeScope;
+    health: StageCollaborationHealth;
+    stageDecision: StageRuntimeDecision;
+    handoffPacket: WorkflowHandoff | null;
+    rejection: RuntimeProposalRejection | null;
+    nextActions: RuntimeNextAction[];
+    closureRefs: TasksCollaborationClosureRefs;
+    createdAt: string;
+}
+export interface TasksCollaborationClosureInput {
+    decision: LifecycleRiskDecision;
+    artifactRefs?: string[];
+    collaborationContractRefs?: string[];
+    outputCloseRequest?: TasksOutputCloseRequest;
+    generatedAt?: string;
+    runId?: string;
+}
+export interface TasksCollaborationClosureResult {
+    runId: string;
+    branch: string;
+    workOrder: TasksStageWorkOrder | null;
+    adjudication: TasksCollaborationAdjudicationResult;
+    projectionRef: RuntimeRef;
+    artifactRefs: RuntimeRef[];
+    registeredArtifacts: RegisteredStageArtifact[];
+    registeredCollaborationContracts: RegisteredStageCollaborationContract[];
+    acceptedTasksRef: RuntimeRef | null;
+}
+export type DoArtifactAcceptanceStatus = 'accepted' | 'not_required_noop' | 'not_accepted_rejected' | 'not_accepted_blocked' | 'not_accepted_missing_implementation' | 'not_accepted_hash_mismatch' | 'not_accepted_wrong_ref' | 'not_accepted_missing_review' | 'not_accepted_boundary_violation' | 'not_accepted_missing_upstream';
+export interface ExecuteStageWorkOrder {
+    contract: typeof STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION;
+    workOrderId: string;
+    stage: 'execute';
+    scope: RuntimeScope;
+    profileRef: RuntimeRef;
+    authorityCeiling: 'proposal_input';
+    requiredOutputKinds: Array<'implementation_evidence' | 'code_review' | 'validation_evidence' | 'checkpoint_decision' | 'evidence_judgment' | 'manager_closure_request'>;
+    forbiddenActions: SpecProposalAuthorityAttempt[];
+    inputRefs: RuntimeRef[];
+    stageManager: 'execute-manager';
+    agentTeam: Array<typeof EXECUTE_IMPLEMENTER_AGENT | typeof EXECUTE_CODE_REVIEW_AGENT | typeof EXECUTE_DEBUGGER_AGENT | typeof EXECUTE_TEST_RUNNER_AGENT | typeof EXECUTE_VALIDATOR_AGENT | typeof EXECUTE_TEST_REVIEW_AGENT | typeof EXECUTE_EVIDENCE_JUDGMENT_VALIDATOR_AGENT | typeof EXECUTE_EVIDENCE_JUDGMENT_REVIEW_AGENT>;
+    requiredCapabilities: string[];
+    optionalCapabilities: string[];
+    materialPackIds: string[];
+    generatedAt: string;
+}
+export type ExecuteArtifactAcceptanceStatus = 'accepted' | 'not_required_noop' | 'not_accepted_rejected' | 'not_accepted_blocked' | 'not_accepted_missing_implementation' | 'not_accepted_missing_review' | 'not_accepted_missing_validation' | 'not_accepted_missing_checkpoint' | 'not_accepted_missing_judgment' | 'not_accepted_wrong_ref' | 'not_accepted_hash_mismatch' | 'not_accepted_missing_upstream';
+export interface ExecuteCollaborationClosureRefs {
+    runRef: RuntimeRef;
+    acceptedExecuteRef: RuntimeRef | null;
+    executeAcceptanceStatus: ExecuteArtifactAcceptanceStatus;
+    acceptedTasksHandoffRef: RuntimeRef | null;
+    truthAlignmentProjectionRef: RuntimeRef | null;
+    laneEvidenceRefs: RuntimeRef[];
+    artifactRefs: RuntimeRef[];
+    collaborationContractRef: RuntimeRef | null;
+    lifecycleRiskProjectionRef: RuntimeRef;
+    adjudicationProjectionRef: RuntimeRef;
+    stageRunProjectionRef: RuntimeRef;
+    workflowHandoffProjectionRef?: RuntimeRef;
+    reasons: string[];
+}
+export interface ExecuteCollaborationAdjudicationResult {
+    contract: typeof STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION;
+    adjudicationId: string;
+    stage: 'execute';
+    scope: RuntimeScope;
+    health: StageCollaborationHealth;
+    stageDecision: StageRuntimeDecision;
+    handoffPacket: WorkflowHandoff | null;
+    rejection: RuntimeProposalRejection | null;
+    nextActions: RuntimeNextAction[];
+    closureRefs: ExecuteCollaborationClosureRefs;
+    createdAt: string;
+}
+export interface ExecuteCollaborationClosureInput {
+    decision: LifecycleRiskDecision;
+    artifactRefs?: string[];
+    collaborationContractRefs?: string[];
+    generatedAt?: string;
+    runId?: string;
+}
+export interface ExecuteCollaborationClosureResult {
+    runId: string;
+    branch: string;
+    workOrder: ExecuteStageWorkOrder | null;
+    adjudication: ExecuteCollaborationAdjudicationResult;
+    projectionRef: RuntimeRef;
+    artifactRefs: RuntimeRef[];
+    registeredArtifacts: RegisteredStageArtifact[];
+    registeredCollaborationContracts: RegisteredStageCollaborationContract[];
+    acceptedExecuteRef: RuntimeRef | null;
+}
+export type TestArtifactAcceptanceStatus = 'accepted' | 'not_required_noop' | 'not_accepted_rejected' | 'not_accepted_blocked' | 'not_accepted_missing_execution' | 'not_accepted_missing_validation' | 'not_accepted_hash_mismatch' | 'not_accepted_wrong_ref' | 'not_accepted_missing_review' | 'not_accepted_failed_tests' | 'not_accepted_unmapped_acceptance' | 'not_accepted_missing_upstream';
+export type EvidenceJudgmentArtifactAcceptanceStatus = 'accepted' | 'not_required_noop' | 'not_accepted_rejected' | 'not_accepted_blocked' | 'not_accepted_missing_verification' | 'not_accepted_hash_mismatch' | 'not_accepted_wrong_ref' | 'not_accepted_missing_review' | 'not_accepted_failed_verification' | 'not_accepted_incomplete_coverage' | 'not_accepted_open_gap' | 'not_accepted_missing_upstream';
+export type TruthAlignmentStatus = 'aligned' | 'drift_detected' | 'update_required' | 'blocked';
+export type TruthAlignmentSemanticImpact = 'none' | 'bounded' | 'material';
+export type TruthAlignmentOwnerStage = SddStage;
+export interface TruthAlignmentProjection {
+    contract: typeof TRUTH_ALIGNMENT_CONTRACT;
+    branch: string;
+    sourceStage: 'execute';
+    declaredTruthRefs: RuntimeRef[];
+    acceptedRealityRefs: RuntimeRef[];
+    status: TruthAlignmentStatus;
+    ownerStage: TruthAlignmentOwnerStage | null;
+    semanticImpact: TruthAlignmentSemanticImpact;
+    staleRefs: RuntimeRef[];
+    invalidatesStages: SddStage[];
+    reasons: string[];
+    createdAt: string;
+}
+export type ShipReadinessAcceptanceStatus = 'accepted' | 'not_required_noop' | 'not_accepted_rejected' | 'not_accepted_blocked' | 'not_accepted_missing_readiness' | 'not_accepted_hash_mismatch' | 'not_accepted_wrong_ref' | 'not_accepted_missing_review' | 'not_accepted_open_blocker' | 'not_accepted_release_drift' | 'not_accepted_missing_upstream' | 'not_accepted_authority_violation';
+export interface ShipStageWorkOrder {
+    contract: typeof STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION;
+    workOrderId: string;
+    stage: 'ship';
+    scope: RuntimeScope;
+    profileRef: RuntimeRef;
+    authorityCeiling: 'proposal_input';
+    requiredOutputKinds: Array<'ship_readiness' | 'release_review' | 'manager_closure_request'>;
+    forbiddenActions: SpecProposalAuthorityAttempt[];
+    inputRefs: RuntimeRef[];
+    stageManager: typeof SHIP_STAGE_MANAGER;
+    agentTeam: Array<typeof SHIP_STAGE_VALIDATOR_AGENT | typeof SHIP_STAGE_REVIEW_AGENT>;
+    requiredCapabilities: string[];
+    optionalCapabilities: string[];
+    materialPackIds: string[];
+    generatedAt: string;
+}
+export interface ShipCollaborationClosureRefs {
+    runRef: RuntimeRef;
+    acceptedShipReadinessRef: RuntimeRef | null;
+    shipReadinessStatus: ShipReadinessAcceptanceStatus;
+    shipReadinessHash: string | null;
+    releaseDocumentRef: RuntimeRef | null;
+    truthAlignmentProjectionRef: RuntimeRef | null;
+    artifactRefs: RuntimeRef[];
+    collaborationContractRef: RuntimeRef | null;
+    lifecycleRiskProjectionRef: RuntimeRef;
+    adjudicationProjectionRef: RuntimeRef;
+    stageRunProjectionRef: RuntimeRef;
+    reasons: string[];
+}
+export interface ShipCollaborationAdjudicationResult {
+    contract: typeof STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION;
+    adjudicationId: string;
+    stage: 'ship';
+    scope: RuntimeScope;
+    health: StageCollaborationHealth;
+    stageDecision: StageRuntimeDecision;
+    handoffPacket: WorkflowHandoff | null;
+    rejection: RuntimeProposalRejection | null;
+    nextActions: RuntimeNextAction[];
+    closureRefs: ShipCollaborationClosureRefs;
+    createdAt: string;
+}
+export interface ShipCollaborationClosureInput {
+    decision: LifecycleRiskDecision;
+    artifactRefs?: string[];
+    collaborationContractRefs?: string[];
+    generatedAt?: string;
+    runId?: string;
+}
+export interface ShipCollaborationClosureResult {
+    runId: string;
+    branch: string;
+    workOrder: ShipStageWorkOrder | null;
+    adjudication: ShipCollaborationAdjudicationResult;
+    projectionRef: RuntimeRef;
+    artifactRefs: RuntimeRef[];
+    registeredArtifacts: RegisteredStageArtifact[];
+    registeredCollaborationContracts: RegisteredStageCollaborationContract[];
+    acceptedShipReadinessRef: RuntimeRef | null;
+    releaseDocumentRef: RuntimeRef | null;
+}
+export interface StageClosureAdjudicationInput {
+    profile: StageCollaborationProfile;
+    closureRequest?: StageClosureRequest | null;
+    answerRefs?: RuntimeRef[];
+    generatedAt?: string;
+    retryBudgetRemaining?: number;
+}
+export type SpecCollaborationDiagnosticStatus = 'missing' | 'incompatible' | StageCollaborationHealth;
+export interface SpecCollaborationHealthDiagnostic {
+    status: SpecCollaborationDiagnosticStatus;
+    branch: string;
+    latest: RuntimeAdjudicationResult | null;
+    projectionCount: number;
+    latestClarificationGateId: string | null;
+    latestHandoffId: string | null;
+    latestRejectionReason: RuntimeProposalRejectionReason | null;
+    reasons: string[];
+}
+export type FullStageChainDiagnosticStatus = 'missing' | 'partial' | 'ready' | 'blocked' | 'rejected';
+export interface FullStageChainStageDiagnostic {
+    stage: SddStage;
+    expectedHealth: StageCollaborationHealth;
+    projectionType: string;
+    projectionRef: RuntimeRef | null;
+    health: StageCollaborationHealth | null;
+    status: StageRuntimeDecision['status'] | null;
+    acceptedRef: RuntimeRef | null;
+    acceptedHash: string | null;
+    collaborationContractRef: RuntimeRef | null;
+    collaborationContractStatus: 'validated' | 'missing';
+    handoff: {
+        fromStage: SddStage;
+        toStage: SddStage;
+        status: string;
+    } | null;
+    handoffProjectionRef: RuntimeRef | null;
+    reasons: string[];
+}
+export interface FullStageChainDiagnostic {
+    contract: 'sdd-full-stage-chain-diagnostic-v1';
+    branch: string;
+    status: FullStageChainDiagnosticStatus;
+    stages: FullStageChainStageDiagnostic[];
+    projectionCounts: {
+        adjudications: number;
+        completedStages: number;
+        validatedCollaborationContracts: number;
+        handoffs: number;
+    };
+    finalHealth: StageCollaborationHealth | null;
+    reasons: string[];
+}
+export declare function deriveSpecCollaborationProfile(decision: LifecycleRiskDecision, generatedAt?: string): StageCollaborationProfile;
+export declare function buildSpecStageWorkOrder(profile: StageCollaborationProfile, profileRef: RuntimeRef, generatedAt?: string): SpecStageWorkOrder;
+export declare function planCollaborationScopeKey(scope: RuntimeScope): string;
+export declare function buildPlanStageWorkOrder(scope: RuntimeScope, profileRef: RuntimeRef, inputRefs: RuntimeRef[], generatedAt?: string, intensity?: StageCollaborationIntensity): PlanStageWorkOrder;
+export declare function tasksCollaborationScopeKey(scope: RuntimeScope): string;
+export declare function buildTasksStageWorkOrder(scope: RuntimeScope, profileRef: RuntimeRef, inputRefs: RuntimeRef[], generatedAt?: string): TasksStageWorkOrder;
+export declare function executeCollaborationScopeKey(scope: RuntimeScope): string;
+export declare function buildExecuteStageWorkOrder(scope: RuntimeScope, profileRef: RuntimeRef, inputRefs: RuntimeRef[], generatedAt?: string): ExecuteStageWorkOrder;
+export declare function truthAlignmentScopeKey(scope: RuntimeScope): string;
+export declare function shipCollaborationScopeKey(scope: RuntimeScope): string;
+export declare function buildShipStageWorkOrder(scope: RuntimeScope, profileRef: RuntimeRef, inputRefs: RuntimeRef[], generatedAt?: string): ShipStageWorkOrder;
+export declare function specCollaborationScopeKey(scope: RuntimeScope): string;
+export declare function recordSpecCollaborationAdjudicationProjection(projectRoot: string, result: RuntimeAdjudicationResult): Promise<RuntimeProjectionEnvelopeWriteResult<RuntimeAdjudicationResult>>;
+export declare function recordPlanCollaborationAdjudicationProjection(projectRoot: string, result: PlanCollaborationAdjudicationResult): Promise<RuntimeProjectionEnvelopeWriteResult<PlanCollaborationAdjudicationResult>>;
+export declare function recordTasksCollaborationAdjudicationProjection(projectRoot: string, result: TasksCollaborationAdjudicationResult): Promise<RuntimeProjectionEnvelopeWriteResult<TasksCollaborationAdjudicationResult>>;
+export declare function recordExecuteCollaborationAdjudicationProjection(projectRoot: string, result: ExecuteCollaborationAdjudicationResult): Promise<RuntimeProjectionEnvelopeWriteResult<ExecuteCollaborationAdjudicationResult>>;
+export declare function recordTruthAlignmentProjection(projectRoot: string, result: TruthAlignmentProjection): Promise<RuntimeProjectionEnvelopeWriteResult<TruthAlignmentProjection>>;
+export declare function readTruthAlignmentProjection(projectRoot: string, scope: RuntimeScope): Promise<RuntimeProjectionEnvelope<TruthAlignmentProjection> | null>;
+export declare function recordShipCollaborationAdjudicationProjection(projectRoot: string, result: ShipCollaborationAdjudicationResult): Promise<RuntimeProjectionEnvelopeWriteResult<ShipCollaborationAdjudicationResult>>;
+export declare function reconcileSpecCollaborationClosure(projectRoot: string, input: SpecCollaborationClosureInput): Promise<SpecCollaborationClosureResult>;
+export declare function reconcilePlanCollaborationClosure(projectRoot: string, input: PlanCollaborationClosureInput): Promise<PlanCollaborationClosureResult>;
+export declare function reconcileTasksCollaborationClosure(projectRoot: string, input: TasksCollaborationClosureInput): Promise<TasksCollaborationClosureResult>;
+export declare function reconcileExecuteCollaborationClosure(projectRoot: string, input: ExecuteCollaborationClosureInput): Promise<ExecuteCollaborationClosureResult>;
+export declare function reconcileShipCollaborationClosure(projectRoot: string, input: ShipCollaborationClosureInput): Promise<ShipCollaborationClosureResult>;
+export declare function inspectFullStageChain(projectRoot: string, branch: string): Promise<FullStageChainDiagnostic>;
+export declare function inspectSpecCollaborationHealth(projectRoot: string, branch: string): Promise<SpecCollaborationHealthDiagnostic>;
+export declare function adjudicateSpecStageClosureRequest(input: StageClosureAdjudicationInput): RuntimeAdjudicationResult;