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

package/extensions/goal-loop-core.ts

@@ -1090,6 +1090,10 @@ export interface AuditLogEntry {
   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 {
@@ -1145,3 +1149,55 @@ export function formatAuditLog(entries: AuditLogEntry[]): string {
     })
     .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/loops/goal.ts

@@ -42,6 +42,8 @@ import {
   appendAuditLog,
   computeListDepth,
   formatAuditLog,
+  formatGoalAuditHistory,
+  runWithInfraRetry,
   readAuditLog,
   stripThinkBlocks,
   type AuditLogEntry,
@@ -1703,24 +1705,38 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       // Esc during the audit aborts this tool's signal → threaded into the
       // auditor session, which aborts cleanly and returns "Auditor aborted."
       latestAuditProgress = { label: "starting", lastEventAt: Date.now() };
-      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,
-            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
@@ -1746,7 +1762,8 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
           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
@@ -1771,7 +1788,9 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
           report: cleanOutput,
           impossibleReason: result.impossibleReason,
           error: result.error,
-        });
+          durationMs: auditDurationMs,
+          retriedOnce,
+        } as AuditLogEntry);
       }
 
       // Escape hatch: the user aborted the audit (Esc). Offer the explicit
@@ -1897,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: {},
         };
@@ -2785,12 +2804,28 @@ function cmdStats(args: string, ctx: ExtensionContext): void {
  */
 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");

package/package.json

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