sdd-agent-platform 0.4.1 → 0.4.2

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

@@ -1,6 +1,6 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtemp, rm } from 'node:fs/promises';
+import { access, mkdtemp, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
 
@@ -10,6 +10,7 @@ import { createRun, listRuns, readRunState, writeRunState } from './run-state.js
 import { validTaskMarkdown, writeBranchDocs } from '../test-support/fixtures.js';
 import { getRunDir } from '../runtime-paths.js';
 import { exists } from '../storage/json-io.js';
+import { buildRunDurationBreakdown } from './timing.js';
 
 test('createRun writes state and append-only events', async () => {
   const root = await mkdtemp(path.join(tmpdir(), 'sdd-runtime-'));
@@ -24,6 +25,7 @@ test('createRun writes state and append-only events', async () => {
     assert.equal(events.some((event) => event.event === 'run_started'), true);
     assert.equal(events.some((event) => event.event === 'lifecycle_decision_recorded'), true);
     assert.equal(await exists(getRunDir(root, state.runId)), false);
+    await assert.rejects(access(path.join(root, '.sdd', 'runs')));
   } finally {
     await rm(root, { recursive: true, force: true });
   }
@@ -43,7 +45,8 @@ test('createRun binds scoped branch task metadata', async () => {
     assert.equal(restored.currentTask, 'T1');
     assert.equal(restored.taskId, 'T1');
     assert.deepEqual(restored.affectedFiles, ['packages/core/src/index.ts']);
-    assert.match(restored.artifactRoot, /\.sdd[\\/]runs[\\/]feature[\\/]evidence/);
+    assert.equal(restored.artifactRoot.replace(/\\/g, '/'), '.sdd/runs/feature');
+    assert.equal(await exists(path.join(root, '.sdd', 'runs')), false);
     assert.equal(restored.documentSnapshot.tasksHash !== null, true);
   } finally {
     await rm(root, { recursive: true, force: true });
@@ -68,3 +71,48 @@ test('listRuns sorts run summaries by updated time descending', async () => {
     await rm(root, { recursive: true, force: true });
   }
 });
+
+test('buildRunDurationBreakdown classifies runtime gaps and validation contributors', () => {
+  const base = {
+    contract: 'phase-1.2-run-state-contract',
+    runId: 'run-1',
+    createdAt: '2026-05-01T00:00:00.000Z',
+    updatedAt: '2026-05-01T00:01:00.000Z',
+    status: 'blocked',
+    phase: 'test',
+    currentTask: 'T1',
+    taskId: 'T1',
+    partition: 'master',
+    gitBranch: null,
+    artifactRoot: '',
+    lifecycleDecision: null,
+    documentSnapshot: { specHash: null, planHash: null, tasksHash: null, verifyHash: null },
+    affectedFiles: [],
+    tasks: {},
+    delegations: {},
+    artifacts: [],
+    validation: { status: 'blocked', commands: [], evidence: [] },
+  } as const;
+
+  const breakdown = buildRunDurationBreakdown(base, {
+    events: [
+      { contract: 'sdd-event-log-v1', runId: 'run-1', time: '2026-05-01T00:00:00.000Z', event: 'lifecycle_decision_recorded' },
+      { contract: 'sdd-event-log-v1', runId: 'run-1', time: '2026-05-01T00:00:05.000Z', event: 'run_context_bound' },
+      { contract: 'sdd-event-log-v1', runId: 'run-1', time: '2026-05-01T00:00:06.000Z', event: 'agent_invocation_started' },
+      { contract: 'sdd-event-log-v1', runId: 'run-1', time: '2026-05-01T00:00:16.000Z', event: 'runtime_output_received' },
+      { contract: 'sdd-event-log-v1', runId: 'run-1', time: '2026-05-01T00:00:20.000Z', event: 'validation_started' },
+      { contract: 'sdd-event-log-v1', runId: 'run-1', time: '2026-05-01T00:00:30.000Z', event: 'validation_completed' },
+      { contract: 'sdd-event-log-v1', runId: 'run-1', time: '2026-05-01T00:00:40.000Z', event: 'workflow_gate_blocked', data: { status: 'blocked' } },
+      { contract: 'sdd-event-log-v1', runId: 'run-1', time: '2026-05-01T00:00:50.000Z', event: 'run_finished' }
+    ],
+    testSteps: [{ stepId: 'step-1', testRunId: 'test-1', runId: 'run-1', taskId: 'T1', command: 'npm test', status: 'PASS', exitCode: 0, durationMs: 12_000, outputArtifact: 'artifacts/test.log', payload: { startedAt: '2026-05-01T00:00:30.000Z', endedAt: '2026-05-01T00:00:42.000Z' } }]
+  });
+
+  assert.equal(breakdown.elapsedDurationMs, 60_000);
+  assert.equal(breakdown.queueOrBindDurationMs, 5_000);
+  assert.equal(breakdown.hostWaitingDurationMs, 10_000);
+  assert.equal(breakdown.validationDurationMs, 36_000);
+  assert.equal(breakdown.blockedDurationMs, 10_000);
+  assert.equal(breakdown.waitingDurationMs, 16_000);
+  assert.equal(breakdown.slowReason, 'validation');
+});

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

@@ -1,10 +1,10 @@
 import { createHash } from 'node:crypto';
-import { mkdir, readdir, readFile } from 'node:fs/promises';
+import { readdir, readFile } from 'node:fs/promises';
 import path from 'node:path';
 import {
-  getEvidenceDir,
   getLegacyRunDir,
   getProjectConfigPath,
+  getRunEvidenceRoot,
   getRunsDir
 } from '../runtime-paths.js';
 import { exists } from '../storage/json-io.js';
@@ -17,6 +17,7 @@ import { branchToSafePartition } from '../path-safety.js';
 import { resolveSddContext } from '../sdd-docs/context.js';
 import { parseSddBranch } from '../sdd-docs/task-parser.js';
 import { inspectSddTask } from '../sdd-docs/task-inspection.js';
+import { buildRunDurationBreakdown } from './timing.js';
 
 export async function readRunState(projectRoot: string, runId: string): Promise<RunState> {
   const storedState = await readRuntimeRunState(projectRoot, runId);
@@ -84,14 +85,12 @@ export interface CreateRunOptions {
 
 export async function createRun(projectRoot: string, options: CreateRunOptions = {}): Promise<RunState> {
   await validateProjectConfig(projectRoot);
-  if (Boolean(options.branch) !== Boolean(options.taskId)) {
-    throw new Error('Scoped run creation requires both --branch <branch> and --task <task_id>.');
+  if (options.taskId && !options.branch) {
+    throw new Error('Task-scoped run creation requires --branch <branch>.');
   }
-  const scope = options.branch && options.taskId ? await resolveCreateRunScope(projectRoot, options.branch, options.taskId) : null;
-  await mkdir(getRunsDir(projectRoot), { recursive: true });
+  const scope = options.branch ? await resolveCreateRunScope(projectRoot, options.branch, options.taskId ?? null) : null;
   const runId = options.runId ?? await createUniqueRunId(projectRoot);
 
-
   const now = new Date().toISOString();
   const state: RunState = {
     contract: RUN_STATE_CONTRACT,
@@ -110,7 +109,7 @@ export async function createRun(projectRoot: string, options: CreateRunOptions =
     projectRoot: path.resolve(projectRoot),
     projectConfigPath: path.relative(projectRoot, getProjectConfigPath(projectRoot)),
     eventLogPath: getRuntimeStoreEventRef(),
-    artifactRoot: path.relative(projectRoot, getEvidenceDir(projectRoot, stateEvidenceBranchSlug(scope?.partition ?? null))),
+    artifactRoot: path.relative(projectRoot, path.join(getRunEvidenceRoot(projectRoot), stateEvidenceBranchSlug(scope?.partition ?? null))),
     lifecycleDecision: options.lifecycleDecision ?? emptyRunLifecycleDecisionRecord(),
     tasks: {},
     agents: {},
@@ -122,11 +121,6 @@ export async function createRun(projectRoot: string, options: CreateRunOptions =
       status: 'not_run',
       commands: [],
       evidence: []
-    },
-    syncBack: {
-      mode: 'proposal',
-      proposalPath: null,
-      status: 'not_created'
     }
   };
 
@@ -134,7 +128,7 @@ export async function createRun(projectRoot: string, options: CreateRunOptions =
   await appendEvent(projectRoot, runId, {
     event: 'run_started',
     runId,
-    summary: scope ? `Scoped run created for ${scope.partition}/${scope.taskId}.` : 'Run created by Phase 7.2 SQLite-first runtime storage',
+    summary: scope ? `Scoped run created for ${scope.partition}${scope.taskId ? `/${scope.taskId}` : ''}.` : 'Run created by Phase 7.2 SQLite-first runtime storage',
     data: {
       runtimeVersion: RUNTIME_VERSION,
       stateRef: '.sdd/runtime.sqlite:runs',
@@ -223,9 +217,9 @@ export function summarizeRunState(state: RunState): RunSummary {
     createdAt: state.createdAt,
     updatedAt: state.updatedAt,
     validationStatus: state.validation.status,
-    syncBackStatus: state.syncBack.status,
     taskIds: Object.keys(state.tasks).sort(),
-    artifactCount: state.artifacts.length
+    artifactCount: state.artifacts.length,
+    durationBreakdown: buildRunDurationBreakdown(state)
   };
 }
 
@@ -253,6 +247,7 @@ export function normalizeRunDocumentSnapshot(snapshot: unknown): RunDocumentSnap
     specContractHash: stringOrNull(snapshot.specContractHash),
     planContractHash: stringOrNull(snapshot.planContractHash),
     tasksContractHash: stringOrNull(snapshot.tasksContractHash),
+    taskContractHash: stringOrNull(snapshot.taskContractHash),
     planBasedOnSpecHash: stringOrNull(snapshot.planBasedOnSpecHash),
     tasksBasedOnPlanHash: stringOrNull(snapshot.tasksBasedOnPlanHash),
     planBasedOnSpecContractHash: stringOrNull(snapshot.planBasedOnSpecContractHash),
@@ -268,6 +263,7 @@ export function emptyRunDocumentSnapshot(): RunDocumentSnapshot {
     specContractHash: null,
     planContractHash: null,
     tasksContractHash: null,
+    taskContractHash: null,
     planBasedOnSpecHash: null,
     tasksBasedOnPlanHash: null,
     planBasedOnSpecContractHash: null,
@@ -307,9 +303,18 @@ function emptyRunLifecycleDecisionRecord(): RunStateLifecycleDecisionRecord {
   };
 }
 
-async function resolveCreateRunScope(projectRoot: string, branch: string, taskId: string): Promise<{ partition: string; rawBranch: string; taskId: string; affectedFiles: string[]; documentSnapshot: RunDocumentSnapshot }> {
+async function resolveCreateRunScope(projectRoot: string, branch: string, taskId: string | null): Promise<{ partition: string; rawBranch: string; taskId: string | null; affectedFiles: string[]; documentSnapshot: RunDocumentSnapshot }> {
   const context = await resolveSddContext(projectRoot, { branch, branchSource: 'cli_option' });
   const model = await parseSddBranch(projectRoot, context.partition);
+  if (!taskId) {
+    return {
+      partition: context.partition,
+      rawBranch: context.rawBranch,
+      taskId: null,
+      affectedFiles: [],
+      documentSnapshot: documentSnapshotFromModel(model)
+    };
+  }
   const task = inspectSddTask(model, taskId).task;
   if (!task) {
     throw new Error(`Cannot create scoped run: task ${taskId} was not found in specs/${context.partition}/tasks.md.`);
@@ -319,18 +324,23 @@ async function resolveCreateRunScope(projectRoot: string, branch: string, taskId
     rawBranch: context.rawBranch,
     taskId,
     affectedFiles: task.affectedFiles,
-    documentSnapshot: {
-      specHash: model.documents.specHash ?? null,
-      planHash: model.documents.planHash ?? null,
-      tasksHash: model.documents.tasksHash ?? null,
-      specContractHash: model.documents.specContractHash ?? null,
-      planContractHash: model.documents.planContractHash ?? null,
-      tasksContractHash: model.documents.tasksContractHash ?? null,
-      planBasedOnSpecHash: model.documents.planBasedOnSpecHash ?? null,
-      tasksBasedOnPlanHash: model.documents.tasksBasedOnPlanHash ?? null,
-      planBasedOnSpecContractHash: model.documents.planBasedOnSpecContractHash ?? null,
-      tasksBasedOnPlanContractHash: model.documents.tasksBasedOnPlanContractHash ?? null
-    }
+    documentSnapshot: documentSnapshotFromModel(model, task)
+  };
+}
+
+function documentSnapshotFromModel(model: Awaited<ReturnType<typeof parseSddBranch>>, task: ReturnType<typeof inspectSddTask>['task'] = null): RunDocumentSnapshot {
+  return {
+    specHash: model.documents.specHash ?? null,
+    planHash: model.documents.planHash ?? null,
+    tasksHash: model.documents.tasksHash ?? null,
+    specContractHash: model.documents.specContractHash ?? null,
+    planContractHash: model.documents.planContractHash ?? null,
+    tasksContractHash: model.documents.tasksContractHash ?? null,
+    taskContractHash: task?.contractHash ?? null,
+    planBasedOnSpecHash: model.documents.planBasedOnSpecHash ?? null,
+    tasksBasedOnPlanHash: model.documents.tasksBasedOnPlanHash ?? null,
+    planBasedOnSpecContractHash: model.documents.planBasedOnSpecContractHash ?? null,
+    tasksBasedOnPlanContractHash: model.documents.tasksBasedOnPlanContractHash ?? null
   };
 }
 

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

@@ -1,6 +1,8 @@
 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 { isBranchStageEvidenceRef, toBranchStageEvidenceRef } from '../runtime-paths.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 { SddStage } from '../contracts.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';
@@ -15,8 +17,12 @@ export const TASK_EVIDENCE_VIEW_CONTRACT_VERSION = 'phase-8.12-task-evidence-vie
 export interface TaskEvidencePayloadGroups {
   active: RuntimeArtifactPayloadRecord[];
   candidate: RuntimeArtifactPayloadRecord[];
+  partial: RuntimeArtifactPayloadRecord[];
+  active_attempt: RuntimeArtifactPayloadRecord[];
   rejected: RuntimeArtifactPayloadRecord[];
   superseded: RuntimeArtifactPayloadRecord[];
+  quarantined: RuntimeArtifactPayloadRecord[];
+  stale: RuntimeArtifactPayloadRecord[];
   all: RuntimeArtifactPayloadRecord[];
 }
 
@@ -59,7 +65,6 @@ export interface TaskEvidenceView {
   compatibility: LatestEligibleRunCandidate['compatibility'] | null;
   payloads: TaskEvidencePayloadGroups;
   validation: TaskEvidenceValidationView;
-  syncBackDecision: RuntimeSyncBackDecisionRecord | null;
   runtimeActivity: TaskEvidenceRuntimeActivity;
   gaps: SddTaskGap[];
   durableGaps: RuntimeDurableGapRecord[];
@@ -73,11 +78,10 @@ export async function readTaskEvidenceView(projectRoot: string, input: { branch?
   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
+  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),
-      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),
@@ -86,7 +90,6 @@ export async function readTaskEvidenceView(projectRoot: string, input: { branch?
     : 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),
@@ -113,7 +116,6 @@ export async function readTaskEvidenceView(projectRoot: string, input: { branch?
       environmentSessions,
       acceptanceEvidenceMaps
     },
-    syncBackDecision,
     runtimeActivity,
     gaps: [...workflow.visibleGaps.filter((gap) => gap.taskId === input.taskId || gap.taskId === null), ...runtimeTaskGaps(selectedRunState?.tasks[input.taskId])],
     durableGaps,
@@ -134,15 +136,63 @@ async function readTaskPayloads(projectRoot: string, branch: string, taskId: str
   const payloads = runIds.length > 0
     ? (await Promise.all(runIds.map((runId) => listRuntimeArtifactPayloads(projectRoot, { runId, taskId })))).flat()
     : await listRuntimeArtifactPayloads(projectRoot, { branchSlug: branchToSafePartition(branch), taskId });
+  const normalizedPayloads = payloads.map((payload) => normalizeTaskEvidencePayload(branch, payload));
   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
+    active: normalizedPayloads.filter((payload) => payload.status === 'active'),
+    candidate: normalizedPayloads.filter((payload) => payload.status === 'candidate'),
+    partial: normalizedPayloads.filter((payload) => payload.status === 'partial'),
+    active_attempt: normalizedPayloads.filter((payload) => payload.status === 'active_attempt'),
+    rejected: normalizedPayloads.filter((payload) => payload.status === 'rejected'),
+    superseded: normalizedPayloads.filter((payload) => payload.status === 'superseded'),
+    quarantined: normalizedPayloads.filter((payload) => payload.status === 'quarantined'),
+    stale: normalizedPayloads.filter((payload) => payload.status === 'stale'),
+    all: normalizedPayloads
   };
 }
 
+function normalizeTaskEvidencePayload(branch: string, payload: RuntimeArtifactPayloadRecord): RuntimeArtifactPayloadRecord {
+  const fileName = payload.logicalRef.replace(/\\/g, '/').split('/').filter(Boolean).pop();
+  if (!fileName) {
+    return payload;
+  }
+  const logicalRef = isBranchStageEvidenceRef(payload.logicalRef)
+    ? payload.logicalRef
+    : toBranchStageEvidenceRef(branch, stageForPayload(payload, fileName), fileName);
+  const physicalPayloadPath = payload.physicalPayloadPath.replace(/\\/g, '/').replace(/^artifacts\//, '');
+  return {
+    ...payload,
+    logicalRef,
+    physicalPayloadPath,
+    payload: normalizeTaskEvidencePayloadMetadata(payload.payload, logicalRef, physicalPayloadPath)
+  };
+}
+
+function normalizeTaskEvidencePayloadMetadata(value: unknown, logicalRef: string, physicalPayloadPath: string): unknown {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return value;
+  }
+  return {
+    ...value,
+    logicalRef,
+    artifactPath: logicalRef,
+    physicalPayloadPath
+  };
+}
+
+function stageForPayload(payload: RuntimeArtifactPayloadRecord, fileName: string): SddStage {
+  const role = payload.artifactRole.toLowerCase();
+  if (role.includes('goal') || fileName.startsWith('acceptance-coverage-')) {
+    return 'goal-verify';
+  }
+  if (role.includes('validation') || fileName.startsWith('validation-') || fileName.startsWith('test-validation-')) {
+    return 'test';
+  }
+  if (role.includes('ship') || fileName.startsWith('ship-') || fileName.startsWith('release-')) {
+    return 'ship';
+  }
+  return 'do';
+}
+
 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);
@@ -154,10 +204,6 @@ async function readValidationWaveEvidence(projectRoot: string, partition: string
   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([

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

@@ -6,3 +6,4 @@ 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';

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

@@ -7,7 +7,6 @@ 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 { inspectSyncBack } from '../sync-back/inspect.js';
 import { createRuntimeAnalysisReport } from './findings.js';
 import type { RuntimeAnalysisInputIssue, RuntimeAnalysisOptions, RuntimeAnalysisReport } from './model.js';
 
@@ -27,7 +26,6 @@ export async function buildRuntimeAnalysisReport(projectRoot: string, options: R
   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;
-  const syncBack = selectedTaskId ? await runtimeAnalysisStep(inputIssues, 'sync_back', () => inspectSyncBack(projectRoot, { runId: selectedRunId ?? undefined, branch, taskId: selectedTaskId }), { runId: selectedRunId ?? undefined, taskId: selectedTaskId }) : null;
 
   return createRuntimeAnalysisReport({
     generatedAt: new Date().toISOString(),
@@ -43,7 +41,6 @@ export async function buildRuntimeAnalysisReport(projectRoot: string, options: R
     runInspection,
     evidenceSummary,
     contextPackage,
-    syncBack,
     inputIssues
   });
 }