sdd-agent-platform 0.3.0 → 0.4.1

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

@@ -0,0 +1,489 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { DatabaseSync } from 'node:sqlite';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+
+import { writeArtifact } from '../run-state/artifacts.js';
+import { appendEvent, readRunEvents } from '../run-state/events.js';
+import { listInvocationLedgerEntries } from '../run-state/invocation-ledger.js';
+import { createRun, readRunState } from '../run-state/run-state.js';
+import { initProject } from '../config/init-project.js';
+import { doctor } from '../doctor/doctor.js';
+import { getInvocationLedgerPath, getRuntimeStorePath } from '../runtime-paths.js';
+import { lookupEvidence } from '../evidence/lookup.js';
+import { readTaskEvidenceView } from '../run-state/task-evidence.js';
+import { getProjectStatus, statuslineProjectionFromStatus } from '../status/project-status.js';
+import { STAGE_TEAM_RUNTIME_CONTRACT_VERSION, WORKFLOW_GATE_RUNTIME_CONTRACT_VERSION } from '../contracts.js';
+import { buildFanInEvidenceSet, type LlmAdvisorAssessmentRecord, type StageRoleResultRecord, type StageTeamSessionRecord } from '../execution/stage-team-runtime.js';
+import type { WorkflowGateDecision } from '../workflow-gate/types.js';
+import { listRuntimeAcceptanceEvidenceMaps, listRuntimeDurableGaps, listRuntimeFanInEvidenceSets, listRuntimeLlmAdvisorAssessments, listRuntimeStageRoleResults, listRuntimeStageTeamSessions, listRuntimeValidationEnvironmentSessions, listRuntimeValidationWaveRuns, listRuntimeWorkflowGateDecisions, recordRuntimeAcceptanceEvidenceMap, recordRuntimeArtifactPayload, recordRuntimeDurableGap, recordRuntimeFanInEvidenceSet, recordRuntimeLlmAdvisorAssessment, recordRuntimeStageRoleResult, recordRuntimeStageTeamSession, recordRuntimeValidationEnvironmentSession, recordRuntimeValidationWaveRun, recordRuntimeWorkflowGateDecision, runtimeScopedId, updateRuntimeDurableGapStatus } from './runtime-store.js';
+
+test('runtime store mirrors run state events artifacts and doctor visibility', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-runtime-store-'));
+  try {
+    await initProject(root);
+    const run = await createRun(root, { runId: 'store-run-001' });
+    await appendEvent(root, run.runId, { event: 'runtime_store_test_event', runId: run.runId, summary: 'store mirror test' });
+    await writeArtifact(root, run.runId, 'validation-T1.md', 'runtime store artifact');
+
+    const db = new DatabaseSync(getRuntimeStorePath(root), { readOnly: true });
+    try {
+      const storedRun = db.prepare('SELECT run_id, status FROM runs WHERE run_id = ?').get(run.runId) as { run_id?: string; status?: string } | undefined;
+      const storedEvent = db.prepare('SELECT event_name FROM events WHERE run_id = ? AND event_name = ?').get(run.runId, 'runtime_store_test_event') as { event_name?: string } | undefined;
+      const storedArtifact = db.prepare('SELECT path FROM artifacts WHERE run_id = ? AND path = ?').get(run.runId, 'artifacts/validation-T1.md') as { path?: string } | undefined;
+      const storedEvidence = db.prepare('SELECT logical_ref, physical_payload_path FROM artifact_payloads WHERE run_id = ? AND logical_ref = ? AND status = ?').get(run.runId, 'artifacts/validation-T1.md', 'active') as { logical_ref?: string; physical_payload_path?: string } | undefined;
+      assert.equal(storedRun?.run_id, run.runId);
+      assert.equal(storedRun?.status, 'created');
+      assert.equal(storedEvent?.event_name, 'runtime_store_test_event');
+      assert.equal(storedArtifact?.path, 'artifacts/validation-T1.md');
+      assert.equal(storedEvidence?.logical_ref, 'artifacts/validation-T1.md');
+      assert.match(storedEvidence?.physical_payload_path ?? '', /^artifacts\/validation-T1-store-run-001-[a-f0-9]{12}\.md$/);
+    } finally {
+      db.close();
+    }
+
+    const report = await doctor(root, { latestOnly: true });
+    const runtimeStoreCheck = report.checks.find((check) => check.check === 'runtime_store');
+    assert.equal(runtimeStoreCheck?.level, 'PASS');
+    assert.match(runtimeStoreCheck?.message ?? '', /phase-8\.17-validation-wave-runtime-v6/);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('runtime store persists workflow gate decisions as runtime policy authority', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-workflow-gate-runtime-'));
+  try {
+    await initProject(root);
+    const run = await createRun(root, { runId: 'workflow-gate-run-001' });
+    const decision: WorkflowGateDecision = {
+      decisionId: 'gate-001',
+      inputHash: 'input-hash-001',
+      generatedAt: '2026-01-01T00:00:00.000Z',
+      partition: 'master',
+      taskId: 'T1',
+      runId: run.runId,
+      decisionKind: 'ship',
+      status: 'PASS',
+      decidedBy: 'runtime_policy',
+      hardBlocks: [],
+      warnings: [],
+      advisorSummary: {
+        status: 'none',
+        highConcernCount: 0,
+        mediumConcernCount: 0,
+        invalidCount: 0,
+        lowConfidenceCount: 0,
+        summaries: []
+      },
+      allowedNextActions: ['ship'],
+      forbiddenNextActions: [],
+      humanRequired: false,
+      reasons: ['runtime_policy produced PASS'],
+      evidenceRefs: ['artifacts/validation-T1.md'],
+      payload: { contract: WORKFLOW_GATE_RUNTIME_CONTRACT_VERSION, packetId: 'packet-001' }
+    };
+
+    await recordRuntimeWorkflowGateDecision(root, decision);
+    const decisions = await listRuntimeWorkflowGateDecisions(root, { partition: 'master', taskId: 'T1', decisionKind: 'ship' });
+
+    assert.equal(decisions.length, 1);
+    assert.equal(decisions[0].decisionId, decision.decisionId);
+    assert.equal(decisions[0].decidedBy, 'runtime_policy');
+    assert.deepEqual(decisions[0].payload, { contract: WORKFLOW_GATE_RUNTIME_CONTRACT_VERSION, packetId: 'packet-001' });
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('runtime store persists validation wave sessions and acceptance evidence maps', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-validation-wave-runtime-'));
+  try {
+    await initProject(root);
+    const run = await createRun(root, { runId: 'validation-wave-run-001' });
+    await recordRuntimeValidationEnvironmentSession(root, {
+      sessionId: 'env-001',
+      partition: 'master',
+      runId: run.runId,
+      waveRunId: 'wave-001',
+      status: 'completed',
+      reuseKey: 'master:1:T1,T2',
+      createdAt: '2026-01-01T00:00:00.000Z',
+      updatedAt: '2026-01-01T00:01:00.000Z',
+      payload: { shared: true }
+    });
+    await recordRuntimeValidationWaveRun(root, {
+      waveRunId: 'wave-001',
+      partition: 'master',
+      runId: run.runId,
+      taskIds: ['T1', 'T2'],
+      status: 'PASS',
+      environmentSessionId: 'env-001',
+      startedAt: '2026-01-01T00:00:00.000Z',
+      completedAt: '2026-01-01T00:01:00.000Z',
+      payload: { tasks: 2 }
+    });
+    await recordRuntimeAcceptanceEvidenceMap(root, {
+      mapId: 'map-001',
+      waveRunId: 'wave-001',
+      testRunId: 'test-run-001',
+      partition: 'master',
+      runId: run.runId,
+      taskId: 'T1',
+      acceptanceRef: 'AC-1',
+      status: 'complete',
+      evidenceRefs: ['artifacts/test-T1-001.log'],
+      gaps: [],
+      createdAt: '2026-01-01T00:01:00.000Z',
+      payload: { source: 'validation-wave' }
+    });
+
+    const waves = await listRuntimeValidationWaveRuns(root, { partition: 'master', taskId: 'T1' });
+    const sessions = await listRuntimeValidationEnvironmentSessions(root, { partition: 'master', waveRunId: 'wave-001' });
+    const maps = await listRuntimeAcceptanceEvidenceMaps(root, { partition: 'master', taskId: 'T1', waveRunId: 'wave-001' });
+
+    assert.equal(waves.length, 1);
+    assert.deepEqual(waves[0].taskIds, ['T1', 'T2']);
+    assert.equal(sessions[0].reuseKey, 'master:1:T1,T2');
+    assert.deepEqual(maps[0].evidenceRefs, ['artifacts/test-T1-001.log']);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('runtime store imports changed legacy run state and events', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-runtime-legacy-import-'));
+  try {
+    await initProject(root);
+    const run = await createRun(root, { runId: 'legacy-run-001' });
+    const state = await readRunState(root, run.runId);
+    const statePath = path.join(root, '.sdd', 'runs', run.runId, 'state.json');
+    await mkdir(path.dirname(statePath), { recursive: true });
+    const legacyIngestion = {
+      contract: 'sdd-artifact-result-ingestion-v1' as const,
+      runId: run.runId,
+      delegationId: 'D-T1-validator-001',
+      task: 'T1',
+      agent: 'validator',
+      artifactPath: 'artifacts/validation-T1.md',
+      status: 'accepted' as const,
+      resultStatus: 'PASS' as const,
+      delegationStatus: 'COMPLETED' as const,
+      ingestedAt: '2026-01-01T00:00:00.000Z',
+      issues: [],
+      gaps: []
+    };
+    await writeFile(statePath, `${JSON.stringify({
+      ...state,
+      status: 'completed',
+      updatedAt: '2026-01-01T00:00:00.000Z',
+      artifacts: [{ path: 'artifacts/validation-T1.md', kind: 'validation', task: 'T1', agent: 'validator', createdAt: '2026-01-01T00:00:00.000Z' }],
+      artifactIngestions: { 'D-T1-validator-001:artifacts/validation-T1.md': legacyIngestion }
+    }, null, 2)}\n`, 'utf8');
+    await writeFile(path.join(root, '.sdd', 'runs', run.runId, 'events.jsonl'), `${JSON.stringify({
+      contract: 'sdd-event-log-v1',
+      time: '2026-01-01T00:00:00.000Z',
+      event: 'legacy_event_after_store',
+      runId: run.runId,
+      summary: 'legacy event'
+    })}\n`, 'utf8');
+    await mkdir(path.dirname(getInvocationLedgerPath(root, run.runId)), { recursive: true });
+    await writeFile(getInvocationLedgerPath(root, run.runId), `${JSON.stringify({
+      contract: 'sdd-invocation-ledger-v1',
+      version: '1.0.0',
+      entryId: 'legacy-ledger-entry-001',
+      runId: run.runId,
+      taskId: 'T1',
+      branch: 'master',
+      kind: 'command',
+      ref: 'npm test',
+      status: 'declared',
+      timestamp: '2026-01-01T00:00:00.000Z',
+      materialRefs: [],
+      metadata: { source: 'legacy-test' }
+    })}\n`, 'utf8');
+    const dbBeforeImport = new DatabaseSync(getRuntimeStorePath(root));
+    try {
+      dbBeforeImport.prepare('DELETE FROM runs WHERE run_id = ?').run(run.runId);
+    } finally {
+      dbBeforeImport.close();
+    }
+
+    const importedState = await readRunState(root, run.runId);
+    const importedEvents = await readRunEvents(root, run.runId);
+    const importedLedger = await listInvocationLedgerEntries(root, run.runId);
+    const db = new DatabaseSync(getRuntimeStorePath(root), { readOnly: true });
+    try {
+      const artifact = db.prepare('SELECT path, status FROM artifacts WHERE run_id = ? AND path = ?').get(run.runId, 'artifacts/validation-T1.md') as { path?: string; status?: string } | undefined;
+      const ingestion = db.prepare('SELECT status, result_status FROM artifact_ingestions WHERE run_id = ? AND artifact_path = ?').get(run.runId, 'artifacts/validation-T1.md') as { status?: string; result_status?: string } | undefined;
+      const activity = db.prepare('SELECT ref, status FROM activities WHERE run_id = ? AND activity_id = ?').get(run.runId, 'legacy-ledger-entry-001') as { ref?: string; status?: string } | undefined;
+      assert.equal(importedState.status, 'completed');
+      assert.equal(importedEvents.some((event) => event.event === 'legacy_event_after_store'), true);
+      assert.equal(importedLedger.some((entry) => entry.entryId === 'legacy-ledger-entry-001'), true);
+      assert.equal(artifact?.status, 'legacy_imported');
+      assert.equal(ingestion?.status, 'accepted');
+      assert.equal(ingestion?.result_status, 'PASS');
+      assert.equal(activity?.ref, 'npm test');
+    } finally {
+      db.close();
+    }
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+
+test('evidence lookup locates metadata payload statuses without gate authority', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-evidence-lookup-'));
+  try {
+    await initProject(root);
+    const run = await createRun(root, { runId: 'lookup-run-001' });
+    await recordRuntimeArtifactPayload(root, {
+      payloadId: runtimeScopedId(run.runId, 'artifacts/validation-T1.md', 'active-a'),
+      runId: run.runId,
+      sourceRunId: run.runId,
+      branchSlug: 'feature',
+      taskId: 'T1',
+      logicalRef: 'artifacts/validation-T1.md',
+      physicalPayloadPath: 'artifacts/validation-T1-lookup-run-001-active-a.md',
+      artifactRole: 'validation',
+      digest: 'active-a',
+      status: 'active',
+      payload: { title: 'first active' }
+    });
+    await recordRuntimeArtifactPayload(root, {
+      payloadId: runtimeScopedId(run.runId, 'artifacts/validation-T1.md', 'active-b'),
+      runId: run.runId,
+      sourceRunId: run.runId,
+      branchSlug: 'feature',
+      taskId: 'T1',
+      logicalRef: 'artifacts/validation-T1.md',
+      physicalPayloadPath: 'artifacts/validation-T1-lookup-run-001-active-b.md',
+      artifactRole: 'validation',
+      digest: 'active-b',
+      status: 'active',
+      payload: { title: 'second active' }
+    });
+    await recordRuntimeArtifactPayload(root, {
+      payloadId: runtimeScopedId(run.runId, 'artifacts/review-T1.md', 'candidate'),
+      runId: run.runId,
+      sourceRunId: run.runId,
+      branchSlug: 'feature',
+      taskId: 'T1',
+      logicalRef: 'artifacts/review-T1.md',
+      physicalPayloadPath: 'artifacts/review-T1-lookup-run-001-candidate.md',
+      artifactRole: 'review',
+      digest: 'candidate',
+      status: 'candidate',
+      payload: { title: 'candidate review' }
+    });
+    await recordRuntimeArtifactPayload(root, {
+      payloadId: runtimeScopedId(run.runId, 'artifacts/review-T1.md', 'rejected'),
+      runId: run.runId,
+      sourceRunId: run.runId,
+      branchSlug: 'feature',
+      taskId: 'T1',
+      logicalRef: 'artifacts/review-T1.md',
+      physicalPayloadPath: 'artifacts/review-T1-lookup-run-001-rejected.md',
+      artifactRole: 'review',
+      digest: 'rejected',
+      status: 'rejected',
+      payload: { title: 'rejected review' }
+    });
+    await recordRuntimeArtifactPayload(root, {
+      payloadId: runtimeScopedId(run.runId, 'artifacts/validation-T1.md', 'active-t2'),
+      runId: run.runId,
+      sourceRunId: run.runId,
+      branchSlug: 'feature',
+      taskId: 'T2',
+      logicalRef: 'artifacts/validation-T1.md',
+      physicalPayloadPath: 'artifacts/validation-T1-lookup-run-001-active-t2.md',
+      artifactRole: 'validation',
+      digest: 'active-t2',
+      status: 'active',
+      payload: { title: 'different task active' }
+    });
+
+    const lookup = await lookupEvidence(root, { runId: run.runId, taskId: 'T1', status: 'any' });
+
+    assert.equal(lookup.retrievalMemoryOnly, true);
+    assert.equal(lookup.gateTruthAuthority, false);
+    assert.deepEqual(lookup.counts, { active: 1, candidate: 1, rejected: 1, superseded: 1 });
+    assert.equal(lookup.payloads.some((payload) => payload.status === 'superseded'), true);
+    assert.deepEqual(lookup.resolvedPayloads.map((payload) => payload.physicalPayloadPath), ['artifacts/validation-T1-lookup-run-001-active-b.md']);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('runtime durable gaps persist query and protect terminal closure authority', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-durable-gap-'));
+  try {
+    await initProject(root);
+    const run = await createRun(root, { runId: 'durable-gap-run-001' });
+    await recordRuntimeDurableGap(root, {
+      gapId: 'gap-001',
+      partition: 'master',
+      taskId: 'T1',
+      runId: run.runId,
+      stage: 'test',
+      gate: 'workflow',
+      source: 'agent',
+      category: 'evidence_gap',
+      severity: 'blocking',
+      status: 'open',
+      message: 'Validation evidence is missing.',
+      recommendation: 'Run sdd test task T1 --branch master.',
+      evidenceRefs: ['artifacts/validation-T1.md'],
+      proposalRefs: [],
+      sourceRefs: ['agent:validator'],
+      payload: { proposedBy: 'validator' }
+    });
+
+    const open = await listRuntimeDurableGaps(root, { partition: 'master', taskId: 'T1', status: 'open_terminal' });
+    assert.equal(open.length, 1);
+    assert.equal(open[0].severity, 'blocking');
+    await assert.rejects(() => recordRuntimeDurableGap(root, {
+      ...open[0],
+      gapId: 'gap-llm-close',
+      source: 'llm_advisor',
+      status: 'resolved',
+      payload: {}
+    }), /terminal status resolved cannot be written by llm_advisor/);
+    await assert.rejects(() => updateRuntimeDurableGapStatus(root, { gapId: 'gap-001', status: 'resolved', source: 'team' }), /terminal status resolved cannot be written by team/);
+
+    const status = await getProjectStatus(root, { branch: 'master' });
+    const report = await doctor(root, { latestOnly: true, branch: 'master' });
+    const evidence = await readTaskEvidenceView(root, { branch: 'master', taskId: 'T1' });
+    assert.equal(status.durableGaps.length, 1);
+    assert.equal(statuslineProjectionFromStatus(status).counts.durableGaps, 1);
+    assert.equal(report.checks.some((check) => check.check === 'durable_gap_runtime' && check.level === 'FAIL' && /blocking=1/.test(check.message)), true);
+    assert.equal(evidence.durableGaps.length, 1);
+
+    const resolved = await updateRuntimeDurableGapStatus(root, { gapId: 'gap-001', status: 'resolved', source: 'gate_policy' });
+    assert.equal(resolved?.status, 'resolved');
+    assert.equal(resolved?.closedAt !== null, true);
+    assert.equal((await listRuntimeDurableGaps(root, { partition: 'master', taskId: 'T1', status: 'open_terminal' })).length, 0);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('stage team role results advisors and fan-in evidence persist as advisory gate inputs', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-stage-team-runtime-'));
+  try {
+    await initProject(root);
+    const run = await createRun(root, { runId: 'stage-team-run-001' });
+    const session: StageTeamSessionRecord = {
+      contract: STAGE_TEAM_RUNTIME_CONTRACT_VERSION,
+      sessionId: 'session-001',
+      partition: 'master',
+      runId: run.runId,
+      taskId: 'T1',
+      stage: 'test',
+      lifecycleProfile: 'full',
+      status: 'completed',
+      createdAt: '2026-01-01T00:00:00.000Z',
+      updatedAt: '2026-01-01T00:01:00.000Z',
+      assignments: [{
+        assignmentId: 'assignment-001',
+        roleId: 'role.evidence-runner',
+        agentId: 'validator',
+        status: 'completed',
+        required: true,
+        authorityCeiling: 'gate_input',
+        materialRefs: ['verify.md'],
+        createdAt: '2026-01-01T00:00:00.000Z',
+        updatedAt: '2026-01-01T00:01:00.000Z'
+      }],
+      payload: { profileReason: 'high risk' }
+    };
+    const roleResult: StageRoleResultRecord = {
+      contract: STAGE_TEAM_RUNTIME_CONTRACT_VERSION,
+      resultId: 'role-result-001',
+      sessionId: session.sessionId,
+      assignmentId: 'assignment-001',
+      partition: 'master',
+      runId: run.runId,
+      taskId: 'T1',
+      roleId: 'role.evidence-runner',
+      agentId: 'validator',
+      outputKind: 'evidence',
+      authorityCeiling: 'gate_input',
+      status: 'accepted',
+      summary: 'Validation evidence collected.',
+      evidenceRefs: ['artifacts/validation-T1.md'],
+      durableGapIds: ['gap-001'],
+      proposalRefs: ['artifacts/proposal-T1.md'],
+      advisorAssessmentIds: ['advisor-001'],
+      createdAt: '2026-01-01T00:02:00.000Z',
+      payload: { exitCode: 0 }
+    };
+    const advisor: LlmAdvisorAssessmentRecord = {
+      contract: STAGE_TEAM_RUNTIME_CONTRACT_VERSION,
+      assessmentId: 'advisor-001',
+      sessionId: session.sessionId,
+      partition: 'master',
+      runId: run.runId,
+      taskId: 'T1',
+      kind: 'evidence_sufficiency',
+      concern: 'high',
+      validity: 'valid',
+      confidence: 'high',
+      advisoryOnly: true,
+      summary: 'Evidence is incomplete until deterministic gate confirms it.',
+      evidenceRefs: ['artifacts/validation-T1.md'],
+      durableGapIds: ['gap-001'],
+      proposalRefs: ['artifacts/proposal-T1.md'],
+      createdAt: '2026-01-01T00:03:00.000Z',
+      payload: { recommendation: 'rerun validation' }
+    };
+    const fanIn = buildFanInEvidenceSet({
+      fanInId: 'fanin-001',
+      partition: 'master',
+      runId: run.runId,
+      taskId: 'T1',
+      stage: 'test',
+      roleResultIds: [roleResult.resultId],
+      durableGapIds: ['gap-001'],
+      proposalRefs: ['artifacts/proposal-T1.md'],
+      advisorAssessmentIds: [advisor.assessmentId],
+      evidenceRefs: ['artifacts/validation-T1.md'],
+      canonicalEvidenceRefs: ['payload-validation-T1'],
+      createdAt: '2026-01-01T00:04:00.000Z',
+      payload: { gateWillDecide: true }
+    });
+
+    await recordRuntimeStageTeamSession(root, session);
+    await recordRuntimeStageRoleResult(root, roleResult);
+    await recordRuntimeLlmAdvisorAssessment(root, advisor);
+    await recordRuntimeFanInEvidenceSet(root, fanIn);
+    await assert.rejects(() => recordRuntimeStageRoleResult(root, { ...roleResult, resultId: 'role-result-bad', payload: { stage_passed: true } }), /stage_passed/);
+    await assert.rejects(() => recordRuntimeLlmAdvisorAssessment(root, { ...advisor, assessmentId: 'advisor-bad', advisoryOnly: false } as unknown as LlmAdvisorAssessmentRecord), /advisoryOnly=true/);
+    await assert.rejects(() => recordRuntimeFanInEvidenceSet(root, { ...fanIn, fanInId: 'fanin-bad', gateInputOnly: false } as unknown as typeof fanIn), /gateInputOnly=true/);
+
+    assert.equal((await listRuntimeStageTeamSessions(root, { partition: 'master', taskId: 'T1' })).length, 1);
+    assert.equal((await listRuntimeStageRoleResults(root, { partition: 'master', taskId: 'T1' }))[0].authorityCeiling, 'gate_input');
+    assert.equal((await listRuntimeLlmAdvisorAssessments(root, { partition: 'master', taskId: 'T1' }))[0].advisoryOnly, true);
+    assert.equal((await listRuntimeLlmAdvisorAssessments(root, { partition: 'master', taskId: 'T1' }))[0].confidence, 'high');
+    assert.equal((await listRuntimeFanInEvidenceSets(root, { partition: 'master', taskId: 'T1' }))[0].gateInputOnly, true);
+
+    const evidence = await readTaskEvidenceView(root, { branch: 'master', taskId: 'T1' });
+    const status = await getProjectStatus(root, { branch: 'master' });
+    const statusline = statuslineProjectionFromStatus(status);
+    const report = await doctor(root, { latestOnly: true, branch: 'master' });
+    assert.equal(evidence.stageTeam.sessions.length, 1);
+    assert.equal(evidence.stageTeam.roleResults.length, 1);
+    assert.equal(evidence.stageTeam.advisorAssessments.length, 1);
+    assert.equal(evidence.stageTeam.fanInEvidenceSets.length, 1);
+    assert.equal(status.stageTeamHealth.highConcernAdvisors, 1);
+    assert.equal(statusline.counts.stageTeamSessions, 1);
+    assert.equal(statusline.counts.stageRoleResults, 1);
+    assert.equal(statusline.counts.advisorAssessments, 1);
+    assert.equal(report.checks.some((check) => check.check === 'stage_team_runtime' && check.level === 'WARN' && /high_concern=1/.test(check.message)), true);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});