@cortexkit/opencode-magic-context 0.14.1 → 0.15.0

package/dist/index.js

@@ -14215,11 +14215,16 @@ var init_magic_context = __esm(() => {
         enabled: exports_external.boolean().default(false),
         score_threshold: exports_external.number().min(0.3).max(0.95).default(0.55),
         min_prompt_chars: exports_external.number().min(5).max(500).default(20)
-      }).default({ enabled: false, score_threshold: 0.55, min_prompt_chars: 20 })
+      }).default({ enabled: false, score_threshold: 0.55, min_prompt_chars: 20 }),
+      caveman_text_compression: exports_external.object({
+        enabled: exports_external.boolean().default(false),
+        min_chars: exports_external.number().min(100).max(1e4).default(500)
+      }).default({ enabled: false, min_chars: 500 })
     }).default({
       temporal_awareness: false,
       git_commit_indexing: { enabled: false, since_days: 365, max_commits: 2000 },
-      auto_search: { enabled: false, score_threshold: 0.55, min_prompt_chars: 20 }
+      auto_search: { enabled: false, score_threshold: 0.55, min_prompt_chars: 20 },
+      caveman_text_compression: { enabled: false, min_chars: 500 }
     }),
     memory: exports_external.object({
       enabled: exports_external.boolean().default(true),
@@ -15615,6 +15620,77 @@ var init_data_path = () => {};
 function getErrorMessage(error48) {
   return error48 instanceof Error ? error48.message : String(error48);
 }
+function readString(value) {
+  if (typeof value === "string" && value.length > 0)
+    return value;
+  if (typeof value === "number")
+    return String(value);
+  return;
+}
+function clip(value, max) {
+  if (value.length <= max)
+    return value;
+  return `${value.slice(0, max)}\u2026`;
+}
+function describeError(error48) {
+  const stringForm = clip(safeString(error48), 400);
+  if (!(error48 instanceof Error) && !(error48 && typeof error48 === "object")) {
+    return {
+      name: typeof error48,
+      message: "",
+      stringForm,
+      brief: stringForm || "<empty>"
+    };
+  }
+  const obj = error48;
+  const nameFromField = readString(obj.name);
+  const nameFromCtor = error48?.constructor?.name;
+  const name = nameFromField ?? nameFromCtor ?? "Error";
+  const message = readString(obj.message) ?? "";
+  const status = readString(obj.status) ?? readString(obj.statusCode);
+  const code = readString(obj.code);
+  let causeName;
+  const cause = obj.cause;
+  if (cause && typeof cause === "object") {
+    const causeRecord = cause;
+    causeName = readString(causeRecord.name) ?? cause.constructor?.name;
+  }
+  const stack = readString(obj.stack);
+  const stackHead = stack ? stack.split(`
+`).slice(0, 4).map((l) => l.trim()).filter((l) => l.length > 0).join(" | ") : undefined;
+  const briefParts = [];
+  if (name)
+    briefParts.push(name);
+  if (message)
+    briefParts.push(`message="${clip(message, 200)}"`);
+  if (status)
+    briefParts.push(`status=${status}`);
+  if (code)
+    briefParts.push(`code=${code}`);
+  if (causeName)
+    briefParts.push(`cause=${causeName}`);
+  if (!message && stringForm && stringForm !== name) {
+    briefParts.push(`str="${clip(stringForm, 200)}"`);
+  }
+  const brief = briefParts.join(" ") || stringForm || name;
+  return {
+    name,
+    message,
+    ...status ? { status } : {},
+    ...code ? { code } : {},
+    ...causeName ? { causeName } : {},
+    ...stackHead ? { stackHead } : {},
+    stringForm,
+    brief
+  };
+}
+function safeString(value) {
+  try {
+    return String(value);
+  } catch {
+    return "<unstringifiable>";
+  }
+}
 
 // src/features/magic-context/memory/storage-memory-embeddings.ts
 function isEmbeddingBlob(value) {
@@ -150778,6 +150854,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   ensureColumn(db, "tags", "drop_mode", "TEXT DEFAULT 'full'");
   ensureColumn(db, "tags", "tool_name", "TEXT");
   ensureColumn(db, "tags", "input_byte_size", "INTEGER DEFAULT 0");
+  ensureColumn(db, "tags", "caveman_depth", "INTEGER DEFAULT 0");
   ensureColumn(db, "session_meta", "system_prompt_tokens", "INTEGER DEFAULT 0");
   ensureColumn(db, "session_meta", "compaction_marker_state", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "key_files", "TEXT DEFAULT ''");
@@ -151183,7 +151260,10 @@ function incrementHistorianFailure(db, sessionId, error48) {
   db.transaction(() => {
     ensureSessionMetaRow(db, sessionId);
     const current = getHistorianFailureState(db, sessionId);
-    db.prepare("UPDATE session_meta SET historian_failure_count = ?, historian_last_error = ?, historian_last_failure_at = ? WHERE session_id = ?").run(current.failureCount + 1, error48, Date.now(), sessionId);
+    const nextCount = current.failureCount + 1;
+    db.prepare("UPDATE session_meta SET historian_failure_count = ?, historian_last_error = ?, historian_last_failure_at = ? WHERE session_id = ?").run(nextCount, error48, Date.now(), sessionId);
+    const reason = error48.replace(/\s+/g, " ").trim().slice(0, 300);
+    sessionLog(sessionId, `historian failure recorded: count=${nextCount} reason="${reason}"`);
   })();
 }
 function clearHistorianFailureState(db, sessionId) {
@@ -151267,6 +151347,7 @@ function removeStrippedPlaceholderId(db, sessionId, messageId) {
   return true;
 }
 var init_storage_meta_persisted = __esm(() => {
+  init_logger();
   init_storage_meta_shared();
 });
 
@@ -151502,7 +151583,8 @@ function toTagEntry(row) {
     inputByteSize: row.input_byte_size ?? 0,
     byteSize: row.byte_size,
     reasoningByteSize: row.reasoning_byte_size ?? 0,
-    sessionId: row.session_id
+    sessionId: row.session_id,
+    cavemanDepth: typeof row.caveman_depth === "number" && Number.isFinite(row.caveman_depth) ? row.caveman_depth : 0
   };
 }
 function isTagNumberRow(row) {
@@ -151530,6 +151612,9 @@ function updateTagStatus(db, sessionId, tagId, status) {
 function updateTagDropMode(db, sessionId, tagNumber, dropMode) {
   getUpdateTagDropModeStatement(db).run(dropMode, sessionId, tagNumber);
 }
+function updateCavemanDepth(db, sessionId, tagNumber, depth) {
+  db.prepare("UPDATE tags SET caveman_depth = ? WHERE session_id = ? AND tag_number = ?").run(depth, sessionId, tagNumber);
+}
 function updateTagMessageId(db, sessionId, tagId, messageId) {
   getUpdateTagMessageIdStatement(db).run(messageId, sessionId, tagId);
 }
@@ -151549,14 +151634,14 @@ function getMaxTagNumberBySession(db, sessionId) {
   return isMaxTagNumberRow(row) ? row.max_tag_number : 0;
 }
 function getTagsBySession(db, sessionId) {
-  const rows = db.prepare("SELECT id, message_id, type, status, drop_mode, tool_name, input_byte_size, byte_size, reasoning_byte_size, session_id, tag_number FROM tags WHERE session_id = ? ORDER BY tag_number ASC, id ASC").all(sessionId).filter(isTagRow);
+  const rows = db.prepare("SELECT id, message_id, type, status, drop_mode, tool_name, input_byte_size, byte_size, reasoning_byte_size, session_id, tag_number, caveman_depth FROM tags WHERE session_id = ? ORDER BY tag_number ASC, id ASC").all(sessionId).filter(isTagRow);
   return rows.map(toTagEntry);
 }
 function getTopNBySize(db, sessionId, n) {
   if (n <= 0) {
     return [];
   }
-  const rows = db.prepare("SELECT id, message_id, type, status, drop_mode, tool_name, input_byte_size, byte_size, reasoning_byte_size, session_id, tag_number FROM tags WHERE session_id = ? AND status = 'active' ORDER BY byte_size DESC, tag_number ASC LIMIT ?").all(sessionId, n).filter(isTagRow);
+  const rows = db.prepare("SELECT id, message_id, type, status, drop_mode, tool_name, input_byte_size, byte_size, reasoning_byte_size, session_id, tag_number, caveman_depth FROM tags WHERE session_id = ? AND status = 'active' ORDER BY byte_size DESC, tag_number ASC LIMIT ?").all(sessionId, n).filter(isTagRow);
   return rows.map(toTagEntry);
 }
 var insertTagStatements, updateTagStatusStatements, updateTagDropModeStatements, updateTagMessageIdStatements, getTagNumbersByMessageIdStatements, deleteTagsByMessageIdStatements, getMaxTagNumberBySessionStatements;
@@ -152157,14 +152242,12 @@ async function runHistorianPrompt(args) {
     const dumpPath = dumpHistorianResponse(parentSessionId, dumpLabel ?? "historian-response", result);
     return { ok: true, result, dumpPath };
   } catch (modelError) {
-    const modelMsg = getErrorMessage(modelError);
-    const modelStack = modelError instanceof Error ? modelError.stack : undefined;
-    sessionLog(parentSessionId, "compartment agent: historian attempt failed", {
-      error: modelMsg,
-      promptLength: prompt.length,
-      stack: modelStack
-    });
-    return { ok: false, error: `Historian failed while processing this session: ${modelMsg}` };
+    const desc = describeError(modelError);
+    sessionLog(parentSessionId, `historian prompt failed: ${desc.brief} promptLength=${prompt.length}${desc.stackHead ? ` stackHead="${desc.stackHead}"` : ""}`);
+    return {
+      ok: false,
+      error: `Historian failed while processing this session: ${desc.brief}`
+    };
   } finally {
     if (agentSessionId) {
       await client.session.delete({ path: { id: agentSessionId }, query: { directory: sessionDirectory } }).catch((e) => {
@@ -153529,108 +153612,6 @@ var init_note_nudger = __esm(() => {
   lastDeliveredAt = new Map;
 });
 
-// src/features/magic-context/memory/embedding-backfill.ts
-async function ensureMemoryEmbeddings(args) {
-  if (!isEmbeddingEnabled()) {
-    return args.existingEmbeddings;
-  }
-  const missingMemories = args.memories.filter((memory) => !args.existingEmbeddings.has(memory.id));
-  if (missingMemories.length === 0) {
-    return args.existingEmbeddings;
-  }
-  try {
-    const embeddings = await embedBatch(missingMemories.map((memory) => memory.content));
-    const modelId = getEmbeddingModelId();
-    const staged = new Map;
-    args.db.transaction(() => {
-      for (const [index, memory] of missingMemories.entries()) {
-        const embedding = embeddings[index];
-        if (!embedding) {
-          continue;
-        }
-        saveEmbedding(args.db, memory.id, embedding, modelId);
-        staged.set(memory.id, embedding);
-      }
-    })();
-    for (const [id, embedding] of staged) {
-      args.existingEmbeddings.set(id, embedding);
-    }
-  } catch (error48) {
-    log("[magic-context] failed to backfill memory embeddings:", error48);
-  }
-  return args.existingEmbeddings;
-}
-var init_embedding_backfill = __esm(() => {
-  init_logger();
-  init_embedding();
-  init_storage_memory_embeddings();
-});
-
-// src/features/magic-context/memory/promotion.ts
-function isPromotableCategory(category) {
-  return PROMOTABLE_CATEGORIES.some((promotableCategory) => promotableCategory === category);
-}
-function resolveExpiresAt(category) {
-  const ttl = CATEGORY_DEFAULT_TTL[category];
-  return ttl === undefined ? null : Date.now() + ttl;
-}
-function promoteSessionFactsToMemory(db, sessionId, projectPath, facts) {
-  for (const fact of facts) {
-    if (!isPromotableCategory(fact.category)) {
-      continue;
-    }
-    try {
-      const normalizedHash = computeNormalizedHash(fact.content);
-      const existingMemory = getMemoryByHash(db, projectPath, fact.category, normalizedHash);
-      if (existingMemory) {
-        updateMemorySeenCount(db, existingMemory.id);
-        continue;
-      }
-      const memoryInput = {
-        projectPath,
-        category: fact.category,
-        content: fact.content,
-        sourceSessionId: sessionId,
-        sourceType: "historian",
-        expiresAt: resolveExpiresAt(fact.category)
-      };
-      const memory = insertMemory(db, memoryInput);
-      embedAndStoreMemory(db, sessionId, memory.id, memory.content);
-    } catch (error48) {
-      sessionLog(sessionId, `memory promotion failed for fact "${fact.content.slice(0, 60)}":`, error48);
-    }
-  }
-}
-async function embedAndStoreMemory(db, sessionId, memoryId, content) {
-  try {
-    const embedding = await embedText(content);
-    if (embedding) {
-      saveEmbedding(db, memoryId, embedding, getEmbeddingModelId());
-    }
-  } catch (error48) {
-    sessionLog(sessionId, `memory embedding failed for memory ${memoryId}:`, error48);
-  }
-}
-var init_promotion = __esm(() => {
-  init_logger();
-  init_constants();
-  init_embedding();
-  init_storage_memory();
-  init_storage_memory_embeddings();
-});
-// src/features/magic-context/memory/index.ts
-var init_memory = __esm(() => {
-  init_project_identity();
-  init_promotion();
-  init_constants();
-  init_embedding();
-  init_embedding_backfill();
-  init_embedding_cache();
-  init_storage_memory();
-  init_storage_memory_embeddings();
-  init_storage_memory_fts();
-});
-
 // src/hooks/magic-context/caveman.ts
 function protectRegions(text) {
   const preserved = [];
@@ -153863,6 +153844,108 @@ var init_caveman = __esm(() => {
   };
 });
 
+// src/features/magic-context/memory/embedding-backfill.ts
+async function ensureMemoryEmbeddings(args) {
+  if (!isEmbeddingEnabled()) {
+    return args.existingEmbeddings;
+  }
+  const missingMemories = args.memories.filter((memory) => !args.existingEmbeddings.has(memory.id));
+  if (missingMemories.length === 0) {
+    return args.existingEmbeddings;
+  }
+  try {
+    const embeddings = await embedBatch(missingMemories.map((memory) => memory.content));
+    const modelId = getEmbeddingModelId();
+    const staged = new Map;
+    args.db.transaction(() => {
+      for (const [index, memory] of missingMemories.entries()) {
+        const embedding = embeddings[index];
+        if (!embedding) {
+          continue;
+        }
+        saveEmbedding(args.db, memory.id, embedding, modelId);
+        staged.set(memory.id, embedding);
+      }
+    })();
+    for (const [id, embedding] of staged) {
+      args.existingEmbeddings.set(id, embedding);
+    }
+  } catch (error48) {
+    log("[magic-context] failed to backfill memory embeddings:", error48);
+  }
+  return args.existingEmbeddings;
+}
+var init_embedding_backfill = __esm(() => {
+  init_logger();
+  init_embedding();
+  init_storage_memory_embeddings();
+});
+
+// src/features/magic-context/memory/promotion.ts
+function isPromotableCategory(category) {
+  return PROMOTABLE_CATEGORIES.some((promotableCategory) => promotableCategory === category);
+}
+function resolveExpiresAt(category) {
+  const ttl = CATEGORY_DEFAULT_TTL[category];
+  return ttl === undefined ? null : Date.now() + ttl;
+}
+function promoteSessionFactsToMemory(db, sessionId, projectPath, facts) {
+  for (const fact of facts) {
+    if (!isPromotableCategory(fact.category)) {
+      continue;
+    }
+    try {
+      const normalizedHash = computeNormalizedHash(fact.content);
+      const existingMemory = getMemoryByHash(db, projectPath, fact.category, normalizedHash);
+      if (existingMemory) {
+        updateMemorySeenCount(db, existingMemory.id);
+        continue;
+      }
+      const memoryInput = {
+        projectPath,
+        category: fact.category,
+        content: fact.content,
+        sourceSessionId: sessionId,
+        sourceType: "historian",
+        expiresAt: resolveExpiresAt(fact.category)
+      };
+      const memory = insertMemory(db, memoryInput);
+      embedAndStoreMemory(db, sessionId, memory.id, memory.content);
+    } catch (error48) {
+      sessionLog(sessionId, `memory promotion failed for fact "${fact.content.slice(0, 60)}":`, error48);
+    }
+  }
+}
+async function embedAndStoreMemory(db, sessionId, memoryId, content) {
+  try {
+    const embedding = await embedText(content);
+    if (embedding) {
+      saveEmbedding(db, memoryId, embedding, getEmbeddingModelId());
+    }
+  } catch (error48) {
+    sessionLog(sessionId, `memory embedding failed for memory ${memoryId}:`, error48);
+  }
+}
+var init_promotion = __esm(() => {
+  init_logger();
+  init_constants();
+  init_embedding();
+  init_storage_memory();
+  init_storage_memory_embeddings();
+});
+// src/features/magic-context/memory/index.ts
+var init_memory = __esm(() => {
+  init_project_identity();
+  init_promotion();
+  init_constants();
+  init_embedding();
+  init_embedding_backfill();
+  init_embedding_cache();
+  init_storage_memory();
+  init_storage_memory_embeddings();
+  init_storage_memory_fts();
+});
+
 // src/hooks/magic-context/compartment-runner-compressor.ts
 function cavemanLevelForDepth(outputDepth) {
   if (outputDepth <= 1)
@@ -154317,6 +154400,7 @@ async function runCompartmentAgent(deps) {
     const priorFacts = existingFacts;
     const existingValidationError = validateStoredCompartments(priorCompartments);
     if (existingValidationError) {
+      sessionLog(sessionId, `historian failure: source=existing-validation reason="${existingValidationError}"`);
       await notifyHistorianIssue(`## Historian alert
 
 Historian skipped this session because existing stored compartments are invalid: ${existingValidationError}
@@ -154335,6 +154419,7 @@ No new compartments or facts were written. Rebuild or clear the broken compartme
     }
     const chunkCoverageError = validateChunkCoverage(chunk);
     if (chunkCoverageError) {
+      sessionLog(sessionId, `historian failure: source=chunk-coverage reason="${chunkCoverageError}" chunkRange=${chunk.startIndex}-${chunk.endIndex}`);
       await notifyHistorianIssue(`## Historian alert
 
 Historian skipped this session because the raw chunk could not be represented safely: ${chunkCoverageError}
@@ -154370,6 +154455,7 @@ ${chunk.text}`);
       twoPass: deps.historianTwoPass
     });
     if (!validatedPass.ok) {
+      sessionLog(sessionId, `historian failure: source=validation reason="${validatedPass.error}" chunkRange=${chunk.startIndex}-${chunk.endIndex} fallbackModel=${deps.fallbackModelId ?? "<none>"} twoPass=${deps.historianTwoPass ? "true" : "false"}`);
       incrementHistorianFailure(db, sessionId, validatedPass.error);
       await notifyHistorianIssue(`## Historian alert
 
@@ -154381,6 +154467,8 @@ No new compartments or facts were written. Check the historian model/output and
     const newCompartments = validatedPass.compartments;
     const lastNewEnd = newCompartments[newCompartments.length - 1]?.endMessage ?? 0;
     if (lastNewEnd + 1 <= offset) {
+      sessionLog(sessionId, `historian failure: source=no-progress reason="historian returned compartments that did not advance past raw message ${offset - 1}" newCompartmentCount=${newCompartments.length} lastNewEnd=${lastNewEnd} priorEnd=${offset - 1}`);
+      incrementHistorianFailure(db, sessionId, `no forward progress beyond raw message ${offset - 1}`);
       await notifyHistorianIssue(`## Historian alert
 
 Historian returned compartments that made no forward progress beyond raw message ${offset - 1}.
@@ -154434,11 +154522,13 @@ No new compartments or facts were written. Check the historian model/output and
       }
     }
   } catch (error48) {
-    const msg = getErrorMessage(error48);
+    const desc = describeError(error48);
+    sessionLog(sessionId, `historian failure: source=exception ${desc.brief}${desc.stackHead ? ` stackHead="${desc.stackHead}"` : ""}`);
     if (!issueNotified) {
+      incrementHistorianFailure(db, sessionId, desc.brief);
       await notifyHistorianIssue(`## Historian alert
 
-Historian failed unexpectedly: ${msg}
+Historian failed unexpectedly: ${desc.brief}
 
 No new compartments or facts were written. Check the historian model/output and try again.`);
     }
@@ -166438,6 +166528,120 @@ init_compartment_storage();
 init_project_identity();
 init_storage();
 init_logger();
+
+// src/hooks/magic-context/caveman-cleanup.ts
+init_storage();
+init_shared();
+init_caveman();
+var DEPTH_UNTOUCHED = 0;
+var DEPTH_LITE = 1;
+var DEPTH_FULL = 2;
+var DEPTH_ULTRA = 3;
+var DEPTH_TO_LEVEL = {
+  [DEPTH_LITE]: "lite",
+  [DEPTH_FULL]: "full",
+  [DEPTH_ULTRA]: "ultra"
+};
+function computeTargetDepth(positionIndex, totalEligible) {
+  if (totalEligible <= 0)
+    return DEPTH_UNTOUCHED;
+  const fraction = positionIndex / totalEligible;
+  if (fraction < 0.2)
+    return DEPTH_ULTRA;
+  if (fraction < 0.4)
+    return DEPTH_FULL;
+  if (fraction < 0.6)
+    return DEPTH_LITE;
+  return DEPTH_UNTOUCHED;
+}
+function applyCavemanCleanup(sessionId, db, targets, tags, config2) {
+  const result = {
+    compressedToLite: 0,
+    compressedToFull: 0,
+    compressedToUltra: 0
+  };
+  if (!config2.enabled)
+    return result;
+  const maxTag = tags.reduce((max, t) => Math.max(max, t.tagNumber), 0);
+  const protectedCutoff = maxTag - config2.protectedTags;
+  const eligible = tags.filter((tag) => tag.type === "message" && tag.status === "active" && tag.tagNumber <= protectedCutoff && tag.byteSize >= config2.minChars).sort((a, b) => a.tagNumber - b.tagNumber);
+  if (eligible.length === 0)
+    return result;
+  const tagsNeedingCompression = eligible.filter((tag, index) => {
+    const target = targets.get(tag.tagNumber);
+    if (!target || !target.getContent || !target.setContent)
+      return false;
+    const targetDepth = computeTargetDepth(index, eligible.length);
+    return targetDepth > tag.cavemanDepth;
+  });
+  if (tagsNeedingCompression.length === 0)
+    return result;
+  const originalByTag = getSourceContents(db, sessionId, tagsNeedingCompression.map((t) => t.tagNumber));
+  const positionByTag = new Map;
+  for (let i = 0;i < eligible.length; i += 1) {
+    positionByTag.set(eligible[i].tagNumber, i);
+  }
+  db.transaction(() => {
+    for (const tag of tagsNeedingCompression) {
+      const originalText = originalByTag.get(tag.tagNumber);
+      if (typeof originalText !== "string" || originalText.length === 0)
+        continue;
+      const positionIndex = positionByTag.get(tag.tagNumber) ?? 0;
+      const targetDepth = computeTargetDepth(positionIndex, eligible.length);
+      if (targetDepth <= tag.cavemanDepth)
+        continue;
+      const level = DEPTH_TO_LEVEL[targetDepth];
+      if (!level)
+        continue;
+      const compressed = cavemanCompress(originalText, level);
+      if (compressed.length === 0)
+        continue;
+      const target = targets.get(tag.tagNumber);
+      if (!target)
+        continue;
+      target.setContent(compressed);
+      updateCavemanDepth(db, sessionId, tag.tagNumber, targetDepth);
+      if (targetDepth === DEPTH_LITE)
+        result.compressedToLite += 1;
+      else if (targetDepth === DEPTH_FULL)
+        result.compressedToFull += 1;
+      else if (targetDepth === DEPTH_ULTRA)
+        result.compressedToUltra += 1;
+    }
+  })();
+  const total = result.compressedToLite + result.compressedToFull + result.compressedToUltra;
+  if (total > 0) {
+    sessionLog(sessionId, `caveman cleanup: compressed ${total} text tags (lite=${result.compressedToLite}, full=${result.compressedToFull}, ultra=${result.compressedToUltra})`);
+  }
+  return result;
+}
+function replayCavemanCompression(sessionId, db, targets, tags) {
+  const compressedTags = tags.filter((tag) => tag.type === "message" && tag.status === "active" && tag.cavemanDepth > 0 && targets.has(tag.tagNumber));
+  if (compressedTags.length === 0)
+    return 0;
+  const originalByTag = getSourceContents(db, sessionId, compressedTags.map((t) => t.tagNumber));
+  let replayed = 0;
+  for (const tag of compressedTags) {
+    const originalText = originalByTag.get(tag.tagNumber);
+    if (typeof originalText !== "string" || originalText.length === 0)
+      continue;
+    const level = DEPTH_TO_LEVEL[tag.cavemanDepth];
+    if (!level)
+      continue;
+    const compressed = cavemanCompress(originalText, level);
+    if (compressed.length === 0)
+      continue;
+    const target = targets.get(tag.tagNumber);
+    if (!target)
+      continue;
+    if (target.setContent(compressed)) {
+      replayed += 1;
+    }
+  }
+  return replayed;
+}
+
+// src/hooks/magic-context/transform.ts
 init_compartment_runner();
 
 // src/hooks/magic-context/image-token-estimate.ts
@@ -167795,7 +167999,8 @@ function extractToolTagMetadata(part) {
     inputByteSize: estimateInputByteSize(input)
   };
 }
-function tagMessages(sessionId, messages, tagger, db) {
+function tagMessages(sessionId, messages, tagger, db, options = {}) {
+  const skipPrefixInjection = options.skipPrefixInjection === true;
   const targets = new Map;
   const reasoningByMessage = new Map;
   const messageTagNumbers = new Map;
@@ -167869,7 +168074,9 @@ function tagMessages(sessionId, messages, tagger, db) {
             }
           }
           messageTagNumbers.set(message, Math.max(messageTagNumbers.get(message) ?? 0, tagId));
-          textPart.text = prependTag(tagId, textPart.text);
+          if (!skipPrefixInjection) {
+            textPart.text = prependTag(tagId, textPart.text);
+          }
           targets.set(tagId, {
             message,
             setContent: (content) => {
@@ -167896,7 +168103,9 @@ function tagMessages(sessionId, messages, tagger, db) {
           const { toolName, inputByteSize } = extractToolTagMetadata(toolPart);
           const tagId = tagger.assignTag(sessionId, toolPart.callID, "tool", byteSize(toolPart.state.output), db, reasoningBytes, toolName, inputByteSize);
           messageTagNumbers.set(message, Math.max(messageTagNumbers.get(message) ?? 0, tagId));
-          toolPart.state.output = prependTag(tagId, toolPart.state.output);
+          if (!skipPrefixInjection) {
+            toolPart.state.output = prependTag(tagId, toolPart.state.output);
+          }
           toolTagByCallId.set(toolPart.callID, tagId);
           if (thinkingParts.length > 0 && !toolThinkingByCallId.has(toolPart.callID)) {
             toolThinkingByCallId.set(toolPart.callID, thinkingParts);
@@ -168842,7 +169051,16 @@ function applyHeuristicCleanup(sessionId, db, targets, messageTagNumbers, config
   if (droppedTools > 0 || deduplicatedTools > 0 || droppedInjections > 0) {
     sessionLog(sessionId, `heuristic cleanup: dropped ${droppedTools} tool tags, deduplicated ${deduplicatedTools} tool calls, dropped ${droppedInjections} system injections`);
   }
-  return { droppedTools, deduplicatedTools, droppedInjections };
+  let compressedTextTags = 0;
+  if (config2.caveman?.enabled) {
+    const cavemanResult = applyCavemanCleanup(sessionId, db, targets, tags, {
+      enabled: true,
+      minChars: config2.caveman.minChars,
+      protectedTags: config2.protectedTags
+    });
+    compressedTextTags = cavemanResult.compressedToLite + cavemanResult.compressedToFull + cavemanResult.compressedToUltra;
+  }
+  return { droppedTools, deduplicatedTools, droppedInjections, compressedTextTags };
 }
 function extractToolInfo(part) {
   if (part.type === "tool" && typeof part.tool === "string" && DEDUP_SAFE_TOOLS.has(part.tool)) {
@@ -168914,7 +169132,7 @@ async function runPostTransformPhase(args) {
   const hasPendingUserOps = pendingOps.length > 0;
   const shouldApplyPendingOps = (args.schedulerDecision === "execute" || isExplicitFlush || forceMaterialization) && (!compartmentRunning || emergencyBypassCompartmentGate);
   const isCacheBustingPass = isExplicitFlush || shouldApplyPendingOps;
-  const shouldRunHeuristics = args.fullFeatureMode && (!compartmentRunning || emergencyBypassCompartmentGate) && (isExplicitFlush || forceMaterialization || args.schedulerDecision === "execute" && !alreadyRanThisTurn);
+  const shouldRunHeuristics = (!compartmentRunning || emergencyBypassCompartmentGate) && (isExplicitFlush || forceMaterialization || args.schedulerDecision === "execute" && !alreadyRanThisTurn);
   if (shouldRunHeuristics) {
     const reason = isExplicitFlush ? "explicit_flush" : forceMaterialization ? `force_materialization (${args.contextUsage.percentage.toFixed(1)}% >= ${args.forceMaterializationPercentage}%)` : `scheduler_execute (pendingOps=${pendingOps.length}, scheduler=${args.schedulerDecision})`;
     sessionLog(args.sessionId, `heuristics WILL RUN \u2014 reason=${reason}, context=${args.contextUsage.percentage.toFixed(1)}%, turn=${args.currentTurnId}`);
@@ -168944,16 +169162,21 @@ async function runPostTransformPhase(args) {
     }
     if (shouldRunHeuristics) {
       const t5 = performance.now();
+      const cavemanConfig = args.cavemanTextCompression?.enabled ? {
+        enabled: true,
+        minChars: args.cavemanTextCompression.minChars
+      } : undefined;
       const cleanup = applyHeuristicCleanup(args.sessionId, args.db, args.targets, args.messageTagNumbers, {
         autoDropToolAge: args.autoDropToolAge,
         dropToolStructure: args.dropToolStructure,
         protectedTags: args.protectedTags,
-        dropAllTools: forceMaterialization
+        dropAllTools: forceMaterialization,
+        caveman: cavemanConfig
       }, args.tags);
-      if (cleanup.droppedTools > 0 || cleanup.deduplicatedTools > 0 || cleanup.droppedInjections > 0) {
+      if (cleanup.droppedTools > 0 || cleanup.deduplicatedTools > 0 || cleanup.droppedInjections > 0 || cleanup.compressedTextTags > 0) {
         didMutateFromPendingOperations = true;
       }
-      logTransformTiming(args.sessionId, "applyHeuristicCleanup", t5, `droppedTools=${cleanup.droppedTools} deduplicatedTools=${cleanup.deduplicatedTools} droppedInjections=${cleanup.droppedInjections}`);
+      logTransformTiming(args.sessionId, "applyHeuristicCleanup", t5, `droppedTools=${cleanup.droppedTools} deduplicatedTools=${cleanup.deduplicatedTools} droppedInjections=${cleanup.droppedInjections} compressedTextTags=${cleanup.compressedTextTags}`);
       if (args.watermark > 0) {
         const t6 = performance.now();
         truncateErroredTools(args.messages, args.watermark, args.messageTagNumbers);
@@ -169099,7 +169322,7 @@ async function runPostTransformPhase(args) {
   } else {
     args.nudgePlacements.clear(args.sessionId);
   }
-  const stickyNoteNudge = getStickyNoteNudge(args.db, args.sessionId);
+  const stickyNoteNudge = args.fullFeatureMode ? getStickyNoteNudge(args.db, args.sessionId) : null;
   if (stickyNoteNudge) {
     const reinjected = appendReminderToUserMessageById(args.messages, stickyNoteNudge.messageId, stickyNoteNudge.text);
     if (!reinjected) {
@@ -169111,7 +169334,7 @@ async function runPostTransformPhase(args) {
       }
     }
   }
-  const deferredNoteText = peekNoteNudgeText(args.db, args.sessionId, args.currentTurnId, args.projectPath);
+  const deferredNoteText = args.fullFeatureMode ? peekNoteNudgeText(args.db, args.sessionId, args.currentTurnId, args.projectPath) : null;
   if (deferredNoteText) {
     const noteInstruction = `
 
@@ -169396,7 +169619,11 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so ma
     try {
       const t0 = performance.now();
       deps.tagger.initFromDb(sessionId, db);
-      const result = tagMessages(sessionId, messages, deps.tagger, db);
+      const ctxReduceEnabledEffective = deps.ctxReduceEnabled !== false;
+      const skipPrefixInjection = !ctxReduceEnabledEffective || reducedMode;
+      const result = tagMessages(sessionId, messages, deps.tagger, db, {
+        skipPrefixInjection
+      });
       targets = result.targets;
       reasoningByMessage = result.reasoningByMessage;
       messageTagNumbers = result.messageTagNumbers;
@@ -169445,6 +169672,14 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so ma
       }
       logTransformTiming(sessionId, "replayReasoningClearing", tReplay);
     }
+    if (!deps.ctxReduceEnabled && !reducedMode && deps.cavemanTextCompression?.enabled) {
+      const tCavemanReplay = performance.now();
+      const replayedCaveman = replayCavemanCompression(sessionId, db, targets, tags);
+      if (replayedCaveman > 0) {
+        sessionLog(sessionId, `caveman replay: re-applied ${replayedCaveman} text tags`);
+      }
+      logTransformTiming(sessionId, "replayCavemanCompression", tCavemanReplay);
+    }
     const t4 = performance.now();
     const strippedClearedReasoning = stripClearedReasoning(messages, skipTypedReasoningCleanup);
     logTransformTiming(sessionId, "stripClearedReasoning", t4, `strippedParts=${strippedClearedReasoning}`);
@@ -169534,7 +169769,8 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so ma
       hasRecentReduceCall,
       skipTypedReasoningCleanup,
       projectPath: deps.projectPath,
-      autoSearch: deps.autoSearch
+      autoSearch: deps.autoSearch,
+      cavemanTextCompression: deps.ctxReduceEnabled === false && !reducedMode ? deps.cavemanTextCompression : undefined
     });
     logTransformTiming(sessionId, "postTransformPhase", tPostProcess);
     const msgTokens = getMessageTokensCache(sessionId);
@@ -170510,13 +170746,21 @@ function createSystemPromptHashHandler(deps) {
     const sessionId = input.sessionID;
     if (!sessionId)
       return;
+    let sessionMetaEarly;
+    try {
+      sessionMetaEarly = getOrCreateSessionMeta(deps.db, sessionId);
+    } catch (error48) {
+      sessionLog(sessionId, "system-prompt-hash session meta load failed:", error48);
+    }
+    const isSubagentSession = sessionMetaEarly?.isSubagent === true;
+    const effectiveCtxReduceEnabled = isSubagentSession ? false : deps.ctxReduceEnabled;
     const fullPrompt = output.system.join(`
 `);
     if (fullPrompt.length > 0 && !fullPrompt.includes(MAGIC_CONTEXT_MARKER)) {
       const detectedAgent = detectAgentFromSystemPrompt(fullPrompt);
-      const guidance = buildMagicContextSection(detectedAgent, deps.protectedTags, deps.ctxReduceEnabled, deps.dreamerEnabled, deps.dropToolStructure, deps.experimentalTemporalAwareness);
+      const guidance = buildMagicContextSection(detectedAgent, deps.protectedTags, effectiveCtxReduceEnabled, deps.dreamerEnabled, deps.dropToolStructure, deps.experimentalTemporalAwareness);
       output.system.push(guidance);
-      sessionLog(sessionId, `injected ${detectedAgent ?? "generic"} guidance into system prompt`);
+      sessionLog(sessionId, `injected ${detectedAgent ?? "generic"} guidance into system prompt (ctxReduce=${effectiveCtxReduceEnabled}, subagent=${isSubagentSession})`);
     }
     const isCacheBusting = deps.flushedSessions.has(sessionId);
     if (shouldInjectDocs) {
@@ -170765,6 +171009,7 @@ function createMagicContextHook(deps) {
     db,
     nudgePlacements,
     protectedTags: deps.config.protected_tags,
+    ctxReduceEnabled,
     autoDropToolAge: deps.config.auto_drop_tool_age ?? 100,
     dropToolStructure: deps.config.drop_tool_structure ?? true,
     clearReasoningAge: deps.config.clear_reasoning_age ?? 50,
@@ -170807,6 +171052,10 @@ function createMagicContextHook(deps) {
       memoryEnabled: deps.config.memory?.enabled !== false,
       embeddingEnabled: deps.config.embedding?.provider !== "off",
       gitCommitsEnabled: deps.config.experimental?.git_commit_indexing?.enabled === true
+    } : undefined,
+    cavemanTextCompression: ctxReduceEnabled === false && deps.config.experimental?.caveman_text_compression?.enabled === true ? {
+      enabled: true,
+      minChars: deps.config.experimental.caveman_text_compression.min_chars ?? 500
     } : undefined
   });
   const eventHandler = createEventHandler2({