codex-workflow-v2 2.0.0-beta.12.10 → 2.0.0-beta.12.11

package/dist/src/workflow.js

@@ -2,7 +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 { inspectDependencyKnowledgeRefresh, inspectDependencyProvenanceRecovery, } from './dependency-provenance.js';
 import { inspectHistoricalStepProvenanceRecovery, omittedStepEvidenceCommits, } from './historical-step-provenance.js';
 import { renderBrief, renderPlan, renderResult } from './artifacts.js';
 import { assertDelegationCanAuthorize, hashDelegationPolicy, prepareDelegationGrantGate, } from './delegation.js';
@@ -719,6 +719,33 @@ export class WorkflowService {
         }
         const now = this.now();
         const timestamp = now.toISOString();
+        const actor = `agent:milestone-remediation:${milestone.id}`;
+        const storedKnowledgeMap = this.store.readKnowledgeMap(identity.projectId);
+        const scannedKnowledgeMap = scanProjectKnowledge(identity.repositoryRoot, identity.projectId, now);
+        const inspectedKnowledgeMap = inspectKnowledgeMap(storedKnowledgeMap, scannedKnowledgeMap);
+        let dependencyKnowledgeRefresh = null;
+        let refreshedKnowledgeMap = null;
+        if (inspectedKnowledgeMap.status !== 'active' || !inspectedKnowledgeMap.approval) {
+            dependencyKnowledgeRefresh = inspectDependencyKnowledgeRefresh(identity.repositoryRoot, milestone.baseBranch, storedKnowledgeMap, inspectedKnowledgeMap);
+            if (!dependencyKnowledgeRefresh.eligible) {
+                throw new WorkflowError('TRANSITION_BLOCKED', 'Audited remediation cannot bypass unrelated or unproven Project Knowledge drift.', { dependencyKnowledgeRefresh });
+            }
+            const reconciled = reconcileKnowledgeMap(storedKnowledgeMap, scannedKnowledgeMap);
+            const approved = applyKnowledgeSelections(reconciled, [], actor, now);
+            if (!approved.approval) {
+                throw new WorkflowError('STATE_CORRUPT', 'Dependency-only Knowledge refresh did not produce approval evidence.');
+            }
+            refreshedKnowledgeMap = {
+                ...approved,
+                revision: storedKnowledgeMap.revision + 2,
+                createdAt: storedKnowledgeMap.createdAt,
+                updatedAt: timestamp,
+                approval: {
+                    ...approved.approval,
+                    authorizationMode: 'corrective-derived',
+                },
+            };
+        }
         const remediationTaskId = createEntityId('TASK', now.getTime());
         const briefContent = renderBrief(discovery, title);
         const normalizedBriefContent = briefContent.endsWith('\n') ? briefContent : `${briefContent}\n`;
