codex-workflow-v2 2.0.0-alpha.7 → 2.0.0-alpha.7.2

package/dist/src/workflow.js

@@ -12,10 +12,11 @@ import { inspectLocalDependency } from './diagnostics.js';
 import { appendTaskClaim, appendTaskHandback, appendTaskHandoff, assertTaskMutationAllowedByC1, defaultTaskWorkerActor, readTaskC1Posture, } from './alpha6/handoff.js';
 import { applyAdoptionPosture, assertAdoptionBaselinePreserved, buildAdoptionPreparation, initializeProjectRegistrationAdoption, readCurrentAdoptionPosture, } from './alpha6/adoption.js';
 import { appendCurrentPlanRiskAudit, appendReboundPlanRiskAudit, readCurrentPlanRiskAudit, validatePlanRiskAuditCandidate, } from './alpha6/plan-risk.js';
-import { appendCorrectiveDecisionEvent, appendRemediationEvent, assertCorrectiveAuditorIndependence, assertGuardedRemediationAttemptAllowed, defaultCorrectiveAuditorActor, findFailedGuardedStepRequiringCorrectiveDecision, readCorrectiveDecisionEvents, readRemediationEvents, } from './alpha6/remediation.js';
+import { appendCorrectiveDecisionEvent, appendRemediationEvent, assertCorrectiveAuditorIndependence, assertGuardedRemediationAttemptAllowed, defaultCorrectiveAuditorActor, findCurrentGuardedRemediationPosture, findFailedGuardedStepRequiringCorrectiveDecision, readGuardedRemediationPostureForStep, readCorrectiveDecisionEvents, readRemediationEvents, } from './alpha6/remediation.js';
 import { applyMilestoneScopeChangeTransaction, assertMilestoneMembershipIntegrity, assertMilestoneScopeChangeStatusAllowed, normalizeMilestonePlan, prepareMilestoneScopeChangeCandidate, readMilestoneForScopeChange, readMilestoneWithIntegrity, } from './alpha6/milestone.js';
 import { buildCurrentStrictStepReviewCycle, ensurePendingStrictStepReview, isStepReviewRequired, recordStrictStepReview, } from './alpha6/review.js';
 import { applyMilestoneAutonomyContract, assertAutonomousPlanEvolution, prepareMilestoneAutonomyContract, readMilestoneAutonomyEvents, requireActiveMilestoneAutonomy, } from './alpha7/autonomy.js';
+import { appendCorrectiveDecisionRecovery, readValidatedCorrectiveDecisionRecoveryForNavigation, requireCorrectiveDecisionRecoveryForRun, } from './alpha7/corrective-recovery.js';
 import { applyKnowledgeSelections, hashKnowledgeMap, inspectKnowledgeMap, normalizeRelativePath, reconcileKnowledgeMap, scanProjectKnowledge, selectKnowledgeSources, } from './memory.js';
 import { canonicalJsonStringify, sha256Hex } from './alpha6/store-sidecars.js';
 import { commitStep, mergeTaskBranch, runChecks, startLocalTaskBranch, syncBaseIntoTask, validateTaskHistory, } from './git.js';
