pi-goal-list-loop-audit 0.28.29 → 0.28.31

package/extensions/goal-loop-display.ts

@@ -276,11 +276,16 @@ function goalLines(g: Goal, state: State, audit: AuditDisplayProgress | null | u
   // queue work were a standalone goal.
   const isList = g.policy === "list";
   const statusWord = g.status === "active" ? paint(theme, "success", "active") : g.status;
+  // v0.28.30: the status line ALWAYS names the type (user note: "I don't
+  // always see the type — I'd need to scroll up to see if goal/list/loop").
+  // Before, only list items were named; a plain goal's card said "paused ·
+  // 3m" with no type word. The loop surface has its own card.
+  const typeWord = isList ? "list item · " : "goal · ";
   // Token segment only when a budget is set (v0.22.0): the guard is opt-in,
   // and "0/0 tok" carried no information when off.
   const tokenLimit = g.usage?.tokensLimit ?? 0;
   const tokens = tokenLimit > 0 ? ` · ${paint(theme, "dim", `${fmtTokens(g.usage?.tokensUsed ?? 0)}/${fmtTokens(tokenLimit)} tok`)}` : "";
-  const lines = [head, `├─ ${isList ? "list item · " : ""}${statusWord} · ${fmtElapsed(now - Date.parse(g.createdAt))}${tokens}`];
+  const lines = [head, `├─ ${typeWord}${statusWord} · ${fmtElapsed(now - Date.parse(g.createdAt))}${tokens}`];
   if (g.status === "auditing") {
     lines.push(`├─ auditor: ${audit?.label ?? "running"}${audit?.currentTool ? ` · ${truncate(audit.currentTool, 30)}` : ""}`);
     // v0.25.4: auditor-quiet stall — progress events stopped arriving

package/extensions/loops/goal.ts

@@ -551,8 +551,8 @@ function escalateSendRearmStorm(ctx: ExtensionContext, kind: "continuation" | "l
       pauseReason: `send-retry storm: ${mins}m of re-arms with no session activity for ${silent}m — the session never went idle for the continuation`,
       pauseSuggestedAction: "The session produced no events while the send retried (wedged queue). Restart pi, then /goal resume.",
     }, ctx);
-    ctx.ui.notify(`Goal paused: send-retry storm (${mins}m, session silent ${silent}m). Restart pi, then /goal resume.`, "warning");
-    notifyExternal(ctx, "Goal paused: send-retry storm.");
+    ctx.ui.notify(`${goalNoun()} paused: send-retry storm (${mins}m, session silent ${silent}m). Restart pi, then /goal resume.`, "warning");
+    notifyExternal(ctx, `${goalNoun()} paused: send-retry storm.`);
   }
 }
 
@@ -575,8 +575,8 @@ function escalateStallNow(ctx: ExtensionContext, threshold: number): boolean {
       pauseReason: `stalled: ${threshold} continuation refires landed no turn`,
       pauseSuggestedAction: "The continuation chain is broken in this process (wedged message queue or stale API). Restart pi, then /goal resume.",
     }, ctx);
-    ctx.ui.notify(`Goal paused: ${threshold} refires produced no turn. Restart pi, then /goal resume.`, "warning");
-    notifyExternal(ctx, "Goal paused: stalled (continuation not landing).");
+    ctx.ui.notify(`${goalNoun()} paused: ${threshold} refires produced no turn. Restart pi, then /goal resume.`, "warning");
+    notifyExternal(ctx, `${goalNoun()} paused: stalled (continuation not landing).`);
     return true;
   }
   return true;
@@ -659,7 +659,7 @@ function heartbeatTick(): void {
     })
   ) {
     lastWedgeAlertAt = Date.now();
-    const msg = `Goal appears wedged: no activity for ${Math.round((Date.now() - lastActivityAt) / 60_000)}m while the session is busy — likely a hung command (test/build/dev server without a timeout). Check the session; Esc kills a stuck tool call.`;
+    const msg = `${goalNoun()} appears wedged: no activity for ${Math.round((Date.now() - lastActivityAt) / 60_000)}m while the session is busy — likely a hung command (test/build/dev server without a timeout). Check the session; Esc kills a stuck tool call.`;
     appendLedger(ctx.cwd, "wedge_alert", { silentMs: Date.now() - lastActivityAt });
     ctx.ui.notify(msg, "warning");
     notifyExternal(ctx, msg);
@@ -910,6 +910,9 @@ let persistenceDegradedNotified = false;
 
 /** v0.28.11 (U9): objective-first notifies — truncate long objectives. */
 const shortObj = (s: string): string => (s.length > 90 ? `${s.slice(0, 87)}…` : s);
+/** v0.28.30: terminology — a list item is not a goal (user note: "we seem
+ * to call everything goal"). User-facing pause/abort notifies name the policy. */
+const goalNoun = (): string => (state.goal?.policy === "list" ? "List item" : "Goal");
 function notifyPersistenceState(ctx: ExtensionContext): void {
   if (isPersistenceDegraded() && !persistenceDegradedNotified) {
     persistenceDegradedNotified = true;
@@ -1521,7 +1524,7 @@ async function cmdCancel(ctx: ExtensionContext): Promise<void> {
   }
   archiveCurrentGoal(ctx, "aborted", "user cancelled");
   ctx.abort();
-  ctx.ui.notify(`Goal aborted.${isLoopActive() ? " A loop is still active — /loop stop ends it." : ""}`, "info");
+  ctx.ui.notify(`${goalNoun()} aborted.${isLoopActive() ? " A loop is still active — /loop stop ends it." : ""}`, "info");
 }
 
 // ---- v0.28.23: decision picker popup ----
@@ -2837,8 +2840,8 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
             pauseSuggestedAction: "Fix the auditor model (/glla model=provider/id) or restart pi, then /goal resume. Your work was NOT judged.",
           }, ctx);
           appendLedger(ctx.cwd, "goal_paused", { reason: `auditor infra streak ${infraStreak}: ${result.error.slice(0, 120)}` });
