pi-goal-list-loop-audit 0.28.15 → 0.28.17

package/extensions/goal-loop-display.ts

@@ -12,7 +12,17 @@
 
 import type { Goal, State } from "./goal-loop-core.js";
 import { isPersistenceDegraded, lastPersistenceFailure } from "./goal-loop-core.js";
-import type { LoopState } from "./goal-loop-forever.js";
+import { HELD_ON_RESTORE, type LoopState } from "./goal-loop-forever.js";
+
+/** v0.28.17: a loop parked by the session-restore gate (was active when the
+ * last session ended). Held loops must stay VISIBLE — before, only
+ * state.loop?.active rendered anything and a reload made the loop vanish
+ * from the always-on UI (user report 2026-07-29: "loops are the most
+ * immature"). Stopped loops (any other stopReason) stay invisible. */
+function heldLoop(state: State): LoopState | undefined {
+  const l = state.loop;
+  return l && !l.active && l.stopReason === HELD_ON_RESTORE ? l : undefined;
+}
 
 // ---- formatters ----
 
@@ -128,20 +138,26 @@ export function buildStatusText(state: State, audit?: AuditDisplayProgress | nul
     return `glla: loop ${arrow} iter ${l.iteration}/${l.maxIterations > 0 ? l.maxIterations : "∞"} · best ${l.bestValue ?? "n/a"} · ${stall}${stallSuffix}`;
   }
   const g = state.goal;
