pi-goal-list-loop-audit 0.25.4 → 0.25.6

package/extensions/goal-loop-core.ts

@@ -1090,6 +1090,10 @@ export interface AuditLogEntry {
   report: string;
   impossibleReason?: string;
   error?: string;
+  /** v0.25.4 post-audit: how long the audit took, and whether the infra
+   * retry fired. */
+  durationMs?: number;
+  retriedOnce?: boolean;
 }
 
 export function auditLogPath(cwd: string): string {
@@ -1145,3 +1149,55 @@ export function formatAuditLog(entries: AuditLogEntry[]): string {
     })
     .join("\n");
 }
+
+// =================================================================
+// v0.25.4 (post-audit fix): infra-failure retry-once-with-backoff
+// =================================================================
+
+/** Which auditor infra errors are worth an automatic retry? User aborts
+ * and missing-model config are NOT — retrying can't help them. */
+export function isRetriableInfraError(error?: string): boolean {
+  if (!error) return false;
+  if (/aborted/i.test(error)) return false;
+  if (/no model/i.test(error)) return false;
+  return true;
+}
+
+export interface InfraRetryOutcome<T> {
+  result: T;
+  retriedOnce: boolean;
+}
+
+/** Run the auditor; on a retriable infra failure, wait `backoffMs` and
+ * retry EXACTLY once before reporting "auditor infrastructure error
+ * (retried once)". The failed pair is never a verdict on the work. */
+export async function runWithInfraRetry<T extends { error?: string; approved: boolean; disapproved: boolean }>(
+  run: () => Promise<T>,
+  opts: { backoffMs?: number; sleep?: (ms: number) => Promise<void>; onRetry?: (error: string) => void } = {},
+): Promise<InfraRetryOutcome<T>> {
+  const sleep = opts.sleep ?? ((ms: number) => new Promise<void>((r) => setTimeout(r, ms)));
+  const first = await run();
+  if (first.approved || first.disapproved || !isRetriableInfraError(first.error)) {
+    return { result: first, retriedOnce: false };
+  }
+  opts.onRetry?.(first.error!);
+  await sleep(opts.backoffMs ?? 5000);
+  const second = await run();
+  return { result: second, retriedOnce: true };
+}
+
+/** /glla audits default view: the ACTIVE goal's own audit history (the
+ * surface the goal spec asked for), one line per verdict. */
+export function formatGoalAuditHistory(goal: { id: string; auditHistory?: Array<any> }): string {
+  const history = goal.auditHistory ?? [];
+  if (history.length === 0) return "(no audits on this goal yet)";
+  return history
+    .map((v) => {
+      const glyph = v.approved ? (v.regressionShieldPassed === false ? "🛡" : "✔") : v.impossible ? "⛔" : v.disapproved ? "✖" : "⚠";
+      const day = String(v.at ?? "").slice(5, 16).replace("T", " ");
+      const elapsed = v.durationMs ? ` · ${Math.round(v.durationMs / 60000)}m` : "";
+      const firstLine = (String(v.report ?? "").split("\n").find((l: string) => l.trim()) ?? "").trim().slice(0, 80);
+      return `${glyph} ${day} ${v.model ?? "?"}${elapsed} — ${firstLine}`;
+    })
+    .join("\n");
+}

package/extensions/goal-loop-subagents.ts

@@ -82,19 +82,81 @@ export const EXPLORE_DEFAULT_TOOLS = "read, bash, grep, find, ls";
 interface EmbeddedAgentDefault {
   description: string;
   systemPrompt: string;
+  /** "" means "all tools" (upstream omits builtinToolNames). */
   tools: string;
 }
 
