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

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # 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
+  Compact-first nudge: at 85% context (below the 90% starvation line) a one-shot-per-episode notify to run `/compact` while summarization still fits (episode resets below 80% or on compaction; ledger `context_compact_first_nudge`). The agent_end starvation yield notify now carries the full over-cap ladder — `/compact` retry after GLLA's deterministic trim, larger-context model (GLLA already auto-rotates its fallback chain after a failed compact-and-retry, v0.34.116), `/new` + `/goal resume` from durable disk state with no summarization needed — and states that automatic turns stay parked.
+
+### Fixed
+  Over-cap spin: `sendContinuation` now refuses while `isContextStarvedRefused()` — the single choke point every automatic path funnels through — so a 119–243% session stops queueing truncating turns (ledger `continuation_send_refused_context_starved`, silent; heartbeat one-shot + yield ladder own messaging). The refuse stays sticky while the last-known percent is ≥90% instead of lapsing 90s after the last yield. Heartbeat refuse branch/ledger/text unchanged (pinned). `tests/starvation-ladder.test.ts` (6 tests) pins band, ladder text, nudge episodes, sticky matrix, wiring, and a behavioral starved boot.
+
 ## 0.38.5 — delta-only goal continuation: marker-only steady-state (2026-09-03)
 
 ### Fixed

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.5 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-continuation.ts

