pi-goal-list-loop-audit 0.26.8 → 0.27.0

package/README.md

@@ -199,7 +199,7 @@ No external watchdog plugin needed.
 /glla tokenlimit=10000000            # per-goal token budget (default: off) → GLOBAL
 /glla tokenlimit=0                   # explicitly no cap (the default)
 /glla wedgealert=30                  # hung-command alert minutes (default: 30, 0 = off)
-/glla autoresume=on                  # held goals/loops auto-resume in fresh sessions (unattended rigs)
+/glla autoresume=on                  # auto-resume goals/loops on session LOAD too (default: hold on load, auto-resume on reload/fork; off: never)
 /glla auditcap=5                     # pause the goal after N consecutive auditor disapprovals (default 5, 0 = unlimited)
 /glla aggressivemode=on               # keep-going defaults: autoResume, cap 10, stuck 10, wedge off, quota auto-retry, cap→TODOs
 /glla quotaretryminutes=60            # minutes before auto-retrying a quota-exhausted auditor

package/extensions/goal-loop-core.ts

@@ -660,16 +660,21 @@ export function cloneGoal(goal: Goal): Goal {
  * setting for unattended restarts). One mechanical predicate; no heuristics.
  */
 export function shouldAutoResumeOnSessionStart(reason: string | undefined, autoResume: boolean | undefined): boolean {
-  // v0.26.8: default flipped to ON — keep pushing forward on every session
-  // start unless the user explicitly opts out (/glla autoresume=off). The
-  // "super stuck" brakes (stall escalation, stale-api terminal, pending-
-  // latch watchdog) still stop the machine loudly; a mere process restart
-  // is not a reason to hold work. Explicit off preserves the v0.21.0 gate:
-  // only sessions with history (resume/reload/fork) auto-resume.
-  if (autoResume === false) {
-    return reason === "resume" || reason === "reload" || reason === "fork";
-  }
-  return true;
+  // v0.26.9 tri-state:
+  //   true      → auto-resume on EVERY session start (unattended rigs).
+  //   false     → never auto-resume; always hold for an explicit resume.
+  //   undefined → DEFAULT: a human LOADING a session ("startup"/"new"/
+  //               "resume", or old pi reporting no reason) must not trigger
+  //               work — show the held popup, they resume explicitly.
+  //               In-session MACHINERY ("reload"/"fork") auto-resumes so an
+  //               extension reload or session fork never strands work.
+  // Mid-session continuation (agent_end chains, heartbeat refires,
+  // post-compaction, list/loop transitions) is not gated here at all — it
+  // auto-continues forever unless a super-stuck brake (stall escalation,
+  // stale-api terminal, pending-latch watchdog) stops it loudly.
+  if (autoResume === true) return true;
+  if (autoResume === false) return false;
+  return reason === "reload" || reason === "fork";
 }
 
 /**

package/extensions/loops/goal.ts

@@ -2852,66 +2852,93 @@ async function openSettingsUI(ctx: ExtensionContext): Promise<void> {
       const v = p.value === undefined ? fallback : String(p.value);
       return `${v}  [${p.source}]`;
     };
+    const settings = loadSettings(ctx.cwd);
+    // v0.27.0: every option on ONE screen, grouped into sections, each row
+    // carrying `label — value [provenance] — what it does` so the menu is
+    // also the documentation. Header rows are no-ops when selected.
+    const rows = [
+      "── Keep-going ──",
+      `Auto-resume on load — ${show("autoResume", "default")} — on: resume on session load too · off: never · default: hold on load, resume on reload/fork`,
+      `Auto-accept drafts — ${show("autoAcceptDrafts", "(off)")} — on: goal/loop drafts activate without the Confirm dialog (unattended rigs)`,
+      `Aggressive mode — ${show("aggressiveMode", "(off)")} — flips DEFAULTS toward keep-going (autoResume, cap 10, stuck 10, wedge off, quota auto-retry, cap→TODOs); explicit per-key settings still win`,
+      "── Auditor ──",
+      `Auditor model — ${show("auditorModel", "(pi session model)")} — provider/model override for the isolated auditor`,
+      `Auditor thinking — ${show("auditorThinkingLevel", "(session, floor high)")} — thinking level for the auditor session`,
+      `Audit cap — ${show("auditCap", "(5)")} — pause the goal after N consecutive disapprovals (0 = unlimited)`,
+      `Audit feedback chars — ${show("auditFeedbackChars", "(full report)")} — cap the executor-visible disapproval report (0 = full report)`,
+      `Quota retry minutes — ${show("quotaRetryMinutes", `(${DEFAULT_QUOTA_RETRY_MINUTES})`)} — auto-retry a quota-exhausted auditor after N minutes`,
+      "── Stall brakes ──",
+      `Wedge alert minutes — ${show("wedgeAlertMinutes", `(${WEDGE_ALERT_DEFAULT_MINUTES})`)} — hung-command alert while the session is busy (0 = off)`,
+      `Stuck max interventions — ${show("stuckMaxInterventions", "(5)")} — consecutive stuck interventions before a loop stops`,
+      `Stall escalation refires — ${show("stallEscalationRefires", "(5)")} — heartbeat refires with no turn before the goal pauses / loop stops (0 = never)`,
+      "── Subagents ──",
+      `Subagent model strategy — ${show("subagentModelStrategy", "(inherit-parent)")} — inherit-parent shares your session model+quota; agent-default pins haiku for Explore`,
+      `Subagent Explore pin — ${settings.subagentModelOverrides?.Explore ?? "(follows strategy)"} — provider/model pin; always wins over strategy`,
+      `Subagent Plan pin — ${settings.subagentModelOverrides?.Plan ?? "(follows strategy)"} — provider/model pin; always wins over strategy`,
+      `Subagent general-purpose pin — ${settings.subagentModelOverrides?.["general-purpose"] ?? "(follows strategy)"} — provider/model pin; always wins over strategy`,
+      "── Other ──",
+      `Notify command — ${show("notifyCmd", "(off)")} — desktop push command; the event message is passed as $1`,
+      `Token limit per goal — ${show("tokenLimit", "(off)")} — per-goal token budget; pause when exceeded (0 = off)`,
+      `Reviewer config… — open the reviewer menu (post-completion follow-up enqueuer: mode, triggers, cascade, caps)`,
+      "Done",
+    ];
     let choice: string | undefined;
     try {
       choice = await ctx.ui.select(
         `pi-goal-list-loop-audit settings — global: ${globalSettingsPath()}`,
-        [
-          `Auditor model override — ${show("auditorModel", "(pi session model)")}`,
-          `Auditor thinking — ${show("auditorThinkingLevel", "(session, floor high)")}`,
-          `Notify command — ${show("notifyCmd", "(off)")}`,
-          `Token limit per goal — ${show("tokenLimit", "(off)")}`,
-          `Wedge alert minutes — ${show("wedgeAlertMinutes", `(${WEDGE_ALERT_DEFAULT_MINUTES}m default)`)}`,
-          `Aggressive mode — ${show("aggressiveMode", "(off)")}`,
-          `Quota retry minutes — ${show("quotaRetryMinutes", `(${DEFAULT_QUOTA_RETRY_MINUTES}m default)`)}`,
-          `Stuck max interventions — ${show("stuckMaxInterventions", "(5 default)")}`,
-          `Subagent model strategy — ${show("subagentModelStrategy", "(inherit-parent)")}`,
-          `Subagent Explore model pin — ${loadSettings(ctx.cwd).subagentModelOverrides?.Explore ?? "(follows strategy)"}`,
-          `Subagent Plan model pin — ${loadSettings(ctx.cwd).subagentModelOverrides?.Plan ?? "(follows strategy)"}`,
-          `Subagent general-purpose model pin — ${loadSettings(ctx.cwd).subagentModelOverrides?.["general-purpose"] ?? "(follows strategy)"}`,
-          `Audit feedback characters — ${show("auditFeedbackChars", "(full report)")}`,
-          "Done",
-        ],
+        rows,
       );
     } catch {
       return;
     }
     if (!choice || choice === "Done") return;
+    if (choice.startsWith("──")) continue; // section header — no-op
     try {
-      if (choice.startsWith("Auditor model")) {
+      if (choice.startsWith("Auto-resume")) {
+        const v = await ctx.ui.select("Auto-resume goals/loops on session start", [
+          "default — HOLD when a session is loaded (popup shows what waits); auto-resume on reload/fork so machinery never strands work",
+          "on — auto-resume on EVERY session start (unattended rigs)",
+          "off — never auto-resume; always wait for an explicit resume",
+        ]);
+        if (v) saveSettings("global", ctx.cwd, { autoResume: v.startsWith("on") ? true : v.startsWith("off") ? false : undefined });
+      } else if (choice.startsWith("Auto-accept drafts")) {
+        const v = await ctx.ui.select("Auto-accept goal/loop drafts", [
+          "off — the Confirm dialog gates every draft",
+          "on — drafts activate immediately, no Confirm (unattended rigs)",
+        ]);
+        if (v) saveSettings("global", ctx.cwd, { autoAcceptDrafts: v.startsWith("on") ? true : undefined });
+      } else if (choice.startsWith("Aggressive mode")) {
+        const v = await ctx.ui.select("Aggressive mode (flips DEFAULTS toward keep-going — explicit per-key settings still win)", [
+          "off — current behavior: pause at the audit cap, wedge alerts on, manual resume",
+          "on — autoResume, audit cap 10, stuck max 10, wedge alerts off, quota auto-retry, cap disapprovals become a TODO list and the goal KEEPS GOING",
+        ]);
+        if (v) {
+          saveSettings("global", ctx.cwd, { aggressiveMode: v.startsWith("on") });
+          ctx.ui.notify(`Aggressive mode ${v.startsWith("on") ? "ON — goals keep going past the audit cap; objections become TODOs" : "off"}.`, "info");
+        }
+      } else if (choice.startsWith("Auditor model")) {
         const v = await ctx.ui.input("Auditor model override", "provider/model-id — empty keeps the pi session model");
         if (v !== undefined) saveSettings("global", ctx.cwd, { auditorModel: v.trim() || undefined });
       } else if (choice.startsWith("Auditor thinking")) {
         const v = await ctx.ui.select("Auditor thinking level", ["off", "minimal", "low", "medium", "high", "xhigh"]);
         if (v) saveSettings("global", ctx.cwd, { auditorThinkingLevel: v as Settings["auditorThinkingLevel"] });
-      } else if (choice.startsWith("Notify command")) {
-        const v = await ctx.ui.input("Notify command — the event message is passed as $1", "e.g. a desktop-notification or push command; empty = off");
-        if (v !== undefined) saveSettings("global", ctx.cwd, { notifyCmd: v.trim() || undefined });
-      } else if (choice.startsWith("Token limit")) {
-        const v = await ctx.ui.input("Per-goal token budget", "non-negative integer; 0 or empty = off (no cap)");
+      } else if (choice.startsWith("Audit cap")) {
+        const v = await ctx.ui.input("Consecutive auditor disapprovals before the goal pauses", "non-negative integer; 0 = unlimited, empty = default 5");
         if (v !== undefined) {
           const n = Number.parseInt(v.trim(), 10);
-          if (Number.isFinite(n) && n >= 0) saveSettings("global", ctx.cwd, { tokenLimit: n });
-          else if (!v.trim()) saveSettings("global", ctx.cwd, { tokenLimit: undefined });
+          if (Number.isFinite(n) && n >= 0) saveSettings("global", ctx.cwd, { auditCap: n });
+          else if (!v.trim()) saveSettings("global", ctx.cwd, { auditCap: undefined });
           else ctx.ui.notify(`Not a non-negative integer: ${v}`, "warning");
         }
-      } else if (choice.startsWith("Wedge alert")) {
-        const v = await ctx.ui.input("Wedge alert threshold (minutes)", "non-negative integer; 0 = off, empty = default 30");
+      } else if (choice.startsWith("Audit feedback")) {
+        const v = await ctx.ui.input("Auditor feedback returned to the executor (characters)", "non-negative integer cap; 0 or empty = full report (default)");
         if (v !== undefined) {
-          const n = Number.parseInt(v.trim(), 10);
-          if (Number.isFinite(n) && n >= 0) saveSettings("global", ctx.cwd, { wedgeAlertMinutes: n });
-          else if (!v.trim()) saveSettings("global", ctx.cwd, { wedgeAlertMinutes: undefined });
+          const raw = v.trim();
+          const n = Number(raw);
+          if (/^\d+$/.test(raw) && Number.isSafeInteger(n)) saveSettings("global", ctx.cwd, { auditFeedbackChars: n });
+          else if (!v.trim()) saveSettings("global", ctx.cwd, { auditFeedbackChars: undefined });
           else ctx.ui.notify(`Not a non-negative integer: ${v}`, "warning");
         }
-      } else if (choice.startsWith("Aggressive mode")) {
-        const v = await ctx.ui.select("Aggressive mode (flips DEFAULTS toward keep-going — explicit per-key settings still win)", [
-          "off — current behavior: pause at the audit cap, wedge alerts on, manual resume",
-          "on — autoResume, audit cap 10, stuck max 10, wedge alerts off, quota auto-retry, cap disapprovals become a TODO list and the goal KEEPS GOING",
-        ]);
-        if (v) {
-          saveSettings("global", ctx.cwd, { aggressiveMode: v.startsWith("on") });
-          ctx.ui.notify(`Aggressive mode ${v.startsWith("on") ? "ON — goals keep going past the audit cap; objections become TODOs" : "off"}.`, "info");
-        }
       } else if (choice.startsWith("Quota retry minutes")) {
         const v = await ctx.ui.input("Minutes before auto-retrying a quota-exhausted auditor", `positive integer; empty = default ${DEFAULT_QUOTA_RETRY_MINUTES}`);
         if (v !== undefined) {
@@ -2920,6 +2947,14 @@ async function openSettingsUI(ctx: ExtensionContext): Promise<void> {
           else if (!v.trim()) saveSettings("global", ctx.cwd, { quotaRetryMinutes: undefined });
           else ctx.ui.notify(`Not a positive integer: ${v}`, "warning");
         }
+      } else if (choice.startsWith("Wedge alert")) {
+        const v = await ctx.ui.input("Wedge alert threshold (minutes)", "non-negative integer; 0 = off, empty = default 30");
+        if (v !== undefined) {
+          const n = Number.parseInt(v.trim(), 10);
+          if (Number.isFinite(n) && n >= 0) saveSettings("global", ctx.cwd, { wedgeAlertMinutes: n });
+          else if (!v.trim()) saveSettings("global", ctx.cwd, { wedgeAlertMinutes: undefined });
+          else ctx.ui.notify(`Not a non-negative integer: ${v}`, "warning");
+        }
       } else if (choice.startsWith("Stuck max interventions")) {
         const v = await ctx.ui.input("Consecutive stuck interventions before a loop stops", "positive integer; empty = default 5 (10 under aggressiveMode)");
         if (v !== undefined) {
@@ -2928,6 +2963,14 @@ async function openSettingsUI(ctx: ExtensionContext): Promise<void> {
           else if (!v.trim()) saveSettings("global", ctx.cwd, { stuckMaxInterventions: undefined });
           else ctx.ui.notify(`Not a positive integer: ${v}`, "warning");
         }
+      } else if (choice.startsWith("Stall escalation")) {
+        const v = await ctx.ui.input("Heartbeat refires without a turn before the goal pauses / loop stops", "non-negative integer; 0 = never escalate, empty = default 5");
+        if (v !== undefined) {
+          const n = Number.parseInt(v.trim(), 10);
+          if (Number.isFinite(n) && n >= 0) saveSettings("global", ctx.cwd, { stallEscalationRefires: n });
+          else if (!v.trim()) saveSettings("global", ctx.cwd, { stallEscalationRefires: undefined });
+          else ctx.ui.notify(`Not a non-negative integer: ${v}`, "warning");
+        }
       } else if (choice.startsWith("Subagent model strategy")) {
         const v = await ctx.ui.select("Subagent model (pi-subagents default agents)", [
           "inherit-parent — subagents share your session model + its quota pool (fixes separate-provider 403s; search agents may run on a pricier model)",
@@ -2938,8 +2981,8 @@ async function openSettingsUI(ctx: ExtensionContext): Promise<void> {
           saveSettings("global", ctx.cwd, { subagentModelStrategy: strategy });
           ctx.ui.notify("Subagent model strategy saved — applies to NEW pi sessions (pi-subagents registers agents at session start).", "info");
         }
-      } else if (/^Subagent (Explore|Plan|general-purpose) model pin/.test(choice)) {
-        const agentType = choice.match(/^Subagent (Explore|Plan|general-purpose) model pin/)![1]!;
+      } else if (/^Subagent (Explore|Plan|general-purpose) pin/.test(choice)) {
+        const agentType = choice.match(/^Subagent (Explore|Plan|general-purpose) pin/)![1]!;
         const v = await ctx.ui.input(`Model pin for ${agentType} subagents`, "provider/model-id e.g. minimax/MiniMax-M3 — always wins over strategy; empty = follow strategy");
         if (v !== undefined) {
           const current = loadSettings(ctx.cwd).subagentModelOverrides ?? {};
@@ -2949,15 +2992,19 @@ async function openSettingsUI(ctx: ExtensionContext): Promise<void> {
           saveSettings("global", ctx.cwd, { subagentModelOverrides: Object.keys(next).length > 0 ? next : undefined });
           ctx.ui.notify(`${agentType} model pin saved — applies to NEW pi sessions.`, "info");
         }
-      } else if (choice.startsWith("Audit feedback")) {
-        const v = await ctx.ui.input("Auditor feedback returned to the executor (characters)", "non-negative integer cap; 0 or empty = full report (default)");
+      } else if (choice.startsWith("Notify command")) {
+        const v = await ctx.ui.input("Notify command — the event message is passed as $1", "e.g. a desktop-notification or push command; empty = off");
+        if (v !== undefined) saveSettings("global", ctx.cwd, { notifyCmd: v.trim() || undefined });
+      } else if (choice.startsWith("Token limit")) {
+        const v = await ctx.ui.input("Per-goal token budget", "non-negative integer; 0 or empty = off (no cap)");
         if (v !== undefined) {
-          const raw = v.trim();
-          const n = Number(raw);
-          if (/^\d+$/.test(raw) && Number.isSafeInteger(n)) saveSettings("global", ctx.cwd, { auditFeedbackChars: n });
-          else if (!v.trim()) saveSettings("global", ctx.cwd, { auditFeedbackChars: undefined });
+          const n = Number.parseInt(v.trim(), 10);
+          if (Number.isFinite(n) && n >= 0) saveSettings("global", ctx.cwd, { tokenLimit: n });
+          else if (!v.trim()) saveSettings("global", ctx.cwd, { tokenLimit: undefined });
           else ctx.ui.notify(`Not a non-negative integer: ${v}`, "warning");
         }
+      } else if (choice.startsWith("Reviewer config")) {
+        await cmdReviewerSettings(ctx);
       }
     } catch {
       return;
@@ -3161,6 +3208,8 @@ async function cmdSettings(args: string, ctx: ExtensionContext): Promise<void> {
         fmt("aggressiveMode", "aggressiveMode"),
         fmt("quotaRetryMinutes", "quotaRetryMinutes"),
         fmt("stuckMaxInterventions", "stuckMaxInterventions"),
+        fmt("stallEscalationRefires", "stallEscalation"),
+        fmt("wedgeAlertMinutes", "wedgeAlert"),
         // v0.25.6: effective per-type subagent model resolution.
         ...["Explore", "Plan", "general-purpose"].map(
           (t) => `subagent ${t}: ${resolveEffectiveSubagentModel(t, loadSettings(ctx.cwd), (ctx.model as any)?.id ? `${(ctx.model as any).provider}/${(ctx.model as any).id}` : undefined)}`,
@@ -3329,7 +3378,7 @@ async function cmdSettings(args: string, ctx: ExtensionContext): Promise<void> {
   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)"} autoResume=${effective.autoResume === false ? "off" : "on (default)"} auditFeedbackChars=${effective.auditFeedbackChars ?? DEFAULT_AUDIT_FEEDBACK_CHARS}${(effective.auditFeedbackChars ?? DEFAULT_AUDIT_FEEDBACK_CHARS) === 0 ? " (full report)" : ""}\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" : effective.autoResume === false ? "off" : "default (hold on load)"} auditFeedbackChars=${effective.auditFeedbackChars ?? DEFAULT_AUDIT_FEEDBACK_CHARS}${(effective.auditFeedbackChars ?? DEFAULT_AUDIT_FEEDBACK_CHARS) === 0 ? " (full report)" : ""}\n` +
     `Note: the auditor runs without extensions — it must be a built-in provider, not an extension-registered one.`,
     "info",
   );
@@ -3444,7 +3493,7 @@ export default function (pi: ExtensionAPI): void {
       ["thinking=", "auditor thinking level: /glla thinking=high"],
       ["notify=", "desktop push command: /glla notify='notify-send pi \"$1\"'"],
       ["tokenlimit=", "per-goal token budget (0 = off): /glla tokenlimit=2000000"],
-      ["autoresume=", "on (default): auto-resume goals/loops on every session start; off: hold on fresh sessions"],
+      ["autoresume=", "default: hold when a session is loaded, auto-resume on reload/fork; on: always auto-resume; off: never"],
       ["auditcap=", "N: pause goal after N consecutive auditor disapprovals (default 5, 0 = unlimited)"],
       ["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"],
@@ -3641,12 +3690,14 @@ export default function (pi: ExtensionAPI): void {
     } catch (err) {
       ctx.ui.notify(`glla subagent override sync failed: ${err instanceof Error ? err.message : String(err)}`, "warning");
     }
-    // Restore gate (v0.21.0, default flipped v0.26.8): auto-resume on EVERY
-    // session start by default — keep pushing forward unless super stuck
-    // (the stall escalation / stale-api / latch brakes still stop loudly).
-    // /glla autoresume=off restores the v0.21.0 gate: fresh sessions
-    // ("startup"/"new", or a pi too old to report a reason) HOLD, only
-    // sessions with history ("resume"/"reload"/"fork") auto-resume.
+    // 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 autoResume = shouldAutoResumeOnSessionStart(event?.reason, resolveEffectiveAggressiveSettings(loadSettings(ctx.cwd)).autoResume);
     // v0.25.0 (contract item 6): aggressiveMode announces every auto-event.
     if (
@@ -3668,7 +3719,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 (/glla autoresume=off): ${l.target.slice(0, 60)} — /loop to resume, /glla autoresume=on to auto-resume in this project.`,
+          `Loop held on restore: ${l.target.slice(0, 60)} — /loop to resume, /glla autoresume=on to auto-resume on session load in this project.`,
           "info",
         );
       }
@@ -3687,7 +3738,7 @@ export default function (pi: ExtensionAPI): void {
         const resumeHint = `${resumeCmd} to continue${queued > 0 ? ` (+${queued} waiting in the list)` : ""} · /glla autoresume=on to auto-resume in this project`;
         updateGoal({
           status: "paused",
-          pauseReason: "restored in a fresh session — held because /glla autoresume=off",
+          pauseReason: "restored on session load — held for explicit resume",
           pauseSuggestedAction: resumeHint,
         }, ctx);
         ctx.ui.notify(

package/package.json

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