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

package/README.md

@@ -60,7 +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 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-core.ts

@@ -1,5 +1,5 @@
 /**
- * pi-goal-list-loop-audit — v0.1.0
+ * pi-goal-list-loop-audit — v0.24.5
  * extensions/goal-loop-core.ts
  *
  * Shared types, state machine, JSONL persistence, helpers.
@@ -703,3 +703,44 @@ export function classifySessionCtx(ownerSession: unknown, ownerLive: boolean, se
   if (!ownerSession || !ownerLive) return "claim";
   return sessionManager === ownerSession ? "refresh" : "foreign";
 }
+
+// =================================================================
+// v0.24.5: tool-visibility self-heal
+// =================================================================
+//
+// Root cause (INCIDENT-COMPLETION-BLACKHOLE-2026-07-23): external
+// extensions like pi-plugin-list-selector-modlist call pi.setActiveTools
+// with a frozen tool snapshot at session_start. When glla's session_start
+// handler runs BEFORE theirs (load order), our lazily-registered agent
+// tools get registered, briefly auto-activated, then wiped from the
+// model-facing active set on the very next pi.setActiveTools call from
+// modlist. Commands, widget, watchdog keep working (they don't go
+// through the tool registry), but every agent tool — complete_goal,
+// propose_loop_draft, etc. — answers "Tool not found" to the model.
+//
+// Self-heal: any handler that triggers registerAgentTools must also
+// ensure the registered tool names are present in pi.getActiveTools(),
+// re-adding any missing ones via pi.setActiveTools. Once per session,
+// notify the user naming the external allowlist as the likely culprit
+// so they can fix their profile once and silence it.
+
+export const GLLA_TOOL_NAMES = [
+  "complete_goal",
+  "pause_goal",
+  "complete_task",
+  "update_task_status",
+  "propose_goal_draft",
+  "propose_loop_draft",
+  "propose_loop_refine",
+  "list_add",
+  "list_activate",
+  "list_status",
+  "propose_task_list",
+] as const;
+
+export type GllaToolName = (typeof GLLA_TOOL_NAMES)[number];
+
+export function missingGllaTools(activeNames: readonly string[]): readonly GllaToolName[] {
+  const active = new Set(activeNames);
+  return GLLA_TOOL_NAMES.filter((n) => !active.has(n));
+}

package/extensions/goal-loop-forever.ts

@@ -302,15 +302,21 @@ export function parseLoopStartArgs(raw: string): {
 /** 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 {
+/** 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()) return p;
+      if (existsSync(p) && statSync(p).isFile()) found.push(p);
     } catch { /* unreadable — keep looking */ }
   }
-  return null;
+  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;
 }
 
 /**

package/extensions/loops/goal.ts

@@ -63,6 +63,7 @@ import {
   shouldAutoResumeOnSessionStart,
   statusLabel,
   writeGoalMd,
+  missingGllaTools,
 } from "../goal-loop-core.js";
 import { runGoalCompletionAuditor } from "../goal-loop-auditor.js";
 import {
@@ -82,8 +83,7 @@ import {
   parseLoopStartArgs,
   parseMetric,
   LOOP_DEFAULTS,
-  RESPEC_SPEC_CANDIDATES,
-  resolveSpecFile,
+  resolveSpecFiles,
   respecTarget,
   type LoopState,
 } from "../goal-loop-forever.js";
@@ -1425,14 +1425,37 @@ async function cmdLoop(args: string, ctx: ExtensionContext): Promise<void> {
       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",
+    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,
@@ -2707,6 +2730,29 @@ export default function (pi: ExtensionAPI): void {
   // "no active goal" if called).
   let registeredCtx: ExtensionContext | null = null;
 
+  // v0.24.5 tool-visibility self-heal: surface the notify exactly once
+  // per session so the user learns about an external allowlist once and
+  // can fix their profile to silence it.
+  let toolHealNotified = false;
+  function ensureAgentToolsActive(pi: ExtensionAPI, ctx: ExtensionContext): void {
+    try {
+      const active = pi.getActiveTools();
+      const missing = missingGllaTools(active);
+      if (missing.length === 0) return;
+      pi.setActiveTools([...active, ...missing]);
+      if (!toolHealNotified) {
+        toolHealNotified = true;
+        const list = missing.join(", ");
+        ctx.ui.notify(
+          `glla: ${missing.length} agent tool(s) were hidden by an external tool allowlist (e.g. a modlist profile) and have been re-activated (${list}). Add them to your allowlist profile to silence this.`,
+          "warning",
+        );
+      }
+    } catch {
+      // Older pi without getActiveTools/setActiveTools — nothing we can do.
+    }
+  }
+
   pi.on("message_start", async (event: any, _ctx: ExtensionContext) => {
     // v0.14.0 drafting floor: count real user replies while drafting. Our
     // own injected draft prompt arrives as a user message — skip that one.
@@ -2751,6 +2797,7 @@ export default function (pi: ExtensionAPI): void {
       registerAgentTools(pi, ctx);
       registeredCtx = ctx;
     }
+    ensureAgentToolsActive(pi, ctx);
     warnOnCommandCollision(ctx);
     warnIfAuditorProviderRisky(ctx);
     // Restore gate (v0.21.0): a fresh session ("startup"/"new", or a pi too
@@ -2831,6 +2878,7 @@ export default function (pi: ExtensionAPI): void {
       registerAgentTools(pi, ctx);
       registeredCtx = ctx;
     }
+    ensureAgentToolsActive(pi, ctx);
     // Nudge accounting: a supervising turn with zero tool calls is a nudge
     // (no real progress); 3 consecutive → pause. Tool-use turns reset it.
     if (isSupervising()) {

package/package.json

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