sdd-agent-platform 0.3.0 → 0.4.0

package/node_modules/@sdd-agent-platform/core/src/execution/wave-executor.ts

@@ -0,0 +1,231 @@
+import { WAVE_EXECUTOR_CONTRACT_VERSION } from '../contracts.js';
+import { contractIssue, type ContractValidationIssue } from '../contracts/issues.js';
+import { evaluateGovernancePolicy } from '../governance/policy.js';
+import { inspectWavePlan } from '../planning/wave-plan.js';
+import { appendEvent, readRunEvents } from '../run-state/events.js';
+import type { RuntimeEvent } from '../run-state/model.js';
+import { createRun, readRunState, writeRunState } from '../run-state/run-state.js';
+import { resolveSddContext } from '../sdd-docs/context.js';
+import type { WavePlanGate } from '../planning/wave-plan.js';
+import { inspectBackgroundExecutor, runBackgroundExecutor } from './background-executor.js';
+import type { BackgroundExecutorInspection, BackgroundExecutorResult } from './background-executor.js';
+
+export type WaveExecutorStrategy = 'fast-stop' | 'safe-continue';
+export type WaveExecutorStatus = 'claimed' | 'completed' | 'failed' | 'blocked';
+
+export interface WaveExecutorRunOptions {
+  branch?: string;
+  runId?: string;
+  capabilityId?: string;
+  agent?: string;
+  workerAdapterId?: string;
+  strategy?: WaveExecutorStrategy;
+  artifactPaths?: Record<string, string>;
+}
+
+export interface WaveExecutorTaskResult {
+  waveIndex: number;
+  taskId: string;
+  result: BackgroundExecutorResult;
+}
+
+export interface WaveExecutorResult {
+  version: typeof WAVE_EXECUTOR_CONTRACT_VERSION;
+  runId: string;
+  branch: string;
+  strategy: WaveExecutorStrategy;
+  status: WaveExecutorStatus;
+  plannedWaves: number;
+  executedWaves: number;
+  taskResults: WaveExecutorTaskResult[];
+  manualGates: WavePlanGate[];
+  blockedTasks: WavePlanGate[];
+  issues: ContractValidationIssue[];
+  message: string;
+}
+
+export interface WaveExecutorInspection {
+  version: typeof WAVE_EXECUTOR_CONTRACT_VERSION;
+  runId: string;
+  background: BackgroundExecutorInspection;
+  waveEvents: RuntimeEvent[];
+  valid: boolean;
+  issues: ContractValidationIssue[];
+}
+
+export async function inspectWaveExecutor(projectRoot: string, runId: string): Promise<WaveExecutorInspection> {
+  const [background, events] = await Promise.all([
+    inspectBackgroundExecutor(projectRoot, runId),
+    readRunEvents(projectRoot, runId)
+  ]);
+  const waveEvents = events.filter((event) => event.event.startsWith('wave_executor_'));
+  const issues = [...background.issues];
+  if (waveEvents.length === 0) {
+    issues.push(contractIssue('wave_executor', `Run ${runId} has no wave executor events.`, 'Run sdd wave run before inspecting wave executor evidence.'));
+  }
+  return {
+    version: WAVE_EXECUTOR_CONTRACT_VERSION,
+    runId,
+    background,
+    waveEvents,
+    valid: issues.length === 0,
+    issues
+  };
+}
+
+export async function runWaveExecutor(projectRoot: string, options: WaveExecutorRunOptions = {}): Promise<WaveExecutorResult> {
+  const branch = options.branch ?? (await resolveSddContext(projectRoot)).branch;
+  const strategy = options.strategy ?? 'fast-stop';
+  const agent = options.agent ?? 'implementer';
+  const workerAdapterId = options.workerAdapterId ?? 'sdd-cli-task-worker';
+  const runState = options.runId ? await readRunState(projectRoot, options.runId) : await createRun(projectRoot);
+  const runId = runState.runId;
+  const plan = await inspectWavePlan(projectRoot, { branch, capabilityId: options.capabilityId ?? 'native-file-edit' });
+  const issues: ContractValidationIssue[] = [];
+  const taskResults: WaveExecutorTaskResult[] = [];
+
+  const governance = await evaluateGovernancePolicy(projectRoot, {
+    operation: 'wave_executor',
+    runId,
+    workerAdapterId,
+    riskTags: plan.manualGates.flatMap((gate) => gate.reasons)
+  });
+  if (!governance.allowed) {
+    await appendEvent(projectRoot, runId, { event: 'governance_policy_blocked', runId, summary: `Governance policy blocked wave executor for ${branch}`, data: { branch, strategy, decision: governance } });
+    await writeRunState(projectRoot, { ...runState, status: 'blocked', phase: 'wave', currentTask: null });
+    return {
+      version: WAVE_EXECUTOR_CONTRACT_VERSION,
+      runId,
+      branch,
+      strategy,
+      status: 'blocked',
+      plannedWaves: plan.waves.length,
+      executedWaves: 0,
+      taskResults,
+      manualGates: plan.manualGates,
+      blockedTasks: plan.blockedTasks,
+      issues: governance.issues,
+      message: 'Wave executor blocked by governance policy.'
+    };
+  }
+
+  await writeRunState(projectRoot, {
+    ...runState,
+    status: 'running',
+    phase: 'wave',
+    currentTask: null
+  });
+  await appendEvent(projectRoot, runId, {
+    event: 'wave_executor_started',
+    runId,
+    summary: `Wave executor started for ${branch}`,
+    data: { branch, strategy, plannedWaves: plan.waves.length }
+  });
+
+  if (!plan.valid || plan.manualGates.length > 0 || plan.blockedTasks.length > 0) {
+    for (const gate of [...plan.manualGates, ...plan.blockedTasks]) {
+      issues.push(contractIssue(`task:${gate.taskId}`, gate.reasons.join(' | '), 'Resolve manual or blocked wave gates before running the wave executor.'));
+    }
+    await appendEvent(projectRoot, runId, {
+      event: 'wave_executor_blocked',
+      runId,
+      summary: `Wave executor blocked for ${branch}`,
+      data: { branch, manualGates: plan.manualGates, blockedTasks: plan.blockedTasks, issues }
+    });
+    const blockedState = await readRunState(projectRoot, runId);
+    await writeRunState(projectRoot, { ...blockedState, status: 'blocked', phase: 'wave', currentTask: null });
+    return {
+      version: WAVE_EXECUTOR_CONTRACT_VERSION,
+      runId,
+      branch,
+      strategy,
+      status: 'blocked',
+      plannedWaves: plan.waves.length,
+      executedWaves: 0,
+      taskResults,
+      manualGates: plan.manualGates,
+      blockedTasks: plan.blockedTasks,
+      issues,
+      message: 'Wave executor blocked before executing planned tasks.'
+    };
+  }
+
+  let executedWaves = 0;
+  let stopAfterWave = false;
+  for (const wave of plan.waves) {
+    executedWaves += 1;
+    await appendEvent(projectRoot, runId, {
+      event: 'wave_executor_wave_started',
+      runId,
+      summary: `Wave ${wave.index} started`,
+      data: { branch, waveIndex: wave.index, taskIds: wave.tasks.map((task) => task.taskId) }
+    });
+    let waveTerminalCompleted = true;
+    for (const task of wave.tasks) {
+      const result = await runBackgroundExecutor(projectRoot, {
+        branch,
+        runId,
+        taskId: task.taskId,
+        agent,
+        workerAdapterId,
+        artifactPath: options.artifactPaths?.[task.taskId],
+        delegationId: `W${wave.index}-${task.taskId}-${agent}-001`
+      });
+      taskResults.push({ waveIndex: wave.index, taskId: task.taskId, result });
+      issues.push(...result.issues);
+      if (result.status !== 'completed') {
+        waveTerminalCompleted = false;
+        stopAfterWave = true;
+        if (strategy === 'fast-stop') {
+          break;
+        }
+      }
+    }
+    await appendEvent(projectRoot, runId, {
+      event: 'wave_executor_wave_completed',
+      runId,
+      summary: `Wave ${wave.index} ${waveTerminalCompleted ? 'completed' : 'stopped'}`,
+      data: { branch, waveIndex: wave.index, completed: waveTerminalCompleted }
+    });
+    if (stopAfterWave) {
+      break;
+    }
+  }
+
+  const statuses = taskResults.map((task) => task.result.status);
+  const status: WaveExecutorStatus = statuses.includes('blocked')
+    ? 'blocked'
+    : statuses.includes('failed')
+      ? 'failed'
+      : statuses.includes('claimed') || taskResults.length < plan.summary.plannedTasks
+        ? 'claimed'
+        : 'completed';
+  const completedState = await readRunState(projectRoot, runId);
+  await writeRunState(projectRoot, {
+    ...completedState,
+    status: status === 'completed' ? 'completed' : status === 'failed' ? 'failed' : status === 'blocked' ? 'blocked' : 'running',
+    phase: 'wave',
+    currentTask: null
+  });
+  await appendEvent(projectRoot, runId, {
+    event: status === 'completed' ? 'wave_executor_completed' : 'wave_executor_stopped',
+    runId,
+    summary: `Wave executor ${status} for ${branch}`,
+    data: { branch, strategy, status, executedWaves, taskResults: taskResults.map((task) => ({ waveIndex: task.waveIndex, taskId: task.taskId, status: task.result.status })) }
+  });
+
+  return {
+    version: WAVE_EXECUTOR_CONTRACT_VERSION,
+    runId,
+    branch,
+    strategy,
+    status,
+    plannedWaves: plan.waves.length,
+    executedWaves,
+    taskResults,
+    manualGates: [],
+    blockedTasks: [],
+    issues,
+    message: `Wave executor ${status} after ${executedWaves} wave(s).`
+  };
+}

