pi-goal-list-loop-audit 0.30.0 → 0.31.0

package/extensions/goal-loop-forever.ts

@@ -478,6 +478,75 @@ export function countOpenAuditFindings(cwd: string): number {
  * reasonable answers exist) are presented, never touched. DECIDE lines use
  * "- [?]" so they never inflate the loop's open-findings measure.
  */
+/** v0.31.0: /list audit — the collect-then-drain audit (user design
+ * 2026-07-31: "this command could run a project audit, collect a bunch of
+ * tasks, then do them all too"). Division of labor:
+ *   /goal audit — one audited unit: audit + fix in the SAME pass (small scopes).
+ *   /list audit — audit once, then every open finding becomes its own queued,
+ *                 individually-audited list item (the actionables stop living
+ *                 only inside findings.md — the user's "audits don't make a
+ *                 list of actionables" pain).
+ *   /loop audit — forever fix-first cadence for living codebases.
+ * The collection item FIXES NOTHING: every fix lands as its own list item with
+ * its own isolated audit trail. DECIDE findings are presented at collection
+ * completion, never queued — a decision is not a task (the agent can't "do" it).
+ * The marker survives restarts inside the objective itself (no schema change):
+ * the completion fan-out matches on it.
+ */
+export const LIST_AUDIT_COLLECT_MARKER = "[LIST-AUDIT-COLLECT]";
+
+export function listAuditCollectTarget(focus?: string): string {
+  const scope = focus && focus.trim() ? focus.trim() : "the whole project";
+  return `${LIST_AUDIT_COLLECT_MARKER} Run ONE project audit pass that COLLECTS work — the follow-up fixes are queued as separate list items, so this pass changes no code. Scope: ${scope}. (1) Run a FRESH audit pass over the codebase — spawn Explore subagents for breadth — hunting real problems: bugs, broken flows, regressions, drift between docs and code, dead code, security holes. Not style nits, not speculative refactors. (2) Append every NEW finding to ${AUDIT_FINDINGS_REL} (create the file on the first finding; append-only — never delete, rewrite, or reorder existing lines; never re-report a finding already listed), classified: "- [ ] FIX: SEVERITY: short description (file:line)" for bugs and polish — and "- [?] DECIDE: short description (what the choice is, what each side costs)" for direction, trade-offs, and scope questions where two reasonable answers exist. (3) Change NOTHING — no fixes, no refactors, no drive-by edits: the orchestrator queues each open FIX finding as its own list item after this pass completes, and each fix lands with its own commit and its own audit. (4) DECIDE findings are listed in the completion report — they are presented to the user, never queued and never silently fixed. (5) Honesty law: never fabricate findings to look busy; if the pass is genuinely clean, say so plainly — an empty findings set is a success, not a failure. Done when: the audit pass is complete and every finding it surfaced is appended to ${AUDIT_FINDINGS_REL} with the right classification (or the report states plainly that nothing was found).`;
+}
+
+/** One parsed open finding from the audit findings file. */
+export interface AuditFindingLine {
+  /** Raw finding text with the checkbox + optional "FIX:" prefix stripped. */
+  text: string;
+  /** Severity rank for sorting: 0 = CRITICAL … 4 = unclassified. */
+  rank: number;
+}
+
+const AUDIT_SEVERITY_ORDER = ["CRITICAL", "HIGH", "MEDIUM", "LOW"];
+
+/** v0.31.0: parse findings.md into the fan-out shape — OPEN boxes become
+ * actionable findings (severity-sorted, stable within a rank), DECIDE boxes
+ * ("- [?]") are returned separately for presentation (never queued). Tolerates
+ * the /loop audit format (no "FIX:" prefix): any open box that isn't a
+ * decision is actionable.
+ */
+export function parseAuditFindingsForFanout(md: string): { open: AuditFindingLine[]; decisions: string[] } {
+  const open: AuditFindingLine[] = [];
+  const decisions: string[] = [];
+  md.split("\n").forEach((line, idx) => {
+    const decide = line.match(/^\s*-\s*\[\?\]\s*(.*)$/);
+    if (decide) {
+      const text = (decide[1] ?? "").replace(/^DECIDE:\s*/i, "").trim();
+      if (text) decisions.push(text);
+      return;
+    }
+    const box = line.match(/^\s*-\s*\[ \]\s*(.*)$/);
+    if (!box) return;
+    const text = (box[1] ?? "").replace(/^FIX:\s*/i, "").trim();
+    if (!text) return;
+    const sev = text.match(/^([A-Z]+)\s*:/);
+    const rank = sev ? AUDIT_SEVERITY_ORDER.indexOf(sev[1]!) : -1;
+    open.push({ text, rank: rank >= 0 ? rank : AUDIT_SEVERITY_ORDER.length + (idx / 100000) });
+  });
+  // Severity first; stable within a rank (file order) via the fractional idx.
+  open.sort((a, b) => a.rank - b.rank);
+  return { open, decisions };
+}
+
+/** v0.31.0: the list-item text for one finding — short objective + a checkable
+ * Done when (the fix commit exists AND the box is checked with its hash, so
+ * findings.md stays honest as the drain proceeds).
+ */
+export function listAuditFanoutItemText(finding: string): string {
+  return `Fix audit finding: ${finding} — Done when: the fix is committed on the current branch with the repo's configured identity, and this finding's box in ${AUDIT_FINDINGS_REL} is checked ("- [x] … — fixed in <commit>").`;
+}
+
 export function projectAuditTarget(focus?: string): string {
   const scope = focus && focus.trim() ? focus.trim() : "the whole project";
   return `Run ONE project audit pass and leave the project in a known state. Scope: ${scope}. (1) Run a FRESH audit pass over the codebase — spawn Explore subagents for breadth — hunting real problems: bugs, broken flows, regressions, drift between docs and code, dead code, security holes. Not style nits, not speculative refactors. (2) Append every NEW finding to ${AUDIT_FINDINGS_REL} (create the file on the first finding; append-only — never delete, rewrite, or reorder existing lines; never re-report a finding already listed), classified: "- [ ] FIX: SEVERITY: short description (file:line)" for bugs and polish — whether to fix these is NOT a decision — and "- [?] DECIDE: short description (what the choice is, what each side costs)" for direction, trade-offs, and scope questions where two reasonable answers exist. (3) Fix every NEW FIX finding from this pass — real fixes, committed with the repo's configured identity on the current branch (no invented identities or branches) — then check the box: "- [x] … — fixed in <commit>". (4) Change NOTHING for DECIDE findings — present them in the completion report instead. (5) Honesty law: never fabricate findings to look busy; never check a box without the fix commit existing; never silently turn a DECIDE into a fix. Done when: the audit pass is complete, every new FIX finding has a fix commit and a checked box in ${AUDIT_FINDINGS_REL}, and every DECIDE finding is listed in the file and presented in the completion report.`;

package/extensions/loops/goal.ts

@@ -175,6 +175,10 @@ import {
   countOpenAuditFindings,
   AUDIT_FINDINGS_REL,
   projectAuditTarget,
+  LIST_AUDIT_COLLECT_MARKER,
+  listAuditCollectTarget,
+  parseAuditFindingsForFanout,
+  listAuditFanoutItemText,
   type LoopTickOutcome,
   HELD_ON_RESTORE,
   type LoopState,
@@ -1228,6 +1232,62 @@ function autoArbitrateStackedState(ctx: ExtensionContext): void {
   );
 }
 
+/** v0.31.0: /list audit completion fan-out — read the audit findings file,
+ * queue every OPEN finding as its own list item (severity-sorted, deduped
+ * against the live queue), present DECIDE findings without queueing them.
+ * Confirm-gated like every bulk import (v0.23.7: the user reads what lands
+ * in the queue); a decline leaves the findings open for a later re-run.
+ */
+async function fanOutListAuditFindings(ctx: ExtensionContext): Promise<void> {
+  let md = "";
+  try {
+    md = fs.readFileSync(path.join(ctx.cwd, AUDIT_FINDINGS_REL), "utf-8");
+  } catch {
+    /* no findings file — the audit was clean or never wrote */
+  }
+  const { open, decisions } = parseAuditFindingsForFanout(md);
+  // Dedupe against the live queue (a re-run must not double-queue a finding
+  // that's already waiting) — match on the finding text's first 60 chars.
+  const queuedText = listQueue().map((i) => i.objective).join("\n");
+  const fresh = open.filter((f) => !queuedText.includes(f.text.slice(0, 60)));
+  const alreadyQueued = open.length - fresh.length;
+  const decideNote =
+    decisions.length > 0
+      ? `\n${decisions.length} DECIDE finding(s) need YOU (not queued — a decision is not a task):\n` +
+        decisions.slice(0, 10).map((d) => `  ? ${d.slice(0, 110)}`).join("\n")
+      : "";
+  if (fresh.length === 0) {
+    ctx.ui.notify(
+      open.length > 0
+        ? `Audit collected ${open.length} open finding(s) — all already queued.${decideNote}`
+        : `Audit complete — no open findings; the project is clean, nothing to queue.${decideNote}`,
+      "info",
+    );
+    appendLedger(ctx.cwd, "list_audit_fanout_empty", { open: open.length, decisions: decisions.length });
+    return;
+  }
+  const preview = fresh.map((f, i) => `  ${i + 1}. ${f.text.slice(0, 110)}`).join("\n");
+  let confirmed = true;
+  if (ctx.hasUI) {
+    try {
+      confirmed = await ctx.ui.confirm(`Queue ${fresh.length} audit finding(s) as list items?`, preview);
+    } catch {
+      confirmed = false;
+    }
+  }
+  if (!confirmed) {
+    appendLedger(ctx.cwd, "list_audit_fanout_declined", { findings: fresh.length });
+    ctx.ui.notify(`Fan-out declined — the findings stay open in ${AUDIT_FINDINGS_REL}; /list audit re-queues them any time.`, "info");
+    return;
+  }
+  const n = enqueueItems(ctx, fresh.map((f) => listAuditFanoutItemText(f.text)), "list audit fan-out");
+  appendLedger(ctx.cwd, "list_audit_fanout", { queued: n, alreadyQueued, decisions: decisions.length });
+  ctx.ui.notify(
+    `Queued ${n} finding(s) — the list drains them fix by fix, each with its own audited commit.${alreadyQueued > 0 ? ` (${alreadyQueued} already queued.)` : ""}${decideNote}`,
+    "info",
+  );
+}
+
 function archiveCurrentGoal(ctx: ExtensionContext, status: Status, stopReason?: string): void {
   if (!state.goal) return;
   const goal = state.goal;
@@ -1253,9 +1313,15 @@ function archiveCurrentGoal(ctx: ExtensionContext, status: Status, stopReason?:
   // (v0.2.0 bug: bare /list next silently consumed TWO items, found by the
   // pick-any-item verification in v0.10.0).
   if (goal.policy === "list" && status === "complete") {
+    // v0.31.0: a /list audit collection item completed → fan the open
+    // findings out into the queue (async — Confirm-gated). When the queue
+    // was empty, enqueueItems activates the first fix itself, so the
+    // list-complete / reviewer noise below must NOT fire for this item.
+    const isListAuditCollect = goal.objective.includes(LIST_AUDIT_COLLECT_MARKER);
+    if (isListAuditCollect) void fanOutListAuditFindings(ctx);
     const advanced = activateNextListItem(ctx);
     // v0.26.0: the queue just EMPTIED on a completion → list-complete.
-    if (!advanced) {
+    if (!advanced && !isListAuditCollect) {
       fireReviewer(ctx, { kind: "list", goalId: goal.id, objective: goal.objective, terminal: "goal-complete" });
       // v0.29.0: the well ran dry — point at the project-audit loop. A
       // suggestion, not an action: consent, never auto-start (v0.28.28).
@@ -2084,6 +2150,26 @@ async function cmdList(args: string, ctx: ExtensionContext): Promise<void> {
   const sub = (parts[0] ?? "").toLowerCase();
   const rest = args.trim().slice(sub.length).trim();
 
+  if (sub === "audit") {
+    // v0.31.0: /list audit [focus] — collect-then-drain (user design
+    // 2026-07-31: "run a project audit, collect a bunch of tasks, then do
+    // them all too"). The audit item COLLECTS findings (changes no code);
+    // its completion fans each open finding out into the queue and the
+    // list drains them fix by fix, each with its own isolated audit.
+    // Distinct from /goal audit (fix-in-pass, one audited unit) and
+    // /loop audit (forever fix-first cadence).
+    const objective = listAuditCollectTarget(rest || undefined);
+    const n = enqueueItems(ctx, [objective], "/list audit");
+    if (n === 0) return; // zombie-twin guard already explained itself
+    ctx.ui.notify(
+      "Audit collection item queued — it CHANGES NO CODE: it appends findings to " +
+        AUDIT_FINDINGS_REL +
+        ", and on completion each open finding becomes its own list item (fixes drain one audited commit at a time). DECIDE findings are presented to you, never queued.",
+      "info",
+    );
+    return;
+  }
+
   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.
@@ -5382,9 +5468,10 @@ export default function (pi: ExtensionAPI): void {
     handler: (args: string, ctx: ExtensionContext) => { rememberCtx(ctx); return cmdReview(args, ctx); },
   });
   pi.registerCommand("list", {
-    description: "Loop 2: the list of audited goals — order is the default, not the law. /list <describe tasks or name a plan file> (dumps get shaped into items, files import, 'Done when:' adds directly) | /list show | /list resume | /list next [n] | /list remove <n> | /list clear | /list cancel",
+    description: "Loop 2: the list of audited goals — order is the default, not the law. /list <describe tasks or name a plan file> (dumps get shaped into items, files import, 'Done when:' adds directly) | /list audit [focus] (collect findings, then drain them as items) | /list show | /list resume | /list next [n] | /list remove <n> | /list clear | /list cancel",
     getArgumentCompletions: completions([
       ["show", "display the waiting items"],
+      ["audit", "collect-then-drain: audit the project, queue every finding as its own item"],
       ["resume", "resume the paused list item (the list's head)"],
       ["next", "activate the next item (or /list next <n> for position n)"],
       ["remove", "remove an item: /list remove <n>"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goal-list-loop-audit",
-  "version": "0.30.0",
+  "version": "0.31.0",
   "description": "Goal. Loop. Audit. Done. \u2014 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 \u2014 only the read tools needed to verify your goal.",
   "license": "MIT",
   "author": "dracon",