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

package/extensions/goal-loop-backoff.ts

@@ -180,3 +180,77 @@ export function shouldHeartbeatRefire(input: HeartbeatInput): boolean {
 export function accountTurnForNudges(toolCalls: number, currentNudges: number): number {
   return toolCalls > 0 ? 0 : currentNudges + 1;
 }
+
+/**
+ * v0.27.3: the pure nudge detector and richer accounting. A supervising turn
+ * is a nudge (no real progress) iff it has NO tool calls AND its text is
+ * either short (< DEFAULT_STALL_SHORT_WORDS words) OR highly similar to
+ * the prior assistant turn (3-gram Jaccard > DEFAULT_STALL_SIM_THRESHOLD).
+ * Substantive analytical replies (≥ 15 words, novel) reset the counter
+ * even with no tool calls — the polis-session incident ("3 consecutive
+ * turns with no tool calls" tripped the brake on real investigation work,
+ * screenshot 2026-07-27) showed the simple tool-only check is too coarse.
+ *
+ * Word-count rather than char-count: "Working…" (1 word) is a nudge;
+ * "state-pump-dom.ts has zero references to hud." (8 words, one sentence)
+ * is not. A paragraph with at least one real sentence is > 15 words.
+ *
+ * Pure: no side effects, no state. Safe to unit-test with crafted inputs.
+ */
+export const DEFAULT_STALL_SHORT_WORDS = 15;
+export const DEFAULT_STALL_SIM_THRESHOLD = 0.6;
+
+export function trigramSimilarity(a: string, b: string): number {
+  if (!a && !b) return 1;
+  if (!a || !b) return 0;
+  const grams = (s: string) => {
+    const g = new Map<string, number>();
+    const t = s.toLowerCase();
+    for (let i = 0; i <= t.length - 3; i++) {
+      const k = t.slice(i, i + 3);
+      g.set(k, (g.get(k) ?? 0) + 1);
+    }
+    return g;
+  };
+  const ga = grams(a);
+  const gb = grams(b);
+  let inter = 0;
+  let uni = 0;
+  const keys = new Set([...ga.keys(), ...gb.keys()]);
+  for (const k of keys) {
+    const va = ga.get(k) ?? 0;
+    const vb = gb.get(k) ?? 0;
+    inter += Math.min(va, vb);
+    uni += Math.max(va, vb);
+  }
+  return uni === 0 ? 0 : inter / uni;
+}
+
+export function isNudgeTurn(opts: {
+  toolCalls: number;
+  text: string;
+  priorText: string;
+  shortWords?: number;
+  simThreshold?: number;
+}): boolean {
+  if (opts.toolCalls > 0) return false;
+  const shortThr = opts.shortWords ?? DEFAULT_STALL_SHORT_WORDS;
+  const simThr = opts.simThreshold ?? DEFAULT_STALL_SIM_THRESHOLD;
+  const wordCount = (opts.text.trim().match(/\S+/g) ?? []).length;
+  if (wordCount < shortThr) return true;
+  if (!opts.priorText) return false; // first turn in a streak — no similarity to compare to
+  return trigramSimilarity(opts.text, opts.priorText) > simThr;
+}
+
+export function accountTurnForNudgesRich(
+  opts: {
+    toolCalls: number;
+    text: string;
+    priorText: string;
+    shortWords?: number;
+    simThreshold?: number;
+  },
+  currentNudges: number,
+): number {
+  return isNudgeTurn(opts) ? currentNudges + 1 : 0;
+}

package/extensions/goal-settings.ts

@@ -52,6 +52,13 @@ export interface Settings {
   /** v0.26.1: consecutive heartbeat refires without a real turn before
    * the goal pauses / loop stops (default 5; 0 = never escalate). */
   stallEscalationRefires?: number;
+  /** v0.27.3: a turn with no tool calls AND fewer words than this is a
+   * nudge. Default 15 words. Higher = stricter (more pauses). */
+  stallShortWords?: number;
+  /** v0.27.3: a turn with no tool calls whose text trigram-similarity to
+   * the prior assistant turn exceeds this is a nudge. Default 0.6. Higher
+   * = stricter (more pauses). */
+  stallSimilarityThreshold?: number;
   /** on → propose_* drafts activate WITHOUT the Confirm dialog and the
    * interview floor is skipped — the seed carries the intent (unattended
    * rigs). Default off: nothing activates before the user confirms. */
@@ -131,6 +138,8 @@ export const SETTINGS_KEYS: Array<keyof Settings> = [
   "quotaRetryMinutes",
   "stuckMaxInterventions",
   "stallEscalationRefires",
+  "stallShortWords",
+  "stallSimilarityThreshold",
 ];
 
 /** Where each effective setting comes from (for the /glla display). */

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,
@@ -150,8 +156,10 @@ import {
   type LoopState,
 } from "../goal-loop-forever.js";
 import {
-  accountTurnForNudges,
+  accountTurnForNudgesRich,
   BACKOFF_IDLE_RETRY_MS,
+  DEFAULT_STALL_SIM_THRESHOLD,
+  DEFAULT_STALL_SHORT_WORDS,
   HEARTBEAT_INTERVAL_MS,
   HEARTBEAT_MAX_NUDGES,
   HEARTBEAT_STALL_MS,
@@ -527,6 +535,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.
@@ -2875,6 +2902,8 @@ async function openSettingsUI(ctx: ExtensionContext): Promise<void> {
       `Wedge alert minutes — ${show("wedgeAlertMinutes", `(${WEDGE_ALERT_DEFAULT_MINUTES})`)} — hung-command alert while the session is busy (0 = off)`,
       `Stuck max interventions — ${show("stuckMaxInterventions", "(5)")} — consecutive stuck interventions before a loop stops`,
       `Stall escalation refires — ${show("stallEscalationRefires", "(5)")} — heartbeat refires with no turn before the goal pauses / loop stops (0 = never)`,
+      `Stall short words — ${show("stallShortWords", `(${DEFAULT_STALL_SHORT_WORDS})`)} — turns with no tools AND fewer words than this count as a nudge`,
+      `Stall similarity threshold — ${show("stallSimilarityThreshold", `(${DEFAULT_STALL_SIM_THRESHOLD})`)} — no-tool turns whose text is > this similar to the prior turn count as a nudge (0–1)`,
       "── Subagents ──",
       `Subagent model strategy — ${show("subagentModelStrategy", "(inherit-parent)")} — inherit-parent shares your session model+quota; agent-default pins haiku for Explore`,
       `Subagent Explore pin — ${settings.subagentModelOverrides?.Explore ?? "(follows strategy)"} — provider/model pin; always wins over strategy`,
@@ -3214,6 +3243,8 @@ async function cmdSettings(args: string, ctx: ExtensionContext): Promise<void> {
         fmt("stuckMaxInterventions", "stuckMaxInterventions"),
         fmt("stallEscalationRefires", "stallEscalation"),
         fmt("wedgeAlertMinutes", "wedgeAlert"),
+        fmt("stallShortWords", "stallShortWords"),
+        fmt("stallSimilarityThreshold", "stallSimilarityThreshold"),
         // v0.25.6: effective per-type subagent model resolution.
         ...["Explore", "Plan", "general-purpose"].map(
           (t) => `subagent ${t}: ${resolveEffectiveSubagentModel(t, loadSettings(ctx.cwd), (ctx.model as any)?.id ? `${(ctx.model as any).provider}/${(ctx.model as any).id}` : undefined)}`,
@@ -3366,6 +3397,32 @@ async function cmdSettings(args: string, ctx: ExtensionContext): Promise<void> {
           ctx.ui.notify(`stuckmax must be a positive integer, got: ${value}`, "warning");
         }
       }
+    } else if (key === "stallshortwords" || key === "stallshort") {
+      if (["unset", "default"].includes(value)) {
+        patch.stallShortWords = undefined;
+        changed = true;
+      } else {
+        const n = Number.parseInt(value, 10);
+        if (Number.isInteger(n) && n >= 1) {
+          patch.stallShortWords = n;
+          changed = true;
+        } else {
+          ctx.ui.notify(`stallshortwords must be a positive integer, got: ${value}`, "warning");
+        }
+      }
+    } else if (key === "stallsim" || key === "stallsimilaritythreshold") {
+      if (["unset", "default"].includes(value)) {
+        patch.stallSimilarityThreshold = undefined;
+        changed = true;
+      } else {
+        const n = Number.parseFloat(value);
+        if (Number.isFinite(n) && n >= 0 && n <= 1) {
+          patch.stallSimilarityThreshold = n;
+          changed = true;
+        } else {
+          ctx.ui.notify(`stallsimilaritythreshold must be between 0 and 1, got: ${value}`, "warning");
+        }
+      }
     } else if (key === "thinking" || key === "auditorthinkinglevel") {
       if (["off", "minimal", "low", "medium", "high", "xhigh"].includes(value)) {
         patch.auditorThinkingLevel = value as Settings["auditorThinkingLevel"];
@@ -3463,6 +3520,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 +3836,29 @@ 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).
+    // v0.27.3: enrich lastA with text + priorText for the smarter nudge
+    // accounting below.
+    const assistants = (event.messages as any[]).filter((m: any) => m.role === "assistant");
+    const rawLastA = assistants.length ? assistants[assistants.length - 1] : null;
+    const rawPriorA = assistants.length >= 2 ? assistants[assistants.length - 2] : null;
+    const extractText = (m: any): string => (m && Array.isArray(m.content)) ? m.content.filter((p: any) => p.type === "text").map((p: any) => p.text).join("\n") : "";
+    const lastA = rawLastA ? { stopReason: rawLastA.stopReason, text: extractText(rawLastA), priorText: extractText(rawPriorA) } : null;
+    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 };
@@ -3789,27 +3870,34 @@ export default function (pi: ExtensionAPI): void {
       registeredCtx = ctx;
     }
     ensureAgentToolsActive(pi, ctx);
-    // Nudge accounting: a supervising turn with zero tool calls is a nudge
-    // (no real progress); 3 consecutive → pause. Tool-use turns reset it.
+    // v0.27.3: nudge accounting — substantive analytical turns (long, novel
+    // text) reset the counter even with no tool calls. Polis-session
+    // incident showed the tool-only check fired on real investigation work.
     if (isSupervising()) {
-      heartbeatNudges = accountTurnForNudges(toolCallsThisTurn, heartbeatNudges);
+      const s = loadSettings(ctx.cwd);
+      const shortWordsThr = s.stallShortWords ?? DEFAULT_STALL_SHORT_WORDS;
+      const simThr = s.stallSimilarityThreshold ?? DEFAULT_STALL_SIM_THRESHOLD;
+      heartbeatNudges = accountTurnForNudgesRich(
+        { toolCalls: toolCallsThisTurn, text: lastA?.text ?? "", priorText: lastA?.priorText ?? "", shortWords: shortWordsThr, simThreshold: simThr },
+        heartbeatNudges,
+      );
       if (heartbeatNudges >= HEARTBEAT_MAX_NUDGES) {
         heartbeatNudges = 0;
         if (isLoopActive()) {
           clearLoopTimer();
-          state.loop = { ...state.loop!, active: false, stopReason: `stalled: ${HEARTBEAT_MAX_NUDGES} consecutive turns with no tool calls` };
+          state.loop = { ...state.loop!, active: false, stopReason: `stalled: ${HEARTBEAT_MAX_NUDGES} consecutive unproductive turns (no tools, short or repetitive)` };
           persistState(ctx);
-          ctx.ui.notify(`Loop stopped: stalled (${HEARTBEAT_MAX_NUDGES} turns, no tools). /loop start to begin a new one.`, "warning");
+          ctx.ui.notify(`Loop stopped: stalled (${HEARTBEAT_MAX_NUDGES} unproductive turns). /loop start to begin a new one.`, "warning");
           notifyExternal(ctx, "Loop stopped: stalled (no tool calls).");
           return;
         }
         if (state.goal) {
           updateGoal({
             status: "paused",
-            pauseReason: `stalled: ${HEARTBEAT_MAX_NUDGES} consecutive turns with no tool calls`,
+            pauseReason: `stalled: ${HEARTBEAT_MAX_NUDGES} consecutive unproductive turns (no tools, short or repetitive)`,
             pauseSuggestedAction: "Inspect the goal — /goal resume to retry, /goal tweak to narrow it, /goal cancel to abort.",
           }, ctx);
-          ctx.ui.notify(`Goal paused: stalled (${HEARTBEAT_MAX_NUDGES} turns, no tools).`, "warning");
+          ctx.ui.notify(`Goal paused: stalled (${HEARTBEAT_MAX_NUDGES} unproductive turns).`, "warning");
           notifyExternal(ctx, "Goal paused: stalled (no tool calls).");
           return;
         }

package/package.json

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