codex-workflow-v2 2.0.0-beta.8 → 2.0.0-beta.9

package/dist/src/workflow.js

@@ -2,6 +2,7 @@ import { appendFileSync, existsSync, lstatSync, readFileSync, readdirSync } from
 import { createHash } from 'node:crypto';
 import path from 'node:path';
 import { PROTOCOL_VERSION, STATE_SCHEMA_VERSION, } from './contracts.js';
+import { inspectDependencyProvenanceRecovery } from './dependency-provenance.js';
 import { renderBrief, renderPlan, renderResult } from './artifacts.js';
 import { assertDelegationCanAuthorize, hashDelegationPolicy, prepareDelegationGrantGate, } from './delegation.js';
 import { assessDiscovery, mergeUnique } from './domain/discovery.js';
@@ -32,7 +33,7 @@ import { createCorrectiveYieldExecutor } from './state/corrective-yield-executor
 import { createCorrectiveReplanPublicController, } from './state/corrective-replan-public.js';
 import { inspectWorkflowObservationBoundary, } from './observation.js';
 import { createEntityId } from './ulid.js';
-import { PACKAGE_VERSION } from './version.js';
+import { PACKAGE_NAME, PACKAGE_VERSION } from './version.js';
 import { correctiveReplanBlockedNavigation, correctiveReplanNavigation, evaluateTaskCorrectiveReplanAvailability, evaluateTaskCorrectiveReplanCandidate, identifyCorrectiveReplanPosture, prepareCorrectiveReplanCandidate, TASK_CORRECTIVE_REPLAN_TRANSITION_ID, } from './lifecycle/corrective-replan.js';
 const MAX_STRICT_REVIEW_INFRASTRUCTURE_FAILURES = 2;
 export class WorkflowService {
@@ -2620,6 +2621,111 @@ export class WorkflowService {
             observation: snapshot.observation,
         };
     }
