looply-cli 0.5.10 → 0.5.11

package/dist/run-cmd.js

@@ -63,9 +63,13 @@ const programme_mode_1 = require("./programme-mode");
 const partial_asker_1 = require("./partial-asker");
 const goal_ownership_1 = require("./goal-ownership");
 const goal_compile_1 = require("./goal-compile");
+const planner_timeouts_1 = require("./planner-timeouts");
 const plan_recovery_1 = require("./plan-recovery");
 const goal_execution_evidence_1 = require("./goal-execution-evidence");
 const goal_reproof_1 = require("./goal-reproof");
+const goal_replay_1 = require("./goal-replay");
+const branch_replay_1 = require("./branch-replay");
+const run_base_2 = require("./run-base");
 const round_records_1 = require("./round-records");
 const goal_gap_1 = require("./goal-gap");
 const goal_adaptive_1 = require("./goal-adaptive");
@@ -128,6 +132,7 @@ class RunRefused extends Error {
     code;
     branch;
     delivery;
+    environment;
     /**
      * The same refusal, for a machine.
      *
@@ -152,11 +157,17 @@ class RunRefused extends Error {
      * delivering run, the commit, and each required step's outcome. Carried to
      * the mark so the daemon can settle the pursuit with facts, not a sentence.
      */
-    delivery) {
+    delivery, 
+    /**
+     * Which machine fault, on an `environment` refusal only — carried to the mark so the
+     * controller's hold names it (`environment-hold.ts`).
+     */
+    environment) {
         super(message);
         this.code = code;
         this.branch = branch;
         this.delivery = delivery;
+        this.environment = environment;
     }
 }
 exports.RunRefused = RunRefused;
@@ -1024,6 +1035,9 @@ async function runLoop(opts) {
      * ⚠️ AN ARROW, for the same flow-analysis reason as `recordDelivery` below.
      */
     const deliveringBranch = async () => {
+        // The branch this goal's work was REBUILT onto, when it was: that is the tree that was proved.
+        if (rebuiltAs !== null)
+            return rebuiltAs.branch;
         if (deliveringRunId === null)
             return branch;
         const cut = (0, run_delivery_1.deliveringBranchOf)((0, lane_claims_1.readLaneClaims)(cwd), deliveringRunId);
@@ -2802,7 +2816,31 @@ async function runLoop(opts) {
      * would put sixty minutes of verifier inside a sixty-minute window. They draw
      * from one budget instead.
      */
-    let verifyBudget = verify_cmd_2.VERIFY_MAX_PER_RUN;
+    /**
+     * THE PLANNING TIER (`goal-compile.ts`, COMPILE_TIERS): after a timed-out planning of this goal
+     * version, a longer limit and a smaller plan, so the worst case stays inside the window. The
+     * verify budget shrinks with the plan — that is what pays for the longer compile.
+     */
+    // PROJECT-scoped: a goal's next Start may be placed in another checkout, and must still know.
+    const plannedTimeouts = binding.kind === 'bound' ? (0, planner_timeouts_1.plannerTimeoutsFor)(projectStateDirPath, `${binding.goal.id}@${binding.goal.version}`) : 0;
+    const compileTier = (0, goal_compile_1.compileTierFor)(plannedTimeouts);
+    const adaptiveTier = (0, goal_compile_1.compileTierFor)(plannedTimeouts, goal_compile_1.ADAPTIVE_COMPILE_TIERS);
+    let compileTimedOut = 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),
+     * and the timeout is counted so the next Start plans with the next tier. Null when no planning
+     * timed out in this run — the exit is then whatever it was.
+     */
+    const plannerTimedOut = (message) => {
+        if (!compileTimedOut || binding.kind !== 'bound')
+            return null;
+        const n = (0, planner_timeouts_1.notePlannerTimeout)(projectStateDirPath, `${binding.goal.id}@${binding.goal.version}`);
+        const next = (0, goal_compile_1.compileTierFor)(n);
+        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);
     /**
      * EVERYTHING A START DOES BEFORE THE RUN, under one guard.
      *
@@ -2882,6 +2920,10 @@ async function runLoop(opts) {
     let deliveringRunId = null;
     // L4b: the commit key 2 confirmed HEAD on, beside the run that delivered it.
     let deliveringSha = null;
+    /** This goal's work, rebuilt onto the base for the goal check (`goal-replay.ts`), when it was. */
+    let rebuiltAs = null;
+    /** Why it could not be rebuilt, when that was tried and failed: what the next revision plans around. */
+    let replayTrouble = null;
     /** F27: the tree this Start's evaluator judged, when a programme moved HEAD to the tree the lane holds. */
     let judged = { kind: 'as-is', because: 'no goal-met check ran' };
     /** The first compile's authority answer, kept so its reason is the acted-on one. */
@@ -2927,11 +2969,16 @@ async function runLoop(opts) {
                         checks: config.gates.map((g) => g.name),
                     }),
             }, {
-                compile: (i) => (0, goal_compile_1.compileGoal)(i, { invoke: planAgent }),
+                compile: async (i) => {
+                    const out = await (0, goal_compile_1.compileGoal)(i, { invoke: planAgent, timeoutMs: compileTier.timeoutMs, maxSteps: compileTier.maxSteps });
+                    if (!out.ok && out.failure === 'timed-out')
+                        compileTimedOut = true;
+                    return out;
+                },
                 // M3-2: checked at the committed tree before any step becomes an item; the compile recorded either way.
                 check: (steps) => (0, compile_check_1.checkCompiledPlan)(steps, compileReaders, compiledAt),
                 log: (line) => log(`compile : ${line}`),
-            }, goal_compile_1.COMPILE_MAX_STEPS);
+            }, compileTier.maxSteps);
             // A step whose citation did not hold is re-planned, an empty plan is asked again as an instruction,
             // and only then does a ticket get one direct step (`plan-recovery.ts`) — never a hand-back.
             const compiled = recovered.compiled;
