sdd-agent-platform 0.4.0 → 0.4.1

package/node_modules/@sdd-agent-platform/core/src/workflow-state/resolve.test.ts

@@ -3,6 +3,8 @@ import assert from 'node:assert/strict';
 import { mkdtemp, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
 
 import { initProject } from '../config/init-project.js';
 import { createRun, readRunState, writeRunState } from '../run-state/run-state.js';
@@ -11,6 +13,8 @@ import { bindTestRunState, markTestRunReadyForSyncBack } from '../test-support/r
 import { createDelegationRecord } from '../delegation/validation.js';
 import { resolveWorkflowState } from './resolve.js';
 
+const execFileAsync = promisify(execFile);
+
 test('workflow state resolver projects branch docs latest run and next action', async () => {
   const root = await mkdtemp(path.join(tmpdir(), 'sdd-workflow-state-'));
   try {
@@ -27,7 +31,39 @@ test('workflow state resolver projects branch docs latest run and next action',
     assert.equal(workflow.latestRun?.runId, 'run-1');
     assert.deepEqual(workflow.latestRunsByTask.map((entry) => `${entry.partition}:${entry.taskId}:${entry.runId}`), ['feature:T1:run-1']);
     assert.equal(workflow.taskCounts.total, 1);
-    assert.equal(workflow.recommendedNextCommand, 'sdd sync-back inspect --branch feature --task T1');
+    assert.equal(workflow.recommendedNextCommand, 'sdd ship --branch feature --dry-run');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('workflow state routes validation PASS to ship without requiring sync-back proposal', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-workflow-state-test-pass-'));
+  try {
+    await initProject(root);
+    await writeBranchDocs(root, 'feature', validTaskMarkdown('T1', []));
+    const run = await createRun(root, { runId: 'run-pass-no-syncback' });
+    await bindTestRunState(root, run.runId, 'feature', 'T1');
+    const bound = await readRunState(root, run.runId);
+    await writeRunState(root, {
+      ...bound,
+      status: 'completed',
+      validation: {
+        status: 'pass',
+        commands: ['npm test'],
+        evidence: ['artifacts/validation-T1.md']
+      },
+      syncBack: {
+        ...bound.syncBack,
+        status: 'not_created'
+      }
+    });
+
+    const workflow = await resolveWorkflowState(root, { branch: 'feature', taskId: 'T1' });
+
+    assert.equal(workflow.nextIntent.stage, 'ship');
+    assert.equal(workflow.nextIntent.intent, 'ship_readiness');
+    assert.equal(workflow.recommendedNextCommand, 'sdd ship --branch feature --dry-run');
   } finally {
     await rm(root, { recursive: true, force: true });
   }
@@ -108,7 +144,320 @@ test('workflow state resolver surfaces dependency blockers and points next actio
 
     assert.deepEqual(workflow.dependencyBlockers.map((blocker) => `${blocker.taskId}->${blocker.dependencyId}`), ['DEP2->DEP1']);
     assert.equal(workflow.blockingReasons.some((reason) => reason.includes('DEP2 depends on DEP1')), true);
-    assert.equal(workflow.recommendedNextCommand, 'sdd tasks inspect DEP1 --branch feature');
+    assert.equal(workflow.recommendedNextCommand, 'sdd do task DEP1 --branch feature');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('workflow state treats implemented batch dependency as ready for downstream do', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-workflow-state-runtime-dependency-ready-'));
+  try {
+    await initProject(root);
+    await writeBranchDocs(root, 'feature', `# Tasks
+
+${validTaskMarkdown('DEP1', [])
+  .replace('packages/core/src/index.ts', 'docs/dep1.md')
+  .replace('validation:\n  - npm test', 'validation_batch: dep-batch\nvalidation_timing: batch_end\nrequires_verify_before_next: false\nvalidation:\n  - npm test')}
+${validTaskMarkdown('DEP2', ['DEP1'])
+  .replace('packages/core/src/index.ts', 'docs/dep2.md')
+  .replace('validation:\n  - npm test', 'validation_batch: dep-batch\nvalidation_timing: batch_end\nrequires_verify_before_next: false\nvalidation:\n  - npm test')}`);
+    const run = await createRun(root, { runId: 'run-dep1-implemented' });
+    await bindTestRunState(root, run.runId, 'feature', 'DEP1');
+    const bound = await readRunState(root, run.runId);
+    await writeRunState(root, {
+      ...bound,
+      status: 'completed',
+      tasks: {
+        ...bound.tasks,
+        DEP1: {
+          status: 'implemented_pending_validation',
+          implementationStatus: 'implemented',
+          verificationStatus: 'pending_batch',
+          validationBatch: 'dep-batch',
+          validationTiming: 'batch_end',
+          requiresVerifyBeforeNext: false,
+          gaps: [],
+          artifacts: []
+        }
+      }
+    });
+
+    const workflow = await resolveWorkflowState(root, { branch: 'feature', taskId: 'DEP2' });
+
+    assert.deepEqual(workflow.dependencyBlockers, []);
+    assert.equal(workflow.recommendedNextCommand, 'sdd do task DEP2 --branch feature');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('workflow state blocks downstream do until strict dependency verification passes', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-workflow-state-runtime-dependency-strict-'));
+  try {
+    await initProject(root);
+    await writeBranchDocs(root, 'feature', `# Tasks
+
+${validTaskMarkdown('DEP1', [])
+  .replace('packages/core/src/index.ts', 'docs/dep1.md')
+  .replace('validation:\n  - npm test', 'validation_timing: task_end\nrequires_verify_before_next: true\nvalidation:\n  - npm test')}
+${validTaskMarkdown('DEP2', ['DEP1']).replace('packages/core/src/index.ts', 'docs/dep2.md')}`);
+    const run = await createRun(root, { runId: 'run-dep1-strict-implemented' });
+    await bindTestRunState(root, run.runId, 'feature', 'DEP1');
+    const bound = await readRunState(root, run.runId);
+    await writeRunState(root, {
+      ...bound,
+      status: 'completed',
+      tasks: {
+        ...bound.tasks,
+        DEP1: {
+          status: 'implemented_pending_validation',
+          implementationStatus: 'implemented',
+          verificationStatus: 'not_run',
+          validationBatch: null,
+          validationTiming: 'task_end',
+          requiresVerifyBeforeNext: true,
+          gaps: [],
+          artifacts: []
+        }
+      }
+    });
+
+    const workflow = await resolveWorkflowState(root, { branch: 'feature', taskId: 'DEP2' });
+
+    assert.deepEqual(workflow.dependencyBlockers.map((blocker) => `${blocker.taskId}->${blocker.dependencyId}`), ['DEP2->DEP1']);
+    assert.equal(workflow.blockingReasons.some((reason) => reason.includes('has not passed required verification')), true);
+    assert.equal(workflow.recommendedNextCommand, 'sdd test task DEP1 --branch feature');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+
+test('latest eligible selector prefers older compatible evidence over newer strict-stale evidence', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-workflow-state-eligible-'));
+  try {
+    await initProject(root);
+    await writeBranchDocs(root, 'feature', validTaskMarkdown('T1', []));
+    const compatible = await createRun(root, { runId: 'run-compatible' });
+    await bindTestRunState(root, compatible.runId, 'feature', 'T1');
+    await markTestRunReadyForSyncBack(root, compatible.runId, 'T1');
+
+    const strictStale = await createRun(root, { runId: 'run-strict-stale' });
+    await bindTestRunState(root, strictStale.runId, 'feature', 'T1');
+    await markTestRunReadyForSyncBack(root, strictStale.runId, 'T1');
+    const strictStaleState = await readRunState(root, strictStale.runId);
+    await writeRunState(root, {
+      ...strictStaleState,
+      documentSnapshot: {
+        ...strictStaleState.documentSnapshot,
+        tasksContractHash: 'stale-tasks-contract-hash'
+      }
+    });
+
+    const workflow = await resolveWorkflowState(root, { branch: 'feature', taskId: 'T1' });
+    const selection = workflow.latestEligibleRunsByTask.find((entry) => entry.taskId === 'T1');
+
+    assert.equal(workflow.latestRun?.runId, 'run-compatible');
+    assert.equal(selection?.selected?.runId, 'run-compatible');
+    assert.deepEqual(selection?.rejected.map((entry) => `${entry.runId}:${entry.compatibility}`), ['run-strict-stale:strict_stale']);
+    assert.equal(selection?.rejected[0]?.reasons.some((reason) => reason.includes('strict_stale')), true);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('latest eligible selector rejects newer blocked runs and keeps older completed evidence eligible', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-workflow-state-blocked-eligible-'));
+  try {
+    await initProject(root);
+    await writeBranchDocs(root, 'feature', validTaskMarkdown('T1', []));
+    const completed = await createRun(root, { runId: 'run-completed' });
+    await bindTestRunState(root, completed.runId, 'feature', 'T1');
+    await markTestRunReadyForSyncBack(root, completed.runId, 'T1');
+
+    const blocked = await createRun(root, { runId: 'run-blocked' });
+    await bindTestRunState(root, blocked.runId, 'feature', 'T1');
+    await markTestRunReadyForSyncBack(root, blocked.runId, 'T1');
+    await writeRunState(root, { ...await readRunState(root, blocked.runId), status: 'blocked' });
+
+    const workflow = await resolveWorkflowState(root, { branch: 'feature', taskId: 'T1' });
+    const selection = workflow.latestEligibleRunsByTask.find((entry) => entry.taskId === 'T1');
+
+    assert.equal(selection?.selected?.runId, 'run-completed');
+    assert.equal(selection?.rejected.some((entry) => entry.runId === 'run-blocked' && entry.reasons.includes('Run is blocked.')), true);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('latest eligible selector returns visible candidates and rejects archived or failed runs with reasons', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-workflow-state-rejected-'));
+  try {
+    await initProject(root);
+    await writeBranchDocs(root, 'feature', validTaskMarkdown('T1', []));
+    const failed = await createRun(root, { runId: 'run-failed' });
+    await bindTestRunState(root, failed.runId, 'feature', 'T1');
+    await writeRunState(root, {
+      ...await readRunState(root, failed.runId),
+      status: 'failed',
+      validation: { status: 'fail', commands: ['npm test'], evidence: [] }
+    });
+    const archived = await createRun(root, { runId: 'run-archived' });
+    await bindTestRunState(root, archived.runId, 'feature', 'T1');
+    await writeRunState(root, { ...await readRunState(root, archived.runId), status: 'archived' });
+
+    const workflow = await resolveWorkflowState(root, { branch: 'feature', taskId: 'T1' });
+    const selection = workflow.latestEligibleRunsByTask.find((entry) => entry.taskId === 'T1');
+
+    assert.equal(workflow.latestRun, null);
+    assert.deepEqual(selection?.candidates.map((entry) => entry.runId), ['run-failed']);
+    assert.deepEqual(selection?.rejected.map((entry) => entry.runId).sort(), ['run-archived', 'run-failed']);
+    assert.equal(selection?.rejected.some((entry) => entry.reasons.includes('Run failed.')), true);
+    assert.equal(selection?.rejected.some((entry) => entry.reasons.includes('Run is archived.')), true);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('workflow state uses explicit partition runtime despite divergent git branch', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-workflow-state-divergent-'));
+  try {
+    await initProject(root);
+    await execFileAsync('git', ['init'], { cwd: root });
+    await execFileAsync('git', ['checkout', '-b', 'current-branch'], { cwd: root });
+    await writeBranchDocs(root, 'feature', validTaskMarkdown('T1', [])
+      .replace('packages/core/src/index.ts', 'docs/t1.md')
+      .replace('validation:\n  - npm test', 'validation_timing: task_end\nrequires_verify_before_next: true\nvalidation:\n  - npm test'));
+    const divergent = await createRun(root, { runId: 'run-divergent' });
+    await bindTestRunState(root, divergent.runId, 'feature', 'T1');
+    const bound = await readRunState(root, divergent.runId);
+    await writeRunState(root, {
+      ...bound,
+      status: 'completed',
+      tasks: {
+        ...bound.tasks,
+        T1: {
+          status: 'implemented_pending_validation',
+          implementationStatus: 'implemented',
+          verificationStatus: 'not_run',
+          validationBatch: null,
+          validationTiming: 'task_end',
+          requiresVerifyBeforeNext: true,
+          gaps: [],
+          artifacts: []
+        }
+      }
+    });
+
+    const workflow = await resolveWorkflowState(root, { branch: 'feature', taskId: 'T1' });
+    const selection = workflow.latestEligibleRunsByTask.find((entry) => entry.taskId === 'T1');
+
+    assert.equal(workflow.latestRun?.runId, 'run-divergent');
+    assert.equal(selection?.selected?.runId, 'run-divergent');
+    assert.deepEqual(selection?.rejected.map((entry) => entry.runId), []);
+    assert.equal(workflow.nextIntent.intent, 'run_task_validation');
+    assert.equal(workflow.recommendedNextCommand, 'sdd test task T1 --branch feature');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('workflow state recommends wave validation for implemented wave_end boundary', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-workflow-state-wave-boundary-'));
+  try {
+    await initProject(root);
+    await writeBranchDocs(root, 'feature', `# Tasks
+
+${validTaskMarkdown('W1', [])
+  .replace('packages/core/src/index.ts', 'docs/w1.md')
+  .replace('validation:\n  - npm test', 'validation_batch: docs-wave\nvalidation_timing: wave_end\nrequires_verify_before_next: false\nvalidation:\n  - npm test')}`);
+    const run = await createRun(root, { runId: 'run-w1-implemented' });
+    await bindTestRunState(root, run.runId, 'feature', 'W1');
+    const bound = await readRunState(root, run.runId);
+    await writeRunState(root, {
+      ...bound,
+      status: 'completed',
+      tasks: {
+        ...bound.tasks,
+        W1: {
+          status: 'implemented_pending_validation',
+          implementationStatus: 'implemented',
+          verificationStatus: 'pending_batch',
+          validationBatch: 'docs-wave',
+          validationTiming: 'wave_end',
+          requiresVerifyBeforeNext: false,
+          gaps: [],
+          artifacts: []
+        }
+      }
+    });
+
+    const workflow = await resolveWorkflowState(root, { branch: 'feature', taskId: 'W1' });
+
+    assert.equal(workflow.nextIntent.intent, 'run_wave_validation');
+    assert.equal(workflow.recommendedNextCommand, 'sdd test wave --branch feature --wave 1');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('workflow state dependency readiness ignores newer ineligible runtime state', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-workflow-state-eligible-runtime-'));
+  try {
+    await initProject(root);
+    await writeBranchDocs(root, 'feature', `# Tasks
+
+${validTaskMarkdown('DEP1', [])
+  .replace('packages/core/src/index.ts', 'docs/dep1.md')
+  .replace('validation:\n  - npm test', 'validation_batch: dep-batch\nvalidation_timing: batch_end\nrequires_verify_before_next: false\nvalidation:\n  - npm test')}
+${validTaskMarkdown('DEP2', ['DEP1']).replace('packages/core/src/index.ts', 'docs/dep2.md')}`);
+    const eligible = await createRun(root, { runId: 'run-dep1-eligible' });
+    await bindTestRunState(root, eligible.runId, 'feature', 'DEP1');
+    const eligibleState = await readRunState(root, eligible.runId);
+    await writeRunState(root, {
+      ...eligibleState,
+      status: 'completed',
+      tasks: {
+        ...eligibleState.tasks,
+        DEP1: {
+          status: 'implemented_pending_validation',
+          implementationStatus: 'implemented',
+          verificationStatus: 'pending_batch',
+          validationBatch: 'dep-batch',
+          validationTiming: 'batch_end',
+          requiresVerifyBeforeNext: false,
+          gaps: [],
+          artifacts: []
+        }
+      }
+    });
+    const blocked = await createRun(root, { runId: 'run-dep1-blocked-newer' });
+    await bindTestRunState(root, blocked.runId, 'feature', 'DEP1');
+    const blockedState = await readRunState(root, blocked.runId);
+    await writeRunState(root, {
+      ...blockedState,
+      status: 'blocked',
+      updatedAt: new Date(Date.parse(eligibleState.updatedAt) + 1000).toISOString(),
+      tasks: {
+        ...blockedState.tasks,
+        DEP1: {
+          status: 'pending',
+          implementationStatus: 'not_started',
+          verificationStatus: 'not_run',
+          validationBatch: 'dep-batch',
+          validationTiming: 'batch_end',
+          requiresVerifyBeforeNext: false,
+          gaps: [],
+          artifacts: []
+        }
+      }
+    });
+
+    const workflow = await resolveWorkflowState(root, { branch: 'feature', taskId: 'DEP2' });
+
+    assert.deepEqual(workflow.dependencyBlockers, []);
+    assert.equal(workflow.recommendedNextCommand, 'sdd test batch dep-batch --branch feature');
   } finally {
     await rm(root, { recursive: true, force: true });
   }