pi-goal-list-loop-audit 0.38.6 → 0.38.7

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.38.7 — session visibility: recovery banner + durable verdict tally (2026-09-03)
+
+### Added
+  Load-hold recovery banner: a consent-less cold load that engages the load hold now also paints objective + next pending task + verdict tally + resume command (`/goal`/`/list`/`/loop` by policy), all from durable disk state — the transcript is empty in exactly the sessions that need this. Fires once with the fresh hold; ledger `load_hold_recovery_banner`. Durable verdict tally (`auditorVerdictTally` via `auditVerdictLabel`): disapproval count + last-verdict age on the auditing status-line footer and the `/goal status` `Audits:` line, silent when history is empty — a reloaded session answers "are we progressing?" from stored verdicts.
+
+### Fixed
+  Reload invisibility: resumed-but-empty sessions no longer look goal-less, and capped/queued auditor sessions show stored-verdict evidence instead of a dead surface. Hold mechanics, hold text, auditor phase machine, and auditor card untouched. `tests/session-visibility.test.ts` (5 tests) pins tally classification, banner text, status-line tally, and a behavioral reload.
+
 ## 0.38.6 — over-cap starvation ladder: compact first, then 5 ordered recoveries (2026-09-03)
 
 ### Added

package/docs/INDEX.md

@@ -18,7 +18,7 @@ For shipped docs, the relevant entry points are:
   failback; v0.35.9 hardened cross-version npm tarball checks; v0.35.10
   handles multi-entry npm dry-run reports; v0.35.11 accepts both npm report
   shapes; v0.35.12 supports npm 12's keyed pack reports; v0.35.13 fixes stale-API recovery loops.
-  v0.35.14–v0.38.6 continue through the supervisor freeze (`/glla pause`),
+  v0.35.14–v0.38.7 continue through the supervisor freeze (`/glla pause`),
   load hold, auditor picker parity, Windows launch fix, zombie-watchdog
   subagent carve-out, due-wait backstop, the `/glla agents` visibility panel,
   durable state-root selection, blank-until-resume auditor context, frozen

package/extensions/goal-commands.ts

@@ -23,7 +23,7 @@ import {
 } from "./goal-loop-core.js";
 import { clearDispatchRecord, dispatchRecordExists } from "./goal-loop-dispatch.js";
 import type { AuditDisplayProgress } from "./goal-loop-display.js";
-import { fmtElapsed } from "./goal-loop-display.js";
+import { auditorVerdictTally, fmtElapsed, formatVerdictTallySegment } from "./goal-loop-display.js";
 import { AUDIT_FINDINGS_REL, HELD_ON_RESTORE, LOOP_AUDIT_MARKER, listAuditCollectTarget, projectAuditTarget } from "./goal-loop-forever.js";
 import { buildLoopCompletionSummary, compactCompletionSummary, compactTerminalCompletionSummary } from "./completion-summary.js";
 import { ProjectRollup, discoverGllaProjects, filterPremature, formatRollupJson, formatRollupTable, rollupProject } from "./goal-loop-stats.js";
@@ -381,8 +381,12 @@ async function cmdStatus(ctx: ExtensionContext): Promise<void> {
     `Tokens: ${(g.usage?.tokensUsed ?? 0).toLocaleString()}${(g.usage?.tokensLimit ?? 0) > 0 ? ` / ${(g.usage!.tokensLimit).toLocaleString()}` : " (no cap — set Token limit in /glla settings)"}`, 
     ...formatMainModelRecoveryStatus(state.mainModelRecovery, normalizeMainModelFallbackRefs(loadSettings(ctx.cwd).mainModelFallbacks)),
   ];