-          ctx.ui.notify(`Goal paused: auditor infrastructure failed ${infraStreak}× in a row. Fix the auditor model (/glla model=...), then /goal resume.`, "warning");
-          notifyExternal(ctx, `Goal paused: auditor infrastructure ${infraStreak}× — model likely broken.`);
+          ctx.ui.notify(`${goalNoun()} paused: auditor infrastructure failed ${infraStreak}× in a row. Fix the auditor model (/glla model=...), then /goal resume.`, "warning");
+          notifyExternal(ctx, `${goalNoun()} paused: auditor infrastructure ${infraStreak}× — model likely broken.`);
           return {
             content: [{
               type: "text",
@@ -2945,7 +2948,7 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
           pauseReason: `auditor disapproved ${trailingDisapprovals}× consecutively (cap ${auditCap})`,
           pauseSuggestedAction: "Read the audit history (/goal status), fix the actual gap or /goal tweak the objective, then /goal resume. Raise the cap with /glla auditcap=N.",
         }, ctx);
-        ctx.ui.notify(`Goal paused: auditor disapproved ${trailingDisapprovals}× consecutively (cap ${auditCap}). /goal status for the reports; /goal resume to continue.`, "warning");
+        ctx.ui.notify(`${goalNoun()} paused: auditor disapproved ${trailingDisapprovals}× consecutively (cap ${auditCap}). /goal status for the reports; /goal resume to continue.`, "warning");
           maybeDecisionPopup(ctx);
         appendLedger(ctx.cwd, "goal_paused", { reason: `disapproval cap: ${trailingDisapprovals} consecutive (cap ${auditCap})` });
         notifyExternal(ctx, `Goal paused: ${trailingDisapprovals} consecutive auditor disapprovals`);
@@ -3005,8 +3008,8 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       // action. Before, the action only appeared in /goal status and the
       // widget truncated both at ~60 chars, so decision-pauses ("choose a
       // or b") reached the user as an unreadable fragment.
-      ctx.ui.notify(`Goal paused: ${p.reason}${p.suggestedAction ? `\n\n→ ${p.suggestedAction}` : ""}`, "info");
-      notifyExternal(ctx, `Goal paused: ${(p.suggestedAction ? `${p.reason} → ${p.suggestedAction}` : p.reason).slice(0, 200)}`);
+      ctx.ui.notify(`${goalNoun()} paused: ${p.reason}${p.suggestedAction ? `\n\n→ ${p.suggestedAction}` : ""}`, "info");
+      notifyExternal(ctx, `${goalNoun()} paused: ${(p.suggestedAction ? `${p.reason} → ${p.suggestedAction}` : p.reason).slice(0, 200)}`);
       return { content: [{ type: "text", text: "Goal paused. /goal resume to continue." }], details: {} };
     },
   }));
@@ -4182,6 +4185,64 @@ function cmdLog(args: string, ctx: ExtensionContext): void {
   ctx.ui.notify(`Ledger tail (last ${tail.length}${all ? "" : " non-noise"} events — /glla log <N> for more, /glla log all to include noise):\n${lines.join("\n")}`, "info");
 }
 
