@nijaru/pi-provider-compaction 0.0.3 → 0.0.5

package/dist/index.js

@@ -1,22 +1,239 @@
-// node_modules/@earendil-works/pi-ai/dist/utils/hash.js
-function shortHash(str) {
-  let h1 = 3735928559;
-  let h2 = 1103547991;
-  for (let i = 0;i < str.length; i++) {
-    const ch = str.charCodeAt(i);
-    h1 = Math.imul(h1 ^ ch, 2654435761);
-    h2 = Math.imul(h2 ^ ch, 1597334677);
+// index.ts
+import { createHash, createHmac, randomBytes, randomUUID } from "node:crypto";
+import { normalizeContext as normalizeContext2 } from "@earendil-works/pi-ai";
+import { compact, convertToLlm } from "@earendil-works/pi-coding-agent";
+
+// policy.ts
+import {
+  CONFIG_DIR_NAME,
+  getAgentDir,
+  hasTrustRequiringProjectResources,
+  ProjectTrustStore
+} from "@earendil-works/pi-coding-agent";
+import { closeSync, constants as fsConstants, fstatSync, openSync, readSync } from "node:fs";
+import { join, resolve, sep } from "node:path";
+var COMPACTION_MODEL_FLAG = "compaction-model";
+var PROJECT_POLICY = "compaction-policy.json";
+var AGENT_DIR_OVERRIDE = "PI_COMPACTOR_AGENT_DIR";
+var MAX_POLICY_BYTES = 64 * 1024;
+var MAX_MODEL_SELECTORS = 8;
+var MAX_SELECTOR_LENGTH = 512;
+function normalizeSelector(value) {
+  if (typeof value !== "string")
+    return;
+  const selector = value.trim();
+  if (selector.length === 0 || selector.length > MAX_SELECTOR_LENGTH)
+    return;
+  return selector;
+}
+function parsePolicySelectors(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return;
+  if (!("models" in value) || !Array.isArray(value.models))
+    return;
+  const selectors = [];
+  for (const model of value.models) {
+    const selector = normalizeSelector(model);
+    if (selector === undefined || selectors.includes(selector))
+      continue;
+    selectors.push(selector);
+    if (selectors.length === MAX_MODEL_SELECTORS)
+      break;
   }
-  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
-  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
-  return (h2 >>> 0).toString(36) + (h1 >>> 0).toString(36);
+  return selectors;
+}
+function readPolicySelectors(configPath) {
+  let fd;
+  try {
+    fd = openSync(configPath, fsConstants.O_RDONLY | fsConstants.O_NONBLOCK);
+    const stat = fstatSync(fd);
+    if (!stat.isFile() || stat.size > MAX_POLICY_BYTES)
+      return;
+    const buffer = Buffer.allocUnsafe(MAX_POLICY_BYTES + 1);
+    let bytesRead = 0;
+    while (bytesRead < buffer.length) {
+      const count = readSync(fd, buffer, bytesRead, buffer.length - bytesRead, null);
+      if (count === 0)
+        break;
+      bytesRead += count;
+    }
+    if (bytesRead > MAX_POLICY_BYTES)
+      return;
+    return parsePolicySelectors(JSON.parse(buffer.subarray(0, bytesRead).toString("utf8")));
+  } catch {
+    return;
+  } finally {
+    if (fd !== undefined) {
+      try {
+        closeSync(fd);
+      } catch {}
+    }
+  }
+}
+function activeAgentDir(ctx) {
+  const override = process.env[AGENT_DIR_OVERRIDE]?.trim();
+  if (override)
+    return resolve(override);
+  try {
+    const sessionDir = ctx.sessionManager?.getSessionDir();
+    if (sessionDir) {
+      const resolvedCwd = resolve(ctx.cwd);
+      const safePath = `--${resolvedCwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+      const suffix = `${sep}${join("sessions", safePath)}`;
+      const resolvedSessionDir = resolve(sessionDir);
+      if (resolvedSessionDir.endsWith(suffix)) {
+        return resolvedSessionDir.slice(0, -suffix.length);
+      }
+    }
+  } catch {}
+  return getAgentDir();
+}
+function isProjectPolicyTrusted(ctx, agentDir) {
+  try {
+    if (!ctx.isProjectTrusted())
+      return false;
+    return hasTrustRequiringProjectResources(ctx.cwd) || new ProjectTrustStore(agentDir).get(ctx.cwd) === true;
+  } catch {
+    return false;
+  }
+}
+function readCompactionModelFlagFromArgv(argv = process.argv.slice(2)) {
+  let value;
+  const prefix = `--${COMPACTION_MODEL_FLAG}=`;
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--")
+      break;
+    if (arg === `--${COMPACTION_MODEL_FLAG}`) {
+      const next = argv[i + 1];
+      if (next !== undefined && !next.startsWith("-") && !next.startsWith("@")) {
+        value = next;
+        i++;
+      } else {
+        value = true;
+      }
+    } else if (arg.startsWith(prefix)) {
+      value = arg.slice(prefix.length);
+    }
+  }
+  return value;
+}
+function resolveCompactionModelPolicy(pi, ctx, argv = process.argv.slice(2)) {
+  const argvRaw = readCompactionModelFlagFromArgv(argv);
+  if (typeof argvRaw === "string" && argvRaw.trim()) {
+    const selector = normalizeSelector(argvRaw);
+    return selector ? { hasSelectors: true, source: "flag" } : { hasSelectors: false };
+  }
+  try {
+    const rawFlag = pi.getFlag(COMPACTION_MODEL_FLAG);
+    if (typeof rawFlag === "string" && rawFlag.trim()) {
+      const selector = normalizeSelector(rawFlag);
+      return selector ? { hasSelectors: true, source: "flag" } : { hasSelectors: false };
+    }
+  } catch {}
+  const agentDir = activeAgentDir(ctx);
+  const candidates = [];
+  if (isProjectPolicyTrusted(ctx, agentDir)) {
+    candidates.push({ path: join(ctx.cwd, CONFIG_DIR_NAME, PROJECT_POLICY), source: "project-policy" });
+  }
+  candidates.push({ path: join(agentDir, PROJECT_POLICY), source: "agent-policy" });
+  for (const candidate of candidates) {
+    const selectors = readPolicySelectors(candidate.path);
+    if (selectors !== undefined) {
+      return selectors.length > 0 ? { hasSelectors: true, source: candidate.source } : { hasSelectors: false };
+    }
+  }
+  return { hasSelectors: false };
 }
 
-// node_modules/@earendil-works/pi-ai/dist/utils/sanitize-unicode.js
-function sanitizeSurrogates(text) {
-  return text.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "");
+// provider.ts
+function optionsWithObserver(model, context, options, observe) {
+  const handler = observe(model, context, options ?? {});
+  if (!handler)
+    return options;
+  return {
+    ...options,
+    onPayload: async (payload, requestModel) => {
+      const replacement = await options?.onPayload?.(payload, requestModel);
+      const prepared = replacement === undefined ? payload : replacement;
+      try {
+        return await handler(prepared);
+      } catch {
+        return prepared;
+      }
+    }
+  };
+}
+function decorateProvider(base, observe) {
+  const stream = (model, context, options) => base.stream(model, context, optionsWithObserver(model, context, options, observe));
+  const streamSimple = (model, context, options) => base.streamSimple(model, context, optionsWithObserver(model, context, options, observe));
+  const bound = new Map;
+  return new Proxy(base, {
+    get(target, key) {
+      if (key === "stream")
+        return stream;
+      if (key === "streamSimple")
+        return streamSimple;
+      const value = Reflect.get(target, key, target);
+      if (typeof value !== "function")
+        return value;
+      if (!bound.has(key))
+        bound.set(key, value.bind(target));
+      return bound.get(key);
+    }
+  });
+}
+function installObserver(pi, ctx, observe) {
+  const model = ctx.model;
+  if (!model)
+    return;
+  const registry = ctx.modelRegistry;
+  const id = model.provider;
+  const native = registry.getRegisteredNativeProvider(id);
+  if (native) {
+    const guarded = (...args) => {
+      const handler = observe(...args);
+      return handler ? (payload) => registry.getRegisteredNativeProvider(id) === wrapper ? handler(payload) : payload : undefined;
+    };
+    const wrapper = decorateProvider(native, guarded);
+    pi.registerProvider(wrapper);
+    return () => {
+      if (registry.getRegisteredNativeProvider(id) === wrapper)
+        pi.registerProvider(native);
+    };
+  }
+  const original = registry.getRegisteredProviderConfig(id);
+  if (!original?.streamSimple || original.refreshModels || original.oauth?.modifyModels)
+    return;
+  if (original.api !== model.api)
+    return;
+  const delegate = original.streamSimple.bind(original);
+  const guarded = (...args) => {
+    const handler = observe(...args);
+    return handler ? (payload) => registry.getRegisteredProviderConfig(id)?.streamSimple === wrapper ? handler(payload) : payload : undefined;
+  };
+  const wrapper = (requestModel, context, options) => delegate(requestModel, context, optionsWithObserver(requestModel, context, options, guarded));
+  pi.registerProvider(id, { ...original, api: original?.api ?? model.api, streamSimple: wrapper });
+  return () => {
+    const current = registry.getRegisteredProviderConfig(id);
+    if (current?.streamSimple !== wrapper || registry.getRegisteredNativeProvider(id))
+      return;
+    const restored = { ...current };
+    if (original?.streamSimple)
+      restored.streamSimple = original.streamSimple;
+    else
+      delete restored.streamSimple;
+    if (!original?.api && restored.api === model.api)
+      delete restored.api;
+    pi.unregisterProvider(id);
+    if (Object.keys(restored).length)
+      pi.registerProvider(id, restored);
+  };
 }
 
+// replay.ts
+import { getCurrentSystemPrompt, getCurrentTools as getCurrentTools2, getDeclaredTools, normalizeContext, resolveTranscript as resolveTranscript2 } from "@earendil-works/pi-ai";
+
 // node_modules/@earendil-works/pi-ai/dist/api/constrained-sampling.js
 class UnsupportedStrictJsonSchemaError extends Error {
 }
@@ -56,7 +273,7 @@ function schemaAllowsNull(schema) {
     return true;
   return Array.isArray(schema.anyOf) && schema.anyOf.some((variant) => schemaAllowsNull(variant));
 }
-function makeJsonSchemaNodeStrict(schema) {
+function makeJsonSchemaNodeStrict(schema, isUnsupportedKeyword) {
   if (!isJsonSchemaObject(schema)) {
     throw new UnsupportedStrictJsonSchemaError("boolean schemas are unsupported");
   }
@@ -65,6 +282,13 @@ function makeJsonSchemaNodeStrict(schema) {
       throw new UnsupportedStrictJsonSchemaError(`${key} schemas are unsupported`);
     }
   }
+  if (isUnsupportedKeyword) {
+    for (const [key, value] of Object.entries(schema)) {
+      if (isUnsupportedKeyword(key, value)) {
+        throw new UnsupportedStrictJsonSchemaError(`${key}: ${JSON.stringify(value)} is unsupported`);
+      }
+    }
+  }
   if (schema.anyOf !== undefined) {
     if (!Array.isArray(schema.anyOf) || schema.anyOf.length === 0) {
       throw new UnsupportedStrictJsonSchemaError("anyOf must contain at least one schema");
@@ -73,14 +297,14 @@ function makeJsonSchemaNodeStrict(schema) {
       if (isStructuredSchema(variant)) {
         throw new UnsupportedStrictJsonSchemaError("object and array unions are unsupported");
       }
-      makeJsonSchemaNodeStrict(variant);
+      makeJsonSchemaNodeStrict(variant, isUnsupportedKeyword);
     }
   }
   if (schema.items !== undefined) {
     if (Array.isArray(schema.items)) {
       throw new UnsupportedStrictJsonSchemaError("tuple schemas are unsupported");
     }
-    makeJsonSchemaNodeStrict(schema.items);
+    makeJsonSchemaNodeStrict(schema.items, isUnsupportedKeyword);
   }
   const isObjectSchema = schema.type === "object";
   if (schema.properties !== undefined && !isObjectSchema) {
@@ -104,7 +328,7 @@ function makeJsonSchemaNodeStrict(schema) {
     throw new UnsupportedStrictJsonSchemaError("required contains an unknown property");
   }
   for (const [key, property] of Object.entries(properties)) {
-    makeJsonSchemaNodeStrict(property);
+    makeJsonSchemaNodeStrict(property, isUnsupportedKeyword);
     if (!required.has(key) && !schemaAllowsNull(property)) {
       properties[key] = { anyOf: [property, { type: "null" }] };
     }
@@ -112,12 +336,12 @@ function makeJsonSchemaNodeStrict(schema) {
   schema.required = propertyNames;
   schema.additionalProperties = false;
 }
-function makeStrictJsonSchema(schema) {
+function makeStrictJsonSchema(schema, isUnsupportedKeyword) {
   const cloned = structuredClone(schema);
   if (!isJsonSchemaObject(cloned)) {
     throw new UnsupportedStrictJsonSchemaError("root schema must have type object");
   }
-  makeJsonSchemaNodeStrict(cloned);
+  makeJsonSchemaNodeStrict(cloned, isUnsupportedKeyword);
   if (cloned.type !== "object") {
     throw new UnsupportedStrictJsonSchemaError("root schema must have type object");
   }
@@ -150,13 +374,13 @@ function inferGrammarInputProperty(tool) {
   }
   return inputProperty;
 }
-function resolveJsonSchemaStrictSampling(tool, supportsStrictMode) {
+function resolveJsonSchemaStrictSampling(tool, supportsStrictMode, isUnsupportedKeyword) {
   const config = tool.constrainedSampling;
   if (!config || config.type !== "json_schema")
     return;
   if (supportsStrictMode) {
     try {
-      makeStrictJsonSchema(tool.parameters);
+      makeStrictJsonSchema(tool.parameters, isUnsupportedKeyword);
       return true;
     } catch (error) {
       if (!(error instanceof UnsupportedStrictJsonSchemaError))
@@ -197,6 +421,149 @@ function resolveGrammarConstrainedSampling(tool, supportsOpenAIGrammarTools) {
     throw new Error(`Tool "${tool.name}" cannot use grammar constrained sampling: ${message}.`);
   }
 }
+function createGrammarToolInputProperties(tools, supportsOpenAIGrammarTools) {
+  const properties = new Map;
+  for (const tool of tools ?? []) {
+    const grammar = resolveGrammarConstrainedSampling(tool, supportsOpenAIGrammarTools);
+    if (grammar) {
+      properties.set(tool.name, grammar.inputProperty);
+    }
+  }
+  return properties;
+}
+
+// node_modules/@earendil-works/pi-ai/dist/utils/text.js
+function contentText(content, separator = `
+`) {
+  if (typeof content === "string")
+    return content;
+  return content.filter((block) => block.type === "text").map((block) => block.text).join(separator);
+}
+function getSystemMessageText(message) {
+  const parts = [contentText(message.content)];
+  for (const text of Object.values(message.sections ?? {})) {
+    if (text !== null)
+      parts.push(text);
+  }
+  return parts.filter((part) => part.length > 0).join(`
+
+`);
+}
+function renderSystemMessageUpdate(message) {
+  const parts = [];
+  const text = contentText(message.content);
+  if (text.length > 0)
+    parts.push(text);
+  for (const [name, value] of Object.entries(message.sections ?? {})) {
+    parts.push(value === null ? `Removed system prompt section "${name}".` : `Updated system prompt section "${name}":
+
+${value}`);
+  }
+  return parts.join(`
+
+`);
+}
+
+// node_modules/@earendil-works/pi-ai/dist/utils/transcript.js
+function isSystemMessage(message) {
+  return message.role === "system";
+}
+function getInitialSystemMessage(messages) {
+  const first = messages[0];
+  return first && isSystemMessage(first) ? first : undefined;
+}
+function getCurrentTools(messages) {
+  const tools = new Map;
+  for (const message of messages) {
+    if (!isSystemMessage(message))
+      continue;
+    for (const tool of message.toolsRemoved ?? [])
+      tools.delete(tool.name);
+    for (const tool of message.toolsAdded ?? [])
+      tools.set(tool.name, tool);
+  }
+  return [...tools.values()];
+}
+function getCurrentSystemMessage(messages) {
+  const content = [];
+  const sections = new Map;
+  let timestamp;
+  for (const message of messages) {
+    if (!isSystemMessage(message))
+      continue;
+    timestamp ??= message.timestamp;
+    const text = contentText(message.content);
+    if (text.length > 0)
+      content.push(text);
+    for (const [name, value] of Object.entries(message.sections ?? {})) {
+      if (value === null)
+        sections.delete(name);
+      else
+        sections.set(name, value);
+    }
+  }
+  const tools = getCurrentTools(messages);
+  if (timestamp === undefined && tools.length === 0)
+    return;
+  return {
+    role: "system",
+    content: content.join(`
+
+`),
+    ...sections.size > 0 ? { sections: Object.fromEntries(sections) } : {},
+    ...tools.length > 0 ? { toolsAdded: tools } : {},
+    timestamp: timestamp ?? 0
+  };
+}
+function collapseSystemMessages(context) {
+  const head = getCurrentSystemMessage(context.messages);
+  const messages = context.messages.filter((message) => message.role !== "system");
+  return { messages: head ? [head, ...messages] : messages };
+}
+function resolveTranscript(context, supportsMidConvoSystemMessages) {
+  return supportsMidConvoSystemMessages ? context : collapseSystemMessages(context);
+}
+function hasNonAdditiveToolChanges(messages) {
+  const declared = new Set;
+  for (const message of messages) {
+    if (!isSystemMessage(message))
+      continue;
+    if ((message.toolsRemoved?.length ?? 0) > 0)
+      return true;
+    for (const tool of message.toolsAdded ?? []) {
+      if (declared.has(tool.name))
+        return true;
+      declared.add(tool.name);
+    }
+  }
+  return false;
+}
+function resolveTranscriptTools(messages, supportsToolAdditions) {
+  const anchorsAdditions = supportsToolAdditions && !hasNonAdditiveToolChanges(messages);
+  return {
+    requestTools: anchorsAdditions ? getInitialSystemMessage(messages)?.toolsAdded ?? [] : getCurrentTools(messages),
+    anchorsAdditions
+  };
+}
+
+// node_modules/@earendil-works/pi-ai/dist/utils/hash.js
+function shortHash(str) {
+  let h1 = 3735928559;
+  let h2 = 1103547991;
+  for (let i = 0;i < str.length; i++) {
+    const ch = str.charCodeAt(i);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  return (h2 >>> 0).toString(36) + (h1 >>> 0).toString(36);
+}
+
+// node_modules/@earendil-works/pi-ai/dist/utils/sanitize-unicode.js
+function sanitizeSurrogates(text) {
+  return text.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "");
+}
 
 // node_modules/@earendil-works/pi-ai/dist/api/transform-messages.js
 var NON_VISION_USER_IMAGE_PLACEHOLDER = "(image omitted: model does not support images)";
@@ -242,7 +609,7 @@ function transformMessages(messages, model, normalizeToolCallId) {
   const normalizedMessages = messages.map((msg) => msg.content == null ? { ...msg, content: [] } : msg);
   const imageAwareMessages = downgradeUnsupportedImages(normalizedMessages, model);
   const transformed = imageAwareMessages.map((msg) => {
-    if (msg.role === "user") {
+    if (msg.role === "system" || msg.role === "user") {
       return msg;
     }
     if (msg.role === "toolResult") {
@@ -307,7 +674,8 @@ function transformMessages(messages, model, normalizeToolCallId) {
   const result = [];
   let pendingToolCalls = [];
   let existingToolResultIds = new Set;
-  const insertSyntheticToolResults = () => {
+  const heldSystemMessages = [];
+  const closePendingToolCalls = () => {
     if (pendingToolCalls.length > 0) {
       for (const tc of pendingToolCalls) {
         if (!existingToolResultIds.has(tc.id)) {
@@ -324,11 +692,13 @@ function transformMessages(messages, model, normalizeToolCallId) {
       pendingToolCalls = [];
       existingToolResultIds = new Set;
     }
+    result.push(...heldSystemMessages);
+    heldSystemMessages.length = 0;
   };
   for (let i = 0;i < transformed.length; i++) {
     const msg = transformed[i];
     if (msg.role === "assistant") {
-      insertSyntheticToolResults();
+      closePendingToolCalls();
       const assistantMsg = msg;
       if (assistantMsg.stopReason === "error" || assistantMsg.stopReason === "aborted") {
         continue;
@@ -342,14 +712,20 @@ function transformMessages(messages, model, normalizeToolCallId) {
     } else if (msg.role === "toolResult") {
       existingToolResultIds.add(msg.toolCallId);
       result.push(msg);
+    } else if (msg.role === "system") {
+      if (pendingToolCalls.length > 0) {
+        heldSystemMessages.push(msg);
+      } else {
+        result.push(msg);
+      }
     } else if (msg.role === "user") {
-      insertSyntheticToolResults();
+      closePendingToolCalls();
       result.push(msg);
     } else {
       result.push(msg);
     }
   }
-  insertSyntheticToolResults();
+  closePendingToolCalls();
   return result;
 }
 
@@ -392,8 +768,8 @@ function convertToolResultOutput(model, content) {
   return output;
 }
 function convertResponsesMessages(model, context, allowedToolCallProviders, options) {
+  const normalizedContext = resolveTranscript(context, options?.supportsMidConvoSystemMessages);
   const messages = [];
-  const loadedToolNames = new Set;
   const normalizeIdPart = (part) => {
     const sanitized = part.replace(/[^a-zA-Z0-9_-]/g, "_");
     const normalized = sanitized.length > 64 ? sanitized.slice(0, 64) : sanitized;
@@ -417,19 +793,56 @@ function convertResponsesMessages(model, context, allowedToolCallProviders, opti
     }
     return `${normalizedCallId}|${normalizedItemId}`;
   };
-  const transformedMessages = transformMessages(context.messages, model, normalizeToolCallId);
-  const includeSystemPrompt = options?.includeSystemPrompt ?? true;
-  if (includeSystemPrompt && context.systemPrompt) {
-    const compat = model.compat;
-    const role = model.reasoning && compat?.supportsDeveloperRole !== false ? "developer" : "system";
+  const transformedMessages = transformMessages(normalizedContext.messages, model, normalizeToolCallId);
+  const transcriptTools = resolveTranscriptTools(normalizedContext.messages, (options?.supportsAdditionalTools ?? false) || (options?.supportsToolSearch ?? false));
+  const appendSystemToolAdditions = (message, seed) => {
+    const tools = transcriptTools.anchorsAdditions ? message.toolsAdded ?? [] : [];
+    if (tools.length === 0)
+      return;
+    if (options?.supportsAdditionalTools) {
+      messages.push({
+        type: "additional_tools",
+        role: "developer",
+        tools: convertResponsesTools(tools, options.toolOptions)
+      });
+      return;
+    }
+    if (!options?.supportsToolSearch)
+      return;
+    const names = tools.map((tool) => tool.name);
+    const callId = `pi_tool_load_${shortHash(`${seed}:${names.join(",")}`)}`;
     messages.push({
-      role,
-      content: sanitizeSurrogates(context.systemPrompt)
+      type: "tool_search_call",
+      call_id: callId,
+      execution: "client",
+      status: "completed",
+      arguments: { query: names.join(" "), limit: names.length }
     });
-  }
+    messages.push({
+      type: "tool_search_output",
+      call_id: callId,
+      execution: "client",
+      status: "completed",
+      tools: convertResponsesTools(tools, { ...options.toolOptions, toolSearchResult: true })
+    });
+  };
+  const includeInitialSystemMessage = options?.includeSystemPrompt ?? true;
+  const compat = model.compat;
+  const instructionRole = model.reasoning && compat?.supportsDeveloperRole !== false ? "developer" : "system";
   let msgIndex = 0;
+  let sourceIndex = 0;
   for (const msg of transformedMessages) {
-    if (msg.role === "user") {
+    const isLeadingSystemMessage = sourceIndex++ === 0 && msg.role === "system";
+    if (msg.role === "system") {
+      if (!isLeadingSystemMessage)
+        appendSystemToolAdditions(msg, `system:${msgIndex}`);
+      if (!isLeadingSystemMessage || includeInitialSystemMessage) {
+        const text = isLeadingSystemMessage ? getSystemMessageText(msg) : renderSystemMessageUpdate(msg);
+        if (text.length > 0) {
+          messages.push({ role: instructionRole, content: sanitizeSurrogates(text) });
+        }
+      }
+    } else if (msg.role === "user") {
       if (typeof msg.content === "string") {
         messages.push({
           role: "user",
@@ -493,10 +906,10 @@ function convertResponsesMessages(model, context, allowedToolCallProviders, opti
           const [callId, itemIdRaw] = toolCall.id.split("|");
           const customInputProperty = options?.grammarToolInputProperties?.get(toolCall.name);
           let itemId = itemIdRaw;
-          if (isDifferentModel && itemId?.startsWith("fc_") || customInputProperty === undefined && !itemId?.startsWith("fc_")) {
+          const itemIdPrefix = customInputProperty === undefined ? "fc_" : "ctc_";
+          if (isDifferentModel || !itemId?.startsWith(itemIdPrefix)) {
             itemId = undefined;
           }
-          const canReplayNamespace = isSameModel || options?.deferredTools?.has(toolCall.name) === true;
           if (customInputProperty !== undefined) {
             output.push({
               type: "custom_tool_call",
@@ -504,7 +917,7 @@ function convertResponsesMessages(model, context, allowedToolCallProviders, opti
               call_id: callId,
               name: toolCall.name,
               input: sanitizeSurrogates(getGrammarToolInput(toolCall.name, toolCall.arguments, customInputProperty)),
-              ...canReplayNamespace && toolCall.namespace !== undefined ? { namespace: toolCall.namespace } : {}
+              ...isSameModel && toolCall.namespace !== undefined ? { namespace: toolCall.namespace } : {}
             });
           } else {
             output.push({
@@ -513,7 +926,7 @@ function convertResponsesMessages(model, context, allowedToolCallProviders, opti
               call_id: callId,
               name: toolCall.name,
               arguments: JSON.stringify(toolCall.arguments),
-              ...canReplayNamespace && toolCall.namespace !== undefined ? { namespace: toolCall.namespace } : {}
+              ...isSameModel && toolCall.namespace !== undefined ? { namespace: toolCall.namespace } : {}
             });
           }
         }
@@ -537,43 +950,9 @@ function convertResponsesMessages(model, context, allowedToolCallProviders, opti
           output
         });
       }
-      const deferredTools = [];
-      for (const name of msg.addedToolNames ?? []) {
-        const tool = options?.deferredTools?.get(name);
-        if (!tool || loadedToolNames.has(name))
-          continue;
-        loadedToolNames.add(name);
-        deferredTools.push(tool);
-      }
-      if (deferredTools.length > 0 && options?.deferredToolsMode === "additional-tools") {
-        messages.push({
-          type: "additional_tools",
-          role: "developer",
-          tools: convertResponsesTools(deferredTools, options.toolOptions)
-        });
-      } else if (deferredTools.length > 0 && options?.deferredToolsMode === "tool-search") {
-        const names = deferredTools.map((tool) => tool.name);
-        const searchCallId = `pi_tool_load_${shortHash(`${msg.toolCallId}:${names.join(",")}`)}`;
-        messages.push({
-          type: "tool_search_call",
-          call_id: searchCallId,
-          execution: "client",
-          status: "completed",
-          arguments: { query: names.join(" "), limit: names.length }
-        });
-        messages.push({
-          type: "tool_search_output",
-          call_id: searchCallId,
-          execution: "client",
-          status: "completed",
-          tools: convertResponsesTools(deferredTools, {
-            ...options.toolOptions,
-            deferLoading: true
-          })
-        });
-      }
     }
-    msgIndex++;
+    if (!isLeadingSystemMessage)
+      msgIndex++;
   }
   return messages;
 }
@@ -593,7 +972,7 @@ function convertResponsesTools(tools, options) {
           syntax: grammar.format,
           definition: grammar.definition
         },
-        ...options?.deferLoading ? { defer_loading: true } : {}
+        ...options?.toolSearchResult ? { defer_loading: true } : {}
       };
     }
     const constrainedStrict = resolveJsonSchemaStrictSampling(tool, supportsStrictMode);
@@ -603,7 +982,7 @@ function convertResponsesTools(tools, options) {
       name: tool.name,
       description: tool.description,
       parameters: getJsonSchemaToolParameters(tool, strict === true),
-      ...options?.deferLoading ? { defer_loading: true } : {}
+      ...options?.toolSearchResult ? { defer_loading: true } : {}
     };
     if (supportsStrictMode) {
       functionTool.strict = strict;
@@ -612,157 +991,6 @@ function convertResponsesTools(tools, options) {
   });
 }
 
-// index.ts
-import { calculateCost } from "@earendil-works/pi-ai";
-import {
-  compact,
-  convertToLlm,
-  sessionEntryToContextMessages
-} from "@earendil-works/pi-coding-agent";
-
-// policy.ts
-import {
-  CONFIG_DIR_NAME,
-  getAgentDir,
-  hasTrustRequiringProjectResources,
-  ProjectTrustStore
-} from "@earendil-works/pi-coding-agent";
-import { closeSync, constants as fsConstants, fstatSync, openSync, readSync } from "node:fs";
-import { join, resolve, sep } from "node:path";
-var COMPACTION_MODEL_FLAG = "compaction-model";
-var PROJECT_POLICY = "compaction-policy.json";
-var AGENT_DIR_OVERRIDE = "PI_COMPACTOR_AGENT_DIR";
-var MAX_POLICY_BYTES = 64 * 1024;
-var MAX_MODEL_SELECTORS = 8;
-var MAX_SELECTOR_LENGTH = 512;
-function normalizeSelector(value) {
-  if (typeof value !== "string")
-    return;
-  const selector = value.trim();
-  if (selector.length === 0 || selector.length > MAX_SELECTOR_LENGTH)
-    return;
-  return selector;
-}
-function parsePolicySelectors(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value))
-    return;
-  if (!("models" in value) || !Array.isArray(value.models))
-    return;
-  const selectors = [];
-  for (const model of value.models) {
-    const selector = normalizeSelector(model);
-    if (selector === undefined || selectors.includes(selector))
-      continue;
-    selectors.push(selector);
-    if (selectors.length === MAX_MODEL_SELECTORS)
-      break;
-  }
-  return selectors;
-}
-function readPolicySelectors(configPath) {
-  let fd;
-  try {
-    fd = openSync(configPath, fsConstants.O_RDONLY | fsConstants.O_NONBLOCK);
-    const stat = fstatSync(fd);
-    if (!stat.isFile() || stat.size > MAX_POLICY_BYTES)
-      return;
-    const buffer = Buffer.allocUnsafe(MAX_POLICY_BYTES + 1);
-    let bytesRead = 0;
-    while (bytesRead < buffer.length) {
-      const count = readSync(fd, buffer, bytesRead, buffer.length - bytesRead, null);
-      if (count === 0)
-        break;
-      bytesRead += count;
-    }
-    if (bytesRead > MAX_POLICY_BYTES)
-      return;
-    return parsePolicySelectors(JSON.parse(buffer.subarray(0, bytesRead).toString("utf8")));
-  } catch {
-    return;
-  } finally {
-    if (fd !== undefined) {
-      try {
-        closeSync(fd);
-      } catch {}
-    }
-  }
-}
-function activeAgentDir(ctx) {
-  const override = process.env[AGENT_DIR_OVERRIDE]?.trim();
-  if (override)
-    return resolve(override);
-  try {
-    const sessionDir = ctx.sessionManager?.getSessionDir();
-    if (sessionDir) {
-      const resolvedCwd = resolve(ctx.cwd);
-      const safePath = `--${resolvedCwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
-      const suffix = `${sep}${join("sessions", safePath)}`;
-      const resolvedSessionDir = resolve(sessionDir);
-      if (resolvedSessionDir.endsWith(suffix)) {
-        return resolvedSessionDir.slice(0, -suffix.length);
-      }
-    }
-  } catch {}
-  return getAgentDir();
-}
-function isProjectPolicyTrusted(ctx, agentDir) {
-  try {
-    if (!ctx.isProjectTrusted())
-      return false;
-    return hasTrustRequiringProjectResources(ctx.cwd) || new ProjectTrustStore(agentDir).get(ctx.cwd) === true;
-  } catch {
-    return false;
-  }
-}
-function readCompactionModelFlagFromArgv(argv = process.argv.slice(2)) {
-  let value;
-  const prefix = `--${COMPACTION_MODEL_FLAG}=`;
-  for (let i = 0;i < argv.length; i++) {
-    const arg = argv[i];
-    if (arg === "--")
-      break;
-    if (arg === `--${COMPACTION_MODEL_FLAG}`) {
-      const next = argv[i + 1];
-      if (next !== undefined && !next.startsWith("-") && !next.startsWith("@")) {
-        value = next;
-        i++;
-      } else {
-        value = true;
-      }
-    } else if (arg.startsWith(prefix)) {
-      value = arg.slice(prefix.length);
-    }
-  }
-  return value;
-}
-function resolveCompactionModelPolicy(pi, ctx, argv = process.argv.slice(2)) {
-  const argvRaw = readCompactionModelFlagFromArgv(argv);
-  if (typeof argvRaw === "string" && argvRaw.trim()) {
-    const selector = normalizeSelector(argvRaw);
-    return selector ? { hasSelectors: true, source: "flag" } : { hasSelectors: false };
-  }
-  try {
-    const rawFlag = pi.getFlag(COMPACTION_MODEL_FLAG);
-    if (typeof rawFlag === "string" && rawFlag.trim()) {
-      const selector = normalizeSelector(rawFlag);
-      return selector ? { hasSelectors: true, source: "flag" } : { hasSelectors: false };
-    }
-  } catch {}
-  const agentDir = activeAgentDir(ctx);
-  const candidates = [];
-  if (isProjectPolicyTrusted(ctx, agentDir)) {
-    candidates.push({ path: join(ctx.cwd, CONFIG_DIR_NAME, PROJECT_POLICY), source: "project-policy" });
-  }
-  candidates.push({ path: join(agentDir, PROJECT_POLICY), source: "agent-policy" });
-  for (const candidate of candidates) {
-    const selectors = readPolicySelectors(candidate.path);
-    if (selectors !== undefined) {
-      return selectors.length > 0 ? { hasSelectors: true, source: candidate.source } : { hasSelectors: false };
-    }
-  }
-  return { hasSelectors: false };
-}
-
 // protocol.ts
 var RESPONSES_APIS = new Set([
   "openai-responses",
@@ -794,14 +1022,52 @@ function validateItemSize(item) {
   if (byteLength(item) > MAX_ITEM_BYTES)
     throw new Error("Native compaction output item exceeded 2 MiB");
 }
+function validContent(value) {
+  return typeof value === "string" || Array.isArray(value) && value.every((part) => {
+    if (!isObject(part))
+      return false;
+    if (part.type === "input_text" || part.type === "output_text" || part.type === "summary_text")
+      return typeof part.text === "string";
+    if (part.type === "input_image")
+      return typeof part.image_url === "string" || typeof part.file_id === "string";
+    if (part.type === "refusal")
+      return typeof part.refusal === "string";
+    return false;
+  });
+}
 function validateCompactedOutput(value) {
   if (!isObject(value) || !Array.isArray(value.output) || value.output.length === 0) {
     throw new Error("Responses Compact returned an invalid output window");
   }
+  if (byteLength(value.output) > MAX_RESPONSE_BYTES)
+    throw new Error("Native compaction output exceeded 8 MiB");
   const output = value.output.map((item) => {
     if (!isObject(item))
       throw new Error("Responses Compact returned a non-object output item");
     validateItemSize(item);
+    const type = item.type ?? (typeof item.role === "string" ? "message" : undefined);
+    if (!["compaction", "message", "reasoning", "function_call", "function_call_output", "custom_tool_call", "custom_tool_call_output", "tool_search_call", "tool_search_output", "additional_tools"].includes(String(type)))
+      throw new Error("Responses Compact returned an unsupported output item");
+    if (type === "message" && (!["user", "assistant", "system", "developer"].includes(String(item.role)) || !validContent(item.content)))
+      throw new Error("Responses Compact returned an invalid message item");
+    if (type === "compaction" && !isCompactionItem(item))
+      throw new Error("Responses Compact returned an invalid checkpoint");
+    if (type === "reasoning" && !(typeof item.encrypted_content === "string" || Array.isArray(item.summary) && validContent(item.summary)))
+      throw new Error("Responses Compact returned invalid reasoning");
+    if (String(type).includes("call") || type === "tool_search_output") {
+      if (typeof item.call_id !== "string" || !item.call_id)
+        throw new Error("Responses Compact returned an invalid tool id");
+      if (type === "function_call" && (typeof item.name !== "string" || typeof item.arguments !== "string"))
+        throw new Error("Responses Compact returned an invalid function call");
+      if (type === "custom_tool_call" && (typeof item.name !== "string" || typeof item.input !== "string"))
+        throw new Error("Responses Compact returned an invalid custom call");
+      if ((type === "function_call_output" || type === "custom_tool_call_output") && !validContent(item.output))
+        throw new Error("Responses Compact returned an invalid tool output");
+      if (type === "tool_search_call" && !isObject(item.arguments))
+        throw new Error("Responses Compact returned an invalid tool search");
+    }
+    if ((type === "additional_tools" || type === "tool_search_output") && (!Array.isArray(item.tools) || !item.tools.every(isObject)))
+      throw new Error("Responses Compact returned invalid tools");
     return structuredClone(item);
   });
   const checkpoints = output.filter(isCompactionItem);
@@ -841,6 +1107,9 @@ async function readJsonBounded(response, signal) {
     }
   } finally {
     signal.removeEventListener("abort", onAbort);
+    reader.cancel().catch(() => {
+      return;
+    });
     reader.releaseLock();
   }
   const bytes = new Uint8Array(total);
@@ -988,7 +1257,9 @@ async function requestResponsesCompact(request) {
     onPayload: (payload) => {
       if (!isObject(payload))
         throw new Error("Responses provider exposed a non-object payload");
-      preparedPayload = { ...structuredClone(payload), input: structuredClone(request.input) };
+      if (request.preparedPayload && request.preparedPayload.model !== payload.model)
+        throw new Error("Native route model changed since capture");
+      preparedPayload = { ...structuredClone(request.preparedPayload ?? payload), input: structuredClone(request.input) };
       return preparedPayload;
     }
   });
@@ -1081,6 +1352,9 @@ async function collectCompactionSse(stream, signal) {
     dispatch();
   } finally {
     signal.removeEventListener("abort", onAbort);
+    reader.cancel().catch(() => {
+      return;
+    });
     reader.releaseLock();
   }
   if (!completed)
@@ -1118,13 +1392,15 @@ function buildRemoteV2History(input, item) {
 async function requestRemoteV2(request) {
   const baseFetch = request.fetch ?? globalThis.fetch;
   let sentInput;
+  const controller = new AbortController;
+  const signal = AbortSignal.any([request.signal, controller.signal]);
   const inspections = [];
   const inspectedFetch = async (input, init) => {
     const response = await baseFetch(input, init);
     if (!response.ok || !response.body)
       return response;
     const [providerBody, inspectionBody] = response.body.tee();
-    inspections.push(collectCompactionSse(inspectionBody, request.signal));
+    inspections.push(collectCompactionSse(inspectionBody, signal).then((result) => ({ result }), (error) => ({ error })));
     return new Response(providerBody, {
       status: response.status,
       statusText: response.statusText,
@@ -1144,440 +1420,573 @@ async function requestRemoteV2(request) {
       if (!isObject(payload))
         throw new Error("Codex provider exposed a non-object payload");
       sentInput = structuredClone(request.input);
-      return { ...structuredClone(payload), input: [...sentInput, { type: "compaction_trigger" }] };
+      if (request.preparedPayload && request.preparedPayload.model !== payload.model)
+        throw new Error("Native route model changed since capture");
+      return { ...structuredClone(request.preparedPayload ?? payload), stream: true, input: [...sentInput, { type: "compaction_trigger" }] };
     }
   });
-  const usage = await collectProviderUsage(stream, request.signal);
-  if (!sentInput || inspections.length !== 1) {
-    throw new Error(`Remote V2 observed ${inspections.length} successful provider responses; expected exactly one`);
+  try {
+    const usage = await collectProviderUsage(stream, request.signal);
+    if (!sentInput || inspections.length !== 1)
+      throw new Error(`Remote V2 observed ${inspections.length} successful provider responses; expected exactly one`);
+    const inspection = await inspections[0];
+    if ("error" in inspection)
+      throw inspection.error;
+    return { output: buildRemoteV2History(sentInput, inspection.result.item), usage };
+  } finally {
+    controller.abort();
   }
-  const inspection = await inspections[0];
-  return { output: buildRemoteV2History(sentInput, inspection.item), usage };
 }
 async function requestProviderCompaction(request) {
-  return request.protocol === "remote-v2" ? requestRemoteV2(request) : requestResponsesCompact(request);
+  const result = await (request.protocol === "remote-v2" ? requestRemoteV2(request) : requestResponsesCompact(request));
+  return { ...result, output: validateCompactedOutput(result) };
 }
 
-// index.ts
-var NATIVE_COMPACTION_TYPE = "pi-provider-compaction/openai-responses";
-var NATIVE_COMPACTION_VERSION = 2;
-var NATIVE_COMPACTION_SUMMARY = "This context was compacted using the provider's native OpenAI Responses state.";
+// replay.ts
 var TOOL_CALL_PROVIDERS = new Set(["openai", "openai-codex", "opencode"]);
-function supportsNativeCompaction(model) {
-  return supportsResponsesApi(model);
+var AZURE_TOOL_CALL_PROVIDERS = new Set([...TOOL_CALL_PROVIDERS, "azure"]);
+var MAX_SNAPSHOT_BYTES = 8 * 1024 * 1024;
+var SNAPSHOT_TTL_MS = 5 * 60000;
+function equal(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function serializeInput(model, context, declarations = context) {
+  const compat = model.compat;
+  const flag = (name) => compat?.[name] === true;
+  const codex = model.api === "openai-codex-responses";
+  const normalized = resolveTranscript2(context, flag("supportsMidConvoSystemMessages"));
+  const tools = resolveTranscript2(declarations, flag("supportsMidConvoSystemMessages"));
+  return convertResponsesMessages(model, normalized, model.api === "azure-openai-responses" ? AZURE_TOOL_CALL_PROVIDERS : TOOL_CALL_PROVIDERS, {
+    includeSystemPrompt: !codex,
+    grammarToolInputProperties: createGrammarToolInputProperties(getDeclaredTools(tools.messages), flag("supportsOpenAIGrammarTools")),
+    supportsMidConvoSystemMessages: flag("supportsMidConvoSystemMessages"),
+    supportsAdditionalTools: flag("supportsAdditionalTools"),
+    supportsToolSearch: flag("supportsToolSearch"),
+    toolOptions: {
+      ...codex ? { strict: null } : {},
+      supportsStrictMode: compat?.supportsStrictMode ?? model.api !== "openai-responses",
+      supportsOpenAIGrammarTools: flag("supportsOpenAIGrammarTools")
+    }
+  });
 }
-function readUsage(value) {
-  if (!isObject(value) || !isObject(value.cost))
+function capturePreparedRequest(model, context, canonical, payload, reject = () => {}) {
+  if (!isObject(payload) || !Array.isArray(payload.input) || !payload.input.every(isObject)) {
+    reject("unsupported payload shape");
     return;
-  for (const key of ["input", "output", "cacheRead", "cacheWrite", "totalTokens"]) {
-    if (typeof value[key] !== "number" || !Number.isFinite(value[key]))
-      return;
   }
-  for (const key of ["input", "output", "cacheRead", "cacheWrite", "total"]) {
-    if (typeof value.cost[key] !== "number" || !Number.isFinite(value.cost[key]))
-      return;
+  if (payload.previous_response_id || payload.conversation) {
+    reject("stateful request");
+    return;
   }
-  return value;
-}
-function readIdentity(value) {
-  if (!isObject(value) || typeof value.endpoint !== "string" || !value.endpoint)
+  if (Buffer.byteLength(JSON.stringify({ context, payload })) > MAX_SNAPSHOT_BYTES) {
+    reject("snapshot exceeds size limit");
     return;
-  for (const key of ["organization", "project", "accountId", "azureApiVersion", "azureDeployment"]) {
-    if (value[key] !== undefined && typeof value[key] !== "string")
-      return;
   }
-  return {
-    endpoint: value.endpoint,
-    organization: value.organization,
-    project: value.project,
-    accountId: value.accountId,
-    azureApiVersion: value.azureApiVersion,
-    azureDeployment: value.azureDeployment
-  };
+  const expected = serializeInput(model, context);
+  if (!equal(expected, payload.input)) {
+    reject("prepared input differs from serializer");
+    return;
+  }
+  return { context: structuredClone(context), canonical: structuredClone(canonical), payload: structuredClone(payload), portableInput: expected, createdAt: Date.now() };
+}
+function promptCount(input) {
+  let count = 0;
+  while (input[count]?.role === "system" || input[count]?.role === "developer")
+    count++;
+  return count;
+}
+function closedTools(context) {
+  const pending = new Set;
+  for (const message of context.messages) {
+    if (message.role === "assistant") {
+      if (message.stopReason === "error" || message.stopReason === "aborted")
+        return false;
+      for (const block of message.content)
+        if (block.type === "toolCall") {
+          if (pending.has(block.id))
+            return false;
+          pending.add(block.id);
+        }
+    } else if (message.role === "toolResult") {
+      if (!pending.delete(message.toolCallId))
+        return false;
+    }
+  }
+  return pending.size === 0;
 }
-function readNativeCompactionDetails(value) {
-  if (!isObject(value) || value.type !== NATIVE_COMPACTION_TYPE)
+function mappedPrefix(snapshot, prefix) {
+  if (!equal(snapshot.canonical.messages.slice(0, prefix.messages.length), prefix.messages))
     return;
-  if (value.version !== 1 && value.version !== NATIVE_COMPACTION_VERSION)
+  const head = prefix.messages[0]?.role === "system" ? 1 : 0;
+  if (head && snapshot.context.messages[0]?.role !== "system")
     return;
-  if (typeof value.provider !== "string" || typeof value.api !== "string" || typeof value.model !== "string")
+  if (!equal(snapshot.context.messages.slice(head, prefix.messages.length), prefix.messages.slice(head)))
     return;
-  if (!Array.isArray(value.output) || !value.output.every(isObject) || !value.output.some(isCompactionItem))
+  return normalizeContext({ messages: snapshot.context.messages.slice(0, prefix.messages.length) });
+}
+function selectCoveredPrefix(model, snapshot, prefix, reject = () => {}) {
+  if (Date.now() - snapshot.createdAt > SNAPSHOT_TTL_MS) {
+    reject("snapshot expired");
     return;
-  const protocol = value.version === 1 ? "responses-compact" : value.protocol === "responses-compact" || value.protocol === "remote-v2" ? value.protocol : undefined;
-  if (!protocol)
+  }
+  if (!closedTools(prefix)) {
+    reject("prefix has an incomplete tool exchange or failed assistant");
     return;
-  const strings = (candidate) => candidate === undefined ? undefined : Array.isArray(candidate) && candidate.every((item) => typeof item === "string") ? [...candidate] : undefined;
-  return {
-    type: NATIVE_COMPACTION_TYPE,
-    version: value.version,
-    provider: value.provider,
-    api: value.api,
-    model: value.model,
-    protocol,
-    identity: value.version === 1 ? undefined : readIdentity(value.identity),
-    output: structuredClone(value.output),
-    nativeUsage: readUsage(value.nativeUsage ?? value.usage),
-    usage: readUsage(value.usage),
-    portableUsage: readUsage(value.portableUsage),
-    readFiles: strings(value.readFiles),
-    modifiedFiles: strings(value.modifiedFiles)
-  };
-}
-function identityEqual(left, right) {
-  if (!left)
-    return true;
-  if (!right)
-    return false;
-  return left.endpoint === right.endpoint && left.organization === right.organization && left.project === right.project && left.accountId === right.accountId && left.azureApiVersion === right.azureApiVersion && left.azureDeployment === right.azureDeployment;
-}
-function findLatestNativeCompaction(entries, model, identity) {
-  if (!supportsNativeCompaction(model))
+  }
+  const mapped = mappedPrefix(snapshot, prefix);
+  if (!mapped) {
+    reject("projected prefix differs from request context");
     return;
-  for (let index = entries.length - 1;index >= 0; index--) {
-    const entry = entries[index];
-    if (entry.type !== "compaction")
-      continue;
-    const details = readNativeCompactionDetails(entry.details);
-    if (!details)
-      return;
-    if (details.provider !== model.provider || details.api !== model.api || details.model !== model.id)
-      return;
-    if (!identityEqual(details.identity, identity))
-      return;
-    return { ...details, entryId: entry.id };
   }
-  return;
-}
-function responseItemsFromMessages(model, messages) {
-  const input = convertResponsesMessages(model, { messages: convertToLlm(messages), tools: [] }, TOOL_CALL_PROVIDERS, { includeSystemPrompt: false });
-  return input.filter(isObject);
-}
-function responseItemsFromEntries(model, entries) {
-  return responseItemsFromMessages(model, entries.flatMap((entry) => sessionEntryToContextMessages(entry)));
-}
-function nativeRequestInput(model, branchEntries, activeEntries, previous) {
-  if (previous) {
-    const previousIndex = branchEntries.findIndex((entry) => entry.id === previous.entryId);
-    if (previousIndex >= 0) {
-      return [...structuredClone(previous.output), ...responseItemsFromEntries(model, branchEntries.slice(previousIndex + 1))];
+  const expected = serializeInput(model, mapped, snapshot.context);
+  if (!equal(snapshot.portableInput.slice(0, expected.length), expected)) {
+    reject("serialized prefix does not match prepared input");
+    return;
+  }
+  const start = promptCount(expected);
+  let end = expected.length;
+  if (snapshot.replacement) {
+    if (snapshot.replacement.index < start || snapshot.replacement.index >= end) {
+      reject("previous native slot is outside covered prefix");
+      return;
     }
+    end += snapshot.replacement.count - 1;
   }
-  return responseItemsFromEntries(model, activeEntries);
-}
-function authHeaders(apiKey, headers) {
-  const result = { "content-type": "application/json" };
-  let hasAuthorization = false;
-  for (const [name, value] of Object.entries(headers ?? {})) {
-    if (value === null)
-      continue;
-    result[name] = value;
-    if (name.toLowerCase() === "authorization" && value.trim())
-      hasAuthorization = true;
+  if (end <= start) {
+    reject("empty covered prefix");
+    return;
   }
-  if (!hasAuthorization && apiKey)
-    result.authorization = `Bearer ${apiKey}`;
-  return result;
+  return structuredClone(snapshot.payload.input.slice(start, end));
 }
-async function compactOpenAIResponses(options) {
-  const endpoint = `${options.baseUrl.replace(/\/+$/, "")}/responses/compact`;
-  const body = { model: options.model.id, input: options.input };
-  if (options.instructions)
-    body.instructions = options.instructions;
-  const response = await (options.fetchImpl ?? fetch)(endpoint, {
-    method: "POST",
-    headers: authHeaders(options.apiKey, options.headers),
-    body: JSON.stringify(body),
-    signal: options.signal
-  });
-  if (!response.ok) {
-    const detail = await response.text().catch(() => "");
-    throw new Error(`OpenAI Responses compact request failed (${response.status}${detail ? `: ${detail.slice(0, 400)}` : ""})`);
-  }
-  const result = await response.json();
-  if (!isObject(result) || !Array.isArray(result.output) || !result.output.every(isObject) || !result.output.some(isCompactionItem)) {
-    throw new Error("OpenAI Responses compact response did not contain opaque compaction state");
-  }
-  const usage = compactUsage(options.model, result);
-  return {
-    type: NATIVE_COMPACTION_TYPE,
-    version: NATIVE_COMPACTION_VERSION,
-    provider: options.model.provider,
-    api: options.model.api,
-    model: options.model.id,
-    protocol: "responses-compact",
-    output: structuredClone(result.output),
-    nativeUsage: usage,
-    usage
-  };
+function substituteSummary(payload, index, summary, output) {
+  if (!isObject(payload) || !Array.isArray(payload.input) || !payload.input.every(isObject))
+    return;
+  if (!equal(payload.input[index], summary))
+    return;
+  if (payload.input.filter((item) => equal(item, summary)).length !== 1)
+    return;
+  return { ...payload, input: [...payload.input.slice(0, index), ...structuredClone(output), ...payload.input.slice(index + 1)] };
 }
-function compactUsage(model, result) {
-  const usage = result.usage;
-  if (!isObject(usage))
+function summarySlot(model, snapshot, summaryPrefix) {
+  const mapped = mappedPrefix(snapshot, summaryPrefix);
+  if (!mapped)
     return;
-  const cached = nestedNumber(usage.input_tokens_details, "cached_tokens");
-  const cacheWrite = nestedNumber(usage.input_tokens_details, "cache_write_tokens");
-  const mapped = {
-    input: Math.max(0, readNumber(usage.input_tokens) - cached - cacheWrite),
-    output: readNumber(usage.output_tokens),
-    cacheRead: cached,
-    cacheWrite,
-    reasoning: nestedNumber(usage.output_tokens_details, "reasoning_tokens"),
-    totalTokens: readNumber(usage.total_tokens),
-    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
-  };
-  try {
-    calculateCost(model, mapped);
-  } catch {}
-  return mapped;
-}
-function readNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : 0;
-}
-function nestedNumber(value, key) {
-  return isObject(value) ? readNumber(value[key]) : 0;
-}
-function stableStringify(value) {
-  if (Array.isArray(value))
-    return `[${value.map(stableStringify).join(",")}]`;
-  if (isObject(value)) {
-    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(",")}}`;
-  }
-  return JSON.stringify(value) ?? "null";
-}
-function itemMatches(left, right) {
-  const leftId = typeof left.id === "string" ? left.id : undefined;
-  const rightId = typeof right.id === "string" ? right.id : undefined;
-  if (leftId && rightId)
-    return leftId === rightId;
-  const leftCallId = typeof left.call_id === "string" ? left.call_id : undefined;
-  const rightCallId = typeof right.call_id === "string" ? right.call_id : undefined;
-  if (leftCallId && rightCallId)
-    return leftCallId === rightCallId && left.type === right.type;
-  if (left.type === "message" && right.type === "message") {
-    return left.role === right.role && stableStringify(left.content) === stableStringify(right.content);
-  }
-  return stableStringify(left) === stableStringify(right);
-}
-function findLastSubsequence(items, sequence) {
-  if (sequence.length === 0)
-    return -1;
-  for (let start = items.length - sequence.length;start >= 0; start--) {
-    if (sequence.every((item, offset) => itemMatches(items[start + offset], item)))
-      return start;
-  }
-  return -1;
-}
-function rewriteResponsesPayload(payload, details, postCompactionItems) {
-  if (!isObject(payload) || !Array.isArray(payload.input))
-    return payload;
-  const currentInput = payload.input.filter(isObject);
-  if (currentInput.length !== payload.input.length)
-    return payload;
-  const postStart = findLastSubsequence(currentInput, postCompactionItems);
-  if (postStart >= 0)
-    return { ...payload, input: [...structuredClone(details.output), ...currentInput.slice(postStart)] };
-  const retainedOutput = details.output.filter((item) => item.type !== "compaction");
-  const retainedStart = findLastSubsequence(currentInput, retainedOutput);
-  if (retainedStart >= 0) {
-    return { ...payload, input: [...structuredClone(details.output), ...currentInput.slice(retainedStart + retainedOutput.length)] };
-  }
-  return { ...payload, input: [...structuredClone(details.output), ...structuredClone(postCompactionItems)] };
-}
-function genericCompactionSelected(pi, ctx) {
-  return resolveCompactionModelPolicy(pi, ctx).hasSelectors;
-}
-function normalizedEndpoint(value) {
-  if (!value)
-    return "";
-  try {
-    const url = new URL(value);
-    url.username = "";
-    url.password = "";
-    url.search = "";
-    url.hash = "";
-    return url.toString().replace(/\/+$/, "");
-  } catch {
-    return value.replace(/\/+$/, "");
-  }
+  const prefix = serializeInput(model, mapped, snapshot.context);
+  const index = promptCount(prefix);
+  if (prefix.length !== index + 1 || !equal(snapshot.portableInput.slice(0, prefix.length), prefix))
+    return;
+  return index;
 }
-function headerValue(headers, name) {
-  const match = Object.entries(headers ?? {}).find(([key]) => key.toLowerCase() === name.toLowerCase());
-  return typeof match?.[1] === "string" && match[1] ? match[1] : undefined;
+function requestPolicy(model, snapshot) {
+  return {
+    model,
+    system: getCurrentSystemPrompt(snapshot.context.messages),
+    currentTools: getCurrentTools2(snapshot.context.messages),
+    declarations: getDeclaredTools(resolveTranscript2(snapshot.context, model.compat?.supportsMidConvoSystemMessages).messages),
+    instructions: snapshot.payload.instructions,
+    tools: snapshot.payload.tools,
+    prompt: snapshot.portableInput.slice(0, promptCount(snapshot.portableInput))
+  };
 }
-function codexAccountId(apiKey) {
-  if (!apiKey)
+
+// index.ts
+var NATIVE_COMPACTION_TYPE = "pi-provider-compaction/openai-responses";
+var NATIVE_COMPACTION_VERSION = 3;
+var NATIVE_COMPACTION_SUMMARY = "This context was compacted using the provider's native OpenAI Responses state.";
+var supportsNativeCompaction = supportsResponsesApi;
+var digest = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
+var transcript = (messages) => normalizeContext2({ messages: convertToLlm(messages) });
+function readNativeCompactionDetails(value) {
+  if (!isObject(value) || value.type !== NATIVE_COMPACTION_TYPE || value.version !== 1 && value.version !== 2 && value.version !== 3)
+    return;
+  if (typeof value.provider !== "string" || typeof value.api !== "string" || typeof value.model !== "string")
     return;
-  const parts = apiKey.split(".");
-  if (parts.length !== 3)
+  const protocol = value.version === 1 ? "responses-compact" : value.protocol;
+  if (protocol !== "responses-compact" && protocol !== "remote-v2")
     return;
   try {
-    const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf8"));
-    if (!isObject(payload))
-      return;
-    const auth = payload["https://api.openai.com/auth"];
-    return isObject(auth) && typeof auth.chatgpt_account_id === "string" ? auth.chatgpt_account_id : undefined;
+    const output = validateCompactedOutput(value);
+    if (value.version === 3) {
+      const coverage = value.coverage;
+      if (!isObject(coverage) || coverage.kind !== "summarized-prefix")
+        return;
+      for (const field of ["firstKeptEntryId", "sourceLeafId", "sourceHash", "policyHash", "inputHash", "runtimeId"]) {
+        if (typeof coverage[field] !== "string" || !coverage[field])
+          return;
+      }
+      if (!isObject(value.identity) || typeof value.identity.endpoint !== "string")
+        return;
+    }
+    return { ...structuredClone(value), protocol, output };
   } catch {
     return;
   }
 }
-function azureDeployment(modelId, env) {
-  const raw = env?.AZURE_OPENAI_DEPLOYMENT_NAME_MAP;
-  if (!raw)
-    return modelId;
-  for (const entry of raw.split(",")) {
-    const [candidate, deployment] = entry.split("=", 2).map((part) => part?.trim());
-    if (candidate === modelId && deployment)
-      return deployment;
+function latestCompaction(branch) {
+  for (let index = branch.length - 1;index >= 0; index--) {
+    const entry = branch[index];
+    if (entry.type === "compaction")
+      return entry;
   }
-  return modelId;
-}
-function routeIdentity(model, auth) {
-  const azure = model.api === "azure-openai-responses";
-  return {
-    endpoint: normalizedEndpoint(auth.baseUrl ?? auth.env?.AZURE_OPENAI_BASE_URL ?? model.baseUrl),
-    organization: headerValue(auth.headers, "openai-organization"),
-    project: headerValue(auth.headers, "openai-project"),
-    accountId: model.api === "openai-codex-responses" ? codexAccountId(auth.apiKey) : undefined,
-    azureApiVersion: azure ? auth.env?.AZURE_OPENAI_API_VERSION || "v1" : undefined,
-    azureDeployment: azure ? azureDeployment(model.id, auth.env) : undefined
-  };
+  return;
 }
-function activeTools(pi) {
-  const available = new Map(pi.getAllTools().map((tool) => [tool.name, tool]));
-  return pi.getActiveTools().flatMap((name) => {
-    const tool = available.get(name);
-    return tool ? [{ name: tool.name, description: tool.description, parameters: tool.parameters }] : [];
-  });
+function header(headers, name) {
+  const value = Object.entries(headers ?? {}).find(([key]) => key.toLowerCase() === name)?.[1];
+  return typeof value === "string" && value ? value : undefined;
 }
-function providerContext(pi, ctx, activeEntries) {
-  const messages = activeEntries.flatMap((entry) => sessionEntryToContextMessages(entry));
+function identity(model, options) {
+  const azure = model.api === "azure-openai-responses";
+  const azureBase = options.env?.AZURE_OPENAI_BASE_URL || (options.env?.AZURE_OPENAI_RESOURCE_NAME ? `https://${options.env.AZURE_OPENAI_RESOURCE_NAME}.openai.azure.com/openai/v1` : undefined);
+  const url = new URL(azure ? azureBase ?? model.baseUrl : model.baseUrl);
+  url.username = "";
+  url.password = "";
+  url.search = "";
+  url.hash = "";
+  let accountId = header(options.headers, "chatgpt-account-id");
+  if (!accountId && model.api === "openai-codex-responses" && options.apiKey) {
+    try {
+      const token = JSON.parse(Buffer.from(options.apiKey.split(".")[1], "base64url").toString("utf8"));
+      const id = token["https://api.openai.com/auth"]?.chatgpt_account_id;
+      if (typeof id === "string")
+        accountId = id;
+    } catch {}
+  }
+  const map = options.env?.AZURE_OPENAI_DEPLOYMENT_NAME_MAP?.split(",").map((entry) => entry.split("=").map((part) => part.trim()));
   return {
-    systemPrompt: ctx.getSystemPrompt(),
-    messages: convertToLlm(messages),
-    tools: activeTools(pi)
+    endpoint: url.toString().replace(/\/+$/, ""),
+    organization: header(options.headers, "openai-organization"),
+    project: header(options.headers, "openai-project"),
+    accountId,
+    azureApiVersion: azure ? options.env?.AZURE_OPENAI_API_VERSION ?? "v1" : undefined,
+    azureDeployment: azure ? map?.find(([id]) => id === model.id)?.[1] ?? model.id : undefined
   };
 }
-function cleanHeaders(headers) {
-  if (!headers)
-    return;
-  return Object.fromEntries(Object.entries(headers).filter((entry) => entry[1] !== null));
-}
 function combineUsage(first, second) {
   if (!first)
     return second;
   if (!second)
     return first;
-  return {
-    input: first.input + second.input,
-    output: first.output + second.output,
-    cacheRead: first.cacheRead + second.cacheRead,
-    cacheWrite: first.cacheWrite + second.cacheWrite,
-    cacheWrite1h: first.cacheWrite1h !== undefined || second.cacheWrite1h !== undefined ? (first.cacheWrite1h ?? 0) + (second.cacheWrite1h ?? 0) : undefined,
-    reasoning: first.reasoning !== undefined || second.reasoning !== undefined ? (first.reasoning ?? 0) + (second.reasoning ?? 0) : undefined,
-    totalTokens: first.totalTokens + second.totalTokens,
-    cost: {
-      input: first.cost.input + second.cost.input,
-      output: first.cost.output + second.cost.output,
-      cacheRead: first.cost.cacheRead + second.cost.cacheRead,
-      cacheWrite: first.cost.cacheWrite + second.cost.cacheWrite,
-      total: first.cost.total + second.cost.total
-    }
-  };
+  const result = structuredClone(first);
+  for (const key of ["input", "output", "cacheRead", "cacheWrite", "totalTokens"])
+    result[key] += second[key];
+  for (const key of ["reasoning", "cacheWrite1h"])
+    if (first[key] !== undefined || second[key] !== undefined)
+      result[key] = (first[key] ?? 0) + (second[key] ?? 0);
+  for (const key of ["input", "output", "cacheRead", "cacheWrite", "total"])
+    result.cost[key] += second.cost[key];
+  return result;
 }
-async function nativeAndPortableCompaction(pi, event, ctx) {
-  const model = ctx.model;
-  const protocol = resolveNativeProtocol(model);
-  if (!model || !protocol || genericCompactionSelected(pi, ctx))
-    return;
-  const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
-  if (!auth.ok)
-    return;
-  const provider = ctx.modelRegistry.getProvider(model.provider);
-  if (!provider)
-    return;
-  const identity = routeIdentity(model, auth);
-  const branchEntries = event.branchEntries;
-  const activeEntries = ctx.sessionManager.buildContextEntries();
-  const previous = findLatestNativeCompaction(branchEntries, model, identity);
-  const input = nativeRequestInput(model, branchEntries, activeEntries, previous);
-  const native = await requestProviderCompaction({
-    provider,
-    model,
-    context: providerContext(pi, ctx, activeEntries),
-    input,
-    protocol,
-    apiKey: auth.apiKey,
-    headers: auth.headers,
-    env: auth.env,
-    signal: event.signal
-  });
-  const portable = await compact(event.preparation, model, auth.apiKey, cleanHeaders(auth.headers), event.customInstructions, event.signal, ctx.thinkingLevel, provider.streamSimple.bind(provider), auth.env, undefined, undefined, ctx.sessionManager.getSessionId());
-  const portableDetails = isObject(portable.details) ? portable.details : {};
-  const details = {
-    type: NATIVE_COMPACTION_TYPE,
-    version: NATIVE_COMPACTION_VERSION,
-    provider: model.provider,
-    api: model.api,
-    model: model.id,
-    protocol,
-    identity,
-    output: native.output,
-    nativeUsage: native.usage,
-    portableUsage: portable.usage,
-    readFiles: Array.isArray(portableDetails.readFiles) ? portableDetails.readFiles.filter((item) => typeof item === "string") : undefined,
-    modifiedFiles: Array.isArray(portableDetails.modifiedFiles) ? portableDetails.modifiedFiles.filter((item) => typeof item === "string") : undefined
+function supportedRouteOptions(model, options) {
+  if (model.api !== "azure-openai-responses")
+    return true;
+  const extra = options;
+  if (["azureBaseUrl", "azureResourceName", "azureApiVersion", "azureDeploymentName"].some((key) => extra[key] !== undefined))
+    return false;
+  return !["AZURE_OPENAI_BASE_URL", "AZURE_OPENAI_RESOURCE_NAME", "AZURE_OPENAI_API_VERSION", "AZURE_OPENAI_DEPLOYMENT_NAME_MAP"].some((key) => process.env[key] !== undefined && options.env?.[key] === undefined);
+}
+function pi_provider_compaction_default(pi) {
+  const secret = randomBytes(32);
+  const routeDigest = (value) => createHmac("sha256", secret).update(JSON.stringify(value)).digest("hex");
+  let runtimeId = randomUUID();
+  let ctx;
+  let snapshot;
+  let active;
+  let pending;
+  let uninstall;
+  let installedProvider;
+  let generation = 0;
+  let captureStatus = "no request observed";
+  let compactionStatus = "not attempted in this runtime";
+  const captureRejected = (reason) => {
+    captureStatus = reason;
   };
-  return {
-    compaction: {
-      ...portable,
-      usage: combineUsage(native.usage, portable.usage),
-      details
+  const fallback = (reason) => {
+    compactionStatus = `portable: ${reason}`;
+  };
+  pi.registerCommand("provider-compaction-status", {
+    description: "Show content-free native compaction eligibility and last attempt",
+    handler: async (_args, context) => {
+      context.ui.notify(`Provider compaction
+Observer: ${installedProvider ? "installed" : "unavailable for current registration"}
+Capture: ${captureStatus}
+Last attempt: ${compactionStatus}`, "info");
     }
+  });
+  const invalidate = () => {
+    generation++;
+    runtimeId = randomUUID();
+    snapshot = undefined;
+    active = undefined;
+    pending = undefined;
+    captureStatus = "invalidated by lifecycle/history/policy change";
   };
-}
-function pi_provider_compaction_default(pi) {
-  pi.on("before_provider_request", async (event, ctx) => {
-    const model = ctx.model;
-    if (!supportsNativeCompaction(model))
+  const generic = (context) => resolveCompactionModelPolicy(pi, context).hasSelectors;
+  const route = (model, options) => routeDigest({ model, apiKey: options.apiKey, headers: options.headers, env: options.env });
+  const unchanged = (branch, length, hash) => branch.length >= length && digest(branch.slice(0, length)) === hash && !branch.slice(length).some((entry) => entry.type === "context_edit");
+  const observe = (model, context, options) => {
+    const owner = ctx;
+    if (!owner || options.sessionId !== owner.sessionManager.getSessionId())
       return;
-    const branch = ctx.sessionManager.getBranch();
-    const candidate = findLatestNativeCompaction(branch, model);
-    if (!candidate || genericCompactionSelected(pi, ctx))
+    if (!supportsNativeCompaction(model)) {
+      captureRejected("unsupported API");
       return;
-    const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
-    if (!auth.ok)
+    }
+    if (!options.onPayload) {
+      captureRejected("no payload callback");
       return;
-    const latest = findLatestNativeCompaction(branch, model, routeIdentity(model, auth));
-    if (!latest)
+    }
+    if (generic(owner)) {
+      captureRejected("generic compaction model takes precedence");
       return;
-    const index = branch.findIndex((entry) => entry.id === latest.entryId);
-    const postItems = index >= 0 ? responseItemsFromEntries(model, branch.slice(index + 1)) : [];
-    const rewritten = rewriteResponsesPayload(event.payload, latest, postItems);
-    if (rewritten === event.payload || !isObject(rewritten))
-      return rewritten;
-    const systemPrompt = ctx.getSystemPrompt();
-    return systemPrompt ? { ...rewritten, instructions: systemPrompt } : rewritten;
+    }
+    if (!supportedRouteOptions(model, options)) {
+      captureRejected("unsupported route overrides");
+      return;
+    }
+    const ticket = generation;
+    const branch = owner.sessionManager.getBranch();
+    const branchHash = digest(branch);
+    const canonical = transcript(owner.sessionManager.buildSessionProjection().messages);
+    const current = () => generation === ticket && ctx === owner && !options.signal?.aborted && supportedRouteOptions(model, options) && digest(owner.sessionManager.getBranch()) === branchHash;
+    return async (payload) => {
+      if (!current())
+        return payload;
+      snapshot = undefined;
+      const prepared = capturePreparedRequest(model, context, canonical, payload, captureRejected);
+      if (!prepared) {
+        active = undefined;
+        return payload;
+      }
+      const auth = await owner.modelRegistry.getApiKeyAndHeaders(model);
+      if (!current())
+        return payload;
+      const normalizedHeaders = (headers) => Object.entries(headers ?? {}).map(([name, value]) => [name.toLowerCase(), value]).sort(([a], [b]) => String(a).localeCompare(String(b)));
+      if (!auth.ok || generic(owner) || auth.apiKey !== options.apiKey || (auth.baseUrl ?? model.baseUrl) !== model.baseUrl || !equal(normalizedHeaders(auth.headers), normalizedHeaders(options.headers)) || !equal(auth.env ?? {}, options.env ?? {})) {
+        active = undefined;
+        captureRejected("resolved auth/route differs from prepared request, or generic policy changed");
+        return payload;
+      }
+      const provider = owner.modelRegistry.getProvider(model.provider);
+      if (!provider) {
+        captureRejected("provider unavailable");
+        return payload;
+      }
+      const routeHash = route(model, options);
+      const policyHash = digest(requestPolicy(model, prepared));
+      const latest = latestCompaction(branch);
+      let result = payload;
+      if (active && latest?.id === active.entryId && latest.summary === active.summary && digest(latest.details) === active.detailsHash && unchanged(branch, active.branchLength, active.branchHash) && active.routeHash === routeHash && active.policyHash === policyHash) {
+        const details = readNativeCompactionDetails(latest.details);
+        const projection = owner.sessionManager.buildSessionProjection();
+        const contribution = projection.entries.find((entry) => entry.sourceEntry.id === latest.id);
+        const prefix = contribution ? transcript(contribution.messages) : undefined;
+        const slot = prefix ? summarySlot(model, prepared, prefix) : undefined;
+        if (details?.version === 3 && details.coverage?.runtimeId === runtimeId && details.coverage.firstKeptEntryId === latest.firstKeptEntryId && slot !== undefined) {
+          const replaced = substituteSummary(payload, slot, prepared.portableInput[slot], details.output);
+          if (replaced) {
+            result = replaced;
+            prepared.payload = structuredClone(replaced);
+            prepared.replacement = { index: slot, count: details.output.length };
+          } else
+            active = undefined;
+        } else
+          active = undefined;
+      } else
+        active = undefined;
+      captureStatus = "eligible prepared request captured";
+      snapshot = {
+        prepared,
+        model: structuredClone(model),
+        provider,
+        options: { apiKey: options.apiKey, headers: structuredClone(options.headers), env: structuredClone(options.env), fetch: options.fetch },
+        branchLength: branch.length,
+        branchHash,
+        routeHash,
+        authHash: routeDigest(auth),
+        policyHash,
+        sessionId: owner.sessionManager.getSessionId()
+      };
+      return result;
+    };
+  };
+  const install = (context) => {
+    ctx = context;
+    if (installedProvider === context.model?.provider)
+      return;
+    uninstall?.();
+    uninstall = undefined;
+    installedProvider = undefined;
+    if (!supportsNativeCompaction(context.model))
+      return;
+    uninstall = installObserver(pi, context, observe);
+    if (uninstall)
+      installedProvider = context.model.provider;
+    captureStatus = uninstall ? "awaiting prepared request" : "unsupported provider registration";
+  };
+  pi.on("session_start", (_event, context) => {
+    invalidate();
+    install(context);
+    const latest = latestCompaction(context.sessionManager.getBranch());
+    if (latest?.summary === NATIVE_COMPACTION_SUMMARY)
+      context.ui.notify("Legacy native compaction has no portable summary. Native replay is disabled; recover from earlier history or start a new session.", "warning");
   });
-  pi.on("session_before_compact", async (event, ctx) => {
-    try {
-      return await nativeAndPortableCompaction(pi, event, ctx);
-    } catch (error) {
-      if (event.signal.aborted || error instanceof Error && error.name === "AbortError")
-        return;
-      console.error(`[pi-provider-compaction] native compaction failed: ${error instanceof Error ? error.message : String(error)}`);
+  pi.on("before_agent_start", (_event, context) => {
+    install(context);
+  });
+  pi.on("model_select", (_event, context) => {
+    invalidate();
+    install(context);
+  });
+  pi.on("session_tree", () => {
+    invalidate();
+  });
+  pi.on("session_shutdown", () => {
+    invalidate();
+    uninstall?.();
+    uninstall = undefined;
+    installedProvider = undefined;
+    ctx = undefined;
+  });
+  const removeInvalidation = pi.events.on("pi-provider-compaction:invalidate", invalidate);
+  pi.on("session_shutdown", () => {
+    if (typeof removeInvalidation === "function")
+      removeInvalidation();
+  });
+  pi.on("session_before_compact", async (event, context) => {
+    const capture = snapshot;
+    snapshot = undefined;
+    pending = undefined;
+    if (!capture) {
+      fallback(`no eligible snapshot (${captureStatus})`);
+      return;
+    }
+    if (!context.model || generic(context) || event.signal.aborted) {
+      fallback("missing model, generic model override, or aborted attempt");
+      return;
+    }
+    const protocol = resolveNativeProtocol(context.model);
+    if (!protocol || context.sessionManager.getSessionId() !== capture.sessionId) {
+      fallback("unsupported protocol or changed session");
+      return;
+    }
+    const ticket = generation;
+    const branch = context.sessionManager.getBranch();
+    const branchHash = digest(branch);
+    if (!equal(branch, event.branchEntries) || !unchanged(branch, capture.branchLength, capture.branchHash)) {
+      fallback("history changed since capture");
       return;
     }
+    const projection = context.sessionManager.buildSessionProjection();
+    const boundary = projection.entries.findIndex((entry) => entry.sourceEntry.id === event.preparation.firstKeptEntryId);
+    if (boundary < 0) {
+      fallback("retained boundary missing from projection");
+      return;
+    }
+    const prefix = transcript(projection.entries.slice(0, boundary).flatMap((entry) => entry.messages));
+    const input = selectCoveredPrefix(capture.model, capture.prepared, prefix, fallback);
+    if (!input)
+      return;
+    const current = () => ticket === generation && !event.signal.aborted && supportedRouteOptions(capture.model, capture.options) && !generic(context) && context.modelRegistry.getProvider(capture.model.provider) === capture.provider && digest(context.sessionManager.getBranch()) === branchHash;
+    const auth = await context.modelRegistry.getApiKeyAndHeaders(context.model);
+    if (!current())
+      return { cancel: true };
+    if (!auth.ok || routeDigest(auth) !== capture.authHash) {
+      fallback("auth changed since capture");
+      return;
+    }
+    compactionStatus = "generating portable summary";
+    let portable;
+    try {
+      portable = await compact(event.preparation, capture.model, auth.apiKey, auth.headers, event.customInstructions, event.signal, context.thinkingLevel, capture.provider.streamSimple.bind(capture.provider), auth.env, undefined, undefined, capture.sessionId);
+    } catch {
+      return !current() ? { cancel: true } : undefined;
+    }
+    if (!current() || !portable.summary.trim() || portable.summary === NATIVE_COMPACTION_SUMMARY)
+      return { cancel: true };
+    try {
+      const freshAuth = await context.modelRegistry.getApiKeyAndHeaders(context.model);
+      if (!current())
+        return { cancel: true };
+      if (!freshAuth.ok || routeDigest(freshAuth) !== capture.authHash) {
+        fallback("auth changed after portable generation");
+        return { compaction: portable };
+      }
+      compactionStatus = "requesting native checkpoint";
+      const native = await requestProviderCompaction({
+        provider: capture.provider,
+        model: capture.model,
+        context: capture.prepared.context,
+        input,
+        preparedPayload: capture.prepared.payload,
+        protocol,
+        apiKey: capture.options.apiKey,
+        headers: capture.options.headers,
+        env: capture.options.env,
+        signal: event.signal,
+        fetch: capture.options.fetch
+      });
+      if (!current())
+        return { cancel: true };
+      const finalAuth = await context.modelRegistry.getApiKeyAndHeaders(context.model);
+      if (!current())
+        return { cancel: true };
+      if (!finalAuth.ok || routeDigest(finalAuth) !== capture.authHash) {
+        fallback("auth changed after native generation");
+        return { compaction: portable };
+      }
+      const details = {
+        ...isObject(portable.details) ? portable.details : {},
+        type: NATIVE_COMPACTION_TYPE,
+        version: 3,
+        provider: capture.model.provider,
+        api: capture.model.api,
+        model: capture.model.id,
+        protocol,
+        identity: identity(capture.model, capture.options),
+        output: native.output,
+        nativeUsage: native.usage,
+        portableUsage: portable.usage,
+        coverage: { kind: "summarized-prefix", firstKeptEntryId: portable.firstKeptEntryId, sourceLeafId: branch.at(-1).id, sourceHash: branchHash, policyHash: capture.policyHash, inputHash: digest(input), runtimeId }
+      };
+      pending = { details, capture, summary: portable.summary };
+      return { compaction: { ...portable, usage: combineUsage(native.usage, portable.usage), details } };
+    } catch {
+      if (!current())
+        return { cancel: true };
+      fallback("native acquisition or validation failed");
+      return { compaction: portable };
+    }
+  });
+  pi.on("session_compact", (event, context) => {
+    if (readNativeCompactionDetails(event.compactionEntry.details)?.version === 3)
+      compactionStatus = "native checkpoint committed";
+    else if (!compactionStatus.startsWith("portable:"))
+      fallback("another handler supplied the committed result");
+    if (compactionStatus.startsWith("portable:"))
+      pi.appendEntry("pi-provider-compaction:diagnostic", { status: compactionStatus });
+    active = undefined;
+    snapshot = undefined;
+    const candidate = pending;
+    pending = undefined;
+    if (!candidate || !equal(event.compactionEntry.details, candidate.details) || event.compactionEntry.summary !== candidate.summary)
+      return;
+    const branch = context.sessionManager.getBranch();
+    const coverage = candidate.details.coverage;
+    if (!coverage || event.compactionEntry.firstKeptEntryId !== coverage.firstKeptEntryId || event.compactionEntry.parentId !== coverage.sourceLeafId || branch.at(-1)?.id !== event.compactionEntry.id || digest(branch.slice(0, -1)) !== coverage.sourceHash)
+      return;
+    active = { entryId: event.compactionEntry.id, detailsHash: digest(candidate.details), summary: candidate.summary, branchLength: branch.length, branchHash: digest(branch), routeHash: candidate.capture.routeHash, policyHash: candidate.capture.policyHash };
+  });
+  pi.on("session_compact_failed", () => {
+    pending = undefined;
+    snapshot = undefined;
+    compactionStatus = "compaction failed or cancelled";
   });
 }
 export {
   NATIVE_COMPACTION_SUMMARY,
   NATIVE_COMPACTION_TYPE,
   NATIVE_COMPACTION_VERSION,
-  compactOpenAIResponses,
   pi_provider_compaction_default as default,
-  findLatestNativeCompaction,
   readNativeCompactionDetails,
-  rewriteResponsesPayload,
   supportsNativeCompaction
 };