@@ -879,15 +880,25 @@ export class WorkflowService {
         const inspectedMap = inspectKnowledgeMap(currentMap, scanProjectKnowledge(identity.repositoryRoot, identity.projectId, this.now()));
         const transitions = [];
         const currentPlanRiskAudit = readCurrentPlanRiskAudit(this.store, task);
+        const currentPlanArtifactHash = task.planHash
+            ? this.store.hashArtifact(this.store.taskRoot(identity.projectId, task.id), 'plan.md')
+            : null;
+        const refreshAssessment = assessDelegatedKnowledgeRefresh(currentMap, inspectedMap, task, currentPlanArtifactHash);
         // Validate every delegated transition before the first write so a narrow grant cannot
         // leave the composite operation half-applied.
         this.delegatedAuthorization(identity.projectId, delegationGrantId, 'task.execution_authorize', actor, task);
         let knowledgeMap = currentMap;
         if (inspectedMap.status !== 'active' || !inspectedMap.approval) {
-            if (currentMap.status !== 'active' || !currentMap.approval || inspectedMap.status !== 'stale') {
-                throw new WorkflowError('TRANSITION_BLOCKED', 'Automatic Task context refresh requires a previously approved map with content-only drift.', { currentStatus: currentMap.status, inspectedStatus: inspectedMap.status });
+            if (currentMap.status !== 'active' || !currentMap.approval) {
+                throw new WorkflowError('TRANSITION_BLOCKED', 'Automatic Task context refresh requires a previously approved map with safe delegated drift.', { currentStatus: currentMap.status, inspectedStatus: inspectedMap.status });
+            }
+            assertDelegatedKnowledgeRefresh(refreshAssessment);
+            if (inspectedMap.status !== 'stale') {
+                throw new WorkflowError('TRANSITION_BLOCKED', 'Safe delegated Knowledge drift must reconcile to a stale candidate before approval.', { currentStatus: currentMap.status, inspectedStatus: inspectedMap.status });
+            }
+            if (refreshAssessment.mode === 'delegated-plan-bounded-supporting-source') {
+                this.assertPlanBoundedSupportingSourceGrant(identity.projectId, delegationGrantId, actor, task);
             }
-            assertContentOnlyKnowledgeRefresh(currentMap, inspectedMap);
             this.delegatedAuthorization(identity.projectId, delegationGrantId, 'project_memory.approve', actor, inspectedMap, task.id);
             knowledgeMap = this.reconcileKnowledgeMap(repository, currentMap.revision);
             transitions.push('project-memory reconcile');
@@ -904,11 +915,14 @@ export class WorkflowService {
             appendReboundPlanRiskAudit(this.store, task, refreshedTask, currentPlanRiskAudit, this.now());
         }
         transitions.push('task knowledge-rebind');
-        refreshedTask = this.authorizeTask(repository, taskId, refreshedTask.revision, actor, 'Delegated content-only context refresh.', delegationGrantId);
+        refreshedTask = this.authorizeTask(repository, taskId, refreshedTask.revision, actor, refreshAssessment.mode === 'delegated-plan-bounded-supporting-source'
+            ? 'Delegated Plan-bounded supporting-source context refresh.'
+            : 'Delegated content-only context refresh.', delegationGrantId);
         transitions.push('task execution authorize');
         return {
-            mode: 'delegated-content-only',
+            mode: refreshAssessment.mode,
             transitions,
+            addedSources: refreshAssessment.addedSources,
             knowledgeMap,
             task: refreshedTask,
         };
@@ -1183,7 +1197,15 @@ export class WorkflowService {
             });
         }
         if (planRiskAudit && isStepReviewRequired(task, stepId, planRiskAudit.reviewRequiredStepIds)) {
-            assertGuardedRemediationAttemptAllowed(this.store, task, stepId, planRiskAudit);
+            const guardedPosture = readGuardedRemediationPostureForStep(this.store, task, stepId, planRiskAudit);
+            const staleDecision = guardedPosture?.correctiveDecision
+                && guardedPosture.correctiveDecision.planHash !== task.planHash
+                ? guardedPosture.correctiveDecision
+                : null;
+            const recovery = staleDecision
+                ? requireCorrectiveDecisionRecoveryForRun(this.store, task, stepId, actor, writerToken)
+                : null;
+            assertGuardedRemediationAttemptAllowed(this.store, task, stepId, planRiskAudit, recovery?.correctiveDecisionEventId ?? null);
         }
         const dirty = changedFiles(context.identity.repositoryRoot);
         if (step.status === 'planned' && dirty.length > 0) {
@@ -1636,6 +1658,18 @@ export class WorkflowService {
         }
         return saved;
     }
+    recoverStepCorrectiveDecision(repository, taskId, stepId, expectedRevision, actor, writerToken) {
+        const context = this.context(repository);
+        const task = this.store.readTask(context.identity.projectId, taskId);
+        assertExpectedRevision(task, expectedRevision);
+        this.requireExecutionAdoptionPosture(context.identity, taskId);
+        if (!['ready', 'in_progress', 'needs_fix'].includes(task.status)) {
+            throw new WorkflowError('TRANSITION_BLOCKED', `Task ${taskId} cannot recover a corrective decision while ${task.status}.`);
+        }
+        this.assertExecutionAuthorizationFresh(task);
+        this.assertTaskKnowledgeBinding(context.identity.repositoryRoot, task);
+        return appendCorrectiveDecisionRecovery(this.store, task, stepId, expectedRevision, actor, writerToken, this.now());
+    }
     recordStepCorrectiveDecision(repository, taskId, stepId, expectedRevision, correctiveAudit, actor, writerToken = null) {
         const { identity } = this.context(repository);
         this.readCurrentAdoptionPostureStrict(identity.projectId);
@@ -1643,7 +1677,7 @@ export class WorkflowService {
         assertExpectedRevision(task, expectedRevision);
         this.proveOptionalWriterLeaseToken(this.context(repository), taskId, writerToken);
         this.assertTaskMutationAllowedByHandoff(task, actor ?? null, writerToken);
-        if (task.status !== 'needs_fix' && task.status !== 'blocked') {
+        if (!['ready', 'needs_fix', 'blocked'].includes(task.status)) {
             throw new WorkflowError('TRANSITION_BLOCKED', `Task ${taskId} cannot record a corrective decision while ${task.status}.`);
         }
         const planRiskAudit = readCurrentPlanRiskAudit(this.store, task);
@@ -1659,32 +1693,25 @@ export class WorkflowService {
                 stepId,
             });
         }
-        const step = requireStep(task, stepId);
         if (!isStepReviewRequired(task, stepId, planRiskAudit.reviewRequiredStepIds)) {
             throw new WorkflowError('TRANSITION_BLOCKED', `Step ${stepId} is not guarded by the current Plan Risk Audit and cannot receive a corrective decision.`, {
                 taskId,
                 stepId,
             });
         }
-        if (task.status === 'needs_fix') {
-            if (step.status !== 'failed') {
-                throw new WorkflowError('TRANSITION_BLOCKED', `Corrective decision for ${stepId} requires a currently failed guarded Step while task ${taskId} is needs_fix.`, {
-                    taskId,
-                    stepId,
-                    stepStatus: step.status,
-                });
-            }
-        }
-        else {
-            const currentCycle = buildCurrentStrictStepReviewCycle(this.store, task, stepId);
-            if (step.status !== 'in_progress' || !step.evidence || currentCycle.resolution !== 'unverified') {
-                throw new WorkflowError('TRANSITION_BLOCKED', `Corrective decision for ${stepId} requires a blocked unverified guarded Step with current evidence.`, {
-                    taskId,
-                    stepId,
-                    stepStatus: step.status,
-                    resolution: currentCycle.resolution,
-                });
-            }
+        const posture = readGuardedRemediationPostureForStep(this.store, task, stepId, planRiskAudit);
+        if (!posture) {
+            const step = requireStep(task, stepId);
+            const currentCycle = step.status === 'in_progress' && step.evidence
+                ? buildCurrentStrictStepReviewCycle(this.store, task, stepId).resolution
+                : null;
+            throw new WorkflowError('TRANSITION_BLOCKED', `Corrective decision for ${stepId} requires a failed guarded Step or a blocked unverified strict-review retry posture.`, {
+                taskId,
+                stepId,
+                taskStatus: task.status,
+                stepStatus: step.status,
+                resolution: currentCycle,
+            });
         }
         assertCorrectiveAuditorIndependence(this.store, task, stepId, correctiveAudit.auditor);
         return appendCorrectiveDecisionEvent(this.store, task, stepId, correctiveAudit, planRiskAudit, task.planHash, this.now());
@@ -2146,11 +2173,14 @@ export class WorkflowService {
                     ? this.delegatedApprovalOptions(status.projectId, 'project_memory.approve', knowledgeMap)
                     : [];
                 const storedKnowledgeMap = this.store.readKnowledgeMap(status.projectId);
-                const contextRefreshOptions = action === 'project-memory reconcile'
-                    && storedKnowledgeMap.status === 'active'
+                const refreshAssessment = storedKnowledgeMap.status === 'active'
                     && storedKnowledgeMap.approval
-                    && isContentOnlyKnowledgeRefresh(storedKnowledgeMap, knowledgeMap)
-                    ? this.delegatedContextRefreshOptions(status.projectId, activeTask, knowledgeMap)
+                    ? assessDelegatedKnowledgeRefresh(storedKnowledgeMap, knowledgeMap, activeTask, activeTask.planHash
+                        ? this.store.hashArtifact(this.store.taskRoot(status.projectId, activeTask.id), 'plan.md')
+                        : null)
+                    : null;
+                const contextRefreshOptions = action === 'project-memory reconcile' && refreshAssessment?.eligible
+                    ? this.delegatedContextRefreshOptions(status.projectId, activeTask, knowledgeMap, refreshAssessment.mode)
                     : [];
                 return withAdoption({
                     scope: 'project-memory',
@@ -2163,11 +2193,21 @@ export class WorkflowService {
                         ? {
                             contextRefresh: {
                                 action: 'task context-refresh',
-                                mode: 'delegated-content-only',
+                                mode: refreshAssessment.mode,
+                                addedSources: refreshAssessment.addedSources,
                                 options: contextRefreshOptions,
                             },
                         }
                         : {}),
+                    ...(refreshAssessment && !refreshAssessment.eligible
+                        ? {
+                            contextRefreshBlocked: {
+                                reason: 'Knowledge drift is outside the atomic delegated refresh predicate.',
+                                unsafeDifferences: refreshAssessment.unsafeDifferences,
+                                requiredAction: 'Inspect and approve the Knowledge Map through the ordinary human flow.',
+                            },
+                        }
+                        : {}),
                 });
             }
             const knowledgeMapHash = hashKnowledgeMap(knowledgeMap);
@@ -2383,8 +2423,8 @@ export class WorkflowService {
             ? this.delegatedApprovalOptions(projectId, transition, task)
             : [];
         const failedReviewAttempts = countFailedReviewAttempts(this.store.taskRoot(projectId, task.id));
-        const guardedCorrectiveGate = task.status === 'needs_fix' && planRiskAudit
-            ? findFailedGuardedStepRequiringCorrectiveDecision(this.store, task, planRiskAudit)
+        const guardedCorrectivePosture = planRiskAudit
+            ? findCurrentGuardedRemediationPosture(this.store, task, planRiskAudit)
             : null;
         const next = nextForTask(task);
         const handoffPosture = readTaskC1Posture(this.store, task);
@@ -2428,6 +2468,110 @@ export class WorkflowService {
                         },
                     }
                     : {};
+        let guardedCorrectiveOverlay = {};
+        if (!strictStepReviewStep && guardedCorrectivePosture) {
+            switch (guardedCorrectivePosture.posture) {
+                case 'decision-required':
+                    if (guardedCorrectivePosture.correctiveDecision
+                        && guardedCorrectivePosture.correctiveDecision.planHash !== task.planHash) {
+                        try {
+                            const navigation = readValidatedCorrectiveDecisionRecoveryForNavigation(this.store, task, guardedCorrectivePosture.stepId);
+                            guardedCorrectiveOverlay = navigation.recovery
+                                ? {
+                                    action: 'task run',
+                                    stepId: guardedCorrectivePosture.stepId,
+                                    correctiveDecisionRecovery: {
+                                        state: 'validated',
+                                        recoveryEventId: navigation.recovery.eventId,
+                                        correctiveDecisionEventId: navigation.assessment.decision.eventId,
+                                    },
+                                }
+                                : {
+                                    action: 'task corrective-decision-recover',
+                                    stepId: guardedCorrectivePosture.stepId,
+                                    correctiveDecisionRecovery: {
+                                        state: 'required',
+                                        correctiveDecisionEventId: navigation.assessment.decision.eventId,
+                                        decisionPlanHash: navigation.assessment.decision.planHash,
+                                        reboundPlanHash: task.planHash,
+                                        triggeringAttemptCount: navigation.assessment.decision.triggeringAttemptCount,
+                                        requiredActor: readTaskC1Posture(this.store, task).state === 'claimed'
+                                            ? readTaskC1Posture(this.store, task).claimant
+                                            : null,
+                                    },
+                                };
+                        }
+                        catch (error) {
+                            guardedCorrectiveOverlay = {
+                                action: 'doctor',
+                                stepId: guardedCorrectivePosture.stepId,
+                                blockedAction: 'task corrective-decision-recover',
+                                correctiveDecisionRecovery: {
+                                    state: 'blocked',
+                                    reason: error instanceof Error ? error.message : String(error),
+                                },
+                            };
+                        }
+                        break;
+                    }
+                    guardedCorrectiveOverlay = {
+                        action: 'task corrective-decision',
+                        stepId: guardedCorrectivePosture.stepId,
+                        correctiveDecisionGate: {
+                            attemptCount: guardedCorrectivePosture.attemptCount,
+                            recommendedAuditor: defaultCorrectiveAuditorActor(task.id),
+                            auditorDerived: true,
+                            auditorMustDifferFromLatestStrictReviewer: true,
+                            allowedDecision: 'continue-fix',
+                            escalationDecisions: ['replan-required', 'split-required', 'stop-escalate'],
+                            humanApprovalRequired: false,
+                        },
+                    };
+                    break;
+                case 'hard-stop':
+                    guardedCorrectiveOverlay = {
+                        action: 'task corrective-decision',
+                        stepId: guardedCorrectivePosture.stepId,
+                        correctiveDecisionGate: {
+                            attemptCount: guardedCorrectivePosture.attemptCount,
+                            recommendedAuditor: defaultCorrectiveAuditorActor(task.id),
+                            auditorDerived: true,
+                            auditorMustDifferFromLatestStrictReviewer: true,
+                            allowedDecisions: ['split-required', 'stop-escalate'],
+                            hardStop: true,
+                            humanApprovalRequired: false,
+                        },
+                    };
+                    break;
+                case 'replan-required':
+                    guardedCorrectiveOverlay = {
+                        action: 'task plan-set',
+                        stepId: guardedCorrectivePosture.stepId,
+                        correctiveDecisionGate: {
+                            attemptCount: guardedCorrectivePosture.attemptCount,
+                            decision: guardedCorrectivePosture.correctiveDecision?.decision ?? null,
+                            decisionEventId: guardedCorrectivePosture.correctiveDecision?.eventId ?? null,
+                            requiredAction: 'Record an actual new Plan posture before another remediation run.',
+                        },
+                    };
+                    break;
+                case 'split-required':
+                case 'stop-escalate':
+                    guardedCorrectiveOverlay = {
+                        action: 'doctor',
+                        stepId: guardedCorrectivePosture.stepId,
+                        correctiveDecisionGate: {
+                            attemptCount: guardedCorrectivePosture.attemptCount,
+                            decision: guardedCorrectivePosture.correctiveDecision?.decision ?? null,
+                            decisionEventId: guardedCorrectivePosture.correctiveDecision?.eventId ?? null,
+                            humanApprovalRequired: false,
+                        },
+                    };
+                    break;
+                default:
+                    break;
+            }
+        }
         const result = {
             ...next,
             ...handoffOverlay,
@@ -2468,21 +2612,7 @@ export class WorkflowService {
                     },
                 }
                 : {}),
-            ...(guardedCorrectiveGate
-                ? {
-                    action: 'task corrective-decision',
-                    stepId: guardedCorrectiveGate.stepId,
-                    correctiveDecisionGate: {
-                        attemptCount: guardedCorrectiveGate.attemptCount,
-                        recommendedAuditor: defaultCorrectiveAuditorActor(task.id),
-                        auditorDerived: true,
-                        auditorMustDifferFromLatestStrictReviewer: true,
-                        allowedDecision: 'continue-fix',
-                        escalationDecisions: ['replan-required', 'split-required', 'stop-escalate'],
-                        humanApprovalRequired: false,
-                    },
-                }
-                : {}),
+            ...guardedCorrectiveOverlay,
             ...(delegatedApprovalOptions.length > 0 ? { delegatedApprovalOptions } : {}),
         };
         if (handoffPosture.state === 'pending') {
@@ -2516,10 +2646,13 @@ export class WorkflowService {
             policyHash: grant.policyHash,
         }));
     }
