pi-goal-list-loop-audit 0.38.38 → 0.38.40

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## 0.38.40 — provider overflow errors count as starvation (2026-09-09)
+
+### Fixed
+
+- **PR #48 (Bjynt, merged):** `isContextStarvedLengthStop` now detects explicit provider context-overflow errors (`exceed_context_size_error`, `exceeds the available context size`, `context window exceeded`, …) arriving as `stopReason="error"`, firing the starvation ladder + emergency compactor (≥90% usage gate kept). Case 1 refactor is behavior-identical. Wiring confirmed live via the raw session message's `errorMessage`.
+- Follow-up noted on the PR: OpenAI-style `maximum context length` wording still falls through the matcher set.
+
+### Verification
+
+- Contributor's Case 2 tests + full `release:check` 0 failures; `tsc --noEmit` clean.
+
+## 0.38.39 — Codex-like terminal summary (2026-09-09)
+
+### Fixed
+
+- **Terminal `[goal-event]` summary was not Codex-like (field 20260909_013733):** `•` detail bullets followed by dangling `—` trailer lines, every bullet trailing into `…`, a raw `/var/tmp/…` log path in chat, and no next action. The render is now one voice: uniform `•` bullets (approval/counts/record ride as bullets, record stays last), machine paths (`/tmp/…`, `/var/tmp/…`, `*.tgz`, receipt-only paren groups) stripped from chat bullets (archive keeps the full text), `+` joins the clause-boundary cut set, and `withoutStaleNext` is selective — audit-self-referential Next lines still drop but the first concrete next action survives as the closing bullet ahead of the non-do.
+- **Claim-side guidance:** continuation prompt budgets each label value to ~90 chars, bans machine paths from the recap, and asks for one concrete `Next:` or none.
+
+### Verification
+
+- New pins: uniform-voice, machine-path strip, `+`-boundary cut, next-action ordering, record-last; full `release:check` 0 failures; `tsc --noEmit` clean.
+- Evidence: `audit/CODEX-SUMMARY-2026-09-09.md`. Archive format and delivery/replay mechanics unchanged.
+
 ## 0.38.38 — elapsed-time duplication cut + PR #47 closed (2026-09-09)
 
 ### 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.38 continue through the supervisor freeze (`/glla pause`),
+  v0.35.14–v0.38.40 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/completion-summary.ts

