pi-goal-list-loop-audit 0.29.7 → 0.29.9

package/README.md

@@ -39,10 +39,11 @@ Five top-level commands — `/goal`, `/list`, `/loop`, `/glla`, `/review`:
 /goal resume                       # resume
 /goal cancel                       # abort
 /goal decide                       # re-open the decision picker (v0.28.23)
-/goal audit                        # run the isolated auditor on the current goal now — no agent turn (v0.28.27)
+/goal audit ["focus on payments"]    # one-shot project audit (v0.29.8): fix the non-decisions, present the decisions — findings in .pi-glla/audit-loop/findings.md
+/goal verify                       # run the isolated auditor on the current goal now — no agent turn (v0.28.27, renamed from /goal audit in v0.29.8)
 /goal tweak "<new objective>"      # edit in place (Confirm dialog)
 /goal archive                      # archived goals, newest first
-/glla                               # settings UI table · /glla key=value · /glla stats · /glla audits [N|full] · /glla postaudit · /glla wipe (nuclear reset, Confirm-gated) · /glla autoaccept=on
+/glla                               # settings UI table · /glla status (unified what's-running view) · /glla key=value · /glla stats · /glla audits [N|full] · /glla postaudit · /glla wipe (nuclear reset, Confirm-gated) · /glla autoaccept=on
 /list fix the login bug, add dark mode, write docs   # dump it — the agent shapes it into items, one Confirm
 /list plan.md                      # file detected → bulk import, one Confirm (sisyphus/Ralph style)
 /list <paste a checklist>          # multi-line paste → same batch flow
@@ -66,7 +67,7 @@ matches `/list show`.
 /loop                              # draft the loop (agent grills; measure is test-run before you confirm)
 /loop start "keep polishing the UI"                          # infinite metricless loop (v0.23.6): no plateau, no cap — ends at time=/tokens= or /loop stop
 /loop respec                                                  # infinite metricless loop reconciling the codebase against the root SPEC.md / spec.md (v0.24.3) — 2 specs = you pick, 0 specs = drafting, 1 spec = auto-start (v0.24.4)
-/loop audit                                                    # project-audit loop (v0.29.0): each iteration audits fresh, appends findings to .pi-glla/audit-loop/findings.md, fixes the top ones — the orchestrator counts open findings and the plateau stop ends it when the well is dry
+/loop audit                                                    # project-audit loop (v0.29.0): each iteration audits fresh, appends findings to .pi-glla/audit-loop/findings.md, fixes the top ones — the orchestrator counts open findings and the plateau stop ends it when the well is dry (one-shot version: /goal audit)
 /loop start "reduce TODOs" measure="grep -c TODO src.txt | head -1" direction=min
 /loop start "shrink the bundle" measure="..." direction=min time=4 tokens=500000   # arbitrary bounds
 /loop start "reduce TODOs" measure="..." direction=min branch=1   # scratch-branch mode
@@ -361,7 +362,7 @@ prompts/
   goal-loop-forever-draft.md   # /loop drafting prompt
 scripts/
   smoke.sh                     # live integration harness (tmux + real models)
