@cortexkit/opencode-magic-context 0.1.3 → 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/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-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 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 getOpenCodeStorageDir() {
-  return path2.join(getDataDir(), "opencode", "storage");
+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;
 }
-
-// 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 getDreamState(db, key) {
+  const row = getGetDreamStateStatement(db).get(key);
+  return typeof row?.value === "string" ? row.value : null;
+}
+function setDreamState(db, key, value) {
+  getSetDreamStateStatement(db).run(key, value);
+}
+function deleteDreamState(db, key) {
+  getDeleteDreamStateStatement(db).run(key);
 }
-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");
+// 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 isLeaseActive(db) {
+  const expiry = getLeaseExpiry(db);
+  return expiry !== null && expiry > Date.now();
+}
+function getLeaseHolder(db) {
+  return getDreamState(db, LEASE_HOLDER_KEY);
+}
+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 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;
-  }
-  db.run(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+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 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 releaseLease(db, holderId) {
+  db.transaction(() => {
+    if (getLeaseHolder(db) !== holderId) {
+      return;
+    }
+    deleteDreamState(db, LEASE_HOLDER_KEY);
+    deleteDreamState(db, LEASE_HEARTBEAT_KEY);
+    deleteDreamState(db, LEASE_EXPIRY_KEY);
+  })();
 }
-function openDatabase() {
-  try {
-    const { dbDir, dbPath } = resolveDatabasePath();
-    const existing = databases.get(dbPath);
+// 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) {
-      if (!persistenceByDatabase.has(existing)) {
-        persistenceByDatabase.set(existing, true);
+      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 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 {
+    id: row.id,
+    projectIdentity: row.project_path,
+    reason: row.reason,
+    enqueuedAt: row.enqueued_at,
+    startedAt: null
+  };
+}
+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 removeDreamEntry(db, id) {
+  db.prepare("DELETE FROM dream_queue WHERE id = ?").run(id);
+}
+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 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}`);
       }
-      return existing;
+    } catch {
+      log("[dreamer] could not resolve parent session \u2014 child sessions will be visible in UI");
     }
-    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);
+  }
+  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);
+          });
+        }
       }
-      return existingFallback;
     }
-    const fallback = createFallbackDatabase();
-    databases.set(FALLBACK_DATABASE_KEY, fallback);
-    persistenceByDatabase.set(fallback, false);
-    persistenceErrorByDatabase.set(fallback, errorMessage);
-    return fallback;
+  } finally {
+    releaseLease(args.db, holderId);
+    log(`[dreamer] lease released: ${holderId}`);
   }
-}
-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 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/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 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 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;
+  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));
   }
-  return {
-    usage: {
-      percentage: result.last_context_percentage,
-      inputTokens: result.last_input_tokens
-    },
-    updatedAt: result.last_response_time || Date.now()
-  };
+  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 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)) {
+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;
   }
-  if (result.nudge_anchor_message_id.length === 0 || result.nudge_anchor_text.length === 0) {
+  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;
   }
-  return {
-    messageId: result.nudge_anchor_message_id,
-    nudgeText: result.nudge_anchor_text
-  };
-}
-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 clearPersistedNudgePlacement(db, sessionId) {
-  db.prepare("UPDATE session_meta SET nudge_anchor_message_id = '', nudge_anchor_text = '' WHERE session_id = ?").run(sessionId);
+  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 result;
 }
-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)) {
+// 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;
-  }
-  if (result.sticky_turn_reminder_text.length === 0) {
+  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 {
-    text: result.sticky_turn_reminder_text,
-    messageId: result.sticky_turn_reminder_message_id.length > 0 ? result.sticky_turn_reminder_message_id : 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 clearPersistedStickyTurnReminder(db, sessionId) {
-  db.prepare("UPDATE session_meta SET sticky_turn_reminder_text = '', sticky_turn_reminder_message_id = '' WHERE session_id = ?").run(sessionId);
-}
-// src/features/magic-context/storage-meta-session.ts
-function getOrCreateSessionMeta(db, sessionId) {
-  const result = db.prepare("SELECT session_id, last_response_time, cache_ttl, counter, last_nudge_tokens, last_nudge_band, last_transform_error, is_subagent, last_context_percentage, last_input_tokens, times_execute_threshold_reached, compartment_in_progress, system_prompt_hash FROM session_meta WHERE session_id = ?").get(sessionId);
-  if (isSessionMetaRow(result)) {
-    return toSessionMeta(result);
-  }
-  const defaults = getDefaultSessionMeta(sessionId);
-  ensureSessionMetaRow(db, sessionId);
-  return defaults;
-}
-function updateSessionMeta(db, sessionId, updates) {
-  const setClauses = [];
-  const values = [];
-  for (const [key, column] of Object.entries(META_COLUMNS)) {
-    const value = updates[key];
-    if (value === undefined)
-      continue;
-    if (value === null) {
-      setClauses.push(`${column} = ?`);
-      values.push("");
-    } else if (BOOLEAN_META_KEYS.has(key)) {
-      setClauses.push(`${column} = ?`);
-      values.push(value ? 1 : 0);
-    } else if (typeof value === "string" || typeof value === "number") {
-      setClauses.push(`${column} = ?`);
-      values.push(value);
-    }
-  }
-  if (setClauses.length === 0) {
-    return;
-  }
-  db.transaction(() => {
-    ensureSessionMetaRow(db, sessionId);
-    db.prepare(`UPDATE session_meta SET ${setClauses.join(", ")} WHERE session_id = ?`).run(...values, sessionId);
-  })();
-}
-function 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);
-  })();
+  const startMinutes = startHour * 60 + startMin;
+  const endMinutes = endHour * 60 + endMin;
+  return { startMinutes, endMinutes };
 }
-// src/features/magic-context/storage-notes.ts
-function isSessionNoteRow(row) {
-  if (row === null || typeof row !== "object")
+function isInScheduleWindow(schedule, now = new Date) {
+  const window = parseScheduleWindow(schedule);
+  if (!window)
     return false;
-  const candidate = row;
-  return typeof candidate.id === "number" && typeof candidate.session_id === "string" && typeof candidate.content === "string" && typeof candidate.created_at === "number";
+  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;
 }
-function toSessionNote(row) {
-  return {
-    id: row.id,
-    sessionId: row.session_id,
-    content: row.content,
-    createdAt: row.created_at
-  };
+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 projects;
 }
-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 checkScheduleAndEnqueue(db, schedule) {
+  if (!isInScheduleWindow(schedule)) {
+    return 0;
+  }
+  const projects = findProjectsNeedingDream(db);
+  if (projects.length === 0) {
+    return 0;
+  }
+  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 enqueued;
 }
-function addSessionNote(db, sessionId, content) {
-  db.prepare("INSERT INTO session_notes (session_id, content, created_at) VALUES (?, ?, ?)").run(sessionId, content, Date.now());
+// 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 clearSessionNotes(db, sessionId) {
-  db.prepare("DELETE FROM session_notes WHERE session_id = ?").run(sessionId);
+function getOpenCodeStorageDir() {
+  return path2.join(getDataDir(), "opencode", "storage");
 }
-// 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";
+
+// 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 toPendingOp(row) {
-  if (row.operation !== "drop") {
-    sessionLog(row.session_id, `unknown pending operation "${row.operation}"; ignoring`);
-    return null;
+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}`);
   }
