pi-goal-list-loop-audit 0.27.7 → 0.27.9

package/extensions/goal-loop-auditor.ts

@@ -104,6 +104,7 @@ function buildGoalAuditorPrompt(goal: Goal, completionSummary: string | null | u
     "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.",
     "Be skeptical and semantic. Do not approve from paperwork, intent, file count, word count, build success, or a plausible summary alone.",
+    "Chunk output near context-full: prefer focused, evidence-quote-first replies (one tool call at a time, raw output inline) over mega-replies that hit the output-token cap. The orchestrator's auto-continue fires on stop_reason=\"length\" but pre-empting by chunking is cheaper than recovering from the cap.",
     "Use read/grep/find/ls/bash as needed to inspect real artifacts. Do not mutate files or run destructive commands.",
     "If the work is only an alpha scaffold, generated template, shallow draft, proxy milestone, or lacks the user-facing value requested, disapprove.",
     "If any explicit requirement is missing, weakly verified, contradicted, or not inspectable with the available evidence, disapprove.",

package/extensions/goal-loop-display.ts

@@ -231,12 +231,19 @@ function goalLines(g: Goal, state: State, audit: AuditDisplayProgress | null | u
     });
     // v0.27.1: what survives the pause — the first question at a pause is
     // "did I lose the work?". Answer it on the card.
+    // v0.27.9: when the goal has no telemetry yet (restored-in-fresh-session
+    // before the first turn), render "awaiting first turn" instead of "saved"
+    // — the latter was misleading because no work was ever "saved" before the
+    // session ended.
     const spent: string[] = [];
     const tokUsed = g.usage?.tokensUsed ?? 0;
-    if (tokUsed > 0) spent.push(`${fmtTokens(tokUsed)} tok spent`);
     const audits = g.auditHistory?.length ?? 0;
+    if (tokUsed > 0) spent.push(`${fmtTokens(tokUsed)} tok spent`);
     if (audits > 0) spent.push(`${audits} audit${audits === 1 ? "" : "s"}`);
