sdd-agent-platform 0.4.0 → 0.4.2

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

@@ -1,12 +1,13 @@
-import { readdir, readFile } from 'node:fs/promises';
-import path from 'node:path';
 import { TASK_RUN_EVIDENCE_CONTRACT_VERSION } from '../contracts.js';
-import { getAgentExecutionsDir, getTeamSessionsDir, getWorkerRuntimesDir } from '../runtime-paths.js';
-import { exists } from '../storage/json-io.js';
+import { listAgentExecutionRecords as listRuntimeBackedAgentExecutionRecords, listTeamSessionRecords as listRuntimeBackedTeamSessionRecords } from '../execution/agent-execution-records.js';
+import { listResidentWorkerRuntimeRecords as listRuntimeBackedResidentWorkerRuntimeRecords } from '../execution/resident-worker.js';
+import { listRuntimeTestRuns, listRuntimeTestSteps } from '../storage/runtime-store.js';
 import type { ArtifactIndexEntry, InvocationLedgerEntry, RunState, RunStateArtifactIngestionRecord, RunStateWorktreeLifecycleRecord, RunStatus, RunSummary, RuntimeEvent } from './model.js';
 import { readRunEvents } from './events.js';
 import { listInvocationLedgerEntries } from './invocation-ledger.js';
 import { readRunState, summarizeRunState } from './run-state.js';
