pi-goal-list-loop-audit 0.29.12 → 0.29.14

package/extensions/goal-loop-forever.ts

@@ -404,14 +404,16 @@ export function respecTarget(specName: string): string {
 export const AUDIT_FINDINGS_REL = ".pi-glla/audit-loop/findings.md";
 
 /**
- * The audit-loop measure command: count open findings. Prints exactly one
- * number in every file state (missing file / zero matches → 0). This is
- * what respec (metricless) and the reviewer cascade (no termination) both
- * lacked: an honest metric the plateau stop can believe — audits that stop
- * surfacing new findings = the well is dry = the loop ends.
- */
+ * The audit-loop measure command: count CLOSED findings. Prints exactly one
+ * number in every file state (missing file / zero matches → 0). v0.29.14:
+ * flipped from open-count/min — the open count PUNISHES DISCOVERY (a fresh
+ * audit finding 11 real issues read as a regression: endless-td-style iter
+ * 6 went 27→38→37 and nearly plateau-stopped mid-work). The closed count
+ * is monotonic under the honesty law (a checked box requires a fix commit):
+ * discovery alone doesn't move it, landing fixes does — so the plateau
+ * stop fires only when NO FIXES LAND for the window: the honest dry well. */
 export function auditMeasureCmd(): string {
-  return `c=$(grep -cE '^- \\[ \\]' ${AUDIT_FINDINGS_REL} 2>/dev/null); echo \${c:-0}`;
+  return `c=$(grep -cE '^- \\[[xX]\\]' ${AUDIT_FINDINGS_REL} 2>/dev/null); echo \${c:-0}`;
 }
 
 /**
@@ -425,7 +427,7 @@ export function auditMeasureCmd(): string {
  * identity, on the current branch — no invented identities or branches).
  */
 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.`;
+  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. The orchestrator counts CLOSED findings every iteration (direction=max): discovery alone does not move the metric — landing fixes does. When a full audit pass surfaces nothing new AND no open findings remain, say so plainly — the plateau stop ends the loop when the well is dry.`;
 }
 
 // ---- /goal audit-project (v0.29.8) ----

package/extensions/goal-settings.ts

@@ -58,6 +58,11 @@ export interface Settings {
   /** Consecutive stuck interventions before a loop stops (default 5,
    * 10 under aggressiveMode). */
   stuckMaxInterventions?: number;
+  /** v0.29.13: on a stale-handle terminal, inject /reload into our own
+   * tmux pane (keystroke self-heal; pi walls ctx.reload() behind
+   * assertActive). Default true; only acts when TMUX and TMUX_PANE are
+   * set — pi outside tmux just gets the manual warning. */
+  autoReloadOnStale?: boolean;
   /** v0.26.1: consecutive heartbeat refires without a real turn before
    * the goal pauses / loop stops (default 5; 0 = never escalate). */
   stallEscalationRefires?: number;
@@ -186,6 +191,7 @@ export const SETTINGS_KEYS: Array<keyof Settings> = [
   "quotaRetryMinutes",
   "stuckMaxInterventions",
   "stallEscalationRefires",
+  "autoReloadOnStale",
   "stallShortWords",
   "stallSimilarityThreshold",
   "postaudit",

package/extensions/loops/goal.ts

@@ -15,6 +15,7 @@
  */
 
 import * as fs from "node:fs";
+import { exec } from "node:child_process";
 import * as os from "node:os";
 import * as path from "node:path";
 
@@ -229,6 +230,29 @@ function goStaleTerminal(ctx: ExtensionContext, where: string): void {
   }
   ctx.ui.notify(`glla: ${guidance}`, "warning");
   notifyExternal(ctx, `glla: extension api stale — restart pi. (${where})`);
+  attemptTmuxAutoReload(ctx, where);
+}
+
+/** v0.29.13: automatic recovery — the zombie handle can't call ctx.reload()
+ * (pi walls EVERY runtime method behind assertActive), but fs/child_process
+ * are extension-side and still work. When pi runs inside tmux (this rig's
+ * shape), inject /reload as keystrokes into our own pane: pi rebuilds the
+ * extension runtime in place, the fresh instance loads .pi-glla state and
+ * holds (autoresume=on resumes for you). Opt out: autoReloadOnStale=false.
+ * Best-effort: the manual warning already fired, so failures cost nothing. */
+function attemptTmuxAutoReload(ctx: ExtensionContext, where: string): void {
+  try {
+    if (loadSettings(ctx.cwd).autoReloadOnStale === false) return;
+    const pane = process.env.TMUX_PANE;
+    if (!process.env.TMUX || !pane || !/^%\d+$/.test(pane)) return;
+    appendLedger(ctx.cwd, "auto_reload_injected", { where, pane });
+    ctx.ui.notify("glla: injecting /reload into this pane via tmux — extensions rebuild in place and the fresh instance holds state. /glla resume after (automatic with autoresume=on).", "info");
+    // Escape dismisses any overlay; the dead session sits at an empty prompt.
+    const cmd = `tmux send-keys -t ${pane} Escape && sleep 0.3 && tmux send-keys -t ${pane} -l '/reload' && tmux send-keys -t ${pane} Enter`;
+    exec(cmd, () => { /* best-effort */ });
+  } catch {
+    /* never let recovery take the warning path down */
+  }
 }
 
 /** TEST-ONLY hook (tests/harness): the stale flag is process-terminal in
@@ -2256,7 +2280,7 @@ function sendLoopTurn(): void {
     (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.**"
+      ? "**The closed-findings count went DOWN last iteration — a checked finding was reopened or findings.md was rewritten (both forbidden). Restore the closed entries, 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
@@ -2699,10 +2723,11 @@ async function cmdLoop(args: string, ctx: ExtensionContext): Promise<void> {
     // v0.29.0: the project-audit loop (user design: "the looper running
     // audits to see where to progress and what to fix — the thing that
     // fires at the end of goals and lists"). Unlike respec this is a
-    // METRIC loop: the orchestrator counts open findings every iteration,
-    // direction=min, and the plateau stop is the termination — audits that
-    // stop surfacing new findings = the well is dry. User typed the
-    // command = the act (same auto-start rule as respec).
+    // METRIC loop: the orchestrator counts CLOSED findings every iteration,
+    // direction=max (v0.29.14 — open-count/min punished discovery), and the
+    // plateau stop is the termination — no fixes landing for the window =
+    // the well is dry. User typed the command = the act (same auto-start
+    // rule as respec).
     if (state.goal && state.goal.status === "active") {
       ctx.ui.notify("A goal is active — /goal cancel or /goal pause it before starting a loop.", "warning");
       return;
@@ -2714,7 +2739,7 @@ async function cmdLoop(args: string, ctx: ExtensionContext): Promise<void> {
     await startLoopFromConfig(ctx, {
       target: auditTarget(),
       measureCmd: auditMeasureCmd(),
-      direction: "min",
+      direction: "max",
       plateauWindow: LOOP_DEFAULTS.plateauWindow,
       maxIterations: 0,
       branch: false,
@@ -5346,15 +5371,18 @@ export default function (pi: ExtensionAPI): void {
       state.loop = { ...state.loop, stopReason: HELD_ON_RESTORE };
       persistState(ctx);
     }
-    // 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" };
+    // v0.29.14: migrate live/held audit loops off the open-count/min
+    // metric — it punished DISCOVERY (11 new real findings read as a
+    // regression; iter 27→38→37 nearly plateau-stopped mid-work). Flip to
+    // closed-count/max, null the pinned best (the next closed-count
+    // measure becomes the honest baseline), reset the stall streak. This
+    // supersedes the v0.29.10 baseline-0 reseed (every old-measure loop
+    // gets nulled here).
+    if (state.loop && state.loop.measureCmd?.includes("audit-loop/findings.md") && state.loop.measureCmd?.includes("\\[ \\]")
+      && state.loop.direction !== "max") {
+      state.loop = { ...state.loop, measureCmd: auditMeasureCmd(), direction: "max", bestValue: null, stallCount: 0, kind: state.loop.kind ?? "audit" };
       persistState(ctx);
-      appendLedger(ctx.cwd, "audit_loop_baseline_reseeded", { from: 0 });
+      appendLedger(ctx.cwd, "audit_loop_metric_migrated", { from: "open-count/min", to: "closed-count/max" });
     }
     if (isLoopActive()) {
       const l = state.loop!;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goal-list-loop-audit",
-  "version": "0.29.12",
+  "version": "0.29.14",
   "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",