pi-goal-list-loop-audit 0.25.0 → 0.25.1

package/extensions/goal-loop-auditor.ts

@@ -107,7 +107,11 @@ function buildGoalAuditorPrompt(goal: Goal, completionSummary: string | null | u
     "Use read/grep/find/ls/bash as needed to inspect real artifacts. Do not mutate files or run destructive commands.",
     "If the work is only an alpha scaffold, generated template, shallow draft, proxy milestone, or lacks the user-facing value requested, disapprove.",
     "If any explicit requirement is missing, weakly verified, contradicted, or not inspectable with the available evidence, disapprove.",
-    "Objective shift: if the executor's <completion_summary> explicitly states that the work has shifted to other items (different from the original <goal> objective), and the shift is justified — e.g. the original objective was blocked, the agent pivoted to higher-ROI items, and the new items are independently verified — accept the shift as evidence of reasonable engineering judgment. Do NOT rigidly disapprove because the original objective is not literally shipped; audit the shifted work on its merits and say so in the report.",
+    "Objective shift: if the executor's <completion_summary> explicitly states that the work has shifted to other items",
+    "(different from the original <goal> objective), and the shift is justified — e.g. the original objective was blocked,",
+    "the agent pivoted to higher-ROI items, and the new items are independently verified — accept the shift as evidence",
+    "of reasonable engineering judgment. Do NOT rigidly disapprove because the original objective is not literally shipped;",
+    "audit the shifted work on its merits and say so in the report.",
     "Return a concise audit report. The final line MUST be exactly one of:",
     "<approved/>",
     "<disapproved/>",

package/extensions/goal-loop-forever.ts

@@ -75,6 +75,33 @@ export interface LoopState {
   consecutiveStuck?: number;
   /** v0.24.0: the last stuck reason (for the intervention directive + ledger). */
   lastStuckReason?: string;
+  /** v0.25.1: /loop start toolsamerepeat=N — legacy same-tool-same-result
+   * check window. 0 disables it (multi-signal detector only). */
+  toolSameRepeat?: number;
+  /** v0.25.1: per-iteration progress-signal accumulators for the
+   * multi-signal stuck gate. fileWrites bumps on write/edit tool results;
+   * iterationStartHead/At snapshot when the iteration BEGAN so the tick can
+   * count commits and spec_item_progress events produced during it. */
+  iterMetrics?: {
+    fileWrites: number;
+    iterationStartHead?: string;
+    iterationStartAt?: string;
+  };
+}
+
+/** v0.25.1: stop reason for /loop finish — a clean "completed" end,
+ * distinct from stuck/plateau/stopped-by-user. */
+export function loopFinishStopReason(reason?: string): string {
+  const r = (reason ?? "").trim();
+  return `completed: ${r || "finished by user"}`;
+}
+
+/** v0.25.1: tool names that count as file-write progress signals for the
+ * multi-signal stuck gate (item 3). */
+export const LOOP_WRITE_TOOLS = ["write", "edit", "multi_edit", "write_file"] as const;
+
+export function isLoopWriteTool(toolName: string): boolean {
+  return (LOOP_WRITE_TOOLS as readonly string[]).includes(toolName);
 }
 
 /** Scratch-branch name for branch=1 mode. Format pinned by tests. */
@@ -229,6 +256,7 @@ export function parseLoopStartArgs(raw: string): {
   force: boolean;
   timeLimitHours?: number;
   tokenBudget?: number;
+  toolSameRepeat?: number;
 } {
   // Key=value pairs first (measure= and direction= may hold quoted values),
   // the remaining text is the target.
@@ -294,6 +322,12 @@ export function parseLoopStartArgs(raw: string): {
     force: forceRaw === "1" || forceRaw === "true" || forceRaw === "yes",
     timeLimitHours: Number.isFinite(timeRaw) && timeRaw > 0 ? timeRaw : undefined,
     tokenBudget: Number.isFinite(tokensRaw) && tokensRaw > 0 ? tokensRaw : undefined,
+    toolSameRepeat: (() => {
+      const raw = (kv.get("toolsamerepeat") ?? "").trim();
+      if (!raw) return undefined;
+      const n = Number.parseInt(raw, 10);
+      return Number.isInteger(n) && n >= 0 ? n : undefined;
+    })(),
   };
 }
 

package/extensions/goal-loop-repetition.ts

@@ -142,6 +142,59 @@ export interface LoopStuckInput {
   recentToolResults: ToolResultPrint[];
   /** Consecutive iterations with zero tool calls, including this one. */
   toollessStreak: number;
+  /** v0.25.1 progress signals (multi-signal stuck model): file writes,
+   * git commits, and spec_item_progress events in the FINISHED iteration.
+   * Optional for backward compat — absent = 0. */
+  fileWriteCount?: number;
+  gitCommitCount?: number;
+  specItemProgressCount?: number;
+}
+
+/**
+ * v0.25.1: forward-transition marker — the agent explicitly declares it is
+ * moving on ("Next step (iter-222, implement branch)"). Conservative word
+ * list: if the agent isn't saying "moving on", it's probably spinning.
+ */
+export function forwardTransitionMarker(text: string): boolean {
+  if (
+    /\b(next|next step|next phantom|next iter|iter[ -]\d+|pivot|moving on|implement next|switch to|now (do|implement|fix|add)|then (do|implement|fix|add))\b/i.test(
+      text,
+    )
+  ) {
+    return true;
+  }
+  // Line-start "Next:" / "Next step" — the phrasing the wild-caught
+  // transcripts used.
+  return /^\s*next\s*(step)?\s*:/im.test(text);
+}
+
+/** A forward marker only counts PAIRED with a real write/commit in the
+ * same iteration — pure narration ("next: implement X" × N, shipping
+ * nothing) is the narrate-but-don't-ship loop and IS stuck. */
+export function forwardTransitionPaired(input: LoopStuckInput): boolean {
+  if (!forwardTransitionMarker(input.assistantText)) return false;
+  return (input.fileWriteCount ?? 0) > 0 || (input.gitCommitCount ?? 0) > 0;
+}
+
+/**
+ * v0.25.1 multi-signal stuck gate (progress-signals model): an iteration
+ * is stuck ONLY when every progress signal is zero — file writes, git
+ * commits, spec_item_progress events, and a PAIRED forward transition —
+ * AND the legacy single-signal detector also fires. Stable verification
+ * output from a loop that is still shipping is the GOAL state of a
+ * metricless loop, not the stuck state (the two wild-caught transcripts
+ * that motivated this rework both died in exactly that false positive).
+ *
+ * `toolSameRepeat` (the /loop start toolsamerepeat=N kwarg) forwards to
+ * the legacy check: 0 disables the same-tool-same-result branch entirely
+ * (new detector only), undefined = REPETITION.toolResultRepeat.
+ */
+export function isActuallyStuck(input: LoopStuckInput, toolSameRepeat?: number): string | undefined {
+  if ((input.fileWriteCount ?? 0) > 0) return undefined;
+  if ((input.gitCommitCount ?? 0) > 0) return undefined;
+  if ((input.specItemProgressCount ?? 0) > 0) return undefined;
+  if (forwardTransitionPaired(input)) return undefined;
+  return detectLoopStuck(input, toolSameRepeat);
 }
 
 function clip(text: string, n: number): string {
@@ -154,7 +207,7 @@ function clip(text: string, n: number): string {
  * 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 {
+export function detectLoopStuck(input: LoopStuckInput, toolResultRepeatOverride?: number): string | undefined {
   const { assistantText, recentPrints, previousText, recentToolResults, toollessStreak } = input;
 
   // Narration only: iterations that never touch tools produce nothing inspectable.
@@ -189,14 +242,17 @@ export function detectLoopStuck(input: LoopStuckInput): string | undefined {
   }
 
   // Same tool, same output, three times running: the loop is re-reading a result it already has.
-  const recentTools = recentToolResults.slice(-REPETITION.toolResultRepeat);
+  // v0.25.1: toolsamerepeat=0 disables this branch entirely (new detector only).
+  const toolResultRepeat = toolResultRepeatOverride ?? REPETITION.toolResultRepeat;
+  const recentTools = toolResultRepeat > 0 ? recentToolResults.slice(-toolResultRepeat) : [];
   if (
-    recentTools.length === REPETITION.toolResultRepeat &&
+    toolResultRepeat > 0 &&
+    recentTools.length === 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)`;
+      ? `same ${recentTools[0]!.tool} error ${toolResultRepeat}× in a row`
+      : `same ${recentTools[0]!.tool} result ${toolResultRepeat}× in a row (no new information)`;
   }
 
   return undefined;

package/extensions/loops/goal.ts

@@ -93,7 +93,7 @@ import {
 import { runGoalCompletionAuditor } from "../goal-loop-auditor.js";
 import {
   REPETITION,
-  detectLoopStuck,
+  isActuallyStuck,
   loopInterventionDirective,
   continueVariant,
   textFingerprint,
@@ -111,6 +111,8 @@ import {
   applyRefinement,
   loopBranchName,
   parseLoopStartArgs,
+  loopFinishStopReason,
+  isLoopWriteTool,
   parseMetric,
   LOOP_DEFAULTS,
   resolveSpecFiles,
@@ -1204,18 +1206,63 @@ async function runLoopTick(ctx: ExtensionContext, event?: any): Promise<void> {
   const toolsUsed = loop.toolsThisTurn ?? 0;
   loop.toolsThisTurn = 0;
   loop.toollessStreak = toolsUsed === 0 ? (loop.toollessStreak ?? 0) + 1 : 0;
+  // v0.25.1 multi-signal stuck gate: gather the iteration's progress
+  // signals BEFORE classifying — file writes (tool_result bumps), git
+  // commits since the iteration began (HEAD advance), spec_item_progress
+  // ledger events since the iteration began. ANY positive signal exempts
+  // the iteration: stable verification from a shipping loop is the goal
+  // state of a metricless loop, not the stuck state.
+  const iterStartHead = loop.iterMetrics?.iterationStartHead;
+  const iterStartAt = loop.iterMetrics?.iterationStartAt;
+  const currentHeadRes = await runGit(ctx, ["rev-parse", "HEAD"]);
+  const currentHead = currentHeadRes.ok ? currentHeadRes.stdout : undefined;
+  let gitCommits = 0;
+  if (iterStartHead && currentHead && iterStartHead !== currentHead) {
+    const countRes = await runGit(ctx, ["rev-list", "--count", `${iterStartHead}..HEAD`]);
+    const n = Number.parseInt(countRes.stdout, 10);
+    if (countRes.ok && Number.isFinite(n) && n > 0) gitCommits = n;
+  }
+  let specItemProgress = 0;
+  if (iterStartAt) {
+    try {
+      const ledgerPath = path.join(ctx.cwd, ".pi-glla", "active.jsonl");
+      const lines = fs.readFileSync(ledgerPath, "utf-8").split("\n");
+      for (const line of lines) {
+        if (!line.includes("spec_item_progress")) continue;
+        try {
+          const entry = JSON.parse(line) as { at?: string };
+          if (entry.at && entry.at >= iterStartAt) specItemProgress++;
+        } catch { /* malformed line */ }
+      }
+    } catch { /* no ledger yet */ }
+  }
+  const iterSignals = {
+    fileWrites: loop.iterMetrics?.fileWrites ?? 0,
+    gitCommits,
+    specItemProgress,
+    currentHead,
+  };
   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({
+  const stuckReason = isActuallyStuck({
     assistantText: lastAssistantText,
     recentPrints: loop.recentPrints ?? [],
     previousText,
     recentToolResults: loop.recentToolResults ?? [],
     toollessStreak: loop.toollessStreak ?? 0,
-  });
+    fileWriteCount: iterSignals.fileWrites,
+    gitCommitCount: iterSignals.gitCommits,
+    specItemProgressCount: iterSignals.specItemProgress,
+  }, loop.toolSameRepeat);
+  // Reset the accumulators so the NEXT iteration measures only itself.
+  loop.iterMetrics = {
+    fileWrites: 0,
+    iterationStartHead: iterSignals.currentHead ?? loop.iterMetrics?.iterationStartHead,
+    iterationStartAt: nowIso(),
+  };
   if (stuckReason) {
     loop.consecutiveStuck = (loop.consecutiveStuck ?? 0) + 1;
     loop.lastStuckReason = stuckReason;
@@ -1302,6 +1349,8 @@ interface LoopConfig {
   force?: boolean;
   timeLimitHours?: number;
   tokenBudget?: number;
+  /** v0.25.1: /loop start toolsamerepeat=N (0 = disable legacy check). */
+  toolSameRepeat?: number;
 }
 
 /** Shared loop-start path: /loop start AND propose_loop_draft (after Confirm). */
@@ -1365,6 +1414,8 @@ async function startLoopFromConfig(ctx: ExtensionContext, cfg: LoopConfig): Prom
       tokensUsed: 0,
       branchName,
       originalBranch,
+      toolSameRepeat: cfg.toolSameRepeat,
+      iterMetrics: { fileWrites: 0, iterationStartAt: nowIso() },
     },
   };
   persistState(ctx);
@@ -1475,6 +1526,27 @@ async function cmdLoop(args: string, ctx: ExtensionContext): Promise<void> {
     return;
   }
 
+  // v0.25.1: a CLEAN end — "completed: <reason>", distinct from
+  // stuck/plateau/stopped-by-user. Additive: /loop stop is untouched.
+  if (sub === "finish") {
+    if (!state.loop) {
+      ctx.ui.notify("No loop to finish.", "info");
+      return;
+    }
+    clearLoopTimer();
+    const reason = loopFinishStopReason(rest);
+    state.loop = { ...state.loop, active: false, stopReason: reason };
+    persistState(ctx);
+    await finishLoopGit(ctx, state.loop);
+    appendLedger(ctx.cwd, "loop_stopped", { reason, iterations: state.loop.iteration, best: state.loop.bestValue });
+    ctx.ui.notify(
+      `Loop finished (${reason}) after ${state.loop.iteration} iterations. Best: ${state.loop.bestValue ?? "n/a"}.`,
+      "info",
+    );
+    notifyExternal(ctx, `Loop finished: ${reason}`);
+    return;
+  }
+
   if (sub === "respec") {
     // v0.24.3: reconcile the codebase against the root spec, forever.
     // Same auto-start path as /loop start (the user typed the command —
@@ -2927,6 +2999,7 @@ export default function (pi: ExtensionAPI): void {
       ["respec", "infinite metricless loop reconciling the codebase against the root SPEC.md"],
       ["status", "show metric, iteration, best/last values, stall count"],
       ["stop", "end the loop (keeps the best state)"],
+      ["finish", "end the loop cleanly: /loop finish [reason] → stopReason 'completed: <reason>'"],
     ]),
     handler: (args: string, ctx: ExtensionContext) => { rememberCtx(ctx); return cmdLoop(args, ctx); },
   });
@@ -2985,6 +3058,13 @@ export default function (pi: ExtensionAPI): void {
         { tool: String(event?.toolName ?? "?"), hash: textFingerprint(text), isError: Boolean(event?.isError ?? event?.error) },
         REPETITION.toolWindow,
       );
+      // v0.25.1: file-write progress signal for the multi-signal stuck
+      // gate — a loop that is WRITING files is shipping, not stuck.
+      if (isLoopWriteTool(String(event?.toolName ?? ""))) {
+        const metrics = loop.iterMetrics ?? { fileWrites: 0 };
+        metrics.fileWrites++;
+        loop.iterMetrics = metrics;
+      }
     }
     if (draftingTarget === null) return;
     if (askUserQuestionAnswered(String(event?.toolName ?? ""), event?.details)) {

package/package.json

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