sdd-agent-platform 0.4.1 → 0.5.0

package/node_modules/@sdd-agent-platform/core/src/verification/validation-wave.test.ts

@@ -1,341 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-
-import { evaluateAndRecordWorkflowGateDecision } from '../workflow-gate/evidence-packet.js';
-import { initProject } from '../config/init-project.js';
-import { writeBranchDocs } from '../test-support/fixtures.js';
-import { listRuntimeAcceptanceEvidenceMaps, listRuntimeValidationEnvironmentSessions, listRuntimeValidationWaveRuns, listRuntimeWorkflowGateDecisions, recordRuntimeDurableGap } from '../storage/runtime-store.js';
-import { readRunState, writeRunState } from '../run-state/run-state.js';
-import { readTaskEvidenceView } from '../run-state/task-evidence.js';
-import { writeVerifyContract } from './verify-contract.js';
-import { planValidationWave, renderValidationWaveResult, runValidationWave } from './validation-wave.js';
-
-function taskMarkdown(taskId: string, command: string, wave: number): string {
-  return `### ${taskId}: Validation wave task
-
-\`\`\`sdd-task
-id: ${taskId}
-status: pending
-wave: ${wave}
-depends_on: []
-acceptance_refs:
-  - AC-${taskId}
-plan_refs:
-  - "§4 Target Design Overview"
-affected_files:
-  - docs/${taskId.toLowerCase()}.md
-validation:
-  - ${command} => AC-${taskId}
-risk: []
-\`\`\`
-
-#### Boundary
-
-Stay in validation fixtures.
-
-#### Acceptance
-
-- AC-${taskId}: Validation evidence is mapped.
-`;
-}
-
-function batchTaskMarkdown(taskId: string, command: string, batchId: string): string {
-  return `### ${taskId}: Batch validation task
-
-\`\`\`sdd-task
-id: ${taskId}
-status: pending
-wave: 1
-depends_on: []
-acceptance_refs:
-  - AC-${taskId}
-plan_refs:
-  - "§4 Target Design Overview"
-affected_files:
-  - docs/${taskId.toLowerCase()}.md
-change_surface: docs_only
-implementation_wave: docs-wave-1
-validation_batch: ${batchId}
-validation_timing: batch_end
-requires_verify_before_next: false
-validation:
-  - ${command} => AC-${taskId}
-risk: []
-\`\`\`
-
-#### Boundary
-
-Stay in validation fixtures.
-
-#### Acceptance
-
-- AC-${taskId}: Batch validation evidence is mapped.
-`;
-}
-
-test('validation wave plans multiple tasks from tasks and verify contracts', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-validation-wave-plan-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'feature', `# Tasks
-
-${taskMarkdown('T1', 'node -e "process.stdout.write(\'one\')"', 1)}
-${taskMarkdown('T2', 'node -e "process.stdout.write(\'two\')"', 1)}`);
-    await writeVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-
-    const plan = await planValidationWave(root, { branch: 'feature', wave: 1 });
-
-    assert.equal(plan.status, 'READY');
-    assert.deepEqual(plan.taskIds, ['T1', 'T2']);
-    assert.deepEqual(plan.tasks.map((task) => task.acceptanceRefs[0]), ['AC-T1', 'AC-T2']);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('validation wave blocks explicitly requested tasks missing from verify batches', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-validation-wave-explicit-missing-verify-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'feature', `# Tasks
-
-${batchTaskMarkdown('T1', 'node -e "process.stdout.write(\'one\')"', 'docs-batch-a')}
-${batchTaskMarkdown('T2', 'node -e "process.stdout.write(\'two\')"', 'docs-batch-b')}`);
-    await writeVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-    const verifyPath = path.join(root, 'specs', 'feature', 'verify.md');
-    await writeFile(verifyPath, (await readFile(verifyPath, 'utf8')).replace('      - "T2"', '      - "T-missing"'), 'utf8');
-
-    const plan = await planValidationWave(root, { branch: 'feature', taskIds: ['T1', 'T2'] });
-
-    assert.equal(plan.status, 'BLOCKED');
-    assert.deepEqual(plan.taskIds, ['T1']);
-    assert.match(plan.blockers.join('\n'), /Task T2 was requested but is not covered by verify\.md verification batches/);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('validation batch plan consumes verify batch declarations', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-validation-batch-plan-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'feature', `# Tasks
-
-${batchTaskMarkdown('T1', 'node -e "process.stdout.write(\'one\')"', 'docs-batch-a')}
-${batchTaskMarkdown('T2', 'node -e "process.stdout.write(\'two\')"', 'docs-batch-a')}
-${batchTaskMarkdown('T3', 'node -e "process.stdout.write(\'three\')"', 'docs-batch-b')}`);
-    await writeVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-
-    const plan = await planValidationWave(root, { branch: 'feature', batchId: 'docs-batch-a' });
-
-    assert.equal(plan.status, 'READY');
-    assert.equal(plan.batchId, 'docs-batch-a');
-    assert.deepEqual(plan.taskIds, ['T1', 'T2']);
-    assert.deepEqual(plan.verifyBatches.map((batch) => batch.id), ['docs-batch-a']);
-    assert.equal(plan.verifyBatches[0]?.timing, 'batch_end');
-    assert.deepEqual(plan.verifyBatches[0]?.checks, ['node -e "process.stdout.write(\'one\')"', 'node -e "process.stdout.write(\'two\')"']);
-    assert.deepEqual(plan.verifyBatches[0]?.acceptanceMapping, { T1: ['AC-T1'], T2: ['AC-T2'] });
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('validation batch plan blocks backend validation forbidden by verify batch', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-validation-batch-forbidden-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'feature', `# Tasks
-
-${batchTaskMarkdown('T1', 'mvn test', 'frontend-batch').replace('change_surface: docs_only', 'change_surface: frontend_only')}`);
-    await writeVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-
-    const plan = await planValidationWave(root, { branch: 'feature', batchId: 'frontend-batch' });
-
-    assert.equal(plan.status, 'BLOCKED');
-    assert.equal(plan.verifyBatches[0]?.forbiddenValidation.includes('maven_compile'), true);
-    assert.equal(plan.blockers.some((blocker) => blocker.includes('backend build validation forbidden')), true);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('validation wave records shared environment session and acceptance maps', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-validation-wave-run-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'feature', `# Tasks
-
-${taskMarkdown('T1', 'node -e "process.stdout.write(\'one\')"', 1)}
-${taskMarkdown('T2', 'node -e "process.stdout.write(\'two\')"', 1)}`);
-    await writeVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-
-    const result = await runValidationWave(root, { branch: 'feature', wave: 1, approved: true });
-    const waves = await listRuntimeValidationWaveRuns(root, { partition: 'feature', waveRunId: result.waveRunId });
-    const sessions = await listRuntimeValidationEnvironmentSessions(root, { partition: 'feature', waveRunId: result.waveRunId });
-    const maps = await listRuntimeAcceptanceEvidenceMaps(root, { partition: 'feature', waveRunId: result.waveRunId });
-    const evidence = await readTaskEvidenceView(root, { branch: 'feature', taskId: 'T1' });
-
-    assert.equal(result.status, 'PASS');
-    assert.equal(result.taskResults.length, 2);
-    assert.equal(waves[0].environmentSessionId, result.environmentSessionId);
-    assert.equal(sessions[0].sessionId, result.environmentSessionId);
-    assert.equal(new Set(maps.map((map) => map.taskId)).size, 2);
-    assert.equal(maps.every((map) => map.status === 'complete'), true);
-    assert.match(renderValidationWaveResult(result), /acceptance_maps=2/);
-    assert.equal(evidence.validation.validationWaves.length, 1);
-    assert.equal(evidence.validation.environmentSessions.length, 1);
-    assert.equal(evidence.validation.acceptanceEvidenceMaps.some((map) => map.acceptanceRef === 'AC-T1'), true);
-    const workflowGateScope = (result.workflowGateDecision?.payload as { workflowScope?: { waveRunId: string | null; taskIds: string[]; runIds: string[]; evidenceRefs: string[] } } | undefined)?.workflowScope;
-    const wavePayloadScope = (waves[0].payload as { workflowScope?: unknown }).workflowScope as typeof workflowGateScope;
-    const gateDecisions = await listRuntimeWorkflowGateDecisions(root, { partition: 'feature', decisionKind: 'validation_wave' });
-    const expectedEvidenceRefs = result.taskResults.flatMap((taskResult) => [taskResult.validationArtifact, taskResult.indexArtifact].filter((ref): ref is string => Boolean(ref))).sort();
-
-    assert.equal(workflowGateScope?.waveRunId, result.waveRunId);
-    assert.deepEqual(workflowGateScope?.taskIds, ['T1', 'T2']);
-    assert.deepEqual(workflowGateScope?.runIds, result.taskResults.map((taskResult) => taskResult.runId).sort());
-    assert.deepEqual(workflowGateScope?.evidenceRefs, expectedEvidenceRefs);
-    assert.deepEqual(wavePayloadScope, workflowGateScope);
-    assert.equal(gateDecisions.some((decision) => decision.decisionId === result.workflowGateDecision?.decisionId), true);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('validation wave gate evaluates durable gaps across the whole wave', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-validation-wave-durable-gap-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'feature', `# Tasks
-
-${taskMarkdown('T1', 'node -e "process.stdout.write(\'one\')"', 1)}
-${taskMarkdown('T2', 'node -e "process.stdout.write(\'two\')"', 1)}`);
-    await writeVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-
-    const result = await runValidationWave(root, { branch: 'feature', wave: 1, approved: true });
-    const secondTask = result.taskResults.find((taskResult) => taskResult.taskId === 'T2');
-    assert.ok(result.workflowGateDecision);
-    assert.ok(secondTask);
-    await recordRuntimeDurableGap(root, {
-      gapId: 'gap-T2-blocking',
-      partition: 'feature',
-      taskId: 'T2',
-      runId: secondTask.runId,
-      stage: 'test',
-      gate: 'validation_wave',
-      source: 'runtime',
-      category: 'validation',
-      severity: 'blocking',
-      status: 'open',
-      message: 'Second task blocking gap should block the wave gate.',
-      recommendation: 'Resolve T2 before passing the wave.',
-      evidenceRefs: [],
-      proposalRefs: [],
-      sourceRefs: [],
-      payload: {}
-    });
-    await writeRunState(root, { ...await readRunState(root, secondTask.runId), status: 'blocked' });
-
-    const expectedEvidenceRefs = result.taskResults.flatMap((taskResult) => [taskResult.validationArtifact, taskResult.indexArtifact].filter((ref): ref is string => Boolean(ref)));
-    const { decision } = await evaluateAndRecordWorkflowGateDecision(root, {
-      branch: 'feature',
-      taskId: result.taskResults[0]?.taskId ?? null,
-      runId: result.taskResults[0]?.runId ?? null,
-      decisionKind: 'validation_wave',
-      waveRunId: result.waveRunId,
-      taskIds: result.plan.taskIds,
-      runIds: result.taskResults.map((taskResult) => taskResult.runId),
-      evidenceRefs: expectedEvidenceRefs
-    });
-
-    assert.equal(decision.status, 'BLOCKED');
-    assert.match(JSON.stringify(decision.hardBlocks), /durable_gap_blocking/);
-    assert.match(JSON.stringify(decision.hardBlocks), /gap-T2-blocking/);
-    assert.match(JSON.stringify(decision.hardBlocks), /run_rejected/);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-
-test('validation wave blocks parser task gaps before command execution', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-validation-wave-task-gaps-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'feature', `# Tasks
-
-${batchTaskMarkdown('T1', './mvnw test', 'frontend-batch').replace('affected_files:\n  - docs/t1.md', 'affected_files:\n  - app/src/main/webapp/index.jsp')}`);
-    await writeVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-
-    const result = await runValidationWave(root, { branch: 'feature', batchId: 'frontend-batch' });
-
-    assert.equal(result.status, 'BLOCKED');
-    assert.equal(result.taskResults.length, 0);
-    assert.match(result.gaps.join('\n'), /frontend-only but declares backend build validation/);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('validation wave rerun preserves explicit wave boundary when selected tasks share a batch', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-validation-wave-rerun-wave-boundary-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'feature', `# Tasks
-
-${batchTaskMarkdown('T1', 'node -e "process.stdout.write(\'one\')"', 'docs-batch-a')
-  .replace('validation_timing: batch_end', 'validation_timing: wave_end')
-  .replace('requires_verify_before_next: false', 'requires_verify_before_next: true')}`);
-    await writeVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-
-    const result = await runValidationWave(root, { branch: 'feature', wave: 1 });
-
-    assert.equal(result.status, 'BLOCKED');
-    assert.equal(result.plan.selectionBoundary, 'wave');
-    assert.equal(result.plan.batchId, 'docs-batch-a');
-    assert.match(result.next, /sdd test wave --branch feature --wave 1/);
-    assert.doesNotMatch(result.next, /sdd test batch docs-batch-a/);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('validation wave uses verify acceptance mapping for runtime coverage', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-validation-wave-acceptance-mapping-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'feature', `# Tasks
-
-${batchTaskMarkdown('T1', 'node -e "process.stdout.write(\'one\')"', 'docs-batch-a').replace('  - node -e "process.stdout.write(\'one\')" => AC-T1', '  - node -e "process.stdout.write(\'one\')"')}`);
-    await writeVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-
-    const result = await runValidationWave(root, { branch: 'feature', batchId: 'docs-batch-a', approved: true });
-
-    assert.equal(result.status, 'PASS');
-    assert.equal(result.acceptanceEvidence.some((map) => map.taskId === 'T1' && map.acceptanceRef === 'AC-T1' && map.status === 'complete'), true);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-
-test('validation wave blocks missing verify without generating runtime evidence', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-validation-wave-blocked-'));
-  try {
-    await initProject(root);
-    await writeBranchDocs(root, 'feature', `# Tasks
-
-${taskMarkdown('T1', 'node -e "process.stdout.write(\'one\')"', 1)}`);
-
-    const result = await runValidationWave(root, { branch: 'feature', wave: 1 });
-
-    assert.equal(result.status, 'BLOCKED');
-    assert.equal(result.taskResults.length, 0);
-    assert.match(result.gaps.join('\n'), /verify\.md contract is BLOCKED/);
-    assert.match(result.next, /sdd test wave --branch feature --wave 1/);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});

