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

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 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
+  Ongoing-conversation resend: steady-state goal turns now send the 45-char `[GOAL CHECKPOINT goalId=…]` marker only instead of the full ~23k continuation prompt every turn (history already holds T0 objective/contract/tasks + `complete_task` deltas). Post-compact sends `resync + marker` (~250 chars); full sends only on first-send per process or dynamic deltas (`repairTarget` / `autoResumedAt` / auditor TODOs / audit report / stale-approval mismatch / designer / full-audit). Marker still carries the dispatch marker so `before_agent_start` start-proof keeps matching; `agent_start`/`turn_start` fallback needs no prompt. Ledger `goal_continuation_sent` gains `kind` (`full`/`full+resync`/`resync`/`marker`) + `payloadChars`. Loop turns unchanged (per-iteration prompts vary). `extensions/goal-continuation.ts` (`buildMarkerContent` / `needsFullContinuation` / `buildContinuationContent`); `tests/delta-only-continuation.test.ts` pins the matrix.
+
 ## 0.38.4 — human-input zombie stand-down (PR #36 slice) + AVO close (2026-09-02)
 
 ### 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.4 continue through the supervisor freeze (`/glla pause`),
+  v0.35.14–v0.38.6 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-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;
@@ -1054,6 +1057,52 @@ export function scheduleContinuation(ctx: ExtensionContext, force = false, delay
   continuationTimer = scheduleSessionTimeout(() => sendContinuation(goalId), delay);
 }
 
+export function buildMarkerContent(goalId: string): string {
+  return `[GOAL CHECKPOINT goalId=${goalId}]`;
+}
+
+/** v0.38.5 (delta-only): steady-state live turns need only the wake-up marker —
+ * history already holds T0 objective/contract/tasks + complete_task deltas.
+ * Full is required only for dynamic deltas the model has not seen: repair,
+ * recovery, auditor TODOs/report, stale-approval mismatch, plus the rare
+ * designer / full-audit paths (preserved verbatim in v1). Stable guidance
+ * (vision, discipline) stays clean — it was in the first full send.
+ */
+export function needsFullContinuation(goal: Goal): boolean {
+  if (goal.repairTarget) return true;
+  if (goal.autoResumedAt) return true;
+  if (!auditorSurfaceSuppressed() && goal.pendingTasks && goal.pendingTasks.length > 0) return true;
+  const lastAudit = goal.auditHistory?.[goal.auditHistory.length - 1];
+  if (lastAudit && lastAudit.report && !auditorSurfaceSuppressed()) return true;
+  if (
+    !auditorSurfaceSuppressed() &&
+    goal.status === "active" &&
+    !goal.pendingCompletion &&
+    lastAudit?.approved &&
+    !lastAudit.impossible &&
+    lastAudit.regressionShieldPassed !== false &&
+    typeof lastAudit.revision === "number" &&
+    lastAudit.revision !== (goal.revision ?? 0)
+  ) return true;
+  const next = findNextPendingTask(goal.taskList?.tasks ?? []);
+  if (goal.agentRole === "designer" || next?.agentRole === "designer") return true;
+  try {
+    const settingsCwd = freshCtx?.()?.cwd ?? process.cwd();
+    const eff = resolveEffectiveAggressiveSettings(loadSettings(settingsCwd));
+    if (eff.aggressiveMode && isFullAuditObjective(goal.objective)) return true;
+  } catch { /* settings read failure must not force full */ }
+  return false;
+}
+
+export function buildContinuationContent(goal: Goal, opts: { resync?: string; firstSend?: boolean } = {}): { content: string; kind: string } {
+  const resync = opts.resync ?? "";
+  const marker = buildMarkerContent(goal.id);
+  const needsFull = (opts.firstSend ?? false) || needsFullContinuation(goal);
+  if (needsFull) return { content: resync + continuationPrompt(goal), kind: resync ? "full+resync" : "full" };
+  if (resync) return { content: resync + marker, kind: "resync" };
+  return { content: marker, kind: "marker" };
+}
+
 export function sendContinuation(goalId: string): void {
   // v0.35.15: `/glla pause` — a continuation timer armed BEFORE the pause
   // must not fire into the frozen window. scheduleContinuation already
@@ -1094,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()) {
@@ -1118,15 +1176,24 @@ export function sendContinuation(goalId: string): void {
       resync: Boolean(resync),
     });
     if (!attempt) return;
+    // v0.38.5 (delta-only, ongoing conversation): clean live turns send the
+    // 45-char marker only — history already holds objective/contract/tasks.
+    // Resync (post-compact) sends resync+marker (~250 chars). Full 23k sends
+    // only on first-send per process or dynamic deltas (repair/recovery/
+    // audit). Marker still carries the dispatch marker so before_agent_start
+    // start-proof matching keeps working; fallback agent_start/turn_start
+    // needs no prompt at all.
+    const goalForSend = state.goal!;
+    const { content, kind } = buildContinuationContent(goalForSend, { resync, firstSend: lastContinuationSentAt === 0 });
     flags.extensionApi.sendMessage({
       customType: GOAL_EVENT_ENTRY,
-      content: resync + continuationPrompt(state.goal!),
+      content,
       display: false,
     }, { triggerTurn: true, deliverAs: "followUp" });
-    lastContinuationSentPayload = { content: resync + continuationPrompt(state.goal!), display: false }; // v0.34.88: verbatim retry payload
+    lastContinuationSentPayload = { content, display: false }; // v0.34.88: verbatim retry payload
     if (!dispatchAccepted(ctx, attempt)) return;
     continuationRearmStreak = 0; continuationRearmSince = 0; // v0.28.5 (E3): an accepted dispatch clears the storm
-    appendLedger(ctx.cwd, "goal_continuation_sent", { goalId, attemptId: attempt.id, generation: attempt.generation });
+    appendLedger(ctx.cwd, "goal_continuation_sent", { goalId, attemptId: attempt.id, generation: attempt.generation, kind, payloadChars: content.length });
     // v0.35.37 (audit finding): the welcome-back recovery notice must fire
     // EXACTLY ONCE per auto-resume. The payload above was built with the
     // notice in it; once the dispatch is ACCEPTED the message has landed in

package/extensions/loops/goal-activation.ts

@@ -1980,7 +1980,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 +2191,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.4",
+  "version": "0.38.6",
   "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",