pi-goal-list-loop-audit 0.28.25 → 0.28.27

package/README.md

@@ -39,6 +39,7 @@ Five top-level commands — `/goal`, `/list`, `/loop`, `/glla`, `/review`:
 /goal resume                       # resume
 /goal cancel                       # abort
 /goal decide                       # re-open the decision picker (v0.28.23)
+/goal audit                        # run the isolated auditor on the current goal now — no agent turn (v0.28.27)
 /goal tweak "<new objective>"      # edit in place (Confirm dialog)
 /goal archive                      # archived goals, newest first
 /glla                               # settings UI table · /glla key=value · /glla stats · /glla audits [N|full] · /glla postaudit · /glla autoaccept=on

package/extensions/goal-loop-core.ts

@@ -176,6 +176,15 @@ export interface Goal {
    * At 3 the goal pauses loudly — a broken auditor model must not spin a
    * silent retry-forever loop. Cleared on any real auditor run. */
   auditInfraStreak?: number;
+  /** v0.28.26: the completion claim captured when an audit attempt is
+   * quota-blocked. The quota retry re-runs the AUDITOR directly with this
+   * stored claim instead of re-engaging the agent — re-engaging produced a
+   * hallucinated-closure repetition loop in the field (π-games 2026-07-29:
+   * the agent concluded the goal was closed, stopped calling complete_goal,
+   * and repeated the same essay until the stall brake fired). Cleared when
+   * the retry resolves. Only consumed while paused with an "auditor quota:"
+   * reason, so a stale value is unreachable by construction. */
+  pendingCompletion?: { completionSummary?: string; verificationSummary?: string; at: string };
   /** v0.25.0 (contract item 22): auditor objections extracted as TODOs when
    * aggressiveMode keeps the goal active past the disapproval cap. Rendered
    * into every continuation prompt until the next audit clears them. */
@@ -203,9 +212,9 @@ export interface Goal {
 export type GoalRoute =
   | { kind: "draft" }
   | { kind: "set"; text: string }
-  | { kind: "sub"; name: "status" | "pause" | "resume" | "cancel" | "decide" | "tweak" | "archive" | "start"; rest: string };
+  | { kind: "sub"; name: "status" | "pause" | "resume" | "cancel" | "decide" | "audit" | "tweak" | "archive" | "start"; rest: string };
 
-const GOAL_EXACT_SUBS = new Set(["status", "pause", "resume", "cancel", "decide"]);
+const GOAL_EXACT_SUBS = new Set(["status", "pause", "resume", "cancel", "decide", "audit"]);
 const GOAL_ARG_SUBS = new Set(["tweak", "archive", "start"]);
 
 export function routeGoalArgs(raw: string): GoalRoute {

package/extensions/loops/goal.ts

@@ -568,6 +568,12 @@ function heartbeatTick(): void {
   // machinery below stays quiet for 3 minutes while the replaced session
   // settles (latch watchdog, wedge alert, refire counting all resume after).
   if (Date.now() < compactionGraceUntil) return;
+  // v0.28.27: a stale (session-replaced) handle can never land a send —
+  // the terminal warning already fired once. ALL stall machinery stays
+  // quiet from here on: refiring into a dead process is misleading, and
+  // worse, the stall escalation would PAUSE the goal — silently cancelling
+  // the interruptedAt → auto-resume-on-restart promise the footer shows.
+  if (extensionApiStale) return;
   // v0.26.5: pending-latch watchdog — a queued continuation whose turn
   // trigger was dropped (field-observed post-compaction: continuation
   // ACCEPTED at compact+0s, then 22 minutes of silence). The stuck latch
@@ -947,6 +953,148 @@ function archiveCurrentGoal(ctx: ExtensionContext, status: Status, stopReason?:
   }
 }
 
+/**
+ * v0.28.26: quota-window retry for a STORED completion claim. The auditor
+ * was quota-blocked at complete_goal time; the claim (completionSummary +
+ * verificationSummary) was persisted on the goal, and when the quota window
+ * elapses we re-run the AUDITOR directly — no agent turn. Re-engaging the
+ * agent to re-submit an unchanged claim produced a hallucinated-closure
+ * repetition loop in the field (π-games: the model concluded the goal was
+ * closed, repeated the same essay 4×+, stormed continuations, compacted 14×
+ * in 35 minutes, and burned the stall brake).
+ *
+ * Outcomes: approved → close + cascade (archiveCurrentGoal handles list
+ * advance + reviewer); quota again → re-pause with a fresh scheduled retry
+ * (claim preserved); anything else (disapproved, impossible, non-quota
+ * infra) → hand back to the agent: resume active + continuation, verdict
+ * durable in auditHistory.
+ */
+async function retryStoredCompletionAudit(ctx: ExtensionContext, origin: "quota-retry" | "manual" = "quota-retry"): Promise<void> {
+  const goal = state.goal;
+  if (!goal?.pendingCompletion) return;
+  if (completionAuditInFlight) return;
+  const liveCtx = freshCtx() ?? ctx;
+  const claim = goal.pendingCompletion;
+  updateGoal({ status: "auditing" }, liveCtx);
+  appendLedger(liveCtx.cwd, "goal_resumed", { via: origin === "manual" ? "manual-audit" : "quota-retry-direct-audit" });
+  liveCtx.ui.notify(origin === "manual"
+    ? "Manual /goal audit — running the isolated auditor now (no agent turn needed)."
+    : "Auditor quota window elapsed — retrying the audit with your stored completion claim (no agent turn needed).", "info");
+  const settings = loadSettings(liveCtx.cwd);
+  const { model: auditorModel, error: modelError, via } = resolveAuditorModel(liveCtx, settings.auditorModel);
+  if (modelError) liveCtx.ui.notify(`Auditor model issue: ${modelError}`, "warning");
+  latestAuditProgress = { label: "quota-retry", lastEventAt: Date.now() };
+  completionAuditInFlight = true;
+  const auditStartMs = Date.now();
+  let result: Awaited<ReturnType<typeof runGoalCompletionAuditor>>;
+  try {
+    ({ result } = await runWithInfraRetry(
+      () =>
+        runGoalCompletionAuditor({
+          ctx: liveCtx,
+          goal: state.goal!,
+          completionSummary: claim.completionSummary,
+          verificationSummary: claim.verificationSummary,
+          model: auditorModel,
+          thinkingLevel: settings.auditorThinkingLevel ?? getSessionThinkingLevel(),
+          onProgress: (progress) => {
+            latestAuditProgress = { currentTool: progress.currentTool, label: progress.label, elapsedMs: progress.elapsedMs, lastEventAt: Date.now() };
+            refreshUI(liveCtx);
+          },
+        }),
+      { onRetry: (err) => appendLedger(liveCtx.cwd, "audit_infra_retry", { goalId: state.goal?.id, error: err.slice(0, 200) }) },
+    ));
+  } finally {
+    completionAuditInFlight = false;
+    latestAuditProgress = null;
+  }
+  if (!state.goal) return; // aborted mid-audit
+
+  // Record the run in history (same compact shape as the tool path).
+  const auditorRan = result.output.trim().length > 0;
+  const history = state.goal.auditHistory ?? [];
+  if (auditorRan) {
+    result.output = stripThinkBlocks(result.output);
+    history.push({
+      at: nowIso(),
+      approved: result.approved,
+      disapproved: result.disapproved,
+      impossible: result.impossible,
+      impossibleReason: result.impossibleReason,
+      model: result.model,
+      thinkingLevel: result.thinkingLevel,
+      report: result.output,
+      error: result.error,
+      regressionShieldPassed: result.regressionShieldPassed,
+      regressionShieldMissing: result.regressionShieldMissing,
+      durationMs: Date.now() - auditStartMs,
+    } as any);
+    if (history.length > 20) history.splice(0, history.length - 20);
+  }
+
+  if (result.approved) {
+    updateGoal({ auditHistory: history, pendingCompletion: undefined }, liveCtx);
+    const objective = state.goal.objective;
+    archiveCurrentGoal(liveCtx, "complete", `auditor ${result.model} approved (${origin})`);
+    liveCtx.ui.notify(`Goal complete — auditor ${result.model} approved${origin === "manual" ? " on /goal audit" : " on the quota retry"}.`, "info");
+    notifyExternal(liveCtx, `Goal complete (auditor approved, ${origin}): ${objective.slice(0, 120)}`);
+    return;
+  }
+
+  if (result.error && !result.disapproved && isQuotaError(result.error)) {
+    // Still quota'd — re-pause with a fresh window, claim preserved.
+    const settingsNow = loadSettings(liveCtx.cwd);
+    const defaultSec = (settingsNow.quotaRetryMinutes ?? DEFAULT_QUOTA_RETRY_MINUTES) * 60;
+    const quota = parseQuotaError(result.error, defaultSec);
+    const retryMin = Math.max(1, Math.round(quota.retryAfterSec / 60));
+    updateGoal({
+      status: "paused",
+      auditHistory: history,
+      pauseKind: "wait",
+      pauseResumeAt: new Date(Date.now() + quota.retryAfterSec * 1000).toISOString(),
+      pauseReason: `auditor quota: ${result.error}`,
+      pauseSuggestedAction: `Quota auto-retry in ${retryMin}m — or /goal resume to retry now`,
+    }, liveCtx);
+    appendLedger(liveCtx.cwd, "goal_paused", { reason: `auditor quota: retry in ${quota.retryAfterSec}s (stored-claim retry)` });
+    liveCtx.ui.notify(`Auditor still quota-limited — next auto-retry in ${retryMin}m (your completion claim is stored; no action needed).`, "warning");
+    scheduleQuotaRetry(liveCtx, quota.retryAfterSec, result.error, () => {
+      if (state.goal && state.goal.status === "paused" && (state.goal.pauseReason ?? "").startsWith("auditor quota:") && state.goal.pendingCompletion) {
+        void retryStoredCompletionAudit(liveCtx, origin);
+      }
+    });
+    return;
+  }
+
+  // Any other outcome — disapproved, impossible, non-quota infra — belongs
+  // to the agent: resume and let the continuation drive the next step. The
+  // verdict is durable in auditHistory + /goal status.
+  updateGoal({
+    status: "active",
+    auditHistory: history,
+    pendingCompletion: undefined,
+    pauseReason: result.disapproved
+      ? `auditor disapproved on quota-retry — see /goal status`
+      : result.impossible
+        ? `auditor verdict: IMPOSSIBLE on quota-retry — ${(result.impossibleReason ?? "").slice(0, 120)}`
+        : `auditor infrastructure error on quota-retry: ${(result.error ?? "").slice(0, 120)}`,
+  }, liveCtx);
+  liveCtx.ui.notify(
+    result.disapproved
+      ? `Auditor (${origin}) DISAPPROVED — resuming; the report is in /goal status.`
+      : result.impossible
+        ? `Auditor (${origin}): goal IMPOSSIBLE — ${(result.impossibleReason ?? "").slice(0, 100)}. Resuming; consider /goal tweak.`
+        : `Auditor (${origin}) hit an infrastructure error — resuming; re-call complete_goal when ready.`,
+    "warning",
+  );
+  appendLedger(liveCtx.cwd, "quota_retry_audit_verdict", {
+    approved: false,
+    disapproved: result.disapproved,
+    impossible: result.impossible,
+    error: result.error?.slice(0, 160),
+  });
+  scheduleContinuation(liveCtx, true);
+}
+
 /**
  * v0.26.0: bind the reviewer to the live session. Sources for finding
  * extraction: the archived goal markdown + its audit reports + the
@@ -1169,6 +1317,30 @@ async function cmdGoal(args: string, ctx: ExtensionContext): Promise<void> {
       if (!shown) ctx.ui.notify("No pending decision — the goal isn't paused on a choice (or no UI).", "info");
       return;
     }
+    // v0.28.27: /goal audit — run the isolated auditor on the current goal
+    // RIGHT NOW, without engaging the agent. The user's "the work looks
+    // done — just verify it" handle (and the manual counterpart of the
+    // v0.28.26 stored-claim quota retry). Seeds a synthesized claim so a
+    // quota block falls into the same pendingCompletion retry machinery.
+    if (route.name === "audit") {
+      if (!state.goal) {
+        ctx.ui.notify("No active goal — /goal audit needs a goal to verify.", "warning");
+        return;
+      }
+      if (completionAuditInFlight) {
+        ctx.ui.notify("An audit is already running…", "info");
+        return;
+      }
+      updateGoal({
+        pendingCompletion: {
+          completionSummary: "Manual audit requested by the user via /goal audit (no agent completion claim). Verify the objective against the repo directly.",
+          at: nowIso(),
+        },
+      }, ctx);
+      appendLedger(ctx.cwd, "manual_audit_requested", { goalId: state.goal.id });
+      void retryStoredCompletionAudit(ctx, "manual");
+      return;
+    }
     if (route.name === "tweak") return cmdTweak(route.rest, ctx);
     if (route.name === "archive") return cmdGoals(ctx);
     // v0.16.0: /goal start <objective> — explicit skip-draft. Activates
@@ -2574,6 +2746,9 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
             status: "paused",
             auditHistory: history,
             auditInfraStreak: undefined, // quota reached the auditor — infra streak broken
+            // v0.28.26: store the claim — the quota retry re-runs the
+            // auditor DIRECTLY with it (no agent turn to confuse).
+            pendingCompletion: { completionSummary: p.completionSummary, verificationSummary: p.verificationSummary, at: nowIso() },
             pauseKind: "wait",
             pauseResumeAt: new Date(Date.now() + quota.retryAfterSec * 1000).toISOString(),
             pauseReason: `auditor quota: ${result.error}`,
@@ -2584,6 +2759,13 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
             // Re-check: only auto-resume if STILL paused for the quota
             // reason (a user /goal pause during the window is not stomped).
             if (state.goal && state.goal.status === "paused" && (state.goal.pauseReason ?? "").startsWith("auditor quota:")) {
+              // v0.28.26: a stored claim retries the AUDITOR directly — the
+              // agent is not needed to re-submit an unchanged claim, and
+              // re-engaging it produced hallucinated-closure loops.
+              if (state.goal.pendingCompletion) {
+                void retryStoredCompletionAudit(ctx);
+                return;
+              }
               updateGoal({ status: "active" }, ctx);
               appendLedger(ctx.cwd, "goal_resumed", { via: "quota-retry" });
               if (resolveEffectiveAggressiveSettings(loadSettings(ctx.cwd)).aggressiveMode) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goal-list-loop-audit",
-  "version": "0.28.25",
+  "version": "0.28.27",
   "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/schemas/goal.schema.json

@@ -53,6 +53,7 @@
     "interruptedAt": { "type": "string" },
     "interruptedReason": { "type": "string" },
     "auditInfraStreak": { "type": "number" },
+    "pendingCompletion": { "type": "object" },
     "activePath": { "type": "string" },
     "archivedPath": { "type": "string" },
     "usage": {