sdd-agent-platform 0.4.1 → 0.4.2

package/node_modules/@sdd-agent-platform/core/src/router/stage-route-binding.ts

@@ -0,0 +1,279 @@
+import type { RuntimeRef, SddStage } from '../contracts.js';
+import { readLifecycleRiskDecisionProjection } from '../risk/kernel.js';
+import { resolveSddContext } from '../sdd-docs/context.js';
+import { parseSddBranch, type SddTask, type SddTaskModel } from '../sdd-docs/task-parser.js';
+import { STAGE_ROUTE_BINDING_PRODUCER_VERSION, STAGE_ROUTE_BINDING_PROJECTION_TYPE, runtimeProjectionStableHash } from '../runtime-projection-p0.js';
+import { recordRuntimeProjectionEnvelope, type RuntimeProjectionEnvelopeWriteResult } from '../storage/runtime-store.js';
+
+export const STAGE_ROUTE_BINDING_CONTRACT_VERSION = 'sdd-stage-route-binding-v1' as const;
+
+export type StageRouteEntry = 'sdd:plan' | 'sdd:tasks' | 'sdd:do' | 'sdd:test' | 'sdd:ship';
+export type SddCommandBundle = 'plan' | 'tasks' | 'do' | 'test' | 'ship';
+export type StageRouteBindingStatus = 'bound' | 'ambiguous' | 'not_found' | 'stale_upstream' | 'boundary_expanding' | 'blocked';
+export type StageRouteTargetKind = 'task' | 'stage' | 'gate' | 'evidence_set' | 'ship_scope';
+export type StageRouteBindingNextAction = 'enter_stage' | 'run_internal_stage' | 'ask_clarification' | 'route_to_lifecycle_decision' | 'runtime_repair_required' | 'blocked';
+
+export interface StageRouteBinding {
+  contract: typeof STAGE_ROUTE_BINDING_CONTRACT_VERSION;
+  branch: string;
+  entry: StageRouteEntry;
+  bundle: SddCommandBundle;
+  targetRuntimeStage: SddStage;
+  userText: string;
+  status: StageRouteBindingStatus;
+  targetKind: StageRouteTargetKind | null;
+  targetId: string | null;
+  matchedRefs: RuntimeRef[];
+  activeLifecycleDecisionRef: string | null;
+  nextAction: StageRouteBindingNextAction;
+  reasons: string[];
+}
+
+interface TaskMatchCandidate {
+  task: SddTask;
+  score: number;
+}
+
+export async function bindStageRoute(projectRoot: string, input: { entry: StageRouteEntry; branch?: string; userText?: string }): Promise<StageRouteBinding> {
+  const context = await resolveSddContext(projectRoot, { branch: input.branch, branchSource: input.branch ? 'cli_option' : undefined });
+  const model = await parseSddBranch(projectRoot, context.partition);
+  return bindStageRouteForModel(projectRoot, {
+    branch: context.partition,
+    model,
+    entry: input.entry,
+    userText: input.userText ?? ''
+  });
+}
+
+export async function bindStageRouteForModel(projectRoot: string, input: { branch: string; model: SddTaskModel; entry: StageRouteEntry; userText?: string }): Promise<StageRouteBinding> {
+  const userText = (input.userText ?? '').trim();
+  const activeLifecycleDecisionRef = (await readLifecycleRiskDecisionProjection(projectRoot, { branch: input.branch }))?.id ?? null;
+  if (input.entry === 'sdd:do') {
+    return bindDoTask(input.branch, input.model, userText, activeLifecycleDecisionRef);
+  }
+  return bindBundleStage(input.branch, input.entry, userText, activeLifecycleDecisionRef);
+}
+
+export function stageRouteBindingScopeKey(binding: Pick<StageRouteBinding, 'branch' | 'entry' | 'userText'>): string {
+  return [binding.branch, binding.entry, runtimeProjectionStableHash(binding.userText || '<empty>').slice(0, 16)].join(':');
+}
+
+export async function recordStageRouteBindingProjection(projectRoot: string, binding: StageRouteBinding): Promise<RuntimeProjectionEnvelopeWriteResult<StageRouteBinding>> {
+  return recordRuntimeProjectionEnvelope(projectRoot, {
+    projectionType: STAGE_ROUTE_BINDING_PROJECTION_TYPE,
+    scopeKey: stageRouteBindingScopeKey(binding),
+    inputHash: runtimeProjectionStableHash(binding),
+    producer: 'phase9.18-stage-route-binding-runtime',
+    producerVersion: STAGE_ROUTE_BINDING_PRODUCER_VERSION,
+    payload: binding
+  });
+}
+
+function bindDoTask(branch: string, model: SddTaskModel, userText: string, activeLifecycleDecisionRef: string | null): StageRouteBinding {
+  const staleReason = doStageStaleReason(model);
+  if (staleReason) {
+    return binding({
+      branch,
+      entry: 'sdd:do',
+      targetRuntimeStage: 'do',
+      userText,
+      status: 'stale_upstream',
+      targetKind: 'task',
+      targetId: null,
+      matchedRefs: [],
+      activeLifecycleDecisionRef,
+      nextAction: 'runtime_repair_required',
+      reasons: [staleReason]
+    });
+  }
+
+  const matches = matchTasks(model.tasks, userText);
+  if (matches.length === 0) {
+    const looksLikeId = looksLikeTaskId(userText);
+    return binding({
+      branch,
+      entry: 'sdd:do',
+      targetRuntimeStage: 'do',
+      userText,
+      status: looksLikeId ? 'not_found' : 'boundary_expanding',
+      targetKind: 'task',
+      targetId: null,
+      matchedRefs: [],
+      activeLifecycleDecisionRef,
+      nextAction: looksLikeId ? 'ask_clarification' : 'route_to_lifecycle_decision',
+      reasons: looksLikeId
+        ? [`Task ${userText || '<empty>'} was not found in the accepted task set.`]
+        : [`No accepted task boundary matched "${userText}"; run /sdd or /sdd:spec if this is new scope, risk, or acceptance.`]
+    });
+  }
+
+  const topScore = matches[0].score;
+  const tied = matches.filter((candidate) => candidate.score === topScore);
+  if (tied.length > 1) {
+    return binding({
+      branch,
+      entry: 'sdd:do',
+      targetRuntimeStage: 'do',
+      userText,
+      status: 'ambiguous',
+      targetKind: 'task',
+      targetId: null,
+      matchedRefs: tied.map((candidate) => taskRuntimeRef(candidate.task)),
+      activeLifecycleDecisionRef,
+      nextAction: 'ask_clarification',
+      reasons: [`Ambiguous task text "${userText}" matched ${tied.map((candidate) => candidate.task.id).join(', ')}; specify a task id or more precise title.`]
+    });
+  }
+
+  const task = matches[0].task;
+  return binding({
+    branch,
+    entry: 'sdd:do',
+    targetRuntimeStage: 'do',
+    userText,
+    status: 'bound',
+    targetKind: 'task',
+    targetId: task.id,
+    matchedRefs: [taskRuntimeRef(task)],
+    activeLifecycleDecisionRef,
+    nextAction: 'enter_stage',
+    reasons: [`Bound "${userText}" to task ${task.id}.`]
+  });
+}
+
+function bindBundleStage(branch: string, entry: Exclude<StageRouteEntry, 'sdd:do'>, userText: string, activeLifecycleDecisionRef: string | null): StageRouteBinding {
+  const targetRuntimeStage = bundleTargetRuntimeStage(entry, userText);
+  return binding({
+    branch,
+    entry,
+    targetRuntimeStage,
+    userText,
+    status: 'bound',
+    targetKind: entry === 'sdd:ship' ? 'ship_scope' : 'stage',
+    targetId: targetRuntimeStage,
+    matchedRefs: [{ kind: entry === 'sdd:ship' ? 'projection' : 'command', ref: `${entry}:${targetRuntimeStage}` }],
+    activeLifecycleDecisionRef,
+    nextAction: targetRuntimeStage === bundleForEntry(entry) ? 'enter_stage' : 'run_internal_stage',
+    reasons: [`Bound ${entry} to runtime stage ${targetRuntimeStage}.`]
+  });
+}
+
+function binding(input: Omit<StageRouteBinding, 'contract' | 'bundle'>): StageRouteBinding {
+  return {
+    contract: STAGE_ROUTE_BINDING_CONTRACT_VERSION,
+    bundle: bundleForEntry(input.entry),
+    ...input
+  };
+}
+
+function bundleForEntry(entry: StageRouteEntry): SddCommandBundle {
+  if (entry === 'sdd:plan') return 'plan';
+  if (entry === 'sdd:tasks') return 'tasks';
+  if (entry === 'sdd:do') return 'do';
+  if (entry === 'sdd:test') return 'test';
+  return 'ship';
+}
+
+function bundleTargetRuntimeStage(entry: Exclude<StageRouteEntry, 'sdd:do'>, userText: string): SddStage {
+  const normalized = normalizeSearchText(userText);
+  if (entry === 'sdd:plan') return 'plan';
+  if (entry === 'sdd:tasks') return normalized.includes('verif') || normalized.includes('verify') ? 'verifies' : 'tasks';
+  if (entry === 'sdd:test') return normalized.includes('goalverify') || normalized.includes('goal') ? 'goal-verify' : 'test';
+  return 'ship';
+}
+
+function doStageStaleReason(model: SddTaskModel): string | null {
+  if (model.documents.tasksStale) {
+    return 'Tasks document is stale; return to the tasks bundle before executing do-stage binding.';
+  }
+  if (model.documents.verifyStale) {
+    return 'Verify document is stale; return to the tasks/verifies bundle before executing do-stage binding.';
+  }
+  return null;
+}
+
+function matchTasks(tasks: SddTask[], userText: string): TaskMatchCandidate[] {
+  const query = normalizeSearchText(userText);
+  if (!query) {
+    return [];
+  }
+  return tasks
+    .map((task) => ({ task, score: scoreTask(task, userText, query) }))
+    .filter((candidate) => candidate.score >= 40)
+    .sort((left, right) => right.score - left.score || left.task.id.localeCompare(right.task.id));
+}
+
+function scoreTask(task: SddTask, rawQuery: string, normalizedQuery: string): number {
+  const normalizedId = normalizeSearchText(task.id);
+  if (normalizedId === normalizedQuery) {
+    return 1000;
+  }
+  if (normalizedId.includes(normalizedQuery) && normalizedQuery.length >= 2) {
+    return 700;
+  }
+
+  let score = 0;
+  score = Math.max(score, scoreTextField(task.title ?? '', rawQuery, normalizedQuery, 600, 360, 80));
+  score = Math.max(score, scoreTextField(task.acceptance.join(' '), rawQuery, normalizedQuery, 260, 180, 35));
+  score = Math.max(score, scoreTextField(task.boundary ?? '', rawQuery, normalizedQuery, 180, 120, 24));
+  score = Math.max(score, scoreTextField(task.affectedFiles.join(' '), rawQuery, normalizedQuery, 120, 80, 12));
+  return score;
+}
+
+function scoreTextField(value: string, rawQuery: string, normalizedQuery: string, exactScore: number, containsScore: number, tokenWeight: number): number {
+  const normalizedValue = normalizeSearchText(value);
+  if (!normalizedValue) {
+    return 0;
+  }
+  if (normalizedValue === normalizedQuery) {
+    return exactScore;
+  }
+  if ((normalizedValue.includes(normalizedQuery) || normalizedQuery.includes(normalizedValue)) && Math.min(normalizedValue.length, normalizedQuery.length) >= 2) {
+    return containsScore;
+  }
+  const queryTokens = searchTokens(rawQuery);
+  const valueTokens = searchTokens(value);
+  let overlap = 0;
+  for (const token of queryTokens) {
+    if (valueTokens.has(token)) {
+      overlap += 1;
+    }
+  }
+  return overlap * tokenWeight;
+}
+
+function normalizeSearchText(value: string): string {
+  return value.toLocaleLowerCase().normalize('NFKC').replace(/[\s\p{P}\p{S}_-]+/gu, '');
+}
+
+const LOW_SIGNAL_SEARCH_TOKENS = new Set(['system', 'systems', 'feature', 'features', '功能', '系统', '模块', '服务', '任务', '实现', '完成', '边界']);
+
+function searchTokens(value: string): Set<string> {
+  const tokens = new Set<string>();
+  const normalized = value.toLocaleLowerCase().normalize('NFKC');
+  for (const match of normalized.matchAll(/[a-z0-9]+/g)) {
+    addSearchToken(tokens, match[0]);
+  }
+  for (const match of normalized.matchAll(/\p{Script=Han}+/gu)) {
+    const text = match[0];
+    addSearchToken(tokens, text);
+    for (let index = 0; index < text.length - 1; index += 1) {
+      addSearchToken(tokens, text.slice(index, index + 2));
+    }
+  }
+  return tokens;
+}
+
+function addSearchToken(tokens: Set<string>, token: string): void {
+  if (token.length >= 2 && !LOW_SIGNAL_SEARCH_TOKENS.has(token)) {
+    tokens.add(token);
+  }
+}
+
+function looksLikeTaskId(value: string): boolean {
+  return /^[a-z][a-z0-9._-]*-?\d+$/i.test(value.trim());
+}
+
+function taskRuntimeRef(task: SddTask): RuntimeRef {
+  return { kind: 'task', ref: `task:${task.id}` };
+}

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

