sdd-agent-platform 0.4.0 → 0.4.2

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

@@ -0,0 +1,252 @@
+import { branchToSafePartition } from '../path-safety.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';
+import type { WorkflowGateDecision } from '../workflow-gate/types.js';
+import type { RunState } from './model.js';
+import { resolveWorkflowState } from '../workflow-state/resolve.js';
+import type { LatestEligibleRunCandidate, LatestEligibleRunSelection } from '../workflow-state/latest-eligible-run.js';
+import type { SddTaskGap } from '../sdd-docs/task-parser.js';
+
+export const TASK_EVIDENCE_VIEW_CONTRACT_VERSION = 'phase-8.12-task-evidence-view-v1';
+
+export interface TaskEvidencePayloadGroups {
+  active: RuntimeArtifactPayloadRecord[];
+  candidate: RuntimeArtifactPayloadRecord[];
+  partial: RuntimeArtifactPayloadRecord[];
+  active_attempt: RuntimeArtifactPayloadRecord[];
+  rejected: RuntimeArtifactPayloadRecord[];
+  superseded: RuntimeArtifactPayloadRecord[];
+  quarantined: RuntimeArtifactPayloadRecord[];
+  stale: RuntimeArtifactPayloadRecord[];
+  all: RuntimeArtifactPayloadRecord[];
+}
+
+export interface TaskEvidenceRuntimeActivity {
+  agentExecutions: AgentExecutionRecord[];
+  teamSessions: TeamSessionRecord[];
+  workerRuntimes: ResidentWorkerRuntimeRecord[];
+}
+
+export interface TaskEvidenceValidationView {
+  runValidation: RunState['validation'] | null;
+  testRuns: RuntimeTestRunRecord[];
+  validationWaves: RuntimeValidationWaveRunRecord[];
+  environmentSessions: RuntimeValidationEnvironmentSessionRecord[];
+  acceptanceEvidenceMaps: RuntimeAcceptanceEvidenceMapRecord[];
+}
+
+export interface TaskEvidenceStageTeamView {
+  sessions: StageTeamSessionRecord[];
+  roleResults: StageRoleResultRecord[];
+  advisorAssessments: LlmAdvisorAssessmentRecord[];
+  fanInEvidenceSets: FanInEvidenceSetRecord[];
+}
+
+export interface TaskEvidenceWorkflowGateView {
+  latestDecision: WorkflowGateDecision | null;
+  decisions: WorkflowGateDecision[];
+}
+
+export interface TaskEvidenceView {
+  contract: typeof TASK_EVIDENCE_VIEW_CONTRACT_VERSION;
+  generatedAt: string;
+  retrievalMemoryOnly: false;
+  source: 'runtime.sqlite+branch-evidence-payloads';
+  branch: string;
+  taskId: string;
+  latestEligibleRun: LatestEligibleRunCandidate | null;
+  candidates: LatestEligibleRunCandidate[];
+  rejected: LatestEligibleRunCandidate[];
+  compatibility: LatestEligibleRunCandidate['compatibility'] | null;
+  payloads: TaskEvidencePayloadGroups;
+  validation: TaskEvidenceValidationView;
+  runtimeActivity: TaskEvidenceRuntimeActivity;
+  gaps: SddTaskGap[];
+  durableGaps: RuntimeDurableGapRecord[];
+  stageTeam: TaskEvidenceStageTeamView;
+  workflowGate: TaskEvidenceWorkflowGateView;
+}
+
+export async function readTaskEvidenceView(projectRoot: string, input: { branch?: string | null; taskId: string }): Promise<TaskEvidenceView> {
+  const workflow = await resolveWorkflowState(projectRoot, { branch: input.branch, branchSource: input.branch ? 'cli_option' : undefined, taskId: input.taskId });
+  const selection = workflow.latestEligibleRunsByTask.find((entry) => entry.taskId === input.taskId) ?? emptySelection(workflow.branch, input.taskId);
+  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, runtimeActivity, durableGaps, stageTeam, workflowGate] = selection.selected
+    ? await Promise.all([
+      listRuntimeTestRuns(projectRoot, selection.selected.runId),
+      readValidationWaveEvidence(projectRoot, workflow.branch, input.taskId, 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),
+      readWorkflowGateEvidence(projectRoot, workflow.branch, input.taskId, selection.selected.runId)
+    ])
+    : await Promise.all([
+      Promise.resolve([]),
+      readValidationWaveEvidence(projectRoot, workflow.branch, input.taskId, null),
+      Promise.resolve(emptyRuntimeActivity()),
+      listRuntimeDurableGaps(projectRoot, { partition: workflow.branch, taskId: input.taskId, status: 'open_terminal' }),
+      readStageTeamEvidence(projectRoot, workflow.branch, input.taskId, null),
+      readWorkflowGateEvidence(projectRoot, workflow.branch, input.taskId, null)
+    ]);
+
+  const [validationWaves, environmentSessions, acceptanceEvidenceMaps] = validationWaveEvidence;
+  return {
+    contract: TASK_EVIDENCE_VIEW_CONTRACT_VERSION,
+    generatedAt: new Date().toISOString(),
+    retrievalMemoryOnly: false,
+    source: 'runtime.sqlite+branch-evidence-payloads',
+    branch: workflow.branch,
+    taskId: input.taskId,
+    latestEligibleRun: selection.selected,
+    candidates: selection.candidates,
+    rejected: selection.rejected,
+    compatibility: selection.selected?.compatibility ?? null,
+    payloads,
+    validation: {
+      runValidation: selectedRunState?.validation ?? null,
+      testRuns: testRuns.filter((run) => run.taskId === input.taskId),
+      validationWaves,
+      environmentSessions,
+      acceptanceEvidenceMaps
+    },
+    runtimeActivity,
+    gaps: [...workflow.visibleGaps.filter((gap) => gap.taskId === input.taskId || gap.taskId === null), ...runtimeTaskGaps(selectedRunState?.tasks[input.taskId])],
+    durableGaps,
+    stageTeam,
+    workflowGate
+  };
+}
+
+function emptySelection(partition: string, taskId: string): LatestEligibleRunSelection {
+  return { partition, taskId, selected: null, candidates: [], rejected: [] };
+}
+
+function uniqueRunIds(selection: LatestEligibleRunSelection): string[] {
+  return Array.from(new Set([...selection.candidates, ...selection.rejected].map((candidate) => candidate.runId)));
+}
+
+async function readTaskPayloads(projectRoot: string, branch: string, taskId: string, runIds: string[]): Promise<TaskEvidencePayloadGroups> {
+  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: 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);
+  const waveRunIds = validationWaves.map((wave) => wave.waveRunId);
+  const [environmentSessions, acceptanceEvidenceMaps] = await Promise.all([
+    Promise.all(waveRunIds.map((waveRunId) => listRuntimeValidationEnvironmentSessions(projectRoot, { partition, waveRunId }))).then((items) => items.flat()),
+    Promise.all(waveRunIds.map((waveRunId) => listRuntimeAcceptanceEvidenceMaps(projectRoot, { partition, taskId, waveRunId }))).then((items) => items.flat())
+  ]);
+  return [validationWaves, environmentSessions, acceptanceEvidenceMaps];
+}
+
+
+async function readRuntimeActivity(projectRoot: string, runId: string): Promise<TaskEvidenceRuntimeActivity> {
+  const [agentExecutions, teamSessions, workerRuntimes] = await Promise.all([
+    listRuntimeAgentExecutions(projectRoot, runId),
+    listRuntimeTeamSessions(projectRoot, runId),
+    listRuntimeWorkerRuntimes(projectRoot, runId)
+  ]);
+  return { agentExecutions, teamSessions, workerRuntimes };
+}
+
+async function readStageTeamEvidence(projectRoot: string, partition: string, taskId: string, runId: string | null): Promise<TaskEvidenceStageTeamView> {
+  const query = runId ? { partition, taskId, runId } : { partition, taskId };
+  const [sessions, roleResults, advisorAssessments, fanInEvidenceSets] = await Promise.all([
+    listRuntimeStageTeamSessions(projectRoot, query),
+    listRuntimeStageRoleResults(projectRoot, query),
+    listRuntimeLlmAdvisorAssessments(projectRoot, query),
+    listRuntimeFanInEvidenceSets(projectRoot, query)
+  ]);
+  return { sessions, roleResults, advisorAssessments, fanInEvidenceSets };
+}
+
+async function readWorkflowGateEvidence(projectRoot: string, partition: string, taskId: string, runId: string | null): Promise<TaskEvidenceWorkflowGateView> {
+  const query = runId ? { partition, taskId, runId } : { partition, taskId };
+  const decisions = await listRuntimeWorkflowGateDecisions(projectRoot, query);
+  return { latestDecision: decisions[0] ?? null, decisions };
+}
+
+function emptyRuntimeActivity(): TaskEvidenceRuntimeActivity {
+  return { agentExecutions: [], teamSessions: [], workerRuntimes: [] };
+}
+
+function runtimeTaskGaps(taskState: unknown): SddTaskGap[] {
+  if (!taskState || typeof taskState !== 'object' || !('gaps' in taskState)) {
+    return [];
+  }
+  const gaps = (taskState as { gaps?: unknown }).gaps;
+  return Array.isArray(gaps) ? gaps.filter(isTaskGap) : [];
+}
+
+function isTaskGap(value: unknown): value is SddTaskGap {
+  if (!value || typeof value !== 'object') {
+    return false;
+  }
+  const gap = value as Partial<SddTaskGap>;
+  return typeof gap.type === 'string' && typeof gap.severity === 'string' && typeof gap.field === 'string' && typeof gap.message === 'string' && typeof gap.recommendation === 'string';
+}

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

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

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
   });
 }

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

