codex-workflow-v2 2.0.0-beta.1 → 2.0.0-beta.2

package/dist/src/workflow.d.ts

@@ -74,6 +74,18 @@ export interface Alpha6StrictReviewRescuePreflight {
         expectedRevision?: number;
     }>;
 }
+interface MilestoneInitialAssemblyOption {
+    action: 'linked-task-assembly' | 'milestone plan-set';
+    commands: string[];
+    description: string;
+}
+interface MilestoneInitialAssemblyNavigation {
+    milestoneId: string;
+    revision: number;
+    linkedTaskIds: string[];
+    executionAvailable: false;
+    options: MilestoneInitialAssemblyOption[];
+}
 export declare class WorkflowService {
     readonly store: FileStateStore;
     private readonly now;
@@ -158,6 +170,7 @@ export declare class WorkflowService {
         discoveries: DiscoveryState[];
         tasks: TaskState[];
         milestones: MilestoneState[];
+        milestoneInitialAssembly: MilestoneInitialAssemblyNavigation[];
         delegations: DelegationGrant[];
         adoption: AdoptionPreparation;
     };
@@ -188,6 +201,7 @@ export declare class WorkflowService {
     private delegatedAuthorization;
     private assertHandoffGrant;
     private nextForTaskWithDelegation;
+    private taskPlanContract;
     private assertTaskContextChangeAllowed;
     private taskHasTerminalCorrectiveDecision;
     private taskTerminalCorrectivePosture;
@@ -200,6 +214,9 @@ export declare class WorkflowService {
     private readMilestoneCurrent;
     private readMilestoneScopeChangeCurrent;
     private listMilestonesCurrent;
+    private taskGitNavigationOverride;
+    private withTaskNavigationContracts;
+    private describeMilestoneInitialAssembly;
     private prepareMilestoneScopeChangeCandidate;
     private proveWriterLeaseTokenForHandoff;
     private proveOptionalWriterLeaseToken;
@@ -217,3 +234,4 @@ export declare class WorkflowService {
     private validateKnowledgeTargets;
     private assertReviewFresh;
 }
+export {};

package/dist/src/workflow.js

@@ -13,7 +13,7 @@ import { appendTaskClaim, appendTaskHandback, appendTaskHandoff, assertTaskMutat
 import { applyAdoptionPosture, assertAdoptionBaselinePreserved, buildAdoptionPreparation, initializeProjectRegistrationAdoption, readCurrentAdoptionPosture, } from './alpha6/adoption.js';
 import { appendCurrentPlanRiskAudit, appendReboundPlanRiskAudit, readCurrentPlanRiskAudit, validatePlanRiskAuditCandidate, } from './alpha6/plan-risk.js';
 import { appendCorrectiveDecisionEvent, appendRemediationEvent, appendRemediationModeRecovery, assertCorrectiveAuditorIndependence, assertGuardedRemediationAttemptAllowed, defaultCorrectiveAuditorActor, findCurrentGuardedRemediationPosture, findRemediationModeRecoveryCandidate, findFailedGuardedStepRequiringCorrectiveDecision, readGuardedRemediationPostureForStep, readCorrectiveDecisionEvents, readRemediationEvents, } from './alpha6/remediation.js';
-import { applyMilestoneScopeChangeTransaction, assertMilestoneMembershipIntegrity, assertMilestoneScopeChangeStatusAllowed, normalizeMilestonePlan, prepareMilestoneScopeChangeCandidate, prepareMilestoneScopeChangeBundle, readMilestoneForScopeChange, readMilestoneWithIntegrity, } from './alpha6/milestone.js';
+import { assessMilestoneInitialAssembly, applyMilestoneScopeChangeTransaction, assertMilestoneMembershipIntegrity, assertMilestoneScopeChangeStatusAllowed, normalizeMilestonePlan, prepareMilestoneScopeChangeCandidate, prepareMilestoneScopeChangeBundle, readMilestoneForScopeChange, readMilestoneWithIntegrity, } from './alpha6/milestone.js';
 import { applyProjectTransaction, recoverProjectTransactions, runRollbackProjectTransaction, } from './beta1/project-transaction.js';
 import { buildCurrentStrictStepReviewCycle, ensurePendingStrictStepReview, isStepReviewRequired, recordStrictStepReview, } from './alpha6/review.js';
 import { applyMilestoneAutonomyContract, assertAutonomousPlanEvolution, prepareMilestoneAutonomyContract, readMilestoneAutonomyEvents, requireActiveMilestoneAutonomy, } from './alpha7/autonomy.js';
@@ -2154,11 +2154,15 @@ export class WorkflowService {
         const tasks = this.store.listTasks(identity.projectId);
         const rawMilestones = this.store.listMilestones(identity.projectId);
         const adoption = this.inspectAdoptionPreparation(identity, tasks, rawMilestones);
+        const milestones = this.listMilestonesCurrent(identity.projectId, adoption.currentPosture);
         return {
             projectId: identity.projectId,
             discoveries: this.store.listDiscoveries(identity.projectId),
             tasks,
-            milestones: this.listMilestonesCurrent(identity.projectId, adoption.currentPosture),
+            milestones,
+            milestoneInitialAssembly: milestones
+                .map((milestone) => this.describeMilestoneInitialAssembly(identity.projectId, milestone, tasks))
+                .filter((value) => value !== null),
             delegations: this.store.listDelegations(identity.projectId),
             adoption,
         };
@@ -2588,6 +2592,31 @@ export class WorkflowService {
         }
         const activeMilestone = status.milestones.find((milestone) => !['accepted', 'cancelled'].includes(milestone.status));
         if (activeMilestone) {
+            const initialAssembly = status.milestoneInitialAssembly
+                .find((candidate) => candidate.milestoneId === activeMilestone.id) ?? null;
+            if (initialAssembly) {
+                const activeDiscovery = status.discoveries.find((discovery) => !['materialized', 'abandoned'].includes(discovery.status));
+                if (activeDiscovery) {
+                    return withAdoption({
+                        scope: 'discovery',
+                        id: activeDiscovery.id,
+                        status: activeDiscovery.status,
+                        action: activeDiscovery.status === 'ready_to_materialize' ? 'discovery materialize' : 'discovery update',
+                        readiness: assessDiscovery(activeDiscovery),
+                        milestoneInitialAssembly: initialAssembly,
+                    });
+                }
+                return withAdoption({
+                    scope: 'milestone',
+                    id: activeMilestone.id,
+                    status: activeMilestone.status,
+                    action: 'milestone initial-assembly',
+                    revision: activeMilestone.revision,
+                    linkedTaskIds: initialAssembly.linkedTaskIds,
+                    executionAvailable: initialAssembly.executionAvailable,
+                    milestoneInitialAssembly: initialAssembly,
+                });
+            }
             if (activeMilestone.status === 'awaiting_final_acceptance') {
                 const root = this.store.milestoneRoot(activeMilestone.projectId, activeMilestone.id);
                 const evidence = JSON.parse(readFileSync(path.join(root, 'evidence.json'), 'utf8'));
@@ -2794,7 +2823,7 @@ export class WorkflowService {
                     throw error;
             }
         }
-        const next = nextForTask(task);
+        const next = this.taskGitNavigationOverride(task) ?? nextForTask(task);
         const handoffPosture = readTaskC1Posture(this.store, task);
         const strictStepReviewStep = planRiskAudit
             ? task.steps.find((step) => {
@@ -3051,13 +3080,31 @@ export class WorkflowService {
             ...(delegatedApprovalOptions.length > 0 ? { delegatedApprovalOptions } : {}),
         };
         if (handoffPosture.state === 'pending') {
-            return {
+            return this.withTaskNavigationContracts(task, {
                 ...result,
                 action: 'task claim',
                 blockedAction: next.action,
-            };
+            });
         }
-        return result;
+        const navigableResult = ['task plan-set', 'task plan-set with independent corrective audit']
+            .includes(String(result.action))
+            ? {
+                ...result,
+                taskPlanContract: this.taskPlanContract(projectId, task),
+            }
+            : result;
+        return this.withTaskNavigationContracts(task, navigableResult);
+    }
+    taskPlanContract(projectId, task) {
+        const map = this.store.readKnowledgeMap(projectId);
+        return {
+            requiredRequirementIds: [...task.requirements],
+            requiredAcceptanceIds: [...task.acceptance],
+            currentRisks: [...task.risks],
+            exactInclusionRequired: true,
+            briefHash: task.briefHash,
+            knowledgeMap: knowledgeSummary(map),
+        };
     }
     assertTaskContextChangeAllowed(task) {
         const posture = this.taskTerminalCorrectivePosture(task);
@@ -3205,6 +3252,70 @@ export class WorkflowService {
             ? milestone
             : readMilestoneWithIntegrity(this.store, projectId, milestone.id, (taskId) => this.store.readTask(projectId, taskId), () => this.store.listTasks(projectId))));
     }
+    taskGitNavigationOverride(task) {
+        if (task.status !== 'merging' || task.workspaceOwner !== 'local' || !task.baseCommit || !task.taskBranch) {
+            return null;
+        }
+        const currentBase = runGit(task.repositoryRoot, ['rev-parse', task.baseBranch]);
+        if (currentBase === task.baseCommit)
+            return null;
+        return {
+            scope: 'task',
+            id: task.id,
+            status: task.status,
+            action: 'task sync-base',
+            revision: task.revision,
+            baseSyncRequired: {
+                baseBranch: task.baseBranch,
+                recordedBaseCommit: task.baseCommit,
+                currentBaseCommit: currentBase,
+            },
+        };
+    }
+    withTaskNavigationContracts(task, next) {
+        const action = typeof next.action === 'string' ? next.action : null;
+        if (!action)
+            return next;
+        const policy = gitMutationPolicyForAction(task, action);
+        const claimedC1Posture = readTaskC1Posture(this.store, task).state === 'claimed';
+        const writerTokenContract = writerTokenContractForAction(action, claimedC1Posture);
+        return {
+            ...next,
+            ...(policy ? { gitMutationPolicy: policy } : {}),
+            ...(writerTokenContract ? { writerTokenContract } : {}),
+        };
+    }
+    describeMilestoneInitialAssembly(projectId, milestone, tasks) {
+        const assessment = assessMilestoneInitialAssembly({
+            store: this.store,
+            projectId,
+            milestone,
+            listTasks: () => tasks,
+        });
+        if (!assessment.eligible)
+            return null;
+        const options = [
+            {
+                action: 'linked-task-assembly',
+                commands: ['discovery start', 'discovery materialize'],
+                description: 'Start or materialize the next linked Task Discovery for this Milestone before closing the initial membership Plan.',
+            },
+        ];
+        if (assessment.orphanTaskIds.length > 0) {
+            options.push({
+                action: 'milestone plan-set',
+                commands: ['milestone plan-set'],
+                description: 'Record one complete initial Milestone Plan that classifies every currently linked Task.',
+            });
+        }
+        return {
+            milestoneId: milestone.id,
+            revision: milestone.revision,
+            linkedTaskIds: assessment.orphanTaskIds,
+            executionAvailable: false,
+            options,
+        };
+    }
     prepareMilestoneScopeChangeCandidate(projectId, milestone, plan, actor) {
         validateMilestonePlan(plan);
         return prepareMilestoneScopeChangeCandidate({
@@ -3860,13 +3971,13 @@ function nextForTask(task) {
         awaiting_execution_authorization: 'task authorize',
         ready: task.workspaceOwner ? (stepsComplete ? 'task submit' : 'task run') : 'task start',
         in_progress: activeStep ? 'task step-complete' : stepsComplete ? 'task submit' : 'task run',
-        validating: task.review.status === 'passed' ? 'task result-set' : 'task review-record',
+        validating: task.review.status === 'passed' ? 'task result-set' : 'task review-launch',
         needs_fix: task.steps.some((step) => step.status === 'failed') ? 'task run' : 'task plan-set',
         awaiting_final_acceptance: 'task accept',
         merging: 'task merge',
         ready_to_merge: 'task merge-confirm',
         merged: 'none',
-        blocked: task.review.status === 'unverified' ? 'task review-record' : 'doctor',
+        blocked: task.review.status === 'unverified' ? 'task review-launch' : 'doctor',
         cancelled: 'none',
     };
     const selectedStep = activeStep ?? failedStep ?? runnableStep;
@@ -3888,6 +3999,73 @@ function nextForTask(task) {
             : {}),
     };
 }
+function gitMutationPolicyForAction(task, action) {
+    const metadataWrites = ['.git/index', '.git/index.lock', '.git/HEAD', '.git/refs', '.git/logs'];
+    switch (action) {
+        case 'task start':
+            return {
+                permission: 'git-metadata-write',
+                requiredBeforeFirstCall: true,
+                boundedToTransition: true,
+                transition: 'task start',
+                appliesWhen: { workspaceOwner: 'local' },
+                metadataWrites,
+            };
+        case 'task step-complete':
+            return {
+                permission: 'git-metadata-write',
+                requiredBeforeFirstCall: true,
+                boundedToTransition: true,
+                transition: 'task step-complete',
+                metadataWrites,
+            };
+        case 'task merge':
+            if (task.workspaceOwner !== 'local')
+                return null;
+            return {
+                permission: 'git-metadata-write',
+                requiredBeforeFirstCall: true,
+                boundedToTransition: true,
+                transition: 'task merge',
+                metadataWrites,
+            };
+        case 'task sync-base':
+            return {
+                permission: 'git-metadata-write',
+                requiredBeforeFirstCall: true,
+                boundedToTransition: true,
+                transition: 'task sync-base',
+                metadataWrites,
+            };
+        default:
+            return null;
+    }
+}
+function writerTokenContractForAction(action, claimedC1Posture = false) {
+    const alwaysLeaseBound = ['task step-complete', 'task submit', 'task merge', 'task merge-confirm'];
+    const claimedC1LeaseBound = [
+        'task run',
+        'task step-review',
+        'task review-record',
+        'task review-launch',
+        'task corrective-decision-recover',
+        'task remediation-mode-recover',
+        'task corrective-decision',
+        'task handoff',
+        'task handoff-prepare',
+        'task handback',
+        'task handback-create',
+    ];
+    if (!alwaysLeaseBound.includes(action) && !(claimedC1Posture && claimedC1LeaseBound.includes(action))) {
+        return null;
+    }
+    return {
+        required: true,
+        option: '--writer-token',
+        source: 'active-writer-lease',
+        sensitive: true,
+    };
+}
 function knowledgeSummary(map) {
     return {
         revision: map.revision,