-tests/                         # 613 tests across 58 files, no live pi required (mock-ctx harness drives the orchestrator)
+tests/                         # 614 tests across 58 files, no live pi required (mock-ctx harness drives the orchestrator)
 docs/DESIGN.md                 # architectural decisions
 PLAN.md                        # milestones, decisions, gates
 ```

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-core.ts

@@ -216,10 +216,14 @@ export interface Goal {
 export type GoalRoute =
   | { kind: "draft" }
   | { kind: "set"; text: string }
-  | { kind: "sub"; name: "status" | "pause" | "resume" | "cancel" | "decide" | "audit" | "tweak" | "archive" | "start"; rest: string };
+  | { kind: "sub"; name: "status" | "pause" | "resume" | "cancel" | "decide" | "verify" | "audit" | "tweak" | "archive" | "start"; rest: string };
 
-const GOAL_EXACT_SUBS = new Set(["status", "pause", "resume", "cancel", "decide", "audit"]);
-const GOAL_ARG_SUBS = new Set(["tweak", "archive", "start"]);
+// v0.29.8: "audit" moved to ARG subs ("/goal audit [focus]" is the one-shot
+// project audit — user: "/goal audit IS the audit goal"); the v0.28.27
+// manual current-goal verification moved to "verify" (it happens
+// automatically at completion anyway — verify is the on-demand handle).
+const GOAL_EXACT_SUBS = new Set(["status", "pause", "resume", "cancel", "decide", "verify"]);
+const GOAL_ARG_SUBS = new Set(["audit", "tweak", "archive", "start"]);
 
 export function routeGoalArgs(raw: string): GoalRoute {
   const trimmed = raw.trim();
@@ -228,10 +232,10 @@ export function routeGoalArgs(raw: string): GoalRoute {
   const first = (space === -1 ? trimmed : trimmed.slice(0, space)).toLowerCase();
   const rest = space === -1 ? "" : trimmed.slice(space + 1).trim();
   if (GOAL_EXACT_SUBS.has(first) && rest === "") {
-    return { kind: "sub", name: first as "status" | "pause" | "resume" | "cancel" | "decide", rest: "" };
+    return { kind: "sub", name: first as "status" | "pause" | "resume" | "cancel" | "decide" | "verify", rest: "" };
   }
   if (GOAL_ARG_SUBS.has(first)) {
-    return { kind: "sub", name: first as "tweak" | "archive" | "start", rest };
+    return { kind: "sub", name: first as "audit" | "tweak" | "archive" | "start", rest };
   }
   return { kind: "set", text: trimmed };
 }

package/extensions/goal-loop-forever.ts

@@ -423,3 +423,22 @@ export function auditMeasureCmd(): string {
 export function auditTarget(): string {
   return `Audit the project for real problems and fix them, iteration by iteration. Every iteration: (1) run a FRESH audit pass over the codebase — spawn Explore subagents for breadth — hunting real issues: bugs, broken flows, regressions, drift between docs and code, dead code, security holes. Not style nits, not speculative refactors. (2) Append every NEW finding as one checkbox line "- [ ] SEVERITY: short description (file:line)" to ${AUDIT_FINDINGS_REL} (create the file on the first finding; append-only — never delete, rewrite, or reorder existing lines; never re-report a finding already listed). (3) Fix the highest-severity OPEN finding(s) — real fixes, committed — then check the box: "- [x] … — fixed in <commit>". (4) Honesty law: never fabricate findings to look busy; never mark a finding fixed without the fix commit existing. When a full audit pass surfaces nothing new AND no open findings remain, say so plainly — the orchestrator counts open findings every iteration and the plateau stop ends the loop when the well is dry.`;
 }
+
+// ---- /goal audit-project (v0.29.8) ----
+
+/**
+ * The one-shot project audit (user design 2026-07-30): "/loop audit keeps
+ * firing — this would be fire and address what you can, present what is to
+ * be decided; whether to fix a bug is not a decision." Same findings file
+ * as the audit loop (one ledger per project — the loop can keep working
+ * what the one-shot surfaced), but exactly ONE pass with a finish line the
+ * isolated auditor verifies, and the triage law the loop doesn't have:
+ * FIX findings (bugs, polish — nobody would say "leave that bug in") are
+ * fixed autonomously; DECIDE findings (direction, trade-offs — two
+ * reasonable answers exist) are presented, never touched. DECIDE lines use
+ * "- [?]" so they never inflate the loop's open-findings measure.
+ */
+export function projectAuditTarget(focus?: string): string {
+  const scope = focus && focus.trim() ? focus.trim() : "the whole project";
+  return `Run ONE project audit pass and leave the project in a known state. Scope: ${scope}. (1) Run a FRESH audit pass over the codebase — spawn Explore subagents for breadth — hunting real problems: bugs, broken flows, regressions, drift between docs and code, dead code, security holes. Not style nits, not speculative refactors. (2) Append every NEW finding to ${AUDIT_FINDINGS_REL} (create the file on the first finding; append-only — never delete, rewrite, or reorder existing lines; never re-report a finding already listed), classified: "- [ ] FIX: SEVERITY: short description (file:line)" for bugs and polish — whether to fix these is NOT a decision — and "- [?] DECIDE: short description (what the choice is, what each side costs)" for direction, trade-offs, and scope questions where two reasonable answers exist. (3) Fix every NEW FIX finding from this pass — real fixes, committed with the repo's configured identity on the current branch (no invented identities or branches) — then check the box: "- [x] … — fixed in <commit>". (4) Change NOTHING for DECIDE findings — present them in the completion report instead. (5) Honesty law: never fabricate findings to look busy; never check a box without the fix commit existing; never silently turn a DECIDE into a fix. Done when: the audit pass is complete, every new FIX finding has a fix commit and a checked box in ${AUDIT_FINDINGS_REL}, and every DECIDE finding is listed in the file and presented in the completion report.`;
+}

package/extensions/loops/goal.ts

@@ -165,6 +165,7 @@ import {
   respecTarget,
   auditMeasureCmd,
   auditTarget,
+  projectAuditTarget,
   HELD_ON_RESTORE,
   type LoopState,
 } from "../goal-loop-forever.js";
