sdd-agent-platform 0.4.1 → 0.4.2

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

@@ -6,7 +6,7 @@ import { promisify } from 'node:util';
 import { PROJECT_CONFIG_CONTRACT } from '../../contracts.js';
 import { messageFromError } from '../../contracts/issues.js';
 import { readProjectConfig as readProjectConfigFile } from '../../config/project-config.js';
-import { getProjectConfigPath, getRunsDir } from '../../runtime-paths.js';
+import { getProjectConfigPath, getRunEvidenceRoot } from '../../runtime-paths.js';
 import type { ProjectAgentRuntimeConfig } from '../../router/agent-runtime.js';
 import { parseAgentRuntimeConfig } from '../../router/agent-runtime-config.js';
 import { exists } from '../../storage/json-io.js';
@@ -45,24 +45,24 @@ export async function inspectProjectConfig(projectRoot: string): Promise<{ exist
 }
 
 export async function inspectRunsDirectoryAccess(projectRoot: string): Promise<{ available: boolean; checks: DoctorCheck[] }> {
-  const runsDir = getRunsDir(projectRoot);
-  if (!(await exists(runsDir))) {
+  const stageEvidenceRoot = getRunEvidenceRoot(projectRoot);
+  if (!(await exists(stageEvidenceRoot))) {
     return {
-      available: false,
-      checks: [{ level: 'WARN', check: 'runs_dir', message: '.sdd/runs does not exist yet.', action: 'Run sdd init or sdd run create.' }]
+      available: true,
+      checks: [{ level: 'WARN', check: 'stage_evidence_dir', message: '.sdd/runs/<branch>/<stage> evidence root does not exist yet.', action: 'Let stage-manager or agent-team author accepted evidence under .sdd/runs/<branch>/<stage>/*.md during do/test/ship flow.' }]
     };
   }
 
   try {
-    await access(runsDir, constants.R_OK | constants.W_OK);
+    await access(stageEvidenceRoot, constants.R_OK | constants.W_OK);
     return {
       available: true,
-      checks: [{ level: 'PASS', check: 'runs_dir', message: '.sdd/runs exists and is readable/writable.' }]
+      checks: [{ level: 'PASS', check: 'stage_evidence_dir', message: '.sdd/runs/<branch>/<stage> evidence root exists and is readable/writable.' }]
     };
   } catch {
     return {
       available: false,
-      checks: [{ level: 'FAIL', check: 'runs_dir', message: '.sdd/runs is not readable/writable.', action: 'Fix filesystem permissions for .sdd/runs.' }]
+      checks: [{ level: 'FAIL', check: 'stage_evidence_dir', message: '.sdd/runs/<branch>/<stage> evidence root is not readable/writable.', action: 'Fix filesystem permissions for branch stage evidence under .sdd/runs/<branch>/<stage>/*.md.' }]
     };
   }
 }

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

@@ -12,7 +12,6 @@ import type { DoctorCheck } from '../model.js';
 const BASELINE_GOVERNANCE_POLICY_OPERATIONS: GovernancePolicyOperation[] = [
   'background_executor',
   'wave_executor',
-  'sync_back_apply',
   'destructive_git',
   'external_interaction',
   'cleanup'

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

@@ -189,7 +189,7 @@ async function inspectLatestRunEvidenceFastPath(projectRoot: string, branch: str
       message: `Workflow State Resolver inspected latest run ${latestRun.runId} for ${workflow.branch} without deep evidence scan.`
     }];
     for (const conflict of workflow.affectedFileConflicts) {
-      checks.push({ level: 'WARN', check: 'run_evidence_fast_path_conflict', message: `Affected file ${conflict.file} is active in run ${conflict.runId} for ${conflict.partition}/${conflict.taskId}.`, action: 'Use sdd sync-back inspect or sdd doctor --all-runs for deep runtime evidence diagnostics.' });
+      checks.push({ level: 'WARN', check: 'run_evidence_fast_path_conflict', message: `Affected file ${conflict.file} is active in run ${conflict.runId} for ${conflict.partition}/${conflict.taskId}.`, action: 'Use sdd status or sdd doctor --all-runs for deep runtime evidence diagnostics.' });
     }
     return checks;
   } catch (error) {
@@ -222,7 +222,7 @@ function inspectArtifactScopeConsistency(state: RunState, invocationLedger: Awai
       level: 'FAIL',
       check: 'artifact_scope',
       message: `${state.runId}: ${artifactWrites.length} artifact write(s) are attached to an unscoped run.`,
-      action: 'Create runs with sdd run create --branch <branch> --task <task_id> before writing artifacts.'
+      action: 'Create scoped runtime state with sdd run create --branch <branch> --task <task_id> before registering stage evidence.'
     });
   }
   for (const entry of artifactWrites) {
@@ -231,7 +231,7 @@ function inspectArtifactScopeConsistency(state: RunState, invocationLedger: Awai
         level: 'FAIL',
         check: 'artifact_scope',
         message: `${state.runId}: artifact ${entry.ref} is scoped to task ${entry.taskId}, but run task is ${state.taskId}.`,
-        action: 'Write artifacts only through the scoped run/task pair that owns the evidence.'
+        action: 'Register evidence only through the scoped run/task pair that owns the stage evidence ref.'
       });
     }
     if (entry.branch && state.partition && entry.branch !== state.partition && entry.branch !== state.gitBranch) {
@@ -239,7 +239,7 @@ function inspectArtifactScopeConsistency(state: RunState, invocationLedger: Awai
         level: 'FAIL',
         check: 'artifact_scope',
         message: `${state.runId}: artifact ${entry.ref} is scoped to branch ${entry.branch}, but run branch is ${state.gitBranch ?? state.partition}.`,
-        action: 'Reject branch/run mismatches before artifact writes.'
+        action: 'Reject branch/run mismatches before registering stage evidence refs.'
       });
     }
   }

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