-    delegatedContextRefreshOptions(projectId, task, knowledgeMap) {
+    delegatedContextRefreshOptions(projectId, task, knowledgeMap, mode) {
         return this.store.listDelegations(projectId)
             .filter((grant) => {
             try {
+                if (mode === 'delegated-plan-bounded-supporting-source') {
+                    this.assertPlanBoundedSupportingSourceGrant(projectId, grant.id, grant.delegate, task);
+                }
                 return Boolean(this.delegatedAuthorization(projectId, grant.id, 'project_memory.approve', grant.delegate, knowledgeMap, task.id)
                     && this.delegatedAuthorization(projectId, grant.id, 'task.execution_authorize', grant.delegate, task));
             }
@@ -2540,6 +2673,23 @@ export class WorkflowService {
             policyHash: grant.policyHash,
         }));
     }
+    assertPlanBoundedSupportingSourceGrant(projectId, grantId, actor, task) {
+        const grant = this.store.readDelegation(projectId, grantId);
+        if (!task.milestoneId || grant.scope.kind !== 'milestone' || grant.scope.id !== task.milestoneId) {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Plan-bounded supporting-source refresh requires the active Task Milestone autonomy grant.', { taskId: task.id, taskMilestoneId: task.milestoneId, grantScope: grant.scope });
+        }
+        const milestone = this.store.readMilestone(projectId, task.milestoneId);
+        const autonomy = requireActiveMilestoneAutonomy({
+            store: this.store,
+            projectId,
+            milestone,
+            actor,
+            now: this.now(),
+        });
+        if (autonomy.grant.id !== grant.id) {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Milestone autonomy grant has been superseded.');
+        }
+    }
     assertDelegationScopeExists(projectId, policy) {
         if (policy.scope.kind === 'task') {
             this.store.readTask(projectId, policy.scope.id);
@@ -3028,11 +3178,6 @@ function appendCorrectivePlanAudit(taskRoot, previous, saved, failedReviewAttemp
         ...audit,
     })}\n`, { encoding: 'utf8', mode: 0o600 });
 }
-function assertContentOnlyKnowledgeRefresh(approved, inspected) {
-    if (!isContentOnlyKnowledgeRefresh(approved, inspected)) {
-        throw new WorkflowError('TRANSITION_BLOCKED', 'Automatic Task context refresh is limited to content-hash drift. Knowledge sources, categories, scopes, authorities, gaps, or conflicts changed.', { requiredAction: 'Run project-memory reconcile, inspect the classification diff, and approve it explicitly.' });
-    }
-}
 function isContentOnlyKnowledgeRefresh(approved, inspected) {
     const classification = (map) => JSON.stringify({
         entries: map.entries.map((entry) => ({
@@ -3048,6 +3193,107 @@ function isContentOnlyKnowledgeRefresh(approved, inspected) {
     });
     return classification(approved) === classification(inspected);
 }
+function assertDelegatedKnowledgeRefresh(assessment) {
+    if (assessment.eligible)
+        return;
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Knowledge drift is outside the atomic delegated context-refresh predicate: it is neither content-hash drift nor an exact Plan-bounded supporting-source addition.', {
+        unsafeDifferences: assessment.unsafeDifferences,
+        requiredAction: 'Run project-memory reconcile, inspect the classification diff, and approve it explicitly.',
+    });
+}
+function assessDelegatedKnowledgeRefresh(approved, inspected, task, currentPlanArtifactHash) {
+    if (isContentOnlyKnowledgeRefresh(approved, inspected)) {
+        return {
+            eligible: true,
+            mode: 'delegated-content-only',
+            addedSources: [],
+            unsafeDifferences: [],
+        };
+    }
+    const unsafeDifferences = [];
+    const sourceKey = (source) => `${source.category}\0${source.path}\0${source.scope}`;
+    const approvedByKey = new Map(approved.entries.map((source) => [sourceKey(source), source]));
+    const inspectedByKey = new Map(inspected.entries.map((source) => [sourceKey(source), source]));
+    const inspectedByPath = new Map(inspected.entries.map((source) => [source.path, source]));
+    for (const source of approved.entries) {
+        const candidate = inspectedByKey.get(sourceKey(source));
+        if (!candidate) {
+            const samePath = inspectedByPath.get(source.path);
+            unsafeDifferences.push(samePath
+                ? `Existing source ${source.path} changed category or scope from ${source.category}/${source.scope} to ${samePath.category}/${samePath.scope}.`
+                : `Previously approved source was removed: ${source.path}.`);
+            continue;
+        }
+        if (candidate.authority !== source.authority) {
+            unsafeDifferences.push(`Existing source ${source.path} changed authority from ${source.authority} to ${candidate.authority}.`);
+        }
+        if (candidate.id !== source.id || candidate.discoveredBy !== source.discoveredBy) {
+            unsafeDifferences.push(`Existing source ${source.path} changed classification identity.`);
+        }
+    }
+    const addedSources = inspected.entries.filter((source) => !approvedByKey.has(sourceKey(source)));
+    const currentExecutionAuthorization = [...task.authorizations].reverse().find((authorization) => authorization.kind === 'execution'
+        && authorization.decision === 'approved'
+        && authorization.planHash === task.planHash
+        && authorization.briefHash === task.briefHash);
+    if (!task.planHash || !currentExecutionAuthorization) {
+        unsafeDifferences.push('The current Task Plan was not execution-authorized before Knowledge drift.');
+    }
+    if (!task.planHash || currentPlanArtifactHash !== task.planHash) {
+        unsafeDifferences.push('The current Task Plan artifact does not match its authorized state binding.');
+    }
+    if (task.knowledgeImpact !== 'create') {
+        unsafeDifferences.push(`Task Plan knowledgeImpact is ${task.knowledgeImpact ?? 'unset'}, not create.`);
+    }
+    const declaredTargets = new Set();
+    for (const target of task.knowledgeTargets) {
+        let normalized;
+        try {
+            normalized = normalizeRelativePath(target.path);
+        }
+        catch {
+            unsafeDifferences.push(`Task Plan Knowledge target is not an exact repository-relative path: ${target.path}.`);
+            continue;
+        }
+        if (normalized !== target.path || /[*?\[\]{}]/.test(target.path) || target.path.endsWith('/')) {
+            unsafeDifferences.push(`Task Plan Knowledge target is wildcard, directory-like, or not normalized: ${target.path}.`);
+            continue;
+        }
+        declaredTargets.add(`${target.category}\0${target.path}`);
+    }
+    if (addedSources.length === 0) {
+        unsafeDifferences.push('No new Knowledge source matches the Plan-bounded addition path.');
+    }
+    for (const source of addedSources) {
+        if (source.authority !== 'supporting') {
+            unsafeDifferences.push(`New source ${source.path} has forbidden ${source.authority} authority.`);
+        }
+        if (!declaredTargets.has(`${source.category}\0${source.path}`)) {
+            unsafeDifferences.push(`New source ${source.path} (${source.category}) was not declared by the authorized Task Plan.`);
+        }
+    }
+    if (JSON.stringify(approved.gaps) !== JSON.stringify(inspected.gaps)) {
+        unsafeDifferences.push('Project Knowledge gaps changed.');
+    }
+    if (JSON.stringify(approved.conflicts) !== JSON.stringify(inspected.conflicts)) {
+        unsafeDifferences.push('Project Knowledge conflicts changed.');
+    }
+    if (inspected.conflicts.length > 0) {
+        unsafeDifferences.push('The inspected Project Knowledge Map contains conflicts.');
+    }
+    return {
+        eligible: unsafeDifferences.length === 0,
+        mode: 'delegated-plan-bounded-supporting-source',
+        addedSources: addedSources.map(({ id, path: sourcePath, category, scope, authority }) => ({
+            id,
+            path: sourcePath,
+            category,
+            scope,
+            authority,
+        })),
+        unsafeDifferences: [...new Set(unsafeDifferences)],
+    };
+}
 function validateMilestonePlan(plan) {
     if (!plan.outcome.trim())
         throw new WorkflowError('INVALID_ARGUMENT', 'Milestone outcome is required.');