looply-cli 0.5.32 → 0.5.34

package/dist/run-cmd.js

@@ -28,6 +28,7 @@ const evidence_cache_1 = require("./evidence-cache");
 const control_file_1 = require("./control-file");
 const git_driver_1 = require("./git-driver");
 const untrusted_gate_1 = require("./untrusted-gate");
+const checkout_deps_1 = require("./checkout-deps");
 const model_transport_1 = require("./model-transport");
 const agent_envelope_1 = require("./agent-envelope");
 const provider_limit_1 = require("./provider-limit");
@@ -2862,6 +2863,10 @@ async function runLoop(opts) {
     const adaptiveTier = adaptiveBudget.compile;
     let compileTimedOut = false;
     let checkTimedOut = false;
+    // RBB-B-218: the step check's own tier, and whether a pass this run checked nothing in time.
+    const verifyKey = binding.kind === 'bound' ? (0, verify_cmd_2.verifyTimeoutKey)(binding.goal.id, binding.goal.version) : null;
+    const verifyTier = (0, verify_cmd_2.verifierTierFor)(verifyKey === null ? 0 : (0, planner_timeouts_1.plannerTimeoutsFor)(projectStateDirPath, verifyKey));
+    let verifyTimedOut = false;
     /**
      * A PLANNER THAT RAN OUT OF TIME IS THE MACHINE'S LIMIT, NOT THE GOAL'S FAULT: the run leaves
      * with `environment` / `planner_timeout`, so the controller voids this Start (it costs no try),
@@ -2873,6 +2878,16 @@ async function runLoop(opts) {
      * at the same eight minutes again — finished work that is never judged is never delivered.
      */
     const plannerTimedOut = (message) => {
+        /**
+         * A STEP CHECK THAT RAN OUT OF TIME, with nothing made ready (RBB-B-218): the machine's limit.
+         * The goal is neither judged nor re-planned on it — four plans were spent that way on steps
+         * never tried, and the goal ended "plan_limit_reached" with nothing delivered.
+         */
+        if (verifyTimedOut && verifyKey !== null) {
+            const n = (0, planner_timeouts_1.notePlannerTimeout)(projectStateDirPath, verifyKey);
+            return new RunRefused(`${message} — checking this plan's steps against the code took longer than its limit; the next Start checks each with ` +
+                `${Math.round((0, verify_cmd_2.verifierTierFor)(n).timeoutMs / 60000)} minutes, and this Start does not count`, 'environment', undefined, undefined, 'planner_timeout');
+        }
         if (checkTimedOut && binding.kind === 'bound') {
             const n = (0, planner_timeouts_1.notePlannerTimeout)(projectStateDirPath, (0, adaptive_budget_1.goalCheckTimeoutKey)(binding.goal.id, binding.goal.version));
             return new RunRefused(`${message} — the goal check took longer than its limit; the next Start checks with ${Math.round((0, goal_gap_1.goalCheckTimeoutFor)(n) / 60000)} minutes, ` +
@@ -2885,7 +2900,7 @@ async function runLoop(opts) {
         return new RunRefused(`${message} — planning took longer than its limit; the next Start plans with ${Math.round(next.timeoutMs / 60000)} minutes ` +
             `for at most ${next.maxSteps} steps, and this Start does not count`, 'environment', undefined, undefined, 'planner_timeout');
     };
-    let verifyBudget = Math.min(verify_cmd_2.VERIFY_MAX_PER_RUN, compileTier.maxSteps);
+    let verifyBudget = Math.min(verify_cmd_2.VERIFY_MAX_PER_RUN, compileTier.maxSteps, verifyTier.maxPerRun);
     /**
      * EVERYTHING A START DOES BEFORE THE RUN, under one guard.
      *
@@ -3308,7 +3323,7 @@ async function runLoop(opts) {
                 const pass = await (0, verify_pass_1.verifyDrafts)({
                     queue: runQueue,
                     ledger: ledgerForRun,
-                    verify: (0, verify_cmd_1.makeItemVerifier)(verifyAgent, queue),
+                    verify: (0, verify_cmd_1.makeItemVerifier)(verifyAgent, queue, verifyTier.timeoutMs),
                     cachePut: (id, head, ev) => evidence.put(id, head, ev),
                     headSha: () => git.headSha(),
                     projectId,
@@ -3329,6 +3344,8 @@ async function runLoop(opts) {
                 verifyBudget -= pass.checked;
                 log(`verify  : ${pass.ready} of ${pass.checked} are ready to work on`);
                 pickable = pass.ready;
+                if (pass.ready === 0 && pass.timedOut > 0)
+                    verifyTimedOut = true;
             }
         }
         /**
@@ -3349,7 +3366,8 @@ async function runLoop(opts) {
          * work, and it is never reached again afterwards. `runner.run()` returns to a
          * `finally` that does nothing but clean up.
          */
-        if (!pickable && scope !== null && binding.kind === 'bound' && !compiledThisRun) {
+        // A pass that checked nothing in time judges nothing: the goal check and a new plan wait for a Start that can (RBB-B-218).
+        if (!pickable && scope !== null && binding.kind === 'bound' && !compiledThisRun && !verifyTimedOut) {
             const bound = binding.goal;
             // Captured, because `scope` moves when a new plan is materialised below and
             // the callbacks here must go on describing the goal they were built for.
@@ -3737,7 +3755,7 @@ async function runLoop(opts) {
                             const pass = await (0, verify_pass_1.verifyDrafts)({
                                 queue: runQueue,
                                 ledger: ledgerForRun,
-                                verify: (0, verify_cmd_1.makeItemVerifier)(verifyAgent, queue),
+                                verify: (0, verify_cmd_1.makeItemVerifier)(verifyAgent, queue, verifyTier.timeoutMs),
                                 cachePut: (id, head, ev) => evidence.put(id, head, ev),
                                 headSha: () => git.headSha(),
                                 projectId,
@@ -3750,6 +3768,8 @@ async function runLoop(opts) {
                             verifyBudget -= pass.checked;
                             log(`verify  : ${pass.ready} of ${pass.checked} are ready to work on`);
                             pickable = pass.ready;
+                            if (pass.ready === 0 && pass.timedOut > 0)
+                                verifyTimedOut = true;
                         }
                     }
                 }
@@ -3771,6 +3791,8 @@ async function runLoop(opts) {
             return reproAsks;
         if (seamFailure !== null)
             return `could not check this goal — ${seamFailure}`;
+        if (verifyTimedOut && adaptive === null)
+            return `no step of this plan could be checked against the code in time — ${(0, queue_summary_1.describeNoReady)(runQueue.list())}`;
         const said = adaptive === null ? null : (0, goal_adaptive_1.describeAdaptive)(adaptive, attestedNow(), coverage);
         if (said !== null)
             return said.message;
@@ -3906,6 +3928,12 @@ async function runLoop(opts) {
                 throw said.terminal ? new RunRefused(said.message, said.code, refusedOn, delivery) : (plannerTimedOut(said.message) ?? new Error(said.message));
             }
         }
+        if (verifyTimedOut) {
+            // Before the work-set exits: a step left `unclear` by a timeout is not a person's question.
+            await releaseHold();
+            const unchecked = `no step of this plan could be checked against the code in time — ${(0, queue_summary_1.describeNoReady)(runQueue.list())}`;
+            throw plannerTimedOut(unchecked) ?? new Error(unchecked);
+        }
         const left = scope === null ? null : (0, core_1.workLeft)(runQueue.list());
         if (left === 'finished') {
             // A WORK-SET fact, not a goal verdict: every row reached a terminal state.
@@ -4417,6 +4445,26 @@ async function runLoop(opts) {
      * not when AutoRyn or the file switched it off (`gates.baseCheck`, `run.base_check`).
      */
     const baseCheckWanted = binding.kind === 'bound' && effectiveGates.baseCheck && config.run.baseCheck !== false;
+    /**
+     * THE CHECKS' DEPENDENCIES, BEFORE ANYTHING IS JUDGED (AUT-B-62, `checkout-deps.ts`): a package folder the
+     * gates run in, with a lockfile but no `node_modules`, is installed from its lockfile in the checkout's
+     * sandbox — with internet access, which the gates themselves never get. A failed install is a machine
+     * fault in the package manager's own words, never a red base.
+     */
+    const depsWanted = binding.kind === 'bound';
+    let depsInstalled = false;
+    const dependenciesBeforeFirstRound = async () => {
+        const plan = (0, checkout_deps_1.dependencyInstallPlan)(config.gates, (0, checkout_deps_1.checkoutDepsFs)(cwd));
+        if (plan.length === 0)
+            return { ok: true };
+        const out = await (0, checkout_deps_1.installDependencies)({ plan, runner: (0, untrusted_gate_1.makeUntrustedGateRunner)(cwd, { network: 'internet-client' }), log });
+        if (out.kind === 'failed') {
+            log(`deps    : ${out.because}`);
+            return { ok: false, because: out.because };
+        }
+        depsInstalled = out.kind === 'installed';
+        return { ok: true };
+    };
     const baseHealthBeforeFirstRound = async () => {
         const steps = config.gates;
         let record;
@@ -4424,7 +4472,8 @@ async function runLoop(opts) {
             const treeSha = await git.headTreeSha();
             const key = (0, gate_health_1.baseHealthKey)(treeSha, steps);
             record = (0, gate_health_1.readBaseHealth)(projectStateDirPath);
-            if ((0, gate_health_1.reusable)(record, key, Date.now())) {
+            // Dependencies installed this run: what any earlier check of this base said was said without them.
+            if (!depsInstalled && (0, gate_health_1.reusable)(record, key, Date.now())) {
                 log(`base    : the checks on this base were ${record.state} at ${record.checkedAt}`);
             }
             else {
@@ -4521,7 +4570,7 @@ async function runLoop(opts) {
          * The runner calls this after its own preconditions and after an item is
          * picked, which is the first moment a round is certain.
          */
-        ...((retryToSpend === null || safety === null) && !baseCheckWanted
+        ...((retryToSpend === null || safety === null) && !baseCheckWanted && !depsWanted
             ? {}
             : {
                 beforeFirstRound: async () => {
@@ -4529,6 +4578,11 @@ async function runLoop(opts) {
                      * THE BASE FIRST: a check red on the unchanged code would throw away every round,
                      * so it is found here, before the one retry below is spent on a round it would doom.
                      */
+                    if (depsWanted) {
+                        const deps = await dependenciesBeforeFirstRound();
+                        if (!deps.ok)
+                            return deps;
+                    }
                     if (baseCheckWanted) {
                         const health = await baseHealthBeforeFirstRound();
                         if (!health.ok)