@moretea-labs/forge 1.7.0 → 1.7.1

package/src/runtime/control-plane/execution/retained-work-resume.ts

@@ -0,0 +1,203 @@
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+import type { RepositoryRecord } from '../../../cli/repositories/types';
+import { listRepositories, selectRepositoryCheckout } from '../../../cli/repositories/registry';
+import { repositoryGitStatus } from '../../../cli/repositories/structured-git';
+import { ensureManagedWorkspace } from '../../execution/managed-workspace';
+import { getControllerSession } from '../facade/controller-session-store';
+import { getWorkContract, resumeRetainedCancelledWorkContract, updateWorkContract } from '../facade/work-contract-store';
+import { gitCommitAtRef, gitWorktreeSnapshot } from './work-lifecycle-audit';
+import { readWorkHandle, writeWorkHandle } from './work-handle-store';
+
+export interface RetainedWorkResumeIdentity {
+  principalId: string;
+  sessionId: string;
+  controllerInstanceId: string;
+}
+
+export interface ReauthorizeRetainedCancelledWorkInput {
+  controllerHome: string;
+  repository: RepositoryRecord;
+  workId: string;
+  identity: RetainedWorkResumeIdentity;
+  requestedBy?: string;
+  approvalConfirmed?: boolean;
+  prepareDependencies?: boolean;
+}
+
+/**
+ * Canonical orchestration authority for explicitly re-authorizing the exact
+ * retained cancelled repository Work. Transport adapters provide authenticated
+ * identity and typed user intent only; they must not duplicate these lifecycle,
+ * ownership, zero-delta, or reconstruction rules.
+ */
+export function reauthorizeRetainedCancelledRepositoryWork(
+  input: ReauthorizeRetainedCancelledWorkInput,
+): { reconstructedCheckout: boolean } {
+  const { controllerHome, repository, workId, identity } = input;
+  const store = { controllerHome, repoId: repository.repoId };
+  let work = getWorkContract(store, workId);
+  if (!work || work.status !== 'cancelled') return { reconstructedCheckout: false };
+  if (input.approvalConfirmed !== true || input.requestedBy !== 'user') {
+    throw new Error(`WORK_CANCELLED_RESUME_REAUTHORIZATION_REQUIRED: ${workId}; use exact work_id with requested_by=user and approval_confirmed=true`);
+  }
+  if (!work.principalId?.trim() || work.principalId.trim() !== identity.principalId) {
+    throw new Error(`WORK_CANCELLED_RESUME_PRINCIPAL_MISMATCH: ${workId}`);
+  }
+  const owner = getControllerSession(store, workId);
+  if (owner && (owner.principalId?.trim() || owner.controllerId) !== identity.principalId) {
+    throw new Error(`WORK_CANCELLED_RESUME_CONTROLLER_OWNERSHIP_MISMATCH: ${workId}`);
+  }
+  if (work.completionReceipt || work.completionOutcome) throw new Error(`WORK_CANCELLED_RESUME_COMPLETION_CONFLICT: ${workId}`);
+  if (work.reconciliations.length > 0) throw new Error(`WORK_CANCELLED_RESUME_DELIVERY_HISTORY_AMBIGUOUS: ${workId}`);
+  if (work.phase !== 'cleanup' || work.phaseEvidence.cleanup.state !== 'skipped' || work.phaseEvidence.cleanup.source !== 'recorded') {
+    throw new Error(`WORK_CANCELLED_RESUME_HISTORY_AMBIGUOUS: ${workId}`);
+  }
+  if (work.workKind !== 'repository_change' || work.worktreePolicy.required !== true) {
+    throw new Error(`WORK_CANCELLED_RESUME_ISOLATED_REPOSITORY_WORK_REQUIRED: ${workId}`);
+  }
+
+  let handle = readWorkHandle(controllerHome, repository.repoId, workId);
+  if (handle) {
+    if (handle.repositoryId !== repository.repoId || (handle.workContractId && handle.workContractId !== workId)) {
+      throw new Error(`WORK_CANCELLED_RESUME_HANDLE_IDENTITY_MISMATCH: ${workId}`);
+    }
+    if (handle.principalId !== identity.principalId) throw new Error(`WORK_CANCELLED_RESUME_HANDLE_PRINCIPAL_MISMATCH: ${workId}`);
+    if (['committed', 'merged', 'cleaned', 'failed_terminal_cleanup'].includes(handle.state)
+      || handle.finalization.commit === 'done'
+      || handle.finalization.merge === 'done'
+      || handle.cleanupReceipt?.complete === true) {
+      throw new Error(`WORK_CANCELLED_RESUME_DELIVERY_OR_CLEANUP_CONFLICT: ${workId}`);
+    }
+  }
+
+  const registryRepository = listRepositories(controllerHome, { includeRemoved: true })
+    .find((candidate) => candidate.repoId === repository.repoId);
+  if (!registryRepository) throw new Error(`WORK_CANCELLED_RESUME_REPOSITORY_MISSING: ${workId}`);
+  const recordedCheckoutId = work.checkoutId?.trim();
+  const recordedWorktree = work.worktreeRef?.trim();
+  const checkoutRecord = recordedCheckoutId
+    ? registryRepository.checkouts.find((candidate) => candidate.checkoutId === recordedCheckoutId)
+    : undefined;
+  const checkoutActive = checkoutRecord?.lifecycle === 'active';
+  const worktreePresent = Boolean(recordedWorktree && existsSync(recordedWorktree));
+
+  if (checkoutActive && worktreePresent && recordedCheckoutId && recordedWorktree) {
+    const retained = selectRepositoryCheckout(registryRepository, recordedCheckoutId);
+    if (resolve(retained.canonicalRoot) !== resolve(recordedWorktree)) {
+      throw new Error(`WORK_CANCELLED_RESUME_CHECKOUT_REUSED: ${workId}`);
+    }
+    if (!handle) throw new Error(`WORK_CANCELLED_RESUME_HANDLE_REQUIRED: ${workId}`);
+    if (handle.checkoutId !== recordedCheckoutId || resolve(handle.worktreePath) !== resolve(recordedWorktree)) {
+      throw new Error(`WORK_CANCELLED_RESUME_CHECKOUT_OWNERSHIP_MISMATCH: ${workId}`);
+    }
+    const status = repositoryGitStatus(retained);
+    if (!status.branch || status.branch !== handle.branch) throw new Error(`WORK_CANCELLED_RESUME_BRANCH_OWNERSHIP_MISMATCH: ${workId}`);
+    writeWorkHandle(controllerHome, {
+      ...handle,
+      principalId: identity.principalId,
+      sessionId: identity.sessionId,
+      updatedAt: new Date().toISOString(),
+    });
+    resumeRetainedCancelledWorkContract(store, workId, {
+      principalId: identity.principalId,
+      controllerInstanceId: identity.controllerInstanceId,
+      summary: 'Explicit current user re-authorized the same retained cancelled Work; exact managed checkout ownership was revalidated.',
+    });
+    return { reconstructedCheckout: false };
+  }
+
+  if (checkoutActive) throw new Error(`WORK_CANCELLED_RESUME_PRESERVATION_AMBIGUOUS: ${workId}`);
+  if (!recordedCheckoutId || !recordedWorktree || !handle) throw new Error(`WORK_CANCELLED_RESUME_HANDLE_REQUIRED: ${workId}`);
+
+  const actualChangedPaths = work.scopeEvidence?.actualChangedPaths;
+  if (!actualChangedPaths || actualChangedPaths.length !== 0
+    || work.checks.length !== 0
+    || work.checkRefs.length !== 0
+    || work.evidenceState !== 'none') {
+    throw new Error(`WORK_CANCELLED_RESUME_ZERO_DELTA_PROOF_REQUIRED: ${workId}`);
+  }
+  const recordedBase = work.baseRevision?.trim();
+  if (!recordedBase) throw new Error(`WORK_CANCELLED_RESUME_BASE_REVISION_REQUIRED: ${workId}`);
+  const baseRevision = gitCommitAtRef(repository.canonicalRoot, recordedBase);
+  if (!baseRevision) throw new Error(`WORK_CANCELLED_RESUME_BASE_REVISION_MISSING: ${workId}`);
+  const handleBase = handle.baseCommit ? gitCommitAtRef(repository.canonicalRoot, handle.baseCommit) : undefined;
+  const handleHead = handle.expectedHead ? gitCommitAtRef(repository.canonicalRoot, handle.expectedHead) : undefined;
+  if ((handle.baseCommit && handleBase !== baseRevision) || (handle.expectedHead && handleHead !== baseRevision)) {
+    throw new Error(`WORK_CANCELLED_RESUME_REVISION_AMBIGUOUS: ${workId}`);
+  }
+  if (handle.checkoutId !== recordedCheckoutId || resolve(handle.worktreePath) !== resolve(recordedWorktree)) {
+    throw new Error(`WORK_CANCELLED_RESUME_CHECKOUT_OWNERSHIP_MISMATCH: ${workId}`);
+  }
+  if (handle.branch) {
+    const historicalBranchHead = gitCommitAtRef(repository.canonicalRoot, `refs/heads/${handle.branch}`);
+    if (historicalBranchHead && historicalBranchHead !== baseRevision) {
+      throw new Error(`WORK_CANCELLED_RESUME_UNIQUE_COMMIT_CONFLICT: ${workId}`);
+    }
+  }
+  if (worktreePresent) {
+    const retainedSnapshot = gitWorktreeSnapshot(recordedWorktree);
+    if (!retainedSnapshot || !retainedSnapshot.clean || retainedSnapshot.head !== baseRevision || (handle.branch && retainedSnapshot.branch !== handle.branch)) {
+      throw new Error(`WORK_CANCELLED_RESUME_ZERO_DELTA_PHYSICAL_CONFLICT: ${workId}`);
+    }
+  }
+
+  const branchName = `work/resume-${workId.replace(/[^A-Za-z0-9._-]+/g, '-').slice(0, 42)}-${baseRevision.slice(0, 12)}`;
+  const existingResumeBranch = gitCommitAtRef(repository.canonicalRoot, `refs/heads/${branchName}`);
+  if (existingResumeBranch && existingResumeBranch !== baseRevision) {
+    throw new Error(`WORK_CANCELLED_RESUME_RECONSTRUCTION_BRANCH_CONFLICT: ${workId}`);
+  }
+  const workspace = ensureManagedWorkspace(controllerHome, repository, {
+    requestId: `${workId}:explicit-user-resume:${baseRevision}`,
+    title: `${work.objective} explicit user resume`,
+    branchName,
+    baseRef: baseRevision,
+    prepareDependencies: input.prepareDependencies === true,
+  });
+  if (!workspace.managed || !workspace.checkoutId || !workspace.root || !workspace.branch) {
+    throw new Error(`WORK_CANCELLED_RESUME_RECONSTRUCTION_FAILED: ${workId}`);
+  }
+  const refreshedRepository = listRepositories(controllerHome, { includeRemoved: true })
+    .find((candidate) => candidate.repoId === repository.repoId);
+  if (!refreshedRepository) throw new Error(`WORK_CANCELLED_RESUME_REPOSITORY_MISSING: ${workId}`);
+  const reconstructed = selectRepositoryCheckout(refreshedRepository, workspace.checkoutId);
+  const reconstructedStatus = repositoryGitStatus(reconstructed);
+  if (!reconstructedStatus.clean || reconstructedStatus.head !== baseRevision || reconstructedStatus.branch !== workspace.branch) {
+    throw new Error(`WORK_CANCELLED_RESUME_RECONSTRUCTION_REVISION_MISMATCH: ${workId}`);
+  }
+
+  work = updateWorkContract(store, workId, {
+    checkoutId: workspace.checkoutId,
+    worktreeRef: workspace.root,
+    baseRevision,
+    controllerInstanceId: identity.controllerInstanceId,
+  });
+  const now = new Date().toISOString();
+  handle = writeWorkHandle(controllerHome, {
+    ...handle,
+    principalId: identity.principalId,
+    sessionId: identity.sessionId,
+    checkoutId: workspace.checkoutId,
+    worktreePath: workspace.root,
+    branch: workspace.branch,
+    sourceCheckoutId: repository.activeCheckoutId,
+    managedWorktree: true,
+    baseCommit: baseRevision,
+    deliveryBaseCommit: baseRevision,
+    expectedHead: baseRevision,
+    state: 'prepared',
+    validatedInputFingerprint: undefined,
+    failureReason: undefined,
+    cleanupReceipt: undefined,
+    finalization: { validation: 'pending', commit: 'pending', merge: 'pending', branchCleanup: 'pending', worktreeCleanup: 'pending' },
+    updatedAt: now,
+  });
+  resumeRetainedCancelledWorkContract(store, workId, {
+    principalId: identity.principalId,
+    controllerInstanceId: identity.controllerInstanceId,
+    summary: 'Explicit current user re-authorized the same cancelled Work; prior managed checkout was absent and a fresh isolated checkout was reconstructed at the exact zero-delta base revision.',
+    checkoutId: workspace.checkoutId,
+    worktreeRef: workspace.root,
+  });
+  return { reconstructedCheckout: true };
+}