package/node_modules/@sdd-agent-platform/core/src/execution.ts

@@ -0,0 +1,5 @@
+export * from './execution/agent-execution-records.js';
+export * from './execution/background-executor.js';
+export * from './execution/foreground-subagents.js';
+export * from './execution/resident-worker.js';
+export * from './execution/wave-executor.js';

package/node_modules/@sdd-agent-platform/core/src/governance/policy.test.ts

@@ -0,0 +1,55 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+
+import { initProject } from '../config/init-project.js';
+import { doctor } from '../doctor/doctor.js';
+import { runBackgroundExecutor } from '../execution/background-executor.js';
+import { readRunEvents } from '../run-state/events.js';
+import { validTaskMarkdown, writeBranchDocs } from '../test-support/fixtures.js';
+import { evaluateGovernancePolicy, inspectGovernancePolicy } from './policy.js';
+
+test('governance policy explains confirmation and concurrency gates', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-governance-policy-'));
+  try {
+    await initProject(root);
+    await writeBranchDocs(root, 'master', `# Tasks\n\n${validTaskMarkdown('G1', [])}\n${validTaskMarkdown('G2', [])}\n${validTaskMarkdown('G3', [])}\n${validTaskMarkdown('G4', [])}\n${validTaskMarkdown('G5', [])}`);
+    const policy = await inspectGovernancePolicy(root);
+    const risky = await evaluateGovernancePolicy(root, { operation: 'destructive_git' });
+
+    assert.equal(policy.version, 'phase-3.14-governance-policy-v1');
+    assert.equal(risky.status, 'confirm');
+    assert.equal(risky.allowed, false);
+    assert.equal(risky.issues.some((issue) => issue.field === 'governance.confirmation'), true);
+
+    await runBackgroundExecutor(root, { taskId: 'G1' });
+    await runBackgroundExecutor(root, { taskId: 'G2' });
+    await runBackgroundExecutor(root, { taskId: 'G3' });
+    await runBackgroundExecutor(root, { taskId: 'G4' });
+    const blocked = await runBackgroundExecutor(root, { taskId: 'G5' });
+    const events = await readRunEvents(root, blocked.runId);
+
+    assert.equal(blocked.status, 'blocked');
+    assert.equal(blocked.issues.some((issue) => issue.field === 'governance.concurrency'), true);
+    assert.equal(events.some((event) => event.event === 'governance_policy_blocked'), true);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('doctor reports governance policy contract visibility', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-governance-doctor-'));
+  try {
+    await initProject(root);
+
+    const report = await doctor(root, { latestOnly: true });
+    const check = report.checks.find((item) => item.check === 'governance_policy_contract');
+
+    assert.equal(check?.level, 'PASS');
+    assert.match(check?.message ?? '', /phase-3\.14-governance-policy-v1/);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});

package/node_modules/@sdd-agent-platform/core/src/governance/policy.ts

@@ -0,0 +1,175 @@
+import {
+  GOVERNANCE_POLICY_CONTRACT_VERSION
+} from '../contracts.js';
+import { parseProjectConfig } from '../config/project-config.js';
+import { getProjectConfigPath } from '../runtime-paths.js';
+import { readFile } from 'node:fs/promises';
+import { listDelegationQueueItems } from '../delegation/queue.js';
+import { readAllRunStates } from '../run-state/run-state.js';
+
+export type GovernancePolicyOperation = 'background_executor' | 'wave_executor' | 'sync_back_apply' | 'destructive_git' | 'external_interaction' | 'cleanup';
+export type GovernancePolicyDecisionStatus = 'allow' | 'block' | 'confirm';
+
+export interface GovernancePolicy {
+  version: typeof GOVERNANCE_POLICY_CONTRACT_VERSION;
+  concurrency: {
+    maxBackgroundDelegations: number;
+    maxWaveExecutors: number;
+  };
+  manualConfirmation: {
+    operations: GovernancePolicyOperation[];
+    workerAdapters: string[];
+    riskTags: string[];
+  };
+  cleanup: {
+    archiveOnly: true;
+    deleteRunHistory: false;
+  };
+  retry: {
+    reopenTerminalDelegation: false;
+    maxAttemptsPerDelegation: number;
+  };
+  stopConditions: string[];
+  audit: {
+    requiredEvents: string[];
+    requiredEvidence: string[];
+  };
+}
+
+export interface GovernancePolicyDecisionInput {
+  operation: GovernancePolicyOperation;
+  runId?: string;
+  taskId?: string;
+  workerAdapterId?: string;
+  riskTags?: string[];
+  approved?: boolean;
+  excludeQueueItemId?: string;
+}
+
+export interface GovernancePolicyIssue {
+  field: string;
+  message: string;
+  recommendation: string;
+}
+
+export interface GovernancePolicyDecision {
+  version: typeof GOVERNANCE_POLICY_CONTRACT_VERSION;
+  operation: GovernancePolicyOperation;
+  status: GovernancePolicyDecisionStatus;
+  allowed: boolean;
+  reasons: string[];
+  issues: GovernancePolicyIssue[];
+  policy: GovernancePolicy;
+}
+
+const BUILT_IN_GOVERNANCE_POLICY: GovernancePolicy = {
+  version: GOVERNANCE_POLICY_CONTRACT_VERSION,
+  concurrency: {
+    maxBackgroundDelegations: 4,
+    maxWaveExecutors: 1
+  },
+  manualConfirmation: {
+    operations: ['sync_back_apply', 'destructive_git', 'external_interaction', 'cleanup'],
+    workerAdapters: ['manual-handoff-worker'],
+    riskTags: ['database', 'security', 'permission', 'external', 'destructive-git', 'data-loss']
+  },
+  cleanup: {
+    archiveOnly: true,
+    deleteRunHistory: false
+  },
+  retry: {
+    reopenTerminalDelegation: false,
+    maxAttemptsPerDelegation: 1
+  },
+  stopConditions: ['manual_confirmation_required', 'concurrency_limit_reached', 'terminal_delegation_reopen', 'planner_manual_gate', 'invalid_artifact_evidence'],
+  audit: {
+    requiredEvents: ['governance_policy_blocked', 'governance_policy_confirmed'],
+    requiredEvidence: ['policy version', 'operation', 'decision status', 'reason']
+  }
+};
+
+export async function inspectGovernancePolicy(projectRoot: string): Promise<GovernancePolicy> {
+  await assertProjectConfigReadable(projectRoot);
+  return {
+    ...BUILT_IN_GOVERNANCE_POLICY,
+    concurrency: { ...BUILT_IN_GOVERNANCE_POLICY.concurrency },
+    manualConfirmation: {
+      operations: [...BUILT_IN_GOVERNANCE_POLICY.manualConfirmation.operations],
+      workerAdapters: [...BUILT_IN_GOVERNANCE_POLICY.manualConfirmation.workerAdapters],
+      riskTags: [...BUILT_IN_GOVERNANCE_POLICY.manualConfirmation.riskTags]
+    },
+    cleanup: { ...BUILT_IN_GOVERNANCE_POLICY.cleanup },
+    retry: { ...BUILT_IN_GOVERNANCE_POLICY.retry },
+    stopConditions: [...BUILT_IN_GOVERNANCE_POLICY.stopConditions],
+    audit: {
+      requiredEvents: [...BUILT_IN_GOVERNANCE_POLICY.audit.requiredEvents],
+      requiredEvidence: [...BUILT_IN_GOVERNANCE_POLICY.audit.requiredEvidence]
+    }
+  };
+}
+
+export async function evaluateGovernancePolicy(projectRoot: string, input: GovernancePolicyDecisionInput): Promise<GovernancePolicyDecision> {
+  const policy = await inspectGovernancePolicy(projectRoot);
+  const issues: GovernancePolicyIssue[] = [];
+  const reasons: string[] = [];
+  const queue = await listDelegationQueueItems(projectRoot);
+  const runningDelegations = queue.items.filter((item) => item.status === 'RUNNING' && item.id !== input.excludeQueueItemId).length;
+  const runningWaveExecutors = (await readAllRunStates(projectRoot)).filter((state) => state.status === 'running' && state.phase === 'wave').length;
+
+  if ((input.operation === 'background_executor' || input.operation === 'wave_executor') && runningDelegations >= policy.concurrency.maxBackgroundDelegations) {
+    const reason = `Running delegation count ${runningDelegations} reached governance limit ${policy.concurrency.maxBackgroundDelegations}.`;
+    reasons.push(reason);
+    issues.push(governanceIssue('governance.concurrency', reason, 'Wait for existing delegations to finish, archive stale exploratory runs, or inspect governance policy before starting more background work.'));
+  }
+  if (input.operation === 'wave_executor' && runningWaveExecutors >= policy.concurrency.maxWaveExecutors) {
+    const reason = `Running wave executor count ${runningWaveExecutors} reached governance limit ${policy.concurrency.maxWaveExecutors}.`;
+    reasons.push(reason);
+    issues.push(governanceIssue('governance.wave_concurrency', reason, 'Wait for the running wave executor to finish or archive the stale run before starting another wave.'));
+  }
+
+  const confirmationReasons: string[] = [];
+  if (policy.manualConfirmation.operations.includes(input.operation)) {
+    confirmationReasons.push(`Operation ${input.operation} requires explicit confirmation.`);
+  }
+  if (input.workerAdapterId && policy.manualConfirmation.workerAdapters.includes(input.workerAdapterId)) {
+    confirmationReasons.push(`Worker adapter ${input.workerAdapterId} requires manual confirmation.`);
+  }
+  const riskHits = (input.riskTags ?? []).filter((tag) => policy.manualConfirmation.riskTags.includes(tag));
+  if (riskHits.length > 0) {
+    confirmationReasons.push(`Risk tag(s) require confirmation: ${riskHits.join(', ')}.`);
+  }
+  if (confirmationReasons.length > 0 && !input.approved) {
+    reasons.push(...confirmationReasons);
+    for (const reason of confirmationReasons) {
+      issues.push(governanceIssue('governance.confirmation', reason, 'Get explicit user confirmation before continuing this governed operation.'));
+    }
+  }
+  if (confirmationReasons.length > 0 && input.approved) {
+    reasons.push(...confirmationReasons.map((reason) => `${reason} Approval recorded.`));
+  }
+
+  const status: GovernancePolicyDecisionStatus = issues.length > 0
+    ? confirmationReasons.length > 0 && issues.every((issue) => issue.field === 'governance.confirmation')
+      ? 'confirm'
+      : 'block'
+    : 'allow';
+  return {
+    version: GOVERNANCE_POLICY_CONTRACT_VERSION,
+    operation: input.operation,
+    status,
+    allowed: status === 'allow',
+    reasons: reasons.length > 0 ? reasons : [`Operation ${input.operation} is allowed by governance policy.`],
+    issues,
+    policy
+  };
+}
+
+function governanceIssue(field: string, message: string, recommendation: string): GovernancePolicyIssue {
+  return { field, message, recommendation };
+}
+
+async function assertProjectConfigReadable(projectRoot: string): Promise<void> {
+  const configPath = getProjectConfigPath(projectRoot);
+  const raw = await readFile(configPath, 'utf8');
+  parseProjectConfig(raw, configPath);
+}

package/node_modules/@sdd-agent-platform/core/src/governance.ts

@@ -0,0 +1 @@
+export * from './governance/policy.js';

package/node_modules/@sdd-agent-platform/core/src/index.test.ts

@@ -0,0 +1,25 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import type { CodingFactSet } from './coding-facts.js';
+import type { LifecycleRiskDecision } from './risk.js';
+import type { StageRun, WorkflowHandoff, WorkflowStageHandoffDiagnostic } from './stage-runtime.js';
+import type { WorkUnit } from './work-units.js';
+import type { SubagentDefinition } from './subagents.js';
+import type { ContextOffloadDecision } from './context-offload.js';
+import type { UnifiedTestEvidenceRun } from './evidence-runtime.js';
+
+test('Phase 8 public facades expose contract types', () => {
+  const names: Array<keyof {
+    facts: CodingFactSet;
+    risk: LifecycleRiskDecision;
+    stage: StageRun;
+    handoff: WorkflowHandoff;
+    handoffDiagnostic: WorkflowStageHandoffDiagnostic;
+    work: WorkUnit;
+    subagent: SubagentDefinition;
+    context: ContextOffloadDecision;
+    evidence: UnifiedTestEvidenceRun;
+  }> = ['facts', 'risk', 'stage', 'handoff', 'handoffDiagnostic', 'work', 'subagent', 'context', 'evidence'];
+
+  assert.deepEqual(names, ['facts', 'risk', 'stage', 'handoff', 'handoffDiagnostic', 'work', 'subagent', 'context', 'evidence']);
+});

package/node_modules/@sdd-agent-platform/core/src/index.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/@sdd-agent-platform/core/src/instructions.test.ts

@@ -0,0 +1,43 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { getSddInstructions } from './instructions.js';
+
+test('instructions API returns stable JSON contract payloads', () => {
+  const initPayload = getSddInstructions('init');
+  const doctorPayload = getSddInstructions('doctor');
+  const overviewPayload = getSddInstructions('overview');
+  const doPayload = getSddInstructions('do');
+  const verifyPayload = getSddInstructions('verify');
+  const planPayload = getSddInstructions('plan');
+  const specPayload = getSddInstructions('spec');
+  const tasksPayload = getSddInstructions('tasks');
+
+  assert.equal(doctorPayload.contract, 'sdd-instructions-v1');
+  assert.equal(doctorPayload.action, 'doctor');
+  assert.equal(doctorPayload.requiredCommands.includes('sdd doctor fast --branch <branch>'), true);
+  assert.equal(doctorPayload.forbiddenSideEffects.includes('background write'), true);
+  assert.equal(doctorPayload.forbiddenSideEffects.includes('run deep historical scans unless explicitly requested'), true);
+  assert.equal(overviewPayload.requiredCommands.includes('sdd test task <task_id> --branch <branch>'), true);
+  assert.equal(overviewPayload.forbiddenSideEffects.includes('unapproved complex sync-back apply'), true);
+  assert.match(overviewPayload.summary, /natural-language SDD intent/);
+  assert.equal(overviewPayload.nextSteps.some((step) => /natural-language intent router/.test(step)), true);
+  assert.equal(overviewPayload.nextSteps.some((step) => /ambiguous after status/.test(step)), true);
+  assert.equal(initPayload.allowedSideEffects.includes('write managed generated AI entries'), true);
+  assert.equal(initPayload.allowedSideEffects.includes('write specs/<branch>/spec.md'), false);
+  assert.equal(initPayload.forbiddenSideEffects.some((item) => /legacy --scaffold-docs/.test(item)), true);
+  assert.match(planPayload.summary, /deliverable technical solution document/);
+  assert.equal(planPayload.nextSteps.some((step) => /PlantUML/.test(step)), true);
+  assert.equal(planPayload.nextSteps.some((step) => /state-machine/.test(step) && /api_schema/.test(step)), true);
+  assert.match(specPayload.summary, /workflow partition entry/);
+  assert.equal(specPayload.forbiddenSideEffects.includes('design technical solution in spec.md'), true);
+  assert.equal(specPayload.nextSteps.some((step) => /AC-1/.test(step) && /verification hints/.test(step)), true);
+  assert.match(tasksPayload.summary, /executable evidence contract/);
+  assert.equal(tasksPayload.forbiddenSideEffects.includes('turn tasks.md into project-management backlog'), true);
+  assert.equal(tasksPayload.nextSteps.some((step) => /acceptance_refs/.test(step) && /plan_refs/.test(step)), true);
+  assert.equal(doPayload.requiredCommands.includes('sdd artifact template artifacts/<agent>-<task_id>.md --task <task_id> --agent <agent>'), true);
+  assert.equal(doPayload.forbiddenSideEffects.includes('mark missing evidence as PASS'), true);
+  assert.equal(doPayload.nextSteps.some((step) => /artifacts\/implement-<task_id>\.md/.test(step)), true);
+  assert.equal(verifyPayload.requiredCommands.includes('sdd artifact validate <run_id> <artifact> --task <task_id> --agent validator'), true);
+  assert.equal(verifyPayload.forbiddenSideEffects.includes('unapproved complex sync-back apply'), true);
+});