sdd-agent-platform 0.4.0 → 0.4.2

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

@@ -189,7 +189,7 @@ function riskDecision(profile: LifecycleRiskDecision['profile'], approvalPolicy:
     profile,
     requiredStages: profile === 'blocked' ? [] : ['do', 'test'],
     skippedStages: [],
-    blockedStages: profile === 'blocked' ? ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'sync-back', 'ship'] : [],
+    blockedStages: profile === 'blocked' ? ['spec', 'plan', 'tasks', 'verifies', 'do', 'test', 'goal-verify', 'ship'] : [],
     requiredEvidence: [],
     requiredReviews: [],
     humanCheckpointRequired: approvalPolicy !== 'auto-allow',

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

@@ -187,6 +187,10 @@ export function workflowHandoffScopeKey(scope: RuntimeScope, fromStage: SddStage
 }
 
 export async function recordStageRunProjection(projectRoot: string, stageRun: StageRun): Promise<RuntimeProjectionEnvelopeWriteResult<StageRun>> {
+  const existing = await readStageRunProjection(projectRoot, stageRun.scope, stageRun.stage);
+  if (existing && isTerminalStageRunStatus(existing.payload.status) && !isTerminalStageRunStatus(stageRun.status)) {
+    return { envelope: existing, previous: null, staleness: 'fresh', status: 'unchanged' };
+  }
   return recordRuntimeProjectionEnvelope(projectRoot, {
     projectionType: STAGE_RUN_PROJECTION_TYPE,
     scopeKey: stageRunScopeKey(stageRun.scope, stageRun.stage),
@@ -198,6 +202,10 @@ export async function recordStageRunProjection(projectRoot: string, stageRun: St
   });
 }
 
+function isTerminalStageRunStatus(status: StageRunStatus): boolean {
+  return status === 'completed' || status === 'skipped';
+}
+
 export async function readStageRunProjection(projectRoot: string, scope: RuntimeScope, stage: SddStage): Promise<RuntimeProjectionEnvelope<StageRun> | null> {
   return readRuntimeProjectionEnvelope(projectRoot, STAGE_RUN_PROJECTION_TYPE, stageRunScopeKey(scope, stage));
 }
@@ -339,7 +347,7 @@ function workflowHandoffInputHash(handoff: WorkflowHandoff): string {
 }
 
 function requiresEvidenceForHandoff(toStage: SddStage): boolean {
-  return toStage === 'test' || toStage === 'goal-verify' || toStage === 'sync-back' || toStage === 'ship';
+  return toStage === 'test' || toStage === 'goal-verify' || toStage === 'ship';
 }
 
 function isSubagentRole(role: string): boolean {

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

@@ -9,7 +9,7 @@ import { promisify } from 'node:util';
 import { setTimeout } from 'node:timers/promises';
 
 import { contextBuildTaskMarkdown, validTaskMarkdown, writeBranchDocs } from '../test-support/fixtures.js';
-import { getProjectStatus, getStatuslineProjection } from './project-status.js';
+import { getProjectStatus, getStatuslineProjection, resolveProjectStatusNextIntent } from './project-status.js';
 import { initProject } from '../config/init-project.js';
 import { readAgentRuntimeProjectConfig as readProjectConfig } from '../router/agent-runtime-config.js';
 import { buildContextBuildPackage } from '../context/build-package.js';
@@ -18,6 +18,11 @@ import { STAGE_RUN_CONTRACT_VERSION, SUBAGENT_DISPATCH_CONTRACT_VERSION, WORKFLO
 import { recordStageRunProjection, recordWorkflowHandoffProjection, type StageRun, type WorkflowHandoff } from '../stage-runtime.js';
 import { decideContextOffload, evaluateContextLoadSignal, recordContextLoadSignalProjection, recordContextOffloadDecisionProjection } from '../context-offload.js';
 import { recordSubagentDispatchProjection, type SubagentDispatch } from '../subagents.js';
+import { workflowNextIntent } from '../workflow-state/resolve.js';
+import { createRun } from '../run-state/run-state.js';
+import { createRuntimeEvidenceSet, recordRuntimeArtifactPayload, recordRuntimeWorkflowGateDecision, runtimeScopedId, updateRuntimeSelectionPointer } from '../storage/runtime-store.js';
+import type { WorkflowGateDecision } from '../workflow-gate/types.js';
+import type { TruthReconciliationDecision } from '../truth-reconciliation.js';
 
 const execFileAsync = promisify(execFile);
 
@@ -35,6 +40,119 @@ async function removeTempRoot(root: string): Promise<void> {
   }
 }
 
+test('project status reports closed full-stage chain as complete instead of rerunning ship close', () => {
+  const taskIntent = workflowNextIntent('test', 'run_task_validation', 'sdd test task-T1 --branch master', 'Validate task T1.', null);
+  const nextIntent = resolveProjectStatusNextIntent('master', taskIntent, { finalHealth: 'ship_ready' });
+
+  assert.equal(nextIntent.stage, 'ship');
+  assert.equal(nextIntent.intent, 'workflow_complete');
+  assert.equal(nextIntent.canonicalCommand, 'sdd status --branch master --json');
+  assert.equal(nextIntent.displayCommand, '/sdd status --branch master --json');
+  assert.equal(nextIntent.commandSemantics, 'inspection_navigation');
+  assert.equal(nextIntent.targetRuntimeStage, 'ship');
+
+  const readyIntent = resolveProjectStatusNextIntent('master', taskIntent, { finalHealth: 'ready_for_ship' });
+  assert.equal(readyIntent.stage, 'ship');
+  assert.equal(readyIntent.intent, 'ship_readiness');
+  assert.equal(readyIntent.canonicalCommand, 'sdd ship close --branch master --compact-json');
+});
+
+test('project status prioritizes truth reconciliation before closed full-stage chain routing', () => {
+  const taskIntent = workflowNextIntent('test', 'run_task_validation', 'sdd test task-T1 --branch master', 'Validate task T1.', null);
+  const reconcileIntent = workflowNextIntent('do', 'reconcile_truth', 'sdd do task <task_id> --branch master', 'Reconcile implementation truth drift.', 'truthAlignment requires reconciliation', {
+    targetRuntimeStage: 'do',
+    resumeMode: 'reconcile'
+  });
+  const reconciliation: TruthReconciliationDecision = {
+    contract: 'sdd-truth-reconciliation-v1',
+    branch: 'master',
+    ownerStage: 'do',
+    changedRef: { kind: 'artifact', ref: '.sdd/runs/master/do/implementation-v1.md', hash: 'old-hash' },
+    oldHash: 'old-hash',
+    newHash: 'new-hash',
+    changeKind: 'implementation_mismatch',
+    semanticImpact: 'material',
+    preservesEvidenceRefs: [],
+    supersedesEvidenceRefs: [{ kind: 'artifact', ref: '.sdd/runs/master/do/implementation-v1.md', hash: 'old-hash' }],
+    invalidatesStages: ['do'],
+    minimalFrontier: ['do', 'test', 'goal-verify', 'ship'],
+    nextIntent: reconcileIntent,
+    reasons: ['implementation truth drift requires owner-manager reconciliation']
+  };
+
+  const nextIntent = resolveProjectStatusNextIntent('master', taskIntent, { finalHealth: 'ship_ready' }, undefined, reconciliation);
+
+  assert.equal(nextIntent, reconcileIntent);
+  assert.equal(nextIntent.intent, 'reconcile_truth');
+  assert.equal(nextIntent.targetRuntimeStage, 'do');
+  assert.equal(nextIntent.canonicalCommand, 'sdd do task <task_id> --branch master');
+  assert.equal(nextIntent.canonicalCommand.includes('sync-back'), false);
+});
+
+test('project status routes fresh intra-bundle handoff to the internal runtime stage', () => {
+  const taskIntent = workflowNextIntent('test', 'run_task_validation', 'sdd test task-T1 --branch master', 'Validate task T1.', null);
+  const goalVerifyIntent = resolveProjectStatusNextIntent('master', taskIntent, { finalHealth: 'none' }, {
+    status: 'fresh',
+    latestHandoff: {
+      ...statusHandoff(),
+      id: 'handoff-status-test-goal-verify',
+      fromStage: 'test',
+      toStage: 'goal-verify',
+      fromAgent: 'test-manager',
+      toAgent: 'goal-verify-manager',
+      status: 'proposed'
+    }
+  });
+
+  assert.equal(goalVerifyIntent.bundle, 'test');
+  assert.equal(goalVerifyIntent.targetRuntimeStage, 'goal-verify');
+  assert.equal(goalVerifyIntent.intent, 'run_goal_verify');
+  assert.equal(goalVerifyIntent.canonicalCommand, 'sdd test close --branch master --target goal-verify --compact-json');
+
+  const verifiesIntent = resolveProjectStatusNextIntent('master', taskIntent, { finalHealth: 'none' }, {
+    status: 'fresh',
+    latestHandoff: {
+      ...statusHandoff(),
+      id: 'handoff-status-tasks-verifies',
+      fromStage: 'tasks',
+      toStage: 'verifies',
+      fromAgent: 'tasks-manager',
+      toAgent: 'verifies-manager',
+      status: 'proposed'
+    }
+  });
+
+  assert.equal(verifiesIntent.bundle, 'tasks');
+  assert.equal(verifiesIntent.targetRuntimeStage, 'verifies');
+  assert.equal(verifiesIntent.intent, 'run_verifies');
+  assert.equal(verifiesIntent.canonicalCommand, 'sdd tasks close --branch master --target verifies --compact-json');
+});
+
+test('project status ignores fresh intra-bundle handoff when target runtime stage is already completed', () => {
+  const taskIntent = workflowNextIntent('test', 'run_task_validation', 'sdd test task-T1 --branch master', 'Validate task T1.', null);
+  const nextIntent = resolveProjectStatusNextIntent('master', taskIntent, { finalHealth: 'none' }, {
+    status: 'fresh',
+    latestStageRun: {
+      ...statusStageRun(),
+      id: 'stage-status-goal-verify',
+      stage: 'goal-verify',
+      ownerAgent: 'goal-verify-manager',
+      coMainAgents: ['goal-reviewer'],
+      outputRefs: [{ kind: 'artifact', ref: '.sdd/runs/master/goal-verify/goal-verification-v1.md' }]
+    },
+    latestHandoff: {
+      ...statusHandoff(),
+      id: 'handoff-status-test-goal-verify-completed',
+      fromStage: 'test',
+      toStage: 'goal-verify',
+      fromAgent: 'test-manager',
+      toAgent: 'goal-verify-manager',
+      status: 'proposed'
+    }
+  });
+
+  assert.equal(nextIntent, taskIntent);
+});
 
 test('getProjectStatus resolves configured default SDD branch without silent master fallback', async () => {
   const root = await mkdtemp(path.join(tmpdir(), 'sdd-context-resolver-'));
@@ -119,31 +237,25 @@ test('Phase 6.4 maps slash Git branch names to stable safe partitions', async ()
   }
 });
 
-test('Phase 6.4 marks plan and tasks stale after spec revision hash changes', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-spec-revision-stale-'));
+test('Phase 9.31 ignores legacy based_on metadata for status stale decisions', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-legacy-based-on-ignored-'));
   try {
     await initProject(root);
     const branchDir = path.join(root, 'specs', 'feature');
     await mkdir(branchDir, { recursive: true });
-    const spec = '# Spec\n\nInitial requirement.\n';
-    const planTemplate = '# Plan\n\nbased_on_spec_hash: pending\n\nInitial plan.\n';
-    const specHash = createHash('sha256').update(spec.replace(/\r\n/g, '\n'), 'utf8').digest('hex');
-    const plan = planTemplate.replace('pending', specHash);
-    const planHash = createHash('sha256').update(plan.replace(/\r\n/g, '\n'), 'utf8').digest('hex');
-    await writeFile(path.join(branchDir, 'spec.md'), spec, 'utf8');
-    await writeFile(path.join(branchDir, 'plan.md'), plan, 'utf8');
-    await writeFile(path.join(branchDir, 'tasks.md'), `${validTaskMarkdown('T1', [])}\nbased_on_plan_hash: ${planHash}\n`, 'utf8');
+    await writeFile(path.join(branchDir, 'spec.md'), '# Spec\n\nInitial requirement.\n', 'utf8');
+    await writeFile(path.join(branchDir, 'plan.md'), '# Plan\n\nbased_on_spec_hash: legacy\n\nInitial plan.\n', 'utf8');
+    await writeFile(path.join(branchDir, 'tasks.md'), `${validTaskMarkdown('T1', [])}\nbased_on_plan_hash: legacy\n`, 'utf8');
 
     const fresh = await getProjectStatus(root, { branch: 'feature' });
     await writeFile(path.join(branchDir, 'spec.md'), '# Spec\n\nChanged requirement.\n', 'utf8');
-    const stale = await getProjectStatus(root, { branch: 'feature' });
+    const changed = await getProjectStatus(root, { branch: 'feature' });
 
     assert.equal(fresh.documents.planStale, false);
     assert.equal(fresh.documents.tasksStale, false);
-    assert.equal(stale.documents.planStale, true);
-    assert.equal(stale.documents.tasksStale, true);
-    assert.equal(stale.gaps.some((gap) => gap.field === 'plan.md' && /stale/.test(gap.message)), true);
-    assert.equal(stale.gaps.some((gap) => gap.field === 'tasks.md' && /stale/.test(gap.message)), true);
+    assert.equal(changed.documents.planStale, false);
+    assert.equal(changed.documents.tasksStale, false);
+    assert.equal(changed.gaps.some((gap) => /stale/.test(gap.message)), false);
   } finally {
     await removeTempRoot(root);
   }
@@ -231,6 +343,117 @@ test('statusline exposes context offload and subagent dispatch projections', asy
   }
 });
 
+test('project status exposes workflow gate evidence selection and ignored evidence', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-status-evidence-selection-'));
+  try {
+    await initProject(root);
+    await writeBranchDocs(root, 'master', validTaskMarkdown('T1', []));
+    const run = await createRun(root, { runId: 'run-1', branch: 'master', taskId: 'T1' });
+    const selected = await recordRuntimeArtifactPayload(root, statusPayload(run.runId, 'payload-selected', 'artifacts/validation-T1.md', 'active'));
+    await recordRuntimeArtifactPayload(root, statusPayload(run.runId, 'payload-rejected', 'artifacts/old-validation-T1.md', 'rejected'));
+    await recordRuntimeArtifactPayload(root, statusPayload(run.runId, 'payload-stale', 'artifacts/stale-validation-T1.md', 'stale'));
+    const evidenceSetId = runtimeScopedId('evidence-set', run.runId, selected.payloadId);
+    await createRuntimeEvidenceSet(root, {
+      evidenceSetId,
+      branchSlug: 'master',
+      scopeKind: 'task',
+      scopeId: 'T1',
+      sourceRunId: run.runId,
+      documentContractHashes: {},
+      gateDecisionId: 'gate-status-selection',
+      status: 'accepted',
+      items: [{
+        evidenceSetId,
+        payloadId: selected.payloadId,
+        logicalRef: selected.logicalRef,
+        role: selected.artifactRole,
+        required: true,
+        digestAtSelection: selected.digest
+      }],
+      payload: { selectionReasons: ['selected current validation evidence'] }
+    });
+    await updateRuntimeSelectionPointer(root, {
+      branchSlug: 'master',
+      scopeKind: 'task',
+      scopeId: 'T1',
+      selectedEvidenceSetId: evidenceSetId,
+      selectedAt: '2026-05-31T00:00:00.000Z',
+      selectedByGateDecisionId: 'gate-status-selection',
+      reason: 'latest accepted gate evidence'
+    });
+    await recordRuntimeWorkflowGateDecision(root, statusGateDecision(run.runId, selected, evidenceSetId));
+
+    const status = await getProjectStatus(root, { branch: 'master' });
+
+    assert.equal(status.workflowGateHealth.evidenceSelection.source, 'selection_pointer');
+    assert.equal(status.workflowGateHealth.evidenceSelection.selectionPointerRef, 'selection:task:T1');
+    assert.equal(status.workflowGateHealth.evidenceSelection.acceptedEvidenceSetRef, evidenceSetId);
+    assert.deepEqual(status.workflowGateHealth.evidenceSelection.selectedRefs.map((ref) => ref.logicalRef), ['artifacts/validation-T1.md']);
+    assert.deepEqual(status.workflowGateHealth.evidenceSelection.selectionReasons, ['latest accepted gate evidence', 'selected current validation evidence']);
+    assert.equal(status.workflowGateHealth.evidenceSelection.ignoredCounts.rejected, 1);
+    assert.equal(status.workflowGateHealth.evidenceSelection.ignoredCounts.stale, 1);
+    assert.deepEqual(status.workflowGateHealth.evidenceSelection.ignoredRefs.map((ref) => ref.logicalRef).sort(), ['artifacts/old-validation-T1.md', 'artifacts/stale-validation-T1.md']);
+  } finally {
+    await removeTempRoot(root);
+  }
+});
+
+function statusPayload(runId: string, payloadId: string, logicalRef: string, status: 'active' | 'rejected' | 'stale') {
+  return {
+    payloadId,
+    runId,
+    sourceRunId: runId,
+    branchSlug: 'master',
+    taskId: 'T1',
+    logicalRef,
+    physicalPayloadPath: logicalRef,
+    artifactRole: 'validation',
+    digest: `digest-${payloadId}`,
+    status,
+    payload: {}
+  };
+}
+
+function statusGateDecision(runId: string, selected: Awaited<ReturnType<typeof recordRuntimeArtifactPayload>>, evidenceSetId: string): WorkflowGateDecision {
+  return {
+    decisionId: 'gate-status-selection',
+    inputHash: 'input-hash-status-selection',
+    generatedAt: '2026-05-31T00:01:00.000Z',
+    partition: 'master',
+    taskId: 'T1',
+    runId,
+    decisionKind: 'test',
+    status: 'PASS',
+    decidedBy: 'runtime_policy',
+    hardBlocks: [],
+    warnings: [],
+    advisorSummary: { status: 'none', highConcernCount: 0, mediumConcernCount: 0, invalidCount: 0, lowConfidenceCount: 0, summaries: [] },
+    allowedNextActions: ['continue'],
+    forbiddenNextActions: [],
+    humanRequired: false,
+    reasons: ['runtime_policy produced PASS'],
+    evidenceRefs: [selected.logicalRef],
+    payload: {
+      contract: 'sdd-workflow-gate-runtime-v1',
+      packetId: 'packet-status-selection',
+      workflowScope: { waveRunId: null, taskIds: ['T1'], runIds: [runId], evidenceRefs: [] },
+      evidenceBinding: {
+        contract: 'sdd-gate-evidence-binding-v1',
+        branch: 'master',
+        gate: 'test',
+        selectionPointerRef: 'selection:task:T1',
+        acceptedEvidenceSetRef: evidenceSetId,
+        source: 'selection_pointer',
+        selectedRefs: [{ payloadId: selected.payloadId, logicalRef: selected.logicalRef, digest: selected.digest, status: selected.status }],
+        blockedRefs: [],
+        selectionReasons: ['latest accepted gate evidence', 'selected current validation evidence'],
+        decision: 'pass',
+        reasons: []
+      }
+    }
+  };
+}
+
 function statusStageRun(): StageRun {
   return {
     contract: STAGE_RUN_CONTRACT_VERSION,