+    dependencyProvenanceRecoveryPreflight(repository, taskId) {
+        const snapshot = this.observationSnapshot(repository);
+        if (snapshot.observation.kind !== 'assessment') {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Dependency provenance recovery requires a coherent observation boundary.', {
+                observation: snapshot.observation,
+            });
+        }
+        const task = snapshot.tasks.find((candidate) => candidate.id === taskId);
+        if (!task)
+            throw new WorkflowError('NOT_FOUND', `Task ${taskId} was not found in this repository.`);
+        return this.inspectDependencyProvenanceCandidate(snapshot, task);
+    }
+    recoverDependencyProvenance(repository, taskId, expectedRevision, actor, reason) {
+        const normalizedActor = actor.trim();
+        const normalizedReason = reason.trim();
+        if (!normalizedActor)
+            throw new WorkflowError('INVALID_ARGUMENT', 'Dependency provenance recovery requires an actor.');
+        if (!normalizedReason)
+            throw new WorkflowError('INVALID_ARGUMENT', 'Dependency provenance recovery requires a reason.');
+        const context = this.#mutationContext(repository);
+        const current = context.store.readTask(context.identity.projectId, taskId);
+        const currentHead = headCommit(context.identity.repositoryRoot);
+        const prior = current.dependencyProvenanceRecoveries?.find((record) => record.commitSha === currentHead && record.packageVersion === PACKAGE_VERSION);
+        if (prior && current.systemCommits.includes(currentHead))
+            return current;
+        assertExpectedRevision(current, expectedRevision);
+        const snapshot = this.observationSnapshot(repository);
+        const task = snapshot.tasks.find((candidate) => candidate.id === taskId);
+        if (!task)
+            throw new WorkflowError('NOT_FOUND', `Task ${taskId} was not found in this repository.`);
+        const preflight = this.inspectDependencyProvenanceCandidate(snapshot, task);
+        if (!preflight.eligible || !preflight.commitSha || !preflight.parentCommitSha) {
+            throw new WorkflowError('GIT_PRECONDITION_FAILED', 'The bounded dependency provenance recovery preflight failed.', {
+                taskId,
+                blockers: preflight.blockers,
+            });
+        }
+        return context.store.writeTask({
+            ...task,
+            systemCommits: [...task.systemCommits, preflight.commitSha],
+            dependencyProvenanceRecoveries: [
+                ...(task.dependencyProvenanceRecoveries ?? []),
+                {
+                    commitSha: preflight.commitSha,
+                    parentCommitSha: preflight.parentCommitSha,
+                    packageName: PACKAGE_NAME,
+                    packageVersion: PACKAGE_VERSION,
+                    files: ['package-lock.json', 'package.json'],
+                    actor: normalizedActor,
+                    reason: normalizedReason,
+                    recordedAt: this.now().toISOString(),
+                },
+            ],
+        }, expectedRevision);
+    }
+    milestoneProgress(repository, milestoneId) {
+        const snapshot = this.observationSnapshot(repository);
+        if (snapshot.observation.kind !== 'assessment') {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Milestone progress requires a coherent read-only observation boundary.', {
+                observation: snapshot.observation,
+            });
+        }
+        const milestone = snapshot.milestones.find((candidate) => candidate.id === milestoneId);
+        if (!milestone)
+            throw new WorkflowError('NOT_FOUND', `Milestone ${milestoneId} was not found in this repository.`);
+        const tasksById = new Map(snapshot.tasks.map((task) => [task.id, task]));
+        const tasks = milestone.memberships.map((membership, index) => {
+            const task = tasksById.get(membership.taskId);
+            if (!task)
+                throw new WorkflowError('STATE_CORRUPT', `Milestone member ${membership.taskId} does not exist.`);
+            const stepsCompleted = task.steps.filter((step) => ['completed', 'skipped'].includes(step.status)).length;
+            return {
+                ordinal: `T${String(index + 1).padStart(2, '0')}`,
+                taskId: task.id,
+                title: task.title,
+                status: task.status,
+                revision: task.revision,
+                disposition: membership.disposition,
+                membershipReason: membership.reason,
+                replacementForTaskId: task.replacementForTaskId ?? null,
+                replacedByTaskId: task.replacedByTaskId ?? null,
+                stepsCompleted,
+                stepsTotal: task.steps.length,
+                steps: task.steps.map((step, stepIndex) => ({
+                    ordinal: `S${String(stepIndex + 1).padStart(2, '0')}`,
+                    stepId: step.id,
+                    title: step.title,
+                    status: step.status,
+                })),
+            };
+        });
+        const required = tasks.filter((task) => task.disposition === 'required');
+        return {
+            readOnly: true,
+            projectId: snapshot.identity.projectId,
+            milestoneId: milestone.id,
+            milestoneTitle: milestone.title,
+            milestoneStatus: milestone.status,
+            milestoneRevision: milestone.revision,
+            membershipRevision: milestone.membershipRevision,
+            tasksCompleted: required.filter((task) => task.status === 'merged').length,
+            tasksRequired: required.length,
+            tasks,
+        };
+    }
     alpha6StrictReviewRescuePreflight(repository) {
         const context = this.#mutationContext(repository);
         const dependency = inspectLocalDependency(context.identity.repositoryRoot);
@@ -2939,6 +3045,17 @@ export class WorkflowService {
         const activeTask = requestedTask
             ?? status.tasks.find((task) => taskIsActionableFromRepositoryNext(task, milestonesById));
         if (activeTask) {
+            const dependencyRecovery = this.dependencyProvenanceRecoveryPreflight(repositoryRoot, activeTask.id);
+            if (dependencyRecovery.eligible) {
+                return withAdoption({
+                    scope: 'task',
+                    id: activeTask.id,
+                    status: activeTask.status,
+                    action: 'update dependency-provenance-recover',
+                    revision: activeTask.revision,
+                    dependencyProvenanceRecovery: dependencyRecovery,
+                });
+            }
             const activeTaskMilestone = activeTask.milestoneId
                 ? milestonesById.get(activeTask.milestoneId) ?? null
                 : null;
@@ -3961,6 +4078,27 @@ export class WorkflowService {
             },
         };
     }
+    inspectDependencyProvenanceCandidate(snapshot, task) {
+        const versions = inspectWorkflowVersions(snapshot.identity.repositoryRoot, [task.baseBranch]);
+        const now = this.now().getTime();
+        return inspectDependencyProvenanceRecovery(snapshot.identity.repositoryRoot, task, {
+            activeLeaseCount: snapshot.leases.filter((lease) => Date.parse(lease.expiresAt) > now).length,
+            staleLeaseCount: snapshot.leases.filter((lease) => Date.parse(lease.expiresAt) <= now).length,
+            pendingTransactionCount: snapshot.observation.pendingProjectTransactions.length
+                + snapshot.observation.pendingMilestoneTransactions.length
+                + snapshot.observation.pendingTaskTransactions.length,
+            corruptTransactionCount: snapshot.observation.corruptTaskTransactions.length,
+            coreOperationCount: snapshot.observation.coreTaskOperations.length,
+            versions: {
+                runtime: versions.runtime,
+                declared: versions.declared,
+                locked: versions.locked,
+                installed: versions.installed,
+                currentBranch: versions.currentBranch,
+                baseBranch: versions.milestoneBases.find((base) => base.branch === task.baseBranch)?.version ?? null,
+            },
+        });
+    }
     withTaskNavigationContracts(task, next) {
         const action = typeof next.action === 'string' ? next.action : null;
         if (!action)