pi-ui-extend 0.1.36 → 0.1.38

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

@@ -13,7 +13,7 @@ You operate in a context-constrained environment. Manage context continuously to
 
 The ONLY tool you have for context management is \`compress\`. It replaces older conversation content with technical summaries you produce. It supports both range compression (\`ranges\`) and surgical one-message compression (\`messages\`).
 
-\`[dcp-id]: # (mNNN)\` markdown reference lines and \`<dcp-system-reminder>\` tags are environment-injected metadata. Do not output them.
+\`mNNN\`/\`bN\` DCP boundary IDs and \`<dcp-system-reminder>\` tags are environment-injected metadata. Do not output them.
 
 THE PHILOSOPHY OF COMPRESS
 \`compress\` transforms conversation content into dense, high-fidelity summaries. This is cleanup plus preservation: keep the state needed to continue, discard incidental transcript detail.
@@ -26,21 +26,21 @@ When multiple independent stale sections exist, prefer several focused compressi
 When one older message is huge but the surrounding context is still useful, use message-mode compression for that single message instead of compressing a broad range.
 Summaries should be proportional to future usefulness, not proportional to the amount of text being removed.
 
-Use \`compress\` as steady housekeeping while you work. Closed slice => compress now. Do not start a new search, file-read batch, test, verification run, or web lookup while older completed work remains raw.
+Use \`compress\` as context-pressure housekeeping, not as a reflex after every small step. When context usage is meaningfully high or a DCP reminder provides concrete candidates, compress closed slices before accumulating another large batch of tool output. At low context usage, continue normal work unless a closed slice is clearly large enough that keeping it raw would reduce signal.
 
 A closed slice is any finished implementation, verification, config edit, answered exploration, dead-end debugging branch, or test/log inspection. Passing logs are summary-only: preserve command, pass/fail, key failures if any, and whether follow-up is needed; never keep a full passing log in live context. Treat large shell/read/repo/web outputs as disposable evidence once their facts are extracted.
 
 Before compressing while work is unfinished, ensure one \`todo in_progress\` captures the active objective and next step.
 
-When a \`<dcp-system-reminder>\` appears, treat it as an active instruction for the next safe action, not as background advice. Before making another exploratory tool call or starting a new subtask, check whether any earlier slice is closed; if yes, call \`compress\` first. Do not merely acknowledge the reminder or postpone it across multiple tool calls.
+When a \`<dcp-system-reminder>\` appears, treat it as a context-pressure signal. Follow critical/high-context reminders promptly. For routine reminders, compress only if a genuinely closed, useful-to-summarize slice exists; otherwise continue the next atomic step and re-check later.
 
 CADENCE, SIGNALS, AND LATENCY
 
-- No fixed threshold mandates compression
+- Low context usage does not mandate compression
 - Prioritize closedness and independence over raw size
 - Prefer smaller, regular compressions over infrequent massive compressions for better latency and summary quality
 - When multiple independent stale sections are ready, batch compressions in parallel
-- Before more exploration, ask whether an older completed slice can become summary-only; if yes, compress first
+- Before large new exploration, ask whether an older completed slice can become summary-only; if yes and context pressure is meaningful, compress first
 
 COMPRESS WHEN
 
@@ -81,14 +81,14 @@ It is your responsibility to keep a sharp, high-quality context window for optim
  */
 export const COMPRESS_RANGE_DESCRIPTION = `Collapse one or more ranges of the conversation into detailed summaries.
 
-AUTONOMOUS HOUSEKEEPING
-Do not wait for context emergencies. Closed slice => compress now. A closed slice includes completed implementation, verification, config/doc edit, answered exploration, dead-end debugging, or finished test/log inspection. Compress before starting the next search/read/test/web lookup unless exact raw text is still needed.
+CONTEXT-PRESSURE HOUSEKEEPING
+Use compression when it will materially improve the live context window. Low context usage by itself does not require compression, even when a small closed slice exists. When context usage is meaningfully high, or a DCP reminder supplies concrete high-yield candidates, closed implementation, verification, config/doc edit, answered exploration, dead-end debugging, or finished test/log inspection can become summary-only before another large exploratory batch.
 
 PASSING LOGS AND LARGE OUTPUTS
 Passing check/test/lint/tsc logs are summary-only after you know the result. Preserve command, pass/fail, key failures if any, and follow-up status; drop full passing output. Treat large shell/read/repo/web outputs as disposable evidence once important facts are extracted.
 
 DCP REMINDERS
