@resolveio/server-lib 22.3.186 → 22.3.188

package/util/aicoder-runner-v6.d.ts

@@ -124,6 +124,7 @@ export interface ResolveIOAICoderWorkflowProofReadiness {
     evaluatedAt: string;
 }
 export type ResolveIOAICoderV6ContinuationAction = 'continue' | 'retry_same_step' | 'switch_to_repair' | 'park' | 'budget_stop' | 'infra_retry' | 'ready_to_publish';
+export type ResolveIOAICoderNextActionCostRisk = 'free_or_deterministic' | 'small_model_or_qa' | 'expensive_model' | 'release_or_customer_send' | 'manual_blocked';
 export type ResolveIOAICoderWorkflowReadinessStatus = 'journey_contract_required' | 'journey_contract_repair_required' | 'workflow_build_ready' | 'workflow_qa_required' | 'workflow_business_proof_ready' | 'release_repair_required' | 'infra_repair_only' | 'compile_repair_only' | 'collect_new_evidence' | 'budget_stopped' | 'parked';
 export type ResolveIOAICoderWorkflowReadinessGate = 'journey_contract' | 'build' | 'workflow_qa' | 'release' | 'infra' | 'compile' | 'evidence' | 'manual';
 export type ResolveIOAICoderWorkflowProofCheckpointStatus = 'waiting_for_journey_contract' | 'waiting_for_workflow_proof' | 'waiting_for_new_evidence' | 'waiting_for_release_gate' | 'waiting_for_infra_or_compile' | 'ready_to_continue';
@@ -172,6 +173,49 @@ export interface ResolveIOAICoderWorkflowReadiness {
     businessProofArtifacts: string[];
     workflowProofCheckpoint: ResolveIOAICoderWorkflowProofCheckpoint;
 }
