pi-ui-extend 1.0.39 → 1.0.41

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

@@ -5,6 +5,7 @@ import { modelKeysFromContext, resolveModelConfig, type DcpConfig } from "./conf
 import type { DcpNudgeType } from "./pruner-types.js"
 import { isToolRecordProtected, markToolPruned } from "./pruner.js"
 import { ignoreStaleExtensionContextError, safeGetContextUsage } from "../context-usage.js"
+import { captureDcpTransactionGuard, cloneDcpTransactionState, runDcpStateTransaction } from "./state-transaction.js"
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -17,6 +18,12 @@ const DCP_STATS_DETAILS_KIND = "dcp-stats"
 
 export interface DcpCommandHooks {
   onStateChanged?: (ctx: ExtensionCommandContext) => void
+  persistState?: (
+    ctx: ExtensionCommandContext,
+    state: DcpState,
+    publication?: { beforePublish?: () => void; onPublished?: () => void },
+  ) => Promise<void> | void
+  isSessionSupported?: () => boolean
 }
 
 // ---------------------------------------------------------------------------
@@ -73,6 +80,7 @@ async function staleSafe(action: () => void | Promise<void>): Promise<void> {
 
 interface DcpNudgeStats {
   emitted: number
+  reapplied: number
   upgraded: number
   clearedEvents: number
   clearedAnchors: number
@@ -80,7 +88,7 @@ interface DcpNudgeStats {
   activeByType: Record<DcpNudgeType, number>
   last?: {
     type: DcpNudgeType
-    event: "emitted" | "upgraded"
+    event: "emitted" | "reapplied" | "upgraded"
     createdAt?: number
     contextPercent?: number | null
   }
@@ -89,6 +97,7 @@ interface DcpNudgeStats {
 function collectNudgeStats(ctx: ExtensionCommandContext, state: DcpState): DcpNudgeStats {
   const stats: DcpNudgeStats = {
     emitted: 0,
+    reapplied: 0,
     upgraded: 0,
     clearedEvents: 0,
     clearedAnchors: 0,
@@ -104,8 +113,9 @@ function collectNudgeStats(ctx: ExtensionCommandContext, state: DcpState): DcpNu
     const data = customEntryData(entry, "dcp-nudge")
     if (!data) continue
     const event = data.event
-    if ((event === "emitted" || event === "upgraded") && isNudgeType(data.type)) {
+    if ((event === "emitted" || event === "reapplied" || event === "upgraded") && isNudgeType(data.type)) {
       if (event === "emitted") stats.emitted++
+      else if (event === "reapplied") stats.reapplied++
       else stats.upgraded++
       stats.byType[data.type]++
       const createdAt = typeof data.createdAt === "number" ? data.createdAt : undefined
@@ -173,10 +183,6 @@ Commands:
   /dcp manual       — Show manual mode status
   /dcp manual on    — Enable manual mode (disable autonomous compression nudges)
   /dcp manual off   — Disable manual mode (enable autonomous compression nudges)
-  /dcp decompress   — List active compression blocks
-  /dcp decompress N — Restore compression block N
-  /dcp recompress    — List blocks restored by /dcp decompress
-  /dcp recompress N  — Re-apply a user-restored compression block
   /dcp compress     — Trigger compression (sends compress tool invocation to LLM)`
 
 function handleHelp(ctx: ExtensionCommandContext): void {
@@ -223,7 +229,7 @@ function handleStats(pi: ExtensionAPI, ctx: ExtensionCommandContext, state: DcpS
   const activeBlocks = state.compressionBlocks.filter((b) => b.active).length
   const totalBlocks = state.compressionBlocks.length
   const nudgeStats = collectNudgeStats(ctx, state)
-  const totalNudgeEvents = nudgeStats.emitted + nudgeStats.upgraded
+  const totalNudgeEvents = nudgeStats.emitted + nudgeStats.reapplied + nudgeStats.upgraded
   const activeAnchors = state.nudgeAnchors.length
   const lines: string[] = []
   lines.push("DCP Session Statistics:")
@@ -233,7 +239,7 @@ function handleStats(pi: ExtensionAPI, ctx: ExtensionCommandContext, state: DcpS
   lines.push(`  Manual mode: ${state.manualMode ? "on" : "off"}`)
   lines.push("")
   lines.push("Nudge telemetry:")
-  lines.push(`  Sent: ${fmt(nudgeStats.emitted)} emitted, ${fmt(nudgeStats.upgraded)} upgraded`)
+  lines.push(`  Sent: ${fmt(nudgeStats.emitted)} emitted, ${fmt(nudgeStats.reapplied)} reapplied, ${fmt(nudgeStats.upgraded)} upgraded`)
   lines.push(
     `  By type: ${NUDGE_TYPES.map((type) => `${nudgeLabel(type)}=${fmt(nudgeStats.byType[type])}`).join(", ")}`,
   )
@@ -277,9 +283,7 @@ async function handleSweep(
   const protectedTools = new Set<string>([
     ...ALWAYS_PROTECTED_TOOLS,
     ...config.compress.protectedTools,
-    ...config.strategies.deduplication.protectedTools,
-    ...config.strategies.purgeErrors.protectedTools,
-    ...config.strategies.autoToolPruning.protectedTools,
+    ...config.strategies.emergencyCurrentTurnPruning.protectedTools,
   ])
 
   // Walk the branch (root → leaf) collecting toolCallIds in encounter order,
@@ -383,122 +387,6 @@ function handleManual(
   }
 }
 
-// ---------------------------------------------------------------------------
-// Decompress
-// ---------------------------------------------------------------------------
-
-function handleDecompress(
-  ctx: ExtensionCommandContext,
-  state: DcpState,
-  nArg: string | undefined,
-): void {
-  if (nArg === undefined) {
-    // List all active compression blocks.
-    const activeBlocks = state.compressionBlocks.filter((b) => b.active)
-
-    if (activeBlocks.length === 0) {
-      ctx.ui.notify("No active compression blocks.", "info")
-      return
-    }
-
-    const lines: string[] = ["Active compression blocks:"]
-    for (const block of activeBlocks) {
-      lines.push(
-        `  b${block.id} — "${block.topic}" (est. ${fmt(block.summaryTokenEstimate)} tokens)`,
-      )
-    }
-    lines.push("")
-    lines.push("Run /dcp decompress N to restore a block.")
-
-    ctx.ui.notify(lines.join("\n"), "info")
-  } else {
-    // Restore block N.
-    const id = parseInt(nArg, 10)
-
-    if (isNaN(id)) {
-      ctx.ui.notify(
-        `Invalid block ID: "${nArg}". Usage: /dcp decompress N`,
-        "error",
-      )
-      return
-    }
-
-    const block = state.compressionBlocks.find((b) => b.id === id)
-
-    if (!block) {
-      ctx.ui.notify(`No compression block found with id ${id}.`, "error")
-      return
-    }
-
-    if (!block.active) {
-      ctx.ui.notify(`Compression block b${id} is already decompressed.`, "info")
-      return
-    }
-
-    block.active = false
-    block.deactivatedByUser = true
-    ctx.ui.notify(`Decompressed block b${id}: "${block.topic}"`, "info")
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Recompress
-// ---------------------------------------------------------------------------
-
-function handleRecompress(
-  ctx: ExtensionCommandContext,
-  state: DcpState,
-  nArg: string | undefined,
-): void {
-  const recompressible = state.compressionBlocks.filter((b) => !b.active && b.deactivatedByUser)
-
-  if (nArg === undefined) {
-    if (recompressible.length === 0) {
-      ctx.ui.notify("No user-decompressed compression blocks are available to recompress.", "info")
-      return
-    }
-
-    const lines: string[] = ["Recompressible blocks:"]
-    for (const block of recompressible) {
-      lines.push(
-        `  b${block.id} — "${block.topic}" (est. ${fmt(block.summaryTokenEstimate)} tokens)`,
-      )
-    }
-    lines.push("")
-    lines.push("Run /dcp recompress N to re-apply a block.")
-    ctx.ui.notify(lines.join("\n"), "info")
-    return
-  }
-
-  const id = parseInt(nArg, 10)
-  if (isNaN(id)) {
-    ctx.ui.notify(`Invalid block ID: "${nArg}". Usage: /dcp recompress N`, "error")
-    return
-  }
-
-  const block = state.compressionBlocks.find((b) => b.id === id)
-  if (!block) {
-    ctx.ui.notify(`No compression block found with id ${id}.`, "error")
-    return
-  }
-  if (block.active) {
-    ctx.ui.notify(`Compression block b${id} is already active.`, "info")
-    return
-  }
-  if (!block.deactivatedByUser) {
-    ctx.ui.notify(`Compression block b${id} was superseded by another block and cannot be recompressed directly.`, "error")
-    return
-  }
-
-  for (const coveredId of block.coveredBlockIds ?? []) {
-    const covered = state.compressionBlocks.find((candidate) => candidate.id === coveredId)
-    if (covered) covered.active = false
-  }
-  block.active = true
-  block.deactivatedByUser = false
-  ctx.ui.notify(`Recompressed block b${id}: "${block.topic}"`, "info")
-}
-
 // ---------------------------------------------------------------------------
 // Compress (trigger)
 // ---------------------------------------------------------------------------
@@ -531,6 +419,15 @@ export function registerCommands(
   config: DcpConfig,
   hooks: DcpCommandHooks = {},
 ): void {
+  const persistState = hooks.persistState ?? (async (
+    _ctx: ExtensionCommandContext,
+    _state: DcpState,
+    publication?: { beforePublish?: () => void; onPublished?: () => void },
+  ) => {
+    publication?.beforePublish?.()
+    publication?.onPublished?.()
+  })
+  const isSessionSupported = hooks.isSessionSupported ?? (() => true)
   pi.registerCommand("dcp", {
     description: "Dynamic Context Pruning — manage context window usage",
     getArgumentCompletions(prefix: string): AutocompleteItem[] | null {
@@ -539,8 +436,6 @@ export function registerCommands(
         { value: "stats", label: "stats", description: "Show pruning statistics" },
         { value: "sweep", label: "sweep", description: "Prune tool outputs" },
         { value: "manual", label: "manual", description: "Toggle manual mode" },
-        { value: "decompress", label: "decompress", description: "List or restore compression blocks" },
-        { value: "recompress", label: "recompress", description: "Re-apply a decompressed block" },
         { value: "compress", label: "compress", description: "Trigger LLM compression" },
         { value: "help", label: "help", description: "Show help" },
       ]
@@ -554,8 +449,12 @@ export function registerCommands(
       const parts = args.trim().split(/\s+/).filter(Boolean)
       const sub = parts[0] ?? ""
       const effectiveConfig = resolveModelConfig(config, modelKeysFromContext(ctx))
-
-      try {
+      const mutating = sub === "sweep" || sub === "manual" || sub === "compress"
+      if (mutating && !isSessionSupported()) {
+        ctx.ui.notify("DCP is unavailable in this session. Start a new session to use the current DCP journal format.", "error")
+        return
+      }
+      const execute = async (state: DcpState, ctx: ExtensionCommandContext): Promise<void> => {
         switch (sub) {
           case "":
           case "help":
@@ -581,14 +480,6 @@ export function registerCommands(
             handleManual(ctx, state, parts[1])
             break
 
-          case "decompress":
-            handleDecompress(ctx, state, parts[1])
-            break
-
-          case "recompress":
-            handleRecompress(ctx, state, parts[1])
-            break
-
           case "compress":
             await handleCompress(pi, ctx)
             break
@@ -600,6 +491,40 @@ export function registerCommands(
             )
             break
         }
+      }
+
+      try {
+        if (["sweep", "manual"].includes(sub)) {
+          // Wait outside the commit queue: the active run may need that same
+          // queue to complete provider evidence or a compression transaction.
+          if (sub === "sweep") await ctx.waitForIdle()
+          const assertCurrent = captureDcpTransactionGuard(state, effectiveConfig, undefined, ctx)
+          const epoch = state.sessionEpoch
+          await runDcpStateTransaction(state, async () => {
+            assertCurrent()
+            const working = cloneDcpTransactionState(state)
+            const notifications: Array<Parameters<typeof ctx.ui.notify>> = []
+            const stagedContext = {
+              ...ctx,
+              waitForIdle: async () => {},
+              ui: { ...ctx.ui, notify: (...args: Parameters<typeof ctx.ui.notify>) => { notifications.push(args) } },
+            } as ExtensionCommandContext
+            await execute(working, stagedContext)
+            assertCurrent()
+            let published = false
+            await persistState(ctx, working, {
+              beforePublish: assertCurrent,
+              onPublished: () => { published = true },
+            })
+            if (!published) assertCurrent()
+            if (state.sessionEpoch === epoch) {
+              Object.assign(state, working)
+              for (const notification of notifications) await staleSafe(() => ctx.ui.notify(...notification))
+            }
+          })
+        } else {
+          await execute(state, ctx)
+        }
       } finally {
         await staleSafe(() => {
           hooks.onStateChanged?.(ctx)