sdd-agent-platform 0.4.1 → 0.5.0

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

@@ -1,625 +1,651 @@
-import { execFile } from 'node:child_process';
-import { stat } from 'node:fs/promises';
-import { promisify } from 'node:util';
-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 { 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 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);
-
-export interface RunEvidenceSummary {
-  agentExecutions: number;
-  teamSessions: number;
-  artifactIngestions: number;
-  workerRuntimes: number;
-  staleWorkerRuntimes: number;
-  routePreflight: boolean;
-  tasksChangedAfterRun: boolean;
-  tasksUpdatedAt: string | null;
-  runUpdatedAt: string | null;
-}
-
-export interface TaskRiskSummary {
-  highRiskTasks: string[];
-  mediumRiskTasks: string[];
-  sourceBoundaryTasks: string[];
-  contextRiskTasks: string[];
-  tokenRiskTasks: string[];
-  performanceRiskTasks: string[];
-}
-
-export interface TokenRuntimeProjection {
-  health: 'unknown' | 'nominal' | 'pressure';
-  estimatedTokens: number | null;
-  contextPackages: number;
-  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;
-  };
-  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';
-  context: ContextResolverContract;
-  gitRoot: string | null;
-  documents: SddTaskModel['documents'];
-  tasks: {
-    total: number;
-    pending: number;
-    inProgress: number;
-    completed: number;
-    blocked: number;
-    deferred: number;
-    unknown: number;
-    gaps: number;
-  };
-  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 {
-  contract: 'sdd-statusline-projection-v1';
-  branch: string;
-  workflow: ProjectStatus['workflowStatus'];
-  taskHealth: 'empty' | 'active' | 'blocked' | 'complete';
-  runtimeHealth: 'none' | 'pass' | 'warn' | 'blocked';
-  testHealth: 'none' | 'pass' | 'warn' | 'blocked';
-  teamHealth: 'none' | 'active';
-  tokenHealth: 'unknown' | 'nominal' | 'pressure';
-  contextLoad: ProjectStatus['contextRuntime']['level'];
-  contextAction: ProjectStatus['contextRuntime']['action'];
-  subagentHealth: ProjectStatus['subagentDispatches']['status'];
-  evidenceHealth: 'none' | 'pass' | 'warn' | 'blocked';
-  capabilityHealth: ProjectStatus['capabilityHealth']['status'];
-  latestRunId: string | null;
-  counts: {
-    tasks: ProjectStatus['tasks'];
-    agentExecutions: number;
-    teamSessions: number;
-    workerRuntimes: number;
-    staleWorkerRuntimes: number;
-    artifactIngestions: number;
-    staleReasons: number;
-    affectedFileConflicts: number;
-    subagentDispatches: number;
-    blockingSubagents: number;
-    capabilityWarnings: number;
-    durableGaps: number;
-    stageTeamSessions: number;
-    stageRoleResults: number;
-    advisorAssessments: number;
-    fanInEvidenceSets: number;
-    workflowGateDecisions: number;
-  };
-  taskRisk: TaskRiskSummary;
-  next: string;
-}
-
-export async function getProjectStatus(projectRoot: string, options: { branch?: string | null; branchSource?: ContextBranchSource } = {}): Promise<ProjectStatus> {
-  const [workflow, gitRoot] = await Promise.all([resolveWorkflowState(projectRoot, options), getGitRoot(projectRoot)]);
-  const latestRun = workflow.latestRun;
-  const latestRunState = workflow.latestRunState;
-  const latestRunEvidence = latestRun ? await inspectRunEvidenceSummary(projectRoot, latestRun.runId) : null;
-  const enrichedLatestRunEvidence = latestRun && latestRunEvidence
-    ? await addTaskDocumentStalenessToRunEvidence(workflow.model.tasksPath, latestRun, latestRunEvidence)
-    : latestRunEvidence;
-  const latestRunStaleReasons = latestRunState ? await runDocumentStaleReasons(projectRoot, 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 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,
-    workflowStatus: workflow.workflowStatus,
-    context: workflow.context,
-    gitRoot,
-    documents: workflow.documents,
-    tasks: workflow.taskCounts,
-    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,
-    capabilityHealth,
-    gaps: workflow.visibleGaps,
-    durableGaps,
-    stageTeamHealth,
-    workflowGateHealth
-  };
-}
-
-export async function getStatuslineProjection(projectRoot: string, options: { branch?: string | null; branchSource?: ContextBranchSource } = {}): Promise<StatuslineProjection> {
-  return statuslineProjectionFromStatus(await getProjectStatus(projectRoot, options));
-}
-
-export function statuslineProjectionFromStatus(status: ProjectStatus): StatuslineProjection {
-  const evidence = status.latestRunEvidence;
-  const runtimeHealth = status.latestRun
-    ? status.latestRun.status === 'completed' && status.latestRun.validationStatus === 'pass' ? 'pass' : 'blocked'
-    : 'none';
-  const staleReasons = status.latestRunStaleReasons.length;
-  const affectedFileConflicts = status.affectedFileConflicts.length;
-  return {
-    contract: 'sdd-statusline-projection-v1',
-    branch: status.branch,
-    workflow: status.workflowStatus,
-    taskHealth: taskHealth(status),
-    runtimeHealth,
-    testHealth: testHealth(status),
-    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,
-      agentExecutions: evidence?.agentExecutions ?? 0,
-      teamSessions: evidence?.teamSessions ?? 0,
-      workerRuntimes: evidence?.workerRuntimes ?? 0,
-      staleWorkerRuntimes: evidence?.staleWorkerRuntimes ?? 0,
-      artifactIngestions: evidence?.artifactIngestions ?? 0,
-      staleReasons,
-      affectedFileConflicts,
-      subagentDispatches: status.subagentDispatches.dispatches,
-      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 {
-    highRiskTasks: entries.filter(({ profile }) => profile.riskLevel === 'high').map(({ taskId }) => taskId).filter((taskId): taskId is string => Boolean(taskId)).sort(),
-    mediumRiskTasks: entries.filter(({ profile }) => profile.riskLevel === 'medium').map(({ taskId }) => taskId).filter((taskId): taskId is string => Boolean(taskId)).sort(),
-    sourceBoundaryTasks: entries.filter(({ profile }) => profile.sourceBoundary).map(({ taskId }) => taskId).filter((taskId): taskId is string => Boolean(taskId)).sort(),
-    contextRiskTasks: entries.filter(({ profile }) => profile.contextRisk).map(({ taskId }) => taskId).filter((taskId): taskId is string => Boolean(taskId)).sort(),
-    tokenRiskTasks: entries.filter(({ profile }) => profile.tokenRisk).map(({ taskId }) => taskId).filter((taskId): taskId is string => Boolean(taskId)).sort(),
-    performanceRiskTasks: entries.filter(({ profile }) => profile.performanceRisk).map(({ taskId }) => taskId).filter((taskId): taskId is string => Boolean(taskId)).sort()
-  };
-}
-
-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.durableGaps.some((gap) => gap.severity === 'blocking') || status.dependencyBlockers.length > 0) {
-    return 'blocked';
-  }
-  if (status.tasks.completed === status.tasks.total) {
-    return 'complete';
-  }
-  return 'active';
-}
-
-function testHealth(status: ProjectStatus): StatuslineProjection['testHealth'] {
-  if (!status.latestRun) {
-    return 'none';
-  }
-  if (status.latestRun.validationStatus === 'pass') {
-    return 'pass';
-  }
-  if (status.latestRun.validationStatus === 'pass_with_gaps') {
-    return 'warn';
-  }
-  return 'blocked';
-}
-
-function evidenceHealth(status: ProjectStatus, runtimeHealth: StatuslineProjection['runtimeHealth']): StatuslineProjection['evidenceHealth'] {
-  if (!status.latestRunEvidence) {
-    return 'none';
-  }
-  if (status.latestRunStaleReasons.length > 0 || status.affectedFileConflicts.length > 0 || status.latestRunEvidence.staleWorkerRuntimes > 0) {
-    return 'blocked';
-  }
-  if (runtimeHealth === 'blocked' || status.latestRunEvidence.tasksChangedAfterRun) {
-    return 'warn';
-  }
-  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');
-  const teamRuntimeDecisions = projections.filter((projection) => projection.projectionType === 'team_runtime_decision');
-  const contextTokenEstimates = contextPackages.map((projection) => tokenEstimateFromContextBuildPayload(projection.payload)).filter((value): value is number => value !== null);
-  const teamTokenEstimates = teamRuntimeDecisions.map((projection) => tokenEstimateFromTeamRuntimePayload(projection.payload)).filter((value): value is number => value !== null);
-  const estimatedTokens = [...contextTokenEstimates, ...teamTokenEstimates].reduce((total, value) => total + value, 0);
-  const pressureReasons = [
-    ...contextPackages.map((projection) => contextPressureReason(projection.payload)).filter((value): value is string => value !== null),
-    ...teamRuntimeDecisions.map((projection) => teamPressureReason(projection.payload)).filter((value): value is string => value !== null)
-  ];
-
-  return {
-    health: projections.length === 0 ? 'unknown' : pressureReasons.length > 0 ? 'pressure' : 'nominal',
-    estimatedTokens: projections.length === 0 ? null : estimatedTokens,
-    contextPackages: contextPackages.length,
-    teamRuntimeDecisions: teamRuntimeDecisions.length,
-    pressureReasons
-  };
-}
-
-function tokenEstimateFromContextBuildPayload(payload: unknown): number | null {
-  if (!payload || typeof payload !== 'object') {
-    return null;
-  }
-  const budget = (payload as { budget?: { estimatedTokens?: unknown } }).budget;
-  return typeof budget?.estimatedTokens === 'number' ? budget.estimatedTokens : null;
-}
-
-function tokenEstimateFromTeamRuntimePayload(payload: unknown): number | null {
-  if (!payload || typeof payload !== 'object') {
-    return null;
-  }
-  const decision = payload as { roleIds?: unknown; telemetryPolicy?: { contextBudget?: unknown } | null };
-  const roleCount = Array.isArray(decision.roleIds) ? decision.roleIds.length : 0;
-  const contextBudget = decision.telemetryPolicy?.contextBudget;
-  const perRole = contextBudget === 'medium' ? 3000 : contextBudget === 'small' ? 1200 : 600;
-  return roleCount * perRole;
-}
-
-function contextPressureReason(payload: unknown): string | null {
-  if (!payload || typeof payload !== 'object') {
-    return null;
-  }
-  const contextPackage = payload as { taskId?: unknown; profile?: unknown; budget?: { estimatedBytes?: unknown; maxBytes?: unknown } };
-  const estimatedBytes = contextPackage.budget?.estimatedBytes;
-  const maxBytes = contextPackage.budget?.maxBytes;
-  if (contextPackage.profile === 'brief') {
-    return null;
-  }
-  if (typeof estimatedBytes === 'number' && typeof maxBytes === 'number' && estimatedBytes >= maxBytes * 0.85) {
-    return `context_budget_pressure:${String(contextPackage.taskId ?? 'unknown')}`;
-  }
-  return null;
-}
-
-function teamPressureReason(payload: unknown): string | null {
-  if (!payload || typeof payload !== 'object') {
-    return null;
-  }
-  const decision = payload as { command?: unknown; mode?: unknown; roleIds?: unknown };
-  const roleCount = Array.isArray(decision.roleIds) ? decision.roleIds.length : 0;
-  if (decision.mode === 'team-required' || roleCount > 2) {
-    return `team_runtime_pressure:${String(decision.command ?? 'unknown')}`;
-  }
-  return null;
-}
-
-async function inspectRunEvidenceSummary(projectRoot: string, runId: string): Promise<RunEvidenceSummary> {
-  const [state, events, agentExecutions, teamSessions, workerRuntimeList] = await Promise.all([
-    readRunState(projectRoot, runId),
-    readRunEvents(projectRoot, runId),
-    listAgentExecutionRecords(projectRoot, runId),
-    listTeamSessionRecords(projectRoot, runId),
-    listResidentWorkerRuntimes(projectRoot, { runId })
-  ]);
-  return {
-    agentExecutions: agentExecutions.length,
-    teamSessions: teamSessions.length,
-    artifactIngestions: Object.keys(state.artifactIngestions ?? {}).length,
-    workerRuntimes: workerRuntimeList.runtimes.length,
-    staleWorkerRuntimes: workerRuntimeList.staleRuntimes,
-    routePreflight: events.some((event) => event.event === 'agent_router_preflight'),
-    tasksChangedAfterRun: false,
-    tasksUpdatedAt: null,
-    runUpdatedAt: state.updatedAt ?? null
-  };
-}
-
-async function addTaskDocumentStalenessToRunEvidence(tasksPath: string, latestRun: RunSummary, evidence: RunEvidenceSummary): Promise<RunEvidenceSummary> {
-  try {
-    const tasksStat = await stat(tasksPath);
-    const runUpdatedAtMs = Date.parse(latestRun.updatedAt);
-    if (Number.isNaN(runUpdatedAtMs)) {
-      return { ...evidence, runUpdatedAt: latestRun.updatedAt };
-    }
-    return {
-      ...evidence,
-      tasksChangedAfterRun: tasksStat.mtimeMs > runUpdatedAtMs,
-      tasksUpdatedAt: tasksStat.mtime.toISOString(),
-      runUpdatedAt: latestRun.updatedAt
-    };
-  } catch {
-    return { ...evidence, runUpdatedAt: latestRun.updatedAt };
-  }
-}
-
-async function getGitRoot(projectRoot: string): Promise<string | null> {
-  try {
-    const result = await execFileAsync('git', ['-C', projectRoot, 'rev-parse', '--show-toplevel']);
-    return result.stdout.trim();
-  } catch {
-    return null;
-  }
-}
+import { execFile } from 'node:child_process';
+import { stat } from 'node:fs/promises';
+import { promisify } from 'node:util';
+import type { ContextBranchSource, ContextResolverContract } from '../sdd-docs/context.js';
+import type { SddTaskGap, SddTaskModel } from '../sdd-docs/task-parser.js';
+import type { RunState, RunSummary } from '../run-state/model.js';
+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 { 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);
+
+export interface RunEvidenceSummary {
+  agentExecutions: number;
+  teamSessions: number;
+  artifactIngestions: number;
+  workerRuntimes: number;
+  staleWorkerRuntimes: number;
+  routePreflight: boolean;
+  tasksChangedAfterRun: boolean;
+  tasksUpdatedAt: string | null;
+  runUpdatedAt: string | null;
+}
+
+export interface TaskRiskSummary {
+  highRiskTasks: string[];
+  mediumRiskTasks: string[];
+  sourceBoundaryTasks: string[];
+  contextRiskTasks: string[];
+  tokenRiskTasks: string[];
+  performanceRiskTasks: string[];
+}
+
+export interface TokenRuntimeProjection {
+  health: 'unknown' | 'nominal' | 'pressure';
+  estimatedTokens: number | null;
+  contextPackages: number;
+  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;
+  };
+  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';
+  context: ContextResolverContract;
+  gitRoot: string | null;
+  documents: SddTaskModel['documents'];
+  tasks: {
+    total: number;
+    pending: number;
+    inProgress: number;
+    completed: number;
+    blocked: number;
+    deferred: number;
+    unknown: number;
+    gaps: number;
+  };
+  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 {
+  contract: 'sdd-statusline-projection-v1';
+  branch: string;
+  workflow: ProjectStatus['workflowStatus'];
+  taskHealth: 'empty' | 'active' | 'blocked' | 'complete';
+  runtimeHealth: 'none' | 'pass' | 'warn' | 'blocked';
+  testHealth: 'none' | 'pass' | 'warn' | 'blocked';
+  teamHealth: 'none' | 'active';
+  tokenHealth: 'unknown' | 'nominal' | 'pressure';
+  contextLoad: ProjectStatus['contextRuntime']['level'];
+  contextAction: ProjectStatus['contextRuntime']['action'];
+  subagentHealth: ProjectStatus['subagentDispatches']['status'];
+  evidenceHealth: 'none' | 'pass' | 'warn' | 'blocked';
+  capabilityHealth: ProjectStatus['capabilityHealth']['status'];
+  latestRunId: string | null;
+  counts: {
+    tasks: ProjectStatus['tasks'];
+    agentExecutions: number;
+    teamSessions: number;
+    workerRuntimes: number;
+    staleWorkerRuntimes: number;
+    artifactIngestions: number;
+    staleReasons: number;
+    affectedFileConflicts: number;
+    subagentDispatches: number;
+    blockingSubagents: number;
+    capabilityWarnings: number;
+    durableGaps: number;
+    stageTeamSessions: number;
+    stageRoleResults: number;
+    advisorAssessments: number;
+    fanInEvidenceSets: number;
+    workflowGateDecisions: number;
+  };
+  taskRisk: TaskRiskSummary;
+  next: string;
+}
+
+export async function getProjectStatus(projectRoot: string, options: { branch?: string | null; branchSource?: ContextBranchSource } = {}): Promise<ProjectStatus> {
+  const [workflow, gitRoot] = await Promise.all([resolveWorkflowState(projectRoot, options), getGitRoot(projectRoot)]);
+  const latestRun = workflow.latestRun;
+  const latestRunState = workflow.latestRunState;
+  const latestRunEvidence = latestRun ? await inspectRunEvidenceSummary(projectRoot, latestRun.runId) : null;
+  const enrichedLatestRunEvidence = latestRun && latestRunEvidence
+    ? await addTaskDocumentStalenessToRunEvidence(workflow.model.tasksPath, latestRun, latestRunEvidence)
+    : latestRunEvidence;
+  const latestRunStaleReasons = latestRunState ? await runDocumentStaleReasons(projectRoot, 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 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,
+    workflowStatus: workflow.workflowStatus,
+    context: workflow.context,
+    gitRoot,
+    documents: workflow.documents,
+    tasks: workflow.taskCounts,
+    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,
+    capabilityHealth,
+    gaps: workflow.visibleGaps,
+    durableGaps,
+    stageTeamHealth,
+    workflowGateHealth
+  };
+}
+
+export async function getStatuslineProjection(projectRoot: string, options: { branch?: string | null; branchSource?: ContextBranchSource } = {}): Promise<StatuslineProjection> {
+  return statuslineProjectionFromStatus(await getProjectStatus(projectRoot, options));
+}
+
+export function statuslineProjectionFromStatus(status: ProjectStatus): StatuslineProjection {
+  const evidence = status.latestRunEvidence;
+  const runtimeHealth = status.latestRun
+    ? status.latestRun.status === 'completed' && status.latestRun.validationStatus === 'pass' ? 'pass' : 'blocked'
+    : 'none';
+  const staleReasons = status.latestRunStaleReasons.length;
+  const affectedFileConflicts = status.affectedFileConflicts.length;
+  return {
+    contract: 'sdd-statusline-projection-v1',
+    branch: status.branch,
+    workflow: status.workflowStatus,
+    taskHealth: taskHealth(status),
+    runtimeHealth,
+    testHealth: testHealth(status),
+    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,
+      agentExecutions: evidence?.agentExecutions ?? 0,
+      teamSessions: evidence?.teamSessions ?? 0,
+      workerRuntimes: evidence?.workerRuntimes ?? 0,
+      staleWorkerRuntimes: evidence?.staleWorkerRuntimes ?? 0,
+      artifactIngestions: evidence?.artifactIngestions ?? 0,
+      staleReasons,
+      affectedFileConflicts,
+      subagentDispatches: status.subagentDispatches.dispatches,
+      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 {
+    highRiskTasks: entries.filter(({ profile }) => profile.riskLevel === 'high').map(({ taskId }) => taskId).filter((taskId): taskId is string => Boolean(taskId)).sort(),
+    mediumRiskTasks: entries.filter(({ profile }) => profile.riskLevel === 'medium').map(({ taskId }) => taskId).filter((taskId): taskId is string => Boolean(taskId)).sort(),
+    sourceBoundaryTasks: entries.filter(({ profile }) => profile.sourceBoundary).map(({ taskId }) => taskId).filter((taskId): taskId is string => Boolean(taskId)).sort(),
+    contextRiskTasks: entries.filter(({ profile }) => profile.contextRisk).map(({ taskId }) => taskId).filter((taskId): taskId is string => Boolean(taskId)).sort(),
+    tokenRiskTasks: entries.filter(({ profile }) => profile.tokenRisk).map(({ taskId }) => taskId).filter((taskId): taskId is string => Boolean(taskId)).sort(),
+    performanceRiskTasks: entries.filter(({ profile }) => profile.performanceRisk).map(({ taskId }) => taskId).filter((taskId): taskId is string => Boolean(taskId)).sort()
+  };
+}
+
+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.durableGaps.some((gap) => gap.severity === 'blocking') || status.dependencyBlockers.length > 0) {
+    return 'blocked';
+  }
+  if (status.tasks.completed === status.tasks.total) {
+    return 'complete';
+  }
+  return 'active';
+}
+
+function testHealth(status: ProjectStatus): StatuslineProjection['testHealth'] {
+  if (!status.latestRun) {
+    return 'none';
+  }
+  if (status.latestRun.validationStatus === 'pass') {
+    return 'pass';
+  }
+  if (status.latestRun.validationStatus === 'pass_with_gaps') {
+    return 'warn';
+  }
+  return 'blocked';
+}
+
+function evidenceHealth(status: ProjectStatus, runtimeHealth: StatuslineProjection['runtimeHealth']): StatuslineProjection['evidenceHealth'] {
+  if (!status.latestRunEvidence) {
+    return 'none';
+  }
+  if (status.latestRunStaleReasons.length > 0 || status.affectedFileConflicts.length > 0 || status.latestRunEvidence.staleWorkerRuntimes > 0) {
+    return 'blocked';
+  }
+  if (runtimeHealth === 'blocked' || status.latestRunEvidence.tasksChangedAfterRun) {
+    return 'warn';
+  }
+  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');
+  const teamRuntimeDecisions = projections.filter((projection) => projection.projectionType === 'team_runtime_decision');
+  const contextTokenEstimates = contextPackages.map((projection) => tokenEstimateFromContextBuildPayload(projection.payload)).filter((value): value is number => value !== null);
+  const teamTokenEstimates = teamRuntimeDecisions.map((projection) => tokenEstimateFromTeamRuntimePayload(projection.payload)).filter((value): value is number => value !== null);
+  const estimatedTokens = [...contextTokenEstimates, ...teamTokenEstimates].reduce((total, value) => total + value, 0);
+  const pressureReasons = [
+    ...contextPackages.map((projection) => contextPressureReason(projection.payload)).filter((value): value is string => value !== null),
+    ...teamRuntimeDecisions.map((projection) => teamPressureReason(projection.payload)).filter((value): value is string => value !== null)
+  ];
+
+  return {
+    health: projections.length === 0 ? 'unknown' : pressureReasons.length > 0 ? 'pressure' : 'nominal',
+    estimatedTokens: projections.length === 0 ? null : estimatedTokens,
+    contextPackages: contextPackages.length,
+    teamRuntimeDecisions: teamRuntimeDecisions.length,
+    pressureReasons
+  };
+}
+
+function tokenEstimateFromContextBuildPayload(payload: unknown): number | null {
+  if (!payload || typeof payload !== 'object') {
+    return null;
+  }
+  const budget = (payload as { budget?: { estimatedTokens?: unknown } }).budget;
+  return typeof budget?.estimatedTokens === 'number' ? budget.estimatedTokens : null;
+}
+
+function tokenEstimateFromTeamRuntimePayload(payload: unknown): number | null {
+  if (!payload || typeof payload !== 'object') {
+    return null;
+  }
+  const decision = payload as { roleIds?: unknown; telemetryPolicy?: { contextBudget?: unknown } | null };
+  const roleCount = Array.isArray(decision.roleIds) ? decision.roleIds.length : 0;
+  const contextBudget = decision.telemetryPolicy?.contextBudget;
+  const perRole = contextBudget === 'medium' ? 3000 : contextBudget === 'small' ? 1200 : 600;
+  return roleCount * perRole;
+}
+
+function contextPressureReason(payload: unknown): string | null {
+  if (!payload || typeof payload !== 'object') {
+    return null;
+  }
+  const contextPackage = payload as { taskId?: unknown; profile?: unknown; budget?: { estimatedBytes?: unknown; maxBytes?: unknown } };
+  const estimatedBytes = contextPackage.budget?.estimatedBytes;
+  const maxBytes = contextPackage.budget?.maxBytes;
+  if (contextPackage.profile === 'brief') {
+    return null;
+  }
+  if (typeof estimatedBytes === 'number' && typeof maxBytes === 'number' && estimatedBytes >= maxBytes * 0.85) {
+    return `context_budget_pressure:${String(contextPackage.taskId ?? 'unknown')}`;
+  }
+  return null;
+}
+
+function teamPressureReason(payload: unknown): string | null {
+  if (!payload || typeof payload !== 'object') {
+    return null;
+  }
+  const decision = payload as { command?: unknown; mode?: unknown; roleIds?: unknown };
+  const roleCount = Array.isArray(decision.roleIds) ? decision.roleIds.length : 0;
+  if (decision.mode === 'team-required' || roleCount > 2) {
+    return `team_runtime_pressure:${String(decision.command ?? 'unknown')}`;
+  }
+  return null;
+}
+
+async function inspectRunEvidenceSummary(projectRoot: string, runId: string): Promise<RunEvidenceSummary> {
+  const [state, events, agentExecutions, teamSessions, workerRuntimeList] = await Promise.all([
+    readRunState(projectRoot, runId),
+    readRunEvents(projectRoot, runId),
+    listAgentExecutionRecords(projectRoot, runId),
+    listTeamSessionRecords(projectRoot, runId),
+    listResidentWorkerRuntimes(projectRoot, { runId })
+  ]);
+  return {
+    agentExecutions: agentExecutions.length,
+    teamSessions: teamSessions.length,
+    artifactIngestions: Object.keys(state.artifactIngestions ?? {}).length,
+    workerRuntimes: workerRuntimeList.runtimes.length,
+    staleWorkerRuntimes: workerRuntimeList.staleRuntimes,
+    routePreflight: events.some((event) => event.event === 'agent_router_preflight'),
+    tasksChangedAfterRun: false,
+    tasksUpdatedAt: null,
+    runUpdatedAt: state.updatedAt ?? null
+  };
+}
+
+async function addTaskDocumentStalenessToRunEvidence(tasksPath: string, latestRun: RunSummary, evidence: RunEvidenceSummary): Promise<RunEvidenceSummary> {
+  try {
+    const tasksStat = await stat(tasksPath);
+    const runUpdatedAtMs = Date.parse(latestRun.updatedAt);
+    if (Number.isNaN(runUpdatedAtMs)) {
+      return { ...evidence, runUpdatedAt: latestRun.updatedAt };
+    }
+    return {
+      ...evidence,
+      tasksChangedAfterRun: tasksStat.mtimeMs > runUpdatedAtMs,
+      tasksUpdatedAt: tasksStat.mtime.toISOString(),
+      runUpdatedAt: latestRun.updatedAt
+    };
+  } catch {
+    return { ...evidence, runUpdatedAt: latestRun.updatedAt };
+  }
+}
+
+async function getGitRoot(projectRoot: string): Promise<string | null> {
+  try {
+    const result = await execFileAsync('git', ['-C', projectRoot, 'rev-parse', '--show-toplevel']);
+    return result.stdout.trim();
+  } catch {
+    return null;
+  }
+}
+
+async function runDocumentStaleReasons(_projectRoot: string, state: RunState, model: SddTaskModel): Promise<string[]> {
+  const reasons: string[] = [];
+  const snapshot = state.documentSnapshot;
+  if (!snapshot.specHash && !snapshot.planHash && !snapshot.tasksHash) {
+    reasons.push('Run has no document snapshot hashes; rerun execute before validation.');
+  }
+  appendDocumentHashMismatch(reasons, 'spec.md', snapshot.specHash, model.documents.specHash ?? null);
+  appendDocumentHashMismatch(reasons, 'plan.md', snapshot.planHash, model.documents.planHash ?? null);
+  appendDocumentHashMismatch(reasons, 'tasks.md', snapshot.tasksHash, model.documents.tasksHash ?? null);
+  if (model.documents.planStale) {
+    reasons.push('Current plan.md is stale against spec.md.');
+  }
+  if (model.documents.tasksStale) {
+    reasons.push('Current tasks.md is stale against plan.md or spec.md.');
+  }
+  return reasons;
+}
+
+function appendDocumentHashMismatch(reasons: string[], documentName: string, expected: string | null, actual: string | null): void {
+  if (!expected && !actual) {
+    return;
+  }
+  if (!expected || !actual || expected.replace(/^sha256:/, '') !== actual) {
+    reasons.push(`Run snapshot for ${documentName} is ${expected ?? 'missing'}, current hash is ${actual ?? 'missing'}.`);
+  }
+}