@allocator-one/rcl 4.5.13 → 4.5.14

package/dist/index.js

@@ -49,7 +49,7 @@ import { DEFAULT_CONVERGE_ATTEMPT_CAP, claimConvergeAttempt, ConvergeAttemptBudg
 import { DEFAULT_CONVERGE_ROUND_CAP, HARD_CONVERGE_ROUND_CAP, processRoundReport, recordVerdicts, findingGatingReason, ConvergeRoundCapError, ConvergeRunStateError, } from './converge/run-state.js';
 import { applyRoundGap, previewRoundGap } from './converge/round-gap.js';
 import { withNativeTarget } from './converge/target-ownership.js';
-import { guardReviewLaunch, ReviewLaunchRefused } from './converge/launch-guard.js';
+import { guardReviewLaunch, ReviewCouncilInterrupted, ReviewLaunchRefused } from './converge/launch-guard.js';
 import { selectCurrentRecoveredProduction } from './converge/recovered-production.js';
 import { createBoundFixRecovery } from './converge/bound-fix-recovery.js';
 import { openReadSink } from './telemetry/read-sink.js';
@@ -87,7 +87,8 @@ import { exportOrdinaryPendingPackage, retainOrdinaryLaunchInputs } from './conv
 import { capturePreparedCouncil } from './dispatch/capture-council.js';
 import { executeCapturedOriginal } from './dispatch/original-execution.js';
 import { resolveFinalizedAsyncExecution } from './dispatch/checkpoint-async-store.js';
-import { exportCheckpointProof } from './dispatch/checkpoint.js';
+import { CheckpointJournal, checkpointPath, exportCheckpointProof } from './dispatch/checkpoint.js';
+import { runJournaledCouncil } from './dispatch/journaled-council.js';
 import { captureAggregationInputs, AGGREGATION_ALGORITHM } from './report/aggregation-inputs.js';
 import { decodeSupplementalAsync } from './report/supplemental-async.js';
 import { projectCheckpointReport } from './report/checkpoint-projection.js';
@@ -253,6 +254,7 @@ program
     .option('--resume-async-sha256 <hashes>', 'Comma-separated SHA-256 bindings for every legacy async result retained as historical evidence')
     .option('--retry-reason <reason>', 'Explicit bounded recovery decision for a previous failed or unknown launch; never resets caps')
     .option('--max-attempts <n>', 'Guarded convergence: explicitly authorized attempt cap (omitting preserves the cap)')
+    .option('--max-slice-minutes <n>', 'Guarded convergence: start no new reviewer call after N minutes; running calls finish, then exit 5. Rerunning the same command resumes without a new attempt')
     .option('--max-rounds <n>', 'Guarded convergence: explicitly authorized round cap (2–99; omitting preserves the cap)')
     .option('--no-telemetry', 'Do not deliver this review as evidence to Harness')
     .option('--evidence-required', 'Exit 4 unless Harness acknowledged the evidence (spools first; retry with rcl telemetry flush)')
@@ -1763,8 +1765,11 @@ async function runReview(target, opts) {
             catch { /* Startup delivery remains best-effort for legacy reviews. */ }
         }
         if (!opts.guardedConverge && (opts.launchIntent !== undefined || opts.retryReason !== undefined || opts.retryReport !== undefined ||
-            opts.maxAttempts !== undefined || opts.maxRounds !== undefined)) {
-            throw new ReviewLaunchRefused('guard_required', 'Launch intent, retry reason and launch caps require --guarded-converge.');
+            opts.maxAttempts !== undefined || opts.maxRounds !== undefined || opts.maxSliceMinutes !== undefined)) {
+            throw new ReviewLaunchRefused('guard_required', 'Launch intent, retry reason, launch caps and slice budgets require --guarded-converge.');
+        }
+        if (opts.maxSliceMinutes !== undefined && (!/^[1-9]\d{0,3}$/.test(opts.maxSliceMinutes) || Number(opts.maxSliceMinutes) > 1440)) {
+            throw new ReviewLaunchRefused('invalid_slice_budget', '--max-slice-minutes must be a whole number of minutes from 1 to 1440.');
         }
         if (opts.guardedConverge) {
             const converge = resolveConvergeContext(opts, reviewConvergeEnvironment(opts));
@@ -1912,7 +1917,8 @@ async function runReview(target, opts) {
             console.error(err);
         }
         process.exitCode = opts.guardedConverge && (err instanceof ConvergeAttemptBudgetExceededError || err instanceof ConvergeRoundCapError)
-            ? 2 : opts.guardedConverge && (err instanceof ConvergeAttemptStateError || err instanceof ConvergeRunStateError) ? 3 : 1;
+            ? 2 : opts.guardedConverge && (err instanceof ConvergeAttemptStateError || err instanceof ConvergeRunStateError) ? 3
+            : opts.guardedConverge && err instanceof ReviewCouncilInterrupted ? 5 : 1;
     }
 }
 /**
@@ -2218,10 +2224,38 @@ async function executeCouncil(spinner, prepared, diff, opts, extra, preparedWork
             }
             return result.completion;
         }
+        // Journal the ordinary council so an interrupted process resumes without
+        // repeating successful calls (RCL-80). Without an exact head and base, or
+        // inputs beyond the capture limits, dispatch stays unjournaled.
+        let ordinaryPlan;
+        if (/^[a-f0-9]{40}$/.test(extra.target.headSha ?? '') && /^[a-f0-9]{40}$/.test(extra.target.baseSha ?? '')) {
+            try {
+                ordinaryPlan = capturePreparedCouncil({ target: prepared.converge.target,
+                    headSha: extra.target.headSha, mergeBaseSha: extra.target.baseSha, diff, assignments,
+                    lanes: assignments.map(item => assignmentLane(item.model, prepared.coreModels, prepared.explicit)),
+                    chunks, prompts, config, specBytes: prepared.specContent ?? '', contextDocs,
+                    compatibility: { parser: { name: 'findings-json', version: 1 }, aggregation: AGGREGATION_ALGORITHM } }).plan;
+            }
+            catch (error) {
+                process.stderr.write(`Council journal unavailable (${scrubText(String(error), 200)}); an interrupted run cannot resume.\n`);
+            }
+        }
+        const journalPlan = ordinaryPlan;
+        if (opts.maxSliceMinutes !== undefined && !journalPlan) {
+            throw new ReviewLaunchRefused('slice_budget_unavailable', '--max-slice-minutes needs a journaled council (an exact head and base within the capture limits); rerun without it.');
+        }
         const claim = await guardReviewLaunch({
             gitCommonDir: await resolveGitCommonDir(),
             target: prepared.converge.target,
             startOver: opts.startOver, cycleRemote,
+            ...(journalPlan ? { ordinaryCheckpoint: { exists: async (namespace) => {
+                        try {
+                            return !!await CheckpointJournal.openRead(checkpointPath(common, prepared.converge.target, namespace), journalPlan);
+                        }
+                        catch {
+                            return false;
+                        }
+                    } } } : {}),
             boundFixRecovery,
             recoverySource: prepared.converge.recovery_source,
             headSha: extra.target.headSha ?? '',
@@ -2263,8 +2297,10 @@ async function executeCouncil(spinner, prepared, diff, opts, extra, preparedWork
                 if (boundFixRecovery)
                     process.stderr.write(`Bound fix recovery verified from run ${boundFixRecovery.runId}; attempt ${claim.attempt} retains the existing review history.\n`);
             },
-            run: async (converge) => {
-                const guardedCompletion = await executeCouncil(spinner, { ...prepared, converge }, diff, { ...opts, guardedConverge: false, exclusiveOutputs: true }, extra, work);
+            run: async (converge, ownership, _original, checkpoint) => {
+                if (checkpoint?.resumed)
+                    process.stderr.write(`Resuming the interrupted council of attempt ${converge.attempt}; journaled calls are not repeated.\n`);
+                const guardedCompletion = await executeCouncil(spinner, { ...prepared, converge }, diff, { ...opts, guardedConverge: false, exclusiveOutputs: true }, { ...extra, ...(checkpoint && journalPlan ? { ordinaryCheckpoint: { ...checkpoint, ownership, plan: journalPlan } } : {}) }, work);
                 if (!guardedCompletion)
                     throw new Error('guarded_launch_missing_completion');
                 completion = guardedCompletion;
@@ -2289,7 +2325,7 @@ async function executeCouncil(spinner, prepared, diff, opts, extra, preparedWork
     let asyncStoreDir;
     let asyncKey;
     let asyncLaunched = 0;
-    if (!extra.pendingResume &&
+    if (!extra.pendingResume && !extra.ordinaryCheckpoint?.resumed &&
         asyncTargetLabel !== undefined &&
         (asyncAssignments.length > 0 || (config.asyncModels?.length ?? 0) > 0)) {
         try {
@@ -2396,8 +2432,8 @@ async function executeCouncil(spinner, prepared, diff, opts, extra, preparedWork
                 policy: { version: 1, fraction: config.quorumFraction ?? DEFAULT_QUORUM_FRACTION } });
             chunkReviews = pendingProjection.seatReviews.map(seat => structuredClone(seat.review));
         }
-        else
-            chunkReviews = await runReviews(chunkAssignments.map((ca) => ca.assignment), prompts, {
+        else {
+            const ordinaryRunner = {
                 // Fall back to the shared constants, never to inline literals:
                 // duplicated defaults drift (this read 120_000 after the default
                 // moved to 600_000).
@@ -2418,7 +2454,26 @@ async function executeCouncil(spinner, prepared, diff, opts, extra, preparedWork
                     blocking: chunkAssignments.map((ca) => assignmentLane(ca.assignment.model, prepared.coreModels, prepared.explicit) === 'blocking'),
                 },
                 onReviewComplete: (review) => progress.complete(review),
-            });
+            };
+            const checkpoint = extra.ordinaryCheckpoint;
+            if (checkpoint) {
+                const open = { commonDir: await resolveGitCommonDir(), namespace: checkpoint.namespace,
+                    plan: checkpoint.plan, ownership: checkpoint.ownership };
+                const journal = await (checkpoint.resumed ? CheckpointJournal.openWrite(open) : CheckpointJournal.create(open));
+                const sliceEndsAt = opts.maxSliceMinutes === undefined ? undefined : Date.now() + Number(opts.maxSliceMinutes) * 60_000;
+                const journaled = await runJournaledCouncil({ journal, ownership: checkpoint.ownership,
+                    assignments: chunkAssignments.map((ca) => ca.assignment), prompts, runner: ordinaryRunner,
+                    ...(sliceEndsAt === undefined ? {} : { admit: () => Date.now() < sliceEndsAt }) });
+                if (journaled.retained > 0)
+                    process.stderr.write(`Reused ${journaled.retained} journaled call(s) from the interrupted council.\n`);
+                if (journaled.interrupted) {
+                    throw new ReviewCouncilInterrupted(journaled.reviews.filter(review => review.status !== 'canceled').length, totalCalls);
+                }
+                chunkReviews = journaled.reviews;
+            }
+            else
+                chunkReviews = await runReviews(chunkAssignments.map((ca) => ca.assignment), prompts, ordinaryRunner);
+        }
     }
     finally {
         progress.stop();