pi-goal-list-loop-audit 0.25.3 → 0.25.5

package/extensions/goal-loop-auditor.ts

@@ -159,7 +159,9 @@ function buildGoalAuditorPrompt(goal: Goal, completionSummary: string | null | u
       ? ["4. Verify that the executor has satisfied every item in the <verification_contract>. If any item is missing or weakly addressed, disapprove."]
       : []),
     "5. Explain missing or weak evidence, especially scaffold-vs-final quality gaps.",
-    "6. End with exactly <approved/> only if the objective is truly complete; <impossible>reason</impossible> if it can never be satisfied as stated; otherwise end with exactly <disapproved/>.",
+    "6. When you disapprove, end the report body with a '## Required fixes' section: one line per blocking gap, each an actionable instruction the executor can complete (most critical first). This tail is what the executor sees first — make it self-sufficient.",
+    "7. Write the report in English, and never emit <think> blocks or fragments — your reasoning stays private; the report is the verdict plus evidence.",
+    "8. End with exactly <approved/> only if the objective is truly complete; <impossible>reason</impossible> if it can never be satisfied as stated; otherwise end with exactly <disapproved/>.",
     ...(goal.verificationContract?.trim()
       ? [
           "",

package/extensions/goal-loop-core.ts

@@ -309,8 +309,14 @@ export const DEFAULT_AUDIT_FEEDBACK_CHARS = 0;
  * Bound the auditor report returned to the executor after disapproval.
  * A limit of 0 explicitly means "show the full report".
  */
+/** Executor-visible excerpt of a disapproval report. Full by default
+ * (maxChars 0). When capped, keep the TAIL: since v0.25.4 the auditor
+ * ends disapprovals with the actionable `## Required fixes` section —
+ * head-slicing would cut exactly what the executor needs. */
 export function auditFeedbackExcerpt(output: string, maxChars: number): string {
-  return maxChars === 0 ? output : output.slice(0, maxChars);
+  if (maxChars === 0 || output.length <= maxChars) return output;
+  return `[head truncated — full report via /goal status]
+…${output.slice(-maxChars)}`;
 }
 
 export interface ListItem {
@@ -400,10 +406,19 @@ export interface State {
 /** v0.24.2: count TRAILING consecutive disapprovals (the disapproval-cap
  *  input). Shield-blocks (approved:true) and infra errors (neither flag)
  *  break the streak — they are not verdicts on the work. */
+/** v0.24.2: count TRAILING consecutive disapprovals (the disapproval-cap
+ *  input). Shield-blocks (approved:true) break the streak — the work was
+ *  judged good. v0.25.4: pure infra errors (error set, neither verdict
+ *  flag) are TRANSPARENT, not streak-breakers — the auditor never judged
+ *  the work, so D,D,infra,D is still 3 trailing disapprovals (before, 39
+ *  hegemon-style infra errors would reset the cap and re-open infinite
+ *  re-continuation). */
 export function countTrailingDisapprovals(history: AuditVerdict[]): number {
   let n = 0;
   for (let i = history.length - 1; i >= 0; i--) {
-    if (history[i]!.disapproved) n++;
+    const v = history[i]!;
+    if (v.disapproved) n++;
+    else if (v.error && !v.approved) continue; // infra: not a verdict
     else break;
   }
   return n;
@@ -1044,3 +1059,145 @@ export function formatListDepth(stats: ListDepthStats): string {
   if (stats.durationSamples > 0) lines.push(`avg item duration: ${fmtAge(stats.avgDurationMs!)} (from last ${stats.durationSamples} archived)`);
   return lines.join("\n");
 }
+
+// =================================================================
+// v0.25.4: auditor polish — durable audit log, think-block hygiene,
+// actionable-tail slicing, infra-transparent streaks
+// =================================================================
+
+/** Strip think-block leakage from auditor reports before storage/display.
+ * Motivation (wild, 2026-07-25): MiniMax-M3 reports arrive with
+ * `<think>...</think>` bodies, stray `</think>` fragments, and non-English
+ * reasoning spillover — the executor's feedback should be the verdict,
+ * not the auditor's private monologue. */
+export function stripThinkBlocks(text: string): string {
+  return text
+    .replace(/<think>[\s\S]*?<\/think>/gi, "")
+    .replace(/<\/?think>/gi, "")
+    .replace(/<200b>/g, "") // stray partial-tag artifact seen in the wild
+    .replace(/^\s+/, "");
+}
+
+/** One durable audit-log entry — survives state-snapshot rotation, so
+ * /glla audits can answer "where are we weak" across the whole project. */
+export interface AuditLogEntry {
+  at: string;
+  goalId: string;
+  objective: string;
+  verdict: "approved" | "disapproved" | "impossible" | "shield_blocked" | "error";
+  model: string;
+  thinkingLevel: string;
+  report: string;
+  impossibleReason?: string;
+  error?: string;
+  /** v0.25.4 post-audit: how long the audit took, and whether the infra
+   * retry fired. */
+  durationMs?: number;
+  retriedOnce?: boolean;
+}
+
+export function auditLogPath(cwd: string): string {
+  return path.join(cwd, ".pi-glla", "audits.jsonl");
+}
+
+export function appendAuditLog(cwd: string, entry: AuditLogEntry): void {
+  try {
+    ensureDirs(cwd);
+    fs.appendFileSync(auditLogPath(cwd), JSON.stringify(entry) + "\n");
+  } catch {
+    /* log best-effort — never block the verdict path */
+  }
+}
+
+export function readAuditLog(cwd: string, limit?: number): AuditLogEntry[] {
+  let raw: string;
+  try {
+    raw = fs.readFileSync(auditLogPath(cwd), "utf-8");
+  } catch {
+    return [];
+  }
+  const out: AuditLogEntry[] = [];
+  for (const line of raw.split("\n")) {
+    const t = line.trim();
+    if (!t) continue;
+    try {
+      const e = JSON.parse(t);
+      if (e && typeof e.goalId === "string" && typeof e.verdict === "string") out.push(e as AuditLogEntry);
+    } catch {
+      /* skip malformed */
+    }
+  }
+  return limit !== undefined ? out.slice(-limit) : out;
+}
+
+const VERDICT_GLYPH: Record<AuditLogEntry["verdict"], string> = {
+  approved: "✔",
+  disapproved: "✖",
+  impossible: "⛔",
+  shield_blocked: "🛡",
+  error: "⚠",
+};
+
+/** /glla audits list view: one line per verdict, newest last. */
+export function formatAuditLog(entries: AuditLogEntry[]): string {
+  if (entries.length === 0) return "(no audits logged yet — the log starts with the next verdict)";
+  return entries
+    .map((e) => {
+      const day = e.at.slice(5, 16).replace("T", " ");
+      const firstLine = (e.report.split("\n").find((l) => l.trim()) ?? "").trim().slice(0, 90);
+      return `${VERDICT_GLYPH[e.verdict]} ${day} [${e.goalId.slice(-6)}] ${e.model} — ${firstLine}`;
+    })
+    .join("\n");
+}
+
+// =================================================================
+// v0.25.4 (post-audit fix): infra-failure retry-once-with-backoff
+// =================================================================
+
+/** Which auditor infra errors are worth an automatic retry? User aborts
+ * and missing-model config are NOT — retrying can't help them. */
+export function isRetriableInfraError(error?: string): boolean {
+  if (!error) return false;
+  if (/aborted/i.test(error)) return false;
+  if (/no model/i.test(error)) return false;
+  return true;
+}
+
+export interface InfraRetryOutcome<T> {
+  result: T;
+  retriedOnce: boolean;
+}
+
+/** Run the auditor; on a retriable infra failure, wait `backoffMs` and
+ * retry EXACTLY once before reporting "auditor infrastructure error
+ * (retried once)". The failed pair is never a verdict on the work. */
+export async function runWithInfraRetry<T extends { error?: string; approved: boolean; disapproved: boolean }>(
+  run: () => Promise<T>,
+  opts: { backoffMs?: number; sleep?: (ms: number) => Promise<void>; onRetry?: (error: string) => void } = {},
+): Promise<InfraRetryOutcome<T>> {
+  const sleep = opts.sleep ?? ((ms: number) => new Promise<void>((r) => setTimeout(r, ms)));
+  const first = await run();
+  if (first.approved || first.disapproved || !isRetriableInfraError(first.error)) {
+    return { result: first, retriedOnce: false };
+  }
+  opts.onRetry?.(first.error!);
+  await sleep(opts.backoffMs ?? 5000);
+  const second = await run();
+  return { result: second, retriedOnce: true };
+}
+
+/** /glla audits default view: the ACTIVE goal's own audit history (the
+ * surface the goal spec asked for), one line per verdict. */
+export function formatGoalAuditHistory(goal: { id: string; auditHistory?: Array<any> }): string {
+  const history = goal.auditHistory ?? [];
+  if (history.length === 0) return "(no audits on this goal yet)";
+  return history
+    .map((v) => {
+      const glyph = v.approved ? (v.regressionShieldPassed === false ? "🛡" : "✔") : v.impossible ? "⛔" : v.disapproved ? "✖" : "⚠";
+      const day = String(v.at ?? "").slice(5, 16).replace("T", " ");
+      const elapsed = v.durationMs ? ` · ${Math.round(v.durationMs / 60000)}m` : "";
+      const firstLine = (String(v.report ?? "").split("\n").find((l: string) => l.trim()) ?? "").trim().slice(0, 80);
+      return `${glyph} ${day} ${v.model ?? "?"}${elapsed} — ${firstLine}`;
+    })
+    .join("\n");
+}

package/extensions/goal-loop-display.ts

@@ -72,6 +72,9 @@ export interface AuditDisplayProgress {
   currentTool?: string;
   label?: string;
   elapsedMs?: number;
+  /** v0.25.4: last progress-event time — the widget flags auditor-quiet
+   * stalls when this goes stale while the audit is in flight. */
+  lastEventAt?: number;
 }
 
 /**
@@ -175,7 +178,12 @@ function goalLines(g: Goal, state: State, audit: AuditDisplayProgress | null | u
   const lines = [head, `├─ ${isList ? "list item · " : ""}${statusWord} · ${fmtElapsed(now - Date.parse(g.createdAt))}${tokens}`];
   if (g.status === "auditing") {
     lines.push(`├─ auditor: ${audit?.label ?? "running"}${audit?.currentTool ? ` · ${truncate(audit.currentTool, 30)}` : ""}`);
-    if (audit?.elapsedMs) lines.push(`└─ ${paint(theme, "dim", `${fmtElapsed(audit.elapsedMs)} in isolated session`)}`);
+    // v0.25.4: auditor-quiet stall — progress events stopped arriving
+    // while the audit is in flight (hung model call, stuck tool).
+    const quietMs = audit?.lastEventAt !== undefined ? now - audit.lastEventAt : 0;
+    if (quietMs > 3 * 60_000) {
+      lines.push(`└─ ${paint(theme, "warning", `auditor quiet ${fmtElapsed(quietMs)} — may be stuck; Esc aborts, verdict is not counted`)}`);
+    } else if (audit?.elapsedMs) lines.push(`└─ ${paint(theme, "dim", `${fmtElapsed(audit.elapsedMs)} in isolated session`)}`);
     else lines.push(`└─ ${paint(theme, "dim", "isolated session, read-only tools")}`);
     return lines;
   }

package/extensions/loops/goal.ts

@@ -39,7 +39,14 @@ import {
   isFullAuditObjective,
   lastShippedAtMs,
   resolveEffectiveAggressiveSettings,
+  appendAuditLog,
   computeListDepth,
+  formatAuditLog,
+  formatGoalAuditHistory,
+  runWithInfraRetry,
+  readAuditLog,
+  stripThinkBlocks,
+  type AuditLogEntry,
   ledgerPath,
   crossRecommendMode,
   formatListDepth,
@@ -1697,24 +1704,39 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       ctx.ui.notify(`Auditor running (isolated session, model: ${via ?? "setting"})…`, "info");
       // Esc during the audit aborts this tool's signal → threaded into the
       // auditor session, which aborts cleanly and returns "Auditor aborted."
-      latestAuditProgress = { label: "starting" };
-      const result = await runGoalCompletionAuditor({
-        ctx,
-        goal: state.goal,
-        completionSummary: p.completionSummary,
-        verificationSummary: p.verificationSummary,
-        model: auditorModel,
-        thinkingLevel: settings.auditorThinkingLevel ?? getSessionThinkingLevel(),
-        signal: signal ?? undefined,
-        onProgress: (progress) => {
-          latestAuditProgress = {
-            currentTool: progress.currentTool,
-            label: progress.label,
-            elapsedMs: progress.elapsedMs,
-          };
+      latestAuditProgress = { label: "starting", lastEventAt: Date.now() };
+      const runAudit = () =>
+        runGoalCompletionAuditor({
+          ctx,
+          goal: state.goal!,
+          completionSummary: p.completionSummary,
+          verificationSummary: p.verificationSummary,
+          model: auditorModel,
+          thinkingLevel: settings.auditorThinkingLevel ?? getSessionThinkingLevel(),
+          signal: signal ?? undefined,
+          onProgress: (progress) => {
+            latestAuditProgress = {
+              currentTool: progress.currentTool,
+              label: progress.label,
+              elapsedMs: progress.elapsedMs,
+              lastEventAt: Date.now(),
+            };
+            refreshUI(ctx);
+          },
+        });
+      // v0.25.4 (post-audit fix): a retriable infra failure (stream error,
+      // auth blip — NOT user abort, NOT missing model) gets ONE automatic
+      // retry with backoff before we report "auditor infrastructure error
+      // (retried once)". Neither attempt is a verdict on the work.
+      const auditStartMs = Date.now();
+      const { result, retriedOnce } = await runWithInfraRetry(runAudit, {
+        onRetry: (err) => {
+          latestAuditProgress = { label: `infra error (${err.slice(0, 40)}) — retrying once`, lastEventAt: Date.now() };
           refreshUI(ctx);
+          appendLedger(ctx.cwd, "audit_infra_retry", { goalId: state.goal?.id, error: err.slice(0, 200) });
         },
       });
+      const auditDurationMs = Date.now() - auditStartMs;
       latestAuditProgress = null;
       // Audit history: record REAL verdicts only — a non-empty report is the
       // evidence the auditor actually inspected something. Empty-report runs
@@ -1723,6 +1745,11 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       const auditorRan = result.output.trim().length > 0;
       const history = state.goal.auditHistory ?? [];
       if (auditorRan) {
+        // v0.25.4: strip think-block leakage (MiniMax-M3 `</think>`
+        // fragments + reasoning spillover) before anything stores or
+        // displays the report.
+        const cleanOutput = stripThinkBlocks(result.output);
+        result.output = cleanOutput;
         history.push({
           at: nowIso(),
           approved: result.approved,
@@ -1731,13 +1758,39 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
           impossibleReason: result.impossibleReason,
           model: result.model,
           thinkingLevel: result.thinkingLevel,
-          report: result.output,
+          report: cleanOutput,
           error: result.error,
           regressionShieldPassed: result.regressionShieldPassed,
           regressionShieldMissing: result.regressionShieldMissing,
-        });
+          durationMs: auditDurationMs,
+        } as any);
         // Cap history — 39 infra errors taught us unbounded growth is real.
         if (history.length > 20) history.splice(0, history.length - 20);
+        // v0.25.4: durable append-only audit log — survives state-snapshot
+        // rotation; the review surface for "where are we weak".
+        const verdict: AuditLogEntry["verdict"] =
+          result.error && !result.approved && !result.disapproved
+            ? "error"
+            : result.approved && result.regressionShieldPassed === false
+              ? "shield_blocked"
+              : result.approved
+                ? "approved"
+                : result.impossible
+                  ? "impossible"
+                  : "disapproved";
+        appendAuditLog(ctx.cwd, {
+          at: nowIso(),
+          goalId: state.goal.id,
+          objective: state.goal.objective.slice(0, 200),
+          verdict,
+          model: result.model,
+          thinkingLevel: result.thinkingLevel ?? "(default)",
+          report: cleanOutput,
+          impossibleReason: result.impossibleReason,
+          error: result.error,
+          durationMs: auditDurationMs,
+          retriedOnce,
+        } as AuditLogEntry);
       }
 
       // Escape hatch: the user aborted the audit (Esc). Offer the explicit
@@ -1863,14 +1916,14 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
         updateGoal({
           status: "active",
           auditHistory: history,
-          pauseReason: `auditor infrastructure: ${result.error}`,
+          pauseReason: `auditor infrastructure${retriedOnce ? " (retried once)" : ""}: ${result.error}`,
           pauseSuggestedAction: "Fix the auditor model (/glla model=provider/id) and call complete_goal again — your work was NOT judged",
         }, ctx);
         scheduleContinuation(ctx, true);
         return {
           content: [{
             type: "text",
-            text: `The auditor could not run (infrastructure, NOT a verdict): ${result.error}\nYour completion claim was not evaluated. Fix the auditor model with /glla model=provider/id and call complete_goal again — do not change your deliverable for this.`,
+            text: `The auditor could not run (infrastructure, NOT a verdict${retriedOnce ? "; retried once with backoff, both attempts failed" : ""}): ${result.error}\nYour completion claim was not evaluated. Fix the auditor model with /glla model=provider/id and call complete_goal again — do not change your deliverable for this.`,
           }],
           details: {},
         };
@@ -1916,7 +1969,7 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       const auditFeedbackIsFull = auditFeedbackChars === 0 || result.output.length <= auditFeedbackChars;
       const auditFeedbackLabel = auditFeedbackIsFull
         ? "full report"
-        : `first ${auditFeedbackChars} chars`;
+        : `last ${auditFeedbackChars} chars (Required-fixes tail)`;
       const auditFeedbackTruncationHint = auditFeedbackIsFull
         ? ""
         : `\n\nReport truncated at the configured limit. /goal status shows the full report; change future feedback with /glla auditfeedbackchars=N (0 = full report).`;
@@ -2744,6 +2797,40 @@ function cmdStats(args: string, ctx: ExtensionContext): void {
   ctx.ui.notify(`glla stats — ${rollups.length} project(s)${prematureOnly ? " (premature filter)" : ""}\n${out}`, "info");
 }
 
+/**
+ * v0.25.4: /glla audits [N|full] — browse the durable per-project audit
+ * log (.pi-glla/audits.jsonl). Default: last 10 verdicts, one line each.
+ * "full" prints the latest report in full.
+ */
+function cmdAudits(args: string, ctx: ExtensionContext): void {
+  const full = /\bfull\b/.test(args);
+  const all = /\b(?:all|global|log)\b/.test(args);
+  const nMatch = args.match(/\b(\d+)\b/);
+  if (full) {
+    // Latest report — active goal's history first, then the log.
+    const fromGoal = state.goal?.auditHistory?.at(-1);
+    if (fromGoal?.report) {
+      ctx.ui.notify(`Latest audit on this goal — ${fromGoal.model} (${fromGoal.at})\n${fromGoal.report}`, "info");
+      return;
+    }
+    const latest = readAuditLog(ctx.cwd).at(-1);
+    ctx.ui.notify(latest ? `Latest audit — ${latest.verdict} (${latest.model}, ${latest.at})\n${latest.report}` : "No audits logged yet.", "info");
+    return;
+  }
+  // Default: the ACTIVE goal's own audit history (with per-audit elapsed);
+  // "all"/"global"/"log" browses the durable cross-goal log.
+  if (!all && state.goal?.auditHistory && state.goal.auditHistory.length > 0) {
+    ctx.ui.notify(
+      `glla audits — this goal's history (${state.goal.auditHistory.length} verdict(s); /glla audits all for the project log)\n${formatGoalAuditHistory(state.goal)}`,
+      "info",
+    );
+    return;
+  }
+  const n = nMatch ? Number(nMatch[1]) : 10;
+  const entries = readAuditLog(ctx.cwd, n);
+  ctx.ui.notify(`glla audits — last ${entries.length} verdict(s) in ${ctx.cwd}\n${formatAuditLog(entries)}`, "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
@@ -2762,6 +2849,10 @@ async function cmdSettings(args: string, ctx: ExtensionContext): Promise<void> {
     cmdStats(trimmed.slice("stats".length).trim(), ctx);
     return;
   }
+  if (/^audits\b/.test(trimmed)) {
+    cmdAudits(trimmed.slice("audits".length).trim(), ctx);
+    return;
+  }
   if (!trimmed) {
     if (ctx.hasUI) {
       await openSettingsUI(ctx);
@@ -3059,6 +3150,7 @@ export default function (pi: ExtensionAPI): void {
       ["quotaretryminutes=", "N: minutes before auto-retrying a quota-exhausted auditor (default 60)"],
       ["stuckmax=", "N: consecutive stuck interventions before a loop stops (default 5)"],
       ["stats", "per-project ledger rollups: /glla stats [json|premature|project=<path>]"],
+      ["audits", "audit-log browser: /glla audits [N|full] — recent verdicts from .pi-glla/audits.jsonl"],
       ["autoaccept=", "on: drafts activate without the Confirm dialog (unattended rigs)"],
       ["project", "write a project override: /glla project key=value"],
     ]),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goal-list-loop-audit",
-  "version": "0.25.3",
+  "version": "0.25.5",
   "description": "Goal. Loop. Audit. Done. — 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 — only the read tools needed to verify your goal.",
   "license": "MIT",
   "author": "dracon",