package/node_modules/@sdd-agent-platform/core/src/verification/verify-contract.test.ts

@@ -1,204 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-
-import { validTaskMarkdown, writeBranchDocs } from '../test-support/fixtures.js';
-import { inspectVerifyContract, writeVerifyContract } from './verify-contract.js';
-
-
-test('inspectVerifyContract blocks when verify document is missing', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-verify-contract-missing-'));
-  try {
-    await writeBranchDocs(root, 'feature', validTaskMarkdown('T1', []));
-
-    const inspection = await inspectVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-
-    assert.equal(inspection.status, 'BLOCKED');
-    assert.equal(inspection.exists, false);
-    assert.equal(inspection.taskCount, 1);
-    assert.equal(inspection.issues.some((issue) => issue.field === 'verify.md' && issue.level === 'FAIL'), true);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('writeVerifyContract creates task-derived verify contract', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-verify-contract-write-'));
-  try {
-    await writeBranchDocs(root, 'feature', validTaskMarkdown('T1', []));
-
-    const written = await writeVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-    const inspection = await inspectVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-
-    assert.equal(written.status, 'created');
-    assert.match(written.content, /contract: sdd-verify-doc-v1/);
-    assert.match(written.content, /verification_batches:/);
-    assert.match(written.content, /id: \"task-T1\"/);
-    assert.match(written.content, /failure_policy:\n      repair_flow: deferred/);
-    assert.match(written.content, /\| T1 \|/);
-    assert.match(written.content, /author_role: verification-designer/);
-    assert.match(written.content, /independent_from_roles:\n  - task-planner\n  - implementer/);
-    assert.equal(inspection.status, 'PASS');
-    assert.equal(inspection.exists, true);
-    assert.equal(inspection.issues.length, 0);
-    assert.equal(inspection.authorRole, 'verification-designer');
-    assert.deepEqual(inspection.independentFromRoles, ['task-planner', 'implementer']);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('writeVerifyContract groups tasks by validation_batch', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-verify-contract-batch-'));
-  try {
-    await writeBranchDocs(root, 'feature', `# Tasks
-
-### T1: UI copy
-
-\`\`\`sdd-task
-id: T1
-status: pending
-wave: 1
-depends_on: []
-acceptance_refs:
-  - AC-T1-copy
-affected_files:
-  - app/src/main/webapp/index.jsp
-change_surface: frontend_only
-implementation_wave: ui-wave-1
-validation_batch: ui-render-wave-1
-validation_timing: batch_end
-requires_verify_before_next: false
-validation:
-  - browser/manual check copy => AC-T1-copy
-required_artifacts:
-  - artifacts/ui-render-wave-1.md
-risk: []
-\`\`\`
-
-#### Boundary
-
-Only UI copy.
-
-#### Acceptance
-
-- Copy renders.
-
-### T2: UI image
-
-\`\`\`sdd-task
-id: T2
-status: pending
-wave: 1
-depends_on: []
-acceptance_refs:
-  - AC-T2-image
-affected_files:
-  - app/src/main/webapp/assets/banner.svg
-change_surface: frontend_only
-implementation_wave: ui-wave-1
-validation_batch: ui-render-wave-1
-validation_timing: batch_end
-requires_verify_before_next: false
-validation:
-  - browser/manual check image => AC-T2-image
-required_artifacts:
-  - artifacts/ui-render-wave-1.md
-risk: []
-\`\`\`
-
-#### Boundary
-
-Only UI image.
-
-#### Acceptance
-
-- Image renders.
-`);
-
-    const written = await writeVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-
-    assert.match(written.content, /id: \"ui-render-wave-1\"/);
-    assert.match(written.content, /timing: batch_end/);
-    assert.match(written.content, /change_surface: frontend_only/);
-    assert.match(written.content, /forbidden_validation:\n      - \"maven_compile\"\n      - \"gradle_build\"/);
-    assert.match(written.content, /T1:\n        - \"AC-T1-copy\"/);
-    assert.match(written.content, /T2:\n        - \"AC-T2-image\"/);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('inspectVerifyContract warns when verify document is stale', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-verify-contract-stale-'));
-  try {
-    await writeBranchDocs(root, 'feature', validTaskMarkdown('T1', []));
-    await writeVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-    await writeFile(path.join(root, 'specs', 'feature', 'tasks.md'), validTaskMarkdown('T2', []), 'utf8');
-
-    const inspection = await inspectVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-
-    assert.equal(inspection.status, 'WARN');
-    assert.equal(inspection.issues.some((issue) => issue.field === 'based_on_tasks_contract_hash'), true);
-    assert.equal(inspection.issues.some((issue) => issue.field === 'tasks' && /T2/.test(issue.message)), true);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('inspectVerifyContract blocks legacy verify documents without tasks contract hash', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-verify-contract-legacy-'));
-  try {
-    await writeBranchDocs(root, 'feature', validTaskMarkdown('T1', []));
-    const written = await writeVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-    await writeFile(path.join(root, 'specs', 'feature', 'verify.md'), written.content.replace(/^based_on_tasks_contract_hash: .+\n/m, ''), 'utf8');
-
-    const inspection = await inspectVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-
-    assert.equal(inspection.status, 'BLOCKED');
-    assert.equal(inspection.issues.some((issue) => issue.field === 'based_on_tasks_contract_hash' && issue.level === 'FAIL'), true);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('writeVerifyContract upgrades legacy verify documents without force', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-verify-contract-upgrade-'));
-  try {
-    await writeBranchDocs(root, 'feature', validTaskMarkdown('T1', []));
-    const written = await writeVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-    await writeFile(path.join(root, 'specs', 'feature', 'verify.md'), written.content.replace(/^based_on_tasks_contract_hash: .+\n/m, ''), 'utf8');
-
-    const upgraded = await writeVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-    const inspection = await inspectVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-
-    assert.equal(upgraded.status, 'updated');
-    assert.match(upgraded.content, /based_on_tasks_contract_hash: /);
-    assert.equal(inspection.status, 'PASS');
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('writeVerifyContract preserves stale bound verify documents without force', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-verify-contract-preserve-stale-'));
-  try {
-    await writeBranchDocs(root, 'feature', validTaskMarkdown('T1', []));
-    const written = await writeVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-    const verifyPath = path.join(root, 'specs', 'feature', 'verify.md');
-    const initial = await readFile(verifyPath, 'utf8');
-    await writeFile(path.join(root, 'specs', 'feature', 'tasks.md'), validTaskMarkdown('T2', []), 'utf8');
-
-    const preserved = await writeVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-    const inspection = await inspectVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
-
-    assert.equal(written.status, 'created');
-    assert.equal(preserved.status, 'unchanged');
-    assert.equal(preserved.content, initial);
-    assert.equal(inspection.status, 'WARN');
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});

package/packages/cli/dist/commands/lifecycle.d.ts

@@ -1,6 +0,0 @@
-export interface CliResult {
-    exitCode: number;
-    output?: string;
-    error?: string;
-}
-export declare function handleLifecycleCommand(projectRoot: string, command: string | undefined, subcommand: string | undefined, rest: string[]): Promise<CliResult | null>;

package/packages/cli/dist/commands/lifecycle.js

@@ -1,112 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { evaluateLifecycleDecisionGate, recordLifecycleDecision } from '@sdd-agent-platform/core/lifecycle';
-import { renderLifecycleDecisionGate } from '@sdd-agent-platform/core/lifecycle';
-import { extractLifecycleRiskSignalsFromText } from '@sdd-agent-platform/core/lifecycle';
-import { readOption, readRepeatedOptions } from '../options.js';
-import { renderLifecycleRiskExtraction } from '../renderers/lifecycle.js';
-export async function handleLifecycleCommand(projectRoot, command, subcommand, rest) {
-    if (command !== 'lifecycle' || subcommand !== 'decide') {
-        return null;
-    }
-    const lifecycleInput = await readLifecycleSignalOptions(rest);
-    if (lifecycleInput.error) {
-        return {
-            exitCode: 2,
-            error: lifecycleInput.error
-        };
-    }
-    const result = evaluateLifecycleDecisionGate(lifecycleInput.signals);
-    const runId = readOption(rest, '--run');
-    if (runId) {
-        await recordLifecycleDecision(projectRoot, runId, result.record);
-    }
-    const json = rest.includes('--json');
-    return {
-        exitCode: 0,
-        output: json
-            ? JSON.stringify({ riskExtraction: lifecycleInput.riskExtraction, ...result, recordedRunId: runId ?? null }, null, 2)
-            : `${renderLifecycleRiskExtraction(lifecycleInput.riskExtraction)}${renderLifecycleDecisionGate(result)}${runId ? `\nrecorded_run=${runId}` : ''}`
-    };
-}
-async function readLifecycleSignalOptions(args) {
-    const directSafe = args.includes('--direct-safe');
-    const riskTags = readRepeatedOptions(args, '--risk');
-    const contracts = readRepeatedOptions(args, '--contract');
-    const permissions = readRepeatedOptions(args, '--permission');
-    const fromText = readOption(args, '--from-text');
-    const fromFile = readOption(args, '--from-file');
-    if (fromText && fromFile) {
-        return { signals: {}, riskExtraction: null, error: 'Usage: sdd lifecycle decide accepts only one of --from-text or --from-file' };
-    }
-    const riskExtraction = fromText
-        ? extractLifecycleRiskSignalsFromText(fromText, 'from_text')
-        : fromFile
-            ? extractLifecycleRiskSignalsFromText(await readFile(fromFile, 'utf8'), 'from_file')
-            : null;
-    const extracted = riskExtraction?.signals ?? {};
-    const signals = {
-        intent_clarity: directSafe ? 'high' : readSignalClarity(args, '--intent') ?? 'medium',
-        acceptance_clarity: directSafe ? 'high' : readSignalClarity(args, '--acceptance') ?? 'medium',
-        estimated_change_size: directSafe ? 'tiny' : readEstimatedChangeSize(args, '--size') ?? 'small',
-        task_count_estimate: Number(readOption(args, '--tasks') ?? (directSafe ? '1' : '1')),
-        file_count_estimate: Number(readOption(args, '--files') ?? (directSafe ? '1' : '1')),
-        affected_layers: readRepeatedOptions(args, '--layer'),
-        affected_contracts: uniqueCliStrings([...contracts, ...(extracted.affected_contracts ?? [])]),
-        dependency_fanout: readDependencyFanout(args, '--fanout') ?? 'local',
-        impact_confidence: directSafe ? 'high' : extracted.impact_confidence ?? readImpactConfidence(args, '--impact-confidence') ?? 'medium',
-        risk_tags: uniqueCliStrings([...riskTags, ...(extracted.risk_tags ?? [])]),
-        reversibility: directSafe ? 'reversible' : extracted.reversibility ?? readReversibility(args, '--reversibility') ?? 'unknown',
-        validation_clarity: directSafe ? 'clear' : extracted.validation_clarity ?? readValidationClarity(args, '--validation') ?? 'partial',
-        validation_available: directSafe || args.includes('--validation-available'),
-        validation_cost: directSafe ? 'cheap' : readValidationCost(args, '--validation-cost') ?? 'unknown',
-        policy_hits: readRepeatedOptions(args, '--policy'),
-        permission_required: permissions,
-        requires_agents: args.includes('--requires-agents'),
-        handoff_count: Number(readOption(args, '--handoffs') ?? '0'),
-        artifact_dependency: args.includes('--artifact-dependency'),
-        runtime_recovery_need: args.includes('--runtime-recovery'),
-        orchestration_uncertainty: directSafe ? 'low' : readOrchestrationUncertainty(args, '--orchestration') ?? 'medium',
-        human_checkpoint_required: args.includes('--checkpoint'),
-        approval_reason: readRepeatedOptions(args, '--approval-reason'),
-        source_artifacts: uniqueCliStrings([...readRepeatedOptions(args, '--source-artifact'), ...(fromFile ? [fromFile] : [])]),
-        can_scout_impact: !args.includes('--cannot-scout-impact'),
-        architecture_decision_required: args.includes('--architecture') || Boolean(extracted.architecture_decision_required),
-        external_unknown: args.includes('--external-unknown') || Boolean(extracted.external_unknown)
-    };
-    return { signals, riskExtraction };
-}
-function uniqueCliStrings(values) {
-    return Array.from(new Set(values.filter((value) => value.length > 0)));
-}
-function readSignalClarity(args, name) {
-    const value = readOption(args, name);
-    return value === 'high' || value === 'medium' || value === 'low' ? value : null;
-}
-function readEstimatedChangeSize(args, name) {
-    const value = readOption(args, name);
-    return value === 'tiny' || value === 'small' || value === 'medium' || value === 'large' ? value : null;
-}
-function readImpactConfidence(args, name) {
-    return readSignalClarity(args, name);
-}
-function readValidationClarity(args, name) {
-    const value = readOption(args, name);
-    return value === 'clear' || value === 'partial' || value === 'unclear' ? value : null;
-}
-function readValidationCost(args, name) {
-    const value = readOption(args, name);
-    return value === 'cheap' || value === 'moderate' || value === 'expensive' || value === 'unknown' ? value : null;
-}
-function readDependencyFanout(args, name) {
-    const value = readOption(args, name);
-    return value === 'none' || value === 'local' || value === 'multi_component' || value === 'unknown' ? value : null;
-}
-function readReversibility(args, name) {
-    const value = readOption(args, name);
-    return value === 'reversible' || value === 'irreversible' || value === 'unknown' ? value : null;
-}
-function readOrchestrationUncertainty(args, name) {
-    const value = readOption(args, name);
-    return value === 'low' || value === 'medium' || value === 'high' ? value : null;
-}
-//# sourceMappingURL=lifecycle.js.map