@@ -2,3 +2,5 @@ export * from './router/agent-runtime-config.js';
 export * from './router/agent-runtime.js';
 export * from './router/route-cache.js';
 export * from './router/route-sdd-task.js';
+export * from './router/stage-route-binding.js';
+export * from './router/runtime-import.js';

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

@@ -1,8 +1,9 @@
 import { createHash } from 'node:crypto';
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
-import { getEvidenceAttachmentPath, getLegacyArtifactPath, getRunRelativeArtifactPath, normalizeArtifactRootRelativePath } from '../runtime-paths.js';
-import { readRuntimeRunState, recordRuntimeArtifactPayload, recordRuntimeEvidenceAttachment, resolveRuntimeArtifactPayload, runtimeScopedId, withRuntimeStore } from '../storage/runtime-store.js';
+import { getBranchStageEvidencePathFromRef, getEvidenceAttachmentPath, getLegacyArtifactPath, getRunRelativeArtifactPath, getRuntimeStorePath, isBranchStageEvidenceRef, normalizeArtifactRootRelativePath, normalizeBranchStageEvidenceRef, toBranchStageEvidenceRef } from '../runtime-paths.js';
+import { readRuntimeRunState, recordRuntimeArtifactPayload, recordRuntimeEvidenceAttachment, resolveRuntimeArtifactPayload, runtimeScopedId, withRuntimeStore, type RuntimeArtifactPayloadRecord } from '../storage/runtime-store.js';
+import type { SddStage } from '../contracts.js';
 import { appendArtifactHashLedgerEntry } from './invocation-ledger.js';
 
 export async function writeArtifact(projectRoot: string, runId: string, artifactRootRelativePath: string, content: string): Promise<{ absolutePath: string; runRelativePath: string }> {
@@ -47,20 +48,144 @@ export async function writeArtifact(projectRoot: string, runId: string, artifact
   return { absolutePath, runRelativePath };
 }
 
+export async function recordStageEvidenceArtifact(projectRoot: string, runId: string, stageEvidenceRef: string, content: string, options: { taskId?: string | null; artifactRole?: string } = {}): Promise<{ absolutePath: string; runRelativePath: string }> {
+  const runRelativePath = normalizeBranchStageEvidenceRef(stageEvidenceRef);
+  const runScope = await resolveRunScope(projectRoot, runId);
+  const taskId = options.taskId ?? runScope.taskId;
+  const contentHash = hashDocumentContent(content);
+  const absolutePath = getBranchStageEvidencePathFromRef(projectRoot, runRelativePath);
+  await mkdir(path.dirname(absolutePath), { recursive: true });
+  await writeFile(absolutePath, content, 'utf8');
+  await appendArtifactHashLedgerEntry(projectRoot, {
+    runId,
+    taskId,
+    branch: runScope.branchSlug,
+    artifactPath: runRelativePath,
+    content,
+    status: 'written'
+  });
+  await recordRuntimeArtifact(projectRoot, { runId, path: runRelativePath, content, status: 'written', taskId });
+  await recordRuntimeArtifactPayload(projectRoot, {
+    payloadId: runtimeScopedId(runId, runRelativePath, contentHash),
+    runId,
+    sourceRunId: runId,
+    branchSlug: runScope.branchSlug,
+    taskId,
+    logicalRef: runRelativePath,
+    physicalPayloadPath: runRelativePath,
+    artifactRole: options.artifactRole ?? artifactKind(runRelativePath),
+    digest: contentHash,
+    status: 'active',
+    payload: { logicalRef: runRelativePath, physicalPayloadPath: runRelativePath, storage: 'stage-evidence', status: 'written' }
+  });
+  await recordRuntimeEvidenceAttachment(projectRoot, {
+    branchSlug: runScope.branchSlug,
+    runId,
+    taskId,
+    kind: options.artifactRole ?? artifactKind(runRelativePath),
+    relativePath: runRelativePath,
+    contentHash,
+    bytes: Buffer.byteLength(content, 'utf8'),
+    payload: { logicalRef: runRelativePath, physicalPayloadPath: runRelativePath, storage: 'stage-evidence', status: 'written' }
+  });
+  return { absolutePath, runRelativePath };
+}
+
+export async function recordRuntimeOnlyArtifact(projectRoot: string, runId: string, artifactRootRelativePath: string, content: string, options: { logicalRef?: string; branch?: string | null; taskId?: string | null; artifactRole?: string } = {}): Promise<{ absolutePath: string; runRelativePath: string }> {
+  const normalized = normalizeArtifactRootRelativePath(artifactRootRelativePath);
+  const runRelativePath = options.logicalRef ?? getRunRelativeArtifactPath(normalized);
+  const runScope = await resolveRunScope(projectRoot, runId);
+  const branchSlug = options.branch ?? runScope.branchSlug;
+  const taskId = options.taskId ?? runScope.taskId;
+  const contentHash = hashDocumentContent(content);
+  const physicalPayloadPath = `runtime.sqlite:${runId}:${runRelativePath}`;
+  await appendArtifactHashLedgerEntry(projectRoot, {
+    runId,
+    taskId,
+    branch: branchSlug,
+    artifactPath: runRelativePath,
+    content,
+    status: 'recorded'
+  });
+  await recordRuntimeArtifact(projectRoot, { runId, path: runRelativePath, content, status: 'recorded', taskId });
+  await recordRuntimeArtifactPayload(projectRoot, {
+    payloadId: runtimeScopedId(runId, runRelativePath, contentHash),
+    runId,
+    sourceRunId: runId,
+    branchSlug,
+    taskId,
+    logicalRef: runRelativePath,
+    physicalPayloadPath,
+    artifactRole: options.artifactRole ?? artifactKind(runRelativePath),
+    digest: contentHash,
+    status: 'active',
+    payload: { logicalRef: runRelativePath, physicalPayloadPath, storage: 'runtime.sqlite', content }
+  });
+  await recordRuntimeEvidenceAttachment(projectRoot, {
+    branchSlug,
+    runId,
+    taskId,
+    kind: options.artifactRole ?? artifactKind(runRelativePath),
+    relativePath: physicalPayloadPath,
+    contentHash,
+    bytes: Buffer.byteLength(content, 'utf8'),
+    payload: { logicalRef: runRelativePath, physicalPayloadPath, storage: 'runtime.sqlite' }
+  });
+  return { absolutePath: `${getRuntimeStorePath(projectRoot)}#${runRelativePath}`, runRelativePath };
+}
+
 export async function readArtifact(projectRoot: string, runId: string, artifactRootRelativePath: string): Promise<string> {
   const normalized = normalizeArtifactRootRelativePath(artifactRootRelativePath);
   const runRelativePath = getRunRelativeArtifactPath(normalized);
-  const payload = await resolveRuntimeArtifactPayload(projectRoot, runId, runRelativePath);
   const runScope = await resolveRunScope(projectRoot, runId);
-  const evidencePath = getEvidenceAttachmentPath(projectRoot, runScope.branchSlug, payload?.physicalPayloadPath ?? runRelativePath);
+  const payload = await resolveRuntimeArtifactPayload(projectRoot, runId, runRelativePath)
+    ?? await resolveRuntimeArtifactPayload(projectRoot, runId, runtimeStageEvidenceRef(runScope.branchSlug, normalized));
+  const payloadContent = runtimePayloadContent(payload);
+  if (payloadContent !== null) {
+    return payloadContent;
+  }
   if (payload) {
-    return readFile(evidencePath, 'utf8');
+    if (isBranchStageEvidenceRef(payload.physicalPayloadPath)) {
+      return readFile(getBranchStageEvidencePathFromRef(projectRoot, payload.physicalPayloadPath), 'utf8');
+    }
+    return readFile(getEvidenceAttachmentPath(projectRoot, runScope.branchSlug, payload.physicalPayloadPath), 'utf8');
   }
+  const stageEvidenceRef = runtimeStageEvidenceRef(runScope.branchSlug, normalized);
   try {
-    return await readFile(evidencePath, 'utf8');
+    return await readFile(getBranchStageEvidencePathFromRef(projectRoot, stageEvidenceRef), 'utf8');
   } catch {
-    return readFile(getLegacyArtifactPath(projectRoot, runId, normalized), 'utf8');
+    try {
+      return await readFile(getEvidenceAttachmentPath(projectRoot, runScope.branchSlug, runRelativePath), 'utf8');
+    } catch {
+      return readFile(getLegacyArtifactPath(projectRoot, runId, normalized), 'utf8');
+    }
+  }
+}
+
+function runtimePayloadContent(payload: RuntimeArtifactPayloadRecord | null): string | null {
+  if (!payload || !payload.payload || typeof payload.payload !== 'object' || Array.isArray(payload.payload)) {
+    return null;
   }
+  const content = (payload.payload as { content?: unknown }).content;
+  return typeof content === 'string' ? content : null;
+}
+
+function runtimeStageEvidenceRef(branch: string, artifactRootRelativePath: string): string {
+  const fileName = path.posix.basename(artifactRootRelativePath.replace(/\\/g, '/'));
+  return toBranchStageEvidenceRef(branch, runtimeStageForArtifact(fileName), fileName);
+}
+
+function runtimeStageForArtifact(fileName: string): SddStage {
+  if (fileName.startsWith('acceptance-coverage-')) {
+    return 'goal-verify';
+  }
+  if (fileName.startsWith('test-') || fileName.startsWith('validation-')) {
+    return 'test';
+  }
+  if (fileName.startsWith('ship-') || fileName.startsWith('release-')) {
+    return 'ship';
+  }
+  return 'do';
 }
 
 function uniquePhysicalPayloadPath(logicalRef: string, runId: string, digest: string): string {
@@ -89,9 +214,6 @@ export function artifactKind(artifactPath: string): string {
   if (fileName.startsWith('gap-report-')) {
     return 'gap-report';
   }
-  if (fileName === 'sync-back-proposal.md') {
-    return 'sync-back-proposal';
-  }
   return 'artifact';
 }
 

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

@@ -1,11 +1,13 @@
 import { TASK_RUN_EVIDENCE_CONTRACT_VERSION } from '../contracts.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;
@@ -63,7 +65,6 @@ export interface TaskRunEvidenceContract {
   artifacts: ArtifactIndexEntry[];
   validation: RunState['validation'];
   gaps: TaskRunEvidenceGap[];
-  syncBackProposal: string | null;
   invocationLedger: InvocationLedgerEntry[];
   agentExecutions: AgentExecutionRecordView[];
   teamSessions: TeamSessionRecordView[];
@@ -80,7 +81,6 @@ export interface RunInspection {
   artifactIngestions: RunStateArtifactIngestionRecord[];
   worktrees: RunStateWorktreeLifecycleRecord[];
   validation: RunState['validation'];
-  syncBack: RunState['syncBack'];
   tasks: Record<string, unknown>;
   taskRunEvidence: TaskRunEvidenceContract;
   taskEvidenceView: TaskEvidenceView | null;
@@ -92,19 +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),
     listRuntimeBackedAgentExecutionRecords(projectRoot, runId),
     listRuntimeBackedTeamSessionRecords(projectRoot, runId),
     listRuntimeBackedResidentWorkerRuntimeRecords(projectRoot, runId),
-    listInvocationLedgerEntries(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,
@@ -113,7 +115,6 @@ 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, agentExecutionViews, teamSessionViews, workerRuntimeViews, invocationLedger),
     taskEvidenceView,
     tasks: state.tasks,
@@ -142,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/model.ts

@@ -28,6 +28,7 @@ export interface RunDocumentSnapshot {
   specContractHash: string | null;
   planContractHash: string | null;
   tasksContractHash: string | null;
+  taskContractHash: string | null;
   planBasedOnSpecHash: string | null;
   tasksBasedOnPlanHash: string | null;
   planBasedOnSpecContractHash: string | null;
@@ -89,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 {
@@ -104,6 +108,9 @@ export interface RunStateArtifactIngestionRecord {
   ingestedAt: string;
   issues: RunStateContractValidationIssue[];
   gaps: RunStateTaskGap[];
+  contentDigest?: string;
+  retryOf?: string | null;
+  replayReason?: string | null;
 }
 
 export interface RunStateWorktreeLifecycleRecord {
@@ -174,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;
@@ -196,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 {