-If a \`<dcp-system-reminder>\` is present in context, treat it as a direct instruction to evaluate compression immediately. If a safe closed range exists, call this tool before further exploration. Skipping compression is acceptable only when the newest raw context is still needed for the next concrete edit, test, or answer.
+If a \`<dcp-system-reminder>\` is present in context, treat it as a signal to evaluate compression. Critical or high-context reminders should be handled promptly. Routine reminders should lead to compression only when a safe, closed, useful-to-summarize range exists; otherwise continue the next atomic step and re-check later.
 
 THE SUMMARY
 Your summary must be COMPLETE FOR CONTINUATION, not a transcript rewrite. Preserve only information that will plausibly matter later: user intent, accepted constraints, decisions, files/symbols changed or inspected, exact errors that are still actionable, verification status, and next steps.
@@ -128,7 +128,7 @@ Compressed block sections in context are clearly marked with a header:
 
 - \`[Compressed conversation section]\`
 
-Compressed block IDs always use the \`bN\` form (never \`mNNN\`) and are represented as hidden markdown reference metadata lines.
+Compressed block IDs always use the \`bN\` form (never \`mNNN\`) and are represented as hidden DCP metadata.
 
 Rules:
 
@@ -154,7 +154,7 @@ You specify boundaries by ID using the injected metadata IDs present in the conv
 - \`mNNN\` IDs identify raw messages (3 digits, zero-padded, e.g. \`m001\`, \`m042\`)
 - \`bN\` IDs identify previously compressed blocks
 
-Each message has an ID in a hidden single-line markdown reference metadata line like \`[dcp-id]: # (m001)\`.
+Current raw message IDs are provided in hidden DCP control metadata at the end of the model context.
 Some message-compression candidate hints include a low/medium/high priority; prefer high-priority stale message IDs for message-mode compression when a full range would be too broad.
 The ID reference line appears at the end of the message it belongs to — it identifies the message above it, not the one below it.
 Treat these reference lines as boundary metadata only, not as tool result content.
@@ -202,24 +202,23 @@ If the compressed range includes user messages, preserve user intent exactly. Pr
 
 /**
  * Injected into messages when context usage exceeds maxContextPercent.
- * nudgeForce = "soft" — steady housekeeping tone.
+ * nudgeForce = "soft" — high context-pressure tone.
  */
 export const CONTEXT_LIMIT_NUDGE_SOFT = `<dcp-system-reminder>
 ACTION REQUIRED: Context usage is high.
 
-Before doing more exploration, look for a closed, self-contained range that no longer needs to stay raw and compress it now.
+Before doing more exploration, look for a high-yield closed range that no longer needs to stay raw. Compress it now if one is safe and useful.
 
-Do not treat this as optional housekeeping. If any completed research, implementation, verification, config/doc edit, CI-log inspection, or dead-end debugging slice is present, call the \`compress\` tool before continuing normal work.
-If a completed implementation+verification slice exists, compress it before replying or starting another task.
-High-priority stale shell/read/repo/web outputs must be compressed once no exact raw text is needed. Passing logs should not remain raw after they are understood.
+This is context-pressure guidance, not a request to compress tiny or still-needed slices. If completed research, implementation, verification, config/doc edit, CI-log inspection, or dead-end debugging is large enough to reduce signal, call the \`compress\` tool before continuing normal work.
+High-priority stale shell/read/repo/web outputs should be compressed once no exact raw text is needed. Passing logs should not remain raw after they are understood.
 
 RANGE SELECTION
 Prefer older, resolved history. Avoid the newest active working slice unless it is clearly done.
 Use injected boundary IDs (\`mNNN\` for messages, \`bN\` for compressed blocks) and ensure \`startId\` appears before \`endId\`.
 For a single large stale message, use message-mode compression via the \`messages\` array.
 
-If multiple independent ranges are ready, batch them in a single \`compress\` call.
-If nothing is cleanly closed yet, continue only with the next atomic step and re-check immediately afterward.
+If multiple independent high-yield ranges are ready, batch them in a single \`compress\` call.
+If nothing is cleanly closed and worth summarizing yet, continue with the next atomic step and re-check later.
 </dcp-system-reminder>`
 
 /**
@@ -227,17 +226,16 @@ If nothing is cleanly closed yet, continue only with the next atomic step and re
  * at the configured nudgeFrequency cadence.
  */
 export const TURN_NUDGE = `<dcp-system-reminder>
-ACTION REQUIRED: Evaluate the conversation for compressible ranges before continuing.
+CONTEXT CHECK: Evaluate whether compression would materially improve the live context.
 
-If any range is cleanly closed and unlikely to be needed again, use the \`compress\` tool now.
-If direction has shifted, compress earlier ranges that are now less relevant.
+If a range is cleanly closed, non-trivial, and unlikely to be needed verbatim again, use the \`compress\` tool. If direction has shifted, consider whether earlier ranges are now less relevant.
 
-Do not defer this across another batch of searches, reads, CI log fetches, or tests. The next safe action should be compression whenever a closed slice exists.
-High-priority stale shell/read/repo/web outputs and understood passing logs must be compressed once no exact raw text is needed.
+Do not compress just because a small slice closed while context is still low. Prefer compression before another large batch of searches, reads, CI log fetches, or tests when a high-yield stale slice exists.
+High-priority stale shell/read/repo/web outputs and understood passing logs should be compressed once no exact raw text is needed.
 
 Prefer small, closed-range compressions over one broad compression.
 Use message-mode compression for isolated large stale messages.
-The goal is to filter noise and distill key information so context accumulation stays under control.
+The goal is to filter meaningful noise and distill key information so context accumulation stays under control.
 Keep active context uncompressed.
 </dcp-system-reminder>`
 