@@ -3193,6 +3240,53 @@ async function runLoop(opts) {
                     }
                     log(`goal    : judging ${(0, goal_met_target_1.describeTarget)(judged)}`);
                 }
+                /**
+                 * THE CODE MOVED AWAY FROM THIS GOAL'S WORK: REBUILD IT ONTO THE BASE, THEN JUDGE THAT TREE
+                 * (`goal-replay.ts`, owner ruling 2026-10-16). In a checkout Looply made, when HEAD holds none
+                 * of this plan's commits, they are replayed onto the base as a fresh run branch BEFORE the
+                 * evaluator looks — so the verdict and the gates are about the same tree, and the branch holds
+                 * only this goal's work. A replay that does not apply puts HEAD back; KEY 2 then plans what is
+                 * missing instead of refusing (`replan`).
+                 */
+                if (judged.kind === 'as-is' && (0, reaper_1.hasProvisionedMarker)(cwd)) {
+                    const rounds = await (0, round_records_1.readRoundRecords)(stateDir, ledger_store_1.nodeLedgerFs);
+                    if (rounds.ok) {
+                        const committed = (0, goal_execution_evidence_1.committedShasOf)({ scope: askedScope, items: owned, rounds: rounds.rounds });
+                        const aligned = await (0, goal_replay_1.alignWithOwnWork)({
+                            headSha: () => git.headSha(),
+                            changedPaths: () => git.changedPaths(),
+                            isAncestor: (a, of) => git.isAncestor(a, of),
+                            baseRef: async () => (await (0, run_base_2.resolveBaseBranch)(git, config.run.baseBranch).catch(() => null))?.ref ?? null,
+                            commitOf: (ref) => git.commitOf(ref),
+                            // The same patch replay the delivery rebuild uses: never a 3-way merge (`branch-replay.ts`).
+                            replay: (base, shas) => (0, branch_replay_1.replayOnto)((0, git_driver_1.nodeGitExec)(cwd), (dir) => (0, git_driver_1.nodeGitExec)(dir), base, shas),
+                            commitsBetween: async (base, sha) => (await (0, git_driver_1.nodeGitExec)(cwd)(['rev-list', '--reverse', `${base}..${sha}`])).stdout.split(/\r?\n/).filter((l) => l.trim() !== ''),
+                            createBranch: (name, from) => git.createBranch(name, from),
+                        }, { committed, branch: `${branch}-rebuilt`, aliases: (0, goal_replay_1.replayedAs)(projectStateDirPath, goalId) });
+                        if (aligned.kind === 'rebuilt') {
+                            (0, goal_replay_1.recordReplay)(projectStateDirPath, goalId, aligned.picked);
+                            (0, run_base_1.writeCheckoutGoal)(stateDir, { goalId, branch: aligned.branch, at: new Date().toISOString() });
+                            (0, lane_claims_1.recordLaneClaim)(cwd, {
+                                schema: lane_claims_1.LANE_CLAIMS_SCHEMA,
+                                kind: 'claims',
+                                at: new Date().toISOString(),
+                                branch: aligned.branch,
+                                runId,
+                                goalId,
+                                goalVersion: bound.version,
+                                planRevision: revision,
+                                servings: [],
+                                workspace: cwd,
+                            });
+                            rebuiltAs = { branch: aligned.branch, head: aligned.head };
+                            log(`goal    : this goal's ${committed.length} commit(s) were not in the tree here — rebuilt onto ${aligned.base} as ${aligned.branch}; judging that`);
+                        }
+                        else if (aligned.kind === 'failed') {
+                            replayTrouble = aligned.because;
+                            log(`goal    : ${aligned.because}`);
+                        }
+                    }
+                }
                 adaptive = await (0, goal_adaptive_1.decideAdaptive)({
                     goalId: scope.goalId,
                     goalVersion: bound.version,
@@ -3233,10 +3327,19 @@ async function runLoop(opts) {
                     compile: async (i, maxSteps) => {
                         const at = await git.headTreeSha().catch(() => null);
                         const recovered = await (0, plan_recovery_1.compileWithRecovery)(i, {
-                            compile: (j) => (0, goal_compile_1.compileGoal)(j, { invoke: planAgent, maxSteps }),
+                            compile: async (j) => {
+                                const out = await (0, goal_compile_1.compileGoal)(j, {
+                                    invoke: planAgent,
+                                    maxSteps: Math.min(maxSteps, adaptiveTier.maxSteps),
+                                    timeoutMs: adaptiveTier.timeoutMs,
+                                });
+                                if (!out.ok && out.failure === 'timed-out')
+                                    compileTimedOut = true;
+                                return out;
+                            },
                             check: (steps) => (0, compile_check_1.checkCompiledPlan)(steps, compileReaders, at),
                             log: (line) => log(`goal    : ${line}`),
-                        }, maxSteps);
+                        }, Math.min(maxSteps, adaptiveTier.maxSteps));
                         return recovered.compiled;
                     },
                     changedPaths: () => git.changedPaths(),
@@ -3272,16 +3375,47 @@ async function runLoop(opts) {
                          */
                         if (!confirmed.ok && confirmed.moved === true && judged.kind !== 'carried') {
                             log('goal    : the code moved on since this plan was delivered — running the gates again at the current tree');
+                            let reproofVerdict = null;
                             const again = await (0, goal_reproof_1.reproveAtHead)(head, (0, goal_execution_evidence_1.committedShasOf)(key2Input), {
                                 changedPaths: () => git.changedPaths(),
                                 isAncestor: (a, of) => git.isAncestor(a, of),
                                 changedPathsBetween: (from, to) => git.changedPathsBetween(from, to),
-                                runGates: async (paths) => (await (0, gate_1.runGate)({ steps: config.gates, changedPaths: paths, runner: (0, untrusted_gate_1.makeUntrustedGateRunner)(cwd) })).steps,
+                                runGates: async (paths) => {
+                                    const gate = await (0, gate_1.runGate)({ steps: config.gates, changedPaths: paths, runner: (0, untrusted_gate_1.makeUntrustedGateRunner)(cwd) });
+                                    reproofVerdict = gate.verdict;
+                                    return gate.steps;
+                                },
+                                aliases: (0, goal_replay_1.replayedAs)(projectStateDirPath, goalId),
                             });
                             confirmed = again.ok
                                 ? (0, goal_execution_evidence_1.confirmGoalExecutionEvidence)({ ...key2Input, rechecked: { contains: again.contains, steps: again.steps } })
                                 : { ok: false, because: `${goal_execution_evidence_1.CODE_MOVED_ON}, and it could not be checked again: ${again.because}` };
                             log(`goal    : ${confirmed.ok ? 'the gates pass at the current tree, and this plan’s work is in it' : confirmed.because}`);
+                            if (!confirmed.ok) {
+                                /**
+                                 * NEVER A HAND-BACK FOR THIS (owner ruling 2026-10-16). Three answers, none of them a
+                                 * person's question:
+                                 *   - the gate could not RUN here (sandbox, tool): the machine's fault — retryable, and
+                                 *     the run's words name it, so the Start is voided (`environment`);
+                                 *   - the tree has uncommitted changes: not this run's to judge — retryable;
+                                 *   - the gates are red here, or the work is not in this tree (and could not be
+                                 *     rebuilt onto the base): a gap the work can close — the next revision plans it.
+                                 */
+                                if (reproofVerdict === 'blocked') {
+                                    return {
+                                        ok: false,
+                                        reason: `gate blocked: step could not run — the environment is unavailable, not the change (${confirmed.because})`,
+                                        unknown: true,
+                                    };
+                                }
+                                if (!again.ok && /uncommitted change/.test(again.because))
+                                    return { ok: false, reason: again.because, unknown: true };
+                                return {
+                                    ok: false,
+                                    reason: replayTrouble === null ? confirmed.because : `${confirmed.because} (${replayTrouble})`,
+                                    replan: true,
+                                };
+                            }
                         }
                         /**
                          * 🔴 WHAT KEY 2 SAW, KEPT FOR THE FOURTH KEY.
@@ -3295,7 +3429,8 @@ async function runLoop(opts) {
                          */
                         if (confirmed.ok) {
                             deliveringRunId = confirmed.round.runId;
-                            deliveringSha = confirmed.round.sha ?? null;
+                            // A REBUILT tree delivers its own tip: the original round's commit is not in it.
+                            deliveringSha = rebuiltAs !== null ? rebuiltAs.head : (confirmed.round.sha ?? null);
                             key2Saw = {
                                 delivered: new Set(confirmed.delivered),
                                 checks: new Map((confirmed.reproved ?? confirmed.round.gate?.steps ?? []).map((st) => [
@@ -3575,7 +3710,7 @@ async function runLoop(opts) {
                 await releaseHold();
                 // The branch the controller will ask the lane about: the one that delivered (F20).
                 const refusedOn = deliveredOn;
-                throw said.terminal ? new RunRefused(said.message, said.code, refusedOn, delivery) : new Error(said.message);
+                throw said.terminal ? new RunRefused(said.message, said.code, refusedOn, delivery) : (plannerTimedOut(said.message) ?? new Error(said.message));
             }
         }
         const left = scope === null ? null : (0, core_1.workLeft)(runQueue.list());
@@ -3603,7 +3738,8 @@ async function runLoop(opts) {
             throw new RunRefused(`nothing here can move without you — ${(0, queue_summary_1.describeNoReady)(runQueue.list())}`, 'human_required');
         }
         await releaseHold();
-        throw new Error(`nothing to do — ${(0, queue_summary_1.describeNoReady)(runQueue.list())}`);
+        const nothing = `nothing to do — ${(0, queue_summary_1.describeNoReady)(runQueue.list())}`;
+        throw plannerTimedOut(compileNote === null ? nothing : `${nothing} (${compileNote})`) ?? new Error(nothing);
     }
     /**
      * THE APPROVAL BOUNDARY, AND THE ONLY PLACE IT COULD LIVE.