@@ -5,10 +5,8 @@ import type {
   RuntimeAnalysisReport,
   RuntimeAnalysisReportInput,
   RuntimeAnalysisRunInspectionLike,
-  RuntimeAnalysisStatus,
-  RuntimeAnalysisSyncBackLike
+  RuntimeAnalysisStatus
 } from './model.js';
-
 export function createRuntimeAnalysisReport(input: RuntimeAnalysisReportInput): RuntimeAnalysisReport {
   const findings = buildRuntimeAnalysisFindings(input);
   return {
@@ -30,7 +28,6 @@ export function createRuntimeAnalysisReport(input: RuntimeAnalysisReportInput):
     runInspection: input.runInspection,
     evidenceSummary: input.evidenceSummary,
     contextPackage: input.contextPackage,
-    syncBack: input.syncBack,
     findings
   };
 }
@@ -76,7 +73,7 @@ export function buildRuntimeAnalysisFindings(input: RuntimeAnalysisReportInput):
       category: 'run',
       source: input.status.latestRun?.runId ?? 'latest-run',
       message: reason,
-      action: input.status.latestRun?.currentTask ? `sdd test task ${input.status.latestRun.currentTask} --branch ${input.branch}` : undefined,
+      action: input.status.latestRun?.currentTask ? `sdd test task-${input.status.latestRun.currentTask} --branch ${input.branch}` : undefined,
       runId: input.status.latestRun?.runId ?? undefined,
       taskId: input.status.latestRun?.currentTask ?? undefined
     });