@@ -245,12 +243,11 @@ Keep active context uncompressed.
  * Injected after iterationNudgeThreshold tool calls since the last user message.
  */
 export const ITERATION_NUDGE = `<dcp-system-reminder>
-ACTION REQUIRED: You've been iterating for a while after the last user message.
+CONTEXT CHECK: You've been iterating for a while after the last user message.
 
-Pause before the next non-atomic tool call. If there is a closed portion that is unlikely to be referenced immediately (for example, finished research before implementation, completed config edit, completed CI-log triage, a verified fix, or a dead-end investigation), use the \`compress\` tool on it now.
+Pause before the next large non-atomic tool batch. If there is a closed portion that is unlikely to be referenced immediately and is worth summarizing (for example, finished research before implementation, completed config edit, completed CI-log triage, a verified fix, or a dead-end investigation), use the \`compress\` tool on it.
 
-Do not keep accumulating tool outputs while a completed slice remains raw. If a range is closed, compression is the next safe action.
-If a completed implementation+verification slice exists, compress it before replying or starting another task.
+Avoid accumulating large tool outputs while a high-yield completed slice remains raw. If only small or still-needed ranges are closed, continue the next atomic step and re-check later.
 
 Prefer multiple short, closed ranges over one large range when several independent slices are ready.
 Use message-mode compression for isolated large stale messages.
@@ -264,7 +261,7 @@ Use message-mode compression for isolated large stale messages.
 export const MANUAL_MODE_SYSTEM_PROMPT = `
 You are operating in DCP manual mode for context management.
 
