pi-goal-list-loop-audit 0.20.1 → 0.21.1

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

@@ -127,34 +127,36 @@ export function buildWidgetLines(state: State, audit?: AuditDisplayProgress | nu
   return goalLines(g, state, audit, now, theme);
 }
 
-// Branch lines indent one space (pi-tasks convention): the tree sits under
-// the head glyph, text column consistent across widgets.
+// Branch lines sit flush-left (pi-tasks convention): pi's widget renderer
+// adds its own one-space gutter, so any indent here doubles up.
 function goalLines(g: Goal, state: State, audit: AuditDisplayProgress | null | undefined, now: number, theme?: DisplayTheme): string[] {
+  // Head glyph is ● (not ◆): U+25C6 renders as a color-emoji diamond in some
+  // terminal fonts and ignores ANSI color; ● takes the paint everywhere.
   const icon =
     g.status === "paused"
       ? paint(theme, pauseIsError(g) ? "error" : "warning", "⏸")
       : g.status === "auditing"
         ? paint(theme, "accent", "⟡")
-        : paint(theme, "success", "◆");
+        : paint(theme, "success", "●");
   const head = `${icon} ${truncate(g.objective.replace(/\s+/g, " "), 64)}`;
   const statusWord = g.status === "active" ? paint(theme, "success", "active") : g.status;
   const tokens = paint(theme, "dim", `${fmtTokens(g.usage?.tokensUsed ?? 0)}/${fmtTokens(g.usage?.tokensLimit ?? 10_000_000)} tok`);
-  const lines = [head, ` ├─ ${statusWord} · ${fmtElapsed(now - Date.parse(g.createdAt))} · ${tokens}`];
+  const lines = [head, `├─ ${statusWord} · ${fmtElapsed(now - Date.parse(g.createdAt))} · ${tokens}`];
   if (g.status === "auditing") {
-    lines.push(` ├─ auditor: ${audit?.label ?? "running"}${audit?.currentTool ? ` · ${truncate(audit.currentTool, 30)}` : ""}`);
-    if (audit?.elapsedMs) lines.push(` └─ ${paint(theme, "dim", `${fmtElapsed(audit.elapsedMs)} in isolated session`)}`);
-    else lines.push(` └─ ${paint(theme, "dim", "isolated session, read-only tools")}`);
+    lines.push(`├─ auditor: ${audit?.label ?? "running"}${audit?.currentTool ? ` · ${truncate(audit.currentTool, 30)}` : ""}`);
+    if (audit?.elapsedMs) lines.push(`└─ ${paint(theme, "dim", `${fmtElapsed(audit.elapsedMs)} in isolated session`)}`);
+    else lines.push(`└─ ${paint(theme, "dim", "isolated session, read-only tools")}`);
     return lines;
   }
   if (g.status === "paused" && g.pauseReason) {
-    lines.push(` ├─ ${paint(theme, pauseIsError(g) ? "error" : "warning", truncate(g.pauseReason, 60))}`);
-    if (g.pauseSuggestedAction) lines.push(` └─ ${paint(theme, "dim", truncate(g.pauseSuggestedAction, 60))}`);
+    lines.push(`├─ ${paint(theme, pauseIsError(g) ? "error" : "warning", truncate(g.pauseReason, 60))}`);
+    if (g.pauseSuggestedAction) lines.push(`└─ ${paint(theme, "dim", truncate(g.pauseSuggestedAction, 60))}`);
     return lines;
   }
   const next = nextPending(g);
-  if (next) lines.push(` ├─ next: ${truncate(next, 56)}`);
+  if (next) lines.push(`├─ next: ${truncate(next, 56)}`);
   const queue = state.list?.length ?? 0;
-  lines.push(` └─ ${paint(theme, "dim", `${queue > 0 ? `list ${queue} · ` : ""}/goal status · /glla`)}`);
+  lines.push(`└─ ${paint(theme, "dim", `${queue > 0 ? `list ${queue} · ` : ""}/goal status · /glla`)}`);
   return lines;
 }
 
@@ -164,12 +166,12 @@ function loopLines(l: LoopState, now: number, theme?: DisplayTheme): string[] {
   const stallText = `stall ${l.stallCount}/${l.plateauWindow}`;
   const stall = l.stallCount >= l.plateauWindow - 1 ? paint(theme, "warning", stallText) : stallText;
   const lines = [
-    `${paint(theme, "accent", "◆")} ${truncate(l.target, 64)}`,
-    ` ├─ loop ${arrow} iter ${l.iteration}/${l.maxIterations} · ${fmtElapsed(now - Date.parse(l.startedAt))}`,
-    ` ├─ best ${best} · last ${l.lastValue ?? "n/a"} · ${stall}`,
-    ` └─ ${paint(theme, "dim", truncate(l.measureCmd, 56))}`,
+    `${paint(theme, "accent", "●")} ${truncate(l.target, 64)}`,
+    `├─ loop ${arrow} iter ${l.iteration}/${l.maxIterations} · ${fmtElapsed(now - Date.parse(l.startedAt))}`,
+    `├─ best ${best} · last ${l.lastValue ?? "n/a"} · ${stall}`,
+    `└─ ${paint(theme, "dim", truncate(l.measureCmd, 56))}`,
   ];
-  if (l.branchName) lines.push(`  ⎇ ${paint(theme, "muted", truncate(l.branchName, 50))}`);
+  if (l.branchName) lines.push(`⎇ ${paint(theme, "muted", truncate(l.branchName, 50))}`);
   return lines;
 }
 

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)
@@ -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.1",
+  "version": "0.21.1",
   "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",