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

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,89 @@ 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;
+}
+
+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");
+}

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,12 @@ import {
   isFullAuditObjective,
   lastShippedAtMs,
   resolveEffectiveAggressiveSettings,
+  appendAuditLog,
   computeListDepth,
+  formatAuditLog,
+  readAuditLog,
+  stripThinkBlocks,
+  type AuditLogEntry,
   ledgerPath,
   crossRecommendMode,
   formatListDepth,
@@ -1697,7 +1702,7 @@ 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" };
+      latestAuditProgress = { label: "starting", lastEventAt: Date.now() };
       const result = await runGoalCompletionAuditor({
         ctx,
         goal: state.goal,
@@ -1711,6 +1716,7 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
             currentTool: progress.currentTool,
             label: progress.label,
             elapsedMs: progress.elapsedMs,
+            lastEventAt: Date.now(),
           };
           refreshUI(ctx);
         },
@@ -1723,6 +1729,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 +1742,36 @@ 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,
         });
         // 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,
+        });
       }
 
       // Escape hatch: the user aborted the audit (Esc). Offer the explicit
@@ -1916,7 +1950,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 +2778,24 @@ 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 nMatch = args.match(/\b(\d+)\b/);
+  if (full) {
+    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;
+  }
+  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 +2814,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 +3115,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.4",
   "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",