pi-goal-list-loop-audit 0.22.4 → 0.22.6

package/extensions/goal-loop-auditor.ts

@@ -91,6 +91,11 @@ function makeAuditorResourceLoader(): ResourceLoader {
 
 function buildGoalAuditorPrompt(goal: Goal, completionSummary: string | null | undefined, verificationSummary: string | null | undefined): string {
   const goalMd = renderGoalMarkdown(goal);
+  // v0.22.6: if a previous audit APPROVED but the regression shield blocked
+  // it, tell THIS run exactly which contract items went unreferenced — the
+  // auditor quotes evidence for them explicitly and the loop converges
+  // instead of repeating the same gap.
+  const shieldGaps = [...(goal.auditHistory ?? [])].reverse().find((v) => v.regressionShieldPassed === false)?.regressionShieldMissing;
   return [
     "You are the independent completion auditor for pi-goal-list-loop-audit.",
     "The executor claims the goal is complete. Your job is to decide whether the user's objective is actually satisfied.",
@@ -125,6 +130,13 @@ function buildGoalAuditorPrompt(goal: Goal, completionSummary: string | null | u
       goal.verificationContract.trim(),
       "</verification_contract>",
     ] : []),
+    ...(shieldGaps && shieldGaps.length > 0 ? [
+      "",
+      "REGRESSION SHIELD RETRY: a previous audit of yours ended in <approved/>, but the orchestrator blocked it",
+      "because the report never referenced these contract items in its evidence:",
+      ...shieldGaps.map((i) => `- ${i}`),
+      "This time, address each of them explicitly: name the item and paste the raw output that proves it.",
+    ] : []),
     "",
     "Audit checklist:",
     "1. Extract the real success criteria from the objective, including quality/reader outcomes.",

package/extensions/goal-loop-core.ts

@@ -95,6 +95,8 @@ export interface AuditVerdict {
   error?: string;
   /** regression_shield outcome when the goal had a verification contract. */
   regressionShieldPassed?: boolean;
+  /** Contract items the shield found unreferenced (fed into the next audit's prompt, v0.22.6). */
+  regressionShieldMissing?: string[];
 }
 
 /**

package/extensions/goal-loop-shield.ts

@@ -20,7 +20,10 @@ export function contractItems(contract: string): string[] {
     .map((l) => l.trim())
     .map((l) => l.replace(/^(?:done when|verify|verified when|verification|done)\s*:\s*/i, ""))
     .map((l) => l.replace(/^[-*•]\s+/, "").replace(/^\d+[.)]\s+/, ""))