-\`[dcp-id]: # (mNNN)\` markdown reference lines and \`<dcp-system-reminder>\` tags are environment-injected metadata. Do not output them.
+\`mNNN\`/\`bN\` DCP boundary IDs and \`<dcp-system-reminder>\` tags are environment-injected metadata. Do not output them.
 
 In manual mode you do NOT proactively compress conversation content. Compression is a deliberate, user-directed action.
 

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

@@ -4,7 +4,6 @@ import type { CompressionCandidate, MessageCompressionCandidate } from "./pruner
 import {
   estimateMessageTokens,
   extractBlockId,
-  extractMessageId,
   messageText,
 } from "./pruner-metadata.js";
 
@@ -54,16 +53,13 @@ function resolveAddressableBoundaryId(
     return null;
   }
 
-  const messageId = extractMessageId(text);
-  if (!messageId) return null;
-  if (!hasAddressableSnapshot(state)) return { id: messageId, text };
-
-  if (state.messageMetaSnapshot.has(messageId) || state.messageIdSnapshot.has(messageId)) {
-    return { id: messageId, text };
-  }
-
+  // Inline [dcp-id] markers are no longer injected into message content; the
+  // snapshot rebuilt by injectMessageIds() is the sole addressability source.
+  // Resolve the message id by matching its (timestamp, role) in the snapshot.
   const currentId = findCurrentMessageId(msg, state);
-  return currentId ? { id: currentId, text } : null;
+  if (currentId) return { id: currentId, text };
+
+  return null;
 }
 
 export function detectCompressionCandidate(

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

@@ -1,6 +1,8 @@
+import type { DcpConfig } from "./config.js";
 import type { DcpState } from "./state.js";
 import { PASSTHROUGH_ROLES, estimateMessageTokens } from "./pruner-metadata.js";
 import { stableMessageId } from "./pruner-message-ids.js";
+import { writeDcpDebugLog } from "./debug-log.js";
 
 function messageMatchesBoundary(msg: any, messageIndex: number, stableId: string | undefined, timestamp: number): boolean {
   if (stableId && stableMessageId(msg, messageIndex) === stableId) return true;
@@ -23,7 +25,7 @@ function collectToolCallIds(messages: any[]): Set<string> {
   return ids;
 }
 
-export function syncCompressionBlocks(messages: any[], state: DcpState): void {
+export function syncCompressionBlocks(messages: any[], state: DcpState, config: DcpConfig): void {
   if (state.compressionBlocks.length === 0) return;
 
   const toolCallIds = collectToolCallIds(messages);
@@ -38,6 +40,13 @@ export function syncCompressionBlocks(messages: any[], state: DcpState): void {
     ) {
       block.active = false;
       block.deactivatedReason = "missing-origin-compress-call";
+      writeDcpDebugLog(config, "block.auto_deactivated", {
+        blockId: `b${block.id}`,
+        reason: "missing-origin-compress-call",
+        topic: block.topic,
+        createdByToolCallId: block.createdByToolCallId,
+        activeBlocksAfter: state.compressionBlocks.filter((b) => b.active).length,
+      });
       continue;
     }
 
@@ -49,6 +58,15 @@ export function syncCompressionBlocks(messages: any[], state: DcpState): void {
     if (startIdx === -1 || endIdx === -1) {
       block.active = false;
       block.deactivatedReason = "missing-origin-message";
+      writeDcpDebugLog(config, "block.auto_deactivated", {
+        blockId: `b${block.id}`,
+        reason: "missing-origin-message",
+        topic: block.topic,
+        missingBoundary: startIdx === -1 ? "start" : "end",
+        startMessageId: block.startMessageId,
+        endMessageId: block.endMessageId,
+        activeBlocksAfter: state.compressionBlocks.filter((b) => b.active).length,
+      });
     }
   }
 }

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

@@ -1,4 +1,4 @@
-import type { DcpState } from "./state.js";
+import type { DcpState, MessageIdMeta } from "./state.js";
 import type { DcpConfig } from "./config.js";
 import {
   ID_ELIGIBLE_ROLES,
@@ -9,11 +9,6 @@ import {
 } from "./pruner-metadata.js";
 
 export interface InjectMessageIdsOptions {
-  /**
-   * When false, rebuild internal mNNN snapshots without appending visible
-   * DCP marker lines to provider-visible message content.
-   */
-  visible?: boolean;
   /** Config enables priority markers for message-mode candidates. */
   config?: DcpConfig;
 }
@@ -51,10 +46,29 @@ function priorityForMessage(tokenEstimate: number, config: DcpConfig | undefined
   return "low";
 }
 
-function formatIdTag(id: string, _priority: "low" | "medium" | "high"): string {
-  // Keep the provider-visible marker itself short and single-line. Priority is
-  // retained in state and emitted in message-compression candidate hints.
-  return `\n[dcp-id]: # (${id})`;
+function controlLineForMessageId(id: string, state: DcpState): string {
+  const meta = state.messageMetaSnapshot.get(id);
+  if (!meta) return `- ${id}`;
+
+  const details: string[] = [meta.role];
+  if (meta.blockId !== undefined) details.push(`block=b${meta.blockId}`);
+  if (meta.toolName) details.push(`tool=${meta.toolName}`);
+  if (meta.priority) details.push(`priority=${meta.priority}`);
+  return `- ${id}: ${details.join(", ")}`;
+}
+
+export function buildMessageIdControlText(state: DcpState): string | undefined {
+  const ids = [...state.messageIdSnapshot.keys()];
+  if (ids.length === 0) return undefined;
+
+  return [
+    "<dcp-message-ids>",
+    "DCP metadata for the preceding conversation messages. These IDs are model-visible but UI-hidden control data.",
+    "Use only these current IDs with the compress tool; do not quote or output this metadata.",
+    `Current raw message IDs: ${ids.join(", ")}`,
+    ...ids.map((id) => controlLineForMessageId(id, state)),
+    "</dcp-message-ids>",
+  ].join("\n");
 }
 
 export function injectMessageIds(
@@ -62,11 +76,13 @@ export function injectMessageIds(
   state: DcpState,
   options: InjectMessageIdsOptions = {},
 ): void {
-  const visible = options.visible ?? true;
-
-  // Clear the snapshots and rebuild
-  state.messageIdSnapshot.clear();
-  state.messageMetaSnapshot.clear();
+  // Rebuild into local maps and assign once at the end, so readers (compress
+  // tool, candidates, provider payload builder) never observe a transiently
+  // empty snapshot mid-rebuild. The previous clear()-then-set loop exposed a
+  // window where any concurrent reader saw `messageIdSnapshot` as empty,
+  // which surfaced to the model as `Current raw message IDs: none`.
+  const nextIdSnapshot = new Map<string, number>()
+  const nextMetaSnapshot = new Map<string, MessageIdMeta>()
 
   let counter = 1;
 
@@ -86,52 +102,11 @@ export function injectMessageIds(
     const blockId = extractBlockId(originalText);
     const tokenEstimate = estimateMessageTokens(msg);
     const priority = priorityForMessage(tokenEstimate, options.config);
-    const idTag = formatIdTag(id, priority);
     const rawStableId = stableMessageId(msg, messageIndex);
 
-    if (!visible) {
-      // Snapshot-only mode: keep mNNN mappings fresh for DCP internals, but
-      // do not expose synthetic IDs to the agent.
-    } else if (role === "user") {
-      if (typeof msg.content === "string") {
-        msg.content = msg.content + `\n${idTag}`;
-      } else if (Array.isArray(msg.content)) {
-        msg.content = [...msg.content, { type: "text", text: idTag }];
-      }
-    } else if (role === "toolResult" || role === "bashExecution") {
-      if (Array.isArray(msg.content)) {
-        msg.content = [...msg.content, { type: "text", text: idTag }];
-      } else if (typeof msg.content === "string") {
-        msg.content = msg.content + idTag;
-      }
-    } else if (role === "assistant") {
-      if (Array.isArray(msg.content)) {
-        // Insert the ID tag before any tool_use (toolCall) blocks.
-        // Anthropic requires: thinking → text → tool_use.
-        // Appending after tool_use blocks violates that constraint.
-        const firstToolCallIdx = msg.content.findIndex(
-          (b: any) => b.type === "toolCall",
-        );
-        const idBlock = { type: "text", text: idTag };
-        if (firstToolCallIdx === -1) {
-          // No tool_use blocks — append as usual
-          msg.content = [...msg.content, idBlock];
-        } else {
-          // Insert immediately before the first tool_use block
-          msg.content = [
-            ...msg.content.slice(0, firstToolCallIdx),
-            idBlock,
-            ...msg.content.slice(firstToolCallIdx),
-          ];
-        }
-      } else if (typeof msg.content === "string") {
-        msg.content = msg.content + idTag;
-      }
-    }
-
     if (msg.timestamp !== undefined) {
-      state.messageIdSnapshot.set(id, msg.timestamp);
-      state.messageMetaSnapshot.set(id, {
+      nextIdSnapshot.set(id, msg.timestamp);
+      nextMetaSnapshot.set(id, {
         timestamp: msg.timestamp,
         stableId: rawStableId,
         role,
@@ -144,4 +119,7 @@ export function injectMessageIds(
       });
     }
   }
+
+  state.messageIdSnapshot = nextIdSnapshot
+  state.messageMetaSnapshot = nextMetaSnapshot
 }

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

@@ -17,6 +17,8 @@ const DCP_BLOCK_ID_METADATA_LINE_RE = /^\s*<dcp-block-id(?:>|=)b\d+(?:<\/dcp-blo
 const DCP_ID_MARKDOWN_REF_LINE_RE = /^\s*\[dcp-id\]:\s*#\s*\(m\d+(?:\s+priority=(?:low|medium|high))?\)(?:\s+priority=(?:low|medium|high))?\s*$/i;
 const DCP_BLOCK_ID_MARKDOWN_REF_LINE_RE = /^\s*\[dcp-block-id\]:\s*#\s*\(b\d+\)\s*$/i;
 const DCP_MARKDOWN_REF_FRAGMENT_LINE_RE = /^\s*\[dcp[^\n]*$/i;
+const DCP_MESSAGE_IDS_START_LINE_RE = /^\s*<dcp-message-ids>/i;
+const DCP_MESSAGE_IDS_END_LINE_RE = /<\/dcp-message-ids>\s*$/i;
 const DCP_SYSTEM_REMINDER_START_LINE_RE = /^\s*<dcp-system-reminder>/i;
 const DCP_SYSTEM_REMINDER_END_LINE_RE = /(?:<\/dcp-system-reminder>|(?<!<)dcp-system-reminder>)\s*$/i;
 const MARKDOWN_FENCE_LINE_RE = /^\s*(```|~~~)/;
@@ -185,6 +187,7 @@ function stripStaleDcpMetadataLines(text: string): string {
 
   const lines = text.split("\n");
   const kept: string[] = [];
+  let inMessageIds = false;
   let inSystemReminder = false;
   let inMarkdownFence = false;
 
@@ -200,6 +203,16 @@ function stripStaleDcpMetadataLines(text: string): string {
       continue;
     }
 
+    if (inMessageIds) {
+      if (DCP_MESSAGE_IDS_END_LINE_RE.test(line)) inMessageIds = false;
+      continue;
+    }
+
+    if (DCP_MESSAGE_IDS_START_LINE_RE.test(line)) {
+      if (!DCP_MESSAGE_IDS_END_LINE_RE.test(line)) inMessageIds = true;
+      continue;
+    }
+
     if (inSystemReminder) {
       if (DCP_SYSTEM_REMINDER_END_LINE_RE.test(line)) inSystemReminder = false;
       continue;
@@ -253,6 +266,11 @@ function stripStaleDcpMetadataFromAssistantBlock(block: any): any | undefined {
 
 export function stripStaleDcpMetadataFromAssistantMessage(message: any): any {
   if (!message || typeof message !== "object" || message.role !== "assistant") return message;
+  return stripStaleDcpMetadataFromMessage(message);
+}
+
+export function stripStaleDcpMetadataFromMessage(message: any): any {
+  if (!message || typeof message !== "object") return message;
   if (typeof message.content === "string") {
     return { ...message, content: stripStaleDcpMetadataLines(message.content) };
   }

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

@@ -300,13 +300,13 @@ export function getNudgeType(
   const cadence = Math.max(1, Math.floor(nudgeFrequency));
 
   if (!Number.isFinite(contextPercent)) return null;
-  if (contextPercent <= minContextPercent) return null;
-  if (state.nudgeCounter + 1 < cadence) return null;
-
   if (contextPercent > maxContextPercent) {
     return nudgeForce === "strong" ? "context-strong" : "context-soft";
   }
 
+  if (contextPercent <= minContextPercent) return null;
+  if (state.nudgeCounter + 1 < cadence) return null;
+
   if (toolCallsSinceLastUser >= iterationNudgeThreshold) {
     return "iteration";
   }

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

@@ -64,7 +64,7 @@ export function applyPruning(
 
   // 2. Reconcile persisted compression blocks with the current raw context,
   // then apply active compression blocks.
-  syncCompressionBlocks(msgs, state);
+  syncCompressionBlocks(msgs, state, config);
   applyCompressionBlocks(msgs, state);
 
   // 2b. Post-compression safety net: remove any orphaned tool pairs that the
@@ -83,7 +83,9 @@ export function applyPruning(
   // 6. Apply explicit tool output pruning (prunedToolIds)
   applyToolOutputPruning(msgs, state);
 
-  // 7. Refresh visible message ID snapshots used by the compress tool.
+  // 7. Refresh message ID snapshots used by the compress tool. Markers are
+  // never injected into provider-visible content; the before_provider_request
+  // hook delivers the id map as a hidden control payload.
   injectMessageIds(msgs, state, { config });
 
   // 8. state.messageIdSnapshot/messageMetaSnapshot are already updated by injectMessageIds

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

@@ -45,13 +45,13 @@ async function listSessionIds(sessionDir: string): Promise<string[]> {
 }
 
 function resolveDcpStateDir(ctx: ExtensionContext): string | undefined {
-	const sessionDir = ctx.sessionManager.getSessionDir()
+	const sessionDir = ctx.sessionManager?.getSessionDir?.()
 	if (!sessionDir) return undefined
 	return join(sessionDir, DCP_STATE_DIR)
 }
 
 export function resolveDcpStatePath(ctx: ExtensionContext): string | undefined {
-	const sessionId = ctx.sessionManager.getSessionId()
+	const sessionId = ctx.sessionManager?.getSessionId?.()
 	const stateDir = resolveDcpStateDir(ctx)
 	if (!sessionId || !stateDir) return undefined
 	return join(stateDir, safeSessionFileName(sessionId))
@@ -76,6 +76,35 @@ export async function loadDcpState(ctx: ExtensionContext): Promise<SerializedDcp
 	}
 }
 
+/**
+ * Load the DCP sidecar for an arbitrary session file path, e.g. the previous
+ * session during fork/resume/new. Resolves the sidecar via the session file's
+ * first-line session id rather than the live session manager, so it works
+ * independent of the current ctx.sessionManager state.
+ */
+export async function loadDcpStateFromSessionFile(
+	sessionFile: string,
+): Promise<SerializedDcpState | undefined> {
+	if (!sessionFile) return undefined
+
+	try {
+		const firstLine = (await readFile(sessionFile, "utf8")).split("\n", 1)[0]?.trim()
+		if (!firstLine) return undefined
+		const parsed = JSON.parse(firstLine) as { type?: string; id?: unknown }
+		if (parsed.type !== "session" || typeof parsed.id !== "string" || !parsed.id) {
+			return undefined
+		}
+		const stateDir = join(dirname(sessionFile), DCP_STATE_DIR)
+		const statePath = join(stateDir, safeSessionFileName(parsed.id))
+		const text = await readFile(statePath, "utf8")
+		return JSON.parse(text) as SerializedDcpState
+	} catch {
+		// A missing/unreadable sidecar for the previous session (e.g. a fresh
+		// fork with no prior compression) means there is simply nothing to inherit.
+		return undefined
+	}
+}
+
 export async function cleanupStaleDcpStateFiles(ctx: ExtensionContext): Promise<number> {
 	const stateDir = resolveDcpStateDir(ctx)
 	const sessionDir = ctx.sessionManager.getSessionDir()

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

@@ -39,13 +39,13 @@ export interface ToolRecord {
 }
 
 export interface MessageIdMeta {
-  /** The actual message.timestamp associated with the visible DCP id. */
+  /** The actual message.timestamp associated with the model-visible DCP id. */
   timestamp: number
   /** Stable raw message key when available; falls back to timestamp-derived key. */
   stableId?: string
   /** The message role at the time the id was injected. */
   role: string
-  /** Present when this visible message represents an active compression block. */
+  /** Present when this addressable message represents an active compression block. */
   blockId?: number
   /** Tool call metadata for tool-result-like messages. */
   toolCallId?: string
@@ -54,7 +54,7 @@ export interface MessageIdMeta {
   text?: string
   /** Rough token estimate for priority/candidate guidance. */
   tokenEstimate?: number
-  /** Optional compression priority marker exposed with the visible message ID. */
+  /** Optional compression priority marker exposed with the model-visible message ID. */
   priority?: "low" | "medium" | "high"
 }
 
@@ -162,7 +162,7 @@ export interface DcpState {
    * message positions by timestamp (which is stable across pruning passes).
    */
   messageIdSnapshot: Map<string, number>
-  /** Extra metadata for the visible DCP message IDs in messageIdSnapshot. */
+  /** Extra metadata for the model-visible DCP message IDs in messageIdSnapshot. */
   messageMetaSnapshot: Map<string, MessageIdMeta>
 
   // ── Turn tracking ──────────────────────────────────────────────────────────
@@ -278,6 +278,64 @@ export function resetState(state: DcpState): void {
   state.lastNudge = undefined
 }
 
+/**
+ * Merge compression blocks (and their accounting) from a source sidecar into
+ * the current state without clobbering other fields. Used at session_start to
+ * carry compression state across fork/resume/new into a session whose own
+ * sidecar is empty.
+ *
+ * Returns the number of newly added blocks (blocks whose id already exists are
+ * skipped). Accounting is carried over so inherited blocks are neither lost
+ * nor double-counted when later folded by a new compression range.
+ */
+export function inheritCompressionBlocks(state: DcpState, data: unknown): number {
+  if (!data || typeof data !== "object") return 0
+  const saved = data as Partial<SerializedDcpState>
+  if (!Array.isArray(saved.compressionBlocks) || saved.compressionBlocks.length === 0) return 0
+
+  const existingIds = new Set(state.compressionBlocks.map((b) => b.id))
+  const validBlocks = saved.compressionBlocks
+    .filter(
+      (b: any) =>
+        b && Number.isFinite(b.startTimestamp) && Number.isFinite(b.endTimestamp),
+    )
+    .map((b: any) => ({
+      ...b,
+      anchorTimestamp: Number.isFinite(b.anchorTimestamp)
+        ? b.anchorTimestamp
+        : b.endTimestamp + 1,
+    })) as CompressionBlock[]
+
+  const toAdd = validBlocks.filter((b) => !existingIds.has(b.id))
+  if (toAdd.length === 0) return 0
+
+  state.compressionBlocks.push(...toAdd)
+  state.nextBlockId =
+    Math.max(state.nextBlockId, ...state.compressionBlocks.map((b) => b.id)) + 1
+
+  if (Array.isArray(saved.accountedCompressionBlockIds)) {
+    for (const id of saved.accountedCompressionBlockIds) {
+      if (typeof id === "number") state.accountedCompressionBlockIds.add(id)
+    }
+  }
+  if (Array.isArray(saved.compressionTokenSavings)) {
+    for (const [id, val] of saved.compressionTokenSavings) {
+      if (
+        typeof id === "number" &&
+        typeof val === "number" &&
+        !state.compressionTokenSavings.has(id)
+      ) {
+        state.compressionTokenSavings.set(id, val)
+      }
+    }
+  }
+  if (typeof saved.tokensSaved === "number" && saved.tokensSaved > state.tokensSaved) {
+    state.tokensSaved = saved.tokensSaved
+  }
+
+  return toAdd.length
+}
+
 /**
  * Compact tool record for persistence — strips outputText, outputDetails,
  * and truncates/summarises inputArgs to keep serialized state bounded.

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

@@ -11,6 +11,16 @@ export const DEFAULT_PI_TOOLS_SUITE_CONFIG_JSONC = String.raw`{
   // Vision-capable model used by GLM's lookup tool. Remove or set to null to disable lookup.
   "lookupModel": "openai-codex/gpt-5.4-mini",
   "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
+  // short notice is appended to the tool result when they look unnecessary
+  // (filler phrasing, restating code, decorative separators, generic
+  // paraphrasing). TODO/FIXME, license headers, docstrings, pragmas, linter
+  // directives, and shebangs are never flagged. Strictness:
+  //   "conservative" — only obvious AI-slop (filler/decorative);
+  //   "balanced"     — + restate-code + generic-explanation (default);
+  //   "aggressive"   — any non-valuable net-new comment.
+  "commentChecker": { "enabled": true, "strictness": "balanced" },
   // "telegramMirror": {
   //   "enabled": true,
   //   "botToken": "123456789:ABCdef...",
@@ -18,6 +28,14 @@ export const DEFAULT_PI_TOOLS_SUITE_CONFIG_JSONC = String.raw`{
   // },
   "dcp": {
     "enabled": true,
+    // Write a JSONL debug log of DCP context/prune/compress events to
+    // ~/.pi/agent/dcp-debug.jsonl. Also overridable via env
+    // PI_DCP_DEBUG=1 / PI_DCP_DEBUG_LOG=/path. Off by default.
+    // The log is size-limited and rotated: when it reaches debugLog.maxBytes
+    // (default 5 MB) it is renamed to .1, pushing older backups down and
+    // dropping the oldest past debugLog.maxBackups (default 3).
+    "debug": false,
+    "debugLog": { "maxBytes": 5242880, "maxBackups": 3 },
     "manualMode": { "enabled": false, "automaticStrategies": true },
     "modelOverrides": {
       "openai-codex/gpt-5.5": {

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

@@ -14,6 +14,7 @@ const MODULES: Array<{ name: string; load: () => Promise<ExtensionModule> }> = [
 	{ name: "ast-grep", load: () => import("./ast-grep/index") },
 	{ name: "async-subagents", load: () => import("./async-subagents/index") },
 	{ name: "lsp", load: () => import("./lsp/index") },
+	{ name: "comment-checker", load: () => import("./comment-checker/index") },
 	{ name: "repo-discovery", load: () => import("./repo-discovery/index") },
 	{ name: "antigravity-auth", load: () => import("./antigravity-auth/index") },
 	{ name: "opencode-import", load: () => import("./opencode-import/index") },