sdd-agent-platform 0.4.1 → 0.4.2

package/node_modules/@sdd-agent-platform/core/dist/stage-collaboration.d.ts

@@ -0,0 +1,888 @@
+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';
+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_verifies' | 'ready_for_do' | 'ready_for_test' | 'ready_for_goal_verify' | '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-drafter' | 'spec-reviewer' | 'scout';
+export type SpecStageCapabilityDomain = 'norm_discovery' | 'uncertainty_resolution' | 'context_curation' | 'solution-design' | 'frontend-engineering' | 'security-engineering' | 'ui-ux-product-design';
+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_DRAFTER_AGENT = "spec-drafter";
+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_DRAFTER_AGENT = "plan-drafter";
+export declare const PLAN_STAGE_REVIEW_AGENT = "plan-reviewer";
+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_DRAFTER_AGENT = "tasks-drafter";
+export declare const TASKS_STAGE_REVIEW_AGENT = "tasks-reviewer";
+export declare const TASKS_STAGE_SLICER_AGENT = "task-slicer";
+export declare const VERIFIES_COLLABORATION_ADJUDICATION_PROJECTION_TYPE = "phase9_4_verifies_collaboration_adjudication";
+export declare const VERIFIES_STAGE_MANAGER = "verifies-manager";
+export declare const VERIFIES_STAGE_DRAFTER_AGENT = "verifies-drafter";
+export declare const VERIFIES_STAGE_REVIEW_AGENT = "verifies-reviewer";
+export declare const VERIFIES_STAGE_VERIFICATION_AGENT = "verification-agent";
+export declare const DO_COLLABORATION_ADJUDICATION_PROJECTION_TYPE = "phase9_5_do_collaboration_adjudication";
+export declare const DO_STAGE_MANAGER = "do-manager";
+export declare const DO_STAGE_IMPLEMENTER_AGENT = "implementer";
+export declare const DO_STAGE_CODE_REVIEW_AGENT = "code-reviewer";
+export declare const DO_STAGE_DEBUGGER_AGENT = "debugger";
+export declare const TEST_COLLABORATION_ADJUDICATION_PROJECTION_TYPE = "phase9_6_test_collaboration_adjudication";
+export declare const TEST_STAGE_MANAGER = "test-manager";
+export declare const TEST_STAGE_RUNNER_AGENT = "test-runner";
+export declare const TEST_STAGE_VALIDATOR_AGENT = "validator";
+export declare const TEST_STAGE_REVIEW_AGENT = "test-reviewer";
+export declare const GOAL_VERIFY_COLLABORATION_ADJUDICATION_PROJECTION_TYPE = "phase9_7_goal_verify_collaboration_adjudication";
+export declare const GOAL_VERIFY_STAGE_MANAGER = "goal-verify-manager";
+export declare const GOAL_VERIFY_STAGE_VALIDATOR_AGENT = "goal-validator";
+export declare const GOAL_VERIFY_STAGE_REVIEW_AGENT = "goal-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;
+    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: 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';
+    scope: RuntimeScope;
+    submittedBy: typeof SPEC_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';
+    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 SpecCollaborationClosureInput {
+    decision: LifecycleRiskDecision;
+    coordination?: SpecManagerCoordinationRecord | null;
+    closureRequest?: StageClosureRequest | null;
+    answerRefs?: RuntimeRef[];
+    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: Array<typeof PLAN_STAGE_DRAFTER_AGENT | typeof PLAN_STAGE_REVIEW_AGENT | 'plan-scout'>;
+    requiredCapabilities: string[];
+    optionalCapabilities: string[];
+    materialPackIds: string[];
+    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[];
+    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 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_DRAFTER_AGENT | typeof TASKS_STAGE_REVIEW_AGENT | typeof TASKS_STAGE_SLICER_AGENT | 'tasks-capability'>;
+    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[];
+    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 VerifiesArtifactAcceptanceStatus = 'accepted' | 'not_required_noop' | 'not_accepted_rejected' | 'not_accepted_blocked' | 'not_accepted_missing_verify' | 'not_accepted_starter_verify' | 'not_accepted_hash_mismatch' | 'not_accepted_wrong_ref' | 'not_accepted_missing_review' | 'not_accepted_incomplete_coverage' | 'not_accepted_missing_upstream';
+export interface VerifiesStageWorkOrder {
+    contract: typeof STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION;
+    workOrderId: string;
+    stage: 'verifies';
+    scope: RuntimeScope;
+    profileRef: RuntimeRef;
+    authorityCeiling: 'proposal_input';
+    requiredOutputKinds: Array<'verifies_context' | 'verifies_review' | 'manager_closure_request'>;
+    forbiddenActions: SpecProposalAuthorityAttempt[];
+    inputRefs: RuntimeRef[];
+    stageManager: typeof VERIFIES_STAGE_MANAGER;
+    agentTeam: Array<typeof VERIFIES_STAGE_DRAFTER_AGENT | typeof VERIFIES_STAGE_REVIEW_AGENT | typeof VERIFIES_STAGE_VERIFICATION_AGENT | 'verifies-capability'>;
+    requiredCapabilities: string[];
+    optionalCapabilities: string[];
+    materialPackIds: string[];
+    generatedAt: string;
+}
+export interface VerifiesCollaborationClosureRefs {
+    runRef: RuntimeRef;
+    acceptedVerifyRef: RuntimeRef | null;
+    verifyAcceptanceStatus: VerifiesArtifactAcceptanceStatus;
+    verifyHash: string | null;
+    verifyContractHash: string | null;
+    acceptedTasksHandoffRef: RuntimeRef | null;
+    artifactRefs: RuntimeRef[];
+    collaborationContractRef: RuntimeRef | null;
+    lifecycleRiskProjectionRef: RuntimeRef;
+    adjudicationProjectionRef: RuntimeRef;
+    stageRunProjectionRef: RuntimeRef;
+    workflowHandoffProjectionRef?: RuntimeRef;
+    reasons: string[];
+}
+export interface VerifiesCollaborationAdjudicationResult {
+    contract: typeof STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION;
+    adjudicationId: string;
+    stage: 'verifies';
+    scope: RuntimeScope;
+    health: StageCollaborationHealth;
+    stageDecision: StageRuntimeDecision;
+    handoffPacket: WorkflowHandoff | null;
+    rejection: RuntimeProposalRejection | null;
+    nextActions: RuntimeNextAction[];
+    closureRefs: VerifiesCollaborationClosureRefs;
+    createdAt: string;
+}
+export interface VerifiesCollaborationClosureInput {
+    decision: LifecycleRiskDecision;
+    artifactRefs?: string[];
+    collaborationContractRefs?: string[];
+    generatedAt?: string;
+    runId?: string;
+}
+export interface VerifiesCollaborationClosureResult {
+    runId: string;
+    branch: string;
+    workOrder: VerifiesStageWorkOrder | null;
+    adjudication: VerifiesCollaborationAdjudicationResult;
+    projectionRef: RuntimeRef;
+    artifactRefs: RuntimeRef[];
+    registeredArtifacts: RegisteredStageArtifact[];
+    registeredCollaborationContracts: RegisteredStageCollaborationContract[];
+    acceptedVerifyRef: 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 DoStageWorkOrder {
+    contract: typeof STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION;
+    workOrderId: string;
+    stage: 'do';
+    scope: RuntimeScope;
+    profileRef: RuntimeRef;
+    authorityCeiling: 'proposal_input';
+    requiredOutputKinds: Array<'implementation_evidence' | 'code_review' | 'manager_closure_request'>;
+    forbiddenActions: SpecProposalAuthorityAttempt[];
+    inputRefs: RuntimeRef[];
+    stageManager: typeof DO_STAGE_MANAGER;
+    agentTeam: Array<typeof DO_STAGE_IMPLEMENTER_AGENT | typeof DO_STAGE_CODE_REVIEW_AGENT | typeof DO_STAGE_DEBUGGER_AGENT>;
+    requiredCapabilities: string[];
+    optionalCapabilities: string[];
+    materialPackIds: string[];
+    generatedAt: string;
+}
+export interface DoCollaborationClosureRefs {
+    runRef: RuntimeRef;
+    acceptedImplementationRef: RuntimeRef | null;
+    implementationAcceptanceStatus: DoArtifactAcceptanceStatus;
+    implementationHash: string | null;
+    changedFileRefs: RuntimeRef[];
+    acceptedVerifyHandoffRef: RuntimeRef | null;
+    artifactRefs: RuntimeRef[];
+    collaborationContractRef: RuntimeRef | null;
+    lifecycleRiskProjectionRef: RuntimeRef;
+    adjudicationProjectionRef: RuntimeRef;
+    stageRunProjectionRef: RuntimeRef;
+    workflowHandoffProjectionRef?: RuntimeRef;
+    reasons: string[];
+}
+export interface DoCollaborationAdjudicationResult {
+    contract: typeof STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION;
+    adjudicationId: string;
+    stage: 'do';
+    scope: RuntimeScope;
+    health: StageCollaborationHealth;
+    stageDecision: StageRuntimeDecision;
+    handoffPacket: WorkflowHandoff | null;
+    rejection: RuntimeProposalRejection | null;
+    nextActions: RuntimeNextAction[];
+    closureRefs: DoCollaborationClosureRefs;
+    createdAt: string;
+}
+export interface DoCollaborationClosureInput {
+    decision: LifecycleRiskDecision;
+    artifactRefs?: string[];
+    collaborationContractRefs?: string[];
+    allowedChangedFileRefs?: string[];
+    generatedAt?: string;
+    runId?: string;
+}
+export interface DoCollaborationClosureResult {
+    runId: string;
+    branch: string;
+    workOrder: DoStageWorkOrder | null;
+    adjudication: DoCollaborationAdjudicationResult;
+    projectionRef: RuntimeRef;
+    artifactRefs: RuntimeRef[];
+    registeredArtifacts: RegisteredStageArtifact[];
+    registeredCollaborationContracts: RegisteredStageCollaborationContract[];
+    acceptedImplementationRef: RuntimeRef | null;
+    changedFileRefs: RuntimeRef[];
+}
+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 interface TestStageWorkOrder {
+    contract: typeof STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION;
+    workOrderId: string;
+    stage: 'test';
+    scope: RuntimeScope;
+    profileRef: RuntimeRef;
+    authorityCeiling: 'proposal_input';
+    requiredOutputKinds: Array<'test_execution' | 'validation_evidence' | 'test_review' | 'manager_closure_request'>;
+    forbiddenActions: SpecProposalAuthorityAttempt[];
+    inputRefs: RuntimeRef[];
+    stageManager: typeof TEST_STAGE_MANAGER;
+    agentTeam: Array<typeof TEST_STAGE_RUNNER_AGENT | typeof TEST_STAGE_VALIDATOR_AGENT | typeof TEST_STAGE_REVIEW_AGENT>;
+    requiredCapabilities: string[];
+    optionalCapabilities: string[];
+    materialPackIds: string[];
+    generatedAt: string;
+}
+export interface TestCollaborationClosureRefs {
+    runRef: RuntimeRef;
+    acceptedTestEvidenceRef: RuntimeRef | null;
+    testAcceptanceStatus: TestArtifactAcceptanceStatus;
+    testEvidenceHash: string | null;
+    acceptedDoHandoffRef: RuntimeRef | null;
+    artifactRefs: RuntimeRef[];
+    collaborationContractRef: RuntimeRef | null;
+    lifecycleRiskProjectionRef: RuntimeRef;
+    adjudicationProjectionRef: RuntimeRef;
+    stageRunProjectionRef: RuntimeRef;
+    workflowHandoffProjectionRef?: RuntimeRef;
+    reasons: string[];
+}
+export interface TestCollaborationAdjudicationResult {
+    contract: typeof STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION;
+    adjudicationId: string;
+    stage: 'test';
+    scope: RuntimeScope;
+    health: StageCollaborationHealth;
+    stageDecision: StageRuntimeDecision;
+    handoffPacket: WorkflowHandoff | null;
+    rejection: RuntimeProposalRejection | null;
+    nextActions: RuntimeNextAction[];
+    closureRefs: TestCollaborationClosureRefs;
+    createdAt: string;
+}
+export interface TestCollaborationClosureInput {
+    decision: LifecycleRiskDecision;
+    artifactRefs?: string[];
+    collaborationContractRefs?: string[];
+    generatedAt?: string;
+    runId?: string;
+}
+export interface TestCollaborationClosureResult {
+    runId: string;
+    branch: string;
+    workOrder: TestStageWorkOrder | null;
+    adjudication: TestCollaborationAdjudicationResult;
+    projectionRef: RuntimeRef;
+    artifactRefs: RuntimeRef[];
+    registeredArtifacts: RegisteredStageArtifact[];
+    registeredCollaborationContracts: RegisteredStageCollaborationContract[];
+    acceptedTestEvidenceRef: RuntimeRef | null;
+}
+export type GoalVerifyArtifactAcceptanceStatus = '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 interface GoalVerifyStageWorkOrder {
+    contract: typeof STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION;
+    workOrderId: string;
+    stage: 'goal-verify';
+    scope: RuntimeScope;
+    profileRef: RuntimeRef;
+    authorityCeiling: 'proposal_input';
+    requiredOutputKinds: Array<'goal_verification' | 'goal_review' | 'manager_closure_request'>;
+    forbiddenActions: SpecProposalAuthorityAttempt[];
+    inputRefs: RuntimeRef[];
+    stageManager: typeof GOAL_VERIFY_STAGE_MANAGER;
+    agentTeam: Array<typeof GOAL_VERIFY_STAGE_VALIDATOR_AGENT | typeof GOAL_VERIFY_STAGE_REVIEW_AGENT>;
+    requiredCapabilities: string[];
+    optionalCapabilities: string[];
+    materialPackIds: string[];
+    generatedAt: string;
+}
+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: 'goal-verify';
+    declaredTruthRefs: RuntimeRef[];
+    acceptedRealityRefs: RuntimeRef[];
+    status: TruthAlignmentStatus;
+    ownerStage: TruthAlignmentOwnerStage | null;
+    semanticImpact: TruthAlignmentSemanticImpact;
+    staleRefs: RuntimeRef[];
+    invalidatesStages: SddStage[];
+    reasons: string[];
+    createdAt: string;
+}
+export interface GoalVerifyCollaborationClosureRefs {
+    runRef: RuntimeRef;
+    acceptedGoalVerificationRef: RuntimeRef | null;
+    goalVerifyAcceptanceStatus: GoalVerifyArtifactAcceptanceStatus;
+    goalVerificationHash: string | null;
+    acceptedTestHandoffRef: RuntimeRef | null;
+    artifactRefs: RuntimeRef[];
+    collaborationContractRef: RuntimeRef | null;
+    lifecycleRiskProjectionRef: RuntimeRef;
+    adjudicationProjectionRef: RuntimeRef;
+    stageRunProjectionRef: RuntimeRef;
+    workflowHandoffProjectionRef?: RuntimeRef;
+    truthAlignmentProjectionRef?: RuntimeRef;
+    reasons: string[];
+}
+export interface GoalVerifyCollaborationAdjudicationResult {
+    contract: typeof STAGE_COLLABORATION_RUNTIME_CONTRACT_VERSION;
+    adjudicationId: string;
+    stage: 'goal-verify';
+    scope: RuntimeScope;
+    health: StageCollaborationHealth;
+    stageDecision: StageRuntimeDecision;
+    handoffPacket: WorkflowHandoff | null;
+    rejection: RuntimeProposalRejection | null;
+    nextActions: RuntimeNextAction[];
+    closureRefs: GoalVerifyCollaborationClosureRefs;
+    createdAt: string;
+}
+export interface GoalVerifyCollaborationClosureInput {
+    decision: LifecycleRiskDecision;
+    artifactRefs?: string[];
+    collaborationContractRefs?: string[];
+    generatedAt?: string;
+    runId?: string;
+}
+export interface GoalVerifyCollaborationClosureResult {
+    runId: string;
+    branch: string;
+    workOrder: GoalVerifyStageWorkOrder | null;
+    adjudication: GoalVerifyCollaborationAdjudicationResult;
+    projectionRef: RuntimeRef;
+    artifactRefs: RuntimeRef[];
+    registeredArtifacts: RegisteredStageArtifact[];
+    registeredCollaborationContracts: RegisteredStageCollaborationContract[];
+    acceptedGoalVerificationRef: RuntimeRef | null;
+}
+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): PlanStageWorkOrder;
+export declare function tasksCollaborationScopeKey(scope: RuntimeScope): string;
+export declare function buildTasksStageWorkOrder(scope: RuntimeScope, profileRef: RuntimeRef, inputRefs: RuntimeRef[], generatedAt?: string): TasksStageWorkOrder;
+export declare function verifiesCollaborationScopeKey(scope: RuntimeScope): string;
+export declare function buildVerifiesStageWorkOrder(scope: RuntimeScope, profileRef: RuntimeRef, inputRefs: RuntimeRef[], generatedAt?: string): VerifiesStageWorkOrder;
+export declare function doCollaborationScopeKey(scope: RuntimeScope): string;
+export declare function buildDoStageWorkOrder(scope: RuntimeScope, profileRef: RuntimeRef, inputRefs: RuntimeRef[], generatedAt?: string): DoStageWorkOrder;
+export declare function testCollaborationScopeKey(scope: RuntimeScope): string;
+export declare function buildTestStageWorkOrder(scope: RuntimeScope, profileRef: RuntimeRef, inputRefs: RuntimeRef[], generatedAt?: string): TestStageWorkOrder;
+export declare function goalVerifyCollaborationScopeKey(scope: RuntimeScope): string;
+export declare function buildGoalVerifyStageWorkOrder(scope: RuntimeScope, profileRef: RuntimeRef, inputRefs: RuntimeRef[], generatedAt?: string): GoalVerifyStageWorkOrder;
+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 recordVerifiesCollaborationAdjudicationProjection(projectRoot: string, result: VerifiesCollaborationAdjudicationResult): Promise<RuntimeProjectionEnvelopeWriteResult<VerifiesCollaborationAdjudicationResult>>;
+export declare function recordDoCollaborationAdjudicationProjection(projectRoot: string, result: DoCollaborationAdjudicationResult): Promise<RuntimeProjectionEnvelopeWriteResult<DoCollaborationAdjudicationResult>>;
+export declare function recordTestCollaborationAdjudicationProjection(projectRoot: string, result: TestCollaborationAdjudicationResult): Promise<RuntimeProjectionEnvelopeWriteResult<TestCollaborationAdjudicationResult>>;
+export declare function recordGoalVerifyCollaborationAdjudicationProjection(projectRoot: string, result: GoalVerifyCollaborationAdjudicationResult): Promise<RuntimeProjectionEnvelopeWriteResult<GoalVerifyCollaborationAdjudicationResult>>;
+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 reconcileVerifiesCollaborationClosure(projectRoot: string, input: VerifiesCollaborationClosureInput): Promise<VerifiesCollaborationClosureResult>;
+export declare function reconcileDoCollaborationClosure(projectRoot: string, input: DoCollaborationClosureInput): Promise<DoCollaborationClosureResult>;
+export declare function reconcileTestCollaborationClosure(projectRoot: string, input: TestCollaborationClosureInput): Promise<TestCollaborationClosureResult>;
+export declare function reconcileGoalVerifyCollaborationClosure(projectRoot: string, input: GoalVerifyCollaborationClosureInput): Promise<GoalVerifyCollaborationClosureResult>;
+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;