pi-goal-list-loop-audit 0.27.1 → 0.27.2

package/extensions/length-continue.ts

@@ -0,0 +1,72 @@
+// pi-goal-list-loop-audit — v0.27.2
+// extensions/length-continue.ts
+//
+// Folded-in auto-continue for output-token truncation (was the standalone
+// pi-length-continue 0.1.0, now deprecated). When ONE assistant response
+// exceeds the model's provider-side per-response output cap, pi ends the
+// turn with stopReason "length" and idles — a dead stop on unattended rigs.
+// The tracker decides when to re-trigger; goal.ts's agent_end handler wires
+// it BEFORE all turn bookkeeping: a truncated turn is not a completed turn
+// (no telemetry), not a stall (no no-tool nudge), and must not run the
+// loop measure or the normal goal continuation on half a response.
+//
+// Guards (same as the standalone):
+//   - consecutive cap: after MAX back-to-back truncations, give up (once)
+//     instead of burning quota in a truncation ping-pong. Any normally
+//     finished turn resets the counter.
+//   - the caller skips when messages are already pending (a queued message
+//     triggers a turn anyway) and routes stale-handle errors to
+//     goStaleTerminal (pi#7154).
+
+export const LENGTH_CONTINUE_MAX = 3;
+
+export const LENGTH_CONTINUE_TEXT = [
+  "Your previous response was cut off at the model's per-response output token limit.",
+  "Continue EXACTLY where you stopped — finish the current artifact, then keep going.",
+  "Keep each individual response shorter from here: split large file writes into multiple smaller write/edit calls across turns instead of one giant response.",
+].join(" ");
+
+export interface LengthContinueTick {
+  /** Send the continue message this round. */
+  fire: boolean;
+  /** The cap was just exceeded — notify the give-up exactly once. */
+  giveUpNow: boolean;
+  /** Current consecutive truncation streak (after this tick). */
+  consecutive: number;
+}
+
+export function makeLengthContinueTracker(max: number = LENGTH_CONTINUE_MAX) {
+  let consecutive = 0;
+  let gaveUp = false;
+  return {
+    tick(stopped: boolean): LengthContinueTick {
+      if (!stopped) {
+        consecutive = 0;
+        gaveUp = false;
+        return { fire: false, giveUpNow: false, consecutive: 0 };
+      }
+      consecutive++;
+      if (consecutive > max) {
+        const giveUpNow = !gaveUp;
+        gaveUp = true;
+        return { fire: false, giveUpNow, consecutive };
+      }
+      return { fire: true, giveUpNow: false, consecutive };
+    },
+    get consecutive(): number {
+      return consecutive;
+    },
+  };
+}
+
+// Session-level singleton — one tracker per extension runtime. The factory
+// calls resetLengthContinue() so an extension reload starts clean.
+let tracker = makeLengthContinueTracker();
+
+export function tickLengthContinue(stopped: boolean): LengthContinueTick {
+  return tracker.tick(stopped);
+}
+
+export function resetLengthContinue(): void {
+  tracker = makeLengthContinueTracker();
+}

package/extensions/loops/goal.ts

@@ -86,6 +86,12 @@ import {
   writeGoalMd,
   missingGllaTools,
 } from "../goal-loop-core.js";
+import {
+  LENGTH_CONTINUE_MAX,
+  LENGTH_CONTINUE_TEXT,
+  resetLengthContinue,
+  tickLengthContinue,
+} from "../length-continue.js";
 import {
   isQuotaError,
   isSubagentQuotaResult,
@@ -527,6 +533,25 @@ function sendContinuation(goalId: string): void {
   }
 }
 
+// v0.27.2: send the truncation-continue nudge. Same guards as
+// sendContinuation (stale api = terminal), independent of goal state —
+// plain sessions truncate too.
+function sendLengthContinue(ctx: ExtensionContext, consecutive: number): void {
+  if (!extensionApi || extensionApiStale) return;
+  try {
+    extensionApi.sendMessage({
+      customType: GOAL_EVENT_ENTRY,
+      content: LENGTH_CONTINUE_TEXT,
+      display: true,
+    }, { triggerTurn: true, deliverAs: "followUp" });
+    appendLedger(ctx.cwd, "length_continue_sent", { consecutive });
+    ctx.ui.notify(`Response hit the output-token cap — auto-continuing (${consecutive}/${LENGTH_CONTINUE_MAX})`, "warning");
+  } catch (err) {
+    appendLedger(ctx.cwd, "length_continue_send_failed", { consecutive, error: err instanceof Error ? err.message : String(err) });
+    if (isStaleApiError(err)) goStaleTerminal(ctx, "sendLengthContinue");
+  }
+}
+
 function continuationPrompt(goal: Goal): string {
   // Read the .md file as the template, then substitute {{tokens}}.
   // For v0.1.0 we inline-substitute so we don't need fs at runtime.
@@ -3463,6 +3488,7 @@ function warnOnCommandCollision(ctx: ExtensionContext): void {
 export default function (pi: ExtensionAPI): void {
   extensionApi = pi;
   extensionApiStale = false; // a fresh factory run means a fresh runtime (reload path)
+  resetLengthContinue(); // v0.27.2: fresh runtime, fresh truncation streak
   startHeartbeat();
   startUITicker();
   // Four top-level commands, that's all (v0.8.0 consolidation):
@@ -3778,6 +3804,23 @@ export default function (pi: ExtensionAPI): void {
     // continuation loop.
     if (isForeignCtx(ctx)) return;
     noteActivity(true);
+    // v0.27.2: folded-in length-continue (standalone pi-length-continue is
+    // deprecated). A response cut by the per-response output cap is NOT a
+    // completed turn (no telemetry), NOT a stall (no no-tool nudge), and
+    // must not run the loop measure or the normal goal continuation on half
+    // a response — re-trigger immediately with split-smaller guidance and
+    // skip ALL turn bookkeeping; the NEXT agent_end processes the run.
+    // Works with no goal active (plain sessions truncate too).
+    const lastA = [...(event.messages as any[])].reverse().find((m) => m.role === "assistant");
+    const lc = tickLengthContinue(lastA?.stopReason === "length");
+    if (lc.giveUpNow) {
+      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");
+      notifyExternal(ctx, "Response truncated 3× in a row — giving up auto-continue.");
+    }
+    if (lastA?.stopReason === "length") {
+      if (lc.fire && !ctx.hasPendingMessages()) sendLengthContinue(ctx, lc.consecutive);
+      return;
+    }
     // v0.25.2: per-goal turn telemetry (/glla stats).
     if (state.goal && state.goal.status === "active") {
       const t = state.goal.telemetry ?? { turns: 0, fileWrites: 0, bashCalls: 0 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goal-list-loop-audit",
-  "version": "0.27.1",
+  "version": "0.27.2",
   "description": "Goal. Loop. Audit. Done. — a pi-coding-agent extension that supervises long-running work, with isolated auditor on each completion. Beat bamboozling by design: the auditor runs in a fresh session with no extensions, no skills, no editor — only the read tools needed to verify your goal.",
   "license": "MIT",
   "author": "dracon",