pi-goal-list-loop-audit 0.28.6 → 0.28.8

package/extensions/goal-loop-core.ts

@@ -897,7 +897,12 @@ export interface EffectiveAggressiveSettings {
   stuckMaxInterventions: number;
   /** 0 = wedge alerts off. */
   wedgeAlertMinutes: number;
-  autoResume: boolean;
+  /** Tri-state: true = always auto-resume; false = never; undefined =
+   * DEFAULT (hold on human session loads, resume on reload/fork).
+   * v0.28.7: must stay tri-state here — coercing unset→false broke the
+   * restore gate's default branch (the 0.28.3 regression the behavioral
+   * harness caught). */
+  autoResume: boolean | undefined;
   aggressiveMode: boolean;
 }
 
@@ -918,7 +923,7 @@ export function resolveEffectiveAggressiveSettings(s: {
     stuckMaxInterventions:
       s.stuckMaxInterventions ?? (aggressiveMode ? AGGRESSIVE_STUCK_MAX_INTERVENTIONS : BASE_STUCK_MAX_INTERVENTIONS),
     wedgeAlertMinutes: s.wedgeAlertMinutes ?? (aggressiveMode ? 0 : 30),
-    autoResume: s.autoResume ?? aggressiveMode,
+    autoResume: s.autoResume ?? (aggressiveMode ? true : undefined),
   };
 }
 

package/extensions/goal-loop-forever.ts