@@ -173,9 +170,6 @@ export function buildRuntimeAnalysisFindings(input: RuntimeAnalysisReportInput):
       });
     }
   }
-  if (input.syncBack) {
-    addSyncBackFindings(input.syncBack, add);
-  }
   for (const issue of input.inputIssues) {
     add({
       severity: 'warning',
@@ -209,18 +203,7 @@ function addRunInspectionFindings(run: RuntimeAnalysisRunInspectionLike, add: (f
       category: 'run',
       source: `${run.summary.runId}:validation`,
       message: `Run validation status is ${run.validation.status}.`,
-      action: run.summary.currentTask ? `sdd test task ${run.summary.currentTask} --branch ${run.summary.partition ?? run.summary.gitBranch ?? 'master'}` : undefined,
-      runId: run.summary.runId,
-      taskId: run.summary.currentTask ?? undefined
-    });
-  }
-  if (run.syncBack.status === 'proposed') {
-    add({
-      severity: 'warning',
-      category: 'sync_back',
-      source: `${run.summary.runId}:sync_back`,
-      message: 'Run has an unapplied sync-back proposal.',
-      action: run.summary.currentTask ? `sdd sync-back inspect --branch ${run.summary.partition ?? run.summary.gitBranch ?? 'master'} --task ${run.summary.currentTask}` : undefined,
+      action: run.summary.currentTask ? `sdd test task-${run.summary.currentTask} --branch ${run.summary.partition ?? run.summary.gitBranch ?? 'master'}` : undefined,
       runId: run.summary.runId,
       taskId: run.summary.currentTask ?? undefined
     });
@@ -233,7 +216,7 @@ function addEvidenceSummaryFindings(summary: RuntimeAnalysisEvidenceSummaryLike,
     category: 'evidence',
     source: `evidence:${summary.runId}`,
     message: 'Evidence summary is derived guidance only and cannot satisfy PASS evidence.',
-    action: summary.taskId ? `sdd test task ${summary.taskId}` : undefined,
+    action: summary.taskId ? `sdd test task-${summary.taskId}` : undefined,
     runId: summary.runId,
     taskId: summary.taskId ?? undefined
   });
@@ -243,7 +226,7 @@ function addEvidenceSummaryFindings(summary: RuntimeAnalysisEvidenceSummaryLike,
       category: 'evidence',
       source: `evidence:${summary.runId}`,
       message: `Evidence projection has pass=${summary.passCount}, blocked=${summary.blockedCount}, fail=${summary.failCount}.`,
-      action: summary.taskId ? `sdd test task ${summary.taskId}` : undefined,
+      action: summary.taskId ? `sdd test task-${summary.taskId}` : undefined,
       runId: summary.runId,
       taskId: summary.taskId ?? undefined
     });
@@ -254,36 +237,13 @@ function addEvidenceSummaryFindings(summary: RuntimeAnalysisEvidenceSummaryLike,
       category: 'evidence',
       source: `evidence:${summary.runId}`,
       message: `Evidence quality issues: ${summary.issueCodes.join(', ')}.`,
-      action: summary.taskId ? `sdd artifact validate ${summary.runId} <artifact> --task ${summary.taskId} --agent <agent>` : undefined,
+      action: summary.taskId ? `sdd test task-${summary.taskId}` : 'sdd status --compact-json',
       runId: summary.runId,
       taskId: summary.taskId ?? undefined
     });
   }
 }
 
