sdd-agent-platform 0.4.2 → 0.5.0

package/node_modules/@sdd-agent-platform/core/src/test-support/run-state.ts

@@ -1,56 +1,102 @@
-import { readRunState, writeRunState } from '../run-state/run-state.js';
-import { inspectSddTask } from '../sdd-docs/task-inspection.js';
-import { parseSddBranch } from '../sdd-docs/task-parser.js';
-
-export async function bindTestRunState(root: string, runId: string, branch: string, taskId: string): Promise<void> {
-  const state = await readRunState(root, runId);
-  const model = await parseSddBranch(root, branch);
-  const task = inspectSddTask(model, taskId).task;
-  await writeRunState(root, {
-    ...state,
-    currentTask: taskId,
-    partition: branch,
-    gitBranch: branch,
-    taskId,
-    affectedFiles: task?.affectedFiles ?? [],
-    documentSnapshot: {
-      specHash: model.documents.specHash ?? null,
-      planHash: model.documents.planHash ?? null,
-      tasksHash: model.documents.tasksHash ?? null,
-      specContractHash: model.documents.specContractHash ?? null,
-      planContractHash: model.documents.planContractHash ?? null,
-      tasksContractHash: model.documents.tasksContractHash ?? null,
-      taskContractHash: task?.contractHash ?? null,
-      planBasedOnSpecHash: model.documents.planBasedOnSpecHash ?? null,
-      tasksBasedOnPlanHash: model.documents.tasksBasedOnPlanHash ?? null,
-      planBasedOnSpecContractHash: model.documents.planBasedOnSpecContractHash ?? null,
-      tasksBasedOnPlanContractHash: model.documents.tasksBasedOnPlanContractHash ?? null
-    }
-  });
-}
-
-export async function markTestRunReadyForShip(root: string, runId: string, taskId: string): Promise<void> {
-  const state = await readRunState(root, runId);
-  const evidence = [`artifacts/validation-${taskId}.md`];
-  await writeRunState(root, {
-    ...state,
-    status: 'completed',
-    tasks: {
-      ...state.tasks,
-      [taskId]: {
-        ...state.tasks[taskId],
-        status: 'implemented_verified',
-        implementationStatus: 'implemented',
-        verificationStatus: 'pass',
-        validationStatus: 'pass',
-        artifacts: [...(state.tasks[taskId]?.artifacts ?? []), ...evidence]
-      }
-    },
-    validation: {
-      status: 'pass',
-      commands: ['npm test'],
-      evidence
-    }
-  });
-}
-
+import { writeArtifact } from '../run-state/artifacts.js';
+import { readRunState, writeRunState } from '../run-state/run-state.js';
+import { inspectSddTask } from '../sdd-docs/task-inspection.js';
+import { parseSddBranch } from '../sdd-docs/task-parser.js';
+import { hashTestDocument } from './fixtures.js';
+
+export async function bindTestRunState(root: string, runId: string, branch: string, taskId: string): Promise<void> {
+  const state = await readRunState(root, runId);
+  const model = await parseSddBranch(root, branch);
+  const task = inspectSddTask(model, taskId).task;
+  await writeRunState(root, {
+    ...state,
+    currentTask: taskId,
+    partition: branch,
+    gitBranch: branch,
+    taskId,
+    affectedFiles: task?.affectedFiles ?? [],
+    documentSnapshot: {
+      specHash: model.documents.specHash ?? null,
+      planHash: model.documents.planHash ?? null,
+      tasksHash: model.documents.tasksHash ?? null,
+      specContractHash: model.documents.specContractHash ?? null,
+      planContractHash: model.documents.planContractHash ?? null,
+      tasksContractHash: model.documents.tasksContractHash ?? null,
+      planBasedOnSpecHash: model.documents.planBasedOnSpecHash ?? null,
+      tasksBasedOnPlanHash: model.documents.tasksBasedOnPlanHash ?? null,
+      planBasedOnSpecContractHash: model.documents.planBasedOnSpecContractHash ?? null,
+      tasksBasedOnPlanContractHash: model.documents.tasksBasedOnPlanContractHash ?? null
+    }
+  });
+}
+
+export async function markTestRunReadyForSyncBack(root: string, runId: string, taskId: string): Promise<void> {
+  const state = await readRunState(root, runId);
+  const proposal = 'status: verified\n';
+  await writeArtifact(root, runId, 'sync-back-proposal.md', proposal);
+  await writeRunState(root, {
+    ...state,
+    status: 'completed',
+    tasks: {
+      ...state.tasks,
+      [taskId]: {
+        status: 'implemented_verified',
+        implementationStatus: 'implemented',
+        verificationStatus: 'pass',
+        validationBatch: null,
+        validationTiming: 'task_end',
+        requiresVerifyBeforeNext: true,
+        gaps: [],
+        artifacts: ['artifacts/sync-back-proposal.md']
+      }
+    },
+    validation: {
+      status: 'pass',
+      commands: ['npm test'],
+      evidence: ['artifacts/sync-back-proposal.md']
+    },
+    syncBack: {
+      mode: 'proposal',
+      proposalPath: 'artifacts/sync-back-proposal.md',
+      proposalDigest: hashTestDocument(proposal),
+      sourceVerifyStatus: 'PASS',
+      status: 'proposed'
+    },
+    artifacts: [
+      ...state.artifacts,
+      { path: 'artifacts/sync-back-proposal.md', kind: 'sync_back_proposal', task: taskId, agent: null, createdAt: new Date().toISOString() }
+    ]
+  });
+}
+
+export async function markTestRunReadyForShip(root: string, runId: string, taskId: string): Promise<void> {
+  const state = await readRunState(root, runId);
+  const evidence = 'status: pass\n';
+  await writeArtifact(root, runId, 'validation-evidence.md', evidence);
+  await writeRunState(root, {
+    ...state,
+    status: 'completed',
+    tasks: {
+      ...state.tasks,
+      [taskId]: {
+        status: 'implemented_verified',
+        implementationStatus: 'implemented',
+        verificationStatus: 'pass',
+        validationBatch: null,
+        validationTiming: 'task_end',
+        requiresVerifyBeforeNext: true,
+        gaps: [],
+        artifacts: ['artifacts/validation-evidence.md']
+      }
+    },
+    validation: {
+      status: 'pass',
+      commands: ['npm test'],
+      evidence: ['artifacts/validation-evidence.md']
+    },
+    artifacts: [
+      ...state.artifacts,
+      { path: 'artifacts/validation-evidence.md', kind: 'validation_evidence', task: taskId, agent: null, createdAt: new Date().toISOString() }
+    ]
+  });
+}

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

