pi-goal-list-loop-audit 0.35.67 → 0.35.68

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.35.68 — bound-stop recovery (2026-08-26)
+
+### Fixed
+  Explicit `/loop resume` now recovers time- and token-bound stops as fresh
+  supervised windows without discarding iteration, history, or best-value
+  state. Recoverable stopped loops can accept a confirmed
+  `propose_loop_refine` change while remaining stopped until explicitly
+  resumed. Clean max-iteration and finished loops remain terminal; automatic
+  startup does not silently reset an explicit budget.
+
+### Tests
+  Coverage verifies fresh time windows, token-budget resets, preserved loop
+  history, stopped-loop refinement, and the unchanged max-iteration guard.
+
 ## 0.35.67 — in-band provider-result recovery (2026-08-26)
 
 ### Fixed

package/extensions/goal-loop-forever.ts

@@ -54,6 +54,23 @@ export function isLifecycleHeldLoopReason(reason?: string): boolean {
     || !!reason?.startsWith("send-retry storm:");
 }
 
+/** A stopped loop can be respecified without discarding its history when the
+ * stop is a recoverable work failure or an explicit time/token window. Max
+ * iterations and clean/user stops remain terminal until a fresh `/loop start`.
+ */
+export function isRefinableStoppedLoopReason(reason?: string): boolean {
+  return !!reason && (
+    reason.startsWith("time bound reached")
+    || reason.startsWith("token budget exhausted")
+    || reason.startsWith("stuck —")
+    || reason.startsWith("plateau —")
+    || reason.startsWith("metric never moved —")
+    || reason.startsWith("measure command broken —")
+    || reason.startsWith("provider errors —")
+    || reason.startsWith("stalled:")
+  );
+}
+
 export interface LoopState {
   target: string;
   /** v0.23.0: optional — a metricless "spec loop" (measure=none) has no

package/extensions/goal-loop.ts

@@ -939,6 +939,8 @@ async function cmdLoop(args: string, ctx: ExtensionContext): Promise<void> {
       !!r?.startsWith("plateau —") ||
       !!r?.startsWith("stalled:") ||
       !!r?.startsWith("stuck —") ||
+      !!r?.startsWith("time bound reached") ||
+      !!r?.startsWith("token budget exhausted") ||
       // v0.35.54 (collect-pass HIGH finding): the v0.35.31 "metric never
       // moved" stop message promises "/loop resume retries or /loop stop",
       // but this predicate never matched that prefix — the promised command
@@ -983,8 +985,33 @@ async function cmdLoop(args: string, ctx: ExtensionContext): Promise<void> {
       // An explicit resume re-arms the counters: fresh stall window,
       // cleared dead-turn/stuck streaks, reprieves restored — the user
       // saying "push again" wins over the ladder's memory (v0.29.19).
-      state.loop = { ...stored, active: true, stopReason: undefined, consecutiveErrors: 0, consecutiveStuck: 0, lastStuckReason: undefined, stallCount: 0, auditPlateauReprieves: 0 };
+      // Time and token bounds are per supervised run window: resuming a
+      // bound-stopped loop preserves its iteration/history/best but starts a
+      // fresh elapsed-time window or token budget instead of stopping again
+      // on the same bound.
+      const resetTimeWindow = stored.stopReason?.startsWith("time bound reached") ?? false;
+      const resetTokenBudget = stored.stopReason?.startsWith("token budget exhausted") ?? false;
+      const resumedAt = nowIso();
+      state.loop = {
+        ...stored,
+        active: true,
+        stopReason: undefined,
+        consecutiveErrors: 0,
+        consecutiveStuck: 0,
+        lastStuckReason: undefined,
+        stallCount: 0,
+        auditPlateauReprieves: 0,
+        ...(resetTimeWindow ? { startedAt: resumedAt } : {}),
+        ...(resetTokenBudget ? { tokensUsed: 0 } : {}),
+      };
       persistState(ctx);
+      if (resetTimeWindow || resetTokenBudget) {
+        appendLedger(ctx.cwd, "loop_bound_window_reset", {
+          timeWindow: resetTimeWindow,
+          tokenBudget: resetTokenBudget,
+          iteration: stored.iteration,
+        });
+      }
       // v0.35.23 (note.md Next #2): an explicit resume is exactly the
       // decision a load hold waits for — release it or the tick below
       // would be frozen.
@@ -995,8 +1022,13 @@ async function cmdLoop(args: string, ctx: ExtensionContext): Promise<void> {
       releaseContinuationDispatchStandDown();
       releaseAuditorSurface();
       scheduleLoopTick(ctx);
+      const boundResetNote = resetTimeWindow
+        ? " · fresh time window"
+        : resetTokenBudget
+          ? " · fresh token budget"
+          : "";
       ctx.ui.notify(
-        `Loop resumed: iteration ${stored.iteration}/${stored.maxIterations > 0 ? stored.maxIterations : "∞"} · best ${stored.bestValue ?? "n/a"} — ${displaySlice(stored.target, 60)}`, 
+        `Loop resumed: iteration ${stored.iteration}/${stored.maxIterations > 0 ? stored.maxIterations : "∞"} · best ${stored.bestValue ?? "n/a"}${boundResetNote} — ${displaySlice(stored.target, 60)}`,
         "info",
       );
       return;

package/extensions/loops/goal-tools.ts

@@ -318,6 +318,7 @@ import {
   listAuditFanoutItemText,
   type LoopTickOutcome,
   HELD_ON_RESTORE,
+  isRefinableStoppedLoopReason,
   type LoopState,
 } from "../goal-loop-forever.js";
 import {
@@ -1928,7 +1929,7 @@ function registerAgentTools(pi: any): void {
   pi.registerTool(defineTool({
     name: "propose_loop_refine",
     label: "Propose loop spec refinement",
-    description: "While a loop is ACTIVE, propose refining the loop's spec — sharpen the target and/or change the measure command — when the current spec no longer captures 'better'. The user confirms; on a measure change the orchestrator test-runs the new command and re-baselines. Never edit the measure command or its inputs directly — that is gaming the metric.",
+    description: "While a loop is active or safely stopped by a recoverable bound/failure, propose refining its spec — sharpen the target and/or change the measure command — when the current spec no longer captures 'better'. The user confirms; on a measure change the orchestrator test-runs the new command and re-baselines. Never edit the measure command or its inputs directly — that is gaming the metric.",
     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)" })),
@@ -1943,9 +1944,11 @@ function registerAgentTools(pi: any): void {
       const liveCtx = currentToolContext(execCtx);
       if (!liveCtx) return staleToolResult();
       const loop = state.loop;
-      if (!loop?.active) {
-        return { content: [{ type: "text", text: "No active loop to refine. propose_loop_refine is only valid while a loop is running." }], details: {} };
+      const stoppedRefinable = !!loop && !loop.active && isRefinableStoppedLoopReason(loop.stopReason);
+      if (!loop || (!loop.active && !stoppedRefinable)) {
+        return { content: [{ type: "text", text: "No refinable loop is available. propose_loop_refine applies while a loop is running or after a recoverable bound/failure stop; clean max-iteration and user-finished loops require /loop start." }], details: {} };
       }
+      const wasActive = loop.active;
       const newTarget = p.target?.trim() || loop.target;
       const newMeasure = p.measureCmd?.trim() || loop.measureCmd || "";
       // v0.23.0: a metricless loop can't be refined into a measured one
@@ -1989,7 +1992,7 @@ function registerAgentTools(pi: any): void {
           confirmed = (await confirmDraft(
             liveCtx,
             "Confirm loop spec refinement",
-          `Rationale: ${sanitizeDisplayText(p.rationale)}\n\nTarget:\n  old: ${displaySlice(loop.target, 120)}\n  new: ${displaySlice(newTarget, 120)}\n\nMeasure:\n  old: ${sanitizeDisplayText(loop.measureCmd ?? "none")}\n  new: ${sanitizeDisplayText(newMeasure)}${newMeasure !== loop.measureCmd ? `\n  test-run: ${sanitizeDisplayText(testOutput).slice(0, 120)} → ${newBaseline}` : ""}${specChange ? `\n\nSpec file (${sanitizeDisplayText(loop.specFile ?? "")}:\n  ${p.specText?.trim() ? `REPLACE with ${p.specText!.trim().length} chars` : ""}${p.specText?.trim() && p.specAppend?.trim() ? " + " : ""}${p.specAppend?.trim() ? `APPEND: ${sanitizeDisplayText(p.specAppend!.trim()).slice(0, 120)}` : ""}` : ""}\n\nThe loop keeps running against the refined spec (iteration ${loop.iteration} so far). Apply?`,
+          `Rationale: ${sanitizeDisplayText(p.rationale)}\n\nTarget:\n  old: ${displaySlice(loop.target, 120)}\n  new: ${displaySlice(newTarget, 120)}\n\nMeasure:\n  old: ${sanitizeDisplayText(loop.measureCmd ?? "none")}\n  new: ${sanitizeDisplayText(newMeasure)}${newMeasure !== loop.measureCmd ? `\n  test-run: ${sanitizeDisplayText(testOutput).slice(0, 120)} → ${newBaseline}` : ""}${specChange ? `\n\nSpec file (${sanitizeDisplayText(loop.specFile ?? "")}:\n  ${p.specText?.trim() ? `REPLACE with ${p.specText!.trim().length} chars` : ""}${p.specText?.trim() && p.specAppend?.trim() ? " + " : ""}${p.specAppend?.trim() ? `APPEND: ${sanitizeDisplayText(p.specAppend!.trim()).slice(0, 120)}` : ""}` : ""}\n\nThe loop ${wasActive ? "keeps running" : "stays stopped until /loop resume"} against the refined spec (iteration ${loop.iteration} so far). Apply?`,
           )) === "yes";
         } catch {
           confirmed = false;
@@ -2026,8 +2029,10 @@ function registerAgentTools(pi: any): void {
       }
       persistState(liveCtx);
       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: {} };
+      liveCtx.ui.notify(`Loop spec refined at iteration ${loop.iteration}.${newBaseline !== null ? ` New baseline: ${newBaseline}.` : ""}${specChange ? " Spec file updated." : ""}${wasActive ? "" : " Run /loop resume to continue with the preserved history."}`, "info");
+      return { content: [{ type: "text", text: wasActive
+        ? "Refinement confirmed and applied. Continue improving against the NEW spec — one small change per turn."
+        : "Refinement confirmed and applied to the stopped loop. Run /loop resume to continue with the preserved history." }], details: {} };
     },
   }));
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goal-list-loop-audit",
-  "version": "0.35.67",
+  "version": "0.35.68",
   "description": "Mission control for autonomous pi: interview-drafted goals, an audited task queue, and forever-loops (metric, spec, project-audit) that run for hours. A detached extension-less auditor process re-verifies every completion with raw evidence without holding the main pi turn; confirmed drafts, decision pauses and consent gates keep you in charge.",
   "license": "AGPL-3.0-only",
   "author": "dracon",