pi-ui-extend 1.0.42 → 1.0.45

package/external/pi-tools-suite/src/dcp/statistics.js

@@ -0,0 +1,156 @@
+// Shared, dependency-free presentation for the extension, TUI and ACP. Plain
+// ESM is intentional: the compiled host can import the shipped extension source
+// without loading TypeScript or bringing the extension runtime into the host.
+
+/** @param {any} v */
+const finite = (v) => typeof v === "number" && Number.isFinite(v);
+/** @param {any} v */
+const num = (v) => finite(v) ? Math.round(v).toLocaleString("en-US") : "unknown";
+/** @param {any} n @param {any} d */
+const percent = (n, d) => finite(n) && finite(d) && d > 0 ? `${(100 * n / d).toFixed(1)}%` : "unknown";
+/** @param {any} v */
+const mode = (v) => typeof v === "boolean" ? (v ? "on" : "off") : "unknown";
+/** @param {any} m */
+const modelRef = (m) => m?.provider && m?.id ? `${m.provider}/${m.id}` : undefined;
+/** @param {any} v */
+const record = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+
+/** Read-only diagnostic reducer. Never runs the pruner, a model, or a mutation.
+ * @param {import('./statistics.js').DcpStatisticsInput} input */
+export function collectDcpStatistics(input) {
+  const entries = input.branch ?? [];
+  const blocks = new Map(), pruned = new Map(), operations = new Map(), measured = new Map();
+  let journal = "absent", previous = null, anchors = [], manualMode;
+  let epoch, snapshot, lastReminder, ignored, evidenceEpoch = false;
+  let projections = 0, attempts = 0, completed = 0, rejected = 0;
+  const publishedIds = new Set();
+  const attemptIds = new Set(), completionIds = new Set(), manualFailures = new Set();
+  const diagnostics = [];
+  for (const entry of entries) {
+    if (entry?.type === "custom" && entry.customType === "dcp-journal") {
+      const op = entry.data;
+      if (!record(op) || op.schemaVersion !== 1 || !["init", "delta"].includes(op.kind) || typeof op.operationId !== "string") {
+        journal = "invalid/unsupported"; break;
+      }
+      if (operations.has(op.operationId)) {
+        if (operations.get(op.operationId) !== JSON.stringify(op)) { journal = "conflicting operations"; break; }
+        continue;
+      }
+      if ((op.kind === "init" && (previous !== null || op.previousOperationId !== null)) ||
+          (op.kind === "delta" && (previous === null || op.previousOperationId !== previous))) {
+        journal = "incomplete/broken chain"; break;
+      }
+      previous = op.operationId;
+      operations.set(previous, JSON.stringify(op));
+      journal = "chain verified";
+      for (const b of op.blocks ?? []) {
+        if (!record(b) || !finite(b.id) || typeof b.active !== "boolean" || blocks.has(b.id)) { journal = "invalid blocks"; break; }
+        blocks.set(b.id, { ...b });
+        const m = b.commitMetrics;
+        if (record(m) && typeof m.operationId === "string" && finite(m.netGainTokens) && m.netGainTokens > 0 &&
+            finite(m.beforeTokens) && finite(m.afterTokens) && m.beforeTokens - m.afterTokens === m.netGainTokens) measured.set(m.operationId, m);
+      }
+      if (journal !== "chain verified") break;
+      for (const update of op.blockStates ?? []) {
+        const b = blocks.get(update.id);
+        if (!b || typeof update.active !== "boolean" || (!b.active && update.active)) { journal = "invalid block states"; break; }
+        b.active = update.active;
+      }
+      if (journal !== "chain verified") break;
+      for (const p of op.prunedTools ?? []) if (typeof p?.toolCallId === "string") pruned.set(p.toolCallId, p);
+      if (Array.isArray(op.nudgeAnchors)) {
+        anchors = op.nudgeAnchors;
+        for (const anchor of anchors) publishedIds.add(anchor.id);
+      }
+      if (typeof op.manualMode === "boolean") manualMode = op.manualMode;
+    }
+    if (entry?.type === "custom" && entry.customType === "dcp-nudge") {
+      const e = entry.data;
+      if (["emitted", "reapplied", "upgraded"].includes(e?.event)) { projections++; lastReminder = e; }
+    }
+    if (entry?.type === "custom" && entry.customType === "dcp-diagnostic" && entry.data?.version === 1) diagnostics.push(entry.data);
+    if (entry?.type === "message" && entry.message?.role === "toolResult" && entry.message.toolName === "compress" && entry.message.isError) {
+      manualFailures.add(entry.message.toolCallId ?? entry.id);
+    }
+  }
+  // Epoch markers invalidate live measurements/evidence, not durable history.
+  for (const d of diagnostics) {
+    if (d.event === "epoch") { epoch = d.epoch; snapshot = undefined; ignored = 0; evidenceEpoch = true; }
+    if (d.event === "request" && d.epoch === epoch) {
+      snapshot = d.snapshot;
+      if (finite(snapshot?.ignored)) ignored = snapshot.ignored;
+      if (d.reminder && !attemptIds.has(d.id)) { attempts++; attemptIds.add(d.id); }
+    }
+    if (d.event === "completion" && d.epoch === epoch && !completionIds.has(d.id) && (!d.reminder || attemptIds.has(d.id))) {
+      if (d.reminder) completed++;
+      completionIds.add(d.id); ignored = d.ignored;
+    }
+    if (d.event === "auto-rejected") rejected++;
+  }
+  const valid = journal === "chain verified" && input.historyStatus !== "unavailable";
+  const all = valid ? [...blocks.values()] : [];
+  const active = all.filter((b) => b.active);
+  const activity = { manual: new Set(), auto: new Set(), consolidation: new Set(), unknownBlocks: 0 };
+  for (const b of all) {
+    const kind = b.commitMetrics?.kind ?? (b.createdByToolCallId ? "manual" : b.autoSummaryRepresentation
+      ? ((b.coveredBlockIds?.length ?? 0) >= 2 && b.sourceCoverage?.itemCount === b.coveredBlockIds.length ? "consolidation" : "auto") : undefined);
+    const bucket = kind === "manual" ? activity.manual : kind === "auto" ? activity.auto : kind === "consolidation" ? activity.consolidation : undefined;
+    if (bucket) bucket.add(b.commitMetrics?.operationId ?? (kind === "manual" ? `manual:${b.createdByToolCallId}` : `auto:${b.id}`));
+    else activity.unknownBlocks++;
+  }
+  const currentWindow = input.model?.contextWindow;
+  const snapshotMatchesModel = snapshot && modelRef(input.model) === snapshot.model &&
+    (!finite(currentWindow) || currentWindow === snapshot.contextWindow);
+  return { valid, journal, operations: operations.size, all, active, pruned: valid ? pruned.size : undefined,
+    summaryTokens: valid && active.every((b) => finite(b.summaryTokenEstimate)) ? active.reduce((s,b) => s + b.summaryTokenEstimate, 0) : undefined,
+    manualMode, activity, measured: valid ? measured.size : undefined,
+    measuredGain: valid && measured.size ? [...measured.values()].reduce((s,m) => s + m.netGainTokens, 0) : valid && all.length === 0 ? 0 : undefined,
+    snapshot: snapshotMatchesModel ? snapshot : undefined, snapshotStale: Boolean(snapshot && !snapshotMatchesModel),
+    published: publishedIds.size, projections, attempts: evidenceEpoch ? attempts : undefined, completed: evidenceEpoch ? completed : undefined,
+    ignored: snapshotMatchesModel ? ignored : undefined, anchors: valid ? anchors : [], lastReminder,
+    rejected: evidenceEpoch ? rejected : undefined, manualFailures: manualFailures.size };
+}
+
+/** @param {import('./statistics.js').DcpStatisticsInput} input */
+export function formatDcpStatistics(input) {
+  let s;
+  try { s = collectDcpStatistics(input); }
+  catch { return "DCP Session Statistics\n\nHistory unavailable: malformed diagnostic/journal records. No zero statistics inferred."; }
+  const usage = input.usage ?? {}, m = input.model, snap = s.snapshot;
+  const window = finite(m?.contextWindow) && m.contextWindow > 0 ? m.contextWindow : usage.contextWindow;
+  const lines = ["DCP Session Statistics:", "Context",
+    `  Model: ${modelRef(m) ?? "unknown"}`,
+    `  SDK usage: ${num(usage.tokens)} / ${num(window)} (${percent(usage.tokens, window)}; may lag)`,
+  ];
+  if (snap) {
+    lines.push(`  Last DCP request: ~${num(snap.projectedTokens)} tokens; ${snap.pressure} (${snap.reason})`,
+      `  Input capacity: ${num(snap.inputCapacityTokens)}; reserved output: ${num(snap.reservedOutputTokens)}`,
+      `  Resolved thresholds: routine ${percent(snap.routineTokens, snap.contextWindow)} / strong ${percent(snap.strongTokens, snap.contextWindow)} / hard ${percent(snap.hardTokens, snap.contextWindow)}`,
+      `  Modes (last request): DCP ${mode(snap.enabled)}, manual ${mode(snap.manualMode)}, auto ${mode(snap.autoEnabled)}`,
+      `  Snapshot: ${finite(snap.createdAt) && Math.abs(snap.createdAt) < 8.64e15 ? new Date(snap.createdAt).toISOString() : "unknown time"} (last request)`);
+  } else lines.push(`  DCP budget/thresholds: ${s.snapshotStale ? "stale (model/window changed); awaiting projection" : "not recorded; awaiting projection"}`);
+  lines.push("History projection (active branch)");
+  if (!s.valid) {
+    lines.push(`  Unavailable: ${input.historyStatus === "unavailable" ? "full history could not be read" : s.journal}`,
+      "  Blocks, gains and reminders: unknown (not zero)");
+    return lines.join("\n");
+  }
+  lines.push(`  Blocks: ${s.active.length} active / ${s.all.length - s.active.length} retired / ${s.all.length} total`,
+    `  Active summaries: ~${num(s.summaryTokens)} tokens; result bodies pruned: ${num(s.pruned)}`);
+  if (snap) lines.push(`  Input/projection: ~${num(snap.rawTokens)} -> ~${num(snap.projectedTokens)} (reduction ~${num(snap.rawTokens - snap.projectedTokens)})`);
+  lines.push("Compression activity",
+    `  Commits: ${s.activity.manual.size} model/tool, ${s.activity.auto.size} auto, ${s.activity.consolidation.size} consolidations`);
+  if (s.activity.unknownBlocks) lines.push(`  Provenance unknown: ${s.activity.unknownBlocks} blocks`);
+  lines.push(`  Measured commit gain: ${num(s.measuredGain)} tokens (${num(s.measured)} measured commits)`,
+    `  Rejections recorded: ${num(s.rejected)} auto; ${num(s.manualFailures)} failed compress results`,
+    "Reminder delivery",
+    `  Anchors journaled: ${s.published}; projection events: ${s.projections} (not sends)`,
+    `  Recorded provider attempts with reminder: ${num(s.attempts)}`,
+    `  confirmed completed opportunities: ${num(s.completed)}`,
+    `  Outstanding consecutive opportunities (last sample): ${num(s.ignored)}`,
+    `  Active anchors: ${s.anchors.length}${s.anchors.length ? " (" + s.anchors.map((/** @type {any} */ a) => `${a.type}/${a.anchorRole ?? "unknown carrier"}`).join(", ") + ")" : ""}`,
+    `  Last published/reapplied: ${s.lastReminder ? `${s.lastReminder.type} / ${s.lastReminder.anchorRole ?? "unknown carrier"}` : "none recorded"}`,
+    `Journal: ${s.journal} (${s.operations} records); full active branch`,
+    "Estimates, not billing. Old unmeasured gains/deliveries excluded.");
+  return lines.join("\n");
+}

