pi-goal-list-loop-audit 0.28.22 → 0.28.24

package/README.md

@@ -38,6 +38,7 @@ Five top-level commands — `/goal`, `/list`, `/loop`, `/glla`, `/review`:
 /goal pause                        # pause
 /goal resume                       # resume
 /goal cancel                       # abort
+/goal decide                       # re-open the decision picker (v0.28.23)
 /goal tweak "<new objective>"      # edit in place (Confirm dialog)
 /goal archive                      # archived goals, newest first
 /glla                               # settings UI table · /glla key=value · /glla stats · /glla audits [N|full] · /glla postaudit · /glla autoaccept=on

package/extensions/goal-loop-core.ts

@@ -203,9 +203,9 @@ export interface Goal {
 export type GoalRoute =
   | { kind: "draft" }
   | { kind: "set"; text: string }
-  | { kind: "sub"; name: "status" | "pause" | "resume" | "cancel" | "tweak" | "archive" | "start"; rest: string };
+  | { kind: "sub"; name: "status" | "pause" | "resume" | "cancel" | "decide" | "tweak" | "archive" | "start"; rest: string };
 
-const GOAL_EXACT_SUBS = new Set(["status", "pause", "resume", "cancel"]);
+const GOAL_EXACT_SUBS = new Set(["status", "pause", "resume", "cancel", "decide"]);
 const GOAL_ARG_SUBS = new Set(["tweak", "archive", "start"]);
 
 export function routeGoalArgs(raw: string): GoalRoute {
@@ -215,7 +215,7 @@ export function routeGoalArgs(raw: string): GoalRoute {
   const first = (space === -1 ? trimmed : trimmed.slice(0, space)).toLowerCase();
   const rest = space === -1 ? "" : trimmed.slice(space + 1).trim();
   if (GOAL_EXACT_SUBS.has(first) && rest === "") {
-    return { kind: "sub", name: first as "status" | "pause" | "resume" | "cancel", rest: "" };
+    return { kind: "sub", name: first as "status" | "pause" | "resume" | "cancel" | "decide", rest: "" };
   }
   if (GOAL_ARG_SUBS.has(first)) {
     return { kind: "sub", name: first as "tweak" | "archive" | "start", rest };

package/extensions/goal-settings.ts

@@ -33,6 +33,10 @@ 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.23: off → decision pauses don't pop the select() picker (the
+   * widget card still shows the options; /goal decide opens it on demand).
+   * Default on; unattended rigs have no UI so this never fires there. */
+  decisionPopup?: 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;
@@ -156,6 +160,7 @@ export const SETTINGS_KEYS: Array<keyof Settings> = [
   "tokenLimit",
   "wedgeAlertMinutes",
   "autoResume",
+  "decisionPopup",
   "carryover",
   "autoAcceptDrafts",
   "auditCap",

package/extensions/loops/goal.ts

@@ -463,6 +463,14 @@ function startUITicker(): void {
 // and escalated loudly past 5 minutes.
 let continuationRearmStreak = 0;
 let loopRearmStreak = 0;
+// v0.28.24: post-compaction grace — a just-replaced session gets 3 minutes
+// to settle (queue drain, provider recovery) before stall counting resumes.
+// Field-observed in junk-runner: a 196k-token compact finished, then the
+// heartbeat burned all 5 stall refires in the next 5 minutes into a session
+// whose turn trigger was still dead — pausing a resumable goal 4 minutes
+// after the compact instead of giving pi room to recover.
+let compactionGraceUntil = 0;
+const COMPACTION_GRACE_MS = 3 * 60_000;
 const SEND_REARM_LEDGER_EVERY = 600; // 600 × 50ms = 30s
 const SEND_REARM_ESCALATE_AT = 6000; // 6000 × 50ms = 5 minutes
 
@@ -545,6 +553,10 @@ function heartbeatTick(): void {
     return;
   }
   const sessionIdle = idle && !pending;
+  // v0.28.24: post-compaction grace — the whole stall/refire/watchdog
+  // machinery below stays quiet for 3 minutes while the replaced session
+  // settles (latch watchdog, wedge alert, refire counting all resume after).
+  if (Date.now() < compactionGraceUntil) return;
   // v0.26.5: pending-latch watchdog — a queued continuation whose turn
   // trigger was dropped (field-observed post-compaction: continuation
   // ACCEPTED at compact+0s, then 22 minutes of silence). The stuck latch
@@ -1138,6 +1150,13 @@ async function cmdGoal(args: string, ctx: ExtensionContext): Promise<void> {
     if (route.name === "pause") return cmdPause(ctx);
     if (route.name === "resume") return cmdResume(ctx);
     if (route.name === "cancel") return cmdCancel(ctx);
+    // v0.28.23: re-open the decision picker for a decision pause (the
+    // popup auto-opens when the pause lands; this is the on-demand path).
+    if (route.name === "decide") {
+      const shown = await showDecisionPrompt(ctx);
+      if (!shown) ctx.ui.notify("No pending decision — the goal isn't paused on a choice (or no UI).", "info");
+      return;
+    }
     if (route.name === "tweak") return cmdTweak(route.rest, ctx);
     if (route.name === "archive") return cmdGoals(ctx);
     // v0.16.0: /goal start <objective> — explicit skip-draft. Activates
@@ -1198,10 +1217,10 @@ async function cmdSet(args: string, ctx: ExtensionContext, skipDraft = false): P
     // v0.28.1 (S3): the goal is persisted — mark the interrupt so the next
     // fresh session LOADS it (held by default since v0.28.21), and tell the truth instead of "starting now".
     updateGoal({ interruptedAt: nowIso(), interruptedReason: "created in a stale session" }, ctx);
-    ctx.ui.notify(`Goal saved: ${shortObj(goal.objective)} — safe in .pi-glla/, but this stale process can't send continuations. Restart pi, then /goal resume (v0.28.21: session loads no longer auto-start by default). (id: ${goal.id})`, "warning");
+    ctx.ui.notify(`Goal saved: ${shortObj(goal.objective)} — safe in .pi-glla/, but this stale process can't send continuations. Restart pi, then /goal resume (v0.28.21: session loads no longer auto-start by default).`, "warning");
     return;
   }
-  ctx.ui.notify(`Goal started: ${shortObj(goal.objective)} — the auditor will verify on completion. (id: ${goal.id})`, "info");
+  ctx.ui.notify(`Goal started: ${shortObj(goal.objective)} — the auditor will verify on completion.`, "info");
   scheduleContinuation(ctx, true);
 }
 
@@ -1212,8 +1231,7 @@ async function cmdStatus(ctx: ExtensionContext): Promise<void> {
   }
   const g = state.goal;
   const lines = [
-    `[${g.id}] ${statusLabel(g.status)}`,
-    `Objective: ${g.objective}`,
+    `${statusLabel(g.status)}: ${g.objective}`,
     // v0.24.7: name WHERE the work came from — a queue item is not a goal.
     ...(g.policy === "list" ? [`Source: /list queue (${listQueue().length} waiting) — /list to manage`] : []),
     `Auto-continue: ${g.autoContinue ? "on" : "off"}`,
@@ -1233,10 +1251,10 @@ async function cmdPause(ctx: ExtensionContext): Promise<void> {
   // v0.22.7: name WHAT was paused — a list item resumes through /list.
   if (state.goal.policy === "list") {
     const queued = listQueue().length;
-    ctx.ui.notify(`List item ${state.goal.id} paused${queued > 0 ? ` (${queued} waiting in the list)` : ""}. /list resume to continue.`, "info");
+    ctx.ui.notify(`List item "${shortObj(state.goal.objective)}" paused${queued > 0 ? ` (${queued} waiting in the list)` : ""}. /list resume to continue.`, "info");
     return;
   }
-  ctx.ui.notify(`Goal ${state.goal.id} paused. /goal resume to continue.`, "info");
+  ctx.ui.notify(`Goal "${shortObj(state.goal.objective)}" paused. /goal resume to continue.`, "info");
 }
 
 async function cmdResume(ctx: ExtensionContext): Promise<void> {
@@ -1291,6 +1309,68 @@ async function cmdCancel(ctx: ExtensionContext): Promise<void> {
   ctx.ui.notify(`Goal aborted.${isLoopActive() ? " A loop is still active — /loop stop ends it." : ""}`, "info");
 }
 
+// ---- v0.28.23: decision picker popup ----
+// A decision pause is ACTIONABLE — the widget card summarizes (and
+// truncates) it, but picking from a truncated wall was the user's
+// complaint. Borrow Claude Code / muselinn-Ask: a real select() modal
+// with the FULL option text, pick → act. Escape leaves the card as the
+// fallback; /goal decide re-opens the picker at any time.
+
+let decisionPromptOpen = false;
+
+/** True when the goal is paused on a user decision with options. */
+function pendingDecision(): Goal | null {
+  const g = state.goal;
+  return g && g.status === "paused" && g.pauseKind === "decision" && g.pauseOptions && g.pauseOptions.length > 0 ? g : null;
+}
+
+/** Open the decision picker for the current decision pause. Returns true
+ * when a picker was shown (false → caller notifies "no pending decision"). */
+async function showDecisionPrompt(ctx: ExtensionContext): Promise<boolean> {
+  const g = pendingDecision();
+  if (!g || !ctx.hasUI || decisionPromptOpen) return false;
+  decisionPromptOpen = true;
+  try {
+    const title = `Decision needed — ${g.objective.replace(/\s+/g, " ").slice(0, 72)}${g.pauseReason ? ` · ${g.pauseReason.slice(0, 80)}` : ""}`;
+    const options = g.pauseOptions!.map((o, i) => (g.pauseRecommended === i + 1 ? `${o}  (recommended)` : o));
+    const pick = await ctx.ui.select(title, options);
+    if (!pick) return true; // Escape — the widget card remains the fallback
+    const idx = options.indexOf(pick);
+    const label = g.pauseOptions![idx] ?? pick.replace(/ {2}\(recommended\)$/, "");
+    // Executable options — "Label (/goal cancel)" — RUN the command.
+    // Placeholder commands (…/<arg>) fall through to the message path.
+    const cmdMatch = label.match(/\(\/(goal|list|loop) ([a-z]+)\)\s*$/);
+    if (cmdMatch && !label.includes("…") && !label.includes("<")) {
+      const [, group, verb] = cmdMatch;
+      if (group === "goal" && verb === "resume") await cmdResume(ctx);
+      else if (group === "goal" && verb === "cancel") await cmdCancel(ctx);
+      else if (group === "loop" && verb === "stop") await cmdLoop("stop", ctx);
+      else if (group === "loop" && verb === "resume") await cmdLoop("resume", ctx);
+      else {
+        extensionApi?.sendUserMessage(`Decision for the paused goal "${g.objective}": ${label} — continue on this path.`);
+        await cmdResume(ctx);
+      }
+      return true;
+    }
+    // Content choice — deliver to the agent, then resume.
+    extensionApi?.sendUserMessage(`Decision for the paused goal "${g.objective}": ${label} — continue on this path.`);
+    await cmdResume(ctx);
+    return true;
+  } finally {
+    decisionPromptOpen = false;
+  }
+}
+
+/** Pop the picker after a decision pause lands — deferred so the current
+ * turn finishes first (pi serializes dialogs). No-ops without a UI, when
+ * disabled (/glla decisionpopup=off), or when one is already open. */
+function maybeDecisionPopup(ctx: ExtensionContext): void {
+  if (!ctx.hasUI || loadSettings(ctx.cwd).decisionPopup === false) return;
+  setTimeout(() => {
+    void showDecisionPrompt(ctx).catch(() => {});
+  }, 600);
+}
+
 async function cmdGoals(ctx: ExtensionContext): Promise<void> {
   const dir = archiveDir(ctx.cwd);
   if (!fs.existsSync(dir)) {
@@ -2447,10 +2527,13 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
           status: "paused",
           auditHistory: history,
           pauseKind: "decision",
+          pauseOptions: ["Tweak the objective — /goal tweak <new text>", "Cancel the goal (/goal cancel)"],
+          pauseRecommended: 1,
           pauseReason: `auditor verdict: IMPOSSIBLE — ${reason}`,
           pauseSuggestedAction: "The auditor says this goal can never be satisfied as stated. /goal tweak the objective (or /goal cancel), then /goal resume.",
         }, ctx);
         ctx.ui.notify(`Auditor: goal IMPOSSIBLE — ${reason}. Goal paused; /goal tweak or /goal cancel, then /goal resume.`, "warning");
+        maybeDecisionPopup(ctx);
         appendLedger(ctx.cwd, "goal_paused", { reason: `auditor impossible: ${reason}` });
         notifyExternal(ctx, `Goal paused (auditor: impossible): ${reason.slice(0, 120)}`);
         return {
@@ -2623,10 +2706,13 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
           status: "paused",
           auditHistory: history,
           pauseKind: "decision",
+          pauseOptions: ["Fix the disapproval gap, then continue (/goal resume)", "Tweak the objective — /goal tweak <new text>", "Cancel the goal (/goal cancel)"],
+          pauseRecommended: 1,
           pauseReason: `auditor disapproved ${trailingDisapprovals}× consecutively (cap ${auditCap})`,
           pauseSuggestedAction: "Read the audit history (/goal status), fix the actual gap or /goal tweak the objective, then /goal resume. Raise the cap with /glla auditcap=N.",
         }, ctx);
         ctx.ui.notify(`Goal paused: auditor disapproved ${trailingDisapprovals}× consecutively (cap ${auditCap}). /goal status for the reports; /goal resume to continue.`, "warning");
+          maybeDecisionPopup(ctx);
         appendLedger(ctx.cwd, "goal_paused", { reason: `disapproval cap: ${trailingDisapprovals} consecutive (cap ${auditCap})` });
         notifyExternal(ctx, `Goal paused: ${trailingDisapprovals} consecutive auditor disapprovals`);
         return {
@@ -2657,7 +2743,7 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
   pi.registerTool(defineTool({
     name: "pause_goal",
     label: "Pause goal",
-    description: "Pause the active goal with a reason and suggested action. Use when blocked on user input or unable to make progress. When the user must CHOOSE between options, pass kind=\"decision\" with the options list (recommended = 1-based index of the best one) — decision pauses render as a prominent DECISION NEEDED card. Time-gated waits (retry at a specific time) use kind=\"wait\" with resumeAt (ISO). Operational failures use kind=\"error\".",
+    description: "Pause the active goal with a reason and suggested action. Use when blocked on user input or unable to make progress. When the user must CHOOSE between options, pass kind=\"decision\" with the options list (recommended = 1-based index of the best one) — decision pauses render as a prominent DECISION NEEDED card. Time-gated waits (retry at a specific time) use kind=\"wait\" with resumeAt (ISO). Operational failures use kind=\"error\". VOCABULARY (v0.28.24): decision options and reasons must reference REAL commands only — /goal resume, /goal cancel, /goal tweak \"<new text>\", /list remove N, /list next, /list resume, /loop stop, /loop resume. These all act on the ACTIVE goal/item: there is NO /goal drop and NO command takes a goal id. Never show goal ids to the user — name the thing ('the active goal', 'list item \"<short name>\"'); ids are internal plumbing the user cannot act on.",
     parameters: Type.Object({
       reason: Type.String({ description: "Why the work is paused" }),
       suggestedAction: Type.Optional(Type.String({ description: "What the user should do next" })),
@@ -2680,6 +2766,7 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
         pauseRecommended: p.kind === "decision" && p.recommended && p.recommended >= 1 ? Math.floor(p.recommended) : undefined,
         pauseResumeAt: p.kind === "wait" && p.resumeAt ? p.resumeAt : undefined,
       }, ctx);
+      if (p.kind === "decision" && p.options && p.options.length > 0) maybeDecisionPopup(ctx);
       // v0.27.1: surface the FULL pause contract — reason AND suggested
       // action. Before, the action only appeared in /goal status and the
       // widget truncated both at ~60 chars, so decision-pauses ("choose a
@@ -3405,6 +3492,14 @@ export async function handleSettingChoice(id: string, ctx: ExtensionContext): Pr
       if (v) saveSettings("global", ctx.cwd, { autoAcceptDrafts: v.startsWith("on") ? true : undefined });
       return;
     }
+    case "decisionPopup": {
+      const v = await ctx.ui.select("Decision popup (v0.28.23 — decision pauses pop the select() picker)", [
+        "on — a decision pause opens the picker; the widget card is the Escape fallback",
+        "off — widget card only; /goal decide opens the picker on demand",
+      ]);
+      if (v) saveSettings("global", ctx.cwd, { decisionPopup: v.startsWith("off") ? false : undefined });
+      return;
+    }
     case "aggressiveMode": {
       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",
@@ -3960,6 +4055,16 @@ 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 === "decisionpopup") {
+      if (["on", "true", "1", "yes"].includes(value)) {
+        patch.decisionPopup = true;
+        changed = true;
+      } else if (["off", "false", "0", "no"].includes(value)) {
+        patch.decisionPopup = false;
+        changed = true;
+      } else {
+        ctx.ui.notify(`decisionpopup 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";
@@ -4091,7 +4196,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, carryover, auditcap, auditfeedbackchars, aggressivemode, quotaretryminutes, stuckmax), optionally prefixed with 'project'.", "info");
+    ctx.ui.notify("Nothing changed. Use key=value (model, thinking, notify, tokenlimit, autoresume, decisionpopup, carryover, auditcap, auditfeedbackchars, aggressivemode, quotaretryminutes, stuckmax), optionally prefixed with 'project'.", "info");
     return;
   }
   saveSettings(scope, ctx.cwd, patch);
@@ -4225,6 +4330,7 @@ export default function (pi: ExtensionAPI): void {
       ["notify=", "desktop push command: /glla notify='notify-send pi \"$1\"'"],
       ["tokenlimit=", "per-goal token budget (0 = off): /glla tokenlimit=2000000"],
       ["autoresume=", "default: hold when a session is loaded, auto-resume on reload/fork; on: always auto-resume; off: never"],
+      ["decisionpopup=", "on|off: decision pauses pop the select() picker (default on; the widget card always lists the options, /goal decide reopens the picker)"],
       ["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"],
@@ -4325,6 +4431,12 @@ export default function (pi: ExtensionAPI): void {
     rememberCtx(ctx);
     if (!isSupervising()) return;
     appendLedger(ctx.cwd, "session_compact", {});
+    // v0.28.24: a compaction is LEGITIMATE busy time — reset the send-rearm
+    // storm streaks (π-web nearly escalated a "send-retry storm" pause during
+    // a 3.5-minute compact) and open the post-compaction stall grace.
+    continuationRearmStreak = 0;
+    loopRearmStreak = 0;
+    compactionGraceUntil = Date.now() + COMPACTION_GRACE_MS;
     const settle = setTimeout(() => {
       const c = freshCtx();
       if (!c) return;
@@ -4497,7 +4609,7 @@ export default function (pi: ExtensionAPI): void {
         // the auto-resume the marker promised.
         if (wasInterrupted) updateGoal({ interruptedAt: undefined, interruptedReason: undefined }, ctx);
         ctx.ui.notify(
-          `Resuming ${state.goal.policy === "list" ? "list item" : "goal"} [${state.goal.id}]: ${state.goal.objective.slice(0, 70)}${listQueue().length > 0 ? ` (+${listQueue().length} queued)` : ""}${wasInterrupted ? " — auto-resumed after the stale-handle interrupt" : ""}`,
+          `Resuming ${state.goal.policy === "list" ? "list item" : "goal"}: ${state.goal.objective.slice(0, 70)}${listQueue().length > 0 ? ` (+${listQueue().length} queued)` : ""}${wasInterrupted ? " — auto-resumed after the stale-handle interrupt" : ""}`,
           "info",
         );
         // v0.28.4 (P3): skip nudge accounting for the first recovery turns.
@@ -4516,14 +4628,14 @@ export default function (pi: ExtensionAPI): void {
           pauseSuggestedAction: resumeHint,
         }, ctx);
         ctx.ui.notify(
-          `${isListItem ? "List item" : "Goal"} held on restore [${state.goal.id}]: ${state.goal.objective.slice(0, 70)}${queued > 0 ? ` (+${queued} waiting in the list)` : ""} — ${resumeCmd} to continue.`,
+          `${isListItem ? "List item" : "Goal"} held on restore: ${state.goal.objective.slice(0, 70)}${queued > 0 ? ` (+${queued} waiting in the list)` : ""} — ${resumeCmd} to continue.`,
           "info",
         );
       }
     } else if (state.goal && state.goal.status === "active") {
       // Active but autoContinue off: nothing auto-fires — just surface it.
       ctx.ui.notify(
-        `Restored ${state.goal.policy === "list" ? "list item" : "goal"} [${state.goal.id}]: ${state.goal.objective.slice(0, 70)}${listQueue().length > 0 ? ` (+${listQueue().length} queued)` : ""}`,
+        `Restored ${state.goal.policy === "list" ? "list item" : "goal"}: ${state.goal.objective.slice(0, 70)}${listQueue().length > 0 ? ` (+${listQueue().length} queued)` : ""}`,
         "info",
       );
     } else if ((!state.goal || state.goal.status === "complete" || state.goal.status === "aborted") && listQueue().length > 0) {
@@ -4543,13 +4655,16 @@ export default function (pi: ExtensionAPI): void {
       updateGoal({
         status: "paused",
         pauseKind: "decision",
+        pauseOptions: ["Stop the loop, then resume the goal (/loop stop)", "Cancel the goal (/goal cancel) — the loop keeps running"],
+        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 [${state.goal.id}] held — a loop also exists; one active thing at a time. /loop to resume the loop, or /loop stop then /goal resume.`,
+        `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);
     }
     // 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
@@ -4639,10 +4754,13 @@ export default function (pi: ExtensionAPI): void {
           updateGoal({
             status: "paused",
             pauseKind: "decision",
+            pauseOptions: ["Retry — /goal resume", "Tweak the objective — /goal tweak <new text>", "Cancel the goal (/goal cancel)"],
+            pauseRecommended: 1,
             pauseReason: `stalled: ${HEARTBEAT_MAX_NUDGES} consecutive unproductive turns (no tools, short or repetitive)`,
             pauseSuggestedAction: "Inspect the goal — /goal resume to retry, /goal tweak to narrow it, /goal cancel to abort.",
           }, ctx);
           ctx.ui.notify(`Goal paused: stalled (${HEARTBEAT_MAX_NUDGES} unproductive turns).`, "warning");
+          maybeDecisionPopup(ctx);
           notifyExternal(ctx, "Goal paused: stalled (no tool calls).");
           return;
         }

package/extensions/reviewer.ts

@@ -111,17 +111,84 @@ export function stripCodeSpans(text: string): string {
     .replace(/`[^`\n]*`/g, " ");
 }
 
+/** v0.28.24: join hard-wrapped lines before classification. Completion
+ * summaries and transcripts arrive wrapped at ~70 cols, and line-by-line
+ * extraction sliced findings at the wrap point (field-observed in
+ * hellhunter: a list item whose ENTIRE objective was "Run a post-completion
+ * regression scan on the hellhunter codebase to" — the first visual line of
+ * a wrapped paragraph, enqueued by the convert-findings-to-list cascade).
+ * A line that doesn't end a sentence continues on the next line unless that
+ * line starts a new list item or heading. */
+export function unwrapHardWrappedLines(text: string): string {
+  const lines = text.split("\n");
+  const out: string[] = [];
+  for (const line of lines) {
+    const prev = out[out.length - 1];
+    const startsNewItem = /^\s*([-*•>]|\d+[.)]|#)/.test(line);
+    // v0.28.24: join only when the continuation starts LOWERCASE — the
+    // mid-sentence signal. Punctuation-less standalone items ("TODO: fix x")
+    // start uppercase/keyword and must NOT merge with the next item.
+    const continuesSentence = /^[a-z]/.test(line.trimStart());
+    if (
+      prev !== undefined &&
+      prev.trim().length > 0 &&
+      line.trim().length > 0 &&
+      !startsNewItem &&
+      continuesSentence &&
+      !/[.!?:;)"'\]]$/.test(prev.trimEnd())
+    ) {
+      out[out.length - 1] = `${prev.trimEnd()} ${line.trimStart()}`;
+    } else {
+      out.push(line);
+    }
+  }
+  return out.join("\n");
+}
+
+/** v0.28.24: a candidate ending in a dangling connector is a wrap/parse
+ * fragment, not a finding ("…codebase to", "…the settings and"). */
+const DANGLING_END = /\s(to|and|or|but|the|a|an|of|for|with|in|on|at|that|which|into|from|by|is|are|was|were|be|been|so|if|then|than|as|nor|yet|per|via)$/i;
+
+/** v0.28.24: cut at a clause boundary, never mid-word — the finding text IS
+ * the item's user-facing name once enqueued. */
+export function cutAtClauseBoundary(s: string, max: number): string {
+  if (s.length <= max) return s;
+  const window = s.slice(0, max);
+  const clause = Math.max(
+    window.lastIndexOf(". "),
+    window.lastIndexOf("! "),
+    window.lastIndexOf("? "),
+    window.lastIndexOf("; "),
+    window.lastIndexOf(", "),
+    window.lastIndexOf(" — "),
+    window.lastIndexOf(": "),
+  );
+  if (clause >= Math.floor(max * 0.4)) return window.slice(0, clause + 1).trimEnd();
+  const space = window.lastIndexOf(" ");
+  return (space > 0 ? window.slice(0, space) : window).trimEnd();
+}
+
 /** Scan source texts line-by-line for finding-shaped content. Code
- * spans are stripped first (v0.26.4) — findings live in prose. */
-export function extractFindings(sources: Array<{ name: string; text: string }>, max: number): Finding[] {
+ * spans are stripped first (v0.26.4) — findings live in prose. Hard-wrapped
+ * lines are joined (v0.28.24) — findings are sentence-shaped, not
+ * visual-line-shaped. `completedObjective` (v0.28.24) dedupes findings that
+ * merely restate the just-completed goal (exact-match dedupe at v0.28.16 was
+ * too narrow — duplicates arrive as prefixes/paraphrases). */
+export function extractFindings(sources: Array<{ name: string; text: string }>, max: number, completedObjective?: string): Finding[] {
   const out: Finding[] = [];
   const seen = new Set<string>();
+  const completedNorm = completedObjective ? normalizeObjective(completedObjective) : "";
   for (const { name, text } of sources) {
-    for (const line of stripCodeSpans(text).split("\n")) {
+    for (const line of unwrapHardWrappedLines(stripCodeSpans(text)).split("\n")) {
       const cls = classifyFindingText(line);
       if (!cls) continue;
-      const clean = line.trim().replace(/^[-*>\s\[\]x]+/, "").slice(0, 200);
+      const clean = cutAtClauseBoundary(line.trim().replace(/^[-*>\s\[\]x]+/, ""), 200);
       if (clean.length < 8 || seen.has(clean)) continue;
+      if (DANGLING_END.test(clean) || /[,;:\u2014-]$/.test(clean)) continue; // v0.28.24: wrap/parse fragment
+      if (completedNorm) {
+        const nf = normalizeObjective(clean);
+        if (nf.length >= 24 && (completedNorm.startsWith(nf) || nf.startsWith(completedNorm))) continue; // v0.28.24: restates the completed goal
+      }
       seen.add(clean);
       out.push({ text: clean, source: name, class: cls });
       if (out.length >= max) return out;
@@ -260,7 +327,7 @@ export function runReviewer(
     }
   }
 
-  const findings = extractFindings(deps.sources, config.maxFindingsPerReview);
+  const findings = extractFindings(deps.sources, config.maxFindingsPerReview, source.objective);
   const bugs = findings.filter((f) => f.class === "bug" || f.class === "refactor");
   const architectural = findings.filter((f) => f.class === "architectural");
   const strategic = findings.filter((f) => f.class === "strategic");

package/extensions/settings-menu.ts

@@ -129,7 +129,16 @@ export function buildSettingsRows(
       valueText: show("autoResume", "default"),
       sourceText: src("autoResume"),
       description:
-        "on: resume on session load too · off: never · default: hold on load, resume on reload/fork",
+        "on: resume on session load too · off: never · default: hold on EVERY load — explicit resume (v0.28.21)",
+    },
+    {
+      id: "decisionPopup",
+      section: "keep-going",
+      label: "Decision popup",
+      valueText: show("decisionPopup", "on"),
+      sourceText: src("decisionPopup"),
+      description:
+        "on: decision pauses pop the select() picker · off: widget card only — /goal decide reopens the picker (v0.28.23)",
     },
     {
       id: "autoAcceptDrafts",

package/package.json

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

package/prompts/goal-loop-continuation.md

@@ -144,6 +144,8 @@ When the goal is genuinely blocked and you cannot make progress without user inp
 pause_goal({reason: "...", suggestedAction: "..."})
 ```
 
+When the user must CHOOSE between paths, use `pause_goal` with `kind="decision"`, an `options` list, and `recommended` (1-based index) — a prominent decision card renders and the user picks. **Vocabulary rules for reasons and options (v0.28.24):** reference only REAL commands — `/goal resume`, `/goal cancel`, `/goal tweak "<new text>"`, `/list remove N`, `/list next`, `/list resume`, `/loop stop`, `/loop resume` — all act on the ACTIVE goal/item; there is **no `/goal drop`** and **no command takes a goal id**. Never show goal ids (`20260729065635-gbtxsm`) in user-facing text — name the thing instead ("the active goal", "list item 'regression scan'"); ids are internal plumbing the user cannot act on.
+
 ## HARD RULES
 
 - **Do not modify the objective silently.** The objective is the user's; if it has drifted from what makes sense, use `complete_goal`'s `newObjective` at completion time, or `pause_goal` and propose a `/goal tweak` mid-flight — never just work on something else and claim the original.