sdd-agent-platform 0.4.1 → 0.4.2

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

@@ -1,5 +1,5 @@
-import { readdir, stat } from 'node:fs/promises';
-import path from 'node:path';
+import { readFile } from 'node:fs/promises';
+
 import { inspectAiToolEntryEvidence } from './checks/ai-entries.js';
 import { inspectDocumentChainEvidence } from './checks/document-chain.js';
 import { inspectLocalRunIndexEvidence } from './checks/local-run-index.js';
@@ -7,10 +7,15 @@ import { inspectGitRepository, inspectProjectConfig, inspectRunsDirectoryAccess,
 import { inspectRunEvidence } from './checks/run-evidence.js';
 import { inspectAgentCapabilityCatalogDoctorContract, inspectAgentSkillTeamRuntimeDoctorContract, inspectCapabilityRegistry, inspectCommandTeamRuntimeDoctorContract, inspectGovernancePolicyContract, inspectHarnessLearningDoctorContract, inspectProjectContextPackDoctorContract, inspectQueryStatusBoundaryContract, inspectSkillAgentEvalDoctorContract, inspectToolPluginContracts } from './checks/registries.js';
 import { inspectBackgroundExecutorContract, inspectDelegationQueueContract, inspectDelegationStateMachineContract, inspectLocalRunIndexContract, inspectTaskGraphPlannerContract, inspectWaveExecutorContract, inspectWavePlannerContract, inspectWorkerAdapterContracts, inspectWorktreeIsolationContract, inspectWorktreeLifecycleContract } from './checks/runtime-contracts.js';
-import { inspectRuntimeStoreEvidence, listRuntimeSyncBackDecisions } from '../storage/runtime-store.js';
-import { getLegacyAgentExecutionsDir, getLegacyRunDir, getLegacyTeamSessionsDir, getLegacyWorkerRuntimesDir } from '../runtime-paths.js';
+import { inspectRuntimeStoreEvidence, listRuntimeRepairs, listRuntimeTestRuns, listRuntimeTestSteps, listRuntimeValidationCacheEntries, listRuntimeValidationCacheUses, recordRuntimeRepair, type RuntimeRepairRecord } from '../storage/runtime-store.js';
+
 import { branchToSafePartition } from '../path-safety.js';
 import { readAllRunStates } from '../run-state/run-state.js';
+import { readRunEvents } from '../run-state/events.js';
+import { buildRunDurationBreakdown } from '../run-state/timing.js';
+import { parseSddBranch } from '../sdd-docs/task-parser.js';
+import { buildMixedVersionRecoveryPlan } from '../workflow-state/migration-recovery.js';
+import { buildOpenRepairRecord } from '../workflow-state/repair-contract.js';
 import { getProjectStatus, statuslineProjectionFromStatus, type ProjectStatus } from '../status/project-status.js';
 import type { DoctorCheck, DoctorReport } from './model.js';
 import { summarizeDoctorStatus } from './summary.js';
@@ -68,7 +73,14 @@ export async function doctor(projectRoot: string, options: { allRuns?: boolean;
   checks.push(...inspectDurableGapRuntime(statusSnapshot));
   checks.push(...inspectStageTeamRuntime(statusSnapshot));
   checks.push(...inspectWorkflowGateRuntime(statusSnapshot));
-  checks.push(...await inspectPhase818Compatibility(projectRoot, options));
+  checks.push(...inspectSpecCollaborationRuntime(statusSnapshot));
+  checks.push(...await inspectRuntimePerformanceObservability(projectRoot, options));
+  checks.push(...await inspectValidationCacheVisibility(projectRoot, options));
+  checks.push(...await inspectMixedVersionRecovery(projectRoot, statusSnapshot, options));
+  
+
+  checks.push(...await inspectRepairRecords(projectRoot, options));
+  await recordDoctorRepairs(projectRoot, checks, options.branch ?? null);
 
   return {
     status: summarizeDoctorStatus(checks),
@@ -101,83 +113,191 @@ function unavailableRuntimeCheck(check: string, label: string, error: unknown):
   }];
 }
 
-async function inspectPhase818Compatibility(projectRoot: string, options: { allRuns?: boolean; branch?: string | null } = {}): Promise<DoctorCheck[]> {
+const STALE_OPEN_RUN_MS = 30 * 60 * 1000;
+const WAITING_DOMINATED_MIN_MS = 10_000;
+const SLOW_VALIDATION_STEP_MS = 30_000;
+
+async function inspectRuntimePerformanceObservability(projectRoot: string, options: { allRuns?: boolean; branch?: string | null } = {}): Promise<DoctorCheck[]> {
   try {
     const branchPartition = options.branch ? branchToSafePartition(options.branch) : null;
     const states = (await readAllRunStates(projectRoot))
       .filter((state) => options.allRuns || state.status !== 'archived')
       .filter((state) => !branchPartition || state.partition === branchPartition || state.gitBranch === options.branch || (state.gitBranch ? branchToSafePartition(state.gitBranch) === branchPartition : false));
-    const legacyRunFiles: string[] = [];
-    const legacySidecars: string[] = [];
-    const syncBackJsonOnly: string[] = [];
-    const syncBackDivergence: string[] = [];
+    const staleOpenRuns: string[] = [];
+    const missingTestSteps: string[] = [];
+    const waitingDominatedRuns: string[] = [];
+    const slowValidationSteps: string[] = [];
+    const hostNoOutputRuns: string[] = [];
 
     for (const state of states) {
-      const legacyRunDir = getLegacyRunDir(projectRoot, state.runId);
-      const runLocalFiles = ['state.json', 'events.jsonl', 'invocations.jsonl'];
-      for (const fileName of runLocalFiles) {
-        if (await fileExists(path.join(legacyRunDir, fileName))) {
-          legacyRunFiles.push(`${state.runId}:${fileName}`);
-        }
+      const ageMs = Date.now() - Date.parse(state.updatedAt);
+      if (!isTerminalRunStatus(state.status) && Number.isFinite(ageMs) && ageMs >= STALE_OPEN_RUN_MS) {
+        staleOpenRuns.push(state.runId);
       }
 
-      const sidecarDirs = [
-        getLegacyAgentExecutionsDir(projectRoot, state.runId),
-        getLegacyTeamSessionsDir(projectRoot, state.runId),
-        getLegacyWorkerRuntimesDir(projectRoot, state.runId)
-      ];
-      if ((await Promise.all(sidecarDirs.map(directoryHasEntries))).some(Boolean)) {
-        legacySidecars.push(state.runId);
+      const [events, testRuns, testSteps] = await Promise.all([
+        readRunEvents(projectRoot, state.runId),
+        listRuntimeTestRuns(projectRoot, state.runId),
+        listRuntimeTestSteps(projectRoot, { runId: state.runId })
+      ]);
+      if (testRuns.length > 0 && testSteps.length === 0) {
+        missingTestSteps.push(state.runId);
       }
 
-      const decisions = await listRuntimeSyncBackDecisions(projectRoot, state.runId);
-      const latestDecision = decisions[0] ?? null;
-      if (state.syncBack.status !== 'not_created' && !latestDecision) {
-        syncBackJsonOnly.push(state.runId);
+      const breakdown = buildRunDurationBreakdown(state, { events, testRuns, testSteps });
+      if (breakdown.waitingDurationMs >= WAITING_DOMINATED_MIN_MS && breakdown.waitingDurationMs > breakdown.activeRuntimeDurationMs) {
+        waitingDominatedRuns.push(`${state.runId}:${breakdown.waitingDurationMs}ms`);
+      }
+      if (breakdown.hostWaitingDurationMs >= WAITING_DOMINATED_MIN_MS && testSteps.length === 0) {
+        hostNoOutputRuns.push(`${state.runId}:${breakdown.hostWaitingDurationMs}ms`);
       }
-      if (latestDecision && latestDecision.status !== state.syncBack.status) {
-        syncBackDivergence.push(`${state.runId}:${state.syncBack.status}->${latestDecision.status}`);
+      for (const step of testSteps) {
+        if (step.durationMs >= SLOW_VALIDATION_STEP_MS) {
+          slowValidationSteps.push(`${step.runId}:${step.stepId}:${step.durationMs}ms`);
+        }
       }
     }
 
-    const oldSyncBackProjection = await fileExists(path.join(projectRoot, '.claude', 'commands', 'sdd', 'syncback.md'));
-    return [
-      legacyRunFiles.length > 0
-        ? { level: 'WARN', check: 'phase8_18_legacy_run_files', message: `legacy_run_files=${legacyRunFiles.join(',')}`, action: 'Runtime authority is runtime.sqlite; keep legacy run-local state/events/invocation files as import fallback only.' }
-        : { level: 'PASS', check: 'phase8_18_legacy_run_files', message: 'No legacy run-local state, event, or invocation files found in inspected runs.' },
-      legacySidecars.length > 0
-        ? { level: 'WARN', check: 'phase8_18_legacy_sidecars', message: `legacy_sidecar_runs=${legacySidecars.join(',')}`, action: 'Runtime authority is runtime.sqlite; keep old sidecars as import fallback and avoid writing new per-run structured sidecars.' }
-        : { level: 'PASS', check: 'phase8_18_legacy_sidecars', message: 'No legacy per-run agent/team/worker sidecar directories found in inspected runs.' },
-      syncBackJsonOnly.length > 0 || syncBackDivergence.length > 0
-        ? { level: 'WARN', check: 'phase8_18_sync_back_compat', message: `state_json_only=${syncBackJsonOnly.join(',') || 'none'} divergence=${syncBackDivergence.join(',') || 'none'}`, action: 'Use sdd sync-back inspect only for explicit diagnostic/recovery/replay, then reconcile canonical sync_back_decisions before relying on write-back state.' }
-        : { level: 'PASS', check: 'phase8_18_sync_back_compat', message: 'Canonical sync_back_decisions are consistent with inspected run compatibility summaries.' },
-      oldSyncBackProjection
-        ? { level: 'WARN', check: 'phase8_18_ai_projection_compat', message: 'Found legacy /sdd:syncback projection at .claude/commands/sdd/syncback.md.', action: 'Run sdd update to remove obsolete managed syncback projection; use diagnostic sync-back only when explicitly requested.' }
-        : { level: 'PASS', check: 'phase8_18_ai_projection_compat', message: 'No legacy /sdd:syncback projection found.' },
-      { level: 'PASS', check: 'phase9_readiness', message: 'code_graph_signals=optional_advisory_only authority=phase8_runtime_policy', action: 'Phase 9 graph providers may feed risk/context/test-impact/status/doctor signals but cannot replace Phase 8 gate truth.' }
-    ];
+    const warnings = staleOpenRuns.length + missingTestSteps.length + waitingDominatedRuns.length + slowValidationSteps.length + hostNoOutputRuns.length;
+    return [{
+      level: warnings > 0 ? 'WARN' : 'PASS',
+      check: 'runtime_performance_observability',
+      message: `runs=${states.length} stale_open=${staleOpenRuns.join(',') || 'none'} missing_test_steps=${missingTestSteps.join(',') || 'none'} waiting_dominated=${waitingDominatedRuns.join(',') || 'none'} slow_validation=${slowValidationSteps.join(',') || 'none'} host_no_output=${hostNoOutputRuns.join(',') || 'none'}`,
+      action: warnings > 0 ? 'Inspect run duration breakdowns with sdd run inspect; persist test_steps for validation commands and investigate long waiting or host-no-output gaps.' : undefined
+    }];
   } catch (error) {
-    return unavailableRuntimeCheck('phase8_18_compatibility', 'Phase 8.18 compatibility diagnostics', error);
+    return unavailableRuntimeCheck('runtime_performance_observability', 'runtime performance observability', error);
   }
 }
 
-async function directoryHasEntries(directory: string): Promise<boolean> {
+async function inspectValidationCacheVisibility(projectRoot: string, options: { branch?: string | null } = {}): Promise<DoctorCheck[]> {
   try {
-    return (await readdir(directory)).length > 0;
-  } catch {
-    return false;
+    const branchPartition = options.branch ? branchToSafePartition(options.branch) : null;
+    const entries = await listRuntimeValidationCacheEntries(projectRoot, { branchSlug: branchPartition, status: 'valid' });
+    const uses = await listRuntimeValidationCacheUses(projectRoot, { branchSlug: branchPartition });
+    const staleEntries = entries.filter((entry) => !entry.payload || typeof entry.payload !== 'object' || !('cachePlan' in entry.payload));
+    return [{
+      level: staleEntries.length > 0 ? 'WARN' : 'PASS',
+      check: 'validation_cache_visibility',
+      message: `entries=${entries.length} uses=${uses.length} stale_entries=${staleEntries.map((entry) => entry.cacheKey).join(',') || 'none'} hit_sources=${[...new Set(uses.map((use) => use.sourceTestRunId))].join(',') || 'none'}`,
+      action: staleEntries.length > 0 ? 'Replay stale validation cache entries; cache hits must remain tied to current cachePlan payload and accepted evidence mapping.' : undefined
+    }];
+  } catch (error) {
+    return unavailableRuntimeCheck('validation_cache_visibility', 'validation cache visibility', error);
   }
 }
 
-async function fileExists(filePath: string): Promise<boolean> {
+async function inspectRepairRecords(projectRoot: string, options: { branch?: string | null } = {}): Promise<DoctorCheck[]> {
   try {
-    await stat(filePath);
-    return true;
+    const branchPartition = options.branch ? branchToSafePartition(options.branch) : null;
+    const repairs = await listRuntimeRepairs(projectRoot, { branchSlug: branchPartition, status: 'open' });
+    return [{
+      level: repairs.length > 0 ? 'WARN' : 'PASS',
+      check: 'repair_records',
+      message: `open=${repairs.length} types=${[...new Set(repairs.map((repair) => repair.repairType))].join(',') || 'none'} next=${repairs.flatMap((repair) => repair.recommendedCommands).slice(0, 3).join(' | ') || 'none'}`,
+      action: repairs.length > 0 ? 'Resolve open repair records with new accepted evidence or a fresh gate PASS; diagnostic text alone does not close repairs.' : undefined
+    }];
+  } catch (error) {
+    return unavailableRuntimeCheck('repair_records', 'repair records', error);
+  }
+}
+
+async function recordDoctorRepairs(projectRoot: string, checks: DoctorCheck[], branch: string | null): Promise<void> {
+  const branchSlug = branch ? branchToSafePartition(branch) : 'master';
+  const repairable = checks.filter((check) => doctorCheckCreatesRepair(check));
+  const repairableCheckNames = new Set(repairable.map((check) => check.check));
+  try {
+    const openRepairs = await listRuntimeRepairs(projectRoot, { branchSlug, status: 'open' });
+    for (const repair of openRepairs) {
+      const checkName = doctorRepairCheckName(repair);
+      if (checkName && (!repairableCheckNames.has(checkName) || repair.recommendedCommands.some((command) => !doctorRepairCommandLooksExecutable(command)))) {
+        await recordRuntimeRepair(projectRoot, {
+          ...repair,
+          status: 'superseded',
+          resolvedAt: new Date().toISOString(),
+          payload: { ...doctorRepairPayload(repair.payload), supersededBy: 'doctor_fail_check_cleared' }
+        });
+      }
+    }
   } catch {
-    return false;
+    return;
+  }
+  for (const check of repairable) {
+    try {
+      await recordRuntimeRepair(projectRoot, buildOpenRepairRecord({
+        branchSlug,
+        message: `${check.check}: ${check.message}`,
+        recommendedCommands: doctorRepairCommands(branchSlug, check),
+        requiredEvidence: ['new accepted evidence or fresh gate PASS']
+      }));
+    } catch {
+      return;
+    }
   }
 }
 
+function doctorCheckCreatesRepair(check: DoctorCheck): boolean {
+  return check.check !== 'repair_records' && check.check !== 'capability_health' && check.level === 'FAIL';
+}
+
+function doctorRepairCheckName(repair: RuntimeRepairRecord): string | null {
+  const blocker = repair.blockers[0] ?? '';
+  const separator = blocker.indexOf(':');
+  return separator > 0 ? blocker.slice(0, separator) : null;
+}
+
+function doctorRepairPayload(payload: unknown): Record<string, unknown> {
+  return payload && typeof payload === 'object' && !Array.isArray(payload) ? payload as Record<string, unknown> : { previousPayload: payload };
+}
+
+function doctorRepairCommands(branchSlug: string, check: DoctorCheck): string[] {
+  if (check.check === 'ai_entry_projection') {
+    return ['sdd update'];
+  }
+  if (check.check === 'capability_health') {
+    return [`sdd status --branch ${branchSlug} --compact-json`];
+  }
+  if (check.check === 'document_chain' || check.check === 'verify_contract' || check.message.includes('verify.md')) {
+    return [`sdd verifies write --branch ${branchSlug} --force`];
+  }
+  return [`sdd doctor --branch ${branchSlug} --latest-only`];
+}
+
+function doctorRepairCommandLooksExecutable(command: string): boolean {
+  const normalized = command.trim().toLowerCase();
+  return normalized.startsWith('sdd ') || normalized.startsWith('npm ') || normalized.startsWith('node ') || normalized.startsWith('npx ');
+}
+
+function isTerminalRunStatus(status: string): boolean {
+  return status === 'completed' || status === 'failed' || status === 'blocked' || status === 'archived';
+}
+
+
+async function inspectMixedVersionRecovery(projectRoot: string, snapshot: DoctorProjectStatusSnapshot, options: { branch?: string | null } = {}): Promise<DoctorCheck[]> {
+  if (!snapshot.status) {
+    return unavailableRuntimeCheck('mixed_version_recovery', 'mixed-version recovery plan', snapshot.error);
+  }
+  try {
+    const model = await parseSddBranch(projectRoot, snapshot.status.branch);
+    const verifyText = model.documents.verifyExists ? await readFile(model.verifyPath, 'utf8') : null;
+    const plan = buildMixedVersionRecoveryPlan({ model, latestEligibleRunsByTask: snapshot.status.latestEligibleRunsByTask, verifyText });
+    const blocking = plan.detectedIssues.filter((issue) => issue.severity === 'blocking').length;
+    const warnings = plan.detectedIssues.filter((issue) => issue.severity === 'warn').length;
+    const legacyArtifacts = plan.detectedIssues.filter((issue) => issue.kind === 'legacy_artifact_ref').map((issue) => `${issue.taskId}:${issue.current}->${issue.expected}`);
+    const strictStale = plan.staleRunImpact.map((impact) => `${impact.taskId}:${impact.runId}`);
+    return [{
+      level: blocking > 0 ? 'FAIL' : warnings > 0 || plan.staleRunImpact.length > 0 ? 'WARN' : 'PASS',
+      check: 'mixed_version_recovery',
+      message: `issues=${plan.detectedIssues.length} safe_fixes=${plan.safeMechanicalUpdates.length} behavior_changes=${plan.behaviorChangingUpdates.length} legacy_artifacts=${legacyArtifacts.join(',') || 'none'} stale_runs=${strictStale.join(',') || 'none'} replay=${plan.evidenceReplayNeeded.join(',') || 'none'} next=${plan.nextCommands.join(' | ')}`,
+      action: plan.detectedIssues.length > 0 ? 'Apply only safe mechanical fixes in dry-run/preview first, then replay validation evidence; do not promote legacy stale runs as accepted truth.' : undefined
+    }];
+  } catch (error) {
+    return unavailableRuntimeCheck('mixed_version_recovery', 'mixed-version recovery plan', error);
+  }
+}
+
+
+
 function inspectContextTokenRuntime(snapshot: DoctorProjectStatusSnapshot): DoctorCheck[] {
   if (!snapshot.status) {
     return unavailableRuntimeCheck('context_token_runtime', 'token runtime projection', snapshot.error);
@@ -200,7 +320,7 @@ function inspectLifecycleRiskRuntime(snapshot: DoctorProjectStatusSnapshot): Doc
     level: risk.status === 'blocked' || risk.status === 'incompatible' || risk.approvalPolicy === 'blocked' ? 'FAIL' : risk.status === 'missing' || risk.status === 'stale' || risk.approvalPolicy === 'human-required' ? 'WARN' : 'PASS',
     check: 'lifecycle_risk_decision',
     message: `status=${risk.status} profile=${risk.profile ?? 'none'} approval=${risk.approvalPolicy ?? 'none'} input=${risk.inputHash ?? 'none'} expected=${risk.expectedInputHash}`,
-    action: risk.status === 'fresh' ? undefined : `Run lifecycle risk projection for ${risk.scopeKey}; workflow gates now consume this decision directly.`
+    action: risk.status === 'fresh' ? undefined : `sdd status --branch ${snapshot.status.branch} --compact-json`
   }];
 }
 
@@ -213,7 +333,7 @@ function inspectWorkflowHandoffRuntime(snapshot: DoctorProjectStatusSnapshot): D
     level: handoff.status === 'blocked' || handoff.status === 'rejected' || handoff.status === 'incompatible' ? 'FAIL' : handoff.status === 'stale' ? 'WARN' : 'PASS',
     check: 'workflow_handoff_state',
     message: `status=${handoff.status} active_stage=${handoff.activeStage?.stage ?? 'none'} latest_stage=${handoff.latestStageRun?.stage ?? 'none'} latest_handoff=${handoff.latestHandoff ? `${handoff.latestHandoff.fromStage}->${handoff.latestHandoff.toStage}:${handoff.latestHandoff.status}` : 'none'} stage_projections=${handoff.projectionCounts.stageRuns} handoff_projections=${handoff.projectionCounts.handoffs}`,
-    action: handoff.status === 'fresh' || handoff.status === 'missing' ? undefined : `Resolve workflow handoff projection for ${snapshot.status.branch}; workflow gates now consume this state directly.`
+    action: handoff.status === 'fresh' || handoff.status === 'missing' ? undefined : `sdd status --branch ${snapshot.status.branch} --compact-json`
   }];
 }
 
@@ -251,8 +371,8 @@ function inspectCapabilityHealthRuntime(snapshot: DoctorProjectStatusSnapshot):
   return [{
     level: health.status === 'blocked' ? 'FAIL' : health.status === 'warn' ? 'WARN' : 'PASS',
     check: 'capability_health',
-    message: `status=${health.status} baseline=${health.baselineDomains.length}/${health.requiredProfessionalDomains.length} packs=${health.materialPacks} active=${health.activeDomains.join(',') || 'none'} sources_quarantined=${health.sources.quarantined} sources_denied=${health.sources.denied} evidence_candidate=${health.evidence.candidate} release_critical_gaps=${health.releaseCriticalGaps.join(',') || 'none'}`,
-    action: health.status === 'pass' ? undefined : health.reasons.join(' ')
+    message: `status=${health.status} baseline=${health.baselineDomains.length}/${health.requiredProfessionalDomains.length} packs=${health.materialPacks} active=${health.activeDomains.join(',') || 'none'} sources_quarantined=${health.sources.quarantined} sources_denied=${health.sources.denied} evidence_candidate=${health.evidence.candidate} adoptions=${health.adoptions.adopted}/${health.adoptions.rejected}/${health.adoptions.unresolved} adoption_closures=${health.adoptions.releaseCriticalClosures.join(',') || 'none'} release_critical_gaps=${health.releaseCriticalGaps.join(',') || 'none'}`, 
+    action: health.status === 'pass' ? undefined : `sdd status --branch ${snapshot.status.branch} --compact-json`
   }];
 }
 
@@ -285,6 +405,21 @@ function inspectStageTeamRuntime(snapshot: DoctorProjectStatusSnapshot): DoctorC
   }];
 }
 
