pi-goal-list-loop-audit 0.38.67 → 0.38.68

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # Changelog
 
+## 0.38.68 — Relentless auto-continue: heat-routed exhaustion, quota retries, truthful recovering (2026-09-19)
+
+### Length-exhaustion wedge fixed at the root: heat, not budget (field 162348)
+
+Repeated output-token truncation at near-full context is a heat problem —
+the prompt no longer fits the model — so growing the truncation budget
+only ping-pongs into the same wall. `decideLengthExhaustion` now routes on
+`contextPercent`: roomy context restarts the truncation budget relentlessly
+(episode 1 of a bounded 2-episode budget, episode 2 parks durably),
+near-full context with a larger-context fallback rotates models, and
+near-full context without one yields to pi auto-compaction and lets the
+settle path own the resume. The compact-defer path no longer kicks a fresh
+turn into the known-hot window, and a manual `/goal resume` between
+episodes restarts the cycle instead of parking one round early.
+
+### Quota-identical auditor failures hammer bounded retries (field 150821)
+
+Rate-limit and plan-quota walls are transient, so they are exempt from the
+identical-failure park: the auditor keeps hammering its bounded retry plan
+instead of parking with "check the auditor/model setup". Billing walls
+and non-quota infra failures still park truthfully. A resumed or recovered
+cycle reseeds the dead candidate chain via `freshAuditorCycleClaim`
+instead of re-walking it, and no longer renders the previous cycle's dead
+chain or diagnostic one round late.
+
+### Armed retry renders recovering, not dead-paused (field 151113)
+
+A supervised auditor wait with an armed retry now renders `recovering`
+with an auto-retrying status line. Bare user waits with no pending claim
+still render `paused` — no false recovering labels.
+
+### glla-delegate skill states its drafting precondition (field 125302)
+
+The skill doc now says `propose_goal_draft` only runs inside an already-open
+drafting session (bare `/goal`, `/list`, or `/list add`), refuses from
+normal chat, and falls back to `list_add` — the refusal is correct
+behavior, so this is a doc fix with a regression pin, no prod change.
+
 ## 0.38.67 — Stop clobbering other extensions' compactions (2026-09-19)
 
 ### session_before_compact returns nothing (issue #56, ezoushen)

package/docs/INDEX.md

@@ -16,7 +16,7 @@ Policy contracts and recent changes live in the `audit/` directory of the
   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.67 continue through the supervisor freeze (`/glla pause`),
+  v0.35.14–v0.38.68 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

