sdd-agent-platform 0.4.0 → 0.4.2

package/node_modules/@sdd-agent-platform/core/src/verification/single-task-loop.test.ts

@@ -8,14 +8,18 @@ import { promisify } from 'node:util';
 
 import { inspectArtifactResultIngestions } from '../artifacts/ingestion.js';
 import { initProject } from '../config/init-project.js';
-import { getProjectStatus } from '../status/project-status.js';
 import { doctor } from '../doctor/doctor.js';
 import { readArtifact, writeArtifact } from '../run-state/artifacts.js';
 import { inspectRun } from '../run-state/inspect-run.js';
+import { readTaskEvidenceView } from '../run-state/task-evidence.js';
 import { rebuildLocalRunIndex } from '../run-state/run-index.js';
 import { readRunEvents } from '../run-state/events.js';
 import { createRun, readRunState } from '../run-state/run-state.js';
+import { recordRuntimeArtifactPayload, runtimeScopedId } from '../storage/runtime-store.js';
+import { evaluateLifecycleRiskDecisionForModel, recordLifecycleRiskDecisionProjection } from '../risk.js';
+import { parseSddBranch } from '../sdd-docs/task-parser.js';
 import { validResultArtifact, validTaskMarkdown, validTrustEvidence, writeBranchDocs } from '../test-support/fixtures.js';
+import { writeVerifyContract } from './verify-contract.js';
 import { bindTestRunState } from '../test-support/run-state.js';
 import { renderSingleTaskLoopResult } from './rendering.js';
 import { runSingleTaskLoop } from './single-task-loop.js';
@@ -32,17 +36,19 @@ test('runSingleTaskLoop completes from supplied review and validation artifacts
     await initProject(root);
     await execFileAsync('git', ['init'], { cwd: root });
     await writeBranchDocs(root, 'feature', validTaskMarkdown('T1', []));
+    await writeVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
+    await seedLifecycleRiskDecision(root, 'feature');
     const state = await createRun(root, { runId: 'run-1' });
     await bindTestRunState(root, state.runId, 'feature', 'T1');
-    await writeArtifact(root, state.runId, 'review-T1.md', validResultArtifact('reviewer', 'T1', 'PASS', 'artifacts/review-T1.md'));
-    await writeArtifact(root, state.runId, 'validation-T1.md', `${validResultArtifact('validator', 'T1', 'PASS', 'artifacts/validation-T1.md')}${validTrustEvidence('T1', 'AC-1', 'artifacts/validation-T1.md')}`);
+    await writeArtifact(root, state.runId, 'code-review-T1.md', validResultArtifact('reviewer', 'T1', 'PASS', '.sdd/runs/feature/do/code-review-T1.md'));
+    await writeArtifact(root, state.runId, 'validation-T1.md', `${validResultArtifact('validator', 'T1', 'PASS', '.sdd/runs/feature/test/validation-T1.md')}${validTrustEvidence('T1', 'AC-1', '.sdd/runs/feature/test/validation-T1.md')}`);
 
     const result = await runSingleTaskLoop(root, {
       runId: state.runId,
       branch: 'feature',
       taskId: 'T1',
-      reviewArtifact: 'artifacts/review-T1.md',
-      validationArtifact: 'artifacts/validation-T1.md'
+      reviewArtifact: '.sdd/runs/feature/do/code-review-T1.md',
+      validationArtifact: '.sdd/runs/feature/test/validation-T1.md'
     });
     const restored = await readRunState(root, state.runId);
     const ingestionInspection = await inspectArtifactResultIngestions(root, state.runId);
@@ -50,16 +56,29 @@ test('runSingleTaskLoop completes from supplied review and validation artifacts
     const doctorReport = await doctor(root, { latestOnly: true });
     const events = stringifyEvents(await readRunEvents(root, state.runId));
     const tasksMarkdown = await readFile(path.join(root, 'specs', 'feature', 'tasks.md'), 'utf8');
+    await execFileAsync('git', ['checkout', '-b', 'feature'], { cwd: root });
+    await recordRuntimeArtifactPayload(root, {
+      payloadId: runtimeScopedId(state.runId, '.sdd/runs/feature/test/validation-T2.md', 'foreign-task'),
+      runId: state.runId,
+      sourceRunId: state.runId,
+      branchSlug: 'feature',
+      taskId: 'T2',
+      logicalRef: '.sdd/runs/feature/test/validation-T2.md',
+      physicalPayloadPath: 'validation-T2-run-1-foreign-task.md',
+      artifactRole: 'validation',
+      digest: 'foreign-task',
+      status: 'active',
+      payload: { logicalRef: '.sdd/runs/feature/test/validation-T2.md' }
+    });
+    const taskEvidence = await readTaskEvidenceView(root, { branch: 'feature', taskId: 'T1' });
 
     assert.equal(result.status, 'completed');
-    assert.deepEqual(result.acceptedArtifacts, ['artifacts/review-T1.md', 'artifacts/validation-T1.md']);
+    assert.deepEqual(result.acceptedArtifacts, ['.sdd/runs/feature/do/code-review-T1.md', '.sdd/runs/feature/test/validation-T1.md']);
     assert.equal(restored.status, 'completed');
     assert.equal(restored.currentTask, 'T1');
-    assert.equal(restored.syncBack.status, 'proposed');
-    assert.equal(restored.syncBack.proposalPath, 'artifacts/sync-back-proposal.md');
     assert.equal(ingestionInspection.valid, true);
     assert.deepEqual(ingestionInspection.records.map((record) => record.delegationId), ['B-T1-reviewer-001', 'B-T1-validator-001']);
-    assert.equal(doctorReport.status, 'WARN');
+    assert.equal(doctorReport.status, 'FAIL');
     assert.match(events, /task_selected/);
     assert.match(events, /review_passed/);
     assert.match(events, /validation_passed/);
@@ -67,73 +86,143 @@ test('runSingleTaskLoop completes from supplied review and validation artifacts
     assert.match(events, /delegation_completed/);
     assert.doesNotMatch(events, /agent_completed/);
     assert.match(tasksMarkdown, /status: pending/);
+    assert.equal(taskEvidence.latestEligibleRun?.runId, state.runId);
+    assert.equal(taskEvidence.compatibility, 'compatible');
+    assert.equal(taskEvidence.payloads.active.some((payload) => payload.logicalRef === '.sdd/runs/feature/test/validation-T1.md'), true);
+    assert.equal(taskEvidence.payloads.all.some((payload) => payload.taskId === 'T2'), false);
+    assert.equal(taskEvidence.validation.runValidation?.status, 'pass');
   } finally {
     await rm(root, { recursive: true, force: true });
   }
 });
 
