pi-goal-list-loop-audit 0.29.6 → 0.29.8

package/README.md

@@ -39,10 +39,11 @@ Five top-level commands — `/goal`, `/list`, `/loop`, `/glla`, `/review`:
 /goal resume                       # resume
 /goal cancel                       # abort
 /goal decide                       # re-open the decision picker (v0.28.23)
-/goal audit                        # run the isolated auditor on the current goal now — no agent turn (v0.28.27)
+/goal audit ["focus on payments"]    # one-shot project audit (v0.29.8): fix the non-decisions, present the decisions — findings in .pi-glla/audit-loop/findings.md
+/goal verify                       # run the isolated auditor on the current goal now — no agent turn (v0.28.27, renamed from /goal audit in v0.29.8)
 /goal tweak "<new objective>"      # edit in place (Confirm dialog)
 /goal archive                      # archived goals, newest first
-/glla                               # settings UI table · /glla key=value · /glla stats · /glla audits [N|full] · /glla postaudit · /glla autoaccept=on
+/glla                               # settings UI table · /glla status (unified what's-running view) · /glla key=value · /glla stats · /glla audits [N|full] · /glla postaudit · /glla wipe (nuclear reset, Confirm-gated) · /glla autoaccept=on
 /list fix the login bug, add dark mode, write docs   # dump it — the agent shapes it into items, one Confirm
 /list plan.md                      # file detected → bulk import, one Confirm (sisyphus/Ralph style)
 /list <paste a checklist>          # multi-line paste → same batch flow
@@ -66,7 +67,7 @@ matches `/list show`.
 /loop                              # draft the loop (agent grills; measure is test-run before you confirm)
 /loop start "keep polishing the UI"                          # infinite metricless loop (v0.23.6): no plateau, no cap — ends at time=/tokens= or /loop stop
 /loop respec                                                  # infinite metricless loop reconciling the codebase against the root SPEC.md / spec.md (v0.24.3) — 2 specs = you pick, 0 specs = drafting, 1 spec = auto-start (v0.24.4)
-/loop audit                                                    # project-audit loop (v0.29.0): each iteration audits fresh, appends findings to .pi-glla/audit-loop/findings.md, fixes the top ones — the orchestrator counts open findings and the plateau stop ends it when the well is dry
+/loop audit                                                    # project-audit loop (v0.29.0): each iteration audits fresh, appends findings to .pi-glla/audit-loop/findings.md, fixes the top ones — the orchestrator counts open findings and the plateau stop ends it when the well is dry (one-shot version: /goal audit)
 /loop start "reduce TODOs" measure="grep -c TODO src.txt | head -1" direction=min
 /loop start "shrink the bundle" measure="..." direction=min time=4 tokens=500000   # arbitrary bounds
 /loop start "reduce TODOs" measure="..." direction=min branch=1   # scratch-branch mode
@@ -194,7 +195,29 @@ running, you can see it — no command needed.
 A 15s heartbeat detects the precise stall condition — active goal/loop + idle
 session + nothing scheduled + quiet for 60s — and re-fires the continuation
 itself. Three consecutive zero-tool turns pause the goal / stop the loop.
-No external watchdog plugin needed.
+No external watchdog plugin needed. It also recovers **stranded audits**
+(v0.29.1): a goal stuck in `auditing` with no auditor session alive re-runs
+the stored claim after 90s instead of black-holing. Storm protection: the
+send→pause→notify path rearms once per cycle and loud-stops after a 6-error
+brake streak, so a broken provider can't spin forever.
+
+**User aborts mean STOP** (v0.29.4): Esc-aborting a turn stands the chain
+down with a named notify (`/goal resume` to continue) — it does NOT count
+toward stall warnings, does NOT auto re-fire, and the stand-down survives
+the heartbeat (v0.29.5). Five consecutive aborts still pause loudly as a
+backstop. A queued steer interrupt (`length`/`toolResult` races) is not an
+abort and resumes normally.
+
+## One active thing (auto-arbitrated)
+
+At most one goal/list-item/loop owns the active slot — activation guards
+refuse a second live thing in-session, and **session loads auto-arbitrate
+dirty stacked state** (v0.29.6): if a pre-guard project persisted a live
+loop AND a live goal, the one with the most recent activity keeps the slot
+and the loser is ARCHIVED (recoverable under `.pi-glla/archive/` / `/loop
+status`), never silently wiped. No picker, no per-start arbitration chores.
+The queued list is a backlog, not a second live thing — untouched.
+`/glla wipe` remains the manual, Confirm-gated clean slate.
 
 ## Config (one global place, rarely opened)
 
