sdd-agent-platform 0.4.0 → 0.4.1

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

@@ -9,7 +9,7 @@ import {
 import { artifactKind, readArtifact, writeArtifact } from '../run-state/artifacts.js';
 import { appendEvent } from '../run-state/events.js';
 import { appendArtifactHashLedgerEntry, appendDeclaredCommandLedgerEntries, appendInvocationLedgerEntry, listInvocationLedgerEntries } from '../run-state/invocation-ledger.js';
-import type { InvocationLedgerEntry, InvocationLedgerKind, RunState } from '../run-state/model.js';
+import type { InvocationLedgerEntry, InvocationLedgerKind, RunState, RunStateTaskRuntime } from '../run-state/model.js';
 import { readRunState, writeRunState } from '../run-state/run-state.js';
 import { toArtifactRootRelativePath } from '../runtime-paths.js';
 import { hasRuntimeEvidenceScopeViolation, readRuntimeEvidenceClaims } from '../context/evidence-summary.js';
@@ -20,6 +20,7 @@ import { taskGap } from '../sdd-docs/task-inspection.js';
 import { inspectSddTask } from '../sdd-docs/task-inspection.js';
 import type { SddTask, SddTaskGap } from '../sdd-docs/task-parser.js';
 import { resolveTaskRun } from '../sync-back/inspect.js';
+import { recordRuntimeSyncBackDecision, runtimeScopedId } from '../storage/runtime-store.js';
 
 export type GoalVerifyStatus = 'PASS' | 'PASS_WITH_GAPS' | 'FAIL' | 'BLOCKED';
 export type HarnessVerifyStatus = 'PASS' | 'GAPS' | 'BLOCKED' | 'HUMAN_NEEDED';
@@ -204,13 +205,28 @@ export async function runGoalVerify(projectRoot: string, options: GoalVerifyOpti
   await persistVerifyState(projectRoot, runId, {
     status,
     taskId: options.taskId,
-    taskState: { status: status === 'PASS' ? 'verified' : 'blocked', verifyStatus: status, gaps, artifacts: allArtifacts, acceptanceCoverage },
+    taskState: buildGoalVerifyTaskState(inspected.task, status, gaps, allArtifacts, acceptanceCoverage),
     commands: plannedCommands,
     evidence: allArtifacts,
     syncBackProposalPath: proposal.runRelativePath,
     syncBackProposalDigest: proposal.digest,
     artifacts: allArtifacts.map((artifactPath) => ({ path: artifactPath, kind: artifactKind(artifactPath), task: options.taskId, agent: agentFromArtifactPath(artifactPath) }))
   });
+  const decisionTime = new Date().toISOString();
+  await recordRuntimeSyncBackDecision(projectRoot, {
+    decisionId: runtimeScopedId(runId, options.taskId, 'sync-back'),
+    runId,
+    branch,
+    taskId: options.taskId,
+    status: 'proposed',
+    proposalPath: proposal.runRelativePath,
+    proposalDigest: proposal.digest,
+    proposalPayloadId: proposal.payloadId,
+    reasons: gaps.map((gap) => `${gap.severity} ${gap.type} ${gap.field}: ${gap.message}`),
+    createdAt: decisionTime,
+    updatedAt: decisionTime,
+    payload: { sourceVerifyStatus: status, standardStatus, artifacts: allArtifacts }
+  });
   await appendEvent(projectRoot, runId, {
     event: status === 'PASS' ? 'validation_passed' : 'validation_failed',
     runId,
@@ -243,10 +259,26 @@ export async function runGoalVerify(projectRoot: string, options: GoalVerifyOpti
   };
 }
 
+function buildGoalVerifyTaskState(task: SddTask | null, status: GoalVerifyStatus, gaps: SddTaskGap[], artifacts: string[], acceptanceCoverage: unknown[]): RunStateTaskRuntime {
+  const verificationStatus = status === 'PASS' ? 'pass' : status === 'PASS_WITH_GAPS' ? 'pass_with_gaps' : status === 'FAIL' ? 'failed' : 'blocked';
+  return {
+    status: status === 'PASS' ? 'implemented_verified' : verificationStatus === 'pass_with_gaps' ? 'validation_blocked' : verificationStatus === 'failed' ? 'validation_failed' : 'validation_blocked',
+    implementationStatus: 'implemented',
+    verificationStatus,
+    validationBatch: task?.validationBatch ?? null,
+    validationTiming: task?.validationTiming ?? 'task_end',
+    requiresVerifyBeforeNext: task?.requiresVerifyBeforeNext ?? true,
+    verifyStatus: status,
+    gaps,
+    artifacts,
+    acceptanceCoverage
+  };
+}
+
 async function persistVerifyState(projectRoot: string, runId: string, input: {
   status: GoalVerifyStatus;
   taskId: string;
-  taskState: unknown;
+  taskState: RunStateTaskRuntime;
   commands: string[];
   evidence: string[];
   syncBackProposalPath: string;
@@ -284,10 +316,11 @@ async function persistVerifyState(projectRoot: string, runId: string, input: {
   });
 }
 
-async function writeSyncBackProposal(projectRoot: string, runId: string, taskId: string, status: string, artifacts: string[], gaps: SddTaskGap[], summary: string): Promise<{ absolutePath: string; runRelativePath: string; digest: string }> {
+async function writeSyncBackProposal(projectRoot: string, runId: string, taskId: string, status: string, artifacts: string[], gaps: SddTaskGap[], summary: string): Promise<{ absolutePath: string; runRelativePath: string; digest: string; payloadId: string }> {
   const content = `# Sync-back Proposal\n\n## ${taskId}\n\n- status: ${status}\n- summary: ${summary}\n- artifacts:\n${artifacts.length > 0 ? artifacts.map((artifact) => `  - ${artifact}`).join('\n') : '  - none'}\n- gaps:\n${gaps.length > 0 ? gaps.map((gap) => `  - [${gap.severity}] ${gap.type} ${gap.field}: ${gap.message}`).join('\n') : '  - none'}\n\n## Boundaries\n\n- Proposal only; tasks.md/spec.md/plan.md were not modified by runtime.\n- Runtime modeled agent/verify steps through supplied artifacts and contract validation; no external agent API was invoked.\n`;
+  const digest = hashDocumentContent(content);
   const written = await writeArtifact(projectRoot, runId, 'sync-back-proposal.md', content);
-  return { ...written, digest: hashDocumentContent(content) };
+  return { ...written, digest, payloadId: runtimeScopedId(runId, written.runRelativePath, digest) };
 }
 
 function renderAcceptanceCoverageArtifact(taskId: string, status: GoalVerifyStatus, task: SddTask | null, reviewArtifact: string | null, validationArtifact: string | null, coverage: AcceptanceCoverageItem[], gaps: SddTaskGap[], executedCommands: string[]): string {

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

@@ -57,7 +57,7 @@ export interface SingleTaskLoopResultLike {
 export function renderGoalVerifyResult(result: GoalVerifyResultLike): string {
   const lines = ['SDD verify task result', 'changed'];
   lines.push(`- acceptance coverage written to ${result.coverageArtifactPath}`);
-  lines.push(`- sync-back proposal written to ${result.syncBackProposalPath}`);
+  lines.push(`- compatibility diagnostic proposal=${result.syncBackProposalPath || 'none'}`);
   lines.push('decision');
   lines.push(`- status=${result.status}`);
   lines.push(`- standard_status=${result.standardStatus}`);
@@ -85,7 +85,8 @@ export function renderGoalVerifyResult(result: GoalVerifyResultLike): string {
   }
   lines.push('next');
   if (result.status === 'PASS') {
-    lines.push(`- sdd sync-back inspect ${result.runId} --task ${result.taskId}`);
+    lines.push(`- sdd test task ${result.taskId} --run ${result.runId}`);
+    lines.push('- then follow the test gate result toward ship readiness; use sync-back only for explicit diagnostic/recovery/replay.');
   } else {
     lines.push(`- update review/validator artifacts and rerun sdd test task ${result.taskId} --run ${result.runId}`);
   }
@@ -108,8 +109,8 @@ export function renderSingleTaskLoopResult(result: SingleTaskLoopResultLike): st
   lines.push(`- required_artifacts=${result.requiredArtifacts.join(',') || 'none'}`);
   lines.push(`- accepted_artifacts=${result.acceptedArtifacts.join(',') || 'none'}`);
   lines.push(`- sync_back_proposal=${result.syncBackProposalPath || 'none'}`);
-  lines.push(`- agent_execution_records=.sdd/runs/${result.runId}/agent-executions/`);
-  lines.push(`- team_session_records=.sdd/runs/${result.runId}/team-sessions/`);
+  lines.push('- agent_execution_records=runtime.sqlite:agent_executions');
+  lines.push('- team_session_records=runtime.sqlite:team_sessions');
   lines.push('gaps');
   if (result.gaps.length === 0) {
     lines.push('- none');
@@ -118,7 +119,12 @@ export function renderSingleTaskLoopResult(result: SingleTaskLoopResultLike): st
   }
   lines.push('next');
   if (result.status === 'completed') {
-    lines.push(`- sdd test task ${result.taskId} --run ${result.runId}`);
+    if (result.task && !requiresImmediateValidation(result.task) && result.task.validationBatch) {
+      lines.push(`- sdd status --branch <branch> to select the next safe do task or validation boundary`);
+      lines.push(`- after all tasks in validation_batch ${result.task.validationBatch} are implemented, run sdd test batch ${result.task.validationBatch}`);
+    } else {
+      lines.push(`- sdd test task ${result.taskId} --run ${result.runId}`);
+    }
   } else {
     const missingArtifacts = result.requiredArtifacts.filter((artifact) => !result.acceptedArtifacts.includes(artifact));
     if (missingArtifacts.length > 0) {
@@ -137,6 +143,10 @@ export function renderSingleTaskLoopResult(result: SingleTaskLoopResultLike): st
   return lines.join('\n');
 }
 
+function requiresImmediateValidation(task: SddTask): boolean {
+  return task.requiresVerifyBeforeNext || task.validationTiming === 'task_end';
+}
+
 function agentForLoopArtifact(artifactPath: string): LoopAgent | null {
   const filename = artifactPath.replace(/\\/g, '/').split('/').pop() ?? '';
   if (filename.startsWith('implement-')) {

package/node_modules/@sdd-agent-platform/core/src/verification/review-gate.test.ts

@@ -0,0 +1,77 @@
+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 { listRuntimeWorkflowGateDecisions } from '../storage/runtime-store.js';
+import { writeBranchDocs } from '../test-support/fixtures.js';
+import { writeVerifyContract } from './verify-contract.js';
+import { runValidationWave } from './validation-wave.js';
+import { renderReviewGateResult, runReviewGate } from './review-gate.js';
+
+function taskMarkdown(taskId: string, command: string, wave: number): string {
+  return `### ${taskId}: Review gate 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 review gate fixtures.
+
+#### Acceptance
+
+- AC-${taskId}: Review gate evidence is mapped.
+`;
+}
+
+test('review gate records a workflow gate decision with whole-wave scope', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-review-gate-'));
+  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 wave = await runValidationWave(root, { branch: 'feature', wave: 1, approved: true });
+    const expectedEvidenceRefs = wave.taskResults.flatMap((taskResult) => [taskResult.validationArtifact, taskResult.indexArtifact].filter((ref): ref is string => Boolean(ref))).sort();
+    const result = await runReviewGate(root, {
+      branch: 'feature',
+      taskId: 'T1',
+      runId: wave.taskResults[0].runId,
+      waveRunId: wave.waveRunId,
+      taskIds: wave.plan.taskIds,
+      runIds: wave.taskResults.map((taskResult) => taskResult.runId),
+      evidenceRefs: expectedEvidenceRefs
+    });
+    const decisions = await listRuntimeWorkflowGateDecisions(root, { partition: 'feature', decisionKind: 'review_gate' });
+    const workflowGateScope = (result.workflowGateDecision.payload as { workflowScope?: { waveRunId: string | null; taskIds: string[]; runIds: string[]; evidenceRefs: string[] } }).workflowScope;
+
+    assert.equal(result.status, 'PASS');
+    assert.equal(decisions.some((decision) => decision.decisionId === result.workflowGateDecision.decisionId), true);
+    assert.equal(workflowGateScope?.waveRunId, wave.waveRunId);
+    assert.deepEqual(workflowGateScope?.taskIds, ['T1', 'T2']);
+    assert.deepEqual(workflowGateScope?.runIds, wave.taskResults.map((taskResult) => taskResult.runId).sort());
+    assert.deepEqual(workflowGateScope?.evidenceRefs, expectedEvidenceRefs);
+    assert.match(renderReviewGateResult(result), /workflow_gate=PASS:/);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});

package/node_modules/@sdd-agent-platform/core/src/verification/review-gate.ts

@@ -0,0 +1,77 @@
+import { evaluateAndRecordWorkflowGateDecision } from '../workflow-gate/evidence-packet.js';
+import type { WorkflowGateDecision, WorkflowGateStatus } from '../workflow-gate/types.js';
+
+export const REVIEW_GATE_RUNTIME_CONTRACT_VERSION = 'phase-8.17-review-gate-runtime-v1';
+
+export interface RunReviewGateOptions {
+  branch?: string | null;
+  taskId?: string | null;
+  runId?: string | null;
+  waveRunId?: string | null;
+  taskIds?: string[];
+  runIds?: string[];
+  evidenceRefs?: string[];
+}
+
+export interface ReviewGateRunResult {
+  contract: typeof REVIEW_GATE_RUNTIME_CONTRACT_VERSION;
+  branch: string;
+  taskId: string | null;
+  runId: string | null;
+  status: WorkflowGateStatus;
+  workflowGateDecision: WorkflowGateDecision;
+  next: string;
+}
+
+export async function runReviewGate(projectRoot: string, options: RunReviewGateOptions = {}): Promise<ReviewGateRunResult> {
+  const { decision } = await evaluateAndRecordWorkflowGateDecision(projectRoot, {
+    branch: options.branch,
+    taskId: options.taskId,
+    runId: options.runId,
+    decisionKind: 'review_gate',
+    waveRunId: options.waveRunId,
+    taskIds: options.taskIds,
+    runIds: options.runIds,
+    evidenceRefs: options.evidenceRefs
+  });
+  return {
+    contract: REVIEW_GATE_RUNTIME_CONTRACT_VERSION,
+    branch: decision.partition,
+    taskId: decision.taskId,
+    runId: decision.runId,
+    status: decision.status,
+    workflowGateDecision: decision,
+    next: nextForReviewGate(decision)
+  };
+}
+
+export function renderReviewGateResult(result: ReviewGateRunResult): string {
+  return [
+    'SDD review gate',
+    '',
+    `status=${result.status}`,
+    `branch=${result.branch}`,
+    `task=${result.taskId ?? 'none'}`,
+    `run=${result.runId ?? 'none'}`,
+    `workflow_gate=${result.workflowGateDecision.status}:${result.workflowGateDecision.decisionId}`,
+    '',
+    'Next:',
+    `- ${result.next}`
+  ].join('\n');
+}
+
+function nextForReviewGate(decision: WorkflowGateDecision): string {
+  if (decision.status === 'PASS') {
+    return `Continue workflow after review gate ${decision.decisionId}.`;
+  }
+  if (decision.status === 'WARN') {
+    return `Inspect review gate ${decision.decisionId} warnings before continuing.`;
+  }
+  if (decision.status === 'HUMAN_REQUIRED') {
+    return `Create a decision card for review gate ${decision.decisionId}.`;
+  }
+  if (decision.status === 'ADVISORY_ONLY') {
+    return `Inspect advisor assessments for review gate ${decision.decisionId}; do not treat advisory output as pass.`;
+  }
+  return `Resolve review gate ${decision.decisionId} blockers before continuing.`;
+}

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

@@ -12,10 +12,13 @@ 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';
+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 { 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';
@@ -32,6 +35,7 @@ test('runSingleTaskLoop completes from supplied review and validation artifacts
     await initProject(root);
     await execFileAsync('git', ['init'], { cwd: root });
     await writeBranchDocs(root, 'feature', validTaskMarkdown('T1', []));
+    await writeVerifyContract(root, { branch: 'feature', branchSource: 'cli_option' });
     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'));
@@ -50,6 +54,21 @@ test('runSingleTaskLoop completes from supplied review and validation artifacts
     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, 'artifacts/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',
+      artifactRole: 'validation',
+      digest: 'foreign-task',
+      status: 'active',
+      payload: { logicalRef: 'artifacts/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']);
@@ -59,7 +78,7 @@ test('runSingleTaskLoop completes from supplied review and validation artifacts
     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, 'WARN');
+    assert.equal(doctorReport.status, 'FAIL');
     assert.match(events, /task_selected/);
     assert.match(events, /review_passed/);
     assert.match(events, /validation_passed/);
@@ -67,6 +86,45 @@ test('runSingleTaskLoop completes from supplied review and validation artifacts
     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 === 'artifacts/sync-back-proposal.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 });
+  }
+});
+
+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', []));
+    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'));
+
+    const result = await runSingleTaskLoop(root, {
+      runId: state.runId,
+      branch: 'feature',
+      taskId: 'T1',
+      reviewArtifact: 'artifacts/review-T1.md',
+      validationArtifact: 'artifacts/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, ['artifacts/review-T1.md', 'artifacts/gap-report-T1.md']);
+    assert.equal(restored.artifacts.some((artifact) => artifact.path === 'artifacts/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(result.gaps.some((gap) => /UNSOURCED_PASS/.test(gap.message)), true);
   } finally {
     await rm(root, { recursive: true, force: true });
   }
@@ -104,6 +162,7 @@ test('runSingleTaskLoop blocks on missing reviewer artifact and creates gap prop
     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.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/);
     const events = stringifyEvents(await readRunEvents(root, state.runId));
@@ -185,9 +244,10 @@ test('runSingleTaskLoop persists agent and team evidence records', async () => {
     assert.equal(teamSession.teamMode.costClass, 'low');
     assert.match(teamSession.teamMode.reason, /review|validation/i);
     assert.equal(inspection.taskRunEvidence.teamSessions.length, inspection.teamSessions.length);
-    assert.equal(status.latestRunEvidence?.routePreflight, true);
-    assert.equal(status.latestRunEvidence?.agentExecutions, 2);
-    assert.equal(status.latestRunEvidence?.teamSessions, 1);
+    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);
   } finally {
     await rm(root, { recursive: true, force: true });

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

@@ -2,7 +2,7 @@ import { createHash } from 'node:crypto';
 import { SDD_RESULT_CONTRACT, SDD_RESULT_VERSION } from '../contracts.js';
 import { artifactKind, writeArtifact } from '../run-state/artifacts.js';
 import { appendEvent } from '../run-state/events.js';
-import type { RunState } from '../run-state/model.js';
+import type { RunState, RunStateTaskRuntime } from '../run-state/model.js';
 import { createRun, readRunState, writeRunState } from '../run-state/run-state.js';
 import { resolveSddContext } from '../sdd-docs/context.js';
 import { bindRunStateToTask } from '../sdd-docs/run-binding.js';
@@ -13,6 +13,7 @@ import type { TeamModeActivation } from '../router/route-cache.js';
 import { routeSddTask } from '../router/route-sdd-task.js';
 import { buildAgentExecutionRecord, buildTeamSessionRecord, writeAgentExecutionRecord, writeTeamSessionRecord } from '../execution/agent-execution-records.js';
 import { runBackgroundExecutor } from '../execution/background-executor.js';
+import { recordRuntimeSyncBackDecision, runtimeScopedId } from '../storage/runtime-store.js';
 
 export type SingleTaskLoopStatus = 'completed' | 'blocked' | 'failed';
 
@@ -92,12 +93,23 @@ export async function runSingleTaskLoop(projectRoot: string, options: SingleTask
       status: 'blocked',
       phase: 'do',
       taskId: options.taskId,
-      taskState: { status: 'blocked', gaps: allGaps, artifacts: [gapArtifact.runRelativePath] },
+      taskState: buildRuntimeTaskState(inspected.task, 'blocked', 'blocked', allGaps, [gapArtifact.runRelativePath]),
       validationStatus: 'blocked',
       syncBackProposalPath: proposal.runRelativePath,
       syncBackProposalDigest: proposal.digest,
       artifacts: [{ path: gapArtifact.runRelativePath, kind: 'gap-report', task: options.taskId, agent: 'runtime' }]
     });
+    await recordLoopSyncBackDecision(projectRoot, {
+      runId,
+      branch,
+      taskId: options.taskId,
+      status: 'proposed',
+      proposalPath: proposal.runRelativePath,
+      proposalDigest: proposal.digest,
+      proposalPayloadId: proposal.payloadId,
+      reasons: allGaps.map((gap) => `${gap.severity} ${gap.type} ${gap.field}: ${gap.message}`),
+      payload: { sourceVerifyStatus: 'blocked', artifacts: [gapArtifact.runRelativePath] }
+    });
     await appendEvent(projectRoot, runId, {
       event: 'gap_detected',
       runId,
@@ -135,11 +147,11 @@ export async function runSingleTaskLoop(projectRoot: string, options: SingleTask
     data: { task: options.taskId, title: inspected.task.title, source: inspected.task.source }
   });
 
-  const steps = buildLoopSteps(options.taskId, options);
+  const steps = buildLoopSteps(options.taskId, options, inspected.task);
   const acceptedArtifacts: string[] = [];
   const gaps: SddTaskGap[] = [];
   let terminalStatus: SingleTaskLoopStatus = 'completed';
-  let validationStatus: RunState['validation']['status'] = 'pass';
+  let validationStatus: RunState['validation']['status'] = 'not_run';
 
   for (const step of steps) {
     const stepRouteDecision = await routeSddTask(projectRoot, { taskId: options.taskId, branch, agent: step.agent, teamModeEnabled: options.teamModeEnabled, teamModeActivation: options.teamModeActivation, approved: options.approved });
@@ -194,7 +206,7 @@ export async function runSingleTaskLoop(projectRoot: string, options: SingleTask
       approved: options.approved
     });
 
-    if (!result.ingestion || !result.ingestion.resultStatus) {
+    if (!result.ingestion || result.ingestion.status !== 'accepted' || !result.ingestion.resultStatus) {
       const issueText = result.issues.map((issue) => issue.message).join('; ') || result.message;
       const recommendation = issueText.includes('manual isolation gate') || issueText.includes('requires confirmation')
         ? 'Resolve the manual isolation or approval gate for this high-risk task before ingesting execution artifacts.'
@@ -250,17 +262,30 @@ export async function runSingleTaskLoop(projectRoot: string, options: SingleTask
     });
   }
 
-  const proposal = await writeSyncBackProposal(projectRoot, runId, options.taskId, terminalStatus === 'completed' ? 'completed' : terminalStatus, acceptedArtifacts, gaps, terminalStatus === 'completed' ? 'Ingestion-aware task loop has accepted required artifacts through the Phase 3 executor.' : terminalStatus === 'blocked' && validationStatus === 'pass_with_gaps' ? 'Ingestion-aware task loop stopped because validator returned PASS_WITH_GAPS; sync-back is a blocked gap proposal, not task completion.' : 'Ingestion-aware task loop stopped with blocking/failing evidence.');
+  const taskState = buildRuntimeTaskState(inspected.task, terminalStatus, validationStatus, gaps, acceptedArtifacts);
+  const proposalStatus = taskState.status === 'implemented_pending_validation' ? taskState.status : terminalStatus === 'completed' ? 'completed' : terminalStatus;
+  const proposal = await writeSyncBackProposal(projectRoot, runId, options.taskId, proposalStatus, acceptedArtifacts, gaps, terminalStatus === 'completed' ? 'Ingestion-aware task loop accepted implementation evidence; validation may still be pending by task contract.' : terminalStatus === 'blocked' && validationStatus === 'pass_with_gaps' ? 'Ingestion-aware task loop stopped because validator returned PASS_WITH_GAPS; sync-back is a blocked gap proposal, not task completion.' : 'Ingestion-aware task loop stopped with blocking/failing evidence.');
   await persistLoopState(projectRoot, runId, {
     status: terminalStatus,
     phase: 'do',
     taskId: options.taskId,
-    taskState: { status: terminalStatus, gaps, artifacts: acceptedArtifacts },
+    taskState,
     validationStatus,
     syncBackProposalPath: proposal.runRelativePath,
     syncBackProposalDigest: proposal.digest,
     artifacts: acceptedArtifacts.map((artifactPath) => ({ path: artifactPath, kind: artifactKind(artifactPath), task: options.taskId, agent: agentFromArtifactPath(artifactPath) }))
   });
+  await recordLoopSyncBackDecision(projectRoot, {
+    runId,
+    branch,
+    taskId: options.taskId,
+    status: 'proposed',
+    proposalPath: proposal.runRelativePath,
+    proposalDigest: proposal.digest,
+    proposalPayloadId: proposal.payloadId,
+    reasons: gaps.map((gap) => `${gap.severity} ${gap.type} ${gap.field}: ${gap.message}`),
+    payload: { sourceVerifyStatus: terminalStatus, artifacts: acceptedArtifacts }
+  });
   await appendEvent(projectRoot, runId, {
     event: 'sync_back_proposed',
     runId,
@@ -298,7 +323,7 @@ export async function runSingleTaskLoop(projectRoot: string, options: SingleTask
   };
 }
 
-function buildLoopSteps(taskId: string, options: SingleTaskLoopOptions): LoopAgentStep[] {
+function buildLoopSteps(taskId: string, options: SingleTaskLoopOptions, task: SddTask | null): LoopAgentStep[] {
   const steps: LoopAgentStep[] = [
     { agent: 'implementer', suppliedArtifact: options.implementArtifact, expectedArtifact: `artifacts/implement-${taskId}.md`, required: false },
     { agent: 'reviewer', suppliedArtifact: options.reviewArtifact, expectedArtifact: `artifacts/review-${taskId}.md`, required: true }
@@ -306,15 +331,69 @@ function buildLoopSteps(taskId: string, options: SingleTaskLoopOptions): LoopAge
   if (options.debugArtifact) {
     steps.push({ agent: 'debugger', suppliedArtifact: options.debugArtifact, expectedArtifact: `artifacts/debug-${taskId}.md`, required: false });
   }
-  steps.push({ agent: 'validator', suppliedArtifact: options.validationArtifact, expectedArtifact: `artifacts/validation-${taskId}.md`, required: true });
+  steps.push({ agent: 'validator', suppliedArtifact: options.validationArtifact, expectedArtifact: `artifacts/validation-${taskId}.md`, required: requiresImmediateValidation(task) });
   return steps;
 }
 
+function requiresImmediateValidation(task: SddTask | null): boolean {
+  return !task || task.requiresVerifyBeforeNext || task.validationTiming === 'task_end';
+}
+
+function buildRuntimeTaskState(task: SddTask | null, status: SingleTaskLoopStatus, validationStatus: RunState['validation']['status'], gaps: SddTaskGap[], artifacts: string[]): RunStateTaskRuntime {
+  const implementationStatus: NonNullable<RunStateTaskRuntime['implementationStatus']> = status === 'completed' ? 'implemented' : status === 'blocked' ? 'blocked' : 'failed';
+  const verificationStatus: NonNullable<RunStateTaskRuntime['verificationStatus']> = verificationStatusForLoop(task, status, validationStatus);
+  return {
+    status: runtimeTaskStatus(implementationStatus, verificationStatus),
+    implementationStatus,
+    verificationStatus,
+    validationBatch: task?.validationBatch ?? null,
+    validationTiming: task?.validationTiming ?? 'task_end',
+    requiresVerifyBeforeNext: task?.requiresVerifyBeforeNext ?? true,
+    gaps,
+    artifacts
+  };
+}
+
+function verificationStatusForLoop(task: SddTask | null, status: SingleTaskLoopStatus, validationStatus: RunState['validation']['status']): NonNullable<RunStateTaskRuntime['verificationStatus']> {
+  if (validationStatus === 'pass') {
+    return 'pass';
+  }
+  if (validationStatus === 'pass_with_gaps') {
+    return 'pass_with_gaps';
+  }
+  if (validationStatus === 'blocked') {
+    return 'blocked';
+  }
+  if (validationStatus === 'fail') {
+    return 'failed';
+  }
+  if (status !== 'completed') {
+    return status === 'failed' ? 'failed' : 'blocked';
+  }
+  return task && !requiresImmediateValidation(task) ? 'pending_batch' : 'not_run';
+}
+
+function runtimeTaskStatus(implementationStatus: NonNullable<RunStateTaskRuntime['implementationStatus']>, verificationStatus: NonNullable<RunStateTaskRuntime['verificationStatus']>): string {
+  if (implementationStatus === 'implemented' && verificationStatus === 'pending_batch') {
+    return 'implemented_pending_validation';
+  }
+  if (implementationStatus === 'implemented' && verificationStatus === 'pass') {
+    return 'implemented_verified';
+  }
+  if (verificationStatus === 'pass_with_gaps' || verificationStatus === 'blocked') {
+    return 'validation_blocked';
+  }
+  if (implementationStatus === 'failed' || verificationStatus === 'failed') {
+    return 'failed';
+  }
+  return implementationStatus;
+}
+
 async function persistLoopState(projectRoot: string, runId: string, input: {
   status: SingleTaskLoopStatus;
   phase: string;
   taskId: string;
-  taskState: unknown;
+  taskState: RunStateTaskRuntime;
   validationStatus: RunState['validation']['status'];
   syncBackProposalPath: string;
   syncBackProposalDigest: string;
@@ -351,10 +430,29 @@ async function persistLoopState(projectRoot: string, runId: string, input: {
   });
 }
 
-async function writeSyncBackProposal(projectRoot: string, runId: string, taskId: string, status: string, artifacts: string[], gaps: SddTaskGap[], summary: string): Promise<{ absolutePath: string; runRelativePath: string; digest: string }> {
+async function writeSyncBackProposal(projectRoot: string, runId: string, taskId: string, status: string, artifacts: string[], gaps: SddTaskGap[], summary: string): Promise<{ absolutePath: string; runRelativePath: string; digest: string; payloadId: string }> {
   const content = `# Sync-back Proposal\n\n## ${taskId}\n\n- status: ${status}\n- summary: ${summary}\n- artifacts:\n${artifacts.length > 0 ? artifacts.map((artifact) => `  - ${artifact}`).join('\n') : '  - none'}\n- gaps:\n${gaps.length > 0 ? gaps.map((gap) => `  - [${gap.severity}] ${gap.type} ${gap.field}: ${gap.message}`).join('\n') : '  - none'}\n\n## Boundaries\n\n- Proposal only; tasks.md/spec.md/plan.md were not modified by runtime.\n- Runtime modeled agent/verify steps through supplied artifacts and contract validation; no external agent API was invoked.\n`;
+  const digest = hashDocumentContent(content);
   const written = await writeArtifact(projectRoot, runId, 'sync-back-proposal.md', content);
-  return { ...written, digest: hashDocumentContent(content) };
+  return { ...written, digest, payloadId: runtimeScopedId(runId, written.runRelativePath, digest) };
+}
+
+async function recordLoopSyncBackDecision(projectRoot: string, input: { runId: string; branch: string; taskId: string; status: string; proposalPath: string; proposalDigest: string; proposalPayloadId: string; reasons: string[]; payload: unknown }): Promise<void> {
+  const now = new Date().toISOString();
+  await recordRuntimeSyncBackDecision(projectRoot, {
+    decisionId: runtimeScopedId(input.runId, input.taskId, 'sync-back'),
+    runId: input.runId,
+    branch: input.branch,
+    taskId: input.taskId,
+    status: input.status,
+    proposalPath: input.proposalPath,
+    proposalDigest: input.proposalDigest,
+    proposalPayloadId: input.proposalPayloadId,
+    reasons: input.reasons,
+    createdAt: now,
+    updatedAt: now,
+    payload: input.payload
+  });
 }
 
 function renderLoopGapReport(taskId: string, gaps: SddTaskGap[]): string {