sdd-agent-platform 0.4.2 → 0.5.0

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

@@ -1,146 +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;
-}
+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,9 +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/timing.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';

package/node_modules/@sdd-agent-platform/core/src/runtime-analysis/build.ts

@@ -1,60 +1,60 @@
-import { buildContextBuildPackage } from '../context/build-package.js';
-import { buildEvidenceSummaryProjection } from '../context/evidence-summary.js';
-import { messageFromError } from '../contracts/issues.js';
-import { doctor } from '../doctor/doctor.js';
-import { inspectTaskGraph } from '../planning/task-graph.js';
-import { inspectWavePlan } from '../planning/wave-plan.js';
-import { inspectRun } from '../run-state/inspect-run.js';
-import { inspectLocalRunIndex } from '../run-state/run-index.js';
-import { getProjectStatus } from '../status/project-status.js';
-import { createRuntimeAnalysisReport } from './findings.js';
-import type { RuntimeAnalysisInputIssue, RuntimeAnalysisOptions, RuntimeAnalysisReport } from './model.js';
-
-export async function buildRuntimeAnalysisReport(projectRoot: string, options: RuntimeAnalysisOptions = {}): Promise<RuntimeAnalysisReport> {
-  const profile = options.profile ?? 'normal';
-  const status = await getProjectStatus(projectRoot, { branch: options.branch ?? undefined });
-  const branch = status.branch;
-  const [doctorReport, runIndex, taskGraph, wavePlan] = await Promise.all([
-    doctor(projectRoot, { latestOnly: true, branch }),
-    inspectLocalRunIndex(projectRoot),
-    inspectTaskGraph(projectRoot, { branch }),
-    inspectWavePlan(projectRoot, { branch })
-  ]);
-  const selectedRunId = options.runId ?? status.latestRun?.runId ?? null;
-  const selectedTaskId = options.taskId ?? status.latestRun?.currentTask ?? taskGraph.nodes.find((node) => node.status === 'pending')?.taskId ?? status.latestRunsByTask[0]?.taskId ?? null;
-  const inputIssues: RuntimeAnalysisInputIssue[] = [];
-  const runInspection = selectedRunId ? await runtimeAnalysisStep(inputIssues, 'run', () => inspectRun(projectRoot, selectedRunId), { runId: selectedRunId }) : null;
-  const evidenceSummary = selectedRunId ? await runtimeAnalysisStep(inputIssues, 'evidence', () => buildEvidenceSummaryProjection(projectRoot, { runId: selectedRunId, taskId: selectedTaskId ?? undefined }), { runId: selectedRunId, taskId: selectedTaskId ?? undefined }) : null;
-  const contextPackage = selectedTaskId ? await runtimeAnalysisStep(inputIssues, 'context', () => buildContextBuildPackage(projectRoot, { taskId: selectedTaskId, branch, mode: 'do', profile }), { taskId: selectedTaskId }) : null;
-
-  return createRuntimeAnalysisReport({
-    generatedAt: new Date().toISOString(),
-    profile,
-    branch,
-    selectedRunId,
-    selectedTaskId,
-    status,
-    doctor: doctorReport,
-    runIndex,
-    taskGraph,
-    wavePlan,
-    runInspection,
-    evidenceSummary,
-    contextPackage,
-    inputIssues
-  });
-}
-
-async function runtimeAnalysisStep<T>(inputIssues: RuntimeAnalysisInputIssue[], source: RuntimeAnalysisInputIssue['source'], step: () => Promise<T>, context: { runId?: string; taskId?: string } = {}): Promise<T | null> {
-  try {
-    return await step();
-  } catch (error) {
-    inputIssues.push({
-      source,
-      message: messageFromError(error),
-      runId: context.runId,
-      taskId: context.taskId
-    });
-    return null;
-  }
-}
+import { buildContextBuildPackage } from '../context/build-package.js';
+import { buildEvidenceSummaryProjection } from '../context/evidence-summary.js';
+import { messageFromError } from '../contracts/issues.js';
+import { doctor } from '../doctor/doctor.js';
+import { inspectTaskGraph } from '../planning/task-graph.js';
+import { inspectWavePlan } from '../planning/wave-plan.js';
+import { inspectRun } from '../run-state/inspect-run.js';
+import { inspectLocalRunIndex } from '../run-state/run-index.js';
+import { getProjectStatus } from '../status/project-status.js';
+import { createRuntimeAnalysisReport } from './findings.js';
+import type { RuntimeAnalysisInputIssue, RuntimeAnalysisOptions, RuntimeAnalysisReport } from './model.js';
+
+export async function buildRuntimeAnalysisReport(projectRoot: string, options: RuntimeAnalysisOptions = {}): Promise<RuntimeAnalysisReport> {
+  const profile = options.profile ?? 'normal';
+  const status = await getProjectStatus(projectRoot, { branch: options.branch ?? undefined });
+  const branch = status.branch;
+  const [doctorReport, runIndex, taskGraph, wavePlan] = await Promise.all([
+    doctor(projectRoot, { latestOnly: true, branch }),
+    inspectLocalRunIndex(projectRoot),
+    inspectTaskGraph(projectRoot, { branch }),
+    inspectWavePlan(projectRoot, { branch })
+  ]);
+  const selectedRunId = options.runId ?? status.latestRun?.runId ?? null;
+  const selectedTaskId = options.taskId ?? status.latestRun?.currentTask ?? taskGraph.nodes.find((node) => node.status === 'pending')?.taskId ?? status.latestRunsByTask[0]?.taskId ?? null;
+  const inputIssues: RuntimeAnalysisInputIssue[] = [];
+  const runInspection = selectedRunId ? await runtimeAnalysisStep(inputIssues, 'run', () => inspectRun(projectRoot, selectedRunId), { runId: selectedRunId }) : null;
+  const evidenceSummary = selectedRunId ? await runtimeAnalysisStep(inputIssues, 'evidence', () => buildEvidenceSummaryProjection(projectRoot, { runId: selectedRunId, taskId: selectedTaskId ?? undefined }), { runId: selectedRunId, taskId: selectedTaskId ?? undefined }) : null;
+  const contextPackage = selectedTaskId ? await runtimeAnalysisStep(inputIssues, 'context', () => buildContextBuildPackage(projectRoot, { taskId: selectedTaskId, branch, mode: 'execute', profile }), { taskId: selectedTaskId }) : null;
+
+  return createRuntimeAnalysisReport({
+    generatedAt: new Date().toISOString(),
+    profile,
+    branch,
+    selectedRunId,
+    selectedTaskId,
+    status,
+    doctor: doctorReport,
+    runIndex,
+    taskGraph,
+    wavePlan,
+    runInspection,
+    evidenceSummary,
+    contextPackage,
+    inputIssues
+  });
+}
+
+async function runtimeAnalysisStep<T>(inputIssues: RuntimeAnalysisInputIssue[], source: RuntimeAnalysisInputIssue['source'], step: () => Promise<T>, context: { runId?: string; taskId?: string } = {}): Promise<T | null> {
+  try {
+    return await step();
+  } catch (error) {
+    inputIssues.push({
+      source,
+      message: messageFromError(error),
+      runId: context.runId,
+      taskId: context.taskId
+    });
+    return null;
+  }
+}