@@ -86,7 +86,7 @@ export function isUsefulCompletionSummary(text: string | undefined): boolean {
  * back to the word break, then to a hard cut only when the head holds
  * no space past the halfway mark — a long token such as a commit hash
  * must not eviscerate the whole value. Trailing punctuation is stripped
- * before the ellipsis. Short values pass through untouched (no `…`). */
+ * `npm version…+ latest` cut inside a `+`-joined list). */
 export function clipSummaryValue(value: string, limit: number): string {
   const clean = value.replace(/\s+/g, " ").trim();
   const capped = Number.isFinite(limit) ? Math.max(8, Math.floor(limit)) : 72;
@@ -95,16 +95,16 @@ export function clipSummaryValue(value: string, limit: number): string {
   const floor = Math.max(16, Math.floor((capped - 1) * 0.4));
   let boundary = -1;
   for (let i = 0; i < head.length; i++) {
-    if (/[,;:·—–(\[]/.test(head[i]!)) boundary = i;
+    if (/[,;:·—–(+[\[]/.test(head[i]!)) boundary = i;
   }
   if (boundary >= floor) {
-    const cut = head.slice(0, boundary).replace(/[,;:·—–(\[\s]+$/u, "");
+    const cut = head.slice(0, boundary).replace(/[,;:·—–(+[\[\s]+$/u, "");
     if (cut.length >= Math.min(floor, 16)) return `${cut}…`;
   }
   const space = head.lastIndexOf(" ");
   const kept = (space > capped / 2 ? head.slice(0, space) : head)
     .trimEnd()
-    .replace(/[,;:·—–(\[]$/u, "");
+    .replace(/[,;:·—–(+\[]$/u, "");
   return `${kept}…`;
 }
 
@@ -152,6 +152,34 @@ export interface HumanCompletionBrief {
   details: string[];
 }
 
+/** v0.38.39 (field 20260909_013733): absolute machine paths read as a
+ * machine receipt in user chat (`Tests: … (/var/tmp/glla-….log…`). The
+ * chat brief strips `/tmp/…`, `/var/tmp/…`, and `*.tgz` tokens so bullets
+ * carry human-readable proof (counts, versions, repo-relative paths);
+ * the durable archive keeps the full text. Falls back to the original
+ * when stripping would empty the value. */
+export function chatSafeDetailValue(value: string): string {
+  const withoutGroups = value.replace(/\([^()]*\)/g, (group) => {
+    // A parenthesized group that carries nothing but stripped tokens and
+    // receipt words is machine packaging — drop the whole group so no
+    // `( tarball )` husk survives. Groups with real words stay verbatim.
+    const inner = group
+      .slice(1, -1)
+      .replace(/(?:\/var)?\/tmp\/\S+/g, "")
+      .replace(/\S+\.tgz\b/g, "")
+      .replace(/\btarballs?\b|\blogs?\b/gi, "");
+    return /[a-z]/i.test(inner) ? group : "";
+  });
+  const stripped = withoutGroups
+    .replace(/(?:\/var)?\/tmp\/\S+/g, "")
+    .replace(/\btarballs?\s+\S+\.tgz\b/gi, "")
+    .replace(/\S+\.tgz\b/g, "")
+    .replace(/\(\s*\)/g, "")
+    .replace(/\s{2,}/g, " ")
+    .trim();
+  return stripped || value;
+}
+
 /** The human briefing: outcome first in its own words, then only the
  * labels that carry real content (filler like `Unresolved: none` or
  * `Changed: not recorded` is dropped, never shown). The durable archive
@@ -170,7 +198,9 @@ export function humanCompletionBrief(
     const separator = line.indexOf(":");
     if (separator < 0) continue;
     const content = briefValueContent(line.slice(separator + 1));
-    if (content) details.push(`${line.slice(0, separator)}: ${clipSummaryValue(content, valueBudget)}`);
+    // v0.38.39: machine paths are archive evidence, not chat evidence —
+    // strip before clipping so the budget applies to the human text.
+    if (content) details.push(`${line.slice(0, separator)}: ${clipSummaryValue(chatSafeDetailValue(content), valueBudget)}`);
   }
   return { outcome, details };
 }
@@ -178,10 +208,27 @@ export function humanCompletionBrief(
 /** v0.38.20: the agent's `Next:` recap line goes stale the moment the
  * verdict lands — reprinting it next to the approval trailer reads as
  * complete-before-verify (field 2026-09-04: `Next: detached auditor
- * verdict decides.` printed above `— auditor … approved.`). Every approval
- * surface strips it; the full six-label record stays in the archive. */
+ * verdict decides.` printed above `— auditor … approved.`).
+ * v0.38.39 (field 20260909_013733): the Codex close wants at most ONE
+ * concrete next action, so the filter is now selective instead of total:
+ * self-referential audit/process lines (`verdict decides`, `awaiting
+ * approval`, …) still drop, but the first concrete action survives as
+ * the closing bullet. The full six-label record stays in the archive. */
+const STALE_NEXT_PATTERN = /auditor|verdict|approv|audit|settl|review/i;
 export function withoutStaleNext(details: string[] | undefined): string[] {
-  return (details ?? []).filter((d) => !/^\s*Next\s*:/i.test(d));
+  const kept: string[] = [];
+  let actionKept = false;
+  for (const detail of details ?? []) {
+    if (!/^\s*Next\s*:/i.test(detail)) {
+      kept.push(detail);
+      continue;
+    }
+    if (STALE_NEXT_PATTERN.test(detail)) continue;
+    if (actionKept) continue;
+    actionKept = true;
+    kept.push(detail);
+  }
+  return kept;
 }
 
 /** v0.38.20: the approval chat notify — outcome first, all bounded
@@ -202,13 +249,24 @@ export function buildApprovalChatLines(notice: {
     `✓ done — ${notice.outcome}`,
     // v0.38.37 (audit 2026-09-08): one verifiable-result bullet per
     // informing detail — the Codex closing shape.
+    // v0.38.39: the approval/counts/record trailer rides as bullets too
+    // (field 20260909_013733 — the `—` tail read as a second voice); the
+    // record pointer stays last.
     ...withoutStaleNext(notice.details).map((detail) => `• ${detail}`),
-    notice.approval,
-    ...(notice.counts ? [notice.counts] : []),
-    notice.record,
+    trailerBullet(notice.approval),
+    ...(notice.counts ? [trailerBullet(notice.counts)] : []),
+    trailerBullet(notice.record),
   ];
 }
 
+/** v0.38.39 (field 20260909_013733): the trailer rides as bullets too —
+ * the Codex close is uniform `•` lines (`• Changed:` … `• record:`),
+ * never a `•` block followed by dangling `—` lines. The `— ` sigil is
+ * stripped at render; the input strings keep it for non-chat surfaces. */
+function trailerBullet(line: string): string {
+  return `• ${line.replace(/^—\s*/, "")}`;
+}
+
 /** v0.38.25: the audit-goal counts line — verdict proof ONLY, built from
  * durable goal state. Raw run stats (turns/file-writes/bash calls) read as
  * a machine receipt in user chat (field 2026-09-08 223522/223523); the
@@ -297,7 +355,7 @@ export function buildTerminalApprovalRender(input: TerminalApprovalRenderInput):
       ...(input.extras ?? []),
     ],
     recap,
-    transcriptLines: [...withoutStaleNext(brief.details).map((detail) => `• ${detail}`), input.approval],
+    transcriptLines: [...withoutStaleNext(brief.details).map((detail) => `• ${detail}`), trailerBullet(input.approval)],
     countsLine,
     outcome: brief.outcome,
     approval: input.approval,

package/extensions/length-continue.ts

@@ -46,6 +46,10 @@ export interface AssistantLengthMessageLike {
   usage?: {
     output?: number;
   };
+  /** Provider error message, when stopReason is "error". */
+  errorMessage?: string;
+  /** Error type from provider (e.g., "exceed_context_size_error"). */
+  errorType?: string;
 }
 
 export const LENGTH_CONTINUE_CONTEXT_STARVED_PERCENT = 90;
@@ -60,21 +64,49 @@ export const LENGTH_CONTINUE_CONTEXT_STARVED_MAX_OUTPUT = 8;
  * here queues another 1-token request before pi's post-agent_end compaction
  * check and delays the actual cure (field: darklord 2026-08-02, 198,116 /
  * 198,179 total tokens of a 200,000 window, output=1 twice).
+ *
+ * v0.38.36: also detect explicit context-overflow provider errors
+ * (e.g., "exceed_context_size_error", "exceeds the available context size")
+ * which arrive as stopReason="error" with an errorMessage, not as
+ * stopReason="length". These are also context starvation — the request
+ * exceeded the model's context window before generation could start.
  */
 export function isContextStarvedLengthStop(
   message: AssistantLengthMessageLike | null | undefined,
   contextUsage: ContextUsageLike | null | undefined,
 ): boolean {
-  if (message?.stopReason !== "length") return false;
-  const output = message.usage?.output;
-  if (typeof output !== "number" || !Number.isFinite(output)) return false;
-  if (output > LENGTH_CONTINUE_CONTEXT_STARVED_MAX_OUTPUT) return false;
-  const percent = typeof contextUsage?.percent === "number"
-    ? contextUsage.percent
-    : typeof contextUsage?.tokens === "number" && typeof contextUsage?.contextWindow === "number" && contextUsage.contextWindow > 0
-      ? (contextUsage.tokens / contextUsage.contextWindow) * 100
-      : null;
-  return percent !== null && Number.isFinite(percent) && percent >= LENGTH_CONTINUE_CONTEXT_STARVED_PERCENT;
+  // Case 1: pi's context-safety clamp (stopReason="length" with tiny output)
+  if (message?.stopReason === "length") {
+    const output = message.usage?.output;
+    if (typeof output === "number" && Number.isFinite(output) && output <= LENGTH_CONTINUE_CONTEXT_STARVED_MAX_OUTPUT) {
+      const percent = typeof contextUsage?.percent === "number"
+        ? contextUsage.percent
+        : typeof contextUsage?.tokens === "number" && typeof contextUsage?.contextWindow === "number" && contextUsage.contextWindow > 0
+          ? (contextUsage.tokens / contextUsage.contextWindow) * 100
+          : null;
+      return percent !== null && Number.isFinite(percent) && percent >= LENGTH_CONTINUE_CONTEXT_STARVED_PERCENT;
+    }
+    return false; // Real overlong response, not context starvation
+  }
+  // Case 2: explicit provider context-overflow error (stopReason="error")
+  if (message?.stopReason === "error") {
+    const errMsg = (message.errorMessage ?? message.errorType ?? "").toLowerCase();
+    if (
+      errMsg.includes("exceed_context_size") ||
+      errMsg.includes("exceeds the available context") ||
+      errMsg.includes("exceeds the context window") ||
+      (errMsg.includes("exceeds the model") && errMsg.includes("context")) ||
+      (errMsg.includes("context window") && errMsg.includes("exceed"))
+    ) {
+      const percent = typeof contextUsage?.percent === "number"
+        ? contextUsage.percent
+        : typeof contextUsage?.tokens === "number" && typeof contextUsage?.contextWindow === "number" && contextUsage.contextWindow > 0
+          ? (contextUsage.tokens / contextUsage.contextWindow) * 100
+          : null;
+      return percent !== null && Number.isFinite(percent) && percent >= LENGTH_CONTINUE_CONTEXT_STARVED_PERCENT;
+    }
+  }
+  return false;
 }
 
 export function makeLengthContinueTracker(max: number = LENGTH_CONTINUE_MAX) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goal-list-loop-audit",
-  "version": "0.38.38",
+  "version": "0.38.40",
   "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/prompts/goal-loop-continuation.md

@@ -197,4 +197,4 @@ The orchestrator's backstop is the stall watchdog: three consecutive turns with
 
 `complete_goal` submits a nonterminal claim, not a completion verdict. While the detached audit is pending, do not say the goal is done/complete/approved or present a final success summary. Do not wait or poll. If a response is needed, give one brief pending-status sentence. GLLA posts the concrete outcome-first summary into chat after verified approval and durable archive, without needing another user prompt. Do not duplicate that summary. A rejected claim remains unfinished and repair work continues.
 
-The agent-written completionSummary is user-facing evidence, not a step log: open with the outcome in plain words, then one verifiable result per label with its proof inline (test counts, file paths, commit refs) — never raw run stats. Cut values at clause boundaries, never mid-word; pass what was deliberately left out as the complete_goal leftOut parameter — it renders as the closing bullet, and is omitted when absent.
+The agent-written completionSummary is user-facing evidence, not a step log: open with the outcome in plain words, then one verifiable result per label with its proof inline (test counts, file paths, commit refs) — never raw run stats. Keep each label value to one line of ~90 chars so every chat bullet fits without a trailing …; cite human-readable proof (counts, versions, repo-relative paths, PR numbers) and never machine paths (/var/tmp logs, tarballs — those live in the archive only). Cut values at clause boundaries, never mid-word; write Next: as one concrete follow-up action or none (audit-self-referential lines like "verdict decides" are stripped at render); pass what was deliberately left out as the complete_goal leftOut parameter — it renders as the closing bullet, and is omitted when absent.