codex-workflow-v2 2.0.0-beta.13.1 → 2.0.0-beta.13.2

package/dist/src/workflow.js

@@ -1,3 +1,4 @@
+import { pendingReviewRunnerFingerprint, PENDING_REVIEW_UPDATE_SIDECAR, preparePendingReviewUpdateEvent, PENDING_REVIEW_SOURCE_VERSION, pendingReviewSourceBinding, pendingReviewBindingHash, assertPendingReviewTransport, verifiedPendingReviewTransport } from './pending-review-update.js';
 import { appendFileSync, existsSync, lstatSync, readFileSync, readdirSync } from 'node:fs';
 import { createHash } from 'node:crypto';
 import path from 'node:path';
@@ -2970,7 +2971,15 @@ export class WorkflowService {
             throw new WorkflowError('TRANSITION_BLOCKED', `External Strict Step Review requires ${stepId} in progress with canonical evidence.`);
         }
         validateTaskHistory(identity.repositoryRoot, task);
-        if (!isClean(identity.repositoryRoot) || headCommit(identity.repositoryRoot) !== step.evidence.commitSha) {
+        const transport = verifiedPendingReviewTransport(identity.repositoryRoot, task, stepId, this.store.taskRoot(task.projectId, task.id));
+        if (transport) {
+            const cycle = buildCurrentStrictStepReviewCycle(this.store, task, stepId);
+            if (cycle.resolution !== 'pending' || cycle.pendingEvent?.eventHash !== transport.source.pendingEventHash
+                || cycle.binding.evidenceHash !== transport.source.evidenceHash) {
+                throw new WorkflowError('TRANSITION_BLOCKED', 'The transported strict review must retain its exact pending chain.');
+            }
+        }
+        if (!isClean(identity.repositoryRoot) || (headCommit(identity.repositoryRoot) !== step.evidence.commitSha && !transport)) {
             throw new WorkflowError('GIT_PRECONDITION_FAILED', 'External Strict Step Review requires a clean checkout at the completion commit.');
         }
         const envelope = this.taskContext(repository, taskId, 'independent-reviewer');
@@ -3657,6 +3666,137 @@ export class WorkflowService {
             now: this.now(),
         }, actor, confirmationCode);
     }
