sdd-agent-platform 0.4.1 → 0.4.2

package/node_modules/@sdd-agent-platform/core/src/status/project-status.ts

@@ -8,8 +8,8 @@ import { readRunEvents } from '../run-state/events.js';
 import { readRunState } from '../run-state/run-state.js';
 import { listAgentExecutionRecords, listTeamSessionRecords } from '../execution/agent-execution-records.js';
 import { listResidentWorkerRuntimes } from '../execution/resident-worker.js';
-import { runDocumentStaleReasons } from '../sync-back/inspect.js';
-import { resolveWorkflowState, type WorkflowLatestTaskRun, type WorkflowNextIntent } from '../workflow-state/resolve.js';
+import { runDocumentStaleReasons } from '../workflow-state/resolve-task-run.js';
+import { resolveWorkflowState, workflowNextIntent, type WorkflowLatestTaskRun, type WorkflowNextIntent } from '../workflow-state/resolve.js';
 import type { WorkflowAffectedFileConflict } from '../workflow-state/affected-file-conflicts.js';
 import type { WorkflowDependencyBlocker } from '../workflow-state/dependencies.js';
 import type { LatestEligibleRunSelection } from '../workflow-state/latest-eligible-run.js';
@@ -18,12 +18,29 @@ import { listRuntimeProjections } from '../storage/runtime-store.js';
 import { inspectLifecycleRiskDecisionForModel, type LifecycleRiskConsumerDiagnostic } from '../risk.js';
 import { inspectWorkflowStageHandoff, type WorkflowStageHandoffDiagnostic } from '../stage-runtime.js';
 import { inspectContextOffloadRuntime, type ContextRuntimeDiagnostic } from '../context-offload.js';
+import { inspectFullStageChain, inspectSpecCollaborationHealth, type FullStageChainDiagnostic, type SpecCollaborationHealthDiagnostic } from '../stage-collaboration.js';
+import { inspectRuntimeProjectionP0, type RuntimeProjectionP0Diagnostic } from '../runtime-projection-p0.js';
 import { inspectSubagentDispatches, type SubagentDispatchDiagnostic } from '../subagents.js';
 import { inspectAgentCapabilityCatalog, REQUIRED_PROFESSIONAL_CAPABILITY_DOMAINS, type AgentCapabilityDomain, type ProfessionalCapabilityDomain } from '../registries/agent-capability-catalog.js';
 import { validateAgentSkillTeamRuntime } from '../router/runtime-validation.js';
-import { listRuntimeDurableGaps, listRuntimeFanInEvidenceSets, listRuntimeLlmAdvisorAssessments, listRuntimeStageRoleResults, listRuntimeStageTeamSessions, listRuntimeTestRuns, listRuntimeWorkflowGateDecisions, type RuntimeDurableGapRecord } from '../storage/runtime-store.js';
+import {
+  listRuntimeArtifactPayloads,
+  listRuntimeCapabilityAdoptions,
+  listRuntimeDurableGaps,
+  listRuntimeFanInEvidenceSets,
+  listRuntimeLlmAdvisorAssessments,
+  listRuntimeStageRoleResults,
+  listRuntimeStageTeamSessions,
+  listRuntimeTestRuns,
+  listRuntimeWorkflowGateDecisions,
+  type RuntimeArtifactPayloadRecord,
+  type RuntimeArtifactPayloadStatus,
+  type RuntimeCapabilityAdoptionRecord,
+  type RuntimeDurableGapRecord
+} from '../storage/runtime-store.js';
 import type { CapabilityEvidenceClassification } from '../evidence-runtime.js';
 import type { WorkflowGateDecision, WorkflowGateDecisionKind } from '../workflow-gate/types.js';
+import type { TruthReconciliationDecision } from '../truth-reconciliation.js';
 
 const execFileAsync = promisify(execFile);
 
@@ -79,6 +96,13 @@ export interface CapabilityHealthProjection {
     diagnostic: number;
     blocked: number;
   };