@@ -43,6 +43,11 @@ export interface LoopState {
   maxIterations: number;
   plateauWindow: number;
   stallCount: number;
+  /** v0.28.8 (E5): consecutive iterations where the measure printed NO
+   * number. Tracked separately from stallCount — plateau judges movement
+   * (a real number that didn't improve); a broken measure says nothing
+   * about movement and must stop the loop with its own loud reason. */
+  consecutiveNullMeasures?: number;
   bestValue: number | null;
   lastValue: number | null;
   active: boolean;
@@ -172,14 +177,20 @@ export type LoopTickOutcome =
  */
 export function applyMeasurement(loop: LoopState, value: number | null, at: string): LoopTickOutcome {
   loop.iteration++;
+  // improved is judged BEFORE bestValue moves (post-mutation it would read false).
   const improved = value !== null && loop.direction !== undefined && isImprovement(loop.direction, value, loop.bestValue);
   if (value === null) {
-    loop.stallCount++;
-  } else if (improved) {
-    loop.bestValue = value;
-    loop.stallCount = 0;
+    // E5: a null measure is NOT a stall — it carries no information about
+    // improvement. Plateau stays reserved for real non-improving numbers.
+    loop.consecutiveNullMeasures = (loop.consecutiveNullMeasures ?? 0) + 1;
   } else {
-    loop.stallCount++;
+    loop.consecutiveNullMeasures = 0;
+    if (improved) {
+      loop.bestValue = value;
+      loop.stallCount = 0;
+    } else {
+      loop.stallCount++;
+    }
   }
   loop.lastValue = value;
   loop.history.push({ iteration: loop.iteration, value, improved, at });
@@ -198,6 +209,14 @@ export function applyMeasurement(loop: LoopState, value: number | null, at: stri
     loop.stopReason = `token budget exhausted (${(loop.tokensUsed ?? 0).toLocaleString()} >= ${loop.tokenBudget.toLocaleString()}); best: ${loop.bestValue ?? "n/a"}`;
     return { kind: "stop", reason: loop.stopReason };
   }
+  // E5: a broken measure command gets its OWN loud stop — never the
+  // misleading "plateau — no improvement" (there was nothing to improve
+  // against; the metric itself is dead).
+  if ((loop.consecutiveNullMeasures ?? 0) >= loop.plateauWindow) {
+    loop.active = false;
+    loop.stopReason = `measure command broken — ${loop.consecutiveNullMeasures} consecutive iterations printed no number (cmd: \`${loop.measureCmd ?? "?"}\`). Fix the measure command, or /loop stop.`;
+    return { kind: "stop", reason: loop.stopReason };
+  }
   if (loop.stallCount >= loop.plateauWindow) {
     loop.active = false;
     loop.stopReason = `plateau — no improvement in ${loop.plateauWindow} consecutive iterations (best: ${loop.bestValue ?? "n/a"})`;

package/extensions/loops/goal.ts

@@ -224,6 +224,13 @@ function goStaleTerminal(ctx: ExtensionContext, where: string): void {
   notifyExternal(ctx, `glla: extension api stale — restart pi. (${where})`);
 }
 
+/** TEST-ONLY hook (tests/harness): the stale flag is process-terminal in
+ * production — only a pi restart clears it — so behavioral tests reset it
+ * between stale scenarios. Never called by production code. */
+export function __testOnlyResetStaleFlag(): void {
+  extensionApiStale = false;
+}
+
 /** v0.28.1 (S3): side-effect-free staleness probe — getSessionName()
  * routes through pi's assertActive() and throws the stale signature iff
  * pi invalidated this factory handle (session replacement). A positive
@@ -872,8 +879,16 @@ function fireReviewer(
             `[REVIEWER FOLLOW-UP — ${reason}. Propose this as a /goal via propose_goal_draft (the user Confirms or rejects): ${objective}]`,
             { deliverAs: ctx.isIdle() ? "followUp" : "steer" },
           );
-        } catch {
-          /* proposal best-effort */
+          return true;
+        } catch (err) {
+          // v0.28.8 (E4): the phantom-reviewer hole — a swallowed throw used
+          // to still count as "proposed" in the report + notify. Now the
+          // failure is LOUD and the proposal goes uncounted.
+          ctx.ui.notify(
+            `Reviewer /goal proposal NOT delivered: ${err instanceof Error ? err.message : String(err)} — the follow-up never reached the session. Restart pi if the session was just replaced.`,
+            "warning",
+          );
+          return false;
         }
       },
       notify: (message, level) => ctx.ui.notify(message, level),
@@ -2523,11 +2538,12 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
   pi.registerTool(defineTool({
     name: "complete_task",
     label: "Complete task",
-    description: "Mark a task in the active goal's task list as complete (does not stop the turn).",
-    parameters: Type.Object({
+    description: "Mark a task in the active goal's task list as complete (does not stop the turn).",    parameters: Type.Object({
       id: Type.String({ description: "Task id to complete" }),
     }),
-    async execute(_id, params) {
+    async execute(_id, params, _signal, _onUpdate, execCtx) {
+      const foreign7 = foreignToolGuard(execCtx);
+      if (foreign7) return { content: [{ type: "text", text: foreign7 }], details: {} };
       const p = params as { id: string };
       if (!state.goal || !state.goal.taskList) {
         return { content: [{ type: "text", text: "No task list in this goal." }], details: {} };
@@ -2555,7 +2571,9 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       id: Type.String(),
       status: Type.Union([Type.Literal("pending"), Type.Literal("in_progress"), Type.Literal("complete")]),
     }),
-    async execute(_id, params) {
+    async execute(_id, params, _signal, _onUpdate, execCtx) {
+      const foreign8 = foreignToolGuard(execCtx);
+      if (foreign8) return { content: [{ type: "text", text: foreign8 }], details: {} };
       const p = params as { id: string; status: "pending" | "in_progress" | "complete" };
       if (!state.goal || !state.goal.taskList) {
         return { content: [{ type: "text", text: "No task list in this goal." }], details: {} };
@@ -3012,6 +3030,8 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       })),
     }),
     async execute(_id, params, _signal, _onUpdate, execCtx) {
+      const foreign9 = foreignToolGuard(execCtx);
+      if (foreign9) return { content: [{ type: "text", text: foreign9 }], details: {} };
       if (!state.goal || state.goal.status !== "active") {
         return { content: [{ type: "text", text: "No active goal to break down." }], details: {} };
       }
@@ -3179,7 +3199,9 @@ async function promptSettingsMenu(
  * Same handlers as v0.27.0's if/else chain — only the trigger changed from
  * `startsWith(label)` strings to stable ids.
  */
-async function handleSettingChoice(id: string, ctx: ExtensionContext): Promise<void> {
+// v0.28.7 (T4): exported for the behavioral settings-editor tests
+// (tests/settings-editors.test.ts drives each editor class end-to-end).
+export async function handleSettingChoice(id: string, ctx: ExtensionContext): Promise<void> {
   switch (id) {
     case "autoResume": {
       const v = await ctx.ui.select("Auto-resume goals/loops on session start", [

package/extensions/reviewer.ts

@@ -197,7 +197,11 @@ export interface ReviewerDeps {
   /** Source texts for finding extraction (archive md, audit reports). */
   sources: Array<{ name: string; text: string }>;
   enqueueListItems: (objectives: string[]) => void;
-  proposeGoal: (objective: string, reason: string) => void;
+  /** Deliver a /goal proposal message to the session. Returns true when the
+   * message was actually sent; false when the send failed (the v0.28.8 E4
+   * contract — a failed send must NOT count as `proposed`, else the user is
+   * told about phantom proposals that never arrived). */
+  proposeGoal: (objective: string, reason: string) => boolean;
   notify: (message: string, level: "info" | "warning") => void;
   ledger: (type: string, value: Record<string, unknown>) => void;
 }
@@ -274,23 +278,29 @@ export function runReviewer(
       // v0.27.5 aggressive: also propose the FIRST architectural finding
       // as a relaunch so the queue gets burned through even when the
       // unattended rig can't Confirm.
-      deps.proposeGoal(
-        architectural[0]!.text,
-        `aggressive postaudit: relaunching as /goal without Confirm (${architectural.length} architectural findings total)`,
-      );
+      if (
+        deps.proposeGoal(
+          architectural[0]!.text,
+          `aggressive postaudit: relaunching as /goal without Confirm (${architectural.length} architectural findings total)`,
+        )
+      ) {
+        proposed += 1;
+      }
       enqueued += architectural.length;
-      proposed += 1;
       cascadeStep = "aggressive-relaunch";
     } else if (auto) {
       deps.enqueueListItems(architectural.map((f) => f.text));
       enqueued += architectural.length;
       cascadeStep = convertStep;
     } else {
-      deps.proposeGoal(
-        architectural.map((f) => f.text).join("; "),
-        `reviewer found ${architectural.length} architectural-class finding(s) — needs your Confirm`,
-      );
-      proposed += architectural.length;
+      if (
+        deps.proposeGoal(
+          architectural.map((f) => f.text).join("; "),
+          `reviewer found ${architectural.length} architectural-class finding(s) — needs your Confirm`,
+        )
+      ) {
+        proposed += architectural.length;
+      }
       cascadeStep = "propose-goal";
     }
   }

package/package.json

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