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

package/extensions/goal-settings.ts

@@ -152,6 +152,21 @@ export function loadSettings(cwd: string): Settings {
   ) as unknown as Settings;
 }
 
+/**
+ * v0.29.5: autoResume is GLOBAL-only (user directive 2026-07-30: "we are
+ * not supporting project level setting for it now, just global"). Launch-
+ * time restore reads this, never the project file — a stale autoResume
+ * key in a project's settings.json is ignored (junk-runner field case: a
+ * project-local opt-in from the unattended-audit era kept auto-firing the
+ * list at every bare `pi` launch after the global default flipped off).
+ */
+export function loadGlobalSettings(): Settings {
+  return mergeSettings(
+    DEFAULT_SETTINGS as unknown as Record<string, unknown>,
+    readSettingsFile(globalSettingsPath()) as Record<string, unknown>,
+  ) as unknown as Settings;
+}
+
 /** Every provenance-tracked key (the /glla headless display + UI). */
 export const SETTINGS_KEYS: Array<keyof Settings> = [
   "auditorModel",

package/extensions/loops/goal.ts

@@ -106,6 +106,7 @@ import {
   DEFAULT_SETTINGS,
   SETTINGS_KEYS,
   globalSettingsPath,
+  loadGlobalSettings,
   loadSettings,
   projectSettingsPath,
   saveSettings,
@@ -706,6 +707,10 @@ function heartbeatTick(): void {
     ctx.ui.notify(msg, "warning");
     notifyExternal(ctx, msg);
   }
+  // v0.29.5: user-abort stand-down — the chain stays DOWN until the
+  // user resumes. Without this guard the 60s heartbeat re-fired the
+  // continuation and defeated the 0.29.4 stand-down within a minute.
+  if (abortedStandDown) return;
   if (!fire) return;
   // v0.26.6: the 0.25.0 "recent ship (<5m)" suppression was REMOVED. It fed
   // lastShippedAtMs, which read the state-file MTIME — and the heartbeat's
@@ -747,6 +752,10 @@ let consecutiveErrorIterations = 0;
 // v0.28.5 (E8): user aborts are NOT provider errors — separate counter,
 // separate brake message, and no auto-resume (aborting is user intent).
 let consecutiveAbortIterations = 0;
+// v0.29.5: set when a user abort stands the chain down (0.29.4) — the
+// heartbeat refire + post-compaction refire must NOT resurrect it; only
+// an explicit schedule (resume/activate/next turn) clears it.
+let abortedStandDown = false;
 let consecutiveNoToolIterations = 0;
 
 // =================================================================
@@ -779,6 +788,7 @@ function freshCtx(): ExtensionContext | null {
 }
 
 function scheduleContinuation(ctx: ExtensionContext, force = false, delayMs?: number): void {
+  abortedStandDown = false; // v0.29.5: any explicit schedule ends the stand-down
   if (!isActionableGoal()) return;
   rememberCtx(ctx);
   const goalId = state.goal!.id;
@@ -993,6 +1003,43 @@ function updateGoal(patch: Partial<Goal>, ctx: ExtensionContext): void {
   persistState(ctx);
 }
 
+// v0.29.6: stacked-state auto-arbitration (user directive: "auto archive /
+// wipe extra goals/loops/lists … make sure that we only have one"). Dirty
+// pre-guard states can persist a live loop AND a live goal; the 0.28.21
+// decision picker asked the user to arbitrate artifacts they didn't
+// remember at every pi start. Now deterministic: MOST RECENT ACTIVITY
+// keeps the slot; the loser is ARCHIVED (recoverable), never wiped. The
+// queued list is a backlog, not a live artifact — untouched.
+function autoArbitrateStackedState(ctx: ExtensionContext): void {
+  const loop = state.loop?.active ? state.loop : undefined;
+  const goal = state.goal && state.goal.status !== "complete" && state.goal.status !== "aborted" ? state.goal : undefined;
+  if (!loop || !goal) return; // at most one live artifact — the invariant holds
+  const lastMeasure = loop.history.length > 0 ? loop.history[loop.history.length - 1] : undefined;
+  const loopMs = Date.parse(lastMeasure?.at ?? loop.startedAt ?? "") || 0;
+  const goalMs = Date.parse(goal.updatedAt ?? goal.createdAt ?? "") || 0;
+  const keepGoal = goalMs > loopMs; // tie → the loop keeps the slot (0.28.21 default)
+  appendLedger(ctx.cwd, "stacked_state_auto_arbitrated", {
+    kept: keepGoal ? "goal" : "loop",
+    goalId: goal.id,
+    goalMs,
+    loopMs,
+    loopIteration: loop.iteration,
+    loopTarget: loop.target.slice(0, 120),
+  });
+  if (keepGoal) {
+    // Same shape as /loop stop: the loop record stays in state (inactive)
+    // with an honest reason — /loop status still shows it.
+    state = { ...state, loop: { ...loop, active: false, stopReason: "auto-arbitrated on session load: the goal was more recent (one active thing)" } };
+    persistState(ctx);
+  } else {
+    archiveCurrentGoal(ctx, "aborted", "auto-arbitrated on session load: the loop was more recent (one active thing)");
+  }
+  ctx.ui.notify(
+    `Stacked state auto-arbitrated (one active thing): kept the ${keepGoal ? "goal" : "loop"} — more recent activity — and archived the ${keepGoal ? `loop (iter ${loop.iteration}, best ${loop.bestValue ?? "n/a"})` : `goal (${goal.id})`}. Recoverable: /loop status · .pi-glla/archive/ · /glla wipe for a clean slate.`,
+    "info",
+  );
+}
+
 function archiveCurrentGoal(ctx: ExtensionContext, status: Status, stopReason?: string): void {
   if (!state.goal) return;
   const goal = state.goal;
@@ -1223,7 +1270,7 @@ function fireReviewer(
       manual: opts.manual,
       ledgerEntries,
       sources,
-      enqueueListItems: (objectives) => enqueueItems(ctx, objectives, "reviewer", { autoActivate: loadSettings(ctx.cwd).autoResume === true }),
+      enqueueListItems: (objectives) => enqueueItems(ctx, objectives, "reviewer", { autoActivate: loadGlobalSettings().autoResume === true }),
       proposeGoal: (objective, reason) => {
         try {
           extensionApi?.sendUserMessage(
@@ -5060,7 +5107,7 @@ export default function (pi: ExtensionAPI): void {
       const c = freshCtx();
       if (!c) return;
       try {
-        if (c.isIdle() && !c.hasPendingMessages() && continuationTimer === null && loopTimer === null && isSupervising()) {
+        if (c.isIdle() && !c.hasPendingMessages() && continuationTimer === null && loopTimer === null && isSupervising() && !abortedStandDown) {
           appendLedger(c.cwd, "compaction_refire", {});
           if (isLoopActive()) scheduleLoopTick(c);
           else scheduleContinuation(c, true);
@@ -5182,15 +5229,19 @@ export default function (pi: ExtensionAPI): void {
     } catch (err) {
       ctx.ui.notify(`glla subagent override sync failed: ${err instanceof Error ? err.message : String(err)}`, "warning");
     }
+    // v0.29.6: stacked-state auto-arbitration FIRST — one live artifact
+    // survives before the restore gate decides hold-vs-resume for it.
+    autoArbitrateStackedState(ctx);
     // Restore gate (v0.26.9 tri-state): a human LOADING a session
     // ("startup"/"new"/"resume", or no reason) HOLDS — the popup shows what
     // is waiting and nothing starts until they resume explicitly. In-session
-    // machinery ("reload"/"fork") auto-resumes. /glla autoresume=on opts a
-    // project into auto-resume everywhere (unattended rigs); autoresume=off
-    // never auto-resumes. Once running, the chain auto-continues forever
-    // unless a super-stuck brake (stall escalation / stale-api / latch)
-    // stops it loudly.
-    const autoResumeSetting = resolveEffectiveAggressiveSettings(loadSettings(ctx.cwd)).autoResume;
+    // machinery ("reload"/"fork") auto-resumes. /glla autoresume=on opts
+    // into auto-resume everywhere (unattended rigs); autoresume=off never
+    // auto-resumes. v0.29.5: the setting is GLOBAL-only — project-level
+    // autoResume keys are ignored. Once running, the chain auto-continues
+    // forever unless a super-stuck brake (stall escalation / stale-api /
+    // latch) stops it loudly.
+    const autoResumeSetting = resolveEffectiveAggressiveSettings(loadGlobalSettings()).autoResume;
     const autoResume = shouldAutoResumeOnSessionStart(event?.reason, autoResumeSetting);
     // v0.25.0 (contract item 6): aggressiveMode announces every auto-event.
     if (
@@ -5212,7 +5263,7 @@ export default function (pi: ExtensionAPI): void {
         state.loop = { ...l, active: false, stopReason: HELD_ON_RESTORE };
         persistState(ctx);
         ctx.ui.notify(
-          `Loop held on restore: ${l.target.slice(0, 60)} — /loop resume to continue, /glla autoresume=on to auto-resume on session load in this project.`,
+          `Loop held on restore: ${l.target.slice(0, 60)} — /loop resume to continue, /glla autoresume=on to auto-resume on session load (global setting).`,
           "info",
         );
       }
@@ -5239,7 +5290,7 @@ export default function (pi: ExtensionAPI): void {
         // v0.22.7: name WHAT is held — a list head resumes through /list.
         const isListItem = state.goal.policy === "list";
         const resumeCmd = isListItem ? "/list resume" : "/goal resume";
-        const resumeHint = `${resumeCmd} to continue${queued > 0 ? ` (+${queued} waiting in the list)` : ""} · /glla autoresume=on to auto-resume in this project`;
+        const resumeHint = `${resumeCmd} to continue${queued > 0 ? ` (+${queued} waiting in the list)` : ""} · /glla autoresume=on to auto-resume on load (global setting)`;
         updateGoal({
           status: "paused",
           pauseKind: "blocked",
@@ -5265,31 +5316,10 @@ export default function (pi: ExtensionAPI): void {
         ctx.ui.notify(`List has ${listQueue().length} item(s) waiting — /list next to activate the head.`, "info");
       }
     }
-    // v0.28.21: enforce one-active-thing at the restore boundary for DIRTY
-    // legacy states — pre-guard versions could persist an active goal AND
-    // an active/held loop; the chain above handles the loop first, and the
-    // goal would otherwise stay active and fire on agent_end. Pause it:
-    // at most one thing owns the active slot, and nothing auto-starts.
-    if (state.loop && state.goal && state.goal.status === "active") {
-      updateGoal({
-        status: "paused",
-        pauseKind: "decision",
-        // v0.29.3: third option — the wipe escape. Old projects stack a
-        // goal AND a loop AND a list from pre-guard versions; arbitrating
-        // between two artifacts the user doesn't even remember is the odd
-        // part — "i feel like wipe does [make sense]". Wipe keeps its own
-        // Confirm (destructive), so picking it is safe to offer.
-        pauseOptions: ["Stop the loop, then resume the goal (/loop stop)", "Cancel the goal (/goal cancel) — the loop keeps running", "Wipe everything — clean slate for stale leftovers (/glla wipe)"],
-        pauseRecommended: 1,
-        pauseReason: "held on session load — the loop owns the active slot (one active thing at a time)",
-        pauseSuggestedAction: "/loop to work the loop, or /loop stop then /goal resume to work the goal",
-      }, ctx);
-      ctx.ui.notify(
-        `Goal held — a loop also exists; one active thing at a time. /loop to resume the loop, or /loop stop then /goal resume.`,
-        "info",
-      );
-      maybeDecisionPopup(ctx);
-    }
+    // v0.29.6: the 0.28.21 loop-vs-goal decision picker is SUPERSEDED by
+    // auto-arbitration above — stacked states resolve deterministically
+    // (most recent activity keeps the slot; the loser is archived) before
+    // the restore gate, so a live loop and a live goal cannot coexist here.
     // Always paint on session load (v0.22.1): the branches above only reach
     // refreshUI via persistState, so a goal that was ALREADY paused (or any
     // state that doesn't mutate on load) rendered nothing — "can't tell if
@@ -5529,6 +5559,7 @@ export default function (pi: ExtensionAPI): void {
       // was answered by another turn under the user's hands ("it auto
       // triggered and I kept spamming esc on it" — pully, 2026-07-30).
       ctx.ui.notify(`${goalNoun()} standing down — turn aborted by user (not counted toward stalls). /goal resume to continue, /goal cancel to stop.`, "info");
+      abortedStandDown = true; // v0.29.5: heartbeat/compaction refires must not resurrect the chain
       appendLedger(ctx.cwd, "abort_stand_down", { consecutiveAborts: consecutiveAbortIterations });
       return;
     } else {

package/package.json

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