-  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 rows = db.prepare(`PRAGMA table_info(${table})`).all();
+  if (rows.some((row) => row.name === column)) {
+    return;
   }
-  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);
+  db.run(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+}
+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)}`);
   }
-  return sources;
 }
-// src/features/magic-context/storage-tags.ts
-var insertTagStatements = new WeakMap;
-function getInsertTagStatement(db) {
-  let stmt = insertTagStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("INSERT INTO tags (session_id, message_id, type, byte_size, tag_number) VALUES (?, ?, ?, ?, ?)");
-    insertTagStatements.set(db, stmt);
+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;
   }
-  return stmt;
 }
-function isTagRow(row) {
+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.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";
+  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 toTagEntry(row) {
-  const type = row.type === "tool" ? "tool" : row.type === "file" ? "file" : "message";
-  const status = row.status === "dropped" || row.status === "compacted" ? row.status : "active";
+function getDefaultSessionMeta(sessionId) {
   return {
-    tagNumber: row.tag_number,
-    messageId: row.message_id,
-    type,
-    status,
-    byteSize: row.byte_size,
-    sessionId: row.session_id
+    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 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);
+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 ?? "");
 }
-// src/features/magic-context/compaction.ts
-function createCompactionHandler() {
+function toSessionMeta(row) {
   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 });
-    }
+    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/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;
-  }
-  return DEFAULT_CONTEXT_LIMIT;
+
+// 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 resolveCacheTtl(cacheTtl, modelKey) {
-  if (typeof cacheTtl === "string") {
-    return cacheTtl;
-  }
-  if (modelKey && typeof cacheTtl[modelKey] === "string") {
-    return cacheTtl[modelKey];
-  }
-  if (modelKey) {
-    const bareModelId = modelKey.split("/").slice(1).join("/");
-    if (bareModelId && typeof cacheTtl[bareModelId] === "string") {
-      return cacheTtl[bareModelId];
-    }
-  }
-  return cacheTtl.default ?? "5m";
+function 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 resolveExecuteThreshold(config2, modelKey, fallback) {
-  if (typeof config2 === "number") {
-    return config2;
-  }
-  if (modelKey && typeof config2[modelKey] === "number") {
-    return config2[modelKey];
-  }
-  if (modelKey) {
-    const bareModelId = modelKey.split("/").slice(1).join("/");
-    if (bareModelId && typeof config2[bareModelId] === "number") {
-      return config2[bareModelId];
-    }
-  }
-  return config2.default ?? fallback;
+function 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 resolveModelKey(providerID, modelID) {
-  if (!providerID || !modelID) {
-    return;
+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 `${providerID}/${modelID}`;
+  return {
+    usage: {
+      percentage: result.last_context_percentage,
+      inputTokens: result.last_input_tokens
+    },
+    updatedAt: result.last_response_time || Date.now()
+  };
 }
-function resolveSessionId(properties) {
-  if (typeof properties?.sessionID === "string") {
-    return properties.sessionID;
-  }
-  const info = properties?.info;
-  if (info === null || typeof info !== "object") {
-    return;
-  }
-  const record2 = info;
-  if (typeof record2.sessionID === "string") {
-    return record2.sessionID;
+function 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 (typeof record2.id === "string") {
-    return record2.id;
+  if (result.nudge_anchor_message_id.length === 0 || result.nudge_anchor_text.length === 0) {
+    return null;
   }
-  return;
+  return {
+    messageId: result.nudge_anchor_message_id,
+    nudgeText: result.nudge_anchor_text
+  };
 }
-
-// src/features/magic-context/scheduler.ts
-var TTL_PATTERN = /^(\d+)([smh])$/;
-var NUMERIC_PATTERN = /^\d+$/;
-var UNIT_TO_MS = {
-  s: 1000,
-  m: 60 * 1000,
-  h: 60 * 60 * 1000
-};
-function parseCacheTtl(ttl) {
-  const normalizedTtl = ttl.trim();
-  if (NUMERIC_PATTERN.test(normalizedTtl)) {
-    return Number(normalizedTtl);
+function 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 clearPersistedNudgePlacement(db, sessionId) {
+  db.prepare("UPDATE session_meta SET nudge_anchor_message_id = '', nudge_anchor_text = '' WHERE session_id = ?").run(sessionId);
+}
+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 match = normalizedTtl.match(TTL_PATTERN);
-  if (!match) {
-    throw new Error(`Invalid cache TTL format: ${ttl}`);
+  if (result.sticky_turn_reminder_text.length === 0) {
+    return null;
   }
-  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";
-    }
+    text: result.sticky_turn_reminder_text,
+    messageId: result.sticky_turn_reminder_message_id.length > 0 ? result.sticky_turn_reminder_message_id : null
   };
 }
-
-// src/features/magic-context/tagger.ts
-var GET_COUNTER_SQL = `SELECT counter FROM session_meta WHERE session_id = ?`;
-var GET_ASSIGNMENTS_SQL = "SELECT message_id, tag_number FROM tags WHERE session_id = ? ORDER BY tag_number ASC";
-function isAssignmentRow(row) {
-  if (row === null || typeof row !== "object") {
-    return false;
-  }
-  const candidate = row;
-  return typeof candidate.message_id === "string" && typeof candidate.tag_number === "number";
+function 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);
+  })();
 }
-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 clearPersistedStickyTurnReminder(db, sessionId) {
+  db.prepare("UPDATE session_meta SET sticky_turn_reminder_text = '', sticky_turn_reminder_message_id = '' WHERE session_id = ?").run(sessionId);
 }
-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;
+// 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);
   }
-  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 defaults = getDefaultSessionMeta(sessionId);
+  ensureSessionMetaRow(db, sessionId);
+  return defaults;
+}
+function updateSessionMeta(db, sessionId, updates) {
+  const setClauses = [];
+  const values = [];
+  for (const [key, column] of Object.entries(META_COLUMNS)) {
+    const value = updates[key];
+    if (value === undefined)
+      continue;
+    if (value === null) {
+      setClauses.push(`${column} = ?`);
+      values.push("");
+    } else if (BOOLEAN_META_KEYS.has(key)) {
+      setClauses.push(`${column} = ?`);
+      values.push(value ? 1 : 0);
+    } else if (typeof value === "string" || typeof value === "number") {
+      setClauses.push(`${column} = ?`);
+      values.push(value);
     }
-    const counter = Math.max(row?.counter ?? 0, maxTagNumber);
-    counters.set(sessionId, counter);
   }
-  function cleanup(sessionId) {
-    counters.delete(sessionId);
-    assignments.delete(sessionId);
+  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 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 {
-    assignTag,
-    getTag,
-    bindTag,
-    getAssignments,
-    resetCounter,
-    getCounter,
-    initFromDb,
-    cleanup
+    id: row.id,
+    sessionId: row.session_id,
+    content: row.content,
+    createdAt: row.created_at
   };
 }
-
-// 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);
+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 stmt;
+  return {
+    id: row.id,
+    sessionId: row.session_id,
+    tagId: row.tag_id,
+    operation: row.operation,
+    queuedAt: row.queued_at
+  };
 }
-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);
+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;
   }
-  return stmt;
+  const placeholders = tagIds.map(() => "?").join(", ");
+  const rows = db.prepare(`SELECT tag_id, content FROM source_contents WHERE session_id = ? AND tag_id IN (${placeholders})`).all(sessionId, ...tagIds).filter(isSourceContentRow);
+  const sources = new Map;
+  for (const row of rows) {
+    sources.set(row.tag_id, row.content);
+  }
+  return sources;
 }
-function getDeleteDreamStateStatement(db) {
-  let stmt = deleteDreamStateStatements.get(db);
+// src/features/magic-context/storage-tags.ts
+var insertTagStatements = new WeakMap;
+function getInsertTagStatement(db) {
+  let stmt = insertTagStatements.get(db);
   if (!stmt) {
-    stmt = db.prepare("DELETE FROM dream_state WHERE key = ?");
-    deleteDreamStateStatements.set(db, stmt);
+    stmt = db.prepare("INSERT INTO tags (session_id, message_id, type, byte_size, tag_number) VALUES (?, ?, ?, ?, ?)");
+    insertTagStatements.set(db, stmt);
   }
   return stmt;
 }
-function getDreamState(db, key) {
-  const row = getGetDreamStateStatement(db).get(key);
-  return typeof row?.value === "string" ? row.value : null;
-}
-function setDreamState(db, key, value) {
-  getSetDreamStateStatement(db).run(key, value);
+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 deleteDreamState(db, key) {
-  getDeleteDreamStateStatement(db).run(key);
+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
+  };
 }
-
-// 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 insertTag(db, sessionId, messageId, type, byteSize, tagNumber) {
+  getInsertTagStatement(db).run(sessionId, messageId, type, byteSize, tagNumber);
+  return tagNumber;
 }
-function isLeaseActive(db) {
-  const expiry = getLeaseExpiry(db);
-  return expiry !== null && expiry > Date.now();
+function updateTagStatus(db, sessionId, tagId, status) {
+  db.prepare("UPDATE tags SET status = ? WHERE session_id = ? AND tag_number = ?").run(status, sessionId, tagId);
 }
-function getLeaseHolder(db) {
-  return getDreamState(db, LEASE_HOLDER_KEY);
+function updateTagMessageId(db, sessionId, tagId, messageId) {
+  db.prepare("UPDATE tags SET message_id = ? WHERE session_id = ? AND tag_number = ?").run(messageId, sessionId, tagId);
 }
-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 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 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 getTopNBySize(db, sessionId, n) {
+  if (n <= 0) {
+    return [];
+  }
+  const rows = db.prepare("SELECT id, message_id, type, status, byte_size, session_id, tag_number FROM tags WHERE session_id = ? AND status = 'active' ORDER BY byte_size DESC, tag_number ASC LIMIT ?").all(sessionId, n).filter(isTagRow);
+  return rows.map(toTagEntry);
 }
-function releaseLease(db, holderId) {
-  db.transaction(() => {
-    if (getLeaseHolder(db) !== holderId) {
-      return;
+// src/plugin/dream-timer.ts
+var DREAM_TIMER_INTERVAL_MS = 15 * 60 * 1000;
+function startDreamScheduleTimer(args) {
+  const { client, dreamerConfig } = args;
+  if (!dreamerConfig.enabled || !dreamerConfig.schedule?.trim()) {
+    return;
+  }
+  const timer = setInterval(() => {
+    try {
+      const db = openDatabase();
+      checkScheduleAndEnqueue(db, dreamerConfig.schedule);
+      processDreamQueue({
+        db,
+        client,
+        tasks: dreamerConfig.tasks,
+        taskTimeoutMinutes: dreamerConfig.task_timeout_minutes,
+        maxRuntimeMinutes: dreamerConfig.max_runtime_minutes
+      }).catch((error48) => {
+        log("[dreamer] timer-triggered queue processing failed:", error48);
+      });
+    } catch (error48) {
+      log("[dreamer] timer-triggered schedule check failed:", error48);
     }
-    deleteDreamState(db, LEASE_HOLDER_KEY);
-    deleteDreamState(db, LEASE_HEARTBEAT_KEY);
-    deleteDreamState(db, LEASE_EXPIRY_KEY);
-  })();
+  }, DREAM_TIMER_INTERVAL_MS);
+  if (typeof timer === "object" && "unref" in timer) {
+    timer.unref();
+  }
+  log(`[dreamer] started independent schedule timer (every ${DREAM_TIMER_INTERVAL_MS / 60000}m)`);
 }
-// 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/plugin/event.ts
+function createEventHandler(args) {
+  return async (input) => {
+    await args.magicContext?.event?.(input);
+  };
 }
-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;
+
+// src/features/magic-context/compaction.ts
+function createCompactionHandler() {
   return {
-    id: row.id,
-    projectIdentity: row.project_path,
-    reason: row.reason,
-    enqueuedAt: row.enqueued_at,
-    startedAt: null
+    onCompacted(sessionId, db) {
+      db.transaction(() => {
+        db.prepare("UPDATE tags SET status = 'compacted' WHERE session_id = ? AND status IN ('active', 'dropped')").run(sessionId);
+        db.prepare("DELETE FROM pending_ops WHERE session_id = ?").run(sessionId);
+      })();
+      updateSessionMeta(db, sessionId, { lastNudgeBand: null });
+    }
   };
 }
-function 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 removeDreamEntry(db, id) {
-  db.prepare("DELETE FROM dream_queue WHERE id = ?").run(id);
+
+// src/hooks/is-anthropic-provider.ts
+function isAnthropicProvider(providerID) {
+  return providerID === "anthropic" || providerID === "google-vertex-anthropic";
 }
-function resetDreamEntry(db, id) {
-  db.prepare("UPDATE dream_queue SET started_at = NULL, retry_count = COALESCE(retry_count, 0) + 1 WHERE id = ?").run(id);
+
+// src/hooks/magic-context/event-resolvers.ts
+var DEFAULT_CONTEXT_LIMIT = 200000;
+function resolveContextLimit(providerID, modelID, config2) {
+  if (!providerID) {
+    return DEFAULT_CONTEXT_LIMIT;
+  }
+  if (modelID) {
+    const modelSpecific = config2.modelContextLimitsCache?.get(`${providerID}/${modelID}`);
+    if (typeof modelSpecific === "number" && modelSpecific > 0) {
+      return modelSpecific;
+    }
+  }
+  if (isAnthropicProvider(providerID)) {
+    return 1e6;
+  }
+  return DEFAULT_CONTEXT_LIMIT;
 }
-function getEntryRetryCount(db, id) {
-  const row = db.query("SELECT retry_count FROM dream_queue WHERE id = ?").get(id);
-  return row?.retry_count ?? 0;
+function resolveCacheTtl(cacheTtl, modelKey) {
+  if (typeof cacheTtl === "string") {
+    return cacheTtl;
+  }
+  if (modelKey && typeof cacheTtl[modelKey] === "string") {
+    return cacheTtl[modelKey];
+  }
+  if (modelKey) {
+    const bareModelId = modelKey.split("/").slice(1).join("/");
+    if (bareModelId && typeof cacheTtl[bareModelId] === "string") {
+      return cacheTtl[bareModelId];
+    }
+  }
+  return cacheTtl.default ?? "5m";
 }
-function 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 resolveExecuteThreshold(config2, modelKey, fallback) {
+  if (typeof config2 === "number") {
+    return config2;
+  }
+  if (modelKey && typeof config2[modelKey] === "number") {
+    return config2[modelKey];
+  }
+  if (modelKey) {
+    const bareModelId = modelKey.split("/").slice(1).join("/");
+    if (bareModelId && typeof config2[bareModelId] === "number") {
+      return config2[bareModelId];
+    }
+  }
+  return config2.default ?? fallback;
 }
-// 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 resolveModelKey(providerID, modelID) {
+  if (!providerID || !modelID) {
+    return;
+  }
+  return `${providerID}/${modelID}`;
 }
-function resolveDreamSessionDirectory(projectIdentity) {
-  return dreamProjectDirectories.get(projectIdentity) ?? projectIdentity;
+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;
 }
-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;
+
+// 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);
   }
-  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 match = normalizedTtl.match(TTL_PATTERN);
+  if (!match) {
+    throw new Error(`Invalid cache TTL format: ${ttl}`);
   }
-  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
-        });
+  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) {
-        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);
-          });
+        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";
     }
-  } finally {
-    releaseLease(args.db, holderId);
-    log(`[dreamer] lease released: ${holderId}`);
-  }
-  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));
+  };
+}
+
+// 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 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;
+  const candidate = row;
+  return typeof candidate.message_id === "string" && typeof candidate.tag_number === "number";
 }
-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;
+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);
   }
-  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;
+  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;
   }
-  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);
+  function assignTag(sessionId, messageId, type, byteSize, db) {
+    const sessionAssignments = getSessionAssignments(sessionId);
+    const existing = sessionAssignments.get(messageId);
+    if (existing !== undefined) {
+      return existing;
     }
-  } else {
-    removeDreamEntry(args.db, entry.id);
+    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 result;
-}
-// 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 getTag(sessionId, messageId) {
+    return assignments.get(sessionId)?.get(messageId);
   }
-  const startMinutes = startHour * 60 + startMin;
-  const endMinutes = endHour * 60 + endMin;
-  return { startMinutes, endMinutes };
-}
-function isInScheduleWindow(schedule, now = new Date) {
-  const window = parseScheduleWindow(schedule);
-  if (!window)
-    return false;
-  const currentMinutes = now.getHours() * 60 + now.getMinutes();
-  if (window.startMinutes <= window.endMinutes) {
-    return currentMinutes >= window.startMinutes && currentMinutes < window.endMinutes;
+  function bindTag(sessionId, messageId, tagNumber) {
+    getSessionAssignments(sessionId).set(messageId, tagNumber);
   }
-  return currentMinutes >= window.startMinutes || currentMinutes < window.endMinutes;
-}
-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);
-    }
+  function getAssignments(sessionId) {
+    return getSessionAssignments(sessionId);
   }
-  return projects;
-}
-function checkScheduleAndEnqueue(db, schedule) {
-  if (!isInScheduleWindow(schedule)) {
-    return 0;
+  function resetCounter(sessionId, db) {
+    counters.set(sessionId, 0);
+    assignments.delete(sessionId);
+    getUpsertCounterStatement(db).run(sessionId, 0);
   }
-  const projects = findProjectsNeedingDream(db);
-  if (projects.length === 0) {
-    return 0;
+  function getCounter(sessionId) {
+    return counters.get(sessionId) ?? 0;
   }
-  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 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";
@@ -21120,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);
@@ -21170,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);
@@ -21242,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.
@@ -21384,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
 
@@ -21405,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`);
     }
@@ -21480,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,
@@ -21592,6 +21655,7 @@ function createMagicContextHook(deps) {
   const systemPromptHashHandler = createSystemPromptHashHandler({
     db,
     protectedTags: deps.config.protected_tags,
+    ctxReduceEnabled,
     flushedSessions,
     lastHeuristicsTurnId
   });
@@ -21608,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,
@@ -21620,7 +21685,8 @@ function createMagicContextHook(deps) {
       recentReduceBySession,
       variantBySession,
       flushedSessions,
-      lastHeuristicsTurnId
+      lastHeuristicsTurnId,
+      ctxReduceEnabled
     }),
     event: async (input) => {
       await eventHook(input);
@@ -21723,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",
@@ -21742,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);
@@ -21756,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) {
@@ -21839,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);
@@ -21942,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) {
@@ -22103,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.";
     }
   });
@@ -22331,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;
@@ -22345,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;
     }
@@ -22386,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"]
       })
     } : {}
   };
@@ -22499,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