sdd-agent-platform 0.4.2 → 0.5.1

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

@@ -1,755 +1,628 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { execFile } from 'node:child_process';
-import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { promisify } from 'node:util';
-
-import { ingestArtifactResult } from '../artifacts/ingestion.js';
-import { initProject } from '../config/init-project.js';
-import { createDelegationRecord } from '../delegation/validation.js';
-import { writeArtifact } from '../run-state/artifacts.js';
-import { appendEvent, readRunEvents } from '../run-state/events.js';
-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 { 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 { 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);
-
-
-test('doctor reports AI entry drift after init', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-doctor-drift-'));
-  try {
-    await initProject(root);
-    const skillPath = path.join(root, '.claude', 'skills', 'sdd', 'SKILL.md');
-    await writeFile(skillPath, `${await readFile(skillPath, 'utf8')}\nmanual drift\n`, 'utf8');
-
-    const report = await doctor(root);
-
-    assert.equal(report.status, 'FAIL');
-    assert.equal(report.checks.some((check) => check.check === 'ai_entry_sdd' && check.level === 'FAIL' && /will not overwrite user-modified/.test(check.action ?? '')), true);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('doctor reports missing git repo as fail in temp directory', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-runtime-'));
-  try {
-    await initProject(root);
-    const report = await doctor(root);
-    assert.equal(report.status, 'FAIL');
-    assert.equal(report.checks.some((check) => check.check === 'git_repo' && check.level === 'FAIL'), true);
-    assert.equal(report.checks.some((check) => check.check === 'git_repo' && /git init/.test(check.action ?? '')), true);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('doctor reports broken document-chain refs and high-risk evidence gaps', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-document-chain-doctor-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'master', `# Tasks
-
-### D1: Broken document chain
-
-\`\`\`sdd-task
-id: D1
-status: pending
-wave: 1
-depends_on: []
-acceptance_refs:
-  - AC-404
-affected_files:
-  - packages/core/src/index.ts
-validation:
-  - npm test
-risk:
-  - database
-\`\`\`
-
-#### Boundary
-
-Stay inside document-chain checks.
-
-#### Acceptance
-
-- Broken ref is detected.
-`);
-    await writeFile(path.join(root, 'specs', 'master', 'spec.md'), '# Spec\n\n| ID | Acceptance |\n|---|---|\n| AC-1 | Existing acceptance. |\n', 'utf8');
-
-    const report = await doctor(root, { latestOnly: true });
-
-    assert.equal(report.checks.some((check) => check.check === 'document_chain_acceptance_ref' && check.level === 'FAIL' && /AC-404/.test(check.message)), true);
-    assert.equal(report.checks.some((check) => check.check === 'document_chain_high_risk_evidence' && check.level === 'FAIL' && /D1/.test(check.message)), true);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('doctor reports local run index drift with rebuild action', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-local-index-doctor-'));
-  try {
-    await initProject(root);
-    const run = await createRun(root, { runId: 'run-1' });
-    await rebuildLocalRunIndex(root);
-    await writeRunState(root, { ...run, status: 'completed', tasks: { T2: { status: 'completed' } } });
-
-    const report = await doctor(root);
-
-    assert.equal(report.checks.some((check) => check.check === 'local_run_index' && check.level === 'WARN' && /rebuild/.test(check.action ?? '')), true);
-    assert.equal(report.checks.some((check) => check.check === 'local_run_index_contract' && check.level === 'PASS'), true);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('doctor reports artifact writes attached to unscoped runs', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-doctor-artifact-scope-'));
-  try {
-    await initProject(root);
-    const state = await createRun(root, { runId: 'run-1' });
-    await writeArtifact(root, state.runId, 'review-T1.md', validResultArtifact('reviewer', 'T1', 'PASS', 'artifacts/review-T1.md'));
-
-    const report = await doctor(root, { allRuns: true });
-
-    assert.equal(report.checks.some((check) => check.check === 'artifact_scope' && check.level === 'FAIL' && /unscoped run/.test(check.message)), true);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('doctor reports stale delegation and terminal event gaps without auto-fix', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-doctor-hardening-'));
-  try {
-    await initProject(root);
-    const state = await createRun(root, { runId: 'run-1' });
-    const stale = createDelegationRecord({
-      delegationId: 'D-T1-reviewer-001',
-      task: 'T1',
-      agent: 'reviewer',
-      expectedArtifact: 'artifacts/review-T1.md',
-      startedAt: '2020-01-01T00:00:00.000Z',
-      timeoutSeconds: 1
-    });
-    const completed = createDelegationRecord({
-      delegationId: 'D-T1-validator-001',
-      task: 'T1',
-      agent: 'validator',
-      expectedArtifact: 'artifacts/validation-T1.md',
-      status: 'COMPLETED'
-    });
-    await writeRunState(root, { ...state, delegations: { [stale.delegationId]: stale, [completed.delegationId]: completed } });
-    await appendEvent(root, state.runId, { event: 'delegation_started', runId: state.runId, data: { delegationId: stale.delegationId } });
-
-    const report = await doctor(root);
-
-    assert.equal(report.status, 'FAIL');
-    assert.equal(report.checks.some((check) => check.check === 'stale_delegation'), true);
-    assert.equal(report.checks.some((check) => check.check === 'terminal_event_missing'), true);
-    assert.equal(report.checks.some((check) => check.check === 'artifact_invalid'), true);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('archiveRun cancels running delegations and normal doctor skips archived evidence', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-archive-run-'));
-  try {
-    await initProject(root);
-    const state = await createRun(root, { runId: 'run-1' });
-    const running = createDelegationRecord({
-      delegationId: 'D-T1-reviewer-001',
-      task: 'T1',
-      agent: 'reviewer',
-      expectedArtifact: 'artifacts/review-T1.md',
-      startedAt: '2020-01-01T00:00:00.000Z',
-      timeoutSeconds: 1
-    });
-    await writeRunState(root, { ...state, delegations: { [running.delegationId]: running } });
-    await appendEvent(root, state.runId, { event: 'delegation_started', runId: state.runId, data: { delegationId: running.delegationId } });
-
-    const archived = await archiveRun(root, state.runId, { reason: 'exploratory failure' });
-    const normalDoctor = await doctor(root);
-    const allRunsDoctor = await doctor(root, { allRuns: true });
-    const events = await readRunEvents(root, state.runId);
-
-    assert.equal(archived.status, 'archived');
-    assert.equal(archived.delegations[running.delegationId].status, 'CANCELLED');
-    assert.equal(events.some((event) => event.event === 'delegation_cancelled'), true);
-    assert.equal(events.some((event) => event.event === 'run_archived'), true);
-    assert.equal(normalDoctor.checks.some((check) => check.check === 'stale_delegation'), false);
-    assert.equal(normalDoctor.checks.some((check) => check.check === 'run_evidence_scope'), true);
-    assert.equal(allRunsDoctor.checks.some((check) => check.check === 'stale_delegation'), false);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('doctor latestOnly ignores older failed run evidence', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-doctor-latest-only-'));
-  try {
-    await initProject(root);
-    const older = await createRun(root, { runId: 'run-older' });
-    const newer = await createRun(root, { runId: 'run-newer' });
-    const stale = createDelegationRecord({
-      delegationId: 'D-T1-reviewer-001',
-      task: 'T1',
-      agent: 'reviewer',
-      expectedArtifact: 'artifacts/review-T1.md',
-      startedAt: '2020-01-01T00:00:00.000Z',
-      timeoutSeconds: 1
-    });
-    await writeRunState(root, { ...older, updatedAt: '2026-05-01T00:00:00.000Z', delegations: { [stale.delegationId]: stale } });
-    await writeRunState(root, { ...newer, updatedAt: '2026-05-02T00:00:00.000Z' });
-    await appendEvent(root, older.runId, { event: 'delegation_started', runId: older.runId, data: { delegationId: stale.delegationId } });
-
-    const latestOnly = await doctor(root, { latestOnly: true });
-    const allRuns = await doctor(root, { allRuns: true });
-
-    assert.equal(latestOnly.checks.some((check) => check.check === 'stale_delegation'), false);
-    assert.equal(latestOnly.checks.some((check) => check.check === 'run_evidence_fast_path'), true);
-    assert.equal(allRuns.checks.some((check) => check.check === 'stale_delegation'), true);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-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 {
-    await initProject(root);
-    await writeBranchDocs(root, 'feature', validTaskMarkdown('T1', []));
-    const state = await createRun(root, { runId: 'run-1' });
-    await bindTestRunState(root, state.runId, 'feature', 'T1');
-    await writeArtifact(root, state.runId, 'validation-T1.md', validResultArtifact('validator', 'T1', 'PASS', 'artifacts/validation-T1.md'));
-    const restored = await readRunState(root, state.runId);
-    await writeRunState(root, {
-      ...restored,
-      status: 'completed',
-      validation: {
-        status: 'pass',
-        commands: ['npm test'],
-        evidence: ['artifacts/validation-T1.md']
-      },
-      tasks: {
-        T1: {
-          status: 'verified',
-          verifyStatus: 'PASS',
-          gaps: [],
-          artifacts: ['artifacts/validation-T1.md'],
-          acceptanceCoverage: [{ acceptance: 'AC-1', status: 'PASS', evidence: 'Mentioned in artifacts/validation-T1.md.' }]
-        }
-      },
-      artifacts: [{ path: 'artifacts/validation-T1.md', kind: 'validation', task: 'T1', agent: 'validator', createdAt: new Date().toISOString() }]
-    });
-
-    const report = await doctor(root, { allRuns: true, branch: 'feature' });
-
-    assert.equal(report.checks.some((check) => check.check === 'acceptance_trust' && check.level === 'FAIL'), true);
-    assert.equal(report.checks.some((check) => check.check === 'artifact_trust' && check.level === 'FAIL' && /UNSOURCED_PASS/.test(check.message)), true);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('doctor reports artifact ingestion state mismatch', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-artifact-ingest-doctor-'));
-  try {
-    await initProject(root);
-    const state = await createRun(root, { runId: 'run-1' });
-    const delegation = createDelegationRecord({
-      delegationId: 'D-T1-reviewer-001',
-      task: 'T1',
-      agent: 'reviewer',
-      expectedArtifact: 'artifacts/review-T1.md'
-    });
-    await writeRunState(root, { ...state, delegations: { [delegation.delegationId]: delegation } });
-    await appendEvent(root, state.runId, { event: 'delegation_started', runId: state.runId, data: { delegationId: delegation.delegationId } });
-    await writeArtifact(root, state.runId, 'review-T1.md', `# Review
-
-\`\`\`sdd-result
-contract: sdd-result-v1
-version: 1.3.0
-agent: reviewer
-task: T1
-status: PASS
-artifacts:
-  - artifacts/review-T1.md
-\`\`\`
-`);
-    const ingested = await ingestArtifactResult(root, state.runId, { delegationId: delegation.delegationId, artifactPath: 'artifacts/review-T1.md' });
-    const acceptedState = await readRunState(root, state.runId);
-    await writeRunState(root, {
-      ...acceptedState,
-      artifacts: [],
-      artifactIngestions: {
-        [`${delegation.delegationId}:artifacts/review-T1.md`]: ingested.record
-      }
-    });
-
-    const report = await doctor(root);
-
-    assert.equal(report.status, 'FAIL');
-    assert.equal(report.checks.some((check) => check.check === 'artifact_result_ingestion' && /missing from run artifact index/.test(check.message)), true);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('doctor honors explicit branch for document-chain scope', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-doctor-branch-'));
-  try {
-    await initProject(root);
-    await execFileAsync('git', ['init'], { cwd: root });
-    await execFileAsync('git', ['checkout', '-b', 'other'], { cwd: root });
-
-    const report = await doctor(root, { latestOnly: true, branch: 'master' });
-
-    assert.equal(report.checks.some((check) => /Document chain skipped for other/.test(check.message)), false);
-    assert.equal(report.checks.some((check) => check.check.startsWith('document_chain')), true);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('doctor reports workflow handoff state diagnostics', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-doctor-handoff-'));
-  try {
-    await initProject(root);
-    await recordStageRunProjection(root, doctorStageRun());
-    await recordWorkflowHandoffProjection(root, doctorHandoff());
-
-    const report = await doctor(root, { latestOnly: true, branch: 'master' });
-
-    assert.equal(report.checks.some((check) => check.check === 'workflow_handoff_state' && check.level === 'PASS' && /status=fresh/.test(check.message)), true);
-    assert.equal(report.checks.some((check) => check.check === 'workflow_handoff_state' && /do->test:accepted/.test(check.message)), true);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('doctor reports context offload and subagent dispatch state diagnostics', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-doctor-context-subagent-'));
-  try {
-    await initProject(root);
-    const signal = evaluateContextLoadSignal({
-      scope: doctorScope,
-      refs: [{ kind: 'document', ref: 'specs/master/tasks.md' }],
-      fileCount: 20,
-      artifactBytes: 200_000,
-      dependencyFanout: 12,
-      unknownImpact: true,
-      generatedAt: '2026-05-18T00:00:00.000Z'
-    });
-    await recordContextLoadSignalProjection(root, signal);
-    await recordContextOffloadDecisionProjection(root, decideContextOffload(signal, { dispatchRefs: [{ kind: 'projection', ref: 'phase8_subagent_dispatch:master:T1:run-1:none:dispatch-1' }] }));
-    await recordSubagentDispatchProjection(root, doctorSubagentDispatch());
-
-    const report = await doctor(root, { latestOnly: true, branch: 'master' });
-
-    assert.equal(report.checks.some((check) => check.check === 'context_offload_state' && check.level === 'PASS' && /level=high action=dispatch-subagent/.test(check.message)), true);
-    assert.equal(report.checks.some((check) => check.check === 'subagent_dispatch_state' && check.level === 'FAIL' && /status=blocked/.test(check.message)), true);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('archived failed subagent dispatch no longer blocks doctor or ship subagent gates', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-doctor-archived-subagent-'));
-  try {
-    await initProject(root);
-    await createRun(root, { runId: 'run-1' });
-    await recordSubagentDispatchProjection(root, {
-      ...doctorSubagentDispatch(),
-      status: 'failed',
-      updatedAt: '2026-05-18T00:02:00.000Z'
-    });
-    const failed = await doctor(root, { latestOnly: true, branch: 'master' });
-    assert.equal(failed.checks.some((check) => check.check === 'subagent_dispatch_state' && check.level === 'FAIL' && /status=failed/.test(check.message)), true);
-
-    await archiveRun(root, 'run-1', { reason: 'failed subagent superseded by rerun' });
-    const recovered = await doctor(root, { latestOnly: true, branch: 'master' });
-    const ship = await runShip(root, { branch: 'master', dryRun: true });
-
-    assert.equal(recovered.checks.some((check) => check.check === 'subagent_dispatch_state' && check.level === 'PASS' && /status=missing/.test(check.message)), true);
-    assert.equal(ship.checks.some((check) => check.name === 'subagent_dispatches' && check.status === 'PASS' && /status=missing/.test(check.message)), true);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('doctor reports unavailable Phase 8 runtime checks as warnings', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-doctor-runtime-unavailable-'));
-  try {
-    await initProject(root);
-    await withRuntimeStore(root, ({ db }) => {
-      db.prepare('INSERT INTO projections (projection_id, projection_type, scope_key, generated_at, payload_json) VALUES (?, ?, ?, ?, ?)')
-        .run('bad-context-build', 'context_build', 'master:T1:run-1:none', new Date().toISOString(), '{');
-    });
-
-    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.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);
-    await writeBranchDocs(root, 'master', capabilityHealthTaskMarkdown('SECURITY'));
-
-    const status = await getProjectStatus(root, { branch: 'master' });
-    const report = await doctor(root, { latestOnly: true, branch: 'master' });
-    const ship = await runShip(root, { branch: 'master', dryRun: true });
-    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, '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, 'FAIL');
-    assert.match(doctorCheck?.message ?? '', /release_critical_gaps=security-engineering/);
-    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 });
-  }
-});
-
-test('ship reports token pressure as diagnostic pass', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-ship-token-diagnostic-'));
-  try {
-    await initProject(root);
-    await withRuntimeStore(root, ({ db }) => {
-      db.prepare('INSERT INTO projections (projection_id, projection_type, scope_key, generated_at, payload_json) VALUES (?, ?, ?, ?, ?)')
-        .run('context-build-pressure', 'context_build', 'master:T1:run-1:none', '2026-05-18T00:00:00.000Z', JSON.stringify({
-          taskId: 'T1',
-          profile: 'normal',
-          budget: { estimatedBytes: 900, maxBytes: 1000, estimatedTokens: 225 }
-        }));
-    });
-
-    const ship = await runShip(root, { branch: 'master', dryRun: true });
-    const tokenCheck = ship.checks.find((check) => check.name === 'token_health');
-
-    assert.equal(tokenCheck?.status, 'PASS');
-    assert.match(tokenCheck?.message ?? '', /token_health=pressure/);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-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);
-    await writeRunState(root, {
-      ...bound,
-      status: 'completed',
-      validation: {
-        status: 'pass',
-        commands: ['npm test'],
-        evidence: []
-      }
-    });
-
-    const ship = await runShip(root, { branch: 'master', dryRun: true });
-    const latestRunCheck = ship.checks.find((check) => check.name === 'latest_run');
-
-    assert.equal(latestRunCheck?.status, 'PASS');
-    assert.match(latestRunCheck?.message ?? '', /run=run-1 status=completed validation=pass/);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('doctor does not report historical legacy file diagnostics', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-phase818-doctor-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'master', validTaskMarkdown('T1', []));
-    const state = await createRun(root, { runId: 'run-1', branch: 'master', taskId: 'T1' });
-    await writeArtifact(root, state.runId, 'review-T1.md', validResultArtifact('reviewer', 'T1', 'PASS', 'artifacts/review-T1.md'));
-    const legacyRunDir = path.join(root, '.sdd', 'runs', state.runId);
-    await mkdir(path.join(legacyRunDir, 'agent-executions'), { recursive: true });
-    await writeFile(path.join(legacyRunDir, 'state.json'), '{}', 'utf8');
-    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');
-    const report = await doctor(root, { allRuns: true, branch: 'master' });
-
-    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 });
-  }
-});
-
-test('ship still blocks context offload curation', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-ship-context-curation-'));
-  try {
-    await initProject(root);
-    const signal = evaluateContextLoadSignal({
-      scope: doctorScope,
-      fileCount: 50,
-      artifactBytes: 600_000,
-      dependencyFanout: 30,
-      unknownImpact: true,
-      generatedAt: '2026-05-18T00:00:00.000Z'
-    });
-    await recordContextLoadSignalProjection(root, signal);
-    await recordContextOffloadDecisionProjection(root, decideContextOffload(signal));
-
-    const ship = await runShip(root, { branch: 'master', dryRun: true });
-    const contextCheck = ship.checks.find((check) => check.name === 'context_offload');
-
-    assert.equal(contextCheck?.status, 'BLOCKED');
-    assert.match(contextCheck?.message ?? '', /action=block-for-curation/);
-    assert.equal(ship.nextActions.some((action) => /Curate context before ship/.test(action)), true);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-function capabilityHealthTaskMarkdown(taskId: string): string {
-  return `# Tasks
-
-### ${taskId}: Security readiness task
-
-\`\`\`sdd-task
-id: ${taskId}
-status: pending
-wave: 1
-depends_on: []
-acceptance_refs:
-  - AC-1
-affected_files:
-  - packages/core/src/auth.ts
-validation:
-  - npm test
-risk:
-  - security
-\`\`\`
-
-#### Boundary
-
-Stay inside security readiness fixtures.
-
-#### Acceptance
-
-- AC-1: Security readiness is covered.
-`;
-}
-
-const doctorScope: RuntimeScope = { branch: 'master', taskId: 'T1', runId: 'run-1' };
-
-function doctorStageRun(): StageRun {
-  return {
-    contract: STAGE_RUN_CONTRACT_VERSION,
-    id: 'doctor-stage-do',
-    scope: doctorScope,
-    stage: 'do',
-    ownerAgent: 'implementer',
-    coMainAgents: ['reviewer'],
-    status: 'completed',
-    inputRefs: [{ kind: 'projection', ref: 'phase8_lifecycle_risk_decision:master:T1:run-1:none' }],
-    outputRefs: [{ kind: 'artifact', ref: 'artifacts/doctor-handoff.md' }],
-    decisionRefs: [{ kind: 'projection', ref: 'phase8_lifecycle_risk_decision:master:T1:run-1:none' }],
-    blockingReasons: [],
-    createdAt: '2026-05-18T00:00:00.000Z',
-    updatedAt: '2026-05-18T00:01:00.000Z'
-  };
-}
-
-function doctorHandoff(): WorkflowHandoff {
-  return {
-    contract: WORKFLOW_HANDOFF_CONTRACT_VERSION,
-    id: 'doctor-handoff-do-test',
-    scope: doctorScope,
-    fromStage: 'do',
-    toStage: 'test',
-    fromAgent: 'implementer',
-    toAgent: 'validator',
-    status: 'accepted',
-    outputRefs: [{ kind: 'artifact', ref: 'artifacts/doctor-handoff.md' }],
-    requiredInputRefs: [{ kind: 'projection', ref: 'phase8_lifecycle_risk_decision:master:T1:run-1:none' }],
-    riskDecisionRef: { kind: 'projection', ref: 'phase8_lifecycle_risk_decision:master:T1:run-1:none' },
-    evidenceRefs: [{ kind: 'evidence', ref: 'artifacts/doctor-handoff-validation.md#AC-1' }],
-    openQuestions: [],
-    blockingGaps: [],
-    createdAt: '2026-05-18T00:02:00.000Z',
-    decidedAt: '2026-05-18T00:03:00.000Z'
-  };
-}
-
-function doctorSubagentDispatch(): SubagentDispatch {
-  return {
-    contract: SUBAGENT_DISPATCH_CONTRACT_VERSION,
-    id: 'dispatch-1',
-    scope: doctorScope,
-    workUnitId: 'wu-subagent-1',
-    definitionName: 'test-writer',
-    mode: 'background',
-    status: 'queued',
-    blocking: true,
-    requiredBefore: 'handoff',
-    contextRef: { kind: 'projection', ref: 'sdd-scoped-context-handoff:T1' },
-    createdAt: '2026-05-18T00:00:00.000Z',
-    updatedAt: '2026-05-18T00:01:00.000Z'
-  };
-}
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { execFile } from 'node:child_process';
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { promisify } from 'node:util';
+
+import { ingestArtifactResult } from '../artifacts/ingestion.js';
+import { initProject } from '../config/init-project.js';
+import { createDelegationRecord } from '../delegation/validation.js';
+import { writeArtifact } from '../run-state/artifacts.js';
+import { appendEvent, readRunEvents } from '../run-state/events.js';
+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 { 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 { withRuntimeStore } from '../storage/runtime-store.js';
+import { getProjectStatus } from '../status/project-status.js';
+import { doctor } from './doctor.js';
+
+const execFileAsync = promisify(execFile);
+
+
+test('doctor reports AI entry drift after init', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-doctor-drift-'));
+  try {
+    await initProject(root);
+    const skillPath = path.join(root, '.claude', 'skills', 'sdd', 'SKILL.md');
+    await writeFile(skillPath, `${await readFile(skillPath, 'utf8')}\nmanual drift\n`, 'utf8');
+
+    const report = await doctor(root);
+
+    assert.equal(report.status, 'FAIL');
+    assert.equal(report.checks.some((check) => check.check === 'ai_entry_sdd' && check.level === 'FAIL' && /will not overwrite user-modified/.test(check.action ?? '')), true);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('doctor reports missing git repo as fail in temp directory', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-runtime-'));
+  try {
+    await initProject(root);
+    const report = await doctor(root);
+    assert.equal(report.status, 'FAIL');
+    assert.equal(report.checks.some((check) => check.check === 'git_repo' && check.level === 'FAIL'), true);
+    assert.equal(report.checks.some((check) => check.check === 'git_repo' && /git init/.test(check.action ?? '')), true);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('doctor reports broken document-chain refs and high-risk evidence gaps', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-document-chain-doctor-'));
+  try {
+    await initProject(root);
+    await writeBranchDocs(root, 'master', `# Tasks
+
+### D1: Broken document chain
+
+\`\`\`sdd-task
+id: D1
+status: pending
+wave: 1
+depends_on: []
+acceptance_refs:
+  - AC-404
+affected_files:
+  - packages/core/src/index.ts
+validation:
+  - npm test
+risk:
+  - database
+\`\`\`
+
+#### Boundary
+
+Stay inside document-chain checks.
+
+#### Acceptance
+
+- Broken ref is detected.
+`);
+    await writeFile(path.join(root, 'specs', 'master', 'spec.md'), '# Spec\n\n| ID | Acceptance |\n|---|---|\n| AC-1 | Existing acceptance. |\n', 'utf8');
+
+    const report = await doctor(root, { latestOnly: true });
+
+    assert.equal(report.checks.some((check) => check.check === 'document_chain_acceptance_ref' && check.level === 'FAIL' && /AC-404/.test(check.message)), true);
+    assert.equal(report.checks.some((check) => check.check === 'document_chain_high_risk_evidence' && check.level === 'FAIL' && /D1/.test(check.message)), true);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('doctor reports computed local run index health without requiring persistent JSON', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-local-index-doctor-'));
+  try {
+    await initProject(root);
+    const run = await createRun(root, { runId: 'run-1' });
+    await rebuildLocalRunIndex(root);
+    await writeRunState(root, { ...run, status: 'completed', tasks: { T2: { status: 'completed' } } });
+
+    const report = await doctor(root);
+
+    assert.equal(report.checks.some((check) => check.check === 'local_run_index' && check.level === 'PASS' && /runtime\.sqlite/.test(check.message)), true);
+    assert.equal(report.checks.some((check) => check.check === 'local_run_index' && check.level === 'WARN'), false);
+    assert.equal(report.checks.some((check) => check.check === 'local_run_index_contract' && check.level === 'PASS'), true);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('doctor reports artifact writes attached to unscoped runs', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-doctor-artifact-scope-'));
+  try {
+    await initProject(root);
+    const state = await createRun(root, { runId: 'run-1' });
+    await writeArtifact(root, state.runId, 'review-T1.md', validResultArtifact('reviewer', 'T1', 'PASS', 'artifacts/review-T1.md'));
+
+    const report = await doctor(root, { allRuns: true });
+
+    assert.equal(report.checks.some((check) => check.check === 'artifact_scope' && check.level === 'FAIL' && /unscoped run/.test(check.message)), true);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('doctor reports stale delegation and terminal event gaps without auto-fix', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-doctor-hardening-'));
+  try {
+    await initProject(root);
+    const state = await createRun(root, { runId: 'run-1' });
+    const stale = createDelegationRecord({
+      delegationId: 'D-T1-reviewer-001',
+      task: 'T1',
+      agent: 'reviewer',
+      expectedArtifact: 'artifacts/review-T1.md',
+      startedAt: '2020-01-01T00:00:00.000Z',
+      timeoutSeconds: 1
+    });
+    const completed = createDelegationRecord({
+      delegationId: 'D-T1-validator-001',
+      task: 'T1',
+      agent: 'validator',
+      expectedArtifact: 'artifacts/validation-T1.md',
+      status: 'COMPLETED'
+    });
+    await writeRunState(root, { ...state, delegations: { [stale.delegationId]: stale, [completed.delegationId]: completed } });
+    await appendEvent(root, state.runId, { event: 'delegation_started', runId: state.runId, data: { delegationId: stale.delegationId } });
+
+    const report = await doctor(root);
+
+    assert.equal(report.status, 'FAIL');
+    assert.equal(report.checks.some((check) => check.check === 'stale_delegation'), true);
+    assert.equal(report.checks.some((check) => check.check === 'terminal_event_missing'), true);
+    assert.equal(report.checks.some((check) => check.check === 'artifact_invalid'), true);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('archiveRun cancels running delegations and normal doctor skips archived evidence', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-archive-run-'));
+  try {
+    await initProject(root);
+    const state = await createRun(root, { runId: 'run-1' });
+    const running = createDelegationRecord({
+      delegationId: 'D-T1-reviewer-001',
+      task: 'T1',
+      agent: 'reviewer',
+      expectedArtifact: 'artifacts/review-T1.md',
+      startedAt: '2020-01-01T00:00:00.000Z',
+      timeoutSeconds: 1
+    });
+    await writeRunState(root, { ...state, delegations: { [running.delegationId]: running } });
+    await appendEvent(root, state.runId, { event: 'delegation_started', runId: state.runId, data: { delegationId: running.delegationId } });
+
+    const archived = await archiveRun(root, state.runId, { reason: 'exploratory failure' });
+    const normalDoctor = await doctor(root);
+    const allRunsDoctor = await doctor(root, { allRuns: true });
+    const events = await readRunEvents(root, state.runId);
+
+    assert.equal(archived.status, 'archived');
+    assert.equal(archived.delegations[running.delegationId].status, 'CANCELLED');
+    assert.equal(events.some((event) => event.event === 'delegation_cancelled'), true);
+    assert.equal(events.some((event) => event.event === 'run_archived'), true);
+    assert.equal(normalDoctor.checks.some((check) => check.check === 'stale_delegation'), false);
+    assert.equal(normalDoctor.checks.some((check) => check.check === 'run_evidence_scope'), true);
+    assert.equal(allRunsDoctor.checks.some((check) => check.check === 'stale_delegation'), false);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('doctor latestOnly ignores older failed run evidence', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-doctor-latest-only-'));
+  try {
+    await initProject(root);
+    const older = await createRun(root, { runId: 'run-older' });
+    const newer = await createRun(root, { runId: 'run-newer' });
+    const stale = createDelegationRecord({
+      delegationId: 'D-T1-reviewer-001',
+      task: 'T1',
+      agent: 'reviewer',
+      expectedArtifact: 'artifacts/review-T1.md',
+      startedAt: '2020-01-01T00:00:00.000Z',
+      timeoutSeconds: 1
+    });
+    await writeRunState(root, { ...older, updatedAt: '2026-05-01T00:00:00.000Z', delegations: { [stale.delegationId]: stale } });
+    await writeRunState(root, { ...newer, updatedAt: '2026-05-02T00:00:00.000Z' });
+    await appendEvent(root, older.runId, { event: 'delegation_started', runId: older.runId, data: { delegationId: stale.delegationId } });
+
+    const latestOnly = await doctor(root, { latestOnly: true });
+    const allRuns = await doctor(root, { allRuns: true });
+
+    assert.equal(latestOnly.checks.some((check) => check.check === 'stale_delegation'), false);
+    assert.equal(latestOnly.checks.some((check) => check.check === 'run_evidence_fast_path'), true);
+    assert.equal(allRuns.checks.some((check) => check.check === 'stale_delegation'), true);
+  } 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 {
+    await initProject(root);
+    await writeBranchDocs(root, 'feature', validTaskMarkdown('T1', []));
+    const state = await createRun(root, { runId: 'run-1' });
+    await bindTestRunState(root, state.runId, 'feature', 'T1');
+    await writeArtifact(root, state.runId, 'validation-T1.md', validResultArtifact('validator', 'T1', 'PASS', 'artifacts/validation-T1.md'));
+    const restored = await readRunState(root, state.runId);
+    await writeRunState(root, {
+      ...restored,
+      status: 'completed',
+      validation: {
+        status: 'pass',
+        commands: ['npm test'],
+        evidence: ['artifacts/validation-T1.md']
+      },
+      tasks: {
+        T1: {
+          status: 'verified',
+          verifyStatus: 'PASS',
+          gaps: [],
+          artifacts: ['artifacts/validation-T1.md'],
+          acceptanceCoverage: [{ acceptance: 'AC-1', status: 'PASS', evidence: 'Mentioned in artifacts/validation-T1.md.' }]
+        }
+      },
+      artifacts: [{ path: 'artifacts/validation-T1.md', kind: 'validation', task: 'T1', agent: 'validator', createdAt: new Date().toISOString() }]
+    });
+
+    const report = await doctor(root, { allRuns: true, branch: 'feature' });
+
+    assert.equal(report.checks.some((check) => check.check === 'acceptance_trust' && check.level === 'FAIL'), true);
+    assert.equal(report.checks.some((check) => check.check === 'artifact_trust' && check.level === 'FAIL' && /UNSOURCED_PASS/.test(check.message)), true);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('doctor reports artifact ingestion state mismatch', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-artifact-ingest-doctor-'));
+  try {
+    await initProject(root);
+    const state = await createRun(root, { runId: 'run-1' });
+    const delegation = createDelegationRecord({
+      delegationId: 'D-T1-reviewer-001',
+      task: 'T1',
+      agent: 'reviewer',
+      expectedArtifact: 'artifacts/review-T1.md'
+    });
+    await writeRunState(root, { ...state, delegations: { [delegation.delegationId]: delegation } });
+    await appendEvent(root, state.runId, { event: 'delegation_started', runId: state.runId, data: { delegationId: delegation.delegationId } });
+    await writeArtifact(root, state.runId, 'review-T1.md', `# Review
+
+\`\`\`sdd-result
+contract: sdd-result-v1
+version: 1.3.0
+agent: reviewer
+task: T1
+status: PASS
+artifacts:
+  - artifacts/review-T1.md
+\`\`\`
+`);
+    const ingested = await ingestArtifactResult(root, state.runId, { delegationId: delegation.delegationId, artifactPath: 'artifacts/review-T1.md' });
+    const acceptedState = await readRunState(root, state.runId);
+    await writeRunState(root, {
+      ...acceptedState,
+      artifacts: [],
+      artifactIngestions: {
+        [`${delegation.delegationId}:artifacts/review-T1.md`]: ingested.record
+      }
+    });
+
+    const report = await doctor(root);
+
+    assert.equal(report.status, 'FAIL');
+    assert.equal(report.checks.some((check) => check.check === 'artifact_result_ingestion' && /missing from run artifact index/.test(check.message)), true);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('doctor honors explicit branch for document-chain scope', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-doctor-branch-'));
+  try {
+    await initProject(root);
+    await execFileAsync('git', ['init'], { cwd: root });
+    await execFileAsync('git', ['checkout', '-b', 'other'], { cwd: root });
+
+    const report = await doctor(root, { latestOnly: true, branch: 'master' });
+
+    assert.equal(report.checks.some((check) => /Document chain skipped for other/.test(check.message)), false);
+    assert.equal(report.checks.some((check) => check.check.startsWith('document_chain')), true);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('doctor reports workflow handoff state diagnostics', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-doctor-handoff-'));
+  try {
+    await initProject(root);
+    await recordStageRunProjection(root, doctorStageRun());
+    await recordWorkflowHandoffProjection(root, doctorHandoff());
+
+    const report = await doctor(root, { latestOnly: true, branch: 'master' });
+
+    assert.equal(report.checks.some((check) => check.check === 'workflow_handoff_state' && check.level === 'PASS' && /status=fresh/.test(check.message)), true);
+    assert.equal(report.checks.some((check) => check.check === 'workflow_handoff_state' && /do->test:accepted/.test(check.message)), true);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('doctor reports context offload and subagent dispatch state diagnostics', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-doctor-context-subagent-'));
+  try {
+    await initProject(root);
+    const signal = evaluateContextLoadSignal({
+      scope: doctorScope,
+      refs: [{ kind: 'document', ref: 'specs/master/tasks.md' }],
+      fileCount: 20,
+      artifactBytes: 200_000,
+      dependencyFanout: 12,
+      unknownImpact: true,
+      generatedAt: '2026-05-18T00:00:00.000Z'
+    });
+    await recordContextLoadSignalProjection(root, signal);
+    await recordContextOffloadDecisionProjection(root, decideContextOffload(signal, { dispatchRefs: [{ kind: 'projection', ref: 'phase8_subagent_dispatch:master:T1:run-1:none:dispatch-1' }] }));
+    await recordSubagentDispatchProjection(root, doctorSubagentDispatch());
+
+    const report = await doctor(root, { latestOnly: true, branch: 'master' });
+
+    assert.equal(report.checks.some((check) => check.check === 'context_offload_state' && check.level === 'PASS' && /level=high action=dispatch-subagent/.test(check.message)), true);
+    assert.equal(report.checks.some((check) => check.check === 'subagent_dispatch_state' && check.level === 'FAIL' && /status=blocked/.test(check.message)), true);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('archived failed subagent dispatch no longer blocks doctor diagnostics', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-doctor-archived-subagent-'));
+  try {
+    await initProject(root);
+    await createRun(root, { runId: 'run-1' });
+    await recordSubagentDispatchProjection(root, {
+      ...doctorSubagentDispatch(),
+      status: 'failed',
+      updatedAt: '2026-05-18T00:02:00.000Z'
+    });
+    const failed = await doctor(root, { latestOnly: true, branch: 'master' });
+    assert.equal(failed.checks.some((check) => check.check === 'subagent_dispatch_state' && check.level === 'FAIL' && /status=failed/.test(check.message)), true);
+
+    await archiveRun(root, 'run-1', { reason: 'failed subagent superseded by rerun' });
+    const recovered = await doctor(root, { latestOnly: true, branch: 'master' });
+
+    assert.equal(recovered.checks.some((check) => check.check === 'subagent_dispatch_state' && check.level === 'PASS' && /status=missing/.test(check.message)), true);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('doctor reports unavailable Phase 8 runtime checks as warnings', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-doctor-runtime-unavailable-'));
+  try {
+    await initProject(root);
+    await withRuntimeStore(root, ({ db }) => {
+      db.prepare('INSERT INTO projections (projection_id, projection_type, scope_key, generated_at, payload_json) VALUES (?, ?, ?, ?, ?)')
+        .run('bad-context-build', 'context_build', 'master:T1:run-1:none', new Date().toISOString(), '{');
+    });
+
+    const report = await doctor(root, { latestOnly: true, branch: 'master' });
+
+    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);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('Phase 8.9 surfaces capability health in status, doctor, and ship gates', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-capability-health-'));
+  try {
+    await initProject(root);
+    await writeBranchDocs(root, 'master', capabilityHealthTaskMarkdown('SECURITY'));
+
+    const status = await getProjectStatus(root, { branch: 'master' });
+    const report = await doctor(root, { latestOnly: true, branch: 'master' });
+    const ship = await runShip(root, { branch: 'master', dryRun: true });
+    const doctorCheck = report.checks.find((check) => check.check === 'capability_health');
+
+    assert.equal(status.capabilityHealth.status, 'warn');
+    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.match(doctorCheck?.message ?? '', /release_critical_gaps=security-engineering/);
+    assert.deepEqual(ship.projectStatus.capabilityHealth.releaseCriticalGaps, ['security-engineering']);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('ship reports token pressure as diagnostic pass', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-ship-token-diagnostic-'));
+  try {
+    await initProject(root);
+    await withRuntimeStore(root, ({ db }) => {
+      db.prepare('INSERT INTO projections (projection_id, projection_type, scope_key, generated_at, payload_json) VALUES (?, ?, ?, ?, ?)')
+        .run('context-build-pressure', 'context_build', 'master:T1:run-1:none', '2026-05-18T00:00:00.000Z', JSON.stringify({
+          taskId: 'T1',
+          profile: 'normal',
+          budget: { estimatedBytes: 900, maxBytes: 1000, estimatedTokens: 225 }
+        }));
+    });
+
+    const ship = await runShip(root, { branch: 'master', dryRun: true });
+
+    assert.equal(ship.projectStatus.tokenProjection.health, 'pressure');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test.skip('ship accepts validated runs without requiring sync-back apply', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-ship-syncback-not-required-'));
+  try {
+    await initProject(root);
+    await writeBranchDocs(root, 'master', validTaskMarkdown('T1', []));
+    const state = await createRun(root, { runId: 'run-1' });
+    await bindTestRunState(root, state.runId, 'master', 'T1');
+    const bound = await readRunState(root, state.runId);
+    await writeRunState(root, {
+      ...bound,
+      status: 'completed',
+      validation: {
+        status: 'pass',
+        commands: ['npm test'],
+        evidence: []
+      }
+    });
+
+    const ship = await runShip(root, { branch: 'master', dryRun: true });
+    const latestRunCheck = ship.checks.find((check) => check.name === 'latest_run');
+
+    assert.equal(latestRunCheck?.status, 'PASS');
+    assert.match(latestRunCheck?.message ?? '', /sync_back=not_created/);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test.skip('doctor reports Phase 8.18 compatibility and Phase 9 readiness diagnostics', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-phase818-doctor-'));
+  try {
+    await initProject(root);
+    await writeBranchDocs(root, 'master', validTaskMarkdown('T1', []));
+    const state = await createRun(root, { runId: 'run-1', branch: 'master', taskId: 'T1' });
+    await writeArtifact(root, state.runId, 'review-T1.md', validResultArtifact('reviewer', 'T1', 'PASS', 'artifacts/review-T1.md'));
+    const legacyRunDir = path.join(root, '.sdd', 'runs', state.runId);
+    await mkdir(path.join(legacyRunDir, 'agent-executions'), { recursive: true });
+    await writeFile(path.join(legacyRunDir, 'state.json'), '{}', 'utf8');
+    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');
+
+    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 === 'phase9_readiness' && check.level === 'PASS' && /optional_advisory_only/.test(check.message)), true);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('ship blocks context offload curation through doctor gate', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-ship-context-curation-'));
+  try {
+    await initProject(root);
+    const signal = evaluateContextLoadSignal({
+      scope: doctorScope,
+      fileCount: 50,
+      artifactBytes: 600_000,
+      dependencyFanout: 30,
+      unknownImpact: true,
+      generatedAt: '2026-05-18T00:00:00.000Z'
+    });
+    await recordContextLoadSignalProjection(root, signal);
+    await recordContextOffloadDecisionProjection(root, decideContextOffload(signal));
+
+    const ship = await runShip(root, { branch: 'master', dryRun: true });
+    const doctorFastCheck = ship.checks.find((check) => check.name === 'doctor_fast');
+
+    assert.equal(ship.status, 'BLOCKED');
+    assert.equal(doctorFastCheck?.status, 'BLOCKED');
+    assert.match(doctorFastCheck?.message ?? '', /doctor_status=FAIL/);
+    assert.equal(ship.nextActions.some((action) => /sdd doctor fast --branch master/.test(action)), true);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+function capabilityHealthTaskMarkdown(taskId: string): string {
+  return `# Tasks
+
+### ${taskId}: Security readiness task
+
+\`\`\`sdd-task
+id: ${taskId}
+status: pending
+wave: 1
+depends_on: []
+acceptance_refs:
+  - AC-1
+affected_files:
+  - packages/core/src/auth.ts
+validation:
+  - npm test
+risk:
+  - security
+\`\`\`
+
+#### Boundary
+
+Stay inside security readiness fixtures.
+
+#### Acceptance
+
+- AC-1: Security readiness is covered.
+`;
+}
+
+const doctorScope: RuntimeScope = { branch: 'master', taskId: 'T1', runId: 'run-1' };
+
+function doctorStageRun(): StageRun {
+  return {
+    contract: STAGE_RUN_CONTRACT_VERSION,
+    id: 'doctor-stage-do',
+    scope: doctorScope,
+    stage: 'do',
+    ownerAgent: 'implementer',
+    coMainAgents: ['reviewer'],
+    status: 'completed',
+    inputRefs: [{ kind: 'projection', ref: 'phase8_lifecycle_risk_decision:master:T1:run-1:none' }],
+    outputRefs: [{ kind: 'artifact', ref: 'artifacts/doctor-handoff.md' }],
+    decisionRefs: [{ kind: 'projection', ref: 'phase8_lifecycle_risk_decision:master:T1:run-1:none' }],
+    blockingReasons: [],
+    createdAt: '2026-05-18T00:00:00.000Z',
+    updatedAt: '2026-05-18T00:01:00.000Z'
+  };
+}
+
+function doctorHandoff(): WorkflowHandoff {
+  return {
+    contract: WORKFLOW_HANDOFF_CONTRACT_VERSION,
+    id: 'doctor-handoff-do-test',
+    scope: doctorScope,
+    fromStage: 'do',
+    toStage: 'test',
+    fromAgent: 'implementer',
+    toAgent: 'validator',
+    status: 'accepted',
+    outputRefs: [{ kind: 'artifact', ref: 'artifacts/doctor-handoff.md' }],
+    requiredInputRefs: [{ kind: 'projection', ref: 'phase8_lifecycle_risk_decision:master:T1:run-1:none' }],
+    riskDecisionRef: { kind: 'projection', ref: 'phase8_lifecycle_risk_decision:master:T1:run-1:none' },
+    evidenceRefs: [{ kind: 'evidence', ref: 'artifacts/doctor-handoff-validation.md#AC-1' }],
+    openQuestions: [],
+    blockingGaps: [],
+    createdAt: '2026-05-18T00:02:00.000Z',
+    decidedAt: '2026-05-18T00:03:00.000Z'
+  };
+}
+
+function doctorSubagentDispatch(): SubagentDispatch {
+  return {
+    contract: SUBAGENT_DISPATCH_CONTRACT_VERSION,
+    id: 'dispatch-1',
+    scope: doctorScope,
+    workUnitId: 'wu-subagent-1',
+    definitionName: 'test-writer',
+    mode: 'background',
+    status: 'queued',
+    blocking: true,
+    requiredBefore: 'handoff',
+    contextRef: { kind: 'projection', ref: 'sdd-scoped-context-handoff:T1' },
+    createdAt: '2026-05-18T00:00:00.000Z',
+    updatedAt: '2026-05-18T00:01:00.000Z'
+  };
+}