-    .filter((l) => l.length > 0);
+    .filter((l) => l.length > 0)
+    // Boundary lines ("Out of scope: ...") constrain the auditor's judgment;
+    // they are not deliverables and have no evidence to quote (v0.22.6).
+    .filter((l) => !/^out of scope\b/i.test(l));
 }
 
 export interface RegressionShieldResult {
@@ -29,14 +32,35 @@ export interface RegressionShieldResult {
   hasEvidenceBlock: boolean;
 }
 
+/** Strip prose punctuation glued to a token ("file/element." → "file/element"). */
+function stripEdgePunct(w: string): string {
+  return w.replace(/^[^A-Za-z0-9]+/, "").replace(/[^A-Za-z0-9/_.-]+$/, "");
+}
+
+/**
+ * Is a candidate token present in the report? Compound tokens joined by
+ * "-" or "/" (left-cropped, file/element, Phaser/Svelte) count as present
+ * when ALL their segments (len >= 3) appear — a good-faith report writes
+ * "no cropped strip on the left", not the contract's literal compound.
+ */
+function tokenPresent(candidate: string, reportLower: string): boolean {
+  const c = candidate.toLowerCase();
+  if (reportLower.includes(c)) return true;
+  const segments = c.split(/[-/]+/).filter((s) => s.length >= 3);
+  return segments.length > 1 && segments.every((s) => reportLower.includes(s));
+}
+
 /**
  * Check an approved auditor report against the verification contract.
  * Rules (deliberately simple + auditable):
  *   1. The report must contain an <evidence> ... </evidence> block.
- *   2. Every contract item must be referenced inside the report by a
- *      distinctive token (the item's longest word >= 5 chars, or the full
- *      item if shorter) — a cheap, honest proxy for "the auditor addressed
- *      this item".
+ *   2. Every contract item must be referenced inside the report by ANY of
+ *      its top-3 longest tokens (>= 5 chars, edge punctuation stripped;
+ *      compounds match via their segments). v0.22.6: the previous
+ *      single-longest-word rule false-rejected genuine approvals when the
+ *      longest word was contract-only vocabulary ("left-cropped") or had
+ *      prose punctuation glued on ("file/element.") — three real approved
+ *      audits on hegemon were converted to disapprovals that way.
  */
 export function checkRegressionShield(report: string, contract: string): RegressionShieldResult {
   const hasEvidenceBlock = /<evidence>[\t\n\r ]*[\s\S]*?<\/evidence>/i.test(report);
@@ -44,12 +68,16 @@ export function checkRegressionShield(report: string, contract: string): Regress
   const missingItems: string[] = [];
   const reportLower = report.toLowerCase();
   for (const item of items) {
-    // Distinctive token: longest word >= 5 chars in the item; fall back to the
-    // whole item (short items like "npm test" are matched whole).
-    const words = item.split(/[^A-Za-z0-9_.\-/]+/).filter(Boolean);
-    const distinctive = words.reduce((a, b) => (b.length >= 5 && b.length > a.length ? b : a), "");
-    const needle = (distinctive || item).toLowerCase();
-    if (!reportLower.includes(needle)) missingItems.push(item);
+    const candidates = item
+      .split(/[^A-Za-z0-9_.\-/]+/)
+      .map(stripEdgePunct)
+      .filter((w) => w.length >= 5)
+      .sort((a, b) => b.length - a.length)
+      .slice(0, 3);
+    const addressed = candidates.length > 0
+      ? candidates.some((c) => tokenPresent(c, reportLower))
+      : reportLower.includes(item.toLowerCase());
+    if (!addressed) missingItems.push(item);
   }
   return {
     passed: hasEvidenceBlock && missingItems.length === 0,

package/extensions/loops/goal.ts

@@ -578,6 +578,13 @@ async function cmdResume(ctx: ExtensionContext): Promise<void> {
     ? { tokensUsed: state.goal.usage.tokensUsed, tokensLimit: freshLimit }
     : undefined;
   updateGoal({ status: "active", pauseReason: undefined, pauseSuggestedAction: undefined, ...(usage ? { usage } : {}) }, ctx);
+  // v0.22.5: say what was resumed — with a non-empty list this also resumes
+  // the queue (the active goal IS the list's head item).
+  const queued = listQueue().length;
+  ctx.ui.notify(
+    `Resumed goal [${state.goal.id}]: ${state.goal.objective.replace(/\s+/g, " ").slice(0, 70)}${queued > 0 ? ` (+${queued} queued in the list — resuming the list's head)` : ""}`,
+    "info",
+  );
   scheduleContinuation(ctx, true);
 }
 
@@ -1307,6 +1314,7 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
           report: result.output,
           error: result.error,
           regressionShieldPassed: result.regressionShieldPassed,
+          regressionShieldMissing: result.regressionShieldMissing,
         });
         // Cap history — 39 infra errors taught us unbounded growth is real.
         if (history.length > 20) history.splice(0, history.length - 20);
@@ -1365,6 +1373,29 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
         };
       }
 