-/** Embedded copies keyed by agent name. Only agents in
- * KNOWN_PINNED_DEFAULT_AGENTS need entries. */
+export const PLAN_DEFAULT_DESCRIPTION = "Software architect agent for designing implementation plans. Use this when you need to plan the implementation strategy for a task. Returns step-by-step plans, identifies critical files, and considers architectural trade-offs.";
+
+export const PLAN_DEFAULT_SYSTEM_PROMPT = `# CRITICAL: READ-ONLY MODE - NO FILE MODIFICATIONS
+You are a software architect and planning specialist.
+Your role is EXCLUSIVELY to explore the codebase and design implementation plans.
+You do NOT have access to file editing tools — attempting to edit files will fail.
+
+You are STRICTLY PROHIBITED from:
+- Creating new files
+- Modifying existing files
+- Deleting files
+- Moving or copying files
+- Creating temporary files anywhere, including /tmp
+- Using redirect operators (>, >>, |) or heredocs to write to files
+- Running ANY commands that change system state
+
+# Planning Process
+1. Understand requirements
+2. Explore thoroughly (read files, find patterns, understand architecture)
+3. Design solution based on your assigned perspective
+4. Detail the plan with step-by-step implementation strategy
+
+# Requirements
+- Consider trade-offs and architectural decisions
+- Identify dependencies and sequencing
+- Anticipate potential challenges
+- Follow existing patterns where appropriate
+
+# Tool Usage
+- Use the find tool for file pattern matching (NOT the bash find command)
+- Use the grep tool for content search (NOT bash grep/rg command)
+- Use the read tool for reading files (NOT bash cat/head/tail)
+- Use Bash ONLY for read-only operations
+
+# Output Format
+- Use absolute file paths
+- Do not use emojis
+- End your response with:
+
+### Critical Files for Implementation
+List 3-5 files most critical for implementing this plan:
+- /absolute/path/to/file.ts - [Brief reason]`;
+
+export const GENERAL_PURPOSE_DEFAULT_DESCRIPTION = "General-purpose agent for researching complex questions, searching for code, and executing multi-step tasks. When you are searching for a keyword or file and are not confident that you will find the right match in the first few tries use this agent to perform the search for you.";
+
+/** Embedded copies keyed by agent name. Explore needs an entry for the
+ * strategy-driven sync (KNOWN_PINNED_DEFAULT_AGENTS); Plan and
+ * general-purpose entries exist so users can pin them per-type via
+ * subagentModelOverrides (v0.25.6). */
 const EMBEDDED_DEFAULTS: Record<string, EmbeddedAgentDefault> = {
   Explore: {
     description: EXPLORE_DEFAULT_DESCRIPTION,
     systemPrompt: EXPLORE_DEFAULT_SYSTEM_PROMPT,
     tools: EXPLORE_DEFAULT_TOOLS,
   },
+  Plan: {
+    description: PLAN_DEFAULT_DESCRIPTION,
+    systemPrompt: PLAN_DEFAULT_SYSTEM_PROMPT,
+    tools: EXPLORE_DEFAULT_TOOLS, // same read-only set upstream
+  },
+  "general-purpose": {
+    description: GENERAL_PURPOSE_DEFAULT_DESCRIPTION,
+    systemPrompt: "", // upstream: empty prompt, promptMode append
+    tools: "", // upstream: all tools (builtinToolNames omitted)
+  },
 };
 