+/**
+ * v0.28.31: /glla reset — ONE confirmed command that leaves a project with
+ * zero live glla state. User directive: "make sure we only have one goal or
+ * loop or list at a time — many of my older projects have leftovers" (the
+ * fleet scan found queued lists up to 56 deep, held loops at iter 50, and
+ * paused goals across ~10 projects). The goal is archived HONESTLY (aborted
+ * — lands in goals/ + the archive, reviewer's abort-suppression applies),
+ * the list is cleared, the loop record is wiped after a graceful stop.
+ * History stays in .pi-glla; only the live state goes.
+ */
+async function cmdGllaReset(ctx: ExtensionContext): Promise<void> {
+  const g = state.goal;
+  const live = g && (g.status === "active" || g.status === "paused" || g.status === "auditing");
+  const n = listQueue().length;
+  const loop = state.loop;
+  if (!g && n === 0 && !loop) {
+    ctx.ui.notify("glla state is already clean — no goal, no list, no loop.", "info");
+    return;
+  }
+  const parts: string[] = [];
+  if (live) parts.push(`goal archived as aborted: ${g!.objective.replace(/\s+/g, " ").slice(0, 70)}`);
+  else if (g) parts.push(`terminal goal record cleared (${g.status})`);
+  if (n > 0) parts.push(`list cleared (${n} item${n === 1 ? "" : "s"})`);
+  if (loop) parts.push(`loop ${loop.active ? "stopped" : "cleared"} (iter ${loop.iteration}${loop.bestValue !== null && loop.bestValue !== undefined ? `, best ${loop.bestValue}` : ""})`);
+  if (ctx.hasUI) {
+    try {
+      const ok = await ctx.ui.confirm("Reset glla state?", `${parts.map((p) => `  ${p}`).join("\n")}\n\nHistory stays in .pi-glla (archive + ledger); the live state is wiped.`);
+      if (!ok) {
+        ctx.ui.notify("Reset cancelled.", "info");
+        return;
+      }
+    } catch {
+      ctx.ui.notify("Reset cancelled.", "info");
+      return;
+    }
+  }
+  appendLedger(ctx.cwd, "glla_reset", { goalId: live ? g!.id : undefined, listCleared: n, loop: loop ? { iteration: loop.iteration, active: loop.active } : undefined });
+  if (live) {
+    archiveCurrentGoal(ctx, "aborted", "user reset (/glla reset)");
+    ctx.abort();
+  } else if (g) {
+    state = { ...state, goal: null };
+  }
+  if (n > 0) {
+    state = { ...state, list: [] };
+    appendLedger(ctx.cwd, "list_cleared", { via: "glla_reset" });
+  }
+  if (loop) {
+    clearLoopTimer();
+    state.loop = undefined;
+    await finishLoopGit(ctx, loop);
+    appendLedger(ctx.cwd, "loop_stopped", { reason: "user reset (/glla reset)", iterations: loop.iteration, best: loop.bestValue });
+  }
+  persistState(ctx);
+  ctx.ui.notify(`glla reset done: ${parts.join(" · ")}. Clean slate.`, "info");
+  notifyExternal(ctx, "glla state reset by user — clean slate.");
+}
+
 function cmdAudits(args: string, ctx: ExtensionContext): void {
   const full = /\bfull\b/.test(args);
   const all = /\b(?:all|global|log)\b/.test(args);
@@ -4239,6 +4300,11 @@ async function cmdSettings(args: string, ctx: ExtensionContext): Promise<void> {
     cmdLog(trimmed.slice("log".length).trim(), ctx);
     return;
   }
+  // v0.28.31: /glla reset — one-shot clean slate for leftover-laden projects.
+  if (/^reset\b/.test(trimmed)) {
+    await cmdGllaReset(ctx);
+    return;
+  }
   if (/^reviewer\b/.test(trimmed)) {
     await cmdReviewerSettings(ctx);
     return;
@@ -4630,6 +4696,7 @@ export default function (pi: ExtensionAPI): void {
       ["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)"],
       ["log", "event-trail tail: /glla log [N] — who created/resumed/paused what, from where (v0.28.28)"],
+      ["reset", "wipe live glla state (goal archived, list cleared, loop stopped) — one-shot cleanup for leftover-laden projects"],
       ["auditfeedbackchars=", "cap on executor-visible disapproval report chars (0 = full report, the default)"],
       ["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)"],
@@ -5057,7 +5124,7 @@ export default function (pi: ExtensionAPI): void {
             pauseReason: `stalled: ${HEARTBEAT_MAX_NUDGES} consecutive unproductive turns (no tools, short or repetitive)`,
             pauseSuggestedAction: "Inspect the goal — /goal resume to retry, /goal tweak to narrow it, /goal cancel to abort.",
           }, ctx);
-          ctx.ui.notify(`Goal paused: stalled (${HEARTBEAT_MAX_NUDGES} unproductive turns).`, "warning");
+          ctx.ui.notify(`${goalNoun()} paused: stalled (${HEARTBEAT_MAX_NUDGES} unproductive turns).`, "warning");
           maybeDecisionPopup(ctx);
           notifyExternal(ctx, "Goal paused: stalled (no tool calls).");
           return;
@@ -5106,7 +5173,7 @@ export default function (pi: ExtensionAPI): void {
           pauseReason: `token limit exceeded (${used.toLocaleString()} > ${limit.toLocaleString()})`,
           pauseSuggestedAction: "/glla tokenlimit=<n> to raise the cap (or 0 to disable), then /goal resume",
         }, ctx);
-        ctx.ui.notify(`Goal paused: token limit exceeded (${used.toLocaleString()} > ${limit.toLocaleString()}). /glla tokenlimit=<n> to raise, 0 to disable.`, "warning");
+        ctx.ui.notify(`${goalNoun()} paused: token limit exceeded (${used.toLocaleString()} > ${limit.toLocaleString()}). /glla tokenlimit=<n> to raise, 0 to disable.`, "warning");
         notifyExternal(ctx, `Goal paused: token limit exceeded (${used} > ${limit}).`);
         return;
       }

package/package.json

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