codex-workflow-v2 2.0.0-beta.13.12 → 2.0.0-beta.13.14

package/dist/reviewer-runtime-build.json

@@ -1,8 +1,8 @@
 {
   "protocol": "codex-workflow-runtime-build-manifest-v1",
   "packageName": "codex-workflow-v2",
-  "packageVersion": "2.0.0-beta.13.12",
-  "packageManifestSha256": "cece4a19cf9b80798da3b1063c7ec5d1c1a1fd70c99d7f991dad76805bba2c28",
+  "packageVersion": "2.0.0-beta.13.14",
+  "packageManifestSha256": "bd8443dc87a9d88b3cb7cc945383fb348747da3c888107f0f84918912f598365",
   "requiredEntrypoints": [
     "dist/src/cli.js",
     "dist/src/gateway-handshake.js",
@@ -336,11 +336,11 @@
     },
     {
       "path": "dist/src/version.js",
-      "sha256": "bf75f74ae7a19aed755727e739aa50c92e34501bd9dce8b87a9d4766f66d92c7"
+      "sha256": "9f099071a7202ab9b8ca13d65e822ba93d3d81992a9feb28434c891ae1f11dba"
     },
     {
       "path": "dist/src/workflow.js",
-      "sha256": "2c33573d6e9964ebb7e47303b692022ace22051dabbf1cfd85f9e73e4f6c334b"
+      "sha256": "98fe880a68b4b4d32bba2c470cc99f0a80edb8bccff53d9e2c1150a4b1ba269f"
     }
   ],
   "runtimeDependencies": [
@@ -1124,5 +1124,5 @@
       ]
     }
   ],
-  "fingerprint": "2ce1f08a3f69ecef89ce398d6c47e0b293efb85de6927a4c0b22095a49a6c2e8"
+  "fingerprint": "17ea7a36af433b3f922cabf4678774c5388d6151087d5deea9403a44e325de3f"
 }

package/dist/src/version.d.ts

@@ -1,2 +1,2 @@
 export declare const PACKAGE_NAME = "codex-workflow-v2";
-export declare const PACKAGE_VERSION = "2.0.0-beta.13.12";
+export declare const PACKAGE_VERSION = "2.0.0-beta.13.14";

package/dist/src/version.js

@@ -1,3 +1,3 @@
 export const PACKAGE_NAME = 'codex-workflow-v2';
-export const PACKAGE_VERSION = '2.0.0-beta.13.12';
+export const PACKAGE_VERSION = '2.0.0-beta.13.14';
 //# sourceMappingURL=version.js.map

package/dist/src/workflow.d.ts