-function addSyncBackFindings(syncBack: RuntimeAnalysisSyncBackLike, add: (finding: RuntimeAnalysisFinding) => void): void {
-  if (syncBack.status === 'ready') {
-    add({
-      severity: 'warning',
-      category: 'sync_back',
-      source: syncBack.targetTasksPath,
-      message: `Sync-back is ready for ${syncBack.taskId ?? 'unknown task'} but not applied.`,
-      action: `sdd sync-back apply ${syncBack.runId} --branch ${syncBack.branch} --task ${syncBack.taskId ?? '<task_id>'}${syncBack.applyPolicy.requiresApproval ? ' --approved' : ''}`,
-      runId: syncBack.runId,
-      taskId: syncBack.taskId ?? undefined
-    });
-  } else if (syncBack.status === 'blocked') {
-    add({
-      severity: 'blocking',
-      category: 'sync_back',
-      source: syncBack.targetTasksPath,
-      message: `Sync-back is blocked: ${syncBack.reasons.join('; ')}`,
-      action: `sdd sync-back inspect ${syncBack.runId} --branch ${syncBack.branch} --task ${syncBack.taskId ?? '<task_id>'}`,
-      runId: syncBack.runId,
-      taskId: syncBack.taskId ?? undefined
-    });
-  }
-}
 
 export function summarizeRuntimeAnalysisStatus(findings: RuntimeAnalysisFinding[]): RuntimeAnalysisStatus {
   if (findings.some((finding) => finding.severity === 'blocking')) {

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

@@ -48,7 +48,6 @@ export interface RuntimeAnalysisRunInspectionLike {
   summary: { runId: string; currentTask: string | null; partition: string | null; gitBranch: string | null };
   state: { status: string };
   validation: { status: string };
-  syncBack: { status: string };
 }
 
 export interface RuntimeAnalysisEvidenceSummaryLike {
@@ -71,19 +70,10 @@ export interface RuntimeAnalysisContextPackageLike {
   nextCommands: string[];
 }
 
-export interface RuntimeAnalysisSyncBackLike {
-  runId: string;
-  branch: string;
-  taskId: string | null;
-  status: 'ready' | 'blocked' | 'applied';
-  reasons: string[];
-  targetTasksPath: string;
-  applyPolicy: { requiresApproval: boolean };
-}
 
 export type RuntimeAnalysisStatus = 'PASS' | 'WARN' | 'BLOCKED';
 export type RuntimeAnalysisFindingSeverity = 'info' | 'warning' | 'blocking';
-export type RuntimeAnalysisFindingCategory = 'workflow' | 'doctor' | 'run_index' | 'run' | 'evidence' | 'sync_back' | 'task_graph' | 'wave_plan' | 'context';
+export type RuntimeAnalysisFindingCategory = 'workflow' | 'doctor' | 'run_index' | 'run' | 'evidence' | 'task_graph' | 'wave_plan' | 'context';
 
 export interface RuntimeAnalysisOptions {
   branch?: string | null;
@@ -124,7 +114,6 @@ export interface RuntimeAnalysisReportInput {
   runInspection: RuntimeAnalysisRunInspectionLike | null;
   evidenceSummary: RuntimeAnalysisEvidenceSummaryLike | null;
   contextPackage: RuntimeAnalysisContextPackageLike | null;
-  syncBack: RuntimeAnalysisSyncBackLike | null;
   inputIssues: RuntimeAnalysisInputIssue[];
 }
 
@@ -147,6 +136,5 @@ export interface RuntimeAnalysisReport {
   runInspection: RuntimeAnalysisRunInspectionLike | null;
   evidenceSummary: RuntimeAnalysisEvidenceSummaryLike | null;
   contextPackage: RuntimeAnalysisContextPackageLike | null;
-  syncBack: RuntimeAnalysisSyncBackLike | null;
   findings: RuntimeAnalysisFinding[];
 }

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

@@ -59,8 +59,6 @@ test('runtime analysis report composes workflow runtime evidence and non-authori
     assert.equal(report.contextPackage?.taskId, 'T1');
     assert.equal(report.contextPackage?.authoritative, false);
     assert.equal(report.contextPackage?.usableForPass, false);
-    assert.equal(report.syncBack?.status, 'ready');
-    assert.equal(report.findings.some((finding) => finding.category === 'sync_back' && finding.action?.includes('sdd sync-back apply run-1 --branch feature --task T1')), true);
     assert.equal(report.findings.some((finding) => finding.category === 'evidence' && finding.message.includes('cannot satisfy PASS evidence')), true);
   } finally {
     await rm(root, { recursive: true, force: true });