opencode-acp 1.1.1 → 1.3.0

package/dist/index.js

@@ -1350,13 +1350,14 @@ var DEFAULT_PROTECTED_TOOLS = [
   "todowrite",
   "todoread",
   "compress",
+  "decompress",
   "batch",
   "plan_enter",
   "plan_exit",
   "write",
   "edit"
 ];
-var COMPRESS_DEFAULT_PROTECTED_TOOLS = ["task", "skill", "todowrite", "todoread"];
+var COMPRESS_DEFAULT_PROTECTED_TOOLS = ["task", "skill", "todowrite", "todoread", "decompress"];
 function showConfigWarnings(ctx, configPath, configData, isProject) {
   const invalidKeys = getInvalidConfigKeys(configData);
   const typeErrors = validateConfigTypes(configData);
@@ -3466,20 +3467,20 @@ function matchesGlob(inputPath, pattern) {
   regex += "$";
   return new RegExp(regex).test(input);
 }
-function getFilePathsFromParameters(tool3, parameters) {
+function getFilePathsFromParameters(tool4, parameters) {
   if (typeof parameters !== "object" || parameters === null) {
     return [];
   }
   const paths = [];
   const params = parameters;
-  if (tool3 === "apply_patch" && typeof params.patchText === "string") {
+  if (tool4 === "apply_patch" && typeof params.patchText === "string") {
     const pathRegex = /\*\*\* (?:Add|Delete|Update) File: ([^\n\r]+)/g;
     let match;
     while ((match = pathRegex.exec(params.patchText)) !== null) {
       paths.push(match[1].trim());
     }
   }
-  if (tool3 === "multiedit") {
+  if (tool4 === "multiedit") {
     if (typeof params.filePath === "string") {
       paths.push(params.filePath);
     }
@@ -3574,13 +3575,13 @@ var deduplicate = (state, logger, config, messages) => {
     logger.debug(`Marked ${newPruneIds.length} duplicate tool calls for pruning`);
   }
 };
-function createToolSignature(tool3, parameters) {
+function createToolSignature(tool4, parameters) {
   if (!parameters) {
-    return tool3;
+    return tool4;
   }
   const normalized = normalizeParameters(parameters);
   const sorted = sortObjectKeys(normalized);
-  return `${tool3}::${JSON.stringify(sorted)}`;
+  return `${tool4}::${JSON.stringify(sorted)}`;
 }
 function normalizeParameters(params) {
   if (typeof params !== "object" || params === null) return params;
@@ -3655,9 +3656,9 @@ var purgeErrors = (state, logger, config, messages) => {
 };
 
 // lib/ui/utils.ts
-function extractParameterKey(tool3, parameters) {
+function extractParameterKey(tool4, parameters) {
   if (!parameters) return "";
-  if (tool3 === "read" && parameters.filePath) {
+  if (tool4 === "read" && parameters.filePath) {
     const offset = parameters.offset;
     const limit = parameters.limit;
     if (offset !== void 0 && limit !== void 0) {
@@ -3671,10 +3672,10 @@ function extractParameterKey(tool3, parameters) {
     }
     return parameters.filePath;
   }
-  if ((tool3 === "write" || tool3 === "edit" || tool3 === "multiedit") && parameters.filePath) {
+  if ((tool4 === "write" || tool4 === "edit" || tool4 === "multiedit") && parameters.filePath) {
     return parameters.filePath;
   }
-  if (tool3 === "apply_patch" && typeof parameters.patchText === "string") {
+  if (tool4 === "apply_patch" && typeof parameters.patchText === "string") {
     const pathRegex = /\*\*\* (?:Add|Delete|Update) File: ([^\n\r]+)/g;
     const paths = [];
     let match;
@@ -3691,51 +3692,51 @@ function extractParameterKey(tool3, parameters) {
     }
     return "patch";
   }
-  if (tool3 === "list") {
+  if (tool4 === "list") {
     return parameters.path || "(current directory)";
   }
-  if (tool3 === "glob") {
+  if (tool4 === "glob") {
     if (parameters.pattern) {
       const pathInfo = parameters.path ? ` in ${parameters.path}` : "";
       return `"${parameters.pattern}"${pathInfo}`;
     }
     return "(unknown pattern)";
   }
-  if (tool3 === "grep") {
+  if (tool4 === "grep") {
     if (parameters.pattern) {
       const pathInfo = parameters.path ? ` in ${parameters.path}` : "";
       return `"${parameters.pattern}"${pathInfo}`;
     }
     return "(unknown pattern)";
   }
-  if (tool3 === "bash") {
+  if (tool4 === "bash") {
     if (parameters.description) return parameters.description;
     if (parameters.command) {
       return parameters.command.length > 50 ? parameters.command.substring(0, 50) + "..." : parameters.command;
     }
   }
-  if (tool3 === "webfetch" && parameters.url) {
+  if (tool4 === "webfetch" && parameters.url) {
     return parameters.url;
   }
-  if (tool3 === "websearch" && parameters.query) {
+  if (tool4 === "websearch" && parameters.query) {
     return `"${parameters.query}"`;
   }
-  if (tool3 === "codesearch" && parameters.query) {
+  if (tool4 === "codesearch" && parameters.query) {
     return `"${parameters.query}"`;
   }
-  if (tool3 === "todowrite") {
+  if (tool4 === "todowrite") {
     return `${parameters.todos?.length || 0} todos`;
   }
-  if (tool3 === "todoread") {
+  if (tool4 === "todoread") {
     return "read todo list";
   }
-  if (tool3 === "task" && parameters.description) {
+  if (tool4 === "task" && parameters.description) {
     return parameters.description;
   }
-  if (tool3 === "skill" && parameters.name) {
+  if (tool4 === "skill" && parameters.name) {
     return parameters.name;
   }
-  if (tool3 === "lsp") {
+  if (tool4 === "lsp") {
     const op = parameters.operation || "lsp";
     const path = parameters.filePath || "";
     const line = parameters.line;
@@ -3748,7 +3749,7 @@ function extractParameterKey(tool3, parameters) {
     }
     return op;
   }
-  if (tool3 === "question") {
+  if (tool4 === "question") {
     const questions = parameters.questions;
     if (Array.isArray(questions) && questions.length > 0) {
       const headers = questions.map((q) => q.header || "").filter(Boolean).slice(0, 3);
@@ -4710,1983 +4711,2405 @@ function extractBoundaryConsumedBlocks(startReference, endReference) {
   return consumed;
 }
 
-// lib/host-permissions.ts
-var findLastMatchingRule = (rules, predicate) => {
-  for (let index = rules.length - 1; index >= 0; index -= 1) {
-    const rule = rules[index];
-    if (rule && predicate(rule)) {
-      return rule;
+// lib/compress/decompress.ts
+import { tool as tool3 } from "@opencode-ai/plugin";
+
+// lib/messages/utils.ts
+import { createHash } from "crypto";
+var SUMMARY_ID_HASH_LENGTH = 16;
+var DCP_BLOCK_ID_TAG_REGEX = /(<dcp-message-id(?=[\s>])[^>]*>)b\d+(<\/dcp-message-id>)/g;
+var DCP_MESSAGE_REF_TAG_REGEX = /<dcp-message-id>m\d+<\/dcp-message-id>/g;
+var DCP_PAIRED_TAG_REGEX = /<dcp[^>]*>[\s\S]*?<\/dcp[^>]*>/gi;
+var DCP_UNPAIRED_TAG_REGEX = /<\/?dcp[^>]*>/gi;
+var generateStableId = (prefix, seed) => {
+  const hash = createHash("sha256").update(seed).digest("hex").slice(0, SUMMARY_ID_HASH_LENGTH);
+  return `${prefix}_${hash}`;
+};
+var createSyntheticUserMessage = (baseMessage, content, stableSeed) => {
+  const userInfo = baseMessage.info;
+  const now = Date.now();
+  const deterministicSeed = stableSeed?.trim() || userInfo.id;
+  const messageId = generateStableId("msg_dcp_summary", deterministicSeed);
+  const partId = generateStableId("prt_dcp_summary", deterministicSeed);
+  return {
+    info: {
+      id: messageId,
+      sessionID: userInfo.sessionID,
+      role: "user",
+      agent: userInfo.agent,
+      model: userInfo.model,
+      time: { created: now }
+    },
+    parts: [
+      {
+        id: partId,
+        sessionID: userInfo.sessionID,
+        messageID: messageId,
+        type: "text",
+        text: content
+      }
+    ]
+  };
+};
+var createSyntheticTextPart = (baseMessage, content, stableSeed) => {
+  const userInfo = baseMessage.info;
+  const deterministicSeed = stableSeed?.trim() || userInfo.id;
+  const partId = generateStableId("prt_dcp_text", deterministicSeed);
+  return {
+    id: partId,
+    sessionID: userInfo.sessionID,
+    messageID: userInfo.id,
+    type: "text",
+    text: content
+  };
+};
+var appendToLastTextPart = (message, injection) => {
+  const textPart = findLastTextPart(message);
+  if (!textPart) {
+    return false;
+  }
+  return appendToTextPart(textPart, injection);
+};
+var findLastTextPart = (message) => {
+  for (let i = message.parts.length - 1; i >= 0; i--) {
+    const part = message.parts[i];
+    if (part.type === "text") {
+      return part;
     }
   }
-  return void 0;
+  return null;
 };
-var wildcardMatch = (value, pattern) => {
-  const normalizedValue = value.replaceAll("\\", "/");
-  let escaped = pattern.replaceAll("\\", "/").replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
-  if (escaped.endsWith(" .*")) {
-    escaped = escaped.slice(0, -3) + "( .*)?";
+var appendToTextPart = (part, injection) => {
+  if (typeof part.text !== "string") {
+    return false;
   }
-  const flags = process.platform === "win32" ? "si" : "s";
-  return new RegExp(`^${escaped}$`, flags).test(normalizedValue);
+  const normalizedInjection = injection.replace(/^\n+/, "");
+  if (!normalizedInjection.trim()) {
+    return false;
+  }
+  if (part.text.includes(normalizedInjection)) {
+    return true;
+  }
+  const baseText = part.text.replace(/\n*$/, "");
+  part.text = baseText.length > 0 ? `${baseText}
+
+${normalizedInjection}` : normalizedInjection;
+  return true;
 };
-var getPermissionRules = (permissionConfigs) => {
-  const rules = [];
-  for (const permissionConfig of permissionConfigs) {
-    if (!permissionConfig) {
+var appendToAllToolParts = (message, tag) => {
+  let injected = false;
+  for (const part of message.parts) {
+    if (part.type === "tool") {
+      injected = appendToToolPart(part, tag) || injected;
+    }
+  }
+  return injected;
+};
+var appendToToolPart = (part, tag) => {
+  if (part.state?.status !== "completed" || typeof part.state.output !== "string") {
+    return false;
+  }
+  if (part.state.output.includes(tag)) {
+    return true;
+  }
+  part.state.output = `${part.state.output}${tag}`;
+  return true;
+};
+var hasContent = (message) => {
+  return message.parts.some(
+    (part) => part.type === "text" && typeof part.text === "string" && part.text.trim().length > 0 || part.type === "tool" && part.state?.status === "completed" && typeof part.state.output === "string"
+  );
+};
+function buildToolIdList(state, messages) {
+  const toolIds = [];
+  for (const msg of messages) {
+    if (isMessageCompacted(state, msg)) {
       continue;
     }
-    for (const [permission, value] of Object.entries(permissionConfig)) {
-      if (value === "ask" || value === "allow" || value === "deny") {
-        rules.push({ permission, pattern: "*", action: value });
-        continue;
-      }
-      for (const [pattern, action] of Object.entries(value)) {
-        if (action === "ask" || action === "allow" || action === "deny") {
-          rules.push({ permission, pattern, action });
+    const parts = Array.isArray(msg.parts) ? msg.parts : [];
+    if (parts.length > 0) {
+      for (const part of parts) {
+        if (part.type === "tool" && part.callID && part.tool) {
+          toolIds.push(part.callID);
         }
       }
     }
   }
-  return rules;
+  state.toolIdList = toolIds;
+  return toolIds;
+}
+var replaceBlockIdsWithBlocked = (text) => {
+  return text.replace(DCP_BLOCK_ID_TAG_REGEX, "$1BLOCKED$2");
 };
-var compressDisabledByOpencode = (...permissionConfigs) => {
-  const match = findLastMatchingRule(
-    getPermissionRules(permissionConfigs),
-    (rule) => wildcardMatch("compress", rule.permission)
-  );
-  return match?.pattern === "*" && match.action === "deny";
+var stripStaleMessageRefs = (text) => {
+  return text.replace(DCP_MESSAGE_REF_TAG_REGEX, "");
 };
-var resolveEffectiveCompressPermission = (basePermission, hostPermissions, agentName) => {
-  if (basePermission === "deny") {
-    return "deny";
-  }
-  return compressDisabledByOpencode(
-    hostPermissions.global,
-    agentName ? hostPermissions.agents[agentName] : void 0
-  ) ? "deny" : basePermission;
+var stripHallucinationsFromString = (text) => {
+  return text.replace(DCP_PAIRED_TAG_REGEX, "").replace(DCP_UNPAIRED_TAG_REGEX, "");
 };
-var hasExplicitToolPermission = (permissionConfig, tool3) => {
-  return permissionConfig ? Object.prototype.hasOwnProperty.call(permissionConfig, tool3) : false;
+var stripHallucinations = (messages) => {
+  for (const message of messages) {
+    for (const part of message.parts) {
+      if (part.type === "text" && typeof part.text === "string") {
+        part.text = stripHallucinationsFromString(part.text);
+      }
+      if (part.type === "tool" && part.state?.status === "completed" && typeof part.state.output === "string") {
+        part.state.output = stripHallucinationsFromString(part.state.output);
+      }
+    }
+  }
 };
 
-// lib/logger.ts
-import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { join as join3 } from "path";
-import { existsSync as existsSync3 } from "fs";
-import { homedir as homedir3 } from "os";
-var Logger = class {
-  logDir;
-  enabled;
-  constructor(enabled) {
-    this.enabled = enabled;
-    const configHome = process.env.XDG_CONFIG_HOME || join3(homedir3(), ".config");
-    this.logDir = join3(configHome, "opencode", "logs", "acp");
-  }
-  async ensureLogDir() {
-    if (!existsSync3(this.logDir)) {
-      await mkdir2(this.logDir, { recursive: true });
+// lib/messages/prune.ts
+var PRUNED_TOOL_OUTPUT_REPLACEMENT = "[Output removed to save context - information superseded or no longer needed]";
+var PRUNED_TOOL_ERROR_INPUT_REPLACEMENT = "[input removed due to failed tool call]";
+var PRUNED_QUESTION_INPUT_REPLACEMENT = "[questions removed - see output for user's answers]";
+var prune = (state, logger, config, messages) => {
+  filterCompressedRanges(state, logger, config, messages);
+  pruneToolOutputs(state, logger, messages);
+  pruneToolInputs(state, logger, messages);
+  pruneToolErrors(state, logger, messages);
+};
+var pruneToolOutputs = (state, logger, messages) => {
+  for (const msg of messages) {
+    if (isMessageCompacted(state, msg)) {
+      continue;
     }
-  }
-  formatData(data) {
-    if (!data) return "";
-    const parts = [];
-    for (const [key, value] of Object.entries(data)) {
-      if (value === void 0 || value === null) continue;
-      if (Array.isArray(value)) {
-        if (value.length === 0) continue;
-        parts.push(
-          `${key}=[${value.slice(0, 3).join(",")}${value.length > 3 ? `...+${value.length - 3}` : ""}]`
-        );
-      } else if (typeof value === "object") {
-        const str = JSON.stringify(value);
-        if (str.length < 50) {
-          parts.push(`${key}=${str}`);
-        }
-      } else {
-        parts.push(`${key}=${value}`);
+    const parts = Array.isArray(msg.parts) ? msg.parts : [];
+    for (const part of parts) {
+      if (part.type !== "tool") {
+        continue;
       }
-    }
-    return parts.join(" ");
-  }
-  getCallerFile(skipFrames = 3) {
-    const originalPrepareStackTrace = Error.prepareStackTrace;
-    try {
-      const err = new Error();
-      Error.prepareStackTrace = (_, stack2) => stack2;
-      const stack = err.stack;
-      Error.prepareStackTrace = originalPrepareStackTrace;
-      for (let i = skipFrames; i < stack.length; i++) {
-        const filename = stack[i]?.getFileName();
-        if (filename && !filename.includes("/logger.")) {
-          const match = filename.match(/([^/\\]+)\.[tj]s$/);
-          return match ? match[1] : filename;
-        }
+      if (!state.prune.tools.has(part.callID)) {
+        continue;
       }
-      return "unknown";
-    } catch {
-      return "unknown";
+      if (part.state.status !== "completed") {
+        continue;
+      }
+      if (part.tool === "question" || part.tool === "edit" || part.tool === "write") {
+        continue;
+      }
+      part.state.output = PRUNED_TOOL_OUTPUT_REPLACEMENT;
     }
   }
-  async write(level, component, message, data) {
-    if (!this.enabled) return;
-    try {
-      await this.ensureLogDir();
-      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-      const dataStr = this.formatData(data);
-      const logLine = `${timestamp} ${level.padEnd(5)} ${component}: ${message}${dataStr ? " | " + dataStr : ""}
-`;
-      const dailyLogDir = join3(this.logDir, "daily");
-      if (!existsSync3(dailyLogDir)) {
-        await mkdir2(dailyLogDir, { recursive: true });
+};
+var pruneToolInputs = (state, logger, messages) => {
+  for (const msg of messages) {
+    if (isMessageCompacted(state, msg)) {
+      continue;
+    }
+    const parts = Array.isArray(msg.parts) ? msg.parts : [];
+    for (const part of parts) {
+      if (part.type !== "tool") {
+        continue;
+      }
+      if (!state.prune.tools.has(part.callID)) {
+        continue;
+      }
+      if (part.state.status !== "completed") {
+        continue;
+      }
+      if (part.tool !== "question") {
+        continue;
+      }
+      if (part.state.input?.questions !== void 0) {
+        part.state.input.questions = PRUNED_QUESTION_INPUT_REPLACEMENT;
       }
-      const logFile = join3(dailyLogDir, `${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.log`);
-      await writeFile2(logFile, logLine, { flag: "a" });
-    } catch (error) {
     }
   }
-  info(message, data) {
-    if (!this.enabled) return;
-    const component = this.getCallerFile(2);
-    return this.write("INFO", component, message, data);
-  }
-  debug(message, data) {
-    if (!this.enabled) return;
-    const component = this.getCallerFile(2);
-    return this.write("DEBUG", component, message, data);
-  }
-  warn(message, data) {
-    if (!this.enabled) return;
-    const component = this.getCallerFile(2);
-    return this.write("WARN", component, message, data);
-  }
-  error(message, data) {
-    if (!this.enabled) return;
-    const component = this.getCallerFile(2);
-    return this.write("ERROR", component, message, data);
-  }
-  /**
-   * Strips unnecessary metadata from messages for cleaner debug logs.
-   *
-   * Removed:
-   * - All IDs (id, sessionID, messageID, parentID)
-   * - summary, path, cost, model, agent, mode, finish, providerID, modelID
-   * - step-start and step-finish parts entirely
-   * - snapshot fields
-   * - ignored text parts
-   *
-   * Kept:
-   * - role, time (created only), tokens (input, output, reasoning, cache)
-   * - text, reasoning, tool parts with content
-   * - tool calls with: tool, callID, input, output, metadata
-   */
-  minimizeForDebug(messages) {
-    return messages.map((msg) => {
-      const minimized = {
-        role: msg.info?.role
-      };
-      if (msg.info?.time?.created) {
-        minimized.time = msg.info.time.created;
+};
+var pruneToolErrors = (state, logger, messages) => {
+  for (const msg of messages) {
+    if (isMessageCompacted(state, msg)) {
+      continue;
+    }
+    const parts = Array.isArray(msg.parts) ? msg.parts : [];
+    for (const part of parts) {
+      if (part.type !== "tool") {
+        continue;
       }
-      if (msg.info?.tokens) {
-        minimized.tokens = {
-          input: msg.info.tokens.input,
-          output: msg.info.tokens.output,
-          reasoning: msg.info.tokens.reasoning,
-          cache: msg.info.tokens.cache
-        };
+      if (!state.prune.tools.has(part.callID)) {
+        continue;
       }
-      if (msg.parts) {
-        minimized.parts = msg.parts.map((part) => {
-          if (part.type === "step-start" || part.type === "step-finish") {
-            return null;
-          }
-          if (part.type === "text") {
-            if (part.ignored) return null;
-            const textPart = { type: "text", text: part.text };
-            if (part.metadata) textPart.metadata = part.metadata;
-            return textPart;
-          }
-          if (part.type === "reasoning") {
-            const reasoningPart = { type: "reasoning", text: part.text };
-            if (part.metadata) reasoningPart.metadata = part.metadata;
-            return reasoningPart;
-          }
-          if (part.type === "tool") {
-            const toolPart = {
-              type: "tool",
-              tool: part.tool,
-              callID: part.callID
-            };
-            if (part.state?.status) {
-              toolPart.status = part.state.status;
-            }
-            if (part.state?.input) {
-              toolPart.input = part.state.input;
-            }
-            if (part.state?.output) {
-              toolPart.output = part.state.output;
-            }
-            if (part.state?.error) {
-              toolPart.error = part.state.error;
-            }
-            if (part.metadata) {
-              toolPart.metadata = part.metadata;
-            }
-            if (part.state?.metadata) {
-              toolPart.metadata = {
-                ...toolPart.metadata || {},
-                ...part.state.metadata
-              };
-            }
-            if (part.state?.title) {
-              toolPart.title = part.state.title;
-            }
-            return toolPart;
+      if (part.state.status !== "error") {
+        continue;
+      }
+      const input = part.state.input;
+      if (input && typeof input === "object") {
+        for (const key of Object.keys(input)) {
+          if (typeof input[key] === "string") {
+            input[key] = PRUNED_TOOL_ERROR_INPUT_REPLACEMENT;
           }
-          return null;
-        }).filter(Boolean);
+        }
       }
-      return minimized;
-    });
+    }
   }
-  async saveContext(sessionId, messages) {
-    if (!this.enabled) return;
-    try {
-      const contextDir = join3(this.logDir, "context", sessionId);
-      if (!existsSync3(contextDir)) {
-        await mkdir2(contextDir, { recursive: true });
+};
+var filterCompressedRanges = (state, logger, config, messages) => {
+  if (state.prune.messages.byMessageId.size === 0 && state.prune.messages.activeByAnchorMessageId.size === 0) {
+    return;
+  }
+  const result = [];
+  for (const msg of messages) {
+    const msgId = msg.info.id;
+    const blockId = state.prune.messages.activeByAnchorMessageId.get(msgId);
+    const summary = blockId !== void 0 ? state.prune.messages.blocksById.get(blockId) : void 0;
+    if (summary) {
+      const rawSummaryContent = summary.summary;
+      if (summary.active !== true || typeof rawSummaryContent !== "string" || rawSummaryContent.length === 0) {
+        logger.warn("Skipping malformed compress summary", {
+          anchorMessageId: msgId,
+          blockId: summary.blockId
+        });
+      } else {
+        const msgIndex = messages.indexOf(msg);
+        const userMessage = getLastUserMessage(messages, msgIndex);
+        const _cleaned = stripStaleMessageRefs(rawSummaryContent);
+        if (userMessage) {
+          const userInfo = userMessage.info;
+          const summaryContent = config.compress.mode === "message" ? replaceBlockIdsWithBlocked(_cleaned) : _cleaned;
+          const summarySeed = `${summary.blockId}:${summary.anchorMessageId}`;
+          result.push(
+            createSyntheticUserMessage(userMessage, summaryContent, summarySeed)
+          );
+          logger.info("Injected compress summary", {
+            anchorMessageId: msgId,
+            summaryLength: summaryContent.length
+          });
+        } else {
+          const anchorInfo = msg.info;
+          const fallbackBase = {
+            info: {
+              id: anchorInfo.id || msgId,
+              sessionID: anchorInfo.sessionID || "",
+              role: "user",
+              agent: anchorInfo.agent || "code",
+              model: anchorInfo.model || {
+                providerID: "",
+                modelID: "",
+                variant: void 0
+              },
+              time: { created: anchorInfo.time?.created || Date.now() }
+            },
+            parts: []
+          };
+          const summaryContent = config.compress.mode === "message" ? replaceBlockIdsWithBlocked(_cleaned) : _cleaned;
+          const summarySeed = `${summary.blockId}:${summary.anchorMessageId}`;
+          result.push(
+            createSyntheticUserMessage(fallbackBase, summaryContent, summarySeed)
+          );
+          logger.info("Injected compress summary (fallback, no preceding user message)", {
+            anchorMessageId: msgId,
+            summaryLength: summaryContent.length
+          });
+        }
       }
-      const minimized = this.minimizeForDebug(messages).filter(
-        (msg) => msg.parts && msg.parts.length > 0
-      );
-      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-      const contextFile = join3(contextDir, `${timestamp}.json`);
-      await writeFile2(contextFile, JSON.stringify(minimized, null, 2));
-    } catch (error) {
     }
+    const pruneEntry = state.prune.messages.byMessageId.get(msgId);
+    if (pruneEntry && pruneEntry.activeBlockIds.length > 0) {
+      continue;
+    }
+    result.push(msg);
   }
+  messages.length = 0;
+  messages.push(...result);
 };
 
-// lib/prompts/store.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, statSync as statSync2, cpSync as cpSync2 } from "fs";
-import { join as join4, dirname as dirname2 } from "path";
-import { homedir as homedir4 } from "os";
-
-// lib/prompts/system.ts
-var SYSTEM = `
-You operate in a context-constrained environment. Manage context continuously to avoid buildup and preserve retrieval quality. Efficient context management is paramount for your agentic performance.
-
-The ONLY tool you have for context management is \`compress\`. It replaces older conversation content with technical summaries you produce.
-
-\`<dcp-message-id>\` 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 not cleanup - it is crystallization. Your summary becomes the authoritative record of what transpired.
-
-Think of compression as phase transitions: raw exploration becomes refined understanding. The original context served its purpose; your summary now carries that understanding forward.
-
-COMPRESS WHEN
-
-A section is genuinely closed and the raw conversation has served its purpose:
-
-- Research concluded and findings are clear
-- Implementation finished and verified
-- Exploration exhausted and patterns understood
-- Dead-end noise can be discarded without waiting for a whole chapter to close
-
-DO NOT COMPRESS IF
-
-- Raw context is still relevant and needed for edits or precise references
-- The target content is still actively in progress
-- You may need exact code, error messages, or file contents in the immediate next steps
-
-Before compressing, ask: _"Is this section closed enough to become summary-only right now?"_
-
-Evaluate conversation signal-to-noise REGULARLY. Use \`compress\` deliberately with quality-first summaries. Prioritize stale content intelligently to maintain a high-signal context window that supports your agency.
-
-It is of your responsibility to keep a sharp, high-quality context window for optimal performance.
-`;
-
-// lib/prompts/compress-range.ts
-var COMPRESS_RANGE = `Collapse a range in the conversation into a detailed summary.
-
-THE SUMMARY
-Your summary must be EXHAUSTIVE. Capture file paths, function signatures, decisions made, constraints discovered, key findings... EVERYTHING that maintains context integrity. This is not a brief note - it is an authoritative record so faithful that the original conversation adds no value.
-
-USER INTENT FIDELITY
-When the compressed range includes user messages, preserve the user's intent with extra care. Do not change scope, constraints, priorities, acceptance criteria, or requested outcomes.
-Directly quote user messages when they are short enough to include safely. Direct quotes are preferred when they best preserve exact meaning.
-
-Yet be LEAN. Strip away the noise: failed attempts that led nowhere, verbose tool outputs, back-and-forth exploration. What remains should be pure signal - golden nuggets of detail that preserve full understanding with zero ambiguity.
-
-COMPRESSED BLOCK PLACEHOLDERS
-When the selected range includes previously compressed blocks, use this exact placeholder format when referencing one:
-
-- \`(bN)\`
-
-Compressed block sections in context are clearly marked with a header:
-
-- \`[Compressed conversation section]\`
-
-Compressed block IDs always use the \`bN\` form (never \`mNNNNN\`) and are represented in the same XML metadata tag format.
-
-Rules:
-
-- Include every required block placeholder exactly once.
-- Do not invent placeholders for blocks outside the selected range.
-- Treat \`(bN)\` placeholders as RESERVED TOKENS. Do not emit \`(bN)\` text anywhere except intentional placeholders.
-- If you need to mention a block in prose, use plain text like \`compressed bN\` (not as a placeholder).
-- Preflight check before finalizing: the set of \`(bN)\` placeholders in your summary must exactly match the required set, with no duplicates.
-
-These placeholders are semantic references. They will be replaced with the full stored compressed block content when the tool processes your output.
-
-FLOW PRESERVATION WITH PLACEHOLDERS
-When you use compressed block placeholders, write the surrounding summary text so it still reads correctly AFTER placeholder expansion.
-
-- Treat each placeholder as a stand-in for a full conversation segment, not as a short label.
-- Ensure transitions before and after each placeholder preserve chronology and causality.
-- Do not write text that depends on the placeholder staying literal (for example, "as noted in \`(b2)\`").
-- Your final meaning must be coherent once each placeholder is replaced with its full compressed block content.
-
-BOUNDARY IDS
-You specify boundaries by ID using the injected IDs visible in the conversation:
-
-- \`mNNNNN\` IDs identify raw messages
-- \`bN\` IDs identify previously compressed blocks
-
-Each message has an ID inside XML metadata tags like \`<dcp-message-id>...</dcp-message-id>\`.
-The same ID tag appears in every tool output of the message it belongs to \u2014 each unique ID identifies one complete message.
-Treat these tags as boundary metadata only, not as tool result content.
-
-Rules:
-
-- Pick \`startId\` and \`endId\` directly from injected IDs in context.
-- IDs must exist in the current visible context. If you cannot see an ID in the messages above, it is stale and will fail.
-- \`startId\` must appear before \`endId\`.
-- Do not invent IDs. Use only IDs that are present in context.
-- NEVER use IDs from compressed block summaries, previous nudges, or your own memory \u2014 only IDs currently visible as XML metadata tags in the conversation.
-
-BATCHING
-When multiple independent ranges are ready and their boundaries do not overlap, include all of them as separate entries in the \`content\` array of a single tool call. Each entry should have its own \`startId\`, \`endId\`, and \`summary\`.
-`;
-
-// lib/prompts/compress-message.ts
-var COMPRESS_MESSAGE = `Collapse selected individual messages in the conversation into detailed summaries.
-
-THE SUMMARY
-Your summary must be EXHAUSTIVE. Capture file paths, function signatures, decisions made, constraints discovered, key findings, tool outcomes, and user intent details that matter... EVERYTHING that preserves the value of the selected message after the raw message is removed.
-
-USER INTENT FIDELITY
-When a selected message contains user intent, preserve that intent with extra care. Do not change scope, constraints, priorities, acceptance criteria, or requested outcomes.
-Directly quote short user instructions when that best preserves exact meaning.
-
-Yet be LEAN. Strip away the noise: failed attempts that led nowhere, verbose tool output, and repetition. What remains should be pure signal - golden nuggets of detail that preserve full understanding with zero ambiguity.
-If a message contains no significant technical decisions, code changes, or user requirements, produce a minimal one-line summary rather than a detailed one.
-
-MESSAGE IDS
-You specify individual raw messages by ID using the injected IDs visible in the conversation:
-
-- \`mNNNNN\` IDs identify raw messages
-
-Each message has an ID inside XML metadata tags like \`<dcp-message-id priority="high">m0007</dcp-message-id>\`.
-The same ID tag appears in every tool output of the message it belongs to \u2014 each unique ID identifies one complete message.
-Treat these tags as message metadata only, not as content to summarize. Use only the inner \`mNNNNN\` value as the \`messageId\`.
-The \`priority\` attribute indicates relative context cost. You MUST compress high-priority messages when their full text is no longer necessary for the active task.
-If prior compress-tool results are present, always compress and summarize them minimally only as part of a broader compression pass. Do not invoke the compress tool solely to re-compress an earlier compression result.
-Messages marked as \`<dcp-message-id>BLOCKED</dcp-message-id>\` cannot be compressed.
-
-Rules:
-
-- Pick each \`messageId\` directly from injected IDs visible in context.
-- Only use raw message IDs of the form \`mNNNNN\`.
-- Ignore XML attributes such as \`priority\` when copying the ID; use only the inner \`mNNNNN\` value.
-- Do not invent IDs. Use only IDs that are present in context.
-
-BATCHING
-Select MANY messages in a single tool call when they are safe to compress.
-Each entry should summarize exactly one message, and the tool can receive as many entries as needed in one batch.
-
-GENERAL CLEANUP
-Use the topic "general cleanup" for broad cleanup passes.
-During general cleanup, compress all medium and high-priority messages that are not relevant to the active task.
-Optimize for reducing context footprint, not for grouping messages by topic.
-Do not compress away still-active instructions, unresolved questions, or constraints that are likely to matter soon.
-Prioritize the earliest messages in the context as they will be the least relevant to the active task.
-General cleanup should be done periodically between other normal compression tool passes, not as the primary form of compression.
-`;
+// lib/messages/sync.ts
+function sortBlocksByCreation(a, b) {
+  const createdAtDiff = a.createdAt - b.createdAt;
+  if (createdAtDiff !== 0) {
+    return createdAtDiff;
+  }
+  return a.blockId - b.blockId;
+}
+var syncCompressionBlocks = (state, logger, messages) => {
+  const messagesState = state.prune.messages;
+  if (!messagesState?.blocksById?.size) {
+    return;
+  }
+  const messageIds = new Set(messages.map((msg) => msg.info.id));
+  const previousActiveBlockIds = new Set(
+    Array.from(messagesState.blocksById.values()).filter((block) => block.active).map((block) => block.blockId)
+  );
+  messagesState.activeBlockIds.clear();
+  messagesState.activeByAnchorMessageId.clear();
+  const now = Date.now();
+  const missingOriginBlockIds = [];
+  const orderedBlocks = Array.from(messagesState.blocksById.values()).sort(sortBlocksByCreation);
+  for (const block of orderedBlocks) {
+    if (block.deactivatedByUser) {
+      block.active = false;
+      if (block.deactivatedAt === void 0) {
+        block.deactivatedAt = now;
+      }
+      block.deactivatedByBlockId = void 0;
+      continue;
+    }
+    if (typeof block.anchorMessageId === "string" && block.anchorMessageId.length > 0 && !messageIds.has(block.anchorMessageId)) {
+      if (!messagesState.byMessageId.has(block.anchorMessageId)) {
+        block.active = false;
+        block.deactivatedAt = now;
+        block.deactivatedByBlockId = void 0;
+        continue;
+      }
+    }
+    for (const consumedBlockId of block.consumedBlockIds) {
+      if (!messagesState.activeBlockIds.has(consumedBlockId)) {
+        continue;
+      }
+      const consumedBlock = messagesState.blocksById.get(consumedBlockId);
+      if (consumedBlock) {
+        consumedBlock.active = false;
+        consumedBlock.deactivatedAt = now;
+        consumedBlock.deactivatedByBlockId = block.blockId;
+        const mappedBlockId = messagesState.activeByAnchorMessageId.get(
+          consumedBlock.anchorMessageId
+        );
+        if (mappedBlockId === consumedBlock.blockId) {
+          messagesState.activeByAnchorMessageId.delete(consumedBlock.anchorMessageId);
+        }
+      }
+      messagesState.activeBlockIds.delete(consumedBlockId);
+    }
+    block.active = true;
+    block.deactivatedAt = void 0;
+    block.deactivatedByBlockId = void 0;
+    messagesState.activeBlockIds.add(block.blockId);
+    if (messageIds.has(block.anchorMessageId)) {
+      messagesState.activeByAnchorMessageId.set(block.anchorMessageId, block.blockId);
+    }
+  }
+  for (const entry of messagesState.byMessageId.values()) {
+    const allBlockIds = Array.isArray(entry.allBlockIds) ? [...new Set(entry.allBlockIds.filter((id) => Number.isInteger(id) && id > 0))] : [];
+    entry.allBlockIds = allBlockIds;
+    entry.activeBlockIds = allBlockIds.filter((id) => messagesState.activeBlockIds.has(id));
+  }
+  const nextActiveBlockIds = messagesState.activeBlockIds;
+  let deactivatedCount = 0;
+  let reactivatedCount = 0;
+  for (const blockId of previousActiveBlockIds) {
+    if (!nextActiveBlockIds.has(blockId)) {
+      deactivatedCount++;
+    }
+  }
+  for (const blockId of nextActiveBlockIds) {
+    if (!previousActiveBlockIds.has(blockId)) {
+      reactivatedCount++;
+    }
+  }
+  if (missingOriginBlockIds.length > 0 || deactivatedCount > 0 || reactivatedCount > 0) {
+    logger.info("Synced compress block state", {
+      missingOriginCount: missingOriginBlockIds.length,
+      deactivatedCount,
+      reactivatedCount
+    });
+  }
+};
 
-// lib/prompts/context-limit-nudge.ts
-var CONTEXT_LIMIT_NUDGE = `
-<system-reminder>
-\u26A0\uFE0F CRITICAL: Context limit reached. You MUST use the \`compress\` tool NOW.
+// lib/host-permissions.ts
+var findLastMatchingRule = (rules, predicate) => {
+  for (let index = rules.length - 1; index >= 0; index -= 1) {
+    const rule = rules[index];
+    if (rule && predicate(rule)) {
+      return rule;
+    }
+  }
+  return void 0;
+};
+var wildcardMatch = (value, pattern) => {
+  const normalizedValue = value.replaceAll("\\", "/");
+  let escaped = pattern.replaceAll("\\", "/").replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  if (escaped.endsWith(" .*")) {
+    escaped = escaped.slice(0, -3) + "( .*)?";
+  }
+  const flags = process.platform === "win32" ? "si" : "s";
+  return new RegExp(`^${escaped}$`, flags).test(normalizedValue);
+};
+var getPermissionRules = (permissionConfigs) => {
+  const rules = [];
+  for (const permissionConfig of permissionConfigs) {
+    if (!permissionConfig) {
+      continue;
+    }
+    for (const [permission, value] of Object.entries(permissionConfig)) {
+      if (value === "ask" || value === "allow" || value === "deny") {
+        rules.push({ permission, pattern: "*", action: value });
+        continue;
+      }
+      for (const [pattern, action] of Object.entries(value)) {
+        if (action === "ask" || action === "allow" || action === "deny") {
+          rules.push({ permission, pattern, action });
+        }
+      }
+    }
+  }
+  return rules;
+};
+var compressDisabledByOpencode = (...permissionConfigs) => {
+  const match = findLastMatchingRule(
+    getPermissionRules(permissionConfigs),
+    (rule) => wildcardMatch("compress", rule.permission)
+  );
+  return match?.pattern === "*" && match.action === "deny";
+};
+var resolveEffectiveCompressPermission = (basePermission, hostPermissions, agentName) => {
+  if (basePermission === "deny") {
+    return "deny";
+  }
+  return compressDisabledByOpencode(
+    hostPermissions.global,
+    agentName ? hostPermissions.agents[agentName] : void 0
+  ) ? "deny" : basePermission;
+};
+var hasExplicitToolPermission = (permissionConfig, tool4) => {
+  return permissionConfig ? Object.prototype.hasOwnProperty.call(permissionConfig, tool4) : false;
+};
 
-If mid-atomic-operation, finish that step first, then compress immediately.
+// lib/compress-permission.ts
+var compressPermission = (state, config) => {
+  return state.compressPermission ?? config.compress.permission;
+};
+var syncCompressPermissionState = (state, config, hostPermissions, messages) => {
+  const activeAgent = getLastUserMessage(messages)?.info.agent;
+  state.compressPermission = resolveEffectiveCompressPermission(
+    config.compress.permission,
+    hostPermissions,
+    activeAgent
+  );
+};
 
-HOW TO CALL COMPRESS:
-{
-  "topic": "Short Label",
-  "content": [
-    {
-      "startId": "<ID from early in this conversation>",
-      "endId": "<ID from later in this conversation>",
-      "summary": "Complete technical summary of everything in the range"
+// lib/prompts/extensions/nudge.ts
+function buildCompressedBlockGuidance(state, gcConfig, context) {
+  const activeBlockIds = Array.from(state.prune.messages.activeBlockIds).filter((id) => Number.isInteger(id) && id > 0).sort((a, b) => a - b);
+  const refs = activeBlockIds.map((id) => `b${id}`);
+  const blockCount = refs.length;
+  const blockList = blockCount > 0 ? refs.join(", ") : "none";
+  const lines = [
+    "Compressed block context:",
+    `- Active compressed blocks: ${blockCount} (${blockList})`,
+    "- If your selected compression range includes any listed block, include each required placeholder exactly once in the summary using `(bN)`."
+  ];
+  const usageRatio = context?.currentTokens && context?.modelContextLimit ? context.currentTokens / context.modelContextLimit : 0;
+  if (gcConfig && usageRatio > 0.5) {
+    const promotionThreshold = gcConfig.promotionThreshold;
+    const agingBlocks = [];
+    for (const blockId of activeBlockIds) {
+      const block = state.prune.messages.blocksById.get(blockId);
+      if (!block) continue;
+      const survived = block.survivedCount ?? 0;
+      const gen = block.generation ?? "young";
+      const sizeK = (block.summary.length / 1e3).toFixed(1);
+      const preview = block.summary.slice(0, 120).replace(/\n/g, " ");
+      if (gen === "old" || survived >= promotionThreshold - 2) {
+        agingBlocks.push(
+          `  b${blockId}: age=${survived}/${promotionThreshold}, gen=${gen}, size=${sizeK}K chars \u2014 ${preview}...`
+        );
+      }
     }
-  ]
+    if (agingBlocks.length > 0) {
+      lines.push("");
+      lines.push("\u26A0\uFE0F Block aging warning \u2014 these blocks may be truncated by GC soon:");
+      lines.push(...agingBlocks);
+      lines.push(
+        "To preserve important content: use the compress tool to re-summarize these blocks into new concise ones. Unhandled blocks will be auto-truncated."
+      );
+    }
+  }
+  return lines.join("\n");
 }
-
-\u26A0\uFE0F ID RULES \u2014 MOST COMMON CAUSE OF ERRORS:
-- ONLY use IDs you can see in <dcp-message-id> tags in the messages ABOVE.
-- Do NOT copy IDs from this example. Do NOT invent IDs.
-- Do NOT use IDs from compressed block summaries \u2014 they are stale.
-- startId must appear BEFORE endId in the conversation.
-
-SUMMARY RULES:
-- Capture ALL essential details: file paths, decisions, constraints, key findings.
-- Preserve user intent exactly. Direct-quote short user messages.
-- Prefer one large range over multiple small ones.
-- Compress OLDER resolved history first. Keep recent active work.
-</system-reminder>
-`;
-
-// lib/prompts/turn-nudge.ts
-var TURN_NUDGE = `
-<system-reminder>
-Context is getting full. Compress closed/older conversation ranges now.
-
-{
-  "topic": "Short Label",
-  "content": [{ "startId": "<visible message ID>", "endId": "<visible message ID>", "summary": "..." }]
+function renderMessagePriorityGuidance(priorityLabel, refs) {
+  const refList = refs.length > 0 ? refs.join(", ") : "none";
+  return [
+    "Message priority context:",
+    "- Higher-priority older messages consume more context and should be compressed right away if it is safe to do so.",
+    `- ${priorityLabel}-priority message IDs before this point: ${refList}`
+  ].join("\n");
 }
+function appendGuidanceToDcpTag(nudgeText, guidance) {
+  if (!guidance.trim()) {
+    return nudgeText;
+  }
+  const closeTag = "</dcp-system-reminder>";
+  const closeTagIndex = nudgeText.lastIndexOf(closeTag);
+  if (closeTagIndex === -1) {
+    return nudgeText;
+  }
+  const beforeClose = nudgeText.slice(0, closeTagIndex).trimEnd();
+  const afterClose = nudgeText.slice(closeTagIndex);
+  return `${beforeClose}
 
-\u26A0\uFE0F ONLY use IDs from <dcp-message-id> tags visible above. Do NOT invent or copy example IDs.
-</system-reminder>
-`;
-
-// lib/prompts/iteration-nudge.ts
-var ITERATION_NUDGE = `
-<system-reminder>
-You've been iterating for a while. If any earlier work is closed and unlikely to be referenced, compress it now.
-
-{
-  "topic": "Short Label",
-  "content": [{ "startId": "<visible message ID>", "endId": "<visible message ID>", "summary": "..." }]
+${guidance}
+${afterClose}`;
 }
 
-\u26A0\uFE0F ONLY use IDs from <dcp-message-id> tags visible above. Do NOT invent or copy example IDs.
-</system-reminder>
-`;
-
-// lib/prompts/extensions/system.ts
-var MANUAL_MODE_SYSTEM_EXTENSION = `<dcp-system-reminder>
-Manual mode is enabled. Do NOT use compress unless the user has explicitly triggered it through a manual marker.
-
-Only use the compress tool after seeing \`<compress triggered manually>\` in the current user instruction context.
-
-Issue exactly ONE compress tool per manual trigger. Do NOT launch multiple compress tools in parallel. Each trigger grants a single compression; after it completes, wait for the next trigger.
-
-After completing a manually triggered context-management action, STOP IMMEDIATELY. Do NOT continue with any task execution. End your response right after the tool use completes and wait for the next user input.
-</dcp-system-reminder>
-`;
-var SUBAGENT_SYSTEM_EXTENSION = `<dcp-system-reminder>
-You are operating in a subagent environment.
-
-The initial subagent instruction is imperative and must be followed exactly.
-It is the only user message intentionally not assigned a message ID, and therefore is not eligible for compression.
-All subsequent messages in the session will have IDs.
-</dcp-system-reminder>
-`;
-function buildProtectedToolsExtension(protectedTools) {
-  if (protectedTools.length === 0) {
-    return "";
+// lib/messages/priority.ts
+var MEDIUM_PRIORITY_MIN_TOKENS = 500;
+var HIGH_PRIORITY_MIN_TOKENS = 5e3;
+function buildPriorityMap(config, state, messages) {
+  if (config.compress.mode !== "message") {
+    return /* @__PURE__ */ new Map();
   }
-  const toolList = protectedTools.map((t) => `\`${t}\``).join(", ");
-  return `<dcp-system-reminder>
-The following tools are environment-managed: ${toolList}.
-Their outputs are automatically preserved during compression.
-Do not include their content in compress tool summaries \u2014 the environment retains it independently.
-</dcp-system-reminder>`;
+  const priorities = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    if (isIgnoredUserMessage(message)) {
+      continue;
+    }
+    if (isProtectedUserMessage(config, message)) {
+      continue;
+    }
+    if (isMessageCompacted(state, message)) {
+      continue;
+    }
+    const rawMessageId = message.info.id;
+    if (typeof rawMessageId !== "string" || rawMessageId.length === 0) {
+      continue;
+    }
+    const ref = state.messageIds.byRawId.get(rawMessageId);
+    if (!ref) {
+      continue;
+    }
+    const tokenCount = countAllMessageTokens(message);
+    priorities.set(rawMessageId, {
+      ref,
+      tokenCount,
+      priority: messageHasCompress(message) ? "high" : classifyMessagePriority(tokenCount)
+    });
+  }
+  return priorities;
+}
+function classifyMessagePriority(tokenCount) {
+  if (tokenCount >= HIGH_PRIORITY_MIN_TOKENS) {
+    return "high";
+  }
+  if (tokenCount >= MEDIUM_PRIORITY_MIN_TOKENS) {
+    return "medium";
+  }
+  return "low";
+}
+function listPriorityRefsBeforeIndex(messages, priorities, anchorIndex, priority) {
+  const refs = [];
+  const seen = /* @__PURE__ */ new Set();
+  const upperBound = Math.max(0, Math.min(anchorIndex, messages.length));
+  for (let index = 0; index < upperBound; index++) {
+    const rawMessageId = messages[index]?.info.id;
+    if (typeof rawMessageId !== "string") {
+      continue;
+    }
+    const entry = priorities.get(rawMessageId);
+    if (!entry || entry.priority !== priority || seen.has(entry.ref)) {
+      continue;
+    }
+    seen.add(entry.ref);
+    refs.push(entry.ref);
+  }
+  return refs;
 }
 
-// lib/prompts/store.ts
-var PROMPT_DEFINITIONS = [
-  {
-    key: "system",
-    fileName: "system.md",
-    label: "System",
-    description: "Core system-level ACP instruction block",
-    usage: "Injected into the model system prompt on every request",
-    runtimeField: "system"
-  },
-  {
-    key: "compress-range",
-    fileName: "compress-range.md",
-    label: "Compress Range",
-    description: "range-mode compress tool instructions and summary constraints",
-    usage: "Registered as the range-mode compress tool description",
-    runtimeField: "compressRange"
-  },
-  {
-    key: "compress-message",
-    fileName: "compress-message.md",
-    label: "Compress Message",
-    description: "message-mode compress tool instructions and summary constraints",
-    usage: "Registered as the message-mode compress tool description",
-    runtimeField: "compressMessage"
-  },
-  {
-    key: "context-limit-nudge",
-    fileName: "context-limit-nudge.md",
-    label: "Context Limit Nudge",
-    description: "High-priority nudge when context is over max threshold",
-    usage: "Injected when context usage is beyond configured max limits",
-    runtimeField: "contextLimitNudge"
-  },
-  {
-    key: "turn-nudge",
-    fileName: "turn-nudge.md",
-    label: "Turn Nudge",
-    description: "Nudge to compress closed ranges at turn boundaries",
-    usage: "Injected when context is between min and max limits at a new user turn",
-    runtimeField: "turnNudge"
-  },
-  {
-    key: "iteration-nudge",
-    fileName: "iteration-nudge.md",
-    label: "Iteration Nudge",
-    description: "Nudge after many iterations without user input",
-    usage: "Injected when iteration threshold is crossed",
-    runtimeField: "iterationNudge"
+// lib/messages/inject/utils.ts
+var MESSAGE_MODE_NUDGE_PRIORITY = "high";
+function getNudgeFrequency(config) {
+  return Math.max(1, Math.floor(config.compress.nudgeFrequency || 1));
+}
+function getIterationNudgeThreshold(config) {
+  return Math.max(1, Math.floor(config.compress.iterationNudgeThreshold || 1));
+}
+function findLastNonIgnoredMessage(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (isIgnoredUserMessage(message)) {
+      continue;
+    }
+    if (isSyntheticMessage(message)) {
+      continue;
+    }
+    return { message, index: i };
   }
-];
-var HTML_COMMENT_REGEX = /<!--[\s\S]*?-->/g;
-var LEGACY_INLINE_COMMENT_LINE_REGEX = /^[ \t]*\/\/.*?\/\/[ \t]*$/gm;
-var DCP_SYSTEM_REMINDER_TAG_REGEX = /^\s*<dcp-system-reminder\b[^>]*>[\s\S]*<\/dcp-system-reminder>\s*$/i;
-var DEFAULTS_README_FILE = "README.md";
-var BUNDLED_EDITABLE_PROMPTS = {
-  system: SYSTEM,
-  compressRange: COMPRESS_RANGE,
-  compressMessage: COMPRESS_MESSAGE,
-  contextLimitNudge: CONTEXT_LIMIT_NUDGE,
-  turnNudge: TURN_NUDGE,
-  iterationNudge: ITERATION_NUDGE
-};
-var INTERNAL_PROMPT_EXTENSIONS = {
-  manualExtension: MANUAL_MODE_SYSTEM_EXTENSION,
-  subagentExtension: SUBAGENT_SYSTEM_EXTENSION
-};
-function createBundledRuntimePrompts() {
+  return null;
+}
+function countMessagesAfterIndex(messages, index) {
+  let count = 0;
+  for (let i = index + 1; i < messages.length; i++) {
+    const message = messages[i];
+    if (isIgnoredUserMessage(message)) {
+      continue;
+    }
+    count++;
+  }
+  return count;
+}
+function getModelInfo(messages) {
+  const lastUserMessage = getLastUserMessage(messages);
+  if (!lastUserMessage) {
+    return {
+      providerId: void 0,
+      modelId: void 0
+    };
+  }
+  const userInfo = lastUserMessage.info;
   return {
-    system: BUNDLED_EDITABLE_PROMPTS.system,
-    compressRange: BUNDLED_EDITABLE_PROMPTS.compressRange,
-    compressMessage: BUNDLED_EDITABLE_PROMPTS.compressMessage,
-    contextLimitNudge: BUNDLED_EDITABLE_PROMPTS.contextLimitNudge,
-    turnNudge: BUNDLED_EDITABLE_PROMPTS.turnNudge,
-    iterationNudge: BUNDLED_EDITABLE_PROMPTS.iterationNudge,
-    manualExtension: INTERNAL_PROMPT_EXTENSIONS.manualExtension,
-    subagentExtension: INTERNAL_PROMPT_EXTENSIONS.subagentExtension
+    providerId: userInfo.model.providerID,
+    modelId: userInfo.model.modelID
+  };
+}
+function resolveContextTokenLimit(config, state, providerId, modelId, threshold) {
+  const parseLimitValue = (limit) => {
+    if (limit === void 0) {
+      return void 0;
+    }
+    if (typeof limit === "number") {
+      return limit;
+    }
+    if (!limit.endsWith("%") || state.modelContextLimit === void 0) {
+      return void 0;
+    }
+    const parsedPercent = parseFloat(limit.slice(0, -1));
+    if (isNaN(parsedPercent)) {
+      return void 0;
+    }
+    const roundedPercent = Math.round(parsedPercent);
+    const clampedPercent = Math.max(0, Math.min(100, roundedPercent));
+    return Math.round(clampedPercent / 100 * state.modelContextLimit);
   };
+  const modelLimits = threshold === "max" ? config.compress.modelMaxLimits : config.compress.modelMinLimits;
+  if (modelLimits && providerId !== void 0 && modelId !== void 0) {
+    const providerModelId = `${providerId}/${modelId}`;
+    const modelLimit = modelLimits[providerModelId];
+    if (modelLimit !== void 0) {
+      return parseLimitValue(modelLimit);
+    }
+  }
+  const globalLimit = threshold === "max" ? config.compress.maxContextLimit : config.compress.minContextLimit;
+  return parseLimitValue(globalLimit);
 }
-function findOpencodeDir2(startDir) {
-  let current = startDir;
-  while (current !== "/") {
-    const candidate = join4(current, ".opencode");
-    if (existsSync4(candidate)) {
-      try {
-        if (statSync2(candidate).isDirectory()) {
-          return candidate;
+function isContextOverLimits(config, state, providerId, modelId, messages) {
+  const summaryTokenExtension = config.compress.summaryBuffer ? getActiveSummaryTokenUsage(state) : 0;
+  const resolvedMaxContextLimit = resolveContextTokenLimit(
+    config,
+    state,
+    providerId,
+    modelId,
+    "max"
+  );
+  const maxContextLimit = resolvedMaxContextLimit === void 0 ? void 0 : resolvedMaxContextLimit + summaryTokenExtension;
+  const minContextLimit = resolveContextTokenLimit(config, state, providerId, modelId, "min");
+  const currentTokens = getCurrentTokenUsage(state, messages);
+  let overMaxLimit = maxContextLimit === void 0 ? false : currentTokens > maxContextLimit;
+  const overMinLimit = minContextLimit === void 0 ? false : currentTokens >= minContextLimit;
+  if (overMaxLimit) {
+    const recentCompressCount = 3;
+    const recentMessages = messages.slice(-recentCompressCount);
+    for (const msg of recentMessages) {
+      if (msg.info.role === "assistant" && msg.parts) {
+        for (const part of msg.parts) {
+          if (part.type === "tool-invocation" && part.toolInvocation?.toolName === "compress") {
+            overMaxLimit = false;
+            break;
+          }
         }
-      } catch {
       }
+      if (!overMaxLimit) break;
     }
-    const parent = dirname2(current);
-    if (parent === current) {
+  }
+  return {
+    overMaxLimit,
+    overMinLimit,
+    currentTokens,
+    modelContextLimit: state.modelContextLimit
+  };
+}
+function addAnchor(anchorMessageIds, anchorMessageId, anchorMessageIndex, messages, interval) {
+  if (anchorMessageIndex < 0) {
+    return false;
+  }
+  let latestAnchorMessageIndex = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (anchorMessageIds.has(messages[i].info.id)) {
+      latestAnchorMessageIndex = i;
       break;
     }
-    current = parent;
   }
-  return null;
+  const shouldAdd = latestAnchorMessageIndex < 0 || anchorMessageIndex - latestAnchorMessageIndex >= interval;
+  if (!shouldAdd) {
+    return false;
+  }
+  const previousSize = anchorMessageIds.size;
+  anchorMessageIds.add(anchorMessageId);
+  return anchorMessageIds.size !== previousSize;
 }
-function resolvePromptPaths(workingDirectory) {
-  const configHome = process.env.XDG_CONFIG_HOME || join4(homedir4(), ".config");
-  const globalRoot = join4(configHome, "opencode", "acp-prompts");
-  const legacyGlobalRoot = join4(configHome, "opencode", "dcp-prompts");
-  if (!existsSync4(globalRoot) && existsSync4(legacyGlobalRoot)) {
-    try {
-      cpSync2(legacyGlobalRoot, globalRoot, { recursive: true });
-      console.log("[ACP] Migrated prompts from dcp-prompts to acp-prompts");
-    } catch (e) {
-      console.warn(`[ACP] Prompts migration failed: ${e.message}`);
+function buildMessagePriorityGuidance(messages, compressionPriorities, anchorIndex, priority) {
+  if (!compressionPriorities || compressionPriorities.size === 0) {
+    return "";
+  }
+  const refs = listPriorityRefsBeforeIndex(messages, compressionPriorities, anchorIndex, priority);
+  const priorityLabel = `${priority[0].toUpperCase()}${priority.slice(1)}`;
+  return renderMessagePriorityGuidance(priorityLabel, refs);
+}
+function injectAnchoredNudge(message, nudgeText) {
+  if (!nudgeText.trim()) {
+    return;
+  }
+  if (message.info.role === "user") {
+    if (appendToLastTextPart(message, nudgeText)) {
+      return;
     }
+    message.parts.push(createSyntheticTextPart(message, nudgeText));
+    return;
+  }
+  if (message.info.role !== "assistant") {
+    return;
+  }
+  if (!hasContent(message)) {
+    return;
+  }
+  for (const part of message.parts) {
+    if (part.type === "text") {
+      if (appendToTextPart(part, nudgeText)) {
+        return;
+      }
+    }
+  }
+  const syntheticPart = createSyntheticTextPart(message, nudgeText);
+  const firstToolIndex = message.parts.findIndex((p) => p.type === "tool");
+  if (firstToolIndex === -1) {
+    message.parts.push(syntheticPart);
+  } else {
+    message.parts.splice(firstToolIndex, 0, syntheticPart);
   }
-  const defaultsDir = join4(globalRoot, "defaults");
-  const globalOverridesDir = join4(globalRoot, "overrides");
-  const configDirOverridesDir = process.env.OPENCODE_CONFIG_DIR ? join4(process.env.OPENCODE_CONFIG_DIR, "acp-prompts", "overrides") : null;
-  const opencodeDir = findOpencodeDir2(workingDirectory);
-  const projectOverridesDir = opencodeDir ? join4(opencodeDir, "acp-prompts", "overrides") : null;
-  return {
-    defaultsDir,
-    globalOverridesDir,
-    configDirOverridesDir,
-    projectOverridesDir
-  };
 }
-function stripConditionalTag(content, tagName) {
-  const regex = new RegExp(`<${tagName}>[\\s\\S]*?</${tagName}>`, "gi");
-  return content.replace(regex, "");
+function collectAnchoredMessages(anchorMessageIds, messages) {
+  const anchoredMessages = [];
+  for (const anchorMessageId of anchorMessageIds) {
+    const index = messages.findIndex((message) => message.info.id === anchorMessageId);
+    if (index === -1) {
+      continue;
+    }
+    anchoredMessages.push({
+      message: messages[index],
+      index
+    });
+  }
+  return anchoredMessages;
 }
-function unwrapDcpTagIfWrapped(content) {
-  const trimmed = content.trim();
-  if (DCP_SYSTEM_REMINDER_TAG_REGEX.test(trimmed)) {
-    return trimmed.replace(/^\s*<dcp-system-reminder\b[^>]*>\s*/i, "").replace(/\s*<\/dcp-system-reminder>\s*$/i, "").trim();
+function collectTurnNudgeAnchors2(state, config, messages) {
+  const turnNudgeAnchors = /* @__PURE__ */ new Set();
+  const targetRole = config.compress.nudgeForce === "strong" ? "user" : "assistant";
+  for (const message of messages) {
+    if (!state.nudges.turnNudgeAnchors.has(message.info.id)) continue;
+    if (message.info.role === targetRole) {
+      turnNudgeAnchors.add(message.info.id);
+    }
   }
-  return trimmed;
+  return turnNudgeAnchors;
 }
-function normalizeReminderPromptContent(content) {
-  const normalized = content.trim();
-  if (!normalized) {
-    return "";
+function applyRangeModeAnchoredNudge(anchorMessageIds, messages, baseNudgeText, compressedBlockGuidance) {
+  const nudgeText = appendGuidanceToDcpTag(baseNudgeText, compressedBlockGuidance);
+  if (!nudgeText.trim()) {
+    return;
   }
-  const startsWrapped = /^\s*<dcp-system-reminder\b[^>]*>/i.test(normalized);
-  const endsWrapped = /<\/dcp-system-reminder>\s*$/i.test(normalized);
-  if (startsWrapped !== endsWrapped) {
+  for (const { message } of collectAnchoredMessages(anchorMessageIds, messages)) {
+    injectAnchoredNudge(message, nudgeText);
+  }
+}
+function applyMessageModeAnchoredNudge(anchorMessageIds, messages, baseNudgeText, compressionPriorities) {
+  for (const { message, index } of collectAnchoredMessages(anchorMessageIds, messages)) {
+    const priorityGuidance = buildMessagePriorityGuidance(
+      messages,
+      compressionPriorities,
+      index,
+      MESSAGE_MODE_NUDGE_PRIORITY
+    );
+    const nudgeText = appendGuidanceToDcpTag(baseNudgeText, priorityGuidance);
+    injectAnchoredNudge(message, nudgeText);
+  }
+}
+function resolveThresholdPercent(threshold, modelContextLimit) {
+  if (threshold === void 0) return void 0;
+  if (typeof threshold === "number") {
+    if (!modelContextLimit) return void 0;
+    return threshold / modelContextLimit * 100;
+  }
+  const parsed = parseFloat(threshold);
+  return isNaN(parsed) ? void 0 : parsed;
+}
+function buildContextUsageGuidance(config, currentTokens, modelContextLimit) {
+  if (currentTokens === void 0 || modelContextLimit === void 0 || modelContextLimit === 0) {
     return "";
   }
-  return unwrapDcpTagIfWrapped(normalized);
+  const pct = currentTokens / modelContextLimit * 100;
+  const percentage = pct.toFixed(1);
+  const formatK = (n) => n >= 1e3 ? `${(n / 1e3).toFixed(1)}K` : String(n);
+  const minPct = resolveThresholdPercent(config.compress.minContextLimit, modelContextLimit) ?? 45;
+  const maxPct = resolveThresholdPercent(config.compress.maxContextLimit, modelContextLimit) ?? 55;
+  const base = `Context usage: ${formatK(currentTokens)} / ${formatK(modelContextLimit)} tokens (${percentage}%). ACP threshold: ${maxPct.toFixed(0)}%.`;
+  let guidance;
+  if (pct < minPct) {
+    guidance = " Context is ample \u2014 focus on your task. Only compress obvious waste (large terminal outputs, duplicated content).";
+  } else if (pct < maxPct) {
+    guidance = " Context is moderate \u2014 compress completed sections and high-token waste. Preserve key details.";
+  } else {
+    guidance = " Context is high \u2014 compress aggressively but selectively. Preserve only what is essential.";
+  }
+  return `
+
+${base}${guidance}`;
+}
+function applyAnchoredNudges(state, config, messages, prompts, compressionPriorities, currentTokens, modelContextLimit, suffixMessage) {
+  const contextUsageInfo = buildContextUsageGuidance(config, currentTokens, modelContextLimit);
+  const contextLimitNudgeWithUsage = prompts.contextLimitNudge + contextUsageInfo;
+  const turnNudgeAnchors = collectTurnNudgeAnchors2(state, config, messages);
+  if (suffixMessage) {
+    const nudgeParts = [];
+    if (config.compress.mode === "message") {
+      if (state.nudges.contextLimitAnchors.size > 0) {
+        for (const { index } of collectAnchoredMessages(state.nudges.contextLimitAnchors, messages)) {
+          const guidance = buildMessagePriorityGuidance(messages, compressionPriorities, index, MESSAGE_MODE_NUDGE_PRIORITY);
+          nudgeParts.push(appendGuidanceToDcpTag(contextLimitNudgeWithUsage, guidance));
+        }
+      }
+      if (turnNudgeAnchors.size > 0) {
+        for (const { index } of collectAnchoredMessages(turnNudgeAnchors, messages)) {
+          const guidance = buildMessagePriorityGuidance(messages, compressionPriorities, index, MESSAGE_MODE_NUDGE_PRIORITY);
+          nudgeParts.push(appendGuidanceToDcpTag(prompts.turnNudge, guidance));
+        }
+      }
+      if (state.nudges.iterationNudgeAnchors.size > 0) {
+        for (const { index } of collectAnchoredMessages(state.nudges.iterationNudgeAnchors, messages)) {
+          const guidance = buildMessagePriorityGuidance(messages, compressionPriorities, index, MESSAGE_MODE_NUDGE_PRIORITY);
+          nudgeParts.push(appendGuidanceToDcpTag(prompts.iterationNudge, guidance));
+        }
+      }
+    } else {
+      if (state.nudges.contextLimitAnchors.size > 0) {
+        nudgeParts.push(contextLimitNudgeWithUsage);
+      }
+      if (turnNudgeAnchors.size > 0) {
+        nudgeParts.push(prompts.turnNudge);
+      }
+      if (state.nudges.iterationNudgeAnchors.size > 0) {
+        nudgeParts.push(prompts.iterationNudge);
+      }
+    }
+    const combined = nudgeParts.join("\n\n");
+    if (combined.trim()) {
+      injectAnchoredNudge(suffixMessage, combined);
+    }
+    return;
+  }
+  if (config.compress.mode === "message") {
+    applyMessageModeAnchoredNudge(
+      state.nudges.contextLimitAnchors,
+      messages,
+      contextLimitNudgeWithUsage,
+      compressionPriorities
+    );
+    applyMessageModeAnchoredNudge(
+      turnNudgeAnchors,
+      messages,
+      prompts.turnNudge,
+      compressionPriorities
+    );
+    applyMessageModeAnchoredNudge(
+      state.nudges.iterationNudgeAnchors,
+      messages,
+      prompts.iterationNudge,
+      compressionPriorities
+    );
+    return;
+  }
+  applyRangeModeAnchoredNudge(
+    state.nudges.contextLimitAnchors,
+    messages,
+    contextLimitNudgeWithUsage,
+    ""
+  );
+  applyRangeModeAnchoredNudge(
+    turnNudgeAnchors,
+    messages,
+    prompts.turnNudge,
+    ""
+  );
+  applyRangeModeAnchoredNudge(
+    state.nudges.iterationNudgeAnchors,
+    messages,
+    prompts.iterationNudge,
+    ""
+  );
 }
-function stripPromptComments(content) {
-  return content.replace(/^\uFEFF/, "").replace(/\r\n?/g, "\n").replace(HTML_COMMENT_REGEX, "").replace(LEGACY_INLINE_COMMENT_LINE_REGEX, "");
+
+// lib/messages/inject/inject.ts
+var ACP_SUFFIX_SEED = "acp-dynamic-guidance";
+function createSuffixMessage(messages) {
+  if (messages.length === 0) return null;
+  const base = messages.find((m) => m.info.role === "user") || messages[messages.length - 1];
+  const synthetic = createSyntheticUserMessage(base, "", ACP_SUFFIX_SEED);
+  messages.push(synthetic);
+  return synthetic;
 }
-function toEditablePromptText(definition, rawContent) {
-  let normalized = stripPromptComments(rawContent).trim();
-  if (!normalized) {
-    return "";
-  }
-  if (definition.key === "system") {
-    normalized = stripConditionalTag(normalized, "manual");
-    normalized = stripConditionalTag(normalized, "subagent");
-  }
-  if (definition.key !== "compress-range" && definition.key !== "compress-message") {
-    normalized = normalizeReminderPromptContent(normalized);
+var injectCompressNudges = (state, config, logger, messages, prompts, compressionPriorities) => {
+  if (compressPermission(state, config) === "deny") {
+    return;
   }
-  return normalized.trim();
-}
-function wrapRuntimePromptContent(definition, editableText) {
-  const trimmed = editableText.trim();
-  if (!trimmed) {
-    return "";
+  if (state.manualMode) {
+    return;
   }
-  if (definition.key === "compress-range" || definition.key === "compress-message") {
-    return trimmed;
+  const lastMessage = findLastNonIgnoredMessage(messages);
+  const lastAssistantMessage = messages.findLast((message) => message.info.role === "assistant");
+  if (lastAssistantMessage && messageHasCompress(lastAssistantMessage)) {
+    state.nudges.contextLimitAnchors.clear();
+    state.nudges.turnNudgeAnchors.clear();
+    state.nudges.iterationNudgeAnchors.clear();
+    void saveSessionState(state, logger);
+    return;
   }
-  return `<dcp-system-reminder>
-${trimmed}
-</dcp-system-reminder>`;
-}
-function buildDefaultPromptFileContent(bundledEditableText) {
-  return `${bundledEditableText.trim()}
-`;
-}
-function buildDefaultsReadmeContent() {
-  const lines = [];
-  lines.push("# ACP Prompt Defaults");
-  lines.push("");
-  lines.push("This directory stores the ACP prompts.");
-  lines.push("Each prompt file here should contain plain text only (no XML wrappers).");
-  lines.push("");
-  lines.push("## Creating Overrides");
-  lines.push("");
-  lines.push(
-    "1. Copy a prompt file from this directory into an overrides directory using the same filename."
-  );
-  lines.push("2. Edit the copied file using plain text.");
-  lines.push("3. Restart OpenCode.");
-  lines.push("");
-  lines.push("To reset an override, delete the matching file from your overrides directory.");
-  lines.push("");
-  lines.push(
-    "Do not edit the default prompt files directly, they are just for reference, only files in the overrides directory are used."
+  const { providerId, modelId } = getModelInfo(messages);
+  let anchorsChanged = false;
+  const { overMaxLimit, overMinLimit, currentTokens, modelContextLimit } = isContextOverLimits(
+    config,
+    state,
+    providerId,
+    modelId,
+    messages
   );
-  lines.push("");
-  lines.push("Override precedence (highest first):");
-  lines.push("1. `.opencode/acp-prompts/overrides/` (project)");
-  lines.push("2. `$OPENCODE_CONFIG_DIR/acp-prompts/overrides/` (config dir)");
-  lines.push("3. `~/.config/opencode/acp-prompts/overrides/` (global)");
-  lines.push("");
-  lines.push("## Prompt Files");
-  lines.push("");
-  for (const definition of PROMPT_DEFINITIONS) {
-    lines.push(`- \`${definition.fileName}\``);
-    lines.push(`  - Purpose: ${definition.description}.`);
-    lines.push(`  - Runtime use: ${definition.usage}.`);
-  }
-  return `${lines.join("\n")}
-`;
-}
-function readFileIfExists(filePath) {
-  if (!existsSync4(filePath)) {
-    return null;
+  if (!overMinLimit) {
+    const hadTurnAnchors = state.nudges.turnNudgeAnchors.size > 0;
+    const hadIterationAnchors = state.nudges.iterationNudgeAnchors.size > 0;
+    if (hadTurnAnchors || hadIterationAnchors) {
+      state.nudges.turnNudgeAnchors.clear();
+      state.nudges.iterationNudgeAnchors.clear();
+      anchorsChanged = true;
+    }
   }
-  try {
-    return readFileSync2(filePath, "utf-8");
-  } catch {
-    return null;
+  if (overMaxLimit) {
+    if (lastMessage) {
+      const interval = getNudgeFrequency(config);
+      const added = addAnchor(
+        state.nudges.contextLimitAnchors,
+        lastMessage.message.info.id,
+        lastMessage.index,
+        messages,
+        interval
+      );
+      if (added) {
+        anchorsChanged = true;
+      }
+    }
+  } else if (overMinLimit) {
+    const isLastMessageUser = lastMessage?.message.info.role === "user";
+    if (isLastMessageUser && lastAssistantMessage) {
+      const previousSize = state.nudges.turnNudgeAnchors.size;
+      state.nudges.turnNudgeAnchors.add(lastMessage.message.info.id);
+      state.nudges.turnNudgeAnchors.add(lastAssistantMessage.info.id);
+      if (state.nudges.turnNudgeAnchors.size !== previousSize) {
+        anchorsChanged = true;
+      }
+    }
+    const lastUserMessage = getLastUserMessage(messages);
+    if (lastUserMessage && lastMessage) {
+      const lastUserMessageIndex = messages.findIndex(
+        (message) => message.info.id === lastUserMessage.info.id
+      );
+      if (lastUserMessageIndex >= 0) {
+        const messagesSinceUser = countMessagesAfterIndex(messages, lastUserMessageIndex);
+        const iterationThreshold = getIterationNudgeThreshold(config);
+        if (lastMessage.index > lastUserMessageIndex && messagesSinceUser >= iterationThreshold) {
+          const interval = getNudgeFrequency(config);
+          const added = addAnchor(
+            state.nudges.iterationNudgeAnchors,
+            lastMessage.message.info.id,
+            lastMessage.index,
+            messages,
+            interval
+          );
+          if (added) {
+            anchorsChanged = true;
+          }
+        }
+      }
+    }
   }
-}
-var PromptStore = class {
-  logger;
-  paths;
-  customPromptsEnabled;
-  runtimePrompts;
-  constructor(logger, workingDirectory, customPromptsEnabled = false) {
-    this.logger = logger;
-    this.paths = resolvePromptPaths(workingDirectory);
-    this.customPromptsEnabled = customPromptsEnabled;
-    this.runtimePrompts = createBundledRuntimePrompts();
-    if (this.customPromptsEnabled) {
-      this.ensureDefaultFiles();
+  const suffixMessage = createSuffixMessage(messages);
+  applyAnchoredNudges(state, config, messages, prompts, compressionPriorities, currentTokens, modelContextLimit, suffixMessage);
+  injectContextUsage(suffixMessage, config, currentTokens, modelContextLimit);
+  if (config.compress.mode !== "message") {
+    const blockGuidance = buildCompressedBlockGuidance(state, config.gc, { currentTokens, modelContextLimit });
+    if (blockGuidance.trim() && suffixMessage) {
+      appendToLastTextPart(suffixMessage, "\n\n" + blockGuidance);
     }
-    this.reload();
   }
-  getRuntimePrompts() {
-    return { ...this.runtimePrompts };
+  injectVisibleIdRange(state, messages, suffixMessage);
+  if (anchorsChanged) {
+    void saveSessionState(state, logger);
   }
-  reload() {
-    const nextPrompts = createBundledRuntimePrompts();
-    if (!this.customPromptsEnabled) {
-      this.runtimePrompts = nextPrompts;
+};
+function injectContextUsage(target, config, currentTokens, modelContextLimit) {
+  if (!target) return;
+  const usageTag = buildContextUsageGuidance(config, currentTokens, modelContextLimit);
+  if (!usageTag) return;
+  for (const part of target.parts) {
+    if (part.type === "text") {
+      appendToTextPart(part, usageTag);
       return;
     }
-    for (const definition of PROMPT_DEFINITIONS) {
-      const bundledSource = BUNDLED_EDITABLE_PROMPTS[definition.runtimeField];
-      const bundledEditable = toEditablePromptText(definition, bundledSource);
-      const bundledRuntime = wrapRuntimePromptContent(definition, bundledEditable);
-      const fallbackValue = bundledRuntime || bundledSource.trim();
-      let effectiveValue = fallbackValue;
-      for (const candidate of this.getOverrideCandidates(definition.fileName)) {
-        const rawOverride = readFileIfExists(candidate.path);
-        if (rawOverride === null) {
-          continue;
-        }
-        const editableOverride = toEditablePromptText(definition, rawOverride);
-        if (!editableOverride) {
-          this.logger.warn("Prompt override is empty or invalid after normalization", {
-            key: definition.key,
-            path: candidate.path
-          });
-          continue;
-        }
-        const wrappedOverride = wrapRuntimePromptContent(definition, editableOverride);
-        if (!wrappedOverride) {
-          this.logger.warn("Prompt override could not be wrapped for runtime", {
-            key: definition.key,
-            path: candidate.path
-          });
-          continue;
+  }
+  target.parts.push(createSyntheticTextPart(target, usageTag));
+}
+function injectVisibleIdRange(state, messages, target) {
+  if (!target) return;
+  const visibleRefs = [];
+  for (const message of messages) {
+    const ref = state.messageIds.byRawId.get(message.info.id);
+    if (ref) {
+      visibleRefs.push(ref);
+    }
+  }
+  if (visibleRefs.length === 0) return;
+  visibleRefs.sort();
+  const first = visibleRefs[0];
+  const last = visibleRefs[visibleRefs.length - 1];
+  const rangeTag = `
+
+[Visible message IDs: ${first} to ${last} (${visibleRefs.length} messages). Only use IDs in this range for compress.]`;
+  for (const part of target.parts) {
+    if (part.type === "text") {
+      appendToTextPart(part, rangeTag);
+      return;
+    }
+  }
+  target.parts.push(createSyntheticTextPart(target, rangeTag));
+}
+var injectMessageIds = (state, config, messages, compressionPriorities) => {
+  if (compressPermission(state, config) === "deny") {
+    return;
+  }
+  for (const message of messages) {
+    if (isIgnoredUserMessage(message)) {
+      continue;
+    }
+    const messageRef = state.messageIds.byRawId.get(message.info.id);
+    if (!messageRef) {
+      continue;
+    }
+    const isBlockedMessage = isProtectedUserMessage(config, message);
+    const priority = config.compress.mode === "message" && !isBlockedMessage ? compressionPriorities?.get(message.info.id)?.priority : void 0;
+    const tag = formatMessageIdTag(
+      isBlockedMessage ? "BLOCKED" : messageRef,
+      priority ? { priority } : void 0
+    );
+    if (message.info.role === "user") {
+      let injected = false;
+      for (const part of message.parts) {
+        if (part.type === "text") {
+          injected = appendToTextPart(part, tag) || injected;
         }
-        effectiveValue = wrappedOverride;
-        break;
       }
-      nextPrompts[definition.runtimeField] = effectiveValue;
+      if (injected) {
+        continue;
+      }
+      message.parts.push(createSyntheticTextPart(message, tag));
+      continue;
     }
-    this.runtimePrompts = nextPrompts;
-  }
-  getOverrideCandidates(fileName) {
-    const candidates = [];
-    if (this.paths.projectOverridesDir) {
-      candidates.push({
-        path: join4(this.paths.projectOverridesDir, fileName)
-      });
+    if (message.info.role !== "assistant") {
+      continue;
     }
-    if (this.paths.configDirOverridesDir) {
-      candidates.push({
-        path: join4(this.paths.configDirOverridesDir, fileName)
-      });
+    if (!hasContent(message)) {
+      continue;
     }
-    candidates.push({
-      path: join4(this.paths.globalOverridesDir, fileName)
-    });
-    return candidates;
-  }
-  ensureDefaultFiles() {
-    try {
-      mkdirSync2(this.paths.defaultsDir, { recursive: true });
-      mkdirSync2(this.paths.globalOverridesDir, { recursive: true });
-    } catch {
-      this.logger.warn("Failed to initialize prompt directories", {
-        defaultsDir: this.paths.defaultsDir,
-        globalOverridesDir: this.paths.globalOverridesDir
-      });
-      return;
+    if (appendToAllToolParts(message, tag)) {
+      continue;
     }
-    for (const definition of PROMPT_DEFINITIONS) {
-      const bundledEditable = toEditablePromptText(
-        definition,
-        BUNDLED_EDITABLE_PROMPTS[definition.runtimeField]
-      );
-      const managedContent = buildDefaultPromptFileContent(
-        bundledEditable || BUNDLED_EDITABLE_PROMPTS[definition.runtimeField]
-      );
-      const filePath = join4(this.paths.defaultsDir, definition.fileName);
-      try {
-        const existing = readFileIfExists(filePath);
-        if (existing === managedContent) {
-          continue;
+    if (appendToLastTextPart(message, tag)) {
+      continue;
+    }
+    const syntheticPart = createSyntheticTextPart(message, tag);
+    const firstToolIndex = message.parts.findIndex((p) => p.type === "tool");
+    if (firstToolIndex === -1) {
+      message.parts.push(syntheticPart);
+    } else {
+      message.parts.splice(firstToolIndex, 0, syntheticPart);
+    }
+  }
+};
+
+// lib/messages/inject/subagent-results.ts
+async function fetchSubAgentMessages(client, sessionId) {
+  const response = await client.session.messages({
+    path: { id: sessionId }
+  });
+  return filterMessages(response?.data || response);
+}
+var injectExtendedSubAgentResults = async (client, state, logger, messages, allowSubAgents) => {
+  if (!allowSubAgents) {
+    return;
+  }
+  for (const message of messages) {
+    const parts = Array.isArray(message.parts) ? message.parts : [];
+    for (const part of parts) {
+      if (part.type !== "tool" || part.tool !== "task" || !part.callID) {
+        continue;
+      }
+      if (state.prune.tools.has(part.callID)) {
+        continue;
+      }
+      if (part.state?.status !== "completed" || typeof part.state.output !== "string") {
+        continue;
+      }
+      const cachedResult = state.subAgentResultCache.get(part.callID);
+      if (cachedResult !== void 0) {
+        if (cachedResult) {
+          part.state.output = stripHallucinationsFromString(
+            mergeSubagentResult(part.state.output, cachedResult)
+          );
         }
-        writeFileSync2(filePath, managedContent, "utf-8");
-      } catch {
-        this.logger.warn("Failed to write default prompt file", {
-          key: definition.key,
-          path: filePath
+        continue;
+      }
+      const subAgentSessionId = getSubAgentId(part);
+      if (!subAgentSessionId) {
+        continue;
+      }
+      let subAgentMessages = [];
+      try {
+        subAgentMessages = await fetchSubAgentMessages(client, subAgentSessionId);
+      } catch (error) {
+        logger.warn("Failed to fetch subagent session for output expansion", {
+          subAgentSessionId,
+          callID: part.callID,
+          error: error instanceof Error ? error.message : String(error)
         });
+        continue;
       }
-    }
-    const readmePath = join4(this.paths.defaultsDir, DEFAULTS_README_FILE);
-    const readmeContent = buildDefaultsReadmeContent();
-    try {
-      const existing = readFileIfExists(readmePath);
-      if (existing !== readmeContent) {
-        writeFileSync2(readmePath, readmeContent, "utf-8");
+      const subAgentResultText = buildSubagentResultText(subAgentMessages);
+      if (!subAgentResultText) {
+        continue;
       }
-    } catch {
-      this.logger.warn("Failed to write defaults README", {
-        path: readmePath
-      });
+      state.subAgentResultCache.set(part.callID, subAgentResultText);
+      part.state.output = stripHallucinationsFromString(
+        mergeSubagentResult(part.state.output, subAgentResultText)
+      );
     }
   }
 };
 
-// lib/messages/utils.ts
-import { createHash } from "crypto";
-var SUMMARY_ID_HASH_LENGTH = 16;
-var DCP_BLOCK_ID_TAG_REGEX = /(<dcp-message-id(?=[\s>])[^>]*>)b\d+(<\/dcp-message-id>)/g;
-var DCP_MESSAGE_REF_TAG_REGEX = /<dcp-message-id>m\d+<\/dcp-message-id>/g;
-var DCP_PAIRED_TAG_REGEX = /<dcp[^>]*>[\s\S]*?<\/dcp[^>]*>/gi;
-var DCP_UNPAIRED_TAG_REGEX = /<\/?dcp[^>]*>/gi;
-var generateStableId = (prefix, seed) => {
-  const hash = createHash("sha256").update(seed).digest("hex").slice(0, SUMMARY_ID_HASH_LENGTH);
-  return `${prefix}_${hash}`;
-};
-var createSyntheticUserMessage = (baseMessage, content, stableSeed) => {
-  const userInfo = baseMessage.info;
-  const now = Date.now();
-  const deterministicSeed = stableSeed?.trim() || userInfo.id;
-  const messageId = generateStableId("msg_dcp_summary", deterministicSeed);
-  const partId = generateStableId("prt_dcp_summary", deterministicSeed);
-  return {
-    info: {
-      id: messageId,
-      sessionID: userInfo.sessionID,
-      role: "user",
-      agent: userInfo.agent,
-      model: userInfo.model,
-      time: { created: now }
-    },
-    parts: [
-      {
-        id: partId,
-        sessionID: userInfo.sessionID,
-        messageID: messageId,
-        type: "text",
-        text: content
+// lib/messages/reasoning-strip.ts
+function stripStaleMetadata(messages) {
+  const lastUserMessage = getLastUserMessage(messages);
+  if (lastUserMessage?.info.role !== "user") {
+    return;
+  }
+  const modelID = lastUserMessage.info.model.modelID;
+  const providerID = lastUserMessage.info.model.providerID;
+  messages.forEach((message) => {
+    if (message.info.role !== "assistant") {
+      return;
+    }
+    const msgModelID = message.info.modelID;
+    const msgProviderID = message.info.providerID;
+    if (msgModelID === modelID && msgProviderID === providerID) {
+      return;
+    }
+    message.parts = message.parts.map((part) => {
+      if (part.type !== "text" && part.type !== "tool" && part.type !== "reasoning") {
+        return part;
       }
-    ]
-  };
-};
-var createSyntheticTextPart = (baseMessage, content, stableSeed) => {
-  const userInfo = baseMessage.info;
-  const deterministicSeed = stableSeed?.trim() || userInfo.id;
-  const partId = generateStableId("prt_dcp_text", deterministicSeed);
-  return {
-    id: partId,
-    sessionID: userInfo.sessionID,
-    messageID: userInfo.id,
-    type: "text",
-    text: content
-  };
-};
-var appendToLastTextPart = (message, injection) => {
-  const textPart = findLastTextPart(message);
-  if (!textPart) {
-    return false;
+      if (!("metadata" in part)) {
+        return part;
+      }
+      const { metadata: _metadata, ...rest } = part;
+      return rest;
+    });
+  });
+}
+
+// lib/commands/compression-targets.ts
+function byBlockId(a, b) {
+  return a.blockId - b.blockId;
+}
+function buildTarget(blocks) {
+  const ordered = [...blocks].sort(byBlockId);
+  const first = ordered[0];
+  if (!first) {
+    throw new Error("Cannot build compression target from empty block list.");
   }
-  return appendToTextPart(textPart, injection);
-};
-var findLastTextPart = (message) => {
-  for (let i = message.parts.length - 1; i >= 0; i--) {
-    const part = message.parts[i];
-    if (part.type === "text") {
-      return part;
+  const grouped = first.mode === "message";
+  return {
+    displayId: first.blockId,
+    runId: first.runId,
+    topic: grouped ? first.batchTopic || first.topic : first.topic,
+    compressedTokens: ordered.reduce((total, block) => total + block.compressedTokens, 0),
+    durationMs: ordered.reduce((total, block) => Math.max(total, block.durationMs), 0),
+    grouped,
+    blocks: ordered
+  };
+}
+function groupMessageBlocks(blocks) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const block of blocks) {
+    const existing = grouped.get(block.runId);
+    if (existing) {
+      existing.push(block);
+      continue;
     }
+    grouped.set(block.runId, [block]);
   }
-  return null;
-};
-var appendToTextPart = (part, injection) => {
-  if (typeof part.text !== "string") {
-    return false;
-  }
-  const normalizedInjection = injection.replace(/^\n+/, "");
-  if (!normalizedInjection.trim()) {
-    return false;
+  return Array.from(grouped.values()).map(buildTarget);
+}
+function splitTargets(blocks) {
+  const messageBlocks = [];
+  const singleBlocks = [];
+  for (const block of blocks) {
+    if (block.mode === "message") {
+      messageBlocks.push(block);
+    } else {
+      singleBlocks.push(block);
+    }
   }
-  if (part.text.includes(normalizedInjection)) {
-    return true;
+  const targets = [
+    ...singleBlocks.map((block) => buildTarget([block])),
+    ...groupMessageBlocks(messageBlocks)
+  ];
+  return targets.sort((a, b) => a.displayId - b.displayId);
+}
+function getActiveCompressionTargets(messagesState) {
+  const activeBlocks = Array.from(messagesState.activeBlockIds).map((blockId) => messagesState.blocksById.get(blockId)).filter((block) => !!block && block.active);
+  return splitTargets(activeBlocks);
+}
+function getRecompressibleCompressionTargets(messagesState, availableMessageIds) {
+  const allBlocks = Array.from(messagesState.blocksById.values()).filter((block) => {
+    return availableMessageIds.has(block.compressMessageId);
+  });
+  const messageGroups = /* @__PURE__ */ new Map();
+  const singleTargets = [];
+  for (const block of allBlocks) {
+    if (block.mode === "message") {
+      const existing = messageGroups.get(block.runId);
+      if (existing) {
+        existing.push(block);
+      } else {
+        messageGroups.set(block.runId, [block]);
+      }
+      continue;
+    }
+    if (block.deactivatedByUser && !block.active) {
+      singleTargets.push(buildTarget([block]));
+    }
   }
-  const baseText = part.text.replace(/\n*$/, "");
-  part.text = baseText.length > 0 ? `${baseText}
-
-${normalizedInjection}` : normalizedInjection;
-  return true;
-};
-var appendToAllToolParts = (message, tag) => {
-  let injected = false;
-  for (const part of message.parts) {
-    if (part.type === "tool") {
-      injected = appendToToolPart(part, tag) || injected;
+  for (const blocks of messageGroups.values()) {
+    if (blocks.some((block) => block.deactivatedByUser && !block.active)) {
+      singleTargets.push(buildTarget(blocks));
     }
   }
-  return injected;
-};
-var appendToToolPart = (part, tag) => {
-  if (part.state?.status !== "completed" || typeof part.state.output !== "string") {
-    return false;
+  return singleTargets.sort((a, b) => a.displayId - b.displayId);
+}
+function resolveCompressionTarget(messagesState, blockId) {
+  const block = messagesState.blocksById.get(blockId);
+  if (!block) {
+    return null;
   }
-  if (part.state.output.includes(tag)) {
-    return true;
+  if (block.mode !== "message") {
+    return buildTarget([block]);
   }
-  part.state.output = `${part.state.output}${tag}`;
-  return true;
-};
-var hasContent = (message) => {
-  return message.parts.some(
-    (part) => part.type === "text" && typeof part.text === "string" && part.text.trim().length > 0 || part.type === "tool" && part.state?.status === "completed" && typeof part.state.output === "string"
+  const blocks = Array.from(messagesState.blocksById.values()).filter(
+    (candidate) => candidate.mode === "message" && candidate.runId === block.runId
   );
-};
-function buildToolIdList(state, messages) {
-  const toolIds = [];
-  for (const msg of messages) {
-    if (isMessageCompacted(state, msg)) {
+  if (blocks.length === 0) {
+    return null;
+  }
+  return buildTarget(blocks);
+}
+
+// lib/compress/decompress-logic.ts
+function parseBlockIdArg(arg) {
+  const normalized = arg.trim().toLowerCase();
+  const blockRef = parseBlockRef(normalized);
+  if (blockRef !== null) {
+    return blockRef;
+  }
+  if (!/^[1-9]\d*$/.test(normalized)) {
+    return null;
+  }
+  const parsed = Number.parseInt(normalized, 10);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
+}
+function findActiveParentBlockId(messagesState, block) {
+  const queue = [...block.parentBlockIds];
+  const visited = /* @__PURE__ */ new Set();
+  while (queue.length > 0) {
+    const parentBlockId = queue.shift();
+    if (parentBlockId === void 0 || visited.has(parentBlockId)) {
       continue;
     }
-    const parts = Array.isArray(msg.parts) ? msg.parts : [];
-    if (parts.length > 0) {
-      for (const part of parts) {
-        if (part.type === "tool" && part.callID && part.tool) {
-          toolIds.push(part.callID);
-        }
+    visited.add(parentBlockId);
+    const parent = messagesState.blocksById.get(parentBlockId);
+    if (!parent) {
+      continue;
+    }
+    if (parent.active) {
+      return parent.blockId;
+    }
+    for (const ancestorId of parent.parentBlockIds) {
+      if (!visited.has(ancestorId)) {
+        queue.push(ancestorId);
       }
     }
   }
-  state.toolIdList = toolIds;
-  return toolIds;
+  return null;
 }
-var replaceBlockIdsWithBlocked = (text) => {
-  return text.replace(DCP_BLOCK_ID_TAG_REGEX, "$1BLOCKED$2");
-};
-var stripStaleMessageRefs = (text) => {
-  return text.replace(DCP_MESSAGE_REF_TAG_REGEX, "");
-};
-var stripHallucinationsFromString = (text) => {
-  return text.replace(DCP_PAIRED_TAG_REGEX, "").replace(DCP_UNPAIRED_TAG_REGEX, "");
-};
-var stripHallucinations = (messages) => {
-  for (const message of messages) {
-    for (const part of message.parts) {
-      if (part.type === "text" && typeof part.text === "string") {
-        part.text = stripHallucinationsFromString(part.text);
-      }
-      if (part.type === "tool" && part.state?.status === "completed" && typeof part.state.output === "string") {
-        part.state.output = stripHallucinationsFromString(part.state.output);
-      }
+function findActiveAncestorBlockId(messagesState, target) {
+  for (const block of target.blocks) {
+    const activeAncestorBlockId = findActiveParentBlockId(messagesState, block);
+    if (activeAncestorBlockId !== null) {
+      return activeAncestorBlockId;
     }
   }
-};
-
-// lib/messages/prune.ts
-var PRUNED_TOOL_OUTPUT_REPLACEMENT = "[Output removed to save context - information superseded or no longer needed]";
-var PRUNED_TOOL_ERROR_INPUT_REPLACEMENT = "[input removed due to failed tool call]";
-var PRUNED_QUESTION_INPUT_REPLACEMENT = "[questions removed - see output for user's answers]";
-var prune = (state, logger, config, messages) => {
-  filterCompressedRanges(state, logger, config, messages);
-  pruneToolOutputs(state, logger, messages);
-  pruneToolInputs(state, logger, messages);
-  pruneToolErrors(state, logger, messages);
-};
-var pruneToolOutputs = (state, logger, messages) => {
-  for (const msg of messages) {
-    if (isMessageCompacted(state, msg)) {
-      continue;
-    }
-    const parts = Array.isArray(msg.parts) ? msg.parts : [];
-    for (const part of parts) {
-      if (part.type !== "tool") {
-        continue;
-      }
-      if (!state.prune.tools.has(part.callID)) {
-        continue;
-      }
-      if (part.state.status !== "completed") {
-        continue;
-      }
-      if (part.tool === "question" || part.tool === "edit" || part.tool === "write") {
-        continue;
-      }
-      part.state.output = PRUNED_TOOL_OUTPUT_REPLACEMENT;
+  return null;
+}
+function snapshotActiveMessages(messagesState) {
+  const activeMessages = /* @__PURE__ */ new Map();
+  for (const [messageId, entry] of messagesState.byMessageId) {
+    if (entry.activeBlockIds.length > 0) {
+      activeMessages.set(messageId, entry.tokenCount);
     }
   }
-};
-var pruneToolInputs = (state, logger, messages) => {
-  for (const msg of messages) {
-    if (isMessageCompacted(state, msg)) {
-      continue;
-    }
-    const parts = Array.isArray(msg.parts) ? msg.parts : [];
-    for (const part of parts) {
-      if (part.type !== "tool") {
-        continue;
-      }
-      if (!state.prune.tools.has(part.callID)) {
-        continue;
-      }
-      if (part.state.status !== "completed") {
-        continue;
-      }
-      if (part.tool !== "question") {
-        continue;
-      }
-      if (part.state.input?.questions !== void 0) {
-        part.state.input.questions = PRUNED_QUESTION_INPUT_REPLACEMENT;
+  return activeMessages;
+}
+function deactivateCompressionTarget(messagesState, target) {
+  const deactivatedAt = Date.now();
+  for (const block of target.blocks) {
+    block.active = false;
+    block.deactivatedByUser = true;
+    block.deactivatedAt = deactivatedAt;
+    block.deactivatedByBlockId = void 0;
+    for (const consumedId of block.consumedBlockIds) {
+      const consumedBlock = messagesState.blocksById.get(consumedId);
+      if (consumedBlock) {
+        consumedBlock.deactivatedByUser = true;
       }
     }
   }
-};
-var pruneToolErrors = (state, logger, messages) => {
-  for (const msg of messages) {
-    if (isMessageCompacted(state, msg)) {
-      continue;
+}
+function computeRestoredMessages(messagesState, activeMessagesBefore) {
+  let restoredMessageCount = 0;
+  let restoredTokens = 0;
+  for (const [messageId, tokenCount] of activeMessagesBefore) {
+    const entry = messagesState.byMessageId.get(messageId);
+    const isActiveNow = entry ? entry.activeBlockIds.length > 0 : false;
+    if (!isActiveNow) {
+      restoredMessageCount++;
+      restoredTokens += tokenCount;
     }
-    const parts = Array.isArray(msg.parts) ? msg.parts : [];
-    for (const part of parts) {
-      if (part.type !== "tool") {
-        continue;
-      }
-      if (!state.prune.tools.has(part.callID)) {
-        continue;
-      }
-      if (part.state.status !== "error") {
-        continue;
-      }
-      const input = part.state.input;
-      if (input && typeof input === "object") {
-        for (const key of Object.keys(input)) {
-          if (typeof input[key] === "string") {
-            input[key] = PRUNED_TOOL_ERROR_INPUT_REPLACEMENT;
-          }
-        }
+  }
+  return { restoredMessageCount, restoredTokens };
+}
+function computeReactivatedBlockIds(messagesState, activeBlockIdsBefore) {
+  return Array.from(messagesState.activeBlockIds).filter((blockId) => !activeBlockIdsBefore.has(blockId)).sort((a, b) => a - b);
+}
+var MAX_PREVIEW_LENGTH = 2e3;
+var MAX_MESSAGE_PREVIEW_LENGTH = 200;
+function buildRestoredContentPreview(messages, activeMessagesBefore, messagesState) {
+  const restoredMessages = [];
+  for (const msg of messages) {
+    const msgId = msg.info.id;
+    if (activeMessagesBefore.has(msgId)) {
+      const entry = messagesState.byMessageId.get(msgId);
+      const isActiveNow = entry ? entry.activeBlockIds.length > 0 : false;
+      if (!isActiveNow) {
+        restoredMessages.push(msg);
       }
     }
   }
-};
-var filterCompressedRanges = (state, logger, config, messages) => {
-  if (state.prune.messages.byMessageId.size === 0 && state.prune.messages.activeByAnchorMessageId.size === 0) {
-    return;
+  if (restoredMessages.length === 0) {
+    return "";
   }
-  const result = [];
-  for (const msg of messages) {
-    const msgId = msg.info.id;
-    const blockId = state.prune.messages.activeByAnchorMessageId.get(msgId);
-    const summary = blockId !== void 0 ? state.prune.messages.blocksById.get(blockId) : void 0;
-    if (summary) {
-      const rawSummaryContent = summary.summary;
-      if (summary.active !== true || typeof rawSummaryContent !== "string" || rawSummaryContent.length === 0) {
-        logger.warn("Skipping malformed compress summary", {
-          anchorMessageId: msgId,
-          blockId: summary.blockId
-        });
-      } else {
-        const msgIndex = messages.indexOf(msg);
-        const userMessage = getLastUserMessage(messages, msgIndex);
-        const _cleaned = stripStaleMessageRefs(rawSummaryContent);
-        if (userMessage) {
-          const userInfo = userMessage.info;
-          const summaryContent = config.compress.mode === "message" ? replaceBlockIdsWithBlocked(_cleaned) : _cleaned;
-          const summarySeed = `${summary.blockId}:${summary.anchorMessageId}`;
-          result.push(
-            createSyntheticUserMessage(userMessage, summaryContent, summarySeed)
-          );
-          logger.info("Injected compress summary", {
-            anchorMessageId: msgId,
-            summaryLength: summaryContent.length
-          });
-        } else {
-          const anchorInfo = msg.info;
-          const fallbackBase = {
-            info: {
-              id: anchorInfo.id || msgId,
-              sessionID: anchorInfo.sessionID || "",
-              role: "user",
-              agent: anchorInfo.agent || "code",
-              model: anchorInfo.model || {
-                providerID: "",
-                modelID: "",
-                variant: void 0
-              },
-              time: { created: anchorInfo.time?.created || Date.now() }
-            },
-            parts: []
-          };
-          const summaryContent = config.compress.mode === "message" ? replaceBlockIdsWithBlocked(_cleaned) : _cleaned;
-          const summarySeed = `${summary.blockId}:${summary.anchorMessageId}`;
-          result.push(
-            createSyntheticUserMessage(fallbackBase, summaryContent, summarySeed)
-          );
-          logger.info("Injected compress summary (fallback, no preceding user message)", {
-            anchorMessageId: msgId,
-            summaryLength: summaryContent.length
-          });
+  const lines = [];
+  let totalLength = 0;
+  for (const msg of restoredMessages) {
+    if (totalLength >= MAX_PREVIEW_LENGTH) break;
+    const role = msg.info.role ?? "unknown";
+    const textContent = extractTextContent(msg);
+    const truncated = textContent.length > MAX_MESSAGE_PREVIEW_LENGTH ? textContent.slice(0, MAX_MESSAGE_PREVIEW_LENGTH) + "..." : textContent;
+    const line = `[${role}] ${truncated}`;
+    lines.push(line);
+    totalLength += line.length + 1;
+  }
+  return lines.join("\n");
+}
+function extractTextContent(msg) {
+  if (!msg.parts || msg.parts.length === 0) {
+    return "";
+  }
+  const textParts = [];
+  for (const part of msg.parts) {
+    if (typeof part === "object" && part !== null) {
+      if ("text" in part && typeof part.text === "string") {
+        textParts.push(part.text);
+      } else if ("type" in part && part.type === "tool") {
+        const toolName = "tool" in part && typeof part.tool === "string" ? part.tool : "tool";
+        const state = part.state;
+        if (state && typeof state.output === "string") {
+          const output = state.output.length > 80 ? state.output.slice(0, 80) + "..." : state.output;
+          textParts.push(`[${toolName}] ${output}`);
         }
       }
     }
-    const pruneEntry = state.prune.messages.byMessageId.get(msgId);
-    if (pruneEntry && pruneEntry.activeBlockIds.length > 0) {
-      continue;
-    }
-    result.push(msg);
   }
-  messages.length = 0;
-  messages.push(...result);
-};
+  return textParts.join(" ").replace(/\s+/g, " ").trim();
+}
 
-// lib/messages/sync.ts
-function sortBlocksByCreation(a, b) {
-  const createdAtDiff = a.createdAt - b.createdAt;
-  if (createdAtDiff !== 0) {
-    return createdAtDiff;
-  }
-  return a.blockId - b.blockId;
+// lib/compress/decompress.ts
+async function prepareDecompressSession(ctx, toolCtx) {
+  await toolCtx.ask({
+    permission: "compress",
+    patterns: ["*"],
+    always: ["*"],
+    metadata: {}
+  });
+  toolCtx.metadata({ title: "Decompress" });
+  const rawMessages = await fetchSessionMessages(ctx.client, toolCtx.sessionID);
+  await ensureSessionInitialized(
+    ctx.client,
+    ctx.state,
+    toolCtx.sessionID,
+    ctx.logger,
+    rawMessages,
+    ctx.config.manualMode.enabled
+  );
+  assignMessageRefs(ctx.state, rawMessages);
+  return { rawMessages };
 }
-var syncCompressionBlocks = (state, logger, messages) => {
-  const messagesState = state.prune.messages;
-  if (!messagesState?.blocksById?.size) {
-    return;
+async function finalizeDecompressSession(ctx) {
+  await saveSessionState(ctx.state, ctx.logger);
+}
+var TOOL_DESCRIPTION = `Restores previously compressed content identified by a block ID.
+
+Use this tool when you need exact details from a compressed block that the summary cannot provide.
+The tool returns a condensed preview of the restored content so you can reason about it immediately.
+
+Argument: blockId \u2014 the block reference to decompress (e.g., "b0", "b2")
+
+IMPORTANT:
+- Decompressing inflates context. Check context usage before decompressing.
+- Message-mode blocks from the same batch (same runId) are restored together.
+- After decompression, the restored messages will appear in full in your next context window.
+- Do NOT call this tool in parallel with compress \u2014 their state mutations may conflict.`;
+function buildSchema3() {
+  return {
+    blockId: tool3.schema.string().describe('Block reference to decompress (e.g., "b0", "b2")')
+  };
+}
+function createDecompressTool(ctx) {
+  return tool3({
+    description: TOOL_DESCRIPTION,
+    args: buildSchema3(),
+    async execute(args, toolCtx) {
+      const { rawMessages } = await prepareDecompressSession(ctx, toolCtx);
+      const contextUsageBefore = ctx.state.modelContextLimit ? Math.round(
+        getCurrentTokenUsage(ctx.state, rawMessages) / ctx.state.modelContextLimit * 100
+      ) : void 0;
+      const targetBlockId = parseBlockIdArg(args.blockId);
+      if (targetBlockId === null) {
+        return `Error: Invalid block ID "${args.blockId}". Use format "b0", "b1", etc.`;
+      }
+      const messagesState = ctx.state.prune.messages;
+      const target = resolveCompressionTarget(messagesState, targetBlockId);
+      if (!target) {
+        return `Error: Block ${targetBlockId} does not exist. No compression found with that ID.`;
+      }
+      const activeBlocks = target.blocks.filter((block) => block.active);
+      if (activeBlocks.length === 0) {
+        const activeAncestorBlockId = findActiveAncestorBlockId(messagesState, target);
+        if (activeAncestorBlockId !== null) {
+          return `Error: Block ${target.displayId} is nested inside active block ${activeAncestorBlockId}. Decompress block ${activeAncestorBlockId} first.`;
+        }
+        return `Error: Block ${target.displayId} is not active. It may have already been decompressed.`;
+      }
+      const activeMessagesBefore = snapshotActiveMessages(messagesState);
+      const activeBlockIdsBefore = new Set(messagesState.activeBlockIds);
+      deactivateCompressionTarget(messagesState, target);
+      syncCompressionBlocks(ctx.state, ctx.logger, rawMessages);
+      const { restoredMessageCount, restoredTokens } = computeRestoredMessages(
+        messagesState,
+        activeMessagesBefore
+      );
+      const reactivatedBlockIds = computeReactivatedBlockIds(
+        messagesState,
+        activeBlockIdsBefore
+      );
+      ctx.state.stats.totalPruneTokens = Math.max(
+        0,
+        ctx.state.stats.totalPruneTokens - restoredTokens
+      );
+      const contextUsageAfter = ctx.state.modelContextLimit ? Math.round(
+        getCurrentTokenUsage(ctx.state, rawMessages) / ctx.state.modelContextLimit * 100
+      ) : void 0;
+      await finalizeDecompressSession(ctx);
+      const restoredContentPreview = buildRestoredContentPreview(
+        rawMessages,
+        activeMessagesBefore,
+        messagesState
+      );
+      const lines = [];
+      lines.push(
+        `Decompressed block b${target.displayId}. Restored ${restoredMessageCount} message(s) (~${formatTokenCount(restoredTokens)}).`
+      );
+      if (contextUsageBefore !== void 0 && contextUsageAfter !== void 0) {
+        lines.push(`Context usage: ${contextUsageBefore}% \u2192 ${contextUsageAfter}%.`);
+      }
+      if (reactivatedBlockIds.length > 0) {
+        const refs = reactivatedBlockIds.map((id) => `b${id}`).join(", ");
+        lines.push(`Also restored nested block(s): ${refs}.`);
+      }
+      if (restoredContentPreview) {
+        lines.push("");
+        lines.push("RESTORED CONTENT (condensed):");
+        lines.push(restoredContentPreview);
+      }
+      ctx.logger.info("Decompress tool completed", {
+        targetBlockId: target.displayId,
+        targetRunId: target.runId,
+        restoredMessageCount,
+        restoredTokens,
+        reactivatedBlockIds
+      });
+      return lines.join("\n");
+    }
+  });
+}
+
+// lib/logger.ts
+import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { join as join3 } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { homedir as homedir3 } from "os";
+var Logger = class {
+  logDir;
+  enabled;
+  constructor(enabled) {
+    this.enabled = enabled;
+    const configHome = process.env.XDG_CONFIG_HOME || join3(homedir3(), ".config");
+    this.logDir = join3(configHome, "opencode", "logs", "acp");
   }
-  const messageIds = new Set(messages.map((msg) => msg.info.id));
-  const previousActiveBlockIds = new Set(
-    Array.from(messagesState.blocksById.values()).filter((block) => block.active).map((block) => block.blockId)
-  );
-  messagesState.activeBlockIds.clear();
-  messagesState.activeByAnchorMessageId.clear();
-  const now = Date.now();
-  const missingOriginBlockIds = [];
-  const orderedBlocks = Array.from(messagesState.blocksById.values()).sort(sortBlocksByCreation);
-  for (const block of orderedBlocks) {
-    if (block.deactivatedByUser) {
-      block.active = false;
-      if (block.deactivatedAt === void 0) {
-        block.deactivatedAt = now;
-      }
-      block.deactivatedByBlockId = void 0;
-      continue;
+  async ensureLogDir() {
+    if (!existsSync3(this.logDir)) {
+      await mkdir2(this.logDir, { recursive: true });
     }
-    if (typeof block.anchorMessageId === "string" && block.anchorMessageId.length > 0 && !messageIds.has(block.anchorMessageId)) {
-      if (!messagesState.byMessageId.has(block.anchorMessageId)) {
-        block.active = false;
-        block.deactivatedAt = now;
-        block.deactivatedByBlockId = void 0;
-        continue;
+  }
+  formatData(data) {
+    if (!data) return "";
+    const parts = [];
+    for (const [key, value] of Object.entries(data)) {
+      if (value === void 0 || value === null) continue;
+      if (Array.isArray(value)) {
+        if (value.length === 0) continue;
+        parts.push(
+          `${key}=[${value.slice(0, 3).join(",")}${value.length > 3 ? `...+${value.length - 3}` : ""}]`
+        );
+      } else if (typeof value === "object") {
+        const str = JSON.stringify(value);
+        if (str.length < 50) {
+          parts.push(`${key}=${str}`);
+        }
+      } else {
+        parts.push(`${key}=${value}`);
       }
     }
-    for (const consumedBlockId of block.consumedBlockIds) {
-      if (!messagesState.activeBlockIds.has(consumedBlockId)) {
-        continue;
-      }
-      const consumedBlock = messagesState.blocksById.get(consumedBlockId);
-      if (consumedBlock) {
-        consumedBlock.active = false;
-        consumedBlock.deactivatedAt = now;
-        consumedBlock.deactivatedByBlockId = block.blockId;
-        const mappedBlockId = messagesState.activeByAnchorMessageId.get(
-          consumedBlock.anchorMessageId
-        );
-        if (mappedBlockId === consumedBlock.blockId) {
-          messagesState.activeByAnchorMessageId.delete(consumedBlock.anchorMessageId);
+    return parts.join(" ");
+  }
+  getCallerFile(skipFrames = 3) {
+    const originalPrepareStackTrace = Error.prepareStackTrace;
+    try {
+      const err = new Error();
+      Error.prepareStackTrace = (_, stack2) => stack2;
+      const stack = err.stack;
+      Error.prepareStackTrace = originalPrepareStackTrace;
+      for (let i = skipFrames; i < stack.length; i++) {
+        const filename = stack[i]?.getFileName();
+        if (filename && !filename.includes("/logger.")) {
+          const match = filename.match(/([^/\\]+)\.[tj]s$/);
+          return match ? match[1] : filename;
         }
       }
-      messagesState.activeBlockIds.delete(consumedBlockId);
-    }
-    block.active = true;
-    block.deactivatedAt = void 0;
-    block.deactivatedByBlockId = void 0;
-    messagesState.activeBlockIds.add(block.blockId);
-    if (messageIds.has(block.anchorMessageId)) {
-      messagesState.activeByAnchorMessageId.set(block.anchorMessageId, block.blockId);
+      return "unknown";
+    } catch {
+      return "unknown";
+    }
+  }
+  async write(level, component, message, data) {
+    if (!this.enabled) return;
+    try {
+      await this.ensureLogDir();
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const dataStr = this.formatData(data);
+      const logLine = `${timestamp} ${level.padEnd(5)} ${component}: ${message}${dataStr ? " | " + dataStr : ""}
+`;
+      const dailyLogDir = join3(this.logDir, "daily");
+      if (!existsSync3(dailyLogDir)) {
+        await mkdir2(dailyLogDir, { recursive: true });
+      }
+      const logFile = join3(dailyLogDir, `${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.log`);
+      await writeFile2(logFile, logLine, { flag: "a" });
+    } catch (error) {
     }
   }
-  for (const entry of messagesState.byMessageId.values()) {
-    const allBlockIds = Array.isArray(entry.allBlockIds) ? [...new Set(entry.allBlockIds.filter((id) => Number.isInteger(id) && id > 0))] : [];
-    entry.allBlockIds = allBlockIds;
-    entry.activeBlockIds = allBlockIds.filter((id) => messagesState.activeBlockIds.has(id));
+  info(message, data) {
+    if (!this.enabled) return;
+    const component = this.getCallerFile(2);
+    return this.write("INFO", component, message, data);
   }
-  const nextActiveBlockIds = messagesState.activeBlockIds;
-  let deactivatedCount = 0;
-  let reactivatedCount = 0;
-  for (const blockId of previousActiveBlockIds) {
-    if (!nextActiveBlockIds.has(blockId)) {
-      deactivatedCount++;
-    }
+  debug(message, data) {
+    if (!this.enabled) return;
+    const component = this.getCallerFile(2);
+    return this.write("DEBUG", component, message, data);
   }
-  for (const blockId of nextActiveBlockIds) {
-    if (!previousActiveBlockIds.has(blockId)) {
-      reactivatedCount++;
-    }
+  warn(message, data) {
+    if (!this.enabled) return;
+    const component = this.getCallerFile(2);
+    return this.write("WARN", component, message, data);
   }
-  if (missingOriginBlockIds.length > 0 || deactivatedCount > 0 || reactivatedCount > 0) {
-    logger.info("Synced compress block state", {
-      missingOriginCount: missingOriginBlockIds.length,
-      deactivatedCount,
-      reactivatedCount
+  error(message, data) {
+    if (!this.enabled) return;
+    const component = this.getCallerFile(2);
+    return this.write("ERROR", component, message, data);
+  }
+  /**
+   * Strips unnecessary metadata from messages for cleaner debug logs.
+   *
+   * Removed:
+   * - All IDs (id, sessionID, messageID, parentID)
+   * - summary, path, cost, model, agent, mode, finish, providerID, modelID
+   * - step-start and step-finish parts entirely
+   * - snapshot fields
+   * - ignored text parts
+   *
+   * Kept:
+   * - role, time (created only), tokens (input, output, reasoning, cache)
+   * - text, reasoning, tool parts with content
+   * - tool calls with: tool, callID, input, output, metadata
+   */
+  minimizeForDebug(messages) {
+    return messages.map((msg) => {
+      const minimized = {
+        role: msg.info?.role
+      };
+      if (msg.info?.time?.created) {
+        minimized.time = msg.info.time.created;
+      }
+      if (msg.info?.tokens) {
+        minimized.tokens = {
+          input: msg.info.tokens.input,
+          output: msg.info.tokens.output,
+          reasoning: msg.info.tokens.reasoning,
+          cache: msg.info.tokens.cache
+        };
+      }
+      if (msg.parts) {
+        minimized.parts = msg.parts.map((part) => {
+          if (part.type === "step-start" || part.type === "step-finish") {
+            return null;
+          }
+          if (part.type === "text") {
+            if (part.ignored) return null;
+            const textPart = { type: "text", text: part.text };
+            if (part.metadata) textPart.metadata = part.metadata;
+            return textPart;
+          }
+          if (part.type === "reasoning") {
+            const reasoningPart = { type: "reasoning", text: part.text };
+            if (part.metadata) reasoningPart.metadata = part.metadata;
+            return reasoningPart;
+          }
+          if (part.type === "tool") {
+            const toolPart = {
+              type: "tool",
+              tool: part.tool,
+              callID: part.callID
+            };
+            if (part.state?.status) {
+              toolPart.status = part.state.status;
+            }
+            if (part.state?.input) {
+              toolPart.input = part.state.input;
+            }
+            if (part.state?.output) {
+              toolPart.output = part.state.output;
+            }
+            if (part.state?.error) {
+              toolPart.error = part.state.error;
+            }
+            if (part.metadata) {
+              toolPart.metadata = part.metadata;
+            }
+            if (part.state?.metadata) {
+              toolPart.metadata = {
+                ...toolPart.metadata || {},
+                ...part.state.metadata
+              };
+            }
+            if (part.state?.title) {
+              toolPart.title = part.state.title;
+            }
+            return toolPart;
+          }
+          return null;
+        }).filter(Boolean);
+      }
+      return minimized;
     });
   }
+  async saveContext(sessionId, messages) {
+    if (!this.enabled) return;
+    try {
+      const contextDir = join3(this.logDir, "context", sessionId);
+      if (!existsSync3(contextDir)) {
+        await mkdir2(contextDir, { recursive: true });
+      }
+      const minimized = this.minimizeForDebug(messages).filter(
+        (msg) => msg.parts && msg.parts.length > 0
+      );
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+      const contextFile = join3(contextDir, `${timestamp}.json`);
+      await writeFile2(contextFile, JSON.stringify(minimized, null, 2));
+    } catch (error) {
+    }
+  }
 };
 
-// lib/compress-permission.ts
-var compressPermission = (state, config) => {
-  return state.compressPermission ?? config.compress.permission;
-};
-var syncCompressPermissionState = (state, config, hostPermissions, messages) => {
-  const activeAgent = getLastUserMessage(messages)?.info.agent;
-  state.compressPermission = resolveEffectiveCompressPermission(
-    config.compress.permission,
-    hostPermissions,
-    activeAgent
-  );
-};
+// lib/prompts/store.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, statSync as statSync2, cpSync as cpSync2 } from "fs";
+import { join as join4, dirname as dirname2 } from "path";
+import { homedir as homedir4 } from "os";
+
+// lib/prompts/system.ts
+var SYSTEM = `
+
+You operate in a context-constrained environment. Context management helps preserve retrieval quality, but your primary goal is completing the task at hand. Do not let context management distract from the actual work.
+
+The tools you have for context management are \`compress\` and \`decompress\`. \`compress\` replaces older conversation content with technical summaries you produce. \`decompress\` restores previously compressed content when you need exact details.
+
+\`<dcp-message-id>\` and \`<dcp-system-reminder>\` tags are environment-injected metadata. Do not output them.
+
+COMPRESSION PHILOSOPHY
+
+Compression replaces raw conversation content with dense summaries. When used correctly, it keeps your context sharp and focused. When used carelessly, it destroys information you need.
+
+The key principle: compress based on context pressure, not habit. When context is ample, compress rarely or not at all. When context is tight, compress aggressively but selectively. The runtime context usage indicator tells you the current pressure level.
+
+CONTEXT PRESSURE LEVELS
+
+- Ample: Context is well below the threshold. Do NOT compress unless there is obvious waste (huge terminal dumps, duplicated content). Focus entirely on your task.
+- Moderate: Context is approaching the threshold. Compress completed sections proactively. Prioritize high-token waste over minor cleanup.
+- High: Context has exceeded the threshold. Compress aggressively. Every compression should free meaningful tokens. Preserve only what is essential for the current task.
+
+WHAT TO COMPRESS FIRST (high value, low risk)
+
+- Verbose terminal/bash command output (build logs, test output, directory listings)
+- Exploration that led nowhere (failed approaches, dead-end searches)
+- Redundant tool results (reading the same file multiple times, repeated status checks)
+- Intermediate steps of completed multi-step tasks
+- Large file contents that have already been used and are no longer needed
+
+WHAT TO COMPRESS CAREFULLY (high risk - verify before compressing)
+
+- Temporary secrets/keys/tokens needed later: Do NOT compress unless recorded elsewhere
+- File paths and directory structures: Keep in summary - losing these wastes tokens rediscovering them
+- Key function/method signatures and APIs: Summarize with exact names and signatures
+- Critical error messages and stack traces: Keep the error type and key detail in summary
+- User preferences and requirements: These must survive compression intact
+- Architectural decisions and rationale: Summarize the decision, not just the conclusion
+
+BEFORE COMPRESSING IMPORTANT CONTENT
+
+Verify the information is persisted in one of:
+- A file you have written or edited
+- An issue, PR, or devlog entry
+- The compression summary itself (include the critical bits explicitly)
+
+If it is not persisted anywhere, either persist it first or include it explicitly in your compression summary.
+
+AFTER COMPRESSING
+
+Generate recovery breadcrumbs in your summary so future-you can reconstruct the context:
+- Reference specific files by path
+- Include key variable names, function signatures, or configuration values
+- Note what was decided and why, not just what was done
+- Example: "Implemented auth check in src/middleware.ts using validateToken() from auth.ts - user table is users not user"
+
+If you later realize you need the original details from a compressed block, use \`decompress\` to restore them. You can decompress, read the content, then re-compress if needed.
+
+Use \`compress\` and \`decompress\` deliberately with quality-first summaries. Prioritize stale content intelligently to maintain a high-signal context window.
+`;
+
+// lib/prompts/compress-range.ts
+var COMPRESS_RANGE = `Collapse a range in the conversation into a detailed summary.
+
+THE SUMMARY
+Your summary must be EXHAUSTIVE. Capture file paths, function signatures, decisions made, constraints discovered, key findings... EVERYTHING that maintains context integrity. This is not a brief note - it is an authoritative record so faithful that the original conversation adds no value.
+
+USER INTENT FIDELITY
+When the compressed range includes user messages, preserve the user's intent with extra care. Do not change scope, constraints, priorities, acceptance criteria, or requested outcomes.
+Directly quote user messages when they are short enough to include safely. Direct quotes are preferred when they best preserve exact meaning.
+
+Yet be LEAN. Strip away the noise: failed attempts that led nowhere, verbose tool outputs, back-and-forth exploration. What remains should be pure signal - golden nuggets of detail that preserve full understanding with zero ambiguity.
+
+COMPRESSED BLOCK PLACEHOLDERS
+When the selected range includes previously compressed blocks, use this exact placeholder format when referencing one:
+
+- \`(bN)\`
+
+Compressed block sections in context are clearly marked with a header:
+
+- \`[Compressed conversation section]\`
+
+Compressed block IDs always use the \`bN\` form (never \`mNNNNN\`) and are represented in the same XML metadata tag format.
+
+Rules:
+
+- Include every required block placeholder exactly once.
+- Do not invent placeholders for blocks outside the selected range.
+- Treat \`(bN)\` placeholders as RESERVED TOKENS. Do not emit \`(bN)\` text anywhere except intentional placeholders.
+- If you need to mention a block in prose, use plain text like \`compressed bN\` (not as a placeholder).
+- Preflight check before finalizing: the set of \`(bN)\` placeholders in your summary must exactly match the required set, with no duplicates.
+
+These placeholders are semantic references. They will be replaced with the full stored compressed block content when the tool processes your output.
+
+FLOW PRESERVATION WITH PLACEHOLDERS
+When you use compressed block placeholders, write the surrounding summary text so it still reads correctly AFTER placeholder expansion.
+
+- Treat each placeholder as a stand-in for a full conversation segment, not as a short label.
+- Ensure transitions before and after each placeholder preserve chronology and causality.
+- Do not write text that depends on the placeholder staying literal (for example, "as noted in \`(b2)\`").
+- Your final meaning must be coherent once each placeholder is replaced with its full compressed block content.
+
+BOUNDARY IDS
+You specify boundaries by ID using the injected IDs visible in the conversation:
+
+- \`mNNNNN\` IDs identify raw messages
+- \`bN\` IDs identify previously compressed blocks
+
+Each message has an ID inside XML metadata tags like \`<dcp-message-id>...</dcp-message-id>\`.
+The same ID tag appears in every tool output of the message it belongs to \u2014 each unique ID identifies one complete message.
+Treat these tags as boundary metadata only, not as tool result content.
+
+Rules:
+
+- Pick \`startId\` and \`endId\` directly from injected IDs in context.
+- IDs must exist in the current visible context. If you cannot see an ID in the messages above, it is stale and will fail.
+- \`startId\` must appear before \`endId\`.
+- Do not invent IDs. Use only IDs that are present in context.
+- NEVER use IDs from compressed block summaries, previous nudges, or your own memory \u2014 only IDs currently visible as XML metadata tags in the conversation.
+
+BATCHING
+When multiple independent ranges are ready and their boundaries do not overlap, include all of them as separate entries in the \`content\` array of a single tool call. Each entry should have its own \`startId\`, \`endId\`, and \`summary\`.
+`;
+
+// lib/prompts/compress-message.ts
+var COMPRESS_MESSAGE = `Collapse selected individual messages in the conversation into detailed summaries.
+
+THE SUMMARY
+Your summary must be EXHAUSTIVE. Capture file paths, function signatures, decisions made, constraints discovered, key findings, tool outcomes, and user intent details that matter... EVERYTHING that preserves the value of the selected message after the raw message is removed.
+
+USER INTENT FIDELITY
+When a selected message contains user intent, preserve that intent with extra care. Do not change scope, constraints, priorities, acceptance criteria, or requested outcomes.
+Directly quote short user instructions when that best preserves exact meaning.
+
+Yet be LEAN. Strip away the noise: failed attempts that led nowhere, verbose tool output, and repetition. What remains should be pure signal - golden nuggets of detail that preserve full understanding with zero ambiguity.
+If a message contains no significant technical decisions, code changes, or user requirements, produce a minimal one-line summary rather than a detailed one.
 
-// lib/prompts/extensions/nudge.ts
-function buildCompressedBlockGuidance(state, gcConfig, context) {
-  const activeBlockIds = Array.from(state.prune.messages.activeBlockIds).filter((id) => Number.isInteger(id) && id > 0).sort((a, b) => a - b);
-  const refs = activeBlockIds.map((id) => `b${id}`);
-  const blockCount = refs.length;
-  const blockList = blockCount > 0 ? refs.join(", ") : "none";
-  const lines = [
-    "Compressed block context:",
-    `- Active compressed blocks: ${blockCount} (${blockList})`,
-    "- If your selected compression range includes any listed block, include each required placeholder exactly once in the summary using `(bN)`."
-  ];
-  const usageRatio = context?.currentTokens && context?.modelContextLimit ? context.currentTokens / context.modelContextLimit : 0;
-  if (gcConfig && usageRatio > 0.5) {
-    const promotionThreshold = gcConfig.promotionThreshold;
-    const agingBlocks = [];
-    for (const blockId of activeBlockIds) {
-      const block = state.prune.messages.blocksById.get(blockId);
-      if (!block) continue;
-      const survived = block.survivedCount ?? 0;
-      const gen = block.generation ?? "young";
-      const sizeK = (block.summary.length / 1e3).toFixed(1);
-      const preview = block.summary.slice(0, 120).replace(/\n/g, " ");
-      if (gen === "old" || survived >= promotionThreshold - 2) {
-        agingBlocks.push(
-          `  b${blockId}: age=${survived}/${promotionThreshold}, gen=${gen}, size=${sizeK}K chars \u2014 ${preview}...`
-        );
-      }
-    }
-    if (agingBlocks.length > 0) {
-      lines.push("");
-      lines.push("\u26A0\uFE0F Block aging warning \u2014 these blocks may be truncated by GC soon:");
-      lines.push(...agingBlocks);
-      lines.push(
-        "To preserve important content: use the compress tool to re-summarize these blocks into new concise ones. Unhandled blocks will be auto-truncated."
-      );
-    }
-  }
-  return lines.join("\n");
-}
-function renderMessagePriorityGuidance(priorityLabel, refs) {
-  const refList = refs.length > 0 ? refs.join(", ") : "none";
-  return [
-    "Message priority context:",
-    "- Higher-priority older messages consume more context and should be compressed right away if it is safe to do so.",
-    `- ${priorityLabel}-priority message IDs before this point: ${refList}`
-  ].join("\n");
-}
-function appendGuidanceToDcpTag(nudgeText, guidance) {
-  if (!guidance.trim()) {
-    return nudgeText;
-  }
-  const closeTag = "</dcp-system-reminder>";
-  const closeTagIndex = nudgeText.lastIndexOf(closeTag);
-  if (closeTagIndex === -1) {
-    return nudgeText;
-  }
-  const beforeClose = nudgeText.slice(0, closeTagIndex).trimEnd();
-  const afterClose = nudgeText.slice(closeTagIndex);
-  return `${beforeClose}
+MESSAGE IDS
+You specify individual raw messages by ID using the injected IDs visible in the conversation:
 
-${guidance}
-${afterClose}`;
-}
+- \`mNNNNN\` IDs identify raw messages
 
-// lib/messages/priority.ts
-var MEDIUM_PRIORITY_MIN_TOKENS = 500;
-var HIGH_PRIORITY_MIN_TOKENS = 5e3;
-function buildPriorityMap(config, state, messages) {
-  if (config.compress.mode !== "message") {
-    return /* @__PURE__ */ new Map();
-  }
-  const priorities = /* @__PURE__ */ new Map();
-  for (const message of messages) {
-    if (isIgnoredUserMessage(message)) {
-      continue;
-    }
-    if (isProtectedUserMessage(config, message)) {
-      continue;
-    }
-    if (isMessageCompacted(state, message)) {
-      continue;
-    }
-    const rawMessageId = message.info.id;
-    if (typeof rawMessageId !== "string" || rawMessageId.length === 0) {
-      continue;
-    }
-    const ref = state.messageIds.byRawId.get(rawMessageId);
-    if (!ref) {
-      continue;
-    }
-    const tokenCount = countAllMessageTokens(message);
-    priorities.set(rawMessageId, {
-      ref,
-      tokenCount,
-      priority: messageHasCompress(message) ? "high" : classifyMessagePriority(tokenCount)
-    });
-  }
-  return priorities;
-}
-function classifyMessagePriority(tokenCount) {
-  if (tokenCount >= HIGH_PRIORITY_MIN_TOKENS) {
-    return "high";
-  }
-  if (tokenCount >= MEDIUM_PRIORITY_MIN_TOKENS) {
-    return "medium";
-  }
-  return "low";
-}
-function listPriorityRefsBeforeIndex(messages, priorities, anchorIndex, priority) {
-  const refs = [];
-  const seen = /* @__PURE__ */ new Set();
-  const upperBound = Math.max(0, Math.min(anchorIndex, messages.length));
-  for (let index = 0; index < upperBound; index++) {
-    const rawMessageId = messages[index]?.info.id;
-    if (typeof rawMessageId !== "string") {
-      continue;
-    }
-    const entry = priorities.get(rawMessageId);
-    if (!entry || entry.priority !== priority || seen.has(entry.ref)) {
-      continue;
-    }
-    seen.add(entry.ref);
-    refs.push(entry.ref);
-  }
-  return refs;
-}
+Each message has an ID inside XML metadata tags like \`<dcp-message-id priority="high">m0007</dcp-message-id>\`.
+The same ID tag appears in every tool output of the message it belongs to \u2014 each unique ID identifies one complete message.
+Treat these tags as message metadata only, not as content to summarize. Use only the inner \`mNNNNN\` value as the \`messageId\`.
+The \`priority\` attribute indicates relative context cost. You MUST compress high-priority messages when their full text is no longer necessary for the active task.
+If prior compress-tool results are present, always compress and summarize them minimally only as part of a broader compression pass. Do not invoke the compress tool solely to re-compress an earlier compression result.
+Messages marked as \`<dcp-message-id>BLOCKED</dcp-message-id>\` cannot be compressed.
 
-// lib/messages/inject/utils.ts
-var MESSAGE_MODE_NUDGE_PRIORITY = "high";
-function getNudgeFrequency(config) {
-  return Math.max(1, Math.floor(config.compress.nudgeFrequency || 1));
-}
-function getIterationNudgeThreshold(config) {
-  return Math.max(1, Math.floor(config.compress.iterationNudgeThreshold || 1));
-}
-function findLastNonIgnoredMessage(messages) {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const message = messages[i];
-    if (isIgnoredUserMessage(message)) {
-      continue;
-    }
-    if (isSyntheticMessage(message)) {
-      continue;
-    }
-    return { message, index: i };
-  }
-  return null;
-}
-function countMessagesAfterIndex(messages, index) {
-  let count = 0;
-  for (let i = index + 1; i < messages.length; i++) {
-    const message = messages[i];
-    if (isIgnoredUserMessage(message)) {
-      continue;
-    }
-    count++;
-  }
-  return count;
-}
-function getModelInfo(messages) {
-  const lastUserMessage = getLastUserMessage(messages);
-  if (!lastUserMessage) {
-    return {
-      providerId: void 0,
-      modelId: void 0
-    };
-  }
-  const userInfo = lastUserMessage.info;
-  return {
-    providerId: userInfo.model.providerID,
-    modelId: userInfo.model.modelID
-  };
-}
-function resolveContextTokenLimit(config, state, providerId, modelId, threshold) {
-  const parseLimitValue = (limit) => {
-    if (limit === void 0) {
-      return void 0;
-    }
-    if (typeof limit === "number") {
-      return limit;
-    }
-    if (!limit.endsWith("%") || state.modelContextLimit === void 0) {
-      return void 0;
-    }
-    const parsedPercent = parseFloat(limit.slice(0, -1));
-    if (isNaN(parsedPercent)) {
-      return void 0;
-    }
-    const roundedPercent = Math.round(parsedPercent);
-    const clampedPercent = Math.max(0, Math.min(100, roundedPercent));
-    return Math.round(clampedPercent / 100 * state.modelContextLimit);
-  };
-  const modelLimits = threshold === "max" ? config.compress.modelMaxLimits : config.compress.modelMinLimits;
-  if (modelLimits && providerId !== void 0 && modelId !== void 0) {
-    const providerModelId = `${providerId}/${modelId}`;
-    const modelLimit = modelLimits[providerModelId];
-    if (modelLimit !== void 0) {
-      return parseLimitValue(modelLimit);
-    }
-  }
-  const globalLimit = threshold === "max" ? config.compress.maxContextLimit : config.compress.minContextLimit;
-  return parseLimitValue(globalLimit);
-}
-function isContextOverLimits(config, state, providerId, modelId, messages) {
-  const summaryTokenExtension = config.compress.summaryBuffer ? getActiveSummaryTokenUsage(state) : 0;
-  const resolvedMaxContextLimit = resolveContextTokenLimit(
-    config,
-    state,
-    providerId,
-    modelId,
-    "max"
-  );
-  const maxContextLimit = resolvedMaxContextLimit === void 0 ? void 0 : resolvedMaxContextLimit + summaryTokenExtension;
-  const minContextLimit = resolveContextTokenLimit(config, state, providerId, modelId, "min");
-  const currentTokens = getCurrentTokenUsage(state, messages);
-  let overMaxLimit = maxContextLimit === void 0 ? false : currentTokens > maxContextLimit;
-  const overMinLimit = minContextLimit === void 0 ? false : currentTokens >= minContextLimit;
-  if (overMaxLimit) {
-    const recentCompressCount = 3;
-    const recentMessages = messages.slice(-recentCompressCount);
-    for (const msg of recentMessages) {
-      if (msg.info.role === "assistant" && msg.parts) {
-        for (const part of msg.parts) {
-          if (part.type === "tool-invocation" && part.toolInvocation?.toolName === "compress") {
-            overMaxLimit = false;
-            break;
-          }
-        }
-      }
-      if (!overMaxLimit) break;
+Rules:
+
+- Pick each \`messageId\` directly from injected IDs visible in context.
+- Only use raw message IDs of the form \`mNNNNN\`.
+- Ignore XML attributes such as \`priority\` when copying the ID; use only the inner \`mNNNNN\` value.
+- Do not invent IDs. Use only IDs that are present in context.
+
+BATCHING
+Select MANY messages in a single tool call when they are safe to compress.
+Each entry should summarize exactly one message, and the tool can receive as many entries as needed in one batch.
+
+GENERAL CLEANUP
+Use the topic "general cleanup" for broad cleanup passes.
+During general cleanup, compress all medium and high-priority messages that are not relevant to the active task.
+Optimize for reducing context footprint, not for grouping messages by topic.
+Do not compress away still-active instructions, unresolved questions, or constraints that are likely to matter soon.
+Prioritize the earliest messages in the context as they will be the least relevant to the active task.
+General cleanup should be done periodically between other normal compression tool passes, not as the primary form of compression.
+`;
+
+// lib/prompts/context-limit-nudge.ts
+var CONTEXT_LIMIT_NUDGE = `
+<system-reminder>
+\u26A0\uFE0F CRITICAL: Context limit reached. You MUST use the \`compress\` tool NOW.
+
+If mid-atomic-operation, finish that step first, then compress immediately.
+
+HOW TO CALL COMPRESS:
+{
+  "topic": "Short Label",
+  "content": [
+    {
+      "startId": "<ID from early in this conversation>",
+      "endId": "<ID from later in this conversation>",
+      "summary": "Complete technical summary of everything in the range"
     }
-  }
-  return {
-    overMaxLimit,
-    overMinLimit,
-    currentTokens,
-    modelContextLimit: state.modelContextLimit
-  };
+  ]
 }
-function addAnchor(anchorMessageIds, anchorMessageId, anchorMessageIndex, messages, interval) {
-  if (anchorMessageIndex < 0) {
-    return false;
-  }
-  let latestAnchorMessageIndex = -1;
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (anchorMessageIds.has(messages[i].info.id)) {
-      latestAnchorMessageIndex = i;
-      break;
-    }
-  }
-  const shouldAdd = latestAnchorMessageIndex < 0 || anchorMessageIndex - latestAnchorMessageIndex >= interval;
-  if (!shouldAdd) {
-    return false;
-  }
-  const previousSize = anchorMessageIds.size;
-  anchorMessageIds.add(anchorMessageId);
-  return anchorMessageIds.size !== previousSize;
+
+\u26A0\uFE0F ID RULES \u2014 MOST COMMON CAUSE OF ERRORS:
+- ONLY use IDs you can see in <dcp-message-id> tags in the messages ABOVE.
+- Do NOT copy IDs from this example. Do NOT invent IDs.
+- Do NOT use IDs from compressed block summaries \u2014 they are stale.
+- startId must appear BEFORE endId in the conversation.
+
+SUMMARY RULES:
+- Capture ALL essential details: file paths, decisions, constraints, key findings.
+- Preserve user intent exactly. Direct-quote short user messages.
+- Prefer one large range over multiple small ones.
+- Compress OLDER resolved history first. Keep recent active work.
+</system-reminder>
+`;
+
+// lib/prompts/turn-nudge.ts
+var TURN_NUDGE = `
+<system-reminder>
+Context is getting full. Compress closed/older conversation ranges now.
+
+{
+  "topic": "Short Label",
+  "content": [{ "startId": "<visible message ID>", "endId": "<visible message ID>", "summary": "..." }]
 }
-function buildMessagePriorityGuidance(messages, compressionPriorities, anchorIndex, priority) {
-  if (!compressionPriorities || compressionPriorities.size === 0) {
+
+\u26A0\uFE0F ONLY use IDs from <dcp-message-id> tags visible above. Do NOT invent or copy example IDs.
+</system-reminder>
+`;
+
+// lib/prompts/iteration-nudge.ts
+var ITERATION_NUDGE = `
+<system-reminder>
+You've been iterating for a while. If any earlier work is closed and unlikely to be referenced, compress it now.
+
+{
+  "topic": "Short Label",
+  "content": [{ "startId": "<visible message ID>", "endId": "<visible message ID>", "summary": "..." }]
+}
+
+\u26A0\uFE0F ONLY use IDs from <dcp-message-id> tags visible above. Do NOT invent or copy example IDs.
+</system-reminder>
+`;
+
+// lib/prompts/extensions/system.ts
+var MANUAL_MODE_SYSTEM_EXTENSION = `<dcp-system-reminder>
+Manual mode is enabled. Do NOT use compress unless the user has explicitly triggered it through a manual marker.
+
+Only use the compress tool after seeing \`<compress triggered manually>\` in the current user instruction context.
+
+Issue exactly ONE compress tool per manual trigger. Do NOT launch multiple compress tools in parallel. Each trigger grants a single compression; after it completes, wait for the next trigger.
+
+After completing a manually triggered context-management action, STOP IMMEDIATELY. Do NOT continue with any task execution. End your response right after the tool use completes and wait for the next user input.
+</dcp-system-reminder>
+`;
+var SUBAGENT_SYSTEM_EXTENSION = `<dcp-system-reminder>
+You are operating in a subagent environment.
+
+The initial subagent instruction is imperative and must be followed exactly.
+It is the only user message intentionally not assigned a message ID, and therefore is not eligible for compression.
+All subsequent messages in the session will have IDs.
+</dcp-system-reminder>
+`;
+function buildProtectedToolsExtension(protectedTools) {
+  if (protectedTools.length === 0) {
     return "";
   }
-  const refs = listPriorityRefsBeforeIndex(messages, compressionPriorities, anchorIndex, priority);
-  const priorityLabel = `${priority[0].toUpperCase()}${priority.slice(1)}`;
-  return renderMessagePriorityGuidance(priorityLabel, refs);
+  const toolList = protectedTools.map((t) => `\`${t}\``).join(", ");
+  return `<dcp-system-reminder>
+The following tools are environment-managed: ${toolList}.
+Their outputs are automatically preserved during compression.
+Do not include their content in compress tool summaries \u2014 the environment retains it independently.
+</dcp-system-reminder>`;
 }
-function injectAnchoredNudge(message, nudgeText) {
-  if (!nudgeText.trim()) {
-    return;
-  }
-  if (message.info.role === "user") {
-    if (appendToLastTextPart(message, nudgeText)) {
-      return;
-    }
-    message.parts.push(createSyntheticTextPart(message, nudgeText));
-    return;
-  }
-  if (message.info.role !== "assistant") {
-    return;
-  }
-  if (!hasContent(message)) {
-    return;
-  }
-  for (const part of message.parts) {
-    if (part.type === "text") {
-      if (appendToTextPart(part, nudgeText)) {
-        return;
-      }
-    }
-  }
-  const syntheticPart = createSyntheticTextPart(message, nudgeText);
-  const firstToolIndex = message.parts.findIndex((p) => p.type === "tool");
-  if (firstToolIndex === -1) {
-    message.parts.push(syntheticPart);
-  } else {
-    message.parts.splice(firstToolIndex, 0, syntheticPart);
+var DECOMPRESS_SYSTEM_EXTENSION = `<dcp-system-reminder>
+THE PHILOSOPHY OF DECOMPRESS
+\`decompress\` restores previously compressed content. Use it when you need exact details
+that were lost in compression.
+
+DECOMPRESS WHEN
+- You need exact code, error messages, or file contents from a compressed block
+- A summary lacks the precision needed for your next step
+- You discovered the compressed content is still relevant
+
+DO NOT DECOMPRESS IF
+- Context usage is already high (>70%) \u2014 decompressing inflates context
+- The summary is sufficient for your needs
+- You plan to immediately recompress the same content
+
+Before decompressing, check context usage. Decompressing restores full messages,
+which can significantly increase context size.
+
+NOTE: Message-mode blocks created in the same batch (same runId) are restored together.
+Decompressing one block from a batch restores all blocks in that batch.
+</dcp-system-reminder>
+`;
+
+// lib/prompts/store.ts
+var PROMPT_DEFINITIONS = [
+  {
+    key: "system",
+    fileName: "system.md",
+    label: "System",
+    description: "Core system-level ACP instruction block",
+    usage: "Injected into the model system prompt on every request",
+    runtimeField: "system"
+  },
+  {
+    key: "compress-range",
+    fileName: "compress-range.md",
+    label: "Compress Range",
+    description: "range-mode compress tool instructions and summary constraints",
+    usage: "Registered as the range-mode compress tool description",
+    runtimeField: "compressRange"
+  },
+  {
+    key: "compress-message",
+    fileName: "compress-message.md",
+    label: "Compress Message",
+    description: "message-mode compress tool instructions and summary constraints",
+    usage: "Registered as the message-mode compress tool description",
+    runtimeField: "compressMessage"
+  },
+  {
+    key: "context-limit-nudge",
+    fileName: "context-limit-nudge.md",
+    label: "Context Limit Nudge",
+    description: "High-priority nudge when context is over max threshold",
+    usage: "Injected when context usage is beyond configured max limits",
+    runtimeField: "contextLimitNudge"
+  },
+  {
+    key: "turn-nudge",
+    fileName: "turn-nudge.md",
+    label: "Turn Nudge",
+    description: "Nudge to compress closed ranges at turn boundaries",
+    usage: "Injected when context is between min and max limits at a new user turn",
+    runtimeField: "turnNudge"
+  },
+  {
+    key: "iteration-nudge",
+    fileName: "iteration-nudge.md",
+    label: "Iteration Nudge",
+    description: "Nudge after many iterations without user input",
+    usage: "Injected when iteration threshold is crossed",
+    runtimeField: "iterationNudge"
   }
+];
+var HTML_COMMENT_REGEX = /<!--[\s\S]*?-->/g;
+var LEGACY_INLINE_COMMENT_LINE_REGEX = /^[ \t]*\/\/.*?\/\/[ \t]*$/gm;
+var DCP_SYSTEM_REMINDER_TAG_REGEX = /^\s*<dcp-system-reminder\b[^>]*>[\s\S]*<\/dcp-system-reminder>\s*$/i;
+var DEFAULTS_README_FILE = "README.md";
+var BUNDLED_EDITABLE_PROMPTS = {
+  system: SYSTEM,
+  compressRange: COMPRESS_RANGE,
+  compressMessage: COMPRESS_MESSAGE,
+  contextLimitNudge: CONTEXT_LIMIT_NUDGE,
+  turnNudge: TURN_NUDGE,
+  iterationNudge: ITERATION_NUDGE
+};
+var INTERNAL_PROMPT_EXTENSIONS = {
+  manualExtension: MANUAL_MODE_SYSTEM_EXTENSION,
+  subagentExtension: SUBAGENT_SYSTEM_EXTENSION,
+  decompressExtension: DECOMPRESS_SYSTEM_EXTENSION
+};
+function createBundledRuntimePrompts() {
+  return {
+    system: BUNDLED_EDITABLE_PROMPTS.system,
+    compressRange: BUNDLED_EDITABLE_PROMPTS.compressRange,
+    compressMessage: BUNDLED_EDITABLE_PROMPTS.compressMessage,
+    contextLimitNudge: BUNDLED_EDITABLE_PROMPTS.contextLimitNudge,
+    turnNudge: BUNDLED_EDITABLE_PROMPTS.turnNudge,
+    iterationNudge: BUNDLED_EDITABLE_PROMPTS.iterationNudge,
+    manualExtension: INTERNAL_PROMPT_EXTENSIONS.manualExtension,
+    subagentExtension: INTERNAL_PROMPT_EXTENSIONS.subagentExtension,
+    decompressExtension: INTERNAL_PROMPT_EXTENSIONS.decompressExtension
+  };
 }
-function collectAnchoredMessages(anchorMessageIds, messages) {
-  const anchoredMessages = [];
-  for (const anchorMessageId of anchorMessageIds) {
-    const index = messages.findIndex((message) => message.info.id === anchorMessageId);
-    if (index === -1) {
-      continue;
+function findOpencodeDir2(startDir) {
+  let current = startDir;
+  while (current !== "/") {
+    const candidate = join4(current, ".opencode");
+    if (existsSync4(candidate)) {
+      try {
+        if (statSync2(candidate).isDirectory()) {
+          return candidate;
+        }
+      } catch {
+      }
     }
-    anchoredMessages.push({
-      message: messages[index],
-      index
-    });
+    const parent = dirname2(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
   }
-  return anchoredMessages;
+  return null;
 }
-function collectTurnNudgeAnchors2(state, config, messages) {
-  const turnNudgeAnchors = /* @__PURE__ */ new Set();
-  const targetRole = config.compress.nudgeForce === "strong" ? "user" : "assistant";
-  for (const message of messages) {
-    if (!state.nudges.turnNudgeAnchors.has(message.info.id)) continue;
-    if (message.info.role === targetRole) {
-      turnNudgeAnchors.add(message.info.id);
+function resolvePromptPaths(workingDirectory) {
+  const configHome = process.env.XDG_CONFIG_HOME || join4(homedir4(), ".config");
+  const globalRoot = join4(configHome, "opencode", "acp-prompts");
+  const legacyGlobalRoot = join4(configHome, "opencode", "dcp-prompts");
+  if (!existsSync4(globalRoot) && existsSync4(legacyGlobalRoot)) {
+    try {
+      cpSync2(legacyGlobalRoot, globalRoot, { recursive: true });
+      console.log("[ACP] Migrated prompts from dcp-prompts to acp-prompts");
+    } catch (e) {
+      console.warn(`[ACP] Prompts migration failed: ${e.message}`);
     }
   }
-  return turnNudgeAnchors;
+  const defaultsDir = join4(globalRoot, "defaults");
+  const globalOverridesDir = join4(globalRoot, "overrides");
+  const configDirOverridesDir = process.env.OPENCODE_CONFIG_DIR ? join4(process.env.OPENCODE_CONFIG_DIR, "acp-prompts", "overrides") : null;
+  const opencodeDir = findOpencodeDir2(workingDirectory);
+  const projectOverridesDir = opencodeDir ? join4(opencodeDir, "acp-prompts", "overrides") : null;
+  return {
+    defaultsDir,
+    globalOverridesDir,
+    configDirOverridesDir,
+    projectOverridesDir
+  };
 }
-function applyRangeModeAnchoredNudge(anchorMessageIds, messages, baseNudgeText, compressedBlockGuidance) {
-  const nudgeText = appendGuidanceToDcpTag(baseNudgeText, compressedBlockGuidance);
-  if (!nudgeText.trim()) {
-    return;
-  }
-  for (const { message } of collectAnchoredMessages(anchorMessageIds, messages)) {
-    injectAnchoredNudge(message, nudgeText);
-  }
+function stripConditionalTag(content, tagName) {
+  const regex = new RegExp(`<${tagName}>[\\s\\S]*?</${tagName}>`, "gi");
+  return content.replace(regex, "");
 }
-function applyMessageModeAnchoredNudge(anchorMessageIds, messages, baseNudgeText, compressionPriorities) {
-  for (const { message, index } of collectAnchoredMessages(anchorMessageIds, messages)) {
-    const priorityGuidance = buildMessagePriorityGuidance(
-      messages,
-      compressionPriorities,
-      index,
-      MESSAGE_MODE_NUDGE_PRIORITY
-    );
-    const nudgeText = appendGuidanceToDcpTag(baseNudgeText, priorityGuidance);
-    injectAnchoredNudge(message, nudgeText);
+function unwrapDcpTagIfWrapped(content) {
+  const trimmed = content.trim();
+  if (DCP_SYSTEM_REMINDER_TAG_REGEX.test(trimmed)) {
+    return trimmed.replace(/^\s*<dcp-system-reminder\b[^>]*>\s*/i, "").replace(/\s*<\/dcp-system-reminder>\s*$/i, "").trim();
   }
+  return trimmed;
 }
-function buildContextUsageInfo(currentTokens, modelContextLimit) {
-  if (currentTokens === void 0 || modelContextLimit === void 0 || modelContextLimit === 0) {
+function normalizeReminderPromptContent(content) {
+  const normalized = content.trim();
+  if (!normalized) {
     return "";
   }
-  const percentage = (currentTokens / modelContextLimit * 100).toFixed(1);
-  const formatK = (n) => n >= 1e3 ? `${(n / 1e3).toFixed(1)}K` : String(n);
-  return `
-
-Context usage: ${formatK(currentTokens)} / ${formatK(modelContextLimit)} tokens (${percentage}%). ACP (Active Context Pruning) threshold: 55%. You ARE the ACP agent \u2014 use the compress tool proactively to manage context quality.`;
-}
-function applyAnchoredNudges(state, config, messages, prompts, compressionPriorities, currentTokens, modelContextLimit, suffixMessage) {
-  const contextUsageInfo = buildContextUsageInfo(currentTokens, modelContextLimit);
-  const contextLimitNudgeWithUsage = prompts.contextLimitNudge + contextUsageInfo;
-  const turnNudgeAnchors = collectTurnNudgeAnchors2(state, config, messages);
-  if (suffixMessage) {
-    const nudgeParts = [];
-    if (config.compress.mode === "message") {
-      if (state.nudges.contextLimitAnchors.size > 0) {
-        for (const { index } of collectAnchoredMessages(state.nudges.contextLimitAnchors, messages)) {
-          const guidance = buildMessagePriorityGuidance(messages, compressionPriorities, index, MESSAGE_MODE_NUDGE_PRIORITY);
-          nudgeParts.push(appendGuidanceToDcpTag(contextLimitNudgeWithUsage, guidance));
-        }
-      }
-      if (turnNudgeAnchors.size > 0) {
-        for (const { index } of collectAnchoredMessages(turnNudgeAnchors, messages)) {
-          const guidance = buildMessagePriorityGuidance(messages, compressionPriorities, index, MESSAGE_MODE_NUDGE_PRIORITY);
-          nudgeParts.push(appendGuidanceToDcpTag(prompts.turnNudge, guidance));
-        }
-      }
-      if (state.nudges.iterationNudgeAnchors.size > 0) {
-        for (const { index } of collectAnchoredMessages(state.nudges.iterationNudgeAnchors, messages)) {
-          const guidance = buildMessagePriorityGuidance(messages, compressionPriorities, index, MESSAGE_MODE_NUDGE_PRIORITY);
-          nudgeParts.push(appendGuidanceToDcpTag(prompts.iterationNudge, guidance));
-        }
-      }
-    } else {
-      if (state.nudges.contextLimitAnchors.size > 0) {
-        nudgeParts.push(contextLimitNudgeWithUsage);
-      }
-      if (turnNudgeAnchors.size > 0) {
-        nudgeParts.push(prompts.turnNudge);
-      }
-      if (state.nudges.iterationNudgeAnchors.size > 0) {
-        nudgeParts.push(prompts.iterationNudge);
-      }
-    }
-    const combined = nudgeParts.join("\n\n");
-    if (combined.trim()) {
-      injectAnchoredNudge(suffixMessage, combined);
-    }
-    return;
-  }
-  if (config.compress.mode === "message") {
-    applyMessageModeAnchoredNudge(
-      state.nudges.contextLimitAnchors,
-      messages,
-      contextLimitNudgeWithUsage,
-      compressionPriorities
-    );
-    applyMessageModeAnchoredNudge(
-      turnNudgeAnchors,
-      messages,
-      prompts.turnNudge,
-      compressionPriorities
-    );
-    applyMessageModeAnchoredNudge(
-      state.nudges.iterationNudgeAnchors,
-      messages,
-      prompts.iterationNudge,
-      compressionPriorities
-    );
-    return;
+  const startsWrapped = /^\s*<dcp-system-reminder\b[^>]*>/i.test(normalized);
+  const endsWrapped = /<\/dcp-system-reminder>\s*$/i.test(normalized);
+  if (startsWrapped !== endsWrapped) {
+    return "";
   }
-  applyRangeModeAnchoredNudge(
-    state.nudges.contextLimitAnchors,
-    messages,
-    contextLimitNudgeWithUsage,
-    ""
-  );
-  applyRangeModeAnchoredNudge(
-    turnNudgeAnchors,
-    messages,
-    prompts.turnNudge,
-    ""
-  );
-  applyRangeModeAnchoredNudge(
-    state.nudges.iterationNudgeAnchors,
-    messages,
-    prompts.iterationNudge,
-    ""
-  );
+  return unwrapDcpTagIfWrapped(normalized);
 }
-
-// lib/messages/inject/inject.ts
-var ACP_SUFFIX_SEED = "acp-dynamic-guidance";
-function createSuffixMessage(messages) {
-  if (messages.length === 0) return null;
-  const base = messages.find((m) => m.info.role === "user") || messages[messages.length - 1];
-  const synthetic = createSyntheticUserMessage(base, "", ACP_SUFFIX_SEED);
-  messages.push(synthetic);
-  return synthetic;
+function stripPromptComments(content) {
+  return content.replace(/^\uFEFF/, "").replace(/\r\n?/g, "\n").replace(HTML_COMMENT_REGEX, "").replace(LEGACY_INLINE_COMMENT_LINE_REGEX, "");
 }
-var injectCompressNudges = (state, config, logger, messages, prompts, compressionPriorities) => {
-  if (compressPermission(state, config) === "deny") {
-    return;
-  }
-  if (state.manualMode) {
-    return;
-  }
-  const lastMessage = findLastNonIgnoredMessage(messages);
-  const lastAssistantMessage = messages.findLast((message) => message.info.role === "assistant");
-  if (lastAssistantMessage && messageHasCompress(lastAssistantMessage)) {
-    state.nudges.contextLimitAnchors.clear();
-    state.nudges.turnNudgeAnchors.clear();
-    state.nudges.iterationNudgeAnchors.clear();
-    void saveSessionState(state, logger);
-    return;
-  }
-  const { providerId, modelId } = getModelInfo(messages);
-  let anchorsChanged = false;
-  const { overMaxLimit, overMinLimit, currentTokens, modelContextLimit } = isContextOverLimits(
-    config,
-    state,
-    providerId,
-    modelId,
-    messages
-  );
-  if (!overMinLimit) {
-    const hadTurnAnchors = state.nudges.turnNudgeAnchors.size > 0;
-    const hadIterationAnchors = state.nudges.iterationNudgeAnchors.size > 0;
-    if (hadTurnAnchors || hadIterationAnchors) {
-      state.nudges.turnNudgeAnchors.clear();
-      state.nudges.iterationNudgeAnchors.clear();
-      anchorsChanged = true;
-    }
+function toEditablePromptText(definition, rawContent) {
+  let normalized = stripPromptComments(rawContent).trim();
+  if (!normalized) {
+    return "";
   }
-  if (overMaxLimit) {
-    if (lastMessage) {
-      const interval = getNudgeFrequency(config);
-      const added = addAnchor(
-        state.nudges.contextLimitAnchors,
-        lastMessage.message.info.id,
-        lastMessage.index,
-        messages,
-        interval
-      );
-      if (added) {
-        anchorsChanged = true;
-      }
-    }
-  } else if (overMinLimit) {
-    const isLastMessageUser = lastMessage?.message.info.role === "user";
-    if (isLastMessageUser && lastAssistantMessage) {
-      const previousSize = state.nudges.turnNudgeAnchors.size;
-      state.nudges.turnNudgeAnchors.add(lastMessage.message.info.id);
-      state.nudges.turnNudgeAnchors.add(lastAssistantMessage.info.id);
-      if (state.nudges.turnNudgeAnchors.size !== previousSize) {
-        anchorsChanged = true;
-      }
-    }
-    const lastUserMessage = getLastUserMessage(messages);
-    if (lastUserMessage && lastMessage) {
-      const lastUserMessageIndex = messages.findIndex(
-        (message) => message.info.id === lastUserMessage.info.id
-      );
-      if (lastUserMessageIndex >= 0) {
-        const messagesSinceUser = countMessagesAfterIndex(messages, lastUserMessageIndex);
-        const iterationThreshold = getIterationNudgeThreshold(config);
-        if (lastMessage.index > lastUserMessageIndex && messagesSinceUser >= iterationThreshold) {
-          const interval = getNudgeFrequency(config);
-          const added = addAnchor(
-            state.nudges.iterationNudgeAnchors,
-            lastMessage.message.info.id,
-            lastMessage.index,
-            messages,
-            interval
-          );
-          if (added) {
-            anchorsChanged = true;
-          }
-        }
-      }
-    }
+  if (definition.key === "system") {
+    normalized = stripConditionalTag(normalized, "manual");
+    normalized = stripConditionalTag(normalized, "subagent");
   }
-  const suffixMessage = createSuffixMessage(messages);
-  applyAnchoredNudges(state, config, messages, prompts, compressionPriorities, currentTokens, modelContextLimit, suffixMessage);
-  injectContextUsage(suffixMessage, currentTokens, modelContextLimit);
-  if (config.compress.mode !== "message") {
-    const blockGuidance = buildCompressedBlockGuidance(state, config.gc, { currentTokens, modelContextLimit });
-    if (blockGuidance.trim() && suffixMessage) {
-      appendToLastTextPart(suffixMessage, "\n\n" + blockGuidance);
-    }
+  if (definition.key !== "compress-range" && definition.key !== "compress-message") {
+    normalized = normalizeReminderPromptContent(normalized);
   }
-  injectVisibleIdRange(state, messages, suffixMessage);
-  if (anchorsChanged) {
-    void saveSessionState(state, logger);
+  return normalized.trim();
+}
+function wrapRuntimePromptContent(definition, editableText) {
+  const trimmed = editableText.trim();
+  if (!trimmed) {
+    return "";
   }
-};
-function injectContextUsage(target, currentTokens, modelContextLimit) {
-  if (!target) return;
-  if (currentTokens === void 0 || modelContextLimit === void 0 || modelContextLimit === 0) {
-    return;
+  if (definition.key === "compress-range" || definition.key === "compress-message") {
+    return trimmed;
   }
-  const percentage = (currentTokens / modelContextLimit * 100).toFixed(1);
-  const formatK = (n) => n >= 1e3 ? `${(n / 1e3).toFixed(1)}K` : String(n);
-  const usageTag = `
-
-Context usage: ${formatK(currentTokens)} / ${formatK(modelContextLimit)} tokens (${percentage}%). ACP (Active Context Pruning) threshold: 55%. You ARE the ACP agent \u2014 use the compress tool proactively to manage context quality.`;
-  for (const part of target.parts) {
-    if (part.type === "text") {
-      appendToTextPart(part, usageTag);
-      return;
-    }
+  return `<dcp-system-reminder>
+${trimmed}
+</dcp-system-reminder>`;
+}
+function buildDefaultPromptFileContent(bundledEditableText) {
+  return `${bundledEditableText.trim()}
+`;
+}
+function buildDefaultsReadmeContent() {
+  const lines = [];
+  lines.push("# ACP Prompt Defaults");
+  lines.push("");
+  lines.push("This directory stores the ACP prompts.");
+  lines.push("Each prompt file here should contain plain text only (no XML wrappers).");
+  lines.push("");
+  lines.push("## Creating Overrides");
+  lines.push("");
+  lines.push(
+    "1. Copy a prompt file from this directory into an overrides directory using the same filename."
+  );
+  lines.push("2. Edit the copied file using plain text.");
+  lines.push("3. Restart OpenCode.");
+  lines.push("");
+  lines.push("To reset an override, delete the matching file from your overrides directory.");
+  lines.push("");
+  lines.push(
+    "Do not edit the default prompt files directly, they are just for reference, only files in the overrides directory are used."
+  );
+  lines.push("");
+  lines.push("Override precedence (highest first):");
+  lines.push("1. `.opencode/acp-prompts/overrides/` (project)");
+  lines.push("2. `$OPENCODE_CONFIG_DIR/acp-prompts/overrides/` (config dir)");
+  lines.push("3. `~/.config/opencode/acp-prompts/overrides/` (global)");
+  lines.push("");
+  lines.push("## Prompt Files");
+  lines.push("");
+  for (const definition of PROMPT_DEFINITIONS) {
+    lines.push(`- \`${definition.fileName}\``);
+    lines.push(`  - Purpose: ${definition.description}.`);
+    lines.push(`  - Runtime use: ${definition.usage}.`);
   }
-  target.parts.push(createSyntheticTextPart(target, usageTag));
+  return `${lines.join("\n")}
+`;
 }
-function injectVisibleIdRange(state, messages, target) {
-  if (!target) return;
-  const visibleRefs = [];
-  for (const message of messages) {
-    const ref = state.messageIds.byRawId.get(message.info.id);
-    if (ref) {
-      visibleRefs.push(ref);
-    }
+function readFileIfExists(filePath) {
+  if (!existsSync4(filePath)) {
+    return null;
   }
-  if (visibleRefs.length === 0) return;
-  visibleRefs.sort();
-  const first = visibleRefs[0];
-  const last = visibleRefs[visibleRefs.length - 1];
-  const rangeTag = `
-
-[Visible message IDs: ${first} to ${last} (${visibleRefs.length} messages). Only use IDs in this range for compress.]`;
-  for (const part of target.parts) {
-    if (part.type === "text") {
-      appendToTextPart(part, rangeTag);
-      return;
-    }
+  try {
+    return readFileSync2(filePath, "utf-8");
+  } catch {
+    return null;
   }
-  target.parts.push(createSyntheticTextPart(target, rangeTag));
 }
-var injectMessageIds = (state, config, messages, compressionPriorities) => {
-  if (compressPermission(state, config) === "deny") {
-    return;
-  }
-  for (const message of messages) {
-    if (isIgnoredUserMessage(message)) {
-      continue;
+var PromptStore = class {
+  logger;
+  paths;
+  customPromptsEnabled;
+  runtimePrompts;
+  constructor(logger, workingDirectory, customPromptsEnabled = false) {
+    this.logger = logger;
+    this.paths = resolvePromptPaths(workingDirectory);
+    this.customPromptsEnabled = customPromptsEnabled;
+    this.runtimePrompts = createBundledRuntimePrompts();
+    if (this.customPromptsEnabled) {
+      this.ensureDefaultFiles();
     }
-    const messageRef = state.messageIds.byRawId.get(message.info.id);
-    if (!messageRef) {
-      continue;
+    this.reload();
+  }
+  getRuntimePrompts() {
+    return { ...this.runtimePrompts };
+  }
+  reload() {
+    const nextPrompts = createBundledRuntimePrompts();
+    if (!this.customPromptsEnabled) {
+      this.runtimePrompts = nextPrompts;
+      return;
     }
-    const isBlockedMessage = isProtectedUserMessage(config, message);
-    const priority = config.compress.mode === "message" && !isBlockedMessage ? compressionPriorities?.get(message.info.id)?.priority : void 0;
-    const tag = formatMessageIdTag(
-      isBlockedMessage ? "BLOCKED" : messageRef,
-      priority ? { priority } : void 0
-    );
-    if (message.info.role === "user") {
-      let injected = false;
-      for (const part of message.parts) {
-        if (part.type === "text") {
-          injected = appendToTextPart(part, tag) || injected;
+    for (const definition of PROMPT_DEFINITIONS) {
+      const bundledSource = BUNDLED_EDITABLE_PROMPTS[definition.runtimeField];
+      const bundledEditable = toEditablePromptText(definition, bundledSource);
+      const bundledRuntime = wrapRuntimePromptContent(definition, bundledEditable);
+      const fallbackValue = bundledRuntime || bundledSource.trim();
+      let effectiveValue = fallbackValue;
+      for (const candidate of this.getOverrideCandidates(definition.fileName)) {
+        const rawOverride = readFileIfExists(candidate.path);
+        if (rawOverride === null) {
+          continue;
         }
+        const editableOverride = toEditablePromptText(definition, rawOverride);
+        if (!editableOverride) {
+          this.logger.warn("Prompt override is empty or invalid after normalization", {
+            key: definition.key,
+            path: candidate.path
+          });
+          continue;
+        }
+        const wrappedOverride = wrapRuntimePromptContent(definition, editableOverride);
+        if (!wrappedOverride) {
+          this.logger.warn("Prompt override could not be wrapped for runtime", {
+            key: definition.key,
+            path: candidate.path
+          });
+          continue;
+        }
+        effectiveValue = wrappedOverride;
+        break;
       }
-      if (injected) {
-        continue;
-      }
-      message.parts.push(createSyntheticTextPart(message, tag));
-      continue;
-    }
-    if (message.info.role !== "assistant") {
-      continue;
-    }
-    if (!hasContent(message)) {
-      continue;
-    }
-    if (appendToAllToolParts(message, tag)) {
-      continue;
+      nextPrompts[definition.runtimeField] = effectiveValue;
     }
-    if (appendToLastTextPart(message, tag)) {
-      continue;
+    this.runtimePrompts = nextPrompts;
+  }
+  getOverrideCandidates(fileName) {
+    const candidates = [];
+    if (this.paths.projectOverridesDir) {
+      candidates.push({
+        path: join4(this.paths.projectOverridesDir, fileName)
+      });
     }
-    const syntheticPart = createSyntheticTextPart(message, tag);
-    const firstToolIndex = message.parts.findIndex((p) => p.type === "tool");
-    if (firstToolIndex === -1) {
-      message.parts.push(syntheticPart);
-    } else {
-      message.parts.splice(firstToolIndex, 0, syntheticPart);
+    if (this.paths.configDirOverridesDir) {
+      candidates.push({
+        path: join4(this.paths.configDirOverridesDir, fileName)
+      });
     }
+    candidates.push({
+      path: join4(this.paths.globalOverridesDir, fileName)
+    });
+    return candidates;
   }
-};
-
-// lib/messages/inject/subagent-results.ts
-async function fetchSubAgentMessages(client, sessionId) {
-  const response = await client.session.messages({
-    path: { id: sessionId }
-  });
-  return filterMessages(response?.data || response);
-}
-var injectExtendedSubAgentResults = async (client, state, logger, messages, allowSubAgents) => {
-  if (!allowSubAgents) {
-    return;
-  }
-  for (const message of messages) {
-    const parts = Array.isArray(message.parts) ? message.parts : [];
-    for (const part of parts) {
-      if (part.type !== "tool" || part.tool !== "task" || !part.callID) {
-        continue;
-      }
-      if (state.prune.tools.has(part.callID)) {
-        continue;
-      }
-      if (part.state?.status !== "completed" || typeof part.state.output !== "string") {
-        continue;
-      }
-      const cachedResult = state.subAgentResultCache.get(part.callID);
-      if (cachedResult !== void 0) {
-        if (cachedResult) {
-          part.state.output = stripHallucinationsFromString(
-            mergeSubagentResult(part.state.output, cachedResult)
-          );
-        }
-        continue;
-      }
-      const subAgentSessionId = getSubAgentId(part);
-      if (!subAgentSessionId) {
-        continue;
-      }
-      let subAgentMessages = [];
+  ensureDefaultFiles() {
+    try {
+      mkdirSync2(this.paths.defaultsDir, { recursive: true });
+      mkdirSync2(this.paths.globalOverridesDir, { recursive: true });
+    } catch {
+      this.logger.warn("Failed to initialize prompt directories", {
+        defaultsDir: this.paths.defaultsDir,
+        globalOverridesDir: this.paths.globalOverridesDir
+      });
+      return;
+    }
+    for (const definition of PROMPT_DEFINITIONS) {
+      const bundledEditable = toEditablePromptText(
+        definition,
+        BUNDLED_EDITABLE_PROMPTS[definition.runtimeField]
+      );
+      const managedContent = buildDefaultPromptFileContent(
+        bundledEditable || BUNDLED_EDITABLE_PROMPTS[definition.runtimeField]
+      );
+      const filePath = join4(this.paths.defaultsDir, definition.fileName);
       try {
-        subAgentMessages = await fetchSubAgentMessages(client, subAgentSessionId);
-      } catch (error) {
-        logger.warn("Failed to fetch subagent session for output expansion", {
-          subAgentSessionId,
-          callID: part.callID,
-          error: error instanceof Error ? error.message : String(error)
+        const existing = readFileIfExists(filePath);
+        if (existing === managedContent) {
+          continue;
+        }
+        writeFileSync2(filePath, managedContent, "utf-8");
+      } catch {
+        this.logger.warn("Failed to write default prompt file", {
+          key: definition.key,
+          path: filePath
         });
-        continue;
       }
-      const subAgentResultText = buildSubagentResultText(subAgentMessages);
-      if (!subAgentResultText) {
-        continue;
+    }
+    const readmePath = join4(this.paths.defaultsDir, DEFAULTS_README_FILE);
+    const readmeContent = buildDefaultsReadmeContent();
+    try {
+      const existing = readFileIfExists(readmePath);
+      if (existing !== readmeContent) {
+        writeFileSync2(readmePath, readmeContent, "utf-8");
       }
-      state.subAgentResultCache.set(part.callID, subAgentResultText);
-      part.state.output = stripHallucinationsFromString(
-        mergeSubagentResult(part.state.output, subAgentResultText)
-      );
+    } catch {
+      this.logger.warn("Failed to write defaults README", {
+        path: readmePath
+      });
     }
   }
 };
 
-// lib/messages/reasoning-strip.ts
-function stripStaleMetadata(messages) {
-  const lastUserMessage = getLastUserMessage(messages);
-  if (lastUserMessage?.info.role !== "user") {
-    return;
-  }
-  const modelID = lastUserMessage.info.model.modelID;
-  const providerID = lastUserMessage.info.model.providerID;
-  messages.forEach((message) => {
-    if (message.info.role !== "assistant") {
-      return;
-    }
-    const msgModelID = message.info.modelID;
-    const msgProviderID = message.info.providerID;
-    if (msgModelID === modelID && msgProviderID === providerID) {
-      return;
-    }
-    message.parts = message.parts.map((part) => {
-      if (part.type !== "text" && part.type !== "tool" && part.type !== "reasoning") {
-        return part;
-      }
-      if (!("metadata" in part)) {
-        return part;
-      }
-      const { metadata: _metadata, ...rest } = part;
-      return rest;
-    });
-  });
-}
-
 // lib/prompts/index.ts
 function renderSystemPrompt(prompts, protectedToolsExtension, manual, subagent) {
   const extensions = [];
@@ -6699,6 +7122,7 @@ function renderSystemPrompt(prompts, protectedToolsExtension, manual, subagent)
   if (subagent) {
     extensions.push(prompts.subagentExtension.trim());
   }
+  extensions.push(prompts.decompressExtension.trim());
   return [prompts.system.trim(), ...extensions].filter(Boolean).join("\n\n").replace(/\n([ \t]*\n)+/g, "\n\n").trim();
 }
 
@@ -6888,158 +7312,7 @@ async function handleContextCommand(ctx) {
   await sendIgnoredMessage(client, sessionId, message, params, logger);
 }
 
-// lib/commands/compression-targets.ts
-function byBlockId(a, b) {
-  return a.blockId - b.blockId;
-}
-function buildTarget(blocks) {
-  const ordered = [...blocks].sort(byBlockId);
-  const first = ordered[0];
-  if (!first) {
-    throw new Error("Cannot build compression target from empty block list.");
-  }
-  const grouped = first.mode === "message";
-  return {
-    displayId: first.blockId,
-    runId: first.runId,
-    topic: grouped ? first.batchTopic || first.topic : first.topic,
-    compressedTokens: ordered.reduce((total, block) => total + block.compressedTokens, 0),
-    durationMs: ordered.reduce((total, block) => Math.max(total, block.durationMs), 0),
-    grouped,
-    blocks: ordered
-  };
-}
-function groupMessageBlocks(blocks) {
-  const grouped = /* @__PURE__ */ new Map();
-  for (const block of blocks) {
-    const existing = grouped.get(block.runId);
-    if (existing) {
-      existing.push(block);
-      continue;
-    }
-    grouped.set(block.runId, [block]);
-  }
-  return Array.from(grouped.values()).map(buildTarget);
-}
-function splitTargets(blocks) {
-  const messageBlocks = [];
-  const singleBlocks = [];
-  for (const block of blocks) {
-    if (block.mode === "message") {
-      messageBlocks.push(block);
-    } else {
-      singleBlocks.push(block);
-    }
-  }
-  const targets = [
-    ...singleBlocks.map((block) => buildTarget([block])),
-    ...groupMessageBlocks(messageBlocks)
-  ];
-  return targets.sort((a, b) => a.displayId - b.displayId);
-}
-function getActiveCompressionTargets(messagesState) {
-  const activeBlocks = Array.from(messagesState.activeBlockIds).map((blockId) => messagesState.blocksById.get(blockId)).filter((block) => !!block && block.active);
-  return splitTargets(activeBlocks);
-}
-function getRecompressibleCompressionTargets(messagesState, availableMessageIds) {
-  const allBlocks = Array.from(messagesState.blocksById.values()).filter((block) => {
-    return availableMessageIds.has(block.compressMessageId);
-  });
-  const messageGroups = /* @__PURE__ */ new Map();
-  const singleTargets = [];
-  for (const block of allBlocks) {
-    if (block.mode === "message") {
-      const existing = messageGroups.get(block.runId);
-      if (existing) {
-        existing.push(block);
-      } else {
-        messageGroups.set(block.runId, [block]);
-      }
-      continue;
-    }
-    if (block.deactivatedByUser && !block.active) {
-      singleTargets.push(buildTarget([block]));
-    }
-  }
-  for (const blocks of messageGroups.values()) {
-    if (blocks.some((block) => block.deactivatedByUser && !block.active)) {
-      singleTargets.push(buildTarget(blocks));
-    }
-  }
-  return singleTargets.sort((a, b) => a.displayId - b.displayId);
-}
-function resolveCompressionTarget(messagesState, blockId) {
-  const block = messagesState.blocksById.get(blockId);
-  if (!block) {
-    return null;
-  }
-  if (block.mode !== "message") {
-    return buildTarget([block]);
-  }
-  const blocks = Array.from(messagesState.blocksById.values()).filter(
-    (candidate) => candidate.mode === "message" && candidate.runId === block.runId
-  );
-  if (blocks.length === 0) {
-    return null;
-  }
-  return buildTarget(blocks);
-}
-
 // lib/commands/decompress.ts
-function parseBlockIdArg(arg) {
-  const normalized = arg.trim().toLowerCase();
-  const blockRef = parseBlockRef(normalized);
-  if (blockRef !== null) {
-    return blockRef;
-  }
-  if (!/^[1-9]\d*$/.test(normalized)) {
-    return null;
-  }
-  const parsed = Number.parseInt(normalized, 10);
-  return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
-}
-function findActiveParentBlockId(messagesState, block) {
-  const queue = [...block.parentBlockIds];
-  const visited = /* @__PURE__ */ new Set();
-  while (queue.length > 0) {
-    const parentBlockId = queue.shift();
-    if (parentBlockId === void 0 || visited.has(parentBlockId)) {
-      continue;
-    }
-    visited.add(parentBlockId);
-    const parent = messagesState.blocksById.get(parentBlockId);
-    if (!parent) {
-      continue;
-    }
-    if (parent.active) {
-      return parent.blockId;
-    }
-    for (const ancestorId of parent.parentBlockIds) {
-      if (!visited.has(ancestorId)) {
-        queue.push(ancestorId);
-      }
-    }
-  }
-  return null;
-}
-function findActiveAncestorBlockId(messagesState, target) {
-  for (const block of target.blocks) {
-    const activeAncestorBlockId = findActiveParentBlockId(messagesState, block);
-    if (activeAncestorBlockId !== null) {
-      return activeAncestorBlockId;
-    }
-  }
-  return null;
-}
-function snapshotActiveMessages(messagesState) {
-  const activeMessages = /* @__PURE__ */ new Map();
-  for (const [messageId, entry] of messagesState.byMessageId) {
-    if (entry.activeBlockIds.length > 0) {
-      activeMessages.set(messageId, entry.tokenCount);
-    }
-  }
-  return activeMessages;
-}
 function formatDecompressMessage(target, restoredMessageCount, restoredTokens, reactivatedBlockIds) {
   const lines = [];
   lines.push(`Restored compression ${target.displayId}.`);
@@ -7148,32 +7421,14 @@ async function handleDecompressCommand(ctx) {
   }
   const activeMessagesBefore = snapshotActiveMessages(messagesState);
   const activeBlockIdsBefore = new Set(messagesState.activeBlockIds);
-  const deactivatedAt = Date.now();
-  for (const block of target.blocks) {
-    block.active = false;
-    block.deactivatedByUser = true;
-    block.deactivatedAt = deactivatedAt;
-    block.deactivatedByBlockId = void 0;
-    for (const consumedId of block.consumedBlockIds) {
-      const consumedBlock = messagesState.blocksById.get(consumedId);
-      if (consumedBlock) {
-        consumedBlock.deactivatedByUser = true;
-      }
-    }
-  }
+  deactivateCompressionTarget(messagesState, target);
   syncCompressionBlocks(state, logger, messages);
-  let restoredMessageCount = 0;
-  let restoredTokens = 0;
-  for (const [messageId, tokenCount] of activeMessagesBefore) {
-    const entry = messagesState.byMessageId.get(messageId);
-    const isActiveNow = entry ? entry.activeBlockIds.length > 0 : false;
-    if (!isActiveNow) {
-      restoredMessageCount++;
-      restoredTokens += tokenCount;
-    }
-  }
+  const { restoredMessageCount, restoredTokens } = computeRestoredMessages(
+    messagesState,
+    activeMessagesBefore
+  );
   state.stats.totalPruneTokens = Math.max(0, state.stats.totalPruneTokens - restoredTokens);
-  const reactivatedBlockIds = Array.from(messagesState.activeBlockIds).filter((blockId) => !activeBlockIdsBefore.has(blockId)).sort((a, b) => a - b);
+  const reactivatedBlockIds = computeReactivatedBlockIds(messagesState, activeBlockIdsBefore);
   await saveSessionState(state, logger);
   const message = formatDecompressMessage(
     target,
@@ -7247,7 +7502,7 @@ var COMPRESS_TRIGGER_PROMPT = [
   "Follow the active compress mode, preserve all critical implementation details, and choose safe targets.",
   "Return after compress with a brief explanation of what content was compressed."
 ].join("\n\n");
-function getTriggerPrompt(tool3, state, config, userFocus) {
+function getTriggerPrompt(tool4, state, config, userFocus) {
   const base = COMPRESS_TRIGGER_PROMPT;
   const compressedBlockGuidance = config.compress.mode === "message" ? "" : buildCompressedBlockGuidance(state, config.gc);
   const sections = [base, compressedBlockGuidance];
@@ -7276,8 +7531,8 @@ async function handleManualToggleCommand(ctx, modeArg) {
   );
   logger.info("Manual mode toggled", { manualMode: state.manualMode });
 }
-async function handleManualTriggerCommand(ctx, tool3, userFocus) {
-  return getTriggerPrompt(tool3, ctx.state, ctx.config, userFocus);
+async function handleManualTriggerCommand(ctx, tool4, userFocus) {
+  return getTriggerPrompt(tool4, ctx.state, ctx.config, userFocus);
 }
 function applyPendingManualTrigger(state, messages, logger) {
   const pending = state.pendingManualTrigger;
@@ -8348,7 +8603,8 @@ var server = (async (ctx) => {
     event: createEventHandler(state, logger),
     tool: {
       ...config.compress.permission !== "deny" && {
-        compress: config.compress.mode === "message" ? createCompressMessageTool(compressToolContext) : createCompressRangeTool(compressToolContext)
+        compress: config.compress.mode === "message" ? createCompressMessageTool(compressToolContext) : createCompressRangeTool(compressToolContext),
+        decompress: createDecompressTool(compressToolContext)
       }
     },
     config: async (opencodeConfig) => {
@@ -8364,7 +8620,7 @@ var server = (async (ctx) => {
       }
       const toolsToAdd = [];
       if (config.compress.permission !== "deny" && !config.experimental.allowSubAgents) {
-        toolsToAdd.push("compress");
+        toolsToAdd.push("compress", "decompress");
       }
       if (toolsToAdd.length > 0) {
         const existingPrimaryTools = opencodeConfig.experimental?.primary_tools ?? [];