@cortexkit/opencode-magic-context 0.1.2 → 0.2.0

package/dist/index.js

@@ -13799,6 +13799,7 @@ var EmbeddingConfigSchema = BaseEmbeddingConfigSchema.transform((data) => {
 });
 var MagicContextConfigSchema = exports_external.object({
   enabled: exports_external.boolean().default(false),
+  ctx_reduce_enabled: exports_external.boolean().default(true),
   historian: AgentOverrideConfigSchema.optional(),
   dreamer: DreamerConfigSchema.optional(),
   cache_ttl: exports_external.union([exports_external.string(), exports_external.object({ default: exports_external.string() }).catchall(exports_external.string())]).default("5m"),
@@ -13951,7 +13952,6 @@ You run during scheduled dream windows to maintain a project's cross-session mem
 
 **Memory operations** (ctx_memory with extended dreamer actions):
 - \`action="list"\` \u2014 browse all active memories, optionally filter by category
-- \`action="search", query="..."\` \u2014 semantic search across memories
 - \`action="update", id=N, content="..."\` \u2014 rewrite a memory's content
 - \`action="merge", ids=[N,M,...], content="...", category="..."\` \u2014 consolidate duplicates into one canonical memory
 - \`action="archive", id=N, reason="..."\` \u2014 archive a stale memory with provenance
@@ -14033,7 +14033,7 @@ Check verifiable memories against actual repository state. Update stale wording,
 ### Verification examples
 - Memory: "compartment_token_budget defaults to 20000" \u2192 grep schema for \`compartment_token_budget\`, check \`.default(...)\`
 - Memory: "Durable state lives in ~/.local/share/opencode/storage/plugin/magic-context/context.db" \u2192 check storage-db.ts for the path construction
-- Memory: "ctx_memory search combines semantic and FTS" \u2192 grep for ctx_memory tool definition, verify search action exists
+- Memory: "ctx_search searches memories, facts, and history" \u2192 grep for ctx_search tool definition and unified search implementation
 
 ### Success criteria
 - All CONFIG_DEFAULTS memories match actual schema defaults.
@@ -14549,12 +14549,12 @@ function extractLatestAssistantText(messages) {
 // src/features/magic-context/sidekick/agent.ts
 var SIDEKICK_SYSTEM_PROMPT = `You are Sidekick, a focused memory-retrieval subagent for an AI coding assistant.
 
-Your job is to search project memories and return a concise augmentation for the user's prompt.
+Your job is to search project memories, session facts, and conversation history and return a concise augmentation for the user's prompt.
 
 Rules:
-- Use ctx_memory(action="search", query="...") to look up relevant memories before answering.
+- Use ctx_search(query="...") to look up relevant memories, facts, and history before answering.
 - Run targeted searches only; prefer 1-3 precise queries.
-- Return only memories that materially help with the user's prompt.
+- Return only findings that materially help with the user's prompt.
 - If nothing useful is found, respond with exactly: No relevant memories found.
 - Keep the response focused and concise.
 - Do not invent facts or speculate beyond what memories support.`;
@@ -14945,1276 +14945,1323 @@ function buildCompartmentAgentPrompt(existingState, inputSource) {
 `);
 }
 
