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

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 0.38.8 — TUI information-density pass (2026-09-03)
+
+### Added
+  Widget `audits:` row (verdict tally, width-truncated, silent when empty); verdict tally suffix on all paused status lines via `pausedStatusSuffix`; per-tab row counts in the settings menu (`settingsTabLabel`, pure). Starvation ladder reflowed to one recovery per line, same content and phrases.
+
+### Fixed
+  Glance-density gaps: parked sessions read as waiting-with-history instead of dead; ladder recoveries scannable; settings tabs locate content. Display-only — no automation, hold, auditor, or menu-structure changes. `tests/tui-density.test.ts` (5 tests) pins all four surfaces plus an 80-column widget fit; before/after captures in `audit/TUI-DENSITY-2026-09-03.md`.
+
+## 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.8 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)) {
@@ -861,10 +923,14 @@ function pausedStatusSuffix(g: Goal, state: State, extras: WidgetExtras | undefi
   const queueLabel = (state.list?.length ?? 0) > 0 ? `${state.list!.length} queued` : "queue empty";
   const lifecycleText = lifecycle.replace(/^lifecycle: /, "");
   const repair = g.repairTarget ? ` · replan required: ${truncate(g.repairTarget.objective.replace(/\s+/g, " "), 100)}` : "";
+  // v0.38.8: parked goals carry their verdict tally — a paused session
+  // with 2 disapprovals reads as "waiting with history", not dead.
+  const tallyText = formatVerdictTallySegment(auditorVerdictTally(g.auditHistory, now), now);
+  const verdict = tallyText ? ` · ${tallyText}` : "";
   if (queueFirst) {
-    return ` · ${queueLabel} · ${lifecycleText.replace(` · ${queueLabel}`, "")} · ${transition}${repair}`;
+    return ` · ${queueLabel} · ${lifecycleText.replace(` · ${queueLabel}`, "")} · ${transition}${repair}${verdict}`;
   }
-  return ` · ${lifecycleText} · ${transition}${repair}`;
+  return ` · ${lifecycleText} · ${transition}${repair}${verdict}`;
 }
 
 /**
@@ -954,7 +1020,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 —
@@ -1357,6 +1428,13 @@ function goalLines(g: Goal, state: State, audit: AuditDisplayProgress | null | u
     : 48;
   const head = `${icon} ${truncate(g.objective.replace(/\s+/g, " "), objBudget)} ${paint(theme, "dim", "·")} ${segsText}`;
   const lines = [head];
+  // v0.38.8: durable verdict tally as a first-class card row — the widget
+  // is the glance surface, and stored verdicts are the progress evidence
+  // when no auditor is live. Silent when history is empty.
+  const headTally = formatVerdictTallySegment(auditorVerdictTally(g.auditHistory, now), now);
+  if (headTally) {
+    lines.push(`├─ ${paint(theme, "dim", `audits: ${truncate(headTally, Math.max(20, (width ?? 80) - 12))}`)}`);
+  }
   if (g.repairTarget) {
     lines.push(`├─ ${paint(theme, "warning", `REPLAN REQUIRED · original target: ${truncate(g.repairTarget.objective.replace(/\s+/g, " "), Math.max(30, (width ?? 80) - 28))}`)}`);
     const repairStep = g.repairTarget.replanPromptedAt

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/extensions/loops/goal-ui.ts

@@ -997,11 +997,16 @@ export function shouldCompactFirstNudge(percent: number | null | undefined): boo
 export function buildStarvationLadderMessage(input: { percent?: number | null; streak?: number } = {}): string {
   const at = typeof input.percent === "number" && Number.isFinite(input.percent)
     ? `${input.percent.toFixed(1)}%` : "nearly full";
-  return `glla: output-token stop was context starvation (tiny output at ${at} context) — yielding to pi auto-compaction instead of re-sending. ` +
-    `If compaction fails or context is already over cap, in order: (1) run /compact again — GLLA already trimmed repeat payloads to a checkpoint, so the retry may now fit; ` +
-    `(2) switch to a larger-context model, then /compact (GLLA auto-rotates its fallback chain after a failed compact-and-retry); ` +
-    `(3) /new, then /goal resume — the goal, tasks, ledger and audits are durable on disk, and the post-compact resync re-anchors the fresh session with no summarization needed. ` +
-    `Automatic turns stay parked until a real compaction lands.`;
+  // v0.38.8: one recovery per line — the single-paragraph version buried
+  // the ladder. Same content, scannable shape.
+  return [
+    `glla: output-token stop was context starvation (tiny output at ${at} context) — yielding to pi auto-compaction instead of re-sending.`,
+    `If compaction fails or context is already over cap, in order:`,
+    `(1) run /compact again — GLLA already trimmed repeat payloads to a checkpoint, so the retry may now fit;`,
+    `(2) switch to a larger-context model, then /compact (GLLA auto-rotates its fallback chain after a failed compact-and-retry);`,
+    `(3) /new, then /goal resume — the goal, tasks, ledger and audits are durable on disk, and the post-compact resync re-anchors the fresh session with no summarization needed.`,
+    `Automatic turns stay parked until a real compaction lands.`,
+  ].join("\n");
 }
 function noteContextStarvedYield(): { streak: number; shouldRefuse: boolean } {
   const now = Date.now();

package/extensions/settings-menu.ts

@@ -58,6 +58,10 @@ export type SettingsSectionId =
   | "stall-brakes"
   | "other";
 
+/** v0.38.8: tab label with its row count — pure so tests pin the shape. */
+export function settingsTabLabel(label: string, rowCount: number): string {
+  return rowCount > 0 ? `${label} (${rowCount})` : label;
+}
 export const SETTINGS_SECTIONS: readonly { id: SettingsSectionId; label: string }[] = [
   { id: "keep-going", label: "Keep-going" },
   { id: "main-agent", label: "Main agent" },
@@ -766,11 +770,15 @@ export class SettingsMenuComponent implements Component {
 
     // v0.28.19: color-only tabs (user call: "dropping the brackets") —
     // active = accent + bold, inactive = dim. No bracket chrome.
+    // v0.38.8: per-tab row counts — the menu holds 7 sections and the
+    // count says where the settings live at a glance.
+    const tabLabel = (s: { id: SettingsSectionId; label: string }): string =>
+      settingsTabLabel(s.label, this.rows.filter((r) => r.section === s.id).length);
     lines.push(
       SETTINGS_SECTIONS.map((s, i) =>
         i === this.activeSectionIdx
-          ? this.theme.fg("accent", this.theme.bold(s.label))
-          : this.theme.fg("dim", s.label),
+          ? this.theme.fg("accent", this.theme.bold(tabLabel(s)))
+          : this.theme.fg("dim", tabLabel(s)),
       ).join("  "),
     );
 

package/package.json

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