pi-ui-extend 1.0.41 → 1.0.45

package/external/pi-tools-suite/src/dcp/compression-progress.ts

@@ -27,6 +27,28 @@ export function outstandingCompressionTokens(state: DcpState, input: Compression
   return Math.max(0, previous.remainingTokens + growth + stricterTarget)
 }
 
+/**
+ * Bound one automatic recovery plan to what the *current* budget actually
+ * requires. `compressionProgress.remainingTokens` is deliberately cumulative:
+ * it follows content growth and stricter historical targets across callbacks.
+ * That debt is useful for progress accounting, but feeding the whole stale debt
+ * back into candidate sizing can make a later, much smaller capacity gap select
+ * an uneconomically huge range (and repeatedly fail with non-positive gain).
+ */
+export function compressionPlanningTokens(
+  state: DcpState,
+  input: CompressionProgressInput,
+  remainingTokens: number | undefined = outstandingCompressionTokens(state, input),
+): number {
+  const requested = Math.max(1, Math.ceil(input.requiredTokens))
+  if (
+    remainingTokens === undefined ||
+    remainingTokens <= 0 ||
+    state.compressionProgress?.kind !== input.kind
+  ) return requested
+  return Math.min(remainingTokens, requested)
+}
+
 /** Follow actual projection growth, not context callback/retry count. */
 export function trackCompressionProgress(
   state: DcpState,

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

@@ -10,6 +10,8 @@ import { parse as parseJsonc, type ParseError } from "jsonc-parser"
 export interface DcpConfig {
   enabled: boolean
   debug: boolean
+  /** Non-fatal loader diagnostics, e.g. removed settings that were ignored. */
+  issues?: string[]
   debugLog?: {
     maxBytes?: number
     maxBackups?: number
@@ -55,15 +57,21 @@ export interface DcpConfig {
      * session — disabled by default; opt in via config.
      */
     autoCompress: {
+      /** Gates autonomous firing only. Explicit `compress` calls may still use
+       * the summarizer settings below when their per-selection summary is omitted. */
       enabled: boolean
       /** Auto fallback is eligible after more than this many completed,
        * correlated opportunities with a delivered actionable reminder.
        * Failed calls and insufficient commits do not reset patience. */
       patience: number
-      /** Models to try, in order, when producing a model-generated summary.
+      /** Models to try, in order, for auto-compress and explicit generated summaries.
+       * The first entry is the primary summarizer. Additional entries remain
+       * supported for backward compatibility with the old inline fallback list.
        * Empty array → deterministic programmatic digest (no model call). */
       summarizerModel: string[]
-      /** Hard ceiling in ms for a single summarizer model call. */
+      /** Explicit fallback summarizers tried after `summarizerModel`, in order. */
+      summarizerFallbackModels: string[]
+      /** Hard ceiling in ms for a summarizer model call on either path. */
       timeoutMs: number
     }
   }
@@ -90,7 +98,7 @@ export interface DcpConfig {
   modelOverrides: Record<string, DcpConfigOverride>
 }
 
-export type DcpConfigOverride = DeepPartial<Omit<DcpConfig, "modelOverrides">>
+export type DcpConfigOverride = DeepPartial<Omit<DcpConfig, "modelOverrides" | "issues">>
 
 type DeepPartial<T> = T extends Array<infer U>
   ? Array<DeepPartial<U>>
@@ -105,6 +113,7 @@ type DeepPartial<T> = T extends Array<infer U>
 const DEFAULT_CONFIG: DcpConfig = {
   enabled: true,
   debug: false,
+  issues: [],
   manualMode: {
     enabled: false,
   },
@@ -139,6 +148,7 @@ const DEFAULT_CONFIG: DcpConfig = {
       enabled: false,
       patience: 2,
       summarizerModel: [],
+      summarizerFallbackModels: [],
       timeoutMs: 20000,
     },
   },
@@ -228,43 +238,75 @@ function readJsoncFile(filePath: string): Record<string, unknown> {
 /**
  * Return the nested DCP config from a shared pi-tools-suite config file.
  */
-function readDcpFromSuiteConfig(filePath: string): Record<string, unknown> {
+function readDcpFromSuiteConfig(filePath: string, issues: string[]): Record<string, unknown> {
   const raw = readJsoncFile(filePath)
   const dcp = raw["dcp"]
   if (dcp === null || typeof dcp !== "object" || Array.isArray(dcp)) return {}
-  return stripRemovedDcpKeys(dcp as Record<string, unknown>)
+  return stripRemovedDcpKeys(dcp as Record<string, unknown>, issues)
 }
 
-function stripRemovedDcpKeys(raw: Record<string, unknown>): Record<string, unknown> {
+const REMOVED_DCP_GUIDANCE: Record<string, string> = {
+  pruneNotification: "removed; pruning notifications are no longer configurable",
+  "manualMode.automaticStrategies": "removed; manual mode now has one explicit enabled flag",
+  "strategies.deduplication": "removed; no automatic replacement policy is currently mapped to this setting",
+  "strategies.purgeErrors": "removed; no automatic replacement policy is currently mapped to this setting",
+  "strategies.autoToolPruning": "removed; use explicit /dcp sweep or DCP compression/emergency policies instead",
+}
+
+function reportRemovedKey(issues: string[], prefix: string, key: string): void {
+  const fullKey = prefix ? `${prefix}.${key}` : key
+  const canonical = fullKey.replace(/^modelOverrides\.[^.]+\./, "")
+  const guidance = REMOVED_DCP_GUIDANCE[canonical] ?? "removed and ignored"
+  issues.push(`dcp.${fullKey} is ${guidance}.`)
+}
+
+function stripRemovedDcpKeys(
+  raw: Record<string, unknown>,
+  issues: string[],
+  prefix = "",
+): Record<string, unknown> {
   const cleaned = structuredClone(raw)
+  if (Object.prototype.hasOwnProperty.call(cleaned, "pruneNotification")) {
+    reportRemovedKey(issues, prefix, "pruneNotification")
+  }
   delete cleaned.pruneNotification
 
   const manualMode = cleaned.manualMode
   if (manualMode && typeof manualMode === "object" && !Array.isArray(manualMode)) {
+    if (Object.prototype.hasOwnProperty.call(manualMode, "automaticStrategies")) {
+      reportRemovedKey(issues, prefix, "manualMode.automaticStrategies")
+    }
     delete (manualMode as Record<string, unknown>).automaticStrategies
   }
 
   const strategies = cleaned.strategies
   if (strategies && typeof strategies === "object" && !Array.isArray(strategies)) {
     const record = strategies as Record<string, unknown>
-    delete record.deduplication
-    delete record.purgeErrors
-    delete record.autoToolPruning
+    for (const key of ["deduplication", "purgeErrors", "autoToolPruning"] as const) {
+      if (Object.prototype.hasOwnProperty.call(record, key)) {
+        reportRemovedKey(issues, prefix, `strategies.${key}`)
+      }
+      delete record[key]
+    }
   }
 
   const modelOverrides = cleaned.modelOverrides
   if (modelOverrides && typeof modelOverrides === "object" && !Array.isArray(modelOverrides)) {
     for (const [key, override] of Object.entries(modelOverrides as Record<string, unknown>)) {
       if (!override || typeof override !== "object" || Array.isArray(override)) continue
-      ;(modelOverrides as Record<string, unknown>)[key] = stripRemovedDcpKeys(override as Record<string, unknown>)
+      ;(modelOverrides as Record<string, unknown>)[key] = stripRemovedDcpKeys(
+        override as Record<string, unknown>,
+        issues,
+        prefix ? `${prefix}.modelOverrides.${key}` : `modelOverrides.${key}`,
+      )
     }
   }
 
   return cleaned
 }
 
-function mergeSuiteDcpConfig(config: DcpConfig, filePath: string): DcpConfig {
-  const raw = readDcpFromSuiteConfig(filePath)
+function mergeSuiteDcpConfig(config: DcpConfig, filePath: string, issues: string[]): DcpConfig {
+  const raw = readDcpFromSuiteConfig(filePath, issues)
   if (Object.keys(raw).length === 0) return config
   return deepMerge(config, raw as Partial<DcpConfig>)
 }
@@ -275,6 +317,55 @@ function normalizeModelKey(key: string | undefined): string | undefined {
   return trimmed.length > 0 ? trimmed : undefined
 }
 
+export function summarizerModelRefs(
+  settings: DcpConfig["compress"]["autoCompress"],
+): string[] {
+  const refs = [
+    ...(Array.isArray(settings.summarizerModel) ? settings.summarizerModel : []),
+    ...(Array.isArray(settings.summarizerFallbackModels) ? settings.summarizerFallbackModels : []),
+  ]
+  const seen = new Set<string>()
+  const result: string[] = []
+  for (const ref of refs) {
+    if (typeof ref !== "string") continue
+    const normalized = ref.trim()
+    if (!normalized || seen.has(normalized)) continue
+    seen.add(normalized)
+    result.push(normalized)
+  }
+  return result
+}
+
+function normalizeModelRefArray(value: unknown): string[] {
+  if (!Array.isArray(value)) return []
+  const seen = new Set<string>()
+  const result: string[] = []
+  for (const ref of value) {
+    if (typeof ref !== "string") continue
+    const normalized = ref.trim()
+    if (!normalized || seen.has(normalized)) continue
+    seen.add(normalized)
+    result.push(normalized)
+  }
+  return result
+}
+
+function normalizeResolvedModelArrays(config: DcpConfig): DcpConfig {
+  const autoCompress = config.compress?.autoCompress
+  if (!autoCompress || typeof autoCompress !== "object") return config
+  return {
+    ...config,
+    compress: {
+      ...config.compress,
+      autoCompress: {
+        ...autoCompress,
+        summarizerModel: normalizeModelRefArray(autoCompress.summarizerModel),
+        summarizerFallbackModels: normalizeModelRefArray(autoCompress.summarizerFallbackModels),
+      },
+    },
+  }
+}
+
 function escapeRegExp(text: string): string {
   return text.replace(/[|\\{}()[\]^$+?.]/g, "\\$&")
 }
@@ -378,17 +469,17 @@ export function resolveModelConfig(
   modelKeys: Array<string | undefined> = [],
 ): DcpConfig {
   const overrides = config.modelOverrides
-  if (!overrides || Object.keys(overrides).length === 0) return config
+  if (!overrides || Object.keys(overrides).length === 0) return normalizeResolvedModelArrays(config)
 
   const matches = matchingModelEntries(overrides, modelKeys)
-  if (matches.length === 0) return config
+  if (matches.length === 0) return normalizeResolvedModelArrays(config)
 
   let resolved = deepMerge(config, {})
   for (const [, override] of matches) {
     resolved = deepMerge(resolved, override as Partial<DcpConfig>)
   }
 
-  return resolved
+  return normalizeResolvedModelArrays(resolved)
 }
 
 // ---------------------------------------------------------------------------
@@ -407,9 +498,15 @@ export interface LoadConfigOptions {
 export function loadConfig(options: LoadConfigOptions = {}): DcpConfig {
   // Layer 1: defaults (deep clone so we never mutate the constant)
   let config: DcpConfig = structuredClone(DEFAULT_CONFIG)
+  const issues: string[] = []
 
   const homeDir = options.homeDir ?? os.homedir()
-  config = mergeSuiteDcpConfig(config, path.join(homeDir, ".config", "pi", "pi-tools-suite.jsonc"))
+  config = mergeSuiteDcpConfig(
+    config,
+    path.join(homeDir, ".config", "pi", "pi-tools-suite.jsonc"),
+    issues,
+  )
+  config.issues = issues
 
-  return config
+  return normalizeResolvedModelArrays(config)
 }

package/external/pi-tools-suite/src/dcp/conversation-index.ts

@@ -76,19 +76,43 @@ function stripDcpCarrierText(text: string): string {
   return stripStaleDcpMetadataLines(text)
 }
 
-function canonicalHashValue(value: unknown, seen = new WeakSet<object>()): unknown {
+const OMIT_JSON_OBJECT_VALUE = Symbol("omit-json-object-value")
+
+function canonicalHashValue(
+  value: unknown,
+  seen = new WeakSet<object>(),
+  arrayElement = false,
+): unknown | typeof OMIT_JSON_OBJECT_VALUE {
   if (value === null || typeof value === "string" || typeof value === "boolean") return value
-  if (typeof value === "number") return Number.isFinite(value) ? value : String(value)
+  // Exact membership is persisted in JSONL, so hash the value that can actually
+  // survive that persistence boundary. JSON.stringify serializes non-finite
+  // numbers as null, drops undefined/function/symbol object properties, and
+  // converts those values to null when they occupy an array slot. Encoding an
+  // in-memory-only sentinel here made otherwise unchanged toolResult.details
+  // fail exact replay after restart.
+  if (typeof value === "number") return Number.isFinite(value) ? value : null
   if (typeof value === "bigint") return `${value}n`
-  if (typeof value === "undefined") return "[undefined]"
-  if (typeof value === "function" || typeof value === "symbol") return String(value)
-  if (Array.isArray(value)) return value.map((item) => canonicalHashValue(item, seen))
+  if (typeof value === "undefined" || typeof value === "function" || typeof value === "symbol") {
+    return arrayElement ? null : OMIT_JSON_OBJECT_VALUE
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => {
+      const canonical = canonicalHashValue(item, seen, true)
+      return canonical === OMIT_JSON_OBJECT_VALUE ? null : canonical
+    })
+  }
   if (typeof value === "object") {
     if (seen.has(value as object)) return "[cycle]"
+    const toJSON = (value as { toJSON?: unknown }).toJSON
+    if (typeof toJSON === "function") {
+      const serialized = (toJSON as () => unknown).call(value)
+      return canonicalHashValue(serialized, seen, arrayElement)
+    }
     seen.add(value as object)
     const output: Record<string, unknown> = {}
     for (const key of Object.keys(value as Record<string, unknown>).sort()) {
-      output[key] = canonicalHashValue((value as Record<string, unknown>)[key], seen)
+      const canonical = canonicalHashValue((value as Record<string, unknown>)[key], seen, false)
+      if (canonical !== OMIT_JSON_OBJECT_VALUE) output[key] = canonical
     }
     seen.delete(value as object)
     return output
@@ -106,14 +130,17 @@ export function canonicalMessageHash(message: any): string {
   if (message && typeof message === "object") {
     for (const key of Object.keys(message).sort()) {
       if (IDENTITY_ONLY_MESSAGE_KEYS.has(key)) continue
-      canonical[key] = key === "content"
+      const value = key === "content"
         ? canonicalContentForMessageHash(message)
         : canonicalHashValue(message[key])
+      if (value !== OMIT_JSON_OBJECT_VALUE) canonical[key] = value
     }
   } else {
-    canonical.value = canonicalHashValue(message)
+    const value = canonicalHashValue(message)
+    if (value !== OMIT_JSON_OBJECT_VALUE) canonical.value = value
   }
-  return createHash("sha256").update(JSON.stringify(canonicalHashValue(canonical))).digest("hex")
+  const normalized = canonicalHashValue(canonical)
+  return createHash("sha256").update(JSON.stringify(normalized === OMIT_JSON_OBJECT_VALUE ? {} : normalized)).digest("hex")
 }
 
 const CANONICAL_HASH_RE = /^[a-f0-9]{64}$/i

package/external/pi-tools-suite/src/dcp/diagnostics.ts

@@ -0,0 +1,41 @@
+import type { DcpConfig } from "./config.js";
+import { modelKeysFromContext } from "./config.js";
+import type { DcpState } from "./state.js";
+import { estimateMessageTokens, getActiveSummaryTokenEstimate, resolveContextThresholds } from "./pruner-metadata.js";
+import { planDcpBudget } from "./progress-controller.js";
+
+/** Scalar-only diagnostic snapshot; never stores raw messages or credentials.
+ * These records are observational, never journal/recovery authority. */
+export function dcpRequestSnapshot(config: DcpConfig, state: DcpState, model: any,
+  usage: { tokens?: number | null; contextWindow?: number } | undefined,
+  raw: any[], projected: any[], reason: string) {
+  const contextWindow = Number.isFinite(model?.contextWindow) && model.contextWindow > 0
+    ? model.contextWindow : usage?.contextWindow;
+  const rawTokens = raw.reduce((sum, message) => sum + estimateMessageTokens(message), 0);
+  const projectedTokens = projected.reduce((sum, message) => sum + estimateMessageTokens(message), 0);
+  const thresholds = resolveContextThresholds(config, modelKeysFromContext({ model } as any), contextWindow);
+  const budget = contextWindow ? planDcpBudget({
+    providerUsageTokens: usage?.tokens, repoProjectedTokens: projectedTokens, contextWindow,
+    reservedOutputTokens: model?.maxTokens ?? 0, reservedToolTokens: 0,
+    maxContextPercent: thresholds.maxContextPercent,
+    hardContextPercent: config.strategies.emergencyCurrentTurnPruning.hardContextPercent,
+    targetContextPercent: Math.min(config.strategies.emergencyCurrentTurnPruning.targetContextPercent, thresholds.maxContextPercent * 0.9),
+    summaryBufferEnabled: config.compress.summaryBuffer,
+    activeSummaryTokens: getActiveSummaryTokenEstimate(state), summaryBufferMaxBonusRatio: 0.05,
+    estimatorMarginTokens: Math.max(256, Math.ceil(contextWindow * 0.0025)),
+  }) : undefined;
+  const routineTokens = contextWindow ? thresholds.minContextPercent * contextWindow : undefined;
+  let pressure = "unknown";
+  if (budget && routineTokens !== undefined) {
+    pressure = budget.capacityExceeded ? "over capacity" : budget.hardPressure ? "hard" : budget.pressured ? "strong"
+      : budget.projectedBeforeTokens > routineTokens ? "routine" : "below routine threshold";
+  }
+  return { model: model?.provider && model?.id ? `${model.provider}/${model.id}` : undefined,
+    contextWindow, rawTokens, projectedTokens, inputCapacityTokens: budget?.inputCapacityTokens,
+    reservedOutputTokens: budget?.reservedOutputTokens, routineTokens, strongTokens: budget?.softHeadroomTokens,
+    hardTokens: budget?.hardHeadroomTokens, enabled: config.enabled, manualMode: state.manualMode,
+    autoEnabled: config.compress.autoCompress.enabled, ignored: state.consecutiveIgnoredNudges,
+    routineProjectedTokens: budget?.projectedBeforeTokens ?? projectedTokens,
+    routineUsageAdjustmentTokens: 0,
+    pressure, reason, createdAt: Date.now() };
+}

package/external/pi-tools-suite/src/dcp/fresh-tool-results.ts

@@ -0,0 +1,38 @@
+/**
+ * Proof that a tool result was produced locally in this epoch and has never
+ * belonged to an attempted provider prefix. This is NOT provider-seen evidence:
+ * failed/ambiguous sends consume freshness too. Never persist or rehydrate it.
+ */
+export class FreshToolResultTracker {
+  private ready = false;
+  private readonly pending = new Map<string, string>();
+  private readonly fresh = new Set<string>();
+
+  reset(): void {
+    this.ready = false;
+    this.pending.clear();
+    this.fresh.clear();
+  }
+
+  /** Call before every send, not after successful completion. */
+  beforeProviderRequest(): void {
+    this.reset();
+    this.ready = true;
+  }
+
+  toolCall(id: string, name: string, alreadyKnown: boolean): void {
+    // Resumed/in-flight old calls and reused IDs cannot create a freshness grant.
+    if (!this.ready || alreadyKnown) return;
+    this.pending.set(id, name);
+  }
+
+  toolResult(id: string, name: string): void {
+    const expectedName = this.pending.get(id);
+    this.pending.delete(id);
+    if (expectedName === name) this.fresh.add(id);
+  }
+
+  get eligibleIds(): ReadonlySet<string> {
+    return this.fresh;
+  }
+}