package/external/pi-tools-suite/src/default-pi-tools-suite-config.ts

@@ -19,8 +19,10 @@ export const DEFAULT_PI_TOOLS_SUITE_CONFIG_JSONC = String.raw`{
     "notify": true
   },
   // Context Gateway is off by default. observe is passive telemetry; enforce
-  // selectively compacts only recognised complete simple test/build output.
-  // Reads and repo results remain producer-owned passthrough/native-compact.
+  // compacts recognised complete simple test/build output and over-budget
+  // structured web_search/web_fetch results whose raw details remain recoverable
+  // from the append-only session. Reads/repo and unsupported result shapes stay
+  // producer-owned passthrough/native-compact.
   "contextGateway": {
     "mode": "off",
     "budgets": {
@@ -57,6 +59,7 @@ export const DEFAULT_PI_TOOLS_SUITE_CONFIG_JSONC = String.raw`{
   // Vision-capable model used by the coding-discipline lookup tool for blind-model
   // screenshot/image questions. Remove or set to null to disable lookup.
   "lookupModel": "zai/glm-5.3-flash",
+  "lookupFallbackModels": [],
   "terminalBell": { "sound": true },
   // comment-checker: nudges the agent to remove AI-slop code comments it just
   // added via write/edit/apply_patch. Net-new comments are classified and a
@@ -94,29 +97,43 @@ export const DEFAULT_PI_TOOLS_SUITE_CONFIG_JSONC = String.raw`{
       }
     },
     "modelOverrides": {
+      // DCP policy reviewed 2026-09-14. Engineering starting points, not
+      // provider-certified optima. Keep candidate/message availability aligned
+      // with each model's routine compression threshold.
       "openai-codex/gpt-5*": {
         "compress": {
           "minContextPercent": "26%",
-          "maxContextPercent": "46%"
+          "maxContextPercent": "46%",
+          "autoCandidates": { "minContextPercent": 0.26 },
+          "messageMode": { "minContextPercent": 0.26 }
         }
       },
       "openai-codex/gpt-5.4-mini": {
         "compress": {
           "minContextPercent": "20%",
-          "maxContextPercent": "38%"
+          "maxContextPercent": "38%",
+          "autoCandidates": { "minContextPercent": 0.20 },
+          "messageMode": { "minContextPercent": 0.20 }
+        }
+      },
+      "openai-codex/gpt-6-astra": {
+        "compress": {
+          "minContextPercent": "26%",
+          "maxContextPercent": "46%",
+          "autoCandidates": { "minContextPercent": 0.26 },
+          "messageMode": { "minContextPercent": 0.26 }
         }
       },
       "zai/*": {
         "compress": {
           "minContextPercent": "16%",
-          "maxContextPercent": "30%"
+          "maxContextPercent": "30%",
+          "autoCandidates": { "minContextPercent": 0.16 },
+          "messageMode": { "minContextPercent": 0.16 }
         }
       },
-      // glm-5.3 reports a ~1M-token window. Even zai/* 16%/30% = 160K/300K is
-      // above the ~15% (~150K) point where long sessions degrade, and an
-      // observed 14h/273K-token session never crossed 16%. Lower ONLY glm-5.3
-      // within the zai family: 8%/15% (~80K/150K) so nudging starts early and
-      // auto-compress fires at the observed degradation point. Other zai/*
+      // GLM-5.3 and GLM-5.3-Flash expose ~1M-token windows. Use 8%/15%
+      // (~80K/~150K) as a conservative long-session policy while other zai/*
       // models keep 16%/30%.
       "zai/glm-5.3": {
         "compress": {
@@ -126,34 +143,68 @@ export const DEFAULT_PI_TOOLS_SUITE_CONFIG_JSONC = String.raw`{
           "messageMode": { "minContextPercent": 0.08 }
         }
       },