@@ -146,6 +146,7 @@ export interface ContinuationDeps {
   isForeignCtx(ctx: ExtensionContext): boolean;
   sessionManagerId(ctx: ExtensionContext): string;
   isActionableGoal(): boolean;
+  isContextStarvedRefused(): boolean;
   isSupervising(): boolean;
   goalNoun(): string;
   activeGoalSurfaceCommand(command: string): string;
@@ -170,6 +171,7 @@ let goStaleTerminal: ContinuationDeps["goStaleTerminal"];
 let isForeignCtx: ContinuationDeps["isForeignCtx"];
 let sessionManagerId: ContinuationDeps["sessionManagerId"];
 let isActionableGoal: ContinuationDeps["isActionableGoal"];
+let isContextStarvedRefused: ContinuationDeps["isContextStarvedRefused"];
 let isSupervising: ContinuationDeps["isSupervising"];
 let goalNoun: ContinuationDeps["goalNoun"];
 let activeGoalSurfaceCommand: ContinuationDeps["activeGoalSurfaceCommand"];
@@ -194,6 +196,7 @@ export function createGoalContinuation(flagsArg: ContinuationFlags, d: Continuat
   isForeignCtx = d.isForeignCtx;
   sessionManagerId = d.sessionManagerId;
   isActionableGoal = d.isActionableGoal;
+  isContextStarvedRefused = d.isContextStarvedRefused;
   isSupervising = d.isSupervising;
   goalNoun = d.goalNoun;
   activeGoalSurfaceCommand = d.activeGoalSurfaceCommand;
@@ -1140,6 +1143,15 @@ export function sendContinuation(goalId: string): void {
     continuationTimer = scheduleSessionTimeout(() => sendContinuation(goalId), BACKOFF_IDLE_RETRY_MS);
     return;
   }
+  // v0.38.6: the starvation choke point — EVERY automatic send path funnels
+  // through here (agent_end, heartbeat rearm, loop tick, recovery). While
+  // the session is starved with no compaction, no turn can land, so refuse
+  // SILENTLY (ledger only): the heartbeat one-shot + agent_end yield ladder
+  // own user messaging, and a refused send must not rearm a timer spin.
+  if (isContextStarvedRefused()) {
+    appendLedger(ctx.cwd, "continuation_send_refused_context_starved", { goalId, generation: flags.sessionGeneration });
+    return;
+  }
   if (!guardGoalBeforeContinuation(ctx, "dispatch", goalId)) return;
   if (!isActionableGoal()) return;
   if (!ctx.isIdle() || ctx.hasPendingMessages()) {

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
@@ -1980,7 +2008,11 @@ export function registerGoalRuntime(pi: ExtensionAPI): void {
           return;
         }
       }
-      ctx.ui.notify("glla: output-token stop was context starvation (tiny output at a nearly full context) — yielding to pi auto-compaction instead of re-sending.", "info");
+      // v0.38.6: the yield now carries the full over-cap ladder (retry
+      // /compact after GLLA's deterministic trim, larger-context model,
+      // /new + resume from durable state) instead of only the auto-compact
+      // pointer — field 2026-09-03: summarization itself was failing.
+      ctx.ui.notify(buildStarvationLadderMessage({ percent: typeof contextUsage?.percent === "number" ? contextUsage.percent : null, streak: starved.streak }), "info");
       return;
     }
     if (lc.giveUpNow) {
@@ -2187,6 +2219,20 @@ export function registerGoalRuntime(pi: ExtensionAPI): void {
     if (!state.goal) return;
     if (state.goal.status !== "active") return;
     clearContinuationTimer();
+    // v0.38.6: feed the sticky refuse gate + compact-first nudge with the
+    // live percent. Placed AFTER the goal gate: the length-continue order
+    // pin requires the length path first, and starved sessions already
+    // returned via the yield ladder above. Recording null clears a stale
+    // reading (host estimate gone) so the refuse can lapse instead of
+    // sticking forever.
+    noteContextPercent(typeof contextUsage?.percent === "number" ? contextUsage.percent : null);
+    if (shouldCompactFirstNudge(contextUsage?.percent)) {
+      appendLedger(ctx.cwd, "context_compact_first_nudge", {
+        goalId: state.goal?.id ?? null,
+        contextPercent: contextUsage?.percent ?? null,
+      });
+      ctx.ui.notify(`glla: context at ${contextUsage!.percent!.toFixed(1)}% — run /compact now while summarization still fits. Below 90% the compact succeeds; past it you get the over-cap ladder (retry /compact, larger model, or /new + resume).`, "info");
+    }
 
     const last = [...(event.messages as any[])].reverse().find((m) => m.role === "assistant");
     const text = last && Array.isArray(last.content) ? last.content.filter((p: any) => p.type === "text").map((p: any) => p.text).join("\n") : "";

package/extensions/loops/goal-runtime-globals.ts

@@ -150,6 +150,11 @@ export const GOAL_RUNTIME_GLOBAL_NAMES = [
   "contextStarvedStreak",
   "lastContextStarvedAt",
   "noteContextStarvedYield",
+  "noteContextPercent",
+  "shouldCompactFirstNudge",
+  "buildStarvationLadderMessage",
+  "COMPACT_FIRST_NUDGE_PERCENT",
+  "lastContextPercent",
   "clearContextStarvedStreak",
   "onCompactionLanded",
   "isContextStarvedRefused",
@@ -310,6 +315,11 @@ interface GoalRuntimeDataTypes {
   CONTEXT_STARVATION_RECENT_WINDOW_MS: number;
   contextStarvedStreak: number;
   lastContextStarvedAt: number;
+  noteContextPercent: (pct: number | null | undefined) => void;
+  shouldCompactFirstNudge: (percent: number | null | undefined) => boolean;
+  buildStarvationLadderMessage: (input?: { percent?: number | null; streak?: number }) => string;
+  COMPACT_FIRST_NUDGE_PERCENT: number;
+  lastContextPercent: number | null;
   postCompactResumeOwed: boolean;
   postCompactResyncPending: boolean;
   COMPACTION_GRACE_MS: number;
@@ -487,6 +497,11 @@ declare global {
   var contextStarvedStreak: GoalRuntimeGlobals["contextStarvedStreak"];
   var lastContextStarvedAt: GoalRuntimeGlobals["lastContextStarvedAt"];
   var noteContextStarvedYield: GoalRuntimeGlobals["noteContextStarvedYield"];
+  var noteContextPercent: GoalRuntimeGlobals["noteContextPercent"];
+  var shouldCompactFirstNudge: GoalRuntimeGlobals["shouldCompactFirstNudge"];
+  var buildStarvationLadderMessage: GoalRuntimeGlobals["buildStarvationLadderMessage"];
+  var COMPACT_FIRST_NUDGE_PERCENT: GoalRuntimeGlobals["COMPACT_FIRST_NUDGE_PERCENT"];
+  var lastContextPercent: GoalRuntimeGlobals["lastContextPercent"];
   var clearContextStarvedStreak: GoalRuntimeGlobals["clearContextStarvedStreak"];
   var onCompactionLanded: GoalRuntimeGlobals["onCompactionLanded"];
   var isContextStarvedRefused: GoalRuntimeGlobals["isContextStarvedRefused"];

package/extensions/loops/goal-ui.ts

@@ -171,6 +171,7 @@ import {
 } from "../goal-continuation.js";
 export { __testOnlySetContinuationStartTimeout, __testOnlySetContinuationRetryBackoff } from "../goal-continuation.js";
 import {
+  LENGTH_CONTINUE_CONTEXT_STARVED_PERCENT,
   LENGTH_CONTINUE_MAX,
   LENGTH_CONTINUE_TEXT,
   isContextStarvedLengthStop,
@@ -963,8 +964,45 @@ let lastCompactionAt = 0;
 // immediately clears the streak.
 const CONTEXT_STARVATION_REFUSE_THRESHOLD = 2;
 const CONTEXT_STARVATION_RECENT_WINDOW_MS = 90_000;
+// v0.38.6: compact-first band — heavy but still compactable. One proactive
+// nudge per episode here avoids the over-cap ladder entirely (summarization
+// still fits below the 90% starvation line).
+export const COMPACT_FIRST_NUDGE_PERCENT = 85;
+export const COMPACT_FIRST_RESET_PERCENT = 80;
 let contextStarvedStreak = 0;
 let lastContextStarvedAt = 0;
+// v0.38.6: last-known context percent (sampled at agent_end). Keeps the
+// refuse sticky while the session is physically over cap even after the 90s
+// recency window lapses — a slow-truncating 120%+ session must not re-arm
+// the spin (field 2026-09-03: 119–243% truncation loops).
+let lastContextPercent: number | null = null;
+let compactFirstNudged = false;
+export function noteContextPercent(pct: number | null | undefined): void {
+  lastContextPercent = typeof pct === "number" && Number.isFinite(pct) ? pct : null;
+}
+/** v0.38.6: compact-first decision — pure. True exactly once per episode
+ * while percent sits at/above the nudge band; resets below 80% or on
+ * compaction. Returns false for missing/non-finite input. */
+export function shouldCompactFirstNudge(percent: number | null | undefined): boolean {
+  if (typeof percent !== "number" || !Number.isFinite(percent)) return false;
+  if (percent < COMPACT_FIRST_RESET_PERCENT) { compactFirstNudged = false; return false; }
+  if (percent < COMPACT_FIRST_NUDGE_PERCENT || compactFirstNudged) return false;
+  compactFirstNudged = true;
+  return true;
+}
+/** v0.38.6: the over-cap ladder, user-facing. Three recoveries in order
+ * (retry /compact after GLLA's deterministic trim, larger-context model,
+ * /new + resume from durable state) plus the no-LLM backstop: the
+ * post-compact resync re-anchors a fresh session with no summarization. */
+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.`;
+}
 function noteContextStarvedYield(): { streak: number; shouldRefuse: boolean } {
   const now = Date.now();
   if (now - lastContextStarvedAt > CONTEXT_STARVATION_RECENT_WINDOW_MS) {
@@ -981,6 +1019,7 @@ function clearContextStarvedStreak(): void {
 /** Public: a session_compact landed — clear the starvation refuse gate. */
 function onCompactionLanded(): void {
   clearContextStarvedStreak();
+  compactFirstNudged = false; // v0.38.6: fresh episode after real room
 }
 /** Public: has the yield path declared compaction absent? The heartbeat
  * consults this to refuse to schedule a new continuation while the
@@ -988,7 +1027,10 @@ function onCompactionLanded(): void {
 function isContextStarvedRefused(): boolean {
   if (contextStarvedStreak < CONTEXT_STARVATION_REFUSE_THRESHOLD) return false;
   if (lastCompactionAt > lastContextStarvedAt) return false; // a compact happened after the streak — fresh slate
-  return Date.now() - lastContextStarvedAt <= CONTEXT_STARVATION_RECENT_WINDOW_MS;
+  if (Date.now() - lastContextStarvedAt <= CONTEXT_STARVATION_RECENT_WINDOW_MS) return true;
+  // v0.38.6: sticky while physically over cap — recency lapse must not
+  // re-arm the spin against a session that never got room (field: 243%).
+  return lastContextPercent !== null && lastContextPercent >= LENGTH_CONTINUE_CONTEXT_STARVED_PERCENT;
 }
 /** Test-only: simulate a compaction event at a controlled time without firing
  * the full session_compact plumbing. Pass null to clear. */
@@ -1132,6 +1174,11 @@ defineGoalRuntimeGlobal("CONTEXT_STARVATION_RECENT_WINDOW_MS", { get: () => CONT
 defineGoalRuntimeGlobal("contextStarvedStreak", { get: () => contextStarvedStreak, set: (v) => { contextStarvedStreak = v as any; } });
 defineGoalRuntimeGlobal("lastContextStarvedAt", { get: () => lastContextStarvedAt, set: (v) => { lastContextStarvedAt = v as any; } });
 defineGoalRuntimeGlobal("noteContextStarvedYield", { get: () => noteContextStarvedYield });
+defineGoalRuntimeGlobal("noteContextPercent", { get: () => noteContextPercent });
+defineGoalRuntimeGlobal("shouldCompactFirstNudge", { get: () => shouldCompactFirstNudge });
+defineGoalRuntimeGlobal("buildStarvationLadderMessage", { get: () => buildStarvationLadderMessage });
+defineGoalRuntimeGlobal("COMPACT_FIRST_NUDGE_PERCENT", { get: () => COMPACT_FIRST_NUDGE_PERCENT });
+defineGoalRuntimeGlobal("lastContextPercent", { get: () => lastContextPercent, set: (v) => { lastContextPercent = v as any; } });
 defineGoalRuntimeGlobal("clearContextStarvedStreak", { get: () => clearContextStarvedStreak });
 defineGoalRuntimeGlobal("onCompactionLanded", { get: () => onCompactionLanded });
 defineGoalRuntimeGlobal("isContextStarvedRefused", { get: () => isContextStarvedRefused });

package/extensions/loops/goal.ts

@@ -288,6 +288,7 @@ const continuationDeps: ContinuationDeps = {
   isForeignCtx,
   sessionManagerId,
   isActionableGoal,
+  isContextStarvedRefused,
   isSupervising,
   goalNoun,
   activeGoalSurfaceCommand,

package/package.json

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