sdd-agent-platform 0.4.1 → 0.5.0

package/node_modules/@sdd-agent-platform/core/src/workflow-gate/evidence-packet.ts

@@ -1,196 +1,190 @@
-import { createHash } from 'node:crypto';
-import { readFile } from 'node:fs/promises';
-import { WORKFLOW_GATE_RUNTIME_CONTRACT_VERSION } from '../contracts.js';
-import { listRuntimeArtifactPayloads, listRuntimeDurableGaps, listRuntimeFanInEvidenceSets, listRuntimeLlmAdvisorAssessments, listRuntimeSyncBackDecisions, recordRuntimeWorkflowGateDecision, runtimeScopedId, type RuntimeArtifactPayloadRecord } from '../storage/runtime-store.js';
-import { getEvidenceAttachmentPath } from '../runtime-paths.js';
-import { readAllRunStates } from '../run-state/run-state.js';
-import { affectedFileConflictsForSelectedRuns } from '../workflow-state/affected-file-conflicts.js';
-import { resolveWorkflowState } from '../workflow-state/resolve.js';
-import { evaluateWorkflowGateHardChecks } from './hard-checks.js';
-import { synthesizeWorkflowGateDecision } from './policy.js';
-import type { WorkflowGateDecision, WorkflowGateDecisionKind, WorkflowGateEvidencePacket } from './types.js';
-
-export async function buildWorkflowGateEvidencePacket(projectRoot: string, input: { branch?: string | null; taskId?: string | null; runId?: string | null; decisionKind: WorkflowGateDecisionKind; waveRunId?: string | null; taskIds?: string[]; runIds?: string[]; evidenceRefs?: string[] }): Promise<WorkflowGateEvidencePacket> {
-  const workflow = await resolveWorkflowState(projectRoot, { branch: input.branch, branchSource: input.branch ? 'cli_option' : undefined, taskId: input.taskId ?? null });
-  const taskId = input.taskId ?? workflow.latestRun?.taskId ?? workflow.model.tasks[0]?.id ?? null;
-  const selection = taskId ? workflow.latestEligibleRunsByTask.find((candidate) => candidate.taskId === taskId) ?? null : null;
-  const runId = input.runId ?? selection?.selected?.runId ?? workflow.latestRun?.runId ?? null;
-  const scopedTaskIds = sortedUnique(input.taskIds ?? (taskId ? [taskId] : []));
-  const scopedLatestEligibleSelections = scopedTaskIds.length > 0
-    ? scopedTaskIds.map((scopedTaskId) => workflow.latestEligibleRunsByTask.find((candidate) => candidate.taskId === scopedTaskId) ?? emptyLatestEligibleSelection(workflow.branch, scopedTaskId))
-    : (selection ? [selection] : []);
-  const scopedRunIds = sortedUnique(input.runIds ?? scopedLatestEligibleSelections.flatMap((candidate) => candidate.selected ? [candidate.selected.runId] : []));
-  const workflowScope = {
-    waveRunId: input.waveRunId ?? null,
-    taskIds: scopedTaskIds,
-    runIds: scopedRunIds.length > 0 ? scopedRunIds : sortedUnique(runId ? [runId] : []),
-    evidenceRefs: sortedUnique(input.evidenceRefs ?? [])
-  };
-  const scopedTasks = workflowScope.taskIds.length > 0
-    ? workflow.model.tasks.filter((candidate) => workflowScope.taskIds.includes(candidate.id))
-    : workflow.model.tasks.filter((candidate) => candidate.id === taskId);
-  const runtimeInputs = await loadRuntimeGateInputs(projectRoot, workflow.branch, workflowScope.taskIds, workflowScope.runIds);
-  const scopedAffectedFileConflicts = await loadScopedAffectedFileConflicts(projectRoot, workflow.affectedFileConflicts, workflowScope.runIds);
-  const packetBase = {
-    packetId: runtimeScopedId(WORKFLOW_GATE_RUNTIME_CONTRACT_VERSION, workflow.branch, taskId ?? 'none', runId ?? 'none', input.decisionKind),
-    generatedAt: new Date().toISOString(),
-    decisionKind: input.decisionKind,
-    partition: workflow.branch,
-    taskId,
-    runId,
-    documents: workflow.documents,
-    latestEligibleSelection: selection,
-    latestEligibleSelections: scopedLatestEligibleSelections,
-    workflowScope,
-    runtimeHealth: runtimeInputs.runtimeHealth,
-    durableGaps: runtimeInputs.durableGaps,
-    dependencyBlockers: workflow.dependencyBlockers,
-    affectedFileConflicts: scopedAffectedFileConflicts,
-    syncBackDecision: runtimeInputs.syncBackDecisions[0] ?? null,
-    syncBackDecisions: runtimeInputs.syncBackDecisions,
-    fanInEvidenceSets: runtimeInputs.fanInEvidenceSets,
-    advisorAssessments: runtimeInputs.advisorAssessments,
-    canonicalEvidenceRefs: sortedUnique([...workflowScope.evidenceRefs, ...runtimeInputs.payloads.filter((payload) => payload.status === 'active').map((payload) => payload.logicalRef)]),
-    requiredArtifactRefs: sortedUnique(scopedTasks.flatMap((task) => task.requiredArtifacts)),
-    artifactPayloadHealth: await inspectArtifactPayloadHealth(projectRoot, runtimeInputs.payloads.filter((payload) => payload.status === 'active'))
-  };
-  return {
-    ...packetBase,
-    hardChecks: evaluateWorkflowGateHardChecks(packetBase)
-  };
-}
-
-function emptyLatestEligibleSelection(partition: string, taskId: string): WorkflowGateEvidencePacket['latestEligibleSelections'][number] {
-  return {
-    partition,
-    taskId,
-    selected: null,
-    candidates: [],
-    rejected: []
-  };
-}
-
-async function loadScopedAffectedFileConflicts(projectRoot: string, fallback: WorkflowGateEvidencePacket['affectedFileConflicts'], runIds: string[]): Promise<WorkflowGateEvidencePacket['affectedFileConflicts']> {
-  if (runIds.length === 0) {
-    return fallback;
-  }
-  const states = await readAllRunStates(projectRoot);
-  const selectedRuns = states.filter((state) => runIds.includes(state.runId));
-  return affectedFileConflictsForSelectedRuns(states, selectedRuns);
-}
-
-async function loadRuntimeGateInputs(projectRoot: string, partition: string, taskIds: string[], runIds: string[]): Promise<{
-  runtimeHealth: WorkflowGateEvidencePacket['runtimeHealth'];
-  durableGaps: WorkflowGateEvidencePacket['durableGaps'];
-  syncBackDecisions: NonNullable<WorkflowGateEvidencePacket['syncBackDecision']>[];
-  fanInEvidenceSets: WorkflowGateEvidencePacket['fanInEvidenceSets'];
-  advisorAssessments: WorkflowGateEvidencePacket['advisorAssessments'];
-  payloads: RuntimeArtifactPayloadRecord[];
-}> {
-  try {
-    const runtimeScopes = scopedRuntimeQueries(taskIds, runIds);
-    const [durableGapResults, syncBackDecisionResults, fanInEvidenceSetResults, advisorAssessmentResults, payloadResults] = await Promise.all([
-      Promise.all(runtimeScopes.map((scope) => listRuntimeDurableGaps(projectRoot, { partition, taskId: scope.taskId, runId: scope.runId, status: 'open_terminal' }))),
-      Promise.all(runIds.map((scopedRunId) => listRuntimeSyncBackDecisions(projectRoot, scopedRunId))),
-      Promise.all(runtimeScopes.map((scope) => listRuntimeFanInEvidenceSets(projectRoot, { partition, taskId: scope.taskId, runId: scope.runId }))),
-      Promise.all(runtimeScopes.map((scope) => listRuntimeLlmAdvisorAssessments(projectRoot, { partition, taskId: scope.taskId, runId: scope.runId }))),
-      Promise.all(runIds.map((scopedRunId) => listRuntimeArtifactPayloads(projectRoot, { runId: scopedRunId })))
-    ]);
-    return {
-      runtimeHealth: { status: 'ok', issues: [] },
-      durableGaps: uniqueBy(durableGapResults.flat(), (gap) => gap.gapId),
-      syncBackDecisions: uniqueBy(syncBackDecisionResults.flat(), (decision) => decision.decisionId),
-      fanInEvidenceSets: uniqueBy(fanInEvidenceSetResults.flat(), (evidenceSet) => evidenceSet.fanInId),
-      advisorAssessments: uniqueBy(advisorAssessmentResults.flat(), (assessment) => assessment.assessmentId),
-      payloads: uniqueBy(payloadResults.flat(), (payload) => payload.payloadId)
-    };
-  } catch (error) {
-    return {
-      runtimeHealth: { status: 'unavailable', issues: [messageFromError(error)] },
-      durableGaps: [],
-      syncBackDecisions: [],
-      fanInEvidenceSets: [],
-      advisorAssessments: [],
-      payloads: []
-    };
-  }
-}
-
-function scopedRuntimeQueries(taskIds: string[], runIds: string[]): Array<{ taskId: string | null; runId: string | null }> {
-  if (taskIds.length === 0 && runIds.length === 0) {
-    return [{ taskId: null, runId: null }];
-  }
-  if (taskIds.length === 0) {
-    return runIds.map((scopedRunId) => ({ taskId: null, runId: scopedRunId }));
-  }
-  if (runIds.length === 0) {
-    return taskIds.map((scopedTaskId) => ({ taskId: scopedTaskId, runId: null }));
-  }
-  return uniqueBy([
-    ...taskIds.flatMap((scopedTaskId) => runIds.map((scopedRunId) => ({ taskId: scopedTaskId, runId: scopedRunId }))),
-    ...taskIds.map((scopedTaskId) => ({ taskId: scopedTaskId, runId: null })),
-    ...runIds.map((scopedRunId) => ({ taskId: null, runId: scopedRunId }))
-  ], (scope) => `${scope.taskId ?? 'none'}:${scope.runId ?? 'none'}`);
-}
-
-function uniqueBy<T>(items: T[], keyOf: (item: T) => string): T[] {
-  const seen = new Set<string>();
-  return items.filter((item) => {
-    const key = keyOf(item);
-    if (seen.has(key)) {
-      return false;
-    }
-    seen.add(key);
-    return true;
-  });
-}
-
-async function inspectArtifactPayloadHealth(projectRoot: string, payloads: RuntimeArtifactPayloadRecord[]): Promise<WorkflowGateEvidencePacket['artifactPayloadHealth']> {
-  return Promise.all(payloads.map(async (payload) => {
-    try {
-      const raw = await readFile(getEvidenceAttachmentPath(projectRoot, payload.branchSlug, payload.physicalPayloadPath), 'utf8');
-      const actualDigest = hashDocumentContent(raw);
-      return {
-        payloadId: payload.payloadId,
-        logicalRef: payload.logicalRef,
-        physicalPayloadPath: payload.physicalPayloadPath,
-        expectedDigest: payload.digest,
-        actualDigest,
-        status: actualDigest === payload.digest ? 'ok' as const : 'digest_drift' as const
-      };
-    } catch {
-      return {
-        payloadId: payload.payloadId,
-        logicalRef: payload.logicalRef,
-        physicalPayloadPath: payload.physicalPayloadPath,
-        expectedDigest: payload.digest,
-        actualDigest: null,
-        status: 'missing' as const
-      };
-    }
-  }));
-}
-
-function hashDocumentContent(raw: string): string {
-  return createHash('sha256').update(raw.replace(/\r\n/g, '\n'), 'utf8').digest('hex');
-}
-
-export async function evaluateAndRecordWorkflowGateDecision(projectRoot: string, input: { branch?: string | null; taskId?: string | null; runId?: string | null; decisionKind: WorkflowGateDecisionKind; waveRunId?: string | null; taskIds?: string[]; runIds?: string[]; evidenceRefs?: string[] }): Promise<{ packet: WorkflowGateEvidencePacket; decision: WorkflowGateDecision }> {
-  const packet = await buildWorkflowGateEvidencePacket(projectRoot, input);
-  const decision = synthesizeWorkflowGateDecision(packet);
-  try {
-    await recordRuntimeWorkflowGateDecision(projectRoot, decision);
-  } catch (error) {
-    if (packet.runtimeHealth.status === 'ok') {
-      throw error;
-    }
-  }
-  return { packet, decision };
-}
-function sortedUnique(values: string[]): string[] {
-  return [...new Set(values.filter(Boolean))].sort();
-}
-
-function messageFromError(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}
+import { createHash } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import { WORKFLOW_GATE_RUNTIME_CONTRACT_VERSION } from '../contracts.js';
+import { listRuntimeArtifactPayloads, listRuntimeDurableGaps, listRuntimeFanInEvidenceSets, listRuntimeLlmAdvisorAssessments, recordRuntimeWorkflowGateDecision, runtimeScopedId, type RuntimeArtifactPayloadRecord } from '../storage/runtime-store.js';
+import { getEvidenceAttachmentPath } from '../runtime-paths.js';
+import { readAllRunStates } from '../run-state/run-state.js';
+import { affectedFileConflictsForSelectedRuns } from '../workflow-state/affected-file-conflicts.js';
+import { resolveWorkflowState } from '../workflow-state/resolve.js';
+import { evaluateWorkflowGateHardChecks } from './hard-checks.js';
+import { synthesizeWorkflowGateDecision } from './policy.js';
+import type { WorkflowGateDecision, WorkflowGateDecisionKind, WorkflowGateEvidencePacket } from './types.js';
+
+export async function buildWorkflowGateEvidencePacket(projectRoot: string, input: { branch?: string | null; taskId?: string | null; runId?: string | null; decisionKind: WorkflowGateDecisionKind; waveRunId?: string | null; taskIds?: string[]; runIds?: string[]; evidenceRefs?: string[] }): Promise<WorkflowGateEvidencePacket> {
+  const workflow = await resolveWorkflowState(projectRoot, { branch: input.branch, branchSource: input.branch ? 'cli_option' : undefined, taskId: input.taskId ?? null });
+  const taskId = input.taskId ?? workflow.latestRun?.taskId ?? workflow.model.tasks[0]?.id ?? null;
+  const selection = taskId ? workflow.latestEligibleRunsByTask.find((candidate) => candidate.taskId === taskId) ?? null : null;
+  const runId = input.runId ?? selection?.selected?.runId ?? workflow.latestRun?.runId ?? null;
+  const scopedTaskIds = sortedUnique(input.taskIds ?? (taskId ? [taskId] : []));
+  const scopedLatestEligibleSelections = scopedTaskIds.length > 0
+    ? scopedTaskIds.map((scopedTaskId) => workflow.latestEligibleRunsByTask.find((candidate) => candidate.taskId === scopedTaskId) ?? emptyLatestEligibleSelection(workflow.branch, scopedTaskId))
+    : (selection ? [selection] : []);
+  const scopedRunIds = sortedUnique(input.runIds ?? scopedLatestEligibleSelections.flatMap((candidate) => candidate.selected ? [candidate.selected.runId] : []));
+  const workflowScope = {
+    waveRunId: input.waveRunId ?? null,
+    taskIds: scopedTaskIds,
+    runIds: scopedRunIds.length > 0 ? scopedRunIds : sortedUnique(runId ? [runId] : []),
+    evidenceRefs: sortedUnique(input.evidenceRefs ?? [])
+  };
+  const scopedTasks = workflowScope.taskIds.length > 0
+    ? workflow.model.tasks.filter((candidate) => workflowScope.taskIds.includes(candidate.id))
+    : workflow.model.tasks.filter((candidate) => candidate.id === taskId);
+  const runtimeInputs = await loadRuntimeGateInputs(projectRoot, workflow.branch, workflowScope.taskIds, workflowScope.runIds);
+  const scopedAffectedFileConflicts = await loadScopedAffectedFileConflicts(projectRoot, workflow.affectedFileConflicts, workflowScope.runIds);
+  const packetBase = {
+    packetId: runtimeScopedId(WORKFLOW_GATE_RUNTIME_CONTRACT_VERSION, workflow.branch, taskId ?? 'none', runId ?? 'none', input.decisionKind),
+    generatedAt: new Date().toISOString(),
+    decisionKind: input.decisionKind,
+    partition: workflow.branch,
+    taskId,
+    runId,
+    documents: workflow.documents,
+    latestEligibleSelection: selection,
+    latestEligibleSelections: scopedLatestEligibleSelections,
+    workflowScope,
+    runtimeHealth: runtimeInputs.runtimeHealth,
+    durableGaps: runtimeInputs.durableGaps,
+    dependencyBlockers: workflow.dependencyBlockers,
+    affectedFileConflicts: scopedAffectedFileConflicts,
+    fanInEvidenceSets: runtimeInputs.fanInEvidenceSets,
+    advisorAssessments: runtimeInputs.advisorAssessments,
+    canonicalEvidenceRefs: sortedUnique([...workflowScope.evidenceRefs, ...runtimeInputs.payloads.filter((payload) => payload.status === 'active').map((payload) => payload.logicalRef)]),
+    requiredArtifactRefs: sortedUnique(scopedTasks.flatMap((task) => task.requiredArtifacts)),
+    artifactPayloadHealth: await inspectArtifactPayloadHealth(projectRoot, runtimeInputs.payloads.filter((payload) => payload.status === 'active'))
+  };
+  return {
+    ...packetBase,
+    hardChecks: evaluateWorkflowGateHardChecks(packetBase)
+  };
+}
+
+function emptyLatestEligibleSelection(partition: string, taskId: string): WorkflowGateEvidencePacket['latestEligibleSelections'][number] {
+  return {
+    partition,
+    taskId,
+    selected: null,
+    candidates: [],
+    rejected: []
+  };
+}
+
+async function loadScopedAffectedFileConflicts(projectRoot: string, fallback: WorkflowGateEvidencePacket['affectedFileConflicts'], runIds: string[]): Promise<WorkflowGateEvidencePacket['affectedFileConflicts']> {
+  if (runIds.length === 0) {
+    return fallback;
+  }
+  const states = await readAllRunStates(projectRoot);
+  const selectedRuns = states.filter((state) => runIds.includes(state.runId));
+  return affectedFileConflictsForSelectedRuns(states, selectedRuns);
+}
+
+async function loadRuntimeGateInputs(projectRoot: string, partition: string, taskIds: string[], runIds: string[]): Promise<{
+  runtimeHealth: WorkflowGateEvidencePacket['runtimeHealth'];
+  durableGaps: WorkflowGateEvidencePacket['durableGaps'];
+  fanInEvidenceSets: WorkflowGateEvidencePacket['fanInEvidenceSets'];
+  advisorAssessments: WorkflowGateEvidencePacket['advisorAssessments'];
+  payloads: RuntimeArtifactPayloadRecord[];
+}> {
+  try {
+    const runtimeScopes = scopedRuntimeQueries(taskIds, runIds);
+    const [durableGapResults, fanInEvidenceSetResults, advisorAssessmentResults, payloadResults] = await Promise.all([
+      Promise.all(runtimeScopes.map((scope) => listRuntimeDurableGaps(projectRoot, { partition, taskId: scope.taskId, runId: scope.runId, status: 'open_terminal' }))),
+      Promise.all(runtimeScopes.map((scope) => listRuntimeFanInEvidenceSets(projectRoot, { partition, taskId: scope.taskId, runId: scope.runId }))),
+      Promise.all(runtimeScopes.map((scope) => listRuntimeLlmAdvisorAssessments(projectRoot, { partition, taskId: scope.taskId, runId: scope.runId }))),
+      Promise.all(runIds.map((scopedRunId) => listRuntimeArtifactPayloads(projectRoot, { runId: scopedRunId })))
+    ]);
+    return {
+      runtimeHealth: { status: 'ok', issues: [] },
+      durableGaps: uniqueBy(durableGapResults.flat(), (gap) => gap.gapId),
+      fanInEvidenceSets: uniqueBy(fanInEvidenceSetResults.flat(), (evidenceSet) => evidenceSet.fanInId),
+      advisorAssessments: uniqueBy(advisorAssessmentResults.flat(), (assessment) => assessment.assessmentId),
+      payloads: uniqueBy(payloadResults.flat(), (payload) => payload.payloadId)
+    };
+  } catch (error) {
+    return {
+      runtimeHealth: { status: 'unavailable', issues: [messageFromError(error)] },
+      durableGaps: [],
+      fanInEvidenceSets: [],
+      advisorAssessments: [],
+      payloads: []
+    };
+  }
+}
+
+function scopedRuntimeQueries(taskIds: string[], runIds: string[]): Array<{ taskId: string | null; runId: string | null }> {
+  if (taskIds.length === 0 && runIds.length === 0) {
+    return [{ taskId: null, runId: null }];
+  }
+  if (taskIds.length === 0) {
+    return runIds.map((scopedRunId) => ({ taskId: null, runId: scopedRunId }));
+  }
+  if (runIds.length === 0) {
+    return taskIds.map((scopedTaskId) => ({ taskId: scopedTaskId, runId: null }));
+  }
+  return uniqueBy([
+    ...taskIds.flatMap((scopedTaskId) => runIds.map((scopedRunId) => ({ taskId: scopedTaskId, runId: scopedRunId }))),
+    ...taskIds.map((scopedTaskId) => ({ taskId: scopedTaskId, runId: null })),
+    ...runIds.map((scopedRunId) => ({ taskId: null, runId: scopedRunId }))
+  ], (scope) => `${scope.taskId ?? 'none'}:${scope.runId ?? 'none'}`);
+}
+
+function uniqueBy<T>(items: T[], keyOf: (item: T) => string): T[] {
+  const seen = new Set<string>();
+  return items.filter((item) => {
+    const key = keyOf(item);
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+}
+
+async function inspectArtifactPayloadHealth(projectRoot: string, payloads: RuntimeArtifactPayloadRecord[]): Promise<WorkflowGateEvidencePacket['artifactPayloadHealth']> {
+  return Promise.all(payloads.map(async (payload) => {
+    try {
+      const raw = await readFile(getEvidenceAttachmentPath(projectRoot, payload.branchSlug, payload.physicalPayloadPath), 'utf8');
+      const actualDigest = hashDocumentContent(raw);
+      return {
+        payloadId: payload.payloadId,
+        logicalRef: payload.logicalRef,
+        physicalPayloadPath: payload.physicalPayloadPath,
+        expectedDigest: payload.digest,
+        actualDigest,
+        status: actualDigest === payload.digest ? 'ok' as const : 'digest_drift' as const
+      };
+    } catch {
+      return {
+        payloadId: payload.payloadId,
+        logicalRef: payload.logicalRef,
+        physicalPayloadPath: payload.physicalPayloadPath,
+        expectedDigest: payload.digest,
+        actualDigest: null,
+        status: 'missing' as const
+      };
+    }
+  }));
+}
+
+function hashDocumentContent(raw: string): string {
+  return createHash('sha256').update(raw.replace(/\r\n/g, '\n'), 'utf8').digest('hex');
+}
+
+export async function evaluateAndRecordWorkflowGateDecision(projectRoot: string, input: { branch?: string | null; taskId?: string | null; runId?: string | null; decisionKind: WorkflowGateDecisionKind; waveRunId?: string | null; taskIds?: string[]; runIds?: string[]; evidenceRefs?: string[] }): Promise<{ packet: WorkflowGateEvidencePacket; decision: WorkflowGateDecision }> {
+  const packet = await buildWorkflowGateEvidencePacket(projectRoot, input);
+  const decision = synthesizeWorkflowGateDecision(packet);
+  try {
+    await recordRuntimeWorkflowGateDecision(projectRoot, decision);
+  } catch (error) {
+    if (packet.runtimeHealth.status === 'ok') {
+      throw error;
+    }
+  }
+  return { packet, decision };
+}
+function sortedUnique(values: string[]): string[] {
+  return [...new Set(values.filter(Boolean))].sort();
+}
+
+function messageFromError(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}