pi-goal-list-loop-audit 0.20.0 → 0.21.0

package/extensions/goal-loop-core.ts

@@ -578,3 +578,16 @@ export function buildTaskSummary(tasks: Task[]): string {
 export function cloneGoal(goal: Goal): Goal {
   return JSON.parse(JSON.stringify(goal));
 }
+
+/**
+ * Session-restore gate (v0.21.0): a session that carries conversation
+ * history ("resume" | "reload" | "fork") IS the goal's own context —
+ * auto-resuming work there is natural. A fresh session ("startup" | "new",
+ * or an older pi that reports no reason) has no context — restored state
+ * HOLDS until an explicit /goal resume (or /glla autoresume=on, the rig
+ * setting for unattended restarts). One mechanical predicate; no heuristics.
+ */
+export function shouldAutoResumeOnSessionStart(reason: string | undefined, autoResume: boolean | undefined): boolean {
+  if (autoResume === true) return true;
+  return reason === "resume" || reason === "reload" || reason === "fork";
+}

package/extensions/goal-loop-display.ts

@@ -17,9 +17,11 @@ export function fmtElapsed(ms: number): string {
   const s = Math.floor(ms / 1000);
   if (s < 60) return `${s}s`;
   const m = Math.floor(s / 60);
-  if (m < 60) return `${m}m`;
+  // Seconds stay visible up to the hour: the elapsed counter is the
+  // liveness signal — minute-only granularity looks frozen on a 1s tick.
+  if (m < 60) return `${m}m ${String(s % 60).padStart(2, "0")}s`;
   const h = Math.floor(m / 60);
-  return `${h}h${m % 60}m`;
+  return `${h}h ${String(m % 60).padStart(2, "0")}m`;
 }
 
 export function fmtTokens(n: number): string {

package/extensions/loops/goal.ts

@@ -55,6 +55,7 @@ import {
   piGlaDir,
   readState,
   renderGoalMarkdown,
+  shouldAutoResumeOnSessionStart,
   statusLabel,
   writeGoalMd,
 } from "../goal-loop-core.js";
@@ -87,6 +88,8 @@ import {
 
 const GOAL_EVENT_ENTRY = "goal-event";
 const STATE_ENTRY = "goal-state";
+/** stopReason marker for a loop held (not stopped) by the fresh-session restore gate. */
+const HELD_ON_RESTORE = "held: restored in a fresh session";
 
 // =================================================================
 // Module-level state (one per session)
@@ -158,7 +161,7 @@ function startUITicker(): void {
   uiTicker = setInterval(() => {
     const ctx = freshCtx();
     if (ctx && isSupervising()) refreshUI(ctx);
-  }, 5_000);
+  }, 1_000);
   uiTicker.unref?.();
 }
 
@@ -1142,12 +1145,24 @@ async function cmdLoop(args: string, ctx: ExtensionContext): Promise<void> {
   const rest = args.trim().slice(sub.length).trim();
 
   if (!sub) {
-    // /loop with no args → draft the loop config (metric design is the whole
-    // game for a long-running loop; never start one blind).
+    // /loop with no args → resume a held loop if one is waiting; otherwise
+    // draft the loop config (metric design is the whole game for a
+    // long-running loop; never start one blind).
     if (isLoopActive()) {
       ctx.ui.notify("A loop is already active — /loop status to inspect, /loop stop to end it.", "info");
       return;
     }
+    const stored = state.loop;
+    if (stored && !stored.active && stored.stopReason === HELD_ON_RESTORE) {
+      state.loop = { ...stored, active: true, stopReason: undefined };
+      persistState(ctx);
+      scheduleLoopTick(ctx);
+      ctx.ui.notify(
+        `Loop resumed: iteration ${stored.iteration}/${stored.maxIterations} · best ${stored.bestValue ?? "n/a"} — ${stored.target.slice(0, 60)}`,
+        "info",
+      );
+      return;
+    }
     await startDrafting(ctx, "loop");
     return;
   }
@@ -1843,6 +1858,9 @@ interface Settings {
   notifyCmd?: string;
   /** Per-goal token budget; crossing it pauses the goal. Default 1,000,000. */
   tokenLimit?: number;
+  /** on → restored goals/loops/lists auto-resume even in fresh sessions
+   * (unattended rigs). Default off: restore holds until /goal resume. */
+  autoResume?: boolean;
 }
 
 const DEFAULT_SETTINGS: Settings = {
@@ -1887,7 +1905,7 @@ function settingsProvenance(cwd: string): Record<keyof Settings, { value: unknow
   const glob = readSettingsFile(globalSettingsPath());
   const effective = loadSettings(cwd);
   const out: Record<string, { value: unknown; source: "project" | "global" | "default" }> = {};
-  const keys: Array<keyof Settings> = ["auditorModel", "auditorThinkingLevel", "notifyCmd", "tokenLimit"];
+  const keys: Array<keyof Settings> = ["auditorModel", "auditorThinkingLevel", "notifyCmd", "tokenLimit", "autoResume"];
   for (const k of keys) {
     if ((proj as Record<string, unknown>)[k] !== undefined) out[k] = { value: (proj as any)[k], source: "project" };
     else if ((glob as Record<string, unknown>)[k] !== undefined) out[k] = { value: (glob as any)[k], source: "global" };
@@ -2046,6 +2064,7 @@ async function cmdSettings(args: string, ctx: ExtensionContext): Promise<void> {
         fmt("auditorThinkingLevel", "thinking"),
         fmt("notifyCmd", "notify"),
         fmt("tokenLimit", "tokenLimit"),
+        fmt("autoResume", "autoResume"),
         `\nglobal:  ${globalSettingsPath()}`,
         `project: ${projectSettingsPath(ctx.cwd)}`,
         `Set with: /glla key=value (global) · /glla project key=value (project override)`,
@@ -2084,6 +2103,16 @@ async function cmdSettings(args: string, ctx: ExtensionContext): Promise<void> {
       } else {
         ctx.ui.notify(`tokenlimit must be a positive integer, got: ${value}`, "warning");
       }
+    } else if (key === "autoresume") {
+      if (["on", "true", "1", "yes"].includes(value)) {
+        patch.autoResume = true;
+        changed = true;
+      } else if (["off", "false", "0", "no", "unset"].includes(value)) {
+        patch.autoResume = undefined;
+        changed = true;
+      } else {
+        ctx.ui.notify(`autoresume must be on or off, got: ${value}`, "warning");
+      }
     } else if (key === "thinking" || key === "auditorthinkinglevel") {
       if (["off", "minimal", "low", "medium", "high", "xhigh"].includes(value)) {
         patch.auditorThinkingLevel = value as Settings["auditorThinkingLevel"];
@@ -2094,13 +2123,13 @@ async function cmdSettings(args: string, ctx: ExtensionContext): Promise<void> {
     }
   }
   if (!changed) {
-    ctx.ui.notify("Nothing changed. Use key=value (model, thinking, notify, tokenlimit), optionally prefixed with 'project'.", "info");
+    ctx.ui.notify("Nothing changed. Use key=value (model, thinking, notify, tokenlimit, autoresume), optionally prefixed with 'project'.", "info");
     return;
   }
   saveSettings(scope, ctx.cwd, patch);
   const effective = loadSettings(ctx.cwd);
   ctx.ui.notify(
-    `Saved to ${scope} config. Effective now: model=${effective.auditorModel ?? "(session model)"} thinking=${effective.auditorThinkingLevel ?? "(session)"} notify=${effective.notifyCmd ?? "(off)"} tokenLimit=${effective.tokenLimit ?? 0}${(effective.tokenLimit ?? 0) > 0 ? "" : " (off)"}\n` +
+    `Saved to ${scope} config. Effective now: model=${effective.auditorModel ?? "(session model)"} thinking=${effective.auditorThinkingLevel ?? "(session)"} notify=${effective.notifyCmd ?? "(off)"} tokenLimit=${effective.tokenLimit ?? 0}${(effective.tokenLimit ?? 0) > 0 ? "" : " (off)"} autoResume=${effective.autoResume === true ? "on" : "off"}\n` +
     `Note: the auditor runs without extensions — it must be a built-in provider, not an extension-registered one.`,
     "info",
   );
@@ -2228,7 +2257,7 @@ export default function (pi: ExtensionAPI): void {
     }
   });
 
-  pi.on("session_start", async (_event: any, ctx: ExtensionContext) => {
+  pi.on("session_start", async (event: any, ctx: ExtensionContext) => {
     rememberCtx(ctx);
     state = readState(ctx.cwd);
     if (!registeredCtx) {
@@ -2237,27 +2266,60 @@ export default function (pi: ExtensionAPI): void {
     }
     warnOnCommandCollision(ctx);
     warnIfAuditorProviderRisky(ctx);
-    // Resumption notice: make persisted supervisor state visible on startup.
+    // Restore gate (v0.21.0): a fresh session ("startup"/"new", or a pi too
+    // old to report a reason) has no conversation context for the restored
+    // work — HOLD instead of auto-firing, so opening pi in a folder never
+    // starts working before you can even load your session. Sessions with
+    // history ("resume"/"reload"/"fork") auto-resume; /glla autoresume=on
+    // opts a project into auto-resume everywhere (unattended rigs).
+    const autoResume = shouldAutoResumeOnSessionStart(event?.reason, loadSettings(ctx.cwd).autoResume);
     if (isLoopActive()) {
       const l = state.loop!;
-      ctx.ui.notify(
-        `Resuming loop (iteration ${l.iteration}/${l.maxIterations}, best ${l.bestValue ?? "n/a"}, stall ${l.stallCount}/${l.plateauWindow}): ${l.target.slice(0, 60)}`,
-        "info",
-      );
+      if (autoResume) {
+        ctx.ui.notify(
+          `Resuming loop (iteration ${l.iteration}/${l.maxIterations}, best ${l.bestValue ?? "n/a"}, stall ${l.stallCount}/${l.plateauWindow}): ${l.target.slice(0, 60)}`,
+          "info",
+        );
+        scheduleLoopTick(ctx);
+      } else {
+        state.loop = { ...l, active: false, stopReason: HELD_ON_RESTORE };
+        persistState(ctx);
+        ctx.ui.notify(
+          `Loop held on restore (fresh session, no work started): ${l.target.slice(0, 60)} — /loop to resume, /glla autoresume=on to auto-resume in this project.`,
+          "info",
+        );
+      }
+    } else if (state.goal && state.goal.status === "active" && state.goal.autoContinue) {
+      if (autoResume) {
+        ctx.ui.notify(
+          `Resuming goal [${state.goal.id}]: ${state.goal.objective.slice(0, 70)}${listQueue().length > 0 ? ` (+${listQueue().length} queued)` : ""}`,
+          "info",
+        );
+        scheduleContinuation(ctx, true);
+      } else {
+        updateGoal({
+          status: "paused",
+          pauseReason: "restored in a fresh session — no work started",
+          pauseSuggestedAction: "/goal resume to continue · /glla autoresume=on to auto-resume in this project",
+        }, ctx);
+        ctx.ui.notify(
+          `Goal held on restore [${state.goal.id}]: ${state.goal.objective.slice(0, 70)} — /goal resume to continue.`,
+          "info",
+        );
+      }
     } else if (state.goal && state.goal.status === "active") {
+      // Active but autoContinue off: nothing auto-fires — just surface it.
       ctx.ui.notify(
-        `Resuming goal [${state.goal.id}]: ${state.goal.objective.slice(0, 70)}${listQueue().length > 0 ? ` (+${listQueue().length} queued)` : ""}`,
+        `Restored goal [${state.goal.id}]: ${state.goal.objective.slice(0, 70)}${listQueue().length > 0 ? ` (+${listQueue().length} queued)` : ""}`,
         "info",
       );
-    }
-    if (isLoopActive()) {
-      // Session restarted mid-loop: resume measuring from persisted state.
-      scheduleLoopTick(ctx);
-    } else if (state.goal && state.goal.status === "active" && state.goal.autoContinue) {
-      scheduleContinuation(ctx, true);
     } else if ((!state.goal || state.goal.status === "complete" || state.goal.status === "aborted") && listQueue().length > 0) {
-      // Session restarted with a non-empty queue but no active goal.
-      activateNextListItem(ctx);
+      if (autoResume) {
+        // Session restarted with a non-empty queue but no active goal.
+        activateNextListItem(ctx);
+      } else {
+        ctx.ui.notify(`List has ${listQueue().length} item(s) waiting — /list next to activate the head.`, "info");
+      }
     }
   });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goal-list-loop-audit",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "description": "Goal. Loop. Audit. Done. — 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 — only the read tools needed to verify your goal.",
   "license": "MIT",
   "author": "dracon",