@@ -206,17 +229,21 @@ No external watchdog plugin needed.
 /glla tokenlimit=10000000            # per-goal token budget (default: off) → GLOBAL
 /glla tokenlimit=0                   # explicitly no cap (the default)
 /glla wedgealert=30                  # hung-command alert minutes (default: 30, 0 = off)
-/glla autoresume=on                  # auto-resume goals/loops on ANY session start (default: load HELD, never auto-start — explicit /goal resume, /list resume, or /loop; off: never)
+/glla autoresume=on                  # auto-resume goals/loops on ANY session start (default: load HELD, never auto-start — explicit /goal resume, /list resume, or /loop; off: never) — GLOBAL-only (v0.29.5): project-level keys are inert
 /glla auditcap=5                     # pause the goal after N consecutive auditor disapprovals (default 5, 0 = unlimited)
 /glla aggressivemode=on               # keep-going defaults: autoResume, cap 10, stuck 10, wedge off, quota auto-retry, cap→TODOs
 /glla quotaretryminutes=60            # minutes before auto-retrying a quota-exhausted auditor
 /glla stuckmax=10                     # consecutive stuck interventions before a loop stops (default 5)
 /glla auditfeedbackchars=800         # cap the executor-visible auditor report (default 0 = full report)
-/glla autoaccept=on                  # drafts ACTIVATE without the Confirm dialo... (every draft dialog also offers "always auto-accept" inline)unattended rigs)
+/glla autoaccept=on                  # drafts ACTIVATE without the Confirm dialog (v0.29.4: they start immediately — autoResume no longer gates drafts; every draft dialog also offers "always auto-accept" inline)
 /glla project tokenlimit=500         # rare per-project override
 ```
 
-Resolution per key: **project > global > defaults**. The auditor defaults to
+Resolution per key: **project > global > defaults** — EXCEPT `autoResume`,
+which is **global-only** (v0.29.5): per-project opt-ins from old versions
+silently overrode the global hold at launch (the junk-runner incident), so
+the launch-restore gate and the reviewer-enqueue gate read only the global
+file now. The auditor defaults to
 your pi session model. When the session provider is extension-registered the
 auditor can't auth it — you're told once (info level) with the fix:
 `/glla model=provider/id`, set once, rarely touched again. The plugin never
@@ -232,7 +259,12 @@ history and is available through `/goal status` regardless.
 floor — every `propose_*` draft (goal, list batch, loop, task list)
 activates the moment the agent proposes it, with a notification and a
 `draft_autoaccepted` ledger entry (auto-accept is never silent). The seed
-carries the intent. Pair with `autoresume=on` for fully unattended rigs.
+carries the intent. Since v0.29.4 auto-accepted drafts **start immediately**
+— the draft path is decoupled from `autoResume`, which gates ONLY
+launch-time restore of persisted state ("load it but don't auto-start it").
+For fully unattended rigs you typically want both on; for attended rigs,
+`autoaccept=on` + `autoresume=off` is the sweet spot (new drafts go, old
+state holds).
 
 ## Subagents
 
@@ -330,7 +362,7 @@ prompts/
   goal-loop-forever-draft.md   # /loop drafting prompt
 scripts/
   smoke.sh                     # live integration harness (tmux + real models)
-tests/                         # 545 tests across 58 files, no live pi required (mock-ctx harness drives the orchestrator)
+tests/                         # 614 tests across 58 files, no live pi required (mock-ctx harness drives the orchestrator)
 docs/DESIGN.md                 # architectural decisions
 PLAN.md                        # milestones, decisions, gates
 ```

package/docs/DESIGN.md