@@ -324,6 +324,9 @@ export declare class WorkflowService {
     recoverHistoricalStepProvenance(repository: string, taskId: string, expectedRevision: number, commitSha: string, actor: string, reason: string): TaskState;
     activeDownstreamProofDependencyRecoveryPreflight(repository: string, taskId: string): DependencyProvenanceRecoveryPreflight;
     downstreamProofReplanUpdatePreflight(repository: string, taskId: string): Record<string, unknown>;
+    /** Read-only readiness for a later, explicitly delegated context refresh.
+     * Provenance registration never approves these product content changes. */
+    private deferredPlanIntegrityKnowledge;
     planIntegrityUpdatePreflight(repository: string, taskId: string): Record<string, unknown>;
     planIntegrityDependencyRecoveryPreflight(repository: string, taskId: string): DependencyProvenanceRecoveryPreflight;
     downstreamProofReplanDependencyRecoveryPreflight(repository: string, taskId: string): DependencyProvenanceRecoveryPreflight;

package/dist/src/workflow.js

@@ -51,7 +51,7 @@ 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;
 // Release-reviewed exact compatibility target; never infer support from PACKAGE_VERSION.
-const CONSUMED_CARRYOVER_TARGET_VERSION = '2.0.0-beta.13.12';
+const CONSUMED_CARRYOVER_TARGET_VERSION = '2.0.0-beta.13.14';
 export class WorkflowService {
     store;
     now;
@@ -4797,6 +4797,43 @@ export class WorkflowService {
             blockers,
         };
     }
+    /** Read-only readiness for a later, explicitly delegated context refresh.
+     * Provenance registration never approves these product content changes. */
+    deferredPlanIntegrityKnowledge(repository, task, stepId, dirtyFiles) {
+        const approved = this.store.readKnowledgeMap(task.projectId);
+        const inspected = inspectKnowledgeMap(approved, scanProjectKnowledge(repository, task.projectId, this.now()));
+        const before = new Map(approved.entries.map(entry => [entry.path, entry]));
+        const productPaths = inspected.entries.filter(entry => entry.path !== 'package.json'
+            && before.get(entry.path)?.contentHash !== entry.contentHash).map(entry => entry.path).sort();
+        if (inspected.status === 'active' && inspected.approval)
+            return { deferred: false, productPaths, blockers: [], options: [] };
+        const blockers = [];
+        if (!isContentOnlyKnowledgeRefresh(approved, inspected))
+            blockers.push('Knowledge classification, sources, gaps or conflicts changed.');
+        if (productPaths.length === 0)
+            return { deferred: false, productPaths, blockers, options: [] };
+        const step = task.steps.find(candidate => candidate.id === stepId);
+        if (approved.status !== 'active' || !approved.approval || !task.planHash
+            || this.store.hashArtifact(this.store.taskRoot(task.projectId, task.id), 'plan.md') !== task.planHash
+            || !task.authorizations.some(auth => auth.kind === 'execution' && auth.decision === 'approved'
+                && auth.planHash === task.planHash && auth.briefHash === task.briefHash)) {
+            blockers.push('Deferred Knowledge refresh requires the unchanged execution-approved Plan and active approved Map.');
+        }
+        if (!step || step.status !== 'failed' || task.status !== 'needs_fix'
+            || productPaths.some(file => !dirtyFiles.includes(file) || !pathAllowed(file, step.allowedWrites)
+                || pathAllowed(file, step.forbiddenScope))) {
+            blockers.push('Product Knowledge drift must belong to the exact failed-Step dirty scope.');
+        }
+        if (!step?.failurePause || hashDirtyWorktree(repository, dirtyFiles) !== step.failurePause.dirtyWorktreeHash
+            || canonicalJsonStringify([...dirtyFiles].sort()) !== canonicalJsonStringify([...step.failurePause.dirtyFiles].sort())) {
+            blockers.push('Product dirty bytes differ from the recorded failed-Step checkpoint.');
+        }
+        const options = blockers.length === 0
+            ? this.delegatedContextRefreshOptions(task.projectId, task, inspected, 'delegated-content-only') : [];
+        if (options.length === 0)
+            blockers.push('No eligible existing delegated content-only context refresh is available.');
+        return { deferred: true, productPaths, blockers, options };
+    }
     planIntegrityUpdatePreflight(repository, taskId) {
         const snapshot = this.observationSnapshot(repository);
         if (snapshot.observation.kind !== 'assessment') {
@@ -4826,6 +4863,7 @@ export class WorkflowService {
                 mode: 'post-rebind-dirty-carryover',
             }
             : null;
+        const deferredKnowledge = this.deferredPlanIntegrityKnowledge(snapshot.identity.repositoryRoot, task, assessment?.stepId ?? adoptedCompatibility?.stepId ?? dirtyCarryoverCompatibility?.stepId ?? null, assessment?.evidence?.changedFiles ?? adoptedCompatibility?.dirtyFiles ?? dirtyCarryoverCompatibility?.dirtyFiles ?? []);
         const versions = inspectWorkflowVersions(snapshot.identity.repositoryRoot, [task.baseBranch]);
         const versionSurfaces = {
             declared: versions.declared,
@@ -4847,6 +4885,7 @@ export class WorkflowService {
                     && sourceBetaVersion.patch !== null
                     && targetBetaVersion.patch > sourceBetaVersion.patch));
         const blockers = [
+            ...deferredKnowledge.blockers,
             ...(assessments.length > 1 ? ['Exactly one failed Step may expose a Plan-integrity conflict.'] : []),
             ...(assessment?.blockers ?? (adoptedCompatibility || dirtyCarryoverCompatibility
                 ? []
@@ -4890,6 +4929,11 @@ export class WorkflowService {
             compatibilityMode: adoptedCompatibility?.mode
                 ?? dirtyCarryoverCompatibility?.mode
                 ?? 'failed-step-conflict',
+            deferredKnowledgeRefresh: deferredKnowledge.deferred ? {
+                action: 'task context-refresh', mode: 'delegated-content-only',
+                productPaths: deferredKnowledge.productPaths, delegatedApprovalOptions: deferredKnowledge.options,
+                application: 'after-provenance-and-scope-recovery', approvalDeferred: true,
+            } : null,
             requiredTransport: [
                 'Commit only package.json and package-lock.json on the active Milestone base.',
                 'Fast-forward or apply only that dependency commit to the Task branch while preserving all product bytes.',
@@ -4964,7 +5008,13 @@ export class WorkflowService {
                     ? [assessment.evidence.remediationEventId]
                     : assessment.evidence.remediationEvents.map((event) => event.eventId),
             };
-        return this.inspectDependencyProvenanceCandidate(snapshot, task, null, null, null, compatibility);
+        const provenance = this.inspectDependencyProvenanceCandidate(snapshot, task, null, null, null, compatibility);
+        const deferredKnowledge = this.deferredPlanIntegrityKnowledge(snapshot.identity.repositoryRoot, task, compatibility.stepId, compatibility.dirtyFiles);
+        return { ...provenance,
+            eligible: provenance.eligible && deferredKnowledge.blockers.length === 0,
+            action: deferredKnowledge.blockers.length === 0 ? provenance.action : null,
+            blockers: [...provenance.blockers, ...deferredKnowledge.blockers],
+        };
     }
     downstreamProofReplanDependencyRecoveryPreflight(repository, taskId) {
         const snapshot = this.observationSnapshot(repository);
@@ -5129,7 +5179,10 @@ export class WorkflowService {
         const scannedKnowledgeMap = scanProjectKnowledge(context.identity.repositoryRoot, task.projectId, now);
         const inspectedKnowledgeMap = inspectKnowledgeMap(currentKnowledgeMap, scannedKnowledgeMap);
         let refreshedKnowledgeMap = null;
-        if (inspectedKnowledgeMap.status !== 'active' || !inspectedKnowledgeMap.approval) {
+        const deferredKnowledge = this.deferredPlanIntegrityKnowledge(context.identity.repositoryRoot, task, preflight.planIntegrity.stepId, preflight.planIntegrity.dirtyFiles);
+        if (deferredKnowledge.blockers.length > 0)
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Plan-integrity transport cannot defer unrelated or unauthorized Knowledge drift.', { blockers: deferredKnowledge.blockers });
+        if (!deferredKnowledge.deferred && (inspectedKnowledgeMap.status !== 'active' || !inspectedKnowledgeMap.approval)) {
             const knowledgeRefresh = inspectDependencyKnowledgeRefresh(context.identity.repositoryRoot, task.baseBranch, currentKnowledgeMap, inspectedKnowledgeMap, preflight.planIntegrity.dirtyFiles);
             if (!knowledgeRefresh.eligible) {
                 throw new WorkflowError('TRANSITION_BLOCKED', 'Plan-integrity dependency recovery cannot bypass unrelated Project Knowledge drift.', {
@@ -6517,6 +6570,8 @@ export class WorkflowService {
             : null;
         let rootCauseReplanDirtyCarryover = ['task run', 'task handoff-prepare', 'task claim'].includes(String(next.action))
             && rootCauseStepId
+            // Match runStep: historical carryover admits a replacement start, never a failed retry.
+            && task.steps.find(step => step.id === rootCauseStepId)?.status === 'planned'
             && changedFiles(repositoryRoot).length > 0
             ? this.assessCurrentRootCauseReplanDirtyCarryover(repositoryRoot, task, rootCauseStepId)
             : null;