-test('runSingleTaskLoop blocks on missing reviewer artifact and creates gap proposal', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-loop-block-'));
+test('runSingleTaskLoop blocks rejected validation ingestion without accepting the artifact', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-loop-rejected-validation-'));
   try {
     await initProject(root);
     await writeBranchDocs(root, 'feature', validTaskMarkdown('T1', []));
+    await seedLifecycleRiskDecision(root, 'feature');
     const state = await createRun(root, { runId: 'run-1' });
+    await bindTestRunState(root, state.runId, 'feature', 'T1');
+    await writeArtifact(root, state.runId, 'code-review-T1.md', validResultArtifact('reviewer', 'T1', 'PASS', '.sdd/runs/feature/do/code-review-T1.md'));
+    await writeArtifact(root, state.runId, 'validation-T1.md', validResultArtifact('validator', 'T1', 'PASS', '.sdd/runs/feature/test/validation-T1.md'));
 
     const result = await runSingleTaskLoop(root, {
       runId: state.runId,
       branch: 'feature',
-      taskId: 'T1'
+      taskId: 'T1',
+      reviewArtifact: '.sdd/runs/feature/do/code-review-T1.md',
+      validationArtifact: '.sdd/runs/feature/test/validation-T1.md'
     });
     const restored = await readRunState(root, state.runId);
-    const gapReport = await readArtifact(root, state.runId, 'gap-report-T1.md');
-    const proposal = await readArtifact(root, state.runId, 'sync-back-proposal.md');
+    const ingestionInspection = await inspectArtifactResultIngestions(root, state.runId);
 
     assert.equal(result.status, 'blocked');
-    assert.equal(result.gaps.some((gap) => gap.field === 'implementer'), false);
-    assert.equal(result.gaps.some((gap) => gap.field === 'reviewer'), true);
+    assert.equal(restored.status, 'blocked');
+    assert.equal(restored.validation.status, 'blocked');
+    assert.deepEqual(result.acceptedArtifacts, ['.sdd/runs/feature/do/code-review-T1.md', '.sdd/runs/feature/do/gap-report-T1.md']);
+    assert.equal(restored.artifacts.some((artifact) => artifact.path === '.sdd/runs/feature/test/validation-T1.md'), false);
+    assert.equal(ingestionInspection.valid, true);
+    assert.equal(ingestionInspection.records.find((record) => record.artifactPath === '.sdd/runs/feature/test/validation-T1.md')?.status, 'rejected');
+    assert.equal(result.gaps.some((gap) => /UNSOURCED_PASS/.test(gap.message)), true);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('runSingleTaskLoop blocks missing do-stage evidence through runtime reconciliation without legacy artifacts', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-loop-do-stage-block-'));
+  try {
+    await initProject(root);
+    await writeBranchDocs(root, 'feature', validTaskMarkdown('T1', []));
+    await seedLifecycleRiskDecision(root, 'feature');
+    const state = await createRun(root, { runId: 'run-1' });
+
+    const result = await runSingleTaskLoop(root, {
+      runId: state.runId,
+      branch: 'feature',
+      taskId: 'T1'
+    });
+    const restored = await readRunState(root, state.runId);
     const rendered = renderSingleTaskLoopResult(result);
+    const events = stringifyEvents(await readRunEvents(root, state.runId));
 
+    assert.equal(result.status, 'blocked');
+    assert.deepEqual(result.requiredArtifacts, ['.sdd/runs/<branch>/do/implementation-vN.md', '.sdd/runs/<branch>/do/code-review-vN.md', '.sdd/runs/<branch>/do/do-manager-vN.md']);
+    assert.deepEqual(result.acceptedArtifacts, []);
+    assert.equal(result.gaps.some((gap) => gap.field === 'do-stage-runtime'), true);
     assert.match(rendered, /^SDD do task result/);
     assert.match(rendered, /status=blocked/);
-    assert.match(rendered, /create or validate missing run-relative artifacts/);
-    assert.match(rendered, /sdd artifact template artifacts\/review-T1.md --task T1 --agent reviewer --run run-1 --write/);
-    assert.match(rendered, /sdd artifact template artifacts\/implement-T1.md --task T1 --agent implementer --run run-1 --write/);
-    assert.match(rendered, /sdd artifact template artifacts\/validation-T1.md --task T1 --agent validator --run run-1 --write/);
-    assert.match(rendered, /--implement-artifact artifacts\/implement-T1.md/);
-    assert.match(rendered, /--validation-artifact artifacts\/validation-T1.md/);
-    assert.match(rendered, /physical artifact files belong under branch evidence \.sdd\/runs\/<branchSlug>\/evidence\/artifacts\//);
-    assert.match(rendered, /artifact_path_scope=CLI flags use run-relative artifacts\/<file>/);
+    assert.match(rendered, /write missing do-stage evidence: \.sdd\/runs\/<branch>\/do\/implementation-vN\.md, \.sdd\/runs\/<branch>\/do\/code-review-vN\.md, \.sdd\/runs\/<branch>\/do\/do-manager-vN\.md/);
+    assert.match(rendered, /artifact_path_scope=agent-authored \.sdd\/runs\/<branch>\/do\/\*\.md evidence/);
+    assert.doesNotMatch(rendered, /sdd artifact template/);
+    assert.doesNotMatch(rendered, /--review-artifact|--validation-artifact/);
     assert.equal(restored.status, 'blocked');
-    assert.match(gapReport, /reviewer artifact was not supplied/);
-    assert.match(proposal, /Proposal only/);
+    assert.deepEqual(restored.artifacts, []);
+    await assert.rejects(readArtifact(root, state.runId, 'gap-report-T1.md'));
+    await assert.rejects(readArtifact(root, state.runId, 'sync-back-proposal.md'));
+    assert.match(events, /stage_collaboration_reconciled/);
+    assert.doesNotMatch(events, /delegation_failed/);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('runSingleTaskLoop blocks missing task before do-stage evidence guidance', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-loop-router-block-do-stage-'));
+  try {
+    await initProject(root);
+    await writeBranchDocs(root, 'feature', validTaskMarkdown('T1', []));
+    await seedLifecycleRiskDecision(root, 'feature');
+    const state = await createRun(root, { runId: 'run-1' });
+
+    const result = await runSingleTaskLoop(root, {
+      runId: state.runId,
+      branch: 'feature',
+      taskId: 'MISSING-1'
+    });
+    const restored = await readRunState(root, state.runId);
+    const rendered = renderSingleTaskLoopResult(result);
     const events = stringifyEvents(await readRunEvents(root, state.runId));
-    assert.match(events, /delegation_failed/);
-    assert.doesNotMatch(events, /agent_failed/);
+
+    assert.equal(result.status, 'blocked');
+    assert.equal(result.task, null);
+    assert.deepEqual(result.requiredArtifacts, []);
+    assert.deepEqual(result.acceptedArtifacts, []);
+    assert.equal(result.gaps.some((gap) => gap.field === 'agent_router'), true);
+    assert.equal(restored.status, 'blocked');
+    assert.deepEqual(restored.artifacts, []);
+    assert.doesNotMatch(rendered, /sdd artifact template|--review-artifact|--validation-artifact|(?<!\.sdd[\\/])runs[\\/]|artifacts\/gap-report|artifacts\/sync-back-proposal/);
+    await assert.rejects(readArtifact(root, state.runId, 'gap-report-MISSING-1.md'));
+    await assert.rejects(readArtifact(root, state.runId, 'sync-back-proposal.md'));
+    assert.match(events, /agent_router_preflight/);
+    assert.match(events, /gap_detected/);
+    assert.doesNotMatch(events, /stage_collaboration_reconciled|delegation_failed/);
   } finally {
     await rm(root, { recursive: true, force: true });
   }
 });
 
-test('runSingleTaskLoop blocks PASS_WITH_GAPS validation with gap report and blocked sync-back proposal', async () => {
+test('runSingleTaskLoop blocks PASS_WITH_GAPS validation with gap report', async () => {
   const root = await mkdtemp(path.join(tmpdir(), 'sdd-loop-pass-with-gaps-'));
   try {
     await initProject(root);
     await writeBranchDocs(root, 'feature', validTaskMarkdown('T1', []));
+    await seedLifecycleRiskDecision(root, 'feature');
     const state = await createRun(root, { runId: 'run-1' });
     await bindTestRunState(root, state.runId, 'feature', 'T1');
-    await writeArtifact(root, state.runId, 'review-T1.md', validResultArtifact('reviewer', 'T1', 'PASS', 'artifacts/review-T1.md'));
-    await writeArtifact(root, state.runId, 'validation-T1.md', `${validResultArtifact('validator', 'T1', 'PASS_WITH_GAPS', 'artifacts/validation-T1.md')}${validTrustEvidence('T1', 'AC-1', 'artifacts/validation-T1.md')}`);
+    await writeArtifact(root, state.runId, 'code-review-T1.md', validResultArtifact('reviewer', 'T1', 'PASS', '.sdd/runs/feature/do/code-review-T1.md'));
+    await writeArtifact(root, state.runId, 'validation-T1.md', `${validResultArtifact('validator', 'T1', 'PASS_WITH_GAPS', '.sdd/runs/feature/test/validation-T1.md')}${validTrustEvidence('T1', 'AC-1', '.sdd/runs/feature/test/validation-T1.md')}`);
 
     const result = await runSingleTaskLoop(root, {
       runId: state.runId,
       branch: 'feature',
       taskId: 'T1',
-      reviewArtifact: 'artifacts/review-T1.md',
-      validationArtifact: 'artifacts/validation-T1.md'
+      reviewArtifact: '.sdd/runs/feature/do/code-review-T1.md',
+      validationArtifact: '.sdd/runs/feature/test/validation-T1.md'
     });
     const restored = await readRunState(root, state.runId);
     const gapReport = await readArtifact(root, state.runId, 'gap-report-T1.md');
-    const proposal = await readArtifact(root, state.runId, 'sync-back-proposal.md');
     const events = stringifyEvents(await readRunEvents(root, state.runId));
 
     assert.equal(result.status, 'blocked');
@@ -141,8 +230,6 @@ test('runSingleTaskLoop blocks PASS_WITH_GAPS validation with gap report and blo
     assert.equal(restored.validation.status, 'pass_with_gaps');
     assert.equal(result.gaps.some((gap) => gap.field === 'validation_gaps'), true);
     assert.match(gapReport, /Validator returned PASS_WITH_GAPS/);
-    assert.match(proposal, /status: blocked/);
-    assert.match(proposal, /blocked gap proposal, not task completion/);
     assert.match(events, /gap_created/);
     assert.match(events, /gap_escalated/);
     assert.doesNotMatch(events, /run_completed/);
@@ -151,45 +238,32 @@ test('runSingleTaskLoop blocks PASS_WITH_GAPS validation with gap report and blo
   }
 });
 
-test('runSingleTaskLoop persists agent and team evidence records', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-phase60-execution-records-'));
+test('runSingleTaskLoop records do-stage reconciliation without legacy agent delegation', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-phase95-do-stage-records-'));
   try {
     await initProject(root);
+    await seedLifecycleRiskDecision(root, 'master');
 
     const result = await runSingleTaskLoop(root, { taskId: 'ONBOARDING-1', branch: 'master' });
     const inspection = await inspectRun(root, result.runId);
-    const status = await getProjectStatus(root, { branch: 'master' });
-    const report = await doctor(root);
+    const events = stringifyEvents(await readRunEvents(root, result.runId));
 
     assert.equal(result.status, 'blocked');
     assert.equal(result.routeDecision.teamMode.decision, 'enabled');
     assert.equal(result.routeDecision.teamMode.activation, 'auto');
-    assert.equal(result.routeDecision.teamMode.mode, 'review-lite');
-    assert.equal(result.routeDecision.teamMode.costClass, 'low');
-    assert.equal(inspection.agentExecutions.length, 2);
-    const implementerRecord = inspection.agentExecutions.find((record) => record.status === 'skipped' && record.profile === 'implementer');
-    const reviewerRecord = inspection.agentExecutions.find((record) => record.status === 'blocked' && record.profile === 'reviewer');
-    assert.ok(implementerRecord);
-    assert.ok(reviewerRecord);
-    assert.equal(implementerRecord.toolPermission?.profile, 'implementer');
-    assert.equal(implementerRecord.routeDecision.recommendedProfile, 'implementer');
-    assert.equal(reviewerRecord.toolPermission?.profile, 'reviewer');
-    assert.equal(reviewerRecord.routeDecision.recommendedProfile, 'reviewer');
-    assert.match(reviewerRecord.routeId, /^[a-f0-9]{16}$/);
+    assert.deepEqual(result.requiredArtifacts, ['.sdd/runs/<branch>/do/implementation-vN.md', '.sdd/runs/<branch>/do/code-review-vN.md', '.sdd/runs/<branch>/do/do-manager-vN.md']);
+    assert.deepEqual(result.acceptedArtifacts, []);
+    assert.equal(inspection.agentExecutions.length, 0);
     assert.equal(inspection.teamSessions.length, 1);
-    const teamSession = inspection.teamSessions[0];
-    assert.ok(teamSession);
-    assert.equal(teamSession.status, 'blocked');
-    assert.equal(teamSession.teamMode.activation, 'auto');
-    assert.equal(teamSession.teamMode.mode, 'review-lite');
-    assert.equal(teamSession.teamMode.costClass, 'low');
-    assert.match(teamSession.teamMode.reason, /review|validation/i);
-    assert.equal(inspection.taskRunEvidence.teamSessions.length, inspection.teamSessions.length);
-    assert.equal(status.latestRunEvidence?.routePreflight, true);
-    assert.equal(status.latestRunEvidence?.agentExecutions, 2);
-    assert.equal(status.latestRunEvidence?.teamSessions, 1);
-    assert.equal(report.checks.some((check) => check.check === 'agent_team_execution_records' && /agent execution record/.test(check.message)), true);
+    assert.equal(inspection.teamSessions[0]?.status, 'created');
+    assert.match(events, /stage_collaboration_reconciled/);
+    assert.doesNotMatch(events, /delegation_failed/);
   } finally {
     await rm(root, { recursive: true, force: true });
   }
 });
+
+async function seedLifecycleRiskDecision(root: string, branch: string): Promise<void> {
+  const model = await parseSddBranch(root, branch);
+  await recordLifecycleRiskDecisionProjection(root, evaluateLifecycleRiskDecisionForModel(branch, model));
+}