sdd-agent-platform 0.4.1 → 0.4.2

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

@@ -8,7 +8,6 @@ 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';
@@ -17,6 +16,8 @@ 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';
@@ -36,17 +37,18 @@ test('runSingleTaskLoop completes from supplied review and validation artifacts
     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);
@@ -56,26 +58,24 @@ test('runSingleTaskLoop completes from supplied review and validation artifacts
     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, 'artifacts/validation-T2.md', 'foreign-task'),
+      payloadId: runtimeScopedId(state.runId, '.sdd/runs/feature/test/validation-T2.md', 'foreign-task'),
       runId: state.runId,
       sourceRunId: state.runId,
       branchSlug: 'feature',
       taskId: 'T2',
-      logicalRef: 'artifacts/validation-T2.md',
-      physicalPayloadPath: 'artifacts/validation-T2-run-1-foreign-task.md',
+      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: 'artifacts/validation-T2.md' }
+      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, 'FAIL');
@@ -88,10 +88,9 @@ test('runSingleTaskLoop completes from supplied review and validation artifacts
     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 === 'artifacts/sync-back-proposal.md'), true);
+    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');
-    assert.equal(taskEvidence.syncBackDecision?.status, 'proposed');
   } finally {
     await rm(root, { recursive: true, force: true });
   }
@@ -102,17 +101,18 @@ test('runSingleTaskLoop blocks rejected validation ingestion without accepting t
   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', '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'));
 
     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);
@@ -120,21 +120,22 @@ test('runSingleTaskLoop blocks rejected validation ingestion without accepting t
     assert.equal(result.status, 'blocked');
     assert.equal(restored.status, 'blocked');
     assert.equal(restored.validation.status, 'blocked');
-    assert.deepEqual(result.acceptedArtifacts, ['artifacts/review-T1.md', 'artifacts/gap-report-T1.md']);
-    assert.equal(restored.artifacts.some((artifact) => artifact.path === 'artifacts/validation-T1.md'), false);
+    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 === 'artifacts/validation-T1.md')?.status, 'rejected');
+    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 on missing reviewer artifact and creates gap proposal', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-loop-block-'));
+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, {
@@ -143,56 +144,85 @@ test('runSingleTaskLoop blocks on missing reviewer artifact and creates gap prop
       taskId: 'T1'
     });
     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');
-
-    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);
     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(restored.artifactRoot, /\.sdd[\\/]runs[\\/]feature[\\/]evidence/);
-    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');
@@ -200,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/);
@@ -210,46 +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);
-    const rejectedRun = status.latestEligibleRunsByTask.flatMap((selection) => selection.rejected).find((candidate) => candidate.runId === result.runId);
-    assert.equal(rejectedRun?.reasons.includes('Run is blocked.'), true);
-    assert.equal(inspection.taskRunEvidence.agentExecutions.length, 2);
-    assert.equal(inspection.taskRunEvidence.teamSessions.length, 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));
+}