sdd-agent-platform 0.4.0 → 0.4.2

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

@@ -1,13 +1,20 @@
 import type { ContextBranchSource, ContextResolverContract } from '../sdd-docs/context.js';
 import type { SddTaskGap, SddTaskModel } from '../sdd-docs/task-parser.js';
 import type { RunSummary } from '../run-state/model.js';
-import { type WorkflowLatestTaskRun } from '../workflow-state/resolve.js';
+import { 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';
 import { type LifecycleRiskConsumerDiagnostic } from '../risk.js';
 import { type WorkflowStageHandoffDiagnostic } from '../stage-runtime.js';
 import { type ContextRuntimeDiagnostic } from '../context-offload.js';
+import { type FullStageChainDiagnostic, type SpecCollaborationHealthDiagnostic } from '../stage-collaboration.js';
+import { type RuntimeProjectionP0Diagnostic } from '../runtime-projection-p0.js';
 import { type SubagentDispatchDiagnostic } from '../subagents.js';
+import { type AgentCapabilityDomain, type ProfessionalCapabilityDomain } from '../registries/agent-capability-catalog.js';
+import { type RuntimeArtifactPayloadStatus, type RuntimeDurableGapRecord } from '../storage/runtime-store.js';
+import type { WorkflowGateDecision, WorkflowGateDecisionKind } from '../workflow-gate/types.js';
+import type { TruthReconciliationDecision } from '../truth-reconciliation.js';
 export interface RunEvidenceSummary {
     agentExecutions: number;
     teamSessions: number;
@@ -34,6 +41,83 @@ export interface TokenRuntimeProjection {
     teamRuntimeDecisions: number;
     pressureReasons: string[];
 }
+export type CapabilityHealthStatus = 'absent' | 'pass' | 'warn' | 'blocked';
+export interface CapabilityHealthProjection {
+    status: CapabilityHealthStatus;
+    requiredProfessionalDomains: ProfessionalCapabilityDomain[];
+    baselineDomains: ProfessionalCapabilityDomain[];
+    missingBaselineDomains: ProfessionalCapabilityDomain[];
+    materialPacks: number;
+    activeDomains: AgentCapabilityDomain[];
+    activePacks: string[];
+    sources: {
+        total: number;
+        quarantined: number;
+        denied: number;
+        futureAdapters: number;
+    };
+    evidence: {
+        accepted: number;
+        candidate: number;
+        quarantined: number;
+        diagnostic: number;
+        blocked: number;
+    };
+    adoptions: {
+        adopted: number;
+        rejected: number;
+        unresolved: number;
+        acceptedAuthority: number;
+        releaseCriticalClosures: ProfessionalCapabilityDomain[];
+    };
+    warnings: string[];
+    releaseCriticalGaps: ProfessionalCapabilityDomain[];
+    reasons: string[];
+}
+export interface StageTeamHealthProjection {
+    sessions: number;
+    roleResults: number;
+    advisorAssessments: number;
+    fanInEvidenceSets: number;
+    highConcernAdvisors: number;
+    lifecycleProfiles: string[];
+    directProfileRequiresNoTeam: boolean;
+}
+export interface WorkflowGateHealthProjection {
+    decisions: number;
+    blocked: number;
+    warnings: number;
+    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 {
     branch: string;
     workflowStatus: 'active' | 'not_started';
@@ -53,17 +137,27 @@ export interface ProjectStatus {
     taskRisk: TaskRiskSummary;
     latestRun: RunSummary | null;
     latestRunsByTask: WorkflowLatestTaskRun[];
+    latestEligibleRunsByTask: LatestEligibleRunSelection[];
     latestRunEvidence: RunEvidenceSummary | null;
     latestRunStaleReasons: string[];
     affectedFileConflicts: WorkflowAffectedFileConflict[];
     dependencyBlockers: WorkflowDependencyBlocker[];
     recommendedNextCommand: string;
+    nextIntent: WorkflowNextIntent;
     tokenProjection: TokenRuntimeProjection;
     contextRuntime: ContextRuntimeDiagnostic;
     subagentDispatches: SubagentDispatchDiagnostic;
     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 {
     contract: 'sdd-statusline-projection-v1';
@@ -78,6 +172,7 @@ export interface StatuslineProjection {
     contextAction: ProjectStatus['contextRuntime']['action'];
     subagentHealth: ProjectStatus['subagentDispatches']['status'];
     evidenceHealth: 'none' | 'pass' | 'warn' | 'blocked';
+    capabilityHealth: ProjectStatus['capabilityHealth']['status'];
     latestRunId: string | null;
     counts: {
         tasks: ProjectStatus['tasks'];
@@ -90,6 +185,14 @@ export interface StatuslineProjection {
         affectedFileConflicts: number;
         subagentDispatches: number;
         blockingSubagents: number;
+        capabilityWarnings: number;
+        durableGaps: number;
+        stageTeamSessions: number;
+        stageRoleResults: number;
+        advisorAssessments: number;
+        fanInEvidenceSets: number;
+        workflowGateDecisions: number;
+        specCollaborationProjections: number;
     };
     taskRisk: TaskRiskSummary;
     next: string;
@@ -98,6 +201,7 @@ export declare function getProjectStatus(projectRoot: string, options?: {
     branch?: string | null;
     branchSource?: ContextBranchSource;
 }): Promise<ProjectStatus>;
+export declare function resolveProjectStatusNextIntent(branch: string, workflowIntent: WorkflowNextIntent, fullStageChain: Pick<FullStageChainDiagnostic, 'finalHealth'>, workflowHandoff?: Pick<WorkflowStageHandoffDiagnostic, 'status' | 'latestHandoff' | 'latestStageRun'>, truthReconciliation?: TruthReconciliationDecision | null): WorkflowNextIntent;
 export declare function getStatuslineProjection(projectRoot: string, options?: {
     branch?: string | null;
     branchSource?: ContextBranchSource;

package/node_modules/@sdd-agent-platform/core/dist/status/project-status.js

@@ -5,14 +5,19 @@ 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 } from '../workflow-state/resolve.js';
+import { runDocumentStaleReasons } from '../workflow-state/resolve-task-run.js';
+import { resolveWorkflowState, workflowNextIntent } from '../workflow-state/resolve.js';
 import { buildTaskRiskProfile } from '../task-risk-profile.js';
 import { listRuntimeProjections } from '../storage/runtime-store.js';
 import { inspectLifecycleRiskDecisionForModel } from '../risk.js';
 import { inspectWorkflowStageHandoff } from '../stage-runtime.js';
 import { inspectContextOffloadRuntime } from '../context-offload.js';
+import { inspectFullStageChain, inspectSpecCollaborationHealth } from '../stage-collaboration.js';
+import { inspectRuntimeProjectionP0 } from '../runtime-projection-p0.js';
 import { inspectSubagentDispatches } from '../subagents.js';
+import { inspectAgentCapabilityCatalog, REQUIRED_PROFESSIONAL_CAPABILITY_DOMAINS } from '../registries/agent-capability-catalog.js';
+import { validateAgentSkillTeamRuntime } from '../router/runtime-validation.js';
+import { listRuntimeArtifactPayloads, listRuntimeCapabilityAdoptions, listRuntimeDurableGaps, listRuntimeFanInEvidenceSets, listRuntimeLlmAdvisorAssessments, listRuntimeStageRoleResults, listRuntimeStageTeamSessions, listRuntimeTestRuns, listRuntimeWorkflowGateDecisions } from '../storage/runtime-store.js';
 const execFileAsync = promisify(execFile);
 export async function getProjectStatus(projectRoot, options = {}) {
     const [workflow, gitRoot] = await Promise.all([resolveWorkflowState(projectRoot, options), getGitRoot(projectRoot)]);
@@ -22,13 +27,21 @@ export async function getProjectStatus(projectRoot, options = {}) {
     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, 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,
         workflowStatus: workflow.workflowStatus,
@@ -39,19 +52,72 @@ export async function getProjectStatus(projectRoot, options = {}) {
         taskRisk,
         latestRun,
         latestRunsByTask: workflow.latestRunsByTask,
+        latestEligibleRunsByTask: workflow.latestEligibleRunsByTask,
         latestRunEvidence: enrichedLatestRunEvidence,
         latestRunStaleReasons,
         affectedFileConflicts: workflow.affectedFileConflicts,
         dependencyBlockers: workflow.dependencyBlockers,
-        recommendedNextCommand: workflow.recommendedNextCommand,
+        recommendedNextCommand: nextIntent.canonicalCommand,
+        nextIntent,
         tokenProjection,
         contextRuntime,
         subagentDispatches,
         lifecycleRisk,
         workflowHandoff,
-        gaps: workflow.visibleGaps
+        capabilityHealth,
+        gaps: workflow.visibleGaps,
+        durableGaps,
+        stageTeamHealth,
+        workflowGateHealth,
+        specCollaborationHealth,
+        fullStageChain,
+        runtimeProjectionP0,
+        truthReconciliation: workflow.truthReconciliation
     };
 }
+export function resolveProjectStatusNextIntent(branch, workflowIntent, fullStageChain, workflowHandoff, truthReconciliation) {
+    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, workflowHandoff) {
+    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, options = {}) {
     return statuslineProjectionFromStatus(await getProjectStatus(projectRoot, options));
 }
@@ -69,12 +135,13 @@ export function statuslineProjectionFromStatus(status) {
         taskHealth: taskHealth(status),
         runtimeHealth,
         testHealth: testHealth(status),
-        teamHealth: (evidence?.teamSessions ?? 0) > 0 ? 'active' : 'none',
+        teamHealth: (evidence?.teamSessions ?? 0) > 0 || status.stageTeamHealth.sessions > 0 || status.stageTeamHealth.roleResults > 0 ? 'active' : 'none',
         tokenHealth: status.tokenProjection.health,
         contextLoad: status.contextRuntime.level,
         contextAction: status.contextRuntime.action,
         subagentHealth: status.subagentDispatches.status,
         evidenceHealth: evidenceHealth(status, runtimeHealth),
+        capabilityHealth: status.capabilityHealth.status,
         latestRunId: status.latestRun?.runId ?? null,
         counts: {
             tasks: status.tasks,
@@ -86,12 +153,119 @@ export function statuslineProjectionFromStatus(status) {
             staleReasons,
             affectedFileConflicts,
             subagentDispatches: status.subagentDispatches.dispatches,
-            blockingSubagents: status.subagentDispatches.blockingOpen
+            blockingSubagents: status.subagentDispatches.blockingOpen,
+            capabilityWarnings: status.capabilityHealth.warnings.length,
+            durableGaps: status.durableGaps.length,
+            stageTeamSessions: status.stageTeamHealth.sessions,
+            stageRoleResults: status.stageTeamHealth.roleResults,
+            advisorAssessments: status.stageTeamHealth.advisorAssessments,
+            fanInEvidenceSets: status.stageTeamHealth.fanInEvidenceSets,
+            workflowGateDecisions: status.workflowGateHealth.decisions,
+            specCollaborationProjections: status.specCollaborationHealth.projectionCount
         },
         taskRisk: status.taskRisk,
         next: status.recommendedNextCommand
     };
 }
+async function inspectStageTeamHealth(projectRoot, partition, runId) {
+    const query = runId ? { partition, runId } : { partition };
+    const [sessions, roleResults, advisorAssessments, fanInEvidenceSets] = await Promise.all([
+        listRuntimeStageTeamSessions(projectRoot, query),
+        listRuntimeStageRoleResults(projectRoot, query),
+        listRuntimeLlmAdvisorAssessments(projectRoot, query),
+        listRuntimeFanInEvidenceSets(projectRoot, query)
+    ]);
+    return {
+        sessions: sessions.length,
+        roleResults: roleResults.length,
+        advisorAssessments: advisorAssessments.length,
+        fanInEvidenceSets: fanInEvidenceSets.length,
+        highConcernAdvisors: advisorAssessments.filter((assessment) => assessment.concern === 'high').length,
+        lifecycleProfiles: [...new Set(sessions.map((session) => session.lifecycleProfile))].sort(),
+        directProfileRequiresNoTeam: !sessions.some((session) => session.lifecycleProfile === 'direct' && session.assignments.some((assignment) => assignment.required))
+    };
+}
+async function inspectWorkflowGateHealth(projectRoot, partition, runId) {
+    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]));
+    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,
+        statusesByKind,
+        evidenceSelection: workflowGateEvidenceSelection(latestDecision, artifactPayloads)
+    };
+}
+const NON_CONSUMABLE_EVIDENCE_STATUSES = ['partial', 'active_attempt', 'rejected', 'superseded', 'quarantined', 'stale'];
+function workflowGateEvidenceSelection(latestDecision, payloads) {
+    const binding = gateEvidenceBindingPayload(latestDecision);
+    const ignoredRefs = payloads.filter((payload) => NON_CONSUMABLE_EVIDENCE_STATUSES.includes(payload.status)).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) {
+    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) {
+    if (!latestDecision || !isRecord(latestDecision.payload)) {
+        return null;
+    }
+    const binding = latestDecision.payload.evidenceBinding;
+    return isRecord(binding) ? binding : null;
+}
+function gateEvidenceSelectionSource(value) {
+    return value === 'selection_pointer' || value === 'candidate_payloads' || value === 'legacy_active_payloads' || value === 'none' ? value : 'unknown';
+}
+function readSelectionRefs(value) {
+    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) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
+}
+function readNullableString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : null;
+}
+function payloadSelectionRef(payload) {
+    return {
+        payloadId: payload.payloadId,
+        logicalRef: payload.logicalRef,
+        digest: payload.digest,
+        status: payload.status
+    };
+}
 function summarizeTaskRisk(tasks) {
     const entries = tasks.map((task) => ({ taskId: task?.id ?? null, profile: buildTaskRiskProfile(task) }));
     return {
@@ -107,7 +281,7 @@ function taskHealth(status) {
     if (status.tasks.total === 0) {
         return 'empty';
     }
-    if (status.tasks.blocked > 0 || status.gaps.some((gap) => gap.severity === 'blocking') || status.dependencyBlockers.length > 0) {
+    if (status.tasks.blocked > 0 || status.gaps.some((gap) => gap.severity === 'blocking') || status.durableGaps.some((gap) => gap.severity === 'blocking') || status.dependencyBlockers.length > 0) {
         return 'blocked';
     }
     if (status.tasks.completed === status.tasks.total) {
@@ -139,6 +313,167 @@ function evidenceHealth(status, runtimeHealth) {
     }
     return 'pass';
 }
+async function inspectCapabilityHealth(projectRoot, branch, latestRunId, tasks) {
+    try {
+        const [catalog, runtimeValidation, testRuns, adoptionRecords] = await Promise.all([
+            inspectAgentCapabilityCatalog(projectRoot),
+            validateAgentSkillTeamRuntime(projectRoot),
+            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')
+            .map((capability) => capability.domain));
+        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 releaseCriticalAdoptions = releaseCriticalCapabilityAdoptions(adoptionRecords);
+        const activeDomains = uniqueSorted([
+            ...acceptedProfessionalEvidence.map((item) => item.domainOrSourceId),
+            ...releaseCriticalAdoptions.map((record) => record.capabilityDomain)
+        ]);
+        const activePacks = uniqueSorted(catalog.materialPacks
+            .filter((pack) => pack.domains.some((domain) => activeDomains.includes(domain)))
+            .map((pack) => pack.id));
+        const sources = runtimeValidation.inspection.capabilitySources;
+        const releaseCriticalGaps = releaseCriticalCapabilityGaps(tasks, acceptedProfessionalEvidence, releaseCriticalAdoptions);
+        const blocked = missingBaselineDomains.length > 0 || !runtimeValidation.valid || releaseCriticalGaps.length > 0;
+        const noEvidence = latestRunId !== null && latestEvidence.length === 0;
+        const warnings = [
+            ...missingBaselineDomains.map((domain) => `missing baseline professional domain ${domain}`),
+            ...runtimeValidation.issues.map((issue) => issue.message),
+            ...noCapabilityEvidenceWarnings(noEvidence),
+            ...releaseCriticalGaps.map((domain) => `release-critical capability gap ${domain}`)
+        ];
+        return {
+            status: blocked ? 'blocked' : warnings.length > 0 ? 'warn' : 'pass',
+            requiredProfessionalDomains: [...REQUIRED_PROFESSIONAL_CAPABILITY_DOMAINS],
+            baselineDomains,
+            missingBaselineDomains,
+            materialPacks: catalog.materialPacks.length,
+            activeDomains,
+            activePacks,
+            sources: {
+                total: sources.length,
+                quarantined: sources.filter((source) => source.quarantineRequired || source.quarantineStatus === 'quarantined').length,
+                denied: sources.filter((source) => source.quarantineStatus === 'denied').length,
+                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)
+        };
+    }
+    catch (error) {
+        return {
+            status: 'absent',
+            requiredProfessionalDomains: [...REQUIRED_PROFESSIONAL_CAPABILITY_DOMAINS],
+            baselineDomains: [],
+            missingBaselineDomains: [],
+            materialPacks: 0,
+            activeDomains: [],
+            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)}`]
+        };
+    }
+}
+function capabilityEvidenceFromTestRuns(payloads) {
+    return payloads.flatMap((payload) => isRecord(payload) && Array.isArray(payload.capabilityEvidence)
+        ? payload.capabilityEvidence.filter(isCapabilityEvidenceClassification)
+        : []);
+}
+function isCapabilityEvidenceClassification(value) {
+    return isRecord(value)
+        && (value.class === 'accepted' || value.class === 'candidate' || value.class === 'quarantined' || value.class === 'diagnostic' || value.class === 'blocked')
+        && (value.source === 'professional_capability' || value.source === 'external_source' || value.source === 'runtime_diagnostic')
+        && typeof value.domainOrSourceId === 'string';
+}
+function capabilityEvidenceCounts(evidence) {
+    return {
+        accepted: evidence.filter((item) => item.class === 'accepted').length,
+        candidate: evidence.filter((item) => item.class === 'candidate').length,
+        quarantined: evidence.filter((item) => item.class === 'quarantined').length,
+        diagnostic: evidence.filter((item) => item.class === 'diagnostic').length,
+        blocked: evidence.filter((item) => item.class === 'blocked').length
+    };
+}
+function releaseCriticalCapabilityGaps(tasks, acceptedProfessionalEvidence, releaseCriticalAdoptions) {
+    const required = releaseCriticalDomainsForTasks(tasks);
+    const acceptedEvidenceDomains = new Set(acceptedProfessionalEvidence.map((item) => item.domainOrSourceId));
+    const adoptedDomains = new Set(releaseCriticalAdoptions.map((record) => record.capabilityDomain));
+    return required.filter((domain) => !acceptedEvidenceDomains.has(domain) && !adoptedDomains.has(domain));
+}
+function releaseCriticalCapabilityAdoptions(records) {
+    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, releaseCriticalAdoptions) {
+    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) {
+    const domains = new Set();
+    for (const task of tasks) {
+        const text = [task.title ?? '', ...task.risk, ...task.affectedFiles, ...task.validation, ...task.acceptance, task.boundary ?? ''].join('\n').toLowerCase();
+        if (/security|auth|permission|secret|token|安全/.test(text)) {
+            domains.add('security-engineering');
+        }
+        if (/performance|latency|throughput|benchmark|capacity|性能/.test(text)) {
+            domains.add('performance-engineering');
+        }
+        if (/observability|logging|metrics|tracing|diagnostic|可观测/.test(text)) {
+            domains.add('observability-engineering');
+        }
+        if (/release|deploy|rollback|ci|ship|发布/.test(text)) {
+            domains.add('release-engineering');
+        }
+        if (/database|schema|migration|query|data|db|数据/.test(text)) {
+            domains.add('db-data-engineering');
+        }
+        if (/ui|ux|frontend|browser|figma|accessibility|交互|前端/.test(text)) {
+            domains.add(text.includes('frontend') || text.includes('browser') || text.includes('前端') ? 'frontend-engineering' : 'ui-ux-product-design');
+        }
+    }
+    return [...domains].sort((left, right) => left.localeCompare(right));
+}
+function isRequiredProfessionalDomain(domain) {
+    return REQUIRED_PROFESSIONAL_CAPABILITY_DOMAINS.includes(domain);
+}
+function noCapabilityEvidenceWarnings(noEvidence) {
+    return noEvidence ? ['latest run has no capability evidence classification'] : [];
+}
+function capabilityHealthReasons(latestRunId, evidenceCount, blocked, warnings) {
+    if (blocked) {
+        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 adoption state.'];
+    }
+    return ['Professional capability baseline, source policy, and release-critical adoption are visible.'];
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object';
+}
+function uniqueSorted(values) {
+    return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
 async function inspectTokenRuntimeProjection(projectRoot) {
     const projections = await listRuntimeProjections(projectRoot, ['context_build', 'team_runtime_decision']);
     const contextPackages = projections.filter((projection) => projection.projectionType === 'context_build');