@cortexkit/opencode-magic-context 0.31.4 → 0.32.0

package/dist/index.js

@@ -15406,8 +15406,11 @@ var init_magic_context = __esm(() => {
       provider: "local",
       model: DEFAULT_LOCAL_EMBEDDING_MODEL
     }).describe("Embedding provider configuration"),
-    temporal_awareness: exports_external.boolean().default(true).describe('Inject wall-clock gap markers (<!-- +Xm -->) between user messages where > 5 min elapsed since the previous message, and add start/end date attributes on compartments. Gives the agent a sense of session pacing and "how long ago" across multi-day sessions. Graduated from experimental.temporal_awareness; default: true (set false to opt out).'),
+    temporal_awareness: exports_external.boolean().default(true).describe('Inject wall-clock gap markers (<!-- +Xm -->) between user messages where > 5 min elapsed since the previous message, and add compact date ranges to compartment headings. Gives the agent a sense of session pacing and "how long ago" across multi-day sessions. Graduated from experimental.temporal_awareness; default: true (set false to opt out).'),
     keep_subagents: exports_external.boolean().default(false).describe("Debug: keep the child sessions Magic Context spawns for its own subagents (historian, dreamer, sidekick, memory-migration) instead of deleting them on success. Useful for short-term inspection/data collection — their full transcript (prompt, tool calls, token usage, output) stays in the host session store. Kept sessions accumulate until manually cleared; leave false for normal use. Requires a restart to take effect."),
