pi-goal-list-loop-audit 0.24.2 → 0.24.4

package/README.md

@@ -60,6 +60,7 @@ matches `/list show`.
 /list cancel                       # stop the whole list: abort the active item + drop all waiting
 /loop                              # draft the loop (agent grills; measure is test-run before you confirm)
 /loop start "keep polishing the UI"                          # infinite metricless loop (v0.23.6): no plateau, no cap — ends at time=/tokens= or /loop stop
+/loop respec                                                  # infinite metricless loop reconciling the codebase against the root SPEC.md / spec.md (v0.24.3) — 2 specs = you pick, 0 specs = drafting, 1 spec = auto-start (v0.24.4)
 /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

package/extensions/goal-loop-forever.ts

@@ -10,6 +10,9 @@
  * self-reports progress.
  */
 
+import { existsSync, statSync } from "node:fs";
+import { join } from "node:path";
+
 export type LoopDirection = "min" | "max";
 
 export interface LoopMeasure {
@@ -293,3 +296,36 @@ export function parseLoopStartArgs(raw: string): {
     tokenBudget: Number.isFinite(tokensRaw) && tokensRaw > 0 ? tokensRaw : undefined,
   };
 }
+
+// ---- /loop respec (v0.24.3) ----
+
+/** Root-only spec candidates, in priority order. No fuzzy search. */
+export const RESPEC_SPEC_CANDIDATES = ["SPEC.md", "spec.md"] as const;
+
+/** Resolve every root spec candidate that exists (priority order). */
+export function resolveSpecFiles(cwd: string): string[] {
+  const found: string[] = [];
+  for (const name of RESPEC_SPEC_CANDIDATES) {
+    const p = join(cwd, name);
+    try {
+      if (existsSync(p) && statSync(p).isFile()) found.push(p);
+    } catch { /* unreadable — keep looking */ }
+  }
+  return found;
+}
+
+/** Resolve the project spec in the root only; null when absent. */
+export function resolveSpecFile(cwd: string): string | null {
+  return resolveSpecFiles(cwd)[0] ?? null;
+}
+
+/**
+ * The respec target. The spec is DATA, not gospel: the loop reconciles code
+ * against it but reports stale/contradictory requirements instead of forcing
+ * the code to match a bad spec. Rotation keeps it honest: implement one
+ * iteration, audit the next (the doorknob failure is implementing nothing
+ * while claiming polish).
+ */
+export function respecTarget(specName: string): string {
+  return `Reconcile the codebase against ${specName} (the project spec in the root). Read the spec critically first: if a requirement is stale, contradictory, or wrong for the current codebase, report the discrepancy and move on — never force the code to match a bad spec. Otherwise pick the next gap between spec and code and close it. Rotate: one iteration implements a missing or outdated spec item, the next audits something already "implemented" against the spec and fixes what drifted.`;
+}

package/extensions/loops/goal.ts

@@ -81,6 +81,9 @@ import {
   loopBranchName,
   parseLoopStartArgs,
   parseMetric,
+  LOOP_DEFAULTS,
+  resolveSpecFiles,
+  respecTarget,
   type LoopState,
 } from "../goal-loop-forever.js";
 import {
@@ -1408,6 +1411,63 @@ async function cmdLoop(args: string, ctx: ExtensionContext): Promise<void> {
     return;
   }
 
+  if (sub === "respec") {
+    // v0.24.3: reconcile the codebase against the root spec, forever.
+    // Same auto-start path as /loop start (the user typed the command —
+    // that IS the act); metricless + unbounded by design. No limit-nagging:
+    // bounds exist on /loop start for whoever wants them.
+    if (state.goal && state.goal.status === "active") {
+      ctx.ui.notify("A goal is active — /goal cancel or /goal pause it before starting a loop.", "warning");
+      return;
+    }
+    if (isLoopActive()) {
+      ctx.ui.notify("A loop is already active. /loop stop first.", "warning");
+      return;
+    }
+    const specs = resolveSpecFiles(ctx.cwd);
+    if (specs.length === 0) {
+      // No spec → the target is undetermined; grill instead of dead-ending
+      // on an error (v0.24.4).
+      ctx.ui.notify("No SPEC.md / spec.md in the project root — drafting the loop target with you (or bootstrap a spec first).", "info");
+      await startDrafting(
+        ctx,
+        "loop",
+        "reconcile the codebase against the project spec — but NO SPEC.md / spec.md exists in the root. Grill the user: should the first work be bootstrapping a SPEC.md from the current code (then reconcile against it), or is the reconciliation target better stated in prose? Challenge vague answers.",
+      );
+      return;
+    }
+    let specPath = specs[0]!;
+    if (specs.length > 1) {
+      // Two specs = ambiguous — never silently pick (v0.24.4). One
+      // slash-bar select, plus a nudge to consolidate.
+      const names = specs.map((p) => path.basename(p));
+      const choice = await ctx.ui.select(
+        "Both SPEC.md and spec.md exist in the root — which one is the spec?",
+        names,
+      );
+      if (choice === undefined) {
+        ctx.ui.notify("respec cancelled.", "info");
+        return;
+      }
+      specPath = specs[names.indexOf(choice)]!;
+      ctx.ui.notify(
+        `Using ${path.basename(specPath)} as the spec. Both files exist — worth consolidating; the loop treats only ${path.basename(specPath)} as the spec.`,
+        "info",
+      );
+    }
+    const target = respecTarget(path.basename(specPath));
+    await startLoopFromConfig(ctx, {
+      target,
+      measureCmd: "",
+      direction: undefined,
+      plateauWindow: LOOP_DEFAULTS.plateauWindow,
+      maxIterations: 0,
+      branch: false,
+      force: false,
+    });
+    return;
+  }
+
   // Anything else is a natural-language target (v0.22.4): draft it — the
   // metric is the whole game for a loop, and /loop start with full params
   // is the skip-drafting path. Previously this fell through to a usage
@@ -1868,7 +1928,7 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       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." }],
+          content: [{ type: "text", text: "You cannot start or draft a loop — only the user can, from the slash bar (the Confirm is the product). Do NOT write draft files or wait for the user to say 'start' in chat; that dead-ends. Instead hand the user the exact command: /loop start \"<target>\" (bare = infinite metricless; add measure=\"<cmd>\" direction=min|max for a metric loop), or /loop respec to reconcile against the root spec, or /loop with no args to draft interactively." }],
           details: {},
         };
       }
@@ -2654,9 +2714,10 @@ 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>\" = infinite metricless loop (no plateau, no cap; ends at time=/tokens= or /loop stop) · add measure=\"<cmd>\" direction=min|max [window=5] [max=50] [branch=1] for a metric loop · /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>\" = 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. '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]"],
+      ["respec", "infinite metricless loop reconciling the codebase against the root SPEC.md"],
       ["status", "show metric, iteration, best/last values, stall count"],
       ["stop", "end the loop (keeps the best state)"],
     ]),

package/package.json

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