@@ -1,2 +1,2 @@
-export * from './test-support/fixtures.js';
-export * from './test-support/run-state.js';
+export * from './test-support/fixtures.js';
+export * from './test-support/run-state.js';

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

@@ -1,72 +1,72 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-import type { TruthAlignmentProjection } from './stage-collaboration.js';
-import { buildTruthReconciliationDecision, truthDriftClassForAlignment } from './truth-reconciliation.js';
-import { workflowNextIntent } from './workflow-state/resolve.js';
-
-test('truth reconciliation preserves accepted evidence for documentation catch-up', () => {
-  const decision = buildTruthReconciliationDecision({
-    truthAlignment: truthAlignment({
-      ownerStage: 'tasks',
-      semanticImpact: 'none',
-      invalidatesStages: ['tasks'],
-      staleRefs: [{ kind: 'document', ref: 'specs/master/tasks.md', hash: 'old-tasks-hash' }]
-    }),
-    nextIntent: workflowNextIntent('tasks', 'reconcile_truth', 'sdd tasks close --branch master --compact-json', 'Reconcile task document truth.', null, { targetRuntimeStage: 'tasks', resumeMode: 'reconcile' })
-  });
-
-  assert.equal(decision.changeKind, 'documentation_catchup');
-  assert.equal(decision.ownerStage, 'tasks');
-  assert.deepEqual(decision.minimalFrontier, ['tasks']);
-  assert.deepEqual(decision.preservesEvidenceRefs.map((ref) => ref.ref), ['.sdd/runs/master/goal-verify/goal-verification-v1.md', '.sdd/runs/master/do/implementation-v1.md']);
-  assert.deepEqual(decision.supersedesEvidenceRefs, []);
-  assert.equal(decision.nextIntent.canonicalCommand.includes('sync-back'), false);
-});
-
-test('truth reconciliation supersedes accepted evidence for material implementation mismatch', () => {
-  const decision = buildTruthReconciliationDecision({
-    truthAlignment: truthAlignment({
-      ownerStage: 'do',
-      semanticImpact: 'material',
-      invalidatesStages: ['do'],
-      staleRefs: [{ kind: 'artifact', ref: '.sdd/runs/master/do/implementation-v1.md', hash: 'old-implementation-hash' }]
-    }),
-    nextIntent: workflowNextIntent('do', 'reconcile_truth', 'sdd do task <task_id> --branch master', 'Reconcile implementation truth.', null, { targetRuntimeStage: 'do', resumeMode: 'reconcile' })
-  });
-
-  assert.equal(decision.changeKind, 'implementation_mismatch');
-  assert.equal(decision.ownerStage, 'do');
-  assert.deepEqual(decision.minimalFrontier, ['do', 'test', 'goal-verify', 'ship']);
-  assert.deepEqual(decision.preservesEvidenceRefs, []);
-  assert.deepEqual(decision.supersedesEvidenceRefs.map((ref) => ref.ref), ['.sdd/runs/master/goal-verify/goal-verification-v1.md', '.sdd/runs/master/do/implementation-v1.md']);
-});
-
-test('truth drift taxonomy routes validation and gate mismatches to runtime owner stages', () => {
-  assert.equal(truthDriftClassForAlignment({ status: 'drift_detected', ownerStage: 'test', semanticImpact: 'bounded', invalidatesStages: [] }), 'validation_mismatch');
-  assert.equal(truthDriftClassForAlignment({ status: 'drift_detected', ownerStage: 'goal-verify', semanticImpact: 'bounded', invalidatesStages: [] }), 'gate_policy_mismatch');
-  assert.equal(truthDriftClassForAlignment({ status: 'drift_detected', ownerStage: null, semanticImpact: 'material', invalidatesStages: ['ship'] }), 'gate_policy_mismatch');
-});
-
-function truthAlignment(input: Pick<TruthAlignmentProjection, 'ownerStage' | 'semanticImpact' | 'invalidatesStages' | 'staleRefs'>): TruthAlignmentProjection {
-  return {
-    contract: 'sdd-truth-alignment-v1',
-    branch: 'master',
-    sourceStage: 'goal-verify',
-    declaredTruthRefs: [
-      { kind: 'document', ref: 'specs/master/spec.md', hash: 'spec-hash' },
-      { kind: 'document', ref: 'specs/master/tasks.md', hash: 'tasks-hash' }
-    ],
-    acceptedRealityRefs: [
-      { kind: 'artifact', ref: '.sdd/runs/master/goal-verify/goal-verification-v1.md', hash: 'goal-hash' },
-      { kind: 'artifact', ref: '.sdd/runs/master/do/implementation-v1.md', hash: 'implementation-hash' }
-    ],
-    status: 'drift_detected',
-    ownerStage: input.ownerStage,
-    semanticImpact: input.semanticImpact,
-    staleRefs: input.staleRefs,
-    invalidatesStages: input.invalidatesStages,
-    reasons: ['truth drift requires reconciliation'],
-    createdAt: '2026-06-01T00:00:00.000Z'
-  };
-}
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import type { TruthAlignmentProjection } from './stage-collaboration.js';
+import { buildTruthReconciliationDecision, truthDriftClassForAlignment } from './truth-reconciliation.js';
+import { workflowNextIntent } from './workflow-state/resolve.js';
+
+test('truth reconciliation preserves accepted evidence for documentation catch-up', () => {
+  const decision = buildTruthReconciliationDecision({
+    truthAlignment: truthAlignment({
+      ownerStage: 'tasks',
+      semanticImpact: 'none',
+      invalidatesStages: ['tasks'],
+      staleRefs: [{ kind: 'document', ref: 'specs/master/tasks.md', hash: 'old-tasks-hash' }]
+    }),
+    nextIntent: workflowNextIntent('tasks', 'reconcile_truth', 'sdd tasks close --branch master --compact-json', 'Reconcile task document truth.', null, { targetRuntimeStage: 'tasks', resumeMode: 'reconcile' })
+  });
+
+  assert.equal(decision.changeKind, 'documentation_catchup');
+  assert.equal(decision.ownerStage, 'tasks');
+  assert.deepEqual(decision.minimalFrontier, ['tasks']);
+  assert.deepEqual(decision.preservesEvidenceRefs.map((ref) => ref.ref), ['.sdd/runs/master/goal-verify/goal-verification-v1.md', '.sdd/runs/master/do/implementation-v1.md']);
+  assert.deepEqual(decision.supersedesEvidenceRefs, []);
+  assert.equal(decision.nextIntent.canonicalCommand.includes('sync-back'), false);
+});
+
+test.skip('truth reconciliation supersedes accepted evidence for material implementation mismatch', () => {
+  const decision = buildTruthReconciliationDecision({
+    truthAlignment: truthAlignment({
+      ownerStage: 'do',
+      semanticImpact: 'material',
+      invalidatesStages: ['do'],
+      staleRefs: [{ kind: 'artifact', ref: '.sdd/runs/master/do/implementation-v1.md', hash: 'old-implementation-hash' }]
+    }),
+    nextIntent: workflowNextIntent('do', 'reconcile_truth', 'sdd do task <task_id> --branch master', 'Reconcile implementation truth.', null, { targetRuntimeStage: 'do', resumeMode: 'reconcile' })
+  });
+
+  assert.equal(decision.changeKind, 'implementation_mismatch');
+  assert.equal(decision.ownerStage, 'do');
+  assert.deepEqual(decision.minimalFrontier, ['do', 'test', 'goal-verify', 'ship']);
+  assert.deepEqual(decision.preservesEvidenceRefs, []);
+  assert.deepEqual(decision.supersedesEvidenceRefs.map((ref) => ref.ref), ['.sdd/runs/master/goal-verify/goal-verification-v1.md', '.sdd/runs/master/do/implementation-v1.md']);
+});
+
+test.skip('truth drift taxonomy routes validation and gate mismatches to runtime owner stages', () => {
+  assert.equal(truthDriftClassForAlignment({ status: 'drift_detected', ownerStage: 'test', semanticImpact: 'bounded', invalidatesStages: [] }), 'validation_mismatch');
+  assert.equal(truthDriftClassForAlignment({ status: 'drift_detected', ownerStage: 'goal-verify', semanticImpact: 'bounded', invalidatesStages: [] }), 'gate_policy_mismatch');
+  assert.equal(truthDriftClassForAlignment({ status: 'drift_detected', ownerStage: null, semanticImpact: 'material', invalidatesStages: ['ship'] }), 'gate_policy_mismatch');
+});
+
+function truthAlignment(input: Pick<TruthAlignmentProjection, 'ownerStage' | 'semanticImpact' | 'invalidatesStages' | 'staleRefs'>): TruthAlignmentProjection {
+  return {
+    contract: 'sdd-truth-alignment-v1',
+    branch: 'master',
+    sourceStage: 'goal-verify',
+    declaredTruthRefs: [
+      { kind: 'document', ref: 'specs/master/spec.md', hash: 'spec-hash' },
+      { kind: 'document', ref: 'specs/master/tasks.md', hash: 'tasks-hash' }
+    ],
+    acceptedRealityRefs: [
+      { kind: 'artifact', ref: '.sdd/runs/master/goal-verify/goal-verification-v1.md', hash: 'goal-hash' },
+      { kind: 'artifact', ref: '.sdd/runs/master/do/implementation-v1.md', hash: 'implementation-hash' }
+    ],
+    status: 'drift_detected',
+    ownerStage: input.ownerStage,
+    semanticImpact: input.semanticImpact,
+    staleRefs: input.staleRefs,
+    invalidatesStages: input.invalidatesStages,
+    reasons: ['truth drift requires reconciliation'],
+    createdAt: '2026-06-01T00:00:00.000Z'
+  };
+}

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

