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

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## 0.35.69 — metricless-loop cadence (2026-08-26)
+
+### Added
+  Metricless and measured loops accept an opt-in `cadence=<seconds>` minimum
+  interval between successful automatic iterations. The cadence is persisted,
+  shown in `/loop status` and loop prompts, and explicit starts/resumes bypass
+  it for an urgent wake. The default remains unchanged.
+
+### Tests
+  Coverage verifies cadence parsing, delayed automatic re-wakes, urgent
+  explicit starts, and the existing unbounded metricless behavior.
+
+## 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/INSTALL.md

@@ -98,13 +98,15 @@ waiting for a decision.
 
 /loop
 /loop start "reduce flaky tests" measure="..." direction=min
-/loop start "keep improving the spec" measure=none max=20
+/loop start "keep improving the spec" measure=none max=20 cadence=900
 /loop audit
 ```
 
 Use `/goal` for one outcome, `/list` for several independently auditable
-outcomes, and `/loop` for an improvement process without one final item. See
-the README for the full command semantics.
+outcomes, and `/loop` for an improvement process without one final item. For
+metricless loops that intentionally mature between checks, add optional
+`cadence=<seconds>`; the interval is visible in `/loop status`, while explicit
+starts/resumes remain urgent. See the README for the full command semantics.
 
 ## Modes
 

package/README.md

@@ -170,7 +170,7 @@ automatic repeats are fenced. Use `/list resume` for an intentional retry and
 /loop                                     # interview + Confirm
 /loop plan                                # research-first loop design
 /loop start "reduce flaky tests" measure="..." direction=min
-/loop start "keep improving the spec" measure=none max=20
+/loop start "keep improving the spec" measure=none max=20 cadence=900
 /loop audit                               # recurring project-audit cadence
 /loop status
 /loop stop
@@ -183,7 +183,10 @@ There are three loop styles:
   before you confirm it and stops on plateau or a configured bound.
 - **Metricless specification:** no honest number exists, so the loop advances
   a specification or checklist. It ends at its time/token/iteration bound or
-  `/loop stop`; it has no fake plateau metric.
+  `/loop stop`; it has no fake plateau metric. Add optional
+  `cadence=<seconds>` to put a minimum gap between successful automatic
+  iterations; explicit starts/resumes remain urgent and `/loop status` shows
+  the armed cadence.
 - **Project audit:** each iteration looks for the next important finding,
   appends evidence to the audit ledger, and works through the findings.
 

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
@@ -103,6 +120,12 @@ export interface LoopState {
   tokenBudget?: number;
   /** v0.15.0: accumulated loop tokens (input+output), orchestrator-counted. */
   tokensUsed?: number;
+  /** v0.35.x: optional minimum gap between successful metricless-loop
+   * iterations. Units are milliseconds internally; absent means unchanged
+   * immediate cadence. */
+  minimumIterationIntervalMs?: number;
+  /** v0.35.x: completion timestamp used to arm the next cadence window. */
+  lastIterationCompletedAt?: string;
   /** v0.15.0: living spec — user-confirmed target/measure refinements. */
   refinements?: LoopRefinement[];
   /** branch=1 mode: scratch branch holding the loop's commits. */
@@ -382,6 +405,8 @@ export function parseLoopStartArgs(raw: string): {
   timeLimitHours?: number;
   tokenBudget?: number;
   toolSameRepeat?: number;
+  /** v0.35.x: optional metricless minimum cadence, supplied in seconds. */
+  minimumIterationIntervalMs?: number;
 } {
   // Key=value pairs first (measure= and direction= may hold quoted values),
   // the remaining text is the target. v0.35.4: quoted spans are TARGET
@@ -392,7 +417,7 @@ export function parseLoopStartArgs(raw: string): {
   let rest = raw.trim();
   const kv = new Map<string, string>();
   const kvRe = /(\w+)=(?:"([^"]*)"|'([^']*)'|(\S+))/g;
-  const KNOWN_KEYS = new Set(["measure", "direction", "window", "max", "branch", "force", "done", "time", "tokens", "toolsamerepeat"]);
+  const KNOWN_KEYS = new Set(["measure", "direction", "window", "max", "branch", "force", "done", "time", "tokens", "toolsamerepeat", "cadence"]);
   const quoteSpans: Array<[number, number]> = [];
   const quoteRe = /"([^"]*)"|'([^']*)'/g;
   let qm: RegExpExecArray | null;
@@ -447,6 +472,10 @@ export function parseLoopStartArgs(raw: string): {
   }
   const timeRaw = Number.parseFloat(kv.get("time") ?? "");
   const tokensRaw = Number.parseInt(kv.get("tokens") ?? "", 10);
+  const cadenceRaw = Number.parseFloat(kv.get("cadence") ?? "");
+  const cadenceMs = Number.isFinite(cadenceRaw) && cadenceRaw > 0
+    ? Math.min(Math.round(cadenceRaw * 1_000), 24 * 60 * 60_000)
+    : undefined;
   return {
     target,
     measureCmd: metricless ? "" : measureRaw,
@@ -467,6 +496,7 @@ export function parseLoopStartArgs(raw: string): {
       const n = Number.parseInt(raw, 10);
       return Number.isInteger(n) && n >= 0 ? n : undefined;
     })(),
+    ...(cadenceMs !== undefined ? { minimumIterationIntervalMs: cadenceMs } : {}),
   };
 }
 

package/extensions/goal-loop.ts

@@ -282,6 +282,17 @@ function loopPrompt(loop: LoopState, regressionNote: string, strategyNote: strin
 }
 
 function scheduleLoopTick(ctx: ExtensionContext): void {
+  // v0.35.15: `/glla pause` freezes loop re-arms too — the supervisor's
+  if (supervisorPaused(state)) return;
+  scheduleLoopTickWithUrgency(ctx, false);
+}
+
+function scheduleLoopTickUrgent(ctx: ExtensionContext): void {
+  if (supervisorPaused(state)) return;
+  scheduleLoopTickWithUrgency(ctx, true);
+}
+
+function scheduleLoopTickWithUrgency(ctx: ExtensionContext, urgent: boolean): void {
   // v0.35.15: `/glla pause` freezes loop re-arms too — the supervisor's
   // automatic machinery includes the metric loop's turn dispatch.
   if (supervisorPaused(state)) return;
@@ -295,7 +306,18 @@ function scheduleLoopTick(ctx: ExtensionContext): void {
   } catch {
     return;
   }
-  loopTimer = scheduleSessionTimeout(() => sendLoopTurn(), delay);
+  // A cadence is an intentional maturity gap between successful iterations,
+  // not a replacement for the busy-send backoff. Explicit starts/resumes are
+  // urgent wakes and bypass the gap once; automatic re-arms honor it.
+  if (!urgent) {
+    const loop = state.loop;
+    const intervalMs = loop?.minimumIterationIntervalMs;
+    const completedAt = loop?.lastIterationCompletedAt ? Date.parse(loop.lastIterationCompletedAt) : Number.NaN;
+    if (intervalMs !== undefined && Number.isFinite(completedAt)) {
+      delay = Math.max(delay, completedAt + intervalMs - Date.now());
+    }
+  }
+  loopTimer = scheduleSessionTimeout(() => sendLoopTurn(), Math.max(0, delay));
 }
 
 function sendLoopTurn(): void {
@@ -379,6 +401,9 @@ function sendLoopTurn(): void {
   } else if (bounds.length) {
     boundsNote = `\n- Arbitrary bounds: the loop also stops after ${bounds.join(" or ")}`;
   }
+  if (loop.minimumIterationIntervalMs !== undefined) {
+    boundsNote += `\n- Minimum cadence: wait at least ${Math.ceil(loop.minimumIterationIntervalMs / 1_000)}s after each completed iteration before the next automatic wake; explicit starts/resumes are urgent.`;
+  }
   // v0.24.0: a stuck intervention REPLACES the pep talk — the rotating
   // directive names why the loop is stuck and what rung of the ladder it's on.
   // v0.29.19: a plateau reprieve's one-shot shove takes priority over the
@@ -584,7 +609,9 @@ async function runLoopTick(initialCtx: ExtensionContext, event?: any): Promise<v
     loop.consecutiveStuck = 0;
     loop.lastStuckReason = undefined;
   }
-  let outcome: LoopTickOutcome = metricless ? applyMetriclessTick(loop, nowIso()) : applyMeasurement(loop, value, nowIso());
+  const completedAt = nowIso();
+  let outcome: LoopTickOutcome = metricless ? applyMetriclessTick(loop, completedAt) : applyMeasurement(loop, value, completedAt);
+  loop.lastIterationCompletedAt = completedAt;
   // 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) {
@@ -766,6 +793,8 @@ interface LoopConfig {
   force?: boolean;
   timeLimitHours?: number;
   tokenBudget?: number;
+  /** v0.35.x: optional metricless minimum cadence in milliseconds. */
+  minimumIterationIntervalMs?: number;
   /** v0.25.1: /loop start toolsamerepeat=N (0 = disable legacy check). */
   toolSameRepeat?: number;
   /** v0.29.10: don't seed bestValue from the pre-work baseline measure —
@@ -871,6 +900,7 @@ async function startLoopFromConfig(ctx: ExtensionContext, cfg: LoopConfig): Prom
       startedAt: nowIso(),
       timeLimitHours: cfg.timeLimitHours,
       tokenBudget: cfg.tokenBudget,
+      minimumIterationIntervalMs: cfg.minimumIterationIntervalMs,
       tokensUsed: 0,
       branchName,
       originalBranch,
@@ -882,16 +912,18 @@ async function startLoopFromConfig(ctx: ExtensionContext, cfg: LoopConfig): Prom
     },
   });
   persistState(ctx);
-  appendLedger(ctx.cwd, "loop_started", { target: cfg.target, measureCmd: cfg.measureCmd || "none", direction: cfg.direction ?? "none", baseline, branch: branchName, timeLimitHours: cfg.timeLimitHours, tokenBudget: cfg.tokenBudget });
+  appendLedger(ctx.cwd, "loop_started", { target: cfg.target, measureCmd: cfg.measureCmd || "none", direction: cfg.direction ?? "none", baseline, branch: branchName, timeLimitHours: cfg.timeLimitHours, tokenBudget: cfg.tokenBudget, minimumIterationIntervalMs: cfg.minimumIterationIntervalMs });
   ctx.ui.notify(
     metricless
       ? `Loop started (metricless spec loop — NO plateau stop): ${displaySlice(cfg.target, 60)}\nEnds only at ${cfg.maxIterations > 0 ? `max ${cfg.maxIterations} iterations` : "no iteration cap"}${cfg.timeLimitHours ? ` · ${cfg.timeLimitHours}h` : ""}${cfg.tokenBudget ? ` · ${cfg.tokenBudget.toLocaleString()} tokens` : ""} · /loop stop. Every iteration must make ONE real, inspectable change — cosmetic churn is the doorknob failure.` +
+        (cfg.minimumIterationIntervalMs ? ` · cadence ≥ ${Math.ceil(cfg.minimumIterationIntervalMs / 1_000)}s` : "") +
         (branchName ? `\nbranch mode: committing each iteration to ${branchName}` : "")
       : `Loop started: ${displaySlice(cfg.target, 60)}\nBaseline: ${cfg.deferBaseline ? "deferred — the first real measurement seeds it" : (baseline ?? "(forced without a number — first turn must produce one)")} · direction ${cfg.direction} · window ${cfg.plateauWindow} · ${cfg.maxIterations > 0 ? `max ${cfg.maxIterations}` : "no iteration cap"}` +
+        (cfg.minimumIterationIntervalMs ? ` · cadence ≥ ${Math.ceil(cfg.minimumIterationIntervalMs / 1_000)}s` : "") +
         (branchName ? `\nbranch mode: committing improvements to ${branchName}` : ""),
     "info",
   );
-  scheduleLoopTick(ctx);
+  scheduleLoopTickUrgent(ctx);
   return true;
 }
 
@@ -920,7 +952,7 @@ async function cmdLoop(args: string, ctx: ExtensionContext): Promise<void> {
       if (flags.continuationDispatchStoodDown) {
         releaseContinuationDispatchStandDown();
         releaseAuditorSurface();
-        scheduleLoopTick(ctx);
+        scheduleLoopTickUrgent(ctx);
         ctx.ui.notify("Loop dispatch stand-down cleared — retrying one continuation explicitly.", "info");
       } else {
         ctx.ui.notify("A loop is already active — /loop status to inspect, /loop stop to end it.", "info");
@@ -939,6 +971,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 +1017,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.
@@ -994,9 +1053,14 @@ async function cmdLoop(args: string, ctx: ExtensionContext): Promise<void> {
       }
       releaseContinuationDispatchStandDown();
       releaseAuditorSurface();
-      scheduleLoopTick(ctx);
+      scheduleLoopTickUrgent(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;
@@ -1016,7 +1080,7 @@ async function cmdLoop(args: string, ctx: ExtensionContext): Promise<void> {
         ctx.ui.notify(formatLoopRecoveryStatus(ctx), "info");
         return;
       }
-      ctx.ui.notify("No loop. /loop to draft one, /loop start \"<target>\" for an infinite metricless loop, or add measure=\"<cmd>\" direction=min|max for a metric loop [window=5] [max=50] [time=<hours>] [tokens=<budget>]", "info");
+      ctx.ui.notify("No loop. /loop to draft one, /loop start \"<target>\" for an infinite metricless loop, or add measure=\"<cmd>\" direction=min|max for a metric loop [window=5] [max=50] [time=<hours>] [tokens=<budget>] [cadence=<seconds>]", "info");
       return;
     }
     const lines = [
@@ -1028,6 +1092,11 @@ async function cmdLoop(args: string, ctx: ExtensionContext): Promise<void> {
     if (loop.timeLimitHours !== undefined) bounds.push(`time ≤ ${loop.timeLimitHours}h`);
     if (loop.tokenBudget !== undefined) bounds.push(`tokens ${(loop.tokensUsed ?? 0).toLocaleString()}/${loop.tokenBudget.toLocaleString()}`);
     if (bounds.length) lines.push(`Bounds: ${bounds.join(" · ")}`);
+    if (loop.minimumIterationIntervalMs !== undefined) {
+      const lastCompleted = loop.lastIterationCompletedAt ? Date.parse(loop.lastIterationCompletedAt) : Number.NaN;
+      const nextDelay = Number.isFinite(lastCompleted) ? Math.max(0, lastCompleted + loop.minimumIterationIntervalMs - Date.now()) : 0;
+      lines.push(`Cadence: ≥ ${Math.ceil(loop.minimumIterationIntervalMs / 1_000)}s between iterations${nextDelay > 0 ? ` · next in ${Math.ceil(nextDelay / 1_000)}s` : " · ready"}`);
+    }
     if (loop.refinements?.length) lines.push(`Spec refined ${loop.refinements.length}× (latest: iteration ${loop.refinements[loop.refinements.length - 1]!.iteration})`);
     if (loop.stopReason) lines.push(`Stopped: ${loop.stopReason}`);
     if (state.mainModelRecovery?.kind === "loop") lines.push(...formatLoopRecoveryStatusLines(ctx));

package/extensions/loops/goal-activation.ts

@@ -752,13 +752,13 @@ export function registerGoalRuntime(pi: ExtensionAPI): void {
     },
   });
   pi.registerCommand("loop", {
-    description: "Loop 3: metric-driven process — it never completes. /loop <target> drafts the metric with you · /loop start \"<target>\" = infinite metricless loop (no plateau, no cap; ends at time=/tokens= or /loop stop) · /loop respec = infinite metricless reconcile against the root SPEC.md · add measure=\"<cmd>\" direction=min|max [window=5] [max=50] [branch=1] for a metric loop · /loop status · /loop stop (alias /loop cancel). 'Improve until X' is a /goal, not a loop.",
+    description: "Loop 3: metric-driven process — it never completes. /loop <target> drafts the metric with you · /loop start \"<target>\" = infinite metricless loop (no plateau, no cap; ends at time=/tokens= or /loop stop) · /loop respec = infinite metricless reconcile against the root SPEC.md · add measure=\"<cmd>\" direction=min|max [window=5] [max=50] [cadence=<seconds>] [branch=1] for a loop · cadence is opt-in and limits automatic wakes between successful iterations · /loop status · /loop stop (alias /loop cancel). 'Improve until X' is a /goal, not a loop.",
     getArgumentCompletions: completions([
-      ["start", "skip drafting: /loop start \"<target>\" measure=\"<cmd>\" direction=min|max [window=5] [max=50]"],
+      ["start", "skip drafting: /loop start \"<target>\" measure=\"<cmd>\" direction=min|max [window=5] [max=50] [cadence=<seconds>]"],
       ["respec", "infinite metricless loop reconciling the codebase against the root SPEC.md"],
       ["plan", "extended loop draft: deep research + multi-round metric design, same Confirm as a regular draft"],
       ["audit", "project-audit loop: each iteration audits fresh, appends findings, fixes the top ones — plateau stops when the well is dry (v0.29.0)"],
-      ["status", "show metric, iteration, best/last values, stall count"],
+      ["status", "show metric, iteration, best/last values, stall count, and cadence"],
       ["resume", "resume a held loop (session-restore gate / manual main-model recovery)"],
       ["refine", "queue an operator respec suggestion into the next iteration's prompt: /loop refine <text>"],
       ["polish", "alias of /loop refine"],

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 {
@@ -1804,7 +1805,7 @@ function registerAgentTools(pi: any): void {
   pi.registerTool(defineTool({
     name: "propose_loop_draft",
     label: "Propose loop draft",
-    description: "During loop drafting (/loop with no args), propose the loop configuration. The orchestrator test-runs the measure command ONCE and shows the user real output + parsed number in a Confirm dialog. A measure producing no number is auto-rejected. Omit measureCmd (or pass \"none\") for a metricless spec loop — no plateau stop; ends only at bounds or /loop stop.",
+    description: "During loop drafting (/loop with no args), propose the loop configuration. The orchestrator test-runs the measure command ONCE and shows the user real output + parsed number in a Confirm dialog. A measure producing no number is auto-rejected. Omit measureCmd (or pass \"none\") for a metricless spec loop — no plateau stop; ends only at bounds or /loop stop. An optional cadence is the minimum seconds between automatic wakes after successful iterations.",
     parameters: Type.Object({
       target: Type.String({ description: "What to improve, concretely" }),
       measureCmd: Type.Optional(Type.String({ description: 'Shell command that prints ONE number representing progress — or the literal "none" for a metricless spec loop' })),
@@ -1813,12 +1814,13 @@ function registerAgentTools(pi: any): void {
       max: Type.Optional(Type.Number({ description: "Iteration cap (default 50)" })),
       time: Type.Optional(Type.Number({ description: "Arbitrary bound: stop after this many hours" })),
       tokens: Type.Optional(Type.Number({ description: "Arbitrary bound: stop after this many tokens (input+output)" })),
+      cadence: Type.Optional(Type.Number({ description: "Minimum seconds between automatic wakes after successful iterations (opt-in; explicit starts/resumes are urgent)" })),
       branch: Type.Optional(Type.Boolean({ description: "branch=true: scratch-branch mode (clean git tree required)" })),
     }),
     async execute(_id, params, _signal, _onUpdate, execCtx) {
       const foreign3 = foreignToolGuard(execCtx);
       if (foreign3) return { content: [{ type: "text", text: foreign3 }], details: {} };
-      const p = params as { target: string; measureCmd?: string; direction?: "min" | "max"; window?: number; max?: number; time?: number; tokens?: number; branch?: boolean };
+      const p = params as { target: string; measureCmd?: string; direction?: "min" | "max"; window?: number; max?: number; time?: number; tokens?: number; cadence?: number; branch?: boolean };
       const liveCtx = currentToolContext(execCtx);
       if (!liveCtx) return staleToolResult();
       if (warnIfStaleAtEntry(liveCtx, "loop drafting")) {
@@ -1872,6 +1874,9 @@ function registerAgentTools(pi: any): void {
         };
       }
       const window = p.window && p.window > 0 ? Math.floor(p.window) : 5;
+      const cadenceMs = typeof p.cadence === "number" && Number.isFinite(p.cadence) && p.cadence > 0
+        ? Math.min(Math.round(p.cadence * 1_000), 24 * 60 * 60_000)
+        : undefined;
       // v0.23.0: explicit max=0 = truly unbounded (no iteration cap).
       // v0.23.8: metricless + no explicit max = UNBOUNDED here too — the
       // drafter path was still defaulting to 50 after v0.23.6 flipped the
@@ -1889,8 +1894,8 @@ function registerAgentTools(pi: any): void {
           liveCtx,
           "Confirm loop",
           metricless
-            ? `Target: ${sanitizeDisplayText(p.target.trim())}\n\nMeasure: NONE — metricless spec loop. There is NO plateau stop: the loop ends only at ${max > 0 ? `${max} iterations` : "NO iteration cap"}${typeof p.time === "number" && p.time > 0 ? ` · Time bound: ${p.time}h` : ""}${typeof p.tokens === "number" && p.tokens > 0 ? ` · Token bound: ${p.tokens.toLocaleString()}` : ""} · /loop stop.${p.branch ? "\nbranch mode: scratch branch, every iteration committed (clean tree required)" : ""}\n\nEvery iteration must make ONE real, inspectable change — cosmetic churn is the known failure mode (doorknob-polishing). Start it?`
-            : `Target: ${sanitizeDisplayText(p.target.trim())}\n\nMeasure: ${sanitizeDisplayText(p.measureCmd ?? "")}\nTest-run output: ${sanitizeDisplayText(rawOutput).slice(0, 200)}\nParsed number: ${parsed} (${p.direction === "min" ? "lower is better" : "higher is better"})\n\nPlateau stop: ${window} non-improving iterations · Cap: ${max > 0 ? `${max} iterations` : "none (unbounded)"}${typeof p.time === "number" && p.time > 0 ? ` · Time bound: ${p.time}h` : ""}${typeof p.tokens === "number" && p.tokens > 0 ? ` · Token bound: ${p.tokens.toLocaleString()}` : ""}${p.branch ? "\nbranch mode: scratch branch (clean tree required)" : ""}\n\nThe loop never completes — it runs until one of these bounds, plateau, or /loop stop. Start it?`,
+            ? `Target: ${sanitizeDisplayText(p.target.trim())}\n\nMeasure: NONE — metricless spec loop. There is NO plateau stop: the loop ends only at ${max > 0 ? `${max} iterations` : "NO iteration cap"}${typeof p.time === "number" && p.time > 0 ? ` · Time bound: ${p.time}h` : ""}${typeof p.tokens === "number" && p.tokens > 0 ? ` · Token bound: ${p.tokens.toLocaleString()}` : ""}${cadenceMs ? ` · Cadence: ≥ ${Math.ceil(cadenceMs / 1_000)}s` : ""} · /loop stop.${p.branch ? "\nbranch mode: scratch branch, every iteration committed (clean tree required)" : ""}\n\nEvery iteration must make ONE real, inspectable change — cosmetic churn is the known failure mode (doorknob-polishing). Start it?`
+            : `Target: ${sanitizeDisplayText(p.target.trim())}\n\nMeasure: ${sanitizeDisplayText(p.measureCmd ?? "")}\nTest-run output: ${sanitizeDisplayText(rawOutput).slice(0, 200)}\nParsed number: ${parsed} (${p.direction === "min" ? "lower is better" : "higher is better"})\n\nPlateau stop: ${window} non-improving iterations · Cap: ${max > 0 ? `${max} iterations` : "none (unbounded)"}${typeof p.time === "number" && p.time > 0 ? ` · Time bound: ${p.time}h` : ""}${typeof p.tokens === "number" && p.tokens > 0 ? ` · Token bound: ${p.tokens.toLocaleString()}` : ""}${cadenceMs ? ` · Cadence: ≥ ${Math.ceil(cadenceMs / 1_000)}s` : ""}${p.branch ? "\nbranch mode: scratch branch (clean tree required)" : ""}\n\nThe loop never completes — it runs until one of these bounds, plateau, or /loop stop. Start it?`,
           );
           confirmed = c === "yes";
         } catch {
@@ -1913,6 +1918,7 @@ function registerAgentTools(pi: any): void {
         maxIterations: max,
         timeLimitHours: typeof p.time === "number" && Number.isFinite(p.time) && p.time > 0 ? p.time : undefined,
         tokenBudget: typeof p.tokens === "number" && Number.isFinite(p.tokens) && p.tokens > 0 ? Math.floor(p.tokens) : undefined,
+        minimumIterationIntervalMs: cadenceMs,
         branch: p.branch === true,
       });
       if (!started) {
@@ -1928,7 +1934,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 +1949,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 +1997,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 +2034,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.69",
   "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",

package/prompts/goal-loop-forever-draft.md

@@ -65,7 +65,9 @@ stops it.
    furnace.
 5. When concrete, call `propose_loop_draft` with `target`, `measureCmd` (or
    omit/`"none"` for metricless), `direction` (measured only), and optional
-   `window`/`max`/`time`/`tokens`.
+   `window`/`max`/`time`/`tokens`/`cadence`. `cadence` is seconds between
+   successful automatic iterations; it is opt-in, shown in `/loop status`, and
+   explicit starts/resumes remain urgent.
 6. **The orchestrator will run your proposed measure command ONCE** and show
    the user the real output and parsed number in the Confirm dialog. If your
    command produces no number, the proposal is rejected automatically — fix