-  if (g.auditHistory && g.auditHistory.length > 0) {
-    lines.push(`Audits: ${g.auditHistory.length} (${g.auditHistory.filter((v) => v.approved).length} approved)`);
+  // v0.38.7: /goal status names disapprovals + last-verdict age, not just
+  // the approval count — a capped/queued session must show what unblocks.
+  const statusTally = auditorVerdictTally(g.auditHistory);
+  if (statusTally.total > 0) {
+    const tallyText = formatVerdictTallySegment(statusTally);
+    lines.push(`Audits: ${tallyText} (${statusTally.approvals} approved)`);
   }
   if (g.status === "auditing") {
     lines.push(`Completion audit: ${isCompletionAuditRecoveryPending(g) ? `recovery pending — ${activeGoalSurfaceCommand("resume")} retries the stored claim` : flags.completionAuditInFlight && flags.latestAuditProgress?.label === "queued" ? "detached auditor queued" : flags.completionAuditInFlight ? "detached auditor running" : "awaiting lifecycle recovery"}`);

package/extensions/goal-loop-display.ts

@@ -13,7 +13,7 @@
 import { truncateToWidth as tuiTruncateToWidth, visibleWidth as tuiVisibleWidth } from "@earendil-works/pi-tui";
 
 import type { DurableDeferRecommendationInput, Goal, MainModelRecovery, State } from "./goal-loop-core.js";
-import { buildDurableDeferRecommendation, compactDisplayText, formatMainModelRecoveryStatus, isMonitorGoal, isPersistenceDegraded, lastPersistenceFailure, sanitizeDisplayText, sanitizeProviderAuditReport, sanitizeProviderDisplayText, stripThinkBlocks } from "./goal-loop-core.js";
+import { auditVerdictLabel, buildDurableDeferRecommendation, compactDisplayText, formatMainModelRecoveryStatus, isMonitorGoal, isPersistenceDegraded, lastPersistenceFailure, sanitizeDisplayText, sanitizeProviderAuditReport, sanitizeProviderDisplayText, stripThinkBlocks } from "./goal-loop-core.js";
 
 export { isMonitorGoal };
 import { HELD_ON_RESTORE, type LoopState } from "./goal-loop-forever.js";
@@ -432,6 +432,68 @@ function latestAuditFeedback(g: Goal): LatestAuditFeedback | undefined {
   };
 }
 
+/** v0.38.7 (note.md Next: reload recovery + progress signal): durable
+ * verdict tally — disapproval count + last-verdict age from auditHistory.
+ * After a reload the in-memory auditor progress is gone; the stored
+ * verdicts are what answers "are we progressing?". Classification goes
+ * through auditVerdictLabel so a shield-blocked approval is never counted
+ * as a disapproval and an infra error is never counted as a verdict. */
+export interface AuditorVerdictTally {
+  total: number;
+  approvals: number;
+  disapprovals: number;
+  lastAt: number | null;
+  lastLabel: string | null;
+}
+export function auditorVerdictTally(history: Goal["auditHistory"], now = Date.now()): AuditorVerdictTally {
+  void now;
+  const entries = Array.isArray(history) ? history : [];
+  let approvals = 0;
+  let disapprovals = 0;
+  for (const v of entries) {
+    const label = auditVerdictLabel(v);
+    if (label === "approved") approvals++;
+    else if (label === "disapproved") disapprovals++;
+  }
+  const last = entries[entries.length - 1];
+  const lastMs = last ? Date.parse(last.at) : Number.NaN;
+  return {
+    total: entries.length,
+    approvals,
+    disapprovals,
+    lastAt: last && Number.isFinite(lastMs) ? lastMs : null,
+    lastLabel: last ? auditVerdictLabel(last) : null,
+  };
+}
+/** Compact tally segment for the always-on surfaces. "" when no verdicts. */
+export function formatVerdictTallySegment(t: AuditorVerdictTally, now = Date.now()): string {
+  if (t.total <= 0) return "";
+  const dis = t.disapprovals > 0 ? ` · ${t.disapprovals} disapproved` : "";
+  const age = t.lastAt !== null && t.lastLabel ? ` · last ${t.lastLabel} ${fmtElapsed(now - t.lastAt)} ago` : "";
+  return `${t.total} verdict${t.total === 1 ? "" : "s"}${dis}${age}`;
+}
+/** v0.38.7: the load-hold recovery banner — objective + next task + verdict
+ * tally + resume command, all from durable disk state (never transcript
+ * memory, which is empty in exactly the sessions that need this). */
+export interface LoadHoldRecoverySummary {
+  objective?: string | null;
+  status?: string;
+  nextTask?: string | null;
+  tally: AuditorVerdictTally;
+  resumeCommand: string;
+  listWaiting?: number;
+}
+export function buildLoadHoldRecoveryLines(s: LoadHoldRecoverySummary, now = Date.now()): string[] {
+  const lines = [
+    `glla: recovered from disk — "${truncate((s.objective ?? "").trim() || "(no objective recorded)", 120)}" (${s.status ?? "held"})`,
+  ];
+  lines.push(s.nextTask ? `next: ${truncate(s.nextTask, 100)}` : `next: no pending tasks recorded`);
+  const tally = formatVerdictTallySegment(s.tally, now);
+  lines.push(tally ? `audits: ${tally}` : `audits: none yet`);
+  if ((s.listWaiting ?? 0) > 0) lines.push(`list: ${s.listWaiting} waiting — /list to manage`);
+  lines.push(`run ${s.resumeCommand} to continue`);
+  return lines;
+}
 function activeAttention(g: Goal): ActiveAttention | undefined {
   if (g.status !== "active" || !g.pauseReason) return undefined;
   if (/regression shield/i.test(g.pauseReason)) {
@@ -954,7 +1016,12 @@ function buildStatusTextBase(state: State, audit?: AuditDisplayProgress | null,
     const quietSuffix = quietAge !== undefined ? ` · silent ${fmtElapsed(quietAge)}` : "";
     const next = ` · next: ${auditorNextTransition(phase)}`;
     const detachedSuffix = live ? "" : " · detached worker";
-    return `glla: ${host} · ${label}${quietSuffix}${next}${detachedSuffix}${heldSuffix}`;
+    // v0.38.7: durable verdict tally on the always-on footer — after a
+    // reload there is no live auditor evidence, so the stored verdicts
+    // (disapproval count + last-verdict age) answer "are we progressing?".
+    const tallyText = formatVerdictTallySegment(auditorVerdictTally(g.auditHistory, now), now);
+    const verdictSuffix = tallyText ? ` · ${tallyText}` : "";
+    return `glla: ${host} · ${label}${quietSuffix}${next}${detachedSuffix}${verdictSuffix}${heldSuffix}`;
   }
   if (g.status === "paused") {
     // v0.28.22: the status line names the ACTIONABILITY, not the reason —

package/extensions/loops/goal-activation.ts

@@ -238,7 +238,7 @@ import {
   textFingerprint,
   pushCapped as pushRepetitionCapped,
 } from "../goal-loop-repetition.js";
-import { buildStatusText, buildWidgetLines, type AuditDisplayProgress } from "../goal-loop-display.js";
+import { auditorVerdictTally, buildLoadHoldRecoveryLines, buildStatusText, buildWidgetLines, type AuditDisplayProgress } from "../goal-loop-display.js";
 import { compactLoopCompletionSummary } from "../completion-summary.js";
 import {
   defaultAgentDir,
@@ -1864,6 +1864,34 @@ export function registerGoalRuntime(pi: ExtensionAPI): void {
           "Loaded without starting: your goal/list/loop state is restored and shown below, but automation is HELD for your decision. /goal resume, /list resume, or /list next starts work; enable Auto-resume in /glla settings to restore load-time automation.",
           "warning",
         );
+        // v0.38.7 (note.md Next: objectives seemingly lost on reload) —
+        // the recovery banner: objective + next task + verdict tally +
+        // resume command, all from durable disk state. The transcript is
+        // empty in exactly the sessions that need this, so nothing here
+        // may depend on in-memory progress. Fires with the fresh hold
+        // (guarded above), never as a timer re-arm.
+        const tasks = state.goal?.taskList?.tasks ?? [];
+        const pendingTasks = tasks.filter((t) => t.status === "pending" || t.status === "in_progress");
+        const tally = auditorVerdictTally(state.goal?.auditHistory);
+        const resumeCommand = state.goal
+          ? (state.goal.policy === "list" ? "/list resume" : "/goal resume")
+          : (state.list?.length ?? 0) > 0 ? "/list resume" : state.loop ? "/loop resume" : "/goal resume";
+        const banner = buildLoadHoldRecoveryLines({
+          objective: state.goal?.objective ?? ((state.list?.length ?? 0) > 0 ? `${state.list!.length} queued list items` : null),
+          status: state.goal?.status ?? (state.loop ? "loop" : "held"),
+          nextTask: pendingTasks[0]?.title ?? null,
+          tally,
+          resumeCommand,
+          listWaiting: state.goal?.policy === "list" ? undefined : state.list?.length ?? 0,
+        });
+        appendLedger(ctx.cwd, "load_hold_recovery_banner", {
+          goalId: state.goal?.id ?? null,
+          status: state.goal?.status ?? null,
+          pendingTasks: pendingTasks.length,
+          totalVerdicts: tally.total,
+          disapprovals: tally.disapprovals,
+        });
+        ctx.ui.notify(banner.join("\n"), "info");
       }
     } else if ((autoResume || explicitRecovery) && typeof state.loadHoldAt === "number") {
       // v0.35.28 (issue #16): a hold persisted by a PREVIOUS process must

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goal-list-loop-audit",
-  "version": "0.38.6",
+  "version": "0.38.7",
   "description": "Mission control for autonomous pi: interview-drafted goals, an audited task queue, and forever-loops (metric, spec, project-audit) that run for hours. A detached extension-less auditor process re-verifies every completion with raw evidence without holding the main pi turn; confirmed drafts, decision pauses and consent gates keep you in charge.",
   "license": "AGPL-3.0-only",
   "author": "dracon",