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

package/extensions/goal-loop-display.ts

@@ -37,6 +37,36 @@ export function truncate(s: string, max: number): string {
   return s.length <= max ? s : s.slice(0, Math.max(0, max - 1)) + "…";
 }
 
+/**
+ * Word-wrap to `width`, capped at `maxLines` (v0.27.1). A pause is the one
+ * state where the FULL text matters — the reason often carries a decision
+ * the user must make (dedup choices, impossible-verdict narrowing), and a
+ * 60-char truncate hid it. Over-long words are hard-split; when the cap
+ * cuts content the last line ends with "…" (the pause-time notification
+ * and /goal status always carry the full text).
+ */
+export function wrap(s: string, width: number, maxLines: number): string[] {
+  const norm = s.replace(/\s+/g, " ").trim();
+  const words = norm.split(" ").filter(Boolean);
+  const all: string[] = [];
+  let cur = "";
+  for (let w of words) {
+    const next = cur ? `${cur} ${w}` : w;
+    if (next.length <= width) { cur = next; continue; }
+    if (cur) all.push(cur);
+    while (w.length > width) { all.push(w.slice(0, width)); w = w.slice(width); }
+    cur = w;
+  }
+  if (cur) all.push(cur);
+  if (all.length === 0) all.push("");
+  if (all.length <= maxLines) return all;
+  const out = all.slice(0, maxLines);
+  // The last kept line already fits within width — truncate() would leave it
+  // unmarked, so force the ellipsis to signal "more in /goal status".
+  out[maxLines - 1] = out[maxLines - 1]!.slice(0, Math.max(0, width - 1)) + "…";
+  return out;
+}
+
 /**
  * Width-aware truncation budget (v0.22.2). The hardcoded caps are FLOORS for
  * narrow terminals; when the terminal is wider, lines may use the available
@@ -191,8 +221,29 @@ function goalLines(g: Goal, state: State, audit: AuditDisplayProgress | null | u
     return lines;
   }
   if (g.status === "paused" && g.pauseReason) {
-    lines.push(`├─ ${paint(theme, pauseIsError(g) ? "error" : "warning", truncate(g.pauseReason, budgetFor(width, 3, 60)))}`);
-    if (g.pauseSuggestedAction) lines.push(`└─ ${paint(theme, "dim", truncate(g.pauseSuggestedAction, budgetFor(width, 3, 60)))}`);
+    const isErr = pauseIsError(g);
+    const budget = budgetFor(width, 3, 60);
+    // v0.27.1: wrap reason + suggested action over up to 3 lines each
+    // (see wrap()); before, both were truncated at ~60 chars and the actual
+    // question in a decision-pause never reached the user.
+    wrap(g.pauseReason, budget, 3).forEach((w, i) => {
+      lines.push(`${i === 0 ? "├─" : "│ "} ${paint(theme, isErr ? "error" : "warning", w)}`);
+    });
+    // v0.27.1: what survives the pause — the first question at a pause is
+    // "did I lose the work?". Answer it on the card.
+    const spent: string[] = [];
+    const tokUsed = g.usage?.tokensUsed ?? 0;
+    if (tokUsed > 0) spent.push(`${fmtTokens(tokUsed)} tok spent`);
+    const audits = g.auditHistory?.length ?? 0;
+    if (audits > 0) spent.push(`${audits} audit${audits === 1 ? "" : "s"}`);
+    const savedLine = `saved${spent.length > 0 ? ` — ${spent.join(" · ")}` : ""} · resumes exactly here`;
+    if (g.pauseSuggestedAction) {
+      lines.push(`├─ ${paint(theme, "dim", truncate(savedLine, budget))}`);
+      const wrapped = wrap(g.pauseSuggestedAction, budget, 3);
+      wrapped.forEach((w, i) => lines.push(`${i === wrapped.length - 1 ? "└─" : "│ "} ${paint(theme, "dim", w)}`));
+    } else {
+      lines.push(`└─ ${paint(theme, "dim", truncate(savedLine, budget))}`);
+    }
     return lines;
   }
   const next = nextPending(g);

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.
@@ -2254,8 +2279,12 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
         pauseReason: p.reason,
         pauseSuggestedAction: p.suggestedAction,
       }, ctx);
-      ctx.ui.notify(`Goal paused: ${p.reason}`, "info");
-      notifyExternal(ctx, `Goal paused: ${p.reason.slice(0, 120)}`);
+      // v0.27.1: surface the FULL pause contract — reason AND suggested
+      // action. Before, the action only appeared in /goal status and the
+      // widget truncated both at ~60 chars, so decision-pauses ("choose a
+      // or b") reached the user as an unreadable fragment.
+      ctx.ui.notify(`Goal paused: ${p.reason}${p.suggestedAction ? `\n\n→ ${p.suggestedAction}` : ""}`, "info");
+      notifyExternal(ctx, `Goal paused: ${(p.suggestedAction ? `${p.reason} → ${p.suggestedAction}` : p.reason).slice(0, 200)}`);
       return { content: [{ type: "text", text: "Goal paused. /goal resume to continue." }], details: {} };
     },
   }));
@@ -3459,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):
@@ -3774,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.0",
+  "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",