sdd-agent-platform 0.4.2 → 0.5.1

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

@@ -1,269 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { execFile } from 'node:child_process';
-import { mkdtemp, readFile, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { promisify } from 'node:util';
-
-import { inspectArtifactResultIngestions } from '../artifacts/ingestion.js';
-import { initProject } from '../config/init-project.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';
-
-const execFileAsync = promisify(execFile);
-
-function stringifyEvents(events: Awaited<ReturnType<typeof readRunEvents>>): string {
-  return events.map((event) => `${event.event}\n${event.summary ?? ''}`).join('\n');
-}
-
-test('runSingleTaskLoop completes from supplied review and validation artifacts without modifying tasks markdown', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-loop-pass-'));
-  try {
-    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, '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: '.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);
-    await rebuildLocalRunIndex(root);
-    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, ['.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(ingestionInspection.valid, true);
-    assert.deepEqual(ingestionInspection.records.map((record) => record.delegationId), ['B-T1-reviewer-001', 'B-T1-validator-001']);
-    assert.equal(doctorReport.status, 'FAIL');
-    assert.match(events, /task_selected/);
-    assert.match(events, /review_passed/);
-    assert.match(events, /validation_passed/);
-    assert.match(events, /delegation_started/);
-    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 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',
-      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);
-
-    assert.equal(result.status, 'blocked');
-    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, /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.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.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', 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, '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: '.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 events = stringifyEvents(await readRunEvents(root, state.runId));
-
-    assert.equal(result.status, 'blocked');
-    assert.equal(restored.status, 'blocked');
-    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(events, /gap_created/);
-    assert.match(events, /gap_escalated/);
-    assert.doesNotMatch(events, /run_completed/);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-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 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.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);
-    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));
-}