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

package/extensions/goal-loop-core.ts

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

@@ -39,6 +39,10 @@ import {
   isFullAuditObjective,
   lastShippedAtMs,
   resolveEffectiveAggressiveSettings,
+  computeListDepth,
+  ledgerPath,
+  crossRecommendMode,
+  formatListDepth,
   shouldSuppressHeartbeatForRecentShip,
   mergeSettings,
   parseListImport,
@@ -92,6 +96,7 @@ import {
 } from "../goal-settings.js";
 import {
   discoverGllaProjects,
+  parseLedgerEntries,
   filterPremature,
   formatRollupJson,
   formatRollupTable,
@@ -562,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 {
@@ -573,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" });
@@ -852,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

package/package.json

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