@@ -804,7 +831,6 @@ export class WorkflowService {
         const readCandidateTask = (taskId) => taskId === remediationTaskId
             ? remediationTask
             : this.store.readTask(identity.projectId, taskId);
-        const actor = `agent:milestone-remediation:${milestone.id}`;
         const preparedCandidate = prepareMilestoneScopeChangeCandidate({
             milestone,
             plan,
@@ -856,6 +882,12 @@ export class WorkflowService {
             kind: 'audited-remediation-materialization',
             now,
             targets: [
+                ...(refreshedKnowledgeMap
+                    ? [{
+                            path: relative(path.join(projectRoot, 'knowledge-map.json')),
+                            content: `${JSON.stringify(refreshedKnowledgeMap, null, 2)}\n`,
+                        }]
+                    : []),
                 {
                     path: relative(path.join(this.store.discoveryRoot(identity.projectId, discovery.id), 'state.json')),
                     content: `${JSON.stringify(consumedDiscovery, null, 2)}\n`,
@@ -892,12 +924,17 @@ export class WorkflowService {
                 const savedAuthorization = [...savedMilestone.authorizations]
                     .reverse()
                     .find((authorization) => authorization.kind === 'execution' && authorization.decision === 'approved');
+                const savedKnowledgeMap = this.store.readKnowledgeMap(identity.projectId);
                 if (savedDiscovery.materializedEntityId !== remediationTaskId
                     || savedRemediationTask.milestoneId !== milestone.id
                     || !savedBlockedMembership?.dependsOnTaskIds?.includes(remediationTaskId)
                     || savedRemediationMembership?.disposition !== 'required'
                     || savedAuthorization?.authorizationMode !== 'corrective-derived'
                     || savedMilestone.status !== 'active'
+                    || (refreshedKnowledgeMap !== null
+                        && (savedKnowledgeMap.revision !== refreshedKnowledgeMap.revision
+                            || savedKnowledgeMap.status !== 'active'
+                            || savedKnowledgeMap.approval?.authorizationMode !== 'corrective-derived'))
                     || locks.inspect(blockedTask.id) !== null) {
                     throw new WorkflowError('STATE_CORRUPT', 'Audited remediation transaction readback failed.');
                 }
@@ -4394,6 +4431,37 @@ export class WorkflowService {
                     ? this.nextForTaskWithDelegation(status.projectId, repositoryRoot, activeTask, null)
                     : planRiskAuditRecovery
                         ?? this.nextForTaskWithDelegation(status.projectId, repositoryRoot, activeTask, activePlanRiskAudit);
+            const auditedRemediationNavigation = taskNext?.auditedRemediation;
+            let auditedDependencyKnowledgeRefreshBlocked = null;
+            if (auditedRemediationNavigation
+                && activeTaskMilestone
+                && ['discovery start', 'discovery update', 'milestone remediation-materialize'].includes(String(taskNext?.action))) {
+                try {
+                    const storedKnowledgeMap = this.store.readKnowledgeMap(status.projectId);
+                    const inspectedKnowledgeMap = inspectCurrentKnowledgeMap();
+                    if (inspectedKnowledgeMap.status !== 'active' || !inspectedKnowledgeMap.approval) {
+                        const dependencyKnowledgeRefresh = inspectDependencyKnowledgeRefresh(repositoryRoot, activeTaskMilestone.baseBranch, storedKnowledgeMap, inspectedKnowledgeMap);
+                        if (dependencyKnowledgeRefresh.eligible) {
+                            return withAdoption(withMilestoneCancellation({
+                                ...taskNext,
+                                auditedRemediation: {
+                                    ...auditedRemediationNavigation,
+                                    dependencyKnowledgeRefresh: {
+                                        ...dependencyKnowledgeRefresh,
+                                        humanApprovalRequired: false,
+                                        application: 'atomic-with-remediation-materialization',
+                                    },
+                                },
+                            }));
+                        }
+                        auditedDependencyKnowledgeRefreshBlocked = dependencyKnowledgeRefresh;
+                    }
+                }
+                catch (error) {
+                    if (!(error instanceof WorkflowError) || error.code !== 'NOT_FOUND')
+                        throw error;
+                }
+            }
             // Active Step work must outrank Project Knowledge refresh/rebind. Both completion and
             // strict review are executable while context refresh correctly remains forbidden.
             const hardStop = taskNext?.action === 'task corrective-decision'
@@ -4488,6 +4556,15 @@ export class WorkflowService {
                             },
                         }
                         : {}),
+                    ...(auditedDependencyKnowledgeRefreshBlocked
+                        ? {
+                            auditedDependencyKnowledgeRefreshBlocked: {
+                                ...auditedDependencyKnowledgeRefreshBlocked,
+                                humanApprovalRequired: true,
+                                requiredAction: 'Resolve or explicitly approve the non-dependency Project Knowledge drift.',
+                            },
+                        }
+                        : {}),
                 }));
             }
             const knowledgeMapHash = hashKnowledgeMap(knowledgeMap);
@@ -5485,7 +5562,20 @@ export class WorkflowService {
         return readValidatedStopOverrideContextRebindIfApplicable(this.store, task, stepId, repositoryRoot)?.stopDecision.eventId ?? null;
     }
     taskHasTerminalCorrectiveDecision(task) {
-        return this.taskTerminalCorrectivePosture(task) !== null;
+        try {
+            return this.taskTerminalCorrectivePosture(task) !== null;
+        }
+        catch (error) {
+            if (error instanceof WorkflowError
+                && error.code === 'TRANSITION_BLOCKED'
+                && (error.details.decision === 'stop-escalate' || error.details.decision === 'split-required')) {
+                // A blocking Plan Risk Audit is not a guarded-Step terminal decision, but it
+                // equally cannot own an atomic delegated context refresh. Treat it as
+                // ineligible here so standalone Knowledge reconciliation remains executable.
+                return true;
+            }
+            throw error;
+        }
     }
     taskTerminalCorrectivePosture(task) {
         if (!task.planHash)