@@ -44,6 +44,52 @@ below; later releases append addenda rather than rewrite history.
 - **`notify=<cmd>`**: fire-and-forget shell-out on goal complete / goal pause /
   loop stop, message as `$1`. Settings parser is quote-aware.
 
+## Addendum v0.5.0–v0.29.6 (current state — the long-session era)
+
+The v0.4.0 addendum closed the scaffold era. v0.5.0 through v0.29.6 are 25+
+releases of unattended-rig hardening; the full record is CHANGELOG.md. The
+architectural decisions that changed the SHAPE of the system:
+
+- **Self-watchdog is baked in** (v0.5.0): a 15s heartbeat owns liveness —
+  supervising + idle + nothing scheduled + 60s quiet → re-fire. External
+  liveness plugins are retired.
+- **The restore gate** (v0.26.9 tri-state; hardened v0.28.30, v0.29.4): a
+  bare `pi` start HOLDS everything and paints it — nothing auto-starts from
+  persisted state. In-session reload/fork/compaction continues automatically.
+  `autoResume` (on → any session start resumes; off → never) is **global-only**
+  (v0.29.5) after a stale per-project opt-in silently overrode the global hold.
+- **Drafts and restores are decoupled** (v0.29.4): `autoAcceptDrafts` is the
+  pre-consent for in-session drafts — they START immediately. `autoResume`
+  gates only launch-time restore. "The session auto-starts in some cases ok;
+  launching pi must not."
+- **User aborts mean STOP** (v0.29.4/0.29.5): an aborted turn is exempt from
+  stall accounting, stands the chain down with no auto re-fire, and the
+  stand-down gates the heartbeat + post-compaction refires. The 5-abort loud
+  pause is the backstop.
+- **One active thing, auto-arbitrated** (v0.28.21 guards; v0.29.6 load-time
+  arbitration): at most one live artifact. Dirty stacked states at load are
+  resolved deterministically — most recent activity keeps the slot, the loser
+  is archived (recoverable), no picker. `/glla wipe` (v0.28.31) is the manual,
+  Confirm-gated clean slate.
+- **The completion lifecycle owns its pauses** (v0.29.1): storm/stall
+  escalation never pauses `auditing` goals; a stranded `auditing` state (no
+  live auditor, 90s stale) re-runs the stored claim; send/pause/notify storms
+  rearm once per cycle; the provider-error brake (v0.28.13) keeps cross-cycle
+  memory and parks after 6 consecutive errors.
+- **The audit loop is the project reviewer** (v0.29.0): `/loop audit` runs
+  fresh audit passes every iteration, appends findings to
+  `.pi-glla/audit-loop/findings.md`, fixes the top open ones; the orchestrator
+  counts open boxes as the measure and the plateau stop ends it. The
+  reviewer's reflexive fire-audit-on-clean cascade is opt-in (it paid for
+  verification twice and was hydra fuel).
+- **Git discipline is prompt-law** (v0.29.2): continuation/draft prompts
+  forbid inventing git identities or branches (field incidents: agents
+  committing as `phase-e-agent <phase-e@local>`).
+- **Reviewer = strategist, not verifier** (v0.24.6–v0.29.0): the reviewer
+  scans sources and proposes list items through the standard drafting +
+  Confirm path; it never audits work — the isolated auditor is the only
+  verifier.
+
 ## Addendum v0.4.0 (completion)
 
 - **Auditor compaction enabled** (flaw #3 — the last open one). Safety:

package/extensions/goal-loop-core.ts

@@ -216,10 +216,14 @@ export interface Goal {
 export type GoalRoute =
   | { kind: "draft" }
   | { kind: "set"; text: string }
-  | { kind: "sub"; name: "status" | "pause" | "resume" | "cancel" | "decide" | "audit" | "tweak" | "archive" | "start"; rest: string };
+  | { kind: "sub"; name: "status" | "pause" | "resume" | "cancel" | "decide" | "verify" | "audit" | "tweak" | "archive" | "start"; rest: string };
 
-const GOAL_EXACT_SUBS = new Set(["status", "pause", "resume", "cancel", "decide", "audit"]);
-const GOAL_ARG_SUBS = new Set(["tweak", "archive", "start"]);
+// v0.29.8: "audit" moved to ARG subs ("/goal audit [focus]" is the one-shot
+// project audit — user: "/goal audit IS the audit goal"); the v0.28.27
+// manual current-goal verification moved to "verify" (it happens
+// automatically at completion anyway — verify is the on-demand handle).
+const GOAL_EXACT_SUBS = new Set(["status", "pause", "resume", "cancel", "decide", "verify"]);
+const GOAL_ARG_SUBS = new Set(["audit", "tweak", "archive", "start"]);
 
 export function routeGoalArgs(raw: string): GoalRoute {
   const trimmed = raw.trim();
@@ -228,10 +232,10 @@ export function routeGoalArgs(raw: string): GoalRoute {
   const first = (space === -1 ? trimmed : trimmed.slice(0, space)).toLowerCase();
   const rest = space === -1 ? "" : trimmed.slice(space + 1).trim();
   if (GOAL_EXACT_SUBS.has(first) && rest === "") {
-    return { kind: "sub", name: first as "status" | "pause" | "resume" | "cancel" | "decide", rest: "" };
+    return { kind: "sub", name: first as "status" | "pause" | "resume" | "cancel" | "decide" | "verify", rest: "" };
   }
   if (GOAL_ARG_SUBS.has(first)) {
-    return { kind: "sub", name: first as "tweak" | "archive" | "start", rest };
+    return { kind: "sub", name: first as "audit" | "tweak" | "archive" | "start", rest };
   }
   return { kind: "set", text: trimmed };
 }

package/extensions/goal-loop-forever.ts

@@ -423,3 +423,22 @@ export function auditMeasureCmd(): string {
 export function auditTarget(): string {
   return `Audit the project for real problems and fix them, iteration by iteration. Every iteration: (1) run a FRESH audit pass over the codebase — spawn Explore subagents for breadth — hunting real issues: bugs, broken flows, regressions, drift between docs and code, dead code, security holes. Not style nits, not speculative refactors. (2) Append every NEW finding as one checkbox line "- [ ] SEVERITY: short description (file:line)" 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). (3) Fix the highest-severity OPEN finding(s) — real fixes, committed — then check the box: "- [x] … — fixed in <commit>". (4) Honesty law: never fabricate findings to look busy; never mark a finding fixed without the fix commit existing. When a full audit pass surfaces nothing new AND no open findings remain, say so plainly — the orchestrator counts open findings every iteration and the plateau stop ends the loop when the well is dry.`;
 }
+
+// ---- /goal audit-project (v0.29.8) ----
+
+/**
+ * The one-shot project audit (user design 2026-07-30): "/loop audit keeps
+ * firing — this would be fire and address what you can, present what is to
+ * be decided; whether to fix a bug is not a decision." Same findings file
+ * as the audit loop (one ledger per project — the loop can keep working
+ * what the one-shot surfaced), but exactly ONE pass with a finish line the
+ * isolated auditor verifies, and the triage law the loop doesn't have:
+ * FIX findings (bugs, polish — nobody would say "leave that bug in") are
+ * fixed autonomously; DECIDE findings (direction, trade-offs — two
+ * reasonable answers exist) are presented, never touched. DECIDE lines use
+ * "- [?]" so they never inflate the loop's open-findings measure.
+ */
+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

@@ -165,6 +165,7 @@ import {
   respecTarget,
   auditMeasureCmd,
   auditTarget,
+  projectAuditTarget,
   HELD_ON_RESTORE,
   type LoopState,
 } from "../goal-loop-forever.js";
@@ -1106,7 +1107,7 @@ async function retryStoredCompletionAudit(ctx: ExtensionContext, origin: "quota-
   updateGoal({ status: "auditing" }, liveCtx);
   appendLedger(liveCtx.cwd, "goal_resumed", { via: origin === "manual" ? "manual-audit" : "quota-retry-direct-audit" });
   liveCtx.ui.notify(origin === "manual"
-    ? "Manual /goal audit — running the isolated auditor now (no agent turn needed)."
+    ? "Manual /goal verify — running the isolated auditor now (no agent turn needed)."
     : "Auditor quota window elapsed — retrying the audit with your stored completion claim (no agent turn needed).", "info");
   const settings = loadSettings(liveCtx.cwd);
   const { model: auditorModel, error: modelError, via } = resolveAuditorModel(liveCtx, settings.auditorModel);
@@ -1164,7 +1165,7 @@ async function retryStoredCompletionAudit(ctx: ExtensionContext, origin: "quota-
     updateGoal({ auditHistory: history, pendingCompletion: undefined }, liveCtx);
     const objective = state.goal.objective;
     archiveCurrentGoal(liveCtx, "complete", `auditor ${result.model} approved (${origin})`);
-    liveCtx.ui.notify(`Goal complete — auditor ${result.model} approved${origin === "manual" ? " on /goal audit" : " on the quota retry"}.`, "info");
+    liveCtx.ui.notify(`Goal complete — auditor ${result.model} approved${origin === "manual" ? " on /goal verify" : " on the quota retry"}.`, "info");
     notifyExternal(liveCtx, `Goal complete (auditor approved, ${origin}): ${objective.slice(0, 120)}`);
     return;
   }
@@ -1445,14 +1446,24 @@ async function cmdGoal(args: string, ctx: ExtensionContext): Promise<void> {
       if (!shown) ctx.ui.notify("No pending decision — the goal isn't paused on a choice (or no UI).", "info");
       return;
     }
-    // v0.28.27: /goal audit — run the isolated auditor on the current goal
+    // v0.29.8: /goal audit [focus] — the ONE-SHOT project audit (user:
+    // "/goal audit IS the audit goal — we are not auditing the current
+    // goal, that happens automatically"). Fire-and-address: one audit
+    // pass, FIX findings fixed autonomously (a bug is not a decision),
+    // DECIDE findings presented, untouched. Runs as a normal goal through
+    // cmdSet — the isolated auditor verifies the finish line.
+    if (route.name === "audit") {
+      return cmdSet(projectAuditTarget(route.rest || undefined), ctx, true);
+    }
+    // v0.28.27 (renamed /goal audit → /goal verify in v0.29.8): run the
+    // isolated auditor on the current goal
     // RIGHT NOW, without engaging the agent. The user's "the work looks
     // done — just verify it" handle (and the manual counterpart of the
     // v0.28.26 stored-claim quota retry). Seeds a synthesized claim so a
     // quota block falls into the same pendingCompletion retry machinery.
-    if (route.name === "audit") {
+    if (route.name === "verify") {
       if (!state.goal) {
-        ctx.ui.notify("No active goal — /goal audit needs a goal to verify.", "warning");
+        ctx.ui.notify("No active goal — /goal verify needs a goal to verify.", "warning");
         return;
       }
       if (completionAuditInFlight) {
@@ -1461,7 +1472,7 @@ async function cmdGoal(args: string, ctx: ExtensionContext): Promise<void> {
       }
       updateGoal({
         pendingCompletion: {
-          completionSummary: "Manual audit requested by the user via /goal audit (no agent completion claim). Verify the objective against the repo directly.",
+          completionSummary: "Manual audit requested by the user via /goal verify (no agent completion claim). Verify the objective against the repo directly.",
           at: nowIso(),
         },
       }, ctx);
@@ -4551,6 +4562,37 @@ function cmdAudits(args: string, ctx: ExtensionContext): void {
   ctx.ui.notify(`glla audits — last ${entries.length} verdict(s) in ${ctx.cwd}\n${formatAuditLog(entries)}`, "info");
 }
 
+// v0.29.8: /glla status — the unified "what's running" surface (user: "we
+// need to type goal status [to check], so that command at least is missing
+// for checking on whatever active process we have"). Read-only aggregate of
+// the ONE state — goal, list queue, loop, pending decisions — with pointers
+// to the deep surfaces.
+function cmdGllaStatus(ctx: ExtensionContext): void {
+  const lines: string[] = [];
+  const g = state.goal;
+  if (g) {
+    const tok = (g.usage?.tokensUsed ?? 0) > 0 ? ` · ${g.usage!.tokensUsed} tok` : "";
+    const audit = g.status === "auditing" ? " (auditor running…)" : "";
+    const pause = g.status === "paused" && g.pauseReason ? ` — ${g.pauseReason.slice(0, 90)}` : "";
+    lines.push(`goal [${g.policy}] ${g.status}${audit}${tok}: ${g.objective.slice(0, 90)}${pause}`);
+  } else {
+    lines.push("goal: none");
+  }
+  const q = listQueue();
+  lines.push(`list: ${q.length === 0 ? "empty" : `${q.length} queued — head: ${(q[0]?.objective ?? "").slice(0, 70)}`}`);
+  const l = state.loop;
+  if (l) {
+    lines.push(`loop: ${l.active ? "ACTIVE" : `held/stopped — ${l.stopReason ?? "n/a"}`} · iter ${l.iteration}/${l.maxIterations > 0 ? l.maxIterations : "∞"} · best ${l.bestValue ?? "n/a"} · stall ${l.stallCount} — ${l.target.slice(0, 60)}`);
+  } else {
+    lines.push("loop: none");
+  }
+  if (g?.status === "paused" && g.pauseKind === "decision" && g.pauseOptions?.length) {
+    lines.push(`decision pending (${g.pauseOptions.length} options) — /goal decide`);
+  }
+  lines.push("deep: /goal status · /list · /loop status · /glla stats · /glla audits · /glla log");
+  ctx.ui.notify(`glla status\n${lines.join("\n")}`, "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
@@ -4573,6 +4615,11 @@ async function cmdSettings(args: string, ctx: ExtensionContext): Promise<void> {
     cmdAudits(trimmed.slice("audits".length).trim(), ctx);
     return;
   }
+  // v0.29.8: /glla status — the unified what's-running view.
+  if (/^status\b/.test(trimmed)) {
+    cmdGllaStatus(ctx);
+    return;
+  }
   // v0.28.28: /glla log [N] — the raw event trail, human-readable. "Log it
   // so we can look back and see where we are doing things wrong."
   if (/^log\b/.test(trimmed)) {
@@ -4970,10 +5017,13 @@ export default function (pi: ExtensionAPI): void {
     description: "Set/draft a goal, or /goal status|pause|resume|cancel|tweak <text>|archive|start <objective>. Objectives without a 'Done when:' clause are grilled into a contract first; include the clause or use /goal start to skip the interview and activate instantly.",
     getArgumentCompletions: completions([
       ["start", "skip drafting — /goal start <objective> activates immediately"],
+      ["audit", "one-shot project audit goal: /goal audit [focus] — fix the non-decisions, present the decisions (v0.29.8)"],
+      ["verify", "run the isolated auditor on the current goal NOW (v0.28.27, renamed from /goal audit)"],
       ["status", "show the active goal and its task list"],
       ["pause", "pause the active goal"],
       ["resume", "resume a paused goal (and the list, when items are queued)"],
       ["cancel", "abort the active goal"],
+      ["decide", "re-open the decision picker for a decision pause"],
       ["tweak", "change the objective: /goal tweak <text>"],
       ["archive", "list archived goals"],
     ]),
@@ -4990,6 +5040,7 @@ export default function (pi: ExtensionAPI): void {
       ["autoresume=", "default: hold when a session is loaded, auto-resume on reload/fork; on: always auto-resume; off: never"],
       ["decisionpopup=", "on|off: decision pauses pop the select() picker (default on; the widget card always lists the options, /goal decide reopens the picker)"],
       ["auditcap=", "N: pause goal after N consecutive auditor disapprovals (default 5, 0 = unlimited)"],
+      ["status", "unified what's-running view: goal + list queue + loop + pending decisions (v0.29.8)"],
       ["log", "event-trail tail: /glla log [N] — who created/resumed/paused what, from where (v0.28.28)"],
       ["wipe", "WIPE live glla state (goal archived, list cleared, loop stopped) — one-shot cleanup for leftover-laden projects"],
       ["resume", "resume WHATEVER is paused/held (goal, list item, or held loop) — no need to know the type"],

package/package.json

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