pi-goal-list-loop-audit 0.33.0 → 0.33.2

package/extensions/goal-loop-auditor.ts

@@ -338,6 +338,7 @@ export async function runGoalCompletionAuditor(args: {
     } finally {
       clearInterval(stallTimer);
       unsub();
+      args.signal?.removeEventListener("abort", abort); // v0.33.1: don't retain the session via the signal
       // v0.32.0: dispose the auditor session — each complete_goal leaked one
       // session's subscriptions/stream resources for the parent's lifetime.
       (session as any).dispose?.();

package/extensions/goal-loop-display.ts

@@ -48,6 +48,12 @@ export function truncate(s: string, max: number): string {
   return s.length <= max ? s : s.slice(0, Math.max(0, max - 1)) + "…";
 }
 
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+/** v0.33.1: painted strings measure by their VISIBLE width. */
+function visibleLen(s: string): number {
+  return s.replace(ANSI_RE, "").length;
+}
+
 /** v0.33.0: 5-cell meter with a rounding guard (command-code's rule — never
  * shows empty or full unless the value truly is 0 or 1). */
 export function meter(frac: number, cells = 5): string {
@@ -296,7 +302,6 @@ function goalLines(g: Goal, state: State, audit: AuditDisplayProgress | null | u
       : g.status === "auditing"
         ? paint(theme, "accent", "⟡")
         : paint(theme, "success", "●");
-  const headBase = `${icon} ${truncate(g.objective.replace(/\s+/g, " "), budgetFor(width, 3, 48))}`;
   // v0.24.7: a list item is named as such and points at /list — before,
   // the widget called it "active" and hinted "/goal status", reading as if
   // queue work were a standalone goal.
@@ -325,7 +330,12 @@ function goalLines(g: Goal, state: State, audit: AuditDisplayProgress | null | u
   // ∞/↓/↑ loop, ⟡ auditing, ⏸ paused) + the type-named footer verbs.
   // Token segment only when a budget is set (v0.22.0): the guard is opt-in,
   // and "0/0 tok" carried no information when off.
-  const head = `${headBase} ${paint(theme, "dim", "·")} ${headSegs.join(` ${paint(theme, "dim", "·")} `)}`;
+  // v0.33.1: the head must FIT the terminal — the segments are fixed, so
+  // the objective absorbs whatever room is left (was: objective budgeted
+  // alone, segments appended unbudgeted → 140-col heads at width 100).
+  const segsText = headSegs.join(` ${paint(theme, "dim", "·")} `);
+  const objBudget = width && width > 0 ? Math.max(16, width - 1 - 2 - 3 - visibleLen(segsText)) : 48;
+  const head = `${icon} ${truncate(g.objective.replace(/\s+/g, " "), objBudget)} ${paint(theme, "dim", "·")} ${segsText}`;
   const lines = [head];
   if (g.status === "auditing") {
     lines.push(`├─ auditor: ${audit?.label ?? "running"}${audit?.currentTool ? ` · ${truncate(audit.currentTool, 30)}` : ""}`);
@@ -427,16 +437,19 @@ function loopLines(l: LoopState, now: number, theme?: DisplayTheme, width?: numb
   segs.push(fmtElapsed(now - Date.parse(l.startedAt)));
   if (l.measureCmd) {
     segs.push(`best ${paint(theme, "success", `${l.bestValue ?? "n/a"}`)}`);
+    segs.push(`last ${l.lastValue ?? "n/a"}`); // v0.33.1: a plateauing loop's current reading stays visible
     const stallText = `stall ${l.stallCount}/${l.plateauWindow}`;
     segs.push(l.stallCount >= l.plateauWindow - 1 ? paint(theme, "warning", stallText) : stallText);
   }
-  const lines = [`${icon} ${truncate(l.target, budgetFor(width, 3, 44))} ${paint(theme, "dim", "·")} ${segs.join(` ${paint(theme, "dim", "·")} `)}${stallNote}`];
+  const segsText = segs.join(` ${paint(theme, "dim", "·")} `);
+  const targetBudget = width && width > 0 ? Math.max(16, width - 1 - 2 - 3 - visibleLen(segsText) - visibleLen(stallNote)) : 44;
+  const lines = [`${icon} ${truncate(l.target, targetBudget)} ${paint(theme, "dim", "·")} ${segsText}${stallNote}`];
   const act = extras?.recent?.[extras.recent.length - 1];
   if (act) {
     lines.push(`├─ ${paint(theme, act.ok ? "success" : "error", act.ok ? "✓" : "✗")} ${act.name}${act.arg ? ` ${paint(theme, "dim", truncate(act.arg, 24))}` : ""}${act.ms > 0 ? ` ${paint(theme, "dim", `(${fmtElapsed(act.ms)})`)}` : ""}`);
   }
   const footer = !l.measureCmd
-    ? "metricless (no plateau) · /loop stop · /loop polish"
+    ? "metricless (no plateau) · /loop stop · /loop refine" // v0.33.2: the verb exists now
     : `${l.kind === "audit" ? "metric: closed findings" : truncate(l.measureCmd, budgetFor(width, 3, 30))} · /loop stop`;
   lines.push(`└─ ${paint(theme, "dim", footer)}`);
   if (l.branchName) lines.push(`⎇ ${paint(theme, "muted", truncate(l.branchName, budgetFor(width, 3, 50)))}`);

package/extensions/goal-loop-forever.ts

@@ -10,6 +10,7 @@
  * self-reports progress.
  */
 
+import { createHash } from "node:crypto";
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
 
@@ -110,6 +111,20 @@ export interface LoopState {
   /** v0.25.1: /loop start toolsamerepeat=N — legacy same-tool-same-result
    * check window. 0 disables it (multi-signal detector only). */
   toolSameRepeat?: number;
+  /** v0.33.2: respec loops carry their spec file — drift detection
+   * (specHash compared per tick), checkbox progress (specChecked →
+   * spec_item_progress events), and the refine tool's specText write path. */
+  specFile?: string;
+  specHash?: string;
+  specChecked?: number;
+  /** v0.33.2: hypothesis feedback loop — the last turn's HYPOTHESIS line
+   * plus the verdict computed against the metric movement, injected into
+   * the next iteration's prompt. */
+  lastHypothesis?: string;
+  hypothesisFeedback?: string;
+  /** v0.33.2: /loop refine <text> — the operator's respec suggestion rides
+   * the next iteration's prompt; the agent proposes via propose_loop_refine. */
+  refineHint?: string;
   /** v0.25.1: per-iteration progress-signal accumulators for the
    * multi-signal stuck gate. fileWrites bumps on write/edit tool results;
    * iterationStartHead/At snapshot when the iteration BEGAN so the tick can
@@ -464,6 +479,37 @@ export function countOpenAuditFindings(cwd: string): number {
   }
 }
 
+/** v0.33.2: the first OPEN finding's text — the reprieve note names what
+ * to close, not just how many remain. */
+export function topOpenAuditFinding(cwd: string): string | null {
+  try {
+    const p = join(cwd, AUDIT_FINDINGS_REL);
+    if (!existsSync(p)) return null;
+    const line = readFileSync(p, "utf-8").split("\n").find((l) => /^- \[ \]/.test(l));
+    return line ? line.replace(/^- \[ \]\s*/, "").trim().slice(0, 120) : null;
+  } catch {
+    return null;
+  }
+}
+
+/** v0.33.2: spec drift detection — short sha256 of the spec file. */
+export function specFileHash(p: string): string | null {
+  try {
+    return createHash("sha256").update(readFileSync(p, "utf-8")).digest("hex").slice(0, 16);
+  } catch {
+    return null;
+  }
+}
+
+/** v0.33.2: checked checkbox count in a spec file (spec_item_progress). */
+export function countCheckedSpecItems(p: string): number | null {
+  try {
+    return readFileSync(p, "utf-8").split("\n").filter((l) => /^- \[x\]/i.test(l)).length;
+  } catch {
+    return null;
+  }
+}
+
 // ---- /goal audit-project (v0.29.8) ----
 
 /**

package/extensions/goal-loop-repetition.ts

@@ -190,7 +190,19 @@ export function forwardTransitionPaired(input: LoopStuckInput): boolean {
  * (new detector only), undefined = REPETITION.toolResultRepeat.
  */
 export function isActuallyStuck(input: LoopStuckInput, toolSameRepeat?: number): string | undefined {
-  if ((input.fileWriteCount ?? 0) > 0) return undefined;
+  if ((input.fileWriteCount ?? 0) > 0) {
+    // v0.33.2: write-exemption abuse — endless cosmetic edits with a
+    // near-identical reply are churn, not progress (the metricless
+    // doorknob leak). The stuck ladder's first rung is a prompt note;
+    // any genuinely different iteration resets it.
+    if (input.previousText && input.assistantText && normalizeForPrint(input.assistantText).length > REPETITION.minSimilarLength) {
+      const sim = trigramSimilarity(input.assistantText, input.previousText);
+      if (sim >= REPETITION.similarityThreshold) {
+        return `cosmetic churn: wrote files but the reply is ~${Math.round(sim * 100)}% identical to the previous iteration`;
+      }
+    }
+    return undefined;
+  }
   if ((input.gitCommitCount ?? 0) > 0) return undefined;
   if ((input.specItemProgressCount ?? 0) > 0) return undefined;
   if (forwardTransitionPaired(input)) return undefined;

package/extensions/goal-settings.ts

@@ -211,6 +211,7 @@ export const SETTINGS_KEYS: Array<keyof Settings> = [
   "stallSimilarityThreshold",
   "postaudit",
   "toolOverrides",
+  "reviewer", // v0.33.1: legacy alias — menu saves can write it; provenance must know it exists
 ];
 
 /** Where each effective setting comes from (for the /glla display). */

package/extensions/loops/goal.ts

@@ -169,6 +169,9 @@ import {
   LOOP_DEFAULTS,
   resolveSpecFiles,
   respecTarget,
+  topOpenAuditFinding,
+  specFileHash,
+  countCheckedSpecItems,
   auditMeasureCmd,
   auditTarget,
   AUDIT_PLATEAU_MAX_REPRIEVES,
@@ -639,13 +642,17 @@ function summarizeToolArg(name: string, input: any): string | undefined {
   if (!input || typeof input !== "object") return undefined;
   const v = input.file_path ?? input.path ?? input.command ?? input.pattern ?? input.query ?? input.url ?? input.title;
   if (typeof v !== "string" || v.length === 0) return undefined;
-  const base = name === "bash" ? v : v.split("/").pop() || v;
+  // v0.33.1: strip control chars BEFORE truncating — a raw \n breaks the
+  // widget card into un-prefixed lines (footer spoof), a raw ESC corrupts
+  // the TUI. The objective path was already whitespace-collapsed; this
+  // path was the gap.
+  const base = (name === "bash" ? v : v.split("/").pop() || v).replace(/[\x00-\x1f\x7f-\x9f]/g, " ").replace(/\s+/g, " ").trim();
   return base.length <= 24 ? base : base.slice(0, 23) + "…";
 }
 function noteToolCall(event: any): void {
   const name = String(event?.toolName ?? "?");
   const id = String(event?.toolCallId ?? event?.id ?? `anon-${Date.now()}`);
-  if (inFlightToolCalls.size > 20) inFlightToolCalls.delete(inFlightToolCalls.keys().next().value!);
+  if (inFlightToolCalls.size >= 20) inFlightToolCalls.delete(inFlightToolCalls.keys().next().value!); // v0.33.1: evict BEFORE the 21st
   inFlightToolCalls.set(id, { name, arg: summarizeToolArg(name, event?.input ?? event?.args), at: Date.now() });
 }
 function noteToolResult(event: any): void {
@@ -865,6 +872,14 @@ function heartbeatTick(): void {
     if (!absorbStaleIfSuperseded(ctx)) goStaleTerminal(ctx, "heartbeat probe");
     return;
   }
+  // v0.33.1: nothing supervised → the compact debt/resync belong to a dead
+  // goal/loop. Discharge here so a later goal can't inherit a bogus RESYNC
+  // block or a spurious forced refire (the old in-guard `else` was
+  // unreachable — isSupervising() ≡ isLoopActive() || isActionableGoal()).
+  if (!isSupervising() && (postCompactResumeOwed || postCompactResyncPending)) {
+    postCompactResumeOwed = false;
+    postCompactResyncPending = false;
+  }
   // v0.32.1: post-compaction resume debt — retry on every heartbeat tick
   // past grace until a turn actually starts. Fixed-offset settles alone
   // can both lose (pi busy at 2s AND at grace+2s = a dangling chain).
@@ -1104,7 +1119,10 @@ function sendContinuation(goalId: string): void {
   }
   if (!extensionApi || extensionApiStale) return;
   try {
-    const resync = postCompactResyncPending ? buildPostCompactResync() : "";
+    let resync = "";
+    // v0.33.1: a builder throw (corrupt restored state) must not masquerade
+    // as a transport failure — send without the block instead.
+    if (postCompactResyncPending) { try { resync = buildPostCompactResync(); } catch { resync = ""; } }
     extensionApi.sendMessage({
       customType: GOAL_EVENT_ENTRY,
       content: resync + continuationPrompt(state.goal!),
@@ -1279,6 +1297,14 @@ function notifyPersistenceState(ctx: ExtensionContext): void {
 }
 
 function setGoal(goal: Goal, ctx: ExtensionContext, via = "user"): void {
+  // v0.33.1: per-goal module state resets at activation — a new goal must
+  // not inherit the previous goal's compact debt/resync, quota streak,
+  // token-message dedupe set, or widget action feed.
+  postCompactResumeOwed = false;
+  postCompactResyncPending = false;
+  quotaRetryStreak = 0;
+  countedTokenMessages.clear();
+  recentActions.length = 0;
   // 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").
@@ -1397,6 +1423,8 @@ async function fanOutListAuditFindings(ctx: ExtensionContext): Promise<void> {
 }
 
 function archiveCurrentGoal(ctx: ExtensionContext, status: Status, stopReason?: string): void {
+  postCompactResumeOwed = false; // v0.33.1: the dead goal's compact debt/resync dies with it
+  postCompactResyncPending = false;
   if (!state.goal) return;
   const goal = state.goal;
   ensureDirs(ctx.cwd);
@@ -2589,7 +2617,7 @@ async function runGit(ctx: ExtensionContext, args: string[]): Promise<{ ok: bool
   }
 }
 
-function loopPrompt(loop: LoopState, regressionNote: string, strategyNote: string, boundsNote: string, interventionNote = "", variantNote = ""): string {
+function loopPrompt(loop: LoopState, regressionNote: string, strategyNote: string, boundsNote: string, interventionNote = "", variantNote = "", hypothesisNote = "", refineHintNote = ""): string {
   // v0.23.0: metricless loops get their own prompt — no metric section,
   // anti-doorknob rules instead of anti-gaming rules.
   const metricless = !loop.measureCmd;
@@ -2616,7 +2644,9 @@ function loopPrompt(loop: LoopState, regressionNote: string, strategyNote: strin
     .replace(/\$\{STRATEGY_NOTE\}/g, strategyNote)
     .replace(/\$\{BOUNDS_NOTE\}/g, boundsNote)
     .replace(/\$\{INTERVENTION_NOTE\}/g, interventionNote)
-    .replace(/\$\{VARIANT_NOTE\}/g, variantNote);
+    .replace(/\$\{VARIANT_NOTE\}/g, variantNote)
+    .replace(/\$\{HYPOTHESIS_NOTE\}/g, hypothesisNote)
+    .replace(/\$\{REFINE_HINT\}/g, refineHintNote);
 }
 
 function scheduleLoopTick(ctx: ExtensionContext): void {
@@ -2638,7 +2668,13 @@ function sendLoopTurn(): void {
   if (!isLoopActive() || !extensionApi) return;
   const ctx = freshCtx();
   if (!ctx || !ctx.isIdle() || ctx.hasPendingMessages()) {
-    if (ctx) accountSendRearm(ctx, "loop");
+    if (!ctx) {
+      // v0.33.1: mirror sendContinuation — probe the handle (terminal exit)
+      // and advance the streak so the cadence backs off instead of spinning
+      // a flat 50ms below every watchdog.
+      if (probeExtensionApiStale()) return;
+      loopRearmStreak++;
+    } else accountSendRearm(ctx, "loop");
     loopTimer = setTimeout(() => sendLoopTurn(), sendRearmDelayMs(loopRearmStreak)); // v0.28.29: backing-off cadence
     loopTimer.unref?.();
     return;
@@ -2662,7 +2698,13 @@ function sendLoopTurn(): void {
   // Strategy rotation (from pi-loop-mode's one good idea): one stall before
   // the plateau window closes, stop polishing and change approach entirely.
   const strategyNote = loop.stallCount >= loop.plateauWindow - 1 && loop.stallCount > 0
-    ? "**You are one stall from a plateau stop. Small tweaks are not working — try a FUNDAMENTALLY different approach: different file, different technique, or revert and rethink the angle of attack.**"
+    ? "**You are one stall from a plateau stop. Small tweaks are not working — try a FUNDAMENTALLY different approach: different file, different technique, or revert and rethink the angle of attack.**" +
+      // v0.33.2: a metric flat AT BEST may mean the spec stopped capturing
+      // "better" — the loop holds the evidence, so it says so (was: the
+      // prompt said "call propose_loop_refine" but the loop never suggested it).
+      (loop.lastValue !== null && loop.lastValue === loop.bestValue
+        ? " **The metric has been flat at best — if the spec no longer captures 'better' (saturated metric, drifted target), call propose_loop_refine.**"
+        : "")
     : "";
   // v0.15.0: arbitrary bounds (never "completion") — surface what's armed.
   // v0.23.0: for metricless loops the bounds are the ONLY stop (no
@@ -2693,11 +2735,19 @@ function sendLoopTurn(): void {
   // v0.24.0: identical prompts invite identical answers — rotate the base
   // instruction (metricless loops; metric loops already vary via values).
   const variantNote = metricless ? continueVariant(loop.iteration) : "";
+  // v0.33.2: one-shot prompt payloads, consumed on use.
+  const hypothesisNote = loop.hypothesisFeedback ?? "";
+  if (hypothesisNote) loop.hypothesisFeedback = undefined;
+  const refineHintNote = loop.refineHint
+    ? `**The operator suggests refining the spec:** ${loop.refineHint} — if the current spec no longer captures "better", call propose_loop_refine (target and/or measureCmd${loop.specFile ? " and/or specText/specAppend" : ""}); if it still stands, say why in one line and keep working.`
+    : "";
+  if (refineHintNote) loop.refineHint = undefined;
   try {
-    const loopResync = postCompactResyncPending ? buildPostCompactResync() : "";
+    let loopResync = "";
+    if (postCompactResyncPending) { try { loopResync = buildPostCompactResync(); } catch { loopResync = ""; } } // v0.33.1
     extensionApi.sendMessage({
       customType: GOAL_EVENT_ENTRY,
-      content: loopResync + loopPrompt(loop, regressionNote, strategyNote, boundsNote, interventionNote, variantNote),
+      content: loopResync + loopPrompt(loop, regressionNote, strategyNote, boundsNote, interventionNote, variantNote, hypothesisNote, refineHintNote),
       display: false,
     }, { triggerTurn: true, deliverAs: "followUp" });
     if (loopResync) postCompactResyncPending = false; // consumed only by a landed send
@@ -2768,6 +2818,23 @@ async function runLoopTick(ctx: ExtensionContext, event?: any): Promise<void> {
       }
     } catch { /* no ledger yet */ }
   }
+  // v0.33.2: respec spec drift + checkbox progress — hash compared per
+  // tick (external edits ledger spec_updated); newly checked boxes emit
+  // the spec_item_progress signal the stuck gate already consumes (it was
+  // consumed-but-never-emitted until now).
+  if (loop.specFile) {
+    const hash = specFileHash(loop.specFile);
+    if (hash && loop.specHash && loop.specHash !== hash) {
+      appendLedger(ctx.cwd, "spec_updated", { via: "external", iteration: loop.iteration });
+      ctx.ui.notify("Spec file changed mid-loop — drift ledgered (spec_updated).", "info");
+    }
+    if (hash) loop.specHash = hash;
+    const checked = countCheckedSpecItems(loop.specFile);
+    if (checked !== null && loop.specChecked !== undefined && checked > loop.specChecked) {
+      appendLedger(ctx.cwd, "spec_item_progress", { iteration: loop.iteration, newlyChecked: checked - loop.specChecked, totalChecked: checked });
+    }
+    if (checked !== null) loop.specChecked = checked;
+  }
   const iterSignals = {
     fileWrites: loop.iterMetrics?.fileWrites ?? 0,
     gitCommits,
@@ -2807,6 +2874,26 @@ async function runLoopTick(ctx: ExtensionContext, event?: any): Promise<void> {
     loop.lastStuckReason = undefined;
   }
   let outcome: LoopTickOutcome = metricless ? applyMetriclessTick(loop, nowIso()) : applyMeasurement(loop, value, nowIso());
+  // v0.33.2: close the hypothesis feedback loop — the prediction went into
+  // the ledger; now the VERDICT rides the next iteration's prompt.
+  if (loop.lastHypothesis) {
+    const h = loop.history;
+    const cur = h.length >= 1 ? h[h.length - 1]!.value : null;
+    const prev = h.length >= 2 ? h[h.length - 2]!.value : null;
+    if (metricless || cur === null) {
+      loop.hypothesisFeedback = `Last iteration you predicted: "${loop.lastHypothesis}". ${metricless ? "Metricless loop — no number to verify it against; say honestly whether the prediction landed." : "The measure printed no number — the prediction is unverifiable."}`;
+    } else {
+      const moved = prev === null
+        ? `first measurement ${cur}`
+        : cur === prev
+          ? `flat at ${cur}`
+          : loop.direction === "min"
+            ? (cur < prev ? `improved ${prev} → ${cur}` : `regressed ${prev} → ${cur}`)
+            : (cur > prev ? `improved ${prev} → ${cur}` : `regressed ${prev} → ${cur}`);
+      loop.hypothesisFeedback = `Last iteration you predicted: "${loop.lastHypothesis}". Result: metric ${moved} (best ${loop.bestValue}).`;
+    }
+  }
+  loop.lastHypothesis = hypothesis;
   persistState(ctx);
   appendLedger(ctx.cwd, "loop_measured", {
     iteration: loop.iteration,
@@ -2860,7 +2947,8 @@ async function runLoopTick(ctx: ExtensionContext, event?: any): Promise<void> {
           loop.stopReason = undefined;
           loop.stallCount = 0;
           loop.auditPlateauReprieves = reprieves;
-          loop.auditReprieveNote = `PLATEAU REPRIEVE (${reprieves}/${AUDIT_PLATEAU_MAX_REPRIEVES}): ${open} finding(s) still OPEN in ${AUDIT_FINDINGS_REL} — the plateau stop does not fire while the well isn't dry. Stop hunting and stop narrating: pick the smallest OPEN finding and CLOSE it this iteration (fix commit + checked box). ${AUDIT_PLATEAU_MAX_REPRIEVES - reprieves} reprieve(s) remain.`;
+          const topFinding = topOpenAuditFinding(ctx.cwd); // v0.33.2: name what to close, not just the count
+          loop.auditReprieveNote = `PLATEAU REPRIEVE (${reprieves}/${AUDIT_PLATEAU_MAX_REPRIEVES}): ${open} finding(s) still OPEN in ${AUDIT_FINDINGS_REL} — the plateau stop does not fire while the well isn't dry. Stop hunting and stop narrating: pick the smallest OPEN finding and CLOSE it this iteration (fix commit + checked box).${topFinding ? ` Top open: ${topFinding}` : ""} ${AUDIT_PLATEAU_MAX_REPRIEVES - reprieves} reprieve(s) remain.`;
           persistState(ctx);
           appendLedger(ctx.cwd, "audit_plateau_reprieve", { open, reprieves, best: loop.bestValue });
           ctx.ui.notify(`Audit loop plateau reprieve (${reprieves}/${AUDIT_PLATEAU_MAX_REPRIEVES}): ${open} open findings — the well isn't dry, continuing.`, "info");
@@ -2919,6 +3007,9 @@ interface LoopConfig {
   deferBaseline?: boolean;
   /** v0.29.10: audit loops get audit-flavoured regression wording. */
   kind?: "audit";
+  /** v0.33.2: respec loops carry their spec file (drift detection,
+   * checkbox progress, refine specText writes). */
+  specFile?: string;
 }
 
 /** Shared loop-start path: /loop start AND propose_loop_draft (after Confirm). */
@@ -2985,6 +3076,9 @@ async function startLoopFromConfig(ctx: ExtensionContext, cfg: LoopConfig): Prom
       branchName,
       originalBranch,
       toolSameRepeat: cfg.toolSameRepeat,
+      specFile: cfg.specFile,
+      specHash: cfg.specFile ? specFileHash(cfg.specFile) ?? undefined : undefined,
+      specChecked: cfg.specFile ? countCheckedSpecItems(cfg.specFile) ?? undefined : undefined,
       iterMetrics: { fileWrites: 0, iterationStartAt: nowIso() },
     },
   };
@@ -3103,6 +3197,28 @@ async function cmdLoop(args: string, ctx: ExtensionContext): Promise<void> {
 
   // 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 === "refine" || sub === "polish") {
+    // v0.33.2: the operator's respec verb. The refine flow stays
+    // agent-proposed + user-confirmed (propose_loop_refine) — this command
+    // queues the operator's suggestion into the next iteration's prompt.
+    // ("polish" accepted as an alias: the widget footer advertised it
+    // before the command existed — now it does.)
+    if (!isLoopActive()) {
+      ctx.ui.notify("No active loop to refine — /loop start first.", "warning");
+      return;
+    }
+    const hint = rest.trim();
+    if (!hint) {
+      ctx.ui.notify("Usage: /loop refine <what the spec should capture better> — the suggestion rides the next iteration's prompt; the agent proposes via propose_loop_refine and you confirm.", "info");
+      return;
+    }
+    state.loop!.refineHint = hint.slice(0, 300);
+    persistState(ctx);
+    appendLedger(ctx.cwd, "loop_refine_hint", { iteration: state.loop!.iteration, hint: state.loop!.refineHint });
+    ctx.ui.notify("Refine hint queued — it rides the next iteration's prompt.", "info");
+    return;
+  }
+
   if (sub === "stop" || sub === "cancel") {
     if (!state.loop) {
       ctx.ui.notify("No loop to stop.", "info");
@@ -3241,6 +3357,7 @@ async function cmdLoop(args: string, ctx: ExtensionContext): Promise<void> {
       maxIterations: 0,
       branch: false,
       force: false,
+      specFile: specPath, // v0.33.2
     });
     return;
   }
@@ -4092,12 +4209,14 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
     parameters: Type.Object({
       target: Type.Optional(Type.String({ description: "The sharpened target text (omit to keep the current target)" })),
       measureCmd: Type.Optional(Type.String({ description: "The new measure command printing ONE number (omit to keep the current metric)" })),
+      specText: Type.Optional(Type.String({ description: "v0.33.2: full replacement text for the loop's spec file (respec loops only) — the orchestrator owns the write on user confirm" })),
+      specAppend: Type.Optional(Type.String({ description: "v0.33.2: lines to append to the loop's spec file (respec loops only)" })),
       rationale: Type.String({ description: "Why the current spec no longer captures 'better' — shown to the user in the Confirm dialog" }),
     }),
     async execute(_id, params, _signal, _onUpdate, execCtx) {
       const foreign4 = foreignToolGuard(execCtx);
       if (foreign4) return { content: [{ type: "text", text: foreign4 }], details: {} };
-      const p = params as { target?: string; measureCmd?: string; rationale: string };
+      const p = params as { target?: string; measureCmd?: string; specText?: string; specAppend?: string; rationale: string };
       const liveCtx = (execCtx as ExtensionContext | undefined) ?? ctx;
       const loop = state.loop;
       if (!loop?.active) {
@@ -4110,8 +4229,12 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       if (!loop.measureCmd && p.measureCmd?.trim()) {
         return { content: [{ type: "text", text: "This loop is metricless — refining it into a measured loop isn't supported. /loop stop, then /loop start with a metric." }], details: {} };
       }
-      if (newTarget === loop.target && newMeasure === loop.measureCmd) {
-        return { content: [{ type: "text", text: "Refinement proposed no changes — provide a new target, a new measureCmd, or both." }], details: {} };
+      const specChange = (p.specText?.trim() || p.specAppend?.trim()) ? true : false;
+      if (specChange && !loop.specFile) {
+        return { content: [{ type: "text", text: "This loop has no spec file (specText/specAppend apply to /loop respec loops). Refine the target instead." }], details: {} };
+      }
+      if (newTarget === loop.target && newMeasure === loop.measureCmd && !specChange) {
+        return { content: [{ type: "text", text: "Refinement proposed no changes — provide a new target, a new measureCmd, a spec change, or any combination." }], details: {} };
       }
       // Measure change → orchestrator test-runs the new command first.
       let newBaseline: number | null = null;
@@ -4142,7 +4265,7 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
           confirmed = (await confirmDraft(
             liveCtx,
             "Confirm loop spec refinement",
-          `Rationale: ${p.rationale}\n\nTarget:\n  old: ${loop.target.slice(0, 120)}\n  new: ${newTarget.slice(0, 120)}\n\nMeasure:\n  old: ${loop.measureCmd}\n  new: ${newMeasure}${newMeasure !== loop.measureCmd ? `\n  test-run: ${testOutput.slice(0, 120)} → ${newBaseline}` : ""}\n\nThe loop keeps running against the refined spec (iteration ${loop.iteration} so far). Apply?`,
+          `Rationale: ${p.rationale}\n\nTarget:\n  old: ${loop.target.slice(0, 120)}\n  new: ${newTarget.slice(0, 120)}\n\nMeasure:\n  old: ${loop.measureCmd}\n  new: ${newMeasure}${newMeasure !== loop.measureCmd ? `\n  test-run: ${testOutput.slice(0, 120)} → ${newBaseline}` : ""}${specChange ? `\n\nSpec file (${loop.specFile}):\n  ${p.specText?.trim() ? `REPLACE with ${p.specText!.trim().length} chars` : ""}${p.specText?.trim() && p.specAppend?.trim() ? " + " : ""}${p.specAppend?.trim() ? `APPEND: ${p.specAppend!.trim().slice(0, 120)}` : ""}` : ""}\n\nThe loop keeps running against the refined spec (iteration ${loop.iteration} so far). Apply?`,
           )) === "yes";
         } catch {
           confirmed = false;
@@ -4159,9 +4282,22 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
         oldMeasureCmd: loop.measureCmd ?? "",
         newMeasureCmd: newMeasure,
       }, newBaseline);
+      // v0.33.2: the orchestrator owns the spec write (honesty stays
+      // inspectable — the agent never edits the spec it's judged against
+      // outside a confirmed refine).
+      if (specChange && loop.specFile) {
+        try {
+          if (p.specText?.trim()) fs.writeFileSync(loop.specFile, p.specText.trim() + "\n");
+          if (p.specAppend?.trim()) fs.appendFileSync(loop.specFile, (p.specText?.trim() ? "" : "\n") + p.specAppend.trim() + "\n");
+          loop.specHash = specFileHash(loop.specFile) ?? undefined;
+          appendLedger(liveCtx.cwd, "spec_updated", { via: "refine", iteration: loop.iteration, replaced: Boolean(p.specText?.trim()), appended: Boolean(p.specAppend?.trim()) });
+        } catch (e) {
+          return { content: [{ type: "text", text: `Spec file write failed: ${String(e).slice(0, 200)}. The target/measure refinement was applied; re-propose the spec change.` }], details: {} };
+        }
+      }
       persistState(liveCtx);
-      appendLedger(liveCtx.cwd, "loop_refined", { iteration: loop.iteration, newTarget, newMeasureCmd: newMeasure, newBaseline });
-      liveCtx.ui.notify(`Loop spec refined at iteration ${loop.iteration}.${newBaseline !== null ? ` New baseline: ${newBaseline}.` : ""}`, "info");
+      appendLedger(liveCtx.cwd, "loop_refined", { iteration: loop.iteration, newTarget, newMeasureCmd: newMeasure, newBaseline, specChanged: specChange || undefined });
+      liveCtx.ui.notify(`Loop spec refined at iteration ${loop.iteration}.${newBaseline !== null ? ` New baseline: ${newBaseline}.` : ""}${specChange ? " Spec file updated." : ""}`, "info");
       return { content: [{ type: "text", text: "Refinement confirmed and applied. Continue improving against the NEW spec — one small change per turn." }], details: {} };
     },
   }));
@@ -5920,6 +6056,9 @@ export default function (pi: ExtensionAPI): void {
     writeOwnerFile(ctx.cwd);
     sessionReplacementUntil = 0;
     zombieStoodDown = false;
+    staleTerminalDone = false; // v0.33.1: a rebound session must be able to go terminal AGAIN (was: one-shot for the process lifetime)
+    postCompactResumeOwed = false; // v0.33.1: a compact from a previous session must not resync THIS one
+    postCompactResyncPending = false;
     const startReason = typeof event?.reason === "string" ? event.reason : "unknown";
     appendLedger(ctx.cwd, "session_rebound", { reason: startReason });
     if (extensionApiStale) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goal-list-loop-audit",
-  "version": "0.33.0",
+  "version": "0.33.2",
   "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-forever-metricless.md

@@ -31,6 +31,8 @@ fails, retry with a different approach — just continue, don't stall the loop
 asking permission. You remain the single writer: apply the edit yourself.
 
 ${INTERVENTION_NOTE}
+${HYPOTHESIS_NOTE}
+${REFINE_HINT}
 ${REGRESSION_NOTE}
 ${STRATEGY_NOTE}
 

package/prompts/goal-loop-forever.md

@@ -35,6 +35,8 @@ fails, retry with a different approach — just continue, don't stall the loop
 asking permission. You remain the single writer: apply the edit yourself.
 
 ${INTERVENTION_NOTE}
+${HYPOTHESIS_NOTE}
+${REFINE_HINT}
 ${REGRESSION_NOTE}
 ${STRATEGY_NOTE}