+import { readTaskEvidenceView, type TaskEvidenceView } from './task-evidence.js';
+import { buildRunDurationBreakdown } from './timing.js';
 
 export interface TaskRunEvidenceGap {
   type: string;
@@ -26,7 +27,7 @@ export interface AgentExecutionRecordView {
   artifacts: string[];
   toolPermission: { profile?: string } | null;
   routeId: string;
-  routeDecision: { recommendedProfile?: string };
+  routeDecision: { recommendedProfile?: string | null };
   createdAt: string;
   [key: string]: unknown;
 }
@@ -64,7 +65,6 @@ export interface TaskRunEvidenceContract {
   artifacts: ArtifactIndexEntry[];
   validation: RunState['validation'];
   gaps: TaskRunEvidenceGap[];
-  syncBackProposal: string | null;
   invocationLedger: InvocationLedgerEntry[];
   agentExecutions: AgentExecutionRecordView[];
   teamSessions: TeamSessionRecordView[];
@@ -81,9 +81,9 @@ export interface RunInspection {
   artifactIngestions: RunStateArtifactIngestionRecord[];
   worktrees: RunStateWorktreeLifecycleRecord[];
   validation: RunState['validation'];
-  syncBack: RunState['syncBack'];
   tasks: Record<string, unknown>;
   taskRunEvidence: TaskRunEvidenceContract;
+  taskEvidenceView: TaskEvidenceView | null;
   agentExecutions: AgentExecutionRecordView[];
   invocationLedger: InvocationLedgerEntry[];
   teamSessions: TeamSessionRecordView[];
@@ -92,15 +92,21 @@ export interface RunInspection {
 
 export async function inspectRun(projectRoot: string, runId: string): Promise<RunInspection> {
   const state = await readRunState(projectRoot, runId);
-  const [events, agentExecutions, teamSessions, workerRuntimes, invocationLedger] = await Promise.all([
+  const [events, agentExecutions, teamSessions, workerRuntimes, invocationLedger, testRuns, testSteps] = await Promise.all([
     readRunEvents(projectRoot, runId),
-    listAgentExecutionRecords(projectRoot, runId),
-    listTeamSessionRecords(projectRoot, runId),
-    listResidentWorkerRuntimeRecords(projectRoot, runId),
-    listInvocationLedgerEntries(projectRoot, runId)
+    listRuntimeBackedAgentExecutionRecords(projectRoot, runId),
+    listRuntimeBackedTeamSessionRecords(projectRoot, runId),
+    listRuntimeBackedResidentWorkerRuntimeRecords(projectRoot, runId),
+    listInvocationLedgerEntries(projectRoot, runId),
+    listRuntimeTestRuns(projectRoot, runId),
+    listRuntimeTestSteps(projectRoot, { runId })
   ]);
+  const agentExecutionViews = agentExecutions.map((record) => ({ ...record }) as AgentExecutionRecordView);
+  const teamSessionViews = teamSessions.map((record) => ({ ...record }) as TeamSessionRecordView);
+  const workerRuntimeViews = workerRuntimes.map((record) => ({ ...record }) as ResidentWorkerRuntimeRecordView);
+  const taskEvidenceView = state.partition && state.taskId ? await readTaskEvidenceView(projectRoot, { branch: state.partition, taskId: state.taskId }) : null;
   return {
-    summary: summarizeRunState(state),
+    summary: { ...summarizeRunState(state), durationBreakdown: buildRunDurationBreakdown(state, { events, testRuns, testSteps }) },
     state,
     events,
     eventCount: events.length,
@@ -109,56 +115,16 @@ export async function inspectRun(projectRoot: string, runId: string): Promise<Ru
     artifactIngestions: Object.values(state.artifactIngestions ?? {}),
     worktrees: Object.values(state.worktrees ?? {}),
     validation: state.validation,
-    syncBack: state.syncBack,
-    taskRunEvidence: buildTaskRunEvidence(state, events, agentExecutions, teamSessions, workerRuntimes, invocationLedger),
+    taskRunEvidence: buildTaskRunEvidence(state, events, agentExecutionViews, teamSessionViews, workerRuntimeViews, invocationLedger),
+    taskEvidenceView,
     tasks: state.tasks,
-    agentExecutions,
-    teamSessions,
-    workerRuntimes,
+    agentExecutions: agentExecutionViews,
+    teamSessions: teamSessionViews,
+    workerRuntimes: workerRuntimeViews,
     invocationLedger
   };
 }
 
-async function listAgentExecutionRecords(projectRoot: string, runId: string): Promise<AgentExecutionRecordView[]> {
-  const recordsDir = getAgentExecutionsDir(projectRoot, runId);
-  if (!await exists(recordsDir)) {
-    return [];
-  }
-  const records = await readJsonRecords<AgentExecutionRecordView>(recordsDir);
-  return records.sort((left, right) => left.createdAt.localeCompare(right.createdAt) || left.executionId.localeCompare(right.executionId));
-}
-
-async function listTeamSessionRecords(projectRoot: string, runId: string): Promise<TeamSessionRecordView[]> {
-  const recordsDir = getTeamSessionsDir(projectRoot, runId);
-  if (!await exists(recordsDir)) {
-    return [];
-  }
-  const records = await readJsonRecords<TeamSessionRecordView>(recordsDir);
-  return records.sort((left, right) => left.createdAt.localeCompare(right.createdAt) || left.teamId.localeCompare(right.teamId));
-}
-
-async function listResidentWorkerRuntimeRecords(projectRoot: string, runId: string): Promise<ResidentWorkerRuntimeRecordView[]> {
-  const recordsDir = getWorkerRuntimesDir(projectRoot, runId);
-  if (!await exists(recordsDir)) {
-    return [];
-  }
-  const records = await readJsonRecords<ResidentWorkerRuntimeRecordView>(recordsDir);
-  return records.sort((left, right) => left.updatedAt.localeCompare(right.updatedAt) || left.runtimeId.localeCompare(right.runtimeId));
-}
-
-async function readJsonRecords<T>(recordsDir: string): Promise<T[]> {
-  const entries = await readdir(recordsDir, { withFileTypes: true });
-  const records: T[] = [];
-  for (const entry of entries.filter((candidate) => candidate.isFile() && candidate.name.endsWith('.json'))) {
-    try {
-      const raw = await readFile(path.join(recordsDir, entry.name), 'utf8');
-      records.push(JSON.parse(raw) as T);
-    } catch {
-      continue;
-    }
-  }
-  return records;
-}
 
 function buildTaskRunEvidence(state: RunState, events: RuntimeEvent[], agentExecutions: AgentExecutionRecordView[] = [], teamSessions: TeamSessionRecordView[] = [], workerRuntimes: ResidentWorkerRuntimeRecordView[] = [], invocationLedger: InvocationLedgerEntry[] = []): TaskRunEvidenceContract {
   return {
@@ -177,7 +143,6 @@ function buildTaskRunEvidence(state: RunState, events: RuntimeEvent[], agentExec
     artifacts: state.artifacts,
     validation: state.validation,
     gaps: Object.values(state.tasks).flatMap(extractTaskGaps),
-    syncBackProposal: state.syncBack.proposalPath,
     agentExecutions,
     teamSessions,
     workerRuntimes,

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

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
 import { readFile } from 'node:fs/promises';
 import { INVOCATION_LEDGER_CONTRACT_VERSION } from '../contracts.js';
-import { getInvocationLedgerPath } from '../runtime-paths.js';
+import { getLegacyInvocationLedgerPath } from '../runtime-paths.js';
 import { exists } from '../storage/json-io.js';
 import { RuntimeStoreError, legacyImportId, readRuntimeActivities, recordLegacyImportFailure, recordRuntimeActivity, withRuntimeStore } from '../storage/runtime-store.js';
 import type { InvocationLedgerEntry } from './model.js';
@@ -24,7 +24,7 @@ export async function listInvocationLedgerEntries(projectRoot: string, runId: st
   if (entries.length > 0) {
     return entries;
   }
-  const ledgerPath = getInvocationLedgerPath(projectRoot, runId);
+  const ledgerPath = getLegacyInvocationLedgerPath(projectRoot, runId);
   await importLegacyInvocationLedgerIfNeeded(projectRoot, runId, ledgerPath);
   return readRuntimeActivities(projectRoot, runId);
 }

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

@@ -25,8 +25,14 @@ export interface RunDocumentSnapshot {
   specHash: string | null;
   planHash: string | null;
   tasksHash: string | null;
+  specContractHash: string | null;
+  planContractHash: string | null;
+  tasksContractHash: string | null;
+  taskContractHash: string | null;
   planBasedOnSpecHash: string | null;
   tasksBasedOnPlanHash: string | null;
+  planBasedOnSpecContractHash: string | null;
+  tasksBasedOnPlanContractHash: string | null;
 }
 
 export interface RunStateContractValidationIssue {
@@ -84,6 +90,9 @@ export interface RunStateDelegationRecord {
   expectedArtifact: string;
   terminalEventRequired: boolean;
   terminalEventAt?: string | null;
+  attempt?: number;
+  retryOf?: string | null;
+  replayReason?: 'document_contract_refresh' | 'artifact_reingest' | 'validation_replay' | 'manual_retry' | 'runtime_recovery' | null;
 }
 
 export interface RunStateArtifactIngestionRecord {
@@ -99,6 +108,9 @@ export interface RunStateArtifactIngestionRecord {
   ingestedAt: string;
   issues: RunStateContractValidationIssue[];
   gaps: RunStateTaskGap[];
+  contentDigest?: string;
+  retryOf?: string | null;
+  replayReason?: string | null;
 }
 
 export interface RunStateWorktreeLifecycleRecord {
@@ -117,6 +129,28 @@ export interface RunStateWorktreeLifecycleRecord {
   dirty: boolean;
 }
 
+export type RunTaskImplementationStatus = 'not_started' | 'running' | 'implemented' | 'blocked' | 'failed';
+
+export type RunTaskVerificationStatus = 'not_run' | 'pending_batch' | 'ready_for_validation' | 'running' | 'pass' | 'pass_with_gaps' | 'blocked' | 'failed';
+
+export interface RunStateTaskRuntime {
+  status: string;
+  implementationStatus?: RunTaskImplementationStatus;
+  verificationStatus?: RunTaskVerificationStatus;
+  validationBatch?: string | null;
+  validationTiming?: 'task_end' | 'batch_end' | 'wave_end';
+  requiresVerifyBeforeNext?: boolean;
+  gaps?: unknown[];
+  artifacts?: string[];
+  testStatus?: string;
+  validationStatus?: string;
+  verifyStatus?: string;
+  workflowGateStatus?: string;
+  workflowGateDecisionId?: string;
+  evidence?: string[];
+  acceptanceCoverage?: unknown[];
+}
+
 export interface RunState {
   contract: typeof RUN_STATE_CONTRACT;
   runtimeVersion: typeof RUNTIME_VERSION;
@@ -136,7 +170,7 @@ export interface RunState {
   eventLogPath: string;
   artifactRoot: string;
   lifecycleDecision: RunStateLifecycleDecisionRecord | null;
-  tasks: Record<string, unknown>;
+  tasks: Record<string, RunStateTaskRuntime>;
   agents: Record<string, unknown>;
   delegations: Record<string, RunStateDelegationRecord>;
   artifacts: ArtifactIndexEntry[];
@@ -147,15 +181,31 @@ export interface RunState {
     commands: string[];
     evidence: string[];
   };
-  syncBack: {
-    mode: 'proposal';
-    proposalPath: string | null;
-    proposalDigest?: string | null;
-    sourceVerifyStatus?: 'PASS' | 'PASS_WITH_GAPS' | 'FAIL' | 'BLOCKED' | 'completed' | 'blocked' | 'failed' | null;
-    status: 'not_created' | 'proposed' | 'applied';
-  };
 }
 
+export interface RunDurationContributor {
+  kind: 'validation' | 'waiting' | 'blocked' | 'queue_or_bind' | 'host_waiting' | 'unknown_gap';
+  durationMs: number;
+  startedAt: string;
+  endedAt: string;
+  reason: string;
+  refs: string[];
+}
+
+export interface RunDurationBreakdown {
+  elapsedDurationMs: number;
+  activeRuntimeDurationMs: number;
+  validationDurationMs: number;
+  waitingDurationMs: number;
+  blockedDurationMs: number;
+  queueOrBindDurationMs: number;
+  unknownGapDurationMs: number;
+  hostWaitingDurationMs: number;
+  slowReason: RunDurationContributor['kind'] | 'active_runtime' | 'none';
+  topContributors: RunDurationContributor[];
+}
+
+
 export interface RunSummary {
   runId: string;
   status: RunStatus;
@@ -169,9 +219,9 @@ export interface RunSummary {
   createdAt: string;
   updatedAt: string;
   validationStatus: RunState['validation']['status'];
-  syncBackStatus: RunState['syncBack']['status'];
   taskIds: string[];
   artifactCount: number;
+  durationBreakdown: RunDurationBreakdown;
 }
 
 export interface RuntimeEvent {

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

@@ -66,7 +66,6 @@ export interface LocalRunIndexPartitionTaskEntry {
   runId: string;
   runStatus: RunStatus;
   validationStatus: RunState['validation']['status'];
-  syncBackStatus: RunState['syncBack']['status'];
   affectedFiles: string[];
   updatedAt: string;
 }
@@ -78,7 +77,6 @@ export interface LocalRunIndexAffectedFileEntry {
   taskId: string;
   runId: string;
   runStatus: RunStatus;
-  syncBackStatus: RunState['syncBack']['status'];
   updatedAt: string;
 }
 
@@ -232,7 +230,6 @@ async function buildLocalRunIndexSnapshot(projectRoot: string): Promise<LocalRun
         runId: state.runId,
         runStatus: state.status,
         validationStatus: state.validation.status,
-        syncBackStatus: state.syncBack.status,
         affectedFiles: state.affectedFiles,
         updatedAt: state.updatedAt
       };
@@ -250,7 +247,6 @@ async function buildLocalRunIndexSnapshot(projectRoot: string): Promise<LocalRun
             taskId: state.taskId,
             runId: state.runId,
             runStatus: state.status,
-            syncBackStatus: state.syncBack.status,
             updatedAt: state.updatedAt
           });
         }
@@ -336,7 +332,7 @@ function partitionTaskKey(partition: string, taskId: string): string {
 }
 
 function isActiveRunForAffectedFile(state: RunState): boolean {
-  return state.status !== 'archived' && state.syncBack.status !== 'applied' && state.affectedFiles.length > 0;
+  return state.status !== 'archived' && state.affectedFiles.length > 0;
 }
 
 function contractIssue(field: string, message: string, recommendation: string): ContractValidationIssue {

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';
 
@@ -8,6 +8,9 @@ import { initProject } from '../config/init-project.js';
 import { readRunEvents } from './events.js';
 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-'));
@@ -21,6 +24,8 @@ test('createRun writes state and append-only events', async () => {
     const events = await readRunEvents(root, state.runId);
     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 });
   }
@@ -40,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 });
@@ -65,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,14 +1,11 @@
 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 {
-  getAgentExecutionsDir,
-  getEvidenceDir,
+  getLegacyRunDir,
   getProjectConfigPath,
-  getRunDir,
-  getRunsDir,
-  getTeamSessionsDir,
-  getWorkerRuntimesDir
+  getRunEvidenceRoot,
+  getRunsDir
 } from '../runtime-paths.js';
 import { exists } from '../storage/json-io.js';
 import { RuntimeStoreError, legacyImportId, listRuntimeRunStates, readRuntimeRunState, recordLegacyImportFailure, runtimeScopedId, upsertRuntimeRunState, withRuntimeStore } from '../storage/runtime-store.js';
@@ -20,13 +17,14 @@ 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);
   if (storedState) {
     return normalizeRunState(storedState);
   }
-  const statePath = path.join(getRunDir(projectRoot, runId), 'state.json');
+  const statePath = path.join(getLegacyRunDir(projectRoot, runId), 'state.json');
   const legacyState = await importLegacyRunStateIfNeeded(projectRoot, runId, statePath);
   if (legacyState) {
     return legacyState;
@@ -87,22 +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 agentExecutionsDir = getAgentExecutionsDir(projectRoot, runId);
-  const teamSessionsDir = getTeamSessionsDir(projectRoot, runId);
-  const workerRuntimesDir = getWorkerRuntimesDir(projectRoot, runId);
-  await Promise.all([
-    mkdir(agentExecutionsDir, { recursive: true }),
-    mkdir(teamSessionsDir, { recursive: true }),
-    mkdir(workerRuntimesDir, { recursive: true })
-  ]);
-
   const now = new Date().toISOString();
   const state: RunState = {
     contract: RUN_STATE_CONTRACT,
@@ -121,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: {},
@@ -133,11 +121,6 @@ export async function createRun(projectRoot: string, options: CreateRunOptions =
       status: 'not_run',
       commands: [],
       evidence: []
-    },
-    syncBack: {
-      mode: 'proposal',
-      proposalPath: null,
-      status: 'not_created'
     }
   };
 
@@ -145,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',
@@ -175,7 +158,7 @@ export async function createUniqueRunId(projectRoot: string): Promise<string> {
   for (let sequence = 1; sequence <= 999; sequence += 1) {
     const runId = `${base}-${String(sequence).padStart(3, '0')}`;
     const storedState = await readRuntimeRunState(projectRoot, runId);
-    if (!storedState && !await exists(getRunDir(projectRoot, runId))) {
+    if (!storedState && !await exists(getLegacyRunDir(projectRoot, runId))) {
       return runId;
     }
   }
@@ -234,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)
   };
 }
 
@@ -261,8 +244,14 @@ export function normalizeRunDocumentSnapshot(snapshot: unknown): RunDocumentSnap
     specHash: stringOrNull(snapshot.specHash),
     planHash: stringOrNull(snapshot.planHash),
     tasksHash: stringOrNull(snapshot.tasksHash),
+    specContractHash: stringOrNull(snapshot.specContractHash),
+    planContractHash: stringOrNull(snapshot.planContractHash),
+    tasksContractHash: stringOrNull(snapshot.tasksContractHash),
+    taskContractHash: stringOrNull(snapshot.taskContractHash),
     planBasedOnSpecHash: stringOrNull(snapshot.planBasedOnSpecHash),
-    tasksBasedOnPlanHash: stringOrNull(snapshot.tasksBasedOnPlanHash)
+    tasksBasedOnPlanHash: stringOrNull(snapshot.tasksBasedOnPlanHash),
+    planBasedOnSpecContractHash: stringOrNull(snapshot.planBasedOnSpecContractHash),
+    tasksBasedOnPlanContractHash: stringOrNull(snapshot.tasksBasedOnPlanContractHash)
   };
 }
 
@@ -271,8 +260,14 @@ export function emptyRunDocumentSnapshot(): RunDocumentSnapshot {
     specHash: null,
     planHash: null,
     tasksHash: null,
+    specContractHash: null,
+    planContractHash: null,
+    tasksContractHash: null,
+    taskContractHash: null,
     planBasedOnSpecHash: null,
-    tasksBasedOnPlanHash: null
+    tasksBasedOnPlanHash: null,
+    planBasedOnSpecContractHash: null,
+    tasksBasedOnPlanContractHash: null
   };
 }
 
@@ -308,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.`);
@@ -320,13 +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,
-      planBasedOnSpecHash: model.documents.planBasedOnSpecHash ?? null,
-      tasksBasedOnPlanHash: model.documents.tasksBasedOnPlanHash ?? 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
   };
 }