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

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 };
 }
 
 /**
@@ -918,3 +922,125 @@ export function lastShippedAtMs(cwd: string): number | null {
   }
   return best;
 }
+
+// =================================================================
+// v0.25.3: list-philosophy rework — cross-mode recommendation +
+// /list depth rollups
+// =================================================================
+
+/**
+ * Detect a mode mismatch between what the user described and the mode
+ * they invoked. Returns a recommendation string for the drafting
+ * injection, or undefined when the seed fits the mode.
+ *
+ * The canonical failure this prevents (real incidents 2026-07-24):
+ * "close 76 weak points, one commit each" folded into ONE wrapper goal
+ * with an aggregate "≥ 76 commits" contract → auto-committer squash →
+ * literal count fails → auditor correctly disapproves finished work.
+ */
+export function crossRecommendMode(seed: string, mode: "goal" | "list"): string | undefined {
+  const s = seed.trim();
+  if (!s) return undefined;
+  // Aggregate seed: "N items/findings/weak points/screens/todos/fixes"
+  // (+ "each" / "one commit" flavor) — the wrapper-goal anti-pattern.
+  const aggregate = s.match(/(\d+)\s*(?:items?|findings?|weak[\s-]points?|screens?|todos?|fix(?:es)?|tasks?|issues?)/i);
+  const n = aggregate ? Number(aggregate[1]) : 0;
+  if (n >= 5) {
+    return (
+      `[MODE CHECK — this seed names ${n} discrete items${/each|one commit|as a tasklist/i.test(s) ? ' ("each"/"tasklist" phrasing)' : ""}. ` +
+      `Do NOT fold them into ONE wrapper ${mode === "list" ? "list item" : "goal"} with an aggregate contract ("≥ ${n} commits") — ` +
+      `the auto-committer squashes commits and the literal count fails even when the work is done (the 2026-07-24 76-weak-points incident). ` +
+      `Propose ${n} SHORT /list items via propose_goal_draft items[] — each item closes exactly ONE finding with its own per-item contract. ` +
+      `Any aggregate re-audit becomes the FINAL /goal, not the first.]`
+    );
+  }
+  if (mode === "list") {
+    if (/\b(?:take|takes|taking)\s+(?:a\s+)?(?:few|several|\d+)\s+hours?\b/i.test(s) || /\b(?:multi-hour|deep (?:audit|research|dive)|all day|over the weekend)\b/i.test(s)) {
+      return (
+        `[MODE CHECK — this seed sounds like multi-hour work. /list items are SHORT (minutes, one focused change). ` +
+        `Either break it into ≤ 30-minute items via items[], or tell the user this fits /goal better — one big task, ` +
+        `ends on auditor approval. If the user overrides ("as a list item anyway"), comply.]`
+      );
+    }
+  } else {
+    if (/^(?:fix|typo|rename|bump|remove|delete|clean ?up|tweak)\b/i.test(s) && s.length < 80 && !/\bhours?\b|\ball\b|\bevery\b|\beach\b/i.test(s)) {
+      return (
+        `[MODE CHECK — this seed sounds like a five-minute cleanup. A full audited /goal may be overkill; ` +
+        `suggest /list (queue of short items) or the tasklist plugin. If the user wants the audit anyway, comply.]`
+      );
+    }
+  }
+  return undefined;
+}
+
+/** /list depth rollup: how deep is the queue, how stale is the head,
+ * how long do items actually take (from archived list-policy goals). */
+export interface ListDepthStats {
+  queueDepth: number;
+  oldestItemId?: string;
+  oldestAgeMs?: number;
+  avgDurationMs?: number;
+  durationSamples: number;
+}
+
+export function computeListDepth(
+  queue: Array<{ id: string; addedAt: string }>,
+  ledgerEntries: Array<{ type: string; value?: any }>,
+  nowMs: number,
+): ListDepthStats {
+  let oldestItemId: string | undefined;
+  let oldestAgeMs: number | undefined;
+  for (const item of queue) {
+    const added = Date.parse(item.addedAt);
+    if (Number.isNaN(added)) continue;
+    const age = nowMs - added;
+    if (oldestAgeMs === undefined || age > oldestAgeMs) {
+      oldestAgeMs = age;
+      oldestItemId = item.id;
+    }
+  }
+  // Average item duration from the ledger's list-policy goals (most
+  // recent 10 with both timestamps).
+  const finals = new Map<string, { createdAt?: string; updatedAt?: string; policy?: string; status?: string }>();
+  for (const e of ledgerEntries) {
+    if (e.type === "state" && e.value?.goal?.id) {
+      finals.set(String(e.value.goal.id), e.value.goal);
+    }
+  }
+  const durations: number[] = [];
+  for (const g of finals.values()) {
+    if (g.policy !== "list") continue;
+    if (g.status !== "complete" && g.status !== "archived") continue;
+    const c = Date.parse(g.createdAt ?? "");
+    const u = Date.parse(g.updatedAt ?? "");
+    if (Number.isNaN(c) || Number.isNaN(u) || u < c) continue;
+    durations.push(u - c);
+  }
+  const recent = durations.slice(-10);
+  const avgDurationMs = recent.length > 0 ? Math.round(recent.reduce((a, b) => a + b, 0) / recent.length) : undefined;
+  return {
+    queueDepth: queue.length,
+    oldestItemId,
+    oldestAgeMs,
+    avgDurationMs,
+    durationSamples: recent.length,
+  };
+}
+
+function fmtAge(ms: number): string {
+  const mins = Math.round(ms / 60000);
+  if (mins < 60) return `${mins}m`;
+  const hours = Math.round(mins / 60);
+  if (hours < 24) return `${hours}h`;
+  return `${Math.floor(hours / 24)}d ${Math.round(hours % 24)}h`;
+}
+
+/** Contract item 7's exact headline format, then detail lines. */
+export function formatListDepth(stats: ListDepthStats): string {
+  const oldest = stats.oldestAgeMs !== undefined ? fmtAge(stats.oldestAgeMs) : "—";
+  const avg = stats.avgDurationMs !== undefined ? fmtAge(stats.avgDurationMs) : "—";
+  const lines = [`queue depth: ${stats.queueDepth} · oldest: ${oldest} · avg duration: ${avg}`];
+  if (stats.oldestItemId) lines.push(`oldest item: ${fmtAge(stats.oldestAgeMs!)} (id ${stats.oldestItemId})`);
+  if (stats.durationSamples > 0) lines.push(`avg item duration: ${fmtAge(stats.avgDurationMs!)} (from last ${stats.durationSamples} archived)`);
+  return lines.join("\n");
+}

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