-    const savedLine = `saved${spent.length > 0 ? ` — ${spent.join(" · ")}` : ""} · resumes exactly here`;
+    const hasTelemetry = spent.length > 0;
+    const savedLine = hasTelemetry
+      ? `saved — ${spent.join(" · ")} · resumes exactly here`
+      : `awaiting first turn — resumes exactly here`;
     if (g.pauseSuggestedAction) {
       lines.push(`├─ ${paint(theme, "dim", truncate(savedLine, budget))}`);
       const wrapped = wrap(g.pauseSuggestedAction, budget, 3);

package/extensions/goal-settings.ts

@@ -83,6 +83,18 @@ export interface Settings {
    * Always wins over subagentModelStrategy — the managed override is written
    * WITH this pin regardless of strategy. */
   subagentModelOverrides?: Record<string, string>;
+  /** v0.27.9: per-tool overrides — allowlist (force tools visible despite
+   * an external modlist), hidden (force tools hidden even when allowed by
+   * the session), and per-tool config (Record<toolName, Record<key, value>>
+   * — extensible for tool-specific knobs like timeouts, formats, etc.). */
+  toolOverrides?: {
+    /** Tools that MUST be active even when an external allowlist hides them. */
+    allow?: string[];
+    /** Tools that MUST be hidden even when the session allows them. */
+    hide?: string[];
+    /** Per-tool configuration knobs (extensible). */
+    perToolConfig?: Record<string, Record<string, unknown>>;
+  };
 }
 
 export const DEFAULT_SETTINGS: Settings = {
@@ -146,6 +158,7 @@ export const SETTINGS_KEYS: Array<keyof Settings> = [
   "stallShortWords",
   "stallSimilarityThreshold",
   "postaudit",
+  "toolOverrides",
 ];
 
 /** Where each effective setting comes from (for the /glla display). */

package/extensions/loops/goal.ts

@@ -679,7 +679,7 @@ function archiveCurrentGoal(ctx: ExtensionContext, status: Status, stopReason?:
 function fireReviewer(
   ctx: ExtensionContext,
   source: { kind: "goal" | "list"; goalId: string; objective: string; terminal: string },
-  opts: { manual?: boolean; mode?: "off" | "default" | "auto" | "aggressive" | "report" } = {},
+  opts: { manual?: boolean; mode?: "off" | "on" | "auto" | "aggressive" } = {},
 ): void {
   try {
     const settings = loadSettings(ctx.cwd);
@@ -3068,12 +3068,12 @@ async function cmdReview(args: string, ctx: ExtensionContext): Promise<void> {
   const parts = args.trim().split(/\s+/).filter(Boolean);
   const id = parts[0] ?? "";
   const modeArg = parts[1];
-  const validModes = ["off", "default", "auto", "aggressive", "report"] as const;
+  const validModes = ["off", "on", "auto", "aggressive"] as const;
   const mode = (validModes as readonly string[]).includes(modeArg ?? "")
     ? (modeArg as typeof validModes[number])
     : undefined;
   if (modeArg && !mode) {
-    ctx.ui.notify(`Unknown mode "${modeArg}" — use off | default | auto | aggressive | report.`, "warning");
+    ctx.ui.notify(`Unknown mode "${modeArg}" — use off | on | auto | aggressive.`, "warning");
     return;
   }
   if (!id) {
@@ -3101,6 +3101,98 @@ async function cmdReview(args: string, ctx: ExtensionContext): Promise<void> {
   fireReviewer(ctx, { kind: "goal", goalId, objective, terminal: "goal-complete" }, { manual: true, mode });
 }
 
+/** v0.27.9: /glla tooloverride <action> [args] — per-tool override menu.
+ * Actions:
+ *   list                                show current allow/hide/perToolConfig
+ *   allow <tool>                        force <tool> visible despite modlist
+ *   hide <tool>                         force <tool> hidden despite session
+ *   unallow <tool>                      remove from allow list
+ *   unhide <tool>                       remove from hide list
+ *   set <tool> <key>=<value>            write perToolConfig[tool][key]
+ *   unset <tool> <key>                  remove perToolConfig[tool][key]
+ * Example: /glla tooloverride allow bash hide write_file set bash timeout=60 */
+async function cmdToolOverride(args: string, ctx: ExtensionContext): Promise<void> {
+  const settings = loadSettings(ctx.cwd);
+  const current = settings.toolOverrides ?? {};
+  const parts = args.trim().split(/\s+/).filter(Boolean);
+  const action = parts[0];
+  if (!action || action === "list" || action === "show") {
+    const allow = current.allow ?? [];
+    const hide = current.hide ?? [];
+    const cfg = current.perToolConfig ?? {};
+    const out = `toolOverrides (project):\n  allow: ${allow.length ? allow.join(", ") : "(none)"}\n  hide: ${hide.length ? hide.join(", ") : "(none)"}\n  perToolConfig: ${Object.keys(cfg).length ? JSON.stringify(cfg) : "(none)"}`;
+    ctx.ui.notify(out, "info");
+    return;
+  }
+  const apply = (patch: Partial<NonNullable<Settings["toolOverrides"]>>) => {
+    saveSettings("project", ctx.cwd, { toolOverrides: { ...current, ...patch } });
+  };
+  if (action === "allow" || action === "hide" || action === "unallow" || action === "unhide") {
+    const tool = parts[1];
+    if (!tool) {
+      ctx.ui.notify(`Usage: /glla tooloverride ${action} <tool>`, "warning");
+      return;
+    }
+    if (action === "allow") {
+      const allow = current.allow ?? [];
+      if (!allow.includes(tool)) apply({ allow: [...allow, tool] });
+      ctx.ui.notify(`toolOverrides.allow += ${tool}`, "info");
+    } else if (action === "hide") {
+      const hide = current.hide ?? [];
+      if (!hide.includes(tool)) apply({ hide: [...hide, tool] });
+      ctx.ui.notify(`toolOverrides.hide += ${tool}`, "info");
+    } else if (action === "unallow") {
+      apply({ allow: (current.allow ?? []).filter((t) => t !== tool) });
+      ctx.ui.notify(`toolOverrides.allow -= ${tool}`, "info");
+    } else {
+      apply({ hide: (current.hide ?? []).filter((t) => t !== tool) });
+      ctx.ui.notify(`toolOverrides.hide -= ${tool}`, "info");
+    }
+    return;
+  }
+  if (action === "set" || action === "unset") {
+    const tool = parts[1];
+    const kv = parts[2];
+    if (!tool || !kv) {
+      ctx.ui.notify(`Usage: /glla tooloverride ${action} <tool> <key>[=<value>]`, "warning");
+      return;
+    }
+    const cfg = { ...(current.perToolConfig ?? {}) };
+    const toolCfg = { ...(cfg[tool] ?? {}) };
+    if (action === "set") {
+      const eq = kv.indexOf("=");
+      if (eq < 0) {
+        ctx.ui.notify(`set needs key=value: got "${kv}"`, "warning");
+        return;
+      }
+      const k = kv.slice(0, eq);
+      const v: unknown = parseToolOverrideValue(kv.slice(eq + 1));
+      toolCfg[k] = v;
+    } else {
+      delete toolCfg[kv];
+    }
+    cfg[tool] = toolCfg;
+    apply({ perToolConfig: cfg });
+    ctx.ui.notify(`toolOverrides.perToolConfig.${tool} ${action === "set" ? "set" : "unset"}`, "info");
+    return;
+  }
+  ctx.ui.notify(`Unknown tooloverride action: ${action}. Use: list | allow | hide | unallow | unhide | set | unset.`, "warning");
+}
+
+/** Parse a tool-override value: numbers, booleans, JSON objects/arrays, else string. */
+function parseToolOverrideValue(s: string): unknown {
+  const trimmed = s.trim();
+  if (trimmed === "true") return true;
+  if (trimmed === "false") return false;
+  if (trimmed === "null") return null;
+  if (/^-?\d+$/.test(trimmed)) return Number(trimmed);
+  if (/^-?\d+\.\d+$/.test(trimmed)) return Number(trimmed);
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    try { return JSON.parse(trimmed); } catch { /* fall through */ }
+  }
+  return trimmed;
+}
+
 /** v0.27.5: /glla reviewer | postaudit — the post-completion audit config menu
  * (project-scoped). Reads the dual-write settings (postaudit wins over the
  * legacy reviewer key), and writes back to whichever key was read first —
@@ -3129,8 +3221,8 @@ async function cmdReviewerSettings(ctx: ExtensionContext): Promise<void> {
     try {
       if (choice.startsWith("Enabled")) save({ enabled: !cfg.enabled });
       else if (choice.startsWith("Mode")) {
-        // v0.27.5: 5-state cycle off → default → auto → aggressive → report → off
-        const order: Array<"off" | "default" | "auto" | "aggressive" | "report"> = ["off", "default", "auto", "aggressive", "report"];
+        // v0.27.9: 4-state cycle off → on → auto → aggressive → off
+        const order: Array<"off" | "on" | "auto" | "aggressive"> = ["off", "on", "auto", "aggressive"];
         const i = order.indexOf(cfg.mode as typeof order[number]);
         const next = order[(i + 1) % order.length]!;
         save({ mode: next });
@@ -3257,6 +3349,11 @@ async function cmdSettings(args: string, ctx: ExtensionContext): Promise<void> {
     await cmdReviewerSettings(ctx);
     return;
   }
+  // v0.27.9: per-tool overrides — sub-mode `tooloverride <action> <tool>`
+  if (/^tooloverride\b/.test(trimmed)) {
+    await cmdToolOverride(trimmed.slice("tooloverride".length).trim(), ctx);
+    return;
+  }
   if (!trimmed) {
     if (ctx.hasUI) {
       await openSettingsUI(ctx);
@@ -3663,13 +3760,32 @@ export default function (pi: ExtensionAPI): void {
   // 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.
+  // v0.27.9: also applies toolOverrides.allow / toolOverrides.hide from
+  // .pi-glla/settings.json — the project's per-tool policy wins over the
+  // external allowlist (allow) or over the session default (hide).
   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]);
+      const overrides = loadSettings(ctx.cwd).toolOverrides;
+      let next = [...active, ...missing];
+      let changed = missing.length > 0;
+      // Apply per-tool allowlist — force tools visible despite an external modlist.
+      if (overrides?.allow && overrides.allow.length > 0) {
+        const toAdd = overrides.allow.filter((t) => !next.includes(t));
+        if (toAdd.length > 0) {
+          next = [...next, ...toAdd];
+          changed = true;
+        }
+      }
+      // Apply per-tool hide — force tools hidden even when the session allows them.
+      if (overrides?.hide && overrides.hide.length > 0) {
+        const before = next.length;
+        next = next.filter((t) => !overrides.hide!.includes(t));
+        if (next.length !== before) changed = true;
+      }
+      if (changed) pi.setActiveTools(next);
       if (!toolHealNotified) {
         toolHealNotified = true;
         const list = missing.join(", ");

package/extensions/reviewer.ts

@@ -15,7 +15,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 
-export type ReviewerMode = "off" | "default" | "auto" | "aggressive" | "report";
+export type ReviewerMode = "off" | "on" | "auto" | "aggressive";
 
 export interface ReviewerConfig {
   enabled: boolean;
@@ -37,7 +37,7 @@ export interface ReviewerConfig {
 
 export const DEFAULT_REVIEWER_CONFIG: ReviewerConfig = {
   enabled: true,
-  mode: "default",
+  mode: "on",
   fireOn: ["goal-complete", "list-complete"],
   doNotFireOn: ["goal-aborted", "goal-paused"],
   cascade: ["convert-findings-to-list", "queue-leftovers", "fire-audit-on-clean", "notify-and-idle"],
@@ -49,9 +49,15 @@ export const DEFAULT_REVIEWER_CONFIG: ReviewerConfig = {
   maxReviewsPerDay: 20,
 };
 
-/** Merge a partial project-settings block over the defaults. */
+/** Merge a partial project-settings block over the defaults. v0.27.9:
+ * migrate legacy `"default"` / `"report"` mode values to `"on"` (the
+ * contract-compliant 4-mode set is now `off | on | auto | aggressive`). */
 export function resolveReviewerConfig(block?: Partial<ReviewerConfig>): ReviewerConfig {
-  return { ...DEFAULT_REVIEWER_CONFIG, ...(block ?? {}) };
+  const merged = { ...DEFAULT_REVIEWER_CONFIG, ...(block ?? {}) };
+  if ((merged.mode as string) === "default" || (merged.mode as string) === "report") {
+    merged.mode = "on";
+  }
+  return merged;
 }
 
 export type FindingClass = "bug" | "refactor" | "architectural" | "strategic";
@@ -250,11 +256,10 @@ export function runReviewer(
   let cascadeStep = "notify-and-idle";
   const auto = config.mode === "auto" || config.mode === "aggressive";
   const aggressive = config.mode === "aggressive";
-  const reportOnly = config.mode === "report";
 
   // Cascade: findings → list items (leverage: fix-without-confirm).
   const convertStep = source.kind === "goal" ? "convert-findings-to-list" : "queue-leftovers";
-  if (bugs.length > 0 && config.cascade.includes(convertStep) && !reportOnly) {
+  if (bugs.length > 0 && config.cascade.includes(convertStep)) {
     deps.enqueueListItems(bugs.map((f) => f.text));
     enqueued = bugs.length;
     cascadeStep = convertStep;
@@ -263,7 +268,7 @@ export function runReviewer(
   // auto mode → /list items (the auto-loop rolls straight into them).
   // aggressive mode → enqueue AND relaunch as the next active goal
   // (skips both Confirm and the queue — the unattended rig never stops).
-  if (architectural.length > 0 && !reportOnly) {
+  if (architectural.length > 0) {
     if (aggressive) {
       deps.enqueueListItems(architectural.map((f) => f.text));
       // v0.27.5 aggressive: also propose the FIRST architectural finding
@@ -293,7 +298,7 @@ export function runReviewer(
   // auto mode enqueues the audit as a /list item (no Confirm — the
   // cascade keeps rolling until the findings run dry).
   // aggressive mode → relaunch the audit goal directly (no Confirm).
-  if (findings.length === 0 && config.cascade.includes("fire-audit-on-clean") && !reportOnly) {
+  if (findings.length === 0 && config.cascade.includes("fire-audit-on-clean")) {
     const auditObjective = `Post-completion regression scan after ${source.goalId} (${config.auditScope})`;
     if (aggressive) {
       deps.proposeGoal(auditObjective, "aggressive postaudit: clean completion — relaunching the regression scan as /goal");
@@ -309,7 +314,6 @@ export function runReviewer(
       cascadeStep = "fire-audit-on-clean";
     }
   }
-  if (reportOnly) cascadeStep = "report-only";
 
   const report: ReviewReport = {
     goalId: source.goalId,
@@ -345,7 +349,7 @@ export function runReviewer(
 export function reviewerMenuOptions(cfg: ReviewerConfig): string[] {
   return [
     `Enabled — ${cfg.enabled ? "ON" : "OFF"}`,
-    `Mode — ${cfg.mode} (off = silenced · default = Confirm-gated · auto = auto-loop, no Confirms · aggressive = auto + relaunch · report = report only)`,
+    `Mode — ${cfg.mode} (off = silenced · on = Confirm-gated cascade · auto = auto-loop, no Confirms · aggressive = auto + relaunch)`,
     `Leverage mode — ${cfg.leverageMode} (bug/refactor findings)`,
     `Fire on goal-complete — ${cfg.fireOn.includes("goal-complete") ? "ON" : "OFF"}`,
     `Fire on list-complete — ${cfg.fireOn.includes("list-complete") ? "ON" : "OFF"}`,

package/package.json

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