+    shadow_transform: exports_external.object({
+      enabled: exports_external.boolean().default(false).describe("Dev flag: mirror every transform pass to the Magic Context Rust module over subc and byte-compare outputs. No behavior impact; default off.")
+    }).default({ enabled: false }).describe("Developer-only shadow transform lane. When enabled, the plugin fire-and-forgets a copy of each finalized transform to the Rust module for comparison; the live output is unchanged."),
     todowrite: exports_external.object({
       enabled: exports_external.boolean().default(true).describe("Pi only: register Magic Context's todowrite task-list tool. Disable if you use your own todo extension. OpenCode ships its own built-in todowrite; this setting has no effect there."),
       overlay: exports_external.boolean().default(true).describe("Pi only: show the persistent todo overlay above the editor while tasks are active.")
@@ -150066,6 +150069,12 @@ function parseJsonRecord(value) {
     return null;
   }
 }
+function isRawCompactionSummaryInfo(info) {
+  if (info === null || typeof info !== "object" || Array.isArray(info))
+    return false;
+  const candidate = info;
+  return candidate.summary === true && candidate.finish === "stop";
+}
 function parseJsonUnknown(value) {
   try {
     return JSON.parse(value);
@@ -150088,7 +150097,7 @@ function attachRawPartVersion(value, timeUpdated) {
   return value;
 }
 function readRawSessionMessagesFromDb(db, sessionId) {
-  const messageRows = db.prepare("SELECT id, data, time_updated FROM message WHERE session_id = ? ORDER BY time_created ASC, id ASC").all(sessionId).filter(isRawMessageRow);
+  const messageRows = db.prepare("SELECT id, data, time_created, time_updated FROM message WHERE session_id = ? ORDER BY time_created ASC, id ASC").all(sessionId).filter(isRawMessageRow);
   const partRows = db.prepare("SELECT message_id, data, time_updated FROM part WHERE session_id = ? ORDER BY time_created ASC, id ASC").all(sessionId).filter(isRawPartRow);
   const partsByMessageId = new Map;
   for (const part of partRows) {
@@ -150096,10 +150105,7 @@ function readRawSessionMessagesFromDb(db, sessionId) {
     list.push(attachRawPartVersion(parseJsonUnknown(part.data), part.time_updated));
     partsByMessageId.set(part.message_id, list);
   }
-  const filtered = messageRows.filter((row) => {
-    const info = parseJsonRecord(row.data);
-    return !(info?.summary === true && info?.finish === "stop");
-  });
+  const filtered = messageRows.filter((row) => !isRawCompactionSummaryInfo(parseJsonRecord(row.data)));
   return filtered.flatMap((row, index) => {
     const info = parseJsonRecord(row.data);
     if (!info)
@@ -150110,10 +150116,21 @@ function readRawSessionMessagesFromDb(db, sessionId) {
       id: row.id,
       role,
       parts: partsByMessageId.get(row.id) ?? [],
+      createdAt: row.time_created ?? null,
       version: row.time_updated ?? null
     };
   });
 }
+function readRawSessionMessageIdOrdinalsFromDb(db, sessionId) {
+  const messageRows = db.prepare("SELECT id, data FROM message WHERE session_id = ? ORDER BY time_created ASC, id ASC").all(sessionId).filter(isRawMessageRow);
+  const filtered = messageRows.filter((row) => !isRawCompactionSummaryInfo(parseJsonRecord(row.data)));
+  const ordinalById = new Map;
+  filtered.forEach((row, index) => {
+    if (parseJsonRecord(row.data))
+      ordinalById.set(row.id, index + 1);
+  });
+  return ordinalById;
+}
 function isAnchorRow(row) {
   return row !== null && typeof row === "object" && typeof row.time_created === "number" && typeof row.id === "string";
 }
@@ -150124,7 +150141,7 @@ function readRawSessionTailFromDb(db, sessionId, baseOrdinal, anchorMessageId) {
   const anchorInfo = parseJsonRecord(anchorRow.data ?? "");
   if (anchorInfo?.summary === true && anchorInfo?.finish === "stop")
     return null;
-  const messageRows = db.prepare(`SELECT id, data, time_updated FROM message
+  const messageRows = db.prepare(`SELECT id, data, time_created, time_updated FROM message
              WHERE session_id = ?
                AND (time_created > ? OR (time_created = ? AND id >= ?))
              ORDER BY time_created ASC, id ASC`).all(sessionId, anchorRow.time_created, anchorRow.time_created, anchorRow.id).filter(isRawMessageRow);
@@ -150160,6 +150177,7 @@ function readRawSessionTailFromDb(db, sessionId, baseOrdinal, anchorMessageId) {
       id: row.id,
       role: typeof info.role === "string" ? info.role : "unknown",
       parts: partsByMessageId.get(row.id) ?? [],
+      createdAt: row.time_created ?? null,
       version: row.time_updated ?? null
     });
     ord += 1;
@@ -150223,7 +150241,7 @@ function readRawSessionMessageByIdFromDb(db, sessionId, messageId) {
     return null;
   }
   const info = parseJsonRecord(row.data);
-  if (!info || info.summary === true && info.finish === "stop") {
+  if (!info || isRawCompactionSummaryInfo(info)) {
     return null;
   }
   const ordinalRow = db.prepare(`SELECT COUNT(*) AS ordinal FROM message
@@ -150242,6 +150260,7 @@ function readRawSessionMessageByIdFromDb(db, sessionId, messageId) {
     id: row.id,
     role,
     parts: partRows.map((part) => attachRawPartVersion(parseJsonUnknown(part.data), part.time_updated)),
+    createdAt: row.time_created,
     version: row.time_updated ?? null
   };
 }
@@ -150758,6 +150777,17 @@ function primeInMemoryTailRawMessageCache(args) {
   activeAbsoluteCountCache?.set(sessionId, absoluteMessageCount);
   return true;
 }
+function readRawSessionMessageIdOrdinals(sessionId) {
+  const provider = sessionProviders.get(sessionId);
+  if (provider?.readMessageIdOrdinals)
+    return provider.readMessageIdOrdinals();
+  if (provider) {
+    return new Map(provider.readMessages().map((message) => [message.id, message.ordinal]));
+  }
+  if (!openCodeDbExists())
+    return new Map;
+  return withReadOnlySessionDb((db) => readRawSessionMessageIdOrdinalsFromDb(db, sessionId));
+}
 function readRawSessionMessageById(sessionId, messageId) {
   const provider = sessionProviders.get(sessionId);
   if (provider?.readMessageById) {
@@ -153165,6 +153195,9 @@ var init_project_docs_hash = __esm(() => {
   docsCache = new Map;
 });
 
+// src/features/magic-context/storage-clone.ts
+var init_storage_clone = () => {};
+
 // src/shared/stable-json.ts
 function stableStringify(value, seen = new WeakSet) {
   if (value === undefined)
@@ -157047,7 +157080,7 @@ function deleteToolTagsByOwner(db, sessionId, ownerMsgId) {
   const result = getDeleteToolTagsByOwnerStatement(db).run(sessionId, ownerMsgId);
   return result.changes ?? 0;
 }
-var insertTagStatements, updateTagStatusStatements, updateTagDropModeStatements, updateTagMessageIdStatements, getTagNumbersByMessageIdStatements, deleteTagsByMessageIdStatements, getMaxTagNumberBySessionStatements, getTagNumberByMessageIdStatements, updateTagByteSizeStatements, updateTagInputByteSizeStatements, CONTENT_ID_SUFFIX, RECLAIM_HINT_EXCLUDED_TOOLS, RECLAIM_HINT_MIN_TOKENS = 250, RECLAIM_HINT_EXCLUDED_LIST, updateTagTokenCountStatements, updateTagInputTokenCountStatements, getOwnerScopedToolTagNumbersStatements, getMinMessageTagNumberForRawIdStatements, TAGGER_FLOOR_SCAN_MESSAGES = 8, TAGGER_FLOOR_MAX_PROBES = 64, TAGGER_FLOOR_SAFETY_MARGIN = 256, TAGGER_FLOOR_PER_SKIP_MARGIN = 64, TAG_SELECT_COLUMNS = "id, message_id, type, status, drop_mode, tool_name, input_byte_size, byte_size, reasoning_byte_size, session_id, tag_number, caveman_depth, tool_owner_message_id", getActiveTagsBySessionStatements, getMaxDroppedTagNumberStatements, getToolTagNumberByOwnerStatements, getNullOwnerToolTagStatements, adoptNullOwnerToolTagStatements, deleteToolTagsByOwnerStatements;
+var insertTagStatements, updateTagStatusStatements, updateTagDropModeStatements, updateTagMessageIdStatements, getTagNumbersByMessageIdStatements, deleteTagsByMessageIdStatements, getMaxTagNumberBySessionStatements, getTagNumberByMessageIdStatements, hasPiFallbackMessageTagStatements, updateTagByteSizeStatements, updateTagInputByteSizeStatements, CONTENT_ID_SUFFIX, RECLAIM_HINT_EXCLUDED_TOOLS, RECLAIM_HINT_MIN_TOKENS = 250, RECLAIM_HINT_EXCLUDED_LIST, updateTagTokenCountStatements, updateTagInputTokenCountStatements, getOwnerScopedToolTagNumbersStatements, getMinMessageTagNumberForRawIdStatements, TAGGER_FLOOR_SCAN_MESSAGES = 8, TAGGER_FLOOR_MAX_PROBES = 64, TAGGER_FLOOR_SAFETY_MARGIN = 256, TAGGER_FLOOR_PER_SKIP_MARGIN = 64, TAG_SELECT_COLUMNS = "id, message_id, type, status, drop_mode, tool_name, input_byte_size, byte_size, reasoning_byte_size, session_id, tag_number, caveman_depth, tool_owner_message_id", getActiveTagsBySessionStatements, getMaxDroppedTagNumberStatements, getToolTagNumberByOwnerStatements, getNullOwnerToolTagStatements, adoptNullOwnerToolTagStatements, deleteToolTagsByOwnerStatements;
 var init_storage_tags = __esm(() => {
   insertTagStatements = new WeakMap;
   updateTagStatusStatements = new WeakMap;
@@ -157057,6 +157090,7 @@ var init_storage_tags = __esm(() => {
   deleteTagsByMessageIdStatements = new WeakMap;
   getMaxTagNumberBySessionStatements = new WeakMap;
   getTagNumberByMessageIdStatements = new WeakMap;
+  hasPiFallbackMessageTagStatements = new WeakMap;
   updateTagByteSizeStatements = new WeakMap;
   updateTagInputByteSizeStatements = new WeakMap;
   CONTENT_ID_SUFFIX = /:(?:p|file)\d+$/;
@@ -157093,6 +157127,7 @@ var init_storage = __esm(async () => {
   init_migrations();
   init_project_docs_hash();
   init_project_identity2();
+  init_storage_clone();
   init_storage_m0_mutation_log();
   init_storage_memory_mutation_log();
   init_storage_meta_shared();
@@ -178822,12 +178857,26 @@ var init_decay_curve = __esm(() => {
 });
 
 // src/hooks/magic-context/decay-render.ts
-function escapeXmlAttr2(s) {
-  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
 function escapeXmlContent2(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
+function formatDateRange(startDate, endDate) {
+  if (!startDate || !endDate)
+    return "";
+  if (startDate === endDate)
+    return startDate;
+  if (startDate.slice(0, 7) === endDate.slice(0, 7))
+    return `${startDate}→${endDate.slice(8)}`;
+  return `${startDate}→${endDate}`;
+}
+function compartmentHeading(c) {
+  const dateRange = formatDateRange(c.startDate, c.endDate);
+  const dateSegment = dateRange ? ` · ${dateRange}` : "";
+  return `## ${c.startMessage}-${c.endMessage}${dateSegment} · ${c.title}`;
+}
+function guardCompartmentBody(body) {
+  return body.replace(/^## /gm, " ## ");
+}
 function isTieredRow(c) {
   return typeof c.p1 === "string" && c.p1.length > 0;
 }
@@ -178857,25 +178906,22 @@ function renderCompartmentAtTier(c, tier2) {
   return renderOneCompartment(c, tier2);
 }
 function renderOneCompartment(c, tier2) {
-  const baseAttrs = `start="${c.startMessage}" end="${c.endMessage}" title="${escapeXmlAttr2(c.title)}"`;
   if (tier2 >= 5)
     return "";
+  const heading = compartmentHeading(c);
   if (c.legacy === 1 || !isTieredRow(c)) {
     const flat = (c.content ?? "").trim();
     if (tier2 >= 4 || flat.length === 0)
-      return `<compartment ${baseAttrs} />`;
-    return [
-      `<compartment ${baseAttrs}>`,
-      escapeXmlContent2(legacyBodyForTier(flat, tier2)),
-      "</compartment>"
-    ].join(`
-`);
+      return heading;
+    const body2 = guardCompartmentBody(escapeXmlContent2(legacyBodyForTier(flat, tier2)));
+    return `${heading}
+${body2}`;
   }
   const body = tierBody(c, tier2);
   if (body.length === 0)
-    return `<compartment ${baseAttrs} />`;
-  return [`<compartment ${baseAttrs}>`, escapeXmlContent2(body), "</compartment>"].join(`
-`);
+    return heading;
+  return `${heading}
+${guardCompartmentBody(escapeXmlContent2(body))}`;
 }
 function computeTiers(compartments, historyBudgetTokens) {
   const v2Compartments = compartments.map((c, originalIndex) => ({ c, originalIndex })).filter(({ c }) => c.legacy !== 1);
@@ -178934,6 +178980,7 @@ function extractM0Block(m0Text, tag) {
   const m = m0Text.match(new RegExp(`<${tag}>[\\s\\S]*?</${tag}>`));
   return m ? m[0] : null;
 }
+var DEFAULT_HISTORY_BUDGET_TOKENS = 60000;
 var init_decay_render = __esm(() => {
   init_decay_curve();
   init_read_session_formatting();
@@ -179057,30 +179104,7 @@ function getVisibleMemoryIds(db, sessionId) {
   }
 }
 function renderMemoryBlock(memories) {
-  const byCategory = new Map;
-  for (const m of memories) {
-    const existing = byCategory.get(m.category);
-    if (existing) {
-      existing.push(m);
-    } else {
-      byCategory.set(m.category, [m]);
-    }
-  }
-  const sections = [];
-  for (const category of CATEGORY_PRIORITY) {
-    const categoryMemories = byCategory.get(category);
-    if (!categoryMemories || categoryMemories.length === 0) {
-      continue;
-    }
-    sections.push(`<${category}>`, ...categoryMemories.map((m) => `- ${escapeXmlContent(m.content)}`), `</${category}>`);
-  }
-  if (sections.length === 0) {
-    return null;
-  }
-  return `<project-memory>
-${sections.join(`
-`)}
-</project-memory>`;
+  return renderMemoryBlockV2(memories) || null;
 }
 function utilityTier(m) {
   if (m.retrievalCount > 0)
@@ -179107,14 +179131,12 @@ function trimMemoriesToBudget(sessionId, memories, budgetTokens) {
     return a.id - b.id;
   });
   const result = [];
-  let usedTokens = 0;
   for (const memory of sorted) {
-    const memoryTokens = estimateTokens(`- ${memory.content}`) + 6;
-    if (usedTokens + memoryTokens > budgetTokens) {
+    const candidate = [...result, memory];
+    if (estimateTokens(renderMemoryBlockV2(candidate)) > budgetTokens) {
       break;
     }
     result.push(memory);
-    usedTokens += memoryTokens;
   }
   if (result.length < memories.length) {
     sessionLog(sessionId, `trimmed memories from ${memories.length} to ${result.length} to fit injection budget of ${budgetTokens} tokens`);
@@ -179386,11 +179408,18 @@ function memorySelectionOrder(left, right) {
   return left.id - right.id;
 }
 function memoryRenderOrder(left, right) {
-  const aPriority = MEMORY_CATEGORY_ORDER_PRIORITY[left.category] ?? MEMORY_CATEGORY_ORDER_UNKNOWN;
-  const bPriority = MEMORY_CATEGORY_ORDER_PRIORITY[right.category] ?? MEMORY_CATEGORY_ORDER_UNKNOWN;
-  const categoryDiff = aPriority - bPriority;
-  if (categoryDiff !== 0)
-    return categoryDiff;
+  const leftPriority = V2_MEMORY_CATEGORIES.indexOf(left.category);
+  const rightPriority = V2_MEMORY_CATEGORIES.indexOf(right.category);
+  if (leftPriority >= 0 || rightPriority >= 0) {
+    if (leftPriority < 0)
+      return 1;
+    if (rightPriority < 0)
+      return -1;
+    if (leftPriority !== rightPriority)
+      return leftPriority - rightPriority;
+  } else if (left.category !== right.category) {
+    return left.category < right.category ? -1 : 1;
+  }
   return left.id - right.id;
 }
 function cachedStatement(cache, db, sql) {
@@ -179534,13 +179563,13 @@ function mustMaterialize(args) {
 function trimMemoriesToBudgetV2(sessionId, memories, budgetTokens, renderOptions = {}) {
   const selectionOrder = [...memories].sort(memorySelectionOrder);
   const selected = [];
-  let usedTokens = MEMORY_BLOCK_WRAPPER_TOKENS;
+  const accounting = createMemoryBlockAccounting(renderOptions);
   for (const memory of selectionOrder) {
-    const memoryTokens = estimateTokens(renderMemoryLineV2(memory, renderOptions.sourceNameByMemoryId?.get(memory.id)));
-    if (usedTokens + memoryTokens > budgetTokens)
+    const cost = accounting.candidateCost(memory);
+    if (accounting.usedTokens + cost > budgetTokens)
       continue;
+    accounting.admit(memory, cost);
     selected.push(memory);
-    usedTokens += memoryTokens;
   }
   if (selected.length < memories.length) {
     sessionLog(sessionId, `v2 trimmed memories from ${memories.length} to ${selected.length} to fit injection budget of ${budgetTokens} tokens`);
@@ -179554,23 +179583,22 @@ function trimWorkspaceMemoriesToBudgetV2(sessionId, memories, budgetTokens, work
   }
   const selected = [];
   const selectedIds = new Set;
-  let usedTokens = MEMORY_BLOCK_WRAPPER_TOKENS;
-  const tokenCost = (memory) => estimateTokens(renderMemoryLineV2(memory, renderOptions.sourceNameByMemoryId?.get(memory.id)));
+  const accounting = createMemoryBlockAccounting(renderOptions);
   const trySelect = (memory) => {
     if (selectedIds.has(memory.id))
       return false;
-    const tokens = tokenCost(memory);
-    if (usedTokens + tokens > budgetTokens)
+    const cost = accounting.candidateCost(memory);
+    if (accounting.usedTokens + cost > budgetTokens)
       return false;
     selected.push(memory);
     selectedIds.add(memory.id);
-    usedTokens += tokens;
+    accounting.admit(memory, cost);
     return true;
   };
   for (const memory of memories.filter((candidate) => candidate.status === "permanent").sort(memorySelectionOrder)) {
     trySelect(memory);
   }
-  const remainingAfterPermanent = Math.max(0, budgetTokens - usedTokens);
+  const remainingAfterPermanent = Math.max(0, budgetTokens - accounting.usedTokens);
   const floorTokens = remainingAfterPermanent / Math.max(1, workspace.identities.length);
   const byIdentity = new Map;
   for (const memory of memories) {
@@ -179589,15 +179617,15 @@ function trimWorkspaceMemoriesToBudgetV2(sessionId, memories, budgetTokens, work
     for (const memory of candidates) {
       if (selectedIds.has(memory.id))
         continue;
-      const tokens = tokenCost(memory);
-      if (memberTokens + tokens > floorTokens)
+      const cost = accounting.candidateCost(memory);
+      if (memberTokens + cost > floorTokens)
         continue;
-      if (usedTokens + tokens > budgetTokens)
+      if (accounting.usedTokens + cost > budgetTokens)
         continue;
       selected.push(memory);
       selectedIds.add(memory.id);
-      usedTokens += tokens;
-      memberTokens += tokens;
+      accounting.admit(memory, cost);
+      memberTokens += cost;
     }
   }
   const remaining = memories.filter((memory) => !selectedIds.has(memory.id)).sort(memorySelectionOrder);
@@ -179642,6 +179670,29 @@ function readM0Compartments(db, sessionId) {
 function nullableString(value) {
   return typeof value === "string" ? value : null;
 }
+function withCompartmentDates(sessionId, compartments, temporalAwareness) {
+  if (!temporalAwareness || compartments.length === 0)
+    return compartments;
+  const messageIds = new Set;
+  for (const compartment of compartments) {
+    if (compartment.startMessageId)
+      messageIds.add(compartment.startMessageId);
+    if (compartment.endMessageId)
+      messageIds.add(compartment.endMessageId);
+  }
+  const times = getMessageTimesFromOpenCodeDb(sessionId, Array.from(messageIds));
+  return compartments.map((compartment) => {
+    const startMs = times.get(compartment.startMessageId);
+    const endMs = times.get(compartment.endMessageId);
+    if (startMs === undefined || endMs === undefined)
+      return compartment;
+    return {
+      ...compartment,
+      startDate: formatDate(startMs),
+      endDate: formatDate(endMs)
+    };
+  });
+}
 function rowToM0Compartment(row) {
   return {
     id: Number(row.id ?? 0),
@@ -179684,17 +179735,55 @@ function readNewMemoriesForM1(db, projectPath, afterId, expiryCutoff) {
               ORDER BY ${MEMORY_CATEGORY_ORDER_SQL}, id ASC`).all(projectPath, afterId, expiryCutoff).filter(isMemoryRow);
   return rows.map((row) => ({ ...row }));
 }
+function createMemoryBlockAccounting(renderOptions) {
+  const seenCategories = new Set;
+  const categoryCost = new Map;
+  return {
+    usedTokens: estimateTokens(`<project-memory>
+</project-memory>`),
+    candidateCost(memory) {
+      const line = renderMemoryLineV2(memory, renderOptions.sourceNameByMemoryId?.get(memory.id));
+      let cost = estimateTokens(`${line}
+`);
+      if (!seenCategories.has(memory.category)) {
+        let tags = categoryCost.get(memory.category);
+        if (tags === undefined) {
+          tags = estimateTokens(`<${escapeXmlAttr(memory.category)}>
+</${escapeXmlAttr(memory.category)}>
+`);
+          categoryCost.set(memory.category, tags);
+        }
+        cost += tags;
+      }
+      return cost;
+    },
+    admit(memory, cost) {
+      this.usedTokens += cost;
+      seenCategories.add(memory.category);
+    }
+  };
+}
 function renderMemoryLineV2(memory, sourceName) {
-  const sourceAttr = sourceName ? ` source="${escapeXmlAttr(sourceName)}"` : "";
-  return `  <memory id="${memory.id}" category="${escapeXmlAttr(memory.category)}"${sourceAttr} importance="${memory.importance ?? 50}">${escapeXmlContent(memory.content)}</memory>`;
+  const source = sourceName ? ` [${escapeXmlContent(sourceName)}]` : "";
+  return `#${memory.id}${source}: ${escapeXmlContent(memory.content)}`;
 }
 function renderMemoryBlockV2(memories, wrapper = "project-memory", renderOptions = {}) {
   if (memories.length === 0)
     return "";
+  const ordered = [...memories].sort(memoryRenderOrder);
   const lines = [`<${wrapper}>`];
-  for (const memory of memories) {
+  let openCategory;
+  for (const memory of ordered) {
+    if (memory.category !== openCategory) {
+      if (openCategory !== undefined)
+        lines.push(`</${escapeXmlAttr(openCategory)}>`);
+      openCategory = memory.category;
+      lines.push(`<${escapeXmlAttr(openCategory)}>`);
+    }
     lines.push(renderMemoryLineV2(memory, renderOptions.sourceNameByMemoryId?.get(memory.id)));
   }
+  if (openCategory !== undefined)
+    lines.push(`</${escapeXmlAttr(openCategory)}>`);
   lines.push(`</${wrapper}>`);
   return lines.join(`
 `);
@@ -179723,7 +179812,7 @@ function renderM0(args) {
   const userProfile = renderUserProfileBlock(trimUserMemoriesToBudget(args.userProfileBaseline, args.userProfileBudgetTokens ?? DEFAULT_USER_PROFILE_BUDGET_TOKENS));
   if (userProfile)
     sections.push(userProfile);
-  const baseBudget = args.historyBudgetTokens ?? DEFAULT_HISTORY_BUDGET_TOKENS;
+  const baseBudget = args.historyBudgetTokens ?? DEFAULT_HISTORY_BUDGET_TOKENS2;
   const effectiveBudget = baseBudget / Math.max(1, args.decayPressureMultiplier ?? 1);
   const sessionHistory = renderSessionHistoryWithDecay({
     compartments: args.compartments,
@@ -179813,6 +179902,7 @@ function materializeM0(options) {
     } catch {}
     throw error51;
   }
+  compartments = withCompartmentDates(options.sessionId, compartments, options.temporalAwareness);
   const memoryBudget = options.memoryInjectionBudgetTokens ?? DEFAULT_MEMORY_BUDGET_TOKENS;
   const memoryRenderOptions = {
     sourceNameByMemoryId: sourceNamesForMemories({
@@ -179830,12 +179920,12 @@ function materializeM0(options) {
     memories: trimmed.renderOrder,
     facts,
     memoryRenderOptions,
-    historyBudgetTokens: options.historyBudgetTokens ?? DEFAULT_HISTORY_BUDGET_TOKENS,
+    historyBudgetTokens: options.historyBudgetTokens ?? DEFAULT_HISTORY_BUDGET_TOKENS2,
     userProfileBudgetTokens: options.userProfileBudgetTokens,
     decayPressureMultiplier
   });
   let attempts = 0;
-  const budget = options.historyBudgetTokens ?? DEFAULT_HISTORY_BUDGET_TOKENS;
+  const budget = options.historyBudgetTokens ?? DEFAULT_HISTORY_BUDGET_TOKENS2;
   while (budget > 0 && historySliceTokens(m0Text) > budget * 1.05 && attempts < 3) {
     decayPressureMultiplier *= 1.15;
     m0Text = renderM0({
@@ -179995,7 +180085,7 @@ function renderM1WithMetadata(options, markers, renderedMemoryIds) {
   });
   if (memoryUpdates.block)
     blocks.push(memoryUpdates.block);
-  const newCompartments = readNewCompartments(options.db, options.sessionId, markers.maxCompartmentSeq);
+  const newCompartments = withCompartmentDates(options.sessionId, readNewCompartments(options.db, options.sessionId, markers.maxCompartmentSeq), options.temporalAwareness);
   if (newCompartments.length > 0) {
     blocks.push(`<new-compartments>
 ${newCompartments.map((compartment) => renderCompartmentAtTier(compartment, 1)).join(`
@@ -180211,7 +180301,7 @@ function renderFreshM0NonPersisted(options) {
   const docs = readProjectDocsForM0(projectDirectory ?? "", options.injectDocs);
   snapshotMarkers.projectDocsHash = docs.canonicalHash;
   snapshotMarkers.materializedAt = options.state.cachedM0MaterializedAt ?? 0;
-  const compartments = readM0Compartments(options.db, options.sessionId);
+  const compartments = withCompartmentDates(options.sessionId, readM0Compartments(options.db, options.sessionId), options.temporalAwareness);
   const memories = projectPath ? workspace.isWorkspaced ? getMemoriesByProjects(options.db, workspace.expandedIdentities, ["active", "permanent"], snapshotMarkers.materializedAt, workspace.ownIdentities, workspace.shareCategories) : getMemoriesByProject(options.db, projectPath, ["active", "permanent"], snapshotMarkers.materializedAt) : [];
   const userMemories = safeGetActiveUserMemories(options.db);
   const memoryBudget = options.memoryInjectionBudgetTokens ?? DEFAULT_MEMORY_BUDGET_TOKENS;
@@ -180223,7 +180313,7 @@ function renderFreshM0NonPersisted(options) {
     })
   };
   const trimmed = workspace.isWorkspaced ? trimWorkspaceMemoriesToBudgetV2(options.sessionId, memories, memoryBudget, workspace, memoryRenderOptions) : trimMemoriesToBudgetV2(options.sessionId, memories, memoryBudget);
-  const budget = options.historyBudgetTokens ?? DEFAULT_HISTORY_BUDGET_TOKENS;
+  const budget = options.historyBudgetTokens ?? DEFAULT_HISTORY_BUDGET_TOKENS2;
   let decayPressureMultiplier = 1;
   let m0Text = renderM0({
     projectDocs: docs.renderedBlock,
@@ -180345,7 +180435,7 @@ function injectM0M1(options) {
   const M0_DRIFT_RATIO_FLOOR_TOKENS = 500;
   const M1_DRIFT_RATIO = 0.15;
   const M1_ABSOLUTE_CAP_RATIO = 0.2;
-  const m1AbsoluteBudget = (options.historyBudgetTokens ?? DEFAULT_HISTORY_BUDGET_TOKENS) * M1_ABSOLUTE_CAP_RATIO;
+  const m1AbsoluteBudget = (options.historyBudgetTokens ?? DEFAULT_HISTORY_BUDGET_TOKENS2) * M1_ABSOLUTE_CAP_RATIO;
   const m1HasContent = m1Text !== M1_EMPTY_PLACEHOLDER;
   const m1Tokens = m1HasContent ? estimateTokens(m1Text) : 0;
   const m0Tokens = estimateTokens(m0Text);
@@ -180374,7 +180464,7 @@ function injectM0M1(options) {
     m1Text
   };
 }
-var INJECTION_CACHE_MAX = 100, injectionCache, CONSTRAINT_KEYWORDS, EMPTY_HARD_SIGNALS, MaterializeContentionError, RenderM1InvalidMarkersError, DEFAULT_HISTORY_BUDGET_TOKENS = 60000, DEFAULT_MEMORY_BUDGET_TOKENS = 8000, MEMORY_BLOCK_WRAPPER_TOKENS = 6, DEFAULT_USER_PROFILE_BUDGET_TOKENS = 4000, M0_EMPTY_BODY = "<session-history></session-history>", M1_EMPTY_PLACEHOLDER = "<session-history-since>(no new content since last materialization)</session-history-since>", EMPTY_PROJECT_DOCS, maxCompartmentSeqStatements, maxMemoryIdStatements, legacyCompartmentCountStatements, m0CompartmentStatements, newCompartmentStatements;
+var INJECTION_CACHE_MAX = 100, injectionCache, CONSTRAINT_KEYWORDS, EMPTY_HARD_SIGNALS, MaterializeContentionError, RenderM1InvalidMarkersError, DEFAULT_HISTORY_BUDGET_TOKENS2 = 60000, DEFAULT_MEMORY_BUDGET_TOKENS = 8000, DEFAULT_USER_PROFILE_BUDGET_TOKENS = 4000, M0_EMPTY_BODY = "<session-history></session-history>", M1_EMPTY_PLACEHOLDER = "<session-history-since>(no new content since last materialization)</session-history-since>", EMPTY_PROJECT_DOCS, maxCompartmentSeqStatements, maxMemoryIdStatements, legacyCompartmentCountStatements, m0CompartmentStatements, newCompartmentStatements;
 var init_inject_compartments = __esm(async () => {
   init_compartment_storage();
   init_constants();
@@ -186699,6 +186789,10 @@ function stripUnsafeProjectConfigFields(projectRaw) {
     delete projectRaw.sqlite;
     warnings.push("Ignoring sqlite.* from project config (security: SQLite cache/mmap PRAGMAs apply to the " + "process-global shared database handle; only user-level config may set them).");
   }
+  if ("shadow_transform" in projectRaw) {
+    delete projectRaw.shadow_transform;
+    warnings.push("Ignoring shadow_transform from project config (security: this developer-only mirror lane is user-level only).");
+  }
   const embedding = projectRaw.embedding;
   if (isPlainObject2(embedding)) {
     const removed = [];
@@ -195133,8 +195227,8 @@ function makeToolCompositeKey(ownerMsgId, callId) {
   return `${ownerMsgId}${TOOL_COMPOSITE_KEY_SEP}${callId}`;
 }
 var GET_COUNTER_SQL = `SELECT counter FROM session_meta WHERE session_id = ?`;
-var GET_ASSIGNMENTS_SQL = "SELECT message_id, tag_number, type, tool_owner_message_id FROM tags WHERE session_id = ? ORDER BY tag_number ASC";
-var GET_ASSIGNMENTS_SCOPED_SQL = "SELECT message_id, tag_number, type, tool_owner_message_id FROM tags WHERE session_id = ? AND tag_number >= ? ORDER BY tag_number ASC";
+var GET_ASSIGNMENTS_SQL = "SELECT message_id, tag_number, type, tool_owner_message_id, byte_size, token_count, input_byte_size, input_token_count FROM tags WHERE session_id = ? ORDER BY tag_number ASC";
+var GET_ASSIGNMENTS_SCOPED_SQL = "SELECT message_id, tag_number, type, tool_owner_message_id, byte_size, token_count, input_byte_size, input_token_count FROM tags WHERE session_id = ? AND tag_number >= ? ORDER BY tag_number ASC";
 var PROBE_DATA_VERSION_SQL = "PRAGMA main.data_version";
 var probeDataVersionStatements = new WeakMap;
 function getProbeDataVersionStatement(db) {
@@ -195158,6 +195252,14 @@ function isAssignmentRow(row) {
     return false;
   if (candidate.tool_owner_message_id !== null && typeof candidate.tool_owner_message_id !== "string")
     return false;
+  if (typeof candidate.byte_size !== "number")
+    return false;
+  if (candidate.token_count !== null && typeof candidate.token_count !== "number")
+    return false;
+  if (typeof candidate.input_byte_size !== "number")
+    return false;
+  if (candidate.input_token_count !== null && typeof candidate.input_token_count !== "number")
+    return false;
   return true;
 }
 var UPSERT_COUNTER_SQL = `
@@ -195192,6 +195294,7 @@ var MAX_TAG_ALLOC_RETRIES = 5;
 function createTagger() {
   const counters = new Map;
   const assignments = new Map;
+  const toolAccountingBySession = new Map;
   const loadSignatures = new Map;
   function getSessionAssignments(sessionId) {
     let map2 = assignments.get(sessionId);
@@ -195201,6 +195304,14 @@ function createTagger() {
     }
     return map2;
   }
+  function getSessionToolAccounting(sessionId) {
+    let map2 = toolAccountingBySession.get(sessionId);
+    if (!map2) {
+      map2 = new Map;
+      toolAccountingBySession.set(sessionId, map2);
+    }
+    return map2;
+  }
   function isUniqueConstraintError2(error51) {
     return error51 instanceof Error && "code" in error51 && error51.code === "SQLITE_CONSTRAINT_UNIQUE";
   }
@@ -195254,6 +195365,14 @@ function createTagger() {
       }
       counters.set(sessionId, next);
       sessionAssignments.set(mapKey, next);
+      if (type === "tool") {
+        getSessionToolAccounting(sessionId).set(next, {
+          byteSize: byteSize2,
+          tokenCount: tokenCounts?.tokenCount ?? null,
+          inputByteSize,
+          inputTokenCount: tokenCounts?.inputTokenCount ?? null
+        });
+      }
       return next;
     }
     throw new Error(`tagger.allocateTag: failed to allocate tag for session=${sessionId} key=${mapKey} after ${MAX_TAG_ALLOC_RETRIES} retries`);
@@ -195314,6 +195433,13 @@ function createTagger() {
   function getToolTag(sessionId, callId, ownerMsgId) {
     return assignments.get(sessionId)?.get(makeToolCompositeKey(ownerMsgId, callId));
   }
+  function getToolTagAccounting(sessionId, callId, ownerMsgId) {
+    const tagNumber = getToolTag(sessionId, callId, ownerMsgId);
+    return tagNumber === undefined ? undefined : toolAccountingBySession.get(sessionId)?.get(tagNumber);
+  }
+  function setToolTagAccounting(sessionId, tagNumber, accounting) {
+    getSessionToolAccounting(sessionId).set(tagNumber, accounting);
+  }
   function bindTag(sessionId, messageId, tagNumber) {
     getSessionAssignments(sessionId).set(messageId, tagNumber);
   }
@@ -195332,6 +195458,7 @@ function createTagger() {
   function resetCounter(sessionId, db) {
     counters.set(sessionId, 0);
     assignments.delete(sessionId);
+    toolAccountingBySession.delete(sessionId);
     loadSignatures.delete(sessionId);
     getResetCounterStatement(db).run(sessionId, getHarness());
   }
@@ -195354,11 +195481,19 @@ function createTagger() {
     const assignmentRows = (floor > 0 ? db.prepare(GET_ASSIGNMENTS_SCOPED_SQL).all(sessionId, floor) : db.prepare(GET_ASSIGNMENTS_SQL).all(sessionId)).filter(isAssignmentRow);
     const sessionAssignments = getSessionAssignments(sessionId);
     sessionAssignments.clear();
+    const sessionToolAccounting = getSessionToolAccounting(sessionId);
+    sessionToolAccounting.clear();
     let maxTagNumber = 0;
     for (const assignment of assignmentRows) {
       if (assignment.type === "tool") {
         if (assignment.tool_owner_message_id !== null) {
           sessionAssignments.set(makeToolCompositeKey(assignment.tool_owner_message_id, assignment.message_id), assignment.tag_number);
+          sessionToolAccounting.set(assignment.tag_number, {
+            byteSize: assignment.byte_size,
+            tokenCount: assignment.token_count,
+            inputByteSize: assignment.input_byte_size,
+            inputTokenCount: assignment.input_token_count
+          });
         }
       } else {
         sessionAssignments.set(assignment.message_id, assignment.tag_number);
@@ -195378,6 +195513,7 @@ function createTagger() {
   function cleanup(sessionId) {
     counters.delete(sessionId);
     assignments.delete(sessionId);
+    toolAccountingBySession.delete(sessionId);
     loadSignatures.delete(sessionId);
   }
   return {
@@ -195385,6 +195521,8 @@ function createTagger() {
     assignToolTag,
     getTag,
     getToolTag,
+    getToolTagAccounting,
+    setToolTagAccounting,
     bindTag,
     unbindTag,
     bindToolTag,
@@ -195639,26 +195777,28 @@ function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPer
     sessionLog(sessionId, `compartment trigger: skipped — historian already in progress (usage=${usage.percentage.toFixed(1)}%)`);
     return { shouldFire: false };
   }
-  if (inMemoryTail) {
+  const lazyInMemoryTail = typeof inMemoryTail === "function" ? inMemoryTail : undefined;
+  let resolvedInMemoryTail = typeof inMemoryTail === "function" ? undefined : inMemoryTail;
+  if (resolvedInMemoryTail) {
     try {
       const policyVersion = loadProtectedTailMeta(db, sessionId).protectedTailPolicyVersion;
       if (policyVersion < 3)
-        inMemoryTail = undefined;
+        resolvedInMemoryTail = undefined;
     } catch {
-      inMemoryTail = undefined;
+      resolvedInMemoryTail = undefined;
     }
   }
-  const taggerFloor = taggerFloorOverride !== undefined && taggerFloorOverride > 0 ? taggerFloorOverride : inMemoryTail ? deriveTagLoadFloor(db, sessionId, inMemoryTail.messages.map((m) => m.id)) : 0;
+  const taggerFloor = taggerFloorOverride !== undefined && taggerFloorOverride > 0 ? taggerFloorOverride : resolvedInMemoryTail ? deriveTagLoadFloor(db, sessionId, resolvedInMemoryTail.messages.map((m) => m.id)) : 0;
   const proactiveFloorForGate = getProactiveCompartmentTriggerPercentage(executeThresholdPercentage);
   if (usage.percentage < proactiveFloorForGate) {
     try {
-      const boundFloor = inMemoryTail ? taggerFloor : 0;
+      const boundFloor = resolvedInMemoryTail || lazyInMemoryTail ? taggerFloor : 0;
       const { bound: persistedBound, nullCount } = getTriggerTagTokenUpperBound(db, sessionId, boundFloor);
       if (nullCount === 0) {
-        const untaggedUpperBound = inMemoryTail ? estimateUntaggedInMemoryTailUpperBound(db, sessionId, inMemoryTail, taggerFloor) : 0;
+        const untaggedUpperBound = resolvedInMemoryTail ? estimateUntaggedInMemoryTailUpperBound(db, sessionId, resolvedInMemoryTail, taggerFloor) : 0;
         const eligibleUpperBound = persistedBound + untaggedUpperBound;
         if (eligibleUpperBound < triggerBudget) {
-          const memorySuffix = inMemoryTail ? ` (persisted=${persistedBound}, untagged-memory≤${untaggedUpperBound})` : "";
+          const memorySuffix = resolvedInMemoryTail ? ` (persisted=${persistedBound}, untagged-memory≤${untaggedUpperBound})` : "";
           sessionLog(sessionId, `compartment trigger: cheap-skip at ${usage.percentage.toFixed(1)}% (below proactive floor ${proactiveFloorForGate}%) — live-tail upper bound ${eligibleUpperBound}${memorySuffix} < triggerBudget ${triggerBudget}; no size trigger possible, skipped full raw read`);
           return { shouldFire: false };
         }
@@ -195667,7 +195807,16 @@ function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPer
       sessionLog(sessionId, `compartment trigger: cheap-gate skipped (falling through to full read): ${error51 instanceof Error ? error51.message : String(error51)}`);
     }
   }
-  const tailInfo = getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThresholdPercentage, contextLimit, inMemoryTail, taggerFloor);
+  if (lazyInMemoryTail) {
+    try {
+      const policyVersion = loadProtectedTailMeta(db, sessionId).protectedTailPolicyVersion;
+      if (policyVersion >= 3)
+        resolvedInMemoryTail = lazyInMemoryTail();
+    } catch {
+      resolvedInMemoryTail = undefined;
+    }
+  }
+  const tailInfo = getUnsummarizedTailInfo(db, sessionId, triggerBudget, usage, executeThresholdPercentage, contextLimit, resolvedInMemoryTail, taggerFloor);
   if (!tailInfo.hasNewRawHistory) {
     try {
       const lastCompartmentEnd = getLastCompartmentEndMessage(db, sessionId);
@@ -195694,11 +195843,11 @@ function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPer
     }
     const scale = usage.percentage >= BLOCK_UNTIL_DONE_PERCENTAGE ? 0.25 : 0.5;
     const scaledBoundary = withRawSessionMessageCache(() => {
-      if (inMemoryTail) {
+      if (resolvedInMemoryTail) {
         primeInMemoryTailRawMessageCache({
           sessionId,
-          messages: inMemoryTail.messages,
-          absoluteMessageCount: inMemoryTail.absoluteMessageCount
+          messages: resolvedInMemoryTail.messages,
+          absoluteMessageCount: resolvedInMemoryTail.absoluteMessageCount
         });
       }
       return resolveOpenCodeProtectedTailBoundary({
@@ -195840,9 +195989,8 @@ function executeStatus(db, sessionId, protectedTags, executeThresholdPercentageC
     const compartments = getCompartments(db, sessionId);
     let historyBlockTokens = 0;
     for (const c of compartments) {
-      historyBlockTokens += estimateTokens(`<compartment start="${c.startMessage}" end="${c.endMessage}" title="${c.title}">
+      historyBlockTokens += estimateTokens(`## ${c.startMessage}-${c.endMessage} · ${c.title}
 ${c.content}
-</compartment>
 `);
     }
     const budgetTokens = historyBudgetPercentage && displayContextLimit > 0 ? Math.floor(displayContextLimit * (Math.min(executeThresholdPercentage, 80) / 100) * historyBudgetPercentage) : null;
@@ -196345,6 +196493,7 @@ var reconciliationScheduledSessions = new Set;
 var sessionLocks = new Map;
 var incrementalTimers = new Map;
 var pendingIncrementalKeys = new Set;
+var completedIncrementalKeys = new Set;
 function defer(fn) {
   const immediate = globalThis.setImmediate;
   if (typeof immediate === "function") {
@@ -196412,9 +196561,9 @@ function scheduleReconciliation(db, sessionId, readMessages) {
     });
   });
 }
-function scheduleIncrementalIndex(db, sessionId, messageId, readSingleMessage) {
+function scheduleIncrementalIndex(db, sessionId, messageId, messageSource) {
   const key = `${sessionId}\x00${messageId}`;
-  if (incrementalTimers.has(key) || pendingIncrementalKeys.has(key)) {
+  if (completedIncrementalKeys.has(key) || incrementalTimers.has(key) || pendingIncrementalKeys.has(key)) {
     return;
   }
   const timer = setTimeout(() => {
@@ -196422,12 +196571,12 @@ function scheduleIncrementalIndex(db, sessionId, messageId, readSingleMessage) {
     pendingIncrementalKeys.add(key);
     let attemptedOrdinal = null;
     runWithSessionLock(sessionId, () => {
-      const message = readSingleMessage(sessionId, messageId);
-      if (!message) {
+      const message = typeof messageSource === "function" ? messageSource(sessionId, messageId) : messageSource;
+      if (!message)
         return;
-      }
       attemptedOrdinal = message.ordinal;
       indexSingleMessage(db, sessionId, message);
+      completedIncrementalKeys.add(key);
     }).catch((error51) => {
       markMessageIndexDirty(db, sessionId, attemptedOrdinal ?? getLastIndexedOrdinal(db, sessionId) + 1);
       reconciledSessions.delete(sessionId);
@@ -196441,6 +196590,11 @@ function scheduleIncrementalIndex(db, sessionId, messageId, readSingleMessage) {
 function scheduleClearAndReindex(db, sessionId, readMessages) {
   reconciledSessions.delete(sessionId);
   reconciliationScheduledSessions.delete(sessionId);
+  const prefix = `${sessionId}\x00`;
+  for (const key of completedIncrementalKeys) {
+    if (key.startsWith(prefix))
+      completedIncrementalKeys.delete(key);
+  }
   defer(() => {
     runWithSessionLock(sessionId, () => {
       clearIndexedMessages(db, sessionId);
@@ -196468,6 +196622,10 @@ function clearSessionTracking(sessionId) {
       pendingIncrementalKeys.delete(key);
     }
   }
+  for (const key of completedIncrementalKeys) {
+    if (key.startsWith(prefix))
+      completedIncrementalKeys.delete(key);
+  }
 }
 
 // src/hooks/magic-context/event-handler.ts
@@ -197437,6 +197595,7 @@ function resolveCtxReduceAvailability(sessionId) {
 }
 
 // src/hooks/magic-context/transform.ts
+init_decay_render();
 init_derive_budgets();
 
 // src/hooks/magic-context/image-token-estimate.ts
@@ -197657,6 +197816,1295 @@ function replaySentinelByMessageIds(messages, ids, providerID) {
       missingIds.push(id);
   return { replayed, missingIds };
 }
+
+// src/hooks/magic-context/shadow-sender.ts
+init_compartment_storage();
+init_storage_memory();
+init_storage_memory_mutation_log();
+init_storage_meta_persisted();
+init_workspaces();
+init_data_path();
+init_logger();
+init_temporal_awareness();
+await __promiseAll([
+  init_storage(),
+  init_read_session_chunk()
+]);
+import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+import { existsSync as existsSync21, readFileSync as readFileSync13, statSync as statSync8 } from "node:fs";
+import net from "node:net";
+import { join as join19 } from "node:path";
+var DEFAULT_MODULE_ID = "magic-context";
+function getDefaultConnectionFile() {
+  return join19(getDataDir(), "cortexkit", "run", "subc-connection.json");
+}
+var SUBC_HEADER_LEN = 17;
+var SUBC_PROTOCOL_VERSION = 1;
+var FRAME_REQUEST = 0;
+var FRAME_RESPONSE = 1;
+var FRAME_ERROR = 5;
+var PRIORITY_BACKGROUND_FLAGS = 2 << 1;
+var AUTH_CLIENT_DOMAIN = "subc-client-v1";
+var AUTH_SERVER_DOMAIN = "subc-server-v1";
+var NONCE_LEN = 32;
+var PROOF_LEN = 32;
+var CONNECT_BACKOFF_INITIAL_MS = 1000;
+var CONNECT_BACKOFF_MAX_MS = 30000;
+var REQUEST_TIMEOUT_MS = 5000;
+var HANDSHAKE_TIMEOUT_MS = 2000;
+var RESEED_COOLDOWN_MS = 30 * 60 * 1000;
+var RESEED_ATTEMPT_CAP = 5;
+var declaredTrimBySession = new Map;
+function emptyCounters() {
+  return {
+    enqueued: 0,
+    dropped_oldest: 0,
+    send_failures: 0,
+    connection_skips: 0,
+    ordinal_unresolved: 0,
+    ordinal_mismatch: 0,
+    state_sync_rejects: 0,
+    generation_rejects: 0,
+    resets_sent: 0,
+    transforms_sent: 0
+  };
+}
+function createSessionQueueState() {
+  return {
+    queue: [],
+    running: false,
+    initialized: false,
+    shadowGeneration: 0,
+    lastAckedSeq: 0,
+    lastAckedWatermarks: null,
+    idOrdinalMemoGeneration: 0,
+    idOrdinalMemo: new Map,
+    requireResetReason: "cold_start",
+    blockedUntilReset: false,
+    seedPassPending: false,
+    skipped: false,
+    reseedAttempts: 0,
+    lastReseedAttemptMs: null,
+    reseedAwaitingSuccess: false,
+    counters: emptyCounters()
+  };
+}
+function cloneJson(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function stableHash(value) {
+  return createHmac("sha256", "magic-context-shadow-watermark").update(value).digest("hex");
+}
+function getMessageId(message) {
+  return typeof message.info.id === "string" && message.info.id.length > 0 ? message.info.id : null;
+}
+function readStringField(part, field) {
+  if (!isRecord(part))
+    return null;
+  if (field === "text")
+    return typeof part.text === "string" ? part.text : null;
+  if (field === "tool_state_output") {
+    return isRecord(part.state) && typeof part.state.output === "string" ? part.state.output : null;
+  }
+  return typeof part.content === "string" ? part.content : null;
+}
+function writeStringField(part, field, value) {
+  if (!isRecord(part))
+    return;
+  if (field === "text") {
+    part.text = value;
+    return;
+  }
+  if (field === "tool_state_output") {
+    if (isRecord(part.state))
+      part.state.output = value;
+    return;
+  }
+  part.content = value;
+}
+function removeExactSuffix(value, suffix) {
+  if (!suffix || !value.endsWith(suffix))
+    return null;
+  return value.slice(0, value.length - suffix.length);
+}
+function denormalizeShadowOutput(args) {
+  const clonedOutput = cloneJson(args.outputMessages);
+  const normalizations = [];
+  const messageIndex = new Map;
+  args.outputMessages.forEach((message, index) => {
+    messageIndex.set(message, index);
+  });
+  for (const target of args.normalizationTargets) {
+    const msgIndex = messageIndex.get(target.message);
+    if (msgIndex === undefined)
+      continue;
+    let partIndex = -1;
+    for (let index = 0;index < target.message.parts.length; index += 1) {
+      if (target.message.parts[index] === target.part) {
+        partIndex = index;
+        break;
+      }
+    }
+    if (partIndex < 0)
+      continue;
+    const cloneMessage = clonedOutput[msgIndex];
+    const clonePart = cloneMessage?.parts?.[partIndex];
+    const current = readStringField(clonePart, target.field);
+    if (current === null)
+      continue;
+    const prefix = `§${target.tagNumber}§ `;
+    if (!current.startsWith(prefix))
+      continue;
+    writeStringField(clonePart, target.field, current.slice(prefix.length));
+    normalizations.push({
+      kind: "tag_prefix",
+      message_id: getMessageId(target.message),
+      part_index: partIndex,
+      field: target.field,
+      tag_number: target.tagNumber,
+      removed: prefix
+    });
+  }
+  const hintDecisions = getAutoSearchHintDecisions(args.db, args.sessionId).filter((decision) => decision.decision === "hint" && typeof decision.text === "string");
+  if (hintDecisions.length > 0) {
+    const hintByMessage = new Map;
+    for (const decision of hintDecisions) {
+      if (decision.decision === "hint")
+        hintByMessage.set(decision.messageId, decision.text);
+    }
+    args.outputMessages.forEach((message, msgIndex) => {
+      const messageId = getMessageId(message);
+      if (!messageId)
+        return;
+      const hint = hintByMessage.get(messageId);
+      if (!hint)
+        return;
+      const cloneMessage = clonedOutput[msgIndex];
+      for (let partIndex = 0;partIndex < message.parts.length; partIndex += 1) {
+        const originalPart = message.parts[partIndex];
+        if (!isRecord(originalPart) || originalPart.type !== "text")
+          continue;
+        const clonePart = cloneMessage?.parts?.[partIndex];
+        const current = readStringField(clonePart, "text");
+        if (current === null)
+          continue;
+        const stripped = removeExactSuffix(current, hint);
+        if (stripped === null)
+          continue;
+        writeStringField(clonePart, "text", stripped);
+        normalizations.push({
+          kind: "ctx_search_hint",
+          message_id: messageId,
+          part_index: partIndex,
+          field: "text",
+          removed: hint
+        });
+        break;
+      }
+    });
+  }
+  const tsOutput = clonedOutput.filter((message, index) => {
+    if (!isRawCompactionSummaryInfo(args.outputMessages[index]?.info))
+      return true;
+    normalizations.push({
+      kind: "summary_message",
+      message_id: getMessageId(args.outputMessages[index]),
+      part_index: -1,
+      field: "ts_output",
+      removed: JSON.stringify(message)
+    });
+    return false;
+  });
+  return { ts_output: tsOutput, normalizations };
+}
+function resolveOrdinalsForShadow(args) {
+  const memo = args.memo;
+  if (args.memoGeneration !== args.generation) {
+    memo.clear();
+  }
+  const ordinalById = readRawSessionMessageIdOrdinals(args.sessionId);
+  const normalizations = [];
+  const visibleMessages = args.messages.filter((message) => {
+    if (!isRawCompactionSummaryInfo(message.info))
+      return true;
+    normalizations.push({
+      kind: "summary_message",
+      message_id: getMessageId(message),
+      part_index: -1,
+      field: "input",
+      removed: JSON.stringify(message)
+    });
+    return false;
+  });
+  const annotated = visibleMessages;
+  const resolved = new Array(annotated.length);
+  let firstUnresolvedId;
+  for (let index = 0;index < annotated.length; index += 1) {
+    const messageId = getMessageId(visibleMessages[index]);
+    if (!messageId)
+      return { ok: false, reason: "unresolved" };
+    const ordinal = ordinalById.get(messageId);
+    if (ordinal === undefined && firstUnresolvedId === undefined) {
+      firstUnresolvedId = messageId;
+    }
+    resolved[index] = ordinal;
+  }
+  let suffixStart = annotated.length;
+  while (suffixStart > 0 && resolved[suffixStart - 1] === undefined) {
+    suffixStart -= 1;
+  }
+  for (let index = 0;index < suffixStart; index += 1) {
+    if (resolved[index] === undefined) {
+      return { ok: false, reason: "unresolved", messageId: firstUnresolvedId };
+    }
+  }
+  if (suffixStart < annotated.length) {
+    const base = suffixStart > 0 ? resolved[suffixStart - 1] : -1;
+    for (let index = suffixStart;index < annotated.length; index += 1) {
+      resolved[index] = base + (index - suffixStart) + 1;
+    }
+  }
+  for (let index = 0;index < annotated.length; index += 1) {
+    const messageId = getMessageId(visibleMessages[index]);
+    const ordinal = resolved[index];
+    const prior = memo.get(messageId);
+    if (prior !== undefined && prior !== ordinal) {
+      return { ok: false, reason: "mismatch", messageId };
+    }
+    memo.set(messageId, ordinal);
+    annotated[index].absolute_ordinal = ordinal;
+  }
+  return {
+    ok: true,
+    annotatedInput: annotated,
+    memoGeneration: args.generation,
+    normalizations
+  };
+}
+function ordinalForMessageId(args) {
+  if (args.state.idOrdinalMemoGeneration !== args.generation) {
+    args.state.idOrdinalMemo.clear();
+    args.state.idOrdinalMemoGeneration = args.generation;
+  }
+  if (!args.raw)
+    return null;
+  const prior = args.state.idOrdinalMemo.get(args.messageId);
+  if (prior !== undefined && prior !== args.raw.ordinal)
+    return "mismatch";
+  args.state.idOrdinalMemo.set(args.messageId, args.raw.ordinal);
+  return args.raw.ordinal;
+}
+function flatBlockCountForRawMessage(message) {
+  if (!message)
+    return 1;
+  let count = 0;
+  for (const part of message.parts) {
+    if (!isRecord(part)) {
+      count += 1;
+      continue;
+    }
+    const type = typeof part.type === "string" ? part.type : "unknown";
+    switch (type) {
+      case "text":
+        if (part.ignored !== true)
+          count += 1;
+        break;
+      case "reasoning":
+      case "file":
+      case "image":
+      case "step-start":
+      case "subtask":
+        count += 1;
+        break;
+      case "tool": {
+        count += 1;
+        const status = isRecord(part.state) ? part.state.status : undefined;
+        const hasCompletedStatus = status === "completed" || status === "error";
+        const hasOutput = isRecord(part.state) ? typeof part.state.output === "string" || typeof part.state.error === "string" : typeof part.output === "string" || typeof part.error === "string";
+        if (hasCompletedStatus || hasOutput)
+          count += 1;
+        break;
+      }
+      case "compaction":
+      case "step-finish":
+      case "snapshot":
+      case "patch":
+      case "agent":
+      case "retry":
+        break;
+      default:
+        count += 1;
+        break;
+    }
+  }
+  return Math.max(1, count);
+}
+function flatBlockIdForRawMessage(messageId, raw, edge) {
+  const blockIndex = edge === "start" ? 0 : flatBlockCountForRawMessage(raw) - 1;
+  return `${messageId}#${blockIndex}`;
+}
+function resolveDeclaredTrimForShadow(args) {
+  const marker = getPersistedCompactionMarkerState(args.db, args.sessionId);
+  if (!marker || marker.boundaryOrdinal < 1)
+    return null;
+  const targetEndMessageId = marker.targetEndMessageId ?? marker.boundaryMessageId;
+  if (!targetEndMessageId)
+    return null;
+  const markerKey = `${marker.boundaryOrdinal}:${targetEndMessageId}`;
+  const cached2 = declaredTrimBySession.get(args.sessionId);
+  if (cached2?.markerKey === markerKey)
+    return cached2.trim;
+  const boundaryRaw = readRawSessionMessageById(args.sessionId, targetEndMessageId);
+  if (!boundaryRaw)
+    return null;
+  const compartments = getCompartmentsByEndMessageId(args.db, args.sessionId, targetEndMessageId);
+  const boundaryCompartment = compartments.find((compartment) => compartment.endMessage === marker.boundaryOrdinal);
+  if (!boundaryCompartment)
+    return null;
+  const trim = {
+    flat_boundary_id: flatBlockIdForRawMessage(targetEndMessageId, boundaryRaw, "end"),
+    boundary_bare_message_id: targetEndMessageId,
+    boundary_absolute_ordinal: marker.boundaryOrdinal,
+    next_absolute_ordinal: marker.boundaryOrdinal + 1
+  };
+  declaredTrimBySession.set(args.sessionId, { markerKey, trim });
+  return trim;
+}
+function clearDeclaredTrimForSession(sessionId) {
+  declaredTrimBySession.delete(sessionId);
+}
+function didDeclaredTrimAdvance(before, after) {
+  if (!after)
+    return false;
+  if (!before)
+    return true;
+  return before.flat_boundary_id !== after.flat_boundary_id;
+}
+function resolveShadowWorkspaceContext(db, projectPath) {
+  if (!projectPath) {
+    return {
+      workspace: null,
+      expandedIdentities: [],
+      ownIdentities: [],
+      shareCategories: null
+    };
+  }
+  const identitySet = resolveWorkspaceIdentitySet(db, projectPath);
+  if (identitySet.identities.length <= 1) {
+    return {
+      workspace: null,
+      expandedIdentities: [projectPath],
+      ownIdentities: [projectPath],
+      shareCategories: null
+    };
+  }
+  const expanded = expandWorkspaceIdentitySetWithAliases(db, identitySet.identities);
+  const ownIdentities = expanded.expandedIdentities.filter((identity) => expanded.canonicalIdentityByStoredPath.get(identity) === projectPath);
+  if (ownIdentities.length === 0)
+    ownIdentities.push(projectPath);
+  const shareCategories = resolveWorkspaceShareCategories(db, projectPath) ?? [];
+  const members = [
+    projectPath,
+    ...expanded.expandedIdentities.filter((identity) => identity !== projectPath).sort((left, right) => left.localeCompare(right))
+  ];
+  return {
+    workspace: {
+      fingerprint: computeWorkspaceEpochFingerprint(db, identitySet.identities),
+      members: members.map((member) => ({
+        project_path: member,
+        share_categories: [...shareCategories]
+      }))
+    },
+    expandedIdentities: members,
+    ownIdentities,
+    shareCategories
+  };
+}
+function loadWatermarks(args) {
+  const sessionMeta = getOrCreateSessionMeta(args.db, args.sessionId);
+  const compartmentRow = args.db.prepare("SELECT COALESCE(MAX(sequence), -1) AS max_sequence FROM compartments WHERE session_id = ?").get(args.sessionId);
+  const memoryId = args.projectPath ? getMaxMemoryIdForProjects(args.db, args.workspace.expandedIdentities, args.workspace.ownIdentities, args.workspace.shareCategories) : 0;
+  const m0Row = args.db.prepare("SELECT COALESCE(MAX(id), 0) AS max_id FROM m0_mutation_log WHERE session_id = ?").get(args.sessionId);
+  const memoryMutationId = args.projectPath ? getMaxMemoryMutationIdForProjects(args.db, args.workspace.expandedIdentities) ?? 0 : 0;
+  return {
+    compartment_sequence: compartmentRow?.max_sequence ?? -1,
+    memory_id: memoryId,
+    m0_mutation_id: m0Row?.max_id ?? 0,
+    memory_mutation_id: memoryMutationId,
+    last_todo_state_hash: stableHash(sessionMeta.lastTodoState ?? "")
+  };
+}
+function watermarksEqual(left, right) {
+  return left !== null && left.compartment_sequence === right.compartment_sequence && left.memory_id === right.memory_id && left.m0_mutation_id === right.m0_mutation_id && left.memory_mutation_id === right.memory_mutation_id && left.last_todo_state_hash === right.last_todo_state_hash;
+}
+function serializeCompartment(args) {
+  const startRaw = args.readRawById(args.compartment.startMessageId);
+  const endRaw = args.readRawById(args.compartment.endMessageId);
+  const startOrdinal = ordinalForMessageId({
+    raw: startRaw,
+    messageId: args.compartment.startMessageId,
+    generation: args.state.shadowGeneration,
+    state: args.state
+  });
+  const endOrdinal = ordinalForMessageId({
+    raw: endRaw,
+    messageId: args.compartment.endMessageId,
+    generation: args.state.shadowGeneration,
+    state: args.state
+  });
+  if (startOrdinal === "mismatch" || endOrdinal === "mismatch")
+    return "mismatch";
+  if (startOrdinal === null || endOrdinal === null)
+    return null;
+  const startCreatedAt = startRaw?.createdAt;
+  const endCreatedAt = endRaw?.createdAt;
+  const dateRange = typeof startCreatedAt === "number" && typeof endCreatedAt === "number" ? {
+    start_date: formatDate(startCreatedAt),
+    end_date: formatDate(endCreatedAt)
+  } : {};
+  return {
+    sequence: args.compartment.sequence,
+    start_message: startOrdinal,
+    end_message: endOrdinal,
+    start_message_id: flatBlockIdForRawMessage(args.compartment.startMessageId, startRaw ?? undefined, "start"),
+    end_message_id: flatBlockIdForRawMessage(args.compartment.endMessageId, endRaw ?? undefined, "end"),
+    ...dateRange,
+    title: args.compartment.title,
+    content: args.compartment.content,
+    p1: args.compartment.p1,
+    p2: args.compartment.p2,
+    p3: args.compartment.p3,
+    p4: args.compartment.p4,
+    importance: args.compartment.importance,
+    episode_type: args.compartment.episodeType,
+    legacy: args.compartment.legacy,
+    created_at: args.compartment.createdAt
+  };
+}
+function buildStateSyncPayload(args) {
+  const workspace = resolveShadowWorkspaceContext(args.pass.db, args.pass.projectPath);
+  const currentWatermarks = loadWatermarks({
+    db: args.pass.db,
+    sessionId: args.pass.sessionId,
+    projectPath: args.pass.projectPath,
+    workspace
+  });
+  if (!args.force && args.state.lastAckedWatermarks && currentWatermarks.m0_mutation_id > args.state.lastAckedWatermarks.m0_mutation_id) {
+    return "m0_mutation";
+  }
+  if (!args.force && watermarksEqual(args.state.lastAckedWatermarks, currentWatermarks)) {
+    return null;
+  }
+  const acked = args.force ? {
+    compartment_sequence: -1,
+    memory_id: 0,
+    m0_mutation_id: 0,
+    memory_mutation_id: 0,
+    last_todo_state_hash: ""
+  } : args.state.lastAckedWatermarks ?? {
+    compartment_sequence: -1,
+    memory_id: 0,
+    m0_mutation_id: 0,
+    memory_mutation_id: 0,
+    last_todo_state_hash: ""
+  };
+  const rawById = new Map;
+  const readRawById = (messageId) => {
+    if (!rawById.has(messageId)) {
+      rawById.set(messageId, readRawSessionMessageById(args.pass.sessionId, messageId));
+    }
+    return rawById.get(messageId) ?? null;
+  };
+  const compartments = [];
+  for (const compartment of getCompartments(args.pass.db, args.pass.sessionId)) {
+    if (compartment.sequence <= acked.compartment_sequence)
+      continue;
+    const serialized = serializeCompartment({
+      compartment,
+      readRawById,
+      state: args.state
+    });
+    if (serialized === "mismatch")
+      return "mismatch";
+    if (serialized === null)
+      return "unresolved";
+    compartments.push(serialized);
+  }
+  const allMemories = args.pass.projectPath ? workspace.workspace ? getMemoriesByProjects(args.pass.db, workspace.expandedIdentities, ["active", "permanent"], args.pass.passInputs.now_ms, workspace.ownIdentities, workspace.shareCategories) : getMemoriesByProject(args.pass.db, args.pass.projectPath, ["active", "permanent"], args.pass.passInputs.now_ms) : [];
+  const memories = allMemories.filter((memory) => memory.id > acked.memory_id).map((memory) => ({
+    id: memory.id,
+    project_path: memory.projectPath,
+    category: memory.category,
+    content: memory.content,
+    normalized_hash: memory.normalizedHash,
+    importance: memory.importance,
+    scope: memory.scope,
+    shareable: memory.shareable,
+    source_session_id: memory.sourceSessionId,
+    source_type: memory.sourceType,
+    seen_count: memory.seenCount,
+    retrieval_count: memory.retrievalCount,
+    first_seen_at: memory.firstSeenAt,
+    created_at: memory.createdAt,
+    updated_at: memory.updatedAt,
+    last_seen_at: memory.lastSeenAt,
+    last_retrieved_at: memory.lastRetrievedAt,
+    status: memory.status,
+    expires_at: memory.expiresAt,
+    verification_status: memory.verificationStatus,
+    verified_at: memory.verifiedAt,
+    superseded_by_memory_id: memory.supersededByMemoryId,
+    merged_from: memory.mergedFrom,
+    metadata_json: memory.metadataJson
+  }));
+  const renderedMemoryIds = allMemories.map((memory) => memory.id);
+  const memoryMutations = args.pass.projectPath ? getMemoryMutationsForRenderByProjects(args.pass.db, workspace.expandedIdentities, acked.memory_mutation_id, renderedMemoryIds).map((row) => ({
+    id: row.id,
+    project_path: row.projectPath,
+    mutation_type: row.mutationType,
+    target_memory_id: row.targetMemoryId,
+    superseded_by_id: row.supersededById,
+    category: row.category,
+    new_content: row.newContent,
+    queued_at: row.queuedAt
+  })) : [];
+  const sessionMeta = getOrCreateSessionMeta(args.pass.db, args.pass.sessionId);
+  return {
+    method: "state_sync",
+    params: {
+      shadow_generation: args.state.shadowGeneration,
+      expected_shadow_seq: args.state.lastAckedSeq,
+      seed_boundary_id: args.state.seedPassPending && compartments.length > 0 ? args.pass.declaredTrim?.flat_boundary_id ?? null : null,
+      compartments,
+      memories,
+      memory_mutations: memoryMutations,
+      workspace: workspace.workspace,
+      last_todo_state: sessionMeta.lastTodoState ?? ""
+    },
+    watermarks: currentWatermarks
+  };
+}
+function extractAckValue(response) {
+  if (isRecord(response) && isRecord(response.result))
+    return response.result;
+  return isRecord(response) ? response : {};
+}
+function numericAck(response, keys, fallback) {
+  const value = extractAckValue(response);
+  for (const key of keys) {
+    const candidate = value[key];
+    if (typeof candidate === "number" && Number.isFinite(candidate))
+      return candidate;
+  }
+  return fallback;
+}
+function errorCode(error51) {
+  if (isRecord(error51) && typeof error51.code === "string")
+    return error51.code;
+  return null;
+}
+function isPeerReject(error51) {
+  const code = errorCode(error51);
+  if (code === "stale_generation" || code === "shadow_generation_mismatch" || code === "shadow_seq_mismatch" || code === "seq_mismatch" || code === "cas_mismatch" || code === "state_cas_reject") {
+    return true;
+  }
+  const text = error51 instanceof Error ? error51.message : String(error51);
+  return text.includes("generation") || text.includes("shadow_seq") || text.includes("seq mismatch") || text.includes("CAS");
+}
+function isSeedBoundaryReject(error51) {
+  return errorCode(error51) === "shadow_seed_boundary_mismatch";
+}
+function isConnectionFailure(error51) {
+  const code = errorCode(error51);
+  if (code === "ENOENT" || code === "ECONNREFUSED" || code === "ECONNRESET")
+    return true;
+  const text = error51 instanceof Error ? error51.message : String(error51);
+  return text.includes("backoff") || text.includes("connection") || text.includes("ECONN");
+}
+function toFlatWireBody(payload) {
+  return { method: payload.method, ...payload.params };
+}
+function buildShadowResetBody(args) {
+  return {
+    method: "shadow_reset",
+    params: {
+      shadow_generation: args.state.shadowGeneration,
+      reason: args.reason
+    }
+  };
+}
+function buildShadowTransformBody(args) {
+  const denormalized = args.pass.shadowTsOutput !== undefined && args.pass.shadowNormalizations !== undefined ? {
+    ts_output: args.pass.shadowTsOutput,
+    normalizations: args.pass.shadowNormalizations
+  } : denormalizeShadowOutput({
+    db: args.pass.db,
+    sessionId: args.pass.sessionId,
+    outputMessages: args.pass.outputMessages,
+    normalizationTargets: args.pass.normalizationTargets
+  });
+  return {
+    method: "shadow_transform",
+    params: {
+      shadow_generation: args.state.shadowGeneration,
+      seed_pass: args.state.seedPassPending,
+      input: args.pass.annotatedInput,
+      ts_output: denormalized.ts_output,
+      normalizations: denormalized.normalizations,
+      pass_inputs: args.pass.passInputs,
+      ts_decision: args.pass.tsDecision,
+      declared_trim: args.pass.declaredTrim
+    }
+  };
+}
+function createShadowSender(options = {}) {
+  const transport = options.transport ?? new SubcShadowTransport;
+  const now = options.now ?? Date.now;
+  const reseedCooldownMs = options.reseedCooldownMs ?? RESEED_COOLDOWN_MS;
+  const reseedAttemptCap = options.reseedAttemptCap ?? RESEED_ATTEMPT_CAP;
+  const sessions = new Map;
+  const subagentSessions = new Set;
+  const getState = (sessionId) => {
+    let state = sessions.get(sessionId);
+    if (!state) {
+      state = createSessionQueueState();
+      sessions.set(sessionId, state);
+    }
+    return state;
+  };
+  const schedule = (sessionId) => {
+    const state = getState(sessionId);
+    if (state.running)
+      return;
+    state.running = true;
+    runQueue(sessionId, state).finally(() => {
+      state.running = false;
+      if (state.queue.length > 0)
+        schedule(sessionId);
+    });
+  };
+  const pushWork = (sessionId, work) => {
+    const state = getState(sessionId);
+    if (work.kind === "pass") {
+      state.counters.enqueued += 1;
+      let dropped = 0;
+      for (let index = state.queue.length - 1;index >= 0; index -= 1) {
+        if (state.queue[index]?.kind !== "pass")
+          continue;
+        state.queue.splice(index, 1);
+        dropped += 1;
+      }
+      if (dropped > 0) {
+        state.counters.dropped_oldest += dropped;
+        sessionLog(sessionId, `shadow: dropped ${dropped} stale queued pass${dropped === 1 ? "" : "es"}`);
+      }
+    }
+    state.queue.push(work);
+    schedule(sessionId);
+  };
+  const runQueue = async (sessionId, state) => {
+    while (!state.skipped && state.queue.length > 0) {
+      const item = state.queue.shift();
+      if (!item)
+        continue;
+      if (item.kind === "reset") {
+        try {
+          await performReset({
+            sessionId,
+            state,
+            reason: item.reason,
+            projectRoot: item.projectRoot
+          });
+        } catch (error51) {
+          state.counters.send_failures += 1;
+          state.initialized = false;
+          state.blockedUntilReset = true;
+          state.requireResetReason ??= item.reason || "reset_retry";
+          sessionLog(sessionId, "shadow: reset failed (ignored):", error51);
+        }
+        continue;
+      }
+      try {
+        await processPass(state, item.pass);
+      } catch (error51) {
+        state.counters.send_failures += 1;
+        if (isPeerReject(error51)) {
+          const code = errorCode(error51);
+          if (code?.includes("generation"))
+            state.counters.generation_rejects += 1;
+          else
+            state.counters.state_sync_rejects += 1;
+          state.requireResetReason = code ?? "peer_reject";
+          state.blockedUntilReset = true;
+          state.lastAckedWatermarks = null;
+        } else if (isConnectionFailure(error51)) {
+          state.counters.connection_skips += 1;
+          state.initialized = false;
+          state.requireResetReason = "route_reopen";
+        }
+        sessionLog(sessionId, "shadow: send failed (ignored):", error51);
+      }
+    }
+  };
+  const performReset = async (args) => {
+    const projectRoot = args.projectRoot ?? process.cwd();
+    const body = toFlatWireBody(buildShadowResetBody(args));
+    const response = await transport.call({
+      sessionId: args.sessionId,
+      projectRoot,
+      method: "shadow_reset",
+      body
+    });
+    args.state.shadowGeneration = numericAck(response, ["shadow_generation", "generation"], args.state.shadowGeneration + 1);
+    args.state.lastAckedSeq = numericAck(response, ["shadow_seq", "seq"], 0);
+    args.state.lastAckedWatermarks = null;
+    args.state.idOrdinalMemo.clear();
+    args.state.idOrdinalMemoGeneration = args.state.shadowGeneration;
+    clearDeclaredTrimForSession(args.sessionId);
+    args.state.initialized = true;
+    args.state.blockedUntilReset = false;
+    args.state.requireResetReason = null;
+    args.state.seedPassPending = true;
+    args.state.counters.resets_sent += 1;
+    sessionLog(args.sessionId, `shadow: reset acknowledged (generation=${args.state.shadowGeneration})`);
+  };
+  const beginReseed = (state) => {
+    const attemptAt = now();
+    if (state.reseedAttempts >= reseedAttemptCap)
+      return false;
+    if (state.lastReseedAttemptMs !== null && attemptAt - state.lastReseedAttemptMs < reseedCooldownMs) {
+      return false;
+    }
+    state.reseedAttempts += 1;
+    state.lastReseedAttemptMs = attemptAt;
+    state.reseedAwaitingSuccess = true;
+    return true;
+  };
+  const processPass = async (state, pass) => {
+    if (state.skipped)
+      return;
+    if (state.blockedUntilReset && !state.requireResetReason) {
+      state.requireResetReason = "unknown_block";
+    }
+    if (!state.initialized || state.requireResetReason) {
+      await performReset({
+        sessionId: pass.sessionId,
+        state,
+        reason: state.requireResetReason ?? "cold_start",
+        projectRoot: pass.projectRoot
+      });
+    }
+    if (state.skipped || state.blockedUntilReset)
+      return;
+    let resolved;
+    try {
+      resolved = resolveOrdinalsForShadow({
+        sessionId: pass.sessionId,
+        messages: pass.inputMessages,
+        generation: state.shadowGeneration,
+        memoGeneration: state.idOrdinalMemoGeneration,
+        memo: state.idOrdinalMemo
+      });
+    } catch (error51) {
+      sessionLog(pass.sessionId, "shadow: capture failed (ignored):", error51);
+      return;
+    }
+    if (!resolved.ok) {
+      if (resolved.reason === "mismatch") {
+        state.counters.ordinal_mismatch += 1;
+        state.requireResetReason = "ordinal_mismatch";
+        state.blockedUntilReset = true;
+        state.idOrdinalMemo.clear();
+        await performReset({
+          sessionId: pass.sessionId,
+          state,
+          reason: "ordinal_mismatch",
+          projectRoot: pass.projectRoot
+        });
+      } else {
+        state.counters.ordinal_unresolved += 1;
+        sessionLog(pass.sessionId, `shadow: pass skipped; unresolved ordinal for ${resolved.messageId ?? "unknown"}`);
+      }
+      return;
+    }
+    state.idOrdinalMemoGeneration = resolved.memoGeneration;
+    let preparedPass;
+    let syncPayload;
+    try {
+      const declaredTrim = resolveDeclaredTrimForShadow({
+        db: pass.db,
+        sessionId: pass.sessionId
+      });
+      const denormalized = denormalizeShadowOutput({
+        db: pass.db,
+        sessionId: pass.sessionId,
+        outputMessages: pass.outputMessages,
+        normalizationTargets: pass.normalizationTargets
+      });
+      preparedPass = {
+        ...pass,
+        annotatedInput: resolved.annotatedInput,
+        shadowTsOutput: denormalized.ts_output,
+        shadowNormalizations: [...resolved.normalizations, ...denormalized.normalizations],
+        declaredTrim,
+        tsDecision: {
+          ...pass.tsDecision,
+          marker_state: {
+            marker_message_id: declaredTrim?.boundary_bare_message_id,
+            advanced_this_pass: didDeclaredTrimAdvance(pass.declaredTrimBefore, declaredTrim)
+          }
+        }
+      };
+      syncPayload = buildStateSyncPayload({
+        state,
+        pass: preparedPass,
+        force: state.lastAckedWatermarks === null
+      });
+    } catch (error51) {
+      sessionLog(pass.sessionId, "shadow: capture failed (ignored):", error51);
+      return;
+    }
+    if (syncPayload === "m0_mutation") {
+      await performReset({
+        sessionId: pass.sessionId,
+        state,
+        reason: "m0_mutation",
+        projectRoot: pass.projectRoot
+      });
+      try {
+        const fullSync = buildStateSyncPayload({ state, pass: preparedPass, force: true });
+        if (fullSync === "m0_mutation") {
+          throw new Error("forced state sync unexpectedly requested another m0 reset");
+        }
+        syncPayload = fullSync;
+      } catch (error51) {
+        sessionLog(pass.sessionId, "shadow: capture failed (ignored):", error51);
+        return;
+      }
+    }
+    if (syncPayload === "mismatch") {
+      state.counters.ordinal_mismatch += 1;
+      state.requireResetReason = "ordinal_mismatch";
+      await performReset({
+        sessionId: pass.sessionId,
+        state,
+        reason: "ordinal_mismatch",
+        projectRoot: pass.projectRoot
+      });
+      return;
+    }
+    if (syncPayload === "unresolved") {
+      state.counters.ordinal_unresolved += 1;
+      sessionLog(pass.sessionId, "shadow: state sync skipped; compartment ordinal unresolved");
+      return;
+    }
+    if (syncPayload !== null) {
+      let response2;
+      try {
+        response2 = await transport.call({
+          sessionId: pass.sessionId,
+          projectRoot: pass.projectRoot,
+          method: "state_sync",
+          body: toFlatWireBody(syncPayload)
+        });
+      } catch (error51) {
+        if (isSeedBoundaryReject(error51) && beginReseed(state)) {
+          await performReset({
+            sessionId: pass.sessionId,
+            state,
+            reason: "seed_boundary_reseed",
+            projectRoot: pass.projectRoot
+          });
+          if (!state.skipped)
+            await processPass(state, pass);
+          return;
+        }
+        throw error51;
+      }
+      if (state.skipped)
+        return;
+      state.lastAckedSeq = numericAck(response2, ["shadow_seq", "seq"], syncPayload.params.expected_shadow_seq + 1);
+      state.lastAckedWatermarks = syncPayload.watermarks;
+    }
+    const transformBody = toFlatWireBody(buildShadowTransformBody({ pass: preparedPass, state }));
+    const response = await transport.call({
+      sessionId: pass.sessionId,
+      projectRoot: pass.projectRoot,
+      method: "shadow_transform",
+      body: transformBody
+    });
+    if (state.skipped)
+      return;
+    const ack = extractAckValue(response);
+    state.seedPassPending = false;
+    state.counters.transforms_sent += 1;
+    if (ack.divergence || ack.divergence_class || ack.hard_divergence) {
+      sessionLog(pass.sessionId, "shadow: divergence report", ack);
+    }
+    if (ack.quarantined === true && beginReseed(state)) {
+      await performReset({
+        sessionId: pass.sessionId,
+        state,
+        reason: "quarantine_reseed",
+        projectRoot: pass.projectRoot
+      });
+      if (!state.skipped)
+        await processPass(state, pass);
+    } else if (ack.quarantined !== true && state.reseedAwaitingSuccess) {
+      state.reseedAttempts = 0;
+      state.lastReseedAttemptMs = null;
+      state.reseedAwaitingSuccess = false;
+    }
+  };
+  return {
+    enqueue(pass) {
+      if (pass.isSubagent) {
+        const state = sessions.get(pass.sessionId);
+        if (state) {
+          state.skipped = true;
+          state.queue.length = 0;
+          sessions.delete(pass.sessionId);
+        }
+        clearDeclaredTrimForSession(pass.sessionId);
+        transport.closeSession?.(pass.sessionId);
+        if (!subagentSessions.has(pass.sessionId)) {
+          subagentSessions.add(pass.sessionId);
+          sessionLog(pass.sessionId, "shadow: skipped (subagent session)");
+        }
+        return;
+      }
+      pushWork(pass.sessionId, { kind: "pass", pass });
+    },
+    resetSession(sessionId, reason) {
+      if (subagentSessions.has(sessionId))
+        return;
+      const state = getState(sessionId);
+      state.queue.length = 0;
+      state.requireResetReason = reason;
+      state.blockedUntilReset = true;
+      transport.closeSession?.(sessionId);
+      pushWork(sessionId, { kind: "reset", sessionId, reason });
+    },
+    clearSession(sessionId) {
+      const state = sessions.get(sessionId);
+      if (state)
+        state.skipped = true;
+      sessions.delete(sessionId);
+      subagentSessions.delete(sessionId);
+      clearDeclaredTrimForSession(sessionId);
+      transport.closeSession?.(sessionId);
+    },
+    getStats(sessionId) {
+      return { ...getState(sessionId).counters };
+    }
+  };
+}
+
+class SubcShadowTransport {
+  connectionFile;
+  moduleId;
+  socket = null;
+  reader = null;
+  nextCorr = 1;
+  routes = new Map;
+  pending = Promise.resolve();
+  nextProbeMs = 0;
+  backoffMs = CONNECT_BACKOFF_INITIAL_MS;
+  requestTimeoutMs;
+  constructor(connectionFile, moduleId = DEFAULT_MODULE_ID, requestTimeoutMs = REQUEST_TIMEOUT_MS) {
+    this.connectionFile = connectionFile ?? getDefaultConnectionFile();
+    this.moduleId = moduleId;
+    this.requestTimeoutMs = requestTimeoutMs;
+  }
+  async call(args) {
+    const run = async () => {
+      const route = await this.ensureRoute(args.sessionId, args.projectRoot);
+      return await this.unaryJson(route, args.body);
+    };
+    const next = this.pending.then(run, run);
+    this.pending = next.then(() => {
+      return;
+    }, () => {
+      return;
+    });
+    return next;
+  }
+  closeSession(sessionId) {
+    this.routes.delete(sessionId);
+  }
+  async ensureRoute(sessionId, projectRoot) {
+    const existing = this.routes.get(sessionId);
+    if (existing !== undefined)
+      return existing;
+    await this.ensureConnected();
+    const body = {
+      op: "route.open",
+      target: { kind: "tool_provider", module_id: this.moduleId },
+      identity: {
+        project_root: projectRoot,
+        harness: getHarness(),
+        session: `shadow:${sessionId}`
+      }
+    };
+    const moduleId = process.env.SUBC_MODULE_ID;
+    const launchNonce = process.env.SUBC_LAUNCH_NONCE;
+    if (moduleId && launchNonce) {
+      body.consumer_identity = { module_id: moduleId, launch_nonce: launchNonce };
+    }
+    const response = await this.unaryJson(0, body);
+    const ack = extractAckValue(response);
+    const route = ack.route_channel;
+    if (typeof route !== "number")
+      throw new Error("connection route.open missing route_channel");
+    this.routes.set(sessionId, route);
+    return route;
+  }
+  async ensureConnected() {
+    if (this.socket && !this.socket.destroyed && this.reader)
+      return;
+    const now = Date.now();
+    if (now < this.nextProbeMs) {
+      throw new Error(`connection backoff active until ${this.nextProbeMs}`);
+    }
+    let candidate = null;
+    try {
+      const conn = readConnectionInfo(this.connectionFile);
+      const endpoint = conn.endpoints[0];
+      if (!endpoint)
+        throw new Error("connection file has no endpoint");
+      candidate = await connectTcp(endpoint.host, endpoint.port, HANDSHAKE_TIMEOUT_MS);
+      const reader = new SocketReader(candidate);
+      await authenticateSubcClient(candidate, reader, conn, HANDSHAKE_TIMEOUT_MS);
+      const socket = candidate;
+      this.socket = socket;
+      this.reader = reader;
+      this.routes.clear();
+      this.backoffMs = CONNECT_BACKOFF_INITIAL_MS;
+      this.nextProbeMs = 0;
+      socket.once("close", () => {
+        if (this.socket === socket)
+          this.invalidateConnection(socket);
+      });
+    } catch (error51) {
+      candidate?.destroy();
+      this.invalidateConnection();
+      this.nextProbeMs = Date.now() + this.backoffMs;
+      this.backoffMs = Math.min(this.backoffMs * 2, CONNECT_BACKOFF_MAX_MS);
+      throw error51;
+    }
+  }
+  invalidateConnection(socket = this.socket) {
+    if (socket && this.socket && socket !== this.socket)
+      return;
+    this.socket = null;
+    this.reader = null;
+    this.routes.clear();
+    socket?.destroy();
+  }
+  async unaryJson(channel, body) {
+    await this.ensureConnected();
+    const socket = this.socket;
+    const reader = this.reader;
+    if (!socket || !reader)
+      throw new Error("connection unavailable");
+    const corr = this.nextCorr++;
+    try {
+      await writeFrame(socket, {
+        type: FRAME_REQUEST,
+        channel,
+        corr,
+        body: Buffer.from(JSON.stringify(body))
+      });
+      const frame = await readTerminalFor(reader, channel, corr, this.requestTimeoutMs);
+      if (frame.type === FRAME_ERROR) {
+        throw parseErrorBody(frame.body);
+      }
+      if (frame.type !== FRAME_RESPONSE) {
+        throw new Error(`unexpected subc frame type ${frame.type}`);
+      }
+      if (frame.body.length === 0)
+        return null;
+      return JSON.parse(frame.body.toString("utf8"));
+    } catch (error51) {
+      this.invalidateConnection(socket);
+      throw error51;
+    }
+  }
+}
+function readConnectionInfo(path10) {
+  if (!existsSync21(path10))
+    throw new Error(`connection file not found: ${path10}`);
+  try {
+    const mode = statSync8(path10).mode & 511;
+    if ((mode & 63) !== 0)
+      throw new Error(`connection file has insecure mode ${mode.toString(8)}`);
+  } catch (error51) {
+    if (error51 instanceof Error && error51.message.includes("insecure"))
+      throw error51;
+  }
+  const parsed = JSON.parse(readFileSync13(path10, "utf8"));
+  if (parsed.schema !== 1)
+    throw new Error(`unsupported connection schema ${parsed.schema}`);
+  if (!Array.isArray(parsed.endpoints) || parsed.endpoints.length === 0) {
+    throw new Error("connection file has no endpoints");
+  }
+  if (!Array.isArray(parsed.key) || parsed.key.length < 32)
+    throw new Error("connection key too short");
+  return parsed;
+}
+function connectTcp(host, port, timeoutMs) {
+  return new Promise((resolve4, reject) => {
+    const socket = net.createConnection({ host, port });
+    const timer = setTimeout(() => {
+      socket.destroy();
+      reject(new Error("connection timeout"));
+    }, timeoutMs);
+    socket.once("connect", () => {
+      clearTimeout(timer);
+      resolve4(socket);
+    });
+    socket.once("error", (error51) => {
+      clearTimeout(timer);
+      reject(error51);
+    });
+  });
+}
+
+class SocketReader {
+  chunks = [];
+  buffered = 0;
+  waiters = [];
+  closed = false;
+  constructor(socket) {
+    socket.on("data", (chunk) => {
+      this.chunks.push(Buffer.from(chunk));
+      this.buffered += chunk.length;
+      this.flushWaiters();
+    });
+    socket.on("close", () => {
+      this.closed = true;
+      this.flushWaiters();
+    });
+    socket.on("error", () => {
+      this.closed = true;
+      this.flushWaiters();
+    });
+  }
+  async readExact(length, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (this.buffered < length) {
+      if (this.closed)
+        throw new Error("connection closed");
+      const remaining = deadline - Date.now();
+      if (remaining <= 0)
+        throw new Error("read timeout");
+      await new Promise((resolve4, reject) => {
+        const timer = setTimeout(() => {
+          this.waiters = this.waiters.filter((waiter) => waiter !== onReady);
+          reject(new Error("read timeout"));
+        }, remaining);
+        const onReady = () => {
+          clearTimeout(timer);
+          resolve4();
+        };
+        this.waiters.push(onReady);
+      });
+    }
+    const out = Buffer.allocUnsafe(length);
+    let offset = 0;
+    while (offset < length) {
+      const first = this.chunks[0];
+      const take = Math.min(first.length, length - offset);
+      first.copy(out, offset, 0, take);
+      offset += take;
+      if (take === first.length)
+        this.chunks.shift();
+      else
+        this.chunks[0] = first.subarray(take);
+      this.buffered -= take;
+    }
+    return out;
+  }
+  flushWaiters() {
+    const waiters = this.waiters.splice(0);
+    for (const waiter of waiters)
+      waiter();
+  }
+}
+async function writeAuthMessage(socket, value) {
+  const json2 = Buffer.from(JSON.stringify(value));
+  const len = Buffer.allocUnsafe(4);
+  len.writeUInt32LE(json2.length, 0);
+  socket.write(Buffer.concat([len, json2]));
+}
+async function readAuthMessage(reader, timeoutMs) {
+  const lenBytes = await reader.readExact(4, timeoutMs);
+  const len = lenBytes.readUInt32LE(0);
+  const body = await reader.readExact(len, timeoutMs);
+  return JSON.parse(body.toString("utf8"));
+}
+function proof(key, domain2, clientNonce, serverNonce, daemonId) {
+  return createHmac("sha256", key).update(domain2).update(clientNonce).update(serverNonce).update(daemonId).digest();
+}
+async function authenticateSubcClient(socket, reader, conn, timeoutMs) {
+  const key = Buffer.from(conn.key);
+  const clientNonce = randomBytes(NONCE_LEN);
+  await writeAuthMessage(socket, { client_nonce: [...clientNonce], role: "client" });
+  const serverProof = await readAuthMessage(reader, timeoutMs);
+  const serverNonce = Buffer.from(serverProof.server_nonce ?? []);
+  const daemonId = Buffer.from(serverProof.daemon_id ?? []);
+  const serverProofBytes = Buffer.from(serverProof.server_proof ?? []);
+  const expected = proof(key, AUTH_SERVER_DOMAIN, clientNonce, serverNonce, daemonId);
+  if (daemonId.length !== conn.daemon_id.length || !timingSafeEqual(daemonId, Buffer.from(conn.daemon_id)) || serverProofBytes.length !== PROOF_LEN || !timingSafeEqual(serverProofBytes, expected)) {
+    throw new Error("invalid subc server proof");
+  }
+  const clientAuth = proof(key, AUTH_CLIENT_DOMAIN, clientNonce, serverNonce, daemonId);
+  await writeAuthMessage(socket, { client_auth: [...clientAuth] });
+}
+async function writeFrame(socket, frame) {
+  const header = Buffer.allocUnsafe(SUBC_HEADER_LEN);
+  header.writeUInt32LE(frame.body.length, 0);
+  header.writeUInt8(SUBC_PROTOCOL_VERSION, 4);
+  header.writeUInt8(frame.type, 5);
+  header.writeUInt8(PRIORITY_BACKGROUND_FLAGS, 6);
+  header.writeUInt16LE(frame.channel, 7);
+  header.writeBigUInt64LE(BigInt(frame.corr), 9);
+  socket.write(Buffer.concat([header, frame.body]));
+}
+async function readFrame(reader, timeoutMs) {
+  const header = await reader.readExact(SUBC_HEADER_LEN, timeoutMs);
+  const len = header.readUInt32LE(0);
+  const version2 = header.readUInt8(4);
+  if (version2 !== SUBC_PROTOCOL_VERSION)
+    throw new Error(`unsupported subc frame version ${version2}`);
+  const type = header.readUInt8(5);
+  const channel = header.readUInt16LE(7);
+  const corr = Number(header.readBigUInt64LE(9));
+  const body = len > 0 ? await reader.readExact(len, timeoutMs) : Buffer.alloc(0);
+  return { type, channel, corr, body };
+}
+async function readTerminalFor(reader, channel, corr, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  for (;; ) {
+    const remaining = deadline - Date.now();
+    if (remaining <= 0)
+      throw new Error("subc request timeout");
+    const frame = await readFrame(reader, remaining);
+    if (frame.channel === channel && frame.corr === corr)
+      return frame;
+  }
+}
+function parseErrorBody(body) {
+  try {
+    const parsed = JSON.parse(body.toString("utf8"));
+    const error51 = new Error(`${parsed.code ?? "subc_error"}: ${parsed.message ?? "unknown"}`);
+    if (typeof parsed.code === "string")
+      error51.code = parsed.code;
+    return error51;
+  } catch {
+    return new Error(body.toString("utf8") || "subc_error");
+  }
+}
 // src/hooks/magic-context/strip-content.ts
 var DROPPED_PLACEHOLDER_PATTERN = /^\[dropped §\d+§\]$/;
 var TAG_PREFIX_PATTERN = /^§\d+§\s*/;
@@ -198817,6 +200265,7 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
   const skipPrefixInjection = options.skipPrefixInjection === true;
   const onToolOwnerFallbackLookup = options.onToolOwnerFallbackLookup;
   const targets = new Map;
+  const normalizationTargets = [];
   const reasoningByMessage = new Map;
   const messageTagNumbers = new Map;
   const toolTagByCallId = new Map;
@@ -198937,6 +200386,12 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
         messageTagNumbers.set(message, Math.max(messageTagNumbers.get(message) ?? 0, tagId));
         if (!skipPrefixInjection) {
           textPart.text = prependTag(tagId, textPart.text);
+          normalizationTargets.push({
+            tagNumber: tagId,
+            message,
+            part: textPart,
+            field: "text"
+          });
         }
         targets.set(tagId, {
           message,
@@ -198977,6 +200432,12 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
         messageTagNumbers.set(message, Math.max(messageTagNumbers.get(message) ?? 0, tagId));
         if (!skipPrefixInjection) {
           toolPart.state.output = prependTag(tagId, toolPart.state.output);
+          normalizationTargets.push({
+            tagNumber: tagId,
+            message,
+            part: toolPart,
+            field: "tool_state_output"
+          });
         }
         toolTagByCallId.set(compositeKey, tagId);
         if (thinkingParts.length > 0 && !toolThinkingByCallId.has(compositeKey)) {
@@ -199054,7 +200515,8 @@ function tagMessages(sessionId, messages, tagger, db, options = {}) {
     toolCallIndex,
     batch,
     hasRecentReduceCall,
-    hasRecentCommit: commitDetected
+    hasRecentCommit: commitDetected,
+    normalizationTargets
   };
 }
 // src/hooks/magic-context/transform-postprocess-phase.ts
@@ -200973,6 +202435,11 @@ function clearPendingCompactionMarkerAfterSuccessfulDrain(args) {
   sessionLog(args.sessionId, "compaction-marker drain: CAS-clear failed but no pending blob remains; another drain already cleared it");
   return "cas-lost-already-cleared";
 }
+function finalizeMessageRepresentation(messages, resolvedProviderID) {
+  const clearedParts = modelAcceptsEmptyContent(resolvedProviderID) ? stripClearedReasoning(messages) : 0;
+  const mergedReasoningParts = stripReasoningFromMergedAssistants(messages, resolvedProviderID);
+  return { clearedParts, mergedReasoningParts };
+}
 async function runPostTransformPhase(args) {
   const pendingMaterializationAtPassStart = args.pendingMaterializationSessions.has(args.sessionId);
   const deferredMaterializationAtPassStart = args.deferredMaterializationSessions.has(args.sessionId);
@@ -201221,6 +202688,7 @@ async function runPostTransformPhase(args) {
         injectDocs: args.m0M1.injectDocs,
         memoryInjectionBudgetTokens: args.m0M1.memoryInjectionBudgetTokens,
         historyBudgetTokens: args.m0M1.historyBudgetTokens,
+        temporalAwareness: args.m0M1.temporalAwareness,
         isCacheBustingPass,
         hardSignals: args.m0M1.hardSignals
       });
@@ -201451,6 +202919,10 @@ async function runPostTransformPhase(args) {
   const materializeReason = m0MaterializeReason ?? (explicitMaterializedSuccessfully ? "explicit_flush" : null);
   const materialized = m0RematerializedThisPass || explicitMaterializedSuccessfully || deferredMaterializedSuccessfully;
   const bustedThisPass = args.didMutateFromFlushedStatuses || pendingOpsDidMutate || heuristicOrReasoningDidMutate || autoReclaimDidMutateThisPass || m0RematerializedThisPass || m0M1InjectedThisPass && historyWasConsumedThisPass || historyWasConsumedThisPass;
+  const tFinalRepresentation = performance.now();
+  const finalRepresentation = finalizeMessageRepresentation(args.messages, args.resolvedProviderID);
+  sessionLog(args.sessionId, `final representation: clearedParts=${finalRepresentation.clearedParts} mergedReasoningParts=${finalRepresentation.mergedReasoningParts}`);
+  logTransformTiming(args.sessionId, "finalizeMessageRepresentation", tFinalRepresentation, `clearedParts=${finalRepresentation.clearedParts} mergedReasoningParts=${finalRepresentation.mergedReasoningParts}`);
   return {
     explicitMaterializedSuccessfully,
     deferredMaterializedSuccessfully,
@@ -201505,6 +202977,16 @@ function clearMessageTokensCache(sessionId, messageId) {
     cache.delete(messageId);
 }
 var recordedSessionProjectIdentity = new BoundedSessionMap(MESSAGE_TOKENS_CACHE_MAX);
+function cloneForShadow(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function classifyShadowDecision(args) {
+  if (args.materialized)
+    return "hard";
+  if (args.schedulerDecision === "execute" || args.bustedThisPass)
+    return "soft";
+  return "defer";
+}
 function deriveTaggerLoadFloor(messages, sessionId, db) {
   return deriveTagLoadFloor(db, sessionId, function* () {
     for (const message of messages)
@@ -201548,6 +203030,19 @@ function createTransform(deps) {
     clearOpenCodePendingTransformDecision(sessionId);
     logTransformTiming(sessionId, "findSessionId", startTime, `messages=${messages.length}`);
     const db = deps.db;
+    const shadowSender = deps.shadowSender;
+    let shadowCapture;
+    if (shadowSender) {
+      try {
+        shadowCapture = {
+          nowMs: Date.now(),
+          inputMessages: cloneForShadow(messages),
+          declaredTrimBefore: resolveDeclaredTrimForShadow({ db, sessionId })
+        };
+      } catch (error51) {
+        sessionLog(sessionId, "shadow: capture failed (ignored):", error51);
+      }
+    }
     if (deps.client !== undefined) {
       scheduleReconciliation(db, sessionId, readRawSessionMessages);
     }
@@ -201902,6 +203397,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     let targets = new Map;
     let reasoningByMessage = new Map;
     let messageTagNumbers = new Map;
+    let tagNormalizationTargets = [];
     let batch = null;
     let hasRecentReduceCall = false;
     if (deps.experimentalTemporalAwareness) {
@@ -201925,6 +203421,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       targets = result.targets;
       reasoningByMessage = result.reasoningByMessage;
       messageTagNumbers = result.messageTagNumbers;
+      tagNormalizationTargets = result.normalizationTargets;
       batch = result.batch;
       hasRecentReduceCall = result.hasRecentReduceCall;
       const hadPriorCommitState = deps.commitSeenLastPass?.has(sessionId) ?? false;
@@ -201986,12 +203483,6 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     const t4 = performance.now();
     const strippedClearedReasoning = canUseEmptySentinels ? stripClearedReasoning(messages) : 0;
     logTransformTiming(sessionId, "stripClearedReasoning", t4, `strippedParts=${strippedClearedReasoning}`);
-    const tMergeStrip = performance.now();
-    const strippedMergedReasoning = stripReasoningFromMergedAssistants(messages, resolvedProviderID);
-    if (strippedMergedReasoning > 0) {
-      sessionLog(sessionId, `stripped ${strippedMergedReasoning} reasoning parts from merged assistants (anthropic groupIntoBlocks workaround)`);
-    }
-    logTransformTiming(sessionId, "stripReasoningFromMergedAssistants", tMergeStrip, `strippedParts=${strippedMergedReasoning}`);
     const watermark = getMaxDroppedTagNumber(db, sessionId);
     const contextUsage = contextUsageEarly;
     const schedulerDecision = midTurnAdjustedSchedulerDecision;
@@ -202115,6 +203606,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
         injectDocs: deps.injectDocs,
         memoryInjectionBudgetTokens: deps.memoryConfig?.injectionBudgetTokens,
         historyBudgetTokens,
+        temporalAwareness: deps.experimentalTemporalAwareness,
         hardSignals: m0HardSignals
       }
     });
@@ -202317,6 +203809,45 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     }
     const elapsed = (performance.now() - startTime).toFixed(1);
     sessionLog(sessionId, `transform completed in ${elapsed}ms (${messages.length} messages, ${targets.size} targets, watermark: ${watermark})`);
+    if (shadowSender && shadowCapture) {
+      try {
+        const shadowDecision = {
+          class: classifyShadowDecision({
+            schedulerDecision,
+            materialized: postTransformResult.materialized,
+            bustedThisPass: postTransformResult.bustedThisPass
+          }),
+          marker_state: { advanced_this_pass: false },
+          materialize_reason: postTransformResult.materializeReason,
+          emergency: postTransformResult.emergency
+        };
+        shadowSender.enqueue({
+          sessionId,
+          isSubagent: sessionMeta.isSubagent,
+          db,
+          inputMessages: shadowCapture.inputMessages,
+          outputMessages: messages,
+          normalizationTargets: tagNormalizationTargets,
+          projectRoot: sessionDirectory ?? deps.directory ?? process.cwd(),
+          projectPath: sessionProjectIdentity,
+          passInputs: {
+            now_ms: shadowCapture.nowMs,
+            model_key: deps.getModelKey?.(sessionId) ?? hardModelKey ?? null,
+            usage: {
+              input_tokens: contextUsage.inputTokens,
+              limit: resolvedContextLimit ?? boundaryContextLimit
+            },
+            effective_execute_threshold: boundaryExecuteThreshold,
+            history_budget_tokens: historyBudgetTokens ?? DEFAULT_HISTORY_BUDGET_TOKENS,
+            cache_ttl: sessionMeta.cacheTtl
+          },
+          tsDecision: shadowDecision,
+          declaredTrimBefore: shadowCapture.declaredTrimBefore
+        });
+      } catch (error51) {
+        sessionLog(sessionId, "shadow: capture failed (ignored):", error51);
+      }
+    }
     deps.maybeAutoEmbedSession?.(sessionId);
   };
 }
@@ -203390,6 +204921,7 @@ Context is managed for you entirely automatically — there's nothing to prune a
 var CTX_NOTE_GUIDANCE = `Use \`ctx_note\` ONLY for genuinely future concerns — something to revisit much later, not work coming up in the next few turns (that's already in your active context) and not active multi-step work (use todos for that). Magic Context preserves your full context across both compaction and restarts, so an upcoming restart or "let's come back to this later" is never a reason to take a note — nothing is lost either way. Notes you do take survive compression and resurface at natural work boundaries (after commits, historian runs, todo completion).`;
 var TOOL_HISTORY_GUIDANCE = `Compressed history intentionally omits tool calls and their outputs — summaries like "I edited file X" are historian records, not patterns to replicate. In the live conversation, older tool calls and their results are cleaned up to save context — you may see your own past messages referencing actions without the corresponding tool call or result visible. This is normal context management. ALWAYS use real tool calls; never simulate, fabricate, or inline tool outputs in your text. If there is no tool result message, the action did not happen. NEVER simulate, hallucinate or claim tool calls, command output, search results, file edits, or diffs in plain text as if they actually occurred.`;
 var MEMORY_GUIDANCE = `Use \`ctx_memory\` for durable project knowledge: write what future sessions must know, update/archive/merge the memories you see in \`<project-memory>\` when they drift. Memories persist across sessions and every new session starts with them.
+Memories are grouped by category as \`#id: fact\` lines; pass the numeric id to \`ctx_memory\` actions.
 **Save to memory proactively**: If you spent multiple turns finding something (a file path, a DB location, a config pattern, a workaround), save it with \`ctx_memory\` so future sessions don't repeat the search. Examples:
 - Found a project's source code path after searching → \`ctx_memory(action="write", category="CONFIG_VALUES", content="OpenCode source is at ~/Work/OSS/opencode")\`
 - Discovered a non-obvious build/test command → \`ctx_memory(action="write", category="PROJECT_RULES", content="Always use scripts/release.sh for releases")\`
@@ -203403,7 +204935,7 @@ Use \`ctx_reduce\` to mark spent tagged content as discardable and reclaim space
 Do not announce or narrate \`ctx_reduce\` drops — just call the tool silently. Saying "I'll drop these outputs" wastes tokens the user does not care about.
 ${CTX_NOTE_GUIDANCE}
 ${memoryGuidanceBlock(memoryEnabled)}Use \`ctx_search\` to search across project memories, indexed git commits, and this session's full conversation history (including compacted parts) from one query.
-Use \`ctx_expand\` to recover the raw conversation behind a \`<compartment>\` summary in \`<session-history>\` — pass its \`start\`/\`end\` attributes when the summary is not enough (exact wording, values, error text).
+Use \`ctx_expand\` to recover the raw conversation behind a summary under a \`## start-end · date · title\` heading inside \`<session-history>\` — pass the heading's start/end range when the summary is not enough (exact wording, values, error text).
 **Search before asking the user**: If you can't remember or don't know something that might have been discussed before or stored in project memory, use \`ctx_search\` before asking the user. Examples:
 - Can't remember where a related codebase or dependency lives → \`ctx_search(query="opencode source code path")\`
 - Forgot a prior architectural decision or constraint → \`ctx_search(query="why did we choose SQLite over postgres")\`
@@ -203418,7 +204950,7 @@ NEVER drop assistant text messages unless they are exceptionally large. Your con
 Before your turn finishes, consider using \`ctx_reduce\` to drop large tool outputs you no longer need.`;
 var BASE_INTRO_NO_REDUCE = (memoryEnabled) => `${CTX_NOTE_GUIDANCE}
 ${memoryGuidanceBlock(memoryEnabled)}Use \`ctx_search\` to search across project memories, indexed git commits, and this session's full conversation history (including compacted parts) from one query.
-Use \`ctx_expand\` to recover the raw conversation behind a \`<compartment>\` summary in \`<session-history>\` — pass its \`start\`/\`end\` attributes when the summary is not enough (exact wording, values, error text).
+Use \`ctx_expand\` to recover the raw conversation behind a summary under a \`## start-end · date · title\` heading inside \`<session-history>\` — pass the heading's start/end range when the summary is not enough (exact wording, values, error text).
 **Search before asking the user**: If you can't remember or don't know something that might have been discussed before or stored in project memory, use \`ctx_search\` before asking the user. Examples:
 - Can't remember where a related codebase or dependency lives → \`ctx_search(query="opencode source code path")\`
 - Forgot a prior architectural decision or constraint → \`ctx_search(query="why did we choose SQLite over postgres")\`
@@ -204004,6 +205536,7 @@ function createMagicContextHook(deps) {
   };
   const sidekickRunnable = isSidekickRunnable(deps.config);
   const sidekickConfig = sidekickRunnable ? deps.config.sidekick : undefined;
+  const shadowSender = deps.config.shadow_transform?.enabled === true ? createShadowSender() : undefined;
   const transform2 = createTransform({
     tagger: deps.tagger,
     scheduler: deps.scheduler,
@@ -204063,7 +205596,8 @@ function createMagicContextHook(deps) {
       enabled: true,
       minChars: deps.config.caveman_text_compression.min_chars ?? 500
     } : undefined,
-    maybeAutoEmbedSession
+    maybeAutoEmbedSession,
+    shadowSender
   });
   const eventHandler = createEventHandler2({
     contextUsageMap,
@@ -204090,6 +205624,7 @@ function createMagicContextHook(deps) {
       recompProgressBySession.delete(sessionId);
       internalChildSessions.delete(sessionId);
       channel1StateBySession.delete(sessionId);
+      shadowSender?.clearSession(sessionId);
       clearEmbedSessionState(sessionId);
     }
   });
@@ -204269,22 +205804,9 @@ function createMagicContextHook(deps) {
 // src/plugin/hooks/create-session-hooks.ts
 function buildMagicContextHookConfig(pluginConfig) {
   return {
+    ...pluginConfig,
     protected_tags: pluginConfig.protected_tags ?? DEFAULT_PROTECTED_TAGS,
-    cache_ttl: pluginConfig.cache_ttl,
-    clear_reasoning_age: pluginConfig.clear_reasoning_age,
-    toast_duration_ms: pluginConfig.toast_duration_ms,
-    execute_threshold_percentage: pluginConfig.execute_threshold_percentage ?? DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE,
-    execute_threshold_tokens: pluginConfig.execute_threshold_tokens,
-    historian: pluginConfig.historian,
-    history_budget_percentage: pluginConfig.history_budget_percentage,
-    historian_timeout_ms: pluginConfig.historian_timeout_ms,
-    memory: pluginConfig.memory,
-    sidekick: pluginConfig.sidekick,
-    dreamer: pluginConfig.dreamer,
-    commit_cluster_trigger: pluginConfig.commit_cluster_trigger,
-    system_prompt_injection: pluginConfig.system_prompt_injection,
-    temporal_awareness: pluginConfig.temporal_awareness,
-    caveman_text_compression: pluginConfig.caveman_text_compression
+    execute_threshold_percentage: pluginConfig.execute_threshold_percentage ?? DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE
   };
 }
 function createSessionHooks(args) {
@@ -204507,9 +206029,8 @@ function computeM0BlockTokens(db, sessionId, args) {
     try {
       const compRows = db.prepare("SELECT content, title, start_message, end_message FROM compartments WHERE session_id = ?").all(sessionId);
       for (const c of compRows) {
-        compartmentTokens += estimateTokens(`<compartment start="${c.start_message}" end="${c.end_message}" title="${c.title}">
+        compartmentTokens += estimateTokens(`## ${c.start_message}-${c.end_message} · ${c.title}
 ${c.content}
-</compartment>
 `);
       }
     } catch {}
@@ -205260,9 +206781,9 @@ import { tool } from "@opencode-ai/plugin";
 // src/tools/ctx-expand/constants.ts
 var CTX_EXPAND_DESCRIPTION = `Recover the original conversation from your compacted history.
 
-Older parts of this session are summarized into <compartment> blocks inside <session-history> — e.g. <compartment start="120" end="245" title="Fixed tagger collision">. Each one replaces the raw messages in that ordinal range with a summary. When the summary isn't enough — you need exact wording, a specific value, an error message, or the reasoning behind a decision — expand the range:
+Older parts of this session are summarized under \`## start-end · date · title\` headings inside <session-history> — e.g. \`## 120-245 · … · Fixed tagger collision\`. Each heading replaces the raw messages in that ordinal range with a summary. When the summary isn't enough — you need exact wording, a specific value, an error message, or the reasoning behind a decision — expand the range:
 
-ctx_expand(start=120, end=245)  ← the compartment's own start/end attributes
+ctx_expand(start=120, end=245)  ← the heading's start/end range
 
 Returns the raw transcript as [N] U:/A: lines, capped at ~15K tokens; an oversized range returns the head and tells you where to continue. Also works with ordinals from ctx_search message results — expand a window around a hit (e.g. start=N-10, end=N+5). Ranges after the last compartment are your live tail — already visible in context, not expandable.
 
@@ -206652,12 +208173,12 @@ init_models_dev_cache();
 // src/shared/rpc-server.ts
 init_logger();
 init_rpc_notifications();
-import { randomBytes, timingSafeEqual } from "node:crypto";
+import { randomBytes as randomBytes2, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
 import {
   chmodSync as chmodSync3,
   mkdirSync as mkdirSync11,
   readdirSync,
-  readFileSync as readFileSync14,
+  readFileSync as readFileSync15,
   renameSync as renameSync5,
   rmSync as rmSync3,
   unlinkSync as unlinkSync4,
@@ -206667,17 +208188,17 @@ import { dirname as dirname9 } from "node:path";
 
 // src/shared/rpc-utils.ts
 import { createHash as createHash14 } from "node:crypto";
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 function projectHash(directory) {
   const normalized = directory.replace(/\/+$/, "");
   return createHash14("sha256").update(normalized).digest("hex").slice(0, 16);
 }
 function rpcPortDir(storageDir, directory) {
-  return join20(storageDir, "rpc", projectHash(directory));
+  return join21(storageDir, "rpc", projectHash(directory));
 }
 function rpcPortFilePath(storageDir, directory, pid = process.pid, instanceId) {
   const suffix = instanceId ? `-${instanceId}` : "";
-  return join20(rpcPortDir(storageDir, directory), `port-${pid}${suffix}.json`);
+  return join21(rpcPortDir(storageDir, directory), `port-${pid}${suffix}.json`);
 }
 function isPidAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0)
@@ -206730,7 +208251,7 @@ function tokensMatch(presented, expected) {
   const b = Buffer.from(expected, "utf8");
   if (a.length !== b.length)
     return false;
-  return timingSafeEqual(a, b);
+  return timingSafeEqual2(a, b);
 }
 function bearerToken(req) {
   const auth = req.headers.get("authorization");
@@ -206747,9 +208268,9 @@ class MagicContextRpcServer {
   portFilePath;
   portDir;
   startedAt = Date.now();
-  instanceId = randomBytes(8).toString("hex");
+  instanceId = randomBytes2(8).toString("hex");
   sockets = new Set;
-  token = randomBytes(32).toString("hex");
+  token = randomBytes2(32).toString("hex");
   constructor(storageDir, directory) {
     this.portFilePath = rpcPortFilePath(storageDir, directory, process.pid, this.instanceId);
     this.portDir = rpcPortDir(storageDir, directory);
@@ -206758,6 +208279,10 @@ class MagicContextRpcServer {
     this.handlers.set(method, handler);
   }
   async start() {
+    if (typeof Bun === "undefined") {
+      log("rpc server skipped: Bun runtime not available (no TUI consumer)");
+      return 0;
+    }
     this.startedAt = Date.now();
     const self2 = this;
     const server = Bun.serve({
@@ -206837,7 +208362,7 @@ class MagicContextRpcServer {
       for (const entry of readdirSync(this.portDir)) {
         if (!entry.startsWith("port-") || !entry.endsWith(".json"))
           continue;
-        const record2 = parseRpcPortFile(readFileSync14(`${this.portDir}/${entry}`, "utf-8"));
+        const record2 = parseRpcPortFile(readFileSync15(`${this.portDir}/${entry}`, "utf-8"));
         if (!record2 || record2.pid === process.pid || !isPidAlive(record2.pid))
           continue;
         log(`[rpc] another Magic Context RPC server is active for this project (pid ${record2.pid}, port ${record2.port}); starting separate instance on a new port`);