+export interface ResolveIOAICoderNextActionContract {
+    contractId: string;
+    action: ResolveIOAICoderV6ContinuationAction;
+    label: string;
+    primaryCommand: string;
+    lane: ResolveIOAICoderV6Lane;
+    stepType: ResolveIOAICoderV6StepType;
+    safeToAutoRun: boolean;
+    requiresHumanApproval: boolean;
+    canRunWithoutCodexMonitor: boolean;
+    codexFallbackRequired: boolean;
+    codexFallbackReason: string;
+    costRisk: ResolveIOAICoderNextActionCostRisk;
+    workflowFirstSatisfied: boolean;
+    decisionBasis: {
+        journeyContractReady: boolean;
+        workflowProofReady: boolean;
+        sampleDataReady: boolean;
+        releaseBlocked: boolean;
+        routeOnlyBlocked: boolean;
+        infraOnly: boolean;
+        compileOnly: boolean;
+        sameFailureParked: boolean;
+        canPublish: boolean;
+        canPolishWowUi: boolean;
+        workflowReadinessStatus: string;
+        workflowProofCheckpointStatus: string;
+        failureClass: string;
+        evidenceHash: string;
+        hotfixCommitRequired: boolean;
+        liveHotfixBlockedUntilCommit: boolean;
+    };
+    preconditions: string[];
+    expectedStateTransition: string;
+    successEvidence: string[];
+    requiredHotfixCommitProof: string[];
+    stopConditions: string[];
+    forbiddenActions: string[];
+    nextCommands: string[];
+    blockers: string[];
+    ownerFiles?: string[];
+    createdAt: string;
+}
 export interface ResolveIOAICoderV6SupervisorState {
     version: 'v6';
     runKind: ResolveIOAICoderV6RunKind;
@@ -296,6 +340,7 @@ export interface ResolveIOAICoderV6ContinuationDecision {
     budgetExceeded: boolean;
     workflowReadiness: ResolveIOAICoderWorkflowReadiness;
     workflowProofCheckpoint: ResolveIOAICoderWorkflowProofCheckpoint;
+    nextActionContract: ResolveIOAICoderNextActionContract;
     recoveryPlan: ResolveIOAIManagerRecoveryPlan;
     recoveryCheckpoint: ResolveIOAIManagerRecoveryCheckpoint;
     recoveryEvidenceProbe: ResolveIOAIManagerRecoveryEvidenceProbe;
@@ -339,6 +384,17 @@ export declare function buildResolveIOAICoderV6WorkflowReadiness(bundle: Resolve
     budgetExceeded?: boolean;
     repeatedNoProgressCount?: number;
 }): ResolveIOAICoderWorkflowReadiness;
+export declare function buildResolveIOAICoderNextActionContract(input: {
+    bundle: ResolveIOAICoderV6StateBundle;
+    action: ResolveIOAICoderV6ContinuationAction;
+    reason: string;
+    nextLane: ResolveIOAICoderV6Lane;
+    nextStep: ResolveIOAICoderV6StepType;
+    budgetExceeded?: boolean;
+    workflowReadiness: ResolveIOAICoderWorkflowReadiness;
+    workflowProofCheckpoint: ResolveIOAICoderWorkflowProofCheckpoint;
+    now?: Date | string;
+}): ResolveIOAICoderNextActionContract;
 export declare function buildResolveIOAICoderV6Budget(existing?: Partial<ResolveIOAICoderV6Budget>): ResolveIOAICoderV6Budget;
 export declare function initializeResolveIOAICoderV6State(input: ResolveIOAICoderV6InitializeInput): ResolveIOAICoderV6StateBundle;
 export declare function recordResolveIOAICoderV6Step(bundle: ResolveIOAICoderV6StateBundle, step: ResolveIOAICoderV6StepInput): ResolveIOAICoderV6StateBundle;

package/util/aicoder-runner-v6.js

@@ -55,6 +55,7 @@ exports.evaluateResolveIOAICoderWorkflowProofReadiness = evaluateResolveIOAICode
 exports.fingerprintResolveIOAICoderV6Blocker = fingerprintResolveIOAICoderV6Blocker;
 exports.buildResolveIOAICoderWorkflowProofCheckpoint = buildResolveIOAICoderWorkflowProofCheckpoint;
 exports.buildResolveIOAICoderV6WorkflowReadiness = buildResolveIOAICoderV6WorkflowReadiness;
+exports.buildResolveIOAICoderNextActionContract = buildResolveIOAICoderNextActionContract;
 exports.buildResolveIOAICoderV6Budget = buildResolveIOAICoderV6Budget;
 exports.initializeResolveIOAICoderV6State = initializeResolveIOAICoderV6State;
 exports.recordResolveIOAICoderV6Step = recordResolveIOAICoderV6Step;
@@ -1547,6 +1548,252 @@ function buildResolveIOAICoderV6WorkflowReadiness(bundle, context) {
         workflowProofCheckpoint: workflowProofCheckpoint
     };
 }
