@cortexkit/pi-magic-context 0.42.4 → 0.42.6

package/dist/index.js

@@ -107,6 +107,7 @@ import {
   getNullOwnerToolTag,
   adoptNullOwnerToolTag,
   resolveOpenCodeDbPath,
+  assertOpenCodeStoreGeneration,
   openCodeDbPathExists,
   recordOpenCodeDbReadFailure,
   clearOpenCodeDbReadFailure,
@@ -385,6 +386,18 @@ import {
   getActiveUserMemories,
   updateUserMemoryContent,
   dismissUserMemory,
+  getTaskScheduleState,
+  getMostRecentTaskRunAt,
+  pruneNonCanonicalTaskRows,
+  deleteTaskScheduleRowsForProject,
+  seedTaskScheduleState,
+  writeTaskScheduleState,
+  isRetrospectiveWindowProcessed,
+  recordRetrospectiveWindowProcessed,
+  curateCategoryForMemoryCategory,
+  peekCurateCategoryScope,
+  beginCurateCategoryRun,
+  curateTaskStateAfterSuccess,
   formatSynapseLaneDescriptor,
   buildCanonicalChunkTextFromFts,
   buildCompartmentSummaryFallbackText,
@@ -464,7 +477,7 @@ import {
   registerTodoStateLifecycle,
   syncCtxMemoryToolEnabled,
   registerMagicContextTools
-} from "./index-pbkqtaac.js";
+} from "./index-r918mh6w.js";
 import {
   pushNotification2
 } from "./index-b3eqj1g6.js";
@@ -613,6 +626,9 @@ var DREAM_TASK_CAPABILITIES = {
 function formatDreamTaskBacklogs(backlogs, tasks = CANONICAL_DREAM_TASKS) {
   return tasks.filter((task) => backlogs[task] !== undefined).map((task) => {
     const backlog = backlogs[task];
+    if (task === "curate" && backlog?.category) {
+      return `- curate: ${backlog.category} (${backlog.pending})`;
+    }
     return `- ${task}: ${backlog?.pending ?? 0} pending / ${backlog?.total ?? 0} total`;
   }).join(`
 `);
@@ -1232,7 +1248,19 @@ async function runSessionProjectBackfill(db, source, options = {}) {
   let identityResolutionsSinceYield = 0;
   let afterSessionId = null;
   for (;; ) {
-    const sourcePage = await readPage(afterSessionId, SESSION_PAGE_SIZE);
+    let sourcePage;
+    try {
+      sourcePage = await readPage(afterSessionId, SESSION_PAGE_SIZE);
+    } catch (error) {
+      try {
+        if (!markBackfillRetryPending(db, harness, holderId, now())) {
+          log("[session-projects] backfill lease changed before failure cleanup");
+        }
+      } catch (releaseError) {
+        log(`[session-projects] failed to make backfill lease retryable after discovery failed: ${releaseError}`);
+      }
+      throw error;
+    }
     if (sourcePage.length === 0)
       break;
     afterSessionId = sourcePage.at(-1)?.sessionId ?? afterSessionId;
@@ -2360,70 +2388,6 @@ function backoffMs(failureCount) {
   return minutes * 60 * 1000;
 }
 
-// ../plugin/src/features/magic-context/dreamer/storage-task-schedule.ts
-function toRow(r) {
-  return {
-    projectPath: r.project_path,
-    task: r.task,
-    lastRunAt: r.last_run_at,
-    nextDueAt: r.next_due_at,
-    schedule: r.schedule ?? null,
-    lastStatus: r.last_status ?? null,
-    lastError: r.last_error,
-    retryCount: r.retry_count ?? 0,
-    lastCheckedCommit: r.last_checked_commit ?? null,
-    lastBroadRunAt: r.last_broad_run_at ?? null,
-    retrospectiveWatermarkMs: r.retrospective_watermark_ms ?? null
-  };
-}
-var SELECT_COLUMNS = "project_path, task, last_run_at, next_due_at, schedule, last_status, last_error, retry_count, last_checked_commit, last_broad_run_at, retrospective_watermark_ms";
-function getTaskScheduleState(db, projectPath, task) {
-  const row = db.prepare(`SELECT ${SELECT_COLUMNS} FROM task_schedule_state WHERE project_path = ? AND task = ?`).get(projectPath, task);
-  return row ? toRow(row) : null;
-}
-function getMostRecentTaskRunAt(db, projectPath) {
-  const row = db.prepare("SELECT MAX(last_run_at) AS max_at FROM task_schedule_state WHERE project_path = ?").get(projectPath);
-  const value = row?.max_at ?? null;
-  return typeof value === "number" && value > 0 ? value : null;
-}
-function pruneNonCanonicalTaskRows(db, projectPath, canonicalTasks) {
-  if (canonicalTasks.length === 0)
-    return 0;
-  const placeholders = canonicalTasks.map(() => "?").join(", ");
-  const result = db.prepare(`DELETE FROM task_schedule_state WHERE project_path = ? AND task NOT IN (${placeholders})`).run(projectPath, ...canonicalTasks);
-  return Number(result.changes ?? 0);
-}
-function deleteTaskScheduleRowsForProject(db, projectPath) {
-  const result = db.prepare("DELETE FROM task_schedule_state WHERE project_path = ?").run(projectPath);
-  return Number(result.changes ?? 0);
-}
-function seedTaskScheduleState(db, projectPath, task, nextDueAt, lastRunAt, schedule) {
-  db.prepare("INSERT INTO task_schedule_state (project_path, task, last_run_at, next_due_at, schedule, last_status, last_error, retry_count) VALUES (?, ?, ?, ?, ?, NULL, NULL, 0) ON CONFLICT(project_path, task) DO NOTHING").run(projectPath, task, lastRunAt, nextDueAt, schedule);
-}
-function writeTaskScheduleState(db, row) {
-  const broadCycleUpdate = row.lastBroadRunAt === undefined ? "last_broad_run_at = task_schedule_state.last_broad_run_at" : "last_broad_run_at = excluded.last_broad_run_at";
-  db.prepare(`INSERT INTO task_schedule_state
-           (project_path, task, last_run_at, next_due_at, schedule, last_status, last_error, retry_count, last_checked_commit, last_broad_run_at, retrospective_watermark_ms)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-         ON CONFLICT(project_path, task) DO UPDATE SET
-           last_run_at          = excluded.last_run_at,
-           next_due_at          = excluded.next_due_at,
-           schedule             = excluded.schedule,
-           last_status          = excluded.last_status,
-           last_error           = excluded.last_error,
-           retry_count          = excluded.retry_count,
-           last_checked_commit  = COALESCE(excluded.last_checked_commit, task_schedule_state.last_checked_commit),
-           ${broadCycleUpdate},
-           retrospective_watermark_ms = COALESCE(excluded.retrospective_watermark_ms, task_schedule_state.retrospective_watermark_ms)`).run(row.projectPath, row.task, row.lastRunAt, row.nextDueAt, row.schedule, row.lastStatus, row.lastError, row.retryCount, row.lastCheckedCommit ?? null, row.lastBroadRunAt ?? null, row.retrospectiveWatermarkMs ?? null);
-}
-function isRetrospectiveWindowProcessed(db, projectPath, windowKey) {
-  const row = db.prepare("SELECT 1 AS one FROM retrospective_processed_windows WHERE project_path = ? AND window_key = ?").get(projectPath, windowKey);
-  return row != null;
-}
-function recordRetrospectiveWindowProcessed(db, projectPath, windowKey) {
-  db.prepare("INSERT INTO retrospective_processed_windows (project_path, window_key, processed_at) VALUES (?, ?, ?) ON CONFLICT(project_path, window_key) DO NOTHING").run(projectPath, windowKey, Date.now());
-}
-
 // ../plugin/src/features/magic-context/dreamer/task-gates.ts
 function countActiveMemories(db, projectPath) {
   const row = db.prepare("SELECT COUNT(*) AS cnt FROM memories WHERE project_path = ? AND status IN ('active','permanent')").get(projectPath);
@@ -2431,12 +2395,13 @@ function countActiveMemories(db, projectPath) {
 }
 function countLiveMemories(db, projectPath, options = {}) {
   const unclassified = options.unclassifiedOnly && hasMemoryClassifiedAtColumn(db);
-  const row = db.prepare(`SELECT COUNT(*) AS cnt
-               FROM memories
-              WHERE project_path = ?
-                AND status IN ('active','permanent')
-                AND (expires_at IS NULL OR expires_at > ?)
-                ${unclassified ? "AND classified_at IS NULL" : ""}`).get(projectPath, Date.now());
+  const sql = `SELECT COUNT(*) AS cnt
+                   FROM memories
+                  WHERE project_path = ?
+                    AND status IN ('active','permanent')
+                    AND (expires_at IS NULL OR expires_at > ?)
+                    ${unclassified ? "AND classified_at IS NULL" : ""}`;
+  const row = options.category ? db.prepare(`${sql} AND category = ?`).get(projectPath, Date.now(), options.category) : db.prepare(sql).get(projectPath, Date.now());
   return row?.cnt ?? 0;
 }
 function countUnmappedActiveMemories(db, projectPath) {
@@ -2547,8 +2512,13 @@ function getDreamTaskBacklog(db, projectPath, task, options = {}) {
       return { pending, total };
     }
     case "curate": {
-      const total = countLiveMemories(db, projectPath);
-      return { pending: total, total };
+      const categories = db.prepare(`SELECT category FROM memories
+                      WHERE project_path = ?
+                        AND status IN ('active','permanent')
+                        AND (expires_at IS NULL OR expires_at > ?)`).all(projectPath, Date.now());
+      const scope = peekCurateCategoryScope(db, projectPath, categories);
+      const total = scope?.memories.length ?? 0;
+      return scope ? { pending: total, total, category: scope.category } : { pending: 0, total: 0 };
     }
     case "compress-cues": {
       const total = countLiveMemories(db, projectPath);
@@ -2887,6 +2857,12 @@ function openOpenCodeDb() {
   }
   try {
     const db = new Database(dbPath, { readonly: true });
+    try {
+      assertOpenCodeStoreGeneration(db, "v1", dbPath);
+    } catch (error) {
+      db.close();
+      throw error;
+    }
     db.exec("PRAGMA busy_timeout = 5000");
     clearOpenCodeDbReadFailure();
     return db;
@@ -6186,9 +6162,11 @@ function buildCuratePrompt(args) {
 
 **Project:** ${args.projectPath}
 
+This run covers the whole of the \`${args.category}\` category (the other categories run in later windows).
+
 The memories below are assumed ACCURATE (a separate verify task keeps them true). Your job is pool QUALITY: remove duplicates, tighten wording, and consolidate redundant entries that waste the ~6000-token injection budget. Explain each action in one line first. Do NOT mint new facts (that is the historian's job).
 
-Work ALL THREE phases below in order (A → B → C) over the whole pool. Do NOT stop after consolidating — a run that only merges and never improves or archives is incomplete.
+Work ALL THREE phases below in order (A → B → C) over this category. Do NOT stop after consolidating — a run that only merges and never improves or archives is incomplete.
 
 ### Phase A — Consolidate duplicates
 Group by category, then merge near-identical / superset-subset / same-fact-different-angle clusters into one canonical memory with \`ctx_memory(action="merge", ids=[...], content="...", category="...")\`. Preserve every unique detail; terse present tense; paths/keys verbatim. Every id in a merge MUST share the same category — the system rejects cross-category merges. If two similar memories sit in different categories they are NOT duplicates; do not archive either as a consolidation. One fact per memory.
@@ -6408,6 +6386,7 @@ function buildDreamTaskPrompt(task, args) {
     case "curate":
       return buildCuratePrompt({
         projectPath: args.projectPath,
+        category: args.curate?.category ?? "PROJECT_RULES",
         memories: args.curate?.memories ?? []
       });
     case "maintain-docs":
@@ -11210,6 +11189,7 @@ function createDreamTaskExecutor(deps) {
         processed: Math.max(0, processed),
         total: backlogAtStart.pending,
         startedAt,
+        ...backlogAtStart.category ? { category: backlogAtStart.category } : {},
         ...refused === undefined ? {} : { refused: Math.max(0, refused) }
       });
     };
@@ -11262,7 +11242,8 @@ function createDreamTaskExecutor(deps) {
                   totalAtStart: backlogAtStart.total,
                   pendingAtEnd: end.pending,
                   totalAtEnd: end.total,
-                  processed
+                  processed,
+                  ...backlogAtStart.category ? { category: backlogAtStart.category } : {}
                 };
                 return value;
               })()
@@ -11868,6 +11849,7 @@ async function runAgenticTask(config, ctx, helpers) {
   let expiredArchived = 0;
   try {
     let curateMemories;
+    let curateCategory;
     if (task === "curate") {
       expiredArchived = await archiveExpiredMemories({
         db,
@@ -11879,10 +11861,12 @@ async function runAgenticTask(config, ctx, helpers) {
       });
       if (leaseLost)
         throw new Error("Dream lease lost during expired-memory archive");
-      curateMemories = loadActiveMemoryPromptMemories(db, projectIdentity);
-      log(`[dreamer] curate pool: in_scope=${curateMemories.length} expired_archived=${expiredArchived}`);
-      if (curateMemories.length === 0 && expiredArchived > 0) {
-        const progress = formatExpiredArchiveProgress(expiredArchived);
+      const scope = beginCurateCategoryRun(db, projectIdentity, loadActiveMemoryPromptMemories(db, projectIdentity));
+      curateMemories = scope?.memories ?? [];
+      curateCategory = scope?.category;
+      log(`[dreamer] curate pool: category=${curateCategory ?? "none"} in_scope=${curateMemories.length} expired_archived=${expiredArchived}`);
+      if (curateMemories.length === 0) {
+        const progress = expiredArchived > 0 ? formatExpiredArchiveProgress(expiredArchived) : "curate: no populated project-memory category";
         helpers.recordRun("completed", null, {
           memoryChanges: helpers.computeMemoryDelta(memoryBefore),
           progress
@@ -11894,7 +11878,7 @@ async function runAgenticTask(config, ctx, helpers) {
       projectPath: projectIdentity,
       lastDreamAt: lastRunAt ? String(lastRunAt) : null,
       existingDocs,
-      curate: curateMemories ? { memories: curateMemories } : undefined
+      curate: curateMemories && curateCategory ? { category: curateCategory, memories: curateMemories } : undefined
     });
     const createResponse = await createChildSessionWithFence({
       client: requireDreamClient(deps.client),
@@ -11986,16 +11970,34 @@ async function runAgenticTask(config, ctx, helpers) {
       }
     }
     const curateOutput = task === "curate" ? run.validated : undefined;
+    const curateScopeProgress = task === "curate" && curateCategory && curateMemories ? `curate: ${curateCategory} (${curateMemories.length})` : null;
     const progress = [
+      curateScopeProgress,
       expiredArchived > 0 ? formatExpiredArchiveProgress(expiredArchived) : null,
       curateOutput && curateOutput.memoryOperations.completedActions.length > 0 ? formatCurateMemoryOperations(curateOutput.memoryOperations.completedActions) : null,
       curateRefused > 0 ? `curate: refused ${curateRefused} unsafe mutation(s)` : null
     ].filter((value) => Boolean(value)).join("; ");
+    const curateCount = task === "curate" && curateCategory ? loadActiveMemoryPromptMemories(db, projectIdentity).filter((memory) => curateCategoryForMemoryCategory(memory.category) === curateCategory).length : undefined;
+    const curateBacklog = curateCount !== undefined && curateCategory ? {
+      pending: curateCount,
+      total: curateCount,
+      category: curateCategory
+    } : undefined;
     helpers.recordRun("completed", null, {
       memoryChanges: helpers.computeMemoryDelta(memoryBefore),
-      progress: progress || null
+      progress: progress || null,
+      backlogAfter: curateBacklog
     });
-    return { status: "completed", ...progress ? { detail: progress } : {} };
+    return {
+      status: "completed",
+      ...progress ? { detail: progress } : {},
+      ...curateBacklog ? { backlog: curateBacklog } : {},
+      ...curateCategory ? {
+        schedulePatch: {
+          taskStateJson: curateTaskStateAfterSuccess(db, projectIdentity, curateCategory)
+        }
+      } : {}
+    };
   } finally {
     heartbeat.stop();
     if (childSessionId)
@@ -12060,16 +12062,17 @@ function planDueTasks(db, projectIdentity, tasks, now) {
   }
   return due;
 }
-function advanceAfterRun(db, projectIdentity, due, finishedAt, status, error, schedulePatch) {
+function advanceAfterRun(db, projectIdentity, due, finishedAt, status, error, schedulePatch, startedAt) {
   writeTaskScheduleState(db, {
     projectPath: projectIdentity,
     task: due.config.task,
-    lastRunAt: status === "completed" ? finishedAt : readLastRunAt(db, projectIdentity, due.config.task),
+    lastRunAt: status === "completed" ? startedAt ?? finishedAt : readLastRunAt(db, projectIdentity, due.config.task),
     nextDueAt: nextDueAtMs(due.config.schedule, finishedAt, due.scheduledAt),
     schedule: due.config.schedule,
     lastStatus: status,
     lastError: error,
     retryCount: 0,
+    taskStateJson: schedulePatch?.taskStateJson,
     retrospectiveWatermarkMs: schedulePatch?.retrospectiveWatermarkMs
   });
 }
@@ -12148,6 +12151,7 @@ async function runDomainGroup(deps, group, cb) {
         }
       }
       let outcome;
+      const startedAt = Date.now();
       try {
         outcome = await executor(due.config, {
           db,
@@ -12161,8 +12165,8 @@ async function runDomainGroup(deps, group, cb) {
       }
       const finishedAt = Date.now();
       if (outcome.status === "completed") {
-        advanceAfterRun(db, projectIdentity, due, finishedAt, "completed", null, outcome.schedulePatch);
-        cb?.onRan?.(due.config.task, outcome.detail);
+        advanceAfterRun(db, projectIdentity, due, finishedAt, "completed", null, outcome.schedulePatch, startedAt);
+        cb?.onRan?.(due.config.task, outcome.detail, outcome.backlog);
       } else if (outcome.transient) {
         recordTransientFailure(db, projectIdentity, due, finishedAt, outcome.error ?? null);
         cb?.onFailed?.(due.config.task, outcome.failureDetail ?? outcome.error);
@@ -12229,6 +12233,7 @@ async function runManualDream(deps) {
     return result;
   }
   const groups = new Map;
+  const runLocalBacklogs = {};
   for (const d of gated) {
     const kind = leaseKindFor(d.config.task);
     const arr = groups.get(kind) ?? [];
@@ -12238,10 +12243,12 @@ async function runManualDream(deps) {
   await Promise.all([...groups.values()].map((group) => runDomainGroup({ ...deps, executor: deps.executor }, group, {
     forceGate,
     leaseWaitMs: MANUAL_RUN_LEASE_WAIT_MS,
-    onRan: (t, detail) => {
+    onRan: (t, detail, backlog) => {
       result.ran.push(t);
       if (detail)
         result.details?.push(detail);
+      if (backlog)
+        runLocalBacklogs[t] = backlog;
     },
     onFailed: (task, error) => {
       result.failed.push(task);
@@ -12250,7 +12257,10 @@ async function runManualDream(deps) {
     },
     onBusy: (t) => result.deferredBusy.push(t)
   })));
-  result.backlogAfter = getDreamTaskBacklogs(deps.db, deps.projectIdentity, selectedTaskNames);
+  result.backlogAfter = {
+    ...getDreamTaskBacklogs(deps.db, deps.projectIdentity, selectedTaskNames),
+    ...runLocalBacklogs
+  };
   return result;
 }
 async function runDueTasksForProject(deps) {
@@ -14022,6 +14032,16 @@ import {
 } from "node:path";
 import { pathToFileURL } from "node:url";
 var PI_CODING_AGENT_MODULE2 = "@earendil-works/pi-coding-agent";
+var OMP_CODING_AGENT_MODULE = "@oh-my-pi/pi-coding-agent";
+var CODING_AGENT_MODULES = [
+  PI_CODING_AGENT_MODULE2,
+  OMP_CODING_AGENT_MODULE
+];
+var CODING_AGENT_MODULE_LABEL = CODING_AGENT_MODULES.join(" or ");
+var CODING_AGENT_PACKAGE_NAMES = new Set(CODING_AGENT_MODULES);
+function isCodingAgentPackageName(name) {
+  return typeof name === "string" && CODING_AGENT_PACKAGE_NAMES.has(name);
+}
 var SCRIPT_ENTRY_PATTERN = /\.(mjs|cjs|mts|cts|js|ts|tsx|jsx)$/i;
 var TS_ENTRY_PATTERN = /\.(mts|cts|ts|tsx)$/i;
 function isScriptEntry(filePath) {
@@ -14056,11 +14076,11 @@ function findPackageRoot(startDir) {
   let dir = startDir;
   while (dir !== dirname2(dir)) {
     const pkg = readManifest(join5(dir, "package.json"));
-    if (pkg?.name === PI_CODING_AGENT_MODULE2) {
+    if (isCodingAgentPackageName(pkg?.name)) {
       if (basename2(dir) === "dist") {
         const parentDir = dirname2(dir);
         const parentPkg = readManifest(join5(parentDir, "package.json"));
-        if (parentPkg?.name === PI_CODING_AGENT_MODULE2) {
+        if (parentPkg?.name === pkg.name) {
           return { dir: parentDir, pkg: parentPkg };
         }
       }
@@ -14133,11 +14153,14 @@ var defaultLoaders = [
       }
       const found = findPackageRoot(dirname2(entry));
       if (!found) {
-        throw new Error(`Could not locate ${PI_CODING_AGENT_MODULE2} package.json from ${entry}`);
+        throw new Error(`Could not locate ${CODING_AGENT_MODULE_LABEL} package.json from ${entry}`);
       }
       const entryPath = resolveManifestEntry(found);
       if (TS_ENTRY_PATTERN.test(entry)) {
         const srcEntry = toSourceEntry(entryPath, found.dir);
+        if (!srcEntry && TS_ENTRY_PATTERN.test(entryPath) && existsSync7(entryPath)) {
+          return await import(pathToFileURL(entryPath).href);
+        }
         if (srcEntry && existsSync7(srcEntry)) {
           return await import(pathToFileURL(srcEntry).href);
         }
@@ -14149,6 +14172,10 @@ var defaultLoaders = [
   {
     name: "Bare import",
     load: async () => await import(PI_CODING_AGENT_MODULE2)
+  },
+  {
+    name: "Bare import (OMP)",
+    load: async () => await import(OMP_CODING_AGENT_MODULE)
   }
 ];
 var cachedModulePromise = null;
@@ -14166,7 +14193,7 @@ async function resolvePiCodingAgentModule(loaders) {
         errors.push(err);
       }
     }
-    throw new Error(`Failed to resolve ${PI_CODING_AGENT_MODULE2} via all strategies:
+    throw new Error(`Failed to resolve a Pi/OMP coding-agent module (${CODING_AGENT_MODULE_LABEL}) via all strategies:
 ` + errors.map((e, i) => `  - ${activeLoaders[i].name}: ${e.message || e}`).join(`
 `) + `
 Likely cause: symlinked or nonstandard install layout.`);
@@ -16156,7 +16183,7 @@ function applyFlushedStatuses(sessionId, db, targets, preloadedTags) {
 
 // ../plugin/src/hooks/magic-context/cache-busting-signals.ts
 function hasReclaimRide(signals) {
-  return signals.hardFold || signals.force || signals.explicitFlush || signals.publishedHistory || signals.agentDrop;
+  return signals.hardFold || signals.force || signals.explicitFlush || signals.publishedHistory;
 }
 
 // ../plugin/src/hooks/magic-context/caveman.ts
@@ -17552,6 +17579,73 @@ function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPer
   };
 }
 
+// ../plugin/src/hooks/magic-context/dropped-token-estimate.ts
+var TAG_QUERY_CHUNK_SIZE = 900;
+var ESTIMATED_CHARACTERS_PER_TOKEN = 3.5;
+function estimateCharacters(characters) {
+  return Math.ceil(Math.max(0, characters) / ESTIMATED_CHARACTERS_PER_TOKEN);
+}
+function persistedCountOrByteEstimate(count, bytes) {
+  return typeof count === "number" && Number.isFinite(count) ? Math.max(0, count) : estimateCharacters(bytes);
+}
+function loadPersistedTagTokenCounts(db, sessionId, tagNumbers) {
+  const countsByTag = new Map;
+  for (let offset = 0;offset < tagNumbers.length; offset += TAG_QUERY_CHUNK_SIZE) {
+    const chunk = tagNumbers.slice(offset, offset + TAG_QUERY_CHUNK_SIZE);
+    const placeholders = chunk.map(() => "?").join(",");
+    const rows = db.prepare(`SELECT tag_number AS tagNumber,
+                        type,
+                        byte_size AS byteSize,
+                        input_byte_size AS inputByteSize,
+                        reasoning_byte_size AS reasoningByteSize,
+                        token_count AS tokenCount,
+                        input_token_count AS inputTokenCount,
+                        reasoning_token_count AS reasoningTokenCount
+                   FROM tags
+                  WHERE session_id = ? AND tag_number IN (${placeholders})`).all(sessionId, ...chunk);
+    for (const row of rows)
+      countsByTag.set(row.tagNumber, row);
+  }
+  return countsByTag;
+}
+function estimateDroppedTokensFromTagReductions(db, sessionId, reductions) {
+  if (reductions.length === 0)
+    return 0;
+  const structuralByTag = new Map;
+  const partialCharactersByTag = new Map;
+  for (const reduction of reductions) {
+    if (reduction.mode === "partial") {
+      partialCharactersByTag.set(reduction.tagNumber, (partialCharactersByTag.get(reduction.tagNumber) ?? 0) + Math.max(0, reduction.removedCharacters));
+      continue;
+    }
+    const prior = structuralByTag.get(reduction.tagNumber);
+    if (!prior || reduction.mode === "full") {
+      structuralByTag.set(reduction.tagNumber, reduction);
+    }
+  }
+  const tagNumbers = [...new Set([...structuralByTag.keys(), ...partialCharactersByTag.keys()])];
+  const countsByTag = loadPersistedTagTokenCounts(db, sessionId, tagNumbers);
+  let total = 0;
+  for (const [tagNumber, reduction] of structuralByTag) {
+    const row = countsByTag.get(tagNumber);
+    if (!row)
+      continue;
+    total += persistedCountOrByteEstimate(row.tokenCount, row.byteSize);
+    if (reduction.mode === "full") {
+      total += persistedCountOrByteEstimate(row.reasoningTokenCount, row.reasoningByteSize);
+      if (row.type === "tool") {
+        total += persistedCountOrByteEstimate(row.inputTokenCount, row.inputByteSize);
+      }
+    }
+  }
+  for (const [tagNumber, removedCharacters] of partialCharactersByTag) {
+    if (structuralByTag.has(tagNumber) || !countsByTag.has(tagNumber))
+      continue;
+    total += estimateCharacters(removedCharacters);
+  }
+  return Math.max(0, Math.round(total));
+}
+
 // ../plugin/src/hooks/magic-context/emergency-fail-closed.ts
 class EmergencyFailClosedError extends Error {
   code = "EMERGENCY_FAIL_CLOSED";
@@ -18898,17 +18992,65 @@ function persistFilteredNoise(db, sessionId, chunk, eligibleEnd) {
 }
 
 // ../plugin/src/hooks/magic-context/producer-window-guard.ts
-var PRODUCER_WINDOW_REFUSAL_MARGIN = 0.15;
+var PRODUCER_WINDOW_REFUSAL_MARGIN = 0.03;
+var HISTORIAN_TRUNCATION_MARKER = "[… tokens truncated by Magic Context to fit the historian window …]";
+function producerInputTokenLimit(contextLimitTokens, maxOutputTokens) {
+  if (typeof contextLimitTokens !== "number" || !Number.isFinite(contextLimitTokens) || contextLimitTokens <= 0 || !Number.isFinite(maxOutputTokens) || maxOutputTokens < 0) {
+    return;
+  }
+  const usableInputTokens = Math.max(0, Math.floor(contextLimitTokens - maxOutputTokens));
+  return Math.max(0, Math.floor(usableInputTokens * (1 - PRODUCER_WINDOW_REFUSAL_MARGIN)));
+}
 function producerWindowFailureReason(input) {
   const { producerSourceTokens, contextLimitTokens, maxOutputTokens } = input;
-  if (typeof contextLimitTokens !== "number" || !Number.isFinite(contextLimitTokens) || contextLimitTokens <= 0 || !Number.isFinite(producerSourceTokens) || producerSourceTokens <= 0 || !Number.isFinite(maxOutputTokens) || maxOutputTokens < 0) {
+  const producerInputLimitTokens = producerInputTokenLimit(contextLimitTokens, maxOutputTokens);
+  if (producerInputLimitTokens === undefined || typeof contextLimitTokens !== "number" || !Number.isFinite(producerSourceTokens) || producerSourceTokens <= 0) {
     return null;
   }
   const usableInputTokens = Math.max(0, Math.floor(contextLimitTokens - maxOutputTokens));
-  const refusalThreshold = usableInputTokens * (1 + PRODUCER_WINDOW_REFUSAL_MARGIN);
-  if (producerSourceTokens < refusalThreshold)
+  if (producerSourceTokens <= producerInputLimitTokens)
     return null;
-  return `producer_source_exceeds_window producer_source_tokens=${Math.round(producerSourceTokens)} usable_input_tokens=${usableInputTokens} context_limit_tokens=${Math.round(contextLimitTokens)} max_output_tokens=${Math.round(maxOutputTokens)} refusal_margin=${PRODUCER_WINDOW_REFUSAL_MARGIN}`;
+  return `producer_source_exceeds_window producer_source_tokens=${Math.round(producerSourceTokens)} usable_input_tokens=${usableInputTokens} producer_input_limit_tokens=${producerInputLimitTokens} context_limit_tokens=${Math.round(contextLimitTokens)} max_output_tokens=${Math.round(maxOutputTokens)} estimator_margin=${PRODUCER_WINDOW_REFUSAL_MARGIN}`;
+}
+function splitMarkerPair() {
+  return `
+${HISTORIAN_TRUNCATION_MARKER}
+${HISTORIAN_TRUNCATION_MARKER}
+`;
+}
+function fitAtomicHistorianSourceToProducerWindow(args) {
+  const producerInputLimitTokens = producerInputTokenLimit(args.contextLimitTokens, args.maxOutputTokens);
+  const originalTokens = estimateTokens(args.text);
+  if (producerInputLimitTokens === undefined || originalTokens < producerInputLimitTokens || producerInputLimitTokens <= 0) {
+    return { text: args.text, producerInputLimitTokens, removedTokens: 0 };
+  }
+  const boundary = [...args.resultBoundaries ?? []].filter((candidate) => Number.isFinite(candidate.sourceOffset) && candidate.sourceOffset > 0 && candidate.sourceOffset < args.text.length).sort((a, b) => b.bodyTokens - a.bodyTokens || a.ordinal - b.ordinal)[0];
+  const splitOffset = boundary?.sourceOffset ?? Math.floor(args.text.length / 2);
+  const left = args.text.slice(0, splitOffset);
+  const right = args.text.slice(splitOffset);
+  const markers = splitMarkerPair();
+  const target = producerInputLimitTokens;
+  let lo = 0;
+  let hi = 1;
+  let best = markers;
+  for (let iteration = 0;iteration < 48; iteration++) {
+    const scale = (lo + hi) / 2;
+    const leftLength = Math.floor(left.length * scale);
+    const rightLength = Math.floor(right.length * scale);
+    const candidate = left.slice(0, leftLength) + markers + right.slice(right.length - rightLength);
+    if (estimateTokens(candidate) <= target) {
+      best = candidate;
+      lo = scale;
+    } else {
+      hi = scale;
+    }
+  }
+  return {
+    text: best,
+    producerInputLimitTokens,
+    ...boundary ? { splitBoundaryOrdinal: boundary.ordinal } : {},
+    removedTokens: Math.max(0, originalTokens - estimateTokens(best))
+  };
 }
 
 // ../plugin/src/hooks/magic-context/reference-seeds.generated.ts
@@ -21053,11 +21195,20 @@ async function runPiHistorian(deps) {
         chunkStart: chunk.startIndex,
         sessionCompartments: priorCompartments
       });
-      const chunkText = chunk.oversizeAtomicUnit ? chunk.text : truncateHistorianInputIfNeeded(chunk.text, historianChunkTokens);
+      const fittedAtomicSource = chunk.oversizeAtomicUnit ? fitAtomicHistorianSourceToProducerWindow({
+        text: chunk.text,
+        resultBoundaries: chunk.toolResultBoundaries,
+        contextLimitTokens: historianContextLimit,
+        maxOutputTokens
+      }) : null;
+      const chunkText = chunk.oversizeAtomicUnit ? fittedAtomicSource?.text ?? chunk.text : truncateHistorianInputIfNeeded(chunk.text, historianChunkTokens);
       const producerSourceTokens = estimateTokens(chunkText);
       if (boundarySnapshot.oversizeAtomicUnit || chunk.oversizeAtomicUnit) {
         sessionLog(sessionId, `historian oversize admission: range=${chunk.startIndex}-${chunk.endIndex} rawComponentTokens=${boundarySnapshot.diagnostics?.head.completedFence.tokenMass ?? "unknown"} perRunCap=${perRunCap} producerSourceTokens=${producerSourceTokens} historianChunkTokens=${historianChunkTokens}; ${describeBoundaryDiagnostics(boundarySnapshot)}`);
       }
+      if (fittedAtomicSource && fittedAtomicSource.removedTokens > 0) {
+        sessionLog(sessionId, `historian pathological component split: range=${chunk.startIndex}-${chunk.endIndex} resultBoundary=${fittedAtomicSource.splitBoundaryOrdinal ?? "midpoint"} removedTokens=${fittedAtomicSource.removedTokens} producerSourceTokens=${producerSourceTokens} producerInputLimitTokens=${fittedAtomicSource.producerInputLimitTokens ?? "unknown"}`);
+      }
       const producerWindowFailure = producerWindowFailureReason({
         producerSourceTokens,
         contextLimitTokens: historianContextLimit,
@@ -21791,6 +21942,7 @@ function applyPiHeuristicCleanup(sessionId, db, targets, piMessages, config, pre
   let deduplicatedTools = 0;
   let droppedInjections = 0;
   let droppedStaleReduceCalls = 0;
+  const droppedTokenReductions = [];
   if (config.emergency) {
     const emergency = config.emergency;
     const priorInputSample = getEmergencyInputSample(db, sessionId);
@@ -21827,6 +21979,10 @@ function applyPiHeuristicCleanup(sessionId, db, targets, piMessages, config, pre
             updateTagDropMode(db, sessionId, tag.tagNumber, skeleton ? "truncated" : "full");
             droppedTools++;
             emergencyDroppedTools++;
+            droppedTokenReductions.push({
+              tagNumber: tag.tagNumber,
+              mode: skeleton ? "truncated" : "full"
+            });
           }
         }
       }).immediate();
@@ -21886,12 +22042,22 @@ function applyPiHeuristicCleanup(sessionId, db, targets, piMessages, config, pre
             updateTagStatus(db, sessionId, tag.tagNumber, "dropped");
             if (dropResult === "removed" || didReplace) {
               droppedInjections++;
+              droppedTokenReductions.push({
+                tagNumber: tag.tagNumber,
+                mode: "full"
+              });
             }
           }
         } else {
           if (freezePiContentDecision(db, sessionId, "reminder-strip", tag.messageId)) {
-            if (target.setContent(stripped))
+            if (target.setContent(stripped)) {
               droppedInjections++;
+              droppedTokenReductions.push({
+                tagNumber: tag.tagNumber,
+                mode: "partial",
+                removedCharacters: Math.max(0, content.length - stripped.length)
+              });
+            }
           }
         }
       }
@@ -21930,6 +22096,10 @@ function applyPiHeuristicCleanup(sessionId, db, targets, piMessages, config, pre
           updateTagStatus(db, sessionId, tag.tagNumber, "dropped");
           if (result === "removed" || result === "truncated") {
             deduplicatedTools++;
+            droppedTokenReductions.push({
+              tagNumber: tag.tagNumber,
+              mode: "full"
+            });
           }
         }
       }
@@ -21948,6 +22118,15 @@ function applyPiHeuristicCleanup(sessionId, db, targets, piMessages, config, pre
     });
     compressedTextTags = cavemanResult.compressedToLite + cavemanResult.compressedToFull + cavemanResult.compressedToUltra;
     mutatedTextTags = cavemanResult.mutatedTextTags;
+    if (cavemanResult.textReductions) {
+      for (const r of cavemanResult.textReductions) {
+        droppedTokenReductions.push({
+          tagNumber: r.tagNumber,
+          mode: "partial",
+          removedCharacters: r.removedCharacters
+        });
+      }
+    }
   }
   return {
     droppedTools,
@@ -21956,7 +22135,8 @@ function applyPiHeuristicCleanup(sessionId, db, targets, piMessages, config, pre
     droppedStaleReduceCalls,
     emergencyDroppedTools,
     compressedTextTags,
-    mutatedTextTags
+    mutatedTextTags,
+    droppedTokenReductions
   };
 }
 function buildCtxReduceTagNumbers(tags) {
@@ -22023,7 +22203,7 @@ function memoizedContent(kind, content) {
     return cached;
   const measured = {
     hash: fnv1a32(key),
-    tokens: kind === "excluded" ? 0 : estimateTokens(content),
+    tokens: kind === "excluded" ? 0 : undefined,
     keyBytes: key.length * 2 + 32
   };
   contentMemo.set(key, measured);
@@ -22040,7 +22220,11 @@ function memoizedContent(kind, content) {
   return measured;
 }
 function memoizedTokens(kind, content) {
-  return memoizedContent(kind, content).tokens;
+  const measured = memoizedContent(kind, content);
+  if (measured.tokens === undefined) {
+    measured.tokens = estimateTokens(content);
+  }
+  return measured.tokens;
 }
 function partHash(kind, content) {
   return memoizedContent(kind, content).hash;
@@ -22518,7 +22702,7 @@ function refreshPiTailHygieneBaseline(input) {
   for (let index = input.previous.baselineParts.length;index < measured.parts.length; index += 1) {
     const part = measured.parts[index];
     turnDeltaT += part.tokens;
-    if (part.kind !== "toolOutput")
+    if (part.kind !== "toolOutput" || !part.protected)
       turnDeltaU += part.uTokens;
   }
   return {
@@ -26497,7 +26681,7 @@ function memoryGuidanceBlock(memoryEnabled) {
 ` : "";
 }
 var BASE_INTRO = (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 newest token-mass window stays protected until displaced. Syntax: "3-5", "1,2,9", or "1-5,8,12-15".
+Use \`ctx_reduce\` to mark spent tagged content as discardable and reclaim space. Marking QUEUES content for release. It stays fully visible to you until it is actually released, which may be the next turn or many turns later. Mark a tool output as soon as you're done with it rather than hoarding the call for the end of the turn. The newest token-mass window stays protected until displaced. 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.
@@ -29629,7 +29813,8 @@ async function runPipeline(args) {
   let heuristicOrReasoningDidMutate = false;
   let didMutateFromFlushedStatuses = false;
   let droppedCount = 0;
-  const droppedTokens = 0;
+  let droppedTokens = 0;
+  const droppedTokenReductions = [];
   let emergency = false;
   let autoReclaimDidMutateThisPass = false;
   let suppressDeferredHistoryDrain = false;
@@ -29754,17 +29939,15 @@ async function runPipeline(args) {
     routinePressureAppliedBySession.set(args.sessionId, true);
   }
   const routinePressureAlreadyApplied = !args.sessionMeta.isSubagent && executePressureEligible && routinePressureAppliedBySession.get(args.sessionId) === true;
-  const historianRunning = inFlightHistorian.has(args.sessionId);
-  const publishedWorkDrainAllowed = args.schedulerDecision === "execute" || args.forceMaterialization === true || foldExecutedThisPass || firstRenderBust || hasPendingMaterialization(args.sessionId) || deferredMaterializeEligible;
   const hasPendingMaterializeSignal = hasPendingMaterialization(args.sessionId);
   const rideSignals = {
     hardFold: foldExecutedThisPass || firstRenderBust,
-    force: args.forceMaterialization === true || emergencyDropEligible,
-    explicitFlush: hasPendingMaterializeSignal || args.isCacheBusting,
-    publishedHistory: !prefixPreflightContended && (publishedM1RefreshedThisPass || canConsumeDeferredLate && deferredHistoryWasPendingAtPassStart),
-    agentDrop: false
+    force: (args.forceMaterialization === true || emergencyDropEligible) && (args.contextUsage.percentage >= 95 || getEmergencyInputSample(args.db, args.sessionId) === 0),
+    explicitFlush: hasPendingMaterializeSignal || deferredMaterializeEligible && !prefixPreflightContended,
+    publishedHistory: !prefixPreflightContended && (args.isCacheBusting || publishedM1RefreshedThisPass || canConsumeDeferredLate && deferredHistoryWasPendingAtPassStart)
   };
-  let isCacheBustingPass = hasReclaimRide(rideSignals);
+  const isCacheBustingPass = hasReclaimRide(rideSignals);
+  const publishedWorkDrainAllowed = isCacheBustingPass;
   const usesTokenProtection = args.protectedTokenTierOverrides !== undefined || args.protectedTokens !== undefined;
   const resolveProtectionFloor = () => resolveEpochFloorForPass(args.db, args.sessionId, {
     configuredOverride: args.protectedTokens,
@@ -29829,15 +30012,14 @@ async function runPipeline(args) {
   }
   const deferredMaterializationWasPending = deferredMaterializationSessions.has(args.sessionId);
   const deferredHistoryRefreshWasPending = deferredHistoryWasPendingAtPassStart;
-  const shouldReadPendingOps = !args.compactionOff && (args.schedulerDecision === "execute" || args.forceMaterialization || hasPendingMaterializeSignal || foldExecutedThisPass || firstRenderBust || historianRunning);
+  const shouldReadPendingOps = !args.compactionOff && (publishedWorkDrainAllowed || args.schedulerDecision === "execute" || args.forceMaterialization || hasPendingMaterializeSignal || foldExecutedThisPass || firstRenderBust);
   const pendingOps = shouldReadPendingOps ? getPendingOps(args.db, args.sessionId) : [];
   const protectionWindowForPass = getProtectionWindowForSession(args.db, args.sessionId, protectionFloorResolution.floor);
   const protectedTagNumbersForPass = usesTokenProtection ? protectionWindowForPass.protectedTagNumbers : newestActiveTagNumbersByCount(getActiveTagsBySession(args.db, args.sessionId), args.protectedTags);
   const pendingOperationTags = pendingOps.length > 0 ? getTagsForPendingOperations(args.db, args.sessionId, pendingOps.map((operation) => operation.tagId), usesTokenProtection ? 0 : args.protectedTags, RECENT_TOOL_SKELETON_WINDOW) : [];
-  const baseShouldApplyPendingOps = args.schedulerDecision === "execute" || args.forceMaterialization || hasPendingMaterializeSignal || foldExecutedThisPass || firstRenderBust;
   const deferredMaterialize = canConsumeDeferredLate && deferredMaterializationWasPending;
   const deferredHistoryRefresh = canConsumeDeferredLate && deferredHistoryRefreshWasPending;
-  const shouldApplyPendingOps = (baseShouldApplyPendingOps || deferredMaterialize) && publishedWorkDrainAllowed;
+  const shouldApplyPendingOps = publishedWorkDrainAllowed;
   mutationGateObserverForTests?.({
     foldDue: foldDueDecision.value,
     foldExecuted: foldExecutedThisPass,
@@ -29853,15 +30035,11 @@ async function runPipeline(args) {
     pendingDecisionLogObserverForTests?.(pendingDecisionLog);
     try {
       const tApplyPending = performance.now();
-      pendingOpsDidMutate = applyPendingOperations(args.sessionId, args.db, targets, args.contextUsage.percentage >= 95 ? newestCtxReduceTagNumbers(getTagsBySession(args.db, args.sessionId)) : protectedTagNumbersForPass, pendingOperationTags, pendingOps);
+      pendingOpsDidMutate = applyPendingOperations(args.sessionId, args.db, targets, args.contextUsage.percentage >= 95 ? newestCtxReduceTagNumbers(getTagsBySession(args.db, args.sessionId)) : protectedTagNumbersForPass, pendingOperationTags, pendingOps, [], new Set, (reduction) => droppedTokenReductions.push(reduction));
       if (pendingOpsDidMutate) {
         droppedCount += pendingOps.length;
       }
       logTransformTiming(args.sessionId, "applyPendingOperations", tApplyPending);
-      rideSignals.agentDrop = pendingOpsDidMutate;
-      isCacheBustingPass = hasReclaimRide(rideSignals);
-      if (pendingOpsDidMutate)
-        shouldRunHeuristics = args.heuristics !== undefined;
       executedWorkThisPass ||= isCacheBustingPass;
       materializationSatisfiedThisPass = true;
       pendingOpsAppliedThisPass = true;
@@ -29876,7 +30054,7 @@ async function runPipeline(args) {
     }
   } else {
     const pendingOpsDepth = getPendingOpsCount(args.db, args.sessionId);
-    const refusalReason = args.schedulerDeferReason ?? (historianRunning ? "historian_in_flight" : "scheduler_defer");
+    const refusalReason = args.schedulerDeferReason ?? "no_originating_cache_bust";
     const pendingDecisionLog = `pending ops WILL NOT APPLY — reason=${refusalReason} pendingOps=${pendingOpsDepth === null ? "not loaded (deferred pass)" : pendingOpsDepth} context=${args.contextUsage.percentage.toFixed(1)}%`;
     sessionLog(args.sessionId, pendingDecisionLog);
     pendingDecisionLogObserverForTests?.(pendingDecisionLog);
@@ -29942,7 +30120,7 @@ async function runPipeline(args) {
     sessionLog(args.sessionId, heuristicsDecisionLog);
     pendingDecisionLogObserverForTests?.(heuristicsDecisionLog);
   } else {
-    const reason = args.heuristics === undefined ? "disabled" : args.schedulerDeferReason ?? (historianRunning ? "historian_in_flight" : alreadyRanHeuristicsThisTurn ? "already_ran_this_turn" : "scheduler_defer");
+    const reason = args.heuristics === undefined ? "disabled" : args.schedulerDeferReason ?? (!isCacheBustingPass ? "no_originating_cache_bust" : alreadyRanHeuristicsThisTurn ? "already_ran_this_turn" : "scheduler_defer");
     const heuristicsDecisionLog = `heuristics WILL NOT RUN — reason=${reason}`;
     sessionLog(args.sessionId, heuristicsDecisionLog);
     pendingDecisionLogObserverForTests?.(heuristicsDecisionLog);
@@ -29982,7 +30160,11 @@ async function runPipeline(args) {
           droppedStaleReduceCalls: heuristicsResult.droppedStaleReduceCalls + ridingCleanup.droppedStaleReduceCalls,
           emergencyDroppedTools: heuristicsResult.emergencyDroppedTools,
           compressedTextTags: heuristicsResult.compressedTextTags + ridingCleanup.compressedTextTags,
-          mutatedTextTags: heuristicsResult.mutatedTextTags + ridingCleanup.mutatedTextTags
+          mutatedTextTags: heuristicsResult.mutatedTextTags + ridingCleanup.mutatedTextTags,
+          droppedTokenReductions: [
+            ...heuristicsResult.droppedTokenReductions,
+            ...ridingCleanup.droppedTokenReductions
+          ]
         };
         routineCleanupApplied = true;
       }
@@ -29992,6 +30174,9 @@ async function runPipeline(args) {
       const heuristicMutationCount = heuristicsResult.droppedTools + heuristicsResult.deduplicatedTools + heuristicsResult.droppedInjections + heuristicsResult.droppedStaleReduceCalls + heuristicsResult.mutatedTextTags;
       droppedCount += heuristicsResult.droppedTools + heuristicsResult.deduplicatedTools + heuristicsResult.droppedInjections + heuristicsResult.droppedStaleReduceCalls + heuristicsResult.mutatedTextTags;
       emergency ||= heuristicsResult.emergencyDroppedTools > 0;
+      if (heuristicsResult.droppedTokenReductions.length > 0) {
+        droppedTokenReductions.push(...heuristicsResult.droppedTokenReductions);
+      }
       if (heuristicMutationCount > 0)
         heuristicOrReasoningDidMutate = true;
       heuristicsExecuted = true;
@@ -30100,7 +30285,7 @@ async function runPipeline(args) {
     }
     autoReclaimTargetCount = syntheticPendingOps.length;
     if (syntheticPendingOps.length > 0) {
-      autoReclaimDidMutate = applyPendingOperations(args.sessionId, args.db, targets, protectedTagNumbersForPass, undefined, [], syntheticPendingOps, editMarkerTagIds);
+      autoReclaimDidMutate = applyPendingOperations(args.sessionId, args.db, targets, protectedTagNumbersForPass, undefined, [], syntheticPendingOps, editMarkerTagIds, (reduction) => droppedTokenReductions.push(reduction));
       if (autoReclaimDidMutate) {
         droppedCount += syntheticPendingOps.length;
         autoReclaimDidMutateThisPass = true;
@@ -30364,6 +30549,9 @@ async function runPipeline(args) {
     pendingDropTagNumbers: new Set(channelPendingOps.filter((operation) => operation.operation === "drop").map((operation) => operation.tagId))
   };
   const bustedThisPass = firstRenderBust || didMutateFromFlushedStatuses || pendingOpsDidMutate || heuristicOrReasoningDidMutate || autoReclaimDidMutateThisPass || materialized || historyWasConsumedThisPass;
+  if (bustedThisPass || isCacheBustingPass) {
+    droppedTokens = estimateDroppedTokensFromTagReductions(args.db, args.sessionId, droppedTokenReductions);
+  }
   return {
     messages: outputMessages,
     heuristicsExecuted,
@@ -32811,7 +32999,7 @@ function formatTailHygiene(status) {
 // package.json
 var package_default = {
   name: "@cortexkit/pi-magic-context",
-  version: "0.42.4",
+  version: "0.42.6",
   type: "module",
   description: "Pi and OMP coding agent extension for Magic Context — cross-session memory and context management",
   main: "dist/index.js",