+      // Shield-blocked approval (v0.22.6): the auditor APPROVED but the
+      // regression shield found contract items the evidence never
+      // referenced. NOT a verdict on the work — the next audit is told
+      // exactly what to quote. (The hegemon case: three genuine approvals
+      // shield-blocked on vocabulary mismatches read as a "parser bug".)
+      if (result.regressionShieldPassed === false && result.regressionShieldMissing && result.regressionShieldMissing.length > 0) {
+        const missing = result.regressionShieldMissing;
+        updateGoal({
+          status: "active",
+          auditHistory: history,
+          pauseReason: `regression shield: auditor approved, but evidence never referenced ${missing.length} contract item(s)`,
+          pauseSuggestedAction: "call complete_goal again — the next auditor run is told exactly which items to quote evidence for",
+        }, ctx);
+        scheduleContinuation(ctx, true);
+        return {
+          content: [{
+            type: "text",
+            text: `The auditor APPROVED, but the orchestrator's regression shield blocked completion: the report's evidence never referenced these contract items:\n${missing.map((i) => `- ${i}`).join("\n")}\n\nThis is NOT a verdict on your work — do not change your deliverable for this. Call complete_goal again; the next auditor run is explicitly told to quote raw evidence for each of these items.`,
+          }],
+          details: {},
+        };
+      }
+
       const noContractHint = state.goal.verificationContract?.trim()
         ? ""
         : "\n\nNote: this goal has no verification contract, so the auditor inferred done-criteria from the objective text. For sharper verdicts, /goal tweak the objective to add a 'Done when: ...' clause.";