+/** v0.25.6: agent types the user can pin per-type via
+ * subagentModelOverrides (embedded defaults exist for each). */
+export const OVERRIDABLE_AGENT_TYPES = Object.keys(EMBEDDED_DEFAULTS);
+
 /** Default global agent dir (pi-subagents reads $PI_CODING_AGENT_DIR/agents,
  * default ~/.pi/agent/agents). Parameterized in sync for tests. */
 export function defaultAgentDir(): string {
@@ -107,12 +169,9 @@ export function buildAgentOverrideMd(name: string, model?: string): string {
   const def = EMBEDDED_DEFAULTS[name];
   if (!def) throw new Error(`no embedded default config for agent "${name}"`);
   const yamlDesc = "'" + def.description.replace(/'/g, "''") + "'";
-  const lines = [
-    "---",
-    `description: ${yamlDesc}`,
-    `tools: ${def.tools}`,
-    "prompt_mode: replace",
-  ];
+  const lines = ["---", `description: ${yamlDesc}`];
+  if (def.tools) lines.push(`tools: ${def.tools}`);
+  lines.push(def.systemPrompt ? "prompt_mode: replace" : "prompt_mode: append");
   if (model) lines.push(`model: ${model}`);
   lines.push(
     `x-managed-by: ${SUBAGENT_MANAGED_MARKER}`,
@@ -121,7 +180,7 @@ export function buildAgentOverrideMd(name: string, model?: string): string {
       : "x-glla-note: model pin removed (upstream default pins a fixed model) so this agent inherits the parent session model and its quota pool. Managed by glla — flip /glla subagent strategy to agent-default to restore upstream behavior.",
     "---",
     "",
-    def.systemPrompt,
+    def.systemPrompt || "(no system-prompt override — upstream default is an empty append-mode prompt)",
     "",
   );
   return lines.join("\n");
@@ -135,7 +194,16 @@ export interface SubagentSyncResult {
   written: string[];
   removed: string[];
   /** Files left untouched because the user owns them (no marker). */
-  skipped: Array<{ name: string; reason: string }>;
+  skipped: Array<{ name: string } & { reason: string }>;
+  /** v0.25.6: managed files that were expected (previously written) but
+   * found missing or altered, and got re-written — surface these to the
+   * user (external edit, pi update, or dracon-sync churn). */
+  repaired: string[];
+}
+
+/** State file tracking what the last sync wrote (repair detection). */
+export function subagentSyncStatePath(agentDir: string): string {
+  return path.join(agentDir, "agents", ".glla-subagent-sync.json");
 }
 
 /** Sync <agentDir>/agents/<Name>.md with the desired state. Idempotent:
@@ -145,8 +213,18 @@ export function syncSubagentModelOverrides(opts: {
   strategy: SubagentModelStrategy;
   overrides?: Record<string, string>;
 }): SubagentSyncResult {
-  const result: SubagentSyncResult = { written: [], removed: [], skipped: [] };
+  const result: SubagentSyncResult = { written: [], removed: [], skipped: [], repaired: [] };
   const overrides = opts.overrides ?? {};
+  // v0.25.6: load the previous sync state for repair detection — a file
+  // we wrote before that is now MISSING or CONTENT-CHANGED was touched
+  // externally; re-writing it is a repair the user should hear about.
+  let prevWritten: string[] = [];
+  try {
+    const prev = JSON.parse(fs.readFileSync(subagentSyncStatePath(opts.agentDir), "utf-8"));
+    if (Array.isArray(prev?.written)) prevWritten = prev.written.map(String);
+  } catch {
+    /* first sync or unreadable state */
+  }
   const names = new Set<string>([...KNOWN_PINNED_DEFAULT_AGENTS, ...Object.keys(overrides)]);
 
   for (const name of names) {
@@ -159,11 +237,15 @@ export function syncSubagentModelOverrides(opts: {
       continue;
     }
     const file = path.join(opts.agentDir, "agents", `${name}.md`);
+    // v0.25.6: the strategy-driven (model-less) write applies ONLY to
+    // agents that pin a model upstream (Explore) — Plan/general-purpose
+    // don't pin, so inherit-parent needs no file for them; they get
+    // managed files only via an explicit per-type override.
     const desired = overrideModel
       ? buildAgentOverrideMd(name, overrideModel)
-      : opts.strategy === "inherit-parent"
+      : opts.strategy === "inherit-parent" && (KNOWN_PINNED_DEFAULT_AGENTS as readonly string[]).includes(name)
         ? buildAgentOverrideMd(name)
-        : undefined; // agent-default + no per-type override → file should be absent
+        : undefined; // agent-default / no pin upstream + no override → file should be absent
 
     const exists = fs.existsSync(file);
     const current = exists ? fs.readFileSync(file, "utf-8") : undefined;
@@ -186,6 +268,31 @@ export function syncSubagentModelOverrides(opts: {
     fs.mkdirSync(path.dirname(file), { recursive: true });
     fs.writeFileSync(file, desired);
     result.written.push(name);
+    if (prevWritten.includes(name)) result.repaired.push(name);
+  }
+  // Persist what we manage now (best-effort).
+  try {
+    fs.mkdirSync(path.join(opts.agentDir, "agents"), { recursive: true });
+    fs.writeFileSync(subagentSyncStatePath(opts.agentDir), JSON.stringify({ written: result.written, at: new Date().toISOString() }));
+  } catch {
+    /* repair detection is best-effort */
   }
   return result;
 }
+
+/** v0.25.6: effective model for an agent type, for the headless settings
+ * display. Per-type override wins; inherit-parent falls to the session
+ * model; agent-default means upstream's own resolution (Explore's haiku
+ * pin for Explore, session model for the others). */
+export function resolveEffectiveSubagentModel(
+  name: string,
+  settings: { subagentModelStrategy?: string; subagentModelOverrides?: Record<string, string> },
+  sessionModel?: string,
+): string {
+  const pin = settings.subagentModelOverrides?.[name];
+  if (pin) return `${pin} (per-type pin)`;
+  if ((settings.subagentModelStrategy ?? "inherit-parent") === "inherit-parent") {
+    return sessionModel ? `${sessionModel} (inherits session)` : "(session model)";
+  }
+  return name === "Explore" ? "anthropic/claude-haiku-4-5 (upstream pin)" : "(agent default)";
+}

package/extensions/loops/goal.ts

@@ -42,6 +42,8 @@ import {
   appendAuditLog,
   computeListDepth,
   formatAuditLog,
+  formatGoalAuditHistory,
+  runWithInfraRetry,
   readAuditLog,
   stripThinkBlocks,
   type AuditLogEntry,
@@ -85,6 +87,7 @@ import {
 } from "../goal-loop-core.js";
 import {
   isQuotaError,
+  isSubagentQuotaResult,
   parseQuotaError,
   scheduleQuotaRetry,
   cancelQuotaRetry,
@@ -120,6 +123,7 @@ import {
 import { buildStatusText, buildWidgetLines, type AuditDisplayProgress } from "../goal-loop-display.js";
 import {
   defaultAgentDir,
+  resolveEffectiveSubagentModel,
   syncSubagentModelOverrides,
   type SubagentModelStrategy,
 } from "../goal-loop-subagents.js";
@@ -1703,24 +1707,38 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
       // Esc during the audit aborts this tool's signal → threaded into the
       // auditor session, which aborts cleanly and returns "Auditor aborted."
       latestAuditProgress = { label: "starting", lastEventAt: Date.now() };
-      const result = await runGoalCompletionAuditor({
-        ctx,
-        goal: state.goal,
-        completionSummary: p.completionSummary,
-        verificationSummary: p.verificationSummary,
-        model: auditorModel,
-        thinkingLevel: settings.auditorThinkingLevel ?? getSessionThinkingLevel(),
-        signal: signal ?? undefined,
-        onProgress: (progress) => {
-          latestAuditProgress = {
-            currentTool: progress.currentTool,
-            label: progress.label,
-            elapsedMs: progress.elapsedMs,
-            lastEventAt: Date.now(),
-          };
+      const runAudit = () =>
+        runGoalCompletionAuditor({
+          ctx,
+          goal: state.goal!,
+          completionSummary: p.completionSummary,
+          verificationSummary: p.verificationSummary,
+          model: auditorModel,
+          thinkingLevel: settings.auditorThinkingLevel ?? getSessionThinkingLevel(),
+          signal: signal ?? undefined,
+          onProgress: (progress) => {
+            latestAuditProgress = {
+              currentTool: progress.currentTool,
+              label: progress.label,
+              elapsedMs: progress.elapsedMs,
+              lastEventAt: Date.now(),
+            };
+            refreshUI(ctx);
+          },
+        });
+      // v0.25.4 (post-audit fix): a retriable infra failure (stream error,
+      // auth blip — NOT user abort, NOT missing model) gets ONE automatic
+      // retry with backoff before we report "auditor infrastructure error
+      // (retried once)". Neither attempt is a verdict on the work.
+      const auditStartMs = Date.now();
+      const { result, retriedOnce } = await runWithInfraRetry(runAudit, {
+        onRetry: (err) => {
+          latestAuditProgress = { label: `infra error (${err.slice(0, 40)}) — retrying once`, lastEventAt: Date.now() };
           refreshUI(ctx);
+          appendLedger(ctx.cwd, "audit_infra_retry", { goalId: state.goal?.id, error: err.slice(0, 200) });
         },
       });
+      const auditDurationMs = Date.now() - auditStartMs;
       latestAuditProgress = null;
       // Audit history: record REAL verdicts only — a non-empty report is the
       // evidence the auditor actually inspected something. Empty-report runs
@@ -1746,7 +1764,8 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
           error: result.error,
           regressionShieldPassed: result.regressionShieldPassed,
           regressionShieldMissing: result.regressionShieldMissing,
-        });
+          durationMs: auditDurationMs,
+        } as any);
         // Cap history — 39 infra errors taught us unbounded growth is real.
         if (history.length > 20) history.splice(0, history.length - 20);
         // v0.25.4: durable append-only audit log — survives state-snapshot
@@ -1771,7 +1790,9 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
           report: cleanOutput,
           impossibleReason: result.impossibleReason,
           error: result.error,
-        });
+          durationMs: auditDurationMs,
+          retriedOnce,
+        } as AuditLogEntry);
       }
 
       // Escape hatch: the user aborted the audit (Esc). Offer the explicit
@@ -1897,14 +1918,14 @@ function registerAgentTools(pi: any, ctx: ExtensionContext): void {
         updateGoal({
           status: "active",
           auditHistory: history,
-          pauseReason: `auditor infrastructure: ${result.error}`,
+          pauseReason: `auditor infrastructure${retriedOnce ? " (retried once)" : ""}: ${result.error}`,
           pauseSuggestedAction: "Fix the auditor model (/glla model=provider/id) and call complete_goal again — your work was NOT judged",
         }, ctx);
         scheduleContinuation(ctx, true);
         return {
           content: [{
             type: "text",
-            text: `The auditor could not run (infrastructure, NOT a verdict): ${result.error}\nYour completion claim was not evaluated. Fix the auditor model with /glla model=provider/id and call complete_goal again — do not change your deliverable for this.`,
+            text: `The auditor could not run (infrastructure, NOT a verdict${retriedOnce ? "; retried once with backoff, both attempts failed" : ""}): ${result.error}\nYour completion claim was not evaluated. Fix the auditor model with /glla model=provider/id and call complete_goal again — do not change your deliverable for this.`,
           }],
           details: {},
         };
@@ -2647,6 +2668,8 @@ async function openSettingsUI(ctx: ExtensionContext): Promise<void> {
           `Stuck max interventions — ${show("stuckMaxInterventions", "(5 default)")}`,
           `Subagent model strategy — ${show("subagentModelStrategy", "(inherit-parent)")}`,
           `Subagent Explore model pin — ${loadSettings(ctx.cwd).subagentModelOverrides?.Explore ?? "(follows strategy)"}`,
+          `Subagent Plan model pin — ${loadSettings(ctx.cwd).subagentModelOverrides?.Plan ?? "(follows strategy)"}`,
+          `Subagent general-purpose model pin — ${loadSettings(ctx.cwd).subagentModelOverrides?.["general-purpose"] ?? "(follows strategy)"}`,
           `Audit feedback characters — ${show("auditFeedbackChars", "(full report)")}`,
           "Done",
         ],
@@ -2716,15 +2739,16 @@ async function openSettingsUI(ctx: ExtensionContext): Promise<void> {
           saveSettings("global", ctx.cwd, { subagentModelStrategy: strategy });
           ctx.ui.notify("Subagent model strategy saved — applies to NEW pi sessions (pi-subagents registers agents at session start).", "info");
         }
-      } else if (choice.startsWith("Subagent Explore model pin")) {
-        const v = await ctx.ui.input("Model pin for Explore subagents", "provider/model-id e.g. minimax/MiniMax-M3 — always wins over strategy; empty = follow strategy");
+      } else if (/^Subagent (Explore|Plan|general-purpose) model pin/.test(choice)) {
+        const agentType = choice.match(/^Subagent (Explore|Plan|general-purpose) model pin/)![1]!;
+        const v = await ctx.ui.input(`Model pin for ${agentType} subagents`, "provider/model-id e.g. minimax/MiniMax-M3 — always wins over strategy; empty = follow strategy");
         if (v !== undefined) {
           const current = loadSettings(ctx.cwd).subagentModelOverrides ?? {};
           const next = { ...current };
-          if (v.trim()) next.Explore = v.trim();
-          else delete next.Explore;
+          if (v.trim()) next[agentType] = v.trim();
+          else delete next[agentType];
           saveSettings("global", ctx.cwd, { subagentModelOverrides: Object.keys(next).length > 0 ? next : undefined });
-          ctx.ui.notify("Explore model pin saved — applies to NEW pi sessions.", "info");
+          ctx.ui.notify(`${agentType} model pin saved — applies to NEW pi sessions.`, "info");
         }
       } else if (choice.startsWith("Audit feedback")) {
         const v = await ctx.ui.input("Auditor feedback returned to the executor (characters)", "non-negative integer cap; 0 or empty = full report (default)");
@@ -2785,12 +2809,28 @@ function cmdStats(args: string, ctx: ExtensionContext): void {
  */
 function cmdAudits(args: string, ctx: ExtensionContext): void {
   const full = /\bfull\b/.test(args);
+  const all = /\b(?:all|global|log)\b/.test(args);
   const nMatch = args.match(/\b(\d+)\b/);
   if (full) {
+    // Latest report — active goal's history first, then the log.
+    const fromGoal = state.goal?.auditHistory?.at(-1);
+    if (fromGoal?.report) {
+      ctx.ui.notify(`Latest audit on this goal — ${fromGoal.model} (${fromGoal.at})\n${fromGoal.report}`, "info");
+      return;
+    }
     const latest = readAuditLog(ctx.cwd).at(-1);
     ctx.ui.notify(latest ? `Latest audit — ${latest.verdict} (${latest.model}, ${latest.at})\n${latest.report}` : "No audits logged yet.", "info");
     return;
   }
+  // Default: the ACTIVE goal's own audit history (with per-audit elapsed);
+  // "all"/"global"/"log" browses the durable cross-goal log.
+  if (!all && state.goal?.auditHistory && state.goal.auditHistory.length > 0) {
+    ctx.ui.notify(
+      `glla audits — this goal's history (${state.goal.auditHistory.length} verdict(s); /glla audits all for the project log)\n${formatGoalAuditHistory(state.goal)}`,
+      "info",
+    );
+    return;
+  }
   const n = nMatch ? Number(nMatch[1]) : 10;
   const entries = readAuditLog(ctx.cwd, n);
   ctx.ui.notify(`glla audits — last ${entries.length} verdict(s) in ${ctx.cwd}\n${formatAuditLog(entries)}`, "info");
@@ -2843,6 +2883,10 @@ async function cmdSettings(args: string, ctx: ExtensionContext): Promise<void> {
         fmt("aggressiveMode", "aggressiveMode"),
         fmt("quotaRetryMinutes", "quotaRetryMinutes"),
         fmt("stuckMaxInterventions", "stuckMaxInterventions"),
+        // v0.25.6: effective per-type subagent model resolution.
+        ...["Explore", "Plan", "general-purpose"].map(
+          (t) => `subagent ${t}: ${resolveEffectiveSubagentModel(t, loadSettings(ctx.cwd), (ctx.model as any)?.id ? `${(ctx.model as any).provider}/${(ctx.model as any).id}` : undefined)}`,
+        ),
         `\nglobal:  ${globalSettingsPath()}`,
         `project: ${projectSettingsPath(ctx.cwd)}`,
         `Set with: /glla key=value (global) · /glla project key=value (project override)`,
@@ -3217,6 +3261,18 @@ export default function (pi: ExtensionAPI): void {
         state.goal.telemetry = t;
       }
     }
+    // v0.25.6: subagent quota errors (the pi-subagents#175 shape —
+    // Explore's upstream haiku pin 403s on shared keys). Surface the
+    // repair path immediately; the continuation prompt's WHEN SUBAGENTS
+    // HIT QUOTA ERRORS section carries the full guidance.
+    if (isSubagentQuotaResult(String(event?.toolName ?? ""), Boolean(event?.isError ?? event?.error), event?.output ?? event?.result ?? event?.details ?? "")) {
+      const errText = typeof (event?.output ?? event?.result) === "string" ? (event?.output ?? event?.result) : JSON.stringify(event?.output ?? event?.result ?? event?.details ?? "");
+      appendLedger(registeredCtx?.cwd ?? process.cwd(), "subagent_quota_error", { error: String(errText).slice(0, 200) });
+      registeredCtx?.ui.notify(
+        "Subagent hit a quota error (403/limit). Repair: re-spawn with an explicit model= on your quota pool, or do the work inline — see the continuation prompt's WHEN SUBAGENTS HIT QUOTA ERRORS. Explore's upstream haiku pin is the usual cause (pi-subagents#175); glla's inherit-parent strategy removes it for NEW sessions.",
+        "warning",
+      );
+    }
     if (draftingTarget === null) return;
     if (askUserQuestionAnswered(String(event?.toolName ?? ""), event?.details)) {
       draftingUserReplies++;
@@ -3250,6 +3306,15 @@ export default function (pi: ExtensionAPI): void {
       for (const skip of sync.skipped) {
         ctx.ui.notify(`glla subagent override skipped [${skip.name}]: ${skip.reason}`, "warning");
       }
+      // v0.25.6: notify-with-repair — a managed override that went missing
+      // or was altered externally (pi update, manual edit, sync churn) is
+      // re-written AND surfaced, not silently restored.
+      if (sync.repaired.length > 0) {
+        ctx.ui.notify(
+          `glla repaired managed subagent override(s): ${sync.repaired.join(", ")} — the file(s) were missing or altered externally; re-written per your subagent settings.`,
+          "warning",
+        );
+      }
     } catch (err) {
       ctx.ui.notify(`glla subagent override sync failed: ${err instanceof Error ? err.message : String(err)}`, "warning");
     }

package/extensions/quota-retry.ts

@@ -88,3 +88,13 @@ export function scheduleQuotaRetry(
     "info",
   );
 }
+
+/** v0.25.6: detect a SUBAGENT quota failure in a tool_result — the
+ * pi-subagents#175 shape (Explore's upstream haiku pin 403s on shared
+ * keys). Tool must be an Agent spawn and the payload a quota error. */
+export function isSubagentQuotaResult(toolName: string, isError: boolean, payload: unknown): boolean {
+  if (!isError) return false;
+  if (toolName !== "Agent" && toolName !== "agent") return false;
+  const text = typeof payload === "string" ? payload : JSON.stringify(payload ?? "");
+  return isQuotaError(text);
+}

package/package.json

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