@@ -39,6 +39,10 @@ import {
   isFullAuditObjective,
   lastShippedAtMs,
   resolveEffectiveAggressiveSettings,
+  computeListDepth,
+  ledgerPath,
+  crossRecommendMode,
+  formatListDepth,
   shouldSuppressHeartbeatForRecentShip,
   mergeSettings,
   parseListImport,
@@ -90,6 +94,15 @@ import {
   settingsProvenance,
   type Settings,
 } from "../goal-settings.js";
+import {
+  discoverGllaProjects,
+  parseLedgerEntries,
+  filterPremature,
+  formatRollupJson,
+  formatRollupTable,
+  rollupProject,
+  type ProjectRollup,
+} from "../goal-loop-stats.js";
 import { runGoalCompletionAuditor } from "../goal-loop-auditor.js";
 import {
   REPETITION,
@@ -554,7 +567,15 @@ async function startDrafting(ctx: ExtensionContext, target: "goal" | "list" | "l
     if (target === "list") {
       tmpl = tmpl.replace(
         "[GOAL DRAFTING]",
-        "[GOAL DRAFTING — the confirmed goal goes into the /list LIST, it does not activate immediately. If the user wants MANY things added at once (a plan, a checklist, 'these 50 tasks'), propose them ALL AT ONCE with the items[] parameter — one Confirm for the whole batch, never 50 separate proposals.]",
+        "[LIST DRAFTING — the confirmed item goes into the /list LIST, it does not activate immediately. " +
+          "/list items are SHORT tasks, not multi-hour objectives: each item should fit comfortably in a single agent run " +
+          "(minutes of work, a single focused change). The list's long-running property is QUEUE DEPTH — hundreds of short " +
+          "items activated one at a time over days/weeks — never any single item's scope. " +
+          "If the user describes work that would take hours, propose breaking it into multiple /list items, or suggest /goal " +
+          "for the big version. When the user has many items to enqueue at once ('queue these 50 audits'), propose them ALL AT " +
+          "ONCE with the items[] parameter — one Confirm for the whole batch, never 50 separate proposals. Each items[] entry " +
+          "is still a SHORT task — never an aggregate wrapper ('land all N findings' with a '≥N commits' contract is the " +
+          "canonical anti-pattern: the auto-committer squashes, the count fails, the auditor disapproves finished work).]",
       );
     }
   } catch {
@@ -565,6 +586,12 @@ async function startDrafting(ctx: ExtensionContext, target: "goal" | "list" | "l
   // is blocked until the user has replied at least once (see message_start).
   if (seed) {
     tmpl = buildSeedGrillMessage(tmpl, seed, tool);
+    // v0.25.3: cross-mode recommendation — catch wrapper-goal seeds and
+    // mode mismatches BEFORE the draft crystallizes.
+    if (target === "goal" || target === "list") {
+      const xr = crossRecommendMode(seed, target);
+      if (xr) tmpl += `\n\n${xr}`;
+    }
   }
   try {
     extensionApi?.sendUserMessage(tmpl, { deliverAs: ctx.isIdle() ? "followUp" : "steer" });
@@ -844,6 +871,20 @@ async function cmdList(args: string, ctx: ExtensionContext): Promise<void> {
   const sub = (parts[0] ?? "").toLowerCase();
   const rest = args.trim().slice(sub.length).trim();
 
+  if (sub === "depth") {
+    // v0.25.3: long-running state at a glance — queue depth, oldest item
+    // age, average item duration from archived list-policy goals.
+    let entries: Array<{ type: string; value?: any }> = [];
+    try {
+      entries = parseLedgerEntries(fs.readFileSync(ledgerPath(ctx.cwd), "utf-8"));
+    } catch {
+      /* no ledger yet */
+    }
+    const stats = computeListDepth(listQueue(), entries, Date.now());
+    ctx.ui.notify(`/list depth: ${formatListDepth(stats)}`, "info");
+    return;
+  }
+
   if (sub === "resume") {
     // Resume the list's head. The head activates AS the active goal, so this
     // is the same motion as /goal resume — named for the surface the user is
@@ -2667,6 +2708,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
@@ -2678,7 +2755,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);
@@ -2975,6 +3058,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"],
     ]),
@@ -3066,6 +3150,16 @@ export default function (pi: ExtensionAPI): void {
         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)) {
       draftingUserReplies++;
@@ -3184,6 +3278,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.1",
+  "version": "0.25.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",

package/prompts/goal-loop-draft.md

@@ -1,5 +1,58 @@
 # Goal drafting — pi-goal-list-loop-audit
 
+# Long-running philosophy
+
+The three modes are NOT redundant — each has a distinct source of
+long-running-ness:
+
+| Mode | Item size | Long-running by | Typical lifetime |
+|---|---|---|---|
+| `/goal` | ONE big multi-hour task | Scope | Hours |
+| `/list` | N items × short (minutes each) | Queue depth | Hours → days → weeks |
+| `/loop` | 1 metric × infinite polish | Bounds | Until plateau/stop/finish |
+
+Pick the mode by where the long-running property lives, then draft for
+THAT mode:
+
+- **`/goal` is the multi-hour mode.** Its long-running property is SCOPE:
+  one big task that spans multiple agent runs, requires deep research, or
+  would take hours end-to-end. It ends only when the auditor approves the
+  verification contract. If the work is short enough to fit in a single
+  agent run (a focused change, a single audit, a small refactor), prefer
+  `/list` instead.
+- **`/list` items are short tasks, not multi-hour objectives.** Each item
+  should fit comfortably in a single agent run — minutes of work, a
+  single focused change. The list's long-running property is QUEUE DEPTH:
+  hundreds of short items, activated one at a time, pushed over days or
+  weeks. If the user describes work that would take hours, break it up
+  into multiple `/list` items — or suggest `/goal` for the big version.
+- **`/loop` is metric-driven infinite polish** — its long-running
+  property is open bounds; it ends on plateau, bounds, `/loop stop`, or
+  `/loop finish`.
+
+## Cross-recommend `/goal` ↔ `/list`
+
+While drafting, watch the seed's shape and recommend the right mode:
+
+- **Aggregate seeds belong in `/list` as N items, never as ONE wrapper
+  goal.** The canonical failure (real incidents, 2026-07-24): "close
+  every weak point in X.md (76 items, one commit each)" or "land all 40
+  findings as a tasklist" got folded into ONE goal with an aggregate
+  contract ("≥ 76 commits") — the auto-committer squashed commits, the
+  literal count failed, the auditor correctly disapproved finished work.
+  When the seed contains "N items/findings/weak points/screens" + "each"
+  + "one commit", propose N SHORT items via `propose_goal_draft`
+  `items[]`, each with its OWN per-item contract ("close IMP-AUD3-68:
+  Map.svelte:1528 missing role" — impossible to squash), and let any
+  re-audit pass be the FINAL `/goal`, not the first.
+- **Multi-hour seeds in `/list`** ("this will take hours", "deep audit",
+  "research all 22 screens"): suggest `/goal` — or break the work into
+  ≤ 30-minute items.
+- **Five-minute seeds in `/goal`** ("fix typo in X", "bump version"):
+  suggest `/list` or the tasklist plugin instead — a full audited goal is
+  overkill.
+- The user can always override ("no, as a list item anyway") — comply.
+
 `[GOAL DRAFTING]`
 
 The user invoked `/goal` with no objective. Your job is to turn their vague

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

@@ -1,5 +1,16 @@
 # Loop drafting — pi-goal-list-loop-audit
 
+# Long-running philosophy
+
+`/loop` is the metric-driven infinite-polish mode. Its long-running
+property is BOUNDS: one metric, polished forever, ending only on plateau,
+bounds, `/loop stop`, or `/loop finish`. The other modes long-run
+differently — `/goal` by scope (one big multi-hour task), `/list` by
+queue depth (hundreds of short items, minutes each). If the user's work
+is a single big task with a done state, that's `/goal`; if it's many
+small tasks, that's `/list`; only true open-ended metric improvement
+belongs here.
+
 `[LOOP DRAFTING]`
 
 The user invoked `/loop` with no arguments. Your job is to turn their rough