pi-goal-list-loop-audit 0.28.13 → 0.28.14

package/extensions/goal-settings.ts

@@ -33,6 +33,11 @@ export interface Settings {
   /** on → restored goals/loops/lists auto-resume even in fresh sessions
    * (unattended rigs). Default off: restore holds until /goal resume. */
   autoResume?: boolean;
+  /** v0.28.14: what happens to stale carryover (paused goal, waiting list,
+   * held loop from before this session) when NEW work activates.
+   * pause (default) = leave it + ONE summary; clear = drop it all honestly;
+   * resume = legacy silent stacking. */
+  carryover?: "resume" | "pause" | "clear";
   /** v0.24.2: pause the goal after N consecutive auditor disapprovals (0 = unlimited).
    * Default 5 (raised from 3 in v0.25.0, contract item 7). */
   auditCap?: number;
@@ -146,6 +151,7 @@ export const SETTINGS_KEYS: Array<keyof Settings> = [
   "tokenLimit",
   "wedgeAlertMinutes",
   "autoResume",
+  "carryover",
   "autoAcceptDrafts",
   "auditCap",
   "auditFeedbackChars",

package/extensions/loops/goal.ts

@@ -289,6 +289,56 @@ async function confirmDraft(ctx: ExtensionContext, title: string, body: string):
   }
 }
 
+// v0.28.14: ONE summary + policy application for stale carryover when NEW
+// work activates. pause (default): surface what's waiting, stack nothing
+// silently. clear: drop the queue, dismiss the held loop, archive the
+// paused goal — honestly, with a ledger trail. resume: legacy silent
+// behavior. A new GOAL replacing a paused one archives it in every policy
+// (one-active-thing: state.goal holds exactly one goal).
+function resolveCarryover(ctx: ExtensionContext, trigger: "goal" | "loop"): void {
+  if (carryoverResolved || !carryoverSnapshot) return;
+  carryoverResolved = true;
+  const snap = carryoverSnapshot;
+  carryoverSnapshot = null;
+  const policy = loadSettings(ctx.cwd).carryover ?? "pause";
+  if (policy === "resume") return; // legacy silent stacking
+  const done: string[] = [];
+  const waiting: string[] = [];
+  const pausedGoal = state.goal && state.goal.status === "paused" ? state.goal : null;
+  if (pausedGoal && (trigger === "goal" || policy === "clear")) {
+    archiveCurrentGoal(ctx, "aborted", trigger === "goal" ? "replaced by new goal (carryover)" : "carryover cleared");
+    done.push(`archived paused goal "${(snap.pausedGoal ?? pausedGoal.objective).slice(0, 60)}"`);
+  } else if (snap.pausedGoal) {
+    waiting.push(`paused goal "${snap.pausedGoal}" (/goal resume)`);
+  }
+  if (snap.listCount > 0) {
+    if (policy === "clear") {
+      state = { ...state, list: [] };
+      done.push(`dropped ${snap.listCount} waiting list item(s)`);
+    } else {
+      waiting.push(`${snap.listCount} waiting list item(s) (/list next)`);
+    }
+  }
+  if (snap.heldLoop) {
+    if (policy === "clear" && state.loop && !state.loop.active && state.loop.stopReason === HELD_ON_RESTORE) {
+      state.loop = { ...state.loop, stopReason: "cleared: carryover" };
+      done.push(`dismissed held loop "${snap.heldLoop}"`);
+    } else {
+      waiting.push(`held loop "${snap.heldLoop}" (/loop to resume)`);
+    }
+  }
+  persistState(ctx);
+  appendLedger(ctx.cwd, "carryover_resolved", { policy, trigger, cleared: done.length, waiting: waiting.length });
+  const summary = [...done.map((d) => `✂ ${d}`), ...waiting.map((w) => `⏸ ${w}`)].join(" · ");
+  if (!summary) return;
+  ctx.ui.notify(
+    policy === "clear"
+      ? `Carryover cleared (${trigger}): ${summary}`
+      : `Carryover from before this session: ${summary}${waiting.length > 0 ? " — /glla carryover=clear drops these automatically." : ""}`,
+    "info",
+  );
+}
+
 // The most recent ExtensionContext seen from any event or command handler.
 // pi replaces sessions (newSession/fork/reload) and stale ctx throws on use,
 // so timers must never capture a ctx — they read lastCtx at fire time.
@@ -352,6 +402,11 @@ let postRestoreGraceTurns = 0;
 // refire's own noteActivity, which is what made the hegemon zombie spin
 // self-sustaining (619 refires / 23.5h / zero turns).
 let consecutiveStalls = 0;
