@cortexkit/opencode-magic-context 0.2.0 → 0.2.2

package/dist/index.js

@@ -31,13 +31,6 @@ import { join } from "path";
 
 // src/shared/jsonc-parser.ts
 import { existsSync, readFileSync } from "fs";
-
-// src/shared/error-message.ts
-function getErrorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-
-// src/shared/jsonc-parser.ts
 function stripJsonComments(content) {
   let result = "";
   let inString = false;
@@ -13733,19 +13726,6 @@ var DEFAULT_DREAMER_TASKS = [
   "archive-stale",
   "improve"
 ];
-var DreamingConfigSchema = exports_external.object({
-  enabled: exports_external.boolean().default(false),
-  schedule: exports_external.string().default("02:00-06:00"),
-  max_runtime_minutes: exports_external.number().min(10).default(120),
-  tasks: exports_external.array(DreamingTaskSchema).default(DEFAULT_DREAMER_TASKS),
-  task_timeout_minutes: exports_external.number().min(5).default(20)
-}).default({
-  enabled: false,
-  schedule: "02:00-06:00",
-  max_runtime_minutes: 120,
-  tasks: DEFAULT_DREAMER_TASKS,
-  task_timeout_minutes: 20
-});
 var DreamerConfigSchema = AgentOverrideConfigSchema.merge(exports_external.object({
   enabled: exports_external.boolean().default(false),
   schedule: exports_external.string().default("02:00-06:00"),
@@ -14618,6 +14598,24 @@ async function runSidekick(deps) {
 }
 
 // src/features/magic-context/compartment-storage.ts
+var insertCompartmentStatements = new WeakMap;
+var insertFactStatements = new WeakMap;
+function getInsertCompartmentStatement(db) {
+  let stmt = insertCompartmentStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("INSERT INTO compartments (session_id, sequence, start_message, end_message, start_message_id, end_message_id, title, content, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)");
+    insertCompartmentStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getInsertFactStatement(db) {
+  let stmt = insertFactStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("INSERT INTO session_facts (session_id, category, content, created_at, updated_at) VALUES (?, ?, ?, ?, ?)");
+    insertFactStatements.set(db, stmt);
+  }
+  return stmt;
+}
 function isCompartmentRow(row) {
   if (row === null || typeof row !== "object")
     return false;
@@ -14630,6 +14628,18 @@ function isSessionFactRow(row) {
   const candidate = row;
   return typeof candidate.id === "number" && typeof candidate.session_id === "string" && typeof candidate.category === "string" && typeof candidate.content === "string" && typeof candidate.created_at === "number" && typeof candidate.updated_at === "number";
 }
+function insertCompartmentRows(db, sessionId, compartments, now) {
+  const stmt = getInsertCompartmentStatement(db);
+  for (const compartment of compartments) {
+    stmt.run(sessionId, compartment.sequence, compartment.startMessage, compartment.endMessage, compartment.startMessageId, compartment.endMessageId, compartment.title, compartment.content, now);
+  }
+}
+function insertFactRows(db, sessionId, facts, now) {
+  const stmt = getInsertFactStatement(db);
+  for (const fact of facts) {
+    stmt.run(sessionId, fact.category, fact.content, now, now);
+  }
+}
 function toCompartment(row) {
   return {
     id: row.id,
@@ -14667,20 +14677,14 @@ function appendCompartments(db, sessionId, compartments) {
     return;
   const now = Date.now();
   db.transaction(() => {
-    const stmt = db.prepare("INSERT INTO compartments (session_id, sequence, start_message, end_message, start_message_id, end_message_id, title, content, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)");
-    for (const c of compartments) {
-      stmt.run(sessionId, c.sequence, c.startMessage, c.endMessage, c.startMessageId, c.endMessageId, c.title, c.content, now);
-    }
+    insertCompartmentRows(db, sessionId, compartments, now);
   })();
 }
 function replaceSessionFacts(db, sessionId, facts) {
   const now = Date.now();
   db.transaction(() => {
     db.prepare("DELETE FROM session_facts WHERE session_id = ?").run(sessionId);
-    const stmt = db.prepare("INSERT INTO session_facts (session_id, category, content, created_at, updated_at) VALUES (?, ?, ?, ?, ?)");
-    for (const f of facts) {
-      stmt.run(sessionId, f.category, f.content, now, now);
-    }
+    insertFactRows(db, sessionId, facts, now);
     db.prepare("UPDATE session_meta SET memory_block_cache = '', memory_block_count = 0 WHERE session_id = ?").run(sessionId);
   })();
 }
@@ -14693,14 +14697,8 @@ function replaceAllCompartmentState(db, sessionId, compartments, facts) {
   db.transaction(() => {
     db.prepare("DELETE FROM compartments WHERE session_id = ?").run(sessionId);
     db.prepare("DELETE FROM session_facts WHERE session_id = ?").run(sessionId);
-    const compartmentStmt = db.prepare("INSERT INTO compartments (session_id, sequence, start_message, end_message, start_message_id, end_message_id, title, content, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)");
-    for (const c of compartments) {
-      compartmentStmt.run(sessionId, c.sequence, c.startMessage, c.endMessage, c.startMessageId, c.endMessageId, c.title, c.content, now);
-    }
-    const factStmt = db.prepare("INSERT INTO session_facts (session_id, category, content, created_at, updated_at) VALUES (?, ?, ?, ?, ?)");
-    for (const f of facts) {
-      factStmt.run(sessionId, f.category, f.content, now, now);
-    }
+    insertCompartmentRows(db, sessionId, compartments, now);
+    insertFactRows(db, sessionId, facts, now);
     db.prepare("UPDATE session_meta SET memory_block_cache = '', memory_block_count = 0 WHERE session_id = ?").run(sessionId);
   })();
 }
@@ -14777,14 +14775,8 @@ function promoteRecompStaging(db, sessionId) {
       return null;
     db.prepare("DELETE FROM compartments WHERE session_id = ?").run(sessionId);
     db.prepare("DELETE FROM session_facts WHERE session_id = ?").run(sessionId);
-    const compartmentStmt = db.prepare("INSERT INTO compartments (session_id, sequence, start_message, end_message, start_message_id, end_message_id, title, content, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)");
-    for (const c of staging.compartments) {
-      compartmentStmt.run(sessionId, c.sequence, c.startMessage, c.endMessage, c.startMessageId, c.endMessageId, c.title, c.content, now);
-    }
-    const factStmt = db.prepare("INSERT INTO session_facts (session_id, category, content, created_at, updated_at) VALUES (?, ?, ?, ?, ?)");
-    for (const f of staging.facts) {
-      factStmt.run(sessionId, f.category, f.content, now, now);
-    }
+    insertCompartmentRows(db, sessionId, staging.compartments, now);
+    insertFactRows(db, sessionId, staging.facts, now);
     db.prepare("DELETE FROM recomp_compartments WHERE session_id = ?").run(sessionId);
     db.prepare("DELETE FROM recomp_facts WHERE session_id = ?").run(sessionId);
     db.prepare("UPDATE session_meta SET memory_block_cache = '', memory_block_count = 0 WHERE session_id = ?").run(sessionId);
@@ -15100,6 +15092,13 @@ function clearStaleEntries(db, maxAgeMs) {
 // src/features/magic-context/dreamer/runner.ts
 import { existsSync as existsSync3 } from "fs";
 import { join as join3 } from "path";
+
+// src/shared/error-message.ts
+function getErrorMessage(error48) {
+  return error48 instanceof Error ? error48.message : String(error48);
+}
+
+// src/features/magic-context/dreamer/runner.ts
 var dreamProjectDirectories = new Map;
 function registerDreamProjectDirectory(projectIdentity, directory) {
   dreamProjectDirectories.set(projectIdentity, directory);
@@ -15494,6 +15493,7 @@ function initializeDatabase(db) {
       retry_count INTEGER DEFAULT 0
     );
     CREATE INDEX IF NOT EXISTS idx_dream_queue_project ON dream_queue(project_path);
+CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, enqueued_at);
 
     CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
       content,
@@ -15805,892 +15805,1061 @@ function setPersistedStickyTurnReminder(db, sessionId, text, messageId = "") {
 function clearPersistedStickyTurnReminder(db, sessionId) {
   db.prepare("UPDATE session_meta SET sticky_turn_reminder_text = '', sticky_turn_reminder_message_id = '' WHERE session_id = ?").run(sessionId);
 }
-// src/features/magic-context/storage-meta-session.ts
-function getOrCreateSessionMeta(db, sessionId) {
-  const result = db.prepare("SELECT session_id, last_response_time, cache_ttl, counter, last_nudge_tokens, last_nudge_band, last_transform_error, is_subagent, last_context_percentage, last_input_tokens, times_execute_threshold_reached, compartment_in_progress, system_prompt_hash FROM session_meta WHERE session_id = ?").get(sessionId);
-  if (isSessionMetaRow(result)) {
-    return toSessionMeta(result);
-  }
-  const defaults = getDefaultSessionMeta(sessionId);
-  ensureSessionMetaRow(db, sessionId);
-  return defaults;
+// src/shared/internal-initiator-marker.ts
+var OMO_INTERNAL_INITIATOR_MARKER = "<!-- OMO_INTERNAL_INITIATOR -->";
+
+// src/shared/system-directive.ts
+var SYSTEM_DIRECTIVE_PREFIX = "[SYSTEM DIRECTIVE: MAGIC-CONTEXT";
+function isSystemDirective(text) {
+  return text.trimStart().startsWith(SYSTEM_DIRECTIVE_PREFIX);
 }
-function updateSessionMeta(db, sessionId, updates) {
-  const setClauses = [];
-  const values = [];
-  for (const [key, column] of Object.entries(META_COLUMNS)) {
-    const value = updates[key];
-    if (value === undefined)
-      continue;
-    if (value === null) {
-      setClauses.push(`${column} = ?`);
-      values.push("");
-    } else if (BOOLEAN_META_KEYS.has(key)) {
-      setClauses.push(`${column} = ?`);
-      values.push(value ? 1 : 0);
-    } else if (typeof value === "string" || typeof value === "number") {
-      setClauses.push(`${column} = ?`);
-      values.push(value);
-    }
-  }
-  if (setClauses.length === 0) {
+function removeSystemReminders(text) {
+  return text.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/gi, "").trim();
+}
+
+// src/hooks/magic-context/read-session-db.ts
+import { Database as Database2 } from "bun:sqlite";
+import { join as join6 } from "path";
+function getOpenCodeDbPath() {
+  return join6(getDataDir(), "opencode", "opencode.db");
+}
+var cachedReadOnlyDb = null;
+function closeCachedReadOnlyDb() {
+  if (!cachedReadOnlyDb) {
     return;
   }
-  db.transaction(() => {
-    ensureSessionMetaRow(db, sessionId);
-    db.prepare(`UPDATE session_meta SET ${setClauses.join(", ")} WHERE session_id = ?`).run(...values, sessionId);
-  })();
+  try {
+    cachedReadOnlyDb.db.close(false);
+  } catch (error48) {
+    log("[magic-context] failed to close cached OpenCode read-only DB:", error48);
+  } finally {
+    cachedReadOnlyDb = null;
+  }
 }
-function clearSession(db, sessionId) {
-  db.transaction(() => {
-    db.prepare("DELETE FROM pending_ops WHERE session_id = ?").run(sessionId);
-    db.prepare("DELETE FROM source_contents WHERE session_id = ?").run(sessionId);
-    db.prepare("DELETE FROM tags WHERE session_id = ?").run(sessionId);
-    db.prepare("DELETE FROM session_meta WHERE session_id = ?").run(sessionId);
-    db.prepare("DELETE FROM compartments WHERE session_id = ?").run(sessionId);
-    db.prepare("DELETE FROM session_facts WHERE session_id = ?").run(sessionId);
-    db.prepare("DELETE FROM session_notes WHERE session_id = ?").run(sessionId);
-    db.prepare("DELETE FROM recomp_compartments WHERE session_id = ?").run(sessionId);
-    db.prepare("DELETE FROM recomp_facts WHERE session_id = ?").run(sessionId);
-  })();
+function getReadOnlySessionDb() {
+  const dbPath = getOpenCodeDbPath();
+  if (cachedReadOnlyDb?.path === dbPath) {
+    return cachedReadOnlyDb.db;
+  }
+  closeCachedReadOnlyDb();
+  const db = new Database2(dbPath, { readonly: true });
+  cachedReadOnlyDb = { path: dbPath, db };
+  return db;
 }
-// src/features/magic-context/storage-notes.ts
-function isSessionNoteRow(row) {
-  if (row === null || typeof row !== "object")
-    return false;
-  const candidate = row;
-  return typeof candidate.id === "number" && typeof candidate.session_id === "string" && typeof candidate.content === "string" && typeof candidate.created_at === "number";
+function withReadOnlySessionDb(fn) {
+  return fn(getReadOnlySessionDb());
 }
-function toSessionNote(row) {
-  return {
-    id: row.id,
-    sessionId: row.session_id,
-    content: row.content,
-    createdAt: row.created_at
-  };
+function getRawSessionMessageCountFromDb(db, sessionId) {
+  const row = db.prepare("SELECT COUNT(*) as count FROM message WHERE session_id = ?").get(sessionId);
+  return typeof row?.count === "number" ? row.count : 0;
 }
-function getSessionNotes(db, sessionId) {
-  const rows = db.prepare("SELECT * FROM session_notes WHERE session_id = ? ORDER BY id ASC").all(sessionId).filter(isSessionNoteRow);
-  return rows.map(toSessionNote);
+
+// src/hooks/magic-context/read-session-formatting.ts
+var COMMIT_HASH_PATTERN = /`?\b([0-9a-f]{6,12})\b`?/gi;
+var COMMIT_HINT_PATTERN = /\b(commit(?:ted)?|cherry-?pick(?:ed)?|hash(?:es)?|sha)\b/i;
+var MAX_COMMITS_PER_BLOCK = 5;
+function hasMeaningfulUserText(parts) {
+  for (const part of parts) {
+    if (part === null || typeof part !== "object")
+      continue;
+    const candidate = part;
+    if (candidate.type !== "text" || typeof candidate.text !== "string")
+      continue;
+    if (candidate.ignored === true)
+      continue;
+    const cleaned = removeSystemReminders(candidate.text).replace(OMO_INTERNAL_INITIATOR_MARKER, "").trim();
+    if (!cleaned)
+      continue;
+    if (isSystemDirective(cleaned))
+      continue;
+    return true;
+  }
+  return false;
 }
-function addSessionNote(db, sessionId, content) {
-  db.prepare("INSERT INTO session_notes (session_id, content, created_at) VALUES (?, ?, ?)").run(sessionId, content, Date.now());
+function extractTexts(parts) {
+  const texts = [];
+  for (const part of parts) {
+    if (part === null || typeof part !== "object")
+      continue;
+    const p = part;
+    if (p.type === "text" && typeof p.text === "string" && p.text.trim().length > 0) {
+      texts.push(p.text.trim());
+    }
+  }
+  return texts;
 }
-function clearSessionNotes(db, sessionId) {
-  db.prepare("DELETE FROM session_notes WHERE session_id = ?").run(sessionId);
+function estimateTokens(text) {
+  return Math.ceil(text.length / 3.5);
 }
-// src/features/magic-context/storage-ops.ts
-function isPendingOpRow(row) {
-  if (row === null || typeof row !== "object")
-    return false;
-  const r = row;
-  return typeof r.id === "number" && typeof r.session_id === "string" && typeof r.tag_id === "number" && typeof r.operation === "string" && typeof r.queued_at === "number";
+function normalizeText(text) {
+  return text.replace(/\s+/g, " ").trim();
 }
-function toPendingOp(row) {
-  if (row.operation !== "drop") {
-    sessionLog(row.session_id, `unknown pending operation "${row.operation}"; ignoring`);
-    return null;
+function compactRole(role) {
+  if (role === "assistant")
+    return "A";
+  if (role === "user")
+    return "U";
+  return role.slice(0, 1).toUpperCase() || "M";
+}
+function formatBlock(block) {
+  const range = block.startOrdinal === block.endOrdinal ? `[${block.startOrdinal}]` : `[${block.startOrdinal}-${block.endOrdinal}]`;
+  const commitSuffix = block.commitHashes.length > 0 ? ` commits: ${block.commitHashes.join(", ")}` : "";
+  return `${range} ${block.role}:${commitSuffix} ${block.parts.join(" / ")}`;
+}
+function extractCommitHashes(text) {
+  const hashes = [];
+  const seen = new Set;
+  for (const match of text.matchAll(COMMIT_HASH_PATTERN)) {
+    const hash2 = match[1]?.toLowerCase();
+    if (!hash2 || seen.has(hash2))
+      continue;
+    seen.add(hash2);
+    hashes.push(hash2);
+    if (hashes.length >= MAX_COMMITS_PER_BLOCK)
+      break;
+  }
+  return hashes;
+}
+function compactTextForSummary(text, role) {
+  const commitHashes = role === "assistant" ? extractCommitHashes(text) : [];
+  if (commitHashes.length === 0 || !COMMIT_HINT_PATTERN.test(text)) {
+    return { text, commitHashes };
   }
+  const withoutHashes = text.replace(COMMIT_HASH_PATTERN, "").replace(/\(\s*\)/g, "").replace(/\s+,/g, ",").replace(/,\s*,+/g, ", ").replace(/\s{2,}/g, " ").replace(/\s+([,.;:])/g, "$1").trim();
   return {
-    id: row.id,
-    sessionId: row.session_id,
-    tagId: row.tag_id,
-    operation: row.operation,
-    queuedAt: row.queued_at
+    text: withoutHashes.length > 0 ? withoutHashes : text,
+    commitHashes
   };
 }
-function queuePendingOp(db, sessionId, tagId, operation, queuedAt = Date.now()) {
-  db.prepare("INSERT INTO pending_ops (session_id, tag_id, operation, queued_at) VALUES (?, ?, ?, ?)").run(sessionId, tagId, operation, queuedAt);
-}
-function getPendingOps(db, sessionId) {
-  const rows = db.prepare("SELECT id, session_id, tag_id, operation, queued_at FROM pending_ops WHERE session_id = ? ORDER BY queued_at ASC, id ASC").all(sessionId).filter(isPendingOpRow);
-  return rows.map(toPendingOp).filter((op) => op !== null);
-}
-function removePendingOp(db, sessionId, tagId) {
-  db.prepare("DELETE FROM pending_ops WHERE session_id = ? AND tag_id = ?").run(sessionId, tagId);
+function mergeCommitHashes(existing, next) {
+  if (next.length === 0)
+    return existing;
+  const merged = [...existing];
+  for (const hash2 of next) {
+    if (merged.includes(hash2))
+      continue;
+    merged.push(hash2);
+    if (merged.length >= MAX_COMMITS_PER_BLOCK)
+      break;
+  }
+  return merged;
 }
-// src/features/magic-context/storage-source.ts
-function isSourceContentRow(row) {
+
+// src/hooks/magic-context/read-session-raw.ts
+function isRawMessageRow(row) {
   if (row === null || typeof row !== "object")
     return false;
-  const r = row;
-  return typeof r.tag_id === "number" && typeof r.content === "string";
+  const candidate = row;
+  return typeof candidate.id === "string" && typeof candidate.data === "string";
 }
-function saveSourceContent(db, sessionId, tagId, content) {
-  db.prepare("INSERT OR IGNORE INTO source_contents (tag_id, session_id, content, created_at) VALUES (?, ?, ?, ?)").run(tagId, sessionId, content, Date.now());
-}
-function replaceSourceContent(db, sessionId, tagId, content) {
-  db.prepare(`INSERT INTO source_contents (tag_id, session_id, content, created_at)
-     VALUES (?, ?, ?, ?)
-     ON CONFLICT(session_id, tag_id)
-     DO UPDATE SET content = excluded.content, created_at = excluded.created_at`).run(tagId, sessionId, content, Date.now());
-}
-function getSourceContents(db, sessionId, tagIds) {
-  if (tagIds.length === 0) {
-    return new Map;
-  }
-  const placeholders = tagIds.map(() => "?").join(", ");
-  const rows = db.prepare(`SELECT tag_id, content FROM source_contents WHERE session_id = ? AND tag_id IN (${placeholders})`).all(sessionId, ...tagIds).filter(isSourceContentRow);
-  const sources = new Map;
-  for (const row of rows) {
-    sources.set(row.tag_id, row.content);
-  }
-  return sources;
-}
-// src/features/magic-context/storage-tags.ts
-var insertTagStatements = new WeakMap;
-function getInsertTagStatement(db) {
-  let stmt = insertTagStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("INSERT INTO tags (session_id, message_id, type, byte_size, tag_number) VALUES (?, ?, ?, ?, ?)");
-    insertTagStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function isTagRow(row) {
+function isRawPartRow(row) {
   if (row === null || typeof row !== "object")
     return false;
-  const r = row;
-  return typeof r.id === "number" && typeof r.message_id === "string" && typeof r.type === "string" && typeof r.status === "string" && typeof r.byte_size === "number" && typeof r.session_id === "string" && typeof r.tag_number === "number";
+  const candidate = row;
+  return typeof candidate.message_id === "string" && typeof candidate.data === "string";
 }
-function toTagEntry(row) {
-  const type = row.type === "tool" ? "tool" : row.type === "file" ? "file" : "message";
-  const status = row.status === "dropped" || row.status === "compacted" ? row.status : "active";
-  return {
-    tagNumber: row.tag_number,
-    messageId: row.message_id,
-    type,
-    status,
-    byteSize: row.byte_size,
-    sessionId: row.session_id
-  };
+function parseJsonRecord(value) {
+  const parsed = JSON.parse(value);
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("Expected JSON object");
+  }
+  return parsed;
 }
-function insertTag(db, sessionId, messageId, type, byteSize, tagNumber) {
-  getInsertTagStatement(db).run(sessionId, messageId, type, byteSize, tagNumber);
-  return tagNumber;
+function parseJsonUnknown(value) {
+  return JSON.parse(value);
 }
-function updateTagStatus(db, sessionId, tagId, status) {
-  db.prepare("UPDATE tags SET status = ? WHERE session_id = ? AND tag_number = ?").run(status, sessionId, tagId);
+function readRawSessionMessagesFromDb(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 partRows = db.prepare("SELECT message_id, data 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) {
+    const list = partsByMessageId.get(part.message_id) ?? [];
+    list.push(parseJsonUnknown(part.data));
+    partsByMessageId.set(part.message_id, list);
+  }
+  return messageRows.map((row, index) => {
+    const info = parseJsonRecord(row.data);
+    const role = typeof info.role === "string" ? info.role : "unknown";
+    return {
+      ordinal: index + 1,
+      id: row.id,
+      role,
+      parts: partsByMessageId.get(row.id) ?? []
+    };
+  });
 }
-function updateTagMessageId(db, sessionId, tagId, messageId) {
-  db.prepare("UPDATE tags SET message_id = ? WHERE session_id = ? AND tag_number = ?").run(messageId, sessionId, tagId);
+
+// src/hooks/magic-context/tag-content-primitives.ts
+var encoder = new TextEncoder;
+var TAG_PREFIX_REGEX = /^\u00A7\d+\u00A7\s*/;
+function byteSize(value) {
+  return encoder.encode(value).length;
 }
-function getTagsBySession(db, sessionId) {
-  const rows = db.prepare("SELECT id, message_id, type, status, byte_size, session_id, tag_number FROM tags WHERE session_id = ? ORDER BY tag_number ASC, id ASC").all(sessionId).filter(isTagRow);
-  return rows.map(toTagEntry);
+function stripTagPrefix(value) {
+  return value.replace(TAG_PREFIX_REGEX, "");
 }
-function getTopNBySize(db, sessionId, n) {
-  if (n <= 0) {
-    return [];
-  }
-  const rows = db.prepare("SELECT id, message_id, type, status, byte_size, session_id, tag_number FROM tags WHERE session_id = ? AND status = 'active' ORDER BY byte_size DESC, tag_number ASC LIMIT ?").all(sessionId, n).filter(isTagRow);
-  return rows.map(toTagEntry);
+function prependTag(tagId, value) {
+  const stripped = stripTagPrefix(value);
+  return `\xA7${tagId}\xA7 ${stripped}`;
 }
-// src/plugin/dream-timer.ts
-var DREAM_TIMER_INTERVAL_MS = 15 * 60 * 1000;
-function startDreamScheduleTimer(args) {
-  const { client, dreamerConfig } = args;
-  if (!dreamerConfig.enabled || !dreamerConfig.schedule?.trim()) {
-    return;
-  }
-  const timer = setInterval(() => {
-    try {
-      const db = openDatabase();
-      checkScheduleAndEnqueue(db, dreamerConfig.schedule);
-      processDreamQueue({
-        db,
-        client,
-        tasks: dreamerConfig.tasks,
-        taskTimeoutMinutes: dreamerConfig.task_timeout_minutes,
-        maxRuntimeMinutes: dreamerConfig.max_runtime_minutes
-      }).catch((error48) => {
-        log("[dreamer] timer-triggered queue processing failed:", error48);
-      });
-    } catch (error48) {
-      log("[dreamer] timer-triggered schedule check failed:", error48);
-    }
-  }, DREAM_TIMER_INTERVAL_MS);
-  if (typeof timer === "object" && "unref" in timer) {
-    timer.unref();
-  }
-  log(`[dreamer] started independent schedule timer (every ${DREAM_TIMER_INTERVAL_MS / 60000}m)`);
+function isThinkingPart(part) {
+  if (part === null || typeof part !== "object")
+    return false;
+  const candidate = part;
+  return candidate.type === "thinking" || candidate.type === "reasoning";
 }
 
-// src/plugin/event.ts
-function createEventHandler(args) {
-  return async (input) => {
-    await args.magicContext?.event?.(input);
-  };
+// src/hooks/magic-context/tag-part-guards.ts
+function isTextPart(part) {
+  if (part === null || typeof part !== "object")
+    return false;
+  const p = part;
+  return p.type === "text" && typeof p.text === "string";
 }
-
-// src/features/magic-context/compaction.ts
-function createCompactionHandler() {
-  return {
-    onCompacted(sessionId, db) {
-      db.transaction(() => {
-        db.prepare("UPDATE tags SET status = 'compacted' WHERE session_id = ? AND status IN ('active', 'dropped')").run(sessionId);
-        db.prepare("DELETE FROM pending_ops WHERE session_id = ?").run(sessionId);
-      })();
-      updateSessionMeta(db, sessionId, { lastNudgeBand: null });
-    }
-  };
+function isToolPartWithOutput(part) {
+  if (part === null || typeof part !== "object")
+    return false;
+  const p = part;
+  if (p.type !== "tool" || typeof p.callID !== "string")
+    return false;
+  if (p.state === null || typeof p.state !== "object")
+    return false;
+  return typeof p.state.output === "string";
 }
-
-// src/hooks/is-anthropic-provider.ts
-function isAnthropicProvider(providerID) {
-  return providerID === "anthropic" || providerID === "google-vertex-anthropic";
+function isFilePart(part) {
+  if (part === null || typeof part !== "object")
+    return false;
+  const p = part;
+  return p.type === "file" && typeof p.url === "string";
+}
+function buildFileSourceContent(parts) {
+  const content = parts.filter(isTextPart).map((part) => stripTagPrefix(part.text)).join(`
+`).trim();
+  return content.length > 0 ? content : null;
 }
 
-// src/hooks/magic-context/event-resolvers.ts
-var DEFAULT_CONTEXT_LIMIT = 200000;
-function resolveContextLimit(providerID, modelID, config2) {
-  if (!providerID) {
-    return DEFAULT_CONTEXT_LIMIT;
-  }
-  if (modelID) {
-    const modelSpecific = config2.modelContextLimitsCache?.get(`${providerID}/${modelID}`);
-    if (typeof modelSpecific === "number" && modelSpecific > 0) {
-      return modelSpecific;
-    }
-  }
-  if (isAnthropicProvider(providerID)) {
-    return 1e6;
-  }
-  return DEFAULT_CONTEXT_LIMIT;
+// src/hooks/magic-context/read-session-chunk.ts
+var activeRawMessageCache = null;
+function cleanUserText(text) {
+  return removeSystemReminders(text).replace(OMO_INTERNAL_INITIATOR_MARKER, "").trim();
 }
-function resolveCacheTtl(cacheTtl, modelKey) {
-  if (typeof cacheTtl === "string") {
-    return cacheTtl;
-  }
-  if (modelKey && typeof cacheTtl[modelKey] === "string") {
-    return cacheTtl[modelKey];
+function withRawSessionMessageCache(fn) {
+  const outerCache = activeRawMessageCache;
+  if (!outerCache) {
+    activeRawMessageCache = new Map;
   }
-  if (modelKey) {
-    const bareModelId = modelKey.split("/").slice(1).join("/");
-    if (bareModelId && typeof cacheTtl[bareModelId] === "string") {
-      return cacheTtl[bareModelId];
+  try {
+    return fn();
+  } finally {
+    if (!outerCache) {
+      activeRawMessageCache = null;
     }
   }
-  return cacheTtl.default ?? "5m";
 }
-function resolveExecuteThreshold(config2, modelKey, fallback) {
-  if (typeof config2 === "number") {
-    return config2;
-  }
-  if (modelKey && typeof config2[modelKey] === "number") {
-    return config2[modelKey];
-  }
-  if (modelKey) {
-    const bareModelId = modelKey.split("/").slice(1).join("/");
-    if (bareModelId && typeof config2[bareModelId] === "number") {
-      return config2[bareModelId];
+function readRawSessionMessages(sessionId) {
+  if (activeRawMessageCache) {
+    const cached2 = activeRawMessageCache.get(sessionId);
+    if (cached2) {
+      return cached2;
     }
+    const messages = withReadOnlySessionDb((db) => readRawSessionMessagesFromDb(db, sessionId));
+    activeRawMessageCache.set(sessionId, messages);
+    return messages;
   }
-  return config2.default ?? fallback;
+  return withReadOnlySessionDb((db) => readRawSessionMessagesFromDb(db, sessionId));
 }
-function resolveModelKey(providerID, modelID) {
-  if (!providerID || !modelID) {
-    return;
-  }
-  return `${providerID}/${modelID}`;
+function getRawSessionMessageCount(sessionId) {
+  return withReadOnlySessionDb((db) => getRawSessionMessageCountFromDb(db, sessionId));
 }
-function resolveSessionId(properties) {
-  if (typeof properties?.sessionID === "string") {
-    return properties.sessionID;
-  }
-  const info = properties?.info;
-  if (info === null || typeof info !== "object") {
-    return;
-  }
-  const record2 = info;
-  if (typeof record2.sessionID === "string") {
-    return record2.sessionID;
+function getRawSessionTagKeysThrough(sessionId, upToMessageIndex) {
+  const messages = readRawSessionMessages(sessionId);
+  const keys = [];
+  for (const message of messages) {
+    if (message.ordinal > upToMessageIndex)
+      break;
+    for (const [partIndex, part] of message.parts.entries()) {
+      if (isTextPart(part)) {
+        keys.push(`${message.id}:p${partIndex}`);
+      }
+      if (isFilePart(part)) {
+        keys.push(`${message.id}:file${partIndex}`);
+      }
+      if (isToolPartWithOutput(part)) {
+        keys.push(part.callID);
+      }
+    }
   }
-  if (typeof record2.id === "string") {
-    return record2.id;
+  return keys;
+}
+var PROTECTED_TAIL_USER_TURNS = 5;
+function getProtectedTailStartOrdinal(sessionId) {
+  const messages = readRawSessionMessages(sessionId);
+  const userOrdinals = messages.filter((m) => m.role === "user" && hasMeaningfulUserText(m.parts)).map((m) => m.ordinal);
+  if (userOrdinals.length < PROTECTED_TAIL_USER_TURNS) {
+    return 1;
   }
-  return;
+  return userOrdinals[userOrdinals.length - PROTECTED_TAIL_USER_TURNS];
 }
-
-// src/features/magic-context/scheduler.ts
-var TTL_PATTERN = /^(\d+)([smh])$/;
-var NUMERIC_PATTERN = /^\d+$/;
-var UNIT_TO_MS = {
-  s: 1000,
-  m: 60 * 1000,
-  h: 60 * 60 * 1000
-};
-function parseCacheTtl(ttl) {
-  const normalizedTtl = ttl.trim();
-  if (NUMERIC_PATTERN.test(normalizedTtl)) {
-    return Number(normalizedTtl);
+function readSessionChunk(sessionId, tokenBudget, offset = 1, eligibleEndOrdinal) {
+  const messages = readRawSessionMessages(sessionId);
+  const startOrdinal = Math.max(1, offset);
+  const lines = [];
+  const lineMeta = [];
+  let totalTokens = 0;
+  let messagesProcessed = 0;
+  let lastOrdinal = startOrdinal - 1;
+  let lastMessageId = "";
+  let firstMessageId = "";
+  let currentBlock = null;
+  let pendingNoiseMeta = [];
+  let commitClusters = 0;
+  let lastFlushedRole = "";
+  function flushCurrentBlock() {
+    if (!currentBlock)
+      return true;
+    const blockText = formatBlock(currentBlock);
+    const blockTokens = estimateTokens(blockText);
+    if (totalTokens + blockTokens > tokenBudget && totalTokens > 0) {
+      return false;
+    }
+    if (currentBlock.role === "A" && currentBlock.commitHashes.length > 0 && lastFlushedRole !== "A") {
+      commitClusters++;
+    }
+    lastFlushedRole = currentBlock.role;
+    if (!firstMessageId)
+      firstMessageId = currentBlock.meta[0]?.messageId ?? "";
+    lastOrdinal = currentBlock.meta[currentBlock.meta.length - 1]?.ordinal ?? currentBlock.endOrdinal;
+    lastMessageId = currentBlock.meta[currentBlock.meta.length - 1]?.messageId ?? "";
+    messagesProcessed += currentBlock.meta.length;
+    lines.push(blockText);
+    lineMeta.push(...currentBlock.meta);
+    totalTokens += blockTokens;
+    currentBlock = null;
+    return true;
   }
-  const match = normalizedTtl.match(TTL_PATTERN);
-  if (!match) {
-    throw new Error(`Invalid cache TTL format: ${ttl}`);
+  for (const msg of messages) {
+    if (eligibleEndOrdinal !== undefined && msg.ordinal >= eligibleEndOrdinal)
+      break;
+    if (msg.ordinal < startOrdinal)
+      continue;
+    const meta3 = { ordinal: msg.ordinal, messageId: msg.id };
+    if (msg.role === "user" && !hasMeaningfulUserText(msg.parts)) {
+      pendingNoiseMeta.push(meta3);
+      continue;
+    }
+    const role = compactRole(msg.role);
+    const compacted = compactTextForSummary(extractTexts(msg.parts).map((t) => msg.role === "user" ? cleanUserText(t) : t).map(normalizeText).filter((value) => value.length > 0).join(" / "), msg.role);
+    const text = compacted.text;
+    if (!text) {
+      pendingNoiseMeta.push(meta3);
+      continue;
+    }
+    if (currentBlock && currentBlock.role === role) {
+      currentBlock.endOrdinal = msg.ordinal;
+      currentBlock.parts.push(text);
+      currentBlock.meta.push(...pendingNoiseMeta, meta3);
+      currentBlock.commitHashes = mergeCommitHashes(currentBlock.commitHashes, compacted.commitHashes);
+      pendingNoiseMeta = [];
+      continue;
+    }
+    if (!flushCurrentBlock())
+      break;
+    currentBlock = {
+      role,
+      startOrdinal: pendingNoiseMeta[0]?.ordinal ?? msg.ordinal,
+      endOrdinal: msg.ordinal,
+      parts: [text],
+      meta: [...pendingNoiseMeta, meta3],
+      commitHashes: [...compacted.commitHashes]
+    };
+    pendingNoiseMeta = [];
   }
-  const value = Number(match[1]);
-  const unit = match[2];
-  return value * UNIT_TO_MS[unit];
-}
-function createScheduler(config2) {
+  flushCurrentBlock();
   return {
-    shouldExecute(sessionMeta, contextUsage, currentTime = Date.now(), sessionId) {
-      const threshold = resolveExecuteThreshold(config2.executeThresholdPercentage, undefined, 65);
-      if (contextUsage.percentage >= threshold) {
-        return "execute";
-      }
-      let ttlMs;
-      try {
-        ttlMs = parseCacheTtl(sessionMeta.cacheTtl);
-      } catch (error48) {
-        if (sessionId) {
-          sessionLog(sessionId, `invalid cache_ttl "${sessionMeta.cacheTtl}"; falling back to default 5m`, error48);
-        } else {
-          log(`[magic-context] invalid cache_ttl "${sessionMeta.cacheTtl}"; falling back to default 5m`, error48);
-        }
-        ttlMs = parseCacheTtl("5m");
-      }
-      const elapsedTime = currentTime - sessionMeta.lastResponseTime;
-      if (elapsedTime > ttlMs) {
-        return "execute";
-      }
-      return "defer";
-    }
+    startIndex: startOrdinal,
+    endIndex: lastOrdinal,
+    startMessageId: firstMessageId,
+    endMessageId: lastMessageId,
+    messageCount: messagesProcessed,
+    tokenEstimate: totalTokens,
+    hasMore: lastOrdinal < (eligibleEndOrdinal !== undefined ? Math.min(eligibleEndOrdinal - 1, messages.length) : messages.length),
+    text: lines.join(`
+`),
+    lines: lineMeta,
+    commitClusterCount: commitClusters
   };
 }
 
-// src/features/magic-context/tagger.ts
-var GET_COUNTER_SQL = `SELECT counter FROM session_meta WHERE session_id = ?`;
-var GET_ASSIGNMENTS_SQL = "SELECT message_id, tag_number FROM tags WHERE session_id = ? ORDER BY tag_number ASC";
-function isAssignmentRow(row) {
-  if (row === null || typeof row !== "object") {
-    return false;
+// src/features/magic-context/message-index.ts
+var lastIndexedStatements = new WeakMap;
+var insertMessageStatements = new WeakMap;
+var upsertIndexStatements = new WeakMap;
+var deleteFtsStatements = new WeakMap;
+var deleteIndexStatements = new WeakMap;
+function normalizeIndexText(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function getLastIndexedStatement(db) {
+  let stmt = lastIndexedStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("SELECT last_indexed_ordinal FROM message_history_index WHERE session_id = ?");
+    lastIndexedStatements.set(db, stmt);
   }
-  const candidate = row;
-  return typeof candidate.message_id === "string" && typeof candidate.tag_number === "number";
+  return stmt;
 }
-var UPSERT_COUNTER_SQL = `
-  INSERT INTO session_meta (session_id, counter)
-  VALUES (?, ?)
-  ON CONFLICT(session_id) DO UPDATE SET counter = excluded.counter
-`;
-var upsertCounterStatements = new WeakMap;
-function getUpsertCounterStatement(db) {
-  let stmt = upsertCounterStatements.get(db);
+function getInsertMessageStatement(db) {
+  let stmt = insertMessageStatements.get(db);
   if (!stmt) {
-    stmt = db.prepare(UPSERT_COUNTER_SQL);
-    upsertCounterStatements.set(db, stmt);
+    stmt = db.prepare("INSERT INTO message_history_fts (session_id, message_ordinal, message_id, role, content) VALUES (?, ?, ?, ?, ?)");
+    insertMessageStatements.set(db, stmt);
   }
   return stmt;
 }
-function createTagger() {
-  const counters = new Map;
-  const assignments = new Map;
-  function getSessionAssignments(sessionId) {
-    let map2 = assignments.get(sessionId);
-    if (!map2) {
-      map2 = new Map;
-      assignments.set(sessionId, map2);
-    }
-    return map2;
+function getUpsertIndexStatement(db) {
+  let stmt = upsertIndexStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("INSERT INTO message_history_index (session_id, last_indexed_ordinal, updated_at) VALUES (?, ?, ?) ON CONFLICT(session_id) DO UPDATE SET last_indexed_ordinal = excluded.last_indexed_ordinal, updated_at = excluded.updated_at");
+    upsertIndexStatements.set(db, stmt);
   }
-  function assignTag(sessionId, messageId, type, byteSize, db) {
-    const sessionAssignments = getSessionAssignments(sessionId);
-    const existing = sessionAssignments.get(messageId);
-    if (existing !== undefined) {
-      return existing;
-    }
-    const current = counters.get(sessionId) ?? 0;
-    const next = current + 1;
-    db.transaction(() => {
-      insertTag(db, sessionId, messageId, type, byteSize, next);
-      getUpsertCounterStatement(db).run(sessionId, next);
-    })();
-    counters.set(sessionId, next);
-    sessionAssignments.set(messageId, next);
-    return next;
+  return stmt;
+}
+function getDeleteFtsStatement(db) {
+  let stmt = deleteFtsStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("DELETE FROM message_history_fts WHERE session_id = ?");
+    deleteFtsStatements.set(db, stmt);
   }
-  function getTag(sessionId, messageId) {
-    return assignments.get(sessionId)?.get(messageId);
+  return stmt;
+}
+function getDeleteIndexStatement(db) {
+  let stmt = deleteIndexStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("DELETE FROM message_history_index WHERE session_id = ?");
+    deleteIndexStatements.set(db, stmt);
   }
-  function bindTag(sessionId, messageId, tagNumber) {
-    getSessionAssignments(sessionId).set(messageId, tagNumber);
+  return stmt;
+}
+function getLastIndexedOrdinal(db, sessionId) {
+  const row = getLastIndexedStatement(db).get(sessionId);
+  return typeof row?.last_indexed_ordinal === "number" ? row.last_indexed_ordinal : 0;
+}
+function clearIndexedMessages(db, sessionId) {
+  getDeleteFtsStatement(db).run(sessionId);
+  getDeleteIndexStatement(db).run(sessionId);
+}
+function getIndexableContent(role, parts) {
+  if (role === "user") {
+    if (!hasMeaningfulUserText(parts)) {
+      return "";
+    }
+    return extractTexts(parts).map(cleanUserText).map(normalizeIndexText).filter((text) => text.length > 0).join(" / ");
   }
-  function getAssignments(sessionId) {
-    return getSessionAssignments(sessionId);
+  if (role === "assistant") {
+    return extractTexts(parts).map(removeSystemReminders).map(normalizeIndexText).filter((text) => text.length > 0).join(" / ");
   }
-  function resetCounter(sessionId, db) {
-    counters.set(sessionId, 0);
-    assignments.delete(sessionId);
-    getUpsertCounterStatement(db).run(sessionId, 0);
+  return "";
+}
+function ensureMessagesIndexed(db, sessionId, readMessages) {
+  const messages = readMessages(sessionId);
+  if (messages.length === 0) {
+    db.transaction(() => clearIndexedMessages(db, sessionId))();
+    return;
   }
-  function getCounter(sessionId) {
-    return counters.get(sessionId) ?? 0;
+  let lastIndexedOrdinal = getLastIndexedOrdinal(db, sessionId);
+  if (lastIndexedOrdinal > messages.length) {
+    db.transaction(() => clearIndexedMessages(db, sessionId))();
+    lastIndexedOrdinal = 0;
   }
-  function initFromDb(sessionId, db) {
-    if (counters.has(sessionId)) {
-      return;
-    }
-    const row = db.prepare(GET_COUNTER_SQL).get(sessionId);
-    const assignmentRows = db.prepare(GET_ASSIGNMENTS_SQL).all(sessionId).filter(isAssignmentRow);
-    const sessionAssignments = getSessionAssignments(sessionId);
-    sessionAssignments.clear();
-    let maxTagNumber = 0;
-    for (const assignment of assignmentRows) {
-      sessionAssignments.set(assignment.message_id, assignment.tag_number);
-      if (assignment.tag_number > maxTagNumber) {
-        maxTagNumber = assignment.tag_number;
-      }
-    }
-    const counter = Math.max(row?.counter ?? 0, maxTagNumber);
-    counters.set(sessionId, counter);
-  }
-  function cleanup(sessionId) {
-    counters.delete(sessionId);
-    assignments.delete(sessionId);
+  if (lastIndexedOrdinal >= messages.length) {
+    return;
   }
-  return {
-    assignTag,
-    getTag,
-    bindTag,
-    getAssignments,
-    resetCounter,
-    getCounter,
-    initFromDb,
-    cleanup
-  };
+  const messagesToInsert = messages.filter((message) => message.ordinal > lastIndexedOrdinal).filter((message) => message.role === "user" || message.role === "assistant").map((message) => ({
+    ordinal: message.ordinal,
+    id: message.id,
+    role: message.role,
+    content: getIndexableContent(message.role, message.parts)
+  })).filter((message) => message.content.length > 0);
+  const now = Date.now();
+  db.transaction(() => {
+    const insertMessage = getInsertMessageStatement(db);
+    for (const message of messagesToInsert) {
+      insertMessage.run(sessionId, message.ordinal, message.id, message.role, message.content);
+    }
+    getUpsertIndexStatement(db).run(sessionId, messages.length, now);
+  })();
 }
 
-// src/features/magic-context/memory/project-identity.ts
-import { execSync } from "child_process";
-import path3 from "path";
-var GIT_TIMEOUT_MS = 5000;
-var resolvedCache = new Map;
-function getRootCommitHash(directory) {
-  try {
-    const hash2 = execSync("git rev-list --max-parents=0 HEAD", {
-      cwd: directory,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: GIT_TIMEOUT_MS
-    }).trim();
-    const firstLine = hash2.split(`
-`)[0]?.trim();
-    return firstLine && firstLine.length >= 7 ? firstLine : undefined;
-  } catch {
+// src/features/magic-context/storage-meta-session.ts
+function getOrCreateSessionMeta(db, sessionId) {
+  const result = db.prepare("SELECT session_id, last_response_time, cache_ttl, counter, last_nudge_tokens, last_nudge_band, last_transform_error, is_subagent, last_context_percentage, last_input_tokens, times_execute_threshold_reached, compartment_in_progress, system_prompt_hash FROM session_meta WHERE session_id = ?").get(sessionId);
+  if (isSessionMetaRow(result)) {
+    return toSessionMeta(result);
+  }
+  const defaults = getDefaultSessionMeta(sessionId);
+  ensureSessionMetaRow(db, sessionId);
+  return defaults;
+}
+function updateSessionMeta(db, sessionId, updates) {
+  const setClauses = [];
+  const values = [];
+  for (const [key, column] of Object.entries(META_COLUMNS)) {
+    const value = updates[key];
+    if (value === undefined)
+      continue;
+    if (value === null) {
+      setClauses.push(`${column} = ?`);
+      values.push("");
+    } else if (BOOLEAN_META_KEYS.has(key)) {
+      setClauses.push(`${column} = ?`);
+      values.push(value ? 1 : 0);
+    } else if (typeof value === "string" || typeof value === "number") {
+      setClauses.push(`${column} = ?`);
+      values.push(value);
+    }
+  }
+  if (setClauses.length === 0) {
     return;
   }
+  db.transaction(() => {
+    ensureSessionMetaRow(db, sessionId);
+    db.prepare(`UPDATE session_meta SET ${setClauses.join(", ")} WHERE session_id = ?`).run(...values, sessionId);
+  })();
 }
-function directoryFallback(directory) {
-  const canonical = path3.resolve(directory);
-  const hash2 = Bun.hash(canonical).toString(16).slice(0, 12);
-  return `dir:${hash2}`;
+function clearSession(db, sessionId) {
+  db.transaction(() => {
+    db.prepare("DELETE FROM pending_ops WHERE session_id = ?").run(sessionId);
+    db.prepare("DELETE FROM source_contents WHERE session_id = ?").run(sessionId);
+    db.prepare("DELETE FROM tags WHERE session_id = ?").run(sessionId);
+    db.prepare("DELETE FROM session_meta WHERE session_id = ?").run(sessionId);
+    db.prepare("DELETE FROM compartments WHERE session_id = ?").run(sessionId);
+    db.prepare("DELETE FROM session_facts WHERE session_id = ?").run(sessionId);
+    db.prepare("DELETE FROM session_notes WHERE session_id = ?").run(sessionId);
+    db.prepare("DELETE FROM recomp_compartments WHERE session_id = ?").run(sessionId);
+    db.prepare("DELETE FROM recomp_facts WHERE session_id = ?").run(sessionId);
+    clearIndexedMessages(db, sessionId);
+  })();
 }
-function resolveProjectIdentity(directory) {
-  const resolved = path3.resolve(directory);
-  const cached2 = resolvedCache.get(resolved);
-  if (cached2 !== undefined) {
-    return cached2;
-  }
-  const rootHash = getRootCommitHash(resolved);
-  const identity = rootHash ? `git:${rootHash}` : directoryFallback(resolved);
-  resolvedCache.set(resolved, identity);
-  return identity;
+// src/features/magic-context/storage-notes.ts
+function isSessionNoteRow(row) {
+  if (row === null || typeof row !== "object")
+    return false;
+  const candidate = row;
+  return typeof candidate.id === "number" && typeof candidate.session_id === "string" && typeof candidate.content === "string" && typeof candidate.created_at === "number";
 }
-
-// src/hooks/magic-context/execute-flush.ts
-function executeFlush(db, sessionId) {
-  try {
-    const pendingOps = getPendingOps(db, sessionId);
-    if (pendingOps.length === 0) {
-      return "No pending operations to flush.";
-    }
-    let dropped = 0;
-    db.transaction(() => {
-      for (const op of pendingOps) {
-        updateTagStatus(db, sessionId, op.tagId, "dropped");
-        removePendingOp(db, sessionId, op.tagId);
-        dropped++;
-      }
-    })();
-    const parts = [];
-    if (dropped > 0)
-      parts.push(`${dropped} dropped`);
-    if (dropped > 0) {
-      clearPersistedStickyTurnReminder(db, sessionId);
-    }
-    return `Flushed: ${parts.join(", ")}. Changes take effect on next message.`;
-  } catch (error48) {
-    sessionLog(sessionId, "ctx-flush failed:", error48);
-    return `Error: Failed to flush context operations. ${getErrorMessage(error48)}`;
-  }
+function toSessionNote(row) {
+  return {
+    id: row.id,
+    sessionId: row.session_id,
+    content: row.content,
+    createdAt: row.created_at
+  };
 }
-
-// src/shared/internal-initiator-marker.ts
-var OMO_INTERNAL_INITIATOR_MARKER = "<!-- OMO_INTERNAL_INITIATOR -->";
-
-// src/shared/system-directive.ts
-var SYSTEM_DIRECTIVE_PREFIX = "[SYSTEM DIRECTIVE: MAGIC-CONTEXT";
-function isSystemDirective(text) {
-  return text.trimStart().startsWith(SYSTEM_DIRECTIVE_PREFIX);
+function getSessionNotes(db, sessionId) {
+  const rows = db.prepare("SELECT * FROM session_notes WHERE session_id = ? ORDER BY id ASC").all(sessionId).filter(isSessionNoteRow);
+  return rows.map(toSessionNote);
 }
-function removeSystemReminders(text) {
-  return text.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/gi, "").trim();
+function addSessionNote(db, sessionId, content) {
+  db.prepare("INSERT INTO session_notes (session_id, content, created_at) VALUES (?, ?, ?)").run(sessionId, content, Date.now());
 }
-
-// src/hooks/magic-context/read-session-db.ts
-import { Database as Database2 } from "bun:sqlite";
-import { join as join6 } from "path";
-function getOpenCodeDbPath() {
-  return join6(getDataDir(), "opencode", "opencode.db");
+function clearSessionNotes(db, sessionId) {
+  db.prepare("DELETE FROM session_notes WHERE session_id = ?").run(sessionId);
 }
-var cachedReadOnlyDb = null;
-function closeCachedReadOnlyDb() {
-  if (!cachedReadOnlyDb) {
-    return;
-  }
-  try {
-    cachedReadOnlyDb.db.close(false);
-  } catch (error48) {
-    log("[magic-context] failed to close cached OpenCode read-only DB:", error48);
-  } finally {
-    cachedReadOnlyDb = null;
+// src/features/magic-context/storage-ops.ts
+var queuePendingOpStatements = new WeakMap;
+var getPendingOpsStatements = new WeakMap;
+var clearPendingOpsStatements = new WeakMap;
+var removePendingOpStatements = new WeakMap;
+function getQueuePendingOpStatement(db) {
+  let stmt = queuePendingOpStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("INSERT INTO pending_ops (session_id, tag_id, operation, queued_at) VALUES (?, ?, ?, ?)");
+    queuePendingOpStatements.set(db, stmt);
   }
+  return stmt;
 }
-function getReadOnlySessionDb() {
-  const dbPath = getOpenCodeDbPath();
-  if (cachedReadOnlyDb?.path === dbPath) {
-    return cachedReadOnlyDb.db;
+function getPendingOpsStatement(db) {
+  let stmt = getPendingOpsStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("SELECT id, session_id, tag_id, operation, queued_at FROM pending_ops WHERE session_id = ? ORDER BY queued_at ASC, id ASC");
+    getPendingOpsStatements.set(db, stmt);
   }
-  closeCachedReadOnlyDb();
-  const db = new Database2(dbPath, { readonly: true });
-  cachedReadOnlyDb = { path: dbPath, db };
-  return db;
+  return stmt;
 }
-function withReadOnlySessionDb(fn) {
-  return fn(getReadOnlySessionDb());
+function getRemovePendingOpStatement(db) {
+  let stmt = removePendingOpStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("DELETE FROM pending_ops WHERE session_id = ? AND tag_id = ?");
+    removePendingOpStatements.set(db, stmt);
+  }
+  return stmt;
 }
-function getRawSessionMessageCountFromDb(db, sessionId) {
-  const row = db.prepare("SELECT COUNT(*) as count FROM message WHERE session_id = ?").get(sessionId);
-  return typeof row?.count === "number" ? row.count : 0;
+function isPendingOpRow(row) {
+  if (row === null || typeof row !== "object")
+    return false;
+  const r = row;
+  return typeof r.id === "number" && typeof r.session_id === "string" && typeof r.tag_id === "number" && typeof r.operation === "string" && typeof r.queued_at === "number";
 }
-
-// src/hooks/magic-context/read-session-formatting.ts
-var COMMIT_HASH_PATTERN = /`?\b([0-9a-f]{6,12})\b`?/gi;
-var COMMIT_HINT_PATTERN = /\b(commit(?:ted)?|cherry-?pick(?:ed)?|hash(?:es)?|sha)\b/i;
-var MAX_COMMITS_PER_BLOCK = 5;
-function hasMeaningfulUserText(parts) {
-  for (const part of parts) {
-    if (part === null || typeof part !== "object")
-      continue;
-    const candidate = part;
-    if (candidate.type !== "text" || typeof candidate.text !== "string")
-      continue;
-    if (candidate.ignored === true)
-      continue;
-    const cleaned = removeSystemReminders(candidate.text).replace(OMO_INTERNAL_INITIATOR_MARKER, "").trim();
-    if (!cleaned)
-      continue;
-    if (isSystemDirective(cleaned))
-      continue;
-    return true;
+function toPendingOp(row) {
+  if (row.operation !== "drop") {
+    sessionLog(row.session_id, `unknown pending operation "${row.operation}"; ignoring`);
+    return null;
   }
-  return false;
+  return {
+    id: row.id,
+    sessionId: row.session_id,
+    tagId: row.tag_id,
+    operation: row.operation,
+    queuedAt: row.queued_at
+  };
 }
-function extractTexts(parts) {
-  const texts = [];
-  for (const part of parts) {
-    if (part === null || typeof part !== "object")
-      continue;
-    const p = part;
-    if (p.type === "text" && typeof p.text === "string" && p.text.trim().length > 0) {
-      texts.push(p.text.trim());
-    }
-  }
-  return texts;
+function queuePendingOp(db, sessionId, tagId, operation, queuedAt = Date.now()) {
+  getQueuePendingOpStatement(db).run(sessionId, tagId, operation, queuedAt);
 }
-function estimateTokens(text) {
-  return Math.ceil(text.length / 3.5);
+function getPendingOps(db, sessionId) {
+  const rows = getPendingOpsStatement(db).all(sessionId).filter(isPendingOpRow);
+  return rows.map(toPendingOp).filter((op) => op !== null);
 }
-function normalizeText(text) {
-  return text.replace(/\s+/g, " ").trim();
+function removePendingOp(db, sessionId, tagId) {
+  getRemovePendingOpStatement(db).run(sessionId, tagId);
 }
-function compactRole(role) {
-  if (role === "assistant")
-    return "A";
-  if (role === "user")
-    return "U";
-  return role.slice(0, 1).toUpperCase() || "M";
+// src/features/magic-context/storage-source.ts
+function isSourceContentRow(row) {
+  if (row === null || typeof row !== "object")
+    return false;
+  const r = row;
+  return typeof r.tag_id === "number" && typeof r.content === "string";
 }
-function formatBlock(block) {
-  const range = block.startOrdinal === block.endOrdinal ? `[${block.startOrdinal}]` : `[${block.startOrdinal}-${block.endOrdinal}]`;
-  const commitSuffix = block.commitHashes.length > 0 ? ` commits: ${block.commitHashes.join(", ")}` : "";
-  return `${range} ${block.role}:${commitSuffix} ${block.parts.join(" / ")}`;
+function saveSourceContent(db, sessionId, tagId, content) {
+  db.prepare("INSERT OR IGNORE INTO source_contents (tag_id, session_id, content, created_at) VALUES (?, ?, ?, ?)").run(tagId, sessionId, content, Date.now());
 }
-function extractCommitHashes(text) {
-  const hashes = [];
-  const seen = new Set;
-  for (const match of text.matchAll(COMMIT_HASH_PATTERN)) {
-    const hash2 = match[1]?.toLowerCase();
-    if (!hash2 || seen.has(hash2))
-      continue;
-    seen.add(hash2);
-    hashes.push(hash2);
-    if (hashes.length >= MAX_COMMITS_PER_BLOCK)
-      break;
+function replaceSourceContent(db, sessionId, tagId, content) {
+  db.prepare(`INSERT INTO source_contents (tag_id, session_id, content, created_at)
+     VALUES (?, ?, ?, ?)
+     ON CONFLICT(session_id, tag_id)
+     DO UPDATE SET content = excluded.content, created_at = excluded.created_at`).run(tagId, sessionId, content, Date.now());
+}
+function getSourceContents(db, sessionId, tagIds) {
+  if (tagIds.length === 0) {
+    return new Map;
   }
-  return hashes;
+  const placeholders = tagIds.map(() => "?").join(", ");
+  const rows = db.prepare(`SELECT tag_id, content FROM source_contents WHERE session_id = ? AND tag_id IN (${placeholders})`).all(sessionId, ...tagIds).filter(isSourceContentRow);
+  const sources = new Map;
+  for (const row of rows) {
+    sources.set(row.tag_id, row.content);
+  }
+  return sources;
 }
-function compactTextForSummary(text, role) {
-  const commitHashes = role === "assistant" ? extractCommitHashes(text) : [];
-  if (commitHashes.length === 0 || !COMMIT_HINT_PATTERN.test(text)) {
-    return { text, commitHashes };
+// src/features/magic-context/storage-tags.ts
+var insertTagStatements = new WeakMap;
+var updateTagStatusStatements = new WeakMap;
+var updateTagMessageIdStatements = new WeakMap;
+function getInsertTagStatement(db) {
+  let stmt = insertTagStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("INSERT INTO tags (session_id, message_id, type, byte_size, tag_number) VALUES (?, ?, ?, ?, ?)");
+    insertTagStatements.set(db, stmt);
   }
-  const withoutHashes = text.replace(COMMIT_HASH_PATTERN, "").replace(/\(\s*\)/g, "").replace(/\s+,/g, ",").replace(/,\s*,+/g, ", ").replace(/\s{2,}/g, " ").replace(/\s+([,.;:])/g, "$1").trim();
-  return {
-    text: withoutHashes.length > 0 ? withoutHashes : text,
-    commitHashes
-  };
+  return stmt;
 }
-function mergeCommitHashes(existing, next) {
-  if (next.length === 0)
-    return existing;
-  const merged = [...existing];
-  for (const hash2 of next) {
-    if (merged.includes(hash2))
-      continue;
-    merged.push(hash2);
-    if (merged.length >= MAX_COMMITS_PER_BLOCK)
-      break;
+function getUpdateTagStatusStatement(db) {
+  let stmt = updateTagStatusStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("UPDATE tags SET status = ? WHERE session_id = ? AND tag_number = ?");
+    updateTagStatusStatements.set(db, stmt);
   }
-  return merged;
+  return stmt;
 }
-
-// src/hooks/magic-context/read-session-raw.ts
-function isRawMessageRow(row) {
-  if (row === null || typeof row !== "object")
-    return false;
-  const candidate = row;
-  return typeof candidate.id === "string" && typeof candidate.data === "string";
+function getUpdateTagMessageIdStatement(db) {
+  let stmt = updateTagMessageIdStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("UPDATE tags SET message_id = ? WHERE session_id = ? AND tag_number = ?");
+    updateTagMessageIdStatements.set(db, stmt);
+  }
+  return stmt;
 }
-function isRawPartRow(row) {
+function isTagRow(row) {
   if (row === null || typeof row !== "object")
     return false;
-  const candidate = row;
-  return typeof candidate.message_id === "string" && typeof candidate.data === "string";
+  const r = row;
+  return typeof r.id === "number" && typeof r.message_id === "string" && typeof r.type === "string" && typeof r.status === "string" && typeof r.byte_size === "number" && typeof r.session_id === "string" && typeof r.tag_number === "number";
 }
-function parseJsonRecord(value) {
-  const parsed = JSON.parse(value);
-  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error("Expected JSON object");
-  }
-  return parsed;
+function toTagEntry(row) {
+  const type = row.type === "tool" ? "tool" : row.type === "file" ? "file" : "message";
+  const status = row.status === "dropped" || row.status === "compacted" ? row.status : "active";
+  return {
+    tagNumber: row.tag_number,
+    messageId: row.message_id,
+    type,
+    status,
+    byteSize: row.byte_size,
+    sessionId: row.session_id
+  };
 }
-function parseJsonUnknown(value) {
-  return JSON.parse(value);
+function insertTag(db, sessionId, messageId, type, byteSize2, tagNumber) {
+  getInsertTagStatement(db).run(sessionId, messageId, type, byteSize2, tagNumber);
+  return tagNumber;
 }
-function readRawSessionMessagesFromDb(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 partRows = db.prepare("SELECT message_id, data 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) {
-    const list = partsByMessageId.get(part.message_id) ?? [];
-    list.push(parseJsonUnknown(part.data));
-    partsByMessageId.set(part.message_id, list);
+function updateTagStatus(db, sessionId, tagId, status) {
+  getUpdateTagStatusStatement(db).run(status, sessionId, tagId);
+}
+function updateTagMessageId(db, sessionId, tagId, messageId) {
+  getUpdateTagMessageIdStatement(db).run(messageId, sessionId, tagId);
+}
+function getTagsBySession(db, sessionId) {
+  const rows = db.prepare("SELECT id, message_id, type, status, byte_size, session_id, tag_number FROM tags WHERE session_id = ? ORDER BY tag_number ASC, id ASC").all(sessionId).filter(isTagRow);
+  return rows.map(toTagEntry);
+}
+function getTopNBySize(db, sessionId, n) {
+  if (n <= 0) {
+    return [];
   }
-  return messageRows.map((row, index) => {
-    const info = parseJsonRecord(row.data);
-    const role = typeof info.role === "string" ? info.role : "unknown";
-    return {
-      ordinal: index + 1,
-      id: row.id,
-      role,
-      parts: partsByMessageId.get(row.id) ?? []
-    };
-  });
+  const rows = db.prepare("SELECT id, message_id, type, status, byte_size, session_id, tag_number FROM tags WHERE session_id = ? AND status = 'active' ORDER BY byte_size DESC, tag_number ASC LIMIT ?").all(sessionId, n).filter(isTagRow);
+  return rows.map(toTagEntry);
 }
-
-// src/hooks/magic-context/tag-content-primitives.ts
-var encoder = new TextEncoder;
-var TAG_PREFIX_REGEX = /^\u00A7\d+\u00A7\s*/;
-function byteSize(value) {
-  return encoder.encode(value).length;
+// src/plugin/dream-timer.ts
+var DREAM_TIMER_INTERVAL_MS = 15 * 60 * 1000;
+function startDreamScheduleTimer(args) {
+  const { client, dreamerConfig } = args;
+  if (!dreamerConfig.enabled || !dreamerConfig.schedule?.trim()) {
+    return;
+  }
+  const timer = setInterval(() => {
+    try {
+      const db = openDatabase();
+      checkScheduleAndEnqueue(db, dreamerConfig.schedule);
+      processDreamQueue({
+        db,
+        client,
+        tasks: dreamerConfig.tasks,
+        taskTimeoutMinutes: dreamerConfig.task_timeout_minutes,
+        maxRuntimeMinutes: dreamerConfig.max_runtime_minutes
+      }).catch((error48) => {
+        log("[dreamer] timer-triggered queue processing failed:", error48);
+      });
+    } catch (error48) {
+      log("[dreamer] timer-triggered schedule check failed:", error48);
+    }
+  }, DREAM_TIMER_INTERVAL_MS);
+  if (typeof timer === "object" && "unref" in timer) {
+    timer.unref();
+  }
+  log(`[dreamer] started independent schedule timer (every ${DREAM_TIMER_INTERVAL_MS / 60000}m)`);
+  return () => {
+    clearInterval(timer);
+    log("[dreamer] stopped dream schedule timer");
+  };
 }
-function stripTagPrefix(value) {
-  return value.replace(TAG_PREFIX_REGEX, "");
+
+// src/plugin/event.ts
+function createEventHandler(args) {
+  return async (input) => {
+    await args.magicContext?.event?.(input);
+  };
 }
-function prependTag(tagId, value) {
-  const stripped = stripTagPrefix(value);
-  return `\xA7${tagId}\xA7 ${stripped}`;
+
+// src/features/magic-context/compaction.ts
+function createCompactionHandler() {
+  return {
+    onCompacted(sessionId, db) {
+      db.transaction(() => {
+        db.prepare("UPDATE tags SET status = 'compacted' WHERE session_id = ? AND status IN ('active', 'dropped')").run(sessionId);
+        db.prepare("DELETE FROM pending_ops WHERE session_id = ?").run(sessionId);
+        updateSessionMeta(db, sessionId, { lastNudgeBand: null });
+      })();
+    }
+  };
 }
-function isThinkingPart(part) {
-  if (part === null || typeof part !== "object")
-    return false;
-  const candidate = part;
-  return candidate.type === "thinking" || candidate.type === "reasoning";
+
+// src/hooks/is-anthropic-provider.ts
+function isAnthropicProvider(providerID) {
+  return providerID === "anthropic" || providerID === "google-vertex-anthropic";
 }
 
-// src/hooks/magic-context/tag-part-guards.ts
-function isTextPart(part) {
-  if (part === null || typeof part !== "object")
-    return false;
-  const p = part;
-  return p.type === "text" && typeof p.text === "string";
+// src/hooks/magic-context/event-resolvers.ts
+var DEFAULT_CONTEXT_LIMIT = 200000;
+function resolveContextLimit(providerID, modelID, config2) {
+  if (!providerID) {
+    return DEFAULT_CONTEXT_LIMIT;
+  }
+  if (modelID) {
+    const modelSpecific = config2.modelContextLimitsCache?.get(`${providerID}/${modelID}`);
+    if (typeof modelSpecific === "number" && modelSpecific > 0) {
+      return modelSpecific;
+    }
+  }
+  if (isAnthropicProvider(providerID)) {
+    return 1e6;
+  }
+  return DEFAULT_CONTEXT_LIMIT;
 }
-function isToolPartWithOutput(part) {
-  if (part === null || typeof part !== "object")
-    return false;
-  const p = part;
-  if (p.type !== "tool" || typeof p.callID !== "string")
-    return false;
-  if (p.state === null || typeof p.state !== "object")
-    return false;
-  return typeof p.state.output === "string";
+function resolveCacheTtl(cacheTtl, modelKey) {
+  if (typeof cacheTtl === "string") {
+    return cacheTtl;
+  }
+  if (modelKey && typeof cacheTtl[modelKey] === "string") {
+    return cacheTtl[modelKey];
+  }
+  if (modelKey) {
+    const bareModelId = modelKey.split("/").slice(1).join("/");
+    if (bareModelId && typeof cacheTtl[bareModelId] === "string") {
+      return cacheTtl[bareModelId];
+    }
+  }
+  return cacheTtl.default ?? "5m";
 }
-function isFilePart(part) {
-  if (part === null || typeof part !== "object")
-    return false;
-  const p = part;
-  return p.type === "file" && typeof p.url === "string";
+function resolveExecuteThreshold(config2, modelKey, fallback) {
+  if (typeof config2 === "number") {
+    return config2;
+  }
+  if (modelKey && typeof config2[modelKey] === "number") {
+    return config2[modelKey];
+  }
+  if (modelKey) {
+    const bareModelId = modelKey.split("/").slice(1).join("/");
+    if (bareModelId && typeof config2[bareModelId] === "number") {
+      return config2[bareModelId];
+    }
+  }
+  return config2.default ?? fallback;
 }
-function buildFileSourceContent(parts) {
-  const content = parts.filter(isTextPart).map((part) => stripTagPrefix(part.text)).join(`
-`).trim();
-  return content.length > 0 ? content : null;
+function resolveModelKey(providerID, modelID) {
+  if (!providerID || !modelID) {
+    return;
+  }
+  return `${providerID}/${modelID}`;
+}
+function resolveSessionId(properties) {
+  if (typeof properties?.sessionID === "string") {
+    return properties.sessionID;
+  }
+  const info = properties?.info;
+  if (info === null || typeof info !== "object") {
+    return;
+  }
+  const record2 = info;
+  if (typeof record2.sessionID === "string") {
+    return record2.sessionID;
+  }
+  if (typeof record2.id === "string") {
+    return record2.id;
+  }
+  return;
 }
 
-// src/hooks/magic-context/read-session-chunk.ts
-function cleanUserText(text) {
-  return removeSystemReminders(text).replace(OMO_INTERNAL_INITIATOR_MARKER, "").trim();
+// src/features/magic-context/scheduler.ts
+var TTL_PATTERN = /^(\d+)([smh])$/;
+var NUMERIC_PATTERN = /^\d+$/;
+var UNIT_TO_MS = {
+  s: 1000,
+  m: 60 * 1000,
+  h: 60 * 60 * 1000
+};
+function parseCacheTtl(ttl) {
+  const normalizedTtl = ttl.trim();
+  if (NUMERIC_PATTERN.test(normalizedTtl)) {
+    return Number(normalizedTtl);
+  }
+  const match = normalizedTtl.match(TTL_PATTERN);
+  if (!match) {
+    throw new Error(`Invalid cache TTL format: ${ttl}`);
+  }
+  const value = Number(match[1]);
+  const unit = match[2];
+  return value * UNIT_TO_MS[unit];
 }
-function readRawSessionMessages(sessionId) {
-  return withReadOnlySessionDb((db) => readRawSessionMessagesFromDb(db, sessionId));
+function createScheduler(config2) {
+  return {
+    shouldExecute(sessionMeta, contextUsage, currentTime = Date.now(), sessionId, modelKey) {
+      const threshold = resolveExecuteThreshold(config2.executeThresholdPercentage, modelKey, 65);
+      if (contextUsage.percentage >= threshold) {
+        return "execute";
+      }
+      let ttlMs;
+      try {
+        ttlMs = parseCacheTtl(sessionMeta.cacheTtl);
+      } catch (error48) {
+        if (sessionId) {
+          sessionLog(sessionId, `invalid cache_ttl "${sessionMeta.cacheTtl}"; falling back to default 5m`, error48);
+        } else {
+          log(`[magic-context] invalid cache_ttl "${sessionMeta.cacheTtl}"; falling back to default 5m`, error48);
+        }
+        ttlMs = parseCacheTtl("5m");
+      }
+      const elapsedTime = currentTime - sessionMeta.lastResponseTime;
+      if (elapsedTime > ttlMs) {
+        return "execute";
+      }
+      return "defer";
+    }
+  };
 }
-function getRawSessionMessageCount(sessionId) {
-  return withReadOnlySessionDb((db) => getRawSessionMessageCountFromDb(db, sessionId));
+
+// src/features/magic-context/tagger.ts
+var GET_COUNTER_SQL = `SELECT counter FROM session_meta WHERE session_id = ?`;
+var GET_ASSIGNMENTS_SQL = "SELECT message_id, tag_number FROM tags WHERE session_id = ? ORDER BY tag_number ASC";
+function isAssignmentRow(row) {
+  if (row === null || typeof row !== "object") {
+    return false;
+  }
+  const candidate = row;
+  return typeof candidate.message_id === "string" && typeof candidate.tag_number === "number";
 }
-function getRawSessionTagKeysThrough(sessionId, upToMessageIndex) {
-  return withReadOnlySessionDb((db) => {
-    const messages = readRawSessionMessagesFromDb(db, sessionId);
-    const keys = [];
-    for (const message of messages) {
-      if (message.ordinal > upToMessageIndex)
-        break;
-      for (const [partIndex, part] of message.parts.entries()) {
-        if (isTextPart(part)) {
-          keys.push(`${message.id}:p${partIndex}`);
-        }
-        if (isFilePart(part)) {
-          keys.push(`${message.id}:file${partIndex}`);
-        }
-        if (isToolPartWithOutput(part)) {
-          keys.push(part.callID);
-        }
+var UPSERT_COUNTER_SQL = `
+  INSERT INTO session_meta (session_id, counter)
+  VALUES (?, ?)
+  ON CONFLICT(session_id) DO UPDATE SET counter = excluded.counter
+`;
+var upsertCounterStatements = new WeakMap;
+function getUpsertCounterStatement(db) {
+  let stmt = upsertCounterStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(UPSERT_COUNTER_SQL);
+    upsertCounterStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function createTagger() {
+  const counters = new Map;
+  const assignments = new Map;
+  function getSessionAssignments(sessionId) {
+    let map2 = assignments.get(sessionId);
+    if (!map2) {
+      map2 = new Map;
+      assignments.set(sessionId, map2);
+    }
+    return map2;
+  }
+  function assignTag(sessionId, messageId, type, byteSize2, db) {
+    const sessionAssignments = getSessionAssignments(sessionId);
+    const existing = sessionAssignments.get(messageId);
+    if (existing !== undefined) {
+      return existing;
+    }
+    const current = counters.get(sessionId) ?? 0;
+    const next = current + 1;
+    db.transaction(() => {
+      insertTag(db, sessionId, messageId, type, byteSize2, next);
+      getUpsertCounterStatement(db).run(sessionId, next);
+    })();
+    counters.set(sessionId, next);
+    sessionAssignments.set(messageId, next);
+    return next;
+  }
+  function getTag(sessionId, messageId) {
+    return assignments.get(sessionId)?.get(messageId);
+  }
+  function bindTag(sessionId, messageId, tagNumber) {
+    getSessionAssignments(sessionId).set(messageId, tagNumber);
+  }
+  function getAssignments(sessionId) {
+    return getSessionAssignments(sessionId);
+  }
+  function resetCounter(sessionId, db) {
+    counters.set(sessionId, 0);
+    assignments.delete(sessionId);
+    getUpsertCounterStatement(db).run(sessionId, 0);
+  }
+  function getCounter(sessionId) {
+    return counters.get(sessionId) ?? 0;
+  }
+  function initFromDb(sessionId, db) {
+    if (counters.has(sessionId)) {
+      return;
+    }
+    const row = db.prepare(GET_COUNTER_SQL).get(sessionId);
+    const assignmentRows = db.prepare(GET_ASSIGNMENTS_SQL).all(sessionId).filter(isAssignmentRow);
+    const sessionAssignments = getSessionAssignments(sessionId);
+    sessionAssignments.clear();
+    let maxTagNumber = 0;
+    for (const assignment of assignmentRows) {
+      sessionAssignments.set(assignment.message_id, assignment.tag_number);
+      if (assignment.tag_number > maxTagNumber) {
+        maxTagNumber = assignment.tag_number;
       }
     }
-    return keys;
-  });
+    const counter = Math.max(row?.counter ?? 0, maxTagNumber);
+    counters.set(sessionId, counter);
+  }
+  function cleanup(sessionId) {
+    counters.delete(sessionId);
+    assignments.delete(sessionId);
+  }
+  return {
+    assignTag,
+    getTag,
+    bindTag,
+    getAssignments,
+    resetCounter,
+    getCounter,
+    initFromDb,
+    cleanup
+  };
 }
-var PROTECTED_TAIL_USER_TURNS = 5;
-function getProtectedTailStartOrdinal(sessionId) {
-  return withReadOnlySessionDb((db) => {
-    const messages = readRawSessionMessagesFromDb(db, sessionId);
-    const userOrdinals = messages.filter((m) => m.role === "user" && hasMeaningfulUserText(m.parts)).map((m) => m.ordinal);
-    if (userOrdinals.length < PROTECTED_TAIL_USER_TURNS) {
-      return 1;
-    }
-    return userOrdinals[userOrdinals.length - PROTECTED_TAIL_USER_TURNS];
-  });
+
+// src/features/magic-context/memory/project-identity.ts
+import { execSync } from "child_process";
+import path3 from "path";
+var GIT_TIMEOUT_MS = 5000;
+var resolvedCache = new Map;
+function getRootCommitHash(directory) {
+  try {
+    const hash2 = execSync("git rev-list --max-parents=0 HEAD", {
+      cwd: directory,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: GIT_TIMEOUT_MS
+    }).trim();
+    const firstLine = hash2.split(`
+`)[0]?.trim();
+    return firstLine && firstLine.length >= 7 ? firstLine : undefined;
+  } catch {
+    return;
+  }
 }
-function readSessionChunk(sessionId, tokenBudget, offset = 1, eligibleEndOrdinal) {
-  const messages = readRawSessionMessages(sessionId);
-  const startOrdinal = Math.max(1, offset);
-  const lines = [];
-  const lineMeta = [];
-  let totalTokens = 0;
-  let messagesProcessed = 0;
-  let lastOrdinal = startOrdinal - 1;
-  let lastMessageId = "";
-  let firstMessageId = "";
-  let currentBlock = null;
-  let pendingNoiseMeta = [];
-  let commitClusters = 0;
-  let lastFlushedRole = "";
-  function flushCurrentBlock() {
-    if (!currentBlock)
-      return true;
-    const blockText = formatBlock(currentBlock);
-    const blockTokens = estimateTokens(blockText);
-    if (totalTokens + blockTokens > tokenBudget && totalTokens > 0) {
-      return false;
-    }
-    if (currentBlock.role === "A" && currentBlock.commitHashes.length > 0 && lastFlushedRole !== "A") {
-      commitClusters++;
-    }
-    lastFlushedRole = currentBlock.role;
-    if (!firstMessageId)
-      firstMessageId = currentBlock.meta[0]?.messageId ?? "";
-    lastOrdinal = currentBlock.meta[currentBlock.meta.length - 1]?.ordinal ?? currentBlock.endOrdinal;
-    lastMessageId = currentBlock.meta[currentBlock.meta.length - 1]?.messageId ?? "";
-    messagesProcessed += currentBlock.meta.length;
-    lines.push(blockText);
-    lineMeta.push(...currentBlock.meta);
-    totalTokens += blockTokens;
-    currentBlock = null;
-    return true;
+function directoryFallback(directory) {
+  const canonical = path3.resolve(directory);
+  const hash2 = Bun.hash(canonical).toString(16).slice(0, 12);
+  return `dir:${hash2}`;
+}
+function resolveProjectIdentity(directory) {
+  const resolved = path3.resolve(directory);
+  const cached2 = resolvedCache.get(resolved);
+  if (cached2 !== undefined) {
+    return cached2;
   }
-  for (const msg of messages) {
-    if (eligibleEndOrdinal !== undefined && msg.ordinal >= eligibleEndOrdinal)
-      break;
-    if (msg.ordinal < startOrdinal)
-      continue;
-    const meta3 = { ordinal: msg.ordinal, messageId: msg.id };
-    if (msg.role === "user" && !hasMeaningfulUserText(msg.parts)) {
-      pendingNoiseMeta.push(meta3);
-      continue;
-    }
-    const role = compactRole(msg.role);
-    const compacted = compactTextForSummary(extractTexts(msg.parts).map((t) => msg.role === "user" ? cleanUserText(t) : t).map(normalizeText).filter((value) => value.length > 0).join(" / "), msg.role);
-    const text = compacted.text;
-    if (!text) {
-      pendingNoiseMeta.push(meta3);
-      continue;
+  const rootHash = getRootCommitHash(resolved);
+  const identity = rootHash ? `git:${rootHash}` : directoryFallback(resolved);
+  resolvedCache.set(resolved, identity);
+  return identity;
+}
+
+// src/hooks/magic-context/execute-flush.ts
+function executeFlush(db, sessionId) {
+  try {
+    const pendingOps = getPendingOps(db, sessionId);
+    if (pendingOps.length === 0) {
+      return "No pending operations to flush.";
     }
-    if (currentBlock && currentBlock.role === role) {
-      currentBlock.endOrdinal = msg.ordinal;
-      currentBlock.parts.push(text);
-      currentBlock.meta.push(...pendingNoiseMeta, meta3);
-      currentBlock.commitHashes = mergeCommitHashes(currentBlock.commitHashes, compacted.commitHashes);
-      pendingNoiseMeta = [];
-      continue;
+    let dropped = 0;
+    db.transaction(() => {
+      for (const op of pendingOps) {
+        updateTagStatus(db, sessionId, op.tagId, "dropped");
+        removePendingOp(db, sessionId, op.tagId);
+        dropped++;
+      }
+    })();
+    const parts = [];
+    if (dropped > 0)
+      parts.push(`${dropped} dropped`);
+    if (dropped > 0) {
+      clearPersistedStickyTurnReminder(db, sessionId);
     }
-    if (!flushCurrentBlock())
-      break;
-    currentBlock = {
-      role,
-      startOrdinal: pendingNoiseMeta[0]?.ordinal ?? msg.ordinal,
-      endOrdinal: msg.ordinal,
-      parts: [text],
-      meta: [...pendingNoiseMeta, meta3],
-      commitHashes: [...compacted.commitHashes]
-    };
-    pendingNoiseMeta = [];
+    return `Flushed: ${parts.join(", ")}. Changes take effect on next message.`;
+  } catch (error48) {
+    sessionLog(sessionId, "ctx-flush failed:", error48);
+    return `Error: Failed to flush context operations. ${getErrorMessage(error48)}`;
   }
-  flushCurrentBlock();
-  return {
-    startIndex: startOrdinal,
-    endIndex: lastOrdinal,
-    startMessageId: firstMessageId,
-    endMessageId: lastMessageId,
-    messageCount: messagesProcessed,
-    tokenEstimate: totalTokens,
-    hasMore: lastOrdinal < (eligibleEndOrdinal !== undefined ? Math.min(eligibleEndOrdinal - 1, messages.length) : messages.length),
-    text: lines.join(`
-`),
-    lines: lineMeta,
-    commitClusterCount: commitClusters
-  };
 }
 
 // src/hooks/magic-context/compartment-trigger.ts
@@ -16727,29 +16896,31 @@ var TAIL_INFO_DEFAULTS = {
   commitClusterCount: 0
 };
 function getUnsummarizedTailInfo(db, sessionId, compartmentTokenBudget) {
-  try {
-    const lastCompartmentEnd = getLastCompartmentEndMessage(db, sessionId);
-    const nextStartOrdinal = Math.max(1, lastCompartmentEnd + 1);
-    const rawMessageCount = getRawSessionMessageCount(sessionId);
-    const protectedTailStart = getProtectedTailStartOrdinal(sessionId);
-    const hasEligibleHistory = rawMessageCount >= nextStartOrdinal && nextStartOrdinal < protectedTailStart;
-    if (!hasEligibleHistory) {
-      return { ...TAIL_INFO_DEFAULTS, nextStartOrdinal };
+  return withRawSessionMessageCache(() => {
+    try {
+      const lastCompartmentEnd = getLastCompartmentEndMessage(db, sessionId);
+      const nextStartOrdinal = Math.max(1, lastCompartmentEnd + 1);
+      const rawMessageCount = getRawSessionMessageCount(sessionId);
+      const protectedTailStart = getProtectedTailStartOrdinal(sessionId);
+      const hasEligibleHistory = rawMessageCount >= nextStartOrdinal && nextStartOrdinal < protectedTailStart;
+      if (!hasEligibleHistory) {
+        return { ...TAIL_INFO_DEFAULTS, nextStartOrdinal };
+      }
+      const scanBudget = Math.max(MIN_PROACTIVE_TAIL_TOKEN_ESTIMATE, compartmentTokenBudget * TAIL_SIZE_TRIGGER_MULTIPLIER);
+      const chunk = readSessionChunk(sessionId, scanBudget, nextStartOrdinal, protectedTailStart);
+      const isMeaningful = chunk.hasMore || chunk.tokenEstimate >= MIN_PROACTIVE_TAIL_TOKEN_ESTIMATE || chunk.messageCount >= MIN_PROACTIVE_TAIL_MESSAGE_COUNT;
+      return {
+        nextStartOrdinal,
+        hasNewRawHistory: true,
+        isMeaningful,
+        tokenEstimate: chunk.tokenEstimate,
+        commitClusterCount: chunk.commitClusterCount
+      };
+    } catch (error48) {
+      sessionLog(sessionId, "compartment trigger: raw tail inspection failed:", error48);
+      return TAIL_INFO_DEFAULTS;
     }
-    const scanBudget = Math.max(MIN_PROACTIVE_TAIL_TOKEN_ESTIMATE, compartmentTokenBudget * TAIL_SIZE_TRIGGER_MULTIPLIER);
-    const chunk = readSessionChunk(sessionId, scanBudget, nextStartOrdinal, protectedTailStart);
-    const isMeaningful = chunk.hasMore || chunk.tokenEstimate >= MIN_PROACTIVE_TAIL_TOKEN_ESTIMATE || chunk.messageCount >= MIN_PROACTIVE_TAIL_MESSAGE_COUNT;
-    return {
-      nextStartOrdinal,
-      hasNewRawHistory: true,
-      isMeaningful,
-      tokenEstimate: chunk.tokenEstimate,
-      commitClusterCount: chunk.commitClusterCount
-    };
-  } catch (error48) {
-    sessionLog(sessionId, "compartment trigger: raw tail inspection failed:", error48);
-    return TAIL_INFO_DEFAULTS;
-  }
+  });
 }
 function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPercentage, executeThresholdPercentage, compartmentTokenBudget = DEFAULT_COMPARTMENT_TOKEN_BUDGET) {
   if (sessionMeta.compartmentInProgress) {
@@ -17334,33 +17505,145 @@ function createEventHandler2(deps) {
   };
 }
 
-// src/features/magic-context/memory/constants.ts
-var PROMOTABLE_CATEGORIES = [
-  "ARCHITECTURE_DECISIONS",
-  "CONSTRAINTS",
-  "CONFIG_DEFAULTS",
-  "NAMING",
-  "USER_PREFERENCES",
-  "USER_DIRECTIVES",
-  "ENVIRONMENT",
-  "WORKFLOW_RULES",
-  "KNOWN_ISSUES"
-];
-var CATEGORY_PRIORITY = [
-  "USER_DIRECTIVES",
-  "USER_PREFERENCES",
-  "NAMING",
-  "CONFIG_DEFAULTS",
-  "CONSTRAINTS",
-  "ARCHITECTURE_DECISIONS",
-  "ENVIRONMENT",
-  "WORKFLOW_RULES",
-  "KNOWN_ISSUES"
-];
-var CATEGORY_DEFAULT_TTL = {
-  WORKFLOW_RULES: 90 * 24 * 60 * 60 * 1000,
-  KNOWN_ISSUES: 30 * 24 * 60 * 60 * 1000
-};
+// src/features/magic-context/memory/constants.ts
+var PROMOTABLE_CATEGORIES = [
+  "ARCHITECTURE_DECISIONS",
+  "CONSTRAINTS",
+  "CONFIG_DEFAULTS",
+  "NAMING",
+  "USER_PREFERENCES",
+  "USER_DIRECTIVES",
+  "ENVIRONMENT",
+  "WORKFLOW_RULES",
+  "KNOWN_ISSUES"
+];
+var CATEGORY_PRIORITY = [
+  "USER_DIRECTIVES",
+  "USER_PREFERENCES",
+  "NAMING",
+  "CONFIG_DEFAULTS",
+  "CONSTRAINTS",
+  "ARCHITECTURE_DECISIONS",
+  "ENVIRONMENT",
+  "WORKFLOW_RULES",
+  "KNOWN_ISSUES"
+];
+var CATEGORY_DEFAULT_TTL = {
+  WORKFLOW_RULES: 90 * 24 * 60 * 60 * 1000,
+  KNOWN_ISSUES: 30 * 24 * 60 * 60 * 1000
+};
+
+// src/features/magic-context/memory/storage-memory-embeddings.ts
+var saveEmbeddingStatements = new WeakMap;
+var loadAllEmbeddingsStatements = new WeakMap;
+var deleteEmbeddingStatements = new WeakMap;
+var getStoredModelIdStatements = new WeakMap;
+var clearAllEmbeddingsStatements = new WeakMap;
+function isEmbeddingBlob(value) {
+  return value instanceof Uint8Array || value instanceof ArrayBuffer;
+}
+function isEmbeddingRow(row) {
+  if (row === null || typeof row !== "object")
+    return false;
+  const candidate = row;
+  return typeof candidate.memoryId === "number" && isEmbeddingBlob(candidate.embedding);
+}
+function toFloat32Array(blob) {
+  if (blob instanceof Uint8Array) {
+    const buffer2 = blob.buffer.slice(blob.byteOffset, blob.byteOffset + blob.byteLength);
+    return new Float32Array(buffer2);
+  }
+  return new Float32Array(blob.slice(0));
+}
+function getSaveEmbeddingStatement(db) {
+  let stmt = saveEmbeddingStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("INSERT INTO memory_embeddings (memory_id, embedding, model_id) VALUES (?, ?, ?) ON CONFLICT(memory_id) DO UPDATE SET embedding = excluded.embedding, model_id = excluded.model_id");
+    saveEmbeddingStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getLoadAllEmbeddingsStatement(db) {
+  let stmt = loadAllEmbeddingsStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("SELECT memory_embeddings.memory_id AS memoryId, memory_embeddings.embedding AS embedding FROM memory_embeddings INNER JOIN memories ON memories.id = memory_embeddings.memory_id WHERE memories.project_path = ? ORDER BY memory_embeddings.memory_id ASC");
+    loadAllEmbeddingsStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getStoredModelIdStatement(db) {
+  let stmt = getStoredModelIdStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("SELECT memory_embeddings.model_id AS modelId FROM memory_embeddings INNER JOIN memories ON memories.id = memory_embeddings.memory_id WHERE memories.project_path = ? AND memory_embeddings.model_id IS NOT NULL LIMIT 1");
+    getStoredModelIdStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getClearAllEmbeddingsStatement(db) {
+  let stmt = clearAllEmbeddingsStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("DELETE FROM memory_embeddings WHERE memory_id IN (SELECT id FROM memories WHERE project_path = ?)");
+    clearAllEmbeddingsStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function saveEmbedding(db, memoryId, embedding, modelId) {
+  const blob = Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
+  getSaveEmbeddingStatement(db).run(memoryId, blob, modelId);
+}
+function loadAllEmbeddings(db, projectPath) {
+  const rows = getLoadAllEmbeddingsStatement(db).all(projectPath).filter(isEmbeddingRow);
+  const embeddings = new Map;
+  for (const row of rows) {
+    embeddings.set(row.memoryId, toFloat32Array(row.embedding));
+  }
+  return embeddings;
+}
+function getStoredModelId(db, projectPath) {
+  const row = getStoredModelIdStatement(db).get(projectPath);
+  return typeof row?.modelId === "string" ? row.modelId : null;
+}
+function clearEmbeddingsForProject(db, projectPath) {
+  getClearAllEmbeddingsStatement(db).run(projectPath);
+}
+
+// src/features/magic-context/memory/embedding-cache.ts
+var DEFAULT_EMBEDDING_CACHE_TTL_MS = 60000;
+var projectEmbeddingCache = new Map;
+var embeddingCacheTtlMs = DEFAULT_EMBEDDING_CACHE_TTL_MS;
+function getValidCacheEntry(projectPath) {
+  const entry = projectEmbeddingCache.get(projectPath);
+  if (!entry) {
+    return null;
+  }
+  if (entry.expiresAt <= Date.now()) {
+    projectEmbeddingCache.delete(projectPath);
+    return null;
+  }
+  return entry;
+}
+function getProjectEmbeddings(db, projectPath) {
+  const cached2 = getValidCacheEntry(projectPath);
+  if (cached2) {
+    return cached2.embeddings;
+  }
+  const embeddings = loadAllEmbeddings(db, projectPath);
+  projectEmbeddingCache.set(projectPath, {
+    embeddings,
+    expiresAt: Date.now() + embeddingCacheTtlMs
+  });
+  return embeddings;
+}
+function peekProjectEmbeddings(projectPath) {
+  return getValidCacheEntry(projectPath)?.embeddings ?? null;
+}
+function invalidateProject(projectPath) {
+  projectEmbeddingCache.delete(projectPath);
+}
+function invalidateMemory(projectPath, memoryId) {
+  const cached2 = getValidCacheEntry(projectPath);
+  cached2?.embeddings.delete(memoryId);
+}
 
 // src/features/magic-context/memory/normalize-hash.ts
 function normalizeMemoryContent(content) {
@@ -17526,7 +17809,7 @@ function getMemoriesByProjectStatement(db, statuses) {
   let stmt = statements.get(db);
   if (!stmt) {
     const placeholders = statuses.map(() => "?").join(", ");
-    stmt = db.prepare(`SELECT ${getMemorySelectColumns()} FROM memories WHERE project_path = ? AND status IN (${placeholders}) ORDER BY category ASC, updated_at DESC, id ASC`);
+    stmt = db.prepare(`SELECT ${getMemorySelectColumns()} FROM memories WHERE project_path = ? AND status IN (${placeholders}) AND (expires_at IS NULL OR expires_at > ?) ORDER BY category ASC, updated_at DESC, id ASC`);
     statements.set(db, stmt);
   }
   return stmt;
@@ -17596,6 +17879,7 @@ function insertMemory(db, input) {
   if (!inserted) {
     throw new Error("Failed to load inserted memory row");
   }
+  invalidateProject(input.projectPath);
   return inserted;
 }
 function getMemoryByHash(db, projectPath, category, normalizedHash) {
@@ -17609,7 +17893,7 @@ function getMemoriesByProject(db, projectPath, statuses = ["active", "permanent"
   if (statuses.length === 0) {
     return [];
   }
-  const rows = getMemoriesByProjectStatement(db, statuses).all(projectPath, ...statuses).filter(isMemoryRow);
+  const rows = getMemoriesByProjectStatement(db, statuses).all(projectPath, ...statuses, Date.now()).filter(isMemoryRow);
   return rows.map(toMemory);
 }
 function getMemoryById(db, id) {
@@ -17645,6 +17929,7 @@ function mergeMetadataJson(existing, patch) {
   return JSON.stringify({ ...base, ...patch });
 }
 function updateMemoryContent(db, id, content, normalizedHash) {
+  const memory = getMemoryById(db, id);
   db.transaction(() => {
     getUpdateMemoryContentStatement(db).run(content, normalizedHash, Date.now(), id);
     let stmt = deleteEmbeddingOnContentUpdateStatements.get(db);
@@ -17654,6 +17939,9 @@ function updateMemoryContent(db, id, content, normalizedHash) {
     }
     stmt.run(id);
   })();
+  if (memory) {
+    invalidateMemory(memory.projectPath, id);
+  }
 }
 function supersededMemory(db, id, supersededById) {
   getSupersededMemoryStatement(db).run(supersededById, Date.now(), id);
@@ -18335,19 +18623,19 @@ function cosineSimilarity(a, b) {
 function isArrayLikeNumber(value) {
   return typeof value === "object" && value !== null && "length" in value;
 }
-function toFloat32Array(values) {
+function toFloat32Array2(values) {
   return values instanceof Float32Array ? new Float32Array(values) : Float32Array.from(Array.from(values));
 }
 function extractBatchEmbeddings(result, expectedCount) {
   const { data } = result;
   if (Array.isArray(data) && data.length === expectedCount && data.every((entry) => typeof entry !== "number" && isArrayLikeNumber(entry))) {
-    return data.map((entry) => toFloat32Array(entry));
+    return data.map((entry) => toFloat32Array2(entry));
   }
   if (!isArrayLikeNumber(data)) {
     log("[magic-context] embedding batch returned unexpected data shape");
     return Array.from({ length: expectedCount }, () => null);
   }
-  const flatData = toFloat32Array(data);
+  const flatData = toFloat32Array2(data);
   const dimension = result.dims?.at(-1) ?? flatData.length / expectedCount;
   if (!Number.isInteger(dimension) || dimension <= 0 || flatData.length !== expectedCount * dimension) {
     log("[magic-context] embedding batch returned invalid dimensions");
@@ -18563,7 +18851,8 @@ function resolveModelId(config2) {
   if (config2.provider === "openai-compatible") {
     const endpoint = config2.endpoint.trim();
     const model = config2.model.trim();
-    return `openai-compat:${endpoint}:${model}`;
+    const keyHash = config2.api_key ? computeNormalizedHash(config2.api_key) : "nokey";
+    return `openai-compat:${endpoint}:${model}:${keyHash}`;
   }
   return config2.model.trim() || DEFAULT_LOCAL_EMBEDDING_MODEL;
 }
@@ -18633,80 +18922,6 @@ async function embedBatch(texts) {
 function getEmbeddingModelId() {
   return getOrCreateProvider()?.modelId ?? "off";
 }
-// src/features/magic-context/memory/storage-memory-embeddings.ts
-var saveEmbeddingStatements = new WeakMap;
-var loadAllEmbeddingsStatements = new WeakMap;
-var deleteEmbeddingStatements = new WeakMap;
-var getStoredModelIdStatements = new WeakMap;
-var clearAllEmbeddingsStatements = new WeakMap;
-function isEmbeddingBlob(value) {
-  return value instanceof Uint8Array || value instanceof ArrayBuffer;
-}
-function isEmbeddingRow(row) {
-  if (row === null || typeof row !== "object")
-    return false;
-  const candidate = row;
-  return typeof candidate.memoryId === "number" && isEmbeddingBlob(candidate.embedding);
-}
-function toFloat32Array2(blob) {
-  if (blob instanceof Uint8Array) {
-    const buffer2 = blob.buffer.slice(blob.byteOffset, blob.byteOffset + blob.byteLength);
-    return new Float32Array(buffer2);
-  }
-  return new Float32Array(blob.slice(0));
-}
-function getSaveEmbeddingStatement(db) {
-  let stmt = saveEmbeddingStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("INSERT INTO memory_embeddings (memory_id, embedding, model_id) VALUES (?, ?, ?) ON CONFLICT(memory_id) DO UPDATE SET embedding = excluded.embedding, model_id = excluded.model_id");
-    saveEmbeddingStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function getLoadAllEmbeddingsStatement(db) {
-  let stmt = loadAllEmbeddingsStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("SELECT memory_embeddings.memory_id AS memoryId, memory_embeddings.embedding AS embedding FROM memory_embeddings INNER JOIN memories ON memories.id = memory_embeddings.memory_id WHERE memories.project_path = ? ORDER BY memory_embeddings.memory_id ASC");
-    loadAllEmbeddingsStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function getStoredModelIdStatement(db) {
-  let stmt = getStoredModelIdStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("SELECT memory_embeddings.model_id AS modelId FROM memory_embeddings INNER JOIN memories ON memories.id = memory_embeddings.memory_id WHERE memories.project_path = ? AND memory_embeddings.model_id IS NOT NULL LIMIT 1");
-    getStoredModelIdStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function getClearAllEmbeddingsStatement(db) {
-  let stmt = clearAllEmbeddingsStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("DELETE FROM memory_embeddings WHERE memory_id IN (SELECT id FROM memories WHERE project_path = ?)");
-    clearAllEmbeddingsStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function saveEmbedding(db, memoryId, embedding, modelId) {
-  const blob = Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
-  getSaveEmbeddingStatement(db).run(memoryId, blob, modelId);
-}
-function loadAllEmbeddings(db, projectPath) {
-  const rows = getLoadAllEmbeddingsStatement(db).all(projectPath).filter(isEmbeddingRow);
-  const embeddings = new Map;
-  for (const row of rows) {
-    embeddings.set(row.memoryId, toFloat32Array2(row.embedding));
-  }
-  return embeddings;
-}
-function getStoredModelId(db, projectPath) {
-  const row = getStoredModelIdStatement(db).get(projectPath);
-  return typeof row?.modelId === "string" ? row.modelId : null;
-}
-function clearEmbeddingsForProject(db, projectPath) {
-  getClearAllEmbeddingsStatement(db).run(projectPath);
-}
-
 // src/features/magic-context/memory/embedding-backfill.ts
 async function ensureMemoryEmbeddings(args) {
   if (!isEmbeddingEnabled()) {
@@ -18790,7 +19005,7 @@ function getSearchStatement(db) {
   let stmt = searchStatements.get(db);
   if (!stmt) {
     const selectColumns = Object.entries(COLUMN_MAP).map(([property, column]) => `memories.${column} AS ${property}`).join(", ");
-    stmt = db.prepare(`SELECT ${selectColumns} FROM memories_fts INNER JOIN memories ON memories.id = memories_fts.rowid WHERE memories.project_path = ? AND memories.status IN ('active', 'permanent') AND memories_fts MATCH ? ORDER BY bm25(memories_fts), memories.updated_at DESC, memories.id ASC LIMIT ?`);
+    stmt = db.prepare(`SELECT ${selectColumns} FROM memories_fts INNER JOIN memories ON memories.id = memories_fts.rowid WHERE memories.project_path = ? AND memories.status IN ('active', 'permanent') AND (memories.expires_at IS NULL OR memories.expires_at > ?) AND memories_fts MATCH ? ORDER BY bm25(memories_fts), memories.updated_at DESC, memories.id ASC LIMIT ?`);
     searchStatements.set(db, stmt);
   }
   return stmt;
@@ -18810,7 +19025,7 @@ function searchMemoriesFTS(db, projectPath, query, limit = DEFAULT_SEARCH_LIMIT)
   if (sanitized.length === 0) {
     return [];
   }
-  const rows = getSearchStatement(db).all(projectPath, sanitized, limit).filter(isMemoryRow);
+  const rows = getSearchStatement(db).all(projectPath, Date.now(), sanitized, limit).filter(isMemoryRow);
   return rows.map((row) => ({ ...row }));
 }
 // src/hooks/magic-context/compartment-parser.ts
@@ -19885,9 +20100,9 @@ function loadContextUsage(contextUsageMap, db, sessionId) {
   }
   return contextUsageEntry?.usage ?? { percentage: 0, inputTokens: 0 };
 }
-function resolveSchedulerDecision(scheduler2, sessionMeta, contextUsage, sessionId) {
+function resolveSchedulerDecision(scheduler2, sessionMeta, contextUsage, sessionId, modelKey) {
   try {
-    const schedulerDecision = scheduler2.shouldExecute(sessionMeta, contextUsage, undefined, sessionId);
+    const schedulerDecision = scheduler2.shouldExecute(sessionMeta, contextUsage, undefined, sessionId, modelKey);
     sessionLog(sessionId, `transform scheduler: percentage=${contextUsage.percentage.toFixed(1)}% inputTokens=${contextUsage.inputTokens} cacheTtl=${sessionMeta.cacheTtl} lastResponseTime=${sessionMeta.lastResponseTime} decision=${schedulerDecision}`);
     return schedulerDecision;
   } catch (error48) {
@@ -20129,9 +20344,17 @@ function createScopedAssignments(assignments) {
   return scoped;
 }
 function createExistingTagResolver(sessionId, tagger, db) {
-  const assignments = new Map(tagger.getAssignments(sessionId));
-  const scopedAssignments = createScopedAssignments(assignments);
+  const assignments = tagger.getAssignments(sessionId);
+  let cachedAssignmentSize = -1;
+  let cachedScopedAssignments = null;
   const usedTagNumbers = new Set;
+  function getScopedAssignments() {
+    if (!cachedScopedAssignments || cachedAssignmentSize !== assignments.size) {
+      cachedScopedAssignments = createScopedAssignments(assignments);
+      cachedAssignmentSize = assignments.size;
+    }
+    return cachedScopedAssignments;
+  }
   return {
     resolve(messageId, type, currentContentId, ordinal) {
       const exactTagId = assignments.get(currentContentId);
@@ -20139,13 +20362,12 @@ function createExistingTagResolver(sessionId, tagger, db) {
         usedTagNumbers.add(exactTagId);
         return exactTagId;
       }
-      const fallback = scopedAssignments.get(messageId)?.[type][ordinal];
+      const fallback = getScopedAssignments().get(messageId)?.[type][ordinal];
       if (!fallback || usedTagNumbers.has(fallback.tagNumber)) {
         return;
       }
       updateTagMessageId(db, sessionId, fallback.tagNumber, currentContentId);
       tagger.bindTag(sessionId, currentContentId, fallback.tagNumber);
-      assignments.set(currentContentId, fallback.tagNumber);
       usedTagNumbers.add(fallback.tagNumber);
       return fallback.tagNumber;
     }
@@ -21027,7 +21249,7 @@ function createTransform(deps) {
     const compartmentDirectory = deps.directory ?? "";
     const canRunCompartments = fullFeatureMode && deps.client !== undefined && compartmentDirectory.length > 0;
     const contextUsageEarly = loadContextUsage(deps.contextUsageMap, db, sessionId);
-    const schedulerDecisionEarly = resolveSchedulerDecision(deps.scheduler, sessionMeta, contextUsageEarly, sessionId);
+    const schedulerDecisionEarly = resolveSchedulerDecision(deps.scheduler, sessionMeta, contextUsageEarly, sessionId, deps.getModelKey?.(sessionId));
     const isCacheBusting = deps.flushedSessions.has(sessionId) || schedulerDecisionEarly === "execute";
     let pendingCompartmentInjection = null;
     if (fullFeatureMode) {
@@ -21572,7 +21794,11 @@ function createMagicContextHook(deps) {
     compartmentTokenBudget: deps.config.compartment_token_budget ?? DEFAULT_COMPARTMENT_TOKEN_BUDGET,
     historyBudgetPercentage: deps.config.history_budget_percentage,
     historianTimeoutMs: deps.config.historian_timeout_ms ?? DEFAULT_HISTORIAN_TIMEOUT_MS,
-    getNotificationParams: (sessionId) => getLiveNotificationParams(sessionId, liveModelBySession, variantBySession)
+    getNotificationParams: (sessionId) => getLiveNotificationParams(sessionId, liveModelBySession, variantBySession),
+    getModelKey: (sessionId) => {
+      const model = liveModelBySession.get(sessionId);
+      return resolveModelKey(model?.providerID, model?.modelID);
+    }
   });
   const eventHandler = createEventHandler2({
     contextUsageMap,
@@ -22212,8 +22438,7 @@ function createCtxReduceTool(deps) {
       }
       let dropIds = [];
       try {
-        if (args.drop)
-          dropIds = parseRangeString(args.drop);
+        dropIds = parseRangeString(args.drop);
       } catch (e) {
         return `Error: Invalid range syntax. ${e.message}`;
       }
@@ -22285,107 +22510,9 @@ var DEFAULT_CTX_SEARCH_LIMIT = 10;
 // src/tools/ctx-search/tools.ts
 import { tool as tool5 } from "@opencode-ai/plugin";
 
-// src/features/magic-context/message-index.ts
-var lastIndexedStatements = new WeakMap;
-var insertMessageStatements = new WeakMap;
-var upsertIndexStatements = new WeakMap;
-var deleteFtsStatements = new WeakMap;
-var deleteIndexStatements = new WeakMap;
-function normalizeIndexText(text) {
-  return text.replace(/\s+/g, " ").trim();
-}
-function getLastIndexedStatement(db) {
-  let stmt = lastIndexedStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("SELECT last_indexed_ordinal FROM message_history_index WHERE session_id = ?");
-    lastIndexedStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function getInsertMessageStatement(db) {
-  let stmt = insertMessageStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("INSERT INTO message_history_fts (session_id, message_ordinal, message_id, role, content) VALUES (?, ?, ?, ?, ?)");
-    insertMessageStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function getUpsertIndexStatement(db) {
-  let stmt = upsertIndexStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("INSERT INTO message_history_index (session_id, last_indexed_ordinal, updated_at) VALUES (?, ?, ?) ON CONFLICT(session_id) DO UPDATE SET last_indexed_ordinal = excluded.last_indexed_ordinal, updated_at = excluded.updated_at");
-    upsertIndexStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function getDeleteFtsStatement(db) {
-  let stmt = deleteFtsStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("DELETE FROM message_history_fts WHERE session_id = ?");
-    deleteFtsStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function getDeleteIndexStatement(db) {
-  let stmt = deleteIndexStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("DELETE FROM message_history_index WHERE session_id = ?");
-    deleteIndexStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function getLastIndexedOrdinal(db, sessionId) {
-  const row = getLastIndexedStatement(db).get(sessionId);
-  return typeof row?.last_indexed_ordinal === "number" ? row.last_indexed_ordinal : 0;
-}
-function clearIndexedMessages(db, sessionId) {
-  getDeleteFtsStatement(db).run(sessionId);
-  getDeleteIndexStatement(db).run(sessionId);
-}
-function getIndexableContent(role, parts) {
-  if (role === "user") {
-    if (!hasMeaningfulUserText(parts)) {
-      return "";
-    }
-    return extractTexts(parts).map(cleanUserText).map(normalizeIndexText).filter((text) => text.length > 0).join(" / ");
-  }
-  if (role === "assistant") {
-    return extractTexts(parts).map(removeSystemReminders).map(normalizeIndexText).filter((text) => text.length > 0).join(" / ");
-  }
-  return "";
-}
-function ensureMessagesIndexed(db, sessionId, readMessages) {
-  const messages = readMessages(sessionId);
-  if (messages.length === 0) {
-    db.transaction(() => clearIndexedMessages(db, sessionId))();
-    return;
-  }
-  let lastIndexedOrdinal = getLastIndexedOrdinal(db, sessionId);
-  if (lastIndexedOrdinal > messages.length) {
-    db.transaction(() => clearIndexedMessages(db, sessionId))();
-    lastIndexedOrdinal = 0;
-  }
-  if (lastIndexedOrdinal >= messages.length) {
-    return;
-  }
-  const messagesToInsert = messages.filter((message) => message.ordinal > lastIndexedOrdinal).filter((message) => message.role === "user" || message.role === "assistant").map((message) => ({
-    ordinal: message.ordinal,
-    id: message.id,
-    role: message.role,
-    content: getIndexableContent(message.role, message.parts)
-  })).filter((message) => message.content.length > 0);
-  const now = Date.now();
-  db.transaction(() => {
-    const insertMessage = getInsertMessageStatement(db);
-    for (const message of messagesToInsert) {
-      insertMessage.run(sessionId, message.ordinal, message.id, message.role, message.content);
-    }
-    getUpsertIndexStatement(db).run(sessionId, messages.length, now);
-  })();
-}
-
 // src/features/magic-context/search.ts
 var DEFAULT_UNIFIED_SEARCH_LIMIT = 10;
+var FTS_SEMANTIC_CANDIDATE_LIMIT = 50;
 var SEMANTIC_WEIGHT = 0.7;
 var FTS_WEIGHT = 0.3;
 var SINGLE_SOURCE_PENALTY = 0.8;
@@ -22465,10 +22592,11 @@ async function getSemanticScores(args) {
   if (!queryEmbedding) {
     return semanticScores;
   }
+  const cachedEmbeddings = getProjectEmbeddings(args.db, args.projectPath);
   const embeddings = await ensureMemoryEmbeddings({
     db: args.db,
     memories: args.memories,
-    existingEmbeddings: loadAllEmbeddings(args.db, args.projectPath)
+    existingEmbeddings: cachedEmbeddings
   });
   for (const memory of args.memories) {
     const memoryEmbedding = embeddings.get(memory.id);
@@ -22479,13 +22607,28 @@ async function getSemanticScores(args) {
   }
   return semanticScores;
 }
-function getFtsScores(args) {
+function getFtsMatches(args) {
   try {
-    const matches = searchMemoriesFTS(args.db, args.projectPath, args.query, args.limit);
-    return new Map(matches.map((memory, rank) => [memory.id, 1 / (rank + 1)]));
+    return searchMemoriesFTS(args.db, args.projectPath, args.query, args.limit);
   } catch {
-    return new Map;
+    return [];
+  }
+}
+function getFtsScores(matches) {
+  return new Map(matches.map((memory, rank) => [memory.id, 1 / (rank + 1)]));
+}
+function selectSemanticCandidates(args) {
+  if (args.ftsMatches.length === 0) {
+    return args.memories;
+  }
+  const candidateIds = new Set(args.ftsMatches.map((memory) => memory.id));
+  const cachedEmbeddings = peekProjectEmbeddings(args.projectPath);
+  if (cachedEmbeddings) {
+    for (const memoryId of cachedEmbeddings.keys()) {
+      candidateIds.add(memoryId);
+    }
   }
+  return args.memories.filter((memory) => candidateIds.has(memory.id));
 }
 function mergeMemoryResults(args) {
   const memoryById = new Map(args.memories.map((memory) => [memory.id, memory]));
@@ -22537,16 +22680,27 @@ async function searchMemories(args) {
   if (memories.length === 0) {
     return [];
   }
-  const semanticScores = await getSemanticScores({
+  const ftsMatches = getFtsMatches({
     db: args.db,
     projectPath: args.projectPath,
     query: args.query,
+    limit: FTS_SEMANTIC_CANDIDATE_LIMIT
+  });
+  const ftsScores = getFtsScores(ftsMatches);
+  const semanticCandidates = selectSemanticCandidates({
     memories,
+    projectPath: args.projectPath,
+    ftsMatches
+  });
+  const semanticScores = await getSemanticScores({
+    db: args.db,
+    projectPath: args.projectPath,
+    query: args.query,
+    memories: semanticCandidates,
     embeddingEnabled: args.embeddingEnabled,
     embedQuery: args.embedQuery,
     isEmbeddingRuntimeEnabled: args.isEmbeddingRuntimeEnabled
   });
-  const ftsScores = getFtsScores(args);
   return mergeMemoryResults({
     memories,
     semanticScores,