+    pendingReviewUpdatePreflight(repository, taskId) {
+        const snapshot = this.observationSnapshot(repository);
+        const blockers = observationPreflightBlockers(snapshot.observation);
+        try {
+            pendingReviewRunnerFingerprint();
+        }
+        catch (error) {
+            blockers.push(error instanceof Error ? error.message : String(error));
+        }
+        const task = snapshot.tasks.find((candidate) => candidate.id === taskId);
+        let binding = null;
+        if (PACKAGE_VERSION === PENDING_REVIEW_SOURCE_VERSION)
+            blockers.push('The exact target runner must be newer than the supported source.');
+        if (!task)
+            blockers.push('Task not found.');
+        if (task) {
+            try {
+                binding = pendingReviewSourceBinding(snapshot.identity.repositoryRoot, this.store, task);
+            }
+            catch (error) {
+                blockers.push(error instanceof Error ? error.message : String(error));
+            }
+            const versions = inspectWorkflowVersions(snapshot.identity.repositoryRoot, [task.baseBranch]);
+            if ([versions.declared, versions.locked, versions.installed, versions.currentBranch,
+                ...versions.milestoneBases.map((base) => base.version)].some((version) => version !== PENDING_REVIEW_SOURCE_VERSION)) {
+                blockers.push('All source version surfaces must equal the exact supported beta.13.1.');
+            }
+        }
+        const otherRunningSteps = snapshot.tasks.flatMap((candidate) => candidate.steps.filter((step) => step.status === 'in_progress' && (candidate.id !== taskId || step.id !== binding?.stepId)));
+        if (otherRunningSteps.length)
+            blockers.push('No other Step may be running.');
+        const stale = snapshot.leases.filter((lease) => Date.parse(lease.expiresAt) <= this.now().getTime());
+        if (snapshot.leases.some((lease) => !stale.includes(lease)))
+            blockers.push('No live writer lease may exist.');
+        if (stale.some((lease) => lease.entityId !== taskId))
+            blockers.push('No unrelated stale writer lease may exist.');
+        const staleLeaseRepair = blockers.length === 0 && binding
+            ? stale.map((lease) => ({ action: 'locks repair', entityId: lease.entityId })) : [];
+        if (stale.length)
+            blockers.push('Repair the exact stale Task lease with the installed source locks repair, then rerun source preflight.');
+        return { readOnly: true, eligible: blockers.length === 0 && binding !== null, binding,
+            bindingHash: binding ? pendingReviewBindingHash(binding) : null, blockers, staleLeaseRepair };
+    }
+    pendingReviewDependencyPreflight(repository, taskId, source) {
+        const snapshot = this.observationSnapshot(repository);
+        const blockers = observationPreflightBlockers(snapshot.observation);
+        try {
+            pendingReviewRunnerFingerprint();
+        }
+        catch (error) {
+            blockers.push(error instanceof Error ? error.message : String(error));
+        }
+        const task = snapshot.tasks.find((candidate) => candidate.id === taskId);
+        const taskHead = headCommit(snapshot.identity.repositoryRoot);
+        let baseTransportCommit = null;
+        if (snapshot.leases.length)
+            blockers.push('No live or stale writer lease may exist.');
+        if (!task)
+            blockers.push('Task not found.');
+        if (task && existsSync(path.join(this.store.taskRoot(task.projectId, task.id), PENDING_REVIEW_UPDATE_SIDECAR)))
+            blockers.push('A pending review update is already recorded.');
+        if (task) {
+            try {
+                // Receipt fields are claims, not authority. Reconstruct every source binding from
+                // canonical Task/sidecars and the exact parents of the candidate Git commits.
+                const parent = runGit(repository, ['rev-parse', 'HEAD^']);
+                baseTransportCommit = runGit(repository, ['rev-parse', task.baseBranch]);
+                const baseParent = runGit(repository, ['rev-parse', `${baseTransportCommit}^`]);
+                const reconstructed = pendingReviewSourceBinding(repository, this.store, task, parent, baseParent);
+                if (canonicalJsonStringify(reconstructed) !== canonicalJsonStringify(source)) {
+                    throw new Error('Source receipt does not match reconstructed Task/revision/Plan/HEAD/pending bindings.');
+                }
+                assertPendingReviewTransport(repository, reconstructed, taskHead, baseTransportCommit);
+                if (snapshot.tasks.some((candidate) => candidate.steps.some((step) => step.status === 'in_progress' && (candidate.id !== taskId || step.id !== source.stepId)))) {
+                    throw new Error('No other Step may be running.');
+                }
+                const versions = inspectWorkflowVersions(repository, [task.baseBranch]);
+                if ([versions.runtime, versions.declared, versions.locked, versions.installed, versions.currentBranch,
+                    ...versions.milestoneBases.map((base) => base.version)].some((version) => version !== PACKAGE_VERSION)) {
+                    throw new Error('All target version surfaces must equal the exact target runner.');
+                }
+            }
+            catch (error) {
+                blockers.push(error instanceof Error ? error.message : String(error));
+            }
+        }
+        return { readOnly: true, eligible: blockers.length === 0, blockers, taskHead, baseTransportCommit };
+    }
+    recoverPendingReviewDependency(repository, taskId, expectedRevision, source, actor, reason) {
+        if (!actor.trim() || !reason.trim())
+            throw new WorkflowError('INVALID_ARGUMENT', 'Actor and reason are required.');
+        const initial = this.pendingReviewDependencyPreflight(repository, taskId, source);
+        if (!initial.eligible)
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Pending review dependency preflight failed.', initial);
+        const context = this.#mutationContext(repository);
+        const task = this.store.readTask(context.identity.projectId, taskId);
+        assertExpectedRevision(task, expectedRevision);
+        const preflight = this.pendingReviewDependencyPreflight(repository, taskId, source);
+        if (!preflight.eligible || !preflight.baseTransportCommit) {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Pending review dependency preflight changed.', preflight);
+        }
+        const now = this.now();
+        const nextTask = { ...task, revision: task.revision + 1, updatedAt: now.toISOString(),
+            systemCommits: [...task.systemCommits, preflight.taskHead],
+            dependencyProvenanceRecoveries: [...(task.dependencyProvenanceRecoveries ?? []), {
+                    commitSha: preflight.taskHead, parentCommitSha: source.completionCommit,
+                    packageName: PACKAGE_NAME, packageVersion: PACKAGE_VERSION, files: ['package-lock.json', 'package.json'],
+                    actor: actor.trim(), reason: reason.trim(), recordedAt: now.toISOString(),
+                }] };
+        const projectRoot = this.store.projectRoot(task.projectId);
+        const event = preparePendingReviewUpdateEvent({ source, baseTransportCommit: preflight.baseTransportCommit }, preflight.taskHead, now.toISOString());
+        applyProjectTransaction({ projectRoot, projectId: task.projectId,
+            transactionId: `tx-${createEntityId('TASK', now.getTime()).toLowerCase()}`,
+            kind: 'pending-review-dependency-recovery', now,
+            targets: [{ path: path.relative(projectRoot, path.join(this.store.taskRoot(task.projectId, task.id), 'state.json')).split(path.sep).join('/'),
+                    content: `${JSON.stringify(nextTask, null, 2)}\n` },
+                { path: path.relative(projectRoot, path.join(this.store.taskRoot(task.projectId, task.id), PENDING_REVIEW_UPDATE_SIDECAR)).split(path.sep).join('/'),
+                    content: `${canonicalJsonStringify(event)}\n` }],
+            validate: () => {
+                const saved = this.store.readTask(task.projectId, task.id);
+                if (saved.revision !== nextTask.revision || !verifiedPendingReviewTransport(repository, saved, source.stepId, this.store.taskRoot(task.projectId, task.id))) {
+                    throw new WorkflowError('STATE_CORRUPT', 'Pending review dependency recovery readback failed.');
+                }
+                const cycle = buildCurrentStrictStepReviewCycle(this.store, saved, source.stepId);
+                if (cycle.resolution !== 'pending' || cycle.pendingEvent?.eventHash !== source.pendingEventHash) {
+                    throw new WorkflowError('STATE_CORRUPT', 'Pending review changed during dependency recovery.');
+                }
+            },
+        });
+        return this.store.readTask(task.projectId, task.id);
+    }
     updatePreflight(repository) {
         const snapshot = this.observationSnapshot(repository);
         const tasks = snapshot.tasks;
@@ -4748,6 +4888,19 @@ export class WorkflowService {
             ?? prioritizedRemediationTask
             ?? status.tasks.find((task) => taskIsActionableFromRepositoryNext(task, milestonesById, tasksById));
         if (activeTask) {
+            let pendingReviewDependencyRecovery = null;
+            try {
+                const reconstructed = pendingReviewSourceBinding(repositoryRoot, this.store, activeTask, runGit(repositoryRoot, ['rev-parse', 'HEAD^']), runGit(repositoryRoot, ['rev-parse', `${activeTask.baseBranch}^`]));
+                pendingReviewDependencyRecovery = this.pendingReviewDependencyPreflight(repositoryRoot, activeTask.id, reconstructed);
+            }
+            catch { /* A nonmatching shape follows ordinary navigation without a compatibility bypass. */ }
+            if (pendingReviewDependencyRecovery?.eligible) {
+                return withAdoption({ scope: 'task', id: activeTask.id, status: activeTask.status,
+                    action: 'update pending-review-dependency-recover', revision: activeTask.revision,
+                    pendingReviewDependencyRecovery,
+                    sourceReceiptRequired: true,
+                });
+            }
             const historicalStepProvenanceRecovery = this.historicalStepProvenanceRecoveryPreflight(repositoryRoot, activeTask.id);
             if (historicalStepProvenanceRecovery.eligible) {
                 return withAdoption({
@@ -5092,7 +5245,7 @@ export class WorkflowService {
                 || taskNext?.action === 'task downstream-proof-recover'
                 || taskNext?.action === 'task remediation-mode-recover'
                 || (taskNext?.action === 'task writer-credential-replace'
-                    && taskNext?.blockedAction === 'task remediation-mode-recover')
+                    && ['task step-complete', 'task step-review', 'task remediation-mode-recover'].includes(String(taskNext?.blockedAction)))
                 || taskNext?.action === 'task plan-integrity-recover'
                 || taskNext?.blockedAction === 'task plan-integrity-recover'
                 || taskNext?.action === 'task corrective-yield'