+      "zai/glm-5.3-flash": {
+        "compress": {
+          "minContextPercent": "8%",
+          "maxContextPercent": "15%",
+          "autoCandidates": { "minContextPercent": 0.08 },
+          "messageMode": { "minContextPercent": 0.08 }
+        }
+      },
       "antigravity/*sonnet*": {
         "compress": {
           "minContextPercent": "22%",
-          "maxContextPercent": "40%"
+          "maxContextPercent": "40%",
+          "autoCandidates": { "minContextPercent": 0.22 },
+          "messageMode": { "minContextPercent": 0.22 }
         }
       },
       "antigravity/gemini-3.1-pro*": {
         "compress": {
           "minContextPercent": "24%",
-          "maxContextPercent": "42%"
+          "maxContextPercent": "42%",
+          "autoCandidates": { "minContextPercent": 0.24 },
+          "messageMode": { "minContextPercent": 0.24 }
         }
       },
       "antigravity/gemini-3-flash*": {
         "compress": {
           "minContextPercent": "18%",
-          "maxContextPercent": "34%"
+          "maxContextPercent": "34%",
+          "autoCandidates": { "minContextPercent": 0.18 },
+          "messageMode": { "minContextPercent": 0.18 }
         }
       },
       "antigravity/gemini-2.5-flash*": {
         "compress": {
           "minContextPercent": "18%",
-          "maxContextPercent": "32%"
+          "maxContextPercent": "32%",
+          "autoCandidates": { "minContextPercent": 0.18 },
+          "messageMode": { "minContextPercent": 0.18 }
         }
       },
       "antigravity/antigravity-claude-opus-4-6-thinking": {
         "compress": {
           "minContextPercent": "26%",
-          "maxContextPercent": "44%"
+          "maxContextPercent": "44%",
+          "autoCandidates": { "minContextPercent": 0.26 },
+          "messageMode": { "minContextPercent": 0.26 }
+        }
+      },
+      "antigravity/antigravity-gemini-3.1-pro": {
+        "compress": {
+          "minContextPercent": "24%",
+          "maxContextPercent": "42%",
+          "autoCandidates": { "minContextPercent": 0.24 },
+          "messageMode": { "minContextPercent": 0.24 }
+        }
+      },
+      "antigravity/antigravity-gemini-3.8-flash": {
+        "compress": {
+          "minContextPercent": "18%",
+          "maxContextPercent": "34%",
+          "autoCandidates": { "minContextPercent": 0.18 },
+          "messageMode": { "minContextPercent": 0.18 }
         }
       }
     },
