@cortexkit/opencode-magic-context 0.32.2 → 0.32.4

package/dist/index.js

@@ -15646,25 +15646,28 @@ function closeQuietly(db) {
 }
 
 // src/features/magic-context/compaction-marker.ts
+import { createHash } from "node:crypto";
 import { existsSync as existsSync6 } from "node:fs";
 import { join as join3 } from "node:path";
-function randomBase62(length) {
-  const chars = [];
-  for (let i = 0;i < length; i++) {
-    chars.push(BASE62_CHARS[Math.floor(Math.random() * BASE62_CHARS.length)]);
+function deterministicBase62(seed, length) {
+  let value = BigInt(`0x${createHash("sha256").update(seed).digest("hex")}`);
+  const chars = Array(length);
+  for (let index = length - 1;index >= 0; index -= 1) {
+    chars[index] = BASE62_CHARS[Number(value % 62n)];
+    value /= 62n;
   }
   return chars.join("");
 }
-function generateId(prefix, timestampMs, counter = 0n) {
-  const encoded = BigInt(timestampMs) * 0x1000n + counter;
-  const hex3 = encoded.toString(16).padStart(14, "0");
-  return `${prefix}_${hex3}${randomBase62(14)}`;
+function generateId(prefix, timestampMs, counter, identity) {
+  const encoded = BigInt(Math.max(0, Math.floor(timestampMs))) * 0x1000n + counter & ID_PREFIX_MASK;
+  const hex3 = encoded.toString(16).padStart(ID_PREFIX_HEX_LENGTH, "0");
+  return `${prefix}_${hex3}${deterministicBase62(`${prefix}\x00${identity}`, ID_SUFFIX_LENGTH)}`;
 }
-function generateMessageId(timestampMs, counter = 0n) {
-  return generateId("msg", timestampMs, counter);
+function generateMessageId(timestampMs, counter = 0n, identity = "") {
+  return generateId("msg", timestampMs, counter, identity);
 }
-function generatePartId(timestampMs, counter = 0n) {
-  return generateId("prt", timestampMs, counter);
+function generatePartId(timestampMs, counter = 0n, identity = "") {
+  return generateId("prt", timestampMs, counter, identity);
 }
 function getOpenCodeDbPath() {
   return join3(getDataDir(), "opencode", "opencode.db");
@@ -15763,6 +15766,38 @@ function getOpenCodeMessageById(sessionId, messageId) {
   const row = db.prepare(`SELECT id FROM message WHERE session_id = ? AND id = ? LIMIT 1`).get(sessionId, messageId);
   return row ?? null;
 }
+function removeLegacyMarkerLineageRows(db, args) {
+  const legacySummaries = db.prepare(`SELECT m.id
+             FROM message m
+             WHERE m.session_id = ?
+               AND m.id <> ?
+               AND COALESCE(json_extract(m.data, '$.summary'), 0) = 1
+               AND COALESCE(json_extract(m.data, '$.finish'), '') = 'stop'
+               AND COALESCE(json_extract(m.data, '$.parentID'), '') = ?
+               AND EXISTS (
+                   SELECT 1
+                   FROM part p
+                   WHERE p.session_id = m.session_id
+                     AND p.message_id = m.id
+                     AND COALESCE(json_extract(p.data, '$.type'), '') = 'text'
+                     AND COALESCE(json_extract(p.data, '$.text'), '') = ?
+               )`).all(args.sessionId, args.summaryMessageId, args.boundaryMessageId, args.summaryText);
+  const legacySummaryIds = legacySummaries.flatMap((row) => typeof row.id === "string" ? [row.id] : []);
+  if (legacySummaryIds.length === 0)
+    return;
+  const deleteSummaryParts = db.prepare("DELETE FROM part WHERE session_id = ? AND message_id = ?");
+  const deleteSummary = db.prepare("DELETE FROM message WHERE session_id = ? AND id = ?");
+  for (const summaryMessageId of legacySummaryIds) {
+    deleteSummaryParts.run(args.sessionId, summaryMessageId);
+    deleteSummary.run(args.sessionId, summaryMessageId);
+  }
+  db.prepare(`DELETE FROM part
+         WHERE session_id = ?
+           AND message_id = ?
+           AND id <> ?
+           AND COALESCE(json_extract(data, '$.type'), '') = 'compaction'
+           AND COALESCE(json_extract(data, '$.auto'), 0) = 1`).run(args.sessionId, args.boundaryMessageId, args.compactionPartId);
+}
 function injectCompactionMarker(args) {
   const db = getWritableOpenCodeDb();
   if (!isOpenCodeSchemaCompatible(db, getOpenCodeDbPath())) {
@@ -15774,9 +15809,10 @@ function injectCompactionMarker(args) {
     return null;
   }
   const boundaryTime = boundary.timeCreated;
-  const summaryMsgId = generateMessageId(boundaryTime + 1, 1n);
-  const compactionPartId = generatePartId(boundaryTime, 1n);
-  const summaryPartId = generatePartId(boundaryTime + 1, 2n);
+  const markerIdentity = `${args.sessionId}\x00${args.endMessageId}`;
+  const summaryMsgId = generateMessageId(boundaryTime + 1, 1n, `${markerIdentity}\x00summary-message`);
+  const compactionPartId = generatePartId(boundaryTime, 1n, `${markerIdentity}\x00compaction-part`);
+  const summaryPartId = generatePartId(boundaryTime + 1, 2n, `${markerIdentity}\x00summary-part`);
   const summaryMsgData = JSON.stringify({
     role: "assistant",
     parentID: boundary.id,
@@ -15793,9 +15829,36 @@ function injectCompactionMarker(args) {
   });
   try {
     db.transaction(() => {
-      db.prepare("INSERT INTO part (id, message_id, session_id, time_created, time_updated, data) VALUES (?, ?, ?, ?, ?, ?)").run(compactionPartId, boundary.id, args.sessionId, boundaryTime, boundaryTime, '{"type":"compaction","auto":true}');
-      db.prepare("INSERT INTO message (id, session_id, time_created, time_updated, data) VALUES (?, ?, ?, ?, ?)").run(summaryMsgId, args.sessionId, boundaryTime + 1, boundaryTime + 1, summaryMsgData);
-      db.prepare("INSERT INTO part (id, message_id, session_id, time_created, time_updated, data) VALUES (?, ?, ?, ?, ?, ?)").run(summaryPartId, summaryMsgId, args.sessionId, boundaryTime + 1, boundaryTime + 1, JSON.stringify({ type: "text", text: args.summaryText }));
+      removeLegacyMarkerLineageRows(db, {
+        sessionId: args.sessionId,
+        boundaryMessageId: boundary.id,
+        summaryText: args.summaryText,
+        summaryMessageId: summaryMsgId,
+        compactionPartId
+      });
+      db.prepare(`INSERT INTO part (id, message_id, session_id, time_created, time_updated, data)
+                 VALUES (?, ?, ?, ?, ?, ?)
+                 ON CONFLICT(id) DO UPDATE SET
+                     message_id = excluded.message_id,
+                     session_id = excluded.session_id,
+                     time_created = excluded.time_created,
+                     time_updated = excluded.time_updated,
+                     data = excluded.data`).run(compactionPartId, boundary.id, args.sessionId, boundaryTime, boundaryTime, '{"type":"compaction","auto":true}');
+      db.prepare(`INSERT INTO message (id, session_id, time_created, time_updated, data)
+                 VALUES (?, ?, ?, ?, ?)
+                 ON CONFLICT(id) DO UPDATE SET
+                     session_id = excluded.session_id,
+                     time_created = excluded.time_created,
+                     time_updated = excluded.time_updated,
+                     data = excluded.data`).run(summaryMsgId, args.sessionId, boundaryTime + 1, boundaryTime + 1, summaryMsgData);
+      db.prepare(`INSERT INTO part (id, message_id, session_id, time_created, time_updated, data)
+                 VALUES (?, ?, ?, ?, ?, ?)
+                 ON CONFLICT(id) DO UPDATE SET
+                     message_id = excluded.message_id,
+                     session_id = excluded.session_id,
+                     time_created = excluded.time_created,
+                     time_updated = excluded.time_updated,
+                     data = excluded.data`).run(summaryPartId, summaryMsgId, args.sessionId, boundaryTime + 1, boundaryTime + 1, JSON.stringify({ type: "text", text: args.summaryText }));
     })();
     log(`[magic-context] compaction-marker: injected boundary at user msg ${boundary.id} (ordinal ~${args.endOrdinal}), summary msg ${summaryMsgId}`);
     return {
@@ -15823,11 +15886,12 @@ function removeCompactionMarker(state) {
     return false;
   }
 }
-var BASE62_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", cachedWriteDb = null, REQUIRED_MESSAGE_COLUMNS, REQUIRED_PART_COLUMNS, cachedSchemaCompatible = null;
+var BASE62_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", ID_PREFIX_HEX_LENGTH = 12, ID_SUFFIX_LENGTH = 14, ID_PREFIX_MASK, cachedWriteDb = null, REQUIRED_MESSAGE_COLUMNS, REQUIRED_PART_COLUMNS, cachedSchemaCompatible = null;
 var init_compaction_marker = __esm(async () => {
   init_data_path();
   init_logger();
   await init_sqlite();
+  ID_PREFIX_MASK = (1n << BigInt(ID_PREFIX_HEX_LENGTH * 4)) - 1n;
   REQUIRED_MESSAGE_COLUMNS = ["id", "session_id", "time_created", "time_updated", "data"];
   REQUIRED_PART_COLUMNS = [
     "id",
@@ -15841,7 +15905,7 @@ var init_compaction_marker = __esm(async () => {
 
 // src/features/magic-context/memory/project-identity.ts
 import { execFileSync } from "node:child_process";
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import { existsSync as existsSync8, realpathSync, statSync as statSync2 } from "node:fs";
 import path3 from "node:path";
 function asError(error51) {
@@ -15882,7 +15946,7 @@ function getErrorStderr(error51) {
 }
 function directoryFallback(directory) {
   const canonical = path3.resolve(directory);
-  const hash2 = createHash("md5").update(canonical, "utf8").digest("hex").slice(0, 12);
+  const hash2 = createHash2("md5").update(canonical, "utf8").digest("hex").slice(0, 12);
   return `dir:${hash2}`;
 }
 function assertDirectoryUsable(canonicalDirectory, rawDirectory) {
@@ -16391,6 +16455,9 @@ function modelBodyField(spec) {
 }
 
 // src/shared/model-suggestion-retry.ts
+function copyPromptArgs(args, body) {
+  return { ...args, body: { ...body } };
+}
 function extractMessage(error51) {
   if (typeof error51 === "string")
     return error51;
@@ -16504,40 +16571,41 @@ function shortErr(error51) {
   return extractMessage(error51);
 }
 async function attemptOnce(client, args, timeoutMs, signal, callContext, label) {
+  const originalBody = { ...args.body };
+  const attemptArgs = copyPromptArgs(args, originalBody);
   try {
-    await promptWithTimeout(client, args, timeoutMs, signal);
+    await promptWithTimeout(client, attemptArgs, timeoutMs, signal);
     return;
   } catch (error51) {
     if (isNonRetryable(error51, signal))
       throw error51;
     const suggestion = parseModelSuggestion(error51);
-    if (!suggestion || !args.body.model) {
+    if (!suggestion || !originalBody.model) {
       throw error51;
     }
     log(`[${callContext}] ${label}: model not found, retrying with suggestion`, {
       original: `${suggestion.providerID}/${suggestion.modelID}`,
       suggested: suggestion.suggestion
     });
-    await promptWithTimeout(client, {
-      ...args,
-      body: {
-        ...args.body,
-        model: {
-          providerID: suggestion.providerID,
-          modelID: suggestion.suggestion
-        }
+    await promptWithTimeout(client, copyPromptArgs(args, {
+      ...originalBody,
+      model: {
+        providerID: suggestion.providerID,
+        modelID: suggestion.suggestion
       }
-    }, timeoutMs, signal);
+    }), timeoutMs, signal);
   }
 }
 async function promptSyncWithModelSuggestionRetry(client, args, options = {}) {
   const timeoutMs = options.timeoutMs ?? 300000;
   const callContext = options.callContext ?? "subagent";
   const fallbacks = options.fallbackModels ?? [];
-  const explicitPrimaryLabel = args.body.model?.providerID && args.body.model.modelID ? `${args.body.model.providerID}/${args.body.model.modelID}` : "primary";
+  const baseBody = { ...args.body };
+  const baseArgs = copyPromptArgs(args, baseBody);
+  const explicitPrimaryLabel = baseBody.model?.providerID && baseBody.model.modelID ? `${baseBody.model.providerID}/${baseBody.model.modelID}` : "primary";
   let lastError = null;
   try {
-    await attemptOnce(client, args, timeoutMs, options.signal, callContext, explicitPrimaryLabel);
+    await attemptOnce(client, baseArgs, timeoutMs, options.signal, callContext, explicitPrimaryLabel);
     return;
   } catch (error51) {
     lastError = error51;
@@ -16555,10 +16623,10 @@ async function promptSyncWithModelSuggestionRetry(client, args, options = {}) {
       continue;
     }
     const label = `${parsed.providerID}/${parsed.modelID}`;
-    const attemptArgs = {
-      ...args,
-      body: { ...args.body, model: parsed }
-    };
+    const attemptArgs = copyPromptArgs(baseArgs, {
+      ...baseBody,
+      model: parsed
+    });
     try {
       await attemptOnce(client, attemptArgs, timeoutMs, options.signal, callContext, label);
       log(`[${callContext}] fallback succeeded with ${label} (attempt ${i + 2}/${fallbacks.length + 1})`);
@@ -16586,17 +16654,19 @@ async function promptSyncWithValidatedOutputRetry(client, args, options) {
   const timeoutMs = options.timeoutMs ?? 300000;
   const callContext = options.callContext ?? "subagent";
   const fallbacks = options.fallbackModels ?? [];
-  const explicitPrimaryLabel = args.body.model?.providerID && args.body.model.modelID ? `${args.body.model.providerID}/${args.body.model.modelID}` : "primary";
+  const baseBody = { ...args.body };
+  const baseArgs = copyPromptArgs(args, baseBody);
+  const explicitPrimaryLabel = baseBody.model?.providerID && baseBody.model.modelID ? `${baseBody.model.providerID}/${baseBody.model.modelID}` : "primary";
   const totalAttempts = fallbacks.length + 1;
   let firstError = null;
   let lastError = null;
   try {
-    return await attemptAndValidate(client, args, timeoutMs, options.signal, callContext, {
+    return await attemptAndValidate(client, baseArgs, timeoutMs, options.signal, callContext, {
       label: explicitPrimaryLabel,
       attemptIndex: 0,
       isFallback: false,
       totalAttempts,
-      model: args.body.model
+      model: baseBody.model
     }, options);
   } catch (error51) {
     firstError = error51;
@@ -16615,10 +16685,10 @@ async function promptSyncWithValidatedOutputRetry(client, args, options) {
       continue;
     }
     const label = `${parsed.providerID}/${parsed.modelID}`;
-    const attemptArgs = {
-      ...args,
-      body: { ...args.body, model: parsed }
-    };
+    const attemptArgs = copyPromptArgs(baseArgs, {
+      ...baseBody,
+      model: parsed
+    });
     const attempt = {
       label,
       attemptIndex: i + 1,
@@ -151678,7 +151748,7 @@ var init_project_identity2 = __esm(() => {
 });
 
 // src/features/magic-context/workspaces.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 function tableExists(db, tableName) {
   const row = db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name = ? LIMIT 1").get(tableName);
   return Boolean(row);
@@ -151862,7 +151932,7 @@ function computeWorkspaceEpochFingerprint(db, identities) {
   const canonical = uniqueSorted(identities.filter((identity) => identity.length > 0));
   const epochs = getEpochMap(db, canonical);
   const shareCategories = selectWorkspaceShareCategories(db, canonical);
-  const hash2 = createHash2("sha256");
+  const hash2 = createHash3("sha256");
   hash2.update("share_categories", "utf8");
   hash2.update("\x00");
   hash2.update(shareCategories === null ? "NO_WORKSPACE" : JSON.stringify(shareCategories), "utf8");
@@ -153501,7 +153571,7 @@ var init_migrations = __esm(() => {
 });
 
 // src/features/magic-context/project-docs-hash.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 import { lstatSync, readFileSync as readFileSync6, statSync as statSync3 } from "node:fs";
 import path4 from "node:path";
 function canonicalizeDocContent(raw) {
@@ -153591,7 +153661,7 @@ function hashCanonicalPieces(hashPieces) {
   if (hashPieces.length === 0) {
     return "";
   }
-  return createHash3("sha256").update(hashPieces.join(PROJECT_DOCS_DELIMITER), "utf8").digest("hex");
+  return createHash4("sha256").update(hashPieces.join(PROJECT_DOCS_DELIMITER), "utf8").digest("hex");
 }
 function readProjectDocsCanonical(projectDirectory) {
   const canonicalDirectory = path4.resolve(projectDirectory);
@@ -153671,13 +153741,13 @@ function stableStringify(value, seen = new WeakSet) {
 }
 
 // src/features/magic-context/tool-definition-tokens.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 function keyFor(providerID, modelID, agentName) {
   const agent = agentName && agentName.length > 0 ? agentName : "default";
   return `${providerID}/${modelID}/${agent}`;
 }
 function fingerprintFor(description, parameters) {
-  return createHash4("sha256").update(description).update("\x00").update(stableStringify(parameters)).digest("hex");
+  return createHash5("sha256").update(description).update("\x00").update(stableStringify(parameters)).digest("hex");
 }
 function setDatabase(db) {
   persistenceDb = db;
@@ -155326,10 +155396,10 @@ var init_storage_db = __esm(async () => {
 });
 
 // src/features/magic-context/storage-embedding-measurements.ts
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 function normalizedQueryHash(query) {
   const normalized = query.trim().replace(/\s+/g, " ").toLowerCase();
-  return createHash5("sha256").update(normalized).digest("hex");
+  return createHash6("sha256").update(normalized).digest("hex");
 }
 function recordEmbeddingMeasurement(db, input) {
   const queryTextHash = normalizedQueryHash(input.queryText);
@@ -168888,13 +168958,13 @@ var init_embedding_cache = __esm(() => {
 });
 
 // src/features/magic-context/memory/normalize-hash.ts
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 function normalizeMemoryContent(content) {
   return content.toLowerCase().replace(/\s+/g, " ").trim();
 }
 function computeNormalizedHash(content) {
   const normalized = normalizeMemoryContent(content);
-  return createHash7("md5").update(normalized).digest("hex");
+  return createHash8("md5").update(normalized).digest("hex");
 }
 var init_normalize_hash = () => {};
 
@@ -170617,7 +170687,7 @@ var init_recursive_text_splitter = __esm(() => {
 });
 
 // src/features/magic-context/compartment-chunk-embedding.ts
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 function getLoadFtsRowsStatement(db) {
   let stmt = loadFtsRowsStatements.get(db);
   if (!stmt) {
@@ -170728,7 +170798,7 @@ function parseCanonicalLineRange(line) {
   return { start, end };
 }
 function hashChunkText(text) {
-  return createHash9("sha256").update(text).digest("hex");
+  return createHash10("sha256").update(text).digest("hex");
 }
 function vectorBlob2(vector) {
   return new Uint8Array(vector.buffer, vector.byteOffset, vector.byteLength);
@@ -171138,7 +171208,7 @@ function cosineSimilarity(a, b) {
 }
 
 // src/features/magic-context/memory/embedding-synapse.ts
-import { createHash as createHash10 } from "node:crypto";
+import { createHash as createHash11 } from "node:crypto";
 function isPermanentSynapseCode(code) {
   return code === "artifact_invalid" || code === "substitution_rejected" || code === "not_certified" || code === "probe_required" || code === "idempotency_conflict" || code === "schema_violation";
 }
@@ -171202,7 +171272,7 @@ function wait(ms) {
   return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 function sha256(value) {
-  return createHash10("sha256").update(value).digest("hex");
+  return createHash11("sha256").update(value).digest("hex");
 }
 function stableJson(value) {
   if (Array.isArray(value))
@@ -172684,7 +172754,7 @@ var init_sweep_coordinator = __esm(() => {
 });
 
 // src/features/magic-context/project-embedding-registry.ts
-import { createHash as createHash11, randomUUID as randomUUID4 } from "node:crypto";
+import { createHash as createHash12, randomUUID as randomUUID4 } from "node:crypto";
 function markProjectLoadUntrusted(projectIdentity) {
   untrustedLoadProjects.add(projectIdentity);
 }
@@ -172849,10 +172919,10 @@ function stableStringify2(value) {
   return JSON.stringify(value);
 }
 function sha256Prefix(value, length = 16) {
-  return createHash11("sha256").update(value).digest("hex").slice(0, length);
+  return createHash12("sha256").update(value).digest("hex").slice(0, length);
 }
 function contentSha256(value) {
-  return createHash11("sha256").update(value).digest("hex");
+  return createHash12("sha256").update(value).digest("hex");
 }
 function getRuntimeFingerprint(config2) {
   if (config2.provider === "off") {
@@ -181623,6 +181693,19 @@ var init_compartment_embedding = __esm(() => {
 
 // src/hooks/magic-context/compaction-marker-manager.ts
 import { join as join18 } from "node:path";
+function dropMarkerSummaryTag(db, sessionId, summaryMessageId) {
+  const tagNumber = getTagNumberByMessageId(db, sessionId, `${summaryMessageId}:p0`);
+  if (tagNumber !== null)
+    updateTagStatus(db, sessionId, tagNumber, "dropped");
+}
+function persistMarkerStateAndDropReplacedTag(db, sessionId, state, replacedSummaryMessageId) {
+  db.transaction(() => {
+    setPersistedCompactionMarkerState(db, sessionId, state);
+    if (replacedSummaryMessageId !== null) {
+      dropMarkerSummaryTag(db, sessionId, replacedSummaryMessageId);
+    }
+  })();
+}
 function validatePendingTarget(db, sessionId, pending) {
   const ocMessage = getOpenCodeMessageById(sessionId, pending.endMessageId);
   if (!ocMessage) {
@@ -181690,6 +181773,7 @@ function applyDeferredCompactionMarker(db, sessionId, pending, directory) {
         error: new Error(`no user boundary found at or before endMessageId ${pending.endMessageId} (ordinal ${pending.ordinal}); preserving existing marker`)
       };
     }
+    const removedSummaryMessageId = existing?.summaryMessageId ?? null;
     if (existing) {
       const removed = removeCompactionMarker(existing);
       if (!removed) {
@@ -181714,17 +181798,15 @@ function applyDeferredCompactionMarker(db, sessionId, pending, directory) {
         error: new Error(`injectCompactionMarker returned null for ordinal ${pending.ordinal}; will retry`)
       };
     }
-    setPersistedCompactionMarkerState(db, sessionId, {
+    persistMarkerStateAndDropReplacedTag(db, sessionId, {
       ...result,
       boundaryOrdinal: pending.ordinal,
       targetEndMessageId: pending.endMessageId
-    });
+    }, removedSummaryMessageId);
     sessionLog(sessionId, `compaction-marker drain: applied at ordinal ${pending.ordinal}, boundary user msg ${result.boundaryMessageId}`);
     return {
       kind: "applied",
-      markerOrdinal: pending.ordinal,
-      summaryMessageId: result.summaryMessageId,
-      boundaryMessageId: result.boundaryMessageId
+      markerOrdinal: pending.ordinal
     };
   } catch (err) {
     const error51 = err instanceof Error ? err : new Error(String(err));
@@ -181742,6 +181824,7 @@ function updateCompactionMarkerAfterPublication(db, sessionId, lastCompartmentEn
     return false;
   }
   const existing = getPersistedCompactionMarkerState(db, sessionId);
+  const removedSummaryMessageId = existing?.summaryMessageId ?? null;
   if (existing) {
     if (existingMarkerAlreadyCoversTarget(sessionId, existing, lastCompartmentEnd, targetEndMessageId)) {
       return true;
@@ -181758,7 +181841,7 @@ function updateCompactionMarkerAfterPublication(db, sessionId, lastCompartmentEn
       sessionLog(sessionId, `compaction-marker: failed to remove old boundary at ordinal ${existing.boundaryOrdinal}; preserving persisted state for retry (not injecting new marker this pass)`);
       return false;
     }
-    setPersistedCompactionMarkerState(db, sessionId, null);
+    persistMarkerStateAndDropReplacedTag(db, sessionId, null, removedSummaryMessageId);
     sessionLog(sessionId, `compaction-marker: removed old boundary at ordinal ${existing.boundaryOrdinal}, moving to ${lastCompartmentEnd}`);
   }
   const result = injectCompactionMarker({
@@ -181770,11 +181853,11 @@ function updateCompactionMarkerAfterPublication(db, sessionId, lastCompartmentEn
     resolvedBoundary: boundary
   });
   if (result) {
-    setPersistedCompactionMarkerState(db, sessionId, {
+    persistMarkerStateAndDropReplacedTag(db, sessionId, {
       ...result,
       boundaryOrdinal: lastCompartmentEnd,
       targetEndMessageId
-    });
+    }, removedSummaryMessageId);
     sessionLog(sessionId, `compaction-marker: injected at ordinal ${lastCompartmentEnd}, boundary user msg ${result.boundaryMessageId}`);
     return true;
   }
@@ -181849,6 +181932,7 @@ var MARKER_SUMMARY_TEXT = "[Compacted by magic-context — session history is ma
 var init_compaction_marker_manager = __esm(async () => {
   init_compartment_storage();
   init_storage_meta_persisted();
+  init_storage_tags();
   init_data_path();
   init_logger();
   await __promiseAll([
@@ -184097,7 +184181,7 @@ function softRefreshCachedM1(options) {
 }
 function prependM0M1Messages(sessionId, messages, m0Text, m1Text) {
   messages.unshift({
-    info: { role: "user", sessionID: sessionId },
+    info: { role: "user", sessionID: sessionId, syntheticHead: true },
     parts: [
       {
         type: "text",
@@ -184106,7 +184190,7 @@ function prependM0M1Messages(sessionId, messages, m0Text, m1Text) {
       }
     ]
   }, {
-    info: { role: "user", sessionID: sessionId },
+    info: { role: "user", sessionID: sessionId, syntheticHead: true },
     parts: [{ type: "text", text: m1Text, synthetic: true }]
   });
 }
@@ -190914,6 +190998,7 @@ init_magic_context();
 
 // src/config/transform-mode.ts
 var warnedShadowProjects = new Set;
+var warnedCavemanProjects = new Set;
 var RUST_REQUIRES_USER_SUBC_WARNING = "rust mode requires user-level subc configuration; running ts.";
 var SHADOW_TRANSFORM_WARNING = 'shadow_transform is ignored while transform_mode is "rust" (a session cannot shadow itself); shadow disabled for these sessions.';
 var CAVEMAN_RUST_WARNING = "caveman_text_compression is TS-only and inert in rust mode.";
@@ -190933,7 +191018,11 @@ function resolveTransformMode(args) {
     }
   }
   if (args.configured === "rust" && args.cavemanCompressionEnabled) {
-    warnings.push(CAVEMAN_RUST_WARNING);
+    const projectKey = args.projectKey ?? "<unspecified-project>";
+    if (!warnedCavemanProjects.has(projectKey)) {
+      warnedCavemanProjects.add(projectKey);
+      warnings.push(CAVEMAN_RUST_WARNING);
+    }
   }
   return { mode: args.configured, warnings };
 }
@@ -192131,7 +192220,7 @@ await init_storage_db();
 // src/features/magic-context/v22-deferred-backfill.ts
 init_logger();
 init_project_identity();
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 import { realpathSync as realpathSync2 } from "node:fs";
 import path5 from "node:path";
 
@@ -192193,7 +192282,7 @@ function computeLegacyRustDirIdentity(rawProjectPath) {
   } catch {
     canonical = path5.isAbsolute(rawProjectPath) ? rawProjectPath : path5.join(process.cwd(), rawProjectPath);
   }
-  return `dir:${createHash6("sha256").update(canonical, "utf8").digest("hex")}`;
+  return `dir:${createHash7("sha256").update(canonical, "utf8").digest("hex")}`;
 }
 function upsertRekeyMap(db, oldProjectPath, newProjectPath, rekeyedAt) {
   db.prepare(`INSERT INTO v22_identity_rekey_map (old_project_path, new_project_path, rekeyed_at)
@@ -195670,7 +195759,7 @@ function recordRetrospectiveWindowProcessed(db, projectPath, windowKey) {
 init_task_config();
 
 // src/features/magic-context/dreamer/task-executor.ts
-import { createHash as createHash13 } from "node:crypto";
+import { createHash as createHash14 } from "node:crypto";
 import { existsSync as existsSync20 } from "node:fs";
 
 // src/agents/dreamer.ts
@@ -196965,7 +197054,7 @@ function throwIfAborted2(signal) {
 }
 
 // src/features/magic-context/smart-notes/compiler.ts
-import { createHash as createHash12 } from "node:crypto";
+import { createHash as createHash13 } from "node:crypto";
 init_shared();
 init_assistant_message_extractor();
 init_logger();
@@ -197373,7 +197462,7 @@ function manifestAdvisoryWarnings(code, manifest) {
   return warnings;
 }
 function hashCheck(surfaceCondition, compiledCheck, manifest, checkCron) {
-  return createHash12("sha256").update(surfaceCondition ?? "").update("\x00").update(compiledCheck).update("\x00").update(JSON.stringify(manifest)).update("\x00").update(checkCron).digest("hex");
+  return createHash13("sha256").update(surfaceCondition ?? "").update("\x00").update(compiledCheck).update("\x00").update(JSON.stringify(manifest)).update("\x00").update(checkCron).digest("hex");
 }
 function extractJsonObject(output) {
   const fenced = output.match(/```(?:json)?\s*([\s\S]*?)```/i);
@@ -199842,7 +199931,7 @@ function parseFrictionGateVerdict(verdict) {
 }
 function computeRetrospectiveWindowKey(flagged) {
   const anchors = flagged.map((message) => `${message.sessionId}:${message.ts}`).sort().join("|");
-  return createHash13("sha256").update(anchors).digest("hex").slice(0, 32);
+  return createHash14("sha256").update(anchors).digest("hex").slice(0, 32);
 }
 function renderFrictionWindow(messages, flaggedOrdinals, radius = 2) {
   const flagged = new Set(flaggedOrdinals);
@@ -201114,7 +201203,7 @@ init_logger();
 // src/plugin/embedding-bootstrap-helpers.ts
 init_embedding();
 init_logger();
-import { createHash as createHash14 } from "node:crypto";
+import { createHash as createHash15 } from "node:crypto";
 var EMBEDDING_AFFECTING_KEYS = new Set([
   "embedding.api_key",
   "embedding.endpoint",
@@ -201160,7 +201249,7 @@ var EMBEDDING_WARNING_TERMS = [
 ];
 var loggedFailureSignatures = new Map;
 function sha256Prefix2(value, length = 16) {
-  return createHash14("sha256").update(value).digest("hex").slice(0, length);
+  return createHash15("sha256").update(value).digest("hex").slice(0, length);
 }
 function warningLooksEmbeddingRelated(message) {
   const lower = message.toLowerCase();
@@ -201450,7 +201539,18 @@ function resolveTrustedContextLimit(providerID, modelID, ctx) {
       return detected;
     return fromModelsDev;
   }
-  return detected;
+  if (detected !== undefined) {
+    return detected;
+  }
+  if (modelKey && ctx?.db && ctx.sessionID) {
+    try {
+      const persisted = loadPersistedUsage(ctx.db, ctx.sessionID);
+      if (persisted?.lastObservedModelKey === modelKey && isSaneLimit(persisted.lastUsageContextLimit)) {
+        return persisted.lastUsageContextLimit;
+      }
+    } catch {}
+  }
+  return;
 }
 function resolveCacheTtl(cacheTtl, modelKey) {
   if (typeof cacheTtl === "string") {
@@ -204170,15 +204270,15 @@ function verdictFromToolsMap(tools) {
 function resolveCtxReduceAvailabilityFromMessages(sessionId, messages) {
   const cached2 = availabilityBySession.get(sessionId);
   if (cached2 !== undefined)
-    return cached2;
+    return { callable: cached2, frozen: true };
   for (const message of messages) {
     if (message.info?.role !== "user")
       continue;
     const verdict = verdictFromToolsMap(message.info.tools) ?? true;
     availabilityBySession.set(sessionId, verdict);
-    return verdict;
+    return { callable: verdict, frozen: true };
   }
-  return true;
+  return { callable: true, frozen: false };
 }
 function resolveCtxReduceAvailability(sessionId) {
   const cached2 = availabilityBySession.get(sessionId);
@@ -205184,9 +205284,9 @@ function loadContextUsage(contextUsageMap, db, sessionId) {
   }
   return { percentage: 0, inputTokens: 0 };
 }
-function resolveSchedulerDecision(scheduler, sessionMeta, contextUsage, sessionId, modelKey) {
+function resolveSchedulerDecision(scheduler, sessionMeta, contextUsage, sessionId, modelKey, contextLimit) {
   try {
-    const schedulerDecision = scheduler.shouldExecute(sessionMeta, contextUsage, undefined, sessionId, modelKey);
+    const schedulerDecision = scheduler.shouldExecute(sessionMeta, contextUsage, undefined, sessionId, modelKey, contextLimit);
     sessionLog(sessionId, `transform scheduler: percentage=${contextUsage.percentage.toFixed(1)}% inputTokens=${contextUsage.inputTokens} cacheTtl=${sessionMeta.cacheTtl} lastResponseTime=${sessionMeta.lastResponseTime} decision=${schedulerDecision}`);
     return schedulerDecision;
   } catch (error51) {
@@ -205216,6 +205316,34 @@ function messageInfo2(value) {
     return {};
   return isRecord3(value.info) ? value.info : value;
 }
+function newestUserMessage(messages) {
+  for (let index = messages.length - 1;index >= 0; index -= 1) {
+    if (messageInfo2(messages[index]).role === "user")
+      return messages[index];
+  }
+  return;
+}
+function isSyntheticUserMessage(message) {
+  if (!message || messageInfo2(message).role !== "user" || !Array.isArray(message.parts)) {
+    return false;
+  }
+  return message.parts.length > 0 && message.parts.every((part) => isRecord3(part) && (part.synthetic === true || part.ignored === true));
+}
+function observeSyntheticTurn(state, messages) {
+  const newest = newestUserMessage(messages);
+  const info = messageInfo2(newest);
+  const messageId2 = typeof info.id === "string" ? info.id : null;
+  const synthetic = isSyntheticUserMessage(newest);
+  const isNewMessage = messageId2 === null || messageId2 !== state.lastObservedUserMessageId;
+  if (!synthetic) {
+    state.syntheticTurnCount = 0;
+    state.syntheticLoopBreakerLogged = false;
+  } else if (isNewMessage) {
+    state.syntheticTurnCount += 1;
+  }
+  state.lastObservedUserMessageId = messageId2;
+  return synthetic;
+}
 function assertNativeBoundary(output, sessionId, boundaryId) {
   const first = output.find((message) => messageInfo2(message).role !== "system");
   const info = messageInfo2(first);
@@ -205265,7 +205393,10 @@ function ensureState(states, sessionId) {
       lastAckedSeq: 0,
       lastAckedWatermarks: null,
       idOrdinalMemoGeneration: 0,
-      idOrdinalMemo: new Map
+      idOrdinalMemo: new Map,
+      syntheticTurnCount: 0,
+      lastObservedUserMessageId: null,
+      syntheticLoopBreakerLogged: false
     };
     states.set(sessionId, state);
   }
@@ -205337,6 +205468,7 @@ function buildTransformBody(args) {
     mid_turn: args.midTurn,
     model_key: args.modelKey,
     provider_id: args.providerId,
+    tool_present: args.passInputs.tool_present === true,
     effective_execute_threshold: args.passInputs.effective_execute_threshold,
     history_budget_tokens: args.passInputs.history_budget_tokens,
     clear_reasoning_age: args.passInputs.clear_reasoning_age,
@@ -205440,6 +205572,12 @@ function createRustModeTransform(deps, options) {
   const run = async (sessionId, messages, output, sessionMeta) => {
     const state = ensureState(states, sessionId);
     state.passCount += 1;
+    const syntheticTurn = observeSyntheticTurn(state, messages);
+    const syntheticLoopBlocked = syntheticTurn && state.syntheticTurnCount >= 3;
+    if (syntheticLoopBlocked && !state.syntheticLoopBreakerLogged) {
+      state.syntheticLoopBreakerLogged = true;
+      sessionLog(sessionId, "RUST LOOP BREAKER: suppressing host directives after three consecutive synthetic turns until a real user message arrives");
+    }
     const inputCount = messages.length;
     let decision = "error";
     let servedFrom = "none";
@@ -205462,6 +205600,8 @@ function createRustModeTransform(deps, options) {
       }
     }
     const rawMessages = messages.slice();
+    const reduceAvailability = resolveCtxReduceAvailability(sessionId);
+    const toolPresent = reduceAvailability.frozen && reduceAvailability.callable;
     try {
       const { directory } = await getSessionDirectory(deps, sessionId);
       const model = modelFromMessages(messages) ?? findLastAssistantModelFromOpenCodeDb(sessionId);
@@ -205487,7 +205627,8 @@ function createRustModeTransform(deps, options) {
         clear_reasoning_age: deps.clearReasoningAge,
         cache_ttl: sessionMeta.cacheTtl,
         mid_turn: midTurn,
-        is_subagent: sessionMeta.isSubagent
+        is_subagent: sessionMeta.isSubagent,
+        tool_present: toolPresent
       };
       const resolved = await resolveOrdinalsForModule({
         sessionId,
@@ -205592,7 +205733,11 @@ function createRustModeTransform(deps, options) {
       state.parked = false;
       state.passesSincePark = 0;
       const directiveText = directiveTextOf(response);
-      if (directiveText) {
+      if (syntheticTurn) {
+        try {
+          casChannel2NudgeState(deps.db, sessionId, "pending", "");
+        } catch {}
+      } else if (directiveText) {
         try {
           casChannel2NudgeState(deps.db, sessionId, "", "pending");
           await maybeDeliverChannel2(sessionId, {
@@ -206355,6 +206500,8 @@ function hasToolPartWithCallId(message, callId) {
   return false;
 }
 function isReplayableAssistantAnchor(message) {
+  if (message.info.summary === true)
+    return false;
   return message.info.error === undefined || message.info.error === null;
 }
 function appendReminderToUserMessage(message, reminder) {
@@ -207075,6 +207222,8 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
   };
 }
 // src/hooks/magic-context/transform-postprocess-phase.ts
+init_storage_meta_persisted();
+init_storage_tags();
 init_logger();
 await init_storage();
 
@@ -207149,7 +207298,7 @@ init_storage_memory_fts();
 // src/features/magic-context/search-measurement.ts
 init_embedding();
 init_storage_embedding_measurements();
-import { createHash as createHash15 } from "node:crypto";
+import { createHash as createHash16 } from "node:crypto";
 function resultId(result) {
   switch (result.source) {
     case "memory":
@@ -207232,7 +207381,7 @@ async function recordShadowMeasurement(args) {
   });
 }
 function sha2562(value) {
-  return createHash15("sha256").update(value).digest("hex");
+  return createHash16("sha256").update(value).digest("hex");
 }
 
 // src/features/magic-context/search.ts
@@ -208937,7 +209086,7 @@ function readFilePath(target) {
 init_tag_content_primitives();
 
 // src/hooks/magic-context/todo-view.ts
-import { createHash as createHash16 } from "node:crypto";
+import { createHash as createHash17 } from "node:crypto";
 var TODO_STATUS_PENDING = "pending";
 var TODO_STATUS_IN_PROGRESS = "in_progress";
 var TODO_STATUS_COMPLETED = "completed";
@@ -209005,7 +209154,7 @@ function buildSyntheticTodoPart(stateJson) {
   };
 }
 function computeSyntheticCallId(stateJson) {
-  const hash2 = createHash16("sha256").update(stateJson).digest("hex").slice(0, 16);
+  const hash2 = createHash17("sha256").update(stateJson).digest("hex").slice(0, 16);
   return `${SYNTHETIC_CALL_ID_PREFIX}${hash2}`;
 }
 function parseTodoState(stateJson) {
@@ -209085,28 +209234,98 @@ var degradedCacheCountBySession = new BoundedSessionMap(100);
 function resetDegradedCacheCount(sessionId) {
   degradedCacheCountBySession.delete(sessionId);
 }
-function injectDeferredCompactionSummaryRepresentation(args) {
-  if (args.messages.some((message) => message.info.id === args.summaryMessageId)) {
+function isSyntheticHeadMessage(message) {
+  if (message.info.syntheticHead !== true)
+    return false;
+  if (message.info.id !== undefined)
     return false;
+  if (message.info.role !== "user")
+    return false;
+  const parts = message.parts;
+  if (parts.length === 0)
+    return false;
+  return parts.every((part) => part.synthetic === true);
+}
+var TODO_HEAD_ANCHOR_ID = "__magic_context_todo_head__";
+function injectSyntheticTodoAtHead(messages, sessionId, part) {
+  let headEnd = 0;
+  while (headEnd < messages.length && isSyntheticHeadMessage(messages[headEnd])) {
+    headEnd += 1;
   }
-  const summaryTagNumber = args.tagger.assignTag(args.sessionId, `${args.summaryMessageId}:p0`, "message", byteSize(MARKER_SUMMARY_TEXT), args.db, 0, null, 0, null, () => ({
+  const existing = messages[headEnd];
+  if (existing?.info.id === TODO_HEAD_ANCHOR_ID) {
+    injectToolPartIntoAssistantById(messages, TODO_HEAD_ANCHOR_ID, part);
+    return TODO_HEAD_ANCHOR_ID;
+  }
+  messages.splice(headEnd, 0, {
+    info: {
+      id: TODO_HEAD_ANCHOR_ID,
+      role: "assistant",
+      sessionID: sessionId
+    },
+    parts: [part]
+  });
+  return TODO_HEAD_ANCHOR_ID;
+}
+function injectPersistedTodoAnchor(messages, sessionId, messageId2, part) {
+  if (injectToolPartIntoAssistantById(messages, messageId2, part))
+    return true;
+  if (messageId2 !== TODO_HEAD_ANCHOR_ID)
+    return false;
+  injectSyntheticTodoAtHead(messages, sessionId, part);
+  return true;
+}
+function dropMarkerSummaryTag2(db, sessionId, summaryMessageId) {
+  const tagNumber = getTagNumberByMessageId(db, sessionId, `${summaryMessageId}:p0`);
+  if (tagNumber !== null)
+    updateTagStatus(db, sessionId, tagNumber, "dropped");
+}
+function reconcileMarkerRepresentation(messages, persistedMarkerState, options) {
+  const retainedMessages = [];
+  const staleSummaryIds = new Set;
+  for (const message of messages) {
+    if (message.info.summary !== true) {
+      retainedMessages.push(message);
+      continue;
+    }
+    const messageId2 = message.info.id;
+    if (typeof messageId2 === "string" && messageId2 !== persistedMarkerState?.summaryMessageId) {
+      staleSummaryIds.add(messageId2);
+    }
+  }
+  if (staleSummaryIds.size > 0) {
+    options.db.transaction(() => {
+      for (const messageId2 of staleSummaryIds) {
+        dropMarkerSummaryTag2(options.db, options.sessionId, messageId2);
+      }
+    })();
+  }
+  const removedSummary = retainedMessages.length !== messages.length;
+  if (removedSummary)
+    messages.splice(0, messages.length, ...retainedMessages);
+  if (persistedMarkerState === null)
+    return removedSummary;
+  const summaryTagNumber = options.tagger.assignTag(options.sessionId, `${persistedMarkerState.summaryMessageId}:p0`, "message", byteSize(MARKER_SUMMARY_TEXT), options.db, 0, null, 0, null, () => ({
     tokenCount: estimateTokens(MARKER_SUMMARY_TEXT),
     inputTokenCount: null,
     reasoningTokenCount: null
   }));
-  const summaryText = args.ctxReduceCallable ? prependTag(summaryTagNumber, MARKER_SUMMARY_TEXT) : MARKER_SUMMARY_TEXT;
+  const summaryText = options.ctxReduceAvailability.frozen && options.ctxReduceAvailability.callable ? prependTag(summaryTagNumber, MARKER_SUMMARY_TEXT) : MARKER_SUMMARY_TEXT;
   const summaryMessage = {
     info: {
-      id: args.summaryMessageId,
+      id: persistedMarkerState.summaryMessageId,
       role: "assistant",
-      sessionID: args.sessionId,
+      sessionID: options.sessionId,
       summary: true,
       finish: "stop"
     },
     parts: [{ type: "text", text: summaryText }]
   };
-  const firstTailAssistant = args.messages.findIndex((message) => message.info.role === "assistant" && message.info.summary !== true);
-  args.messages.splice(firstTailAssistant >= 0 ? firstTailAssistant : args.messages.length, 0, summaryMessage);
+  let retainedTailStart = 0;
+  while (retainedTailStart < messages.length && isSyntheticHeadMessage(messages[retainedTailStart])) {
+    retainedTailStart += 1;
+  }
+  messages.splice(retainedTailStart, 0, summaryMessage);
   return true;
 }
 function pendingMarkerCoveredByConsumedBoundary(pending, injection) {
@@ -209488,6 +209707,53 @@ async function runPostTransformPhase(args) {
     }
   }
   logTransformTiming(args.sessionId, "pp.nudgeAndSticky", tNudgeBlock);
+  const explicitRebuildHappened = args.historyRefreshExplicitBeforePrepare && args.rebuiltHistoryFromInitialPrepare;
+  const materializationSatisfied = !deferredMaterializationWasPending || explicitMaterializedSuccessfully || deferredMaterializedSuccessfully;
+  const historyWasConsumedThisPass = args.historyRebuiltThisPass && (args.canConsumeDeferredLate || args.phaseJustAwaitedPublication || explicitRebuildHappened) && materializationSatisfied;
+  let suppressV12HistoryDrain = false;
+  if (historyWasConsumedThisPass && args.deferredHistoryWasPendingAtPassStart) {
+    const pending = getPendingCompactionMarkerState(args.db, args.sessionId);
+    if (pending) {
+      if (!pendingMarkerCoveredByConsumedBoundary(pending, args.pendingCompartmentInjection)) {
+        suppressV12HistoryDrain = true;
+        sessionLog(args.sessionId, `compaction-marker drain: pending ordinal ${pending.ordinal} is newer than consumed boundary ${args.pendingCompartmentInjection?.compartmentEndMessage ?? "<none>"}; preserving deferred history refresh signal`);
+      } else {
+        const outcome = applyDeferredCompactionMarker(args.db, args.sessionId, pending, args.sessionDirectory);
+        switch (outcome.kind) {
+          case "applied":
+          case "already-current":
+          case "stale-skip":
+            if (clearPendingCompactionMarkerAfterSuccessfulDrain({
+              db: args.db,
+              sessionId: args.sessionId,
+              pending,
+              deferredHistoryRefreshSessions: args.deferredHistoryRefreshSessions
+            }) === "cas-lost-newer-pending") {
+              suppressV12HistoryDrain = true;
+            }
+            break;
+          case "retryable-failure":
+            args.passOutcome?.record("compaction-marker-drain-failure");
+            sessionLog(args.sessionId, "compaction-marker drain: retryable failure; preserving deferred history refresh signal", outcome.error);
+            suppressV12HistoryDrain = true;
+            break;
+        }
+      }
+    }
+  }
+  reconcileMarkerRepresentation(args.messages, getPersistedCompactionMarkerState(args.db, args.sessionId), {
+    db: args.db,
+    sessionId: args.sessionId,
+    tagger: args.tagger,
+    ctxReduceAvailability: args.ctxReduceAvailability
+  });
+  const deferredHistoryDrainEligible = historyWasConsumedThisPass && args.deferredHistoryWasPendingAtPassStart && !suppressV12HistoryDrain;
+  if (deferredHistoryDrainEligible) {
+    args.deferredHistoryRefreshSessions.delete(args.sessionId);
+  }
+  if ((explicitMaterializedSuccessfully || deferredMaterializedSuccessfully) && deferredMaterializationAtPassStart) {
+    args.deferredMaterializationSessions.delete(args.sessionId);
+  }
   const tNoteAndTodo = performance.now();
   const noteReadStillVisible = args.fullFeatureMode ? hasVisibleNoteReadCall(args.messages) : false;
   const deferredNoteText = args.fullFeatureMode ? peekNoteNudgeText(args.db, args.sessionId, args.currentTurnId, args.projectPath, noteReadStillVisible) : null;
@@ -209512,29 +209778,22 @@ async function runPostTransformPhase(args) {
         if (persistedAnchor) {
           clearPersistedTodoSyntheticAnchor(args.db, args.sessionId);
         }
-      } else if (persistedAnchor && persistedAnchor.callId === part.callID && injectToolPartIntoAssistantById(args.messages, persistedAnchor.messageId, part)) {
+      } else if (persistedAnchor && persistedAnchor.callId === part.callID && injectPersistedTodoAnchor(args.messages, args.sessionId, persistedAnchor.messageId, part)) {
         if (persistedAnchor.stateJson.length === 0) {
           setPersistedTodoSyntheticAnchor(args.db, args.sessionId, persistedAnchor.callId, persistedAnchor.messageId, args.sessionMeta.lastTodoState);
         }
       } else {
-        const anchoredMessageId = injectToolPartIntoLatestAssistant(args.messages, part);
-        if (anchoredMessageId) {
-          setPersistedTodoSyntheticAnchor(args.db, args.sessionId, part.callID, anchoredMessageId, args.sessionMeta.lastTodoState);
-        } else if (persistedAnchor) {
-          clearPersistedTodoSyntheticAnchor(args.db, args.sessionId);
-        }
+        const anchoredMessageId = injectToolPartIntoLatestAssistant(args.messages, part) ?? injectSyntheticTodoAtHead(args.messages, args.sessionId, part);
+        setPersistedTodoSyntheticAnchor(args.db, args.sessionId, part.callID, anchoredMessageId, args.sessionMeta.lastTodoState);
       }
     } else if (persistedAnchor && persistedAnchor.stateJson.length > 0) {
       const part = buildSyntheticTodoPart(persistedAnchor.stateJson);
       if (part !== null && part.callID === persistedAnchor.callId) {
-        injectToolPartIntoAssistantById(args.messages, persistedAnchor.messageId, part);
+        injectPersistedTodoAnchor(args.messages, args.sessionId, persistedAnchor.messageId, part);
       }
     }
   }
   logTransformTiming(args.sessionId, "pp.noteAndTodoSynthesis", tNoteAndTodo);
-  const explicitRebuildHappened = args.historyRefreshExplicitBeforePrepare && args.rebuiltHistoryFromInitialPrepare;
-  const materializationSatisfied = !deferredMaterializationWasPending || explicitMaterializedSuccessfully || deferredMaterializedSuccessfully;
-  const historyWasConsumedThisPass = args.historyRebuiltThisPass && (args.canConsumeDeferredLate || args.phaseJustAwaitedPublication || explicitRebuildHappened) && materializationSatisfied;
   if (args.compartmentInjectionRebuiltFromDb && args.pendingCompartmentInjection) {
     if (args.pendingCompartmentInjection.compartmentEndMessageId === null) {
       const nextCount = (degradedCacheCountBySession.get(args.sessionId) ?? 0) + 1;
@@ -209546,54 +209805,6 @@ async function runPostTransformPhase(args) {
       degradedCacheCountBySession.delete(args.sessionId);
     }
   }
-  let suppressV12HistoryDrain = false;
-  if (historyWasConsumedThisPass && args.deferredHistoryWasPendingAtPassStart) {
-    const pending = getPendingCompactionMarkerState(args.db, args.sessionId);
-    if (pending) {
-      if (!pendingMarkerCoveredByConsumedBoundary(pending, args.pendingCompartmentInjection)) {
-        suppressV12HistoryDrain = true;
-        sessionLog(args.sessionId, `compaction-marker drain: pending ordinal ${pending.ordinal} is newer than consumed boundary ${args.pendingCompartmentInjection?.compartmentEndMessage ?? "<none>"}; preserving deferred history refresh signal`);
-      } else {
-        const outcome = applyDeferredCompactionMarker(args.db, args.sessionId, pending, args.sessionDirectory);
-        if (outcome.kind === "applied") {
-          injectDeferredCompactionSummaryRepresentation({
-            db: args.db,
-            sessionId: args.sessionId,
-            messages: args.messages,
-            tagger: args.tagger,
-            summaryMessageId: outcome.summaryMessageId,
-            ctxReduceCallable: args.ctxReduceCallable
-          });
-        }
-        switch (outcome.kind) {
-          case "applied":
-          case "already-current":
-          case "stale-skip":
-            if (clearPendingCompactionMarkerAfterSuccessfulDrain({
-              db: args.db,
-              sessionId: args.sessionId,
-              pending,
-              deferredHistoryRefreshSessions: args.deferredHistoryRefreshSessions
-            }) === "cas-lost-newer-pending") {
-              suppressV12HistoryDrain = true;
-            }
-            break;
-          case "retryable-failure":
-            args.passOutcome?.record("compaction-marker-drain-failure");
-            sessionLog(args.sessionId, "compaction-marker drain: retryable failure; preserving deferred history refresh signal", outcome.error);
-            suppressV12HistoryDrain = true;
-            break;
-        }
-      }
-    }
-  }
-  const deferredHistoryDrainEligible = historyWasConsumedThisPass && args.deferredHistoryWasPendingAtPassStart && !suppressV12HistoryDrain;
-  if (deferredHistoryDrainEligible) {
-    args.deferredHistoryRefreshSessions.delete(args.sessionId);
-  }
-  if ((explicitMaterializedSuccessfully || deferredMaterializedSuccessfully) && deferredMaterializationAtPassStart) {
-    args.deferredMaterializationSessions.delete(args.sessionId);
-  }
   if (args.fullFeatureMode && isCacheBustingPass && args.m0M1 && (!!args.m0M1.projectPath || !!args.m0M1.projectDirectory)) {
     checkM0MutationDriftAndSignal({
       db: args.db,
@@ -209823,7 +210034,8 @@ function createTransform(deps) {
     }
     const reducedMode = sessionMeta.isSubagent;
     const fullFeatureMode = !reducedMode;
-    const ctxReduceCallable = resolveCtxReduceAvailabilityFromMessages(sessionId, messages);
+    const ctxReduceAvailability = resolveCtxReduceAvailabilityFromMessages(sessionId, messages);
+    const ctxReduceCallable = ctxReduceAvailability.callable;
     let sessionDirectory = deps.directory ?? "";
     let sessionDirectoryResolvedFromHost = false;
     const cachedDirectory = deps.sessionDirectoryBySession?.get(sessionId);
@@ -209973,7 +210185,7 @@ function createTransform(deps) {
       tokensConfig: deps.executeThresholdTokens,
       contextLimit: emergencyCeilingLimit
     }) / 100)) : undefined;
-    const schedulerDecisionEarly = resolveSchedulerDecision(deps.scheduler, sessionMeta, contextUsageEarly, sessionId, deps.getModelKey?.(sessionId));
+    const schedulerDecisionEarly = resolveSchedulerDecision(deps.scheduler, sessionMeta, contextUsageEarly, sessionId, deps.getModelKey?.(sessionId), resolvedContextLimit);
     const midTurn = isMidTurn(deps, resolvedSessionId);
     const bypassReason = detectMidTurnBypassReason({
       contextUsage: contextUsageEarly,
@@ -210329,7 +210541,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       reasoningByMessage,
       messageTagNumbers,
       tagger: deps.tagger,
-      ctxReduceCallable,
+      ctxReduceAvailability,
       batch,
       contextUsage,
       schedulerDecision,
@@ -211660,7 +211872,7 @@ function createToolExecuteAfterHook(args) {
 init_send_session_notification();
 
 // src/hooks/magic-context/system-prompt-hash.ts
-import { createHash as createHash17 } from "node:crypto";
+import { createHash as createHash18 } from "node:crypto";
 
 // src/agents/magic-context-prompt.ts
 init_language_directive();
@@ -211864,7 +212076,7 @@ function createSystemPromptHashHandler(deps) {
       return;
     if (!availability.frozen)
       return;
-    const currentHash = createHash17("md5").update(systemContent).digest("hex");
+    const currentHash = createHash18("md5").update(systemContent).digest("hex");
     if (!sessionMetaEarly) {
       return;
     }
@@ -212939,7 +213151,13 @@ init_decay_render();
 init_read_session_formatting();
 await init_inject_compartments();
 function computeM0BlockTokens(db, sessionId, args) {
-  const { m0Text, projectIdentity, injectionBudgetTokens, memoryBlockCount } = args;
+  const {
+    m0Text,
+    projectIdentity,
+    injectionBudgetTokens,
+    memoryBlockCount,
+    compartmentTokensOverride
+  } = args;
   const docsBlock = extractM0Block(m0Text, "project-docs");
   const docsTokens = docsBlock ? estimateTokens(docsBlock) : 0;
   const profileBlock = extractM0Block(m0Text, "user-profile");
@@ -212953,7 +213171,9 @@ function computeM0BlockTokens(db, sessionId, args) {
   }
   let compartmentTokens = 0;
   const historyBlock = extractM0Block(m0Text, "session-history");
-  if (historyBlock) {
+  if (typeof compartmentTokensOverride === "number" && Number.isFinite(compartmentTokensOverride) && compartmentTokensOverride >= 0) {
+    compartmentTokens = compartmentTokensOverride;
+  } else if (historyBlock) {
     compartmentTokens = estimateTokens(historyBlock);
   } else {
     try {
@@ -213124,7 +213344,8 @@ function buildSidebarSnapshot(db, sessionId, directory, liveSessionState, inject
       m0Text,
       projectIdentity,
       injectionBudgetTokens,
-      memoryBlockCount
+      memoryBlockCount,
+      compartmentTokensOverride: moduleStatus?.compartment_tokens
     });
     const compartmentTokens = m0Blocks.compartmentTokens;
     const factTokens = m0Blocks.factTokens;
@@ -214510,7 +214731,7 @@ Mark discardable once processed: large outputs you've summarized, repeated or re
 Keep: user messages, unresolved errors, raw evidence you haven't extracted yet, and outputs whose exact wording may matter later.
 Never blanket-mark large ranges (e.g. "1-50") — review what each tag holds first.`;
 // src/tools/ctx-reduce/tools.ts
-import { createHash as createHash18 } from "node:crypto";
+import { createHash as createHash19 } from "node:crypto";
 import { tool as tool4 } from "@opencode-ai/plugin";
 
 // src/features/magic-context/range-parser.ts
@@ -214577,11 +214798,11 @@ function createCtxReduceTool(deps) {
       const stableId = `oc-${sessionId}-${callId}`;
       if (Buffer.byteLength(stableId) <= 128)
         return stableId;
-      return `oc-${createHash18("sha256").update(stableId).digest("hex")}`;
+      return `oc-${createHash19("sha256").update(stableId).digest("hex")}`;
     }
     fallbackCommandSequence += 1;
     const monotonicId = `oc-${sessionId}-${fallbackCommandSequence}`;
-    return Buffer.byteLength(monotonicId) <= 128 ? monotonicId : `oc-${createHash18("sha256").update(monotonicId).digest("hex")}`;
+    return Buffer.byteLength(monotonicId) <= 128 ? monotonicId : `oc-${createHash19("sha256").update(monotonicId).digest("hex")}`;
   };
   return tool4({
     description: CTX_REDUCE_DESCRIPTION,
@@ -214998,11 +215219,11 @@ import {
 import { dirname as dirname9 } from "node:path";
 
 // src/shared/rpc-utils.ts
-import { createHash as createHash19 } from "node:crypto";
+import { createHash as createHash20 } from "node:crypto";
 import { join as join21 } from "node:path";
 function projectHash(directory) {
   const normalized = directory.replace(/\/+$/, "");
-  return createHash19("sha256").update(normalized).digest("hex").slice(0, 16);
+  return createHash20("sha256").update(normalized).digest("hex").slice(0, 16);
 }
 function rpcPortDir(storageDir, directory) {
   return join21(storageDir, "rpc", projectHash(directory));