sdd-agent-platform 0.4.1 → 0.5.0

package/node_modules/@sdd-agent-platform/core/src/run-state/task-evidence.ts

@@ -1,206 +1,198 @@
-import { branchToSafePartition } from '../path-safety.js';
-import { listRuntimeAcceptanceEvidenceMaps, listRuntimeAgentExecutions, listRuntimeArtifactPayloads, listRuntimeDurableGaps, listRuntimeFanInEvidenceSets, listRuntimeLlmAdvisorAssessments, listRuntimeStageRoleResults, listRuntimeStageTeamSessions, listRuntimeSyncBackDecisions, listRuntimeTeamSessions, listRuntimeTestRuns, listRuntimeValidationEnvironmentSessions, listRuntimeValidationWaveRuns, listRuntimeWorkflowGateDecisions, listRuntimeWorkerRuntimes } from '../storage/runtime-store.js';
-import type { RuntimeAcceptanceEvidenceMapRecord, RuntimeArtifactPayloadRecord, RuntimeDurableGapRecord, RuntimeSyncBackDecisionRecord, RuntimeTestRunRecord, RuntimeValidationEnvironmentSessionRecord, RuntimeValidationWaveRunRecord } from '../storage/runtime-store.js';
-import type { AgentExecutionRecord, TeamSessionRecord } from '../router/agent-runtime.js';
-import type { ResidentWorkerRuntimeRecord } from '../execution/resident-worker.js';
-import type { FanInEvidenceSetRecord, LlmAdvisorAssessmentRecord, StageRoleResultRecord, StageTeamSessionRecord } from '../execution/stage-team-runtime.js';
-import type { WorkflowGateDecision } from '../workflow-gate/types.js';
-import type { RunState } from './model.js';
-import { resolveWorkflowState } from '../workflow-state/resolve.js';
-import type { LatestEligibleRunCandidate, LatestEligibleRunSelection } from '../workflow-state/latest-eligible-run.js';
-import type { SddTaskGap } from '../sdd-docs/task-parser.js';
-
-export const TASK_EVIDENCE_VIEW_CONTRACT_VERSION = 'phase-8.12-task-evidence-view-v1';
-
-export interface TaskEvidencePayloadGroups {
-  active: RuntimeArtifactPayloadRecord[];
-  candidate: RuntimeArtifactPayloadRecord[];
-  rejected: RuntimeArtifactPayloadRecord[];
-  superseded: RuntimeArtifactPayloadRecord[];
-  all: RuntimeArtifactPayloadRecord[];
-}
-
-export interface TaskEvidenceRuntimeActivity {
-  agentExecutions: AgentExecutionRecord[];
-  teamSessions: TeamSessionRecord[];
-  workerRuntimes: ResidentWorkerRuntimeRecord[];
-}
-
-export interface TaskEvidenceValidationView {
-  runValidation: RunState['validation'] | null;
-  testRuns: RuntimeTestRunRecord[];
-  validationWaves: RuntimeValidationWaveRunRecord[];
-  environmentSessions: RuntimeValidationEnvironmentSessionRecord[];
-  acceptanceEvidenceMaps: RuntimeAcceptanceEvidenceMapRecord[];
-}
-
-export interface TaskEvidenceStageTeamView {
-  sessions: StageTeamSessionRecord[];
-  roleResults: StageRoleResultRecord[];
-  advisorAssessments: LlmAdvisorAssessmentRecord[];
-  fanInEvidenceSets: FanInEvidenceSetRecord[];
-}
-
-export interface TaskEvidenceWorkflowGateView {
-  latestDecision: WorkflowGateDecision | null;
-  decisions: WorkflowGateDecision[];
-}
-
-export interface TaskEvidenceView {
-  contract: typeof TASK_EVIDENCE_VIEW_CONTRACT_VERSION;
-  generatedAt: string;
-  retrievalMemoryOnly: false;
-  source: 'runtime.sqlite+branch-evidence-payloads';
-  branch: string;
-  taskId: string;
-  latestEligibleRun: LatestEligibleRunCandidate | null;
-  candidates: LatestEligibleRunCandidate[];
-  rejected: LatestEligibleRunCandidate[];
-  compatibility: LatestEligibleRunCandidate['compatibility'] | null;
-  payloads: TaskEvidencePayloadGroups;
-  validation: TaskEvidenceValidationView;
-  syncBackDecision: RuntimeSyncBackDecisionRecord | null;
-  runtimeActivity: TaskEvidenceRuntimeActivity;
-  gaps: SddTaskGap[];
-  durableGaps: RuntimeDurableGapRecord[];
-  stageTeam: TaskEvidenceStageTeamView;
-  workflowGate: TaskEvidenceWorkflowGateView;
-}
-
-export async function readTaskEvidenceView(projectRoot: string, input: { branch?: string | null; taskId: string }): Promise<TaskEvidenceView> {
-  const workflow = await resolveWorkflowState(projectRoot, { branch: input.branch, branchSource: input.branch ? 'cli_option' : undefined, taskId: input.taskId });
-  const selection = workflow.latestEligibleRunsByTask.find((entry) => entry.taskId === input.taskId) ?? emptySelection(workflow.branch, input.taskId);
-  const selectedRunState = selection.selected?.runId === workflow.latestRunState?.runId ? workflow.latestRunState : null;
-  const runIds = uniqueRunIds(selection);
-  const payloads = await readTaskPayloads(projectRoot, workflow.branch, input.taskId, runIds);
-  const [testRuns, validationWaveEvidence, syncBackDecision, runtimeActivity, durableGaps, stageTeam, workflowGate] = selection.selected
-    ? await Promise.all([
-      listRuntimeTestRuns(projectRoot, selection.selected.runId),
-      readValidationWaveEvidence(projectRoot, workflow.branch, input.taskId, selection.selected.runId),
-      latestSyncBackDecision(projectRoot, selection.selected.runId),
-      readRuntimeActivity(projectRoot, selection.selected.runId),
-      listRuntimeDurableGaps(projectRoot, { partition: workflow.branch, taskId: input.taskId, status: 'open_terminal' }),
-      readStageTeamEvidence(projectRoot, workflow.branch, input.taskId, selection.selected.runId),
-      readWorkflowGateEvidence(projectRoot, workflow.branch, input.taskId, selection.selected.runId)
-    ])
-    : await Promise.all([
-      Promise.resolve([]),
-      readValidationWaveEvidence(projectRoot, workflow.branch, input.taskId, null),
-      Promise.resolve(null),
-      Promise.resolve(emptyRuntimeActivity()),
-      listRuntimeDurableGaps(projectRoot, { partition: workflow.branch, taskId: input.taskId, status: 'open_terminal' }),
-      readStageTeamEvidence(projectRoot, workflow.branch, input.taskId, null),
-      readWorkflowGateEvidence(projectRoot, workflow.branch, input.taskId, null)
-    ]);
-
-  const [validationWaves, environmentSessions, acceptanceEvidenceMaps] = validationWaveEvidence;
-  return {
-    contract: TASK_EVIDENCE_VIEW_CONTRACT_VERSION,
-    generatedAt: new Date().toISOString(),
-    retrievalMemoryOnly: false,
-    source: 'runtime.sqlite+branch-evidence-payloads',
-    branch: workflow.branch,
-    taskId: input.taskId,
-    latestEligibleRun: selection.selected,
-    candidates: selection.candidates,
-    rejected: selection.rejected,
-    compatibility: selection.selected?.compatibility ?? null,
-    payloads,
-    validation: {
-      runValidation: selectedRunState?.validation ?? null,
-      testRuns: testRuns.filter((run) => run.taskId === input.taskId),
-      validationWaves,
-      environmentSessions,
-      acceptanceEvidenceMaps
-    },
-    syncBackDecision,
-    runtimeActivity,
-    gaps: [...workflow.visibleGaps.filter((gap) => gap.taskId === input.taskId || gap.taskId === null), ...runtimeTaskGaps(selectedRunState?.tasks[input.taskId])],
-    durableGaps,
-    stageTeam,
-    workflowGate
-  };
-}
-
-function emptySelection(partition: string, taskId: string): LatestEligibleRunSelection {
-  return { partition, taskId, selected: null, candidates: [], rejected: [] };
-}
-
-function uniqueRunIds(selection: LatestEligibleRunSelection): string[] {
-  return Array.from(new Set([...selection.candidates, ...selection.rejected].map((candidate) => candidate.runId)));
-}
-
-async function readTaskPayloads(projectRoot: string, branch: string, taskId: string, runIds: string[]): Promise<TaskEvidencePayloadGroups> {
-  const payloads = runIds.length > 0
-    ? (await Promise.all(runIds.map((runId) => listRuntimeArtifactPayloads(projectRoot, { runId, taskId })))).flat()
-    : await listRuntimeArtifactPayloads(projectRoot, { branchSlug: branchToSafePartition(branch), taskId });
-  return {
-    active: payloads.filter((payload) => payload.status === 'active'),
-    candidate: payloads.filter((payload) => payload.status === 'candidate'),
-    rejected: payloads.filter((payload) => payload.status === 'rejected'),
-    superseded: payloads.filter((payload) => payload.status === 'superseded'),
-    all: payloads
-  };
-}
-
-async function readValidationWaveEvidence(projectRoot: string, partition: string, taskId: string, runId: string | null): Promise<[RuntimeValidationWaveRunRecord[], RuntimeValidationEnvironmentSessionRecord[], RuntimeAcceptanceEvidenceMapRecord[]]> {
-  const query = runId ? { partition, runId, taskId } : { partition, taskId };
-  const validationWaves = await listRuntimeValidationWaveRuns(projectRoot, query);
-  const waveRunIds = validationWaves.map((wave) => wave.waveRunId);
-  const [environmentSessions, acceptanceEvidenceMaps] = await Promise.all([
-    Promise.all(waveRunIds.map((waveRunId) => listRuntimeValidationEnvironmentSessions(projectRoot, { partition, waveRunId }))).then((items) => items.flat()),
-    Promise.all(waveRunIds.map((waveRunId) => listRuntimeAcceptanceEvidenceMaps(projectRoot, { partition, taskId, waveRunId }))).then((items) => items.flat())
-  ]);
-  return [validationWaves, environmentSessions, acceptanceEvidenceMaps];
-}
-
-async function latestSyncBackDecision(projectRoot: string, runId: string): Promise<RuntimeSyncBackDecisionRecord | null> {
-  const decisions = await listRuntimeSyncBackDecisions(projectRoot, runId);
-  return decisions[0] ?? null;
-}
-
-async function readRuntimeActivity(projectRoot: string, runId: string): Promise<TaskEvidenceRuntimeActivity> {
-  const [agentExecutions, teamSessions, workerRuntimes] = await Promise.all([
-    listRuntimeAgentExecutions(projectRoot, runId),
-    listRuntimeTeamSessions(projectRoot, runId),
-    listRuntimeWorkerRuntimes(projectRoot, runId)
-  ]);
-  return { agentExecutions, teamSessions, workerRuntimes };
-}
-
-async function readStageTeamEvidence(projectRoot: string, partition: string, taskId: string, runId: string | null): Promise<TaskEvidenceStageTeamView> {
-  const query = runId ? { partition, taskId, runId } : { partition, taskId };
-  const [sessions, roleResults, advisorAssessments, fanInEvidenceSets] = await Promise.all([
-    listRuntimeStageTeamSessions(projectRoot, query),
-    listRuntimeStageRoleResults(projectRoot, query),
-    listRuntimeLlmAdvisorAssessments(projectRoot, query),
-    listRuntimeFanInEvidenceSets(projectRoot, query)
-  ]);
-  return { sessions, roleResults, advisorAssessments, fanInEvidenceSets };
-}
-
-async function readWorkflowGateEvidence(projectRoot: string, partition: string, taskId: string, runId: string | null): Promise<TaskEvidenceWorkflowGateView> {
-  const query = runId ? { partition, taskId, runId } : { partition, taskId };
-  const decisions = await listRuntimeWorkflowGateDecisions(projectRoot, query);
-  return { latestDecision: decisions[0] ?? null, decisions };
-}
-
-function emptyRuntimeActivity(): TaskEvidenceRuntimeActivity {
-  return { agentExecutions: [], teamSessions: [], workerRuntimes: [] };
-}
-
-function runtimeTaskGaps(taskState: unknown): SddTaskGap[] {
-  if (!taskState || typeof taskState !== 'object' || !('gaps' in taskState)) {
-    return [];
-  }
-  const gaps = (taskState as { gaps?: unknown }).gaps;
-  return Array.isArray(gaps) ? gaps.filter(isTaskGap) : [];
-}
-
-function isTaskGap(value: unknown): value is SddTaskGap {
-  if (!value || typeof value !== 'object') {
-    return false;
-  }
-  const gap = value as Partial<SddTaskGap>;
-  return typeof gap.type === 'string' && typeof gap.severity === 'string' && typeof gap.field === 'string' && typeof gap.message === 'string' && typeof gap.recommendation === 'string';
-}
+import { branchToSafePartition } from '../path-safety.js';
+import { listRuntimeAcceptanceEvidenceMaps, listRuntimeAgentExecutions, listRuntimeArtifactPayloads, listRuntimeDurableGaps, listRuntimeFanInEvidenceSets, listRuntimeLlmAdvisorAssessments, listRuntimeStageRoleResults, listRuntimeStageTeamSessions, listRuntimeTeamSessions, listRuntimeTestRuns, listRuntimeValidationEnvironmentSessions, listRuntimeValidationWaveRuns, listRuntimeWorkflowGateDecisions, listRuntimeWorkerRuntimes } from '../storage/runtime-store.js';
+import type { RuntimeAcceptanceEvidenceMapRecord, RuntimeArtifactPayloadRecord, RuntimeDurableGapRecord, RuntimeTestRunRecord, RuntimeValidationEnvironmentSessionRecord, RuntimeValidationWaveRunRecord } from '../storage/runtime-store.js';
+import type { AgentExecutionRecord, TeamSessionRecord } from '../router/agent-runtime.js';
+import type { ResidentWorkerRuntimeRecord } from '../execution/resident-worker.js';
+import type { FanInEvidenceSetRecord, LlmAdvisorAssessmentRecord, StageRoleResultRecord, StageTeamSessionRecord } from '../execution/stage-team-runtime.js';
+import type { WorkflowGateDecision } from '../workflow-gate/types.js';
+import type { RunState } from './model.js';
+import { resolveWorkflowState } from '../workflow-state/resolve.js';
+import type { LatestEligibleRunCandidate, LatestEligibleRunSelection } from '../workflow-state/latest-eligible-run.js';
+import type { SddTaskGap } from '../sdd-docs/task-parser.js';
+
+export const TASK_EVIDENCE_VIEW_CONTRACT_VERSION = 'phase-8.12-task-evidence-view-v1';
+
+export interface TaskEvidencePayloadGroups {
+  active: RuntimeArtifactPayloadRecord[];
+  candidate: RuntimeArtifactPayloadRecord[];
+  rejected: RuntimeArtifactPayloadRecord[];
+  superseded: RuntimeArtifactPayloadRecord[];
+  all: RuntimeArtifactPayloadRecord[];
+}
+
+export interface TaskEvidenceRuntimeActivity {
+  agentExecutions: AgentExecutionRecord[];
+  teamSessions: TeamSessionRecord[];
+  workerRuntimes: ResidentWorkerRuntimeRecord[];
+}
+
+export interface TaskEvidenceValidationView {
+  runValidation: RunState['validation'] | null;
+  testRuns: RuntimeTestRunRecord[];
+  validationWaves: RuntimeValidationWaveRunRecord[];
+  environmentSessions: RuntimeValidationEnvironmentSessionRecord[];
+  acceptanceEvidenceMaps: RuntimeAcceptanceEvidenceMapRecord[];
+}
+
+export interface TaskEvidenceStageTeamView {
+  sessions: StageTeamSessionRecord[];
+  roleResults: StageRoleResultRecord[];
+  advisorAssessments: LlmAdvisorAssessmentRecord[];
+  fanInEvidenceSets: FanInEvidenceSetRecord[];
+}
+
+export interface TaskEvidenceWorkflowGateView {
+  latestDecision: WorkflowGateDecision | null;
+  decisions: WorkflowGateDecision[];
+}
+
+export interface TaskEvidenceView {
+  contract: typeof TASK_EVIDENCE_VIEW_CONTRACT_VERSION;
+  generatedAt: string;
+  retrievalMemoryOnly: false;
+  source: 'runtime.sqlite+branch-evidence-payloads';
+  branch: string;
+  taskId: string;
+  latestEligibleRun: LatestEligibleRunCandidate | null;
+  candidates: LatestEligibleRunCandidate[];
+  rejected: LatestEligibleRunCandidate[];
+  compatibility: LatestEligibleRunCandidate['compatibility'] | null;
+  payloads: TaskEvidencePayloadGroups;
+  validation: TaskEvidenceValidationView;
+  runtimeActivity: TaskEvidenceRuntimeActivity;
+  gaps: SddTaskGap[];
+  durableGaps: RuntimeDurableGapRecord[];
+  stageTeam: TaskEvidenceStageTeamView;
+  workflowGate: TaskEvidenceWorkflowGateView;
+}
+
+export async function readTaskEvidenceView(projectRoot: string, input: { branch?: string | null; taskId: string }): Promise<TaskEvidenceView> {
+  const workflow = await resolveWorkflowState(projectRoot, { branch: input.branch, branchSource: input.branch ? 'cli_option' : undefined, taskId: input.taskId });
+  const selection = workflow.latestEligibleRunsByTask.find((entry) => entry.taskId === input.taskId) ?? emptySelection(workflow.branch, input.taskId);
+  const selectedRunState = selection.selected?.runId === workflow.latestRunState?.runId ? workflow.latestRunState : null;
+  const runIds = uniqueRunIds(selection);
+  const payloads = await readTaskPayloads(projectRoot, workflow.branch, input.taskId, runIds);
+  const [testRuns, validationWaveEvidence, runtimeActivity, durableGaps, stageTeam, workflowGate] = selection.selected
+    ? await Promise.all([
+      listRuntimeTestRuns(projectRoot, selection.selected.runId),
+      readValidationWaveEvidence(projectRoot, workflow.branch, input.taskId, selection.selected.runId),
+      readRuntimeActivity(projectRoot, selection.selected.runId),
+      listRuntimeDurableGaps(projectRoot, { partition: workflow.branch, taskId: input.taskId, status: 'open_terminal' }),
+      readStageTeamEvidence(projectRoot, workflow.branch, input.taskId, selection.selected.runId),
+      readWorkflowGateEvidence(projectRoot, workflow.branch, input.taskId, selection.selected.runId)
+    ])
+    : await Promise.all([
+      Promise.resolve([]),
+      readValidationWaveEvidence(projectRoot, workflow.branch, input.taskId, null),
+      Promise.resolve(emptyRuntimeActivity()),
+      listRuntimeDurableGaps(projectRoot, { partition: workflow.branch, taskId: input.taskId, status: 'open_terminal' }),
+      readStageTeamEvidence(projectRoot, workflow.branch, input.taskId, null),
+      readWorkflowGateEvidence(projectRoot, workflow.branch, input.taskId, null)
+    ]);
+
+  const [validationWaves, environmentSessions, acceptanceEvidenceMaps] = validationWaveEvidence;
+  return {
+    contract: TASK_EVIDENCE_VIEW_CONTRACT_VERSION,
+    generatedAt: new Date().toISOString(),
+    retrievalMemoryOnly: false,
+    source: 'runtime.sqlite+branch-evidence-payloads',
+    branch: workflow.branch,
+    taskId: input.taskId,
+    latestEligibleRun: selection.selected,
+    candidates: selection.candidates,
+    rejected: selection.rejected,
+    compatibility: selection.selected?.compatibility ?? null,
+    payloads,
+    validation: {
+      runValidation: selectedRunState?.validation ?? null,
+      testRuns: testRuns.filter((run) => run.taskId === input.taskId),
+      validationWaves,
+      environmentSessions,
+      acceptanceEvidenceMaps
+    },
+    runtimeActivity,
+    gaps: [...workflow.visibleGaps.filter((gap) => gap.taskId === input.taskId || gap.taskId === null), ...runtimeTaskGaps(selectedRunState?.tasks[input.taskId])],
+    durableGaps,
+    stageTeam,
+    workflowGate
+  };
+}
+
+function emptySelection(partition: string, taskId: string): LatestEligibleRunSelection {
+  return { partition, taskId, selected: null, candidates: [], rejected: [] };
+}
+
+function uniqueRunIds(selection: LatestEligibleRunSelection): string[] {
+  return Array.from(new Set([...selection.candidates, ...selection.rejected].map((candidate) => candidate.runId)));
+}
+
+async function readTaskPayloads(projectRoot: string, branch: string, taskId: string, runIds: string[]): Promise<TaskEvidencePayloadGroups> {
+  const payloads = runIds.length > 0
+    ? (await Promise.all(runIds.map((runId) => listRuntimeArtifactPayloads(projectRoot, { runId, taskId })))).flat()
+    : await listRuntimeArtifactPayloads(projectRoot, { branchSlug: branchToSafePartition(branch), taskId });
+  return {
+    active: payloads.filter((payload) => payload.status === 'active'),
+    candidate: payloads.filter((payload) => payload.status === 'candidate'),
+    rejected: payloads.filter((payload) => payload.status === 'rejected'),
+    superseded: payloads.filter((payload) => payload.status === 'superseded'),
+    all: payloads
+  };
+}
+
+async function readValidationWaveEvidence(projectRoot: string, partition: string, taskId: string, runId: string | null): Promise<[RuntimeValidationWaveRunRecord[], RuntimeValidationEnvironmentSessionRecord[], RuntimeAcceptanceEvidenceMapRecord[]]> {
+  const query = runId ? { partition, runId, taskId } : { partition, taskId };
+  const validationWaves = await listRuntimeValidationWaveRuns(projectRoot, query);
+  const waveRunIds = validationWaves.map((wave) => wave.waveRunId);
+  const [environmentSessions, acceptanceEvidenceMaps] = await Promise.all([
+    Promise.all(waveRunIds.map((waveRunId) => listRuntimeValidationEnvironmentSessions(projectRoot, { partition, waveRunId }))).then((items) => items.flat()),
+    Promise.all(waveRunIds.map((waveRunId) => listRuntimeAcceptanceEvidenceMaps(projectRoot, { partition, taskId, waveRunId }))).then((items) => items.flat())
+  ]);
+  return [validationWaves, environmentSessions, acceptanceEvidenceMaps];
+}
+
+
+async function readRuntimeActivity(projectRoot: string, runId: string): Promise<TaskEvidenceRuntimeActivity> {
+  const [agentExecutions, teamSessions, workerRuntimes] = await Promise.all([
+    listRuntimeAgentExecutions(projectRoot, runId),
+    listRuntimeTeamSessions(projectRoot, runId),
+    listRuntimeWorkerRuntimes(projectRoot, runId)
+  ]);
+  return { agentExecutions, teamSessions, workerRuntimes };
+}
+
+async function readStageTeamEvidence(projectRoot: string, partition: string, taskId: string, runId: string | null): Promise<TaskEvidenceStageTeamView> {
+  const query = runId ? { partition, taskId, runId } : { partition, taskId };
+  const [sessions, roleResults, advisorAssessments, fanInEvidenceSets] = await Promise.all([
+    listRuntimeStageTeamSessions(projectRoot, query),
+    listRuntimeStageRoleResults(projectRoot, query),
+    listRuntimeLlmAdvisorAssessments(projectRoot, query),
+    listRuntimeFanInEvidenceSets(projectRoot, query)
+  ]);
+  return { sessions, roleResults, advisorAssessments, fanInEvidenceSets };
+}
+
+async function readWorkflowGateEvidence(projectRoot: string, partition: string, taskId: string, runId: string | null): Promise<TaskEvidenceWorkflowGateView> {
+  const query = runId ? { partition, taskId, runId } : { partition, taskId };
+  const decisions = await listRuntimeWorkflowGateDecisions(projectRoot, query);
+  return { latestDecision: decisions[0] ?? null, decisions };
+}
+
+function emptyRuntimeActivity(): TaskEvidenceRuntimeActivity {
+  return { agentExecutions: [], teamSessions: [], workerRuntimes: [] };
+}
+
+function runtimeTaskGaps(taskState: unknown): SddTaskGap[] {
+  if (!taskState || typeof taskState !== 'object' || !('gaps' in taskState)) {
+    return [];
+  }
+  const gaps = (taskState as { gaps?: unknown }).gaps;
+  return Array.isArray(gaps) ? gaps.filter(isTaskGap) : [];
+}
+
+function isTaskGap(value: unknown): value is SddTaskGap {
+  if (!value || typeof value !== 'object') {
+    return false;
+  }
+  const gap = value as Partial<SddTaskGap>;
+  return typeof gap.type === 'string' && typeof gap.severity === 'string' && typeof gap.field === 'string' && typeof gap.message === 'string' && typeof gap.recommendation === 'string';
+}

