@cortexkit/opencode-magic-context 0.28.0 → 0.29.0

package/dist/index.js

@@ -15407,6 +15407,7 @@ var init_magic_context = __esm(() => {
     }).describe("Embedding provider configuration"),
     temporal_awareness: exports_external.boolean().default(true).describe('Inject wall-clock gap markers (<!-- +Xm -->) between user messages where > 5 min elapsed since the previous message, and add start/end date attributes on compartments. Gives the agent a sense of session pacing and "how long ago" across multi-day sessions. Graduated from experimental.temporal_awareness; default: true (set false to opt out).'),
     keep_subagents: exports_external.boolean().default(false).describe("Debug: keep the child sessions Magic Context spawns for its own subagents (historian, dreamer, sidekick, memory-migration) instead of deleting them on success. Useful for short-term inspection/data collection — their full transcript (prompt, tool calls, token usage, output) stays in the host session store. Kept sessions accumulate until manually cleared; leave false for normal use. Requires a restart to take effect."),
+    smart_drops: exports_external.boolean().default(false).describe("Content-aware reclaim of provably-superseded tool output, layered on the existing execute-pass auto-drop. When on: superseded todowrite (keep newest 1), spent ctx_reduce (keep newest 5), and zero-value meta (bash_status, bash_kill, ctx_note read/dismiss) outputs are dropped; older edits to a file are compressed to a filePath-preserving marker while the newest edit per file stays full. Only acts on passes already busting the cache, so it never originates a cache bust. Honors the protected-tag reserve. Experimental: opt-in, default off until cache stability is proven; when off the wire is byte-identical to the positional-only reclaim. Requires a restart."),
     caveman_text_compression: exports_external.object({
       enabled: exports_external.boolean().default(false).describe("Apply deterministic caveman-style text compression to old conversation text. Only active when ctx_reduce_enabled=false. Compresses user/assistant text in oldest-first tiers: ultra (oldest 20%), full, lite, untouched (newest 40%)."),
       min_chars: exports_external.number().min(100).max(1e4).default(500).describe("Text parts shorter than this (characters) stay untouched. Min 100, max 10000. Default: 500.")
@@ -16922,6 +16923,19 @@ var init_read_session_db = __esm(async () => {
   await init_sqlite();
 });
 
+// src/shared/commit-detection.ts
+function textMentionsRecentCommit(text) {
+  return COMMIT_HASH_TEST_PATTERN.test(text) && COMMIT_VERB_PATTERN.test(text);
+}
+function createCommitHashExtractPattern() {
+  return new RegExp(`\`?\\b(${HASH_HEX})\\b\`?`, "gi");
+}
+var HASH_HEX = "[0-9a-f]{7,12}", COMMIT_HASH_TEST_PATTERN, COMMIT_VERB_PATTERN;
+var init_commit_detection = __esm(() => {
+  COMMIT_HASH_TEST_PATTERN = new RegExp(`\\b${HASH_HEX}\\b`, "i");
+  COMMIT_VERB_PATTERN = /\b(?:commit(?:ted|ting|s)?|cherry-?pick(?:ed|ing|s)?|merge[ds]?|merging|rebas(?:e|ed|es|ing))\b/i;
+});
+
 // ../../node_modules/.bun/ai-tokenizer@1.0.6/node_modules/ai-tokenizer/dist/index.js
 function _typeof(o) {
   "@babel/helpers - typeof";
@@ -149471,7 +149485,7 @@ function formatBlock(block) {
 function extractCommitHashes(text) {
   const hashes = [];
   const seen = new Set;
-  for (const match of text.matchAll(COMMIT_HASH_PATTERN)) {
+  for (const match of text.matchAll(createCommitHashExtractPattern())) {
     const hash2 = match[1]?.toLowerCase();
     if (!hash2 || seen.has(hash2))
       continue;
@@ -149484,10 +149498,10 @@ function extractCommitHashes(text) {
 }
 function compactTextForSummary(text, role) {
   const commitHashes = role === "assistant" ? extractCommitHashes(text) : [];
-  if (commitHashes.length === 0 || !COMMIT_HINT_PATTERN.test(text)) {
+  if (commitHashes.length === 0 || !COMMIT_VERB_PATTERN.test(text)) {
     return { text, commitHashes };
   }
-  const withoutHashes = text.replace(COMMIT_HASH_PATTERN, "").replace(/\(\s*\)/g, "").replace(/\s+,/g, ",").replace(/,\s*,+/g, ", ").replace(/\s{2,}/g, " ").replace(/\s+([,.;:])/g, "$1").trim();
+  const withoutHashes = text.replace(createCommitHashExtractPattern(), "").replace(/\(\s*\)/g, "").replace(/\s+,/g, ",").replace(/,\s*,+/g, ", ").replace(/\s{2,}/g, " ").replace(/\s+([,.;:])/g, "$1").trim();
   return {
     text: withoutHashes.length > 0 ? withoutHashes : text,
     commitHashes
@@ -149506,12 +149520,11 @@ function mergeCommitHashes(existing, next) {
   }
   return merged;
 }
-var COMMIT_HASH_PATTERN, COMMIT_HINT_PATTERN, MAX_COMMITS_PER_BLOCK = 5, tokenizer;
+var MAX_COMMITS_PER_BLOCK = 5, tokenizer;
 var init_read_session_formatting = __esm(() => {
+  init_commit_detection();
   init_dist();
   init_claude();
-  COMMIT_HASH_PATTERN = /`?\b([0-9a-f]{6,12})\b`?/gi;
-  COMMIT_HINT_PATTERN = /\b(commit(?:ted)?|cherry-?pick(?:ed)?|hash(?:es)?|sha)\b/i;
   tokenizer = new src_default(exports_claude);
 });
 
@@ -149818,6 +149831,37 @@ var init_tag_part_guards = __esm(() => {
   init_tag_content_primitives();
 });
 
+// src/hooks/magic-context/edit-marker.ts
+function safeSlice(str, maxLen) {
+  if (str.length <= maxLen)
+    return str;
+  const lastCharCode = str.charCodeAt(maxLen - 1);
+  if (lastCharCode >= 55296 && lastCharCode <= 56319) {
+    return str.slice(0, maxLen - 1);
+  }
+  return str.slice(0, maxLen);
+}
+function isEditTool(name2) {
+  return name2 === "edit" || name2 === "write";
+}
+function applyEditMarkerToInput(input) {
+  for (const key of Object.keys(input)) {
+    if (PATH_KEYS.has(key))
+      continue;
+    const value = input[key];
+    if (typeof value !== "string" || !DIFF_KEYS.has(key))
+      continue;
+    if (value.endsWith(TRUNCATION_SENTINEL))
+      continue;
+    input[key] = value.length > EDIT_REGION_HINT_LEN ? `${safeSlice(value, EDIT_REGION_HINT_LEN)}${TRUNCATION_SENTINEL}` : value;
+  }
+}
+var TRUNCATION_SENTINEL = "...[truncated]", EDIT_REGION_HINT_LEN = 40, PATH_KEYS, DIFF_KEYS;
+var init_edit_marker = __esm(() => {
+  PATH_KEYS = new Set(["filePath", "file_path", "path"]);
+  DIFF_KEYS = new Set(["oldString", "newString", "content", "old_string", "new_string"]);
+});
+
 // src/hooks/magic-context/tool-drop-target.ts
 function isToolCallId(value) {
   return typeof value === "string" && value.length > 0;
@@ -149884,7 +149928,41 @@ function estimateInputSize(input) {
     return 0;
   }
 }
-function safeSlice(str, maxLen) {
+function editMarkerToolPart(part, tagId) {
+  if (!isRecord(part))
+    return;
+  const sentinel = `[dropped §${tagId}§]`;
+  if (part.type === "tool" && isRecord(part.state)) {
+    part.state.output = sentinel;
+    if (isRecord(part.state.input))
+      applyEditMarkerToInput(part.state.input);
+    return;
+  }
+  if (part.type === "tool_result") {
+    part.content = sentinel;
+    return;
+  }
+  if (part.type === "tool-invocation" && isRecord(part.args)) {
+    applyEditMarkerToInput(part.args);
+    return;
+  }
+  if (part.type === "tool_use" && isRecord(part.input)) {
+    applyEditMarkerToInput(part.input);
+  }
+}
+function readToolPartInput(part) {
+  if (!isRecord(part))
+    return null;
+  if (part.type === "tool" && isRecord(part.state) && isRecord(part.state.input)) {
+    return part.state.input;
+  }
+  if (part.type === "tool-invocation" && isRecord(part.args))
+    return part.args;
+  if (part.type === "tool_use" && isRecord(part.input))
+    return part.input;
+  return null;
+}
+function safeSlice2(str, maxLen) {
   if (str.length <= maxLen)
     return str;
   const lastCharCode = str.charCodeAt(maxLen - 1);
@@ -149897,9 +149975,9 @@ function truncateInputValues(input) {
   for (const key of Object.keys(input)) {
     const value = input[key];
     if (typeof value === "string") {
-      if (value.endsWith(TRUNCATION_SENTINEL) || value === "[object]" || /^\[\d+ items\]$/.test(value))
+      if (value.endsWith(TRUNCATION_SENTINEL2) || value === "[object]" || /^\[\d+ items\]$/.test(value))
         continue;
-      input[key] = value.length > 5 ? `${safeSlice(value, 5)}${TRUNCATION_SENTINEL}` : value;
+      input[key] = value.length > 5 ? `${safeSlice2(value, 5)}${TRUNCATION_SENTINEL2}` : value;
     } else if (Array.isArray(value)) {
       input[key] = `[${value.length} items]`;
     } else if (value !== null && typeof value === "object") {
@@ -150003,6 +150081,18 @@ function createToolDropTarget(compositeKey, thinkingParts, index, batch, tagId)
     clearThinkingParts(thinkingParts);
     return "truncated";
   };
+  const editMarker = () => {
+    const entry = index.get(compositeKey);
+    if (!entry || entry.occurrences.length === 0)
+      return "absent";
+    if (!entry.hasResult)
+      return "incomplete";
+    for (const occurrence of entry.occurrences) {
+      editMarkerToolPart(occurrence.part, tagId);
+    }
+    clearThinkingParts(thinkingParts);
+    return "truncated";
+  };
   return {
     setContent: (content) => {
       if (isDropContent(content)) {
@@ -150026,14 +150116,34 @@ function createToolDropTarget(compositeKey, thinkingParts, index, batch, tagId)
     },
     drop,
     truncate,
+    editMarker,
     canDrop: () => {
       const entry = index.get(compositeKey);
       return !!entry && entry.occurrences.length > 0 && entry.hasResult;
+    },
+    readInput: () => {
+      const entry = index.get(compositeKey);
+      if (!entry)
+        return null;
+      for (const occurrence of entry.occurrences) {
+        if (occurrence.kind !== "invocation")
+          continue;
+        const input = readToolPartInput(occurrence.part);
+        if (input)
+          return input;
+      }
+      for (const occurrence of entry.occurrences) {
+        const input = readToolPartInput(occurrence.part);
+        if (input)
+          return input;
+      }
+      return null;
     }
   };
 }
-var DROP_PREFIX = "[dropped", IGNORE_PART_TYPES, TRUNCATION_SENTINEL = "...[truncated]";
+var DROP_PREFIX = "[dropped", IGNORE_PART_TYPES, TRUNCATION_SENTINEL2 = "...[truncated]";
 var init_tool_drop_target = __esm(() => {
+  init_edit_marker();
   init_tag_content_primitives();
   IGNORE_PART_TYPES = new Set([
     "thinking",
@@ -155975,7 +156085,7 @@ function toTagEntry(row) {
     messageId: row.message_id,
     type,
     status,
-    dropMode: row.drop_mode === "truncated" ? "truncated" : "full",
+    dropMode: row.drop_mode === "truncated" ? "truncated" : row.drop_mode === "edit_marker" ? "edit_marker" : "full",
     toolName: row.tool_name ?? null,
     inputByteSize: row.input_byte_size ?? 0,
     byteSize: row.byte_size,
@@ -186528,12 +186638,12 @@ function shouldShowAnnouncement() {
   }
   return ordering > 0;
 }
-var ANNOUNCEMENT_VERSION = "0.28.0", ANNOUNCEMENT_FEATURES, ANNOUNCEMENT_FOOTER = "Join us on Discord: https://discord.gg/F2uWxjGnU", STATE_FILENAME = "last_announced_version";
+var ANNOUNCEMENT_VERSION = "0.29.0", ANNOUNCEMENT_FEATURES, ANNOUNCEMENT_FOOTER = "Join us on Discord: https://discord.gg/F2uWxjGnU", STATE_FILENAME = "last_announced_version";
 var init_announcement = __esm(() => {
   init_data_path();
   ANNOUNCEMENT_FEATURES = [
-    `New 'language' option: set a top-level 2-letter language code (e.g. "tr" or "es") and Magic Context writes its summaries, memories, and guidance in that language, while keeping all structure (tags, categories, code, paths) in English. User-level only, off by default.`,
-    "The ctx_reduce reminder now reflects how much tool output is actually reclaimable, instead of escalating to 'urgent' just because you're near compaction. It also no longer suggests dropping the agent's task list or tiny status outputs."
+    `New 'smart_drops' option (opt-in, off by default): on long, edit-heavy sessions it reclaims more context by dropping tool output a later call made obsolete (superseded edits, old todowrite/ctx_reduce, spent status calls) instead of only the oldest. When off, the prompt is byte-identical to before. Enable with "smart_drops": true.`,
+    "When memory is disabled, the ctx_memory tool and its guidance are no longer shown (they had nothing to write to). ctx_search stays, searching conversation history and git commits."
   ];
 });
 
@@ -188141,6 +188251,7 @@ var MAINTAIN_DOCS_SYSTEM_PROMPT = `You are a documentation maintainer for the ma
 
 ## Rules
 - **NEVER touch protected regions.** Any content between \`<!-- mc:protected START ... -->\` and \`<!-- mc:protected END -->\` is hand-authored and cache-critical. Reproduce it BYTE-FOR-BYTE — do not edit, reword, reorder, summarize, trim, or drop a single line, and keep the marker comments. Only a human edits that region.
+- **Preserve an existing doc's structure, voice, and density.** When a doc already exists, it is the source of truth for shape: keep its headings, ordering, level of detail, and writing style. Make the SMALLEST edits that bring it back in sync with the code. NEVER reshape hand-written prose into a generic template, collapse a dense section into bullet stubs, or drop hard-won detail (specific invariants, edge cases, mechanism descriptions) because it does not fit a standard layout. A doc denser and more specific than a template is BETTER, not worse: leave it that way.
 - **Be prescriptive** ("Use X pattern", not "X pattern is used"). **Current state only** — no temporal language, no history.
 - **Verify before writing** — read the actual files, never guess. All file paths in the docs must point to files that exist.`;
 var REVIEW_USER_MEMORIES_SYSTEM_PROMPT = `You are a user-profile reviewer for the magic-context system. You run during a scheduled dream window to decide which recurring behavioral observations about the human user are real, persistent patterns worth keeping in their global user profile.
@@ -188256,7 +188367,7 @@ Return only XML in this exact shape:
 function buildMaintainDocsPrompt(projectPath, lastDreamAt, existingDocs) {
   const hasAny = existingDocs.architecture || existingDocs.structure;
   const gitSinceClause = lastDreamAt ? `Run \`git log --oneline --since="${new Date(Number(lastDreamAt)).toISOString()}"\` to see what changed since the last dream.` : "No previous dream timestamp — treat this as a full analysis.";
-  const modeIntro = hasAny ? `Some docs already exist. Update only the sections affected by recent changes. Do NOT rewrite unchanged sections.` : `No docs exist yet. Create both ARCHITECTURE.md and STRUCTURE.md from scratch using the templates below.`;
+  const modeIntro = hasAny ? `Some docs already exist and are the source of truth for shape. Make SURGICAL \`edit\` changes to only the sections affected by recent code changes; preserve every other section, the existing structure, and the existing density verbatim. Do NOT regenerate a whole file, do NOT reshape prose into a template, and do NOT use the templates below (they are for creation only). If nothing material changed, change nothing.` : `No docs exist yet. Create both ARCHITECTURE.md and STRUCTURE.md from scratch using the templates below as a STARTING shape, then go deeper than the template wherever the code warrants it.`;
   return `## Task: Maintain Codebase Documentation
 
 **Project:** ${projectPath}
@@ -188271,15 +188382,16 @@ ${modeIntro}
 ### Process
 
 1. **Check what changed.** ${gitSinceClause}
-2. **Read existing docs** (if they exist) to understand current state.
+2. **Read existing docs** (if they exist) IN FULL to understand their current structure, depth, and voice; you will preserve all of it except what code changes force you to touch.
 3. **Explore the codebase** to verify and update:
    - Directory structure: \`find . -type d -not -path '*/node_modules/*' -not -path '*/.git/*' -not -path '*/dist/*' | head -60\`
    - Entry points: \`ls src/index.* src/main.* 2>/dev/null\`
    - Key imports: \`grep -r "^import\\|^export" src/ --include="*.ts" | head -80\`
-4. **Write or update** using the Write tool. Always write to project root, NOT to .planning/.
+4. **Apply the change.** If the doc EXISTS: use \`edit\` for the specific sections that drifted, never rewrite the whole file with \`write\`. If the doc is MISSING: create it with \`write\`. Always at project root, NOT \`.planning/\`.
 
 ### Rules
 - **NEVER touch protected regions**: any content between \`<!-- mc:protected START ... -->\` and \`<!-- mc:protected END -->\` is hand-authored and cache-critical. Reproduce it BYTE-FOR-BYTE in your rewrite — do not edit, reword, reorder, summarize, trim, or drop a single line of it, and keep the marker comments themselves. Only a human edits that region.
+- **Preserve existing structure and density**: when a doc exists, keep its headings, ordering, level of detail, and voice. Make the smallest edits that re-sync it with the code. NEVER flatten dense hand-written prose into the generic template, collapse a detailed section into bullet stubs, or drop specific invariants/edge-cases/mechanism detail because it does not match a standard layout. Denser and more specific than the template is BETTER.
 - **Be prescriptive**: "Use X pattern" not "X pattern is used"
 - **Always include file paths** in backticks
 - **Write current state only**: no temporal language, no history
@@ -191259,10 +191371,23 @@ function getAsyncModule() {
   asyncModulePromise ??= newQuickJSAsyncWASMModuleFromVariant(import_quickjs_singlefile_cjs_release_asyncify.default);
   return asyncModulePromise;
 }
+var sandboxRunChain = Promise.resolve();
+function withSandboxLock(fn) {
+  const run = sandboxRunChain.then(fn, fn);
+  sandboxRunChain = run.then(() => {
+    return;
+  }, () => {
+    return;
+  });
+  return run;
+}
 var DEFAULT_TIMEOUT_MS = 2000;
 var DEFAULT_HEAP_LIMIT_BYTES = 8 * 1024 * 1024;
 var DEFAULT_STACK_LIMIT_BYTES = 512 * 1024;
 async function runCompiledSmartNoteCheck(options) {
+  return withSandboxLock(() => runCompiledSmartNoteCheckLocked(options));
+}
+async function runCompiledSmartNoteCheckLocked(options) {
   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const controller = new AbortController;
   const externalAbort = () => controller.abort(options.signal?.reason);
@@ -198717,7 +198842,7 @@ var RECENT_TOOL_SKELETON_WINDOW = 20;
 function buildReplacementContent(tagId) {
   return `[dropped §${tagId}§]`;
 }
-function applyPendingOperations(sessionId, db, targets, protectedTags = 0, preloadedTags, preloadedPendingOps, syntheticPendingOps = []) {
+function applyPendingOperations(sessionId, db, targets, protectedTags = 0, preloadedTags, preloadedPendingOps, syntheticPendingOps = [], editMarkerTagIds = new Set) {
   let didMutateMessage = false;
   db.transaction(() => {
     const tags = preloadedTags ?? getTagsBySession(db, sessionId);
@@ -198748,7 +198873,15 @@ function applyPendingOperations(sessionId, db, targets, protectedTags = 0, prelo
       }
       let shouldPersistDrop = false;
       if (isToolTag) {
-        if (skeletonWindow.has(pendingOp.tagId)) {
+        if (editMarkerTagIds.has(pendingOp.tagId)) {
+          const markResult = target?.editMarker?.() ?? "absent";
+          if (markResult === "incomplete" || markResult === "absent") {
+            continue;
+          }
+          didMutateMessage = true;
+          updateTagDropMode(db, sessionId, pendingOp.tagId, "edit_marker");
+          shouldPersistDrop = true;
+        } else if (skeletonWindow.has(pendingOp.tagId)) {
           const truncResult = target?.truncate?.() ?? "absent";
           if (truncResult === "incomplete" || synthetic && truncResult !== "truncated") {
             continue;
@@ -198793,7 +198926,12 @@ function applyFlushedStatuses(sessionId, db, targets, preloadedTags) {
     if (tag.status === "dropped") {
       const target = targets.get(tag.tagNumber);
       if (tag.type === "tool") {
-        if (tag.dropMode === "truncated") {
+        if (tag.dropMode === "edit_marker") {
+          const markResult = target?.editMarker?.() ?? "absent";
+          if (markResult === "truncated") {
+            didMutateMessage = true;
+          }
+        } else if (tag.dropMode === "truncated") {
           const truncResult = target?.truncate?.() ?? "absent";
           if (truncResult === "truncated") {
             didMutateMessage = true;
@@ -198848,6 +198986,7 @@ function stripStructuralNoise(messages) {
 // src/hooks/magic-context/tag-messages.ts
 init_storage_tags();
 await init_storage();
+init_commit_detection();
 // src/hooks/magic-context/drop-stale-reduce-calls.ts
 var STALE_TOOL_NAMES = new Set(["ctx_reduce"]);
 function isReduceToolPart(part) {
@@ -199168,7 +199307,6 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
   let lastReduceMessageIndex = -1;
   const RECENT_REDUCE_LOOKBACK = 10;
   const COMMIT_LOOKBACK = 5;
-  const COMMIT_HASH_PATTERN2 = /\b[0-9a-f]{7,12}\b/;
   let commitDetected = false;
   let accDerive = 0;
   let accGetToolTag = 0;
@@ -199359,7 +199497,7 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
       for (const part of message.parts) {
         if (isTextPart(part)) {
           const text = part.text;
-          if (COMMIT_HASH_PATTERN2.test(text) && /\b(commit|committed|cherry-pick|merge|rebas)/i.test(text)) {
+          if (textMentionsRecentCommit(text)) {
             commitDetected = true;
             break;
           }
@@ -200854,6 +200992,99 @@ function isVisibleNoteReadPart(part) {
   return false;
 }
 
+// src/hooks/magic-context/supersession-reclaim.ts
+init_edit_marker();
+await init_storage();
+var TODOWRITE_KEEP = 1;
+var CTX_REDUCE_KEEP = 5;
+var ZERO_VALUE_META_TOOLS = new Set(["bash_status", "bash_kill"]);
+var CTX_NOTE_ZERO_VALUE_ACTIONS = new Set(["read", "dismiss"]);
+function buildSupersessionReclaimOps(input) {
+  const realPendingTagIds = new Set((input.pendingOps ?? []).map((op) => op.tagId));
+  const tags = getActiveTagsBySession(input.db, input.sessionId);
+  const toolTags = tags.filter((tag) => tag.type === "tool" && tag.status === "active").sort((left, right) => right.tagNumber - left.tagNumber);
+  const dropTagIds = [];
+  let todowriteSeen = 0;
+  let ctxReduceSeen = 0;
+  for (const tag of toolTags) {
+    const name2 = tag.toolName;
+    if (!name2)
+      continue;
+    let isTarget = false;
+    if (name2 === "todowrite") {
+      todowriteSeen += 1;
+      isTarget = todowriteSeen > TODOWRITE_KEEP;
+    } else if (name2 === "ctx_reduce") {
+      ctxReduceSeen += 1;
+      isTarget = ctxReduceSeen > CTX_REDUCE_KEEP;
+    } else if (ZERO_VALUE_META_TOOLS.has(name2)) {
+      isTarget = true;
+    } else if (name2 === "ctx_note") {
+      const action = input.targets.get(tag.tagNumber)?.readInput?.()?.action;
+      isTarget = typeof action === "string" && CTX_NOTE_ZERO_VALUE_ACTIONS.has(action);
+    }
+    if (isTarget)
+      dropTagIds.push(tag.tagNumber);
+  }
+  const synthetic = [];
+  for (const tagId of dropTagIds) {
+    if (realPendingTagIds.has(tagId))
+      continue;
+    if (input.targets.get(tagId)?.canDrop?.() !== true)
+      continue;
+    synthetic.push({
+      id: 0,
+      sessionId: input.sessionId,
+      tagId,
+      operation: "drop",
+      queuedAt: 0
+    });
+  }
+  return synthetic;
+}
+function buildEditSupersessionReclaim(input) {
+  const realPendingTagIds = new Set((input.pendingOps ?? []).map((op) => op.tagId));
+  const tags = getActiveTagsBySession(input.db, input.sessionId);
+  const editTags = tags.filter((tag) => tag.type === "tool" && tag.status === "active" && isEditTool(tag.toolName)).sort((left, right) => right.tagNumber - left.tagNumber);
+  const seenFile = new Set;
+  const ops = [];
+  const editMarkerTagIds = new Set;
+  for (const tag of editTags) {
+    const filePath = readFilePath(input.targets.get(tag.tagNumber));
+    if (!filePath)
+      continue;
+    if (!seenFile.has(filePath)) {
+      seenFile.add(filePath);
+      continue;
+    }
+    if (realPendingTagIds.has(tag.tagNumber))
+      continue;
+    if (input.targets.get(tag.tagNumber)?.canDrop?.() !== true)
+      continue;
+    editMarkerTagIds.add(tag.tagNumber);
+    ops.push({
+      id: 0,
+      sessionId: input.sessionId,
+      tagId: tag.tagNumber,
+      operation: "drop",
+      queuedAt: 0
+    });
+  }
+  return { ops, editMarkerTagIds };
+}
+var FILE_PATH_KEYS = ["filePath", "file_path", "path"];
+function readFilePath(target) {
+  const input = target?.readInput?.();
+  if (!input)
+    return null;
+  for (const key of FILE_PATH_KEYS) {
+    const value = input[key];
+    if (typeof value === "string" && value.length > 0)
+      return value;
+  }
+  return null;
+}
+
 // src/hooks/magic-context/todo-view.ts
 import { createHash as createHash12 } from "node:crypto";
 var TERMINAL_STATUSES = new Set(["completed", "cancelled"]);
@@ -201124,9 +201355,38 @@ async function runPostTransformPhase(args) {
         watermark: args.sessionMeta.toolReclaimWatermark ?? 0,
         pendingOps
       });
+      const editMarkerTagIds = new Set;
+      if (args.smartDrops) {
+        const selectedIds = new Set(syntheticPendingOps.map((op) => op.tagId));
+        const supersessionOps = buildSupersessionReclaimOps({
+          db: args.db,
+          sessionId: args.sessionId,
+          targets: args.targets,
+          pendingOps
+        });
+        for (const op of supersessionOps) {
+          if (!selectedIds.has(op.tagId)) {
+            syntheticPendingOps.push(op);
+            selectedIds.add(op.tagId);
+          }
+        }
+        const editReclaim = buildEditSupersessionReclaim({
+          db: args.db,
+          sessionId: args.sessionId,
+          targets: args.targets,
+          pendingOps
+        });
+        for (const op of editReclaim.ops) {
+          if (!selectedIds.has(op.tagId)) {
+            syntheticPendingOps.push(op);
+            selectedIds.add(op.tagId);
+            editMarkerTagIds.add(op.tagId);
+          }
+        }
+      }
       autoReclaimTargetCount = syntheticPendingOps.length;
       if (syntheticPendingOps.length > 0) {
-        autoReclaimDidMutate = applyPendingOperations(args.sessionId, args.db, args.targets, args.protectedTags, undefined, [], syntheticPendingOps);
+        autoReclaimDidMutate = applyPendingOperations(args.sessionId, args.db, args.targets, args.protectedTags, undefined, [], syntheticPendingOps, editMarkerTagIds);
         if (autoReclaimDidMutate) {
           droppedCount += syntheticPendingOps.length;
           autoReclaimDidMutateThisPass = true;
@@ -202068,6 +202328,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       sessionDirectory,
       autoSearch: deps.autoSearch,
       cavemanTextCompression: deps.ctxReduceEnabled === false && !reducedMode ? deps.cavemanTextCompression : undefined,
+      smartDrops: deps.smartDrops === true,
       resolvedProviderID,
       historyRefreshSessions: deps.historyRefreshSessions,
       m0M1: {
@@ -202983,16 +203244,20 @@ var PARTNER_FRAME_CLOSER_NO_REDUCE = `
 Context is managed for you entirely automatically — there's nothing to prune and no warnings to act on. Stay reasonably concise per operation, and never let context size change *what* work you take on or *how thoroughly* you do it.`;
 var CTX_NOTE_GUIDANCE = `Use \`ctx_note\` ONLY for genuinely future concerns — something to revisit much later, not work coming up in the next few turns (that's already in your active context) and not active multi-step work (use todos for that). Magic Context preserves your full context across both compaction and restarts, so an upcoming restart or "let's come back to this later" is never a reason to take a note — nothing is lost either way. Notes you do take survive compression and resurface at natural work boundaries (after commits, historian runs, todo completion).`;
 var TOOL_HISTORY_GUIDANCE = `Compressed history intentionally omits tool calls and their outputs — summaries like "I edited file X" are historian records, not patterns to replicate. In the live conversation, older tool calls and their results are cleaned up to save context — you may see your own past messages referencing actions without the corresponding tool call or result visible. This is normal context management. ALWAYS use real tool calls; never simulate, fabricate, or inline tool outputs in your text. If there is no tool result message, the action did not happen. NEVER simulate, hallucinate or claim tool calls, command output, search results, file edits, or diffs in plain text as if they actually occurred.`;
-var BASE_INTRO = (protectedTags) => `Messages and tool outputs are tagged with §N§ identifiers (e.g., §1§, §42§).
-Use \`ctx_reduce\` to mark spent tagged content as discardable and reclaim space. Marking is NOT an immediate delete — it queues the content, which stays fully visible until space is actually needed (as soon as the next turn if you're already under pressure, much later if not), so mark a tool output as soon as you're done with it rather than hoarding the call for the end of the turn. The last ${protectedTags} tags are protected (marking one just queues it until it ages out). Syntax: "3-5", "1,2,9", or "1-5,8,12-15".
-Do not announce or narrate \`ctx_reduce\` drops — just call the tool silently. Saying "I'll drop these outputs" wastes tokens the user does not care about.
-${CTX_NOTE_GUIDANCE}
-Use \`ctx_memory\` for durable project knowledge: write what future sessions must know, update/archive/merge the memories you see in \`<project-memory>\` when they drift. Memories persist across sessions and every new session starts with them.
+var MEMORY_GUIDANCE = `Use \`ctx_memory\` for durable project knowledge: write what future sessions must know, update/archive/merge the memories you see in \`<project-memory>\` when they drift. Memories persist across sessions and every new session starts with them.
 **Save to memory proactively**: If you spent multiple turns finding something (a file path, a DB location, a config pattern, a workaround), save it with \`ctx_memory\` so future sessions don't repeat the search. Examples:
 - Found a project's source code path after searching → \`ctx_memory(action="write", category="CONFIG_VALUES", content="OpenCode source is at ~/Work/OSS/opencode")\`
 - Discovered a non-obvious build/test command → \`ctx_memory(action="write", category="PROJECT_RULES", content="Always use scripts/release.sh for releases")\`
-- Learned a constraint the hard way → \`ctx_memory(action="write", category="CONSTRAINTS", content="Dashboard Tauri build needs RGBA PNGs, not grayscale")\`
-Use \`ctx_search\` to search across project memories, indexed git commits, and this session's full conversation history (including compacted parts) from one query.
+- Learned a constraint the hard way → \`ctx_memory(action="write", category="CONSTRAINTS", content="Dashboard Tauri build needs RGBA PNGs, not grayscale")\``;
+function memoryGuidanceBlock(memoryEnabled) {
+  return memoryEnabled ? `${MEMORY_GUIDANCE}
+` : "";
+}
+var BASE_INTRO = (protectedTags, memoryEnabled) => `Messages and tool outputs are tagged with §N§ identifiers (e.g., §1§, §42§).
+Use \`ctx_reduce\` to mark spent tagged content as discardable and reclaim space. Marking is NOT an immediate delete — it queues the content, which stays fully visible until space is actually needed (as soon as the next turn if you're already under pressure, much later if not), so mark a tool output as soon as you're done with it rather than hoarding the call for the end of the turn. The last ${protectedTags} tags are protected (marking one just queues it until it ages out). Syntax: "3-5", "1,2,9", or "1-5,8,12-15".
+Do not announce or narrate \`ctx_reduce\` drops — just call the tool silently. Saying "I'll drop these outputs" wastes tokens the user does not care about.
+${CTX_NOTE_GUIDANCE}
+${memoryGuidanceBlock(memoryEnabled)}Use \`ctx_search\` to search across project memories, indexed git commits, and this session's full conversation history (including compacted parts) from one query.
 Use \`ctx_expand\` to recover the raw conversation behind a \`<compartment>\` summary in \`<session-history>\` — pass its \`start\`/\`end\` attributes when the summary is not enough (exact wording, values, error text).
 **Search before asking the user**: If you can't remember or don't know something that might have been discussed before or stored in project memory, use \`ctx_search\` before asking the user. Examples:
 - Can't remember where a related codebase or dependency lives → \`ctx_search(query="opencode source code path")\`
@@ -203006,13 +203271,8 @@ NEVER drop large ranges blindly (e.g., "1-50"). Review each tag before deciding.
 Keep your user's instructions and intent — never drop a user message for its directive, even an old one. But a large block of pasted content inside a user message (logs, data dumps, long code, attachments) is fair to mark discardable once you've extracted what you need — it stays searchable via \`ctx_search\`.
 NEVER drop assistant text messages unless they are exceptionally large. Your conversation messages are lightweight; only large tool outputs are worth dropping.
 Before your turn finishes, consider using \`ctx_reduce\` to drop large tool outputs you no longer need.`;
-var BASE_INTRO_NO_REDUCE = () => `${CTX_NOTE_GUIDANCE}
-Use \`ctx_memory\` for durable project knowledge: write what future sessions must know, update/archive/merge the memories you see in \`<project-memory>\` when they drift. Memories persist across sessions and every new session starts with them.
-**Save to memory proactively**: If you spent multiple turns finding something (a file path, a DB location, a config pattern, a workaround), save it with \`ctx_memory\` so future sessions don't repeat the search. Examples:
-- Found a project's source code path after searching → \`ctx_memory(action="write", category="CONFIG_VALUES", content="OpenCode source is at ~/Work/OSS/opencode")\`
-- Discovered a non-obvious build/test command → \`ctx_memory(action="write", category="PROJECT_RULES", content="Always use scripts/release.sh for releases")\`
-- Learned a constraint the hard way → \`ctx_memory(action="write", category="CONSTRAINTS", content="Dashboard Tauri build needs RGBA PNGs, not grayscale")\`
-Use \`ctx_search\` to search across project memories, indexed git commits, and this session's full conversation history (including compacted parts) from one query.
+var BASE_INTRO_NO_REDUCE = (memoryEnabled) => `${CTX_NOTE_GUIDANCE}
+${memoryGuidanceBlock(memoryEnabled)}Use \`ctx_search\` to search across project memories, indexed git commits, and this session's full conversation history (including compacted parts) from one query.
 Use \`ctx_expand\` to recover the raw conversation behind a \`<compartment>\` summary in \`<session-history>\` — pass its \`start\`/\`end\` attributes when the summary is not enough (exact wording, values, error text).
 **Search before asking the user**: If you can't remember or don't know something that might have been discussed before or stored in project memory, use \`ctx_search\` before asking the user. Examples:
 - Can't remember where a related codebase or dependency lives → \`ctx_search(query="opencode source code path")\`
@@ -203046,7 +203306,7 @@ Drop silently — do not narrate it. NEVER drop large ranges blindly (e.g., "1-5
 Older tool calls may show \`[dropped §N§]\` sentinels; that is normal context management, not a pattern to copy. ALWAYS make fresh real tool calls when you need data again; never fabricate or inline tool output.`;
 var CAVEMAN_COMPRESSION_WARNING = `
 **BEWARE**: History compression is on; older user AND assistant text — including your own earlier responses — has been deterministically rewritten in a terse caveman style (dropped articles, missing auxiliaries, \`//\` instead of connectives like \`because\`). This is automatic context compression that runs after the fact, not your actual prior wording or the user's. **DO NOT mimic this style in new turns.** Write fresh responses in normal prose. If you notice your output drifting into caveman cadence, that drift is in-context-learning bleeding from the compressed history — consciously revert to full sentences.`;
-function buildMagicContextSection(_agent, protectedTags, ctxReduceEnabled = true, dreamerEnabled = false, temporalAwarenessEnabled = false, cavemanTextCompressionEnabled = false, subagentMode = false, language) {
+function buildMagicContextSection(_agent, protectedTags, ctxReduceEnabled = true, dreamerEnabled = false, temporalAwarenessEnabled = false, cavemanTextCompressionEnabled = false, subagentMode = false, language, memoryEnabled = true) {
   if (subagentMode) {
     return `## Magic Context
 
@@ -203068,14 +203328,14 @@ ${languageDirective}` : "";
 ${LONG_TERM_PARTNER_FRAME}
 ${PARTNER_FRAME_CLOSER_NO_REDUCE}
 
-${BASE_INTRO_NO_REDUCE()}${smartNoteGuidance}${temporalGuidance}${cavemanWarning}${languageGuidance}`;
+${BASE_INTRO_NO_REDUCE(memoryEnabled)}${smartNoteGuidance}${temporalGuidance}${cavemanWarning}${languageGuidance}`;
   }
   return `## Magic Context
 
 ${LONG_TERM_PARTNER_FRAME}
 ${PARTNER_FRAME_CLOSER_REDUCE}
 
-${BASE_INTRO(protectedTags)}${smartNoteGuidance}${temporalGuidance}
+${BASE_INTRO(protectedTags, memoryEnabled)}${smartNoteGuidance}${temporalGuidance}
 ${GENERIC_SECTION}
 
 Prefer many small targeted operations over one large blanket operation, and keep the working set tidy as routine maintenance.${languageGuidance}`;
@@ -203136,7 +203396,7 @@ function createSystemPromptHashHandler(deps) {
     const fullPrompt = output.system.join(`
 `);
     if (fullPrompt.length > 0 && !fullPrompt.includes(MAGIC_CONTEXT_MARKER) && !skipGuidanceForDisabledSubagent) {
-      const guidance = buildMagicContextSection(null, deps.protectedTags, effectiveCtxReduceEnabled, deps.dreamerEnabled, deps.experimentalTemporalAwareness, deps.experimentalCavemanTextCompression, subagentReduceMode, deps.language);
+      const guidance = buildMagicContextSection(null, deps.protectedTags, effectiveCtxReduceEnabled, deps.dreamerEnabled, deps.experimentalTemporalAwareness, deps.experimentalCavemanTextCompression, subagentReduceMode, deps.language, deps.memoryEnabled !== false);
       output.system.push(guidance);
       sessionLog(sessionId, `injected generic guidance into system prompt (ctxReduce=${effectiveCtxReduceEnabled}, subagent=${isSubagentSession}, subagentReduceMode=${subagentReduceMode})`);
     }
@@ -203574,6 +203834,7 @@ function createMagicContextHook(deps) {
     channel1StateBySession,
     protectedTags: deps.config.protected_tags,
     ctxReduceEnabled,
+    smartDrops: deps.config.smart_drops === true,
     clearReasoningAge: deps.config.clear_reasoning_age ?? 50,
     commitClusterTrigger: deps.config.commit_cluster_trigger,
     historyRefreshSessions,
@@ -203755,6 +204016,7 @@ function createMagicContextHook(deps) {
     protectedTags: deps.config.protected_tags,
     ctxReduceEnabled,
     dreamerEnabled: dreamerRunnable,
+    memoryEnabled: deps.config.memory?.enabled !== false,
     language: deps.config.language,
     injectDocs: deps.config.dreamer?.inject_docs !== false,
     directory: deps.directory,
@@ -206141,6 +206403,7 @@ function createToolRegistry(args) {
   ensureProjectRegisteredFromOpenCodeDirectory(ctx.directory, db);
   const resolveProjectPath = (directory) => resolveProjectIdentity(directory);
   const ctxReduceEnabled = pluginConfig.ctx_reduce_enabled !== false;
+  const memoryEnabled = pluginConfig.memory?.enabled !== false;
   const allTools = {
     ...ctxReduceEnabled ? createCtxReduceTools({
       db,
@@ -206157,12 +206420,12 @@ function createToolRegistry(args) {
       resolveProjectPath,
       ensureProjectRegistered: ensureProjectRegisteredFromOpenCodeDirectory
     }),
-    ...createCtxMemoryTools({
+    ...memoryEnabled ? createCtxMemoryTools({
       db,
       resolveProjectPath,
       ensureProjectRegistered: ensureProjectRegisteredFromOpenCodeDirectory,
       allowedActions: [...CTX_MEMORY_ACTIONS]
-    })
+    }) : {}
   };
   for (const toolDefinition of Object.values(allTools)) {
     normalizeToolArgSchemas(toolDefinition);

package/dist/plugin/hooks/create-session-hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-session-hooks.d.ts","sourceRoot":"","sources":["../../../src/plugin/hooks/create-session-hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAO7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8CAA8C,CAAC;AACrF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,YAAY,EAAE,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0BjF;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACrC,GAAG,EAAE,aAAa,CAAC;IACnB,YAAY,EAAE,wBAAwB,CAAC;IACvC,gBAAgB,EAAE,gBAAgB,CAAC;CACtC;;;;;;qBA+By6J,CAAC;;;;;;;;;;;;qBAAvsD,CAAC;mBAAyB,CAAC;iBAAuB,CAAC;iBAAuB,CAAC;0BAAc,CAAC;uBAAiB,CAAC;;;;;;0BAAmtmC,CAAC;;;;;;EADnitC"}
+{"version":3,"file":"create-session-hooks.d.ts","sourceRoot":"","sources":["../../../src/plugin/hooks/create-session-hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAO7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8CAA8C,CAAC;AACrF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,YAAY,EAAE,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0BjF;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACrC,GAAG,EAAE,aAAa,CAAC;IACnB,YAAY,EAAE,wBAAwB,CAAC;IACvC,gBAAgB,EAAE,gBAAgB,CAAC;CACtC;;;;;;qBA+BmvK,CAAC;;;;;;;;;;;;qBAAjhE,CAAC;mBAAyB,CAAC;iBAAuB,CAAC;iBAAuB,CAAC;0BAAc,CAAC;uBAAiB,CAAC;;;;;;0BAAggnC,CAAC;;;;;;EADh1tC"}

package/dist/plugin/tool-registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool-registry.d.ts","sourceRoot":"","sources":["../../src/plugin/tool-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,WAAW,CAAC;AAiB1D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACrC,GAAG,EAAE,aAAa,CAAC;IACnB,YAAY,EAAE,wBAAwB,CAAC;CAC1C,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAiFjC"}
+{"version":3,"file":"tool-registry.d.ts","sourceRoot":"","sources":["../../src/plugin/tool-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,WAAW,CAAC;AAiB1D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACrC,GAAG,EAAE,aAAa,CAAC;IACnB,YAAY,EAAE,wBAAwB,CAAC;CAC1C,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAyFjC"}