@@ -113,7 +113,7 @@ export interface CommandDeps {
   releaseContinuationDispatchStandDown: () => void;
   releaseInitialSessionLoadBarrier: () => void;
   resolveCarryover: (ctx: ExtensionContext, trigger: "goal" | "loop" | "list") => boolean;
-  safeSteerUser: (ctx: ExtensionContext, text: string) => boolean;
+  resetLengthExhaustionEpisodes: () => void;  safeSteerUser: (ctx: ExtensionContext, text: string) => boolean;
   scheduleContinuation: (ctx: ExtensionContext, force?: boolean, delayMs?: number) => void;
   scheduleSessionTimeout: (callback: () => void, delayMs: number) => NodeJS.Timeout;
   createGoal: (objective: string, ctx: ExtensionContext, policy?: "goal" | "list") => Goal;
@@ -138,7 +138,7 @@ let listQueue: CommandDeps["listQueue"], notifyExternal: CommandDeps["notifyExte
     archiveCurrentGoal: CommandDeps["archiveCurrentGoal"], healGoalPolicy: CommandDeps["healGoalPolicy"], startDrafting: CommandDeps["startDrafting"], warnIfStaleAtEntry: CommandDeps["warnIfStaleAtEntry"], queuePendingListOperation: CommandDeps["queuePendingListOperation"], freshCtx: CommandDeps["freshCtx"],
     freshCtxForGeneration: CommandDeps["freshCtxForGeneration"], goStaleTerminal: CommandDeps["goStaleTerminal"], groupOpenChildren: CommandDeps["groupOpenChildren"], activateNextListItem: CommandDeps["activateNextListItem"], clearMainModelRecoveryTimer: CommandDeps["clearMainModelRecoveryTimer"], mainModelRecoveryTimerActive: CommandDeps["mainModelRecoveryTimerActive"], continuationDispatchPending: CommandDeps["continuationDispatchPending"], resetContinuationDispatchState: CommandDeps["resetContinuationDispatchState"],
     isCompletionAuditRecoveryPending: CommandDeps["isCompletionAuditRecoveryPending"], markCompletionAuditRecoveryPending: CommandDeps["markCompletionAuditRecoveryPending"], retryStoredCompletionAudit: CommandDeps["retryStoredCompletionAudit"], probeMainModelRecovery: CommandDeps["probeMainModelRecovery"], releaseContinuationDispatchStandDown: CommandDeps["releaseContinuationDispatchStandDown"],
-    releaseInitialSessionLoadBarrier: CommandDeps["releaseInitialSessionLoadBarrier"], resolveCarryover: CommandDeps["resolveCarryover"], safeSteerUser: CommandDeps["safeSteerUser"], scheduleContinuation: CommandDeps["scheduleContinuation"], scheduleSessionTimeout: CommandDeps["scheduleSessionTimeout"],
+    releaseInitialSessionLoadBarrier: CommandDeps["releaseInitialSessionLoadBarrier"], resolveCarryover: CommandDeps["resolveCarryover"], resetLengthExhaustionEpisodes: CommandDeps["resetLengthExhaustionEpisodes"], safeSteerUser: CommandDeps["safeSteerUser"], scheduleContinuation: CommandDeps["scheduleContinuation"], scheduleSessionTimeout: CommandDeps["scheduleSessionTimeout"],
     createGoal: CommandDeps["createGoal"], fireReviewer: CommandDeps["fireReviewer"], openSettingsUI: CommandDeps["openSettingsUI"], manuallyResumeMainModelRecovery: CommandDeps["manuallyResumeMainModelRecovery"], activeGoalCommand: CommandDeps["activeGoalCommand"],
     activeGoalStatusCommand: CommandDeps["activeGoalStatusCommand"], activeGoalSurfaceCommand: CommandDeps["activeGoalSurfaceCommand"], goalNoun: CommandDeps["goalNoun"], displaySlice: CommandDeps["displaySlice"], shortObj: CommandDeps["shortObj"];
 
@@ -148,7 +148,7 @@ export function createGoalCommands(d: CommandDeps): void {
   archiveCurrentGoal = d.archiveCurrentGoal; healGoalPolicy = d.healGoalPolicy; startDrafting = d.startDrafting; warnIfStaleAtEntry = d.warnIfStaleAtEntry; queuePendingListOperation = d.queuePendingListOperation; freshCtx = d.freshCtx;
   freshCtxForGeneration = d.freshCtxForGeneration; goStaleTerminal = d.goStaleTerminal; groupOpenChildren = d.groupOpenChildren; activateNextListItem = d.activateNextListItem; clearMainModelRecoveryTimer = d.clearMainModelRecoveryTimer; mainModelRecoveryTimerActive = d.mainModelRecoveryTimerActive; continuationDispatchPending = d.continuationDispatchPending; resetContinuationDispatchState = d.resetContinuationDispatchState;
   isCompletionAuditRecoveryPending = d.isCompletionAuditRecoveryPending; markCompletionAuditRecoveryPending = d.markCompletionAuditRecoveryPending; retryStoredCompletionAudit = d.retryStoredCompletionAudit; probeMainModelRecovery = d.probeMainModelRecovery; releaseContinuationDispatchStandDown = d.releaseContinuationDispatchStandDown;
-  releaseInitialSessionLoadBarrier = d.releaseInitialSessionLoadBarrier; resolveCarryover = d.resolveCarryover; safeSteerUser = d.safeSteerUser; scheduleContinuation = d.scheduleContinuation; scheduleSessionTimeout = d.scheduleSessionTimeout;
+  releaseInitialSessionLoadBarrier = d.releaseInitialSessionLoadBarrier; resolveCarryover = d.resolveCarryover; resetLengthExhaustionEpisodes = d.resetLengthExhaustionEpisodes; safeSteerUser = d.safeSteerUser; scheduleContinuation = d.scheduleContinuation; scheduleSessionTimeout = d.scheduleSessionTimeout;
   createGoal = d.createGoal; fireReviewer = d.fireReviewer; openSettingsUI = d.openSettingsUI; manuallyResumeMainModelRecovery = d.manuallyResumeMainModelRecovery; activeGoalCommand = d.activeGoalCommand;
   activeGoalStatusCommand = d.activeGoalStatusCommand; activeGoalSurfaceCommand = d.activeGoalSurfaceCommand; goalNoun = d.goalNoun; displaySlice = d.displaySlice; shortObj = d.shortObj;
   agentsSnapshot = d.agentsSnapshot;
@@ -589,6 +589,10 @@ async function cmdResume(ctx: ExtensionContext): Promise<void> {
   updateGoal({ status: "active", pauseReason: undefined, pauseSuggestedAction: undefined, pauseKind: undefined, pauseOptions: undefined, pauseRecommended: undefined, pauseResumeAt: undefined, interruptedAt: undefined, interruptedReason: undefined, autoResumedAt: undefined, autoResumedEvent: undefined, ...(staleEntry ? { interruptedAt: nowIso(), interruptedReason: "resumed in a stale session" } : {}), ...(usage ? { usage } : {}) }, ctx);
   if (staleEntry) return;
   releaseAuditorSurface();
+  // A manual resume starts a fresh relentless cycle: a user pause between
+  // an episode-1 exhaustion wedge and the next one must not make that
+  // wedge park one cycle early.
+  resetLengthExhaustionEpisodes();
   // A stored completion claim is a direct-audit resume, not an agent turn.
   // Keeping the claim while merely scheduling a continuation left manual
   // pause/resume with an ACTIVE goal that no timer would ever consume.

package/extensions/goal-loop-core.ts

@@ -11,7 +11,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { createHash } from "node:crypto";
 import { execSync } from "node:child_process";
-import { normalizeProviderErrorText, providerErrorFingerprint, providerErrorPresentation, sanitizeProviderAuditReport, sanitizeProviderDisplayText, type QuotaSignal } from "./quota-retry.js";
+import { normalizeProviderErrorText, providerErrorFingerprint, providerErrorPresentation, quotaSignal, sanitizeProviderAuditReport, sanitizeProviderDisplayText, type QuotaSignal } from "./quota-retry.js";
 import { MAX_AUDITOR_CANDIDATE_REFS, MAX_MAIN_MODEL_FALLBACKS, normalizeBoundedModelRefs } from "./main-model-recovery.js";
 import { resolveGllaStateDir, stateRootPending } from "./glla-state-root.js";
 export { normalizeProviderErrorText, providerErrorFingerprint, providerErrorPresentation, sanitizeProviderAuditReport, sanitizeProviderDisplayText } from "./quota-retry.js";
@@ -4076,6 +4076,51 @@ export function trackAuditorIdenticalFailure(
   };
 }
 
+/** v0.38.68 (relentless goal, field 150821): quota walls are transient —
+the fix is hammering bounded retries, not parking with "check the
+auditor/model setup". Rate-limit and plan-quota fingerprints are exempt
+from the identical park; the retry-plan horizon keeps governing them.
+Billing is NOT exempt (retries cannot fix a paywall) and unknown/non-quota
+failures keep the park. Pure. */
+export function isQuotaIdenticalParkExempt(diagnostic: string | undefined): boolean {
+  const signal = quotaSignal(diagnostic);
+  return signal === "rate-limit" || signal === "plan-quota";
+}
+
+/** v0.38.68 (relentless goal, field 150821): reseed a dead auditor chain
+instead of re-walking it. The 3 -> 4 count bump came from a recovery path
+re-firing an identical-parked claim with the burned cursor intact. Clearing
+the candidate chain, the failure streak, and the retry window restarts a
+fresh bounded window with re-resolved models. Pure — callers spread the
+result over the stored claim. */
+const FRESH_AUDITOR_CYCLE_CLEARED_KEYS = [
+  "auditorCandidateRefs",
+  "auditorCandidateRef",
+  "auditorRetryCandidateRef",
+  "auditorRetryAttemptStartedAt",
+  "auditorAttemptedRefs",
+  "auditorEvictedRefs",
+  "auditorLastFailureFingerprint",
+  "auditorConsecutiveIdenticalFailures",
+  "auditorFailureCount",
+  "auditorFailureClass",
+  "auditorFallbackExhausted",
+  "auditorFailureAt",
+  "retryAttempts",
+  "retryFirstAt",
+  "retryUntil",
+  // v0.38.68 reviewer P2: a fresh cycle must not render the previous
+  // cycle's dead chain or wall text one round late.
+  "exhaustedChain",
+  "providerErrorDiagnostic",
+] as const;
+
+export function freshAuditorCycleClaim<T extends object>(claim: T): T {
+  const reseeded: Record<string, unknown> = {};
+  Object.assign(reseeded, claim);
+  for (const key of FRESH_AUDITOR_CYCLE_CLEARED_KEYS) delete reseeded[key];
+  return reseeded as T;
+}
 /** v0.38.63: append a dead ref to the eviction list when the error proves it
  * unresolvable; otherwise return the list untouched (absent stays absent).
  * Bounded to MAX_AUDITOR_CANDIDATE_REFS like every other cursor ref list. */

package/extensions/goal-loop-display.ts

@@ -1826,7 +1826,21 @@ function goalLines(g: Goal, state: State, audit: AuditDisplayProgress | null | u
   // 090343 "working while displaying paused here"; the rearm storm streak
   // 19 was firing while the head chip said ⏸ paused). The status line already
   // renders ⏳ auto-retrying for these; the widget head must not contradict it.
-  const recovering = g.status === "paused" && !!state.mainModelRecovery && (!!state.mainModelRecovery.retryAt || !!state.mainModelRecovery.pendingModelSwitch);
+  // v0.38.68 (relentless, field 151113): a supervised auditor wait with an
+  // ARMED retry (retry-waiting claim + a finite retry time) is recovering
+  // too — the card read "paused" while the glla recovery timer was
+  // actively auto-retrying. A bare user wait with no retry evidence stays
+  // paused (absent stays absent).
+  const pendingRetryAt = g.pendingCompletion?.phase === "retry-waiting" && typeof g.pendingCompletion.recoveryRetryAt === "string"
+    ? Date.parse(g.pendingCompletion.recoveryRetryAt)
+    : Number.NaN;
+  const waitResumeAt = typeof g.pauseResumeAt === "string" ? Date.parse(g.pauseResumeAt) : Number.NaN;
+  const auditorRecovering = g.status === "paused"
+    && pauseKind(g) === "wait"
+    && !!g.pendingCompletion
+    && (Number.isFinite(pendingRetryAt) || Number.isFinite(waitResumeAt));
+  const recovering = (g.status === "paused" && !!state.mainModelRecovery && (!!state.mainModelRecovery.retryAt || !!state.mainModelRecovery.pendingModelSwitch))
+    || auditorRecovering;
   const icon =
     interrupted
       ? paint(theme, "error", "⚠")

package/extensions/length-continue.ts

@@ -123,6 +123,43 @@ export function isContextStarvedLengthStop(
   return false;
 }
 
+export type LengthExhaustionDecision = "rotate-fallback" | "compact-defer" | "fresh-budget";
+
+/** v0.38.68 (relentless goal, field 162348): answer "compact hiccup or
+over-context" by routing on context heat. Hot context (at or above the
+starvation boundary) means the prompt no longer fits the model — a blind
+fresh truncation budget would burn quota re-emitting a giant artifact into
+a full window, so rotate to a larger-context fallback when one exists and
+otherwise defer to pi auto-compaction. Roomy or unknown context means the
+model simply will not chunk: grant one fresh budget (fresh eyes, split
+instructions) and only park for manual action when that budget exhausts
+too. Pure — the agent_end site owns episodes, notify, and rotation. */
+export function decideLengthExhaustion(args: {
+  contextPercent?: number | null;
+  fallbackRefsAvailable: boolean;
+}): LengthExhaustionDecision {
+  const percent = typeof args.contextPercent === "number" ? args.contextPercent : null;
+  const hot = percent !== null && Number.isFinite(percent) && percent >= LENGTH_CONTINUE_CONTEXT_STARVED_PERCENT;
+  if (hot) return args.fallbackRefsAvailable ? "rotate-fallback" : "compact-defer";
+  return "fresh-budget";
+}
+
+export const LENGTH_EXHAUSTION_MAX_EPISODES = 2;
+
+/** v0.38.68 (relentless goal): bounded exhaustion episodes. The first
+truncation-budget exhaustion stays relentless (rotate / compact-defer /
+fresh-budget per decideLengthExhaustion); when THAT budget exhausts too,
+park for manual action instead of burning quota forever. Pure — the
+agent_end site holds the counter and resets it on clean turns,
+session_start, and manual parks. */
+export function nextLengthExhaustionEpisode(priorEpisodes: number): { episodes: number; parkNow: boolean } {
+  const base = typeof priorEpisodes === "number" && Number.isFinite(priorEpisodes) && priorEpisodes > 0
+    ? Math.trunc(priorEpisodes)
+    : 0;
+  const episodes = base + 1;
+  return { episodes, parkNow: episodes >= LENGTH_EXHAUSTION_MAX_EPISODES };
+}
+
 export function makeLengthContinueTracker(max: number = LENGTH_CONTINUE_MAX) {
   let consecutive = 0;
   let gaveUp = false;

package/extensions/loops/goal-activation.ts

@@ -182,9 +182,13 @@ export { __testOnlySetContinuationStartTimeout, __testOnlySetContinuationRetryBa
 import {
   LENGTH_CONTINUE_MAX,
   LENGTH_CONTINUE_TEXT,
+  LENGTH_EXHAUSTION_MAX_EPISODES,
+  decideLengthExhaustion,
   isContextStarvedLengthStop,
+  nextLengthExhaustionEpisode,
   resetLengthContinue,
   tickLengthContinue,
+  type LengthExhaustionDecision,
 } from "../length-continue.js";
 import { isSubagentProviderFailure } from "../quota-retry.js";
 import { captureProviderTokenUsage } from "../context-growth.js";
@@ -480,6 +484,24 @@ let inBandProviderFailureRaw: string | null = null;
 function clearInBandProviderFailure(): void {
   inBandProviderFailureRaw = null;
 }
+// v0.38.68 (relentless): bounded length-exhaustion episodes. Episode 1
+// stays relentless per context heat (rotate / compact-defer / fresh
+// budget); episode 2 parks for manual action. Reset on clean turns,
+// session_start, and manual parks — never on starved stops (the wedge
+// persists) so a hot context cannot lap the budget forever.
+let lengthExhaustionEpisodes = 0;
+/** A manual resume starts a fresh relentless cycle: a user pause between
+an episode-1 wedge and the next one must not make that wedge park one
+cycle early. */
+export function resetLengthExhaustionEpisodes(): void {
+  lengthExhaustionEpisodes = 0;
+}
+/** Test-only: reset the exhaustion-episode counter without firing turns.
+Module state would otherwise leak across behavioral tests sharing one
+process (an episode-1 leftover makes the next test's first wedge park). */
+export function __testOnlyResetLengthExhaustionEpisodes(): void {
+  resetLengthExhaustionEpisodes();
+}
 
 /** Arm the next automatic re-dispatch after a successful zombie abort.
  * The configured retry budget keeps repeated recovery finite; the caller gets
@@ -1333,6 +1355,7 @@ export function registerGoalRuntime(pi: ExtensionAPI): void {
     // Session-scoped resources are reset only after this context has passed
     // the host-admission gate; child factories never touch host state.
     resetLengthContinue();
+    lengthExhaustionEpisodes = 0;
     sessionHandoffPending = false;
     // Reset terminal ownership before rememberCtx: this is the only event
     // allowed to bind a context after a stale/shutdown handoff.
@@ -2016,6 +2039,45 @@ export function registerGoalRuntime(pi: ExtensionAPI): void {
     replayApprovalSummariesOnContact(ctx);
   });
 
+/** v0.38.68 (relentless, field 162348): shared hot-exhaustion core for the
+goal and loop give-up branches. Rotation and compaction-defer are identical
+for both; only the fresh-budget copy, the park action, and the kick differ
+and stay at the call sites. Returns true when the episode was handled
+(rotated or deferred) so the caller only owns the fresh-budget path. */
+async function handleHotLengthExhaustion(
+  ctx: ExtensionContext,
+  decision: LengthExhaustionDecision,
+  percent: number | null,
+  consecutive: number,
+  recentCompact: boolean,
+): Promise<"kick" | "settle" | "fresh"> {
+  if (decision === "rotate-fallback") {
+    const switched = await recoverFromContextOverflow(ctx, `output-token limit — ${LENGTH_CONTINUE_MAX}× truncated at ${percent !== null ? `${percent.toFixed(1)}%` : "near-full"} context; rotating to a larger-context model`);
+    if (switched) {
+      appendLedger(ctx.cwd, "length_exhausted_rotated", { consecutive, contextPercent: percent });
+      ctx.ui.notify(`glla: response truncated ${LENGTH_CONTINUE_MAX}× at ${percent !== null ? `${percent.toFixed(1)}%` : "near-full"} context — rotated to a larger-context backup model with a fresh truncation budget.`, "info");
+      return "kick";
+    }
+    // Rotation refused (chain burned between decision and attempt) — fall
+    // through to compaction-defer below rather than parking.
+  }
+  if (decision !== "fresh-budget") {
+    noteContextPercent(percent);
+    const yielded = noteContextStarvedYield();
+    appendLedger(ctx.cwd, "length_exhausted_compact_pending", { consecutive, contextPercent: percent, starvedStreak: yielded.streak, recentCompact });
+    ctx.ui.notify(`glla: response truncated ${LENGTH_CONTINUE_MAX}× at ${percent !== null ? `${percent.toFixed(1)}%` : "near-full"} context — the prompt no longer fits this model. Yielding to pi auto-compaction; work stays active and resumes with a fresh truncation budget after compaction lands.${recentCompact ? " A compact-and-retry already failed within the last 90s, so the fallback rotation above is the next recourse." : ""}`, "info");
+    void runEmergencyCompactorIfDue(ctx, yielded.shouldRefuse, {
+      notify: (message) => ctx.ui.notify(message, "info"),
+      page: (message) => notifyExternal(ctx, message),
+    });
+    // v0.38.68 reviewer P1: settle owns the resume — kicking a turn here
+    // dispatches into a known-hot window before the starvation choke
+    // engages (refuse bites at streak>=2; first exhaustion yields streak=1).
+    return "settle";
+  }
+  return "fresh";
+}
+
   pi.on("agent_end", async (event: any, ctx: ExtensionContext) => {
     rememberCtx(ctx);
     signalSupervisionEvent({ plane: state.mainModelRecovery ? "provider-recovery" : state.loop?.active ? "loop" : state.goal?.policy === "list" ? "list" : state.goal ? "goal" : "queue", kind: "progress", source: "agent_end" });
@@ -2098,7 +2160,12 @@ export function registerGoalRuntime(pi: ExtensionAPI): void {
       });
     }
     const contextStarvedLength = isContextStarvedLengthStop(rawLastA, contextUsage);
-    const lc = tickLengthContinue(lastA?.stopReason === "length" && !contextStarvedLength);
+    const lengthStopped = lastA?.stopReason === "length" && !contextStarvedLength;
+    // v0.38.68: a genuinely clean turn closes the exhaustion episode. A
+    // starved stop does NOT (the wedge persists); error stops route to the
+    // recovery paths which own the next turn.
+    if (lastA?.stopReason !== "length" && lastA?.stopReason !== "error" && !contextStarvedLength) lengthExhaustionEpisodes = 0;
+    const lc = tickLengthContinue(lengthStopped);
     if (contextStarvedLength) {
       const starved = noteContextStarvedYield();
       appendLedger(ctx.cwd, "length_continue_deferred_context_full", {
@@ -2141,26 +2208,64 @@ export function registerGoalRuntime(pi: ExtensionAPI): void {
       appendLedger(ctx.cwd, "length_continue_exhausted", { consecutive: lc.consecutive });
       ctx.ui.notify(`glla: response hit the output-token cap ${LENGTH_CONTINUE_MAX}× in a row — stepping aside. Ask the model to split the work into smaller pieces.`, "warning");
       if (state.goal && state.goal.status === "active") {
-        notifyExternal(ctx, `Response truncated ${LENGTH_CONTINUE_MAX}× in a row — ${goalNoun()} paused; split the work, then ${activeGoalSurfaceCommand("resume")}.`);
-        updateGoal({
-          status: "paused",
-          pauseKind: "error",
-          pauseReason: `output-token limit — ${LENGTH_CONTINUE_MAX} responses in a row were truncated mid-artifact; auto-continue exhausted`,
-          pauseSuggestedAction: `Re-scope the current artifact into smaller pieces (several smaller write/edit calls across turns instead of one giant response), then ${activeGoalSurfaceCommand("resume")} — the truncation budget restarts fresh.`,
-        }, ctx);
-        // The pause is the durable record; an explicit recovery gets a full
-        // fresh truncation budget (otherwise the sticky gaveUp flag would
-        // make the resumed turn silently dead on the first truncation).
-        resetLengthContinue();
+        // v0.38.68 (relentless, field 162348): bounded exhaustion episodes
+        // instead of an immediate manual park. Episode 1 stays relentless
+        // per context heat; episode 2 parks — the model proved it will not
+        // chunk and further budgets would only burn quota.
+        const episode = nextLengthExhaustionEpisode(lengthExhaustionEpisodes);
+        lengthExhaustionEpisodes = episode.episodes;
+        if (episode.parkNow) {
+          notifyExternal(ctx, `Response truncated ${LENGTH_CONTINUE_MAX}× in a row — ${goalNoun()} paused; split the work, then ${activeGoalSurfaceCommand("resume")}.`);
+          updateGoal({
+            status: "paused",
+            pauseKind: "error",
+            pauseReason: `output-token limit — ${LENGTH_CONTINUE_MAX} responses in a row were truncated mid-artifact; auto-continue exhausted`,
+            pauseSuggestedAction: `Re-scope the current artifact into smaller pieces (several smaller write/edit calls across turns instead of one giant response), then ${activeGoalSurfaceCommand("resume")} — the truncation budget restarts fresh.`,
+          }, ctx);
+          // The pause is the durable record; an explicit recovery gets a full
+          // fresh truncation budget (otherwise the sticky gaveUp flag would
+          // make the resumed turn silently dead on the first truncation).
+          // Episodes reset so the manual resume starts a fresh relentless cycle.
+          lengthExhaustionEpisodes = 0;
+          resetLengthContinue();
+        } else {
+          const percent = typeof contextUsage?.percent === "number" && Number.isFinite(contextUsage.percent) ? contextUsage.percent : null;
+          const decision = decideLengthExhaustion({ contextPercent: percent, fallbackRefsAvailable: mainModelFallbackRefs(ctx).length > 0 });
+          const sinceLastCompactMs = state.lastCompactionAt ? Date.now() - state.lastCompactionAt : Number.POSITIVE_INFINITY;
+          const handled = await handleHotLengthExhaustion(ctx, decision, percent, lc.consecutive, sinceLastCompactMs < COMPACTION_GRACE_MS);
+          if (handled === "fresh") {
+            appendLedger(ctx.cwd, "length_exhausted_fresh_budget", { consecutive: lc.consecutive, contextPercent: percent, episode: episode.episodes });
+            ctx.ui.notify(`glla: response hit the output-token cap ${LENGTH_CONTINUE_MAX}× in a row — truncation budget restarted (relentless episode ${episode.episodes} of ${LENGTH_EXHAUSTION_MAX_EPISODES - 1}). Split the work into smaller pieces across turns; a repeat parks for manual action.`, "warning");
+          }
+          resetLengthContinue();
+          if (handled !== "settle") scheduleContinuation(ctx);
+        }
       } else if (state.loop?.active) {
-        state.loop.active = false;
-        state.loop.stopReason = `output-token limit — ${LENGTH_CONTINUE_MAX} consecutive truncated responses (iteration ${state.loop.iteration} preserved; /loop resume after re-scoping the work into smaller pieces)`;
-        persistState(ctx);
-        const recap = compactLoopCompletionSummary({ ...state.loop, historyLength: state.loop.history.length });
-        ctx.ui.notify(`glla: response hit the output-token cap ${LENGTH_CONTINUE_MAX}× in a row — the loop stopped. Ask the model to split the work into smaller pieces.\nRecap: ${recap}`, "warning");
-        notifyExternal(ctx, `Response truncated ${LENGTH_CONTINUE_MAX}× in a row — loop stopped; /loop resume after re-scoping. Recap: ${recap}`);
-        appendLedger(ctx.cwd, "loop_stopped", { reason: state.loop.stopReason, iterations: state.loop.iteration, best: state.loop.bestValue, recap });
-        resetLengthContinue();
+        // v0.38.68 (relentless): same bounded episodes as the goal branch.
+        const episode = nextLengthExhaustionEpisode(lengthExhaustionEpisodes);
+        lengthExhaustionEpisodes = episode.episodes;
+        if (episode.parkNow) {
+          state.loop.active = false;
+          state.loop.stopReason = `output-token limit — ${LENGTH_CONTINUE_MAX} consecutive truncated responses (iteration ${state.loop.iteration} preserved; /loop resume after re-scoping the work into smaller pieces)`;
+          persistState(ctx);
+          const recap = compactLoopCompletionSummary({ ...state.loop, historyLength: state.loop.history.length });
+          ctx.ui.notify(`glla: response hit the output-token cap ${LENGTH_CONTINUE_MAX}× in a row — the loop stopped. Ask the model to split the work into smaller pieces.\nRecap: ${recap}`, "warning");
+          notifyExternal(ctx, `Response truncated ${LENGTH_CONTINUE_MAX}× in a row — loop stopped; /loop resume after re-scoping. Recap: ${recap}`);
+          appendLedger(ctx.cwd, "loop_stopped", { reason: state.loop.stopReason, iterations: state.loop.iteration, best: state.loop.bestValue, recap });
+          lengthExhaustionEpisodes = 0;
+          resetLengthContinue();
+        } else {
+          const percent = typeof contextUsage?.percent === "number" && Number.isFinite(contextUsage.percent) ? contextUsage.percent : null;
+          const decision = decideLengthExhaustion({ contextPercent: percent, fallbackRefsAvailable: mainModelFallbackRefs(ctx).length > 0 });
+          const sinceLastCompactMs = state.lastCompactionAt ? Date.now() - state.lastCompactionAt : Number.POSITIVE_INFINITY;
+          const handled = await handleHotLengthExhaustion(ctx, decision, percent, lc.consecutive, sinceLastCompactMs < COMPACTION_GRACE_MS);
+          if (handled === "fresh") {
+            appendLedger(ctx.cwd, "length_exhausted_fresh_budget", { consecutive: lc.consecutive, contextPercent: percent, episode: episode.episodes });
+            ctx.ui.notify(`glla: response hit the output-token cap ${LENGTH_CONTINUE_MAX}× in a row — truncation budget restarted (relentless episode ${episode.episodes} of ${LENGTH_EXHAUSTION_MAX_EPISODES - 1}). Split the work into smaller pieces across turns; a repeat stops the loop.`, "warning");
+          }
+          resetLengthContinue();
+          if (handled !== "settle") scheduleLoopTick(ctx);
+        }
       } else {
         notifyExternal(ctx, "Response truncated 3× in a row — giving up auto-continue.");
       }

package/extensions/loops/goal-auditor-hooks.ts

@@ -116,6 +116,8 @@ import {
   modelSwitch,
   isForbiddenModel,
   filterEvictedAuditorRefs,
+  freshAuditorCycleClaim,
+  isQuotaIdenticalParkExempt,
   withEvictedAuditorRef,
   trackAuditorIdenticalFailure,
 isGoalRevisionCurrent,
@@ -653,29 +655,24 @@ function beginCompletionAudit(ctx: ExtensionContext, claim: PendingCompletion, o
   // An agent-tool resume carries the same in-conversation user
   // authorization as a typed /goal resume, so an exhausted claim also
   // starts a fresh cycle instead of re-walking a dead cursor.
-  const freshAuditorCycle = (origin === "manual" || origin === "agent") && claim.auditorFallbackExhausted === true;
+  // v0.38.68 (relentless, field 150821): the single automatic
+  // session-recovery retry reseeds too — re-walking a burned cursor is what
+  // bumped an identical-parked claim from 3 to 4 failures. Every origin now
+  // starts a fresh bounded window with re-resolved models via
+  // freshAuditorCycleClaim; the automatic attempt stays bounded by
+  // automaticRecoveryAttempted.
+  const freshAuditorCycle = (origin === "manual" || origin === "agent" || origin === "session-recovery") && claim.auditorFallbackExhausted === true;
   const claimForAttempt = (origin === "manual" || origin === "agent")
     ? {
       ...claim,
       retryAttempts: undefined,
       retryFirstAt: undefined,
       retryUntil: undefined,
-      ...(freshAuditorCycle ? {
-        auditorCandidateRefs: undefined,
-        auditorCandidateRef: undefined,
-        auditorRetryCandidateRef: undefined,
-        auditorRetryAttemptStartedAt: undefined,
-        auditorAttemptedRefs: undefined,
-        auditorEvictedRefs: undefined,
-        auditorLastFailureFingerprint: undefined,
-        auditorConsecutiveIdenticalFailures: undefined,
-        auditorFailureCount: undefined,
-        auditorFailureClass: undefined,
-        auditorFallbackExhausted: undefined,
-        auditorFailureAt: undefined,
-      } : {}),
+      ...(freshAuditorCycle ? freshAuditorCycleClaim(claim) : {}),
     }
-    : claim;
+    : origin === "session-recovery" && freshAuditorCycle
+      ? { ...claim, ...freshAuditorCycleClaim(claim) }
+      : claim;
   const pending: PendingCompletion = {
     ...claimForAttempt,
     phase: "running",
@@ -1787,7 +1784,11 @@ async function retryStoredCompletionAudit(origin: CompletionAuditOrigin = "provi
     const plan = auditorRetryPlan(durableClaim, undefined, undefined, aggressive);
     // v0.38.63 (audit-stuck batch): same identical-park gate as the
     // complete_goal ladder path — the loop terminates visibly here too.
+    // v0.38.68 (relentless, field 150821): quota walls are transient —
+    // hammer the bounded retry plan instead of parking with "check the
+    // setup". Only identical NON-quota failures park.
     const identical = trackAuditorIdenticalFailure(durableClaim, failureCopy.fingerprint);
+    const quotaIdenticalExempt = isQuotaIdenticalParkExempt(failureCopy.diagnostic);
     const pending = {
       ...durableClaim,
       phase: "retry-waiting" as const,
@@ -1805,7 +1806,7 @@ async function retryStoredCompletionAudit(origin: CompletionAuditOrigin = "provi
       retryFirstAt: plan.firstAt,
       retryUntil: plan.autoRetryUntil,
     };
-    if (identical.identicalParkDue) {
+    if (identical.identicalParkDue && !quotaIdenticalExempt) {
       const deadChain = (durableClaim.exhaustedChain
         ?? (durableClaim.auditorCandidateRefs ?? durableClaim.auditorAttemptedRefs ?? []).join(" → ")
         ?? "").slice(0, 300) || "unknown chain";

package/extensions/loops/goal-tools.ts

@@ -124,6 +124,7 @@ import {
   modelSwitch,
   isForbiddenModel,
   filterEvictedAuditorRefs,
+  isQuotaIdenticalParkExempt,
   withEvictedAuditorRef,
   trackAuditorIdenticalFailure,
 isGoalRevisionCurrent,
@@ -1791,7 +1792,11 @@ function registerAgentTools(pi: any): void {
           // failures terminate the loop visibly — park blocked naming the
           // dead chain, schedule no further retry. Manual/agent resume
           // still opens a fresh cycle with re-resolved models.
+          // v0.38.68 (relentless, field 150821): quota walls are transient —
+          // hammer the bounded retry plan instead of parking with "check the
+          // setup". Only identical NON-quota failures park.
           const identical = trackAuditorIdenticalFailure(durableCompletionClaim, failureCopy.fingerprint);
+          const quotaIdenticalExempt = isQuotaIdenticalParkExempt(failureCopy.diagnostic);
           const pending = {
             ...durableCompletionClaim,
             phase: "retry-waiting" as const,
@@ -1809,7 +1814,7 @@ function registerAgentTools(pi: any): void {
             retryFirstAt: plan.firstAt,
             retryUntil: plan.autoRetryUntil,
           };
-          if (identical.identicalParkDue) {
+          if (identical.identicalParkDue && !quotaIdenticalExempt) {
             const deadChain = (durableCompletionClaim.exhaustedChain
               ?? (durableCompletionClaim.auditorCandidateRefs ?? durableCompletionClaim.auditorAttemptedRefs ?? []).join(" → ")
               ?? "").slice(0, 300) || "unknown chain";

package/extensions/loops/goal.ts

@@ -16,7 +16,7 @@ import "./goal-auditor-hooks.js";
 import "./goal-list-queue.js";
 import "./goal-tools.js";
 import "./goal-settings-ui.js";
-import { abortZombieRun, enqueueFaultRepairTask, registerGoalRuntime } from "./goal-activation.js";
+import { abortZombieRun, enqueueFaultRepairTask, registerGoalRuntime, resetLengthExhaustionEpisodes } from "./goal-activation.js";
 
 import {
   createGoalContinuation,
@@ -178,6 +178,7 @@ const commandDeps: CommandDeps = {
   releaseContinuationDispatchStandDown,
   releaseInitialSessionLoadBarrier,
   resolveCarryover,
+  resetLengthExhaustionEpisodes,
   safeSteerUser,
   scheduleContinuation,
   scheduleSessionTimeout,

package/package.json

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

package/skills/glla-delegate/SKILL.md

@@ -17,9 +17,14 @@ tools in the main session only:
   current request and offer to queue it first. Queue it without another
   question only when the user has given standing permission such as
   “queue follow-ups as you find them.”
-- If one durable, multi-hour objective is warranted, interview only what is
-  genuinely unknown, then call `propose_goal_draft`; the user's Confirm
-  dialog is the activation gate. Never activate a speculative raw seed.
+- If one durable, multi-hour objective is warranted, `propose_goal_draft`
+  works only while a drafting session is already open (the user ran bare
+  `/goal`, `/list`, or `/list add` with no args): interview only what is
+  genuinely unknown, then propose; the user's Confirm dialog is the
+  activation gate. From normal chat with no draft open, do NOT call
+  `propose_goal_draft` — it refuses outside drafting mode. Ask the user to
+  open drafting with bare `/goal`, or use `list_add` for straight queueing.
+  Never activate a speculative raw seed.
   (Unless Auto-accept drafts is on in /glla settings, which skips the
   Confirm — never promise a dialog that setting suppresses.)
 - Never call `list_activate` for an item the user has not selected or clearly