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

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-core.ts

@@ -157,6 +157,10 @@ export interface Goal {
   };
   createdAt: string;
   updatedAt: string;
+  /** v0.25.2: per-goal telemetry for /glla stats premature-success
+   * detection. Bumped live: turns on agent_end, fileWrites/bashCalls on
+   * tool_result while the goal is active. */
+  telemetry?: { turns: number; fileWrites: number; bashCalls: number };
 }
 
 /**

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

@@ -0,0 +1,273 @@
+// pi-goal-list-loop-audit — v0.25.2
+// extensions/goal-loop-stats.ts
+//
+// /glla stats: per-project ledger rollups. Scans .pi-glla/active.jsonl
+// across every project on the rig and produces the cross-project table
+// the spec-driven verifier (v0.25 design) will be hardened against.
+// Pure helpers take strings/paths so tests drive them from tmpdirs —
+// no dependencies beyond node stdlib (contract boundary).
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+export interface LedgerEntry {
+  type: string;
+  at?: string;
+  value?: any;
+}
+
+export interface GoalTelemetry {
+  turns: number;
+  fileWrites: number;
+  bashCalls: number;
+}
+
+/** Minimal per-goal shape the rollup reasons about (the ledger's `state`
+ * snapshots carry the full goal object; archived goals keep their last). */
+export interface GoalRollupSource {
+  id: string;
+  status?: string;
+  createdAt?: string;
+  updatedAt?: string;
+  usage?: { tokensUsed?: number };
+  auditHistory?: Array<{ approved?: boolean; disapproved?: boolean; error?: string }>;
+  telemetry?: GoalTelemetry;
+}
+
+export interface ProjectRollup {
+  project: string;
+  goalsCreated: number;
+  auditsApproved: number;
+  auditsDisapproved: number;
+  auditsError: number;
+  avgTurns: number;
+  avgWrites: number;
+  prematureCount: number;
+  /** Total token usage across goals (cost in tokens — no price data on
+   * this rig; documented in INSTALL.md). */
+  totalCost: number;
+  lastActive: string;
+}
+
+/** Premature-success thresholds (spec-driven verifier design §3): an
+ * approved goal with almost no turns, no real editing, and no
+ * verification commands is a "claimed done in 12 turns with 0 file
+ * writes" pattern the auditor should have caught. */
+export const PREMATURE_THRESHOLDS = {
+  maxTurns: 50,
+  maxFileWrites: 5,
+  maxBashCalls: 8,
+} as const;
+
+export function parseLedgerEntries(jsonl: string): LedgerEntry[] {
+  const out: LedgerEntry[] = [];
+  for (const line of jsonl.split("\n")) {
+    const t = line.trim();
+    if (!t) continue;
+    try {
+      const e = JSON.parse(t);
+      if (e && typeof e === "object" && typeof e.type === "string") out.push(e as LedgerEntry);
+    } catch {
+      /* malformed line — skip */
+    }
+  }
+  return out;
+}
+
+/** Flag the "approved too easily" pattern. Goals without telemetry
+ * (archived before v0.25.2) are UNKNOWN, not premature — we do not
+ * back-convict historical goals on missing data. */
+export function detectPrematureSuccess(goal: GoalRollupSource): boolean {
+  const audits = goal.auditHistory ?? [];
+  const approved = audits.filter((a) => a.approved).length;
+  if (approved === 0) return false;
+  const t = goal.telemetry;
+  if (!t) return false;
+  return (
+    t.turns < PREMATURE_THRESHOLDS.maxTurns &&
+    t.fileWrites < PREMATURE_THRESHOLDS.maxFileWrites &&
+    t.bashCalls < PREMATURE_THRESHOLDS.maxBashCalls
+  );
+}
+
+/** Roll up one project's ledger. Pure over the parsed entries — the file
+ * read happens in rollupProject. */
+export function rollupEntries(project: string, entries: LedgerEntry[]): ProjectRollup {
+  let goalsCreated = 0;
+  let lastActive = "";
+  const finalGoal = new Map<string, GoalRollupSource>();
+  for (const e of entries) {
+    if (e.at && e.at > lastActive) lastActive = e.at;
+    if (e.type === "goal_created") goalsCreated++;
+    if (e.type === "state" && e.value?.goal?.id) {
+      finalGoal.set(String(e.value.goal.id), e.value.goal as GoalRollupSource);
+    }
+  }
+  let auditsApproved = 0;
+  let auditsDisapproved = 0;
+  let auditsError = 0;
+  let prematureCount = 0;
+  let totalCost = 0;
+  let turnsSum = 0;
+  let turnsN = 0;
+  let writesSum = 0;
+  let writesN = 0;
+  for (const goal of finalGoal.values()) {
+    for (const a of goal.auditHistory ?? []) {
+      if (a.approved) auditsApproved++;
+      else if (a.disapproved) auditsDisapproved++;
+      else if (a.error) auditsError++;
+    }
+    if (detectPrematureSuccess(goal)) prematureCount++;
+    totalCost += goal.usage?.tokensUsed ?? 0;
+    if (goal.telemetry) {
+      turnsSum += goal.telemetry.turns;
+      turnsN++;
+      writesSum += goal.telemetry.fileWrites;
+      writesN++;
+    }
+  }
+  return {
+    project,
+    goalsCreated,
+    auditsApproved,
+    auditsDisapproved,
+    auditsError,
+    avgTurns: turnsN > 0 ? Math.round((turnsSum / turnsN) * 10) / 10 : 0,
+    avgWrites: writesN > 0 ? Math.round((writesSum / writesN) * 10) / 10 : 0,
+    prematureCount,
+    totalCost,
+    lastActive,
+  };
+}
+
+export function rollupProject(projectPath: string): ProjectRollup | undefined {
+  const ledger = path.join(projectPath, ".pi-glla", "active.jsonl");
+  let raw: string;
+  try {
+    raw = fs.readFileSync(ledger, "utf-8");
+  } catch {
+    return undefined;
+  }
+  return rollupEntries(projectPath, parseLedgerEntries(raw));
+}
+
+/** Project discovery (contract item 6). Sources:
+ *  1. ~/.pi/agent/sessions/ — session dir names encode their cwd
+ *     (`--home-dracon-chat-` ≈ /home/dracon/chat); cheap, no file scans.
+ *  2. A bounded walk under ~ (maxdepth 6, pruning node_modules/.git and
+ *     hidden dirs) for .pi-glla/ directories — catches projects no
+ *     session has visited. (Deviation from the contract's one-level walk:
+ *     one level would miss the very projects cited — polis is depth 5.)
+ *  3. The current cwd.
+ * Only roots with a real .pi-glla/active.jsonl survive. Budget-guarded:
+ * the walk stops after `budgetMs`. */
+export function discoverGllaProjects(opts: { home?: string; cwd?: string; budgetMs?: number } = {}): string[] {
+  const home = opts.home ?? os.homedir();
+  const cwd = opts.cwd ?? process.cwd();
+  const budgetMs = opts.budgetMs ?? 2000;
+  const deadline = Date.now() + budgetMs;
+  const found = new Set<string>();
+
+  const hasLedger = (dir: string): boolean => {
+    try {
+      fs.accessSync(path.join(dir, ".pi-glla", "active.jsonl"));
+      return true;
+    } catch {
+      return false;
+    }
+  };
+
+  // Source 1: session dir names.
+  try {
+    const sessionsDir = path.join(home, ".pi", "agent", "sessions");
+    for (const name of fs.readdirSync(sessionsDir)) {
+      // --home-dracon-chat- → /home/dracon/chat (best-effort decode:
+      // strip leading/trailing dashes, then replace -- → /- and - → /).
+      const decoded = name.replace(/^-+|-+$/g, "").replace(/--/g, "\0").replace(/-/g, "/").replace(/\0/g, "-");
+      const candidate = "/" + decoded;
+      if (hasLedger(candidate)) found.add(candidate);
+    }
+  } catch {
+    /* no sessions dir */
+  }
+
+  // Source 2: bounded walk — targeted roots FIRST (~/Dev, ~/chat hold the
+  // rig's projects; polis sits at depth 5), the general home walk last
+  // with whatever budget remains. Deep/wide dirs that never hold projects
+  // are pruned.
+  const PRUNE = new Set(["node_modules", ".git", ".pi", ".cache", ".npm", ".local", ".config", "Downloads", "Pictures", "Videos", "Music", ".mozilla", ".vscode", "snap", ".steam", ".wine"]);
+  const walk = (dir: string, depth: number): void => {
+    if (depth > 6 || Date.now() > deadline) return;
+    if (hasLedger(dir)) {
+      found.add(dir);
+      return; // no nested projects below a project root
+    }
+    let entries: fs.Dirent[];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (Date.now() > deadline) return;
+      if (!e.isDirectory()) continue;
+      if (PRUNE.has(e.name)) continue;
+      walk(path.join(dir, e.name), depth + 1);
+    }
+  };
+  for (const root of [path.join(home, "Dev"), path.join(home, "chat")]) {
+    if (Date.now() > deadline) break;
+    walk(root, 1);
+  }
+  walk(home, 0);
+
+  // Source 3: cwd.
+  if (hasLedger(cwd)) found.add(cwd);
+
+  return [...found].sort();
+}
+
+/** Contract item 4: premature filter — only projects with
+ * premature_count > 0, sorted by premature ratio descending. */
+export function filterPremature(rollups: ProjectRollup[]): ProjectRollup[] {
+  return rollups
+    .filter((r) => r.prematureCount > 0)
+    .sort((a, b) => b.prematureCount / Math.max(1, b.goalsCreated) - a.prematureCount / Math.max(1, a.goalsCreated));
+}
+
+function shortProject(p: string): string {
+  const home = os.homedir();
+  return p.startsWith(home) ? `~${p.slice(home.length)}` : p;
+}
+
+export function formatRollupTable(rollups: ProjectRollup[]): string {
+  const header = "| project | goals | approved | disapproved | errors | avg turns | avg writes | premature | tokens | last active |";
+  const sep = "|---|---|---|---|---|---|---|---|---|---|";
+  const rows = rollups.map(
+    (r) =>
+      `| ${shortProject(r.project)} | ${r.goalsCreated} | ${r.auditsApproved} | ${r.auditsDisapproved} | ${r.auditsError} | ${r.avgTurns} | ${r.avgWrites} | ${r.prematureCount} | ${r.totalCost.toLocaleString()} | ${r.lastActive ? r.lastActive.slice(0, 10) : "—"} |`,
+  );
+  return [header, sep, ...rows].join("\n");
+}
+
+/** JSON schema matches the table exactly (contract item 2). */
+export function formatRollupJson(rollups: ProjectRollup[]): string {
+  return JSON.stringify(
+    rollups.map((r) => ({
+      project: r.project,
+      goals_created: r.goalsCreated,
+      audits_approved: r.auditsApproved,
+      audits_disapproved: r.auditsDisapproved,
+      audits_error: r.auditsError,
+      avg_turns: r.avgTurns,
+      avg_writes: r.avgWrites,
+      premature_count: r.prematureCount,
+      total_cost: r.totalCost,
+      last_active: r.lastActive || null,
+    })),
+    null,
+    2,
+  );
+}

