sdd-agent-platform 0.4.2 → 0.5.1

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

@@ -1,8 +1,8 @@
-export * from './verification/goal-verify.js';
-export { renderGoalVerifyResult, renderSingleTaskLoopResult } from './verification/rendering.js';
-export type { GoalVerifyResultLike, SingleTaskLoopResultLike } from './verification/rendering.js';
-export * from './verification/single-task-loop.js';
-export * from './verification/verify-contract.js';
-export * from './verification/test-runtime.js';
-export * from './verification/validation-wave.js';
-export * from './verification/review-gate.js';
+export * from './verification/task-evidence-judgment.js';
+export { renderTaskEvidenceJudgmentResult, renderSingleTaskLoopResult } from './verification/rendering.js';
+export type { TaskEvidenceJudgmentResultLike, SingleTaskLoopResultLike } from './verification/rendering.js';
+export * from './verification/single-task-loop.js';
+export * from './verification/verify-contract.js';
+export * from './verification/test-runtime.js';
+export * from './verification/validation-wave.js';
+export * from './verification/review-gate.js';

package/node_modules/@sdd-agent-platform/core/src/work-units/contracts.ts

@@ -1,26 +1,26 @@
-import type { RuntimeRef, RuntimeScope } from '../contracts.js';
-import { WORK_UNIT_CONTRACT_VERSION } from '../contracts.js';
-
-export type WorkUnitType = 'main-agent' | 'co-main-agent' | 'subagent';
-export type WorkUnitStatus = 'pending' | 'running' | 'completed' | 'blocked' | 'failed' | 'cancelled';
-export type WorkUnitAuthority = 'stage-owner' | 'stage-contributor' | 'non-authoritative';
-export type WorkUnitRequiredBefore = 'stage-output' | 'handoff' | 'ship' | 'never';
-
-export interface WorkUnit {
-  contract: typeof WORK_UNIT_CONTRACT_VERSION;
-  id: string;
-  scope: RuntimeScope;
-  stageRunId: string;
-  type: WorkUnitType;
-  name: string;
-  purpose: string;
-  status: WorkUnitStatus;
-  blocking: boolean;
-  authority: WorkUnitAuthority;
-  requiredBefore: WorkUnitRequiredBefore;
-  contextRef: RuntimeRef;
-  outputRefs: RuntimeRef[];
-  evidenceRefs: RuntimeRef[];
-  createdAt: string;
-  completedAt?: string;
-}
+import type { RuntimeRef, RuntimeScope } from '../contracts.js';
+import { WORK_UNIT_CONTRACT_VERSION } from '../contracts.js';
+
+export type WorkUnitType = 'main-agent' | 'co-main-agent' | 'subagent';
+export type WorkUnitStatus = 'pending' | 'running' | 'completed' | 'blocked' | 'failed' | 'cancelled';
+export type WorkUnitAuthority = 'stage-owner' | 'stage-contributor' | 'non-authoritative';
+export type WorkUnitRequiredBefore = 'stage-output' | 'handoff' | 'sync-back' | 'ship' | 'never';
+
+export interface WorkUnit {
+  contract: typeof WORK_UNIT_CONTRACT_VERSION;
+  id: string;
+  scope: RuntimeScope;
+  stageRunId: string;
+  type: WorkUnitType;
+  name: string;
+  purpose: string;
+  status: WorkUnitStatus;
+  blocking: boolean;
+  authority: WorkUnitAuthority;
+  requiredBefore: WorkUnitRequiredBefore;
+  contextRef: RuntimeRef;
+  outputRefs: RuntimeRef[];
+  evidenceRefs: RuntimeRef[];
+  createdAt: string;
+  completedAt?: string;
+}

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