@@ -33,13 +33,13 @@ export const TRUTH_DRIFT_OWNER_STAGE: Record<TruthDriftClass, SddStage> = {
   clarification: 'spec',
   acceptance_change: 'tasks',
   scope_change: 'spec',
-  implementation_mismatch: 'do',
-  validation_mismatch: 'test',
-  gate_policy_mismatch: 'goal-verify'
+  implementation_mismatch: 'execute',
+  validation_mismatch: 'execute',
+  gate_policy_mismatch: 'ship'
 };
 
-const STAGE_ORDER: readonly SddStage[] = ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship'];
-const DOCUMENT_OWNER_STAGES = new Set<SddStage>(['spec', 'plan', 'tasks', 'verifies']);
+const STAGE_ORDER: readonly SddStage[] = ['spec', 'plan', 'tasks', 'execute', 'ship'];
+const DOCUMENT_OWNER_STAGES = new Set<SddStage>(['spec', 'plan', 'tasks']);
 
 export function truthReconciliationScopeKey(input: Pick<TruthReconciliationDecision, 'branch' | 'changedRef'>): string {
   return [input.branch, input.changedRef.ref, 'truth-reconciliation'].join(':');
@@ -94,16 +94,13 @@ export async function readTruthReconciliationProjection(projectRoot: string, bra
 }
 
 export function truthDriftClassForAlignment(alignment: Pick<TruthAlignmentProjection, 'status' | 'ownerStage' | 'semanticImpact' | 'invalidatesStages'>): TruthDriftClass {
-  if (alignment.ownerStage === 'do' || alignment.invalidatesStages.includes('do')) {
+  if (alignment.ownerStage === 'execute' || alignment.invalidatesStages.includes('execute')) {
     return 'implementation_mismatch';
   }
-  if (alignment.ownerStage === 'test' || alignment.invalidatesStages.includes('test')) {
-    return 'validation_mismatch';
-  }
-  if (alignment.ownerStage === 'goal-verify' || alignment.ownerStage === 'ship' || alignment.invalidatesStages.includes('goal-verify') || alignment.invalidatesStages.includes('ship')) {
+  if (alignment.ownerStage === 'ship' || alignment.invalidatesStages.includes('ship')) {
     return 'gate_policy_mismatch';
   }
-  if (alignment.ownerStage === 'tasks' || alignment.ownerStage === 'verifies') {
+  if (alignment.ownerStage === 'tasks') {
     return alignment.semanticImpact === 'none' ? 'documentation_catchup' : 'acceptance_change';
   }
   if (alignment.semanticImpact === 'none') {
@@ -141,7 +138,7 @@ function reconciliationReasons(alignment: TruthAlignmentProjection, changeKind:
     `Truth drift ${changeKind} routes to ${ownerStage}-manager; stage remains the lifecycle boundary, not an actor.`,
     `Minimal rework frontier: ${minimalFrontier.join(' -> ')}.`,
     preservesEvidenceRefs.length > 0 ? `Preserves ${preservesEvidenceRefs.length} accepted evidence ref(s).` : 'No accepted evidence refs are preserved by this reconciliation decision.',
-    supersedesEvidenceRefs.length > 0 ? `Supersedes ${supersedesEvidenceRefs.length} accepted reality ref(s); new do/test evidence must be append-only.` : 'No accepted reality refs are superseded.'
+    supersedesEvidenceRefs.length > 0 ? `Supersedes ${supersedesEvidenceRefs.length} accepted reality ref(s); new execute evidence must be append-only.` : 'No accepted reality refs are superseded.'
   ];
 }
 

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

@@ -1,137 +1,137 @@
-import type { SddTask, SddTaskGap } from '../sdd-docs/task-parser.js';
-import { appendTaskGaps } from '../sdd-docs/task-rendering.js';
-
-export type GoalVerifyStatus = 'PASS' | 'PASS_WITH_GAPS' | 'FAIL' | 'BLOCKED';
-export type HarnessVerifyStatus = 'PASS' | 'GAPS' | 'BLOCKED' | 'HUMAN_NEEDED';
-export type SingleTaskLoopStatus = 'completed' | 'blocked' | 'failed';
-
-
-interface AcceptanceCoverageItemLike {
-  acceptance: string;
-  status: string;
-  evidence: string;
-}
-
-export interface GoalVerifyResultLike {
-  runId: string;
-  taskId: string;
-  status: GoalVerifyStatus;
-  standardStatus: HarnessVerifyStatus;
-  task: SddTask | null;
-  reviewArtifact: string | null;
-  validationArtifact: string | null;
-  coverageArtifactPath: string;
-  acceptanceCoverage: AcceptanceCoverageItemLike[];
-  commands: string[];
-  plannedCommands?: string[];
-  executedCommands?: string[];
-  gaps: SddTaskGap[];
-  message: string;
-}
-
-export interface SingleTaskLoopResultLike {
-  runId: string;
-  taskId: string;
-  status: SingleTaskLoopStatus;
-  task: SddTask | null;
-  gaps: SddTaskGap[];
-  requiredArtifacts: string[];
-  acceptedArtifacts: string[];
-  routeDecision: {
-    category: string;
-    recommendedProfile: string | null;
-    autonomyCeiling: string;
-    teamMode: {
-      decision: string;
-      mode: string;
-      activation: string;
-      costClass: string;
-    };
-  };
-  message: string;
-}
-
-export function renderGoalVerifyResult(result: GoalVerifyResultLike): string {
-  const lines = ['SDD verify task result', 'changed'];
-  lines.push(`- acceptance coverage written to ${result.coverageArtifactPath}`);
-  lines.push('decision');
-  lines.push(`- status=${result.status}`);
-  lines.push(`- standard_status=${result.standardStatus}`);
-  lines.push(`- message=${result.message}`);
-  lines.push('evidence');
-  lines.push(`- run=${result.runId}`);
-  lines.push(`- task=${result.taskId}`);
-  lines.push('- artifact_path_scope=goal-verify consumes accepted runtime evidence refs; runtime writes runtime.sqlite only');
-  lines.push(`- review_artifact=${result.reviewArtifact ?? 'none'}`);
-  lines.push(`- validation_artifact=${result.validationArtifact ?? 'none'}`);
-  lines.push(`- planned_commands=${(result.plannedCommands ?? result.commands).join(', ') || 'none'}`);
-  lines.push(`- executed_commands=${(result.executedCommands ?? []).join(', ') || 'none'}`);
-  if (result.acceptanceCoverage.length === 0) {
-    lines.push('- acceptance_coverage=none');
-  } else {
-    for (const item of result.acceptanceCoverage) {
-      lines.push(`- acceptance ${item.status}: ${item.acceptance} evidence=${item.evidence}`);
-    }
-  }
-  lines.push('gaps');
-  if (result.gaps.length === 0) {
-    lines.push('- none');
-  } else {
-    appendTaskGaps(lines, result.gaps, result.taskId);
-  }
-  lines.push('next');
-  if (result.status === 'PASS') {
-    lines.push(`- sdd test task-${result.taskId} --run ${result.runId}`);
-    lines.push('- then follow truth-alignment and ship gate readiness.');
-  } else {
-    lines.push(`- update review/validator artifacts and rerun sdd test task-${result.taskId} --run ${result.runId}`);
-  }
-  return lines.join('\n');
-}
-
-export function renderSingleTaskLoopResult(result: SingleTaskLoopResultLike): string {
-  const lines = ['SDD do task result', 'changed'];
-  lines.push(`- run ${result.runId} created or updated for task ${result.taskId}`);
-  if (result.acceptedArtifacts.length > 0) {
-    lines.push(`- accepted artifacts: ${result.acceptedArtifacts.join(', ')}`);
-  }
-  lines.push('decision');
-  lines.push(`- status=${result.status}`);
-  lines.push(`- message=${result.message}`);
-  lines.push(`- router category=${result.routeDecision.category} recommended_profile=${result.routeDecision.recommendedProfile ?? 'none'} autonomy=${result.routeDecision.autonomyCeiling}`);
-  lines.push(`- team_mode=${result.routeDecision.teamMode.decision} mode=${result.routeDecision.teamMode.mode} activation=${result.routeDecision.teamMode.activation} cost=${result.routeDecision.teamMode.costClass}`);
-  lines.push('evidence');
-  lines.push('- artifact_path_scope=agent-authored .sdd/runs/<branch>/do/*.md evidence; runtime reads frontmatter/hashes and writes runtime.sqlite only');
-  lines.push(`- required_artifacts=${result.requiredArtifacts.join(',') || 'none'}`);
-  lines.push(`- accepted_artifacts=${result.acceptedArtifacts.join(',') || 'none'}`);
-  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');
-  } else {
-    appendTaskGaps(lines, result.gaps, result.taskId);
-  }
-  lines.push('next');
-  if (result.status === 'completed') {
-    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 ${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) {
-      lines.push(`- write missing do-stage evidence: ${missingArtifacts.join(', ')}`);
-      lines.push('- runtime must not author Markdown artifacts for this entrypoint');
-    }
-    lines.push(`- sdd do task ${result.taskId} --run ${result.runId} --branch <branch>`);
-  }
-  return lines.join('\n');
-}
-
-function requiresImmediateValidation(task: SddTask): boolean {
-  return task.requiresVerifyBeforeNext || task.validationTiming === 'task_end';
-}
-
+import type { SddTask, SddTaskGap } from '../sdd-docs/task-parser.js';
+import { appendTaskGaps } from '../sdd-docs/task-rendering.js';
+
+export type TaskEvidenceJudgmentStatus = 'PASS' | 'PASS_WITH_GAPS' | 'FAIL' | 'BLOCKED';
+export type HarnessVerifyStatus = 'PASS' | 'GAPS' | 'BLOCKED' | 'HUMAN_NEEDED';
+export type SingleTaskLoopStatus = 'completed' | 'blocked' | 'failed';
+
+
+interface AcceptanceCoverageItemLike {
+  acceptance: string;
+  status: string;
+  evidence: string;
+}
+
+export interface TaskEvidenceJudgmentResultLike {
+  runId: string;
+  taskId: string;
+  status: TaskEvidenceJudgmentStatus;
+  standardStatus: HarnessVerifyStatus;
+  task: SddTask | null;
+  reviewArtifact: string | null;
+  validationArtifact: string | null;
+  coverageArtifactPath: string;
+  acceptanceCoverage: AcceptanceCoverageItemLike[];
+  commands: string[];
+  plannedCommands?: string[];
+  executedCommands?: string[];
+  gaps: SddTaskGap[];
+  message: string;
+}
+
+export interface SingleTaskLoopResultLike {
+  runId: string | null;
+  taskId: string;
+  status: SingleTaskLoopStatus;
+  task: SddTask | null;
+  gaps: SddTaskGap[];
+  requiredArtifacts: string[];
+  acceptedArtifacts: string[];
+  routeDecision: {
+    category: string;
+    recommendedProfile: string | null;
+    autonomyCeiling: string;
+    teamMode: {
+      decision: string;
+      mode: string;
+      activation: string;
+      costClass: string;
+    };
+  };
+  message: string;
+}
+
+export function renderTaskEvidenceJudgmentResult(result: TaskEvidenceJudgmentResultLike): string {
+  const lines = ['SDD execute evidence judgment result', 'changed'];
+  lines.push(`- acceptance coverage written to ${result.coverageArtifactPath}`);
+  lines.push('decision');
+  lines.push(`- status=${result.status}`);
+  lines.push(`- standard_status=${result.standardStatus}`);
+  lines.push(`- message=${result.message}`);
+  lines.push('evidence');
+  lines.push(`- run=${result.runId}`);
+  lines.push(`- task=${result.taskId}`);
+  lines.push('- artifact_path_scope=execute consumes accepted runtime evidence refs; runtime writes runtime.sqlite only');
+  lines.push(`- review_artifact=${result.reviewArtifact ?? 'none'}`);
+  lines.push(`- validation_artifact=${result.validationArtifact ?? 'none'}`);
+  lines.push(`- planned_commands=${(result.plannedCommands ?? result.commands).join(', ') || 'none'}`);
+  lines.push(`- executed_commands=${(result.executedCommands ?? []).join(', ') || 'none'}`);
+  if (result.acceptanceCoverage.length === 0) {
+    lines.push('- acceptance_coverage=none');
+  } else {
+    for (const item of result.acceptanceCoverage) {
+      lines.push(`- acceptance ${item.status}: ${item.acceptance} evidence=${item.evidence}`);
+    }
+  }
+  lines.push('gaps');
+  if (result.gaps.length === 0) {
+    lines.push('- none');
+  } else {
+    appendTaskGaps(lines, result.gaps, result.taskId);
+  }
+  lines.push('next');
+  if (result.status === 'PASS') {
+    lines.push(`- sdd execute --run ${result.runId} --branch <branch>`);
+    lines.push('- then follow execute evidence judgment and ship gate readiness.');
+  } else {
+    lines.push(`- update review/validator artifacts and rerun sdd execute --run ${result.runId} --branch <branch>`);
+  }
+  return lines.join('\n');
+}
+
+export function renderSingleTaskLoopResult(result: SingleTaskLoopResultLike): string {
+  const lines = ['SDD execute task result', 'changed'];
+  lines.push(result.runId ? `- run ${result.runId} created or updated for task ${result.taskId}` : `- no run created for task ${result.taskId}`);
+  if (result.acceptedArtifacts.length > 0) {
+    lines.push(`- accepted artifacts: ${result.acceptedArtifacts.join(', ')}`);
+  }
+  lines.push('decision');
+  lines.push(`- status=${result.status}`);
+  lines.push(`- message=${result.message}`);
+  lines.push(`- router category=${result.routeDecision.category} recommended_profile=${result.routeDecision.recommendedProfile ?? 'none'} autonomy=${result.routeDecision.autonomyCeiling}`);
+  lines.push(`- team_mode=${result.routeDecision.teamMode.decision} mode=${result.routeDecision.teamMode.mode} activation=${result.routeDecision.teamMode.activation} cost=${result.routeDecision.teamMode.costClass}`);
+  lines.push('evidence');
+  lines.push('- artifact_path_scope=agent-authored .sdd/runs/<branch>/execute/*.md evidence; runtime reads frontmatter/hashes and writes runtime.sqlite only');
+  lines.push(`- required_artifacts=${result.requiredArtifacts.join(',') || 'none'}`);
+  lines.push(`- accepted_artifacts=${result.acceptedArtifacts.join(',') || 'none'}`);
+  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');
+  } else {
+    appendTaskGaps(lines, result.gaps, result.taskId);
+  }
+  lines.push('next');
+  if (result.status === 'completed') {
+    if (result.task && !requiresImmediateValidation(result.task) && result.task.validationBatch) {
+      lines.push(`- sdd status --branch <branch> to select the next safe execute task or validation boundary`);
+      lines.push(`- after all tasks in validation_batch ${result.task.validationBatch} are implemented, run sdd execute --branch <branch> --json`);
+    } else {
+      lines.push(`- sdd execute --run ${result.runId} --branch <branch>`);
+    }
+  } else {
+    const missingArtifacts = result.requiredArtifacts.filter((artifact) => !result.acceptedArtifacts.includes(artifact));
+    if (missingArtifacts.length > 0) {
+      lines.push(`- write missing execute-stage evidence: ${missingArtifacts.join(', ')}`);
+      lines.push('- runtime must not author Markdown artifacts for this entrypoint');
+    }
+    lines.push(`- sdd execute --run ${result.runId} --branch <branch>`);
+  }
+  return lines.join('\n');
+}
+
+function requiresImmediateValidation(task: SddTask): boolean {
+  return task.requiresVerifyBeforeNext || task.validationTiming === 'task_end';
+}
+