package/extensions/loops/goal.ts

@@ -90,10 +90,18 @@ import {
   settingsProvenance,
   type Settings,
 } from "../goal-settings.js";
+import {
+  discoverGllaProjects,
+  filterPremature,
+  formatRollupJson,
+  formatRollupTable,
+  rollupProject,
+  type ProjectRollup,
+} from "../goal-loop-stats.js";
 import { runGoalCompletionAuditor } from "../goal-loop-auditor.js";
 import {
   REPETITION,
-  detectLoopStuck,
+  isActuallyStuck,
   loopInterventionDirective,
   continueVariant,
   textFingerprint,
@@ -111,6 +119,8 @@ import {
   applyRefinement,
   loopBranchName,
   parseLoopStartArgs,
+  loopFinishStopReason,
+  isLoopWriteTool,
   parseMetric,
   LOOP_DEFAULTS,
   resolveSpecFiles,
@@ -1204,18 +1214,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 +1357,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 +1422,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 +1534,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 —
@@ -2595,6 +2675,42 @@ async function openSettingsUI(ctx: ExtensionContext): Promise<void> {
   }
 }
 
+/**
+ * v0.25.2: /glla stats — one command, every project's rollup. Args:
+ *   (none)            markdown table, all discovered projects
+ *   json              machine-readable rollup (same schema as the table)
+ *   premature         only projects with premature_success > 0, ratio-sorted
+ *   project=<path>    limit the scan to one project
+ */
+function cmdStats(args: string, ctx: ExtensionContext): void {
+  const asJson = /\bjson\b/.test(args);
+  const prematureOnly = /\bpremature\b/.test(args);
+  const projectMatch = args.match(/project=(\S+)/);
+  let rollups: ProjectRollup[] = [];
+  if (projectMatch) {
+    const p = projectMatch[1]!.replace(/^~/, os.homedir());
+    const r = rollupProject(p);
+    if (!r) {
+      ctx.ui.notify(`/glla stats: no .pi-glla/active.jsonl under ${p}`, "warning");
+      return;
+    }
+    rollups = [r];
+  } else {
+    const projects = discoverGllaProjects({ cwd: ctx.cwd });
+    for (const p of projects) {
+      const r = rollupProject(p);
+      if (r) rollups.push(r);
+    }
+    if (rollups.length === 0) {
+      ctx.ui.notify("/glla stats: no projects with .pi-glla/active.jsonl found on this rig.", "info");
+      return;
+    }
+  }
+  if (prematureOnly) rollups = filterPremature(rollups);
+  const out = asJson ? formatRollupJson(rollups) : formatRollupTable(rollups);
+  ctx.ui.notify(`glla stats — ${rollups.length} project(s)${prematureOnly ? " (premature filter)" : ""}\n${out}`, "info");
+}
+
 async function cmdSettings(args: string, ctx: ExtensionContext): Promise<void> {
   // The plugin's ONE config surface — global by default, rarely opened.
   //   /glla                      show effective values + where each comes from
@@ -2606,7 +2722,13 @@ async function cmdSettings(args: string, ctx: ExtensionContext): Promise<void> {
   //   /glla auditfeedbackchars=800 cap executor-visible disapproval report (0=full, the default)
   //   /glla project model=...    write to PROJECT override (rare)
   //   /glla model=unset          remove key (from global; project model=unset for project)
+  //   /glla stats [json|premature|project=<path>]   per-project ledger rollups (v0.25.2)
   const trimmed = args.trim();
+  // v0.25.2: /glla stats sub-mode — cross-project telemetry rollups.
+  if (/^stats\b/.test(trimmed)) {
+    cmdStats(trimmed.slice("stats".length).trim(), ctx);
+    return;
+  }
   if (!trimmed) {
     if (ctx.hasUI) {
       await openSettingsUI(ctx);
@@ -2903,6 +3025,7 @@ export default function (pi: ExtensionAPI): void {
       ["aggressivemode=", "on: keep-going defaults — autoResume, cap 10, stuck 10, wedge off, quota auto-retry, cap→TODOs"],
       ["quotaretryminutes=", "N: minutes before auto-retrying a quota-exhausted auditor (default 60)"],
       ["stuckmax=", "N: consecutive stuck interventions before a loop stops (default 5)"],
+      ["stats", "per-project ledger rollups: /glla stats [json|premature|project=<path>]"],
       ["autoaccept=", "on: drafts activate without the Confirm dialog (unattended rigs)"],
       ["project", "write a project override: /glla project key=value"],
     ]),
@@ -2927,6 +3050,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 +3109,23 @@ 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;
+      }
+    }
+    // v0.25.2: per-goal tool telemetry (/glla stats premature detection).
+    if (state.goal && state.goal.status === "active") {
+      const toolName = String(event?.toolName ?? "");
+      if (isLoopWriteTool(toolName) || toolName === "bash") {
+        const t = state.goal.telemetry ?? { turns: 0, fileWrites: 0, bashCalls: 0 };
+        if (isLoopWriteTool(toolName)) t.fileWrites++;
+        if (toolName === "bash") t.bashCalls++;
+        state.goal.telemetry = t;
+      }
     }
     if (draftingTarget === null) return;
     if (askUserQuestionAnswered(String(event?.toolName ?? ""), event?.details)) {
@@ -3104,6 +3245,12 @@ export default function (pi: ExtensionAPI): void {
     // continuation loop.
     if (isForeignCtx(ctx)) return;
     noteActivity();
+    // 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 };
+      t.turns++;
+      state.goal.telemetry = t;
+    }
     if (!registeredCtx) {
       registerAgentTools(pi, ctx);
       registeredCtx = ctx;

package/package.json

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