package/src/runtime/control-plane/execution/work-completion-authority.ts

@@ -0,0 +1,58 @@
+import { completeRequirementFromWork } from '../persistence/requirement-store';
+import {
+  appendWorkEvidence,
+  recordWorkCompletionReceipt,
+  type WorkContractStoreOptions,
+} from '../facade/work-contract-store';
+import type { WorkContract, WorkKind } from '../facade/types';
+
+export interface WorkRequirementProjectionResult {
+  attempted: boolean;
+  ok: boolean;
+  warning?: string;
+}
+
+/**
+ * Project one already-terminal Work receipt into Requirement semantic review.
+ * Work completion remains authoritative; Requirement projection is downstream
+ * and must never turn a durable completion receipt back into a failed Work.
+ */
+export function projectRequirementDeliveryFromCompletedWork(
+  options: WorkContractStoreOptions,
+  work: WorkContract,
+): WorkRequirementProjectionResult {
+  if (!work.requirementId || !options.controllerHome) return { attempted: false, ok: true };
+  try {
+    completeRequirementFromWork(
+      { controllerHome: options.controllerHome },
+      { requirementId: work.requirementId, work },
+    );
+    return { attempted: true, ok: true };
+  } catch (error) {
+    const warning = `Work completion remains authoritative; Requirement projection could not be applied: ${error instanceof Error ? error.message : String(error)}`.slice(0, 2_000);
+    try {
+      appendWorkEvidence(options, work.workId, {
+        title: 'requirement completion projection pending',
+        summary: warning,
+        detailLevel: 'summary',
+      });
+    } catch {
+      // The completion receipt is already canonical and durable. Diagnostic
+      // persistence is downstream and cannot invalidate terminal Work state.
+    }
+    return { attempted: true, ok: false, warning };
+  }
+}
+
+/** Record the canonical Work completion fact, then update downstream Requirement review state. */
+export function completeWorkWithReceipt(
+  options: WorkContractStoreOptions,
+  workId: string,
+  receipt: NonNullable<WorkContract['completionReceipt']>,
+  completionOutcome: NonNullable<WorkContract['completionOutcome']>,
+  completionWorkKind?: WorkKind,
+): WorkContract {
+  const recorded = recordWorkCompletionReceipt(options, workId, receipt, completionOutcome, completionWorkKind);
+  projectRequirementDeliveryFromCompletedWork(options, recorded);
+  return recorded;
+}