@@ -1497,11 +1528,12 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       // Multi-item list draft: one Confirm for the whole batch.
       if (p.items && p.items.length > 0) {
         const preview = p.items.slice(0, 6).map((t, i) => `  ${i + 1}. ${t.slice(0, 60)}`).join("\n");
+        const batchActivates = !state.goal || state.goal.status === "complete" || state.goal.status === "aborted";
         let batchConfirmed = false;
         try {
           batchConfirmed = await liveCtx.ui.confirm(
             "Confirm queue batch",
-            `${p.items.length} items:\n${preview}${p.items.length > 6 ? `\n  … and ${p.items.length - 6} more` : ""}`,
+            `${p.items.length} items:\n${preview}${p.items.length > 6 ? `\n  … and ${p.items.length - 6} more` : ""}${batchActivates ? "\n\n(List is empty — confirming ACTIVATES item 1 immediately as the active goal.)" : ""}`,
           );
         } catch {
           batchConfirmed = false;
@@ -1523,9 +1555,19 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       const contractBlock = p.verificationContract?.trim()
         ? `\n\nDone when:\n${p.verificationContract.trim()}`
         : "\n\n(No verification contract — the auditor will infer done-criteria from the objective. Consider adding one.)";
+      // v0.22.6: a list draft that will activate immediately must SAY so in
+      // the Confirm dialog — "I started a list and ended up with a running
+      // goal" was a real surprise. Title + trailing note name the outcome.
+      const isListDraft = draftingTarget === "list";
+      const willActivate = isListDraft && (!state.goal || state.goal.status === "complete" || state.goal.status === "aborted");
+      const activationNote = isListDraft
+        ? willActivate
+          ? "\n\n(List is empty — confirming ACTIVATES this immediately as the active goal. Reject if you only wanted to queue it.)"
+          : "\n\n(Goes into the list, queued behind the active goal.)"
+        : "";
       let confirmed = false;
       try {
-        confirmed = await liveCtx.ui.confirm("Confirm goal", `${p.objective.trim()}${contractBlock}`);
+        confirmed = await liveCtx.ui.confirm(isListDraft ? "Confirm list item" : "Confirm goal", `${p.objective.trim()}${contractBlock}${activationNote}`);
       } catch {
         confirmed = false;
       }
@@ -2225,21 +2267,55 @@ export default function (pi: ExtensionAPI): void {
   //   /list — the list (add|show|next|remove|clear)
   //   /loop  — the metric loop (draft|start|status|stop)
   //   /glla   — the settings UI (+ scriptable key=value)
+  // v0.22.5: subcommand autocomplete for the /-menu.
+  const completions = (items: Array<[string, string]>) => (prefix: string) =>
+    items
+      .filter(([value]) => value.startsWith(prefix))
+      .map(([value, description]) => ({ value, label: value, description }));
+
   pi.registerCommand("goal", {
     description: "Set/draft a goal, or /goal status|pause|resume|cancel|tweak <text>|archive|start <objective>. Objectives without a 'Done when:' clause are grilled into a contract first; include the clause or use /goal start to skip the interview and activate instantly.",
+    getArgumentCompletions: completions([
+      ["start", "skip drafting — /goal start <objective> activates immediately"],
+      ["status", "show the active goal and its task list"],
+      ["pause", "pause the active goal"],
+      ["resume", "resume a paused goal (and the list, when items are queued)"],
+      ["cancel", "abort the active goal"],
+      ["tweak", "change the objective: /goal tweak <text>"],
+      ["archive", "list archived goals"],
+    ]),
     handler: (args: string, ctx: ExtensionContext) => { rememberCtx(ctx); return cmdGoal(args, ctx); },
   });
   const settingsHandler = (args: string, ctx: ExtensionContext) => { rememberCtx(ctx); return cmdSettings(args, ctx); };
   pi.registerCommand("glla", {
     description: "Open the settings UI for goals, loops, lists, and the auditor. Scriptable form: /glla key=value · /glla project key=value",
+    getArgumentCompletions: completions([
+      ["model=", "auditor model override: /glla model=provider/id"],
+      ["thinking=", "auditor thinking level: /glla thinking=high"],
+      ["notify=", "desktop push command: /glla notify='notify-send pi \"$1\"'"],
+      ["tokenlimit=", "per-goal token budget (0 = off): /glla tokenlimit=2000000"],
+      ["autoresume=", "on: auto-resume held goals/loops in fresh sessions"],
+      ["project", "write a project override: /glla project key=value"],
+    ]),
     handler: settingsHandler,
   });
   pi.registerCommand("list", {
     description: "Loop 2: the list of audited goals — order is the default, not the law. /list <describe tasks or name a plan file> (dumps get shaped into items, files import, 'Done when:' adds directly) | /list show | /list next [n] | /list remove <n> | /list clear",
+    getArgumentCompletions: completions([
+      ["show", "display the queued items"],
+      ["next", "activate the next item (or /list next <n> for position n)"],
+      ["remove", "remove an item: /list remove <n>"],
+      ["clear", "empty the list"],
+    ]),
     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.",
+    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"],
+      ["stop", "end the loop (keeps the best state)"],
+    ]),
     handler: (args: string, ctx: ExtensionContext) => { rememberCtx(ctx); return cmdLoop(args, ctx); },
   });
 
@@ -2309,13 +2385,17 @@ export default function (pi: ExtensionAPI): void {
         );
         scheduleContinuation(ctx, true);
       } else {
+        const queued = listQueue().length;
+        const resumeHint = queued > 0
+          ? `/goal resume to continue (+${queued} queued in the list) · /glla autoresume=on to auto-resume in this project`
+          : "/goal resume to continue · /glla autoresume=on to auto-resume in this project";
         updateGoal({
           status: "paused",
           pauseReason: "restored in a fresh session — no work started",
-          pauseSuggestedAction: "/goal resume to continue · /glla autoresume=on to auto-resume in this project",
+          pauseSuggestedAction: resumeHint,
         }, ctx);
         ctx.ui.notify(
-          `Goal held on restore [${state.goal.id}]: ${state.goal.objective.slice(0, 70)} — /goal resume to continue.`,
+          `Goal held on restore [${state.goal.id}]: ${state.goal.objective.slice(0, 70)}${queued > 0 ? ` (+${queued} queued in the list)` : ""} — /goal resume to continue.`,
           "info",
         );
       }

package/package.json

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