pi-goal-list-loop-audit 0.28.30 → 0.28.32

package/extensions/loops/goal.ts

@@ -4185,6 +4185,134 @@ 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.");
+}
+
+/**
+ * v0.28.32: /glla resume — resume WHATEVER is resumable, without the user
+ * needing to know whether they're supervising a goal, a list item, or a
+ * held loop. Safe because one-active-thing is enforced (v0.28.14+): at
+ * most one thing can be ACTIVE, so the only ambiguity is paused-goal +
+ * held-loop coexisting (nothing running, two resumables — e.g. polis
+ * today) → the v0.28.23 decision-picker pattern. Verbs whose semantics
+ * genuinely differ per type (tweak/finish/next/decide/refine) stay typed.
+ */
+async function cmdGllaResume(ctx: ExtensionContext): Promise<void> {
+  const g = state.goal;
+  const goalResumable = g && g.status === "paused";
+  const loopResumable = state.loop && !state.loop.active && state.loop.stopReason === HELD_ON_RESTORE;
+  if (goalResumable && loopResumable) {
+    if (ctx.hasUI) {
+      try {
+        const loopLabel = `Resume the held loop (iter ${state.loop!.iteration}, best ${state.loop!.bestValue ?? "n/a"}): ${state.loop!.target.replace(/\s+/g, " ").slice(0, 80)}`;
+        const pick = await ctx.ui.select("Two things can resume — which one?", [
+          `Resume the ${g!.policy === "list" ? "list item" : "goal"}: ${g!.objective.replace(/\s+/g, " ").slice(0, 80)}`,
+          loopLabel,
+        ]);
+        if (pick === undefined) {
+          ctx.ui.notify("Resume cancelled.", "info");
+          return;
+        }
+        if (pick === loopLabel) {
+          await cmdLoop("resume", ctx);
+          return;
+        }
+        await cmdResume(ctx);
+        return;
+      } catch {
+        // picker failed — fall through to goal-first
+      }
+    }
+    await cmdResume(ctx);
+    return;
+  }
+  if (goalResumable) {
+    await cmdResume(ctx);
+    return;
+  }
+  if (loopResumable) {
+    await cmdLoop("resume", ctx);
+    return;
+  }
+  ctx.ui.notify("Nothing to resume — no paused goal/list-item, no held loop. /goal, /list, or /loop to start something.", "info");
+}
+
+/**
+ * v0.28.32: /glla cancel — cancel the ONE live thing, uniformly: a goal or
+ * list item is archived as aborted (its queue is untouched), an active or
+ * held loop is stopped. Same outcome shape regardless of hidden type —
+ * the user's caveat ("this sucks if one command doesn't work for others")
+ * is why /list cancel (item + drop queue) and /glla reset (nuke all)
+ * remain the power verbs instead of being folded in.
+ */
+async function cmdGllaCancel(ctx: ExtensionContext): Promise<void> {
+  const g = state.goal;
+  if (g && (g.status === "active" || g.status === "paused" || g.status === "auditing")) {
+    await cmdCancel(ctx);
+    return;
+  }
+  if (state.loop) {
+    await cmdLoop("stop", ctx);
+    return;
+  }
+  ctx.ui.notify("Nothing to cancel — no active/paused goal/list-item, no loop. Queued list items: /list clear; everything: /glla reset.", "info");
+}
+
 function cmdAudits(args: string, ctx: ExtensionContext): void {
   const full = /\bfull\b/.test(args);
   const all = /\b(?:all|global|log)\b/.test(args);
@@ -4242,6 +4370,21 @@ 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;
+  }
+  // v0.28.32: /glla resume + /glla cancel — type-blind verbs over the ONE
+  // live thing ("so we don't have to check what type we are running").
+  if (/^resume\b/.test(trimmed)) {
+    await cmdGllaResume(ctx);
+    return;
+  }
+  if (/^cancel\b/.test(trimmed)) {
+    await cmdGllaCancel(ctx);
+    return;
+  }
   if (/^reviewer\b/.test(trimmed)) {
     await cmdReviewerSettings(ctx);
     return;
@@ -4633,6 +4776,9 @@ 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"],
+      ["resume", "resume WHATEVER is paused/held (goal, list item, or held loop) — no need to know the type"],
+      ["cancel", "cancel the ONE live thing uniformly (goal/list item archived, loop stopped) — queue untouched; /list clear or /glla reset for more"],
       ["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)"],

package/package.json

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