@@ -1,4 +1,3 @@
-import { createHash } from 'node:crypto';
 import { SDD_EVIDENCE_CONTRACT } from '../../contracts.js';
 import { messageFromError } from '../../contracts/issues.js';
 import { containsTemplatePlaceholder, validateArtifactTrust, type EvidenceClaim } from '../../artifacts/sdd-evidence.js';
@@ -14,23 +13,6 @@ export async function inspectRunTrustEvidence(projectRoot: string, state: RunSta
   const materials = ledgerMaterialRefs(invocationLedger);
   let inspectedTrustArtifacts = 0;
 
-  if (state.syncBack.status !== 'not_created') {
-    if (!state.syncBack.proposalPath) {
-      checks.push({ level: 'FAIL', check: 'sync_back_monotonicity', message: `${runId}: sync-back status is ${state.syncBack.status} but proposalPath is missing.`, action: 'Keep sync-back transitions monotonic and preserve the proposal path from verify/apply.' });
-    } else if (!state.syncBack.proposalDigest) {
-      checks.push({ level: 'WARN', check: 'sync_back_proposal_digest', message: `${runId}: sync-back proposal ${state.syncBack.proposalPath} has no recorded digest.`, action: 'Re-run verify with the Phase 6.9 runtime so inspect/apply can detect proposal drift.' });
-    } else {
-      try {
-        const proposal = await readArtifact(projectRoot, runId, toArtifactRootRelativePath(state.syncBack.proposalPath));
-        const digest = hashDocumentContent(proposal);
-        if (digest !== state.syncBack.proposalDigest) {
-          checks.push({ level: 'FAIL', check: 'sync_back_proposal_digest', message: `${runId}: sync-back proposal ${state.syncBack.proposalPath} digest changed from ${state.syncBack.proposalDigest} to ${digest}.`, action: 'Restore the verified proposal or re-run verify before sync-back apply.' });
-        }
-      } catch (error) {
-        checks.push({ level: 'FAIL', check: 'sync_back_proposal_digest', message: `${runId}: cannot read sync-back proposal ${state.syncBack.proposalPath}: ${messageFromError(error)}`, action: 'Restore the proposal artifact before sync-back inspect/apply.' });
-      }
-    }
-  }
 
   for (const [taskId, taskState] of Object.entries(state.tasks)) {
     for (const coverage of acceptanceCoverageEntries(taskState)) {
@@ -119,9 +101,6 @@ function claimMaterialRefs(claim: EvidenceClaim): string[] {
   return refs;
 }
 
-function hashDocumentContent(raw: string): string {
-  return createHash('sha256').update(raw.replace(/\r\n/g, '\n'), 'utf8').digest('hex');
-}
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null;

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

@@ -265,7 +265,7 @@ export async function inspectWaveExecutorContract(projectRoot: string): Promise<
     return [{
       level: 'PASS',
       check: 'wave_executor_contract',
-      message: `Wave executor contract ${WAVE_EXECUTOR_CONTRACT_VERSION} declares ${strategies.length} strategy option(s), planner-driven execution, and no sync-back apply side effects.`
+      message: `Wave executor contract ${WAVE_EXECUTOR_CONTRACT_VERSION} declares ${strategies.length} strategy option(s), planner-driven execution, and no truth-alignment approval side effects.`
     }];
   } catch (error) {
     return [{

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

@@ -15,13 +15,14 @@ import { rebuildLocalRunIndex } from '../run-state/run-index.js';
 import { archiveRun, createRun, readRunState, writeRunState } from '../run-state/run-state.js';
 import { validResultArtifact, validTaskMarkdown, writeBranchDocs } from '../test-support/fixtures.js';
 import { bindTestRunState } from '../test-support/run-state.js';
-import { STAGE_RUN_CONTRACT_VERSION, SUBAGENT_DISPATCH_CONTRACT_VERSION, WORKFLOW_HANDOFF_CONTRACT_VERSION, type RuntimeScope } from '../contracts.js';
+import { EVENT_LOG_CONTRACT, STAGE_RUN_CONTRACT_VERSION, SUBAGENT_DISPATCH_CONTRACT_VERSION, WORKFLOW_HANDOFF_CONTRACT_VERSION, type RuntimeScope } from '../contracts.js';
 import { recordStageRunProjection, recordWorkflowHandoffProjection, type StageRun, type WorkflowHandoff } from '../stage-runtime.js';
 import { decideContextOffload, evaluateContextLoadSignal, recordContextLoadSignalProjection, recordContextOffloadDecisionProjection } from '../context-offload.js';
 import { recordSubagentDispatchProjection, type SubagentDispatch } from '../subagents.js';
 import { runShip } from '../lifecycle/ship.js';
-import { recordRuntimeSyncBackDecision, runtimeScopedId, withRuntimeStore } from '../storage/runtime-store.js';
+import { listRuntimeRepairs, recordRuntimeCapabilityAdoption, recordRuntimeEvent, recordRuntimeTestRun, recordRuntimeTestStep, runtimeScopedId, withRuntimeStore } from '../storage/runtime-store.js';
 import { getProjectStatus } from '../status/project-status.js';
+import { writeVerifyContract } from '../verification/verify-contract.js';
 import { doctor } from './doctor.js';
 
 const execFileAsync = promisify(execFile);
@@ -226,6 +227,101 @@ test('doctor latestOnly ignores older failed run evidence', async () => {
   }
 });
 
+test('doctor reports runtime performance observability warnings', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-runtime-performance-doctor-'));
+  try {
+    await initProject(root);
+    const staleRun = await createRun(root, { runId: 'run-stale' });
+    const missingStepsRun = await createRun(root, { runId: 'run-missing-steps' });
+    const waitingRun = await createRun(root, { runId: 'run-waiting' });
+    const slowRun = await createRun(root, { runId: 'run-slow-validation' });
+
+    const staleState = { ...staleRun, status: 'running' as const, updatedAt: '2020-01-01T00:00:00.000Z' };
+    await withRuntimeStore(root, ({ db }) => {
+      db.prepare('UPDATE runs SET status = ?, updated_at = ?, state_json = ?, state_hash = ? WHERE run_id = ?')
+        .run(staleState.status, staleState.updatedAt, JSON.stringify(staleState), 'test-stale', staleState.runId);
+    });
+    await recordRuntimeTestRun(root, {
+      testRunId: 'test-run-missing-steps',
+      runId: missingStepsRun.runId,
+      partition: 'master',
+      taskId: 'T1',
+      status: 'PASS',
+      startedAt: '2026-05-01T00:00:00.000Z',
+      completedAt: '2026-05-01T00:00:02.000Z',
+      payload: {}
+    });
+    const waitingState = { ...waitingRun, createdAt: '2026-05-01T00:00:00.000Z', updatedAt: '2026-05-01T00:00:40.000Z' };
+    await withRuntimeStore(root, ({ db }) => {
+      db.prepare('DELETE FROM events WHERE run_id = ?').run(waitingRun.runId);
+      db.prepare('UPDATE runs SET updated_at = ?, state_json = ?, state_hash = ? WHERE run_id = ?')
+        .run(waitingState.updatedAt, JSON.stringify(waitingState), 'test-waiting', waitingState.runId);
+    });
+    await recordRuntimeEvent(root, { contract: EVENT_LOG_CONTRACT, runId: waitingRun.runId, time: '2026-05-01T00:00:00.000Z', event: 'agent_invocation_started' });
+    await recordRuntimeEvent(root, { contract: EVENT_LOG_CONTRACT, runId: waitingRun.runId, time: '2026-05-01T00:00:30.000Z', event: 'run_context_bound' });
+    await recordRuntimeTestRun(root, {
+      testRunId: 'test-run-slow-validation',
+      runId: slowRun.runId,
+      partition: 'master',
+      taskId: 'T1',
+      status: 'PASS',
+      startedAt: '2026-05-01T00:00:00.000Z',
+      completedAt: '2026-05-01T00:01:00.000Z',
+      payload: {}
+    });
+    await recordRuntimeTestStep(root, {
+      stepId: 'test-run-slow-validation:001',
+      testRunId: 'test-run-slow-validation',
+      runId: slowRun.runId,
+      taskId: 'T1',
+      command: 'npm test',
+      status: 'PASS',
+      exitCode: 0,
+      durationMs: 45_000,
+      outputArtifact: 'artifacts/test-T1-001.log',
+      payload: { startedAt: '2026-05-01T00:00:00.000Z', endedAt: '2026-05-01T00:00:45.000Z' }
+    });
+
+    const report = await doctor(root, { allRuns: true });
+    const check = report.checks.find((candidate) => candidate.check === 'runtime_performance_observability');
+
+    assert.equal(check?.level, 'WARN');
+    assert.match(check?.message ?? '', /stale_open=.*run-stale/);
+    assert.match(check?.message ?? '', /missing_test_steps=run-missing-steps/);
+    assert.match(check?.message ?? '', /waiting_dominated=run-waiting:30000ms/);
+    assert.match(check?.message ?? '', /host_no_output=run-waiting:30000ms/);
+    assert.match(check?.message ?? '', /slow_validation=run-slow-validation:test-run-slow-validation:001:45000ms/);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('doctor reports mixed-version recovery plan without legacy based_on repair', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-mixed-version-recovery-'));
+  try {
+    await initProject(root);
+    const taskMarkdown = validTaskMarkdown('T1', [])
+      .replace('validation:\n  - npm test', 'validation:\n  - ```powershell npm test')
+      .replace('risk: []', 'required_artifacts:\n  - specs/feature/artifacts/implement-T1.md\nrisk: []');
+    await writeBranchDocs(root, 'feature', taskMarkdown);
+    await writeFile(path.join(root, 'specs', 'feature', 'verify.md'), '# Verify\n\nbased_on_tasks_hash: legacy\n', 'utf8');
+
+    const report = await doctor(root, { branch: 'feature', latestOnly: true });
+    const check = report.checks.find((candidate) => candidate.check === 'mixed_version_recovery');
+
+    assert.equal(check?.level, 'FAIL');
+    assert.match(check?.message ?? '', /issues=2/);
+    assert.match(check?.message ?? '', /safe_fixes=1/);
+    assert.match(check?.message ?? '', /behavior_changes=1/);
+    assert.match(check?.message ?? '', /legacy_artifacts=none/);
+    assert.match(check?.message ?? '', /sdd doctor --branch feature --latest-only/);
+    assert.match(check?.action ?? '', /do not promote legacy stale runs as accepted truth/);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+
 test('doctor trust suite flags mention-only acceptance and weak validator PASS artifacts', async () => {
   const root = await mkdtemp(path.join(tmpdir(), 'sdd-doctor-trust-'));
   try {
@@ -400,17 +496,19 @@ test('doctor reports unavailable Phase 8 runtime checks as warnings', async () =
     });
 
     const report = await doctor(root, { latestOnly: true, branch: 'master' });
+    const warningRepairs = await listRuntimeRepairs(root, { branchSlug: 'master', status: 'open' });
 
     assert.equal(report.checks.some((check) => check.check === 'lifecycle_risk_decision' && check.level === 'WARN' && /unavailable/.test(check.message)), true);
     assert.equal(report.checks.some((check) => check.check === 'workflow_handoff_state' && check.level === 'WARN' && /unavailable/.test(check.message)), true);
     assert.equal(report.checks.some((check) => check.check === 'context_offload_state' && check.level === 'WARN' && /unavailable/.test(check.message)), true);
     assert.equal(report.checks.some((check) => check.check === 'subagent_dispatch_state' && check.level === 'WARN' && /unavailable/.test(check.message)), true);
+    assert.equal(warningRepairs.some((repair) => repair.blockers.some((blocker) => /lifecycle_risk_decision|workflow_handoff_state|context_offload_state|subagent_dispatch_state/.test(blocker))), false);
   } finally {
     await rm(root, { recursive: true, force: true });
   }
 });
 
-test('Phase 8.9 surfaces capability health in status, doctor, and ship gates', async () => {
+test('Phase 8.28 blocks release-critical capability gaps until adoption is recorded', async () => {
   const root = await mkdtemp(path.join(tmpdir(), 'sdd-capability-health-'));
   try {
     await initProject(root);
@@ -422,17 +520,47 @@ test('Phase 8.9 surfaces capability health in status, doctor, and ship gates', a
     const doctorCheck = report.checks.find((check) => check.check === 'capability_health');
     const shipCheck = ship.checks.find((check) => check.name === 'capability_health');
 
-    assert.equal(status.capabilityHealth.status, 'warn');
+    assert.equal(status.capabilityHealth.status, 'blocked');
     assert.equal(status.capabilityHealth.missingBaselineDomains.length, 0);
     assert.equal(status.capabilityHealth.sources.quarantined > 0, true);
     assert.equal(status.capabilityHealth.sources.denied > 0, true);
     assert.deepEqual(status.capabilityHealth.releaseCriticalGaps, ['security-engineering']);
     assert.equal(status.capabilityHealth.warnings.some((warning) => /release-critical capability gap security-engineering/.test(warning)), true);
-    assert.equal(doctorCheck?.level, 'WARN');
+    assert.equal(doctorCheck?.level, 'FAIL');
     assert.match(doctorCheck?.message ?? '', /release_critical_gaps=security-engineering/);
-    assert.equal(shipCheck?.status, 'PASS');
-    assert.match(shipCheck?.message ?? '', /release_critical_gaps=security-engineering/);
-    assert.equal(shipCheck?.nextAction, undefined);
+    assert.equal(shipCheck?.status, 'BLOCKED');
+    const capabilityRepairs = await listRuntimeRepairs(root, { branchSlug: 'master', status: 'open' });
+    assert.equal(capabilityRepairs.some((repair) => repair.blockers.some((blocker) => blocker.startsWith('capability_health:'))), false);
+
+    await recordRuntimeCapabilityAdoption(root, {
+      adoptionId: runtimeScopedId('capability-adoption', 'master', 'ship', 'security-engineering'),
+      branchSlug: 'master',
+      lifecycleStage: 'ship',
+      capabilityDomain: 'security-engineering',
+      sourceId: 'sdd_professional_baseline',
+      status: 'rejected',
+      reason: 'Security capability reviewed; no additional security evidence is required for this scoped release task.',
+      evidenceRefs: ['tasks:SECURITY'],
+      finalAuthority: 'sdd_gate',
+      createdAt: '2026-05-27T00:00:00.000Z',
+      updatedAt: '2026-05-27T00:00:00.000Z',
+      payload: { releaseCritical: true }
+    });
+
+    const adoptedStatus = await getProjectStatus(root, { branch: 'master' });
+    const adoptedReport = await doctor(root, { latestOnly: true, branch: 'master' });
+    const adoptedShip = await runShip(root, { branch: 'master', dryRun: true });
+    const adoptedDoctorCheck = adoptedReport.checks.find((check) => check.check === 'capability_health');
+    const adoptedShipCheck = adoptedShip.checks.find((check) => check.name === 'capability_health');
+
+    assert.equal(adoptedStatus.capabilityHealth.status, 'pass');
+    assert.deepEqual(adoptedStatus.capabilityHealth.releaseCriticalGaps, []);
+    assert.deepEqual(adoptedStatus.capabilityHealth.adoptions.releaseCriticalClosures, ['security-engineering']);
+    assert.equal(adoptedDoctorCheck?.level, 'PASS');
+    assert.match(adoptedDoctorCheck?.message ?? '', /adoption_closures=security-engineering/);
+    assert.equal(adoptedShipCheck?.status, 'PASS');
+    assert.match(adoptedShipCheck?.message ?? '', /adoption_closures=security-engineering/);
+    assert.equal(adoptedShipCheck?.nextAction, undefined);
   } finally {
     await rm(root, { recursive: true, force: true });
   }
@@ -461,11 +589,12 @@ test('ship reports token pressure as diagnostic pass', async () => {
   }
 });
 
-test('ship accepts validated runs without requiring sync-back apply', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-ship-syncback-not-required-'));
+test('ship accepts validated runs without requiring a removed sync-back stage', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-ship-eight-stage-ready-'));
   try {
     await initProject(root);
     await writeBranchDocs(root, 'master', validTaskMarkdown('T1', []));
+    await writeVerifyContract(root, { branch: 'master', branchSource: 'cli_option' });
     const state = await createRun(root, { runId: 'run-1' });
     await bindTestRunState(root, state.runId, 'master', 'T1');
     const bound = await readRunState(root, state.runId);
@@ -483,13 +612,13 @@ test('ship accepts validated runs without requiring sync-back apply', async () =
     const latestRunCheck = ship.checks.find((check) => check.name === 'latest_run');
 
     assert.equal(latestRunCheck?.status, 'PASS');
-    assert.match(latestRunCheck?.message ?? '', /sync_back=not_created/);
+    assert.match(latestRunCheck?.message ?? '', /run=run-1 status=completed validation=pass/);
   } finally {
     await rm(root, { recursive: true, force: true });
   }
 });
 
-test('doctor reports Phase 8.18 compatibility and Phase 9 readiness diagnostics', async () => {
+test('doctor does not report historical legacy file diagnostics', async () => {
   const root = await mkdtemp(path.join(tmpdir(), 'sdd-phase818-doctor-'));
   try {
     await initProject(root);
@@ -502,41 +631,10 @@ test('doctor reports Phase 8.18 compatibility and Phase 9 readiness diagnostics'
     await writeFile(path.join(legacyRunDir, 'events.jsonl'), '{}\n', 'utf8');
     await writeFile(path.join(legacyRunDir, 'invocations.jsonl'), '{}\n', 'utf8');
     await writeFile(path.join(legacyRunDir, 'agent-executions', 'legacy.json'), '{}', 'utf8');
-    await writeRunState(root, {
-      ...state,
-      syncBack: {
-        ...state.syncBack,
-        status: 'proposed',
-        proposalPath: 'artifacts/sync-back-proposal.md',
-        proposalDigest: 'legacy-digest'
-      }
-    });
-    await recordRuntimeSyncBackDecision(root, {
-      decisionId: runtimeScopedId(state.runId, 'T1', 'sync-back'),
-      runId: state.runId,
-      branch: 'master',
-      taskId: 'T1',
-      status: 'blocked',
-      proposalPath: 'artifacts/sync-back-proposal.md',
-      proposalDigest: 'legacy-digest',
-      proposalPayloadId: null,
-      reasons: ['legacy divergence'],
-      createdAt: '2026-05-21T00:00:00.000Z',
-      updatedAt: '2026-05-21T00:00:00.000Z',
-      payload: {}
-    });
-
     const report = await doctor(root, { allRuns: true, branch: 'master' });
 
-    const legacyRunFiles = report.checks.find((check) => check.check === 'phase8_18_legacy_run_files');
-    assert.equal(legacyRunFiles?.level, 'WARN');
-    assert.match(legacyRunFiles?.message ?? '', /run-1:state\.json/);
-    assert.match(legacyRunFiles?.message ?? '', /run-1:events\.jsonl/);
-    assert.match(legacyRunFiles?.message ?? '', /run-1:invocations\.jsonl/);
-    assert.doesNotMatch(legacyRunFiles?.message ?? '', /evidence/);
-    assert.equal(report.checks.some((check) => check.check === 'phase8_18_legacy_sidecars' && check.level === 'WARN' && /run-1/.test(check.message)), true);
-    assert.equal(report.checks.some((check) => check.check === 'phase8_18_sync_back_compat' && check.level === 'WARN' && /proposed->blocked/.test(check.message)), true);
-    assert.equal(report.checks.some((check) => check.check === 'phase9_readiness' && check.level === 'PASS' && /optional_advisory_only/.test(check.message)), true);
+    assert.equal(report.checks.some((check) => check.check === 'phase8_18_legacy_run_files'), false);
+    assert.equal(report.checks.some((check) => check.check === 'phase8_18_legacy_sidecars'), false);
   } finally {
     await rm(root, { recursive: true, force: true });
   }