pi-ui-extend 1.0.39 → 1.0.41

package/external/pi-tools-suite/src/dcp/shadow-plan.ts

@@ -0,0 +1,127 @@
+import type { DcpConfig } from "./config.js"
+import { applyPruning, detectCompressionCandidate, detectEmergencyCompressionCandidate, detectMessageCompressionCandidates, getActiveSummaryTokenEstimate, resolveContextThresholds } from "./pruner.js"
+import { estimateMessageTokens } from "./pruner-metadata.js"
+import type { CompressionCandidate, MessageCompressionCandidate } from "./pruner-types.js"
+import { planDcpBudget, type DcpBudgetPlan } from "./progress-controller.js"
+import type { DcpState } from "./state.js"
+
+export interface DcpShadowPlanInput {
+  messages: any[]
+  state: DcpState
+  config: DcpConfig
+  contextWindow: number
+  providerUsageTokens?: number | null
+  reservedOutputTokens?: number
+  reservedToolTokens?: number
+  modelKeys?: string[]
+}
+
+export interface DcpShadowPlanResult {
+  projectedTokens: number
+  contextPercent: number
+  budget: DcpBudgetPlan
+  routineCandidate: CompressionCandidate | null
+  emergencyCandidate: CompressionCandidate | null
+  messageCandidates: MessageCompressionCandidate[]
+  projectedMessageCount: number
+}
+
+function cloneDcpState(state: DcpState): DcpState {
+  return {
+    ...state,
+    toolCalls: new Map([...state.toolCalls].map(([id, record]) => [id, {
+      ...record,
+      inputArgs: { ...(record.inputArgs ?? {}) },
+    }])),
+    prunedToolIds: new Set(state.prunedToolIds),
+    prunedToolReasons: new Map(state.prunedToolReasons),
+    providerSeenToolIds: new Set(state.providerSeenToolIds),
+    compressionBlocks: state.compressionBlocks.map((block) => ({
+      ...block,
+      coveredBlockIds: block.coveredBlockIds ? [...block.coveredBlockIds] : undefined,
+      protectedFragments: block.protectedFragments?.map((fragment) => ({ ...fragment })),
+      sourceCoverage: block.sourceCoverage ? { ...block.sourceCoverage } : undefined,
+    })),
+    messageIdSnapshot: new Map(state.messageIdSnapshot),
+    messageMetaSnapshot: new Map([...state.messageMetaSnapshot].map(([id, meta]) => [id, {
+      ...meta,
+      toolCallIds: meta.toolCallIds ? [...meta.toolCallIds] : undefined,
+    }])),
+    conversationIndexSnapshot: state.conversationIndexSnapshot.map((entry) => ({
+      ...entry,
+      toolCallIds: entry.toolCallIds ? [...entry.toolCallIds] : undefined,
+    })),
+    messageIdsByStableId: new Map(state.messageIdsByStableId),
+    accountedCompressionBlockIds: new Set(state.accountedCompressionBlockIds),
+    compressionTokenSavings: new Map(state.compressionTokenSavings),
+    accountedPrunedToolIds: new Set(state.accountedPrunedToolIds),
+    nudgeAnchors: state.nudgeAnchors.map((anchor) => ({ ...anchor })),
+    lastNudge: state.lastNudge ? { ...state.lastNudge } : undefined,
+    progressRecovery: state.progressRecovery ? { ...state.progressRecovery } : undefined,
+  }
+}
+
+/**
+ * E10 dry-run planner. All DCP transforms and candidate discovery run against a
+ * detached state clone; the supplied live state is never published, persisted,
+ * or passed to a model. This is intended for rollout diagnostics/shadow checks.
+ */
+export function planDcpShadow(input: DcpShadowPlanInput): DcpShadowPlanResult {
+  const shadowState = cloneDcpState(input.state)
+  const projected = applyPruning(input.messages, shadowState, input.config)
+  const projectedTokens = projected.reduce((sum, message) => sum + estimateMessageTokens(message), 0)
+  const contextWindow = Math.max(1, Math.floor(input.contextWindow))
+  const emergency = input.config.strategies.emergencyCurrentTurnPruning
+  const thresholds = resolveContextThresholds(input.config, input.modelKeys ?? [], contextWindow)
+  const budget = planDcpBudget({
+    providerUsageTokens: input.providerUsageTokens,
+    repoProjectedTokens: projectedTokens,
+    contextWindow,
+    reservedOutputTokens: input.reservedOutputTokens ?? 0,
+    reservedToolTokens: input.reservedToolTokens ?? 0,
+    maxContextPercent: thresholds.maxContextPercent,
+    hardContextPercent: emergency.hardContextPercent,
+    targetContextPercent: Math.min(
+      emergency.targetContextPercent,
+      Math.max(0, thresholds.maxContextPercent * 0.9),
+    ),
+    summaryBufferEnabled: input.config.compress.summaryBuffer,
+    activeSummaryTokens: getActiveSummaryTokenEstimate(shadowState),
+    estimatorMarginTokens: Math.max(256, Math.ceil(contextWindow * 0.0025)),
+  })
+  const contextPercent = budget.projectedBeforeTokens / contextWindow
+  const recovery = budget.pressured ? { requiredSavingsTokens: budget.requiredSavingsTokens } : undefined
+  const routineCandidate = detectCompressionCandidate(
+    projected,
+    shadowState,
+    input.config,
+    contextPercent,
+    recovery,
+  )
+  const emergencyCandidate = routineCandidate === null && budget.pressured
+    ? detectEmergencyCompressionCandidate(
+      projected,
+      shadowState,
+      input.config,
+      contextPercent,
+      budget.softHeadroomTokens / contextWindow,
+      recovery,
+    )
+    : null
+  const messageCandidates = detectMessageCompressionCandidates(
+    projected,
+    shadowState,
+    input.config,
+    contextPercent,
+  )
+
+  return {
+    projectedTokens,
+    contextPercent,
+    budget,
+    routineCandidate,
+    emergencyCandidate,
+    messageCandidates,
+    projectedMessageCount: projected.length,
+  }
+}

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

