pi-goal-list-loop-audit 0.23.8 → 0.24.1

package/README.md

@@ -57,6 +57,7 @@ matches `/list show`.
 /list next                         # skip current, activate next
 /list remove <n>                   # drop item n from the list
 /list clear                        # empty the list
+/list cancel                       # stop the whole list: abort the active item + drop all waiting
 /loop                              # draft the loop (agent grills; measure is test-run before you confirm)
 /loop start "keep polishing the UI"                          # infinite metricless loop (v0.23.6): no plateau, no cap — ends at time=/tokens= or /loop stop
 /loop start "reduce TODOs" measure="grep -c TODO src.txt | head -1" direction=min
@@ -77,6 +78,17 @@ inspectable change; cosmetic churn is the known failure mode
 number, and tells you the trade-off before you confirm. Work with a finish
 line is still a `/goal`.
 
+**Anti-repetition** (v0.24.0, both loop flavors): the plateau stop watches
+the *number*; the stuck ladder watches the *work*. Every iteration is
+classified — exact/near-duplicate replies, A-B-A-B alternation, same
+tool-same-result three times, narration-only streaks, degenerate
+single-reply repetition — and a stuck iteration swaps the next prompt for
+a rotating intervention (different approach → different subtask →
+PROGRESS.md → fix one test failure → review your own diff). Three stuck in
+a row escalates to a hard reset (banned openings, tool-call-first); five
+stops the loop with the reason — bounded and surfaced, like plateau.
+Continuation lines also rotate: identical prompts invite identical answers.
+
 Subcommands match **exactly** — `/goal pause the pipeline` sets an objective
 about a pipeline; only bare `/goal pause` pauses. (Same rule everywhere, so
 your objectives can start with any verb.)

package/extensions/goal-loop-forever.ts

@@ -58,6 +58,20 @@ export interface LoopState {
   branchName?: string;
   /** branch=1 mode: the branch to return to on stop. */
   originalBranch?: string;
+  /** v0.24.0 anti-repetition: rolling fingerprints of iteration replies. */
+  recentPrints?: string[];
+  /** v0.24.0: last few iteration texts (near-duplicate check + banned openings). */
+  recentTexts?: string[];
+  /** v0.24.0: rolling tool-result fingerprints {tool, hash, isError}. */
+  recentToolResults?: { tool: string; hash: string; isError: boolean }[];
+  /** v0.24.0: tool calls seen since the last completed iteration. */
+  toolsThisTurn?: number;
+  /** v0.24.0: consecutive iterations with zero tool calls. */
+  toollessStreak?: number;
+  /** v0.24.0: consecutive stuck interventions (resets on a clean iteration). */
+  consecutiveStuck?: number;
+  /** v0.24.0: the last stuck reason (for the intervention directive + ledger). */
+  lastStuckReason?: string;
 }
 
 /** Scratch-branch name for branch=1 mode. Format pinned by tests. */

package/extensions/goal-loop-repetition.ts

