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

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)
 /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,30 @@ 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 the project spec in the root only; null when absent. */
+export function resolveSpecFile(cwd: string): string | null {
+  for (const name of RESPEC_SPEC_CANDIDATES) {
+    const p = join(cwd, name);
+    try {
+      if (existsSync(p) && statSync(p).isFile()) return p;
+    } catch { /* unreadable — keep looking */ }
+  }
+  return 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,10 @@ import {
   loopBranchName,
   parseLoopStartArgs,
   parseMetric,
+  LOOP_DEFAULTS,
+  RESPEC_SPEC_CANDIDATES,
+  resolveSpecFile,
+  respecTarget,
   type LoopState,
 } from "../goal-loop-forever.js";
 import {
@@ -1408,6 +1412,40 @@ 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 specPath = resolveSpecFile(ctx.cwd);
+    if (!specPath) {
+      ctx.ui.notify(
+        `/loop respec: no spec in the project root (looked for ${RESPEC_SPEC_CANDIDATES.join(", ")}). Create one, or use /loop start "<target>" directly.`,
+        "warning",
+      );
+      return;
+    }
+    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 +1906,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 +2692,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.3",
   "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",