+function aicoderNextActionLabel(command) {
+    switch (command) {
+        case 'repair_aicoder_journey_contract':
+            return 'Repair Journey Contract';
+        case 'run_aicoder_workflow_build':
+            return 'Build North-Star Workflow';
+        case 'run_aicoder_workflow_qa':
+            return 'Run Workflow QA';
+        case 'repair_aicoder_release_gate':
+            return 'Repair Release Gate';
+        case 'repair_aicoder_compile_gate':
+            return 'Repair Compile Gate';
+        case 'repair_aicoder_infra_gate':
+            return 'Repair Infra Gate';
+        case 'run_aicoder_owner_scoped_repair':
+            return 'Run Scoped Repair';
+        case 'publish_aicoder_after_workflow_proof':
+            return 'Publish After Workflow Proof';
+        case 'park_aicoder_until_new_evidence':
+            return 'Park Until New Evidence';
+        case 'park_aicoder_budget_stop':
+            return 'Park Budget Stop';
+        default:
+            return 'Continue Workflow';
+    }
+}
+function aicoderNextActionPrimaryCommand(action, readiness) {
+    if (action === 'budget_stop') {
+        return 'park_aicoder_budget_stop';
+    }
+    if (action === 'park') {
+        return 'park_aicoder_until_new_evidence';
+    }
+    if (action === 'infra_retry') {
+        return readiness.compileOnly ? 'repair_aicoder_compile_gate' : 'repair_aicoder_infra_gate';
+    }
+    if (readiness.status === 'journey_contract_required' || readiness.status === 'journey_contract_repair_required') {
+        return 'repair_aicoder_journey_contract';
+    }
+    if (readiness.status === 'workflow_build_ready') {
+        return 'run_aicoder_workflow_build';
+    }
+    if (readiness.status === 'workflow_qa_required') {
+        return 'run_aicoder_workflow_qa';
+    }
+    if (readiness.status === 'release_repair_required') {
+        return 'repair_aicoder_release_gate';
+    }
+    if (action === 'ready_to_publish') {
+        return 'publish_aicoder_after_workflow_proof';
+    }
+    if (action === 'switch_to_repair' || action === 'retry_same_step') {
+        return 'run_aicoder_owner_scoped_repair';
+    }
+    return 'continue_aicoder_workflow';
+}
+function aicoderNextActionCostRisk(action, command, readiness) {
+    if (action === 'park' || action === 'budget_stop' || readiness.requiresHumanDecision) {
+        return 'manual_blocked';
+    }
+    if (action === 'ready_to_publish' || command === 'repair_aicoder_release_gate' || readiness.nextGate === 'release') {
+        return 'release_or_customer_send';
+    }
+    if (command === 'run_aicoder_workflow_qa' || command === 'repair_aicoder_compile_gate' || command === 'repair_aicoder_infra_gate') {
+        return 'small_model_or_qa';
+    }
+    if (command === 'continue_aicoder_workflow') {
+        return 'free_or_deterministic';
+    }
+    return 'expensive_model';
+}
+function aicoderNextActionExpectedTransition(command) {
+    switch (command) {
+        case 'repair_aicoder_journey_contract':
+            return 'Missing or invalid journey contract becomes a validated first/next/last workflow graph with QA rows.';
+        case 'run_aicoder_workflow_build':
+            return 'Journey contract becomes implemented workflow screens, hub action, data story, and reachable completion state.';
+        case 'run_aicoder_workflow_qa':
+            return 'Route/browser evidence becomes AIQaBusinessAssertion proof for the north-star workflow.';
+        case 'repair_aicoder_release_gate':
+            return 'Publish/deploy/sample-data blocker becomes hotfix evidence, release-gate evidence, or one explicit force-deploy decision.';
+        case 'repair_aicoder_compile_gate':
+            return 'Compile failure becomes a passing build or a new compile blocker fingerprint.';
+        case 'repair_aicoder_infra_gate':
+            return 'Infra/preflight failure becomes a passing startup/browser/Mongo gate or a new infra blocker fingerprint.';
+        case 'run_aicoder_owner_scoped_repair':
+            return 'Current blocker changes to passed, a new evidence hash, or a parked manual decision.';
+        case 'publish_aicoder_after_workflow_proof':
+            return 'Workflow-proven artifact moves through the release gate exactly once with publish/deploy evidence recorded.';
+        case 'park_aicoder_budget_stop':
+        case 'park_aicoder_until_new_evidence':
+            return 'Runner stops spending until an operator records new evidence or an explicit next action.';
+        default:
+            return 'Runner advances to the next workflow-first gate with evidence recorded.';
+    }
+}
+function buildResolveIOAICoderNextActionStopConditions(readiness, command) {
+    var stopConditions = [
+        'Do not accept scorecard, wow score, or route load as app success without AIQaBusinessAssertion workflow proof.'
+    ];
+    if (!readiness.journeyContractReady || command === 'repair_aicoder_journey_contract') {
+        stopConditions.push('Do not run build tasks until docs/APP_JOURNEY_CONTRACT.md validates with first/next/last workflow steps.');
+    }
+    if (!readiness.businessProofReady || readiness.routeOnlyBlocked || command === 'run_aicoder_workflow_qa') {
+        stopConditions.push('Do not publish or run wow UI polish until workflow business proof passes.');
+        stopConditions.push('Route-only proof must stay labeled as route evidence, not acceptance.');
+    }
+    if (readiness.releaseBlocked || command === 'repair_aicoder_release_gate') {
+        stopConditions.push('Do not repeat a full publish/deploy until release blocker evidence changes or hotfix/force evidence is recorded.');
+    }
+    if (readiness.infraOnly || readiness.compileOnly) {
+        stopConditions.push('Infra, startup, Puppeteer, Chrome, Mongo, and compile failures stay in infra/compile repair; do not charge them as product workflow failure.');
+    }
+    if (readiness.sameFailureParked) {
+        stopConditions.push('Do not retry the same model/code repair until the blocker fingerprint, evidence hash, or workflow proof artifact changes.');
+    }
+    if (readiness.requiresHumanDecision) {
+        stopConditions.push('Do not spend additional model or release budget until an operator records the next bounded action.');
+    }
+    return Array.from(new Set(stopConditions)).slice(0, 12);
+}
+function buildResolveIOAICoderNextActionContract(input) {
+    var workflowReadiness = input.workflowReadiness;
+    var workflowProofCheckpoint = input.workflowProofCheckpoint;
+    var history = Array.isArray(input.bundle.aiCoderV6StepHistory) ? input.bundle.aiCoderV6StepHistory : [];
+    var last = history[history.length - 1];
+    var command = aicoderNextActionPrimaryCommand(input.action, workflowReadiness);
+    var costRisk = aicoderNextActionCostRisk(input.action, command, workflowReadiness);
+    var hotfixCommitRequired = command === 'repair_aicoder_release_gate'
+        || workflowReadiness.releaseBlocked
+        || workflowReadiness.nextGate === 'release';
+    var liveHotfixBlockedUntilCommit = hotfixCommitRequired;
+    var requiredHotfixCommitProof = hotfixCommitRequired
+        ? ['sourceCommitSha', 'githubCommitUrl', 'gitCommitStatus=passed', 'gitPushStatus=passed']
+        : [];
+    var requiresHumanApproval = input.action === 'park'
+        || input.action === 'budget_stop'
+        || input.action === 'ready_to_publish'
+        || input.budgetExceeded === true
+        || workflowReadiness.requiresHumanDecision === true;
+    var workflowFirstSatisfied = workflowReadiness.journeyContractReady
+        && workflowReadiness.businessProofReady
+        && !workflowReadiness.releaseBlocked
+        && !workflowReadiness.routeOnlyBlocked
+        && !workflowReadiness.infraOnly
+        && !workflowReadiness.compileOnly
+        && !workflowReadiness.sameFailureParked;
+    var safeToAutoRun = !requiresHumanApproval && (command === 'repair_aicoder_journey_contract'
+        || command === 'run_aicoder_workflow_build'
+        || command === 'run_aicoder_workflow_qa'
+        || command === 'repair_aicoder_release_gate'
+        || command === 'repair_aicoder_compile_gate'
+        || command === 'repair_aicoder_infra_gate'
+        || (command === 'run_aicoder_owner_scoped_repair' && workflowReadiness.canRunProductRepair)
+        || (command === 'continue_aicoder_workflow' && !workflowReadiness.blockers.length));
+    var canRunWithoutCodexMonitor = safeToAutoRun
+        && workflowProofCheckpoint.requiredEvidence.length > 0
+        && workflowProofCheckpoint.nextAction.length > 0;
+    var blockers = Array.from(new Set(__spreadArray(__spreadArray([], __read(workflowReadiness.blockers), false), __read((workflowProofCheckpoint.status === 'waiting_for_new_evidence' ? workflowProofCheckpoint.requiredResetEvidence : [])), false))).slice(0, 12);
+    var preconditions = Array.from(new Set(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([
+        workflowProofCheckpoint.nextAction
+    ], __read(workflowProofCheckpoint.requiredEvidence), false), __read((workflowReadiness.journeyContractReady ? [] : ['validated APP_JOURNEY_CONTRACT.md journey_contract JSON'])), false), __read((workflowReadiness.canRunWorkflowQa ? ['workflow QA rows generated from the journey contract'] : [])), false), __read((workflowReadiness.releaseBlocked ? ['release blocker artifact or hotfix-first release evidence'] : [])), false), __read((hotfixCommitRequired ? ['sourceCommitSha, githubCommitUrl, passed gitCommitStatus, and passed gitPushStatus before live hotfix apply'] : [])), false).map(function (entry) { return cleanText(entry, 300); }).filter(Boolean))).slice(0, 12);
+    var successEvidence = Array.from(new Set(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(workflowProofCheckpoint.requiredEvidence), false), __read((workflowReadiness.businessProofReady ? ['retained AIQaBusinessAssertion artifact'] : [])), false), __read((workflowReadiness.canPublish ? ['release gate accepts the workflow-proven artifact'] : [])), false), __read((command === 'repair_aicoder_release_gate' ? ['hotfix evidence or explicit one-time force release decision'] : [])), false), __read((hotfixCommitRequired ? ['GitHub commit and push proof for any manager-applied hotfix'] : [])), false).map(function (entry) { return cleanText(entry, 300); }).filter(Boolean))).slice(0, 12);
+    var stopConditions = buildResolveIOAICoderNextActionStopConditions(workflowReadiness, command);
+    if (hotfixCommitRequired) {
+        stopConditions.push('Do not apply a live AICoder backend/static hotfix until sourceCommitSha, githubCommitUrl, passed gitCommitStatus, and passed gitPushStatus are recorded.');
+    }
+    var forbiddenActions = Array.from(new Set(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([
+        'accepting route-only proof as app success',
+        'accepting scorecard-only or wow-score-only proof as app success'
+    ], __read((workflowReadiness.journeyContractReady ? [] : ['building product routes before the journey contract validates'])), false), __read((workflowReadiness.businessProofReady ? [] : ['publishing before north-star workflow business proof passes'])), false), __read((workflowReadiness.releaseBlocked ? ['rerunning full deploy/publish without changed release evidence'] : [])), false), __read((hotfixCommitRequired ? ['applying live hotfix before pushed GitHub commit proof'] : [])), false), __read((workflowReadiness.sameFailureParked ? ['retrying the same repair loop without new evidence'] : [])), false))).slice(0, 12);
+    var nextCommands = Array.from(new Set(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([
+        command
+    ], __read((command === 'repair_aicoder_journey_contract' ? ['validate_aicoder_journey_contract', 'generate_workflow_qa_rows'] : [])), false), __read((command === 'run_aicoder_workflow_qa' ? ['execute_contract_qa_assertions', 'record_aiqa_business_assertion'] : [])), false), __read((command === 'repair_aicoder_release_gate' ? [
+        'collect_release_blocker_evidence',
+        'prefer_hotfix_before_full_deploy',
+        'prepare_hotfix_patch_without_live_apply',
+        'commit_and_push_hotfix_to_github',
+        'record_github_commit_for_hotfix',
+        'apply_live_hotfix_only_after_github_commit_proof'
+    ] : [])), false), __read((command === 'repair_aicoder_compile_gate' ? ['rerun_compile_gate_only', 'record_compile_evidence_hash'] : [])), false), __read((command === 'repair_aicoder_infra_gate' ? ['rerun_preflight_gate_only', 'record_infra_evidence_hash'] : [])), false), [
+        'record_aicoder_next_action_result'
+    ], false))).slice(0, 12);
+    var contractBasis = {
+        action: input.action,
+        reason: cleanText(input.reason, 500),
+        command: command,
+        readinessStatus: workflowReadiness.status,
+        checkpointStatus: workflowProofCheckpoint.status,
+        failureClass: cleanText(last === null || last === void 0 ? void 0 : last.failureClass, 120),
+        evidenceHash: (0, ai_runner_manager_policy_1.hashResolveIOAIManagerEvidence)(last)
+    };
+    return {
+        contractId: "aicoder-next-".concat((0, ai_runner_manager_policy_1.hashResolveIOAIManagerEvidence)({
+            failureClass: contractBasis.failureClass,
+            summary: "".concat(contractBasis.reason, ":").concat(contractBasis.command, ":").concat(contractBasis.readinessStatus, ":").concat(contractBasis.checkpointStatus),
+            evidenceHash: contractBasis.evidenceHash,
+            changedFiles: last === null || last === void 0 ? void 0 : last.changedFiles,
+            artifactPaths: last === null || last === void 0 ? void 0 : last.artifactPaths
+        })),
+        action: input.action,
+        label: aicoderNextActionLabel(command),
+        primaryCommand: command,
+        lane: input.nextLane,
+        stepType: input.nextStep,
+        safeToAutoRun: safeToAutoRun,
+        requiresHumanApproval: requiresHumanApproval,
+        canRunWithoutCodexMonitor: canRunWithoutCodexMonitor,
+        codexFallbackRequired: !canRunWithoutCodexMonitor && !requiresHumanApproval,
+        codexFallbackReason: canRunWithoutCodexMonitor
+            ? ''
+            : requiresHumanApproval
+                ? 'Operator approval is required before the next action.'
+                : 'Next action needs stronger deterministic evidence before it can run unattended.',
+        costRisk: costRisk,
+        workflowFirstSatisfied: workflowFirstSatisfied,
+        decisionBasis: {
+            journeyContractReady: workflowReadiness.journeyContractReady,
+            workflowProofReady: workflowReadiness.businessProofReady,
+            sampleDataReady: workflowReadiness.businessProofReady && !workflowReadiness.releaseBlocked,
+            releaseBlocked: workflowReadiness.releaseBlocked,
+            routeOnlyBlocked: workflowReadiness.routeOnlyBlocked,
+            infraOnly: workflowReadiness.infraOnly,
+            compileOnly: workflowReadiness.compileOnly,
+            sameFailureParked: workflowReadiness.sameFailureParked,
+            canPublish: workflowReadiness.canPublish,
+            canPolishWowUi: workflowReadiness.canPolishWowUi,
+            workflowReadinessStatus: workflowReadiness.status,
+            workflowProofCheckpointStatus: workflowProofCheckpoint.status,
+            failureClass: contractBasis.failureClass,
+            evidenceHash: cleanText((last === null || last === void 0 ? void 0 : last.evidenceHash) || contractBasis.evidenceHash, 160),
+            hotfixCommitRequired: hotfixCommitRequired,
+            liveHotfixBlockedUntilCommit: liveHotfixBlockedUntilCommit
+        },
+        preconditions: preconditions,
+        expectedStateTransition: aicoderNextActionExpectedTransition(command),
+        successEvidence: successEvidence,
+        requiredHotfixCommitProof: requiredHotfixCommitProof,
+        stopConditions: stopConditions,
+        forbiddenActions: forbiddenActions,
+        nextCommands: nextCommands,
+        blockers: blockers,
+        ownerFiles: cleanList(last === null || last === void 0 ? void 0 : last.changedFiles, 20, 500),
+        createdAt: isoNow(input.now)
+    };
+}
 function buildResolveIOAICoderV6Budget(existing) {
     return {
         maxPromptTokensPerNonInitialStep: Number((existing === null || existing === void 0 ? void 0 : existing.maxPromptTokensPerNonInitialStep) || 4000),
@@ -1825,7 +2072,17 @@ function decideResolveIOAICoderV6Continuation(bundle) {
             budgetExceeded: decision.budgetExceeded,
             repeatedNoProgressCount: decision.repeatedNoProgressCount
         });
-        return __assign(__assign({}, decision), { workflowReadiness: workflowReadiness, workflowProofCheckpoint: workflowReadiness.workflowProofCheckpoint });
+        var workflowProofCheckpoint = workflowReadiness.workflowProofCheckpoint;
+        return __assign(__assign({}, decision), { workflowReadiness: workflowReadiness, workflowProofCheckpoint: workflowProofCheckpoint, nextActionContract: buildResolveIOAICoderNextActionContract({
+                bundle: bundle,
+                action: decision.action,
+                reason: decision.reason,
+                nextLane: decision.nextLane,
+                nextStep: decision.nextStep,
+                budgetExceeded: decision.budgetExceeded,
+                workflowReadiness: workflowReadiness,
+                workflowProofCheckpoint: workflowProofCheckpoint
+            }) });
     };
     var budgetExceeded = (budget.loopCount >= budget.maxLoopsPerRun && !managerDecision.loopBudgetShouldReset)
         || budget.totalPromptTokenEstimate >= budget.maxTotalPromptTokens