@@ -1,88 +1,88 @@
-import assert from 'node:assert/strict';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import test from 'node:test';
-
-import { WORK_UNIT_CONTRACT_VERSION, type RuntimeRef, type RuntimeScope } from '../contracts.js';
-import { initProject } from '../config/init-project.js';
-import type { WorkUnit } from './contracts.js';
-import { canTransitionWorkUnit, recordWorkUnitProjection, readWorkUnitProjection, transitionWorkUnit, validateWorkUnit, workUnitBlocksGate } from './runtime.js';
-
-const scope: RuntimeScope = { branch: 'master', taskId: 'PHASE8-8', runId: 'run-1' };
-const contextRef: RuntimeRef = { kind: 'projection', ref: 'sdd-context-package:PHASE8-8' };
-const evidenceRef: RuntimeRef = { kind: 'evidence', ref: 'artifacts/phase8-work-unit-validation.md#AC-1' };
-
-test('work unit state machine accepts legal transitions and rejects terminal mutation', () => {
-  const running = transitionWorkUnit(workUnit({ status: 'pending' }), 'running');
-  const completed = transitionWorkUnit(running.workUnit, 'completed', { completedAt: '2026-05-18T00:01:00.000Z' });
-  const reopened = transitionWorkUnit(completed.workUnit, 'running');
-
-  assert.equal(canTransitionWorkUnit('pending', 'running'), true);
-  assert.equal(running.valid, true);
-  assert.equal(completed.valid, true);
-  assert.equal(completed.workUnit.status, 'completed');
-  assert.equal(completed.workUnit.completedAt, '2026-05-18T00:01:00.000Z');
-  assert.equal(canTransitionWorkUnit('completed', 'running'), false);
-  assert.equal(reopened.valid, false);
-  assert.match(reopened.issues[0], /Illegal work unit transition/);
-});
-
-test('work unit validation enforces lifecycle authority and blocking gates', () => {
-  const subagentOwner = validateWorkUnit(workUnit({ type: 'subagent', authority: 'stage-owner', blocking: true, requiredBefore: 'handoff' }));
-  const coMainOwner = validateWorkUnit(workUnit({ type: 'co-main-agent', authority: 'stage-owner', blocking: true, requiredBefore: 'handoff' }));
-  const nonBlockingGate = validateWorkUnit(workUnit({ blocking: false, requiredBefore: 'handoff' }));
-  const blockingWithoutGate = validateWorkUnit(workUnit({ blocking: true, requiredBefore: 'never' }));
-
-  assert.equal(subagentOwner.valid, false);
-  assert.equal(subagentOwner.issues.some((issue) => /Subagent work units must be non-authoritative/.test(issue)), true);
-  assert.equal(coMainOwner.valid, false);
-  assert.equal(coMainOwner.issues.some((issue) => /Only main-agent work units/.test(issue)), true);
-  assert.equal(nonBlockingGate.valid, false);
-  assert.equal(blockingWithoutGate.valid, false);
-});
-
-test('work unit blocking gate semantics distinguish blocking and non-blocking work', () => {
-  assert.equal(workUnitBlocksGate(workUnit({ blocking: true, requiredBefore: 'handoff', status: 'running' }), 'handoff'), true);
-  assert.equal(workUnitBlocksGate(workUnit({ blocking: true, requiredBefore: 'handoff', status: 'completed' }), 'handoff'), false);
-  assert.equal(workUnitBlocksGate(workUnit({ blocking: false, requiredBefore: 'never', status: 'running' }), 'handoff'), false);
-});
-
-test('work unit projections can be written and read', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-work-unit-runtime-'));
-  try {
-    await initProject(root);
-    const unit = workUnit({ status: 'running', blocking: true, requiredBefore: 'handoff' });
-
-    const write = await recordWorkUnitProjection(root, unit);
-    const restored = await readWorkUnitProjection(root, scope, unit.id);
-
-    assert.equal(write.status, 'created');
-    assert.equal(restored?.payload.id, unit.id);
-    assert.equal(restored?.payload.status, 'running');
-    assert.equal(restored?.payload.requiredBefore, 'handoff');
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-function workUnit(overrides: Partial<WorkUnit> = {}): WorkUnit {
-  return {
-    contract: WORK_UNIT_CONTRACT_VERSION,
-    id: 'wu-phase8-8',
-    scope,
-    stageRunId: 'stage-do',
-    type: 'main-agent',
-    name: 'implement phase8 runtime',
-    purpose: 'Record bounded runtime work without transferring lifecycle ownership.',
-    status: 'pending',
-    blocking: true,
-    authority: 'stage-owner',
-    requiredBefore: 'stage-output',
-    contextRef,
-    outputRefs: [],
-    evidenceRefs: [evidenceRef],
-    createdAt: '2026-05-18T00:00:00.000Z',
-    ...overrides
-  };
-}
+import assert from 'node:assert/strict';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import { WORK_UNIT_CONTRACT_VERSION, type RuntimeRef, type RuntimeScope } from '../contracts.js';
+import { initProject } from '../config/init-project.js';
+import type { WorkUnit } from './contracts.js';
+import { canTransitionWorkUnit, recordWorkUnitProjection, readWorkUnitProjection, transitionWorkUnit, validateWorkUnit, workUnitBlocksGate } from './runtime.js';
+
+const scope: RuntimeScope = { branch: 'master', taskId: 'PHASE8-8', runId: 'run-1' };
+const contextRef: RuntimeRef = { kind: 'projection', ref: 'sdd-context-package:PHASE8-8' };
+const evidenceRef: RuntimeRef = { kind: 'evidence', ref: 'artifacts/phase8-work-unit-validation.md#AC-1' };
+
+test('work unit state machine accepts legal transitions and rejects terminal mutation', () => {
+  const running = transitionWorkUnit(workUnit({ status: 'pending' }), 'running');
+  const completed = transitionWorkUnit(running.workUnit, 'completed', { completedAt: '2026-05-18T00:01:00.000Z' });
+  const reopened = transitionWorkUnit(completed.workUnit, 'running');
+
+  assert.equal(canTransitionWorkUnit('pending', 'running'), true);
+  assert.equal(running.valid, true);
+  assert.equal(completed.valid, true);
+  assert.equal(completed.workUnit.status, 'completed');
+  assert.equal(completed.workUnit.completedAt, '2026-05-18T00:01:00.000Z');
+  assert.equal(canTransitionWorkUnit('completed', 'running'), false);
+  assert.equal(reopened.valid, false);
+  assert.match(reopened.issues[0], /Illegal work unit transition/);
+});
+
+test('work unit validation enforces lifecycle authority and blocking gates', () => {
+  const subagentOwner = validateWorkUnit(workUnit({ type: 'subagent', authority: 'stage-owner', blocking: true, requiredBefore: 'handoff' }));
+  const coMainOwner = validateWorkUnit(workUnit({ type: 'co-main-agent', authority: 'stage-owner', blocking: true, requiredBefore: 'handoff' }));
+  const nonBlockingGate = validateWorkUnit(workUnit({ blocking: false, requiredBefore: 'handoff' }));
+  const blockingWithoutGate = validateWorkUnit(workUnit({ blocking: true, requiredBefore: 'never' }));
+
+  assert.equal(subagentOwner.valid, false);
+  assert.equal(subagentOwner.issues.some((issue) => /Subagent work units must be non-authoritative/.test(issue)), true);
+  assert.equal(coMainOwner.valid, false);
+  assert.equal(coMainOwner.issues.some((issue) => /Only main-agent work units/.test(issue)), true);
+  assert.equal(nonBlockingGate.valid, false);
+  assert.equal(blockingWithoutGate.valid, false);
+});
+
+test('work unit blocking gate semantics distinguish blocking and non-blocking work', () => {
+  assert.equal(workUnitBlocksGate(workUnit({ blocking: true, requiredBefore: 'handoff', status: 'running' }), 'handoff'), true);
+  assert.equal(workUnitBlocksGate(workUnit({ blocking: true, requiredBefore: 'handoff', status: 'completed' }), 'handoff'), false);
+  assert.equal(workUnitBlocksGate(workUnit({ blocking: false, requiredBefore: 'never', status: 'running' }), 'handoff'), false);
+});
+
+test('work unit projections can be written and read', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-work-unit-runtime-'));
+  try {
+    await initProject(root);
+    const unit = workUnit({ status: 'running', blocking: true, requiredBefore: 'handoff' });
+
+    const write = await recordWorkUnitProjection(root, unit);
+    const restored = await readWorkUnitProjection(root, scope, unit.id);
+
+    assert.equal(write.status, 'created');
+    assert.equal(restored?.payload.id, unit.id);
+    assert.equal(restored?.payload.status, 'running');
+    assert.equal(restored?.payload.requiredBefore, 'handoff');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+function workUnit(overrides: Partial<WorkUnit> = {}): WorkUnit {
+  return {
+    contract: WORK_UNIT_CONTRACT_VERSION,
+    id: 'wu-phase8-8',
+    scope,
+    stageRunId: 'stage-do',
+    type: 'main-agent',
+    name: 'implement phase8 runtime',
+    purpose: 'Record bounded runtime work without transferring lifecycle ownership.',
+    status: 'pending',
+    blocking: true,
+    authority: 'stage-owner',
+    requiredBefore: 'stage-output',
+    contextRef,
+    outputRefs: [],
+    evidenceRefs: [evidenceRef],
+    createdAt: '2026-05-18T00:00:00.000Z',
+    ...overrides
+  };
+}

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

@@ -1,112 +1,112 @@
-import { createHash } from 'node:crypto';
-
-import type { RuntimeProjectionEnvelope, RuntimeScope } from '../contracts.js';
-import { readRuntimeProjectionEnvelope, recordRuntimeProjectionEnvelope, type RuntimeProjectionEnvelopeWriteResult } from '../storage/runtime-store.js';
-import type { WorkUnit, WorkUnitStatus } from './contracts.js';
-
-export const WORK_UNIT_RUNTIME_PRODUCER_VERSION = 'phase8-work-unit-runtime-v1';
-export const WORK_UNIT_PROJECTION_TYPE = 'phase8_work_unit';
-
-const WORK_UNIT_TRANSITIONS: Record<WorkUnitStatus, readonly WorkUnitStatus[]> = {
-  pending: ['running', 'blocked', 'cancelled'],
-  running: ['completed', 'blocked', 'failed', 'cancelled'],
-  blocked: ['running', 'cancelled'],
-  completed: [],
-  failed: [],
-  cancelled: []
-};
-
-export interface WorkUnitValidationResult {
-  valid: boolean;
-  issues: string[];
-}
-
-export interface WorkUnitTransitionResult extends WorkUnitValidationResult {
-  workUnit: WorkUnit;
-}
-
-export function canTransitionWorkUnit(from: WorkUnitStatus, to: WorkUnitStatus): boolean {
-  return WORK_UNIT_TRANSITIONS[from].includes(to);
-}
-
-export function transitionWorkUnit(workUnit: WorkUnit, status: WorkUnitStatus, options: { completedAt?: string } = {}): WorkUnitTransitionResult {
-  if (!canTransitionWorkUnit(workUnit.status, status)) {
-    return {
-      valid: false,
-      issues: [`Illegal work unit transition ${workUnit.status} -> ${status} for ${workUnit.id}.`],
-      workUnit
-    };
-  }
-  const next: WorkUnit = {
-    ...workUnit,
-    status,
-    completedAt: status === 'completed' || status === 'failed' || status === 'cancelled' ? options.completedAt ?? new Date().toISOString() : workUnit.completedAt
-  };
-  return { valid: validateWorkUnit(next).valid, issues: validateWorkUnit(next).issues, workUnit: next };
-}
-
-export function validateWorkUnit(workUnit: WorkUnit): WorkUnitValidationResult {
-  const issues: string[] = [];
-  if (workUnit.type === 'subagent' && workUnit.authority !== 'non-authoritative') {
-    issues.push('Subagent work units must be non-authoritative.');
-  }
-  if (workUnit.authority === 'stage-owner' && workUnit.type !== 'main-agent') {
-    issues.push('Only main-agent work units can own a lifecycle stage.');
-  }
-  if (!workUnit.blocking && workUnit.requiredBefore !== 'never') {
-    issues.push('Non-blocking work units cannot declare a required-before gate.');
-  }
-  if (workUnit.blocking && workUnit.requiredBefore === 'never') {
-    issues.push('Blocking work units must declare the gate they block.');
-  }
-  return { valid: issues.length === 0, issues };
-}
-
-export function workUnitBlocksGate(workUnit: WorkUnit, gate: WorkUnit['requiredBefore']): boolean {
-  return workUnit.blocking && workUnit.requiredBefore === gate && workUnit.status !== 'completed';
-}
-
-export function workUnitScopeKey(scope: RuntimeScope, workUnitId: string): string {
-  return [scope.branch, scope.taskId ?? 'all', scope.runId ?? 'none', scope.changeRef ?? 'none', workUnitId].join(':');
-}
-
-export async function recordWorkUnitProjection(projectRoot: string, workUnit: WorkUnit): Promise<RuntimeProjectionEnvelopeWriteResult<WorkUnit>> {
-  return recordRuntimeProjectionEnvelope(projectRoot, {
-    projectionType: WORK_UNIT_PROJECTION_TYPE,
-    scopeKey: workUnitScopeKey(workUnit.scope, workUnit.id),
-    inputHash: workUnitInputHash(workUnit),
-    producer: 'phase8-work-unit-runtime',
-    producerVersion: WORK_UNIT_RUNTIME_PRODUCER_VERSION,
-    generatedAt: workUnit.completedAt ?? workUnit.createdAt,
-    payload: workUnit
-  });
-}
-
-export async function readWorkUnitProjection(projectRoot: string, scope: RuntimeScope, workUnitId: string): Promise<RuntimeProjectionEnvelope<WorkUnit> | null> {
-  return readRuntimeProjectionEnvelope(projectRoot, WORK_UNIT_PROJECTION_TYPE, workUnitScopeKey(scope, workUnitId));
-}
-
-function workUnitInputHash(workUnit: WorkUnit): string {
-  return stableHash(JSON.stringify({
-    contract: workUnit.contract,
-    id: workUnit.id,
-    scope: workUnit.scope,
-    stageRunId: workUnit.stageRunId,
-    type: workUnit.type,
-    name: workUnit.name,
-    purpose: workUnit.purpose,
-    status: workUnit.status,
-    blocking: workUnit.blocking,
-    authority: workUnit.authority,
-    requiredBefore: workUnit.requiredBefore,
-    contextRef: workUnit.contextRef,
-    outputRefs: workUnit.outputRefs,
-    evidenceRefs: workUnit.evidenceRefs,
-    createdAt: workUnit.createdAt,
-    completedAt: workUnit.completedAt ?? null
-  }));
-}
-
-function stableHash(value: string): string {
-  return createHash('sha256').update(value, 'utf8').digest('hex');
-}
+import { createHash } from 'node:crypto';
+
+import type { RuntimeProjectionEnvelope, RuntimeScope } from '../contracts.js';
+import { readRuntimeProjectionEnvelope, recordRuntimeProjectionEnvelope, type RuntimeProjectionEnvelopeWriteResult } from '../storage/runtime-store.js';
+import type { WorkUnit, WorkUnitStatus } from './contracts.js';
+
+export const WORK_UNIT_RUNTIME_PRODUCER_VERSION = 'phase8-work-unit-runtime-v1';
+export const WORK_UNIT_PROJECTION_TYPE = 'phase8_work_unit';
+
+const WORK_UNIT_TRANSITIONS: Record<WorkUnitStatus, readonly WorkUnitStatus[]> = {
+  pending: ['running', 'blocked', 'cancelled'],
+  running: ['completed', 'blocked', 'failed', 'cancelled'],
+  blocked: ['running', 'cancelled'],
+  completed: [],
+  failed: [],
+  cancelled: []
+};
+
+export interface WorkUnitValidationResult {
+  valid: boolean;
+  issues: string[];
+}
+
+export interface WorkUnitTransitionResult extends WorkUnitValidationResult {
+  workUnit: WorkUnit;
+}
+
+export function canTransitionWorkUnit(from: WorkUnitStatus, to: WorkUnitStatus): boolean {
+  return WORK_UNIT_TRANSITIONS[from].includes(to);
+}
+
+export function transitionWorkUnit(workUnit: WorkUnit, status: WorkUnitStatus, options: { completedAt?: string } = {}): WorkUnitTransitionResult {
+  if (!canTransitionWorkUnit(workUnit.status, status)) {
+    return {
+      valid: false,
+      issues: [`Illegal work unit transition ${workUnit.status} -> ${status} for ${workUnit.id}.`],
+      workUnit
+    };
+  }
+  const next: WorkUnit = {
+    ...workUnit,
+    status,
+    completedAt: status === 'completed' || status === 'failed' || status === 'cancelled' ? options.completedAt ?? new Date().toISOString() : workUnit.completedAt
+  };
+  return { valid: validateWorkUnit(next).valid, issues: validateWorkUnit(next).issues, workUnit: next };
+}
+
+export function validateWorkUnit(workUnit: WorkUnit): WorkUnitValidationResult {
+  const issues: string[] = [];
+  if (workUnit.type === 'subagent' && workUnit.authority !== 'non-authoritative') {
+    issues.push('Subagent work units must be non-authoritative.');
+  }
+  if (workUnit.authority === 'stage-owner' && workUnit.type !== 'main-agent') {
+    issues.push('Only main-agent work units can own a lifecycle stage.');
+  }
+  if (!workUnit.blocking && workUnit.requiredBefore !== 'never') {
+    issues.push('Non-blocking work units cannot declare a required-before gate.');
+  }
+  if (workUnit.blocking && workUnit.requiredBefore === 'never') {
+    issues.push('Blocking work units must declare the gate they block.');
+  }
+  return { valid: issues.length === 0, issues };
+}
+
+export function workUnitBlocksGate(workUnit: WorkUnit, gate: WorkUnit['requiredBefore']): boolean {
+  return workUnit.blocking && workUnit.requiredBefore === gate && workUnit.status !== 'completed';
+}
+
+export function workUnitScopeKey(scope: RuntimeScope, workUnitId: string): string {
+  return [scope.branch, scope.taskId ?? 'all', scope.runId ?? 'none', scope.changeRef ?? 'none', workUnitId].join(':');
+}
+
+export async function recordWorkUnitProjection(projectRoot: string, workUnit: WorkUnit): Promise<RuntimeProjectionEnvelopeWriteResult<WorkUnit>> {
+  return recordRuntimeProjectionEnvelope(projectRoot, {
+    projectionType: WORK_UNIT_PROJECTION_TYPE,
+    scopeKey: workUnitScopeKey(workUnit.scope, workUnit.id),
+    inputHash: workUnitInputHash(workUnit),
+    producer: 'phase8-work-unit-runtime',
+    producerVersion: WORK_UNIT_RUNTIME_PRODUCER_VERSION,
+    generatedAt: workUnit.completedAt ?? workUnit.createdAt,
+    payload: workUnit
+  });
+}
+
+export async function readWorkUnitProjection(projectRoot: string, scope: RuntimeScope, workUnitId: string): Promise<RuntimeProjectionEnvelope<WorkUnit> | null> {
+  return readRuntimeProjectionEnvelope(projectRoot, WORK_UNIT_PROJECTION_TYPE, workUnitScopeKey(scope, workUnitId));
+}
+
+function workUnitInputHash(workUnit: WorkUnit): string {
+  return stableHash(JSON.stringify({
+    contract: workUnit.contract,
+    id: workUnit.id,
+    scope: workUnit.scope,
+    stageRunId: workUnit.stageRunId,
+    type: workUnit.type,
+    name: workUnit.name,
+    purpose: workUnit.purpose,
+    status: workUnit.status,
+    blocking: workUnit.blocking,
+    authority: workUnit.authority,
+    requiredBefore: workUnit.requiredBefore,
+    contextRef: workUnit.contextRef,
+    outputRefs: workUnit.outputRefs,
+    evidenceRefs: workUnit.evidenceRefs,
+    createdAt: workUnit.createdAt,
+    completedAt: workUnit.completedAt ?? null
+  }));
+}
+
+function stableHash(value: string): string {
+  return createHash('sha256').update(value, 'utf8').digest('hex');
+}

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

@@ -1,2 +1,2 @@
-export * from './work-units/contracts.js';
-export * from './work-units/runtime.js';
+export * from './work-units/contracts.js';
+export * from './work-units/runtime.js';