-// src/plugin/event.ts
-function createEventHandler(args) {
-  return async (input) => {
-    await args.magicContext?.event?.(input);
-  };
-}
-// src/features/magic-context/storage-db.ts
-import { Database } from "bun:sqlite";
-import { mkdirSync } from "fs";
-import { join as join4 } from "path";
-
-// src/shared/data-path.ts
-import * as os2 from "os";
-import * as path2 from "path";
-function getDataDir() {
-  return process.env.XDG_DATA_HOME ?? path2.join(os2.homedir(), ".local", "share");
-}
-function getOpenCodeStorageDir() {
-  return path2.join(getDataDir(), "opencode", "storage");
-}
-
-// src/features/magic-context/storage-db.ts
-var databases = new Map;
-var FALLBACK_DATABASE_KEY = "__fallback__:memory:";
-var persistenceByDatabase = new WeakMap;
-var persistenceErrorByDatabase = new WeakMap;
-function resolveDatabasePath() {
-  const dbDir = join4(getOpenCodeStorageDir(), "plugin", "magic-context");
-  return { dbDir, dbPath: join4(dbDir, "context.db") };
-}
-function initializeDatabase(db) {
-  db.run("PRAGMA journal_mode=WAL");
-  db.run("PRAGMA busy_timeout=5000");
-  db.run("PRAGMA foreign_keys=ON");
-  db.run(`
-    CREATE TABLE IF NOT EXISTS tags (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      session_id TEXT,
-      message_id TEXT,
-      type TEXT,
-      status TEXT DEFAULT 'active',
-      byte_size INTEGER,
-      tag_number INTEGER,
-      UNIQUE(session_id, tag_number)
-    );
-
-    CREATE TABLE IF NOT EXISTS pending_ops (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      session_id TEXT,
-      tag_id INTEGER,
-      operation TEXT,
-      queued_at INTEGER
-    );
-
-    CREATE TABLE IF NOT EXISTS source_contents (
-      tag_id INTEGER,
-      session_id TEXT,
-      content TEXT,
-      created_at INTEGER,
-      PRIMARY KEY(session_id, tag_id)
-    );
-
-    CREATE TABLE IF NOT EXISTS compartments (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      session_id TEXT NOT NULL,
-      sequence INTEGER NOT NULL,
-      start_message INTEGER NOT NULL,
-      end_message INTEGER NOT NULL,
-      start_message_id TEXT DEFAULT '',
-      end_message_id TEXT DEFAULT '',
-      title TEXT NOT NULL,
-      content TEXT NOT NULL,
-      created_at INTEGER NOT NULL,
-      UNIQUE(session_id, sequence)
-    );
-
-    CREATE TABLE IF NOT EXISTS session_facts (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      session_id TEXT NOT NULL,
-      category TEXT NOT NULL,
-      content TEXT NOT NULL,
-      created_at INTEGER NOT NULL,
-      updated_at INTEGER NOT NULL
-    );
-
-    CREATE TABLE IF NOT EXISTS session_notes (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      session_id TEXT NOT NULL,
-      content TEXT NOT NULL,
-      created_at INTEGER NOT NULL
-    );
-
-    CREATE TABLE IF NOT EXISTS memories (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      project_path TEXT NOT NULL,
-      category TEXT NOT NULL,
-      content TEXT NOT NULL,
-      normalized_hash TEXT NOT NULL,
-      source_session_id TEXT,
-      source_type TEXT DEFAULT 'historian',
-      seen_count INTEGER DEFAULT 1,
-      retrieval_count INTEGER DEFAULT 0,
-      first_seen_at INTEGER NOT NULL,
-      created_at INTEGER NOT NULL,
-      updated_at INTEGER NOT NULL,
-      last_seen_at INTEGER NOT NULL,
-      last_retrieved_at INTEGER,
-      status TEXT DEFAULT 'active',
-      expires_at INTEGER,
-      verification_status TEXT DEFAULT 'unverified',
-      verified_at INTEGER,
-      superseded_by_memory_id INTEGER,
-      merged_from TEXT,
-      metadata_json TEXT,
-      UNIQUE(project_path, category, normalized_hash)
-    );
-
-    CREATE TABLE IF NOT EXISTS memory_embeddings (
-      memory_id INTEGER PRIMARY KEY REFERENCES memories(id) ON DELETE CASCADE,
-      embedding BLOB NOT NULL,
-      model_id TEXT
-    );
-
-    CREATE TABLE IF NOT EXISTS dream_state (
-      key TEXT PRIMARY KEY,
-      value TEXT NOT NULL
-    );
-
-    CREATE TABLE IF NOT EXISTS dream_queue (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      project_path TEXT NOT NULL,
-      reason TEXT NOT NULL,
-      enqueued_at INTEGER NOT NULL,
-      started_at INTEGER,
-      retry_count INTEGER DEFAULT 0
-    );
-    CREATE INDEX IF NOT EXISTS idx_dream_queue_project ON dream_queue(project_path);
-
-    CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
-      content,
-      category,
-      content='memories',
-      content_rowid='id',
-      tokenize='porter unicode61'
-    );
-
-    CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
-      INSERT INTO memories_fts(rowid, content, category) VALUES (new.id, new.content, new.category);
-    END;
-
-    CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
-      INSERT INTO memories_fts(memories_fts, rowid, content, category) VALUES ('delete', old.id, old.content, old.category);
-    END;
-
-    CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
-      INSERT INTO memories_fts(memories_fts, rowid, content, category) VALUES ('delete', old.id, old.content, old.category);
-      INSERT INTO memories_fts(rowid, content, category) VALUES (new.id, new.content, new.category);
-    END;
-
-    CREATE TABLE IF NOT EXISTS session_meta (
-      session_id TEXT PRIMARY KEY,
-      last_response_time INTEGER,
-      cache_ttl TEXT,
-      counter INTEGER DEFAULT 0,
-      last_nudge_tokens INTEGER DEFAULT 0,
-      last_nudge_band TEXT DEFAULT '',
-      last_transform_error TEXT DEFAULT '',
-      nudge_anchor_message_id TEXT DEFAULT '',
-      nudge_anchor_text TEXT DEFAULT '',
-      sticky_turn_reminder_text TEXT DEFAULT '',
-      sticky_turn_reminder_message_id TEXT DEFAULT '',
-      is_subagent INTEGER DEFAULT 0,
-      last_context_percentage REAL DEFAULT 0,
-      last_input_tokens INTEGER DEFAULT 0,
-      times_execute_threshold_reached INTEGER DEFAULT 0,
-      compartment_in_progress INTEGER DEFAULT 0,
-      system_prompt_hash TEXT DEFAULT '',
-      memory_block_cache TEXT DEFAULT '',
-      memory_block_count INTEGER DEFAULT 0
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_tags_session_tag_number ON tags(session_id, tag_number);
-    CREATE INDEX IF NOT EXISTS idx_pending_ops_session ON pending_ops(session_id);
-    CREATE INDEX IF NOT EXISTS idx_pending_ops_session_tag_id ON pending_ops(session_id, tag_id);
-    CREATE INDEX IF NOT EXISTS idx_source_contents_session ON source_contents(session_id);
-    
-    CREATE TABLE IF NOT EXISTS recomp_compartments (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      session_id TEXT NOT NULL,
-      sequence INTEGER NOT NULL,
-      start_message INTEGER NOT NULL,
-      end_message INTEGER NOT NULL,
-      start_message_id TEXT DEFAULT '',
-      end_message_id TEXT DEFAULT '',
-      title TEXT NOT NULL,
-      content TEXT NOT NULL,
-      pass_number INTEGER NOT NULL,
-      created_at INTEGER NOT NULL,
-      UNIQUE(session_id, sequence)
-    );
-
-    CREATE TABLE IF NOT EXISTS recomp_facts (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      session_id TEXT NOT NULL,
-      category TEXT NOT NULL,
-      content TEXT NOT NULL,
-      pass_number INTEGER NOT NULL,
-      created_at INTEGER NOT NULL
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_compartments_session ON compartments(session_id);
-    CREATE INDEX IF NOT EXISTS idx_session_facts_session ON session_facts(session_id);
-    CREATE INDEX IF NOT EXISTS idx_recomp_compartments_session ON recomp_compartments(session_id);
-    CREATE INDEX IF NOT EXISTS idx_recomp_facts_session ON recomp_facts(session_id);
-    CREATE INDEX IF NOT EXISTS idx_session_notes_session ON session_notes(session_id);
-    CREATE INDEX IF NOT EXISTS idx_memories_project_status_category ON memories(project_path, status, category);
-    CREATE INDEX IF NOT EXISTS idx_memories_project_status_expires ON memories(project_path, status, expires_at);
-    CREATE INDEX IF NOT EXISTS idx_memories_project_category_hash ON memories(project_path, category, normalized_hash);
-  `);
-  ensureColumn(db, "session_meta", "last_nudge_band", "TEXT DEFAULT ''");
-  ensureColumn(db, "session_meta", "last_transform_error", "TEXT DEFAULT ''");
-  ensureColumn(db, "session_meta", "nudge_anchor_message_id", "TEXT DEFAULT ''");
-  ensureColumn(db, "session_meta", "nudge_anchor_text", "TEXT DEFAULT ''");
-  ensureColumn(db, "session_meta", "sticky_turn_reminder_text", "TEXT DEFAULT ''");
-  ensureColumn(db, "session_meta", "sticky_turn_reminder_message_id", "TEXT DEFAULT ''");
-  ensureColumn(db, "session_meta", "times_execute_threshold_reached", "INTEGER DEFAULT 0");
-  ensureColumn(db, "session_meta", "compartment_in_progress", "INTEGER DEFAULT 0");
-  ensureColumn(db, "session_meta", "system_prompt_hash", "TEXT DEFAULT ''");
-  ensureColumn(db, "compartments", "start_message_id", "TEXT DEFAULT ''");
-  ensureColumn(db, "compartments", "end_message_id", "TEXT DEFAULT ''");
-  ensureColumn(db, "memory_embeddings", "model_id", "TEXT");
-  ensureColumn(db, "session_meta", "memory_block_cache", "TEXT DEFAULT ''");
-  ensureColumn(db, "session_meta", "memory_block_count", "INTEGER DEFAULT 0");
-  ensureColumn(db, "dream_queue", "retry_count", "INTEGER DEFAULT 0");
-}
-function ensureColumn(db, table, column, definition) {
-  if (!/^[a-z_]+$/.test(table) || !/^[a-z_]+$/.test(column) || !/^[A-Z0-9_'(),\s]+$/i.test(definition)) {
-    throw new Error(`Unsafe schema identifier: ${table}.${column} ${definition}`);
-  }
-  const rows = db.prepare(`PRAGMA table_info(${table})`).all();
-  if (rows.some((row) => row.name === column)) {
-    return;
+// src/features/magic-context/dreamer/storage-dream-state.ts
+var getDreamStateStatements = new WeakMap;
+var setDreamStateStatements = new WeakMap;
+var deleteDreamStateStatements = new WeakMap;
+function getGetDreamStateStatement(db) {
+  let stmt = getDreamStateStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("SELECT value FROM dream_state WHERE key = ?");
+    getDreamStateStatements.set(db, stmt);
   }
-  db.run(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+  return stmt;
 }
-function createFallbackDatabase() {
-  try {
-    const fallback = new Database(":memory:");
-    initializeDatabase(fallback);
-    return fallback;
-  } catch (error48) {
-    throw new Error(`[magic-context] storage fatal: failed to initialize fallback database: ${String(error48)}`);
+function getSetDreamStateStatement(db) {
+  let stmt = setDreamStateStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("INSERT INTO dream_state (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value");
+    setDreamStateStatements.set(db, stmt);
   }
+  return stmt;
 }
-function openDatabase() {
-  try {
-    const { dbDir, dbPath } = resolveDatabasePath();
-    const existing = databases.get(dbPath);
-    if (existing) {
-      if (!persistenceByDatabase.has(existing)) {
-        persistenceByDatabase.set(existing, true);
-      }
-      return existing;
-    }
-    mkdirSync(dbDir, { recursive: true });
-    const db = new Database(dbPath);
-    initializeDatabase(db);
-    databases.set(dbPath, db);
-    persistenceByDatabase.set(db, true);
-    persistenceErrorByDatabase.delete(db);
-    return db;
-  } catch (error48) {
-    log("[magic-context] storage error:", error48);
-    const errorMessage = getErrorMessage(error48);
-    const existingFallback = databases.get(FALLBACK_DATABASE_KEY);
-    if (existingFallback) {
-      if (!persistenceByDatabase.has(existingFallback)) {
-        persistenceByDatabase.set(existingFallback, false);
-        persistenceErrorByDatabase.set(existingFallback, errorMessage);
-      }
-      return existingFallback;
-    }
-    const fallback = createFallbackDatabase();
-    databases.set(FALLBACK_DATABASE_KEY, fallback);
-    persistenceByDatabase.set(fallback, false);
-    persistenceErrorByDatabase.set(fallback, errorMessage);
-    return fallback;
+function getDeleteDreamStateStatement(db) {
+  let stmt = deleteDreamStateStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("DELETE FROM dream_state WHERE key = ?");
+    deleteDreamStateStatements.set(db, stmt);
   }
+  return stmt;
 }
-function isDatabasePersisted(db) {
-  return persistenceByDatabase.get(db) ?? false;
-}
-function getDatabasePersistenceError(db) {
-  return persistenceErrorByDatabase.get(db) ?? null;
-}
-// src/features/magic-context/storage-meta-shared.ts
-var META_COLUMNS = {
-  lastResponseTime: "last_response_time",
-  cacheTtl: "cache_ttl",
-  counter: "counter",
-  lastNudgeTokens: "last_nudge_tokens",
-  lastNudgeBand: "last_nudge_band",
-  lastTransformError: "last_transform_error",
-  isSubagent: "is_subagent",
-  lastContextPercentage: "last_context_percentage",
-  lastInputTokens: "last_input_tokens",
-  timesExecuteThresholdReached: "times_execute_threshold_reached",
-  compartmentInProgress: "compartment_in_progress",
-  systemPromptHash: "system_prompt_hash"
-};
-var BOOLEAN_META_KEYS = new Set(["isSubagent", "compartmentInProgress"]);
-function isSessionMetaRow(row) {
-  if (row === null || typeof row !== "object")
-    return false;
-  const r = row;
-  return typeof r.session_id === "string" && typeof r.last_response_time === "number" && typeof r.cache_ttl === "string" && typeof r.counter === "number" && typeof r.last_nudge_tokens === "number" && typeof r.last_nudge_band === "string" && typeof r.last_transform_error === "string" && typeof r.is_subagent === "number" && typeof r.last_context_percentage === "number" && typeof r.last_input_tokens === "number" && typeof r.times_execute_threshold_reached === "number" && typeof r.compartment_in_progress === "number" && (typeof r.system_prompt_hash === "string" || typeof r.system_prompt_hash === "number");
-}
-function getDefaultSessionMeta(sessionId) {
-  return {
-    sessionId,
-    lastResponseTime: 0,
-    cacheTtl: "5m",
-    counter: 0,
-    lastNudgeTokens: 0,
-    lastNudgeBand: null,
-    lastTransformError: null,
-    isSubagent: false,
-    lastContextPercentage: 0,
-    lastInputTokens: 0,
-    timesExecuteThresholdReached: 0,
-    compartmentInProgress: false,
-    systemPromptHash: ""
-  };
+function getDreamState(db, key) {
+  const row = getGetDreamStateStatement(db).get(key);
+  return typeof row?.value === "string" ? row.value : null;
 }
-function ensureSessionMetaRow(db, sessionId) {
-  const defaults = getDefaultSessionMeta(sessionId);
-  db.prepare("INSERT OR IGNORE INTO session_meta (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) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)").run(sessionId, defaults.lastResponseTime, defaults.cacheTtl, defaults.counter, defaults.lastNudgeTokens, defaults.lastNudgeBand ?? "", defaults.lastTransformError ?? "", defaults.isSubagent ? 1 : 0, defaults.lastContextPercentage, defaults.lastInputTokens, defaults.timesExecuteThresholdReached, defaults.compartmentInProgress ? 1 : 0, defaults.systemPromptHash ?? "");
+function setDreamState(db, key, value) {
+  getSetDreamStateStatement(db).run(key, value);
 }
-function toSessionMeta(row) {
-  return {
-    sessionId: row.session_id,
-    lastResponseTime: row.last_response_time,
-    cacheTtl: row.cache_ttl,
-    counter: row.counter,
-    lastNudgeTokens: row.last_nudge_tokens,
-    lastNudgeBand: row.last_nudge_band.length > 0 ? row.last_nudge_band : null,
-    lastTransformError: row.last_transform_error.length > 0 ? row.last_transform_error : null,
-    isSubagent: row.is_subagent === 1,
-    lastContextPercentage: row.last_context_percentage,
-    lastInputTokens: row.last_input_tokens,
-    timesExecuteThresholdReached: row.times_execute_threshold_reached,
-    compartmentInProgress: row.compartment_in_progress === 1,
-    systemPromptHash: String(row.system_prompt_hash)
-  };
+function deleteDreamState(db, key) {
+  getDeleteDreamStateStatement(db).run(key);
 }
 
-// src/features/magic-context/storage-meta-persisted.ts
-function isPersistedUsageRow(row) {
-  if (row === null || typeof row !== "object")
-    return false;
-  const r = row;
-  return typeof r.last_context_percentage === "number" && typeof r.last_input_tokens === "number" && typeof r.last_response_time === "number";
+// src/features/magic-context/dreamer/lease.ts
+var LEASE_HOLDER_KEY = "dreaming_lease_holder";
+var LEASE_HEARTBEAT_KEY = "dreaming_lease_heartbeat";
+var LEASE_EXPIRY_KEY = "dreaming_lease_expiry";
+var LEASE_DURATION_MS = 2 * 60 * 1000;
+function getLeaseExpiry(db) {
+  const value = getDreamState(db, LEASE_EXPIRY_KEY);
+  if (!value) {
+    return null;
+  }
+  const expiry = Number(value);
+  return Number.isFinite(expiry) ? expiry : null;
 }
-function isPersistedNudgePlacementRow(row) {
-  if (row === null || typeof row !== "object")
-    return false;
-  const r = row;
-  return typeof r.nudge_anchor_message_id === "string" && typeof r.nudge_anchor_text === "string";
+function isLeaseActive(db) {
+  const expiry = getLeaseExpiry(db);
+  return expiry !== null && expiry > Date.now();
 }
-function isPersistedStickyTurnReminderRow(row) {
-  if (row === null || typeof row !== "object")
-    return false;
-  const r = row;
-  return typeof r.sticky_turn_reminder_text === "string" && typeof r.sticky_turn_reminder_message_id === "string";
+function getLeaseHolder(db) {
+  return getDreamState(db, LEASE_HOLDER_KEY);
 }
-function loadPersistedUsage(db, sessionId) {
-  const result = db.prepare("SELECT last_context_percentage, last_input_tokens, last_response_time FROM session_meta WHERE session_id = ?").get(sessionId);
-  if (!isPersistedUsageRow(result) || result.last_context_percentage === 0 && result.last_input_tokens === 0) {
-    return null;
-  }
-  return {
-    usage: {
-      percentage: result.last_context_percentage,
-      inputTokens: result.last_input_tokens
-    },
-    updatedAt: result.last_response_time || Date.now()
-  };
+function acquireLease(db, holderId) {
+  return db.transaction(() => {
+    if (isLeaseActive(db)) {
+      const existingHolder = getLeaseHolder(db);
+      if (existingHolder && existingHolder !== holderId) {
+        return false;
+      }
+    }
+    const now = Date.now();
+    setDreamState(db, LEASE_HOLDER_KEY, holderId);
+    setDreamState(db, LEASE_HEARTBEAT_KEY, String(now));
+    setDreamState(db, LEASE_EXPIRY_KEY, String(now + LEASE_DURATION_MS));
+    return true;
+  })();
 }
-function getPersistedNudgePlacement(db, sessionId) {
-  const result = db.prepare("SELECT nudge_anchor_message_id, nudge_anchor_text FROM session_meta WHERE session_id = ?").get(sessionId);
-  if (!isPersistedNudgePlacementRow(result)) {
-    return null;
-  }
-  if (result.nudge_anchor_message_id.length === 0 || result.nudge_anchor_text.length === 0) {
-    return null;
-  }
-  return {
-    messageId: result.nudge_anchor_message_id,
-    nudgeText: result.nudge_anchor_text
-  };
+function renewLease(db, holderId) {
+  return db.transaction(() => {
+    if (getLeaseHolder(db) !== holderId || !isLeaseActive(db)) {
+      return false;
+    }
+    const now = Date.now();
+    setDreamState(db, LEASE_HEARTBEAT_KEY, String(now));
+    setDreamState(db, LEASE_EXPIRY_KEY, String(now + LEASE_DURATION_MS));
+    return true;
+  })();
 }
-function setPersistedNudgePlacement(db, sessionId, messageId, nudgeText) {
+function releaseLease(db, holderId) {
   db.transaction(() => {
-    ensureSessionMetaRow(db, sessionId);
-    db.prepare("UPDATE session_meta SET nudge_anchor_message_id = ?, nudge_anchor_text = ? WHERE session_id = ?").run(messageId, nudgeText, sessionId);
+    if (getLeaseHolder(db) !== holderId) {
+      return;
+    }
+    deleteDreamState(db, LEASE_HOLDER_KEY);
+    deleteDreamState(db, LEASE_HEARTBEAT_KEY);
+    deleteDreamState(db, LEASE_EXPIRY_KEY);
   })();
 }
-function clearPersistedNudgePlacement(db, sessionId) {
-  db.prepare("UPDATE session_meta SET nudge_anchor_message_id = '', nudge_anchor_text = '' WHERE session_id = ?").run(sessionId);
+// src/features/magic-context/dreamer/queue.ts
+function enqueueDream(db, projectIdentity, reason) {
+  const now = Date.now();
+  return db.transaction(() => {
+    const existing = db.query("SELECT id FROM dream_queue WHERE project_path = ?").get(projectIdentity);
+    if (existing) {
+      return null;
+    }
+    const result = db.prepare("INSERT INTO dream_queue (project_path, reason, enqueued_at) VALUES (?, ?, ?)").run(projectIdentity, reason, now);
+    return {
+      id: Number(result.lastInsertRowid),
+      projectIdentity,
+      reason,
+      enqueuedAt: now,
+      startedAt: null
+    };
+  })();
 }
-function getPersistedStickyTurnReminder(db, sessionId) {
-  const result = db.prepare("SELECT sticky_turn_reminder_text, sticky_turn_reminder_message_id FROM session_meta WHERE session_id = ?").get(sessionId);
-  if (!isPersistedStickyTurnReminderRow(result)) {
-    return null;
-  }
-  if (result.sticky_turn_reminder_text.length === 0) {
+function peekQueue(db) {
+  const row = db.query("SELECT id, project_path, reason, enqueued_at FROM dream_queue WHERE started_at IS NULL ORDER BY enqueued_at ASC LIMIT 1").get();
+  if (!row)
     return null;
-  }
   return {
-    text: result.sticky_turn_reminder_text,
-    messageId: result.sticky_turn_reminder_message_id.length > 0 ? result.sticky_turn_reminder_message_id : null
+    id: row.id,
+    projectIdentity: row.project_path,
+    reason: row.reason,
+    enqueuedAt: row.enqueued_at,
+    startedAt: null
   };
 }
-function setPersistedStickyTurnReminder(db, sessionId, text, messageId = "") {
-  db.transaction(() => {
-    ensureSessionMetaRow(db, sessionId);
-    db.prepare("UPDATE session_meta SET sticky_turn_reminder_text = ?, sticky_turn_reminder_message_id = ? WHERE session_id = ?").run(text, messageId, sessionId);
+function dequeueNext(db) {
+  const now = Date.now();
+  return db.transaction(() => {
+    const entry = peekQueue(db);
+    if (!entry)
+      return null;
+    const result = db.prepare("UPDATE dream_queue SET started_at = ? WHERE id = ? AND started_at IS NULL").run(now, entry.id);
+    if (result.changes === 0)
+      return null;
+    return { ...entry, startedAt: now };
   })();
 }
-function clearPersistedStickyTurnReminder(db, sessionId) {
-  db.prepare("UPDATE session_meta SET sticky_turn_reminder_text = '', sticky_turn_reminder_message_id = '' WHERE session_id = ?").run(sessionId);
+function removeDreamEntry(db, id) {
+  db.prepare("DELETE FROM dream_queue WHERE id = ?").run(id);
 }
-// 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 resetDreamEntry(db, id) {
+  db.prepare("UPDATE dream_queue SET started_at = NULL, retry_count = COALESCE(retry_count, 0) + 1 WHERE id = ?").run(id);
 }
-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);
+function getEntryRetryCount(db, id) {
+  const row = db.query("SELECT retry_count FROM dream_queue WHERE id = ?").get(id);
+  return row?.retry_count ?? 0;
+}
+function clearStaleEntries(db, maxAgeMs) {
+  const cutoff = Date.now() - maxAgeMs;
+  const result = db.prepare("DELETE FROM dream_queue WHERE started_at IS NOT NULL AND started_at < ?").run(cutoff);
+  return result.changes;
+}
+// src/features/magic-context/dreamer/runner.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+var dreamProjectDirectories = new Map;
+function registerDreamProjectDirectory(projectIdentity, directory) {
+  dreamProjectDirectories.set(projectIdentity, directory);
+}
+function resolveDreamSessionDirectory(projectIdentity) {
+  return dreamProjectDirectories.get(projectIdentity) ?? projectIdentity;
+}
+async function runDream(args) {
+  const holderId = crypto.randomUUID();
+  const startedAt = Date.now();
+  const result = {
+    startedAt,
+    finishedAt: startedAt,
+    holderId,
+    tasks: []
+  };
+  log(`[dreamer] starting dream run: ${args.tasks.length} tasks, timeout=${args.taskTimeoutMinutes}m, maxRuntime=${args.maxRuntimeMinutes}m, project=${args.projectIdentity}`);
+  if (!acquireLease(args.db, holderId)) {
+    const currentHolder = getLeaseHolder(args.db) ?? "another holder";
+    log(`[dreamer] lease acquisition failed \u2014 already held by ${currentHolder}`);
+    result.tasks.push({
+      name: "lease",
+      durationMs: 0,
+      result: null,
+      error: `Dream lease is already held by ${currentHolder}`
+    });
+    result.finishedAt = Date.now();
+    return result;
+  }
+  log(`[dreamer] lease acquired: ${holderId}`);
+  let parentSessionId = args.parentSessionId;
+  if (!parentSessionId) {
+    try {
+      const sessionDir = args.sessionDirectory ?? args.projectIdentity;
+      const listResponse = await args.client.session.list({
+        query: { directory: sessionDir }
+      });
+      const sessions = normalizeSDKResponse(listResponse, [], {
+        preferResponseOnMissingData: true
+      });
+      parentSessionId = sessions?.find((s) => typeof s?.id === "string")?.id;
+      if (parentSessionId) {
+        log(`[dreamer] resolved parent session: ${parentSessionId}`);
+      }
+    } catch {
+      log("[dreamer] could not resolve parent session \u2014 child sessions will be visible in UI");
+    }
+  }
+  const deadline = startedAt + args.maxRuntimeMinutes * 60 * 1000;
+  const lastDreamAt = getDreamState(args.db, `last_dream_at:${args.projectIdentity}`) ?? getDreamState(args.db, "last_dream_at");
+  log(`[dreamer] last dream at: ${lastDreamAt ?? "never"} (project=${args.projectIdentity})`);
+  try {
+    for (const taskName of args.tasks) {
+      if (Date.now() > deadline) {
+        log(`[dreamer] deadline reached, stopping after ${result.tasks.length} tasks`);
+        break;
+      }
+      log(`[dreamer] starting task: ${taskName}`);
+      const taskStartedAt = Date.now();
+      let agentSessionId = null;
+      const taskAbortController = new AbortController;
+      const leaseRenewalInterval = setInterval(() => {
+        try {
+          if (!renewLease(args.db, holderId)) {
+            log(`[dreamer] task ${taskName}: lease renewal failed \u2014 aborting LLM call`);
+            taskAbortController.abort();
+          }
+        } catch (err) {
+          log(`[dreamer] task ${taskName}: lease renewal threw \u2014 aborting LLM call: ${err}`);
+          taskAbortController.abort();
+        }
+      }, 60000);
+      try {
+        const docsDir = args.sessionDirectory ?? args.projectIdentity;
+        const existingDocs = taskName === "maintain-docs" ? {
+          architecture: existsSync3(join3(docsDir, "ARCHITECTURE.md")),
+          structure: existsSync3(join3(docsDir, "STRUCTURE.md"))
+        } : undefined;
+        const taskPrompt = buildDreamTaskPrompt(taskName, {
+          projectPath: args.projectIdentity,
+          lastDreamAt,
+          existingDocs
+        });
+        const createResponse = await args.client.session.create({
+          body: {
+            ...parentSessionId ? { parentID: parentSessionId } : {},
+            title: `magic-context-dream-${taskName}`
+          },
+          query: { directory: args.sessionDirectory ?? args.projectIdentity }
+        });
+        const createdSession = normalizeSDKResponse(createResponse, null, { preferResponseOnMissingData: true });
+        agentSessionId = typeof createdSession?.id === "string" ? createdSession.id : null;
+        if (!agentSessionId) {
+          throw new Error("Dreamer could not create its child session.");
+        }
+        log(`[dreamer] task ${taskName}: child session created ${agentSessionId}`);
+        await promptSyncWithModelSuggestionRetry(args.client, {
+          path: { id: agentSessionId },
+          query: { directory: args.sessionDirectory ?? args.projectIdentity },
+          body: {
+            agent: DREAMER_AGENT,
+            system: DREAMER_SYSTEM_PROMPT,
+            parts: [{ type: "text", text: taskPrompt }]
+          }
+        }, {
+          timeoutMs: args.taskTimeoutMinutes * 60 * 1000,
+          signal: taskAbortController.signal
+        });
+        const messagesResponse = await args.client.session.messages({
+          path: { id: agentSessionId },
+          query: { directory: args.sessionDirectory ?? args.projectIdentity }
+        });
+        const messages = normalizeSDKResponse(messagesResponse, [], {
+          preferResponseOnMissingData: true
+        });
+        const taskResult = extractLatestAssistantText(messages);
+        if (!taskResult) {
+          throw new Error("Dreamer returned no assistant output.");
+        }
+        const durationMs = Date.now() - taskStartedAt;
+        log(`[dreamer] task ${taskName}: completed in ${(durationMs / 1000).toFixed(1)}s (result: ${String(taskResult).length} chars)`);
+        result.tasks.push({
+          name: taskName,
+          durationMs,
+          result: taskResult
+        });
+      } catch (error48) {
+        const durationMs = Date.now() - taskStartedAt;
+        const errorMsg = getErrorMessage(error48);
+        log(`[dreamer] task ${taskName}: failed after ${(durationMs / 1000).toFixed(1)}s \u2014 ${errorMsg}`);
+        result.tasks.push({
+          name: taskName,
+          durationMs,
+          result: null,
+          error: errorMsg
+        });
+      } finally {
+        clearInterval(leaseRenewalInterval);
+        if (agentSessionId) {
+          await args.client.session.delete({
+            path: { id: agentSessionId },
+            query: { directory: args.sessionDirectory ?? args.projectIdentity }
+          }).catch((error48) => {
+            log("[dreamer] failed to delete child session:", error48);
+          });
+        }
+      }
     }
+  } finally {
+    releaseLease(args.db, holderId);
+    log(`[dreamer] lease released: ${holderId}`);
   }
-  if (setClauses.length === 0) {
-    return;
+  result.finishedAt = Date.now();
+  const hasSuccessfulTask = result.tasks.some((t) => !t.error);
+  if (hasSuccessfulTask) {
+    setDreamState(args.db, `last_dream_at:${args.projectIdentity}`, String(result.finishedAt));
+    setDreamState(args.db, "last_dream_at", String(result.finishedAt));
   }
-  db.transaction(() => {
-    ensureSessionMetaRow(db, sessionId);
-    db.prepare(`UPDATE session_meta SET ${setClauses.join(", ")} WHERE session_id = ?`).run(...values, sessionId);
-  })();
-}
-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);
-  })();
-}
-// 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 toSessionNote(row) {
-  return {
-    id: row.id,
-    sessionId: row.session_id,
-    content: row.content,
-    createdAt: row.created_at
-  };
-}
-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 addSessionNote(db, sessionId, content) {
-  db.prepare("INSERT INTO session_notes (session_id, content, created_at) VALUES (?, ?, ?)").run(sessionId, content, Date.now());
-}
-function clearSessionNotes(db, sessionId) {
-  db.prepare("DELETE FROM session_notes WHERE session_id = ?").run(sessionId);
-}
-// 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";
+  const totalDuration = ((result.finishedAt - startedAt) / 1000).toFixed(1);
+  const succeeded = result.tasks.filter((t) => !t.error).length;
+  const failed = result.tasks.filter((t) => t.error).length;
+  log(`[dreamer] dream run finished in ${totalDuration}s: ${succeeded} succeeded, ${failed} failed`);
+  return result;
 }
-function toPendingOp(row) {
-  if (row.operation !== "drop") {
-    sessionLog(row.session_id, `unknown pending operation "${row.operation}"; ignoring`);
+var MAX_LEASE_RETRIES = 3;
+async function processDreamQueue(args) {
+  clearStaleEntries(args.db, 2 * 60 * 60 * 1000);
+  const entry = dequeueNext(args.db);
+  if (!entry) {
     return null;
   }
-  return {
-    id: row.id,
-    sessionId: row.session_id,
-    tagId: row.tag_id,
-    operation: row.operation,
-    queuedAt: row.queued_at
-  };
-}
-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);
-}
-// 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 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 projectDirectory = resolveDreamSessionDirectory(entry.projectIdentity);
+  log(`[dreamer] dequeued project ${entry.projectIdentity} (dir=${projectDirectory}), starting dream run`);
+  let result;
+  try {
+    result = await runDream({
+      db: args.db,
+      client: args.client,
+      projectIdentity: entry.projectIdentity,
+      tasks: args.tasks,
+      taskTimeoutMinutes: args.taskTimeoutMinutes,
+      maxRuntimeMinutes: args.maxRuntimeMinutes,
+      sessionDirectory: projectDirectory
+    });
+  } catch (error48) {
+    log(`[dreamer] runDream threw for ${entry.projectIdentity}: ${getErrorMessage(error48)}`);
+    removeDreamEntry(args.db, entry.id);
+    return null;
   }
-  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);
+  const leaseError = result.tasks.find((t) => t.name === "lease" && t.error);
+  if (leaseError) {
+    const retryCount = getEntryRetryCount(args.db, entry.id);
+    if (retryCount >= MAX_LEASE_RETRIES) {
+      log(`[dreamer] lease acquisition failed ${retryCount + 1} times for ${entry.projectIdentity} \u2014 removing queue entry`);
+      removeDreamEntry(args.db, entry.id);
+    } else {
+      log(`[dreamer] lease acquisition failed for ${entry.projectIdentity} (attempt ${retryCount + 1}/${MAX_LEASE_RETRIES}) \u2014 keeping for retry`);
+      resetDreamEntry(args.db, entry.id);
+    }
+  } else {
+    removeDreamEntry(args.db, entry.id);
   }
-  return sources;
+  return result;
 }
-// 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);
+// src/features/magic-context/dreamer/scheduler.ts
+function parseScheduleWindow(schedule) {
+  const match = /^(\d{1,2}):(\d{2})-(\d{1,2}):(\d{2})$/.exec(schedule.trim());
+  if (!match)
+    return null;
+  const startHour = Number(match[1]);
+  const startMin = Number(match[2]);
+  const endHour = Number(match[3]);
+  const endMin = Number(match[4]);
+  if (startHour >= 24 || startMin >= 60 || endHour >= 24 || endMin >= 60) {
+    return null;
   }
-  return stmt;
+  const startMinutes = startHour * 60 + startMin;
+  const endMinutes = endHour * 60 + endMin;
+  return { startMinutes, endMinutes };
 }
-function isTagRow(row) {
-  if (row === null || typeof row !== "object")
+function isInScheduleWindow(schedule, now = new Date) {
+  const window = parseScheduleWindow(schedule);
+  if (!window)
     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";
-}
-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 insertTag(db, sessionId, messageId, type, byteSize, tagNumber) {
-  getInsertTagStatement(db).run(sessionId, messageId, type, byteSize, tagNumber);
-  return tagNumber;
-}
-function updateTagStatus(db, sessionId, tagId, status) {
-  db.prepare("UPDATE tags SET status = ? WHERE session_id = ? AND tag_number = ?").run(status, sessionId, tagId);
-}
-function updateTagMessageId(db, sessionId, tagId, messageId) {
-  db.prepare("UPDATE tags SET message_id = ? WHERE session_id = ? AND tag_number = ?").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 [];
-  }
-  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/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 });
-    }
-  };
-}
-
-// src/hooks/is-anthropic-provider.ts
-function isAnthropicProvider(providerID) {
-  return providerID === "anthropic" || providerID === "google-vertex-anthropic";
-}
-
-// 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;
+  const currentMinutes = now.getHours() * 60 + now.getMinutes();
+  if (window.startMinutes <= window.endMinutes) {
+    return currentMinutes >= window.startMinutes && currentMinutes < window.endMinutes;
   }
-  return DEFAULT_CONTEXT_LIMIT;
+  return currentMinutes >= window.startMinutes || currentMinutes < window.endMinutes;
 }
-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];
+function findProjectsNeedingDream(db) {
+  const projectRows = db.query(`SELECT DISTINCT project_path FROM memories WHERE status = 'active' ORDER BY project_path`).all();
+  const projects = [];
+  for (const row of projectRows) {
+    const lastDreamAtStr = getDreamState(db, `last_dream_at:${row.project_path}`);
+    const fallbackStr = !lastDreamAtStr ? getDreamState(db, "last_dream_at") : null;
+    const lastDreamAt = Number(lastDreamAtStr ?? fallbackStr ?? "0") || 0;
+    const updated = db.query(`SELECT COUNT(*) as cnt FROM memories
+                 WHERE project_path = ? AND status = 'active' AND updated_at > ?`).get(row.project_path, lastDreamAt);
+    if (updated && updated.cnt > 0) {
+      projects.push(row.project_path);
     }
   }
-  return cacheTtl.default ?? "5m";
+  return projects;
 }
-function resolveExecuteThreshold(config2, modelKey, fallback) {
-  if (typeof config2 === "number") {
-    return config2;
+function checkScheduleAndEnqueue(db, schedule) {
+  if (!isInScheduleWindow(schedule)) {
+    return 0;
   }
-  if (modelKey && typeof config2[modelKey] === "number") {
-    return config2[modelKey];
+  const projects = findProjectsNeedingDream(db);
+  if (projects.length === 0) {
+    return 0;
   }
-  if (modelKey) {
-    const bareModelId = modelKey.split("/").slice(1).join("/");
-    if (bareModelId && typeof config2[bareModelId] === "number") {
-      return config2[bareModelId];
+  let enqueued = 0;
+  for (const projectIdentity of projects) {
+    const entry = enqueueDream(db, projectIdentity, "scheduled");
+    if (entry) {
+      log(`[dreamer] enqueued project for scheduled dream: ${projectIdentity}`);
+      enqueued++;
     }
   }
-  return config2.default ?? fallback;
+  return enqueued;
 }
-function resolveModelKey(providerID, modelID) {
-  if (!providerID || !modelID) {
-    return;
-  }
-  return `${providerID}/${modelID}`;
+// src/features/magic-context/storage-db.ts
+import { Database } from "bun:sqlite";
+import { mkdirSync } from "fs";
+import { join as join5 } from "path";
+
+// src/shared/data-path.ts
+import * as os2 from "os";
+import * as path2 from "path";
+function getDataDir() {
+  return process.env.XDG_DATA_HOME ?? path2.join(os2.homedir(), ".local", "share");
+}
+function getOpenCodeStorageDir() {
+  return path2.join(getDataDir(), "opencode", "storage");
+}
+
+// src/features/magic-context/storage-db.ts
+var databases = new Map;
+var FALLBACK_DATABASE_KEY = "__fallback__:memory:";
+var persistenceByDatabase = new WeakMap;
+var persistenceErrorByDatabase = new WeakMap;
+function resolveDatabasePath() {
+  const dbDir = join5(getOpenCodeStorageDir(), "plugin", "magic-context");
+  return { dbDir, dbPath: join5(dbDir, "context.db") };
+}
+function initializeDatabase(db) {
+  db.run("PRAGMA journal_mode=WAL");
+  db.run("PRAGMA busy_timeout=5000");
+  db.run("PRAGMA foreign_keys=ON");
+  db.run(`
+    CREATE TABLE IF NOT EXISTS tags (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT,
+      message_id TEXT,
+      type TEXT,
+      status TEXT DEFAULT 'active',
+      byte_size INTEGER,
+      tag_number INTEGER,
+      UNIQUE(session_id, tag_number)
+    );
+
+    CREATE TABLE IF NOT EXISTS pending_ops (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT,
+      tag_id INTEGER,
+      operation TEXT,
+      queued_at INTEGER
+    );
+
+    CREATE TABLE IF NOT EXISTS source_contents (
+      tag_id INTEGER,
+      session_id TEXT,
+      content TEXT,
+      created_at INTEGER,
+      PRIMARY KEY(session_id, tag_id)
+    );
+
+    CREATE TABLE IF NOT EXISTS compartments (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      sequence INTEGER NOT NULL,
+      start_message INTEGER NOT NULL,
+      end_message INTEGER NOT NULL,
+      start_message_id TEXT DEFAULT '',
+      end_message_id TEXT DEFAULT '',
+      title TEXT NOT NULL,
+      content TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      UNIQUE(session_id, sequence)
+    );
+
+    CREATE TABLE IF NOT EXISTS session_facts (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      category TEXT NOT NULL,
+      content TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS session_notes (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      content TEXT NOT NULL,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS memories (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      project_path TEXT NOT NULL,
+      category TEXT NOT NULL,
+      content TEXT NOT NULL,
+      normalized_hash TEXT NOT NULL,
+      source_session_id TEXT,
+      source_type TEXT DEFAULT 'historian',
+      seen_count INTEGER DEFAULT 1,
+      retrieval_count INTEGER DEFAULT 0,
+      first_seen_at INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      last_seen_at INTEGER NOT NULL,
+      last_retrieved_at INTEGER,
+      status TEXT DEFAULT 'active',
+      expires_at INTEGER,
+      verification_status TEXT DEFAULT 'unverified',
+      verified_at INTEGER,
+      superseded_by_memory_id INTEGER,
+      merged_from TEXT,
+      metadata_json TEXT,
+      UNIQUE(project_path, category, normalized_hash)
+    );
+
+    CREATE TABLE IF NOT EXISTS memory_embeddings (
+      memory_id INTEGER PRIMARY KEY REFERENCES memories(id) ON DELETE CASCADE,
+      embedding BLOB NOT NULL,
+      model_id TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS dream_state (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS dream_queue (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      project_path TEXT NOT NULL,
+      reason TEXT NOT NULL,
+      enqueued_at INTEGER NOT NULL,
+      started_at INTEGER,
+      retry_count INTEGER DEFAULT 0
+    );
+    CREATE INDEX IF NOT EXISTS idx_dream_queue_project ON dream_queue(project_path);
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+      content,
+      category,
+      content='memories',
+      content_rowid='id',
+      tokenize='porter unicode61'
+    );
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS message_history_fts USING fts5(
+      session_id UNINDEXED,
+      message_ordinal UNINDEXED,
+      message_id UNINDEXED,
+      role,
+      content,
+      tokenize='porter unicode61'
+    );
+
+    CREATE TABLE IF NOT EXISTS message_history_index (
+      session_id TEXT PRIMARY KEY,
+      last_indexed_ordinal INTEGER NOT NULL DEFAULT 0,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
+      INSERT INTO memories_fts(rowid, content, category) VALUES (new.id, new.content, new.category);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
+      INSERT INTO memories_fts(memories_fts, rowid, content, category) VALUES ('delete', old.id, old.content, old.category);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
+      INSERT INTO memories_fts(memories_fts, rowid, content, category) VALUES ('delete', old.id, old.content, old.category);
+      INSERT INTO memories_fts(rowid, content, category) VALUES (new.id, new.content, new.category);
+    END;
+
+    CREATE TABLE IF NOT EXISTS session_meta (
+      session_id TEXT PRIMARY KEY,
+      last_response_time INTEGER,
+      cache_ttl TEXT,
+      counter INTEGER DEFAULT 0,
+      last_nudge_tokens INTEGER DEFAULT 0,
+      last_nudge_band TEXT DEFAULT '',
+      last_transform_error TEXT DEFAULT '',
+      nudge_anchor_message_id TEXT DEFAULT '',
+      nudge_anchor_text TEXT DEFAULT '',
+      sticky_turn_reminder_text TEXT DEFAULT '',
+      sticky_turn_reminder_message_id TEXT DEFAULT '',
+      is_subagent INTEGER DEFAULT 0,
+      last_context_percentage REAL DEFAULT 0,
+      last_input_tokens INTEGER DEFAULT 0,
+      times_execute_threshold_reached INTEGER DEFAULT 0,
+      compartment_in_progress INTEGER DEFAULT 0,
+      system_prompt_hash TEXT DEFAULT '',
+      memory_block_cache TEXT DEFAULT '',
+      memory_block_count INTEGER DEFAULT 0
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_tags_session_tag_number ON tags(session_id, tag_number);
+    CREATE INDEX IF NOT EXISTS idx_pending_ops_session ON pending_ops(session_id);
+    CREATE INDEX IF NOT EXISTS idx_pending_ops_session_tag_id ON pending_ops(session_id, tag_id);
+    CREATE INDEX IF NOT EXISTS idx_source_contents_session ON source_contents(session_id);
+    
+    CREATE TABLE IF NOT EXISTS recomp_compartments (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      sequence INTEGER NOT NULL,
+      start_message INTEGER NOT NULL,
+      end_message INTEGER NOT NULL,
+      start_message_id TEXT DEFAULT '',
+      end_message_id TEXT DEFAULT '',
+      title TEXT NOT NULL,
+      content TEXT NOT NULL,
+      pass_number INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      UNIQUE(session_id, sequence)
+    );
+
+    CREATE TABLE IF NOT EXISTS recomp_facts (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      category TEXT NOT NULL,
+      content TEXT NOT NULL,
+      pass_number INTEGER NOT NULL,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_compartments_session ON compartments(session_id);
+    CREATE INDEX IF NOT EXISTS idx_session_facts_session ON session_facts(session_id);
+    CREATE INDEX IF NOT EXISTS idx_recomp_compartments_session ON recomp_compartments(session_id);
+    CREATE INDEX IF NOT EXISTS idx_recomp_facts_session ON recomp_facts(session_id);
+    CREATE INDEX IF NOT EXISTS idx_session_notes_session ON session_notes(session_id);
+    CREATE INDEX IF NOT EXISTS idx_memories_project_status_category ON memories(project_path, status, category);
+    CREATE INDEX IF NOT EXISTS idx_memories_project_status_expires ON memories(project_path, status, expires_at);
+    CREATE INDEX IF NOT EXISTS idx_memories_project_category_hash ON memories(project_path, category, normalized_hash);
+    CREATE INDEX IF NOT EXISTS idx_message_history_index_updated_at ON message_history_index(updated_at);
+  `);
+  ensureColumn(db, "session_meta", "last_nudge_band", "TEXT DEFAULT ''");
+  ensureColumn(db, "session_meta", "last_transform_error", "TEXT DEFAULT ''");
+  ensureColumn(db, "session_meta", "nudge_anchor_message_id", "TEXT DEFAULT ''");
+  ensureColumn(db, "session_meta", "nudge_anchor_text", "TEXT DEFAULT ''");
+  ensureColumn(db, "session_meta", "sticky_turn_reminder_text", "TEXT DEFAULT ''");
+  ensureColumn(db, "session_meta", "sticky_turn_reminder_message_id", "TEXT DEFAULT ''");
+  ensureColumn(db, "session_meta", "times_execute_threshold_reached", "INTEGER DEFAULT 0");
+  ensureColumn(db, "session_meta", "compartment_in_progress", "INTEGER DEFAULT 0");
+  ensureColumn(db, "session_meta", "system_prompt_hash", "TEXT DEFAULT ''");
+  ensureColumn(db, "compartments", "start_message_id", "TEXT DEFAULT ''");
+  ensureColumn(db, "compartments", "end_message_id", "TEXT DEFAULT ''");
+  ensureColumn(db, "memory_embeddings", "model_id", "TEXT");
+  ensureColumn(db, "session_meta", "memory_block_cache", "TEXT DEFAULT ''");
+  ensureColumn(db, "session_meta", "memory_block_count", "INTEGER DEFAULT 0");
+  ensureColumn(db, "dream_queue", "retry_count", "INTEGER DEFAULT 0");
 }
-function resolveSessionId(properties) {
-  if (typeof properties?.sessionID === "string") {
-    return properties.sessionID;
+function ensureColumn(db, table, column, definition) {
+  if (!/^[a-z_]+$/.test(table) || !/^[a-z_]+$/.test(column) || !/^[A-Z0-9_'(),\s]+$/i.test(definition)) {
+    throw new Error(`Unsafe schema identifier: ${table}.${column} ${definition}`);
   }
-  const info = properties?.info;
-  if (info === null || typeof info !== "object") {
+  const rows = db.prepare(`PRAGMA table_info(${table})`).all();
+  if (rows.some((row) => row.name === column)) {
     return;
   }
-  const record2 = info;
-  if (typeof record2.sessionID === "string") {
-    return record2.sessionID;
-  }
-  if (typeof record2.id === "string") {
-    return record2.id;
-  }
-  return;
+  db.run(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
 }
-
-// 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}`);
+function createFallbackDatabase() {
+  try {
+    const fallback = new Database(":memory:");
+    initializeDatabase(fallback);
+    return fallback;
+  } catch (error48) {
+    throw new Error(`[magic-context] storage fatal: failed to initialize fallback database: ${String(error48)}`);
   }
-  const value = Number(match[1]);
-  const unit = match[2];
-  return value * UNIT_TO_MS[unit];
 }
-function createScheduler(config2) {
-  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";
+function openDatabase() {
+  try {
+    const { dbDir, dbPath } = resolveDatabasePath();
+    const existing = databases.get(dbPath);
+    if (existing) {
+      if (!persistenceByDatabase.has(existing)) {
+        persistenceByDatabase.set(existing, true);
       }
-      return "defer";
-    }
-  };
-}
-
-// 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";
-}
-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, 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;
-  }
-  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;
+    mkdirSync(dbDir, { recursive: true });
+    const db = new Database(dbPath);
+    initializeDatabase(db);
+    databases.set(dbPath, db);
+    persistenceByDatabase.set(db, true);
+    persistenceErrorByDatabase.delete(db);
+    return db;
+  } catch (error48) {
+    log("[magic-context] storage error:", error48);
+    const errorMessage = getErrorMessage(error48);
+    const existingFallback = databases.get(FALLBACK_DATABASE_KEY);
+    if (existingFallback) {
+      if (!persistenceByDatabase.has(existingFallback)) {
+        persistenceByDatabase.set(existingFallback, false);
+        persistenceErrorByDatabase.set(existingFallback, errorMessage);
       }
+      return existingFallback;
     }
-    const counter = Math.max(row?.counter ?? 0, maxTagNumber);
-    counters.set(sessionId, counter);
-  }
-  function cleanup(sessionId) {
-    counters.delete(sessionId);
-    assignments.delete(sessionId);
+    const fallback = createFallbackDatabase();
+    databases.set(FALLBACK_DATABASE_KEY, fallback);
+    persistenceByDatabase.set(fallback, false);
+    persistenceErrorByDatabase.set(fallback, errorMessage);
+    return fallback;
   }
+}
+function isDatabasePersisted(db) {
+  return persistenceByDatabase.get(db) ?? false;
+}
+function getDatabasePersistenceError(db) {
+  return persistenceErrorByDatabase.get(db) ?? null;
+}
+// src/features/magic-context/storage-meta-shared.ts
+var META_COLUMNS = {
+  lastResponseTime: "last_response_time",
+  cacheTtl: "cache_ttl",
+  counter: "counter",
+  lastNudgeTokens: "last_nudge_tokens",
+  lastNudgeBand: "last_nudge_band",
+  lastTransformError: "last_transform_error",
+  isSubagent: "is_subagent",
+  lastContextPercentage: "last_context_percentage",
+  lastInputTokens: "last_input_tokens",
+  timesExecuteThresholdReached: "times_execute_threshold_reached",
+  compartmentInProgress: "compartment_in_progress",
+  systemPromptHash: "system_prompt_hash"
+};
+var BOOLEAN_META_KEYS = new Set(["isSubagent", "compartmentInProgress"]);
+function isSessionMetaRow(row) {
+  if (row === null || typeof row !== "object")
+    return false;
+  const r = row;
+  return typeof r.session_id === "string" && typeof r.last_response_time === "number" && typeof r.cache_ttl === "string" && typeof r.counter === "number" && typeof r.last_nudge_tokens === "number" && typeof r.last_nudge_band === "string" && typeof r.last_transform_error === "string" && typeof r.is_subagent === "number" && typeof r.last_context_percentage === "number" && typeof r.last_input_tokens === "number" && typeof r.times_execute_threshold_reached === "number" && typeof r.compartment_in_progress === "number" && (typeof r.system_prompt_hash === "string" || typeof r.system_prompt_hash === "number");
+}
+function getDefaultSessionMeta(sessionId) {
   return {
-    assignTag,
-    getTag,
-    bindTag,
-    getAssignments,
-    resetCounter,
-    getCounter,
-    initFromDb,
-    cleanup
+    sessionId,
+    lastResponseTime: 0,
+    cacheTtl: "5m",
+    counter: 0,
+    lastNudgeTokens: 0,
+    lastNudgeBand: null,
+    lastTransformError: null,
+    isSubagent: false,
+    lastContextPercentage: 0,
+    lastInputTokens: 0,
+    timesExecuteThresholdReached: 0,
+    compartmentInProgress: false,
+    systemPromptHash: ""
+  };
+}
+function ensureSessionMetaRow(db, sessionId) {
+  const defaults = getDefaultSessionMeta(sessionId);
+  db.prepare("INSERT OR IGNORE INTO session_meta (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) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)").run(sessionId, defaults.lastResponseTime, defaults.cacheTtl, defaults.counter, defaults.lastNudgeTokens, defaults.lastNudgeBand ?? "", defaults.lastTransformError ?? "", defaults.isSubagent ? 1 : 0, defaults.lastContextPercentage, defaults.lastInputTokens, defaults.timesExecuteThresholdReached, defaults.compartmentInProgress ? 1 : 0, defaults.systemPromptHash ?? "");
+}
+function toSessionMeta(row) {
+  return {
+    sessionId: row.session_id,
+    lastResponseTime: row.last_response_time,
+    cacheTtl: row.cache_ttl,
+    counter: row.counter,
+    lastNudgeTokens: row.last_nudge_tokens,
+    lastNudgeBand: row.last_nudge_band.length > 0 ? row.last_nudge_band : null,
+    lastTransformError: row.last_transform_error.length > 0 ? row.last_transform_error : null,
+    isSubagent: row.is_subagent === 1,
+    lastContextPercentage: row.last_context_percentage,
+    lastInputTokens: row.last_input_tokens,
+    timesExecuteThresholdReached: row.times_execute_threshold_reached,
+    compartmentInProgress: row.compartment_in_progress === 1,
+    systemPromptHash: String(row.system_prompt_hash)
   };
 }
 
-// src/features/magic-context/dreamer/storage-dream-state.ts
-var getDreamStateStatements = new WeakMap;
-var setDreamStateStatements = new WeakMap;
-var deleteDreamStateStatements = new WeakMap;
-function getGetDreamStateStatement(db) {
-  let stmt = getDreamStateStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("SELECT value FROM dream_state WHERE key = ?");
-    getDreamStateStatements.set(db, stmt);
-  }
-  return stmt;
+// src/features/magic-context/storage-meta-persisted.ts
+function isPersistedUsageRow(row) {
+  if (row === null || typeof row !== "object")
+    return false;
+  const r = row;
+  return typeof r.last_context_percentage === "number" && typeof r.last_input_tokens === "number" && typeof r.last_response_time === "number";
 }
-function getSetDreamStateStatement(db) {
-  let stmt = setDreamStateStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("INSERT INTO dream_state (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value");
-    setDreamStateStatements.set(db, stmt);
-  }
-  return stmt;
+function isPersistedNudgePlacementRow(row) {
+  if (row === null || typeof row !== "object")
+    return false;
+  const r = row;
+  return typeof r.nudge_anchor_message_id === "string" && typeof r.nudge_anchor_text === "string";
 }
-function getDeleteDreamStateStatement(db) {
-  let stmt = deleteDreamStateStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("DELETE FROM dream_state WHERE key = ?");
-    deleteDreamStateStatements.set(db, stmt);
+function isPersistedStickyTurnReminderRow(row) {
+  if (row === null || typeof row !== "object")
+    return false;
+  const r = row;
+  return typeof r.sticky_turn_reminder_text === "string" && typeof r.sticky_turn_reminder_message_id === "string";
+}
+function loadPersistedUsage(db, sessionId) {
+  const result = db.prepare("SELECT last_context_percentage, last_input_tokens, last_response_time FROM session_meta WHERE session_id = ?").get(sessionId);
+  if (!isPersistedUsageRow(result) || result.last_context_percentage === 0 && result.last_input_tokens === 0) {
+    return null;
   }
-  return stmt;
+  return {
+    usage: {
+      percentage: result.last_context_percentage,
+      inputTokens: result.last_input_tokens
+    },
+    updatedAt: result.last_response_time || Date.now()
+  };
 }
-function getDreamState(db, key) {
-  const row = getGetDreamStateStatement(db).get(key);
-  return typeof row?.value === "string" ? row.value : null;
+function getPersistedNudgePlacement(db, sessionId) {
+  const result = db.prepare("SELECT nudge_anchor_message_id, nudge_anchor_text FROM session_meta WHERE session_id = ?").get(sessionId);
+  if (!isPersistedNudgePlacementRow(result)) {
+    return null;
+  }
+  if (result.nudge_anchor_message_id.length === 0 || result.nudge_anchor_text.length === 0) {
+    return null;
+  }
+  return {
+    messageId: result.nudge_anchor_message_id,
+    nudgeText: result.nudge_anchor_text
+  };
 }
-function setDreamState(db, key, value) {
-  getSetDreamStateStatement(db).run(key, value);
+function setPersistedNudgePlacement(db, sessionId, messageId, nudgeText) {
+  db.transaction(() => {
+    ensureSessionMetaRow(db, sessionId);
+    db.prepare("UPDATE session_meta SET nudge_anchor_message_id = ?, nudge_anchor_text = ? WHERE session_id = ?").run(messageId, nudgeText, sessionId);
+  })();
 }
-function deleteDreamState(db, key) {
-  getDeleteDreamStateStatement(db).run(key);
+function clearPersistedNudgePlacement(db, sessionId) {
+  db.prepare("UPDATE session_meta SET nudge_anchor_message_id = '', nudge_anchor_text = '' WHERE session_id = ?").run(sessionId);
 }
-
-// src/features/magic-context/dreamer/lease.ts
-var LEASE_HOLDER_KEY = "dreaming_lease_holder";
-var LEASE_HEARTBEAT_KEY = "dreaming_lease_heartbeat";
-var LEASE_EXPIRY_KEY = "dreaming_lease_expiry";
-var LEASE_DURATION_MS = 2 * 60 * 1000;
-function getLeaseExpiry(db) {
-  const value = getDreamState(db, LEASE_EXPIRY_KEY);
-  if (!value) {
+function getPersistedStickyTurnReminder(db, sessionId) {
+  const result = db.prepare("SELECT sticky_turn_reminder_text, sticky_turn_reminder_message_id FROM session_meta WHERE session_id = ?").get(sessionId);
+  if (!isPersistedStickyTurnReminderRow(result)) {
     return null;
   }
-  const expiry = Number(value);
-  return Number.isFinite(expiry) ? expiry : null;
+  if (result.sticky_turn_reminder_text.length === 0) {
+    return null;
+  }
+  return {
+    text: result.sticky_turn_reminder_text,
+    messageId: result.sticky_turn_reminder_message_id.length > 0 ? result.sticky_turn_reminder_message_id : null
+  };
 }
-function isLeaseActive(db) {
-  const expiry = getLeaseExpiry(db);
-  return expiry !== null && expiry > Date.now();
+function setPersistedStickyTurnReminder(db, sessionId, text, messageId = "") {
+  db.transaction(() => {
+    ensureSessionMetaRow(db, sessionId);
+    db.prepare("UPDATE session_meta SET sticky_turn_reminder_text = ?, sticky_turn_reminder_message_id = ? WHERE session_id = ?").run(text, messageId, sessionId);
+  })();
 }
-function getLeaseHolder(db) {
-  return getDreamState(db, LEASE_HOLDER_KEY);
+function clearPersistedStickyTurnReminder(db, sessionId) {
+  db.prepare("UPDATE session_meta SET sticky_turn_reminder_text = '', sticky_turn_reminder_message_id = '' WHERE session_id = ?").run(sessionId);
 }
-function acquireLease(db, holderId) {
-  return db.transaction(() => {
-    if (isLeaseActive(db)) {
-      const existingHolder = getLeaseHolder(db);
-      if (existingHolder && existingHolder !== holderId) {
-        return false;
-      }
-    }
-    const now = Date.now();
-    setDreamState(db, LEASE_HOLDER_KEY, holderId);
-    setDreamState(db, LEASE_HEARTBEAT_KEY, String(now));
-    setDreamState(db, LEASE_EXPIRY_KEY, String(now + LEASE_DURATION_MS));
-    return true;
-  })();
+// 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 renewLease(db, holderId) {
-  return db.transaction(() => {
-    if (getLeaseHolder(db) !== holderId || !isLeaseActive(db)) {
-      return false;
+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);
     }
-    const now = Date.now();
-    setDreamState(db, LEASE_HEARTBEAT_KEY, String(now));
-    setDreamState(db, LEASE_EXPIRY_KEY, String(now + LEASE_DURATION_MS));
-    return true;
+  }
+  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 releaseLease(db, holderId) {
+function clearSession(db, sessionId) {
   db.transaction(() => {
-    if (getLeaseHolder(db) !== holderId) {
-      return;
-    }
-    deleteDreamState(db, LEASE_HOLDER_KEY);
-    deleteDreamState(db, LEASE_HEARTBEAT_KEY);
-    deleteDreamState(db, LEASE_EXPIRY_KEY);
+    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);
   })();
 }
-// src/features/magic-context/dreamer/queue.ts
-function enqueueDream(db, projectIdentity, reason) {
-  const now = Date.now();
-  return db.transaction(() => {
-    const existing = db.query("SELECT id FROM dream_queue WHERE project_path = ?").get(projectIdentity);
-    if (existing) {
-      return null;
-    }
-    const result = db.prepare("INSERT INTO dream_queue (project_path, reason, enqueued_at) VALUES (?, ?, ?)").run(projectIdentity, reason, now);
-    return {
-      id: Number(result.lastInsertRowid),
-      projectIdentity,
-      reason,
-      enqueuedAt: now,
-      startedAt: null
-    };
-  })();
+// 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 peekQueue(db) {
-  const row = db.query("SELECT id, project_path, reason, enqueued_at FROM dream_queue WHERE started_at IS NULL ORDER BY enqueued_at ASC LIMIT 1").get();
-  if (!row)
+function toSessionNote(row) {
+  return {
+    id: row.id,
+    sessionId: row.session_id,
+    content: row.content,
+    createdAt: row.created_at
+  };
+}
+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 addSessionNote(db, sessionId, content) {
+  db.prepare("INSERT INTO session_notes (session_id, content, created_at) VALUES (?, ?, ?)").run(sessionId, content, Date.now());
+}
+function clearSessionNotes(db, sessionId) {
+  db.prepare("DELETE FROM session_notes WHERE session_id = ?").run(sessionId);
+}
+// 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 toPendingOp(row) {
+  if (row.operation !== "drop") {
+    sessionLog(row.session_id, `unknown pending operation "${row.operation}"; ignoring`);
     return null;
+  }
   return {
     id: row.id,
-    projectIdentity: row.project_path,
-    reason: row.reason,
-    enqueuedAt: row.enqueued_at,
-    startedAt: null
+    sessionId: row.session_id,
+    tagId: row.tag_id,
+    operation: row.operation,
+    queuedAt: row.queued_at
   };
 }
-function dequeueNext(db) {
-  const now = Date.now();
-  return db.transaction(() => {
-    const entry = peekQueue(db);
-    if (!entry)
-      return null;
-    const result = db.prepare("UPDATE dream_queue SET started_at = ? WHERE id = ? AND started_at IS NULL").run(now, entry.id);
-    if (result.changes === 0)
-      return null;
-    return { ...entry, startedAt: now };
-  })();
+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 removeDreamEntry(db, id) {
-  db.prepare("DELETE FROM dream_queue WHERE id = ?").run(id);
+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 resetDreamEntry(db, id) {
-  db.prepare("UPDATE dream_queue SET started_at = NULL, retry_count = COALESCE(retry_count, 0) + 1 WHERE id = ?").run(id);
+function removePendingOp(db, sessionId, tagId) {
+  db.prepare("DELETE FROM pending_ops WHERE session_id = ? AND tag_id = ?").run(sessionId, tagId);
 }
-function getEntryRetryCount(db, id) {
-  const row = db.query("SELECT retry_count FROM dream_queue WHERE id = ?").get(id);
-  return row?.retry_count ?? 0;
+// 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 clearStaleEntries(db, maxAgeMs) {
-  const cutoff = Date.now() - maxAgeMs;
-  const result = db.prepare("DELETE FROM dream_queue WHERE started_at IS NOT NULL AND started_at < ?").run(cutoff);
-  return result.changes;
+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());
 }
-// src/features/magic-context/dreamer/runner.ts
-import { existsSync as existsSync3 } from "fs";
-import { join as join5 } from "path";
-var dreamProjectDirectories = new Map;
-function registerDreamProjectDirectory(projectIdentity, directory) {
-  dreamProjectDirectories.set(projectIdentity, directory);
+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 resolveDreamSessionDirectory(projectIdentity) {
-  return dreamProjectDirectories.get(projectIdentity) ?? projectIdentity;
+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;
 }
-async function runDream(args) {
-  const holderId = crypto.randomUUID();
-  const startedAt = Date.now();
-  const result = {
-    startedAt,
-    finishedAt: startedAt,
-    holderId,
-    tasks: []
+// 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) {
+  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";
+}
+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
   };
-  log(`[dreamer] starting dream run: ${args.tasks.length} tasks, timeout=${args.taskTimeoutMinutes}m, maxRuntime=${args.maxRuntimeMinutes}m, project=${args.projectIdentity}`);
-  if (!acquireLease(args.db, holderId)) {
-    const currentHolder = getLeaseHolder(args.db) ?? "another holder";
-    log(`[dreamer] lease acquisition failed \u2014 already held by ${currentHolder}`);
-    result.tasks.push({
-      name: "lease",
-      durationMs: 0,
-      result: null,
-      error: `Dream lease is already held by ${currentHolder}`
-    });
-    result.finishedAt = Date.now();
-    return result;
+}
+function insertTag(db, sessionId, messageId, type, byteSize, tagNumber) {
+  getInsertTagStatement(db).run(sessionId, messageId, type, byteSize, tagNumber);
+  return tagNumber;
+}
+function updateTagStatus(db, sessionId, tagId, status) {
+  db.prepare("UPDATE tags SET status = ? WHERE session_id = ? AND tag_number = ?").run(status, sessionId, tagId);
+}
+function updateTagMessageId(db, sessionId, tagId, messageId) {
+  db.prepare("UPDATE tags SET message_id = ? WHERE session_id = ? AND tag_number = ?").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 [];
   }
-  log(`[dreamer] lease acquired: ${holderId}`);
-  let parentSessionId = args.parentSessionId;
-  if (!parentSessionId) {
-    try {
-      const sessionDir = args.sessionDirectory ?? args.projectIdentity;
-      const listResponse = await args.client.session.list({
-        query: { directory: sessionDir }
-      });
-      const sessions = normalizeSDKResponse(listResponse, [], {
-        preferResponseOnMissingData: true
-      });
-      parentSessionId = sessions?.find((s) => typeof s?.id === "string")?.id;
-      if (parentSessionId) {
-        log(`[dreamer] resolved parent session: ${parentSessionId}`);
-      }
-    } catch {
-      log("[dreamer] could not resolve parent session \u2014 child sessions will be visible in UI");
-    }
+  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/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 deadline = startedAt + args.maxRuntimeMinutes * 60 * 1000;
-  const lastDreamAt = getDreamState(args.db, `last_dream_at:${args.projectIdentity}`) ?? getDreamState(args.db, "last_dream_at");
-  log(`[dreamer] last dream at: ${lastDreamAt ?? "never"} (project=${args.projectIdentity})`);
-  try {
-    for (const taskName of args.tasks) {
-      if (Date.now() > deadline) {
-        log(`[dreamer] deadline reached, stopping after ${result.tasks.length} tasks`);
-        break;
-      }
-      log(`[dreamer] starting task: ${taskName}`);
-      const taskStartedAt = Date.now();
-      let agentSessionId = null;
-      const taskAbortController = new AbortController;
-      const leaseRenewalInterval = setInterval(() => {
-        try {
-          if (!renewLease(args.db, holderId)) {
-            log(`[dreamer] task ${taskName}: lease renewal failed \u2014 aborting LLM call`);
-            taskAbortController.abort();
-          }
-        } catch (err) {
-          log(`[dreamer] task ${taskName}: lease renewal threw \u2014 aborting LLM call: ${err}`);
-          taskAbortController.abort();
-        }
-      }, 60000);
-      try {
-        const docsDir = args.sessionDirectory ?? args.projectIdentity;
-        const existingDocs = taskName === "maintain-docs" ? {
-          architecture: existsSync3(join5(docsDir, "ARCHITECTURE.md")),
-          structure: existsSync3(join5(docsDir, "STRUCTURE.md"))
-        } : undefined;
-        const taskPrompt = buildDreamTaskPrompt(taskName, {
-          projectPath: args.projectIdentity,
-          lastDreamAt,
-          existingDocs
-        });
-        const createResponse = await args.client.session.create({
-          body: {
-            ...parentSessionId ? { parentID: parentSessionId } : {},
-            title: `magic-context-dream-${taskName}`
-          },
-          query: { directory: args.sessionDirectory ?? args.projectIdentity }
-        });
-        const createdSession = normalizeSDKResponse(createResponse, null, { preferResponseOnMissingData: true });
-        agentSessionId = typeof createdSession?.id === "string" ? createdSession.id : null;
-        if (!agentSessionId) {
-          throw new Error("Dreamer could not create its child session.");
-        }
-        log(`[dreamer] task ${taskName}: child session created ${agentSessionId}`);
-        await promptSyncWithModelSuggestionRetry(args.client, {
-          path: { id: agentSessionId },
-          query: { directory: args.sessionDirectory ?? args.projectIdentity },
-          body: {
-            agent: DREAMER_AGENT,
-            system: DREAMER_SYSTEM_PROMPT,
-            parts: [{ type: "text", text: taskPrompt }]
-          }
-        }, {
-          timeoutMs: args.taskTimeoutMinutes * 60 * 1000,
-          signal: taskAbortController.signal
-        });
-        const messagesResponse = await args.client.session.messages({
-          path: { id: agentSessionId },
-          query: { directory: args.sessionDirectory ?? args.projectIdentity }
-        });
-        const messages = normalizeSDKResponse(messagesResponse, [], {
-          preferResponseOnMissingData: true
-        });
-        const taskResult = extractLatestAssistantText(messages);
-        if (!taskResult) {
-          throw new Error("Dreamer returned no assistant output.");
-        }
-        const durationMs = Date.now() - taskStartedAt;
-        log(`[dreamer] task ${taskName}: completed in ${(durationMs / 1000).toFixed(1)}s (result: ${String(taskResult).length} chars)`);
-        result.tasks.push({
-          name: taskName,
-          durationMs,
-          result: taskResult
-        });
-      } catch (error48) {
-        const durationMs = Date.now() - taskStartedAt;
-        const errorMsg = getErrorMessage(error48);
-        log(`[dreamer] task ${taskName}: failed after ${(durationMs / 1000).toFixed(1)}s \u2014 ${errorMsg}`);
-        result.tasks.push({
-          name: taskName,
-          durationMs,
-          result: null,
-          error: errorMsg
-        });
-      } finally {
-        clearInterval(leaseRenewalInterval);
-        if (agentSessionId) {
-          await args.client.session.delete({
-            path: { id: agentSessionId },
-            query: { directory: args.sessionDirectory ?? args.projectIdentity }
-          }).catch((error48) => {
-            log("[dreamer] failed to delete child session:", error48);
-          });
-        }
-      }
+  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);
     }
-  } finally {
-    releaseLease(args.db, holderId);
-    log(`[dreamer] lease released: ${holderId}`);
+  }, DREAM_TIMER_INTERVAL_MS);
+  if (typeof timer === "object" && "unref" in timer) {
+    timer.unref();
   }
-  result.finishedAt = Date.now();
-  const hasSuccessfulTask = result.tasks.some((t) => !t.error);
-  if (hasSuccessfulTask) {
-    setDreamState(args.db, `last_dream_at:${args.projectIdentity}`, String(result.finishedAt));
-    setDreamState(args.db, "last_dream_at", String(result.finishedAt));
+  log(`[dreamer] started independent schedule timer (every ${DREAM_TIMER_INTERVAL_MS / 60000}m)`);
+}
+
+// src/plugin/event.ts
+function createEventHandler(args) {
+  return async (input) => {
+    await args.magicContext?.event?.(input);
+  };
+}
+
+// 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 });
+    }
+  };
+}
+
+// src/hooks/is-anthropic-provider.ts
+function isAnthropicProvider(providerID) {
+  return providerID === "anthropic" || providerID === "google-vertex-anthropic";
+}
+
+// src/hooks/magic-context/event-resolvers.ts
+var DEFAULT_CONTEXT_LIMIT = 200000;
+function resolveContextLimit(providerID, modelID, config2) {
+  if (!providerID) {
+    return DEFAULT_CONTEXT_LIMIT;
   }
-  const totalDuration = ((result.finishedAt - startedAt) / 1000).toFixed(1);
-  const succeeded = result.tasks.filter((t) => !t.error).length;
-  const failed = result.tasks.filter((t) => t.error).length;
-  log(`[dreamer] dream run finished in ${totalDuration}s: ${succeeded} succeeded, ${failed} failed`);
-  return result;
+  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;
 }
-var MAX_LEASE_RETRIES = 3;
-async function processDreamQueue(args) {
-  clearStaleEntries(args.db, 2 * 60 * 60 * 1000);
-  const entry = dequeueNext(args.db);
-  if (!entry) {
-    return null;
+function resolveCacheTtl(cacheTtl, modelKey) {
+  if (typeof cacheTtl === "string") {
+    return cacheTtl;
   }
-  const projectDirectory = resolveDreamSessionDirectory(entry.projectIdentity);
-  log(`[dreamer] dequeued project ${entry.projectIdentity} (dir=${projectDirectory}), starting dream run`);
-  let result;
-  try {
-    result = await runDream({
-      db: args.db,
-      client: args.client,
-      projectIdentity: entry.projectIdentity,
-      tasks: args.tasks,
-      taskTimeoutMinutes: args.taskTimeoutMinutes,
-      maxRuntimeMinutes: args.maxRuntimeMinutes,
-      sessionDirectory: projectDirectory
-    });
-  } catch (error48) {
-    log(`[dreamer] runDream threw for ${entry.projectIdentity}: ${getErrorMessage(error48)}`);
-    removeDreamEntry(args.db, entry.id);
-    return null;
+  if (modelKey && typeof cacheTtl[modelKey] === "string") {
+    return cacheTtl[modelKey];
   }
-  const leaseError = result.tasks.find((t) => t.name === "lease" && t.error);
-  if (leaseError) {
-    const retryCount = getEntryRetryCount(args.db, entry.id);
-    if (retryCount >= MAX_LEASE_RETRIES) {
-      log(`[dreamer] lease acquisition failed ${retryCount + 1} times for ${entry.projectIdentity} \u2014 removing queue entry`);
-      removeDreamEntry(args.db, entry.id);
-    } else {
-      log(`[dreamer] lease acquisition failed for ${entry.projectIdentity} (attempt ${retryCount + 1}/${MAX_LEASE_RETRIES}) \u2014 keeping for retry`);
-      resetDreamEntry(args.db, entry.id);
+  if (modelKey) {
+    const bareModelId = modelKey.split("/").slice(1).join("/");
+    if (bareModelId && typeof cacheTtl[bareModelId] === "string") {
+      return cacheTtl[bareModelId];
     }
-  } else {
-    removeDreamEntry(args.db, entry.id);
   }
-  return result;
+  return cacheTtl.default ?? "5m";
 }
-// src/features/magic-context/dreamer/scheduler.ts
-function parseScheduleWindow(schedule) {
-  const match = /^(\d{1,2}):(\d{2})-(\d{1,2}):(\d{2})$/.exec(schedule.trim());
-  if (!match)
-    return null;
-  const startHour = Number(match[1]);
-  const startMin = Number(match[2]);
-  const endHour = Number(match[3]);
-  const endMin = Number(match[4]);
-  if (startHour >= 24 || startMin >= 60 || endHour >= 24 || endMin >= 60) {
-    return null;
+function resolveExecuteThreshold(config2, modelKey, fallback) {
+  if (typeof config2 === "number") {
+    return config2;
   }
-  const startMinutes = startHour * 60 + startMin;
-  const endMinutes = endHour * 60 + endMin;
-  return { startMinutes, endMinutes };
+  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 isInScheduleWindow(schedule, now = new Date) {
-  const window = parseScheduleWindow(schedule);
-  if (!window)
+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/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 createScheduler(config2) {
+  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";
+    }
+  };
+}
+
+// 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 currentMinutes = now.getHours() * 60 + now.getMinutes();
-  if (window.startMinutes <= window.endMinutes) {
-    return currentMinutes >= window.startMinutes && currentMinutes < window.endMinutes;
   }
-  return currentMinutes >= window.startMinutes || currentMinutes < window.endMinutes;
+  const candidate = row;
+  return typeof candidate.message_id === "string" && typeof candidate.tag_number === "number";
 }
-function findProjectsNeedingDream(db) {
-  const projectRows = db.query(`SELECT DISTINCT project_path FROM memories WHERE status = 'active' ORDER BY project_path`).all();
-  const projects = [];
-  for (const row of projectRows) {
-    const lastDreamAtStr = getDreamState(db, `last_dream_at:${row.project_path}`);
-    const fallbackStr = !lastDreamAtStr ? getDreamState(db, "last_dream_at") : null;
-    const lastDreamAt = Number(lastDreamAtStr ?? fallbackStr ?? "0") || 0;
-    const updated = db.query(`SELECT COUNT(*) as cnt FROM memories
-                 WHERE project_path = ? AND status = 'active' AND updated_at > ?`).get(row.project_path, lastDreamAt);
-    if (updated && updated.cnt > 0) {
-      projects.push(row.project_path);
+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, 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 projects;
-}
-function checkScheduleAndEnqueue(db, schedule) {
-  if (!isInScheduleWindow(schedule)) {
-    return 0;
+  function getTag(sessionId, messageId) {
+    return assignments.get(sessionId)?.get(messageId);
   }
-  const projects = findProjectsNeedingDream(db);
-  if (projects.length === 0) {
-    return 0;
+  function bindTag(sessionId, messageId, tagNumber) {
+    getSessionAssignments(sessionId).set(messageId, tagNumber);
   }
-  let enqueued = 0;
-  for (const projectIdentity of projects) {
-    const entry = enqueueDream(db, projectIdentity, "scheduled");
-    if (entry) {
-      log(`[dreamer] enqueued project for scheduled dream: ${projectIdentity}`);
-      enqueued++;
+  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;
+      }
     }
+    const counter = Math.max(row?.counter ?? 0, maxTagNumber);
+    counters.set(sessionId, counter);
   }
-  return enqueued;
+  function cleanup(sessionId) {
+    counters.delete(sessionId);
+    assignments.delete(sessionId);
+  }
+  return {
+    assignTag,
+    getTag,
+    bindTag,
+    getAssignments,
+    resetCounter,
+    getCounter,
+    initFromDb,
+    cleanup
+  };
 }
+
 // src/features/magic-context/memory/project-identity.ts
 import { execSync } from "child_process";
 import path3 from "path";
@@ -17280,191 +17327,10 @@ function createEventHandler2(deps) {
         sessionLog(sessionId, "event session.deleted persistence failed:", error48);
       }
       deps.onSessionCacheInvalidated?.(sessionId);
-      deps.contextUsageMap.delete(sessionId);
-      deps.tagger.cleanup(sessionId);
-      return;
-    }
-  };
-}
-
-// src/hooks/magic-context/nudger.ts
-var RECENT_CTX_REDUCE_WINDOW_MS = 2 * 60 * 1000;
-function formatLargestTags(tags) {
-  if (tags.length === 0) {
-    return "none";
-  }
-  return tags.map((tag) => `\xA7${tag.tagNumber}\xA7`).join(", ");
-}
-function formatOldToolTags(activeTags, protectedCount, count) {
-  const sortedByNumber = [...activeTags].sort((a, b) => a.tagNumber - b.tagNumber);
-  const protectedThreshold = protectedCount > 0 && sortedByNumber.length > protectedCount ? sortedByNumber[sortedByNumber.length - protectedCount].tagNumber : Infinity;
-  const midpoint = Math.floor(sortedByNumber.length / 2);
-  const earlyHalf = sortedByNumber.slice(0, midpoint);
-  const earlyToolTags = earlyHalf.filter((t) => t.type === "tool" && t.tagNumber < protectedThreshold);
-  if (earlyToolTags.length === 0)
-    return "";
-  const selected = earlyToolTags.sort((a, b) => b.byteSize - a.byteSize).slice(0, count);
-  const formatted = selected.sort((a, b) => a.tagNumber - b.tagNumber).map((t) => `\xA7${t.tagNumber}\xA7(${formatBytes(t.byteSize)})`).join(", ");
-  return ` Old tool outputs worth dropping: ${formatted}`;
-}
-function createNudger(config2) {
-  const lastReduceAtBySession = config2.recentReduceBySession ?? new Map;
-  return (sessionId, contextUsage, db, topNFn, preloadedTags, messagesSinceLastUser, preloadedSessionMeta) => {
-    const sessionMeta = preloadedSessionMeta ?? getOrCreateSessionMeta(db, sessionId);
-    const now = config2.now?.() ?? Date.now();
-    const lastReduceAt = lastReduceAtBySession.get(sessionId);
-    if (lastReduceAt !== undefined && now - lastReduceAt > RECENT_CTX_REDUCE_WINDOW_MS) {
-      lastReduceAtBySession.delete(sessionId);
-    }
-    if (contextUsage.inputTokens < sessionMeta.lastNudgeTokens) {
-      sessionMeta.lastNudgeTokens = contextUsage.inputTokens;
-      updateSessionMeta(db, sessionId, { lastNudgeTokens: contextUsage.inputTokens });
-    }
-    if (lastReduceAt !== undefined && now - lastReduceAt <= RECENT_CTX_REDUCE_WINDOW_MS) {
-      sessionLog(sessionId, `nudge: suppressed at ${contextUsage.percentage.toFixed(1)}% because ctx_reduce ran recently (${now - lastReduceAt}ms ago)`);
-      return null;
-    }
-    const projectedPercentage = estimateProjectedPercentage(db, sessionId, contextUsage, preloadedTags);
-    const executeThreshold = resolveExecuteThreshold(config2.execute_threshold_percentage, undefined, 65);
-    const currentBand = getRollingNudgeBand(contextUsage.percentage, executeThreshold);
-    const currentInterval = getRollingNudgeIntervalTokens(config2.nudge_interval_tokens, currentBand);
-    const lastBand = sessionMeta.lastNudgeBand;
-    if (getRollingNudgeBandPriority(currentBand) < getRollingNudgeBandPriority(lastBand)) {
-      sessionMeta.lastNudgeBand = currentBand;
-      updateSessionMeta(db, sessionId, { lastNudgeBand: currentBand });
-    }
-    const largest = formatLargestTags(topNFn(db, sessionId, 3));
-    const protectedCount = config2.protected_tags;
-    const activeTags = (preloadedTags ?? getTagsBySession(db, sessionId)).filter((t) => t.status === "active");
-    const highestProtected = activeTags.map((t) => t.tagNumber).sort((a, b) => b - a).slice(0, protectedCount)[0];
-    const protectedHint = highestProtected ? ` Tags \xA7${highestProtected}\xA7 and above are protected (last ${protectedCount}) \u2014 You MUST NOT try to reduce those.` : "";
-    const oldToolHint = formatOldToolTags(activeTags, protectedCount, 5);
-    const iterationThreshold = config2.iteration_nudge_threshold;
-    if (messagesSinceLastUser !== undefined && messagesSinceLastUser >= iterationThreshold && contextUsage.percentage >= 35 && contextUsage.percentage < executeThreshold && contextUsage.inputTokens - sessionMeta.lastNudgeTokens >= currentInterval) {
-      sessionLog(sessionId, `nudge fired: iteration_nudge at ${contextUsage.percentage.toFixed(1)}% (${messagesSinceLastUser} messages since user, interval: ${contextUsage.inputTokens - sessionMeta.lastNudgeTokens}/${currentInterval} tokens)`);
-      updateSessionMeta(db, sessionId, { lastNudgeTokens: contextUsage.inputTokens });
-      return {
-        type: "assistant",
-        text: [
-          `
-
-<instruction name="context_iteration">`,
-          `CONTEXT ITERATION NOTICE \u2014 ~${Math.round(contextUsage.percentage)}%`,
-          `You have been executing ${messagesSinceLastUser}+ tool calls without clearing old context.`,
-          `Consider using \`ctx_reduce\` to drop old tool outputs you have already processed.`,
-          ``,
-          `Largest: ${largest}.${oldToolHint}${protectedHint}`,
-          `Tags are marked with \xA7N\xA7 identifiers (e.g., \xA71\xA7, \xA742\xA7).`,
-          ``,
-          `Actions:`,
-          `- drop: Remove content entirely. Best for old tool outputs you already acted on.`,
-          `- Syntax: "3-5", "1,2,9", or "1-5,8,12-15" (bare integers).`,
-          `- Only drop what you have already processed. NEVER drop large ranges blindly.`,
-          `</instruction>`
-        ].join(`
-`)
-      };
-    }
-    const intervalReached = contextUsage.inputTokens - sessionMeta.lastNudgeTokens >= currentInterval;
-    const bandEscalated = lastBand !== null && getRollingNudgeBandPriority(currentBand) > getRollingNudgeBandPriority(lastBand);
-    if (bandEscalated || intervalReached) {
-      const reason = bandEscalated ? `band escalation (${formatRollingNudgeBand(lastBand)} -> ${currentBand})` : `interval ${contextUsage.inputTokens - sessionMeta.lastNudgeTokens}/${currentInterval} tokens`;
-      sessionLog(sessionId, `nudge fired: rolling_${currentBand} at ${contextUsage.percentage.toFixed(1)}% (${reason})`);
-      updateSessionMeta(db, sessionId, {
-        lastNudgeTokens: contextUsage.inputTokens,
-        lastNudgeBand: currentBand
-      });
-      return {
-        type: "assistant",
-        text: buildRollingNudgeText(currentBand, contextUsage.percentage, largest, oldToolHint, protectedHint)
-      };
-    }
-    sessionLog(sessionId, `nudge: none fired at ${contextUsage.percentage.toFixed(1)}% (band=${currentBand} lastBand=${formatRollingNudgeBand(lastBand)} lastNudge=${sessionMeta.lastNudgeTokens} current=${contextUsage.inputTokens} interval=${currentInterval} projected=${projectedPercentage?.toFixed(1) ?? "none"})`);
-    return null;
-  };
-}
-function buildRollingNudgeText(band, percentage, largest, oldToolHint, protectedHint) {
-  const titleByBand = {
-    far: "CONTEXT REMINDER",
-    near: "CONTEXT WARNING",
-    urgent: "CONTEXT URGENT",
-    critical: "CONTEXT CRITICAL"
-  };
-  const instructionByBand = {
-    far: "You should use `ctx_reduce` to drop old tool outputs before continuing.",
-    near: "You should call `ctx_reduce` soon to free space before more heavy reads or tool output.",
-    urgent: "You should call `ctx_reduce` before doing more reads or tool-heavy work.",
-    critical: "You MUST call `ctx_reduce` RIGHT NOW before doing ANYTHING else."
-  };
-  const cautionByBand = {
-    far: "- Only drop what you have already processed. NEVER drop large ranges blindly.",
-    near: "- Review what each tag contains. Drop processed outputs, keep anything you might need soon.",
-    urgent: "- Review each tag before deciding. Avoid broad drops that could remove active context.",
-    critical: '- NEVER drop large ranges blindly (e.g., "1-50"). Review each tag before deciding.'
-  };
-  return [
-    `
-
-<instruction name="context_${band}">`,
-    `${titleByBand[band]} \u2014 ~${Math.round(percentage)}%`,
-    instructionByBand[band],
-    ``,
-    `Largest: ${largest}.${oldToolHint}${protectedHint}`,
-    `Tags are marked with \xA7N\xA7 identifiers (e.g., \xA71\xA7, \xA742\xA7).`,
-    ``,
-    `Actions:`,
-    `- drop: Remove content entirely. Best for old tool outputs you already acted on.`,
-    `- Syntax: "3-5", "1,2,9", or "1-5,8,12-15" (bare integers).`,
-    cautionByBand[band],
-    `</instruction>`
-  ].join(`
-`);
-}
-function estimateProjectedPercentage(db, sessionId, contextUsage, preloadedTags) {
-  const pendingOps = getPendingOps(db, sessionId);
-  const pendingDrops = pendingOps.filter((op) => op.operation === "drop");
-  if (pendingDrops.length === 0) {
-    return null;
-  }
-  const activeTags = (preloadedTags ?? getTagsBySession(db, sessionId)).filter((t) => t.status === "active");
-  const totalActiveBytes = activeTags.reduce((sum, t) => sum + t.byteSize, 0);
-  if (totalActiveBytes === 0) {
-    return null;
-  }
-  const pendingDropTagIds = new Set(pendingDrops.map((op) => op.tagId));
-  const pendingDropBytes = activeTags.filter((t) => pendingDropTagIds.has(t.tagNumber)).reduce((sum, t) => sum + t.byteSize, 0);
-  const dropRatio = pendingDropBytes / totalActiveBytes;
-  return contextUsage.percentage * (1 - dropRatio);
-}
-function generateEmergencyNudgeText(db, sessionId, contextUsage, config2) {
-  const largest = formatLargestTags(getTopNBySize(db, sessionId, 3));
-  const protectedCount = config2.protected_tags;
-  const activeTags = getTagsBySession(db, sessionId).filter((t) => t.status === "active");
-  const highestProtected = activeTags.map((t) => t.tagNumber).sort((a, b) => b - a).slice(0, protectedCount)[0];
-  const protectedHint = highestProtected ? ` Tags \xA7${highestProtected}\xA7 and above are protected (last ${protectedCount}) \u2014 You MUST NOT try to reduce those.` : "";
-  const oldToolHint = formatOldToolTags(activeTags, protectedCount, 5);
-  return [
-    `<instruction name="context_emergency">`,
-    `CONTEXT EMERGENCY \u2014 ~${Math.round(contextUsage.percentage)}%. STOP all current work immediately.`,
-    ``,
-    `You MUST use \`ctx_reduce\` RIGHT NOW to free space. If context overflows, you lose all work.`,
-    ``,
-    `Steps:`,
-    `1. Find OLD tool outputs (grep results, file reads, build logs) you already processed \u2014 look at \xA7N\xA7 tags`,
-    `2. Drop those specifically: e.g. drop="3,7,12" \u2014 NEVER drop large ranges like "1-50"`,
-    `3. KEEP anything related to current task, recent errors, or decisions`,
-    ``,
-    `Largest tags: ${largest}.${oldToolHint}${protectedHint}`,
-    `</instruction>`
-  ].join(`
-`);
-}
-
-// src/hooks/magic-context/text-complete.ts
-var TAG_PREFIX_REGEX2 = /^(\u00a7\d+\u00a7\s*)+/;
-function createTextCompleteHandler() {
-  return async (_input, output) => {
-    output.text = output.text.replace(TAG_PREFIX_REGEX2, "");
+      deps.contextUsageMap.delete(sessionId);
+      deps.tagger.cleanup(sessionId);
+      return;
+    }
   };
 }
 
@@ -17809,6 +17675,10 @@ function archiveMemory(db, id, reason) {
 }
 
 // src/hooks/magic-context/inject-compartments.ts
+var injectionCache = new Map;
+function clearInjectionCache(sessionId) {
+  injectionCache.delete(sessionId);
+}
 function renderMemoryBlock(memories) {
   const byCategory = new Map;
   for (const m of memories) {
@@ -17859,19 +17729,31 @@ function trimMemoriesToBudget(sessionId, memories, budgetTokens) {
   }
   return result;
 }
-function prepareCompartmentInjection(db, sessionId, messages, projectPath, injectionBudgetTokens) {
+function prepareCompartmentInjection(db, sessionId, messages, isCacheBusting, projectPath, injectionBudgetTokens) {
+  const cached2 = injectionCache.get(sessionId);
+  if (!isCacheBusting && cached2) {
+    if (cached2.compartmentEndMessageId.length > 0) {
+      const cutoffIndex2 = messages.findIndex((message) => message.info.id === cached2.compartmentEndMessageId);
+      if (cutoffIndex2 >= 0) {
+        const remaining = messages.slice(cutoffIndex2 + 1);
+        messages.splice(0, messages.length, ...remaining);
+      }
+    }
+    return cached2;
+  }
   const compartments = getCompartments(db, sessionId);
   if (compartments.length === 0) {
+    injectionCache.delete(sessionId);
     return null;
   }
   const facts = getSessionFacts(db, sessionId);
   let memoryBlock;
   let memoryCount = 0;
   if (projectPath) {
-    const cached2 = db.prepare("SELECT memory_block_cache, memory_block_count FROM session_meta WHERE session_id = ?").get(sessionId);
-    if (cached2?.memory_block_cache) {
-      memoryBlock = cached2.memory_block_cache;
-      memoryCount = cached2.memory_block_count;
+    const cachedMemory = db.prepare("SELECT memory_block_cache, memory_block_count FROM session_meta WHERE session_id = ?").get(sessionId);
+    if (cachedMemory?.memory_block_cache) {
+      memoryBlock = cachedMemory.memory_block_cache;
+      memoryCount = cachedMemory.memory_block_count;
     } else {
       let memories = getMemoriesByProject(db, projectPath, ["active", "permanent"]);
       if (injectionBudgetTokens && memories.length > 0) {
@@ -17891,14 +17773,17 @@ function prepareCompartmentInjection(db, sessionId, messages, projectPath, injec
       compartmentCount: compartments.length,
       compartmentEndMessage: lastEnd
     });
-    return {
+    const result2 = {
       block,
       compartmentEndMessage: lastEnd,
+      compartmentEndMessageId: "",
       compartmentCount: compartments.length,
       skippedVisibleMessages: 0,
       factCount: facts.length,
       memoryCount
     };
+    injectionCache.set(sessionId, result2);
+    return result2;
   }
   let skippedVisibleMessages = 0;
   const cutoffIndex = messages.findIndex((message) => message.info.id === lastEndMessageId);
@@ -17907,14 +17792,17 @@ function prepareCompartmentInjection(db, sessionId, messages, projectPath, injec
     const remaining = messages.slice(cutoffIndex + 1);
     messages.splice(0, messages.length, ...remaining);
   }
-  return {
+  const result = {
     block,
     compartmentEndMessage: lastEnd,
+    compartmentEndMessageId: lastEndMessageId,
     compartmentCount: compartments.length,
     skippedVisibleMessages,
     factCount: facts.length,
     memoryCount
   };
+  injectionCache.set(sessionId, result);
+  return result;
 }
 function renderCompartmentInjection(sessionId, messages, prepared) {
   const historyBlock = `<session-history>
@@ -17956,6 +17844,187 @@ function isDroppedPlaceholder(text) {
   return /^\[dropped \u00A7\d+\u00A7\]$/.test(text.trim());
 }
 
+// src/hooks/magic-context/nudger.ts
+var RECENT_CTX_REDUCE_WINDOW_MS = 2 * 60 * 1000;
+function formatLargestTags(tags) {
+  if (tags.length === 0) {
+    return "none";
+  }
+  return tags.map((tag) => `\xA7${tag.tagNumber}\xA7`).join(", ");
+}
+function formatOldToolTags(activeTags, protectedCount, count) {
+  const sortedByNumber = [...activeTags].sort((a, b) => a.tagNumber - b.tagNumber);
+  const protectedThreshold = protectedCount > 0 && sortedByNumber.length > protectedCount ? sortedByNumber[sortedByNumber.length - protectedCount].tagNumber : Infinity;
+  const midpoint = Math.floor(sortedByNumber.length / 2);
+  const earlyHalf = sortedByNumber.slice(0, midpoint);
+  const earlyToolTags = earlyHalf.filter((t) => t.type === "tool" && t.tagNumber < protectedThreshold);
+  if (earlyToolTags.length === 0)
+    return "";
+  const selected = earlyToolTags.sort((a, b) => b.byteSize - a.byteSize).slice(0, count);
+  const formatted = selected.sort((a, b) => a.tagNumber - b.tagNumber).map((t) => `\xA7${t.tagNumber}\xA7(${formatBytes(t.byteSize)})`).join(", ");
+  return ` Old tool outputs worth dropping: ${formatted}`;
+}
+function createNudger(config2) {
+  const lastReduceAtBySession = config2.recentReduceBySession ?? new Map;
+  return (sessionId, contextUsage, db, topNFn, preloadedTags, messagesSinceLastUser, preloadedSessionMeta) => {
+    const sessionMeta = preloadedSessionMeta ?? getOrCreateSessionMeta(db, sessionId);
+    const now = config2.now?.() ?? Date.now();
+    const lastReduceAt = lastReduceAtBySession.get(sessionId);
+    if (lastReduceAt !== undefined && now - lastReduceAt > RECENT_CTX_REDUCE_WINDOW_MS) {
+      lastReduceAtBySession.delete(sessionId);
+    }
+    if (contextUsage.inputTokens < sessionMeta.lastNudgeTokens) {
+      sessionMeta.lastNudgeTokens = contextUsage.inputTokens;
+      updateSessionMeta(db, sessionId, { lastNudgeTokens: contextUsage.inputTokens });
+    }
+    if (lastReduceAt !== undefined && now - lastReduceAt <= RECENT_CTX_REDUCE_WINDOW_MS) {
+      sessionLog(sessionId, `nudge: suppressed at ${contextUsage.percentage.toFixed(1)}% because ctx_reduce ran recently (${now - lastReduceAt}ms ago)`);
+      return null;
+    }
+    const projectedPercentage = estimateProjectedPercentage(db, sessionId, contextUsage, preloadedTags);
+    const executeThreshold = resolveExecuteThreshold(config2.execute_threshold_percentage, undefined, 65);
+    const currentBand = getRollingNudgeBand(contextUsage.percentage, executeThreshold);
+    const currentInterval = getRollingNudgeIntervalTokens(config2.nudge_interval_tokens, currentBand);
+    const lastBand = sessionMeta.lastNudgeBand;
+    if (getRollingNudgeBandPriority(currentBand) < getRollingNudgeBandPriority(lastBand)) {
+      sessionMeta.lastNudgeBand = currentBand;
+      updateSessionMeta(db, sessionId, { lastNudgeBand: currentBand });
+    }
+    const largest = formatLargestTags(topNFn(db, sessionId, 3));
+    const protectedCount = config2.protected_tags;
+    const activeTags = (preloadedTags ?? getTagsBySession(db, sessionId)).filter((t) => t.status === "active");
+    const highestProtected = activeTags.map((t) => t.tagNumber).sort((a, b) => b - a).slice(0, protectedCount)[0];
+    const protectedHint = highestProtected ? ` Tags \xA7${highestProtected}\xA7 and above are protected (last ${protectedCount}) \u2014 You MUST NOT try to reduce those.` : "";
+    const oldToolHint = formatOldToolTags(activeTags, protectedCount, 5);
+    const iterationThreshold = config2.iteration_nudge_threshold;
+    if (messagesSinceLastUser !== undefined && messagesSinceLastUser >= iterationThreshold && contextUsage.percentage >= 35 && contextUsage.percentage < executeThreshold && contextUsage.inputTokens - sessionMeta.lastNudgeTokens >= currentInterval) {
+      sessionLog(sessionId, `nudge fired: iteration_nudge at ${contextUsage.percentage.toFixed(1)}% (${messagesSinceLastUser} messages since user, interval: ${contextUsage.inputTokens - sessionMeta.lastNudgeTokens}/${currentInterval} tokens)`);
+      updateSessionMeta(db, sessionId, { lastNudgeTokens: contextUsage.inputTokens });
+      return {
+        type: "assistant",
+        text: [
+          `
+
+<instruction name="context_iteration">`,
+          `CONTEXT ITERATION NOTICE \u2014 ~${Math.round(contextUsage.percentage)}%`,
+          `You have been executing ${messagesSinceLastUser}+ tool calls without clearing old context.`,
+          `Consider using \`ctx_reduce\` to drop old tool outputs you have already processed.`,
+          ``,
+          `Largest: ${largest}.${oldToolHint}${protectedHint}`,
+          `Tags are marked with \xA7N\xA7 identifiers (e.g., \xA71\xA7, \xA742\xA7).`,
+          ``,
+          `Actions:`,
+          `- drop: Remove content entirely. Best for old tool outputs you already acted on.`,
+          `- Syntax: "3-5", "1,2,9", or "1-5,8,12-15" (bare integers).`,
+          `- Only drop what you have already processed. NEVER drop large ranges blindly.`,
+          `</instruction>`
+        ].join(`
+`)
+      };
+    }
+    const intervalReached = contextUsage.inputTokens - sessionMeta.lastNudgeTokens >= currentInterval;
+    const bandEscalated = lastBand !== null && getRollingNudgeBandPriority(currentBand) > getRollingNudgeBandPriority(lastBand);
+    if (bandEscalated || intervalReached) {
+      const reason = bandEscalated ? `band escalation (${formatRollingNudgeBand(lastBand)} -> ${currentBand})` : `interval ${contextUsage.inputTokens - sessionMeta.lastNudgeTokens}/${currentInterval} tokens`;
+      sessionLog(sessionId, `nudge fired: rolling_${currentBand} at ${contextUsage.percentage.toFixed(1)}% (${reason})`);
+      updateSessionMeta(db, sessionId, {
+        lastNudgeTokens: contextUsage.inputTokens,
+        lastNudgeBand: currentBand
+      });
+      return {
+        type: "assistant",
+        text: buildRollingNudgeText(currentBand, contextUsage.percentage, largest, oldToolHint, protectedHint)
+      };
+    }
+    sessionLog(sessionId, `nudge: none fired at ${contextUsage.percentage.toFixed(1)}% (band=${currentBand} lastBand=${formatRollingNudgeBand(lastBand)} lastNudge=${sessionMeta.lastNudgeTokens} current=${contextUsage.inputTokens} interval=${currentInterval} projected=${projectedPercentage?.toFixed(1) ?? "none"})`);
+    return null;
+  };
+}
+function buildRollingNudgeText(band, percentage, largest, oldToolHint, protectedHint) {
+  const titleByBand = {
+    far: "CONTEXT REMINDER",
+    near: "CONTEXT WARNING",
+    urgent: "CONTEXT URGENT",
+    critical: "CONTEXT CRITICAL"
+  };
+  const instructionByBand = {
+    far: "You should use `ctx_reduce` to drop old tool outputs before continuing.",
+    near: "You should call `ctx_reduce` soon to free space before more heavy reads or tool output.",
+    urgent: "You should call `ctx_reduce` before doing more reads or tool-heavy work.",
+    critical: "You MUST call `ctx_reduce` RIGHT NOW before doing ANYTHING else."
+  };
+  const cautionByBand = {
+    far: "- Only drop what you have already processed. NEVER drop large ranges blindly.",
+    near: "- Review what each tag contains. Drop processed outputs, keep anything you might need soon.",
+    urgent: "- Review each tag before deciding. Avoid broad drops that could remove active context.",
+    critical: '- NEVER drop large ranges blindly (e.g., "1-50"). Review each tag before deciding.'
+  };
+  return [
+    `
+
+<instruction name="context_${band}">`,
+    `${titleByBand[band]} \u2014 ~${Math.round(percentage)}%`,
+    instructionByBand[band],
+    ``,
+    `Largest: ${largest}.${oldToolHint}${protectedHint}`,
+    `Tags are marked with \xA7N\xA7 identifiers (e.g., \xA71\xA7, \xA742\xA7).`,
+    ``,
+    `Actions:`,
+    `- drop: Remove content entirely. Best for old tool outputs you already acted on.`,
+    `- Syntax: "3-5", "1,2,9", or "1-5,8,12-15" (bare integers).`,
+    cautionByBand[band],
+    `</instruction>`
+  ].join(`
+`);
+}
+function estimateProjectedPercentage(db, sessionId, contextUsage, preloadedTags) {
+  const pendingOps = getPendingOps(db, sessionId);
+  const pendingDrops = pendingOps.filter((op) => op.operation === "drop");
+  if (pendingDrops.length === 0) {
+    return null;
+  }
+  const activeTags = (preloadedTags ?? getTagsBySession(db, sessionId)).filter((t) => t.status === "active");
+  const totalActiveBytes = activeTags.reduce((sum, t) => sum + t.byteSize, 0);
+  if (totalActiveBytes === 0) {
+    return null;
+  }
+  const pendingDropTagIds = new Set(pendingDrops.map((op) => op.tagId));
+  const pendingDropBytes = activeTags.filter((t) => pendingDropTagIds.has(t.tagNumber)).reduce((sum, t) => sum + t.byteSize, 0);
+  const dropRatio = pendingDropBytes / totalActiveBytes;
+  return contextUsage.percentage * (1 - dropRatio);
+}
+function generateEmergencyNudgeText(db, sessionId, contextUsage, config2) {
+  const largest = formatLargestTags(getTopNBySize(db, sessionId, 3));
+  const protectedCount = config2.protected_tags;
+  const activeTags = getTagsBySession(db, sessionId).filter((t) => t.status === "active");
+  const highestProtected = activeTags.map((t) => t.tagNumber).sort((a, b) => b - a).slice(0, protectedCount)[0];
+  const protectedHint = highestProtected ? ` Tags \xA7${highestProtected}\xA7 and above are protected (last ${protectedCount}) \u2014 You MUST NOT try to reduce those.` : "";
+  const oldToolHint = formatOldToolTags(activeTags, protectedCount, 5);
+  return [
+    `<instruction name="context_emergency">`,
+    `CONTEXT EMERGENCY \u2014 ~${Math.round(contextUsage.percentage)}%. STOP all current work immediately.`,
+    ``,
+    `You MUST use \`ctx_reduce\` RIGHT NOW to free space. If context overflows, you lose all work.`,
+    ``,
+    `Steps:`,
+    `1. Find OLD tool outputs (grep results, file reads, build logs) you already processed \u2014 look at \xA7N\xA7 tags`,
+    `2. Drop those specifically: e.g. drop="3,7,12" \u2014 NEVER drop large ranges like "1-50"`,
+    `3. KEEP anything related to current task, recent errors, or decisions`,
+    ``,
+    `Largest tags: ${largest}.${oldToolHint}${protectedHint}`,
+    `</instruction>`
+  ].join(`
+`);
+}
+
+// src/hooks/magic-context/text-complete.ts
+var TAG_PREFIX_REGEX2 = /^(\u00a7\d+\u00a7\s*)+/;
+function createTextCompleteHandler() {
+  return async (_input, output) => {
+    output.text = output.text.replace(TAG_PREFIX_REGEX2, "");
+  };
+}
+
 // src/hooks/magic-context/note-nudger.ts
 var stateBySession = new Map;
 function getState(sessionId) {
@@ -19724,7 +19793,7 @@ async function runCompartmentPhase(args) {
     sessionLog(args.sessionId, reason);
     await activeRun;
     sessionLog(args.sessionId, "transform: compartment agent completed, refreshing compartment coverage");
-    pendingCompartmentInjection = prepareCompartmentInjection(args.db, args.resolvedSessionId, args.messages, args.projectPath, args.injectionBudgetTokens);
+    pendingCompartmentInjection = prepareCompartmentInjection(args.db, args.resolvedSessionId, args.messages, args.cacheAlreadyBusting ?? false, args.projectPath, args.injectionBudgetTokens);
   }
   if (args.canRunCompartments && args.sessionMeta.compartmentInProgress && !getActiveCompartmentRun(args.sessionId)) {
     if (!hasEligibleHistoryForCompartment()) {
@@ -20406,7 +20475,6 @@ function tagMessages(sessionId, messages, tagger, db) {
 }
 // src/hooks/magic-context/nudge-injection.ts
 var TRAILING_CONTEXT_NUDGE_PATTERN = /(?:\s*<instruction name="(?:context_[^"]+|deferred_notes)">[\s\S]*?<\/instruction>\s*)+$/;
-var TRAILING_DEFERRED_NOTES_PATTERN = /(?:\s*<instruction name="deferred_notes">[\s\S]*?<\/instruction>\s*)+$/;
 function isToolProtocolPart(part) {
   if (part === null || typeof part !== "object")
     return false;
@@ -20428,12 +20496,6 @@ function stripTrailingExactNudge(text, nudgeText) {
 function stripTrailingContextNudges(text) {
   return text.replace(TRAILING_CONTEXT_NUDGE_PATTERN, "");
 }
-function stripTrailingDeferredNotes(text) {
-  return text.replace(TRAILING_DEFERRED_NOTES_PATTERN, "");
-}
-function isAppendableAssistantMessage(message) {
-  return message.info.role === "assistant" && !hasToolProtocolParts(message) && !isMessageDropped(message);
-}
 function mergeNudgeText(text, currentNudgeText, nextNudgeText) {
   const withoutCurrentNudge = stripTrailingExactNudge(text, currentNudgeText);
   const withoutManagedNudges = stripTrailingContextNudges(withoutCurrentNudge);
@@ -20511,40 +20573,6 @@ function appendNudgeToAssistant(messages, nudge, nudgePlacements, sessionId) {
   }
   sessionLog(sessionId, `nudge placement failed: no suitable assistant message found (${messages.length} messages)`);
 }
-function appendSupplementalNudgeToAssistant(messages, nudge, nudgePlacements, sessionId) {
-  const appendToMessage = (message) => {
-    if (!isAppendableAssistantMessage(message))
-      return false;
-    for (let j = message.parts.length - 1;j >= 0; j--) {
-      const part = message.parts[j];
-      if (isTextPart(part)) {
-        const nextText = `${stripTrailingDeferredNotes(part.text)}${nudge}`;
-        if (nextText !== part.text) {
-          part.text = nextText;
-        }
-        return true;
-      }
-    }
-    message.parts.push({ type: "text", text: nudge });
-    return true;
-  };
-  const placement = nudgePlacements.get(sessionId);
-  if (!placement)
-    return false;
-  for (const message of messages) {
-    if (message.info.id !== placement.messageId)
-      continue;
-    return appendToMessage(message);
-  }
-  return false;
-}
-function canAppendSupplementalNudgeToAssistant(messages, nudgePlacements, sessionId) {
-  const placement = nudgePlacements.get(sessionId);
-  if (!placement)
-    return false;
-  const anchoredMessage = messages.find((message) => message.info.id === placement.messageId);
-  return anchoredMessage ? isAppendableAssistantMessage(anchoredMessage) : false;
-}
 
 // src/hooks/magic-context/apply-context-nudge.ts
 function applyContextNudge(messages, nudge, nudgePlacements, sessionId) {
@@ -20789,6 +20817,7 @@ function runPostTransformPhase(args) {
   const pendingOps = shouldReadPendingOps ? getPendingOps(args.db, args.sessionId) : [];
   const hasPendingUserOps = pendingOps.length > 0;
   const shouldApplyPendingOps = (args.schedulerDecision === "execute" || isExplicitFlush) && !compartmentRunning;
+  const isCacheBustingPass = isExplicitFlush || shouldApplyPendingOps;
   const shouldRunHeuristics = args.fullFeatureMode && !compartmentRunning && (isExplicitFlush || forceMaterialization || hasPendingUserOps && args.schedulerDecision === "execute" && !alreadyRanThisTurn);
   if (shouldRunHeuristics) {
     const reason = isExplicitFlush ? "explicit_flush" : forceMaterialization ? `force_materialization (${args.contextUsage.percentage.toFixed(1)}% >= ${args.forceMaterializationPercentage}%)` : `pending_ops_execute (pendingOps=${pendingOps.length}, scheduler=${args.schedulerDecision})`;
@@ -20854,9 +20883,10 @@ function runPostTransformPhase(args) {
   } catch (error48) {
     sessionLog(args.sessionId, "transform failed applying pending operations:", error48);
     updateSessionMeta(args.db, args.sessionId, { lastTransformError: getErrorMessage(error48) });
-    args.nudgePlacements.clear(args.sessionId);
+    if (isCacheBustingPass)
+      args.nudgePlacements.clear(args.sessionId);
   }
-  if (didMutateFromPendingOperations) {
+  if (didMutateFromPendingOperations && isCacheBustingPass) {
     args.nudgePlacements.clear(args.sessionId);
   }
   if (shouldRunHeuristics && (args.didMutateFromFlushedStatuses || didMutateFromPendingOperations)) {
@@ -20878,16 +20908,18 @@ function runPostTransformPhase(args) {
   if (strippedDropped > 0) {
     sessionLog(args.sessionId, `stripped ${strippedDropped} empty dropped-placeholder messages`);
   }
-  const protectedTailStart = Math.max(0, args.messages.length - args.protectedTags * 2);
-  const strippedSystemInjected = stripSystemInjectedMessages(args.messages, protectedTailStart);
-  if (strippedSystemInjected > 0) {
-    sessionLog(args.sessionId, `stripped ${strippedSystemInjected} system-injected messages (notifications/reminders)`);
+  if (isCacheBustingPass) {
+    const protectedTailStart = Math.max(0, args.messages.length - args.protectedTags * 2);
+    const strippedSystemInjected = stripSystemInjectedMessages(args.messages, protectedTailStart);
+    if (strippedSystemInjected > 0) {
+      sessionLog(args.sessionId, `stripped ${strippedSystemInjected} system-injected messages (notifications/reminders)`);
+    }
   }
   const pendingUserTurnReminder = getPersistedStickyTurnReminder(args.db, args.sessionId);
   if (pendingUserTurnReminder) {
-    if (args.hasRecentReduceCall) {
+    if (args.hasRecentReduceCall && isCacheBustingPass) {
       clearPersistedStickyTurnReminder(args.db, args.sessionId);
-      sessionLog(args.sessionId, "sticky turn reminder cleared \u2014 ctx_reduce found in recent messages");
+      sessionLog(args.sessionId, "sticky turn reminder cleared \u2014 ctx_reduce found in recent messages (cache-busting pass)");
     } else {
       if (pendingUserTurnReminder.messageId) {
         const reinjected = appendReminderToUserMessageById(args.messages, pendingUserTurnReminder.messageId, pendingUserTurnReminder.text);
@@ -20914,15 +20946,20 @@ function runPostTransformPhase(args) {
       const t9 = performance.now();
       applyContextNudge(args.messages, nudge, args.nudgePlacements, args.sessionId);
       logTransformTiming(args.sessionId, "applyContextNudge", t9);
-    } else {
+    } else if (isCacheBustingPass) {
       args.nudgePlacements.clear(args.sessionId);
+    } else {
+      const existing = args.nudgePlacements.get(args.sessionId);
+      if (existing) {
+        reinjectNudgeAtAnchor(args.messages, existing.nudgeText, args.nudgePlacements, args.sessionId);
+      }
     }
-    const canInjectDeferredNoteNudge = canAppendSupplementalNudgeToAssistant(args.messages, args.nudgePlacements, args.sessionId);
     const deferredNoteText = getNoteNudgeText(args.db, args.sessionId);
-    if (deferredNoteText && canInjectDeferredNoteNudge) {
-      appendSupplementalNudgeToAssistant(args.messages, `
+    if (deferredNoteText) {
+      const noteInstruction = `
 
-<instruction name="deferred_notes">${deferredNoteText}</instruction>`, args.nudgePlacements, args.sessionId);
+<instruction name="deferred_notes">${deferredNoteText}</instruction>`;
+      appendReminderToLatestUserMessage(args.messages, noteInstruction);
     }
   } else {
     args.nudgePlacements.clear(args.sessionId);
@@ -20989,10 +21026,13 @@ function createTransform(deps) {
     const fullFeatureMode = !reducedMode;
     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 isCacheBusting = deps.flushedSessions.has(sessionId) || schedulerDecisionEarly === "execute";
     let pendingCompartmentInjection = null;
     if (fullFeatureMode) {
       const projectPath = deps.memoryConfig?.enabled ? resolveProjectIdentity(deps.directory ?? process.cwd()) : undefined;
-      pendingCompartmentInjection = prepareCompartmentInjection(db, sessionId, messages, projectPath, deps.memoryConfig?.injectionBudgetTokens);
+      pendingCompartmentInjection = prepareCompartmentInjection(db, sessionId, messages, isCacheBusting, projectPath, deps.memoryConfig?.injectionBudgetTokens);
     }
     let targets = new Map;
     let reasoningByMessage = new Map;
@@ -21029,9 +21069,10 @@ function createTransform(deps) {
       logTransformTiming(sessionId, "batchFinalize:flushed", t2);
     } catch (error48) {
       sessionLog(sessionId, "transform failed applying flushed statuses:", error48);
-      deps.nudgePlacements.clear(sessionId);
+      if (isCacheBusting)
+        deps.nudgePlacements.clear(sessionId);
     }
-    if (didMutateFromFlushedStatuses) {
+    if (didMutateFromFlushedStatuses && isCacheBusting) {
       deps.nudgePlacements.clear(sessionId);
     }
     const t3 = performance.now();
@@ -21046,9 +21087,8 @@ function createTransform(deps) {
         watermark = tag.tagNumber;
       }
     }
-    const contextUsage = loadContextUsage(deps.contextUsageMap, db, sessionId);
-    const schedulerDecision = resolveSchedulerDecision(deps.scheduler, sessionMeta, contextUsage, sessionId);
-    const isCacheBusting = deps.flushedSessions.has(sessionId) || schedulerDecision === "execute";
+    const contextUsage = contextUsageEarly;
+    const schedulerDecision = schedulerDecisionEarly;
     const rawGetNotifParams = deps.getNotificationParams;
     const compartmentPhase = await runCompartmentPhase({
       canRunCompartments,
@@ -21127,11 +21167,13 @@ function createChatMessageHook(args) {
     const sessionId = input.sessionID;
     if (!sessionId)
       return;
-    const sessionMeta = getOrCreateSessionMeta(args.db, sessionId);
-    const turnUsage = args.toolUsageSinceUserTurn.get(sessionId);
-    const agentAlreadyReduced = args.recentReduceBySession.has(sessionId);
-    if (!sessionMeta.isSubagent && !agentAlreadyReduced && getPersistedStickyTurnReminder(args.db, sessionId) === null && turnUsage !== undefined && turnUsage >= TOOL_HEAVY_TURN_REMINDER_THRESHOLD) {
-      setPersistedStickyTurnReminder(args.db, sessionId, TOOL_HEAVY_TURN_REMINDER_TEXT);
+    if (args.ctxReduceEnabled !== false) {
+      const sessionMeta = getOrCreateSessionMeta(args.db, sessionId);
+      const turnUsage = args.toolUsageSinceUserTurn.get(sessionId);
+      const agentAlreadyReduced = args.recentReduceBySession.has(sessionId);
+      if (!sessionMeta.isSubagent && !agentAlreadyReduced && getPersistedStickyTurnReminder(args.db, sessionId) === null && turnUsage !== undefined && turnUsage >= TOOL_HEAVY_TURN_REMINDER_THRESHOLD) {
+        setPersistedStickyTurnReminder(args.db, sessionId, TOOL_HEAVY_TURN_REMINDER_TEXT);
+      }
     }
     args.toolUsageSinceUserTurn.set(sessionId, 0);
     const previousVariant = args.variantBySession.get(sessionId);
@@ -21177,6 +21219,8 @@ function createEventHook(args) {
       args.emergencyNudgeFired.delete(sessionId);
       return;
     }
+    if (args.ctxReduceEnabled === false)
+      return;
     if (args.emergencyNudgeFired.has(sessionId))
       return;
     const meta3 = getOrCreateSessionMeta(args.db, sessionId);
@@ -21249,12 +21293,18 @@ Use \`ctx_reduce\` to manage context size. It supports one operation:
 - \`drop\`: Remove entirely (best for tool outputs you already acted on).
 Syntax: "3-5", "1,2,9", or "1-5,8,12-15". Last ${protectedTags} tags are protected.
 Use \`ctx_note\` for deferred intentions \u2014 things to tackle later, not right now. NOT for task tracking (use todos). Notes survive context compression and you'll be reminded at natural work boundaries (after commits, historian runs, todo completion).
-Use \`ctx_memory\` to manage cross-session project memories. Write new memories, delete stale ones, or search stored memories by category. Memories persist across sessions and are automatically injected into new sessions.
+Use \`ctx_memory\` to manage cross-session project memories. Write new memories or delete stale ones. Memories persist across sessions and are automatically injected into new sessions.
+Use \`ctx_search\` to search across project memories, session facts, and conversation history from one query.
 Use \`ctx_expand\` to decompress a compartment range to see the original conversation transcript. Use \`start\`/\`end\` from \`<compartment start=N end=M>\` attributes. Returns the compacted U:/A: transcript for that message range, capped at ~15K tokens.
 NEVER drop large ranges blindly (e.g., "1-50"). Review each tag before deciding.
 NEVER drop user messages \u2014 they are short and will be summarized by compartmentalization automatically. Dropping them loses context the historian needs.
 NEVER drop assistant text messages unless they are exceptionally large. Your conversation messages are lightweight; only large tool outputs are worth dropping.
 Before your turn finishes, consider using \`ctx_reduce\` to drop large tool outputs you no longer need.`;
+var BASE_INTRO_NO_REDUCE = `Messages and tool outputs are tagged with \xA7N\xA7 identifiers (e.g., \xA71\xA7, \xA742\xA7).
+Use \`ctx_note\` for deferred intentions \u2014 things to tackle later, not right now. NOT for task tracking (use todos). Notes survive context compression and you'll be reminded at natural work boundaries (after commits, historian runs, todo completion).
+Use \`ctx_memory\` to manage cross-session project memories. Write new memories or delete stale ones. Memories persist across sessions and are automatically injected into new sessions.
+Use \`ctx_search\` to search across project memories, session facts, and conversation history from one query.
+Use \`ctx_expand\` to decompress a compartment range to see the original conversation transcript. Use \`start\`/\`end\` from \`<compartment start=N end=M>\` attributes. Returns the compacted U:/A: transcript for that message range, capped at ~15K tokens.`;
 var SISYPHUS_SECTION = `
 ### Reduction Triggers
 - After collecting background agent results (explore/librarian) \u2014 drop raw outputs once you extracted what you need.
@@ -21391,7 +21441,12 @@ function detectAgentFromSystemPrompt(systemPrompt) {
   }
   return null;
 }
-function buildMagicContextSection(agent, protectedTags) {
+function buildMagicContextSection(agent, protectedTags, ctxReduceEnabled = true) {
+  if (!ctxReduceEnabled) {
+    return `## Magic Context
+
+${BASE_INTRO_NO_REDUCE}`;
+  }
   const section = agent ? AGENT_SECTIONS[agent] : GENERIC_SECTION;
   return `## Magic Context
 
@@ -21412,7 +21467,7 @@ function createSystemPromptHashHandler(deps) {
 `);
     if (fullPrompt.length > 0 && !fullPrompt.includes(MAGIC_CONTEXT_MARKER)) {
       const detectedAgent = detectAgentFromSystemPrompt(fullPrompt);
-      const guidance = buildMagicContextSection(detectedAgent, deps.protectedTags);
+      const guidance = buildMagicContextSection(detectedAgent, deps.protectedTags, deps.ctxReduceEnabled);
       output.system.push(guidance);
       sessionLog(sessionId, `injected ${detectedAgent ?? "generic"} guidance into system prompt`);
     }
@@ -21487,13 +21542,14 @@ function createMagicContextHook(deps) {
   const liveModelBySession = new Map;
   const recentReduceBySession = new Map;
   const toolUsageSinceUserTurn = new Map;
-  const nudgerWithRecentReduce = createNudger({
+  const ctxReduceEnabled = deps.config.ctx_reduce_enabled !== false;
+  const nudgerWithRecentReduce = ctxReduceEnabled ? createNudger({
     protected_tags: deps.config.protected_tags,
     nudge_interval_tokens: deps.config.nudge_interval_tokens ?? DEFAULT_NUDGE_INTERVAL_TOKENS,
     iteration_nudge_threshold: deps.config.iteration_nudge_threshold ?? 15,
     execute_threshold_percentage: deps.config.execute_threshold_percentage ?? 65,
     recentReduceBySession
-  });
+  }) : () => null;
   const transform2 = createTransform({
     tagger: deps.tagger,
     scheduler: deps.scheduler,
@@ -21525,7 +21581,10 @@ function createMagicContextHook(deps) {
     tagger: deps.tagger,
     db,
     nudgePlacements,
-    onSessionCacheInvalidated: deps.onSessionCacheInvalidated
+    onSessionCacheInvalidated: (sessionId) => {
+      clearInjectionCache(sessionId);
+      deps.onSessionCacheInvalidated?.(sessionId);
+    }
   });
   const runDreamQueueInBackground = () => {
     const dreaming = deps.config.dreamer;
@@ -21596,6 +21655,7 @@ function createMagicContextHook(deps) {
   const systemPromptHashHandler = createSystemPromptHashHandler({
     db,
     protectedTags: deps.config.protected_tags,
+    ctxReduceEnabled,
     flushedSessions,
     lastHeuristicsTurnId
   });
@@ -21612,7 +21672,8 @@ function createMagicContextHook(deps) {
     lastHeuristicsTurnId,
     commitSeenLastPass,
     client: deps.client,
-    protectedTags: deps.config.protected_tags
+    protectedTags: deps.config.protected_tags,
+    ctxReduceEnabled
   });
   return {
     "experimental.chat.messages.transform": transform2,
@@ -21624,7 +21685,8 @@ function createMagicContextHook(deps) {
       recentReduceBySession,
       variantBySession,
       flushedSessions,
-      lastHeuristicsTurnId
+      lastHeuristicsTurnId,
+      ctxReduceEnabled
     }),
     event: async (input) => {
       await eventHook(input);
@@ -21727,18 +21789,17 @@ function createCtxExpandTools() {
 }
 // src/tools/ctx-memory/constants.ts
 var CTX_MEMORY_TOOL_NAME = "ctx_memory";
-var CTX_MEMORY_DESCRIPTION = `Manage cross-session project memories. Write new memories, delete stale ones, or search stored memories by category. Memories persist across sessions and are automatically injected into new sessions.
+var CTX_MEMORY_DESCRIPTION = `Manage cross-session project memories. Primary sessions can write new memories or delete stale ones. Dreamer sessions can also list, update, merge, and archive memories. Memories persist across sessions and are automatically injected into new sessions.
 
-Supported actions: write, delete, search, list, update, merge, archive.`;
+Supported actions: write, delete, list, update, merge, archive.`;
 var DEFAULT_SEARCH_LIMIT2 = 10;
 // src/tools/ctx-memory/tools.ts
 import { tool as tool2 } from "@opencode-ai/plugin";
 
 // src/tools/ctx-memory/types.ts
-var CTX_MEMORY_ACTIONS = [
-  "write",
-  "delete",
-  "search",
+var CTX_MEMORY_ACTIONS = ["write", "delete"];
+var CTX_MEMORY_DREAMER_ACTIONS = [
+  ...CTX_MEMORY_ACTIONS,
   "list",
   "update",
   "merge",
@@ -21746,9 +21807,6 @@ var CTX_MEMORY_ACTIONS = [
 ];
 
 // src/tools/ctx-memory/tools.ts
-var SEMANTIC_WEIGHT = 0.7;
-var FTS_WEIGHT = 0.3;
-var SINGLE_SOURCE_PENALTY = 0.8;
 var MEMORY_CATEGORIES = new Set(CATEGORY_PRIORITY);
 function isMemoryCategory2(value) {
   return MEMORY_CATEGORIES.has(value);
@@ -21760,31 +21818,12 @@ function normalizeLimit(limit) {
   return Math.max(1, Math.floor(limit));
 }
 function getAllowedActions(deps) {
-  const allowed = deps.allowedActions?.length ? deps.allowedActions : [...CTX_MEMORY_ACTIONS];
+  const allowed = deps.allowedActions?.length ? deps.allowedActions : [...CTX_MEMORY_DREAMER_ACTIONS];
   return [...allowed];
 }
 function normalizeCategory(category) {
   const trimmed = category?.trim();
-  return trimmed ? trimmed : undefined;
-}
-function normalizeCosineScore(score) {
-  if (!Number.isFinite(score)) {
-    return 0;
-  }
-  return Math.min(1, Math.max(0, score));
-}
-function formatSearchResults(query, results) {
-  if (results.length === 0) {
-    return `No memories found matching "${query}".`;
-  }
-  const noun = results.length === 1 ? "memory" : "memories";
-  const body = results.map((result, index) => `[${index + 1}] (score: ${result.score.toFixed(2)}) [${result.category}]
-${result.content}`).join(`
-
-`);
-  return `Found ${results.length} ${noun} matching "${query}":
-
-${body}`;
+  return trimmed ? trimmed : undefined;
 }
 function formatMemoryList(memories) {
   if (memories.length === 0) {
@@ -21843,77 +21882,6 @@ function filterByCategory(memories, category) {
   }
   return memories.filter((memory) => memory.category === category);
 }
-async function getSemanticScores(deps, query, memories) {
-  const semanticScores = new Map;
-  if (!deps.embeddingEnabled || !isEmbeddingEnabled() || memories.length === 0) {
-    return semanticScores;
-  }
-  const queryEmbedding = await embedText(query);
-  if (!queryEmbedding) {
-    return semanticScores;
-  }
-  const embeddings = await ensureMemoryEmbeddings({
-    db: deps.db,
-    memories,
-    existingEmbeddings: loadAllEmbeddings(deps.db, deps.projectPath)
-  });
-  for (const memory of memories) {
-    const memoryEmbedding = embeddings.get(memory.id);
-    if (!memoryEmbedding) {
-      continue;
-    }
-    semanticScores.set(memory.id, normalizeCosineScore(cosineSimilarity(queryEmbedding, memoryEmbedding)));
-  }
-  return semanticScores;
-}
-function getFtsScores(deps, query, category, limit = DEFAULT_SEARCH_LIMIT2) {
-  try {
-    const matches = filterByCategory(searchMemoriesFTS(deps.db, deps.projectPath, query, limit), category);
-    return new Map(matches.map((memory, rank) => [memory.id, 1 / (rank + 1)]));
-  } catch {
-    return new Map;
-  }
-}
-function mergeResults(memories, semanticScores, ftsScores, limit) {
-  const memoryById = new Map(memories.map((memory) => [memory.id, memory]));
-  const candidateIds = new Set([...semanticScores.keys(), ...ftsScores.keys()]);
-  const results = [];
-  for (const id of candidateIds) {
-    const memory = memoryById.get(id);
-    if (!memory) {
-      continue;
-    }
-    const semanticScore = semanticScores.get(id);
-    const ftsScore = ftsScores.get(id);
-    let score = 0;
-    let source = "fts";
-    if (semanticScore !== undefined && ftsScore !== undefined) {
-      score = SEMANTIC_WEIGHT * semanticScore + FTS_WEIGHT * ftsScore;
-      source = "hybrid";
-    } else if (semanticScore !== undefined) {
-      score = semanticScore * SINGLE_SOURCE_PENALTY;
-      source = "semantic";
-    } else if (ftsScore !== undefined) {
-      score = ftsScore * SINGLE_SOURCE_PENALTY;
-      source = "fts";
-    }
-    if (score > 0) {
-      results.push({
-        id,
-        category: memory.category,
-        content: memory.content,
-        score,
-        source
-      });
-    }
-  }
-  return results.sort((left, right) => {
-    if (right.score !== left.score) {
-      return right.score - left.score;
-    }
-    return left.id - right.id;
-  }).slice(0, limit);
-}
 function queueMemoryEmbedding(deps, memoryId, content) {
   (async () => {
     const embedding2 = await embedText(content);
@@ -21946,13 +21914,12 @@ function createCtxMemoryTool(deps) {
   return tool2({
     description: CTX_MEMORY_DESCRIPTION,
     args: {
-      action: tool2.schema.enum(CTX_MEMORY_ACTIONS).describe("Action to perform on memories"),
+      action: tool2.schema.enum(CTX_MEMORY_DREAMER_ACTIONS).describe("Action to perform on memories"),
       content: tool2.schema.string().optional().describe("Memory content (required for write, update, merge)"),
-      category: tool2.schema.string().optional().describe("Memory category (required for write, optional filter for search/list, optional override for merge)"),
+      category: tool2.schema.string().optional().describe("Memory category (required for write, optional filter for list, optional override for merge)"),
       id: tool2.schema.number().optional().describe("Memory ID (required for delete, update, archive)"),
       ids: tool2.schema.array(tool2.schema.number()).optional().describe("Memory IDs to merge (required for merge)"),
-      query: tool2.schema.string().optional().describe("Natural language search query for project memories (required for search)"),
-      limit: tool2.schema.number().optional().describe("Maximum results to return for search/list (default: 10)"),
+      limit: tool2.schema.number().optional().describe("Maximum results to return for list (default: 10)"),
       reason: tool2.schema.string().optional().describe("Archive reason (optional for archive)")
     },
     async execute(args, toolContext) {
@@ -22107,30 +22074,6 @@ function createCtxMemoryTool(deps) {
         archiveMemory(deps.db, args.id, args.reason);
         return args.reason?.trim() ? `Archived memory [ID: ${args.id}] (${args.reason.trim()}).` : `Archived memory [ID: ${args.id}].`;
       }
-      if (args.action === "search") {
-        if (typeof args.query !== "string") {
-          return "Error: 'query' must be provided when action is 'search'.";
-        }
-        const query = args.query.trim();
-        if (!query) {
-          return "Error: 'query' must be provided when action is 'search'.";
-        }
-        const limit = normalizeLimit(args.limit);
-        const category = normalizeCategory(args.category);
-        const projectMemories = filterByCategory(getMemoriesByProject(deps.db, deps.projectPath), category);
-        const ftsLimit = Math.max(limit * 5, projectMemories.length, DEFAULT_SEARCH_LIMIT2);
-        const semanticScores = await getSemanticScores(deps, query, projectMemories);
-        const ftsScores = getFtsScores(deps, query, category, ftsLimit);
-        const results = mergeResults(projectMemories, semanticScores, ftsScores, limit);
-        if (results.length > 0) {
-          deps.db.transaction(() => {
-            for (const result of results) {
-              updateMemoryRetrievalCount(deps.db, result.id);
-            }
-          })();
-        }
-        return formatSearchResults(query, results);
-      }
       return "Error: Unknown action.";
     }
   });
@@ -22335,8 +22278,458 @@ function createCtxReduceTools(deps) {
     ctx_reduce: createCtxReduceTool(deps)
   };
 }
-// src/plugin/normalize-tool-arg-schemas.ts
+// src/tools/ctx-search/constants.ts
+var CTX_SEARCH_TOOL_NAME = "ctx_search";
+var CTX_SEARCH_DESCRIPTION = "Search across project memories, session facts, and conversation history. Returns ranked results from all sources. Use message ordinals with ctx_expand to retrieve full conversation context around a result.";
+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 SEMANTIC_WEIGHT = 0.7;
+var FTS_WEIGHT = 0.3;
+var SINGLE_SOURCE_PENALTY = 0.8;
+var RESULT_PREVIEW_LIMIT = 220;
+var MEMORY_SOURCE_BOOST = 1.3;
+var FACT_SOURCE_BOOST = 1.15;
+var MESSAGE_SOURCE_BOOST = 1;
+var messageSearchStatements = new WeakMap;
+function normalizeLimit2(limit) {
+  if (typeof limit !== "number" || !Number.isFinite(limit)) {
+    return DEFAULT_UNIFIED_SEARCH_LIMIT;
+  }
+  return Math.max(1, Math.floor(limit));
+}
+function normalizeCosineScore(score) {
+  if (!Number.isFinite(score)) {
+    return 0;
+  }
+  return Math.min(1, Math.max(0, score));
+}
+function previewText(text) {
+  const normalized = text.replace(/\s+/g, " ").trim();
+  if (normalized.length <= RESULT_PREVIEW_LIMIT) {
+    return normalized;
+  }
+  return `${normalized.slice(0, RESULT_PREVIEW_LIMIT - 1).trimEnd()}\u2026`;
+}
+function tokenizeQuery(query) {
+  return Array.from(new Set(query.toLowerCase().split(/\s+/).map((token) => token.trim()).filter((token) => token.length > 0)));
+}
+function scoreTextMatch(content, query, extraText = "") {
+  const tokens = tokenizeQuery(query);
+  if (tokens.length === 0) {
+    return 0;
+  }
+  const haystack = `${content} ${extraText}`.toLowerCase();
+  const queryLower = query.trim().toLowerCase();
+  let matchedTokens = 0;
+  for (const token of tokens) {
+    if (haystack.includes(token)) {
+      matchedTokens++;
+    }
+  }
+  if (matchedTokens === 0) {
+    return 0;
+  }
+  let score = matchedTokens / tokens.length;
+  if (queryLower.length > 0 && haystack.includes(queryLower)) {
+    score += 0.35;
+  }
+  return Math.min(1, score);
+}
+function getMessageSearchStatement(db) {
+  let stmt = messageSearchStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("SELECT message_ordinal AS messageOrdinal, message_id AS messageId, role, content FROM message_history_fts WHERE session_id = ? AND message_history_fts MATCH ? ORDER BY bm25(message_history_fts), CAST(message_ordinal AS INTEGER) ASC LIMIT ?");
+    messageSearchStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getMessageOrdinal(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+async function getSemanticScores(args) {
+  const semanticScores = new Map;
+  if (!args.embeddingEnabled || !args.isEmbeddingRuntimeEnabled() || args.memories.length === 0) {
+    return semanticScores;
+  }
+  const queryEmbedding = await args.embedQuery(args.query);
+  if (!queryEmbedding) {
+    return semanticScores;
+  }
+  const embeddings = await ensureMemoryEmbeddings({
+    db: args.db,
+    memories: args.memories,
+    existingEmbeddings: loadAllEmbeddings(args.db, args.projectPath)
+  });
+  for (const memory of args.memories) {
+    const memoryEmbedding = embeddings.get(memory.id);
+    if (!memoryEmbedding) {
+      continue;
+    }
+    semanticScores.set(memory.id, normalizeCosineScore(cosineSimilarity(queryEmbedding, memoryEmbedding)));
+  }
+  return semanticScores;
+}
+function getFtsScores(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)]));
+  } catch {
+    return new Map;
+  }
+}
+function mergeMemoryResults(args) {
+  const memoryById = new Map(args.memories.map((memory) => [memory.id, memory]));
+  const candidateIds = new Set([...args.semanticScores.keys(), ...args.ftsScores.keys()]);
+  const results = [];
+  for (const id of candidateIds) {
+    const memory = memoryById.get(id);
+    if (!memory) {
+      continue;
+    }
+    const semanticScore = args.semanticScores.get(id);
+    const ftsScore = args.ftsScores.get(id);
+    let score = 0;
+    let matchType = "fts";
+    if (semanticScore !== undefined && ftsScore !== undefined) {
+      score = SEMANTIC_WEIGHT * semanticScore + FTS_WEIGHT * ftsScore;
+      matchType = "hybrid";
+    } else if (semanticScore !== undefined) {
+      score = semanticScore * SINGLE_SOURCE_PENALTY;
+      matchType = "semantic";
+    } else if (ftsScore !== undefined) {
+      score = ftsScore * SINGLE_SOURCE_PENALTY;
+      matchType = "fts";
+    }
+    if (score <= 0) {
+      continue;
+    }
+    results.push({
+      source: "memory",
+      content: previewText(memory.content),
+      score,
+      memoryId: memory.id,
+      category: memory.category,
+      matchType
+    });
+  }
+  return results.sort((left, right) => {
+    if (right.score !== left.score) {
+      return right.score - left.score;
+    }
+    return left.memoryId - right.memoryId;
+  }).slice(0, args.limit);
+}
+async function searchMemories(args) {
+  if (!args.memoryEnabled) {
+    return [];
+  }
+  const memories = getMemoriesByProject(args.db, args.projectPath);
+  if (memories.length === 0) {
+    return [];
+  }
+  const semanticScores = await getSemanticScores({
+    db: args.db,
+    projectPath: args.projectPath,
+    query: args.query,
+    memories,
+    embeddingEnabled: args.embeddingEnabled,
+    embedQuery: args.embedQuery,
+    isEmbeddingRuntimeEnabled: args.isEmbeddingRuntimeEnabled
+  });
+  const ftsScores = getFtsScores(args);
+  return mergeMemoryResults({
+    memories,
+    semanticScores,
+    ftsScores,
+    limit: args.limit
+  });
+}
+function searchFacts(args) {
+  return getSessionFacts(args.db, args.sessionId).map((fact) => ({
+    fact,
+    score: scoreTextMatch(fact.content, args.query, fact.category)
+  })).filter((candidate) => candidate.score > 0).sort((left, right) => {
+    if (right.score !== left.score) {
+      return right.score - left.score;
+    }
+    return left.fact.id - right.fact.id;
+  }).slice(0, args.limit).map(({ fact, score }) => ({
+    source: "fact",
+    content: previewText(fact.content),
+    score,
+    factId: fact.id,
+    factCategory: fact.category
+  }));
+}
+function searchMessages(args) {
+  ensureMessagesIndexed(args.db, args.sessionId, args.readMessages);
+  const sanitizedQuery = sanitizeFtsQuery(args.query.trim());
+  if (sanitizedQuery.length === 0) {
+    return [];
+  }
+  const rows = getMessageSearchStatement(args.db).all(args.sessionId, sanitizedQuery, args.limit).map((row) => row);
+  return rows.map((row, rank) => {
+    const messageOrdinal = getMessageOrdinal(row.messageOrdinal);
+    if (messageOrdinal === null || typeof row.messageId !== "string" || typeof row.role !== "string" || typeof row.content !== "string") {
+      return null;
+    }
+    return {
+      source: "message",
+      content: previewText(row.content),
+      score: 1 / (rank + 1),
+      messageOrdinal,
+      messageId: row.messageId,
+      role: row.role
+    };
+  }).filter((result) => result !== null);
+}
+function getSourceBoost(result) {
+  switch (result.source) {
+    case "memory":
+      return MEMORY_SOURCE_BOOST;
+    case "fact":
+      return FACT_SOURCE_BOOST;
+    case "message":
+      return MESSAGE_SOURCE_BOOST;
+  }
+}
+function compareUnifiedResults(left, right) {
+  const leftEffective = left.score * getSourceBoost(left);
+  const rightEffective = right.score * getSourceBoost(right);
+  if (rightEffective !== leftEffective) {
+    return rightEffective - leftEffective;
+  }
+  if (left.source === "memory" && right.source === "memory") {
+    return left.memoryId - right.memoryId;
+  }
+  if (left.source === "fact" && right.source === "fact") {
+    return left.factId - right.factId;
+  }
+  if (left.source === "message" && right.source === "message") {
+    return left.messageOrdinal - right.messageOrdinal;
+  }
+  return 0;
+}
+async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
+  const trimmedQuery = query.trim();
+  if (trimmedQuery.length === 0) {
+    return [];
+  }
+  const limit = normalizeLimit2(options.limit);
+  const tierLimit = Math.max(limit * 3, DEFAULT_UNIFIED_SEARCH_LIMIT);
+  const [memoryResults, factResults, messageResults] = await Promise.all([
+    searchMemories({
+      db,
+      projectPath,
+      query: trimmedQuery,
+      limit: tierLimit,
+      memoryEnabled: options.memoryEnabled ?? true,
+      embeddingEnabled: options.embeddingEnabled ?? true,
+      embedQuery: options.embedQuery ?? embedText,
+      isEmbeddingRuntimeEnabled: options.isEmbeddingRuntimeEnabled ?? isEmbeddingEnabled
+    }),
+    Promise.resolve(searchFacts({ db, sessionId, query: trimmedQuery, limit: tierLimit })),
+    Promise.resolve(searchMessages({
+      db,
+      sessionId,
+      query: trimmedQuery,
+      limit: tierLimit,
+      readMessages: options.readMessages ?? readRawSessionMessages
+    }))
+  ]);
+  const results = [...memoryResults, ...factResults, ...messageResults].sort(compareUnifiedResults).slice(0, limit);
+  const memoryIds = results.filter((result) => result.source === "memory").map((result) => result.memoryId);
+  if (memoryIds.length > 0) {
+    db.transaction(() => {
+      for (const memoryId of memoryIds) {
+        updateMemoryRetrievalCount(db, memoryId);
+      }
+    })();
+  }
+  return results;
+}
+
+// src/tools/ctx-search/tools.ts
+function normalizeLimit3(limit) {
+  if (typeof limit !== "number" || !Number.isFinite(limit)) {
+    return DEFAULT_CTX_SEARCH_LIMIT;
+  }
+  return Math.max(1, Math.floor(limit));
+}
+function formatResult(result, index) {
+  if (result.source === "memory") {
+    return [
+      `[${index}] [memory] score=${result.score.toFixed(2)} id=${result.memoryId} category=${result.category} match=${result.matchType}`,
+      result.content
+    ].join(`
+`);
+  }
+  if (result.source === "fact") {
+    return [
+      `[${index}] [fact] score=${result.score.toFixed(2)} category=${result.factCategory} id=${result.factId}`,
+      result.content
+    ].join(`
+`);
+  }
+  const expandStart = Math.max(1, result.messageOrdinal - 3);
+  const expandEnd = result.messageOrdinal + 3;
+  return [
+    `[${index}] [message] score=${result.score.toFixed(2)} ordinal=${result.messageOrdinal} role=${result.role}`,
+    result.content,
+    `Expand with ctx_expand(start=${expandStart}, end=${expandEnd}).`
+  ].join(`
+`);
+}
+function formatSearchResults(query, results) {
+  if (results.length === 0) {
+    return `No results found for "${query}" across memories, session facts, or message history.`;
+  }
+  const body = results.map((result, index) => formatResult(result, index + 1)).join(`
+
+`);
+  return `Found ${results.length} result${results.length === 1 ? "" : "s"} for "${query}":
+
+${body}`;
+}
+function createCtxSearchTool(deps) {
+  return tool5({
+    description: CTX_SEARCH_DESCRIPTION,
+    args: {
+      query: tool5.schema.string().describe("Search query across memories, facts, and conversation history."),
+      limit: tool5.schema.number().optional().describe("Maximum results to return (default: 10)")
+    },
+    async execute(args, toolContext) {
+      const query = args.query?.trim();
+      if (!query) {
+        return "Error: 'query' is required.";
+      }
+      const results = await unifiedSearch(deps.db, toolContext.sessionID, deps.projectPath, query, {
+        limit: normalizeLimit3(args.limit),
+        memoryEnabled: deps.memoryEnabled,
+        embeddingEnabled: deps.embeddingEnabled,
+        readMessages: deps.readMessages
+      });
+      return formatSearchResults(query, results);
+    }
+  });
+}
+function createCtxSearchTools(deps) {
+  return {
+    [CTX_SEARCH_TOOL_NAME]: createCtxSearchTool(deps)
+  };
+}
+// src/plugin/normalize-tool-arg-schemas.ts
+import { tool as tool6 } from "@opencode-ai/plugin";
 function stripRootJsonSchemaFields(jsonSchema) {
   const { $schema: _schema, ...rest } = jsonSchema;
   return rest;
@@ -22349,7 +22742,7 @@ function attachJsonSchemaOverride(schema) {
     const originalOverride = schema._zod.toJSONSchema;
     delete schema._zod.toJSONSchema;
     try {
-      return stripRootJsonSchemaFields(tool5.schema.toJSONSchema(schema));
+      return stripRootJsonSchemaFields(tool6.schema.toJSONSchema(schema));
     } finally {
       schema._zod.toJSONSchema = originalOverride;
     }
@@ -22390,20 +22783,27 @@ function createToolRegistry(args) {
       console.warn(`[magic-context] embedding model changed from ${storedModelId} to ${currentModelId}; cleared embeddings for project ${projectPath}`);
     }
   }
+  const ctxReduceEnabled = pluginConfig.ctx_reduce_enabled !== false;
   const allTools = {
-    ...createCtxReduceTools({
+    ...ctxReduceEnabled ? createCtxReduceTools({
       db,
       protectedTags: pluginConfig.protected_tags ?? DEFAULT_PROTECTED_TAGS
-    }),
+    }) : {},
     ...createCtxExpandTools(),
     ...createCtxNoteTools({ db }),
+    ...createCtxSearchTools({
+      db,
+      projectPath,
+      memoryEnabled,
+      embeddingEnabled: embeddingConfig2.provider !== "off"
+    }),
     ...memoryEnabled ? {
       ...createCtxMemoryTools({
         db,
         projectPath,
         memoryEnabled: true,
         embeddingEnabled: embeddingConfig2.provider !== "off",
-        allowedActions: ["write", "delete", "search"]
+        allowedActions: ["write", "delete"]
       })
     } : {}
   };
@@ -22503,12 +22903,18 @@ var plugin = async (ctx) => {
     ctx,
     pluginConfig
   });
-  const tools4 = createToolRegistry({
+  const tools5 = createToolRegistry({
     ctx,
     pluginConfig
   });
+  if (pluginConfig.dreamer) {
+    startDreamScheduleTimer({
+      client: ctx.client,
+      dreamerConfig: pluginConfig.dreamer
+    });
+  }
   return {
-    tool: tools4,
+    tool: tools5,
     event: createEventHandler({ magicContext: hooks.magicContext }),
     "experimental.chat.messages.transform": createMessagesTransformHandler({
       magicContext: hooks.magicContext