pi-goal-list-loop-audit 0.22.7 → 0.23.1

package/README.md

@@ -61,10 +61,21 @@ matches `/list show`.
 /loop start "reduce TODOs" measure="grep -c TODO src.txt | head -1" direction=min
 /loop start "shrink the bundle" measure="..." direction=min time=4 tokens=500000   # arbitrary bounds
 /loop start "reduce TODOs" measure="..." direction=min branch=1   # scratch-branch mode
+/loop start "keep improving SPEC.md" measure=none max=20   # metricless spec loop (v0.23.0)
 /loop status                       # iteration, best, stall, recent values
 /loop stop                         # halt with summary
 ```
 
+**Metricless loops** (`measure=none`): for genuinely endless work — an
+ever-improving spec, continuous hardening — where no number means "better".
+There is **no plateau stop** (nothing to stall on): the loop ends only at
+its bounds (`max` iterations — `max=0` is truly unbounded — `time` hours,
+`tokens` budget) or `/loop stop`. Every iteration must make one real,
+inspectable change; cosmetic churn is the known failure mode
+(doorknob-polishing). The drafter offers this when you say there is no
+number, and tells you the trade-off before you confirm. Work with a finish
+line is still a `/goal`.
+
 Subcommands match **exactly** — `/goal pause the pipeline` sets an objective
 about a pipeline; only bare `/goal pause` pauses. (Same rule everywhere, so
 your objectives can start with any verb.)

package/extensions/goal-loop-display.ts

@@ -81,10 +81,14 @@ export interface AuditDisplayProgress {
 export function buildStatusText(state: State, audit?: AuditDisplayProgress | null, now = Date.now(), theme?: DisplayTheme): string | undefined {
   if (state.loop?.active) {
     const l = state.loop;
+    // v0.23.0: metricless spec loop — no arrow/best/stall, no plateau.
+    if (!l.measureCmd) {
+      return `glla: loop ${paint(theme, "accent", "∞")} iter ${l.iteration}${l.maxIterations > 0 ? `/${l.maxIterations}` : ""} · metricless`;
+    }
     const arrow = paint(theme, "accent", l.direction === "min" ? "↓" : "↑");
     const stallText = `stall ${l.stallCount}/${l.plateauWindow}`;
     const stall = l.stallCount >= l.plateauWindow - 1 ? paint(theme, "warning", stallText) : stallText;
-    return `glla: loop ${arrow} iter ${l.iteration}/${l.maxIterations} · best ${l.bestValue ?? "n/a"} · ${stall}`;
+    return `glla: loop ${arrow} iter ${l.iteration}/${l.maxIterations > 0 ? l.maxIterations : "∞"} · best ${l.bestValue ?? "n/a"} · ${stall}`;
   }
   const g = state.goal;
   if (!g) return undefined;
@@ -179,13 +183,23 @@ function goalLines(g: Goal, state: State, audit: AuditDisplayProgress | null | u
 }
 
 function loopLines(l: LoopState, now: number, theme?: DisplayTheme, width?: number): string[] {
+  // v0.23.0: metricless spec loop — no arrow/best/stall, no plateau.
+  if (!l.measureCmd) {
+    const lines = [
+      `${paint(theme, "accent", "●")} ${truncate(l.target, budgetFor(width, 3, 64))}`,
+      `├─ loop ∞ iter ${l.iteration}${l.maxIterations > 0 ? `/${l.maxIterations}` : ""} · ${fmtElapsed(now - Date.parse(l.startedAt))}`,
+      `└─ ${paint(theme, "dim", "metricless — work the spec (no plateau)")}`,
+    ];
+    if (l.branchName) lines.push(`⎇ ${paint(theme, "muted", truncate(l.branchName, budgetFor(width, 3, 50)))}`);
+    return lines;
+  }
   const arrow = paint(theme, "accent", l.direction === "min" ? "↓" : "↑");
   const best = paint(theme, "success", `${l.bestValue ?? "n/a"}`);
   const stallText = `stall ${l.stallCount}/${l.plateauWindow}`;
   const stall = l.stallCount >= l.plateauWindow - 1 ? paint(theme, "warning", stallText) : stallText;
   const lines = [
     `${paint(theme, "accent", "●")} ${truncate(l.target, budgetFor(width, 3, 64))}`,
-    `├─ loop ${arrow} iter ${l.iteration}/${l.maxIterations} · ${fmtElapsed(now - Date.parse(l.startedAt))}`,
+    `├─ loop ${arrow} iter ${l.iteration}/${l.maxIterations > 0 ? l.maxIterations : "∞"} · ${fmtElapsed(now - Date.parse(l.startedAt))}`,
     `├─ best ${best} · last ${l.lastValue ?? "n/a"} · ${stall}`,
     `└─ ${paint(theme, "dim", truncate(l.measureCmd, budgetFor(width, 3, 56)))}`,
   ];

package/extensions/goal-loop-forever.ts

@@ -30,9 +30,13 @@ export interface LoopRefinement {
 
 export interface LoopState {
   target: string;
-  measureCmd: string;
-  direction: LoopDirection;
+  /** v0.23.0: optional — a metricless "spec loop" (measure=none) has no
+   * metric, no direction, and NO plateau stop; it ends only at max/time/
+   * tokens bounds or /loop stop. */
+  measureCmd?: string;
+  direction?: LoopDirection;
   iteration: number;
+  /** v0.23.0: 0 = unbounded (no iteration cap). Default 50. */
   maxIterations: number;
   plateauWindow: number;
   stallCount: number;
@@ -124,7 +128,7 @@ export type LoopTickOutcome =
  */
 export function applyMeasurement(loop: LoopState, value: number | null, at: string): LoopTickOutcome {
   loop.iteration++;
-  const improved = value !== null && isImprovement(loop.direction, value, loop.bestValue);
+  const improved = value !== null && loop.direction !== undefined && isImprovement(loop.direction, value, loop.bestValue);
   if (value === null) {
     loop.stallCount++;
   } else if (improved) {
@@ -155,7 +159,7 @@ export function applyMeasurement(loop: LoopState, value: number | null, at: stri
     loop.stopReason = `plateau — no improvement in ${loop.plateauWindow} consecutive iterations (best: ${loop.bestValue ?? "n/a"})`;
     return { kind: "stop", reason: loop.stopReason };
   }
-  if (loop.iteration >= loop.maxIterations) {
+  if (loop.maxIterations > 0 && loop.iteration >= loop.maxIterations) {
     loop.active = false;
     loop.stopReason = `max iterations reached (${loop.maxIterations}); best: ${loop.bestValue ?? "n/a"}`;
     return { kind: "stop", reason: loop.stopReason };
@@ -163,11 +167,45 @@ export function applyMeasurement(loop: LoopState, value: number | null, at: stri
   return { kind: "continue", improved, value };
 }
 
+/**
+ * One iteration of a METRICLESS loop (v0.23.0, measure=none). There is no
+ * number to judge movement, so there is no plateau — the loop ends only at
+ * the time/token/iteration bounds or /loop stop. This is the Sisyphus mode:
+ * work the spec until the bounds say stop. The doorknob risk is real and
+ * accepted by the user explicitly; the iteration prompt demands one real,
+ * inspectable change per turn.
+ */
+export function applyMetriclessTick(loop: LoopState, at: string): LoopTickOutcome {
+  loop.iteration++;
+  loop.history.push({ iteration: loop.iteration, value: null, improved: false, at });
+  if (loop.history.length > 200) loop.history.splice(0, loop.history.length - 200);
+
+  if (loop.timeLimitHours !== undefined) {
+    const elapsedH = (Date.parse(at) - Date.parse(loop.startedAt)) / 3_600_000;
+    if (Number.isFinite(elapsedH) && elapsedH >= loop.timeLimitHours) {
+      loop.active = false;
+      loop.stopReason = `time bound reached (${loop.timeLimitHours}h) after ${loop.iteration} iterations`;
+      return { kind: "stop", reason: loop.stopReason };
+    }
+  }
+  if (loop.tokenBudget !== undefined && (loop.tokensUsed ?? 0) >= loop.tokenBudget) {
+    loop.active = false;
+    loop.stopReason = `token budget exhausted (${(loop.tokensUsed ?? 0).toLocaleString()} >= ${loop.tokenBudget.toLocaleString()}) after ${loop.iteration} iterations`;
+    return { kind: "stop", reason: loop.stopReason };
+  }
+  if (loop.maxIterations > 0 && loop.iteration >= loop.maxIterations) {
+    loop.active = false;
+    loop.stopReason = `max iterations reached (${loop.maxIterations})`;
+    return { kind: "stop", reason: loop.stopReason };
+  }
+  return { kind: "continue", improved: false, value: null };
+}
+
 /** Parse `/loop start` args into a config. Throws on missing pieces. */
 export function parseLoopStartArgs(raw: string): {
   target: string;
   measureCmd: string;
-  direction: LoopDirection;
+  direction?: LoopDirection;
   plateauWindow: number;
   maxIterations: number;
   branch: boolean;
@@ -196,10 +234,14 @@ export function parseLoopStartArgs(raw: string): {
   target += rest.slice(cursor);
   target = target.trim().replace(/^["']|["']$/g, "").trim();
 
-  const measureCmd = kv.get("measure") ?? "";
-  if (!measureCmd) throw new Error('missing measure="<shell command that prints a number>"');
+  const measureRaw = (kv.get("measure") ?? "").trim();
+  // v0.23.0: measure=none → metricless "spec loop" (Sisyphus mode). No
+  // metric, no direction, no plateau — bounds and /loop stop only.
+  const metricless = measureRaw.toLowerCase() === "none";
+  if (!measureRaw) throw new Error('missing measure="<shell command that prints a number>" (or measure=none for a metricless spec loop — no plateau, ends only at bounds or /loop stop)');
   const dirRaw = (kv.get("direction") ?? "").toLowerCase();
-  if (dirRaw !== "min" && dirRaw !== "max") throw new Error("missing direction=min|max");
+  if (metricless && dirRaw) throw new Error("direction= is meaningless with measure=none — there is no metric to have a direction");
+  if (!metricless && dirRaw !== "min" && dirRaw !== "max") throw new Error("missing direction=min|max");
   if (!target) throw new Error("missing target (what to improve), e.g. /loop start \"reduce test failures\" measure=\"...\" direction=min");
 
   const window = Number.parseInt(kv.get("window") ?? "", 10);
@@ -218,10 +260,11 @@ export function parseLoopStartArgs(raw: string): {
   const tokensRaw = Number.parseInt(kv.get("tokens") ?? "", 10);
   return {
     target,
-    measureCmd,
-    direction: dirRaw,
+    measureCmd: metricless ? "" : measureRaw,
+    direction: metricless ? undefined : dirRaw as LoopDirection,
     plateauWindow: Number.isFinite(window) && window > 0 ? window : LOOP_DEFAULTS.plateauWindow,
-    maxIterations: Number.isFinite(max) && max > 0 ? max : LOOP_DEFAULTS.maxIterations,
+    // v0.23.0: max=0 = truly unbounded (no iteration cap); absent = 50.
+    maxIterations: kv.has("max") ? (Number.isFinite(max) && max >= 0 ? max : LOOP_DEFAULTS.maxIterations) : LOOP_DEFAULTS.maxIterations,
     branch: branchRaw === "1" || branchRaw === "true" || branchRaw === "yes",
     force: forceRaw === "1" || forceRaw === "true" || forceRaw === "yes",
     timeLimitHours: Number.isFinite(timeRaw) && timeRaw > 0 ? timeRaw : undefined,

package/extensions/loops/goal.ts

@@ -63,6 +63,7 @@ import { runGoalCompletionAuditor } from "../goal-loop-auditor.js";
 import { buildStatusText, buildWidgetLines, type AuditDisplayProgress } from "../goal-loop-display.js";
 import {
   applyMeasurement,
+  applyMetriclessTick,
   applyRefinement,
   loopBranchName,
   parseLoopStartArgs,
@@ -955,18 +956,23 @@ async function runGit(ctx: ExtensionContext, args: string[]): Promise<{ ok: bool
 }
 
 function loopPrompt(loop: LoopState, regressionNote: string, strategyNote: string, boundsNote: string): string {
-  const tmplPath = path.resolve(__dirname, "..", "..", "prompts", "goal-loop-forever.md");
+  // v0.23.0: metricless loops get their own prompt — no metric section,
+  // anti-doorknob rules instead of anti-gaming rules.
+  const metricless = !loop.measureCmd;
+  const tmplPath = path.resolve(__dirname, "..", "..", "prompts", metricless ? "goal-loop-forever-metricless.md" : "goal-loop-forever.md");
   let tmpl: string;
   try {
     tmpl = fs.readFileSync(tmplPath, "utf-8");
   } catch {
-    tmpl = `[LOOP ITERATION ${loop.iteration + 1}] Target: ${loop.target}. Measure: ${loop.measureCmd} (${loop.direction}). Make ONE small change to improve the metric.`;
+    tmpl = metricless
+      ? `[LOOP ITERATION ${loop.iteration + 1}] Target: ${loop.target}. Metricless spec loop — make ONE real, inspectable change advancing the target. No cosmetic churn.`
+      : `[LOOP ITERATION ${loop.iteration + 1}] Target: ${loop.target}. Measure: ${loop.measureCmd} (${loop.direction}). Make ONE small change to improve the metric.`;
   }
   return tmpl
     .replace(/\$\{ITERATION\}/g, String(loop.iteration + 1))
     .replace(/\$\{TARGET\}/g, loop.target)
-    .replace(/\$\{MEASURE_CMD\}/g, loop.measureCmd)
-    .replace(/\$\{DIRECTION\}/g, loop.direction)
+    .replace(/\$\{MEASURE_CMD\}/g, loop.measureCmd ?? "none")
+    .replace(/\$\{DIRECTION\}/g, loop.direction ?? "none")
     .replace(/\$\{DIRECTION_WORD\}/g, loop.direction === "min" ? "lower is better" : "higher is better")
     .replace(/\$\{LAST_VALUE\}/g, loop.lastValue === null ? "(none yet)" : String(loop.lastValue))
     .replace(/\$\{BEST_VALUE\}/g, loop.bestValue === null ? "(none yet)" : String(loop.bestValue))
@@ -1011,10 +1017,22 @@ function sendLoopTurn(): void {
     ? "**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.15.0: arbitrary bounds (never "completion") — surface what's armed.
+  // v0.23.0: for metricless loops the bounds are the ONLY stop (no
+  // plateau), so the note names that — and an unbounded metricless loop
+  // gets the furnace warning.
+  const metricless = !loop.measureCmd;
   const bounds: string[] = [];
   if (loop.timeLimitHours !== undefined) bounds.push(`${loop.timeLimitHours}h`);
   if (loop.tokenBudget !== undefined) bounds.push(`${loop.tokenBudget.toLocaleString()} tokens (used ${(loop.tokensUsed ?? 0).toLocaleString()})`);
-  const boundsNote = bounds.length ? `\n- Arbitrary bounds: the loop also stops after ${bounds.join(" or ")}` : "";
+  let boundsNote = "";
+  if (metricless) {
+    if (loop.maxIterations > 0) bounds.unshift(`${loop.maxIterations} iterations`);
+    boundsNote = bounds.length
+      ? `\n- Bounds armed: the loop ends after ${bounds.join(" or ")} — or /loop stop. There is NO plateau stop.`
+      : `\n- NO bounds armed — this loop ends only at /loop stop. Spend each iteration like it costs money; it does.`;
+  } else if (bounds.length) {
+    boundsNote = `\n- Arbitrary bounds: the loop also stops after ${bounds.join(" or ")}`;
+  }
   try {
     extensionApi.sendMessage({
       customType: GOAL_EVENT_ENTRY,
@@ -1033,7 +1051,8 @@ async function runLoopTick(ctx: ExtensionContext, event?: any): Promise<void> {
   if (event?.messages) {
     loop.tokensUsed = (loop.tokensUsed ?? 0) + sumNewAssistantTokens(event.messages as unknown[], countedLoopTokenMessages);
   }
-  const value = await runMeasure(ctx, loop.measureCmd);
+  const metricless = !loop.measureCmd;
+  const value = metricless ? null : await runMeasure(ctx, loop.measureCmd!);
   // Hypothesis line (pi-autoresearch's good idea): the agent's stated intent
   // for the turn goes into the ledger, making loop history auditable.
   let hypothesis: string | undefined;
@@ -1042,7 +1061,7 @@ async function runLoopTick(ctx: ExtensionContext, event?: any): Promise<void> {
     const text = last && Array.isArray(last.content) ? last.content.filter((p: any) => p.type === "text").map((p: any) => p.text).join("\n") : "";
     hypothesis = text.match(/^HYPOTHESIS:\s*(.+)$/m)?.[1]?.trim().slice(0, 200);
   }
-  const outcome = applyMeasurement(loop, value, nowIso());
+  const outcome = metricless ? applyMetriclessTick(loop, nowIso()) : applyMeasurement(loop, value, nowIso());
   persistState(ctx);
   appendLedger(ctx.cwd, "loop_measured", {
     iteration: loop.iteration,
@@ -1052,11 +1071,12 @@ async function runLoopTick(ctx: ExtensionContext, event?: any): Promise<void> {
     hypothesis,
   });
   // branch=1 mode: commit improvements, hard-reset regressions — always and
-  // only on the scratch branch.
+  // only on the scratch branch. v0.23.0: a metricless loop has no regression
+  // signal, so every iteration stands and is committed.
   if (loop.branchName && outcome.kind === "continue") {
-    if (outcome.improved) {
+    if (metricless || outcome.improved) {
       await runGit(ctx, ["add", "-A"]);
-      const committed = await runGit(ctx, ["commit", "-m", `pi-glla-loop: iteration ${loop.iteration} (${loop.direction}=${loop.bestValue})`]);
+      const committed = await runGit(ctx, ["commit", "-m", metricless ? `pi-glla-loop: iteration ${loop.iteration}` : `pi-glla-loop: iteration ${loop.iteration} (${loop.direction}=${loop.bestValue})`]);
       appendLedger(ctx.cwd, "loop_git", { action: "commit", iteration: loop.iteration, ok: committed.ok });
     } else {
       const reset = await runGit(ctx, ["reset", "--hard", "HEAD"]);
@@ -1092,8 +1112,9 @@ async function finishLoopGit(ctx: ExtensionContext, loop: LoopState): Promise<vo
 
 interface LoopConfig {
   target: string;
+  /** Empty string = metricless spec loop (v0.23.0). */
   measureCmd: string;
-  direction: "min" | "max";
+  direction?: "min" | "max";
   plateauWindow: number;
   maxIterations: number;
   branch: boolean;
@@ -1132,8 +1153,11 @@ async function startLoopFromConfig(ctx: ExtensionContext, cfg: LoopConfig): Prom
   // produces no number is a footgun: without a baseline the loop burns stall
   // iterations before plateau stops it. Refuse fast (force=1 overrides for
   // measures that only work after the agent builds something first).
-  const baseline = await runMeasure(ctx, cfg.measureCmd);
-  if (baseline === null && !(cfg as { force?: boolean }).force) {
+  // v0.23.0: metricless loops skip the baseline entirely — there is no
+  // measure to run, and no plateau to protect.
+  const metricless = !cfg.measureCmd;
+  const baseline = metricless ? null : await runMeasure(ctx, cfg.measureCmd);
+  if (!metricless && baseline === null && !(cfg as { force?: boolean }).force) {
     ctx.ui.notify(
       `/loop start refused: the measure produced no number.\nCommand: ${cfg.measureCmd}\nFix it so it prints exactly one number, or re-run with force=1 if it only works after the agent builds something first.\n(Non-numeric goal — research, docs, features? Use /goal: the independent auditor verifies semantically. /loop only believes a number.)`,
       "warning",
@@ -1144,7 +1168,7 @@ async function startLoopFromConfig(ctx: ExtensionContext, cfg: LoopConfig): Prom
     ...state,
     loop: {
       target: cfg.target,
-      measureCmd: cfg.measureCmd,
+      measureCmd: cfg.measureCmd || undefined,
       direction: cfg.direction,
       iteration: 0,
       maxIterations: cfg.maxIterations,
@@ -1163,10 +1187,13 @@ async function startLoopFromConfig(ctx: ExtensionContext, cfg: LoopConfig): Prom
     },
   };
   persistState(ctx);
-  appendLedger(ctx.cwd, "loop_started", { target: cfg.target, measureCmd: cfg.measureCmd, direction: cfg.direction, 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 });
   ctx.ui.notify(
-    `Loop started: ${cfg.target.slice(0, 60)}\nBaseline: ${baseline ?? "(forced without a number — first turn must produce one)"} · direction ${cfg.direction} · window ${cfg.plateauWindow} · max ${cfg.maxIterations}` +
-    (branchName ? `\nbranch mode: committing improvements to ${branchName}` : ""),
+    metricless
+      ? `Loop started (metricless spec loop — NO plateau stop): ${cfg.target.slice(0, 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.` +
+        (branchName ? `\nbranch mode: committing each iteration to ${branchName}` : "")
+      : `Loop started: ${cfg.target.slice(0, 60)}\nBaseline: ${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"}` +
+        (branchName ? `\nbranch mode: committing improvements to ${branchName}` : ""),
     "info",
   );
   scheduleLoopTick(ctx);
@@ -1192,7 +1219,7 @@ async function cmdLoop(args: string, ctx: ExtensionContext): Promise<void> {
       persistState(ctx);
       scheduleLoopTick(ctx);
       ctx.ui.notify(
-        `Loop resumed: iteration ${stored.iteration}/${stored.maxIterations} · best ${stored.bestValue ?? "n/a"} — ${stored.target.slice(0, 60)}`,
+        `Loop resumed: iteration ${stored.iteration}/${stored.maxIterations > 0 ? stored.maxIterations : "∞"} · best ${stored.bestValue ?? "n/a"} — ${stored.target.slice(0, 60)}`,
         "info",
       );
       return;
@@ -1209,8 +1236,8 @@ async function cmdLoop(args: string, ctx: ExtensionContext): Promise<void> {
     }
     const lines = [
       `Loop: ${loop.active ? "active" : "stopped"} — ${loop.target.slice(0, 80)}`,
-      `Metric: ${loop.measureCmd} (${loop.direction})`,
-      `Iteration ${loop.iteration}/${loop.maxIterations} · best ${loop.bestValue ?? "n/a"} · last ${loop.lastValue ?? "n/a"} · stall ${loop.stallCount}/${loop.plateauWindow}`,
+      `Metric: ${loop.measureCmd ? `${loop.measureCmd} (${loop.direction})` : "none — metricless spec loop (no plateau)"}`,
+      `Iteration ${loop.iteration}/${loop.maxIterations > 0 ? loop.maxIterations : "∞"} · best ${loop.bestValue ?? "n/a"} · last ${loop.lastValue ?? "n/a"} · stall ${loop.stallCount}/${loop.plateauWindow}`,
     ];
     const bounds: string[] = [];
     if (loop.timeLimitHours !== undefined) bounds.push(`time ≤ ${loop.timeLimitHours}h`);
@@ -1634,11 +1661,11 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): 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.",
+    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.",
     parameters: Type.Object({
       target: Type.String({ description: "What to improve, concretely" }),
-      measureCmd: Type.String({ description: "Shell command that prints ONE number representing progress" }),
-      direction: Type.Union([Type.Literal("min"), Type.Literal("max")], { description: "min = lower is better, max = higher is better" }),
+      measureCmd: Type.Optional(Type.String({ description: 'Shell command that prints ONE number representing progress — or the literal "none" for a metricless spec loop' })),
+      direction: Type.Optional(Type.Union([Type.Literal("min"), Type.Literal("max")], { description: "min = lower is better, max = higher is better (omit for a metricless loop)" })),
       window: Type.Optional(Type.Number({ description: "Plateau stop after N non-improving iterations (default 5)" })),
       max: Type.Optional(Type.Number({ description: "Iteration cap (default 50)" })),
       time: Type.Optional(Type.Number({ description: "Arbitrary bound: stop after this many hours" })),
@@ -1646,7 +1673,7 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       branch: Type.Optional(Type.Boolean({ description: "branch=true: scratch-branch mode (clean git tree required)" })),
     }),
     async execute(_id, params, _signal, _onUpdate, execCtx) {
-      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; branch?: boolean };
       if (draftingTarget !== "loop") {
         return {
           content: [{ type: "text", text: "Not in loop drafting mode. The user starts loop drafting with /loop (no args), or starts directly with /loop start." }],
@@ -1659,24 +1686,30 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       if (loopBlock) {
         return { content: [{ type: "text", text: loopBlock }], details: {} };
       }
-      if (!p.target?.trim() || !p.measureCmd?.trim()) {
-        return { content: [{ type: "text", text: "target and measureCmd are both required." }], details: {} };
+      if (!p.target?.trim()) {
+        return { content: [{ type: "text", text: "target is required." }], details: {} };
+      }
+      // v0.23.0: measureCmd omitted or "none" → metricless spec loop.
+      const metricless = !p.measureCmd?.trim() || p.measureCmd.trim().toLowerCase() === "none";
+      if (!metricless && p.direction !== "min" && p.direction !== "max") {
+        return { content: [{ type: "text", text: 'direction=min|max is required for a measured loop (omit measureCmd or pass "none" for a metricless spec loop).' }], details: {} };
       }
       const liveCtx = (execCtx as ExtensionContext | undefined) ?? ctx;
       // THE TEST-RUN: orchestrator runs the proposed measure once. The user
       // sees the real number before a single iteration burns tokens.
+      // (Metricless loops skip this — there is no measure to test-run.)
       let rawOutput = "";
       let parsed: number | null = null;
-      if (extensionApi) {
+      if (!metricless && extensionApi) {
         try {
-          const result = await extensionApi.exec("bash", ["-c", p.measureCmd], { cwd: liveCtx.cwd });
+          const result = await extensionApi.exec("bash", ["-c", p.measureCmd!], { cwd: liveCtx.cwd });
           rawOutput = String((result as any)?.stdout ?? "").trim();
           parsed = parseMetric(rawOutput);
         } catch (err) {
           rawOutput = `(measure command failed: ${err instanceof Error ? err.message : String(err)})`;
         }
       }
-      if (parsed === null) {
+      if (!metricless && parsed === null) {
         return {
           content: [{
             type: "text",
@@ -1686,12 +1719,15 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
         };
       }
       const window = p.window && p.window > 0 ? Math.floor(p.window) : 5;
-      const max = p.max && p.max > 0 ? Math.floor(p.max) : 50;
+      // v0.23.0: explicit max=0 = truly unbounded (no iteration cap).
+      const max = p.max !== undefined && Number.isFinite(p.max) && p.max >= 0 ? Math.floor(p.max) : 50;
       let confirmed = false;
       try {
         confirmed = await liveCtx.ui.confirm(
           "Confirm loop",
-          `Target: ${p.target.trim()}\n\nMeasure: ${p.measureCmd}\nTest-run output: ${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} iterations${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?`,
+          metricless
+            ? `Target: ${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: ${p.target.trim()}\n\nMeasure: ${p.measureCmd}\nTest-run output: ${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?`,
         );
       } catch {
         confirmed = false;
@@ -1705,8 +1741,8 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       draftingTarget = null;
       const started = await startLoopFromConfig(liveCtx, {
         target: p.target.trim(),
-        measureCmd: p.measureCmd,
-        direction: p.direction,
+        measureCmd: metricless ? "" : p.measureCmd!.trim(),
+        direction: metricless ? undefined : p.direction,
         plateauWindow: window,
         maxIterations: max,
         timeLimitHours: typeof p.time === "number" && Number.isFinite(p.time) && p.time > 0 ? p.time : undefined,
@@ -1717,7 +1753,7 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
         return { content: [{ type: "text", text: "Loop could not start (see the warning above — likely a git/dirty-tree issue with branch mode)." }], details: {} };
       }
       return {
-        content: [{ type: "text", text: `Loop confirmed and started. Baseline ${parsed}. Make ONE small change per turn to move the metric ${p.direction === "min" ? "down" : "up"}.` }],
+        content: [{ type: "text", text: metricless ? "Loop confirmed and started (metricless — no plateau). Make ONE real, inspectable change per turn." : `Loop confirmed and started. Baseline ${parsed}. Make ONE small change per turn to move the metric ${p.direction === "min" ? "down" : "up"}.` }],
         details: {},
       };
     },
@@ -1740,7 +1776,12 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
         return { content: [{ type: "text", text: "No active loop to refine. propose_loop_refine is only valid while a loop is running." }], details: {} };
       }
       const newTarget = p.target?.trim() || loop.target;
-      const newMeasure = p.measureCmd?.trim() || loop.measureCmd;
+      const newMeasure = p.measureCmd?.trim() || loop.measureCmd || "";
+      // v0.23.0: a metricless loop can't be refined into a measured one
+      // (no direction, no baseline semantics) — stop and restart instead.
+      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: {} };
       }
@@ -1780,7 +1821,7 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
         iteration: loop.iteration,
         oldTarget: loop.target,
         newTarget,
-        oldMeasureCmd: loop.measureCmd,
+        oldMeasureCmd: loop.measureCmd ?? "",
         newMeasureCmd: newMeasure,
       }, newBaseline);
       persistState(liveCtx);
@@ -2337,7 +2378,7 @@ export default function (pi: ExtensionAPI): void {
     handler: (args: string, ctx: ExtensionContext) => { rememberCtx(ctx); return cmdList(args, ctx); },
   });
   pi.registerCommand("loop", {
-    description: "Loop 3: metric-driven process — it never completes. /loop <target> drafts the metric with you · /loop start \"<target>\" measure=\"<cmd>\" direction=min|max [window=5] [max=50] [time=<hours>] [tokens=<budget>] [branch=1] skips drafting · /loop status · /loop stop. '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>\" measure=\"<cmd>\" direction=min|max [window=5] [max=50] [time=<hours>] [tokens=<budget>] [branch=1] skips drafting · measure=none = metricless spec loop (no plateau; max=0 = unbounded) · /loop status · /loop stop. '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]"],
       ["status", "show metric, iteration, best/last values, stall count"],
@@ -2392,7 +2433,7 @@ export default function (pi: ExtensionAPI): void {
       const l = state.loop!;
       if (autoResume) {
         ctx.ui.notify(
-          `Resuming loop (iteration ${l.iteration}/${l.maxIterations}, best ${l.bestValue ?? "n/a"}, stall ${l.stallCount}/${l.plateauWindow}): ${l.target.slice(0, 60)}`,
+          `Resuming loop (iteration ${l.iteration}/${l.maxIterations > 0 ? l.maxIterations : "∞"}, best ${l.bestValue ?? "n/a"}, stall ${l.stallCount}/${l.plateauWindow}): ${l.target.slice(0, 60)}`,
           "info",
         );
         scheduleLoopTick(ctx);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goal-list-loop-audit",
-  "version": "0.22.7",
+  "version": "0.23.1",
   "description": "Goal. Loop. Audit. Done. — 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 — only the read tools needed to verify your goal.",
   "license": "MIT",
   "author": "dracon",

package/prompts/goal-loop-continuation.md

@@ -45,6 +45,11 @@ If the objective decomposes into milestones and no task list exists yet, call `p
 
 When the agent calls any of these, the orchestrator tracks the call and persists state to `.pi-glla/active.jsonl`.
 
+## EXECUTION DISCIPLINE
+
+- **Delegate independent chunks to subagents.** When the work contains parallel, independent streams — surveying separate subsystems, reading disjoint file sets, running independent verifications — spawn `Agent` subagents (`Explore` for read-only research, `general-purpose` for implementation) instead of serializing everything through your own context. You remain the single writer: synthesize subagent findings and apply edits yourself.
+- **Bound every long command.** Wrap test suites, builds, and dev servers in `timeout <seconds>` (e.g. `timeout 120 bun test src/lib`). An unbounded command that hangs burns an hour; a bounded one burns two minutes and tells you it hung. If a command produces no output for many minutes, treat it as hung: kill it, diagnose why, rerun bounded.
+
 ## TASK WORKFLOW
 
 Use tasks as PROGRESS TRACKERS during your work — not as a post-hoc checklist to batch-mark at the end.

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

@@ -23,16 +23,32 @@ stops it.
      (`wc -c < bundle.js`), timings (`hyperfine`-style), scores.
    - Warn the user if the metric is gameable (agent could improve the number
      without improving the target — e.g. deleting tests to reduce failures).
+   - **Offer the metricless alternative explicitly** (v0.23.0): if the user
+     says there is no number — "just work the spec", "keep improving it",
+     Sisyphus-style — a metricless loop is now legitimate: omit `measureCmd`
+     (or pass `"none"`) in the proposal. Tell the user the trade-off in one
+     sentence: no metric means NO plateau stop — the loop ends only at its
+     bounds (max/time/tokens) or `/loop stop`, and cosmetic churn
+     (doorknob-polishing) is the known failure mode. Never pick metricless
+     silently; the user chooses it after hearing that.
+   - Still redirect to `/goal` when the work HAS a finish line (research,
+     write document X, build feature Y): "improve until done" is a goal
+     with an auditor, not a loop. Metricless loops are for work that is
+     genuinely endless (an ever-improving spec, continuous hardening).
 3. Clarify the **direction**: is lower better (min) or higher better (max)?
+   (Skip this for a metricless loop — there is no direction without a metric.)
 4. Optional tuning: `window` (plateau stop after N non-improving iterations,
-   default 5), `max` (iteration cap, default 50). Suggest smaller values for
-   expensive measures.
-5. When concrete, call `propose_loop_draft` with `target`, `measureCmd`,
-   `direction`, and optional `window`/`max`.
+   default 5 — meaningless for metricless), `max` (iteration cap, default 50;
+   `max=0` = truly unbounded). Suggest smaller values for expensive measures.
+   For metricless loops, ALWAYS discuss bounds — an unbounded metricless loop
+   is a deliberate 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`.
 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
-   the command and propose again.
+   the command and propose again. (Metricless proposals skip the test-run.)
 7. If the user rejects, ask what to change, refine, propose again.
 
 ## Hard rules
@@ -41,10 +57,7 @@ stops it.
 - Do not modify the repo while drafting.
 - Do not propose a measure you have not sanity-checked against the actual
   repo layout (read files first if unsure what exists).
-- **If the user's goal has no honest numeric metric — research, writing a
-  document, building a feature, "understand X" — say so plainly and redirect:
-  `/loop` only believes a number; `/goal` is the right tool because its
-  independent auditor verifies semantic completeness against a contract.
-  Offer to hand them a well-structured `/goal` objective instead. Never
-  invent a fake metric (word count alone, file exists) just to make a loop
-  fit — a number that doesn't track the real target is worse than no number.
+- Never invent a fake metric (word count alone, file exists) just to make a
+  measured loop fit — a number that doesn't track the real target is worse
+  than no number. When no honest number exists, the choice is metricless
+  loop (endless process) or /goal (has a finish line) — and the user picks.

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

@@ -0,0 +1,43 @@
+# Forever loop (metricless) — pi-goal-list-loop-audit
+
+`[LOOP ITERATION ${ITERATION}]`
+
+You are inside an endless work loop with NO metric. The user chose this
+deliberately: there is no number that means "better" for this target, so the
+loop cannot judge movement — and cannot plateau-stop. It ends only at its
+bounds or /loop stop. That freedom is the doorknob-polishing risk made
+flesh; your job is to make every iteration count anyway.
+
+## Target (the spec you are working)
+
+<target>
+${TARGET}
+</target>
+
+## Your job THIS turn
+
+Start your reply with exactly one line: `HYPOTHESIS: <what you will change and why it is real progress on the spec>`.
+Then make **ONE** concrete, inspectable change that advances the target.
+Then stop.
+
+${REGRESSION_NOTE}
+${STRATEGY_NOTE}
+
+## Hard rules
+
+- ONE change per turn. Small beats clever — the next iteration gets another turn.
+- REAL work only: a change a reviewer could inspect and call progress
+  (a section written, a case handled, a defect fixed, a test added).
+  Cosmetic reshuffles, reformatting churn, comment shuffling, and re-wording
+  what already reads well are doorknob-polishing — the exact failure this
+  loop exists despite.
+- Never repeat yourself: before acting, check what earlier iterations
+  already did (git log / the artifacts themselves) and pick the next
+  unaddressed piece of the spec.
+- When the spec is genuinely, verifiably exhausted — every section
+  addressed, every case handled — say so plainly in your reply instead of
+  inventing cosmetic work. The user watches an honest loop gladly; a
+  furnace that rewrites the same paragraph forever, never.
+- The spec is ALIVE: if the target needs sharpening, call
+  propose_loop_refine with your rationale — the user confirms or rejects.
+${BOUNDS_NOTE}