+  adoptions: {
+    adopted: number;
+    rejected: number;
+    unresolved: number;
+    acceptedAuthority: number;
+    releaseCriticalClosures: ProfessionalCapabilityDomain[];
+  };
   warnings: string[];
   releaseCriticalGaps: ProfessionalCapabilityDomain[];
   reasons: string[];
@@ -101,6 +125,37 @@ export interface WorkflowGateHealthProjection {
   humanRequired: number;
   latestDecision: WorkflowGateDecision | null;
   statusesByKind: Partial<Record<WorkflowGateDecisionKind, WorkflowGateDecision['status']>>;
+  evidenceSelection: WorkflowGateEvidenceSelectionProjection;
+}
+
+export type WorkflowGateEvidenceSelectionSource = 'selection_pointer' | 'candidate_payloads' | 'legacy_active_payloads' | 'none' | 'unknown';
+
+export interface WorkflowGateEvidenceSelectionRef {
+  payloadId: string | null;
+  logicalRef: string;
+  digest: string | null;
+  status: string | null;
+}
+
+export interface WorkflowGateEvidenceSelectionProjection {
+  source: WorkflowGateEvidenceSelectionSource;
+  selectionPointerRef: string | null;
+  acceptedEvidenceSetRef: string | null;
+  selectedRefs: WorkflowGateEvidenceSelectionRef[];
+  blockedRefs: string[];
+  ignoredRefs: WorkflowGateEvidenceSelectionRef[];
+  ignoredCounts: Record<Exclude<RuntimeArtifactPayloadStatus, 'active' | 'candidate'>, number>;
+  selectionReasons: string[];
+  reasons: string[];
+}
+
+export interface SpecCollaborationHealthProjection {
+  status: SpecCollaborationHealthDiagnostic['status'];
+  projectionCount: number;
+  latestClarificationGateId: string | null;
+  latestHandoffId: string | null;
+  latestRejectionReason: string | null;
+  reasons: string[];
 }
 
 export interface ProjectStatus {
@@ -135,10 +190,14 @@ export interface ProjectStatus {
   lifecycleRisk: LifecycleRiskConsumerDiagnostic;
   capabilityHealth: CapabilityHealthProjection;
   workflowHandoff: WorkflowStageHandoffDiagnostic;
+  specCollaborationHealth: SpecCollaborationHealthProjection;
+  fullStageChain: FullStageChainDiagnostic;
   gaps: SddTaskGap[];
   durableGaps: RuntimeDurableGapRecord[];
   stageTeamHealth: StageTeamHealthProjection;
   workflowGateHealth: WorkflowGateHealthProjection;
+  runtimeProjectionP0: RuntimeProjectionP0Diagnostic;
+  truthReconciliation: TruthReconciliationDecision | null;
 }
 
 export interface StatuslineProjection {
@@ -174,6 +233,7 @@ export interface StatuslineProjection {
     advisorAssessments: number;
     fanInEvidenceSets: number;
     workflowGateDecisions: number;
+    specCollaborationProjections: number;
   };
   taskRisk: TaskRiskSummary;
   next: string;
@@ -187,17 +247,21 @@ export async function getProjectStatus(projectRoot: string, options: { branch?:
   const enrichedLatestRunEvidence = latestRun && latestRunEvidence
     ? await addTaskDocumentStalenessToRunEvidence(workflow.model.tasksPath, latestRun, latestRunEvidence)
     : latestRunEvidence;
-  const latestRunStaleReasons = latestRunState ? await runDocumentStaleReasons(projectRoot, latestRunState, workflow.model) : [];
+  const latestRunStaleReasons = latestRunState ? runDocumentStaleReasons(latestRunState, workflow.model) : [];
   const taskRisk = summarizeTaskRisk(workflow.model.tasks);
   const tokenProjection = await inspectTokenRuntimeProjection(projectRoot);
   const lifecycleRisk = await inspectLifecycleRiskDecisionForModel(projectRoot, workflow.branch, workflow.model);
   const workflowHandoff = await inspectWorkflowStageHandoff(projectRoot, workflow.branch);
   const contextRuntime = await inspectContextOffloadRuntime(projectRoot, workflow.branch);
   const subagentDispatches = await inspectSubagentDispatches(projectRoot, workflow.branch);
-  const capabilityHealth = await inspectCapabilityHealth(projectRoot, latestRun?.runId ?? null, workflow.model.tasks);
+  const capabilityHealth = await inspectCapabilityHealth(projectRoot, workflow.branch, latestRun?.runId ?? null, workflow.model.tasks);
   const durableGaps = await listRuntimeDurableGaps(projectRoot, { partition: workflow.branch, status: 'open_terminal' });
   const stageTeamHealth = await inspectStageTeamHealth(projectRoot, workflow.branch, latestRun?.runId ?? null);
   const workflowGateHealth = await inspectWorkflowGateHealth(projectRoot, workflow.branch, latestRun?.runId ?? null);
+  const specCollaborationHealth = await inspectSpecCollaborationHealth(projectRoot, workflow.branch);
+  const fullStageChain = await inspectFullStageChain(projectRoot, workflow.branch);
+  const runtimeProjectionP0 = await inspectRuntimeProjectionP0(projectRoot, workflow.branch);
+  const nextIntent = resolveProjectStatusNextIntent(workflow.branch, workflow.nextIntent, fullStageChain, workflowHandoff, workflow.truthReconciliation);
 
   return {
     branch: workflow.branch,
@@ -214,8 +278,8 @@ export async function getProjectStatus(projectRoot: string, options: { branch?:
     latestRunStaleReasons,
     affectedFileConflicts: workflow.affectedFileConflicts,
     dependencyBlockers: workflow.dependencyBlockers,
-    recommendedNextCommand: workflow.recommendedNextCommand,
-    nextIntent: workflow.nextIntent,
+    recommendedNextCommand: nextIntent.canonicalCommand,
+    nextIntent,
     tokenProjection,
     contextRuntime,
     subagentDispatches,
@@ -225,10 +289,65 @@ export async function getProjectStatus(projectRoot: string, options: { branch?:
     gaps: workflow.visibleGaps,
     durableGaps,
     stageTeamHealth,
-    workflowGateHealth
+    workflowGateHealth,
+    specCollaborationHealth,
+    fullStageChain,
+    runtimeProjectionP0,
+    truthReconciliation: workflow.truthReconciliation
   };
 }
 
+export function resolveProjectStatusNextIntent(
+  branch: string,
+  workflowIntent: WorkflowNextIntent,
+  fullStageChain: Pick<FullStageChainDiagnostic, 'finalHealth'>,
+  workflowHandoff?: Pick<WorkflowStageHandoffDiagnostic, 'status' | 'latestHandoff' | 'latestStageRun'>,
+  truthReconciliation?: TruthReconciliationDecision | null
+): WorkflowNextIntent {
+  if (truthReconciliation) {
+    return truthReconciliation.nextIntent;
+  }
+  if (fullStageChain.finalHealth === 'ship_ready') {
+    return workflowNextIntent('ship', 'workflow_complete', `sdd status --branch ${branch} --json`, 'Active Phase 9 stage chain is closed through ship_ready; inspect status only after accepted evidence changes.', null, {
+      targetRuntimeStage: 'ship',
+      displayCommand: `/sdd status --branch ${branch} --json`,
+      evidenceSurface: ['specs/<branch>/*.md', '.sdd/runs/<branch>/<stage>/*.md', 'truthAlignment projection']
+    });
+  }
+  if (fullStageChain.finalHealth === 'ready_for_ship') {
+    return workflowNextIntent('ship', 'ship_readiness', `sdd ship close --branch ${branch} --compact-json`, 'Goal verification and truthAlignment are ready; close ship readiness with ship-stage evidence.', null);
+  }
+  return intraBundleHandoffNextIntent(branch, workflowHandoff) ?? workflowIntent;
+}
+
+function intraBundleHandoffNextIntent(branch: string, workflowHandoff?: Pick<WorkflowStageHandoffDiagnostic, 'status' | 'latestHandoff' | 'latestStageRun'>): WorkflowNextIntent | null {
+  const handoff = workflowHandoff?.latestHandoff;
+  const latestStageRun = workflowHandoff?.latestStageRun;
+  if (workflowHandoff?.status !== 'fresh' || !handoff || !['proposed', 'accepted'].includes(handoff.status)) {
+    return null;
+  }
+  if (latestStageRun?.stage === handoff.toStage && latestStageRun.status === 'completed') {
+    return null;
+  }
+  if (handoff.fromStage === 'tasks' && handoff.toStage === 'verifies') {
+    return workflowNextIntent('tasks', 'run_verifies', `sdd tasks close --branch ${branch} --target verifies --compact-json`, 'Close verifies inside the /sdd:tasks bundle using agent-authored verify evidence.', null, {
+      targetRuntimeStage: 'verifies',
+      resumeMode: 'resume',
+      canAutoAdvanceWithinBundle: true,
+      evidenceSurface: ['specs/<branch>/verify.md', '.sdd/runs/<branch>/verifies/*.md']
+    });
+  }
+  if (handoff.fromStage === 'test' && handoff.toStage === 'goal-verify') {
+    return workflowNextIntent('test', 'run_goal_verify', `sdd test close --branch ${branch} --target goal-verify --compact-json`, 'Close goal verification inside the /sdd:test bundle and compute truthAlignment before ship readiness.', null, {
+      targetRuntimeStage: 'goal-verify',
+      resumeMode: 'resume',
+      canAutoAdvanceWithinBundle: true,
+      evidenceSurface: ['.sdd/runs/<branch>/goal-verify/*.md', 'truthAlignment projection']
+    });
+  }
+  return null;
+}
+
 export async function getStatuslineProjection(projectRoot: string, options: { branch?: string | null; branchSource?: ContextBranchSource } = {}): Promise<StatuslineProjection> {
   return statuslineProjectionFromStatus(await getProjectStatus(projectRoot, options));
 }
@@ -272,7 +391,8 @@ export function statuslineProjectionFromStatus(status: ProjectStatus): Statuslin
       stageRoleResults: status.stageTeamHealth.roleResults,
       advisorAssessments: status.stageTeamHealth.advisorAssessments,
       fanInEvidenceSets: status.stageTeamHealth.fanInEvidenceSets,
-      workflowGateDecisions: status.workflowGateHealth.decisions
+      workflowGateDecisions: status.workflowGateHealth.decisions,
+      specCollaborationProjections: status.specCollaborationHealth.projectionCount
     },
     taskRisk: status.taskRisk,
     next: status.recommendedNextCommand
@@ -301,14 +421,91 @@ async function inspectStageTeamHealth(projectRoot: string, partition: string, ru
 async function inspectWorkflowGateHealth(projectRoot: string, partition: string, runId: string | null): Promise<WorkflowGateHealthProjection> {
   const query = runId ? { partition, runId } : { partition };
   const decisions = await listRuntimeWorkflowGateDecisions(projectRoot, query);
+  const latestDecision = decisions[0] ?? null;
+  const artifactPayloads = await listRuntimeArtifactPayloads(projectRoot, {
+    branchSlug: partition,
+    runId: runId ?? latestDecision?.runId ?? null,
+    taskId: latestDecision?.taskId ?? null
+  });
   const statusesByKind = Object.fromEntries(decisions.map((decision) => [decision.decisionKind, decision.status])) as WorkflowGateHealthProjection['statusesByKind'];
   return {
     decisions: decisions.length,
     blocked: decisions.filter((decision) => decision.status === 'BLOCKED').length,
     warnings: decisions.filter((decision) => decision.status === 'WARN').length,
     humanRequired: decisions.filter((decision) => decision.humanRequired).length,
-    latestDecision: decisions[0] ?? null,
-    statusesByKind
+    latestDecision,
+    statusesByKind,
+    evidenceSelection: workflowGateEvidenceSelection(latestDecision, artifactPayloads)
+  };
+}
+
+const NON_CONSUMABLE_EVIDENCE_STATUSES = ['partial', 'active_attempt', 'rejected', 'superseded', 'quarantined', 'stale'] as const;
+
+function workflowGateEvidenceSelection(latestDecision: WorkflowGateDecision | null, payloads: RuntimeArtifactPayloadRecord[]): WorkflowGateEvidenceSelectionProjection {
+  const binding = gateEvidenceBindingPayload(latestDecision);
+  const ignoredRefs = payloads.filter((payload) => NON_CONSUMABLE_EVIDENCE_STATUSES.includes(payload.status as (typeof NON_CONSUMABLE_EVIDENCE_STATUSES)[number])).map(payloadSelectionRef);
+  return {
+    source: gateEvidenceSelectionSource(binding?.source),
+    selectionPointerRef: readNullableString(binding?.selectionPointerRef),
+    acceptedEvidenceSetRef: readNullableString(binding?.acceptedEvidenceSetRef),
+    selectedRefs: readSelectionRefs(binding?.selectedRefs),
+    blockedRefs: readStringArray(binding?.blockedRefs),
+    ignoredRefs,
+    ignoredCounts: ignoredEvidenceCounts(payloads),
+    selectionReasons: readStringArray(binding?.selectionReasons),
+    reasons: readStringArray(binding?.reasons)
+  };
+}
+
+function ignoredEvidenceCounts(payloads: RuntimeArtifactPayloadRecord[]): WorkflowGateEvidenceSelectionProjection['ignoredCounts'] {
+  return {
+    partial: payloads.filter((payload) => payload.status === 'partial').length,
+    active_attempt: payloads.filter((payload) => payload.status === 'active_attempt').length,
+    rejected: payloads.filter((payload) => payload.status === 'rejected').length,
+    superseded: payloads.filter((payload) => payload.status === 'superseded').length,
+    quarantined: payloads.filter((payload) => payload.status === 'quarantined').length,
+    stale: payloads.filter((payload) => payload.status === 'stale').length
+  };
+}
+
+function gateEvidenceBindingPayload(latestDecision: WorkflowGateDecision | null): Record<string, unknown> | null {
+  if (!latestDecision || !isRecord(latestDecision.payload)) {
+    return null;
+  }
+  const binding = latestDecision.payload.evidenceBinding;
+  return isRecord(binding) ? binding : null;
+}
+
+function gateEvidenceSelectionSource(value: unknown): WorkflowGateEvidenceSelectionSource {
+  return value === 'selection_pointer' || value === 'candidate_payloads' || value === 'legacy_active_payloads' || value === 'none' ? value : 'unknown';
+}
+
+function readSelectionRefs(value: unknown): WorkflowGateEvidenceSelectionRef[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter(isRecord).map((item) => ({
+    payloadId: readNullableString(item.payloadId),
+    logicalRef: readNullableString(item.logicalRef) ?? 'unknown',
+    digest: readNullableString(item.digest),
+    status: readNullableString(item.status)
+  }));
+}
+
+function readStringArray(value: unknown): string[] {
+  return Array.isArray(value) ? value.filter((item): item is string => typeof item === 'string') : [];
+}
+
+function readNullableString(value: unknown): string | null {
+  return typeof value === 'string' && value.length > 0 ? value : null;
+}
+
+function payloadSelectionRef(payload: RuntimeArtifactPayloadRecord): WorkflowGateEvidenceSelectionRef {
+  return {
+    payloadId: payload.payloadId,
+    logicalRef: payload.logicalRef,
+    digest: payload.digest,
+    status: payload.status
   };
 }
 
@@ -363,12 +560,13 @@ function evidenceHealth(status: ProjectStatus, runtimeHealth: StatuslineProjecti
   return 'pass';
 }
 
-async function inspectCapabilityHealth(projectRoot: string, latestRunId: string | null, tasks: SddTaskModel['tasks']): Promise<CapabilityHealthProjection> {
+async function inspectCapabilityHealth(projectRoot: string, branch: string, latestRunId: string | null, tasks: SddTaskModel['tasks']): Promise<CapabilityHealthProjection> {
   try {
-    const [catalog, runtimeValidation, testRuns] = await Promise.all([
+    const [catalog, runtimeValidation, testRuns, adoptionRecords] = await Promise.all([
       inspectAgentCapabilityCatalog(projectRoot),
       validateAgentSkillTeamRuntime(projectRoot),
-      latestRunId ? listRuntimeTestRuns(projectRoot, latestRunId) : Promise.resolve([])
+      latestRunId ? listRuntimeTestRuns(projectRoot, latestRunId) : Promise.resolve([]),
+      listRuntimeCapabilityAdoptions(projectRoot, { branchSlug: branch })
     ]);
     const baselineDomains = uniqueSorted(catalog.capabilities
       .filter((capability) => capability.domainGroup === 'professional' && capability.provenance.sourceId === 'sdd_professional_baseline')
@@ -376,15 +574,18 @@ async function inspectCapabilityHealth(projectRoot: string, latestRunId: string
     const missingBaselineDomains = REQUIRED_PROFESSIONAL_CAPABILITY_DOMAINS.filter((domain) => !baselineDomains.includes(domain));
     const latestEvidence = capabilityEvidenceFromTestRuns(testRuns.map((run) => run.payload));
     const acceptedProfessionalEvidence = latestEvidence.filter((item) => item.source === 'professional_capability' && item.class === 'accepted');
-    const activeDomains = uniqueSorted(acceptedProfessionalEvidence
-      .map((item) => item.domainOrSourceId)) as AgentCapabilityDomain[];
+    const releaseCriticalAdoptions = releaseCriticalCapabilityAdoptions(adoptionRecords);
+    const activeDomains = uniqueSorted([
+      ...acceptedProfessionalEvidence.map((item) => item.domainOrSourceId),
+      ...releaseCriticalAdoptions.map((record) => record.capabilityDomain)
+    ]) as AgentCapabilityDomain[];
     const activePacks = uniqueSorted(catalog.materialPacks
       .filter((pack) => pack.domains.some((domain) => activeDomains.includes(domain)))
       .map((pack) => pack.id));
     const sources = runtimeValidation.inspection.capabilitySources;
-    const blocked = missingBaselineDomains.length > 0 || !runtimeValidation.valid;
+    const releaseCriticalGaps = releaseCriticalCapabilityGaps(tasks, acceptedProfessionalEvidence, releaseCriticalAdoptions);
+    const blocked = missingBaselineDomains.length > 0 || !runtimeValidation.valid || releaseCriticalGaps.length > 0;
     const noEvidence = latestRunId !== null && latestEvidence.length === 0;
-    const releaseCriticalGaps = releaseCriticalCapabilityGaps(tasks, acceptedProfessionalEvidence);
     const warnings = [
       ...missingBaselineDomains.map((domain) => `missing baseline professional domain ${domain}`),
       ...runtimeValidation.issues.map((issue) => issue.message),
@@ -406,6 +607,7 @@ async function inspectCapabilityHealth(projectRoot: string, latestRunId: string
         futureAdapters: sources.filter((source) => source.hostCompatibility.some((item) => item.includes('future_adapter'))).length
       },
       evidence: capabilityEvidenceCounts(latestEvidence),
+      adoptions: capabilityAdoptionCounts(adoptionRecords, releaseCriticalAdoptions),
       releaseCriticalGaps,
       warnings: uniqueSorted(warnings),
       reasons: capabilityHealthReasons(latestRunId, latestEvidence.length, blocked, warnings.length)
@@ -421,6 +623,7 @@ async function inspectCapabilityHealth(projectRoot: string, latestRunId: string
       activePacks: [],
       sources: { total: 0, quarantined: 0, denied: 0, futureAdapters: 0 },
       evidence: { accepted: 0, candidate: 0, quarantined: 0, diagnostic: 0, blocked: 0 },
+      adoptions: { adopted: 0, rejected: 0, unresolved: 0, acceptedAuthority: 0, releaseCriticalClosures: [] },
       warnings: [],
       releaseCriticalGaps: [],
       reasons: [`capability health unavailable: ${error instanceof Error ? error.message : String(error)}`]
@@ -451,12 +654,31 @@ function capabilityEvidenceCounts(evidence: CapabilityEvidenceClassification[]):
   };
 }
 
-function releaseCriticalCapabilityGaps(tasks: SddTaskModel['tasks'], acceptedProfessionalEvidence: CapabilityEvidenceClassification[]): ProfessionalCapabilityDomain[] {
+function releaseCriticalCapabilityGaps(tasks: SddTaskModel['tasks'], acceptedProfessionalEvidence: CapabilityEvidenceClassification[], releaseCriticalAdoptions: RuntimeCapabilityAdoptionRecord[]): ProfessionalCapabilityDomain[] {
   const required = releaseCriticalDomainsForTasks(tasks);
   const acceptedEvidenceDomains = new Set(acceptedProfessionalEvidence.map((item) => item.domainOrSourceId));
-  return required.filter((domain) => !acceptedEvidenceDomains.has(domain));
+  const adoptedDomains = new Set(releaseCriticalAdoptions.map((record) => record.capabilityDomain));
+  return required.filter((domain) => !acceptedEvidenceDomains.has(domain) && !adoptedDomains.has(domain));
+}
+
+function releaseCriticalCapabilityAdoptions(records: RuntimeCapabilityAdoptionRecord[]): RuntimeCapabilityAdoptionRecord[] {
+  return records.filter((record) => (record.status === 'adopted' || record.status === 'rejected')
+    && record.reason.trim().length > 0
+    && (record.finalAuthority === 'sdd_contract' || record.finalAuthority === 'sdd_gate')
+    && isRequiredProfessionalDomain(record.capabilityDomain));
 }
 
+function capabilityAdoptionCounts(records: RuntimeCapabilityAdoptionRecord[], releaseCriticalAdoptions: RuntimeCapabilityAdoptionRecord[]): CapabilityHealthProjection['adoptions'] {
+  return {
+    adopted: records.filter((record) => record.status === 'adopted').length,
+    rejected: records.filter((record) => record.status === 'rejected').length,
+    unresolved: records.filter((record) => record.status === 'unresolved').length,
+    acceptedAuthority: records.filter((record) => record.finalAuthority === 'sdd_contract' || record.finalAuthority === 'sdd_gate').length,
+    releaseCriticalClosures: uniqueSorted(releaseCriticalAdoptions.map((record) => record.capabilityDomain).filter(isRequiredProfessionalDomain))
+  };
+}
+
+
 function releaseCriticalDomainsForTasks(tasks: SddTaskModel['tasks']): ProfessionalCapabilityDomain[] {
   const domains = new Set<ProfessionalCapabilityDomain>();
   for (const task of tasks) {
@@ -483,21 +705,25 @@ function releaseCriticalDomainsForTasks(tasks: SddTaskModel['tasks']): Professio
   return [...domains].sort((left, right) => left.localeCompare(right));
 }
 
+function isRequiredProfessionalDomain(domain: string): domain is ProfessionalCapabilityDomain {
+  return REQUIRED_PROFESSIONAL_CAPABILITY_DOMAINS.includes(domain as ProfessionalCapabilityDomain);
+}
+
 function noCapabilityEvidenceWarnings(noEvidence: boolean): string[] {
   return noEvidence ? ['latest run has no capability evidence classification'] : [];
 }
 
 function capabilityHealthReasons(latestRunId: string | null, evidenceCount: number, blocked: boolean, warnings: number): string[] {
   if (blocked) {
-    return ['Capability catalog or runtime source validation has blocking issues.'];
+    return ['Capability catalog, runtime source validation, or release-critical adoption has blocking issues.'];
   }
   if (latestRunId !== null && evidenceCount === 0) {
     return ['Latest run has no recorded capability evidence classification.'];
   }
   if (warnings > 0) {
-    return ['Capability health has warnings; inspect status JSON for exact missing evidence or release-critical gaps.'];
+    return ['Capability health has warnings; inspect status JSON for exact missing evidence or release-critical adoption state.'];
   }
-  return ['Professional capability baseline and source policy are visible.'];
+  return ['Professional capability baseline, source policy, and release-critical adoption are visible.'];
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {