pi-goal-list-loop-audit 0.28.10 → 0.28.12

package/README.md

@@ -209,7 +209,7 @@ No external watchdog plugin needed.
 /glla quotaretryminutes=60            # minutes before auto-retrying a quota-exhausted auditor
 /glla stuckmax=10                     # consecutive stuck interventions before a loop stops (default 5)
 /glla auditfeedbackchars=800         # cap the executor-visible auditor report (default 0 = full report)
-/glla autoaccept=on                  # drafts ACTIVATE without the Confirm dialog (unattended rigs)
+/glla autoaccept=on                  # drafts ACTIVATE without the Confirm dialo... (every draft dialog also offers "always auto-accept" inline)unattended rigs)
 /glla project tokenlimit=500         # rare per-project override
 ```
 

package/extensions/goal-loop-display.ts

@@ -144,11 +144,11 @@ export function buildStatusText(state: State, audit?: AuditDisplayProgress | nul
       return `glla: ${g.policy} ${paint(theme, "error", "⚠ interrupted — stale handle · auto-resumes on pi restart")}`;
     }
     // v0.24.7: list policy gets its own wording — a queue item is not a goal.
-    // Before: "glla: list ● 3m 19s · list 29" (policy label AND queue counter
-    // both said "list"). After: "glla: list ● 3m 19s · 29 queued". Goal
-    // policy keeps the bare "list N" suffix (no duplication there).
+    // v0.28.11 (U10): goal policy joins it — "list 29" read as a command
+    // fragment; "29 queued" says what the number IS. Both policies now
+    // render "… · N queued".
     const n = state.list?.length ?? 0;
-    const queue = n === 0 ? "" : g.policy === "list" ? ` · ${n} queued` : ` · list ${n}`;
+    const queue = n === 0 ? "" : ` · ${n} queued`;
     const tasks = g.taskList ? ` ${countDone(g)}/${countTotal(g)} tasks ·` : "";
     return `glla: ${g.policy} ${paint(theme, "success", "●")}${tasks} ${fmtElapsed(now - Date.parse(g.createdAt))}${queue}`;
   }
@@ -275,7 +275,7 @@ function goalLines(g: Goal, state: State, audit: AuditDisplayProgress | null | u
   const queue = state.list?.length ?? 0;
   const footer = isList
     ? `${queue > 0 ? `${queue} queued · ` : ""}/list · /glla`
-    : `${queue > 0 ? `list ${queue} · ` : ""}/goal status · /glla`;
+    : `${queue > 0 ? `${queue} queued · ` : ""}/goal status · /glla`;
   lines.push(`└─ ${paint(theme, "dim", footer)}`);
   return lines;
 }

package/extensions/loops/goal.ts

@@ -259,6 +259,36 @@ function warnIfStaleAtEntry(ctx: ExtensionContext, what: string): boolean {
   return true;
 }
 
+/** v0.28.12: draft-class confirm with the auto-accept escape hatch SURFACED.
+ * The polis incident: a user sat through a 14-item batch Confirm having
+ * already reviewed every item during drafting, never knowing /glla
+ * autoaccept=on existed — the Yes/No dialog never mentioned it. Now every
+ * draft dialog is a 3-choice select; the ALWAYS choice persists project
+ * autoAcceptDrafts=true and accepts. Returns "stale" when the dialog can't
+ * render (session replacement) so call sites keep their NOT-a-rejection
+ * handling; falls back to the plain confirm if select is unavailable. */
+type DraftChoice = "yes" | "no" | "stale";
+async function confirmDraft(ctx: ExtensionContext, title: string, body: string): Promise<DraftChoice> {
+  const ALWAYS = "Yes — and always auto-accept drafts (sets autoAcceptDrafts for this project)";
+  try {
+    const choice = await ctx.ui.select(`${title}\n\n${body}`, ["Yes", ALWAYS, "No"]);
+    if (choice === ALWAYS) {
+      saveSettings("project", ctx.cwd, { autoAcceptDrafts: true });
+      appendLedger(ctx.cwd, "draft_autoaccept_enabled", { via: title });
+      ctx.ui.notify("Draft auto-accept ON for this project — future draft confirms are skipped. Undo: /glla autoaccept=off.", "info");
+      return "yes";
+    }
+    return choice === "Yes" ? "yes" : "no";
+  } catch (err) {
+    if (isStaleApiError(err)) return "stale";
+    try {
+      return (await ctx.ui.confirm(title, body)) ? "yes" : "no";
+    } catch (err2) {
+      return isStaleApiError(err2) ? "stale" : "no";
+    }
+  }
+}
+
 // The most recent ExtensionContext seen from any event or command handler.
 // pi replaces sessions (newSession/fork/reload) and stale ctx throws on use,
 // so timers must never capture a ctx — they read lastCtx at fire time.
@@ -758,6 +788,9 @@ function persistState(ctx: ExtensionContext): void {
 // once per recovery. The TUI flag (buildWidgetLines) carries the standing
 // state; these notifies are the LOUD part.
 let persistenceDegradedNotified = false;
+
+/** v0.28.11 (U9): objective-first notifies — truncate long objectives. */
+const shortObj = (s: string): string => (s.length > 90 ? `${s.slice(0, 87)}…` : s);
 function notifyPersistenceState(ctx: ExtensionContext): void {
   if (isPersistenceDegraded() && !persistenceDegradedNotified) {
     persistenceDegradedNotified = true;
@@ -885,7 +918,7 @@ function fireReviewer(
           // to still count as "proposed" in the report + notify. Now the
           // failure is LOUD and the proposal goes uncounted.
           ctx.ui.notify(
-            `Reviewer /goal proposal NOT delivered: ${err instanceof Error ? err.message : String(err)} — the follow-up never reached the session. Restart pi if the session was just replaced.`,
+            `Postaudit /goal proposal NOT delivered: ${err instanceof Error ? err.message : String(err)} — the follow-up never reached the session. Restart pi if the session was just replaced.`,
             "warning",
           );
           return false;
@@ -895,7 +928,7 @@ function fireReviewer(
       ledger: (type, value) => appendLedger(ctx.cwd, type, value),
     });
     if (!outcome.fired && outcome.suppressedReason && opts.manual) {
-      ctx.ui.notify(`Reviewer suppressed: ${outcome.suppressedReason}`, "info");
+      ctx.ui.notify(`Postaudit suppressed: ${outcome.suppressedReason}`, "info");
     }
     // v0.27.5: surface the silent review to interactive users. The internal
     // runReviewer notify fires DURING the goal-completion handler, easy to
@@ -911,7 +944,7 @@ function fireReviewer(
       );
     }
   } catch (err) {
-    ctx.ui.notify(`Reviewer failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`, "warning");
+    ctx.ui.notify(`Postaudit failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`, "warning");
   }
 }
 
@@ -1088,10 +1121,10 @@ async function cmdSet(args: string, ctx: ExtensionContext, skipDraft = false): P
     // v0.28.1 (S3): the goal is persisted — mark the interrupt so the next
     // fresh session auto-resumes, and tell the truth instead of "starting now".
     updateGoal({ interruptedAt: nowIso(), interruptedReason: "created in a stale session" }, ctx);
-    ctx.ui.notify(`Goal ${goal.id} created and safe in .pi-glla/ — this stale process can't send continuations. Restart pi and it auto-resumes.`, "warning");
+    ctx.ui.notify(`Goal saved: ${shortObj(goal.objective)} — safe in .pi-glla/, but this stale process can't send continuations. Restart pi and it auto-resumes. (id: ${goal.id})`, "warning");
     return;
   }
-  ctx.ui.notify(`Goal ${goal.id} created — starting now. Auditor will verify on completion.`, "info");
+  ctx.ui.notify(`Goal started: ${shortObj(goal.objective)} — the auditor will verify on completion. (id: ${goal.id})`, "info");
   scheduleContinuation(ctx, true);
 }
 
@@ -2612,10 +2645,11 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
           details: {},
         };
       }
+      const liveCtx = (execCtx as ExtensionContext | undefined) ?? ctx;
       // v0.14.0: the interview floor — no Confirm until the user replied.
       // v0.23.8: /glla autoaccept=on skips the floor AND the Confirm —
       // the seed carries the intent (unattended rigs). Default off.
-      const autoAccept = loadSettings(ctx.cwd).autoAcceptDrafts === true;
+      const autoAccept = loadSettings(liveCtx.cwd).autoAcceptDrafts === true;
       if (!autoAccept) {
         if (draftingUserReplies === 0) draftingBlockedProposals++;
         const block = draftProposalBlock(draftingUserReplies, draftingBlockedProposals);
@@ -2630,7 +2664,6 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
           details: {},
         };
       }
-      const liveCtx = (execCtx as ExtensionContext | undefined) ?? ctx;
       // v0.28.1 (S3): honest staleness warning before any Confirm attempt.
       warnIfStaleAtEntry(liveCtx, "goal drafting");
       // Multi-item list draft: one Confirm for the whole batch.
@@ -2645,21 +2678,19 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
           liveCtx.ui.notify(`List batch auto-accepted (/glla autoaccept=on): ${p.items.length} items${batchActivates ? " — item 1 ACTIVATES now" : ""}.`, "info");
           appendLedger(liveCtx.cwd, "draft_autoaccepted", { kind: "batch", count: p.items.length });
         } else {
-          try {
-            batchConfirmed = await liveCtx.ui.confirm(
-              "Confirm list batch",
-              `${p.items.length} items:\n${preview}${batchActivates ? "\n\n(List is empty — confirming ACTIVATES item 1 immediately as the active goal.)" : ""}`,
-            );
-          } catch (err) {
-            // v0.28.1 (T1): a stale confirm is NOT a rejection — nothing was
+          const c = await confirmDraft(
+            liveCtx,
+            "Confirm list batch",
+            `${p.items.length} items:\n${preview}${batchActivates ? "\n\n(List is empty — confirming ACTIVATES item 1 immediately as the active goal.)" : ""}`,
+          );
+          if (c === "stale") {
+            // v0.28.1 (T1): a stale dialog is NOT a rejection — nothing was
             // refused; the dialog simply can't render in a doomed process.
-            if (isStaleApiError(err)) {
-              extensionApiStale = true;
-              appendLedger(liveCtx.cwd, "extension_api_stale", { where: "batch confirm" });
-              return { content: [{ type: "text", text: "The Confirm dialog could not render: pi invalidated this session's extension handle (session replacement). This is NOT a rejection — do NOT refine or re-propose. Tell the user to restart pi, then re-run the drafting flow." }], details: {} };
-            }
-            batchConfirmed = false;
+            extensionApiStale = true;
+            appendLedger(liveCtx.cwd, "extension_api_stale", { where: "batch confirm" });
+            return { content: [{ type: "text", text: "The Confirm dialog could not render: pi invalidated this session's extension handle (session replacement). This is NOT a rejection — do NOT refine or re-propose. Tell the user to restart pi, then re-run the drafting flow." }], details: {} };
           }
+          batchConfirmed = c === "yes";
         }
         if (!batchConfirmed) {
           return {
@@ -2696,17 +2727,14 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
         liveCtx.ui.notify(`Draft auto-accepted (/glla autoaccept=on)${willActivate ? " — ACTIVATING now" : ""}: ${p.objective.trim().slice(0, 90)}`, "info");
         appendLedger(liveCtx.cwd, "draft_autoaccepted", { kind: isListDraft ? "list" : "goal", objective: p.objective.trim().slice(0, 200) });
       } else {
-        try {
-          confirmed = await liveCtx.ui.confirm(isListDraft ? "Confirm list item" : "Confirm goal", `${p.objective.trim()}${contractBlock}${activationNote}`);
-        } catch (err) {
-          // v0.28.1 (T1): a stale confirm is NOT "Draft rejected by the user".
-          if (isStaleApiError(err)) {
-            extensionApiStale = true;
-            appendLedger(liveCtx.cwd, "extension_api_stale", { where: "draft confirm" });
-            return { content: [{ type: "text", text: "The Confirm dialog could not render: pi invalidated this session's extension handle (session replacement). This is NOT a rejection — do NOT refine or re-propose. Tell the user to restart pi, then re-run the drafting flow." }], details: {} };
-          }
-          confirmed = false;
+        const c = await confirmDraft(liveCtx, isListDraft ? "Confirm list item" : "Confirm goal", `${p.objective.trim()}${contractBlock}${activationNote}`);
+        if (c === "stale") {
+          // v0.28.1 (T1): a stale dialog is NOT "Draft rejected by the user".
+          extensionApiStale = true;
+          appendLedger(liveCtx.cwd, "extension_api_stale", { where: "draft confirm" });
+          return { content: [{ type: "text", text: "The Confirm dialog could not render: pi invalidated this session's extension handle (session replacement). This is NOT a rejection — do NOT refine or re-propose. Tell the user to restart pi, then re-run the drafting flow." }], details: {} };
         }
+        confirmed = c === "yes";
       }
       if (!confirmed) {
         return {
@@ -2811,7 +2839,7 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       // drafter path was still defaulting to 50 after v0.23.6 flipped the
       // CLI default.
       const max = p.max !== undefined && Number.isFinite(p.max) && p.max >= 0 ? Math.floor(p.max) : metricless ? 0 : 50;
-      const autoAccept = loadSettings(ctx.cwd).autoAcceptDrafts === true;
+      const autoAccept = loadSettings(liveCtx.cwd).autoAcceptDrafts === true;
       let confirmed = false;
       if (autoAccept) {
         confirmed = true;
@@ -2819,12 +2847,14 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
         appendLedger(liveCtx.cwd, "draft_autoaccepted", { kind: "loop", target: p.target.trim().slice(0, 200), metricless });
       } else {
         try {
-          confirmed = await liveCtx.ui.confirm(
+          const c = await confirmDraft(
+          liveCtx,
           "Confirm loop",
           metricless
             ? `Target: ${p.target.trim()}\n\nMeasure: NONE — metricless spec loop. There is NO plateau stop: the loop ends only at ${max > 0 ? `${max} iterations` : "NO iteration cap"}${typeof p.time === "number" && p.time > 0 ? ` · Time bound: ${p.time}h` : ""}${typeof p.tokens === "number" && p.tokens > 0 ? ` · Token bound: ${p.tokens.toLocaleString()}` : ""} · /loop stop.${p.branch ? "\nbranch mode: scratch branch, every iteration committed (clean tree required)" : ""}\n\nEvery iteration must make ONE real, inspectable change — cosmetic churn is the known failure mode (doorknob-polishing). Start it?`
             : `Target: ${p.target.trim()}\n\nMeasure: ${p.measureCmd}\nTest-run output: ${rawOutput.slice(0, 200)}\nParsed number: ${parsed} (${p.direction === "min" ? "lower is better" : "higher is better"})\n\nPlateau stop: ${window} non-improving iterations · Cap: ${max > 0 ? `${max} iterations` : "none (unbounded)"}${typeof p.time === "number" && p.time > 0 ? ` · Time bound: ${p.time}h` : ""}${typeof p.tokens === "number" && p.tokens > 0 ? ` · Token bound: ${p.tokens.toLocaleString()}` : ""}${p.branch ? "\nbranch mode: scratch branch (clean tree required)" : ""}\n\nThe loop never completes — it runs until one of these bounds, plateau, or /loop stop. Start it?`,
           );
+          confirmed = c === "yes";
         } catch {
           confirmed = false;
         }
@@ -2904,13 +2934,20 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
         }
       }
       let confirmed = false;
-      try {
-        confirmed = await liveCtx.ui.confirm(
-          "Confirm loop spec refinement",
+      if (loadSettings(liveCtx.cwd).autoAcceptDrafts === true) {
+        confirmed = true;
+        liveCtx.ui.notify("Loop spec refinement auto-accepted (/glla autoaccept=on).", "info");
+        appendLedger(liveCtx.cwd, "draft_autoaccepted", { kind: "loop-refine" });
+      } else {
+        try {
+          confirmed = (await confirmDraft(
+            liveCtx,
+            "Confirm loop spec refinement",
           `Rationale: ${p.rationale}\n\nTarget:\n  old: ${loop.target.slice(0, 120)}\n  new: ${newTarget.slice(0, 120)}\n\nMeasure:\n  old: ${loop.measureCmd}\n  new: ${newMeasure}${newMeasure !== loop.measureCmd ? `\n  test-run: ${testOutput.slice(0, 120)} → ${newBaseline}` : ""}\n\nThe loop keeps running against the refined spec (iteration ${loop.iteration} so far). Apply?`,
-        );
-      } catch {
-        confirmed = false;
+          )) === "yes";
+        } catch {
+          confirmed = false;
+        }
       }
       if (!confirmed) {
         return { content: [{ type: "text", text: "Refinement rejected by the user. The loop continues against the current spec — keep improving the metric as defined." }], details: {} };
@@ -3048,7 +3085,7 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
         const subs = (t.subtasks ?? []).map((s, j) => `   ${i + 1}.${j + 1} ${s}`).join("\n");
         return `${i + 1}. ${t.title}` + (subs ? `\n${subs}` : "");
       }).join("\n");
-      const autoAcceptTasks = loadSettings(ctx.cwd).autoAcceptDrafts === true;
+      const autoAcceptTasks = loadSettings(liveCtx.cwd).autoAcceptDrafts === true;
       let confirmed = false;
       if (autoAcceptTasks) {
         confirmed = true;
@@ -3056,7 +3093,7 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
         appendLedger(liveCtx.cwd, "draft_autoaccepted", { kind: "tasks", count: p.tasks.length });
       } else {
         try {
-          confirmed = await liveCtx.ui.confirm("Confirm task list", preview);
+          confirmed = (await confirmDraft(liveCtx, "Confirm task list", preview)) === "yes";
         } catch {
           confirmed = false;
         }
@@ -3453,17 +3490,17 @@ async function cmdToolOverride(args: string, ctx: ExtensionContext): Promise<voi
     if (action === "allow") {
       const allow = current.allow ?? [];
       if (!allow.includes(tool)) apply({ allow: [...allow, tool] });
-      ctx.ui.notify(`toolOverrides.allow += ${tool}`, "info");
+      ctx.ui.notify(`"${tool}" is now always visible to the agent (project override saved).`, "info");
     } else if (action === "hide") {
       const hide = current.hide ?? [];
       if (!hide.includes(tool)) apply({ hide: [...hide, tool] });
-      ctx.ui.notify(`toolOverrides.hide += ${tool}`, "info");
+      ctx.ui.notify(`"${tool}" is now always hidden from the agent (project override saved).`, "info");
     } else if (action === "unallow") {
       apply({ allow: (current.allow ?? []).filter((t) => t !== tool) });
-      ctx.ui.notify(`toolOverrides.allow -= ${tool}`, "info");
+      ctx.ui.notify(`"${tool}" visibility override removed — the session decides again.`, "info");
     } else {
       apply({ hide: (current.hide ?? []).filter((t) => t !== tool) });
-      ctx.ui.notify(`toolOverrides.hide -= ${tool}`, "info");
+      ctx.ui.notify(`"${tool}" hide override removed — the session decides again.`, "info");
     }
     return;
   }
@@ -3490,7 +3527,12 @@ async function cmdToolOverride(args: string, ctx: ExtensionContext): Promise<voi
     }
     cfg[tool] = toolCfg;
     apply({ perToolConfig: cfg });
-    ctx.ui.notify(`toolOverrides.perToolConfig.${tool} ${action === "set" ? "set" : "unset"}`, "info");
+    ctx.ui.notify(
+      action === "set"
+        ? `"${tool}" setting saved: ${kv.slice(0, kv.indexOf("="))} = ${JSON.stringify(toolCfg[kv.slice(0, kv.indexOf("="))])} (project override).`
+        : `"${tool}" setting "${kv}" removed — back to the built-in default.`,
+      "info",
+    );
     return;
   }
   ctx.ui.notify(`Unknown tooloverride action: ${action}. Use: list | allow | hide | unallow | unhide | set | unset.`, "warning");
@@ -3530,7 +3572,7 @@ async function cmdReviewerSettings(ctx: ExtensionContext): Promise<void> {
     const cfg = load();
     let choice: string | undefined;
     try {
-      choice = await ctx.ui.select("Reviewer — post-completion follow-up enqueuer (project settings)", reviewerMenuOptions(cfg));
+      choice = await ctx.ui.select("Postaudit — post-completion follow-up enqueuer (project settings)", reviewerMenuOptions(cfg));
     } catch {
       return;
     }
@@ -3557,8 +3599,10 @@ async function cmdReviewerSettings(ctx: ExtensionContext): Promise<void> {
         const n = Number(v?.trim());
         if (Number.isSafeInteger(n) && n >= 1 && n <= 100) save({ maxReviewsPerDay: n });
       }
-    } catch {
-      /* individual save failures are non-fatal */
+    } catch (err) {
+      // v0.28.11 (E7): a swallowed save failure made the user believe the
+      // toggle landed. Loud now.
+      ctx.ui.notify(`Postaudit setting NOT saved: ${err instanceof Error ? err.message : String(err)} — check .pi-glla/settings.json permissions.`, "warning");
     }
   }
 }
@@ -4041,7 +4085,7 @@ export default function (pi: ExtensionAPI): void {
     handler: settingsHandler,
   });
   pi.registerCommand("review", {
-    description: "Manually run the reviewer on an archived goal: /review <goal-id> [off|on|auto|aggressive] — extracts findings, writes a report to .pi-glla/reviews/, cascades per the mode (auto/aggressive = no Confirms). Bypasses the trigger gates (explicit user request).",
+    description: "Manually run the postaudit on an archived goal: /review <goal-id> [off|on|auto|aggressive] — extracts findings, writes a report to .pi-glla/reviews/, cascades per the mode (auto/aggressive = no Confirms). Bypasses the trigger gates (explicit user request).",
     handler: (args: string, ctx: ExtensionContext) => { rememberCtx(ctx); return cmdReview(args, ctx); },
   });
   pi.registerCommand("list", {

package/extensions/reviewer.ts

@@ -226,27 +226,27 @@ export function runReviewer(
   deps: ReviewerDeps,
 ): ReviewerOutcome {
   const none = (suppressedReason: string): ReviewerOutcome => ({ fired: false, suppressedReason, enqueued: 0, proposed: 0 });
-  if (!config.enabled && !deps.manual) return none("reviewer disabled");
+  if (!config.enabled && !deps.manual) return none("the postaudit is disabled (/glla postaudit → Enabled)");
   // v0.27.5: "off" mode is the user-friendly way to silence the postaudit
   // — equivalent to enabled=false but exposed via the postaudit menu.
-  if (config.mode === "off" && !deps.manual) return none("postaudit mode = off");
+  if (config.mode === "off" && !deps.manual) return none("postaudit mode is off (/glla postaudit → Mode)");
   const event = source.kind === "goal" ? `${source.terminal}` : "list-complete";
   if (!deps.manual) {
-    if (config.doNotFireOn.includes(event)) return none(`doNotFireOn: ${event}`);
-    if (source.kind === "goal" && source.terminal !== "goal-complete") return none(`not a completion: ${source.terminal}`);
-    if (!config.fireOn.includes(source.kind === "goal" ? "goal-complete" : "list-complete")) return none("fireOn excludes this event");
+    if (config.doNotFireOn.includes(event)) return none(`this event type (${event}) is excluded in /glla postaudit → fire-on`);
+    if (source.kind === "goal" && source.terminal !== "goal-complete") return none(`the goal ended as ${source.terminal}, not a completion — no follow-up fires`);
+    if (!config.fireOn.includes(source.kind === "goal" ? "goal-complete" : "list-complete")) return none("this event type is excluded in /glla postaudit → fire-on");
     // v0.26.2: in auto mode the queue emptying is the cascade's natural
     // rhythm, not a runaway — the refire window must not strangle it.
     // (The per-day cap below still bounds everything.)
     const refireWindowApplies = !(config.mode === "auto" && source.kind === "list");
     if (refireWindowApplies && reviewerFiredRecently(deps.ledgerEntries, REVIEWER_REFIRE_WINDOW_MS, deps.nowMs)) {
       deps.ledger("reviewer_suppressed", { reason: "refire-window", goalId: source.goalId });
-      return none("reviewer fired within the last 5 minutes (runaway prevention)");
+      return none("a postaudit ran within the last 5 minutes (runaway prevention)");
     }
     const today = reviewsToday(deps.ledgerEntries, deps.nowMs);
     if (today >= config.maxReviewsPerDay) {
       deps.ledger("reviewer_suppressed", { reason: "day-cap", count: today, cap: config.maxReviewsPerDay, goalId: source.goalId });
-      return none(`day cap reached (${today}/${config.maxReviewsPerDay})`);
+      return none(`daily postaudit cap reached (${today}/${config.maxReviewsPerDay}) — /glla postaudit → Max reviews`);
     }
   }
 

package/package.json

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

package/prompts/goal-loop-continuation.md

@@ -93,21 +93,28 @@ Do NOT spawn more subagents of the failed type until quota resets — you will j
 
 ## DETACHED COMMIT DETECTION
 
-If your commits keep getting rewritten away (same content, new SHA — or worse, content reverted), check the auto-committer daemon BEFORE diagnosing yourself as stuck or broken:
+If your commits keep getting rewritten away (same content, new SHA — or worse, content reverted), check for an **auto-commit daemon** BEFORE diagnosing yourself as stuck or broken. **Skip this section entirely if your rig has no auto-committer** — most rigs don't. (The maintainer's rigs run one called `dracon-sync`; yours may run a different one, or none.)
+
+Generic forensics (safe everywhere):
 
 ```bash
 git reflog --date=iso | grep -E "filter-branch|filter-repo"
 git reflog --date=iso | grep -E ": reset:"
+```
+
+If those show rewrites you didn't make, find the daemon (example for the maintainer's rig — adapt the pattern to yours):
+
+```bash
 ps -fea | grep -E "dracon-sync|filter-repo" | grep -v grep
 ```
 
-The auto-committer (`dracon-sync daemon`) may be running `auto_rewrite_large_blobs` on your commits. The fix is NOT to keep re-committing — it is to:
+An auto-committer may be rewriting your commits (e.g. `dracon-sync daemon` running `auto_rewrite_large_blobs`). The fix is NOT to keep re-committing — it is to:
 
-1. Pause the daemon (`dracon-sync pause`, or write the `.pi-glla/.pause-auto-commit` sentinel via the goal tools).
-2. Investigate the rewrite trigger (daemon config `max_push_blob_bytes`, `auto_rewrite_large_blobs`).
+1. Pause the daemon if one exists (on the maintainer's rigs: `dracon-sync pause`, or write the `.pi-glla/.pause-auto-commit` sentinel via the goal tools).
+2. Investigate the rewrite trigger (for `dracon-sync`: daemon config `max_push_blob_bytes`, `auto_rewrite_large_blobs`).
 3. Add `.pi-glla/` to the daemon's exclude list.
 
-Do NOT conclude "the loop is too eager" or "I am broken" before checking what the daemon is doing — the daemon rewriting your commits makes YOUR loop look broken when it is not.
+Do NOT conclude "the loop is too eager" or "I am broken" before checking what a daemon is doing — a daemon rewriting your commits makes YOUR loop look broken when it is not.
 
 ## TASK WORKFLOW