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

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/loops/goal.ts

@@ -156,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,
@@ -2900,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`,
@@ -3239,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)}`,
@@ -3391,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"];
@@ -3497,10 +3529,21 @@ export default function (pi: ExtensionAPI): void {
   //   /loop  — the metric loop (draft|start|status|stop)
   //   /glla   — the settings UI (+ scriptable key=value)
   // v0.22.5: subcommand autocomplete for the /-menu.
+  // v0.27.4: pi's applyCompletion does NOT add a trailing space for argument
+  // completions (it does for the top-level /goal itself). Without a trailing
+  // space the user has to press Space before typing — and if they forget
+  // they end up with `/goal startasdahlasf` (goal.ts:3545 area). Items whose
+  // value ends in `=` (key=value pairs — the user types the value right
+  // after the `=`) get no space; everything else gets a single trailing
+  // space. `label` stays clean for the picker display.
   const completions = (items: Array<[string, string]>) => (prefix: string) =>
     items
       .filter(([value]) => value.startsWith(prefix))
-      .map(([value, description]) => ({ value, label: value, description }));
+      .map(([value, description]) => ({
+        value: value.endsWith("=") ? value : value + " ",
+        label: value,
+        description,
+      }));
 
   pi.registerCommand("goal", {
     description: "Set/draft a goal, or /goal status|pause|resume|cancel|tweak <text>|archive|start <objective>. Objectives without a 'Done when:' clause are grilled into a contract first; include the clause or use /goal start to skip the interview and activate instantly.",
@@ -3811,7 +3854,13 @@ export default function (pi: ExtensionAPI): void {
     // 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");
+    // 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");
@@ -3832,27 +3881,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.2",
+  "version": "0.27.4",
   "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",