-  if (!g) return undefined;
+  const held = heldLoop(state);
+  // v0.28.17: a held loop rides every goal state as a compact suffix.
+  const heldSuffix = held ? paint(theme, "warning", " · loop⏸held") : "";
+  if (!g) {
+    if (held) return `glla: loop ${paint(theme, "warning", "⏸ held")} · iter ${held.iteration} — /loop to resume`;
+    return undefined;
+  }
   if (g.status === "auditing") {
     const tool = audit?.currentTool ? ` · ${audit.currentTool}` : "";
-    return `glla: ${paint(theme, "accent", "auditing…")}${tool}`;
+    return `glla: ${paint(theme, "accent", "auditing…")}${tool}${heldSuffix}`;
   }
   if (g.status === "paused") {
     const label = `${g.policy} paused ⏸ ${truncate(g.pauseReason ?? "", 40)}`;
-    return `glla: ${paint(theme, pauseIsError(g) ? "error" : "warning", label)}`;
+    return `glla: ${paint(theme, pauseIsError(g) ? "error" : "warning", label)}${heldSuffix}`;
   }
   if (g.status === "active") {
     // v0.28.1 (S1/S2): a stale-handle interrupt keeps the goal ACTIVE (the
     // next fresh session auto-resumes it) — say so instead of looking healthy.
     if (g.interruptedAt) {
-      return `glla: ${g.policy} ${paint(theme, "error", "⚠ interrupted — stale handle · auto-resumes on pi restart")}`;
+      return `glla: ${g.policy} ${paint(theme, "error", "⚠ interrupted — stale handle · auto-resumes on pi restart")}${heldSuffix}`;
     }
     // v0.24.7: list policy gets its own wording — a queue item is not a goal.
     // v0.28.11 (U10): goal policy joins it — "list 29" read as a command
@@ -150,9 +166,11 @@ export function buildStatusText(state: State, audit?: AuditDisplayProgress | nul
     const n = state.list?.length ?? 0;
     const queue = n === 0 ? "" : ` · ${n} queued`;
     const tasks = g.taskList ? ` ${countDone(g)}/${countTotal(g)} tasks ·` : "";
-    return `glla: ${g.policy} ${paint(theme, "success", "●")}${tasks} ${fmtElapsed(now - Date.parse(g.createdAt))}${queue}`;
+    return `glla: ${g.policy} ${paint(theme, "success", "●")}${tasks} ${fmtElapsed(now - Date.parse(g.createdAt))}${queue}${heldSuffix}`;
   }
-  return undefined; // complete/aborted → clear
+  // complete/aborted → clear — but a held loop still shows.
+  if (held) return `glla: loop ${paint(theme, "warning", "⏸ held")} · iter ${held.iteration} — /loop to resume`;
+  return undefined;
 }
 
 function countDone(g: Goal): number {
@@ -199,9 +217,27 @@ export function buildWidgetLines(state: State, audit?: AuditDisplayProgress | nu
 function buildWidgetLinesInner(state: State, audit?: AuditDisplayProgress | null, now = Date.now(), theme?: DisplayTheme, width?: number, extras?: { stalls?: number }): string[] | undefined {
   if (state.loop?.active) return loopLines(state.loop, now, theme, width, extras);
   const g = state.goal;
-  if (!g) return undefined;
-  if (g.status === "complete" || g.status === "aborted") return undefined;
-  return goalLines(g, state, audit, now, theme, width);
+  const held = heldLoop(state);
+  if (!g || g.status === "complete" || g.status === "aborted") {
+    // v0.28.17: no visible goal — the held loop gets its own card.
+    return held ? heldLoopLines(held, now, theme, width) : undefined;
+  }
+  const lines = goalLines(g, state, audit, now, theme, width);
+  // v0.28.17: a held loop rides the goal card as a trailing line.
+  if (held) {
+    lines.push(`${paint(theme, "warning", "⏸")} ${truncate(held.target, budgetFor(width, 3, 64))}`);
+    lines.push(`└─ ${paint(theme, "dim", `loop held · iter ${held.iteration} — /loop to resume`)}`);
+  }
+  return lines;
+}
+
+/** v0.28.17: standalone card for a restore-held loop (no goal visible). */
+function heldLoopLines(l: LoopState, now: number, theme?: DisplayTheme, width?: number): string[] {
+  return [
+    `${paint(theme, "warning", "⏸")} ${truncate(l.target, budgetFor(width, 3, 64))}`,
+    `├─ loop held · iter ${l.iteration} · ${fmtElapsed(now - Date.parse(l.startedAt))} so far`,
+    `└─ ${paint(theme, "dim", "held by the session-restore gate — /loop to resume, /loop stop to drop")}`,
+  ];
 }
 
 // Branch lines sit flush-left (pi-tasks convention): pi's widget renderer

package/extensions/goal-loop-forever.ts

@@ -31,6 +31,13 @@ export interface LoopRefinement {
   newMeasureCmd: string;
 }
 
+/** v0.28.17: stopReason marking a loop parked by the session-restore gate
+ * (it was active when the last session ended; the fresh session holds it
+ * until the user resumes with /loop). Exported so the display layer can
+ * recognize held loops — they must stay VISIBLE in the status/widget,
+ * unlike stopped loops which are genuinely gone. */
+export const HELD_ON_RESTORE = "held: restored in a fresh session";
+
 export interface LoopState {
   target: string;
   /** v0.23.0: optional — a metricless "spec loop" (measure=none) has no

package/extensions/loops/goal.ts

@@ -161,6 +161,7 @@ import {
   LOOP_DEFAULTS,
   resolveSpecFiles,
   respecTarget,
+  HELD_ON_RESTORE,
   type LoopState,
 } from "../goal-loop-forever.js";
 import {
@@ -184,8 +185,8 @@ import {
 // =================================================================
 
 const GOAL_EVENT_ENTRY = "goal-event";
-/** stopReason marker for a loop held (not stopped) by the fresh-session restore gate. */
-const HELD_ON_RESTORE = "held: restored in a fresh session";
+// HELD_ON_RESTORE (stopReason marker for a restore-held loop) lives in
+// goal-loop-forever.js since v0.28.17 — the display layer imports it too.
 
 // =================================================================
 // Module-level state (one per session)

package/extensions/reviewer.ts

@@ -213,12 +213,22 @@ export interface ReviewerOutcome {
   reportPath?: string;
   enqueued: number;
   proposed: number;
-  /** v0.27.5: the cascade step that actually fired (notify-and-idle | convert-findings-to-list | queue-leftovers | fire-audit-on-clean | propose-goal | aggressive-relaunch | report-only) — surfaces in /goal status and tests. */
+  /** v0.27.5: the cascade step that actually fired (notify-and-idle | convert-findings-to-list | queue-leftovers | fire-audit-on-clean | propose-goal | aggressive-relaunch | duplicate-suppressed) — surfaces in /goal status and tests. v0.28.16: "duplicate-suppressed" = the clean completion WAS a regression scan, so the follow-up scan was deduped. */
   cascadeStep?: string;
 }
 
 export const REVIEWER_REFIRE_WINDOW_MS = 5 * 60_000;
 
+/** v0.28.16: normalize an objective for duplicate-compare — lowercase,
+ * goal-ids (yyyyMMddHHmmss-xxxxxx) become <id>, whitespace collapses. */
+export function normalizeObjective(s: string): string {
+  return s
+    .toLowerCase()
+    .replace(/\b\d{14}-[a-z0-9]{6}\b/g, "<id>")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
 /** The reviewer lifecycle (contract item 1). */
 export function runReviewer(
   config: ReviewerConfig,
@@ -310,7 +320,16 @@ export function runReviewer(
   // aggressive mode → relaunch the audit goal directly (no Confirm).
   if (findings.length === 0 && config.cascade.includes("fire-audit-on-clean")) {
     const auditObjective = `Post-completion regression scan after ${source.goalId} (${config.auditScope})`;
-    if (aggressive) {
+    // v0.28.16: duplicate-scan dedupe — the reviewer fires ON completion,
+    // so source.objective IS the most recent completion. If the goal that
+    // just completed was itself this same scan (normalized: goal-ids
+    // stripped), the proposal would be a scan-of-a-scan — the cascade loop
+    // that fired twice on 2026-07-28. Suppress the proposal/enqueue (the
+    // report is still written; the ledger records the reason).
+    if (normalizeObjective(source.objective) === normalizeObjective(auditObjective)) {
+      deps.ledger("reviewer_suppressed", { reason: "duplicate-scan", goalId: source.goalId, objective: auditObjective });
+      cascadeStep = "duplicate-suppressed";
+    } else if (aggressive) {
       if (deps.proposeGoal(auditObjective, "aggressive postaudit: clean completion — relaunching the regression scan as /goal")) {
         proposed++;
       }

package/package.json

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