pi-goal-list-loop-audit 0.29.8 → 0.29.10

package/extensions/goal-loop-backoff.ts

@@ -9,6 +9,18 @@
  */
 
 export const BACKOFF_HARD_CAP_MS = 5 * 60 * 1000;
+
+// v0.29.9: ms until the next clock-hour boundary (+ grace). Coding-plan
+// rate-limit windows typically expire at the top of the hour, so a probe
+// scheduled there catches the reset within seconds instead of mid-window.
+// Robust when the premise is wrong too: a non-clock-aligned window is
+// still caught within the hour.
+export function msUntilNextHourBoundary(nowMs: number, graceMs = 60_000): number {
+  const d = new Date(nowMs);
+  d.setMinutes(0, 0, 0);
+  d.setHours(d.getHours() + 1);
+  return d.getTime() + graceMs - nowMs;
+}
 export const BACKOFF_IDLE_RETRY_MS = 50;     // when adding another iter to queue
 export const BACKOFF_ERROR_BASE_MS = 5_000;  // first error retry
 export const BACKOFF_ERROR_MAX_MS = 60_000;  // max error retry (separate from stuck cap)

package/extensions/goal-loop-forever.ts

@@ -57,6 +57,10 @@ export interface LoopState {
   consecutiveNullMeasures?: number;
   bestValue: number | null;
   lastValue: number | null;
+  /** v0.29.10: audit loops (measure counts open findings) get a deferred
+   * baseline (first REAL measurement seeds best — the pre-discovery 0 is
+   * degenerate) and audit-flavoured regression wording. */
+  kind?: "audit";
   active: boolean;
   stopReason?: string;
   history: LoopMeasure[];

package/extensions/loops/goal.ts

@@ -183,6 +183,7 @@ import {
   shouldWedgeAlert,
   PENDING_LATCH_STUCK_MS,
   shouldFirePendingLatchWatchdog,
+  msUntilNextHourBoundary,
 } from "../goal-loop-backoff.js";
 
 // =================================================================
@@ -2239,9 +2240,20 @@ function sendLoopTurn(): void {
     return;
   }
   const loop = state.loop!;
-  const regressedLast = loop.history.length > 0 && !loop.history[loop.history.length - 1]!.improved && loop.lastValue !== null;
-  const regressionNote = regressedLast
-    ? "**Your last change REGRESSED the metric. Undo it first, then try a different small change.**"
+  // v0.29.10: "regressed" = the last two measurements moved the WRONG way
+  // — not merely "didn't beat best". The old trigger (any non-improving
+  // iteration) cried REGRESSED on stalls and on the audit loop's
+  // degenerate baseline-0, telling agents to undo GOOD fixes (junk-runner
+  // 2026-07-30: 17→16 was real progress; the prompt demanded a revert).
+  const hist = loop.history;
+  const prevValue = hist.length >= 2 ? hist[hist.length - 2]!.value : null;
+  const lastHistValue = hist.length >= 1 ? hist[hist.length - 1]!.value : null;
+  const trueRegression = prevValue !== null && lastHistValue !== null && loop.direction !== undefined &&
+    (loop.direction === "min" ? lastHistValue > prevValue : lastHistValue < prevValue);
+  const regressionNote = trueRegression
+    ? loop.kind === "audit"
+      ? "**The open-findings count went UP last iteration — either the fresh audit pass found new problems, or your fix didn't land. Check findings.md, then keep fixing the highest-severity OPEN items.**"
+      : "**Your last change REGRESSED the metric. Undo it first, then try a different small change.**"
     : "";
   // Strategy rotation (from pi-loop-mode's one good idea): one stall before
   // the plateau window closes, stop polishing and change approach entirely.
@@ -2461,6 +2473,14 @@ interface LoopConfig {
   tokenBudget?: number;
   /** v0.25.1: /loop start toolsamerepeat=N (0 = disable legacy check). */
   toolSameRepeat?: number;
+  /** v0.29.10: don't seed bestValue from the pre-work baseline measure —
+   * the first REAL measurement becomes the baseline. For loops whose
+   * metric is created BY the first iteration (the audit loop: 0 open
+   * findings just means findings.md doesn't exist yet); a seeded 0 pins
+   * best at a value no iteration can beat, stalling every iteration. */
+  deferBaseline?: boolean;
+  /** v0.29.10: audit loops get audit-flavoured regression wording. */
+  kind?: "audit";
 }
 
 /** Shared loop-start path: /loop start AND propose_loop_draft (after Confirm). */
@@ -2496,8 +2516,8 @@ async function startLoopFromConfig(ctx: ExtensionContext, cfg: LoopConfig): Prom
   // v0.23.0: metricless loops skip the baseline entirely — there is no
   // measure to run, and no plateau to protect.
   const metricless = !cfg.measureCmd;
-  const baseline = metricless ? null : await runMeasure(ctx, cfg.measureCmd);
-  if (!metricless && baseline === null && !(cfg as { force?: boolean }).force) {
+  const baseline = metricless || cfg.deferBaseline ? null : await runMeasure(ctx, cfg.measureCmd);
+  if (!metricless && !cfg.deferBaseline && baseline === null && !(cfg as { force?: boolean }).force) {
     ctx.ui.notify(
       `/loop start refused: the measure produced no number.\nCommand: ${cfg.measureCmd}\nFix it so it prints exactly one number, or re-run with force=1 if it only works after the agent builds something first.\n(Non-numeric goal — research, docs, features? Use /goal: the independent auditor verifies semantically. /loop only believes a number.)`,
       "warning",
@@ -2515,8 +2535,9 @@ async function startLoopFromConfig(ctx: ExtensionContext, cfg: LoopConfig): Prom
       maxIterations: cfg.maxIterations,
       plateauWindow: cfg.plateauWindow,
       stallCount: 0,
-      bestValue: baseline,
-      lastValue: baseline,
+      bestValue: cfg.deferBaseline ? null : baseline,
+      lastValue: cfg.deferBaseline ? null : baseline,
+      kind: cfg.kind,
       active: true,
       history: [],
       startedAt: nowIso(),
@@ -2535,7 +2556,7 @@ async function startLoopFromConfig(ctx: ExtensionContext, cfg: LoopConfig): Prom
     metricless
       ? `Loop started (metricless spec loop — NO plateau stop): ${cfg.target.slice(0, 60)}\nEnds only at ${cfg.maxIterations > 0 ? `max ${cfg.maxIterations} iterations` : "no iteration cap"}${cfg.timeLimitHours ? ` · ${cfg.timeLimitHours}h` : ""}${cfg.tokenBudget ? ` · ${cfg.tokenBudget.toLocaleString()} tokens` : ""} · /loop stop. Every iteration must make ONE real, inspectable change — cosmetic churn is the doorknob failure.` +
         (branchName ? `\nbranch mode: committing each iteration to ${branchName}` : "")
-      : `Loop started: ${cfg.target.slice(0, 60)}\nBaseline: ${baseline ?? "(forced without a number — first turn must produce one)"} · direction ${cfg.direction} · window ${cfg.plateauWindow} · ${cfg.maxIterations > 0 ? `max ${cfg.maxIterations}` : "no iteration cap"}` +
+      : `Loop started: ${cfg.target.slice(0, 60)}\nBaseline: ${cfg.deferBaseline ? "deferred — the first real measurement seeds it" : (baseline ?? "(forced without a number — first turn must produce one)")} · direction ${cfg.direction} · window ${cfg.plateauWindow} · ${cfg.maxIterations > 0 ? `max ${cfg.maxIterations}` : "no iteration cap"}` +
         (branchName ? `\nbranch mode: committing improvements to ${branchName}` : ""),
     "info",
   );
@@ -2694,6 +2715,11 @@ async function cmdLoop(args: string, ctx: ExtensionContext): Promise<void> {
       maxIterations: 0,
       branch: false,
       force: false,
+      // v0.29.10: the audit loop's metric is CREATED by iteration 1 —
+      // seeding best from the pre-discovery 0 stalls every iteration and
+      // plateau-stops mid-work at the window. Defer the baseline.
+      deferBaseline: true,
+      kind: "audit",
     });
     return;
   }
@@ -5302,6 +5328,16 @@ export default function (pi: ExtensionAPI): void {
     ) {
       ctx.ui.notify("Auto-resume fired (event: session start). Continue working.", "info");
     }
+    // v0.29.10: reseed live/held audit loops stuck on the degenerate
+    // pre-discovery baseline-0 — best can never go below 0, so every
+    // iteration stalls and the prompt cries REGRESSED on real progress
+    // (junk-runner ran pinned like this). Null best = the next measurement
+    // becomes the honest baseline; stall streak resets with it.
+    if (state.loop && state.loop.measureCmd?.includes("audit-loop/findings.md") && state.loop.bestValue === 0) {
+      state.loop = { ...state.loop, bestValue: null, stallCount: 0, kind: state.loop.kind ?? "audit" };
+      persistState(ctx);
+      appendLedger(ctx.cwd, "audit_loop_baseline_reseeded", { from: 0 });
+    }
     if (isLoopActive()) {
       const l = state.loop!;
       if (autoResume) {
@@ -5540,17 +5576,40 @@ export default function (pi: ExtensionAPI): void {
         // v0.29.1: brake-cycle CAP. The v0.28.25 ladder slows the thrash
         // (1m→16m) but never STOPS it — junk-runner/hellhunter/pully each
         // burned 4+ pause↔retry cycles against provider windows that last
-        // hours. After 6 consecutive brakes: park, no more auto-retries.
+        // hours. After 6 consecutive brakes: park. v0.29.9: the park keeps
+        // probing at the top of each hour (clock-aligned window resets).
         if (errorBrakeStreak >= 6) {
+          // v0.29.9: park — but keep probing at the top of each hour
+          // (user: "simply adding an hourly retry … just to pick up work
+          // faster assuming the retry expired"). Coding-plan rate-limit
+          // windows typically expire on clock-hour boundaries, so a probe
+          // scheduled for :01 catches the reset within seconds. One dunk
+          // per hour, free (429s are rejected pre-billing); a successful
+          // probe resets the whole error cycle. If the wall is something
+          // else (auth, outage), the hourly probe is a harmless failed
+          // resume attempt that re-parks via the same brake.
           updateGoal({
             status: "paused",
             pauseKind: "error",
             pauseReason: `${reason} — 6 error-brakes in a row; the provider has been erroring for an extended window`,
-            pauseSuggestedAction: "Check the provider/account (quota, outage), then /goal resume. No more automatic retries.",
+            pauseSuggestedAction: "Probing at the top of each hour — rate-limit windows typically expire on clock-hour boundaries. /goal resume retries now.",
           }, ctx);
-          ctx.ui.notify(`${goalNoun()} parked: ${reason} — 6 brakes in a row, no more auto-retries. Check the provider, then /goal resume.`, "warning");
-          notifyExternal(ctx, `${goalNoun()} parked: provider erroring across 6 error-brake cycles.`);
+          ctx.ui.notify(`${goalNoun()} parked: ${reason} — 6 brakes in a row. Hourly top-of-hour probes will pick work back up when the window opens; /goal resume retries now.`, "warning");
+          notifyExternal(ctx, `${goalNoun()} parked: provider erroring across 6 error-brake cycles — hourly top-of-hour probes scheduled.`);
           appendLedger(ctx.cwd, "error_brake_capped", { streak: errorBrakeStreak, reason });
+          const probeMs = msUntilNextHourBoundary(Date.now());
+          scheduleQuotaRetry(ctx, probeMs / 1000, reason, () => {
+            // Re-check: only probe if STILL parked by the error-brake cap —
+            // a user pause/resume/cancel meanwhile is never stomped.
+            if (state.goal && state.goal.status === "paused" && state.goal.pauseKind === "error"
+              && (state.goal.pauseReason ?? "").includes("error-brakes in a row")) {
+              appendLedger(ctx.cwd, "hourly_rate_probe", { goalId: state.goal.id, streak: errorBrakeStreak });
+              updateGoal({ status: "active" }, ctx);
+              appendLedger(ctx.cwd, "goal_resumed", { via: "hourly-rate-probe" });
+              ctx.ui.notify("Hourly probe: resuming (rate-limit windows typically expire at the top of the hour).", "info");
+              scheduleContinuation(ctx, true);
+            }
+          }, "Hourly rate-limit probe");
           return;
         }
         // v0.28.25: the cooldown escalates per CONSECUTIVE brake — a fleet-wide

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goal-list-loop-audit",
-  "version": "0.29.8",
+  "version": "0.29.10",
   "description": "Goal. Loop. Audit. Done. \u2014 a pi-coding-agent extension that supervises long-running work, with isolated auditor on each completion. Beat bamboozling by design: the auditor runs in a fresh session with no extensions, no skills, no editor \u2014 only the read tools needed to verify your goal.",
   "license": "MIT",
   "author": "dracon",