@@ -168,7 +219,8 @@ export const DEFAULT_PI_TOOLS_SUITE_CONFIG_JSONC = String.raw`{
       "autoCompress": {
         "enabled": false,
         "patience": 2,
-        "summarizerModel": ["zai/glm-5-turbo", "openai-codex/gpt-5.6-luna"],
+        "summarizerModel": ["zai/glm-5-turbo"],
+        "summarizerFallbackModels": ["openai-codex/gpt-5.6-luna"],
         "timeoutMs": 20000
       }
     }

package/external/pi-tools-suite/src/lib/project.ts

@@ -1,4 +1,4 @@
-import { existsSync, statSync } from "node:fs";
+import { accessSync, constants, existsSync, statSync } from "node:fs";
 import path from "node:path";
 
 export function directoryExists(file: string): boolean {
@@ -40,3 +40,38 @@ export function findIndexedProjectRoot(cwd: string): string | undefined {
 export function hasIndexedProjectRoot(cwd: string = process.cwd()): boolean {
 	return findIndexedProjectRoot(cwd) !== undefined;
 }
+
+export function commandAvailable(command: string, env: NodeJS.ProcessEnv = process.env): boolean {
+	const value = command.trim();
+	if (!value || value.includes("/") || value.includes("\\")) return false;
+	const pathValue = env.PATH ?? "";
+	const candidates = process.platform === "win32"
+		? [
+			value,
+			...(env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD")
+				.split(";")
+				.map((extension) => extension.trim())
+				.filter(Boolean)
+				.map((extension) => `${value}${extension.startsWith(".") ? extension : `.${extension}`}`),
+		]
+		: [value];
+	for (const directory of pathValue.split(path.delimiter)) {
+		if (!directory) continue;
+		for (const candidate of candidates) {
+			try {
+				accessSync(path.join(directory, candidate), constants.X_OK);
+				return true;
+			} catch {
+				// Continue through PATH without spawning a process or blocking on shell lookup.
+			}
+		}
+	}
+	return false;
+}
+
+export function hasAvailableIndexedProjectRoot(
+	cwd: string = process.cwd(),
+	env: NodeJS.ProcessEnv = process.env,
+): boolean {
+	return hasIndexedProjectRoot(cwd) && commandAvailable("idx", env);
+}

package/external/pi-tools-suite/src/model-tools/index.ts

@@ -15,8 +15,8 @@ import {
 import { realpath } from "node:fs/promises";
 import { resolve } from "node:path";
 import { Type, type TSchema } from "typebox";
-import { CODEX_ALIAS_TOOL_DESCRIPTIONS, REPO_DISCOVERY_TOOL_NAMES, claudeAliasToolDescriptions } from "../tool-descriptions";
-import { hasIndexedProjectRoot } from "../lib/project.js";
+import { REPO_DISCOVERY_TOOL_NAMES, claudeAliasToolDescriptions, codexAliasToolDescriptions } from "../tool-descriptions";
+import { hasAvailableIndexedProjectRoot } from "../lib/project.js";
 import { applyPatch } from "./apply-patch";
 import { isPathInside } from "./path-utils";
 import {
@@ -32,6 +32,7 @@ import {
 } from "./tool-args";
 
 const CLAUDE_ALIAS_TOOL_DESCRIPTIONS = claudeAliasToolDescriptions(false);
+const CODEX_ALIAS_TOOL_DESCRIPTIONS = codexAliasToolDescriptions(false);
 const CLAUDE_ALIAS_TOOLS = Object.values(CLAUDE_ALIAS_TOOL_DESCRIPTIONS).map((tool) => tool.name);
 const CODEX_ALIAS_TOOLS = ["read", ...Object.values(CODEX_ALIAS_TOOL_DESCRIPTIONS).map((tool) => tool.name)];
 const BUILTIN_TOOLS = ["read", "bash", "edit", "write", "grep", "find", "ls"] as const;
@@ -379,7 +380,8 @@ async function runShellAlias(
   return tool.execute(id, { command, timeout: timeoutSeconds(input) }, signal, onUpdate, ctx);
 }
 
-function registerCodexAliases(runtime: ModelToolsRuntime, pi: ExtensionAPI): void {
+function registerCodexAliases(runtime: ModelToolsRuntime, pi: ExtensionAPI, repoDiscovery: boolean): void {
+	const descriptions = codexAliasToolDescriptions(repoDiscovery);
   const shellParameters = Type.Object({
     command: Type.String({ description: "The shell script to execute in the user's default shell" }),
     workdir: Type.Optional(Type.String({ description: "Working directory" })),
@@ -390,7 +392,7 @@ function registerCodexAliases(runtime: ModelToolsRuntime, pi: ExtensionAPI): voi
 
   pi.registerTool(
     defineTool({
-      ...CODEX_ALIAS_TOOL_DESCRIPTIONS.shellCommand,
+      ...descriptions.shellCommand,
       parameters: shellParameters,
       renderCall: (args, theme, context) => renderShellAliasCall(runtime, args, theme, context),
       renderResult: (result, options, theme, context) => renderShellAliasResult(runtime, result, options, theme, context),
@@ -402,7 +404,7 @@ function registerCodexAliases(runtime: ModelToolsRuntime, pi: ExtensionAPI): voi
 
   pi.registerTool(
     defineTool({
-      ...CODEX_ALIAS_TOOL_DESCRIPTIONS.applyPatch,
+      ...descriptions.applyPatch,
       parameters: Type.Object({
         input: Type.String({ description: "Complete patch text: either a unified diff or a Begin Patch block" }),
       }),
@@ -457,8 +459,9 @@ function shouldPreserveSelection(env: NodeJS.ProcessEnv = process.env): boolean
 
 export default function modelTools(pi: ExtensionAPI, dependencies: Partial<ModelToolsDependencies> = {}): void {
   const runtime = createModelToolsRuntime(dependencies);
-  registerClaudeAliases(runtime, pi, hasIndexedProjectRoot());
-  registerCodexAliases(runtime, pi);
+  const repoDiscovery = hasAvailableIndexedProjectRoot();
+  registerClaudeAliases(runtime, pi, repoDiscovery);
+  registerCodexAliases(runtime, pi, repoDiscovery);
 
   let baseTools: string[] = [];