@@ -0,0 +1,102 @@
+import type { DcpState } from "./state.js"
+import { createHash } from "node:crypto"
+
+/**
+ * Serialize all stateful DCP publications which share one live state object.
+ *
+ * Persistence has its own per-path queue, but that queue cannot protect the
+ * read/plan/publish interval: two callers can otherwise both clone `nextBlockId
+ * === 1`, persist independent snapshots, and both report success for b1.  This
+ * queue deliberately spans preparation, durable publication, and the final
+ * in-memory commit.
+ */
+const transactionTails = new WeakMap<DcpState, Promise<void>>()
+
+export async function runDcpStateTransaction<T>(
+  state: DcpState,
+  operation: () => Promise<T> | T,
+): Promise<T> {
+  const previous = transactionTails.get(state) ?? Promise.resolve()
+  let release!: () => void
+  const current = new Promise<void>((resolve) => {
+    release = resolve
+  })
+  const tail = previous.catch(() => undefined).then(() => current)
+  transactionTails.set(state, tail)
+
+  await previous.catch(() => undefined)
+  try {
+    return await operation()
+  } finally {
+    release()
+    if (transactionTails.get(state) === tail) transactionTails.delete(state)
+  }
+}
+
+/** Runtime ownership changes invalidate any detached compression plan. */
+export function invalidateDcpStateOwner(state: DcpState): number {
+  state.sessionEpoch = Math.max(1, Math.floor(state.sessionEpoch || 0) + 1)
+  return state.sessionEpoch
+}
+
+export function cloneDcpTransactionState(state: DcpState): DcpState {
+  return structuredClone(state)
+}
+
+function canonicalRuntimeValue(value: unknown, seen = new WeakSet<object>()): unknown {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value
+  if (typeof value === "number") return Number.isFinite(value) ? value : String(value)
+  if (typeof value === "bigint") return `${value}n`
+  if (typeof value === "undefined") return "[undefined]"
+  if (Array.isArray(value)) return value.map((item) => canonicalRuntimeValue(item, seen))
+  if (value instanceof Map) {
+    return [...value.entries()]
+      .map(([key, item]) => [canonicalRuntimeValue(key, seen), canonicalRuntimeValue(item, seen)] as const)
+      .sort(([a], [b]) => JSON.stringify(a).localeCompare(JSON.stringify(b)))
+  }
+  if (value instanceof Set) {
+    return [...value.values()]
+      .map((item) => canonicalRuntimeValue(item, seen))
+      .sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)))
+  }
+  if (typeof value === "object") {
+    if (seen.has(value as object)) return "[cycle]"
+    seen.add(value as object)
+    const record = value as Record<string, unknown>
+    const result: Record<string, unknown> = {}
+    for (const key of Object.keys(record).sort()) result[key] = canonicalRuntimeValue(record[key], seen)
+    seen.delete(value as object)
+    return result
+  }
+  return String(value)
+}
+
+function transactionRevision(state: DcpState): string {
+  return createHash("sha256").update(JSON.stringify(canonicalRuntimeValue(state))).digest("hex")
+}
+
+/** Capture ownership before queuing, never after a long await. */
+export function captureDcpTransactionGuard(
+  state: DcpState,
+  config: unknown,
+  signal?: AbortSignal,
+  context?: any,
+): () => void {
+  const epoch = state.sessionEpoch
+  const revision = transactionRevision(state)
+  const configRevision = JSON.stringify(config)
+  const contextRevision = () => JSON.stringify({
+    session: context?.sessionManager?.getSessionId?.(),
+    branch: context?.sessionManager?.getBranch?.(),
+    model: context?.model,
+    cwd: context?.cwd,
+  })
+  const owner = contextRevision()
+  return () => {
+    signal?.throwIfAborted()
+    if (state.sessionEpoch !== epoch || transactionRevision(state) !== revision ||
+      JSON.stringify(config) !== configRevision || contextRevision() !== owner) {
+      throw new Error("stale_plan: DCP session, branch, model, configuration or source revision changed before publication")
+    }
+  }
+}