package/node_modules/@sdd-agent-platform/core/src/run-state/timing.ts

@@ -0,0 +1,146 @@
+import type { RuntimeTestRunRecord, RuntimeTestStepRecord } from '../storage/runtime-store.js';
+import type { RunDurationBreakdown, RunDurationContributor, RunState, RuntimeEvent } from './model.js';
+
+export type RunDurationContributorKind = RunDurationContributor['kind'];
+
+const MIN_CONTRIBUTOR_MS = 1_000;
+
+export function buildRunDurationBreakdown(state: RunState, input: { events?: RuntimeEvent[]; testRuns?: RuntimeTestRunRecord[]; testSteps?: RuntimeTestStepRecord[] } = {}): RunDurationBreakdown {
+  const elapsedDurationMs = durationBetween(state.createdAt, state.updatedAt);
+  const eventContributors = classifyEventGaps(input.events ?? []);
+  const validationContributors = validationDurationContributors(input.testRuns ?? [], input.testSteps ?? []);
+  const contributors = [...eventContributors, ...validationContributors].sort((left, right) => right.durationMs - left.durationMs);
+  const validationDurationMs = sumByKind(contributors, 'validation');
+  const blockedDurationMs = sumByKind(contributors, 'blocked');
+  const queueOrBindDurationMs = sumByKind(contributors, 'queue_or_bind');
+  const unknownGapDurationMs = sumByKind(contributors, 'unknown_gap');
+  const hostWaitingDurationMs = sumByKind(contributors, 'host_waiting');
+  const waitingDurationMs = queueOrBindDurationMs + unknownGapDurationMs + hostWaitingDurationMs;
+  const activeRuntimeDurationMs = Math.max(0, elapsedDurationMs - waitingDurationMs - blockedDurationMs - validationDurationMs);
+  const topContributors = contributors.slice(0, 3);
+  return {
+    elapsedDurationMs,
+    activeRuntimeDurationMs,
+    validationDurationMs,
+    waitingDurationMs,
+    blockedDurationMs,
+    queueOrBindDurationMs,
+    unknownGapDurationMs,
+    hostWaitingDurationMs,
+    slowReason: topContributors[0]?.kind ?? (elapsedDurationMs > 0 ? 'active_runtime' : 'none'),
+    topContributors
+  };
+}
+
+function classifyEventGaps(events: RuntimeEvent[]): RunDurationContributor[] {
+  const sorted = [...events].sort((left, right) => Date.parse(left.time) - Date.parse(right.time));
+  const contributors: RunDurationContributor[] = [];
+  for (let index = 0; index < sorted.length - 1; index += 1) {
+    const current = sorted[index];
+    const next = sorted[index + 1];
+    const durationMs = durationBetween(current.time, next.time);
+    if (durationMs < MIN_CONTRIBUTOR_MS) {
+      continue;
+    }
+    const kind = classifyGap(current, next);
+    contributors.push({
+      kind,
+      durationMs,
+      startedAt: current.time,
+      endedAt: next.time,
+      reason: gapReason(kind, current, next),
+      refs: [current.event, next.event]
+    });
+  }
+  return contributors;
+}
+
+function validationDurationContributors(testRuns: RuntimeTestRunRecord[], testSteps: RuntimeTestStepRecord[]): RunDurationContributor[] {
+  if (testSteps.length > 0) {
+    return testSteps
+      .filter((step) => step.durationMs >= MIN_CONTRIBUTOR_MS)
+      .map((step) => {
+        const refs = step.outputArtifact ? [step.stepId, step.outputArtifact] : [step.stepId];
+        return {
+          kind: 'validation' as const,
+          durationMs: step.durationMs,
+          startedAt: stringPayload(step.payload, 'startedAt') ?? '',
+          endedAt: stringPayload(step.payload, 'endedAt') ?? '',
+          reason: `validation command ${step.command}`,
+          refs
+        };
+      });
+  }
+  return testRuns
+    .map((run) => ({ run, durationMs: durationBetween(run.startedAt, run.completedAt) }))
+    .filter((entry) => entry.durationMs >= MIN_CONTRIBUTOR_MS)
+    .map((entry) => ({
+      kind: 'validation' as const,
+      durationMs: entry.durationMs,
+      startedAt: entry.run.startedAt,
+      endedAt: entry.run.completedAt,
+      reason: `validation test run ${entry.run.testRunId}`,
+      refs: [entry.run.testRunId]
+    }));
+}
+
+function classifyGap(current: RuntimeEvent, next: RuntimeEvent): RunDurationContributorKind {
+  if (current.event === 'lifecycle_decision_recorded' && next.event === 'run_context_bound') {
+    return 'queue_or_bind';
+  }
+  if (mentionsValidation(current) || mentionsValidation(next)) {
+    return 'validation';
+  }
+  if (mentionsBlocked(current) || mentionsBlocked(next)) {
+    return 'blocked';
+  }
+  if (mentionsHostWait(current)) {
+    return 'host_waiting';
+  }
+  return 'unknown_gap';
+}
+
+function gapReason(kind: RunDurationContributorKind, current: RuntimeEvent, next: RuntimeEvent): string {
+  if (kind === 'queue_or_bind') {
+    return 'gap between lifecycle decision and run context bind';
+  }
+  if (kind === 'validation') {
+    return 'gap around validation runtime events';
+  }
+  if (kind === 'blocked') {
+    return 'gap around blocked or gate terminal events';
+  }
+  if (kind === 'host_waiting') {
+    return 'gap after host invocation activity without runtime output';
+  }
+  return `gap between ${current.event} and ${next.event}`;
+}
+
+function mentionsValidation(event: RuntimeEvent): boolean {
+  return event.event.includes('test') || event.event.includes('validation');
+}
+
+function mentionsBlocked(event: RuntimeEvent): boolean {
+  const status = typeof event.data?.status === 'string' ? event.data.status.toLowerCase() : '';
+  return event.event.includes('blocked') || event.event.includes('gate') || status === 'blocked' || status === 'failed';
+}
+
+function mentionsHostWait(event: RuntimeEvent): boolean {
+  return event.event.includes('invocation') || event.event.includes('agent') || event.event.includes('delegation');
+}
+
+function sumByKind(contributors: RunDurationContributor[], kind: RunDurationContributorKind): number {
+  return contributors.filter((contributor) => contributor.kind === kind).reduce((sum, contributor) => sum + contributor.durationMs, 0);
+}
+
+function durationBetween(startedAt: string, endedAt: string): number {
+  const start = Date.parse(startedAt);
+  const end = Date.parse(endedAt);
+  return Number.isFinite(start) && Number.isFinite(end) ? Math.max(0, end - start) : 0;
+}
+
+function stringPayload(payload: unknown, key: string): string | null {
+  return payload && typeof payload === 'object' && key in payload && typeof (payload as Record<string, unknown>)[key] === 'string'
+    ? String((payload as Record<string, unknown>)[key])
+    : null;
+}

package/node_modules/@sdd-agent-platform/core/src/run-state.ts

@@ -1,8 +1,8 @@
-export * from './run-state/artifacts.js';
-export * from './run-state/events.js';
-export * from './run-state/inspect-run.js';
-export * from './run-state/invocation-ledger.js';
-export * from './run-state/model.js';
-export * from './run-state/run-index.js';
-export * from './run-state/run-state.js';
-export * from './run-state/task-evidence.js';
+export * from './run-state/artifacts.js';
+export * from './run-state/events.js';
+export * from './run-state/inspect-run.js';
+export * from './run-state/invocation-ledger.js';
+export * from './run-state/model.js';
+export * from './run-state/run-index.js';
+export * from './run-state/run-state.js';
+export * from './run-state/task-evidence.js';