@@ -182,6 +183,7 @@ import {
   shouldWedgeAlert,
   PENDING_LATCH_STUCK_MS,
   shouldFirePendingLatchWatchdog,
+  msUntilNextHourBoundary,
 } from "../goal-loop-backoff.js";
 
 // =================================================================
@@ -1106,7 +1108,7 @@ async function retryStoredCompletionAudit(ctx: ExtensionContext, origin: "quota-
   updateGoal({ status: "auditing" }, liveCtx);
   appendLedger(liveCtx.cwd, "goal_resumed", { via: origin === "manual" ? "manual-audit" : "quota-retry-direct-audit" });
   liveCtx.ui.notify(origin === "manual"
-    ? "Manual /goal audit — running the isolated auditor now (no agent turn needed)."
+    ? "Manual /goal verify — running the isolated auditor now (no agent turn needed)."
     : "Auditor quota window elapsed — retrying the audit with your stored completion claim (no agent turn needed).", "info");
   const settings = loadSettings(liveCtx.cwd);
   const { model: auditorModel, error: modelError, via } = resolveAuditorModel(liveCtx, settings.auditorModel);
@@ -1164,7 +1166,7 @@ async function retryStoredCompletionAudit(ctx: ExtensionContext, origin: "quota-
     updateGoal({ auditHistory: history, pendingCompletion: undefined }, liveCtx);
     const objective = state.goal.objective;
     archiveCurrentGoal(liveCtx, "complete", `auditor ${result.model} approved (${origin})`);
-    liveCtx.ui.notify(`Goal complete — auditor ${result.model} approved${origin === "manual" ? " on /goal audit" : " on the quota retry"}.`, "info");
+    liveCtx.ui.notify(`Goal complete — auditor ${result.model} approved${origin === "manual" ? " on /goal verify" : " on the quota retry"}.`, "info");
     notifyExternal(liveCtx, `Goal complete (auditor approved, ${origin}): ${objective.slice(0, 120)}`);
     return;
   }
@@ -1445,14 +1447,24 @@ async function cmdGoal(args: string, ctx: ExtensionContext): Promise<void> {
       if (!shown) ctx.ui.notify("No pending decision — the goal isn't paused on a choice (or no UI).", "info");
       return;
     }
-    // v0.28.27: /goal audit — run the isolated auditor on the current goal
+    // v0.29.8: /goal audit [focus] — the ONE-SHOT project audit (user:
+    // "/goal audit IS the audit goal — we are not auditing the current
+    // goal, that happens automatically"). Fire-and-address: one audit
+    // pass, FIX findings fixed autonomously (a bug is not a decision),
+    // DECIDE findings presented, untouched. Runs as a normal goal through
+    // cmdSet — the isolated auditor verifies the finish line.
+    if (route.name === "audit") {
+      return cmdSet(projectAuditTarget(route.rest || undefined), ctx, true);
+    }
+    // v0.28.27 (renamed /goal audit → /goal verify in v0.29.8): run the
+    // isolated auditor on the current goal
     // RIGHT NOW, without engaging the agent. The user's "the work looks
     // done — just verify it" handle (and the manual counterpart of the
     // v0.28.26 stored-claim quota retry). Seeds a synthesized claim so a
     // quota block falls into the same pendingCompletion retry machinery.
-    if (route.name === "audit") {
+    if (route.name === "verify") {
       if (!state.goal) {
-        ctx.ui.notify("No active goal — /goal audit needs a goal to verify.", "warning");
+        ctx.ui.notify("No active goal — /goal verify needs a goal to verify.", "warning");
         return;
       }
       if (completionAuditInFlight) {
@@ -1461,7 +1473,7 @@ async function cmdGoal(args: string, ctx: ExtensionContext): Promise<void> {
       }
       updateGoal({
         pendingCompletion: {
-          completionSummary: "Manual audit requested by the user via /goal audit (no agent completion claim). Verify the objective against the repo directly.",
+          completionSummary: "Manual audit requested by the user via /goal verify (no agent completion claim). Verify the objective against the repo directly.",
           at: nowIso(),
         },
       }, ctx);
@@ -4551,6 +4563,37 @@ function cmdAudits(args: string, ctx: ExtensionContext): void {
   ctx.ui.notify(`glla audits — last ${entries.length} verdict(s) in ${ctx.cwd}\n${formatAuditLog(entries)}`, "info");
 }
 
+// v0.29.8: /glla status — the unified "what's running" surface (user: "we
+// need to type goal status [to check], so that command at least is missing
+// for checking on whatever active process we have"). Read-only aggregate of
+// the ONE state — goal, list queue, loop, pending decisions — with pointers
+// to the deep surfaces.
+function cmdGllaStatus(ctx: ExtensionContext): void {
+  const lines: string[] = [];
+  const g = state.goal;
+  if (g) {
+    const tok = (g.usage?.tokensUsed ?? 0) > 0 ? ` · ${g.usage!.tokensUsed} tok` : "";
+    const audit = g.status === "auditing" ? " (auditor running…)" : "";
+    const pause = g.status === "paused" && g.pauseReason ? ` — ${g.pauseReason.slice(0, 90)}` : "";
+    lines.push(`goal [${g.policy}] ${g.status}${audit}${tok}: ${g.objective.slice(0, 90)}${pause}`);
+  } else {
+    lines.push("goal: none");
+  }
+  const q = listQueue();
+  lines.push(`list: ${q.length === 0 ? "empty" : `${q.length} queued — head: ${(q[0]?.objective ?? "").slice(0, 70)}`}`);
+  const l = state.loop;
+  if (l) {
+    lines.push(`loop: ${l.active ? "ACTIVE" : `held/stopped — ${l.stopReason ?? "n/a"}`} · iter ${l.iteration}/${l.maxIterations > 0 ? l.maxIterations : "∞"} · best ${l.bestValue ?? "n/a"} · stall ${l.stallCount} — ${l.target.slice(0, 60)}`);
+  } else {
+    lines.push("loop: none");
+  }
+  if (g?.status === "paused" && g.pauseKind === "decision" && g.pauseOptions?.length) {
+    lines.push(`decision pending (${g.pauseOptions.length} options) — /goal decide`);
+  }
+  lines.push("deep: /goal status · /list · /loop status · /glla stats · /glla audits · /glla log");
+  ctx.ui.notify(`glla status\n${lines.join("\n")}`, "info");
+}
+
 async function cmdSettings(args: string, ctx: ExtensionContext): Promise<void> {
   // The plugin's ONE config surface — global by default, rarely opened.
   //   /glla                      show effective values + where each comes from
@@ -4573,6 +4616,11 @@ async function cmdSettings(args: string, ctx: ExtensionContext): Promise<void> {
     cmdAudits(trimmed.slice("audits".length).trim(), ctx);
     return;
   }
+  // v0.29.8: /glla status — the unified what's-running view.
+  if (/^status\b/.test(trimmed)) {
+    cmdGllaStatus(ctx);
+    return;
+  }
   // v0.28.28: /glla log [N] — the raw event trail, human-readable. "Log it
   // so we can look back and see where we are doing things wrong."
   if (/^log\b/.test(trimmed)) {
@@ -4970,10 +5018,13 @@ export default function (pi: ExtensionAPI): void {
     description: "Set/draft a goal, or /goal status|pause|resume|cancel|tweak <text>|archive|start <objective>. Objectives without a 'Done when:' clause are grilled into a contract first; include the clause or use /goal start to skip the interview and activate instantly.",
     getArgumentCompletions: completions([
       ["start", "skip drafting — /goal start <objective> activates immediately"],
+      ["audit", "one-shot project audit goal: /goal audit [focus] — fix the non-decisions, present the decisions (v0.29.8)"],
+      ["verify", "run the isolated auditor on the current goal NOW (v0.28.27, renamed from /goal audit)"],
       ["status", "show the active goal and its task list"],
       ["pause", "pause the active goal"],
       ["resume", "resume a paused goal (and the list, when items are queued)"],
       ["cancel", "abort the active goal"],
+      ["decide", "re-open the decision picker for a decision pause"],
       ["tweak", "change the objective: /goal tweak <text>"],
       ["archive", "list archived goals"],
     ]),
@@ -4990,6 +5041,7 @@ export default function (pi: ExtensionAPI): void {
       ["autoresume=", "default: hold when a session is loaded, auto-resume on reload/fork; on: always auto-resume; off: never"],
       ["decisionpopup=", "on|off: decision pauses pop the select() picker (default on; the widget card always lists the options, /goal decide reopens the picker)"],
       ["auditcap=", "N: pause goal after N consecutive auditor disapprovals (default 5, 0 = unlimited)"],
+      ["status", "unified what's-running view: goal + list queue + loop + pending decisions (v0.29.8)"],
       ["log", "event-trail tail: /glla log [N] — who created/resumed/paused what, from where (v0.28.28)"],
       ["wipe", "WIPE live glla state (goal archived, list cleared, loop stopped) — one-shot cleanup for leftover-laden projects"],
       ["resume", "resume WHATEVER is paused/held (goal, list item, or held loop) — no need to know the type"],
@@ -5489,17 +5541,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.7",
+  "version": "0.29.9",
   "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",