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

package/extensions/goal-loop-auditor.ts

@@ -159,7 +159,9 @@ function buildGoalAuditorPrompt(goal: Goal, completionSummary: string | null | u
       ? ["4. Verify that the executor has satisfied every item in the <verification_contract>. If any item is missing or weakly addressed, disapprove."]
       : []),
     "5. Explain missing or weak evidence, especially scaffold-vs-final quality gaps.",
-    "6. End with exactly <approved/> only if the objective is truly complete; <impossible>reason</impossible> if it can never be satisfied as stated; otherwise end with exactly <disapproved/>.",
+    "6. When you disapprove, end the report body with a '## Required fixes' section: one line per blocking gap, each an actionable instruction the executor can complete (most critical first). This tail is what the executor sees first — make it self-sufficient.",
+    "7. Write the report in English, and never emit <think> blocks or fragments — your reasoning stays private; the report is the verdict plus evidence.",
+    "8. End with exactly <approved/> only if the objective is truly complete; <impossible>reason</impossible> if it can never be satisfied as stated; otherwise end with exactly <disapproved/>.",
     ...(goal.verificationContract?.trim()
       ? [
           "",

package/extensions/goal-loop-core.ts

@@ -309,8 +309,14 @@ export const DEFAULT_AUDIT_FEEDBACK_CHARS = 0;
  * Bound the auditor report returned to the executor after disapproval.
  * A limit of 0 explicitly means "show the full report".
  */
+/** Executor-visible excerpt of a disapproval report. Full by default
+ * (maxChars 0). When capped, keep the TAIL: since v0.25.4 the auditor
+ * ends disapprovals with the actionable `## Required fixes` section —
+ * head-slicing would cut exactly what the executor needs. */
 export function auditFeedbackExcerpt(output: string, maxChars: number): string {
-  return maxChars === 0 ? output : output.slice(0, maxChars);
+  if (maxChars === 0 || output.length <= maxChars) return output;
+  return `[head truncated — full report via /goal status]
+…${output.slice(-maxChars)}`;
 }
 
 export interface ListItem {
@@ -400,10 +406,19 @@ export interface State {
 /** v0.24.2: count TRAILING consecutive disapprovals (the disapproval-cap
  *  input). Shield-blocks (approved:true) and infra errors (neither flag)
  *  break the streak — they are not verdicts on the work. */
+/** v0.24.2: count TRAILING consecutive disapprovals (the disapproval-cap
+ *  input). Shield-blocks (approved:true) break the streak — the work was
+ *  judged good. v0.25.4: pure infra errors (error set, neither verdict
+ *  flag) are TRANSPARENT, not streak-breakers — the auditor never judged
+ *  the work, so D,D,infra,D is still 3 trailing disapprovals (before, 39
+ *  hegemon-style infra errors would reset the cap and re-open infinite
+ *  re-continuation). */
 export function countTrailingDisapprovals(history: AuditVerdict[]): number {
   let n = 0;
   for (let i = history.length - 1; i >= 0; i--) {
-    if (history[i]!.disapproved) n++;
+    const v = history[i]!;
+    if (v.disapproved) n++;
+    else if (v.error && !v.approved) continue; // infra: not a verdict
     else break;
   }
   return n;
@@ -922,3 +937,211 @@ 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");
+}
+
+// =================================================================
+// v0.25.4: auditor polish — durable audit log, think-block hygiene,
+// actionable-tail slicing, infra-transparent streaks
+// =================================================================
+
+/** Strip think-block leakage from auditor reports before storage/display.
+ * Motivation (wild, 2026-07-25): MiniMax-M3 reports arrive with
+ * `<think>...</think>` bodies, stray `</think>` fragments, and non-English
+ * reasoning spillover — the executor's feedback should be the verdict,
+ * not the auditor's private monologue. */
+export function stripThinkBlocks(text: string): string {
+  return text
+    .replace(/<think>[\s\S]*?<\/think>/gi, "")
+    .replace(/<\/?think>/gi, "")
+    .replace(/<200b>/g, "") // stray partial-tag artifact seen in the wild
+    .replace(/^\s+/, "");
+}
+
+/** One durable audit-log entry — survives state-snapshot rotation, so
+ * /glla audits can answer "where are we weak" across the whole project. */
+export interface AuditLogEntry {
+  at: string;
+  goalId: string;
+  objective: string;
+  verdict: "approved" | "disapproved" | "impossible" | "shield_blocked" | "error";
+  model: string;
+  thinkingLevel: string;
+  report: string;
+  impossibleReason?: string;
+  error?: string;
+}
+
+export function auditLogPath(cwd: string): string {
+  return path.join(cwd, ".pi-glla", "audits.jsonl");
+}
+
+export function appendAuditLog(cwd: string, entry: AuditLogEntry): void {
+  try {
+    ensureDirs(cwd);
+    fs.appendFileSync(auditLogPath(cwd), JSON.stringify(entry) + "\n");
+  } catch {
+    /* log best-effort — never block the verdict path */
+  }
+}
+
+export function readAuditLog(cwd: string, limit?: number): AuditLogEntry[] {
+  let raw: string;
+  try {
+    raw = fs.readFileSync(auditLogPath(cwd), "utf-8");
+  } catch {
+    return [];
+  }
+  const out: AuditLogEntry[] = [];
+  for (const line of raw.split("\n")) {
+    const t = line.trim();
+    if (!t) continue;
+    try {
+      const e = JSON.parse(t);
+      if (e && typeof e.goalId === "string" && typeof e.verdict === "string") out.push(e as AuditLogEntry);
+    } catch {
+      /* skip malformed */
+    }
+  }
+  return limit !== undefined ? out.slice(-limit) : out;
+}
+
+const VERDICT_GLYPH: Record<AuditLogEntry["verdict"], string> = {
+  approved: "✔",
+  disapproved: "✖",
+  impossible: "⛔",
+  shield_blocked: "🛡",
+  error: "⚠",
+};
+
+/** /glla audits list view: one line per verdict, newest last. */
+export function formatAuditLog(entries: AuditLogEntry[]): string {
+  if (entries.length === 0) return "(no audits logged yet — the log starts with the next verdict)";
+  return entries
+    .map((e) => {
+      const day = e.at.slice(5, 16).replace("T", " ");
+      const firstLine = (e.report.split("\n").find((l) => l.trim()) ?? "").trim().slice(0, 90);
+      return `${VERDICT_GLYPH[e.verdict]} ${day} [${e.goalId.slice(-6)}] ${e.model} — ${firstLine}`;
+    })
+    .join("\n");
+}

package/extensions/goal-loop-display.ts

@@ -72,6 +72,9 @@ export interface AuditDisplayProgress {
   currentTool?: string;
   label?: string;
   elapsedMs?: number;
+  /** v0.25.4: last progress-event time — the widget flags auditor-quiet
+   * stalls when this goes stale while the audit is in flight. */
+  lastEventAt?: number;
 }
 
 /**
@@ -175,7 +178,12 @@ function goalLines(g: Goal, state: State, audit: AuditDisplayProgress | null | u
   const lines = [head, `├─ ${isList ? "list item · " : ""}${statusWord} · ${fmtElapsed(now - Date.parse(g.createdAt))}${tokens}`];
   if (g.status === "auditing") {
     lines.push(`├─ auditor: ${audit?.label ?? "running"}${audit?.currentTool ? ` · ${truncate(audit.currentTool, 30)}` : ""}`);
-    if (audit?.elapsedMs) lines.push(`└─ ${paint(theme, "dim", `${fmtElapsed(audit.elapsedMs)} in isolated session`)}`);
+    // v0.25.4: auditor-quiet stall — progress events stopped arriving
+    // while the audit is in flight (hung model call, stuck tool).
+    const quietMs = audit?.lastEventAt !== undefined ? now - audit.lastEventAt : 0;
+    if (quietMs > 3 * 60_000) {
+      lines.push(`└─ ${paint(theme, "warning", `auditor quiet ${fmtElapsed(quietMs)} — may be stuck; Esc aborts, verdict is not counted`)}`);
+    } else if (audit?.elapsedMs) lines.push(`└─ ${paint(theme, "dim", `${fmtElapsed(audit.elapsedMs)} in isolated session`)}`);
     else lines.push(`└─ ${paint(theme, "dim", "isolated session, read-only tools")}`);
     return lines;
   }

package/extensions/loops/goal.ts

@@ -39,6 +39,15 @@ import {
   isFullAuditObjective,
   lastShippedAtMs,
   resolveEffectiveAggressiveSettings,
+  appendAuditLog,
+  computeListDepth,
+  formatAuditLog,
+  readAuditLog,
+  stripThinkBlocks,
+  type AuditLogEntry,
+  ledgerPath,
+  crossRecommendMode,
+  formatListDepth,
   shouldSuppressHeartbeatForRecentShip,
   mergeSettings,
   parseListImport,
@@ -92,6 +101,7 @@ import {
 } from "../goal-settings.js";
 import {
   discoverGllaProjects,
+  parseLedgerEntries,
   filterPremature,
   formatRollupJson,
   formatRollupTable,
@@ -562,7 +572,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 +591,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 +876,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
@@ -1664,7 +1702,7 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       ctx.ui.notify(`Auditor running (isolated session, model: ${via ?? "setting"})…`, "info");
       // Esc during the audit aborts this tool's signal → threaded into the
       // auditor session, which aborts cleanly and returns "Auditor aborted."
-      latestAuditProgress = { label: "starting" };
+      latestAuditProgress = { label: "starting", lastEventAt: Date.now() };
       const result = await runGoalCompletionAuditor({
         ctx,
         goal: state.goal,
@@ -1678,6 +1716,7 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
             currentTool: progress.currentTool,
             label: progress.label,
             elapsedMs: progress.elapsedMs,
+            lastEventAt: Date.now(),
           };
           refreshUI(ctx);
         },
@@ -1690,6 +1729,11 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       const auditorRan = result.output.trim().length > 0;
       const history = state.goal.auditHistory ?? [];
       if (auditorRan) {
+        // v0.25.4: strip think-block leakage (MiniMax-M3 `</think>`
+        // fragments + reasoning spillover) before anything stores or
+        // displays the report.
+        const cleanOutput = stripThinkBlocks(result.output);
+        result.output = cleanOutput;
         history.push({
           at: nowIso(),
           approved: result.approved,
@@ -1698,13 +1742,36 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
           impossibleReason: result.impossibleReason,
           model: result.model,
           thinkingLevel: result.thinkingLevel,
-          report: result.output,
+          report: cleanOutput,
           error: result.error,
           regressionShieldPassed: result.regressionShieldPassed,
           regressionShieldMissing: result.regressionShieldMissing,
         });
         // Cap history — 39 infra errors taught us unbounded growth is real.
         if (history.length > 20) history.splice(0, history.length - 20);
+        // v0.25.4: durable append-only audit log — survives state-snapshot
+        // rotation; the review surface for "where are we weak".
+        const verdict: AuditLogEntry["verdict"] =
+          result.error && !result.approved && !result.disapproved
+            ? "error"
+            : result.approved && result.regressionShieldPassed === false
+              ? "shield_blocked"
+              : result.approved
+                ? "approved"
+                : result.impossible
+                  ? "impossible"
+                  : "disapproved";
+        appendAuditLog(ctx.cwd, {
+          at: nowIso(),
+          goalId: state.goal.id,
+          objective: state.goal.objective.slice(0, 200),
+          verdict,
+          model: result.model,
+          thinkingLevel: result.thinkingLevel ?? "(default)",
+          report: cleanOutput,
+          impossibleReason: result.impossibleReason,
+          error: result.error,
+        });
       }
 
       // Escape hatch: the user aborted the audit (Esc). Offer the explicit
@@ -1883,7 +1950,7 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       const auditFeedbackIsFull = auditFeedbackChars === 0 || result.output.length <= auditFeedbackChars;
       const auditFeedbackLabel = auditFeedbackIsFull
         ? "full report"
-        : `first ${auditFeedbackChars} chars`;
+        : `last ${auditFeedbackChars} chars (Required-fixes tail)`;
       const auditFeedbackTruncationHint = auditFeedbackIsFull
         ? ""
         : `\n\nReport truncated at the configured limit. /goal status shows the full report; change future feedback with /glla auditfeedbackchars=N (0 = full report).`;
@@ -2711,6 +2778,24 @@ function cmdStats(args: string, ctx: ExtensionContext): void {
   ctx.ui.notify(`glla stats — ${rollups.length} project(s)${prematureOnly ? " (premature filter)" : ""}\n${out}`, "info");
 }
 
+/**
+ * v0.25.4: /glla audits [N|full] — browse the durable per-project audit
+ * log (.pi-glla/audits.jsonl). Default: last 10 verdicts, one line each.
+ * "full" prints the latest report in full.
+ */
+function cmdAudits(args: string, ctx: ExtensionContext): void {
+  const full = /\bfull\b/.test(args);
+  const nMatch = args.match(/\b(\d+)\b/);
+  if (full) {
+    const latest = readAuditLog(ctx.cwd).at(-1);
+    ctx.ui.notify(latest ? `Latest audit — ${latest.verdict} (${latest.model}, ${latest.at})\n${latest.report}` : "No audits logged yet.", "info");
+    return;
+  }
+  const n = nMatch ? Number(nMatch[1]) : 10;
+  const entries = readAuditLog(ctx.cwd, n);
+  ctx.ui.notify(`glla audits — last ${entries.length} verdict(s) in ${ctx.cwd}\n${formatAuditLog(entries)}`, "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
@@ -2729,6 +2814,10 @@ async function cmdSettings(args: string, ctx: ExtensionContext): Promise<void> {
     cmdStats(trimmed.slice("stats".length).trim(), ctx);
     return;
   }
+  if (/^audits\b/.test(trimmed)) {
+    cmdAudits(trimmed.slice("audits".length).trim(), ctx);
+    return;
+  }
   if (!trimmed) {
     if (ctx.hasUI) {
       await openSettingsUI(ctx);
@@ -3026,6 +3115,7 @@ export default function (pi: ExtensionAPI): void {
       ["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>]"],
+      ["audits", "audit-log browser: /glla audits [N|full] — recent verdicts from .pi-glla/audits.jsonl"],
       ["autoaccept=", "on: drafts activate without the Confirm dialog (unattended rigs)"],
       ["project", "write a project override: /glla project key=value"],
     ]),

package/package.json

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