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

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # 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

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

@@ -120,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. */
@@ -399,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
@@ -409,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;
@@ -464,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,
@@ -484,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");
@@ -1021,7 +1053,7 @@ async function cmdLoop(args: string, ctx: ExtensionContext): Promise<void> {
       }
       releaseContinuationDispatchStandDown();
       releaseAuditorSurface();
-      scheduleLoopTick(ctx);
+      scheduleLoopTickUrgent(ctx);
       const boundResetNote = resetTimeWindow
         ? " · fresh time window"
         : resetTokenBudget
@@ -1048,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 = [
@@ -1060,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

@@ -1805,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' })),
@@ -1814,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")) {
@@ -1873,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
@@ -1890,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 {
@@ -1914,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) {

package/package.json

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