@@ -0,0 +1,253 @@
+/**
+ * Loop anti-repetition (v0.24.0) — pure, stateless detectors for the failure
+ * mode the plateau stop cannot see: the loop keeps "working" but the work is
+ * the SAME work. Plateau watches the number; this watches the behavior.
+ *
+ * Clean-room implementation of standard techniques (rolling text
+ * fingerprints, word-trigram Jaccard similarity, repeated-n-gram detection)
+ * for pi-loop-mode's AGPL-licensed repertoire — no code shared.
+ *
+ * Everything here is a pure function; LoopState holds the rolling windows and
+ * runLoopTick (loops/goal.ts) feeds them in. One mechanical predicate per
+ * behavior — no fuzzy heuristics.
+ */
+
+import { createHash } from "node:crypto";
+
+export const REPETITION = {
+  /** Jaccard similarity at which two consecutive iterations count as a near-duplicate. */
+  similarityThreshold: 0.8,
+  /** Minimum normalized length before exact/near-duplicate checks apply (short replies repeat innocently). */
+  minExactLength: 80,
+  minSimilarLength: 60,
+  /** Same fingerprint seen this often inside the rolling window = alternating repetition (A-B-A-B). */
+  windowRepeat: 3,
+  /** Rolling window sizes held on LoopState. */
+  printWindow: 12,
+  textWindow: 3,
+  toolWindow: 6,
+  /** Last N identical tool results (same tool, same output) = no new information. */
+  toolResultRepeat: 3,
+  /** Consecutive iterations with zero tool calls = narration only. */
+  toollessIterations: 2,
+  /** Degenerate single-response repetition (one sentence/word/phrase looping inside ONE reply). */
+  degenerateMinLength: 150,
+  degenerateSentenceRepeats: 4,
+  degenerateWordRepeats: 16,
+  degeneratePhraseRepeats: 8,
+  degenerateMaxPhraseWords: 4,
+  /** Escalation ladder: hard-reset directive after this many consecutive stuck turns… */
+  hardResetAfter: 3,
+  /** …and the loop STOPS after this many (bounded, surfaced — same philosophy as plateau). */
+  maxInterventions: 5,
+} as const;
+
+/** Strip ANSI, collapse whitespace, lowercase — the canonical form all checks use. */
+export function normalizeForPrint(text: string): string {
+  return text.replace(/\x1b\[[0-9;]*m/g, "").replace(/\s+/g, " ").trim().toLowerCase();
+}
+
+/** Stable short fingerprint of one reply's canonical form. */
+export function textFingerprint(text: string): string {
+  return createHash("sha256").update(normalizeForPrint(text).slice(0, 4000)).digest("hex").slice(0, 16);
+}
+
+/** Digits are volatile (counters, timestamps, PIDs) — blank them so "try port 8081" ≈ "try port 8082". */
+function canonical(text: string): string {
+  return normalizeForPrint(text).replace(/\d+/g, "#");
+}
+
+function wordTrigrams(text: string): Set<string> {
+  const words = canonical(text).split(" ").filter(Boolean);
+  const out = new Set<string>();
+  if (words.length < 3) {
+    if (words.length) out.add(words.join(" "));
+    return out;
+  }
+  for (let i = 0; i + 3 <= words.length; i++) out.add(`${words[i]} ${words[i + 1]} ${words[i + 2]}`);
+  return out;
+}
+
+/** Jaccard similarity over word trigrams: 0 = nothing shared, 1 = same shingle set. */
+export function trigramSimilarity(a: string, b: string): number {
+  const sa = wordTrigrams(a);
+  const sb = wordTrigrams(b);
+  if (sa.size === 0 || sb.size === 0) return 0;
+  let shared = 0;
+  for (const t of sa) if (sb.has(t)) shared++;
+  return shared / (sa.size + sb.size - shared);
+}
+
+export interface DegenerateRepeat {
+  kind: "sentence" | "word" | "phrase";
+  unit: string;
+  count: number;
+}
+
+function tokenRun(text: string): DegenerateRepeat | undefined {
+  const tokens = normalizeForPrint(text).match(/[\p{L}\p{N}_'-]+/gu) ?? [];
+  for (let width = 1; width <= REPETITION.degenerateMaxPhraseWords; width++) {
+    const needed = width === 1 ? REPETITION.degenerateWordRepeats : REPETITION.degeneratePhraseRepeats;
+    for (let start = 0; start + width * needed <= tokens.length; start++) {
+      let run = 1;
+      while (
+        start + (run + 1) * width <= tokens.length &&
+        tokens.slice(start, start + width).join("") === tokens.slice(start + run * width, start + (run + 1) * width).join("")
+      ) {
+        run++;
+      }
+      if (run >= needed) {
+        return { kind: width === 1 ? "word" : "phrase", unit: tokens.slice(start, start + width).join(" "), count: run };
+      }
+    }
+  }
+  return undefined;
+}
+
+/** One sentence/word/phrase looping inside a SINGLE response (degenerate generation). */
+export function findDegenerateRepeat(text: string): DegenerateRepeat | undefined {
+  const canon = canonical(text);
+  if (canon.length < REPETITION.degenerateMinLength) return undefined;
+  const sentences = canon
+    .split(/(?<=[.!?])\s+|\n+/)
+    .map((s) => s.trim())
+    .filter((s) => s.length >= 15);
+  if (sentences.length >= REPETITION.degenerateSentenceRepeats) {
+    const counts = new Map<string, number>();
+    for (const s of sentences) counts.set(s, (counts.get(s) ?? 0) + 1);
+    let unit = "";
+    let best = 0;
+    for (const [s, n] of counts) if (n > best) { unit = s; best = n; }
+    if (best >= REPETITION.degenerateSentenceRepeats && best / sentences.length >= 0.5) {
+      return { kind: "sentence", unit, count: best };
+    }
+  }
+  return tokenRun(text);
+}
+
+export interface ToolResultPrint {
+  tool: string;
+  hash: string;
+  isError: boolean;
+}
+
+export interface LoopStuckInput {
+  /** Last assistant text of the finished iteration. */
+  assistantText: string;
+  /** Rolling fingerprints INCLUDING the current iteration's (appended last). */
+  recentPrints: string[];
+  /** Previous iteration's assistant text (for the near-duplicate check). */
+  previousText?: string;
+  /** Rolling tool-result prints (most recent last). */
+  recentToolResults: ToolResultPrint[];
+  /** Consecutive iterations with zero tool calls, including this one. */
+  toollessStreak: number;
+}
+
+function clip(text: string, n: number): string {
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length <= n ? flat : `${flat.slice(0, n)}…`;
+}
+
+/**
+ * The one classifier: given the rolling windows, WHY is the loop stuck —
+ * or undefined when it's working normally. Checks run cheapest-and-most-
+ * certain first; the first hit wins so the reason stays specific.
+ */
+export function detectLoopStuck(input: LoopStuckInput): string | undefined {
+  const { assistantText, recentPrints, previousText, recentToolResults, toollessStreak } = input;
+
+  // Narration only: iterations that never touch tools produce nothing inspectable.
+  if (toollessStreak >= REPETITION.toollessIterations) {
+    return `no tool calls for ${toollessStreak} iterations (narration only)`;
+  }
+
+  // Degenerate generation inside the current response.
+  const degenerate = findDegenerateRepeat(assistantText);
+  if (degenerate) {
+    return `response degenerated: same ${degenerate.kind} repeated ${degenerate.count}× ("${clip(degenerate.unit, 60)}")`;
+  }
+
+  // Exact repeat of the immediately previous iteration.
+  const lastTwo = recentPrints.slice(-2);
+  if (lastTwo.length === 2 && lastTwo[0] === lastTwo[1] && normalizeForPrint(assistantText).length > REPETITION.minExactLength) {
+    return "repeated the previous response exactly";
+  }
+
+  // Near-duplicate of the previous iteration (slight rephrasing defeats fingerprints).
+  if (previousText && normalizeForPrint(assistantText).length > REPETITION.minSimilarLength) {
+    const sim = trigramSimilarity(assistantText, previousText);
+    if (sim >= REPETITION.similarityThreshold) {
+      return `response ~${Math.round(sim * 100)}% similar to the previous iteration`;
+    }
+  }
+
+  // Alternating repetition (A-B-A-B): the current fingerprint keeps recurring in the window.
+  const current = recentPrints[recentPrints.length - 1];
+  if (current && recentPrints.filter((p) => p === current).length >= REPETITION.windowRepeat) {
+    return `same response ${REPETITION.windowRepeat}+ times in recent iterations`;
+  }
+
+  // Same tool, same output, three times running: the loop is re-reading a result it already has.
+  const recentTools = recentToolResults.slice(-REPETITION.toolResultRepeat);
+  if (
+    recentTools.length === REPETITION.toolResultRepeat &&
+    recentTools.every((r) => r.tool === recentTools[0]!.tool && r.hash === recentTools[0]!.hash)
+  ) {
+    return recentTools.every((r) => r.isError)
+      ? `same ${recentTools[0]!.tool} error ${REPETITION.toolResultRepeat}× in a row`
+      : `same ${recentTools[0]!.tool} result ${REPETITION.toolResultRepeat}× in a row (no new information)`;
+  }
+
+  return undefined;
+}
+
+/**
+ * Rotating stuck interventions — a repeated identical nudge gets filtered as
+ * noise, so each consecutive stuck turn gets a DIFFERENT instruction.
+ * consecutiveStuck is 1-based (1 = first intervention).
+ */
+export function loopInterventionDirective(consecutiveStuck: number, reason: string, recentTexts: string[]): string {
+  const strategies = [
+    "Abandon the current angle entirely. Pick a genuinely different approach — different file, different technique — and execute it now.",
+    "Switch to a part of the target you have NOT touched in recent iterations and make one concrete, inspectable change there.",
+    "Write a short PROGRESS.md: current state, what was tried, what keeps failing, the next 3 concrete steps. Then execute step 1.",
+    "Run the project's build/tests, pick exactly ONE failure or warning, and fix only that.",
+    "Review your recent changes (git diff / git log), find one real problem in them, and fix it.",
+  ];
+  const strategy = strategies[(consecutiveStuck - 1) % strategies.length]!;
+  let escalation = "";
+  if (consecutiveStuck >= REPETITION.hardResetAfter) {
+    const banned = recentTexts
+      .map((t) => clip(normalizeForPrint(t), 40))
+      .filter(Boolean)
+      .map((t) => `"${t}"`)
+      .join(", ");
+    escalation =
+      ` HARD RESET (stuck intervention #${consecutiveStuck} in a row): forget your previous phrasing entirely.` +
+      (banned ? ` Banned openings: ${banned}.` : "") +
+      " Your FIRST action this turn must be a tool call that changes a file or produces new information — zero preamble text before it.";
+  }
+  return `⚠ STUCK — ${reason}.${escalation} ${strategy}`;
+}
+
+/**
+ * Varied continuation lines for metricless iterations: identical prompts
+ * invite identical answers, so the base instruction rotates by iteration.
+ */
+export function continueVariant(iteration: number): string {
+  const variants = [
+    "Advance the target with the next concrete, inspectable change.",
+    "Continue: pick the next unit of work from your plan and do it now.",
+    "Keep going — one real change that moves the target forward.",
+    "Proceed with the next focused step toward the target.",
+    "Make the next improvement; something you can point at in a diff.",
+  ];
+  return variants[iteration % variants.length]!;
+}
+
+/** Cap helper for the rolling windows on LoopState. */
+export function pushCapped<T>(arr: T[], item: T, cap: number): T[] {
+  const next = [...arr, item];
+  return next.length > cap ? next.slice(next.length - cap) : next;
+}

package/extensions/loops/goal.ts

@@ -64,6 +64,14 @@ import {
   writeGoalMd,
 } from "../goal-loop-core.js";
 import { runGoalCompletionAuditor } from "../goal-loop-auditor.js";
+import {
+  REPETITION,
+  detectLoopStuck,
+  loopInterventionDirective,
+  continueVariant,
+  textFingerprint,
+  pushCapped as pushRepetitionCapped,
+} from "../goal-loop-repetition.js";
 import { buildStatusText, buildWidgetLines, type AuditDisplayProgress } from "../goal-loop-display.js";
 import {
   applyMeasurement,
@@ -841,7 +849,32 @@ async function cmdList(args: string, ctx: ExtensionContext): Promise<void> {
     state = { ...state, list: [] };
     persistState(ctx);
     appendLedger(ctx.cwd, "list_cleared", {});
-    ctx.ui.notify("List cleared. Active goal (if any) is untouched — /goal cancel for that.", "info");
+    ctx.ui.notify("List cleared. Active goal (if any) is untouched — /goal cancel for that, /list cancel to stop the whole list.", "info");
+    return;
+  }
+
+  // v0.24.1: ONE verb for "stop this whole list" — aborts the active item
+  // when it's list-sourced AND drops the waiting items. Before this the user
+  // had to know to combine /goal cancel + /list clear.
+  if (sub === "cancel") {
+    const waiting = listQueue().length;
+    const activeIsListItem = state.goal?.policy === "list" && (state.goal.status === "active" || state.goal.status === "paused");
+    if (waiting === 0 && !activeIsListItem) {
+      ctx.ui.notify("No list to cancel — nothing waiting, and the active goal (if any) isn't a list item. /goal cancel aborts a standalone goal.", "info");
+      return;
+    }
+    const dropped = waiting;
+    state = { ...state, list: [] };
+    persistState(ctx);
+    if (activeIsListItem) {
+      archiveCurrentGoal(ctx, "aborted", "list cancelled");
+      ctx.abort();
+    }
+    appendLedger(ctx.cwd, "list_cancelled", { abortedActive: activeIsListItem, dropped });
+    ctx.ui.notify(
+      `List cancelled: ${activeIsListItem ? "active item aborted + " : ""}${dropped} waiting item(s) dropped.${!activeIsListItem && state.goal && state.goal.status === "active" ? " Active goal is not a list item — untouched (/goal cancel for that)." : ""}`,
+      "info",
+    );
     return;
   }
 
@@ -982,7 +1015,7 @@ async function runGit(ctx: ExtensionContext, args: string[]): Promise<{ ok: bool
   }
 }
 
-function loopPrompt(loop: LoopState, regressionNote: string, strategyNote: string, boundsNote: string): string {
+function loopPrompt(loop: LoopState, regressionNote: string, strategyNote: string, boundsNote: string, interventionNote = "", variantNote = ""): string {
   // v0.23.0: metricless loops get their own prompt — no metric section,
   // anti-doorknob rules instead of anti-gaming rules.
   const metricless = !loop.measureCmd;
@@ -992,8 +1025,8 @@ function loopPrompt(loop: LoopState, regressionNote: string, strategyNote: strin
     tmpl = fs.readFileSync(tmplPath, "utf-8");
   } catch {
     tmpl = metricless
-      ? `[LOOP ITERATION ${loop.iteration + 1}] Target: ${loop.target}. Metricless spec loop — make ONE real, inspectable change advancing the target. No cosmetic churn.`
-      : `[LOOP ITERATION ${loop.iteration + 1}] Target: ${loop.target}. Measure: ${loop.measureCmd} (${loop.direction}). Make ONE small change to improve the metric.`;
+      ? `[LOOP ITERATION ${loop.iteration + 1}] Target: ${loop.target}. Metricless spec loop — make ONE real, inspectable change advancing the target. No cosmetic churn. ${variantNote} ${interventionNote}`
+      : `[LOOP ITERATION ${loop.iteration + 1}] Target: ${loop.target}. Measure: ${loop.measureCmd} (${loop.direction}). Make ONE small change to improve the metric. ${interventionNote}`;
   }
   return tmpl
     .replace(/\$\{ITERATION\}/g, String(loop.iteration + 1))
@@ -1007,7 +1040,9 @@ function loopPrompt(loop: LoopState, regressionNote: string, strategyNote: strin
     .replace(/\$\{PLATEAU_WINDOW\}/g, String(loop.plateauWindow))
     .replace(/\$\{REGRESSION_NOTE\}/g, regressionNote)
     .replace(/\$\{STRATEGY_NOTE\}/g, strategyNote)
-    .replace(/\$\{BOUNDS_NOTE\}/g, boundsNote);
+    .replace(/\$\{BOUNDS_NOTE\}/g, boundsNote)
+    .replace(/\$\{INTERVENTION_NOTE\}/g, interventionNote)
+    .replace(/\$\{VARIANT_NOTE\}/g, variantNote);
 }
 
 function scheduleLoopTick(ctx: ExtensionContext): void {
@@ -1060,10 +1095,18 @@ function sendLoopTurn(): void {
   } else if (bounds.length) {
     boundsNote = `\n- Arbitrary bounds: the loop also stops after ${bounds.join(" or ")}`;
   }
+  // v0.24.0: a stuck intervention REPLACES the pep talk — the rotating
+  // directive names why the loop is stuck and what rung of the ladder it's on.
+  const interventionNote = (loop.consecutiveStuck ?? 0) > 0 && loop.lastStuckReason
+    ? loopInterventionDirective(loop.consecutiveStuck!, loop.lastStuckReason, loop.recentTexts ?? [])
+    : "";
+  // v0.24.0: identical prompts invite identical answers — rotate the base
+  // instruction (metricless loops; metric loops already vary via values).
+  const variantNote = metricless ? continueVariant(loop.iteration) : "";
   try {
     extensionApi.sendMessage({
       customType: GOAL_EVENT_ENTRY,
-      content: loopPrompt(loop, regressionNote, strategyNote, boundsNote),
+      content: loopPrompt(loop, regressionNote, strategyNote, boundsNote, interventionNote, variantNote),
       display: false,
     }, { triggerTurn: true, deliverAs: "followUp" });
   } catch {
@@ -1083,10 +1126,40 @@ async function runLoopTick(ctx: ExtensionContext, event?: any): Promise<void> {
   // Hypothesis line (pi-autoresearch's good idea): the agent's stated intent
   // for the turn goes into the ledger, making loop history auditable.
   let hypothesis: string | undefined;
+  let lastAssistantText = "";
   if (event) {
     const last = [...(event.messages as any[])].reverse().find((m) => m.role === "assistant");
-    const text = last && Array.isArray(last.content) ? last.content.filter((p: any) => p.type === "text").map((p: any) => p.text).join("\n") : "";
-    hypothesis = text.match(/^HYPOTHESIS:\s*(.+)$/m)?.[1]?.trim().slice(0, 200);
+    lastAssistantText = last && Array.isArray(last.content) ? last.content.filter((p: any) => p.type === "text").map((p: any) => p.text).join("\n") : "";
+    hypothesis = lastAssistantText.match(/^HYPOTHESIS:\s*(.+)$/m)?.[1]?.trim().slice(0, 200);
+  }
+  // v0.24.0 anti-repetition: roll the behavior windows, then classify. The
+  // plateau stop watches the NUMBER; this watches the WORK — a metricless
+  // loop (no number) has no other defense against doorknob-polishing.
+  const toolsUsed = loop.toolsThisTurn ?? 0;
+  loop.toolsThisTurn = 0;
+  loop.toollessStreak = toolsUsed === 0 ? (loop.toollessStreak ?? 0) + 1 : 0;
+  const previousText = loop.recentTexts && loop.recentTexts.length > 0 ? loop.recentTexts[loop.recentTexts.length - 1] : undefined;
+  if (lastAssistantText) {
+    loop.recentPrints = pushRepetitionCapped(loop.recentPrints ?? [], textFingerprint(lastAssistantText), REPETITION.printWindow);
+    loop.recentTexts = pushRepetitionCapped(loop.recentTexts ?? [], lastAssistantText, REPETITION.textWindow);
+  }
+  const stuckReason = detectLoopStuck({
+    assistantText: lastAssistantText,
+    recentPrints: loop.recentPrints ?? [],
+    previousText,
+    recentToolResults: loop.recentToolResults ?? [],
+    toollessStreak: loop.toollessStreak ?? 0,
+  });
+  if (stuckReason) {
+    loop.consecutiveStuck = (loop.consecutiveStuck ?? 0) + 1;
+    loop.lastStuckReason = stuckReason;
+    appendLedger(ctx.cwd, "loop_stuck", { iteration: loop.iteration, reason: stuckReason, consecutive: loop.consecutiveStuck });
+    if (loop.consecutiveStuck === 1 || loop.consecutiveStuck >= REPETITION.hardResetAfter) {
+      ctx.ui.notify(`Loop stuck (${loop.consecutiveStuck}×): ${stuckReason}`, "warning");
+    }
+  } else {
+    loop.consecutiveStuck = 0;
+    loop.lastStuckReason = undefined;
   }
   const outcome = metricless ? applyMetriclessTick(loop, nowIso()) : applyMeasurement(loop, value, nowIso());
   persistState(ctx);
@@ -1096,6 +1169,7 @@ async function runLoopTick(ctx: ExtensionContext, event?: any): Promise<void> {
     best: loop.bestValue,
     stall: loop.stallCount,
     hypothesis,
+    stuck: stuckReason,
   });
   // branch=1 mode: commit improvements, hard-reset regressions — always and
   // only on the scratch branch. v0.23.0: a metricless loop has no regression
@@ -1111,6 +1185,18 @@ async function runLoopTick(ctx: ExtensionContext, event?: any): Promise<void> {
     }
     persistState(ctx);
   }
+  // v0.24.0: the top of the stuck ladder — bounded and surfaced, same
+  // philosophy as a plateau stop. The loop ends WITH the reason, not in silence.
+  if (outcome.kind !== "stop" && (loop.consecutiveStuck ?? 0) >= REPETITION.maxInterventions) {
+    loop.active = false;
+    loop.stopReason = `stuck — ${loop.lastStuckReason} (${loop.consecutiveStuck} consecutive interventions)`;
+    persistState(ctx);
+    await finishLoopGit(ctx, loop);
+    ctx.ui.notify(`Loop stopped: ${loop.stopReason}. ${loop.history.length} iterations recorded.`, "warning");
+    appendLedger(ctx.cwd, "loop_stopped", { reason: loop.stopReason, iterations: loop.iteration, best: loop.bestValue });
+    notifyExternal(ctx, `Loop stopped: ${loop.stopReason}`);
+    return;
+  }
   if (outcome.kind === "stop") {
     await finishLoopGit(ctx, loop);
     ctx.ui.notify(`Loop stopped: ${outcome.reason}. ${loop.history.length} iterations recorded.`, "info");
@@ -2488,13 +2574,14 @@ export default function (pi: ExtensionAPI): void {
     handler: settingsHandler,
   });
   pi.registerCommand("list", {
-    description: "Loop 2: the list of audited goals — order is the default, not the law. /list <describe tasks or name a plan file> (dumps get shaped into items, files import, 'Done when:' adds directly) | /list show | /list resume | /list next [n] | /list remove <n> | /list clear",
+    description: "Loop 2: the list of audited goals — order is the default, not the law. /list <describe tasks or name a plan file> (dumps get shaped into items, files import, 'Done when:' adds directly) | /list show | /list resume | /list next [n] | /list remove <n> | /list clear | /list cancel",
     getArgumentCompletions: completions([
       ["show", "display the waiting items"],
       ["resume", "resume the paused list item (the list's head)"],
       ["next", "activate the next item (or /list next <n> for position n)"],
       ["remove", "remove an item: /list remove <n>"],
       ["clear", "empty the list"],
+      ["cancel", "stop the whole list: abort the active item + drop all waiting"],
     ]),
     handler: (args: string, ctx: ExtensionContext) => { rememberCtx(ctx); return cmdList(args, ctx); },
   });
@@ -2528,6 +2615,18 @@ export default function (pi: ExtensionAPI): void {
   // v0.15.1: ask_user_question answers arrive as tool results, not chat
   // messages — count answered (non-cancelled) questionnaires as replies too.
   pi.on("tool_result", async (event: any) => {
+    // v0.24.0: roll loop tool-result fingerprints (same-tool-same-result
+    // detection) — recorded for ANY tool result while a loop is active.
+    if (isLoopActive()) {
+      const loop = state.loop!;
+      const out = event?.output ?? event?.result ?? event?.details ?? "";
+      const text = typeof out === "string" ? out : JSON.stringify(out) ?? "";
+      loop.recentToolResults = pushRepetitionCapped(
+        loop.recentToolResults ?? [],
+        { tool: String(event?.toolName ?? "?"), hash: textFingerprint(text), isError: Boolean(event?.isError ?? event?.error) },
+        REPETITION.toolWindow,
+      );
+    }
     if (draftingTarget === null) return;
     if (askUserQuestionAnswered(String(event?.toolName ?? ""), event?.details)) {
       draftingUserReplies++;
@@ -2715,5 +2814,9 @@ export default function (pi: ExtensionAPI): void {
   pi.on("tool_call", () => {
     toolCallsThisTurn++;
     noteActivity();
+    // v0.24.0: count loop-iteration tool calls (narration-only detection).
+    if (isLoopActive()) {
+      state.loop!.toolsThisTurn = (state.loop!.toolsThisTurn ?? 0) + 1;
+    }
   });
 }

package/package.json

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

package/prompts/goal-loop-forever-metricless.md

@@ -16,10 +16,13 @@ ${TARGET}
 
 ## Your job THIS turn
 
+${VARIANT_NOTE}
+
 Start your reply with exactly one line: `HYPOTHESIS: <what you will change and why it is real progress on the spec>`.
 Then make **ONE** concrete, inspectable change that advances the target.
 Then stop.
 
+${INTERVENTION_NOTE}
 ${REGRESSION_NOTE}
 ${STRATEGY_NOTE}
 

package/prompts/goal-loop-forever.md

@@ -26,6 +26,7 @@ Start your reply with exactly one line: `HYPOTHESIS: <what you will change and w
 Then make **ONE** small, concrete change that moves the metric in the right
 direction. Then stop.
 
+${INTERVENTION_NOTE}
 ${REGRESSION_NOTE}
 ${STRATEGY_NOTE}