+function inspectSpecCollaborationRuntime(snapshot: DoctorProjectStatusSnapshot): DoctorCheck[] {
+  if (!snapshot.status) {
+    return unavailableRuntimeCheck('spec_collaboration_runtime', 'spec collaboration runtime', snapshot.error);
+  }
+  const health = snapshot.status.specCollaborationHealth;
+  const level = health.status === 'blocked' || health.status === 'rejected' || health.status === 'incompatible' ? 'FAIL' : health.status === 'needs_clarification' ? 'WARN' : 'PASS';
+  return [{
+    level,
+    check: 'spec_collaboration_runtime',
+    message: `status=${health.status} projections=${health.projectionCount} clarification=${health.latestClarificationGateId ?? 'none'} handoff=${health.latestHandoffId ?? 'none'} rejection=${health.latestRejectionReason ?? 'none'}`,
+    action: level === 'PASS' ? undefined : health.reasons.join(' ')
+  }];
+}
+
+
 function inspectDurableGapRuntime(snapshot: DoctorProjectStatusSnapshot): DoctorCheck[] {
   if (!snapshot.status) {
     return unavailableRuntimeCheck('durable_gap_runtime', 'durable gap runtime', snapshot.error);

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

@@ -41,16 +41,24 @@ export async function lookupEvidence(projectRoot: string, filters: EvidenceLooku
     generatedAt: new Date().toISOString(),
     retrievalMemoryOnly: true,
     gateTruthAuthority: false,
-    reason: 'Evidence Lookup is retrieval memory over SQLite metadata and payload refs; PASS, verify, and sync-back authority must use runtime evidence gates.',
+    reason: 'Evidence Lookup is retrieval memory over SQLite metadata and payload refs; PASS, verify, and truth-alignment authority must use runtime evidence gates.',
     filters,
     payloads: filtered,
     resolvedPayloads,
-    counts: {
-      active: filtered.filter((payload) => payload.status === 'active').length,
-      candidate: filtered.filter((payload) => payload.status === 'candidate').length,
-      rejected: filtered.filter((payload) => payload.status === 'rejected').length,
-      superseded: filtered.filter((payload) => payload.status === 'superseded').length
-    }
+    counts: countByStatus(filtered)
+  };
+}
+
+function countByStatus(payloads: RuntimeArtifactPayloadRecord[]): Record<RuntimeArtifactPayloadStatus, number> {
+  return {
+    active: payloads.filter((payload) => payload.status === 'active').length,
+    candidate: payloads.filter((payload) => payload.status === 'candidate').length,
+    partial: payloads.filter((payload) => payload.status === 'partial').length,
+    active_attempt: payloads.filter((payload) => payload.status === 'active_attempt').length,
+    rejected: payloads.filter((payload) => payload.status === 'rejected').length,
+    superseded: payloads.filter((payload) => payload.status === 'superseded').length,
+    quarantined: payloads.filter((payload) => payload.status === 'quarantined').length,
+    stale: payloads.filter((payload) => payload.status === 'stale').length
   };
 }
 

package/node_modules/@sdd-agent-platform/core/src/evidence-runtime/contracts.ts

@@ -42,7 +42,6 @@ export interface UnifiedTestEvidenceRun {
   commands: TestCommandEvidence[];
   acceptanceCoverage: AcceptanceEvidenceCoverage[];
   capabilityEvidence: CapabilityEvidenceClassification[];
-  syncBackReady: boolean;
   gaps: string[];
   next: string;
   generatedAt: string;

package/node_modules/@sdd-agent-platform/core/src/execution/background-executor.test.ts

@@ -10,14 +10,22 @@ import { writeArtifact } from '../run-state/artifacts.js';
 import { readRunState } from '../run-state/run-state.js';
 import { validResultArtifact, validTaskMarkdown, writeBranchDocs } from '../test-support/fixtures.js';
 import { writeVerifyContract } from '../verification/verify-contract.js';
+import { evaluateLifecycleRiskDecisionForModel, recordLifecycleRiskDecisionProjection } from '../risk.js';
+import { parseSddBranch } from '../sdd-docs/task-parser.js';
 import { inspectBackgroundExecutor, runBackgroundExecutor } from './background-executor.js';
 
+async function seedLifecycleRiskDecision(root: string, branch: string): Promise<void> {
+  const model = await parseSddBranch(root, branch);
+  await recordLifecycleRiskDecisionProjection(root, evaluateLifecycleRiskDecisionForModel(branch, model));
+}
+
 test('background executor claims one delegation and persists background run state', async () => {
   const root = await mkdtemp(path.join(tmpdir(), 'sdd-background-claim-'));
   try {
     await initProject(root);
     await writeBranchDocs(root, 'master', validTaskMarkdown('B1', []));
     await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
+    await seedLifecycleRiskDecision(root, 'master');
 
     const result = await runBackgroundExecutor(root, { taskId: 'B1' });
     const state = await readRunState(root, result.runId);
@@ -42,6 +50,7 @@ test('background executor ingests supplied artifact and reaches terminal state',
     await initProject(root);
     await writeBranchDocs(root, 'master', validTaskMarkdown('B1', []));
     await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
+    await seedLifecycleRiskDecision(root, 'master');
 
     const claimed = await runBackgroundExecutor(root, { taskId: 'B1' });
     await writeArtifact(root, claimed.runId, 'implementer-B1.md', validResultArtifact('implementer', 'B1', 'PASS', 'artifacts/implementer-B1.md'));
@@ -66,17 +75,53 @@ test('background executor ingests supplied artifact and reaches terminal state',
   }
 });
 
+test('background executor replays changed terminal artifact into a new attempt', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-background-replay-'));
+  try {
+    await initProject(root);
+    await writeBranchDocs(root, 'master', validTaskMarkdown('B1', []));
+    await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
+    await seedLifecycleRiskDecision(root, 'master');
+
+    const claimed = await runBackgroundExecutor(root, { taskId: 'B1' });
+    await writeArtifact(root, claimed.runId, 'implementer-B1.md', validResultArtifact('implementer', 'B1', 'PASS', 'artifacts/implementer-B1.md'));
+    const completed = await runBackgroundExecutor(root, {
+      runId: claimed.runId,
+      taskId: 'B1',
+      artifactPath: 'artifacts/implementer-B1.md'
+    });
+    await writeArtifact(root, claimed.runId, 'implementer-B1.md', `${validResultArtifact('implementer', 'B1', 'PASS', 'artifacts/implementer-B1.md')}\nReplay evidence.\n`);
+    const replayed = await runBackgroundExecutor(root, {
+      runId: claimed.runId,
+      taskId: 'B1',
+      artifactPath: 'artifacts/implementer-B1.md'
+    });
+    const state = await readRunState(root, claimed.runId);
+
+    assert.equal(completed.status, 'completed');
+    assert.equal(replayed.status, 'completed');
+    assert.equal(replayed.delegationId, 'B-B1-implementer-001');
+    assert.equal(replayed.ingestion?.delegationId, 'B-B1-implementer-002');
+    assert.equal(replayed.ingestion?.retryOf, 'B-B1-implementer-001');
+    assert.equal(state.delegations['B-B1-implementer-001']?.status, 'COMPLETED');
+    assert.equal(state.delegations['B-B1-implementer-002']?.status, 'COMPLETED');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
 test('claude code subagent worker spawns host process and ingests stdout artifact', async () => {
   const root = await mkdtemp(path.join(tmpdir(), 'sdd-background-claude-host-'));
   try {
     await initProject(root);
     await writeBranchDocs(root, 'master', validTaskMarkdown('B1', []));
     await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
+    await seedLifecycleRiskDecision(root, 'master');
     const hostScript = path.join(root, 'fake-claude-host.mjs');
     await writeFile(hostScript, [
       "const prompt = process.argv[2] ?? '';",
       "if (!prompt.includes('Queue item id:')) process.exit(2);",
-      "process.stdout.write('# implementer result\\n\\n```sdd-result\\ncontract: sdd-result-v1\\nversion: 1.3.0\\nagent: implementer\\ntask: B1\\nstatus: PASS\\nartifacts:\\n  - artifacts/implementer-B1.md\\n```\\n');"
+      "process.stdout.write('# implementer result\\n\\n```sdd-result\\ncontract: sdd-result-v1\\nversion: 1.3.0\\nagent: implementer\\ntask: B1\\nstatus: PASS\\nartifacts:\\n  - .sdd/runs/master/do/implementer-B1.md\\n```\\n');"
     ].join('\n'), 'utf8');
 
     const completed = await runBackgroundExecutor(root, {
@@ -90,7 +135,7 @@ test('claude code subagent worker spawns host process and ingests stdout artifac
 
     assert.equal(completed.status, 'completed');
     assert.equal(completed.hostInvocation?.exitCode, 0);
-    assert.equal(completed.hostInvocation?.artifactPath, 'artifacts/implementer-B1.md');
+    assert.equal(completed.hostInvocation?.artifactPath, '.sdd/runs/master/do/implementer-B1.md');
     assert.equal(completed.ingestion?.delegationStatus, 'COMPLETED');
     assert.equal(state.delegations['B-B1-implementer-001']?.status, 'COMPLETED');
     assert.equal(inspection.terminalDelegations, 1);
@@ -106,6 +151,7 @@ test('background executor blocks invalid artifact evidence instead of completing
     await initProject(root);
     await writeBranchDocs(root, 'master', validTaskMarkdown('B1', []));
     await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
+    await seedLifecycleRiskDecision(root, 'master');
 
     const claimed = await runBackgroundExecutor(root, { taskId: 'B1' });
     await writeArtifact(root, claimed.runId, 'implementer-B1.md', '# Missing contract\n');
@@ -131,6 +177,7 @@ test('background executor requires approval for database manual gate and accepts
     await initProject(root);
     await writeBranchDocs(root, 'master', validTaskMarkdown('B1', []).replace('risk: []', 'risk:\n  - database'));
     await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
+    await seedLifecycleRiskDecision(root, 'master');
 
     const blocked = await runBackgroundExecutor(root, { taskId: 'B1' });
     assert.equal(blocked.status, 'blocked');
@@ -160,6 +207,7 @@ test('background executor blocks manual handoff worker adapters', async () => {
     await initProject(root);
     await writeBranchDocs(root, 'master', validTaskMarkdown('B1', []));
     await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option', force: true });
+    await seedLifecycleRiskDecision(root, 'master');
 
     const result = await runBackgroundExecutor(root, { taskId: 'B1', workerAdapterId: 'manual-handoff-worker' });
 

package/node_modules/@sdd-agent-platform/core/src/execution/background-executor.ts

@@ -6,7 +6,7 @@ import { createDelegationRecord, isDelegationTerminal } from '../delegation/vali
 import { listDelegationQueueItems } from '../delegation/queue.js';
 import { persistDelegation } from '../delegation/run-state.js';
 import { evaluateGovernancePolicy } from '../governance/policy.js';
-import { getRunRelativeArtifactPath, toArtifactRootRelativePath } from '../runtime-paths.js';
+import { normalizeStageEvidenceOrLegacyArtifactRef, toBranchStageEvidenceRef } from '../runtime-paths.js';
 import { appendEvent } from '../run-state/events.js';
 import { createRun, readRunState, writeRunState } from '../run-state/run-state.js';
 import type { DelegationQueueItem } from '../run-state/run-index.js';
@@ -119,10 +119,10 @@ export async function runBackgroundExecutor(projectRoot: string, options: Backgr
   }
 
   const delegationId = options.delegationId ?? `B-${options.taskId}-${agent}-001`;
-  const expectedArtifact = options.artifactPath ? getRunRelativeArtifactPath(toArtifactRootRelativePath(options.artifactPath)) : `artifacts/${agent}-${options.taskId}.md`;
+  const expectedArtifact = options.artifactPath ? normalizeStageEvidenceOrLegacyArtifactRef(options.artifactPath) : toBranchStageEvidenceRef(branch, agent === 'validator' ? 'test' : 'do', `${agent}-${options.taskId}.md`);
   const existingDelegation = boundRunState.delegations[delegationId];
-  if (existingDelegation && isDelegationTerminal(existingDelegation.status)) {
-    issues.push(contractIssue('delegationId', `Delegation ${delegationId} is already terminal.`, 'Create a new delegation id for retry instead of reopening a terminal delegation.'));
+  if (existingDelegation && isDelegationTerminal(existingDelegation.status) && !options.artifactPath) {
+    issues.push(contractIssue('delegationId', `Delegation ${delegationId} is already terminal.`, 'Rerun with an artifact path to idempotently reingest the same digest or allocate a retry attempt for changed evidence.'));
   }
 
   const governance = await evaluateGovernancePolicy(projectRoot, {

package/node_modules/@sdd-agent-platform/core/src/execution/foreground-subagents.test.ts

@@ -8,6 +8,8 @@ import { initProject } from '../config/init-project.js';
 import { readRunState } from '../run-state/run-state.js';
 import { listRuntimeProjections } from '../storage/runtime-store.js';
 import { validTaskMarkdown, writeBranchDocs } from '../test-support/fixtures.js';
+import { evaluateLifecycleRiskDecisionForModel, recordLifecycleRiskDecisionProjection } from '../risk.js';
+import { parseSddBranch } from '../sdd-docs/task-parser.js';
 import { runForegroundSubagents } from './foreground-subagents.js';
 
 const hostCommand = [
@@ -20,11 +22,17 @@ const hostCommand = [
   "process.stdout.write(result + evidence);"
 ].join('\n');
 
-test('runForegroundSubagents collects all foreground subagent artifacts without lifecycle authority', async () => {
+async function seedLifecycleRiskDecision(root: string, branch: string): Promise<void> {
+  const model = await parseSddBranch(root, branch);
+  await recordLifecycleRiskDecisionProjection(root, evaluateLifecycleRiskDecisionForModel(branch, model));
+}
+
+test('runForegroundSubagents collects non-authoritative foreground artifacts after lifecycle decision', async () => {
   const root = await mkdtemp(path.join(tmpdir(), 'sdd-foreground-subagents-'));
   try {
     await initProject(root);
     await writeBranchDocs(root, 'feature', validTaskMarkdown('T1', []).replace('packages/core/src/index.ts', 'docs/t1.md'));
+    await seedLifecycleRiskDecision(root, 'feature');
 
     const result = await runForegroundSubagents(root, {
       branch: 'feature',
@@ -35,7 +43,7 @@ test('runForegroundSubagents collects all foreground subagent artifacts without
 
     assert.equal(result.status, 'completed');
     assert.deepEqual(result.agents.map((agent) => `${agent.agent}:${agent.status}`), ['reviewer:completed', 'validator:completed']);
-    assert.equal(result.agents.every((agent) => agent.artifactPath?.startsWith('artifacts/')), true);
+    assert.equal(result.agents.every((agent) => agent.artifactPath?.startsWith('.sdd/runs/feature/do/')), true);
     assert.equal(result.agents.every((agent) => agent.ingestion?.status === 'accepted'), true);
 
     const state = await readRunState(root, result.runId);
@@ -74,6 +82,7 @@ test('runForegroundSubagents blocks before host invocation when dependencies are
   try {
     await initProject(root);
     await writeBranchDocs(root, 'feature', `# Tasks\n\n${validTaskMarkdown('DEP1', [])}\n${validTaskMarkdown('DEP2', ['DEP1']).replace('packages/core/src/index.ts', 'docs/dep2.md')}`);
+    await seedLifecycleRiskDecision(root, 'feature');
 
     const result = await runForegroundSubagents(root, {
       branch: 'feature',

package/node_modules/@sdd-agent-platform/core/src/execution/foreground-subagents.ts

@@ -13,7 +13,7 @@ import { parseSddBranch } from '../sdd-docs/task-parser.js';
 import { routeSddTask } from '../router/route-sdd-task.js';
 import { buildAgentExecutionRecord, writeAgentExecutionRecord } from './agent-execution-records.js';
 import { invokeClaudeCodeSubagentHost, type HostInvocationCommandOptions, type HostInvocationResult } from './host-invocation.js';
-import { getRunRelativeArtifactPath, toArtifactRootRelativePath } from '../runtime-paths.js';
+import { toBranchStageEvidenceRef, toEvidencePayloadFileName } from '../runtime-paths.js';
 import { recordRuntimeProjection } from '../storage/runtime-store.js';
 import { recordSubagentDispatchProjection, recordSubagentResultProjection } from '../subagents/runtime.js';
 import type { SubagentDispatch, SubagentResult } from '../subagents/contracts.js';
@@ -122,7 +122,7 @@ export async function runForegroundSubagents(projectRoot: string, options: Foreg
 
   const slots = agents.map((agent, index) => {
     const delegationId = `F-${options.taskId}-${safeToken(agent)}-${String(index + 1).padStart(3, '0')}`;
-    const expectedArtifact = getRunRelativeArtifactPath(toArtifactRootRelativePath(`artifacts/${safeToken(agent)}-${options.taskId}-${String(index + 1).padStart(3, '0')}.md`));
+    const expectedArtifact = toBranchStageEvidenceRef(branch, 'do', `${safeToken(agent)}-${options.taskId}-${String(index + 1).padStart(3, '0')}.md`);
     return { agent, delegationId, expectedArtifact };
   });
 
@@ -342,7 +342,7 @@ function buildHostFailureDigest(taskId: string, agent: string, delegationId: str
 
 async function readArtifactText(projectRoot: string, runId: string, artifactPath: string): Promise<string> {
   try {
-    return await readArtifact(projectRoot, runId, toArtifactRootRelativePath(artifactPath));
+    return await readArtifact(projectRoot, runId, toEvidencePayloadFileName(artifactPath));
   } catch {
     return '';
   }