sdd-agent-platform 0.4.0 → 0.4.1

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

@@ -9,15 +9,21 @@ 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 } from '../workflow-state/resolve.js';
+import { resolveWorkflowState, 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 { buildTaskRiskProfile } from '../task-risk-profile.js';
 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 { 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 type { CapabilityEvidenceClassification } from '../evidence-runtime.js';
+import type { WorkflowGateDecision, WorkflowGateDecisionKind } from '../workflow-gate/types.js';
 
 const execFileAsync = promisify(execFile);
 
@@ -50,6 +56,53 @@ export interface TokenRuntimeProjection {
   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;
+  };
+  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']>>;
+}
+
 export interface ProjectStatus {
   branch: string;
   workflowStatus: 'active' | 'not_started';
@@ -69,17 +122,23 @@ 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;
   gaps: SddTaskGap[];
+  durableGaps: RuntimeDurableGapRecord[];
+  stageTeamHealth: StageTeamHealthProjection;
+  workflowGateHealth: WorkflowGateHealthProjection;
 }
 
 export interface StatuslineProjection {
@@ -95,6 +154,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'];
@@ -107,6 +167,13 @@ export interface StatuslineProjection {
     affectedFileConflicts: number;
     subagentDispatches: number;
     blockingSubagents: number;
+    capabilityWarnings: number;
+    durableGaps: number;
+    stageTeamSessions: number;
+    stageRoleResults: number;
+    advisorAssessments: number;
+    fanInEvidenceSets: number;
+    workflowGateDecisions: number;
   };
   taskRisk: TaskRiskSummary;
   next: string;
@@ -127,6 +194,10 @@ export async function getProjectStatus(projectRoot: string, options: { branch?:
   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 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);
 
   return {
     branch: workflow.branch,
@@ -138,17 +209,23 @@ export async function getProjectStatus(projectRoot: string, options: { branch?:
     taskRisk,
     latestRun,
     latestRunsByTask: workflow.latestRunsByTask,
+    latestEligibleRunsByTask: workflow.latestEligibleRunsByTask,
     latestRunEvidence: enrichedLatestRunEvidence,
     latestRunStaleReasons,
     affectedFileConflicts: workflow.affectedFileConflicts,
     dependencyBlockers: workflow.dependencyBlockers,
     recommendedNextCommand: workflow.recommendedNextCommand,
+    nextIntent: workflow.nextIntent,
     tokenProjection,
     contextRuntime,
     subagentDispatches,
     lifecycleRisk,
     workflowHandoff,
-    gaps: workflow.visibleGaps
+    capabilityHealth,
+    gaps: workflow.visibleGaps,
+    durableGaps,
+    stageTeamHealth,
+    workflowGateHealth
   };
 }
 
@@ -170,12 +247,13 @@ export function statuslineProjectionFromStatus(status: ProjectStatus): Statuslin
     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,
@@ -187,13 +265,53 @@ export function statuslineProjectionFromStatus(status: ProjectStatus): Statuslin
       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
     },
     taskRisk: status.taskRisk,
     next: status.recommendedNextCommand
   };
 }
 
+async function inspectStageTeamHealth(projectRoot: string, partition: string, runId: string | null): Promise<StageTeamHealthProjection> {
+  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: string, partition: string, runId: string | null): Promise<WorkflowGateHealthProjection> {
+  const query = runId ? { partition, runId } : { partition };
+  const decisions = await listRuntimeWorkflowGateDecisions(projectRoot, query);
+  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
+  };
+}
+
 function summarizeTaskRisk(tasks: Array<Parameters<typeof buildTaskRiskProfile>[0]>): TaskRiskSummary {
   const entries = tasks.map((task) => ({ taskId: task?.id ?? null, profile: buildTaskRiskProfile(task) }));
   return {
@@ -210,7 +328,7 @@ function taskHealth(status: ProjectStatus): StatuslineProjection['taskHealth'] {
   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) {
@@ -245,6 +363,151 @@ function evidenceHealth(status: ProjectStatus, runtimeHealth: StatuslineProjecti
   return 'pass';
 }
 
+async function inspectCapabilityHealth(projectRoot: string, latestRunId: string | null, tasks: SddTaskModel['tasks']): Promise<CapabilityHealthProjection> {
+  try {
+    const [catalog, runtimeValidation, testRuns] = await Promise.all([
+      inspectAgentCapabilityCatalog(projectRoot),
+      validateAgentSkillTeamRuntime(projectRoot),
+      latestRunId ? listRuntimeTestRuns(projectRoot, latestRunId) : Promise.resolve([])
+    ]);
+    const baselineDomains = uniqueSorted(catalog.capabilities
+      .filter((capability) => capability.domainGroup === 'professional' && capability.provenance.sourceId === 'sdd_professional_baseline')
+      .map((capability) => capability.domain)) as ProfessionalCapabilityDomain[];
+    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 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 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),
+      ...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),
+      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 },
+      warnings: [],
+      releaseCriticalGaps: [],
+      reasons: [`capability health unavailable: ${error instanceof Error ? error.message : String(error)}`]
+    };
+  }
+}
+
+function capabilityEvidenceFromTestRuns(payloads: unknown[]): CapabilityEvidenceClassification[] {
+  return payloads.flatMap((payload) => isRecord(payload) && Array.isArray(payload.capabilityEvidence)
+    ? payload.capabilityEvidence.filter(isCapabilityEvidenceClassification)
+    : []);
+}
+
+function isCapabilityEvidenceClassification(value: unknown): value is CapabilityEvidenceClassification {
+  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: CapabilityEvidenceClassification[]): CapabilityHealthProjection['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: SddTaskModel['tasks'], acceptedProfessionalEvidence: CapabilityEvidenceClassification[]): ProfessionalCapabilityDomain[] {
+  const required = releaseCriticalDomainsForTasks(tasks);
+  const acceptedEvidenceDomains = new Set(acceptedProfessionalEvidence.map((item) => item.domainOrSourceId));
+  return required.filter((domain) => !acceptedEvidenceDomains.has(domain));
+}
+
+function releaseCriticalDomainsForTasks(tasks: SddTaskModel['tasks']): ProfessionalCapabilityDomain[] {
+  const domains = new Set<ProfessionalCapabilityDomain>();
+  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 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.'];
+  }
+  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 ['Professional capability baseline and source policy are visible.'];
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === 'object';
+}
+
+function uniqueSorted<T extends string>(values: T[]): T[] {
+  return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+
 async function inspectTokenRuntimeProjection(projectRoot: string): Promise<TokenRuntimeProjection> {
   const projections = await listRuntimeProjections(projectRoot, ['context_build', 'team_runtime_decision']);
   const contextPackages = projections.filter((projection) => projection.projectionType === 'context_build');