+// v0.28.14: carryover snapshot — unfinished work loaded from disk at
+// session_start (predates this session). Resolved ONCE per session at the
+// first NEW activation (new goal / new loop) per the carryover setting.
+let carryoverSnapshot: { pausedGoal?: string; listCount: number; heldLoop?: string } | null = null;
+let carryoverResolved = true;
 // v0.26.6: precise replacement for the removed ship-recency suppression —
 // set while complete_goal's isolated audit runs, so the heartbeat never
 // refires into an in-flight completion.
@@ -807,7 +862,13 @@ function notifyPersistenceState(ctx: ExtensionContext): void {
 }
 
 function setGoal(goal: Goal, ctx: ExtensionContext): void {
-  state = { goal, list: state.list ?? [] }; // preserve the list!
+  // v0.28.14: never silently orphan a live goal — a paused/active goal
+  // being replaced is archived honestly first (the old behavior left it in
+  // goals/ but untracked: "older goals lying around leading to confusion").
+  if (state.goal && state.goal.id !== goal.id && (state.goal.status === "active" || state.goal.status === "paused")) {
+    archiveCurrentGoal(ctx, "aborted", `replaced by goal ${goal.id}`);
+  }
+  state = { ...state, goal }; // preserve list AND loop (v0.28.14: the bare reconstruction used to nuke a held/active loop whenever a goal was set)
   const file = writeGoalMd(ctx.cwd, goal);
   state.goal!.activePath = path.relative(ctx.cwd, file) || file;
   persistState(ctx);
@@ -838,7 +899,7 @@ function archiveCurrentGoal(ctx: ExtensionContext, status: Status, stopReason?:
   if (archived) {
     try { fs.unlinkSync(goalMdPath(ctx.cwd, goal.id)); } catch {}
   }
-  state = { goal: { ...goal, status, archivedPath: path.relative(ctx.cwd, target) || target, stopReason }, list: state.list ?? [] };
+  state = { ...state, goal: { ...goal, status, archivedPath: path.relative(ctx.cwd, target) || target, stopReason } };
   appendLedger(ctx.cwd, "goal_archived", { goalId: goal.id, status, stopReason });
   persistState(ctx);
   // Loop 2: a list-sourced goal COMPLETED → auto-activate the next item.
@@ -957,6 +1018,13 @@ function listQueue(): NonNullable<State["list"]> {
 }
 
 function activateNextListItem(ctx: ExtensionContext, n = 1): boolean {
+  // v0.28.14: one-active-thing choke point — NO call site (session_start,
+  // completion cascade, /list next, list_activate, list-draft auto-activate)
+  // may activate a list item over a live loop, present or future.
+  if (isLoopActive()) {
+    appendLedger(ctx.cwd, "list_activation_blocked_loop", {});
+    return false;
+  }
   const queue = listQueue();
   const taken = takeAt(queue, n);
   if (!taken) return false;
@@ -1110,6 +1178,7 @@ async function cmdSet(args: string, ctx: ExtensionContext, skipDraft = false): P
     return;
   }
   draftingTarget = null; // explicit objective cancels any drafting session
+  resolveCarryover(ctx, "goal"); // v0.28.14: surface/clear stale leftovers
   const goal = createGoal(raw, ctx);
   setGoal(goal, ctx);
   // Reset counters
@@ -1194,10 +1263,17 @@ async function cmdResume(ctx: ExtensionContext): Promise<void> {
 }
 
 async function cmdCancel(ctx: ExtensionContext): Promise<void> {
-  if (!state.goal) return;
+  if (!state.goal) {
+    // v0.28.14: users reach for /goal cancel to kill a LOOP (no goal
+    // active) — point at the right verb instead of doing nothing silently.
+    if (isLoopActive()) {
+      ctx.ui.notify("No goal to cancel — a LOOP is active: /loop stop (or /loop cancel) ends it.", "info");
+    }
+    return;
+  }
   archiveCurrentGoal(ctx, "aborted", "user cancelled");
   ctx.abort();
-  ctx.ui.notify("Goal aborted.", "info");
+  ctx.ui.notify(`Goal aborted.${isLoopActive() ? " A loop is still active — /loop stop ends it." : ""}`, "info");
 }
 
 async function cmdGoals(ctx: ExtensionContext): Promise<void> {
@@ -1464,6 +1540,11 @@ async function cmdList(args: string, ctx: ExtensionContext): Promise<void> {
       ctx.ui.notify(`Usage: /list next [1-${listQueue().length || 1}]`, "info");
       return;
     }
+    // v0.28.14: one-active-thing — /list next must not jump a live loop.
+    if (isLoopActive()) {
+      ctx.ui.notify("A loop is active — /loop stop it before activating a list item.", "warning");
+      return;
+    }
     if (state.goal && state.goal.status === "active") {
       archiveCurrentGoal(ctx, "aborted", `skipped via /list next ${n > 1 ? n : ""}`.trim());
     }
@@ -1912,6 +1993,7 @@ async function startLoopFromConfig(ctx: ExtensionContext, cfg: LoopConfig): Prom
     );
     return false;
   }
+  resolveCarryover(ctx, "loop"); // v0.28.14: surface/clear stale leftovers
   state = {
     ...state,
     loop: {
@@ -1965,6 +2047,12 @@ async function cmdLoop(args: string, ctx: ExtensionContext): Promise<void> {
     }
     const stored = state.loop;
     if (stored && !stored.active && stored.stopReason === HELD_ON_RESTORE) {
+      // v0.28.14: one-active-thing — a held loop must not resume over an
+      // active goal/list-item (this was the last unguarded stacking path).
+      if (state.goal && state.goal.status === "active") {
+        ctx.ui.notify("A goal is active — the held loop stays held. /goal pause or /goal cancel it first, then /loop to resume.", "warning");
+        return;
+      }
       state.loop = { ...stored, active: true, stopReason: undefined };
       persistState(ctx);
       scheduleLoopTick(ctx);
@@ -2026,13 +2114,15 @@ async function cmdLoop(args: string, ctx: ExtensionContext): Promise<void> {
     return;
   }
 
-  if (sub === "stop") {
+  // v0.28.14: /loop cancel is a first-class alias — users reached for
+  // /goal cancel to kill loops because "cancel" is the verb they know.
+  if (sub === "stop" || sub === "cancel") {
     if (!state.loop) {
       ctx.ui.notify("No loop to stop.", "info");
       return;
     }
     clearLoopTimer();
-    state.loop = { ...state.loop, active: false, stopReason: state.loop.stopReason ?? "stopped by user (/loop stop)" };
+    state.loop = { ...state.loop, active: false, stopReason: state.loop.stopReason ?? `stopped by user (/loop ${sub})` };
     persistState(ctx);
     await finishLoopGit(ctx, state.loop);
     appendLedger(ctx.cwd, "loop_stopped", { reason: "user", iterations: state.loop.iteration, best: state.loop.bestValue });
@@ -2646,6 +2736,12 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
         };
       }
       const liveCtx = (execCtx as ExtensionContext | undefined) ?? ctx;
+      // v0.28.14: one-active-thing EARLY guard — refuse the whole interview
+      // when a loop is live (the post-confirm backstop below stays: state
+      // can change mid-interview).
+      if (isLoopActive()) {
+        return { content: [{ type: "text", text: "A loop is active — one active thing at a time. The user must /loop stop it before a goal or list item can activate; do not re-propose until then." }], details: {} };
+      }
       // v0.14.0: the interview floor — no Confirm until the user replied.
       // v0.23.8: /glla autoaccept=on skips the floor AND the Confirm —
       // the seed carries the intent (unattended rigs). Default off.
@@ -2745,6 +2841,11 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       const confirmedTarget = draftingTarget;
       draftingTarget = null;
       const full = p.objective.trim() + (normContract ? `\nDone when:\n${normContract}` : "");
+      // v0.28.14: one-active-thing — no goal/list activation over a live loop.
+      if (isLoopActive()) {
+        return { content: [{ type: "text", text: "A loop is active — one active thing at a time. The user must /loop stop it before a goal or list item can activate; do not re-propose until then." }], details: {} };
+      }
+      resolveCarryover(liveCtx, "goal"); // v0.28.14: surface/clear stale leftovers
       // List drafting: the confirmed contract goes into the QUEUE, not active.
       if (confirmedTarget === "list") {
         const extracted = extractVerificationContract(full);
@@ -2795,6 +2896,11 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
           details: {},
         };
       }
+      // v0.28.14: one-active-thing EARLY guard — refuse before the
+      // interview floor (a live goal blocks any loop proposal).
+      if (state.goal && state.goal.status === "active") {
+        return { content: [{ type: "text", text: "A goal is active — one active thing at a time. The user must /goal pause or /goal cancel it before a loop can start; do not re-propose until then." }], details: {} };
+      }
       // v0.14.0: the interview floor — no Confirm until the user replied.
       if (draftingUserReplies === 0) draftingBlockedProposals++;
       const loopBlock = draftProposalBlock(draftingUserReplies, draftingBlockedProposals);
@@ -2810,6 +2916,12 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
         return { content: [{ type: "text", text: 'direction=min|max is required for a measured loop (omit measureCmd or pass "none" for a metricless spec loop).' }], details: {} };
       }
       const liveCtx = (execCtx as ExtensionContext | undefined) ?? ctx;
+      // v0.28.14: one-active-thing — refuse to even test-run a loop measure
+      // while a goal/list-item is active (the /loop start COMMAND guards
+      // this; the tool path used to skip it and stack a loop over a goal).
+      if (state.goal && state.goal.status === "active") {
+        return { content: [{ type: "text", text: "A goal is active — one active thing at a time. The user must /goal pause or /goal cancel it before a loop can start; do not re-propose until then." }], details: {} };
+      }
       // THE TEST-RUN: orchestrator runs the proposed measure once. The user
       // sees the real number before a single iteration burns tokens.
       // (Metricless loops skip this — there is no measure to test-run.)
@@ -3019,6 +3131,10 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
         return { content: [{ type: "text", text: "n must be a positive integer (1-based position)." }], details: {} };
       }
       const liveCtx = (execCtx as ExtensionContext | undefined) ?? ctx;
+      // v0.28.14: one-active-thing — a list item must not jump a live loop.
+      if (isLoopActive()) {
+        return { content: [{ type: "text", text: "A loop is active — one active thing at a time. The user must /loop stop it before a list item can activate." }], details: {} };
+      }
       if (state.goal && state.goal.status === "active") {
         archiveCurrentGoal(liveCtx, "aborted", "skipped via list_activate");
       }
@@ -3812,6 +3928,14 @@ async function cmdSettings(args: string, ctx: ExtensionContext): Promise<void> {
       } else {
         ctx.ui.notify(`autoresume must be on or off, got: ${value}`, "warning");
       }
+    } else if (key === "carryover") {
+      if (["resume", "pause", "clear"].includes(value)) {
+        patch.carryover = value as "resume" | "pause" | "clear";
+        changed = true;
+        ctx.ui.notify(`carryover=${value}: ${value === "clear" ? "stale goals/lists/held-loops are dropped when new work activates" : value === "pause" ? "stale carryover is surfaced in one summary when new work activates (default)" : "legacy behavior — carryover stacks silently"}.`, "info");
+      } else {
+        ctx.ui.notify(`carryover must be resume, pause, or clear, got: ${value}`, "warning");
+      }
     } else if (key === "autoaccept") {
       if (["on", "true", "1", "yes"].includes(value)) {
         patch.autoAcceptDrafts = true;
@@ -3935,7 +4059,7 @@ async function cmdSettings(args: string, ctx: ExtensionContext): Promise<void> {
     }
   }
   if (!changed) {
-    ctx.ui.notify("Nothing changed. Use key=value (model, thinking, notify, tokenlimit, autoresume, auditcap, auditfeedbackchars, aggressivemode, quotaretryminutes, stuckmax), optionally prefixed with 'project'.", "info");
+    ctx.ui.notify("Nothing changed. Use key=value (model, thinking, notify, tokenlimit, autoresume, carryover, auditcap, auditfeedbackchars, aggressivemode, quotaretryminutes, stuckmax), optionally prefixed with 'project'.", "info");
     return;
   }
   saveSettings(scope, ctx.cwd, patch);
@@ -4253,6 +4377,15 @@ export default function (pi: ExtensionAPI): void {
     // a foreign session.
     if (isForeignCtx(ctx)) return;
     state = readState(ctx.cwd);
+    // v0.28.14: snapshot carryover BEFORE any restore logic mutates state —
+    // a paused goal, waiting list items, or a loop that was live/held when
+    // the last session ended. Resolved once at the first NEW activation.
+    carryoverSnapshot = {
+      pausedGoal: state.goal && state.goal.status === "paused" ? state.goal.objective.slice(0, 60) : undefined,
+      listCount: listQueue().length,
+      heldLoop: state.loop && (state.loop.active || state.loop.stopReason === HELD_ON_RESTORE) ? state.loop.target.slice(0, 60) : undefined,
+    };
+    carryoverResolved = !(carryoverSnapshot.pausedGoal || carryoverSnapshot.listCount > 0 || carryoverSnapshot.heldLoop);
     if (!registeredCtx) {
       registerAgentTools(pi, ctx);
       registeredCtx = ctx;

package/package.json

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