package/src/runtime/control-plane/execution/work-evidence-policy.ts

@@ -0,0 +1,200 @@
+import { reconcileVerificationHistory } from '../facade/check-normalization';
+import type { VerificationRecord, WorkContract } from '../facade/types';
+
+type ReconciledVerificationHistory = ReturnType<typeof reconcileVerificationHistory>;
+
+export interface WorkCompletionEvidenceEvaluation {
+  status: 'complete' | 'failed' | 'incomplete';
+  history: ReconciledVerificationHistory;
+  missingChecks: string[];
+  durableResultEvidence: boolean;
+  semanticAcceptanceComplete: boolean;
+  missingSemanticAcceptanceCriteria: string[];
+  reasons: string[];
+}
+
+export function verificationRecordAppliesToCurrentWorkspace(
+  record: VerificationRecord,
+  currentRevision?: string,
+  currentWorkspaceFingerprint?: string,
+): boolean {
+  if (currentRevision && record.sourceRevision && record.sourceRevision !== currentRevision) return false;
+  if (
+    currentWorkspaceFingerprint
+    && record.workspaceFingerprint
+    && record.workspaceFingerprint !== currentWorkspaceFingerprint
+  ) return false;
+  return true;
+}
+
+function isAuthoritativeCurrentWorkVerification(
+  work: WorkContract,
+  record: VerificationRecord,
+  currentRevision?: string,
+): boolean {
+  const receipt = record.receipt;
+  return Boolean(
+    currentRevision
+    && record.outcome === 'valid_pass'
+    && record.sourceRevision === currentRevision
+    && receipt
+    && receipt.repoId === work.repoId
+    && receipt.workId === work.workId
+    && receipt.checkId === record.checkId
+    && receipt.ok === true
+    && receipt.timedOut === false
+    && receipt.cancelled === false,
+  );
+}
+
+export interface WorkImplementationEvidenceEvaluation {
+  status: 'complete' | 'incomplete';
+  changedPaths: string[];
+  reasons: string[];
+}
+
+export function evaluateWorkImplementationEvidence(
+  work: WorkContract,
+  currentWorkspaceChangedPaths: readonly string[] = [],
+): WorkImplementationEvidenceEvaluation {
+  if (work.workKind !== 'repository_change') {
+    return { status: 'complete', changedPaths: [], reasons: [] };
+  }
+
+  const changedPaths = [...new Set(currentWorkspaceChangedPaths.map((path) => path.trim()).filter(Boolean))].sort();
+  if (changedPaths.length > 0) {
+    return { status: 'complete', changedPaths, reasons: [] };
+  }
+
+  return {
+    status: 'incomplete',
+    changedPaths: [],
+    reasons: ['Repository-change Work has no current net source changes relative to its base revision. Verification evidence cannot substitute for implementation evidence.'],
+  };
+}
+
+export function evaluateReadOnlyReviewSourceIdentity(
+  work: WorkContract,
+  currentRevision?: string,
+  currentWorkspaceChangedPaths?: readonly string[],
+): { status: 'complete' | 'incomplete'; reasons: string[] } {
+  if (work.workKind !== 'read_only_review') return { status: 'complete', reasons: [] };
+  const reasons: string[] = [];
+  if (!work.baseRevision?.trim()) reasons.push('Read-only review has no frozen base revision.');
+  if (!currentRevision?.trim()) reasons.push('Current source revision is unavailable, so unchanged-source proof is incomplete.');
+  if (work.baseRevision && currentRevision && work.baseRevision !== currentRevision) {
+    reasons.push(`Read-only review source drifted from frozen base ${work.baseRevision} to ${currentRevision}.`);
+  }
+  if (currentWorkspaceChangedPaths === undefined) {
+    reasons.push('Current workspace changed-path proof is unavailable for read-only review.');
+  } else if (currentWorkspaceChangedPaths.length > 0) {
+    reasons.push(`Read-only review workspace is not unchanged: ${[...new Set(currentWorkspaceChangedPaths)].slice(0, 12).join(', ')}.`);
+  }
+  return { status: reasons.length === 0 ? 'complete' : 'incomplete', reasons };
+}
+
+export function evaluateWorkCompletionEvidence(
+  work: WorkContract,
+  currentRevision?: string,
+  currentWorkspaceFingerprint?: string,
+  workBoundProcessEvidenceIds: readonly string[] = [],
+  currentWorkspaceChangedPaths?: readonly string[],
+): WorkCompletionEvidenceEvaluation {
+  const applicableCheckRefs = work.checkRefs.filter((record) =>
+    verificationRecordAppliesToCurrentWorkspace(record, currentRevision, currentWorkspaceFingerprint));
+  const history = reconcileVerificationHistory(
+    applicableCheckRefs.map((record) => ({ checkId: record.checkId, outcome: record.outcome, recordedAt: record.recordedAt })),
+  );
+  const missingChecks = work.checks.filter((checkId) => !history.validPasses.includes(checkId));
+  const readOnlySourceIdentity = evaluateReadOnlyReviewSourceIdentity(work, currentRevision, currentWorkspaceChangedPaths);
+  const readOnlyEvidence = work.readOnlyReviewEvidence;
+  const readOnlyEvidenceMatchesCurrentSource = Boolean(
+    work.workKind === 'read_only_review'
+    && readOnlyEvidence
+    && currentRevision
+    && readOnlyEvidence.sourceRevision === currentRevision
+    && (readOnlyEvidence.workspaceFingerprint === undefined
+      || currentWorkspaceFingerprint === undefined
+      || readOnlyEvidence.workspaceFingerprint === currentWorkspaceFingerprint),
+  );
+  const cleanReadOnlyReviewEvidence = Boolean(
+    readOnlyEvidenceMatchesCurrentSource
+    && readOnlySourceIdentity.status === 'complete'
+    && (readOnlyEvidence?.inspectedPaths.length ?? 0) > 0
+    && (readOnlyEvidence?.findings.length ?? 0) === 0,
+  );
+  const workEvidenceIds = work.evidenceRefs.flatMap((evidence) => [evidence.evidenceId, evidence.artifactId])
+    .map((value) => value?.trim())
+    .filter((value): value is string => Boolean(value));
+  const availableDurableEvidenceIds = new Set([
+    ...workEvidenceIds,
+    ...workBoundProcessEvidenceIds.map((value) => value.trim()).filter(Boolean),
+  ]);
+  const durableResultEvidence = availableDurableEvidenceIds.size > 0
+    || applicableCheckRefs.some((record) => isAuthoritativeCurrentWorkVerification(work, record, currentRevision))
+    || cleanReadOnlyReviewEvidence;
+  const requiresSemanticAcceptance = work.workKind === 'local_effect' && work.checks.length === 0;
+  const acceptedCriteria = new Set((work.semanticAcceptanceEvidence ?? [])
+    .filter((review) => review.evidenceIds.length > 0 && review.evidenceIds.every((evidenceId) => availableDurableEvidenceIds.has(evidenceId)))
+    .map((review) => review.criterion));
+  const missingSemanticAcceptanceCriteria = requiresSemanticAcceptance
+    ? work.acceptanceCriteria.filter((criterion) => !acceptedCriteria.has(criterion))
+    : [];
+  const semanticAcceptanceComplete = !requiresSemanticAcceptance
+    || (work.acceptanceCriteria.length > 0 && missingSemanticAcceptanceCriteria.length === 0);
+  const reasons: string[] = [];
+
+  if (history.acceptanceFailures.length > 0) {
+    reasons.push(`Acceptance checks failed: ${history.acceptanceFailures.join(', ')}.`);
+    return { status: 'failed', history, missingChecks, durableResultEvidence, semanticAcceptanceComplete, missingSemanticAcceptanceCriteria, reasons };
+  }
+  if (history.infrastructureIssues.length > 0) {
+    reasons.push(`Infrastructure issues remain: ${history.infrastructureIssues.join(', ')}.`);
+  }
+  if (history.invalidCheckIds.length > 0) {
+    reasons.push(`Invalid check ids remain: ${history.invalidCheckIds.join(', ')}.`);
+  }
+  if (missingChecks.length > 0) {
+    reasons.push(`Declared checks are missing valid_pass evidence: ${missingChecks.join(', ')}.`);
+  }
+  if (work.workKind === 'read_only_review') {
+    reasons.push(...readOnlySourceIdentity.reasons);
+    if (!readOnlyEvidence || readOnlyEvidence.inspectedPaths.length === 0) {
+      reasons.push('Read-only review has no persisted inspected-path evidence.');
+    } else if (!readOnlyEvidenceMatchesCurrentSource) {
+      reasons.push('Persisted read-only review evidence is stale for the current source/workspace identity.');
+    }
+    if ((readOnlyEvidence?.findings.length ?? 0) > 0) {
+      reasons.push(`Read-only review has unresolved semantic findings (${readOnlyEvidence!.findings.length}); clean no-change completion is not allowed.`);
+    }
+  }
+  if (work.checks.length === 0 && !durableResultEvidence) {
+    const staleWorkVerification = work.checkRefs.some((record) =>
+      Boolean(record.receipt)
+      && !verificationRecordAppliesToCurrentWorkspace(record, currentRevision, currentWorkspaceFingerprint));
+    reasons.push(staleWorkVerification
+      ? 'Work-bound verification evidence is stale for the current source/workspace identity.'
+      : 'No durable result evidence (evidenceId, artifactId, or current Work-bound verification receipt) was recorded for this no-check WorkContract.');
+  }
+  if (requiresSemanticAcceptance && !semanticAcceptanceComplete) {
+    reasons.push(work.acceptanceCriteria.length === 0
+      ? 'No-check local-effect Work has no declared acceptance criteria to review.'
+      : `Controller-reviewed semantic acceptance evidence is incomplete; missing criteria: ${missingSemanticAcceptanceCriteria.join(' | ')}.`);
+  }
+
+  const complete = history.infrastructureIssues.length === 0
+    && history.invalidCheckIds.length === 0
+    && missingChecks.length === 0
+    && (work.checks.length > 0 || durableResultEvidence)
+    && semanticAcceptanceComplete
+    && (work.workKind !== 'read_only_review' || cleanReadOnlyReviewEvidence);
+  return {
+    status: complete ? 'complete' : 'incomplete',
+    history,
+    missingChecks,
+    durableResultEvidence,
+    semanticAcceptanceComplete,
+    missingSemanticAcceptanceCriteria,
+    reasons,
+  };
+}