pi-ui-extend 1.0.42 → 1.0.45

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

@@ -128,6 +128,16 @@ function validateExactBlock(value: unknown): asserts value is CompressionBlock {
       throw new DcpJournalError(`DCP journal block b${value.id} has invalid ${key}`);
     }
   }
+  if (value.commitMetrics !== undefined) {
+    const m = value.commitMetrics;
+    if (!isRecord(m) || typeof m.operationId !== "string" || !m.operationId ||
+      !["manual", "auto", "consolidation"].includes(m.kind as string) ||
+      !finiteNonNegativeInteger(m.beforeTokens) || !finiteNonNegativeInteger(m.afterTokens) ||
+      !finiteNonNegativeInteger(m.netGainTokens) || m.netGainTokens <= 0 ||
+      m.beforeTokens - m.afterTokens !== m.netGainTokens) {
+      throw new DcpJournalError(`DCP journal block b${value.id} has invalid commit metrics`);
+    }
+  }
   for (const key of ["sourceMembers", "mutationMembers"] as const) {
     const members = value[key];
     if (!Array.isArray(members) || members.length === 0) {
@@ -438,13 +448,125 @@ function journalBranch(ctx: ExtensionContext): unknown[] {
   }
 }
 
+function indexBranchParents(entries: readonly unknown[], requireFullChain: boolean): Map<string, string | null> | undefined {
+  const parents = new Map<string, string | null>();
+  let previousId: string | null = null;
+  for (const entry of entries) {
+    if (!isRecord(entry) || typeof entry.id !== "string" || !entry.id
+      || parents.has(entry.id)) return undefined;
+    let parentId: string | null = null;
+    if (entry.parentId !== null) {
+      if (typeof entry.parentId !== "string" || !entry.parentId) return undefined;
+      parentId = entry.parentId;
+    }
+    if (requireFullChain && parentId !== previousId) return undefined;
+    parents.set(entry.id, parentId);
+    previousId = entry.id;
+  }
+  return parents;
+}
+
+/**
+ * getBranch() on Pix's lazy manager is a JSONL presentation tail: it may omit
+ * older ancestors AND interleave abandoned branches. Do not "simplify" this
+ * into a positional prefix/suffix comparison or an ID-membership test.
+ *
+ * Walk parentId from the captured current leaf. Only the full read may supply
+ * ancestors missing from the tail; overlapping IDs must have identical parents
+ * (SDK entry identities/parent links are immutable). Both the old leaf and the
+ * read tip must lie on that walk. A side-branch tip merely present in the tail
+ * is not evidence. Missing links/cycles/conflicts deny the retry.
+ *
+ * This proves permission to re-read, NOT a publishable merged snapshot. Never
+ * return the tail/union as history or hydrate synchronously to validate it.
+ * Contract + counterexample: specs/dcp-statistics.md#lazy-tail-retry-invariant.
+ */
+function readSnapshotFollowsCurrentBranch(
+  entries: readonly unknown[],
+  currentEntries: readonly unknown[],
+  previousLeafId: string,
+  currentLeafId: string,
+): boolean {
+  const readParents = indexBranchParents(entries, true);
+  const currentParents = indexBranchParents(currentEntries, false);
+  if (!readParents?.has(previousLeafId) || !currentParents?.has(currentLeafId)) return false;
+
+  const readTipId = (entries.at(-1) as { id: string }).id;
+  const visited = new Set<string>();
+  let cursor: string | null = currentLeafId;
+  let reachedPrevious = false;
+  let reachedReadTip = false;
+  while (cursor !== null) {
+    if (visited.has(cursor)) return false;
+    visited.add(cursor);
+    const currentParent = currentParents.get(cursor);
+    const readParent = readParents.get(cursor);
+    if (currentParent !== undefined && readParent !== undefined && currentParent !== readParent) return false;
+    // An absent old ancestor may be supplied by the full read, but a missing
+    // new descendant cannot be guessed. Null is a root, not a missing value.
+    const parent = currentParent !== undefined ? currentParent : readParent;
+    if (parent === undefined) return false;
+    reachedPrevious ||= cursor === previousLeafId;
+    reachedReadTip ||= cursor === readTipId;
+    cursor = parent;
+  }
+  return reachedPrevious && reachedReadTip;
+}
+
 export async function readDcpJournalBranch(ctx: ExtensionContext): Promise<unknown[]> {
   const manager = ctx.sessionManager as any;
-  if (typeof manager.readFullBranchEntries === "function") {
-    const entries = await manager.readFullBranchEntries();
-    return Array.isArray(entries) ? entries : [];
+  const sessionId = manager.getSessionId?.();
+  const hasLeafIdentity = typeof manager.getLeafId === "function";
+  const readFullBranch = typeof manager.readFullBranchEntries === "function"
+    ? () => manager.readFullBranchEntries()
+    : undefined;
+
+  // Lazy full-history reads yield to the event loop. A normal append on the
+  // same active branch (for example, tool results arriving while a reloaded
+  // runtime is replaying its journal) advances the leaf without changing the
+  // branch owner. Retry that transient race so startup does not permanently
+  // block DCP. A real branch move/fork, owner replacement, or a branch that
+  // keeps moving still fails closed.
+  const maxAttempts = readFullBranch ? 3 : 1;
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    const leafId = manager.getLeafId?.();
+    const entries = readFullBranch ? await readFullBranch() : manager.getBranch();
+    if (ctx.sessionManager !== manager || manager.getSessionId?.() !== sessionId) {
+      throw new DcpJournalError("DCP branch changed during history read; rebuild context");
+    }
+    if (!Array.isArray(entries)) throw new DcpJournalError("DCP full branch is unavailable");
+    // A presentation cursor is not a complete SDK branch, even if it contains
+    // recent users or journal deltas. Never silently initialize from that tail.
+    if (entries[0]?.parentId != null) throw new DcpJournalError("DCP received an incomplete branch (presentation tail)");
+
+    const currentLeafId = manager.getLeafId?.();
+    if (currentLeafId === leafId) {
+      if (hasLeafIdentity) {
+        const readLeafId = entries.at(-1)?.id;
+        if ((leafId == null && entries.length > 0) || (leafId != null && readLeafId !== leafId)) {
+          throw new DcpJournalError("DCP branch changed during history read; rebuild context");
+        }
+      }
+      return entries;
+    }
+
+    let sameBranchAdvance = false;
+    if (leafId && currentLeafId) {
+      try {
+        const currentEntries = manager.getBranch();
+        sameBranchAdvance = Array.isArray(currentEntries)
+          && manager.getLeafId?.() === currentLeafId
+          && readSnapshotFollowsCurrentBranch(entries, currentEntries, leafId, currentLeafId);
+      } catch {
+        sameBranchAdvance = false;
+      }
+    }
+    if (!sameBranchAdvance || attempt === maxAttempts - 1) {
+      throw new DcpJournalError("DCP branch changed during history read; rebuild context");
+    }
   }
-  return journalBranch(ctx);
+
+  throw new DcpJournalError("DCP branch changed during history read; rebuild context");
 }
 
 function restoreLeafAfterAppendFailure(ctx: ExtensionContext, previousLeafId: string | null | undefined): void {

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

@@ -15,7 +15,8 @@ export type DcpBlockedReason =
   | "summarizer-unavailable"
   | "non-positive-gain"
   | "missing-source"
-  | "budget-exhausted";
+  | "budget-exhausted"
+  | "auto-compress-failed";
 
 export interface DcpBlockedReasonInput {
   pressured: boolean;

package/external/pi-tools-suite/src/dcp/pruner-candidates.ts

@@ -102,8 +102,17 @@ export interface CompressionCandidateSelectionOptions {
   requiredSavingsTokens?: number;
   /** Conservative estimator margin added to the required source size. */
   estimatorMarginTokens?: number;
+  /**
+   * Whether an automatic candidate may fold already-compressed block
+   * placeholders into a new block. Capacity-recovery plans disable this so an
+   * economical existing summary is not expanded again while rescuing raw tail
+   * growth. Manual/non-pressure consolidation keeps the historical default.
+   */
+  allowCompressionBlocks?: boolean;
 }
 
+const MIN_AUTOMATIC_BLOCK_CONSOLIDATION = 8;
+
 function selectOldestSafePrefix(
   boundaries: CandidateBoundary[],
   state: DcpState,
@@ -176,7 +185,9 @@ export function detectCompressionCandidate(
   if (!settings.enabled) return null;
   if (contextPercent < settings.minContextPercent) return null;
 
-  const boundaries = buildCandidateBoundaries(messages, _state, { allowBlocks: true });
+  const boundaries = buildCandidateBoundaries(messages, _state, {
+    allowBlocks: options?.allowCompressionBlocks ?? true,
+  });
 
   if (boundaries.length < settings.minMessages) return null;
 
@@ -224,6 +235,83 @@ export function detectCompressionCandidate(
   };
 }
 
+/**
+ * Periodically fold a contiguous prefix of already-compressed summaries into
+ * one summary. Raw-tail recovery deliberately excludes bN blocks so it cannot
+ * recreate the incident's b1 -> b2 -> ... ladder; without a separate bounded
+ * consolidation step, however, a marathon turn can accumulate dozens of small
+ * active summaries until summary overhead itself fills the provider window.
+ *
+ * This detector is intentionally block-only: every selected boundary must be a
+ * synthetic block message and physically adjacent in the provider projection.
+ * Requiring a batch of blocks amortizes the intentional prefix rewrite and
+ * prevents one-old-summary-plus-a-tiny-tail recompression on every turn.
+ */
+export function detectCompressionBlockConsolidationCandidate(
+  messages: any[],
+  state: DcpState,
+  config: DcpConfig,
+  options?: CompressionCandidateSelectionOptions,
+): CompressionCandidate | null {
+  const settings = config.compress.autoCandidates;
+  const boundaries = buildCandidateBoundaries(messages, state, { allowBlocks: true });
+  const minimumBlocks = MIN_AUTOMATIC_BLOCK_CONSOLIDATION;
+  const requiredSavings = Math.max(0, Math.floor(options?.requiredSavingsTokens ?? 0));
+  const estimatorMargin = Math.max(0, Math.floor(options?.estimatorMarginTokens ?? 0));
+  const targetSourceTokens = Math.max(settings.minTokens, requiredSavings + estimatorMargin);
+
+  let run: CandidateBoundary[] = [];
+  const chooseRun = (candidateRun: CandidateBoundary[]): CandidateBoundary[] | null => {
+    if (candidateRun.length < minimumBlocks) return null;
+    let selectedTokens = 0;
+    let selectedEnd = minimumBlocks - 1;
+    for (let index = 0; index < candidateRun.length; index++) {
+      selectedTokens += candidateRun[index]!.tokenEstimate;
+      if (index + 1 >= minimumBlocks && selectedTokens >= targetSourceTokens) {
+        selectedEnd = index;
+        break;
+      }
+      selectedEnd = index;
+    }
+    return candidateRun.slice(0, Math.max(minimumBlocks, selectedEnd + 1));
+  };
+
+  for (const boundary of boundaries) {
+    const previous = run.at(-1);
+    const continuesBlockRun = boundary.blockId !== undefined &&
+      (!previous || boundary.messageIndex === previous.messageIndex + 1);
+    if (continuesBlockRun) {
+      run.push(boundary);
+      continue;
+    }
+    const selected = chooseRun(run);
+    if (selected) {
+      const estimatedTokens = selected.reduce((sum, item) => sum + item.tokenEstimate, 0);
+      return {
+        startId: selected[0]!.id,
+        endId: selected[selected.length - 1]!.id,
+        messageCount: selected.length,
+        estimatedTokens,
+        includedBlockIds: selected.map((item) => item.blockId!),
+        reason: `automatic block-only consolidation of ${selected.length} adjacent summaries`,
+      };
+    }
+    run = boundary.blockId !== undefined ? [boundary] : [];
+  }
+
+  const selected = chooseRun(run);
+  if (!selected) return null;
+  const estimatedTokens = selected.reduce((sum, item) => sum + item.tokenEstimate, 0);
+  return {
+    startId: selected[0]!.id,
+    endId: selected[selected.length - 1]!.id,
+    messageCount: selected.length,
+    estimatedTokens,
+    includedBlockIds: selected.map((item) => item.blockId!),
+    reason: `automatic block-only consolidation of ${selected.length} adjacent summaries`,
+  };
+}
+
 /**
  * Emergency-only range candidate for marathon turns.
  *
@@ -257,7 +345,9 @@ export function detectEmergencyCompressionCandidate(
   if (!emergencySettings.enabled) return null;
   if (contextPercent <= maxContextPercent) return null;
 
-  const boundaries = buildCandidateBoundaries(messages, state, { allowBlocks: true });
+  const boundaries = buildCandidateBoundaries(messages, state, {
+    allowBlocks: options?.allowCompressionBlocks ?? true,
+  });
   if (boundaries.length < settings.minMessages) return null;
 
   let latestUserIndex = -1;

package/external/pi-tools-suite/src/dcp/pruner-nudge.ts

@@ -32,31 +32,51 @@ function nudgeTypeLabel(type: DcpNudgeType): string {
 
 function isRealAnchorCandidate(msg: any): boolean {
   const role = msg?.role ?? "";
-  if (role !== "user" && role !== "assistant") return false;
+  if (role !== "user" && role !== "toolResult") return false;
   return msg?._dcpOrigin !== "block" && msg?._dcpOrigin !== "dcp-control";
 }
 
-function findAnchorMessage(messages: any[]): { msg: any; index: number; stableId: string; timestamp: number; role: string } | null {
+function findAnchorMessage(messages: any[], freshToolResultIds?: ReadonlySet<string>): { msg: any; index: number; stableId: string; timestamp: number; role: string } | null {
   const stableKeys = stableMessageKeys(messages);
-  // A reminder may only be introduced on a fresh user tail. If assistant/tool
-  // traffic already follows that user message then it has already belonged to
-  // an earlier provider prefix; editing it now would invalidate that prefix.
+  // Only append to a fresh tail; never edit an earlier user/assistant prefix.
+  // Tool-result freshness requires a positive local lifecycle grant, not the
+  // absence of successful provider evidence (which is unknown after restart).
   for (let i = messages.length - 1; i >= 0; i--) {
     const msg = messages[i];
     if (msg?._dcpOrigin === "dcp-control") continue;
-    if (msg?.role !== "user" || !isRealAnchorCandidate(msg) || !Number.isFinite(msg.timestamp)) return null;
+    if (!isRealAnchorCandidate(msg) || !Number.isFinite(msg.timestamp)) return null;
+    if (msg.role === "toolResult") {
+      if (!freshToolResultIds?.has(msg.toolCallId)) return null;
+      // A duplicate/reused call ID is not an unambiguous fresh carrier.
+      if (messages.filter((item) => item?.role === "toolResult" && item.toolCallId === msg.toolCallId).length !== 1) return null;
+    }
     return { msg, index: i, stableId: stableKeys[i]!, timestamp: msg.timestamp, role: msg.role };
   }
 
   return null;
 }
 
-export function hasCacheSafeNudgeCarrier(messages: any[]): boolean {
-  return findAnchorMessage(messages) !== null;
+export function hasCacheSafeNudgeCarrier(
+  messages: any[],
+  freshToolResultIds?: ReadonlySet<string>,
+  anchors: readonly DcpNudgeAnchor[] = [],
+): boolean {
+  if (findAnchorMessage(messages, freshToolResultIds) !== null) return true;
+  // A previously published reminder remains deliverable without editing its
+  // carrier. Losing the grant to create a NEW reminder on a provider attempt
+  // must not make retries bypass the completed-opportunity patience policy.
+  const stableKeys = stableMessageKeys(messages);
+  return anchors.some((anchor) => typeof anchor.renderedReminder === "string" &&
+    anchor.renderedReminder.length > 0 &&
+    messages.some((message, index) => anchorMatchesMessage(anchor, message, stableKeys[index]!)));
 }
 
 function anchorMatchesMessage(anchor: DcpNudgeAnchor, msg: any, stableKey: string): boolean {
-  if (anchor.anchorStableId && stableKey === anchor.anchorStableId) return true;
+  if (!isRealAnchorCandidate(msg) || msg.role !== anchor.anchorRole) return false;
+  if (anchor.anchorStableId) return stableKey === anchor.anchorStableId;
+  // Legacy user anchors may be timestamp-only. Tool anchors must never rebind
+  // to another parallel result that happens to share their timestamp.
+  if (msg.role === "toolResult") return false;
   return msg?.timestamp === anchor.anchorTimestamp;
 }
 
@@ -78,24 +98,8 @@ function appendTextToMessage(msg: any, text: string): void {
     return;
   }
 
-  const textBlock = { type: "text", text: suffix };
-  if (msg.role !== "assistant") {
-    msg.content = [...msg.content, textBlock];
-    return;
-  }
-
-  // Keep provider ordering constraints: assistant text must appear before
-  // toolCall blocks for models that enforce text/thinking/tool_use ordering.
-  const firstToolCallIdx = msg.content.findIndex((block: any) => block?.type === "toolCall");
-  if (firstToolCallIdx === -1) {
-    msg.content = [...msg.content, textBlock];
-  } else {
-    msg.content = [
-      ...msg.content.slice(0, firstToolCallIdx),
-      textBlock,
-      ...msg.content.slice(firstToolCallIdx),
-    ];
-  }
+  // Only user/tool-result carriers reach here. Assistant items are immutable.
+  msg.content = [...msg.content, { type: "text", text: suffix }];
 }
 
 function insertBeforeReminderClose(reminder: string, detail: string): string {
@@ -174,7 +178,7 @@ export function upsertNudgeAnchor(
   messages: any[],
   state: DcpState,
   type: DcpNudgeType,
-  options: { contextPercent?: number; renderedReminder?: string } = {},
+  options: { contextPercent?: number; renderedReminder?: string; freshToolResultIds?: ReadonlySet<string> } = {},
 ): { anchor: DcpNudgeAnchor | null; created: boolean; updated: boolean } {
   const stableKeys = stableMessageKeys(messages);
   let existing: DcpNudgeAnchor | null = null;
@@ -198,11 +202,10 @@ export function upsertNudgeAnchor(
     state.lastNudge = undefined;
   }
 
-  const target = findAnchorMessage(messages);
+  const target = findAnchorMessage(messages, options.freshToolResultIds);
   if (!target) {
-    // Mid-turn reminder creation is deliberately deferred rather than
-    // synthesizing an ephemeral tail message that would disappear on the next
-    // provider continuation and break prefix equality.
+    // No positively fresh carrier: do not synthesize a disappearing tail or
+    // reinterpret unknown historical exposure as permission to edit history.
     return { anchor: null, created: false, updated: false };
   }
 
@@ -263,7 +266,7 @@ export function applyAnchoredNudges(
   const reminder = selected.anchor.renderedReminder ?? render(selected.anchor);
   if (materializedReminder) selected.anchor.renderedReminder = reminder;
   const anchorMessage = messages[selected.index];
-  if (anchorMessage?.role !== "user") {
+  if (!isRealAnchorCandidate(anchorMessage)) {
     state.nudgeAnchors = [];
     state.lastNudge = undefined;
     return { rendered: false, stateChanged: true };

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

@@ -30,6 +30,7 @@ export {
   markToolPruned,
 } from "./pruner-tools.js";
 export {
+  detectCompressionBlockConsolidationCandidate,
   detectCompressionCandidate,
   detectEmergencyCompressionCandidate,
   detectMessageCompressionCandidates,

package/external/pi-tools-suite/src/dcp/routine-pressure.ts

@@ -0,0 +1,86 @@
+import { canonicalMessageHash } from "./conversation-index.js";
+import type { CompressionBlock } from "./state.js";
+
+interface ProjectionFrame {
+  owner: string;
+  avoidedTokens: number;
+  blocks: string;
+}
+
+export interface RoutinePressureEstimate {
+  projectedTokens: number;
+  adjustmentTokens: number;
+}
+
+function usableUsage(message: any): boolean {
+  if (message?.role !== "assistant" || ["error", "aborted"].includes(message.stopReason)) return false;
+  const usage = message.usage;
+  if (!usage) return false;
+  const tokens = usage.totalTokens || [usage.input, usage.output, usage.cacheRead, usage.cacheWrite]
+    .reduce((sum, value) => sum + (typeof value === "number" && Number.isFinite(value) ? value : 0), 0);
+  return typeof tokens === "number" && Number.isFinite(tokens) && tokens > 0;
+}
+
+function blockVersion(blocks: readonly CompressionBlock[]): string {
+  return blocks.filter((block) => block.active).map((block) => block.id).join(",");
+}
+
+/**
+ * Runtime-only calibration for ROUTINE nudges, never a provider-send budget.
+ * The SDK's last assistant usage still includes history removed by a later DCP
+ * rewrite. Subtract only the additional locally measured raw/projected delta
+ * since that assistant's correlated request. This keeps provider overhead and
+ * tail growth, and avoids counting older compression twice. Uncorrelated usage
+ * and lifecycle changes fall back to the existing conservative estimate.
+ */
+export class RoutinePressureTracker {
+  private prepared: ProjectionFrame | undefined;
+  private pending: ProjectionFrame | undefined;
+  private sample: (ProjectionFrame & { hash: string; timestamp: unknown }) | undefined;
+
+  reset(): void {
+    this.prepared = undefined;
+    this.pending = undefined;
+    this.sample = undefined;
+  }
+
+  prepare(owner: string, rawTokens: number, projectedTokens: number, blocks: readonly CompressionBlock[]): void {
+    this.prepared = { owner, avoidedTokens: rawTokens - projectedTokens, blocks: blockVersion(blocks) };
+  }
+
+  beforeRequest(): void {
+    this.pending = this.prepared;
+  }
+
+  complete(message: any, correlated: boolean): void {
+    const pending = this.pending;
+    this.pending = undefined;
+    if (!usableUsage(message)) return;
+    this.sample = correlated && pending && typeof message.timestamp === "number" && Number.isFinite(message.timestamp)
+      ? { ...pending, hash: canonicalMessageHash(message), timestamp: message.timestamp }
+      : undefined;
+  }
+
+  estimate(owner: string, nativeTokens: number | null | undefined, raw: readonly any[],
+    rawTokens: number, projectedTokens: number, blocks: readonly CompressionBlock[]): RoutinePressureEstimate {
+    const fallback = Math.max(projectedTokens, nativeTokens ?? 0);
+    const unchanged = { projectedTokens: fallback, adjustmentTokens: 0 };
+    const sample = this.sample;
+    if (!sample || sample.owner !== owner || nativeTokens === null || nativeTokens === undefined) return unchanged;
+    const version = blockVersion(blocks);
+    if (!version || version === sample.blocks) return unchanged;
+    // Confirm the SDK is still based on this exact successful assistant, not
+    // an unrelated/new response, failed stream or a sample from another owner.
+    let latest: any;
+    for (let index = raw.length - 1; index >= 0; index--) {
+      if (usableUsage(raw[index])) {
+        latest = raw[index];
+        break;
+      }
+    }
+    if (!latest || latest.timestamp !== sample.timestamp || canonicalMessageHash(latest) !== sample.hash) return unchanged;
+    const newSavings = Math.max(0, rawTokens - projectedTokens - sample.avoidedTokens);
+    const adjusted = Math.max(projectedTokens, nativeTokens - newSavings);
+    return { projectedTokens: adjusted, adjustmentTokens: fallback - adjusted };
+  }
+}

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

@@ -153,6 +153,15 @@ export interface CompressionBlock {
   active: boolean
   /** Token estimate for the summary text itself */
   summaryTokenEstimate: number
+  /** One record per successful transaction (on its first block), never on retries.
+   * Optional for older journal blocks; absence means unmeasured, not zero gain. */
+  commitMetrics?: {
+    operationId: string
+    kind: "manual" | "auto" | "consolidation"
+    beforeTokens: number
+    afterTokens: number
+    netGainTokens: number
+  }
   /** Wall-clock time the block was created (Date.now()) */
   createdAt: number
   /** Older compression blocks subsumed by this block during roll-up. */

package/external/pi-tools-suite/src/dcp/statistics.d.ts

@@ -0,0 +1,8 @@
+export interface DcpStatisticsInput {
+  branch?: readonly any[];
+  model?: any;
+  usage?: any;
+  historyStatus?: "full" | "unavailable";
+}
+export function collectDcpStatistics(input: DcpStatisticsInput): any;
+export function formatDcpStatistics(input: DcpStatisticsInput): string;