@cortexkit/opencode-magic-context 0.6.1 → 0.7.0

package/dist/index.js

@@ -22202,10 +22202,16 @@ var MagicContextConfigSchema = exports_external.object({
     user_memories: exports_external.object({
       enabled: exports_external.boolean().default(false),
       promotion_threshold: exports_external.number().min(2).max(20).default(3)
-    }).default({ enabled: false, promotion_threshold: 3 })
+    }).default({ enabled: false, promotion_threshold: 3 }),
+    pin_key_files: exports_external.object({
+      enabled: exports_external.boolean().default(false),
+      token_budget: exports_external.number().min(2000).max(30000).default(1e4),
+      min_reads: exports_external.number().min(2).max(20).default(4)
+    }).default({ enabled: false, token_budget: 1e4, min_reads: 4 })
   }).default({
     compaction_markers: false,
-    user_memories: { enabled: false, promotion_threshold: 3 }
+    user_memories: { enabled: false, promotion_threshold: 3 },
+    pin_key_files: { enabled: false, token_budget: 1e4, min_reads: 4 }
   }),
   memory: exports_external.object({
     enabled: exports_external.boolean().default(true),
@@ -23152,6 +23158,11 @@ function promoteRecompStaging(db, sessionId) {
     return { compartments: staging.compartments, facts: staging.facts };
   })();
 }
+function invalidateAllMemoryBlockCaches(db) {
+  try {
+    db.prepare("UPDATE session_meta SET memory_block_cache = '' WHERE memory_block_cache != ''").run();
+  } catch {}
+}
 function clearRecompStaging(db, sessionId) {
   db.transaction(() => {
     db.prepare("DELETE FROM recomp_compartments WHERE session_id = ?").run(sessionId);
@@ -23497,8 +23508,19 @@ function clearStaleEntries(db, maxAgeMs) {
   return result.changes;
 }
 // src/features/magic-context/dreamer/runner.ts
+import { Database } from "bun:sqlite";
 import { existsSync as existsSync4 } from "fs";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
+
+// src/shared/data-path.ts
+import * as os2 from "os";
+import * as path2 from "path";
+function getDataDir() {
+  return process.env.XDG_DATA_HOME ?? path2.join(os2.homedir(), ".local", "share");
+}
+function getOpenCodeStorageDir() {
+  return path2.join(getDataDir(), "opencode", "storage");
+}
 
 // src/shared/error-message.ts
 function getErrorMessage(error48) {
@@ -23508,6 +23530,189 @@ function getErrorMessage(error48) {
 // src/features/magic-context/dreamer/runner.ts
 init_logger();
 
+// src/features/magic-context/key-files/identify-key-files.ts
+init_logger();
+
+// src/features/magic-context/key-files/read-stats.ts
+function getSessionReadStats(openCodeDb, sessionId, minReads) {
+  const fullReads = openCodeDb.prepare(`
+        WITH full_reads AS (
+            SELECT 
+                json_extract(json_extract(data, '$.state'), '$.input.filePath') as file_path,
+                LENGTH(json_extract(json_extract(data, '$.state'), '$.output')) as output_bytes,
+                p.time_created,
+                ROW_NUMBER() OVER (
+                    PARTITION BY json_extract(json_extract(data, '$.state'), '$.input.filePath') 
+                    ORDER BY p.time_created DESC
+                ) as rn
+            FROM part p
+            WHERE p.session_id = ?
+                AND json_extract(data, '$.type') = 'tool'
+                AND json_extract(data, '$.tool') = 'read'
+                AND json_extract(json_extract(data, '$.state'), '$.input.filePath') IS NOT NULL
+                AND json_extract(json_extract(data, '$.state'), '$.input.startLine') IS NULL
+                AND json_extract(json_extract(data, '$.state'), '$.input.start_line') IS NULL
+                AND json_extract(json_extract(data, '$.state'), '$.input.endLine') IS NULL
+                AND json_extract(json_extract(data, '$.state'), '$.input.end_line') IS NULL
+                AND json_extract(json_extract(data, '$.state'), '$.input.offset') IS NULL
+                AND json_extract(json_extract(data, '$.state'), '$.input.limit') IS NULL
+        ),
+        file_counts AS (
+            SELECT file_path, COUNT(*) as full_read_count
+            FROM full_reads
+            GROUP BY file_path
+            HAVING full_read_count >= ?
+        )
+        SELECT 
+            r.file_path,
+            fc.full_read_count,
+            r.output_bytes as latest_read_bytes
+        FROM full_reads r
+        JOIN file_counts fc ON r.file_path = fc.file_path
+        WHERE r.rn = 1
+        ORDER BY fc.full_read_count DESC
+    `).all(sessionId, minReads);
+  if (fullReads.length === 0)
+    return [];
+  const editCounts = new Map;
+  const editRows = openCodeDb.prepare(`
+        SELECT 
+            json_extract(json_extract(data, '$.state'), '$.input.filePath') as file_path,
+            COUNT(*) as edit_count
+        FROM part p
+        WHERE p.session_id = ?
+            AND json_extract(data, '$.type') = 'tool'
+            AND json_extract(data, '$.tool') IN ('edit', 'write', 'mcp_edit', 'mcp_write')
+            AND json_extract(json_extract(data, '$.state'), '$.input.filePath') IS NOT NULL
+        GROUP BY file_path
+    `).all(sessionId);
+  for (const row of editRows) {
+    editCounts.set(row.file_path, row.edit_count);
+  }
+  return fullReads.map((row) => ({
+    filePath: row.file_path,
+    fullReadCount: row.full_read_count,
+    spreadAcrossCompartments: 0,
+    editCount: editCounts.get(row.file_path) ?? 0,
+    latestReadBytes: row.latest_read_bytes ?? 0,
+    latestReadTokens: Math.ceil((row.latest_read_bytes ?? 0) / 3.5)
+  }));
+}
+
+// src/features/magic-context/key-files/storage-key-files.ts
+init_logger();
+function getKeyFiles(db, sessionId) {
+  try {
+    const row = db.prepare("SELECT key_files FROM session_meta WHERE session_id = ?").get(sessionId);
+    if (!row?.key_files)
+      return [];
+    const parsed = JSON.parse(row.key_files);
+    if (!Array.isArray(parsed))
+      return [];
+    return parsed.filter((e) => typeof e === "object" && e !== null && typeof e.filePath === "string" && typeof e.tokens === "number");
+  } catch {
+    return [];
+  }
+}
+function setKeyFiles(db, sessionId, files) {
+  try {
+    db.prepare("INSERT OR IGNORE INTO session_meta (session_id) VALUES (?)").run(sessionId);
+    db.prepare("UPDATE session_meta SET key_files = ? WHERE session_id = ?").run(JSON.stringify(files), sessionId);
+  } catch (error48) {
+    sessionLog(sessionId, "failed to persist key files:", error48);
+  }
+}
+function greedyFitFiles(rankedFiles, tokenBudget) {
+  const selected = [];
+  let remainingBudget = tokenBudget;
+  for (const file2 of rankedFiles) {
+    if (file2.tokens <= 0)
+      continue;
+    if (file2.tokens > remainingBudget)
+      continue;
+    selected.push({ filePath: file2.filePath, tokens: file2.tokens });
+    remainingBudget -= file2.tokens;
+    if (remainingBudget <= 0)
+      break;
+  }
+  return selected;
+}
+
+// src/features/magic-context/key-files/identify-key-files.ts
+var KEY_FILES_SYSTEM_PROMPT = "You are a file importance evaluator. Given read statistics about files in a coding session, identify which are core orientation files worth pinning in context. Return a JSON array.";
+function buildKeyFilesPrompt(candidates, tokenBudget, minReads) {
+  const statsText = candidates.map((s) => `- **${s.filePath}** \u2014 ${s.fullReadCount} full reads, ${s.editCount} edits, ~${s.latestReadTokens} tokens`).join(`
+`);
+  return `## Identify Key Files for Pinning
+
+The following files were fully read ${minReads}+ times during a coding session.
+Identify which ones are **core orientation files** worth keeping permanently in context.
+
+### Signals of a core orientation file:
+- Read many times across different phases of work (not clustered in one task)
+- Read without editing \u2014 consulted for understanding, not modification
+- Contains architecture, configuration, types, or key abstractions
+
+### Signals of a NON-core file (exclude):
+- Read many times but always edited \u2014 actively working on it
+- Very large (>5000 tokens) \u2014 too expensive to pin
+- Test files, scripts, or generated files
+
+### Token budget: ${tokenBudget} tokens total
+
+### Files:
+${statsText}
+
+### Output Format
+Return a JSON array ranked by importance (most important first):
+\`\`\`json
+[
+  {"filePath": "src/path/to/file.ts", "tokens": 2500, "reason": "brief reason"}
+]
+\`\`\`
+
+Only include files you're confident are true orientation files. Return empty array if none qualify.`;
+}
+function parseKeyFilesOutput(text) {
+  const jsonMatch = text.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/) ?? text.match(/\[[\s\S]*\]/);
+  if (!jsonMatch)
+    return [];
+  try {
+    const raw = jsonMatch[1] ?? jsonMatch[0];
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed))
+      return [];
+    return parsed.filter((item) => typeof item === "object" && item !== null && typeof item.filePath === "string" && typeof item.tokens === "number").map((item) => ({ filePath: item.filePath, tokens: item.tokens }));
+  } catch {
+    return [];
+  }
+}
+function getKeyFileCandidates(openCodeDb, sessionId, minReads, tokenBudget) {
+  const stats = getSessionReadStats(openCodeDb, sessionId, minReads);
+  const maxPerFileTokens = Math.min(tokenBudget / 2, 5000);
+  return stats.filter((s) => s.latestReadTokens > 0 && s.latestReadTokens <= maxPerFileTokens);
+}
+function applyKeyFileResults(db, sessionId, llmRanked, tokenBudget, candidatePaths) {
+  const filtered = candidatePaths ? llmRanked.filter((f) => candidatePaths.has(f.filePath)) : llmRanked;
+  const selected = greedyFitFiles(filtered, tokenBudget);
+  setKeyFiles(db, sessionId, selected);
+  const totalTokens = selected.reduce((sum, f) => sum + f.tokens, 0);
+  log(`[key-files][${sessionId}] pinned ${selected.length} files (${totalTokens} tokens): ${selected.map((f) => f.filePath).join(", ")}`);
+  return { filesIdentified: selected.length, totalTokens };
+}
+function heuristicKeyFileSelection(db, sessionId, candidates, tokenBudget) {
+  const scored = candidates.map((c) => ({
+    filePath: c.filePath,
+    tokens: c.latestReadTokens,
+    score: c.fullReadCount * 2 - c.editCount * 3
+  })).filter((c) => c.score > 0).sort((a, b) => b.score - a.score);
+  const selected = greedyFitFiles(scored, tokenBudget);
+  setKeyFiles(db, sessionId, selected);
+  const totalTokens = selected.reduce((sum, f) => sum + f.tokens, 0);
+  log(`[key-files][${sessionId}] heuristic pinned ${selected.length} files (${totalTokens} tokens)`);
+  return { filesIdentified: selected.length, totalTokens };
+}
+
 // src/features/magic-context/memory/storage-memory-embeddings.ts
 var saveEmbeddingStatements = new WeakMap;
 var loadAllEmbeddingsStatements = new WeakMap;
@@ -24403,6 +24608,176 @@ function countNewIds(beforeIds, afterIds) {
   }
   return count;
 }
+function getOpenCodeDbPath() {
+  return join7(getDataDir(), "opencode", "opencode.db");
+}
+function openOpenCodeDb() {
+  const dbPath = getOpenCodeDbPath();
+  if (!existsSync4(dbPath)) {
+    log(`[key-files] OpenCode DB not found at ${dbPath} \u2014 skipping`);
+    return null;
+  }
+  try {
+    const db = new Database(dbPath, { readonly: true });
+    db.exec("PRAGMA busy_timeout = 5000");
+    return db;
+  } catch (error48) {
+    log(`[key-files] failed to open OpenCode DB at ${dbPath}: ${getErrorMessage(error48)}`);
+    return null;
+  }
+}
+function isSessionIdRow(row) {
+  if (row === null || typeof row !== "object") {
+    return false;
+  }
+  return typeof row.sessionId === "string";
+}
+function hasExplicitEmptyKeyFilesOutput(text) {
+  return /```(?:json)?\s*\[\s*\]\s*```/s.test(text) || /^\s*\[\s*\]\s*$/s.test(text);
+}
+async function getActiveProjectSessionIds(args) {
+  const listResponse = await args.client.session.list({
+    query: { directory: args.sessionDirectory ?? args.projectIdentity }
+  });
+  const sessions = normalizeSDKResponse(listResponse, [], {
+    preferResponseOnMissingData: true
+  });
+  const projectSessionIds = new Set(sessions.map((session) => typeof session?.id === "string" ? session.id : null).filter((sessionId) => Boolean(sessionId)));
+  if (projectSessionIds.size === 0) {
+    return [];
+  }
+  return args.db.prepare("SELECT session_id AS sessionId FROM session_meta WHERE is_subagent = 0 ORDER BY session_id ASC").all().filter(isSessionIdRow).map((row) => row.sessionId).filter((sessionId) => projectSessionIds.has(sessionId));
+}
+async function identifyKeyFilesForSession(args) {
+  let openCodeDb = null;
+  try {
+    openCodeDb = openOpenCodeDb();
+    if (!openCodeDb) {
+      return;
+    }
+    const candidates = getKeyFileCandidates(openCodeDb, args.sessionId, args.config.min_reads, args.config.token_budget);
+    if (candidates.length === 0) {
+      log(`[key-files][${args.sessionId}] no candidates found \u2014 skipping`);
+      return;
+    }
+    const prompt = buildKeyFilesPrompt(candidates, args.config.token_budget, args.config.min_reads);
+    const applyHeuristicFallback = () => {
+      heuristicKeyFileSelection(args.db, args.sessionId, candidates, args.config.token_budget);
+    };
+    let agentSessionId = null;
+    const abortController = new AbortController;
+    const leaseInterval = setInterval(() => {
+      try {
+        if (!renewLease(args.db, args.holderId)) {
+          log(`[key-files][${args.sessionId}] lease renewal failed \u2014 aborting`);
+          abortController.abort();
+        }
+      } catch {
+        abortController.abort();
+      }
+    }, 60000);
+    try {
+      const createResponse = await args.client.session.create({
+        body: {
+          ...args.parentSessionId ? { parentID: args.parentSessionId } : {},
+          title: `magic-context-dream-key-files-${args.sessionId.slice(0, 12)}`
+        },
+        query: { directory: args.sessionDirectory }
+      });
+      const created = normalizeSDKResponse(createResponse, null, { preferResponseOnMissingData: true });
+      agentSessionId = typeof created?.id === "string" ? created.id : null;
+      if (!agentSessionId) {
+        throw new Error("Could not create key-file identification session.");
+      }
+      log(`[key-files][${args.sessionId}] child session created ${agentSessionId}`);
+      const remainingMs = Math.max(0, args.deadline - Date.now());
+      await promptSyncWithModelSuggestionRetry(args.client, {
+        path: { id: agentSessionId },
+        query: { directory: args.sessionDirectory },
+        body: {
+          agent: DREAMER_AGENT,
+          system: KEY_FILES_SYSTEM_PROMPT,
+          parts: [{ type: "text", text: prompt }]
+        }
+      }, { timeoutMs: Math.min(remainingMs, 5 * 60 * 1000), signal: abortController.signal });
+      const messagesResponse = await args.client.session.messages({
+        path: { id: agentSessionId },
+        query: { directory: args.sessionDirectory }
+      });
+      const messages = normalizeSDKResponse(messagesResponse, [], {
+        preferResponseOnMissingData: true
+      });
+      const responseText = extractLatestAssistantText(messages);
+      if (!responseText) {
+        log(`[key-files][${args.sessionId}] no response from agent \u2014 using heuristic fallback`);
+        applyHeuristicFallback();
+        return;
+      }
+      const parsed = parseKeyFilesOutput(responseText);
+      if (parsed.length > 0 || hasExplicitEmptyKeyFilesOutput(responseText)) {
+        const candidatePaths = new Set(candidates.map((c) => c.filePath));
+        applyKeyFileResults(args.db, args.sessionId, parsed, args.config.token_budget, candidatePaths);
+        return;
+      }
+      log(`[key-files][${args.sessionId}] could not parse agent output \u2014 using heuristic fallback`);
+      applyHeuristicFallback();
+    } catch (error48) {
+      log(`[key-files][${args.sessionId}] identification failed: ${getErrorMessage(error48)} \u2014 using heuristic fallback`);
+      try {
+        applyHeuristicFallback();
+      } catch (fallbackError) {
+        log(`[key-files][${args.sessionId}] heuristic fallback failed: ${getErrorMessage(fallbackError)}`);
+      }
+    } finally {
+      clearInterval(leaseInterval);
+      if (agentSessionId) {
+        await args.client.session.delete({
+          path: { id: agentSessionId },
+          query: { directory: args.sessionDirectory }
+        }).catch((error48) => {
+          log(`[key-files][${args.sessionId}] session cleanup failed: ${getErrorMessage(error48)}`);
+        });
+      }
+    }
+  } finally {
+    if (openCodeDb) {
+      try {
+        openCodeDb.close(false);
+      } catch (error48) {
+        log(`[key-files][${args.sessionId}] failed to close OpenCode DB: ${getErrorMessage(error48)}`);
+      }
+    }
+  }
+}
+async function identifyKeyFiles(args) {
+  const sessionIds = await getActiveProjectSessionIds({
+    db: args.db,
+    client: args.client,
+    projectIdentity: args.projectIdentity,
+    sessionDirectory: args.sessionDirectory
+  });
+  if (sessionIds.length === 0) {
+    log(`[key-files] no active sessions found for ${args.projectIdentity}`);
+    return;
+  }
+  log(`[key-files] evaluating ${sessionIds.length} active session(s) for ${args.projectIdentity}`);
+  for (const sessionId of sessionIds) {
+    if (Date.now() > args.deadline) {
+      log("[key-files] deadline reached \u2014 stopping key-file identification");
+      break;
+    }
+    await identifyKeyFilesForSession({
+      db: args.db,
+      client: args.client,
+      parentSessionId: args.parentSessionId,
+      sessionDirectory: args.sessionDirectory,
+      holderId: args.holderId,
+      deadline: args.deadline,
+      sessionId,
+      config: args.config
+    });
+  }
+}
 async function runDream(args) {
   const holderId = crypto.randomUUID();
   const startedAt = Date.now();
@@ -24474,8 +24849,8 @@ async function runDream(args) {
       try {
         const docsDir = args.sessionDirectory ?? args.projectIdentity;
         const existingDocs = taskName === "maintain-docs" ? {
-          architecture: existsSync4(join6(docsDir, "ARCHITECTURE.md")),
-          structure: existsSync4(join6(docsDir, "STRUCTURE.md"))
+          architecture: existsSync4(join7(docsDir, "ARCHITECTURE.md")),
+          structure: existsSync4(join7(docsDir, "STRUCTURE.md"))
         } : undefined;
         const taskPrompt = buildDreamTaskPrompt(taskName, {
           projectPath: args.projectIdentity,
@@ -24581,6 +24956,22 @@ async function runDream(args) {
         log(`[dreamer] smart note evaluation failed: ${getErrorMessage(error48)}`);
       }
     }
+    if (args.experimentalPinKeyFiles?.enabled && Date.now() <= deadline) {
+      try {
+        await identifyKeyFiles({
+          db: args.db,
+          client: args.client,
+          projectIdentity: args.projectIdentity,
+          parentSessionId,
+          sessionDirectory: args.sessionDirectory ?? args.projectIdentity,
+          holderId,
+          deadline,
+          config: args.experimentalPinKeyFiles
+        });
+      } catch (error48) {
+        log(`[key-files] identification phase failed: ${getErrorMessage(error48)}`);
+      }
+    }
   } finally {
     releaseLease(args.db, holderId);
     log(`[dreamer] lease released: ${holderId}`);
@@ -24789,7 +25180,8 @@ async function processDreamQueue(args) {
       taskTimeoutMinutes: args.taskTimeoutMinutes,
       maxRuntimeMinutes: args.maxRuntimeMinutes,
       sessionDirectory: projectDirectory,
-      experimentalUserMemories: args.experimentalUserMemories
+      experimentalUserMemories: args.experimentalUserMemories,
+      experimentalPinKeyFiles: args.experimentalPinKeyFiles
     });
   } catch (error48) {
     log(`[dreamer] runDream threw for ${entry.projectIdentity}: ${getErrorMessage(error48)}`);
@@ -25286,7 +25678,7 @@ function getEmbeddingModelId() {
 
 // src/features/magic-context/memory/project-identity.ts
 import { execSync } from "child_process";
-import path2 from "path";
+import path3 from "path";
 var GIT_TIMEOUT_MS = 5000;
 var resolvedCache = new Map;
 function getRootCommitHash(directory) {
@@ -25305,12 +25697,12 @@ function getRootCommitHash(directory) {
   }
 }
 function directoryFallback(directory) {
-  const canonical = path2.resolve(directory);
+  const canonical = path3.resolve(directory);
   const hash2 = Bun.hash(canonical).toString(16).slice(0, 12);
   return `dir:${hash2}`;
 }
 function resolveProjectIdentity(directory) {
-  const resolved = path2.resolve(directory);
+  const resolved = path3.resolve(directory);
   const cached2 = resolvedCache.get(resolved);
   if (cached2 !== undefined) {
     return cached2;
@@ -25397,22 +25789,10 @@ function removeSystemReminders(text) {
 }
 
 // src/hooks/magic-context/read-session-db.ts
-import { Database } from "bun:sqlite";
+import { Database as Database2 } from "bun:sqlite";
 import { join as join8 } from "path";
-
-// src/shared/data-path.ts
-import * as os2 from "os";
-import * as path3 from "path";
-function getDataDir() {
-  return process.env.XDG_DATA_HOME ?? path3.join(os2.homedir(), ".local", "share");
-}
-function getOpenCodeStorageDir() {
-  return path3.join(getDataDir(), "opencode", "storage");
-}
-
-// src/hooks/magic-context/read-session-db.ts
 init_logger();
-function getOpenCodeDbPath() {
+function getOpenCodeDbPath2() {
   return join8(getDataDir(), "opencode", "opencode.db");
 }
 var cachedReadOnlyDb = null;
@@ -25429,12 +25809,12 @@ function closeCachedReadOnlyDb() {
   }
 }
 function getReadOnlySessionDb() {
-  const dbPath = getOpenCodeDbPath();
+  const dbPath = getOpenCodeDbPath2();
   if (cachedReadOnlyDb?.path === dbPath) {
     return cachedReadOnlyDb.db;
   }
   closeCachedReadOnlyDb();
-  const db = new Database(dbPath, { readonly: true });
+  const db = new Database2(dbPath, { readonly: true });
   cachedReadOnlyDb = { path: dbPath, db };
   return db;
 }
@@ -25877,7 +26257,6 @@ var upsertIndexStatements = new WeakMap;
 var deleteFtsStatements = new WeakMap;
 var deleteIndexStatements = new WeakMap;
 var countIndexedMessageStatements = new WeakMap;
-var deleteIndexedMessageStatements = new WeakMap;
 function normalizeIndexText(text) {
   return text.replace(/\s+/g, " ").trim();
 }
@@ -25929,14 +26308,6 @@ function getCountIndexedMessageStatement(db) {
   }
   return stmt;
 }
-function getDeleteIndexedMessageStatement(db) {
-  let stmt = deleteIndexedMessageStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare("DELETE FROM message_history_fts WHERE session_id = ? AND message_id = ?");
-    deleteIndexedMessageStatements.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;
@@ -25944,10 +26315,7 @@ function getLastIndexedOrdinal(db, sessionId) {
 function deleteIndexedMessage(db, sessionId, messageId) {
   const row = getCountIndexedMessageStatement(db).get(sessionId, messageId);
   const count = typeof row?.count === "number" ? row.count : 0;
-  if (count > 0) {
-    getDeleteIndexedMessageStatement(db).run(sessionId, messageId);
-  }
-  getDeleteIndexStatement(db).run(sessionId);
+  clearIndexedMessages(db, sessionId);
   return count;
 }
 function clearIndexedMessages(db, sessionId) {
@@ -25999,7 +26367,7 @@ function ensureMessagesIndexed(db, sessionId, readMessages) {
   })();
 }
 // src/features/magic-context/storage-db.ts
-import { Database as Database2 } from "bun:sqlite";
+import { Database as Database3 } from "bun:sqlite";
 import { mkdirSync } from "fs";
 import { join as join9 } from "path";
 init_logger();
@@ -26435,6 +26803,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   ensureColumn(db, "tags", "reasoning_byte_size", "INTEGER DEFAULT 0");
   ensureColumn(db, "session_meta", "system_prompt_tokens", "INTEGER DEFAULT 0");
   ensureColumn(db, "session_meta", "compaction_marker_state", "TEXT DEFAULT ''");
+  ensureColumn(db, "session_meta", "key_files", "TEXT DEFAULT ''");
 }
 function ensureColumn(db, table, column, definition) {
   if (!/^[a-z_]+$/.test(table) || !/^[a-z_]+$/.test(column) || !/^[A-Z0-9_'(),\s]+$/i.test(definition)) {
@@ -26448,7 +26817,7 @@ function ensureColumn(db, table, column, definition) {
 }
 function createFallbackDatabase() {
   try {
-    const fallback = new Database2(":memory:");
+    const fallback = new Database3(":memory:");
     initializeDatabase(fallback);
     runMigrations(fallback);
     return fallback;
@@ -26467,7 +26836,7 @@ function openDatabase() {
       return existing;
     }
     mkdirSync(dbDir, { recursive: true });
-    const db = new Database2(dbPath);
+    const db = new Database3(dbPath);
     initializeDatabase(db);
     runMigrations(db);
     databases.set(dbPath, db);
@@ -27019,7 +27388,8 @@ function startDreamScheduleTimer(args) {
     dreamerConfig,
     embeddingConfig: embeddingConfig2,
     memoryEnabled,
-    experimentalUserMemories
+    experimentalUserMemories,
+    experimentalPinKeyFiles
   } = args;
   const dreamingEnabled = Boolean(dreamerConfig?.enabled && dreamerConfig.schedule?.trim());
   const embeddingSweepEnabled = memoryEnabled && embeddingConfig2.provider !== "off";
@@ -27049,7 +27419,8 @@ function startDreamScheduleTimer(args) {
         tasks: dreamerConfig.tasks,
         taskTimeoutMinutes: dreamerConfig.task_timeout_minutes,
         maxRuntimeMinutes: dreamerConfig.max_runtime_minutes,
-        experimentalUserMemories
+        experimentalUserMemories,
+        experimentalPinKeyFiles
       }).catch((error48) => {
         log("[dreamer] timer-triggered queue processing failed:", error48);
       });
@@ -27848,7 +28219,8 @@ Dreaming is not configured for this project.`, {});
     tasks: deps.dreamer.config.tasks,
     taskTimeoutMinutes: deps.dreamer.config.task_timeout_minutes,
     maxRuntimeMinutes: deps.dreamer.config.max_runtime_minutes,
-    experimentalUserMemories: deps.dreamer.experimentalUserMemories
+    experimentalUserMemories: deps.dreamer.experimentalUserMemories,
+    experimentalPinKeyFiles: deps.dreamer.experimentalPinKeyFiles
   });
   await deps.sendNotification(sessionId, result ? summarizeDreamResult(result) : "Dream queued, but another worker is already processing the queue.", {});
   throw new Error(`${SENTINEL_PREFIX}CTX-DREAM_HANDLED__`);
@@ -27937,7 +28309,7 @@ Historian recomp started. Rebuilding compartments and facts from raw session his
 init_logger();
 
 // src/features/magic-context/compaction-marker.ts
-import { Database as Database3 } from "bun:sqlite";
+import { Database as Database4 } from "bun:sqlite";
 import { join as join10 } from "path";
 init_logger();
 var BASE62_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
@@ -27959,12 +28331,12 @@ function generateMessageId(timestampMs, counter = 0n) {
 function generatePartId(timestampMs, counter = 0n) {
   return generateId("prt", timestampMs, counter);
 }
-function getOpenCodeDbPath2() {
+function getOpenCodeDbPath3() {
   return join10(getDataDir(), "opencode", "opencode.db");
 }
 var cachedWriteDb = null;
 function getWritableOpenCodeDb() {
-  const dbPath = getOpenCodeDbPath2();
+  const dbPath = getOpenCodeDbPath3();
   if (cachedWriteDb?.path === dbPath) {
     return cachedWriteDb.db;
   }
@@ -27973,7 +28345,7 @@ function getWritableOpenCodeDb() {
       cachedWriteDb.db.close(false);
     } catch {}
   }
-  const db = new Database3(dbPath);
+  const db = new Database4(dbPath);
   db.exec("PRAGMA journal_mode=WAL");
   db.exec("PRAGMA busy_timeout=5000");
   cachedWriteDb = { path: dbPath, db };
@@ -28348,7 +28720,7 @@ function createEventHandler2(deps) {
           const contextLimit = resolveContextLimit(info.providerID, info.modelID, {
             modelContextLimitsCache: deps.config.modelContextLimitsCache
           });
-          const percentage = totalInputTokens / contextLimit * 100;
+          const percentage = contextLimit > 0 ? totalInputTokens / contextLimit * 100 : 0;
           sessionLog(info.sessionID, `event message.updated: totalInputTokens=${totalInputTokens} contextLimit=${contextLimit} percentage=${percentage.toFixed(1)}%`);
           deps.contextUsageMap.set(info.sessionID, {
             usage: {
@@ -31569,14 +31941,8 @@ function runPostTransformPhase(args) {
         const reinjected = appendReminderToUserMessageById(args.messages, pendingUserTurnReminder.messageId, pendingUserTurnReminder.text);
         if (!reinjected) {
           if (isCacheBustingPass) {
-            const newAnchorId = appendReminderToLatestUserMessage(args.messages, pendingUserTurnReminder.text);
-            if (newAnchorId) {
-              setPersistedStickyTurnReminder(args.db, args.sessionId, pendingUserTurnReminder.text, newAnchorId);
-              sessionLog(args.sessionId, `sticky turn reminder re-anchored: ${pendingUserTurnReminder.messageId} \u2192 ${newAnchorId}`);
-            } else {
-              clearPersistedStickyTurnReminder(args.db, args.sessionId);
-              sessionLog(args.sessionId, `sticky turn reminder cleared \u2014 anchor ${pendingUserTurnReminder.messageId} gone and no user message visible`);
-            }
+            clearPersistedStickyTurnReminder(args.db, args.sessionId);
+            sessionLog(args.sessionId, `sticky turn reminder cleared \u2014 anchor ${pendingUserTurnReminder.messageId} gone (compacted/deleted)`);
           } else {
             sessionLog(args.sessionId, `preserving sticky turn reminder anchor to avoid cache bust: messageId=${pendingUserTurnReminder.messageId}`);
           }
@@ -31617,13 +31983,8 @@ function runPostTransformPhase(args) {
     const reinjected = appendReminderToUserMessageById(args.messages, stickyNoteNudge.messageId, stickyNoteNudge.text);
     if (!reinjected) {
       if (isCacheBustingPass) {
-        const newAnchorId = appendReminderToLatestUserMessage(args.messages, stickyNoteNudge.text);
-        if (newAnchorId) {
-          markNoteNudgeDelivered(args.db, args.sessionId, stickyNoteNudge.text, newAnchorId);
-          sessionLog(args.sessionId, `sticky note nudge re-anchored: ${stickyNoteNudge.messageId} \u2192 ${newAnchorId}`);
-        } else {
-          sessionLog(args.sessionId, `sticky note nudge anchor ${stickyNoteNudge.messageId} gone \u2014 no user message visible to re-anchor`);
-        }
+        clearNoteNudgeState(args.db, args.sessionId);
+        sessionLog(args.sessionId, `sticky note nudge cleared \u2014 anchor ${stickyNoteNudge.messageId} gone (compacted/deleted)`);
       } else {
         sessionLog(args.sessionId, `preserving sticky note nudge anchor to avoid cache bust: messageId=${stickyNoteNudge.messageId}`);
       }
@@ -31983,8 +32344,8 @@ function createToolExecuteAfterHook(args) {
 }
 
 // src/hooks/magic-context/system-prompt-hash.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync4, realpathSync } from "fs";
+import { join as join12, resolve as resolve2, sep } from "path";
 
 // src/agents/magic-context-prompt.ts
 var BASE_INTRO = (protectedTags) => `Messages and tool outputs are tagged with \xA7N\xA7 identifiers (e.g., \xA71\xA7, \xA742\xA7).
@@ -32186,7 +32547,9 @@ init_logger();
 var MAGIC_CONTEXT_MARKER = "## Magic Context";
 var PROJECT_DOCS_MARKER = "<project-docs>";
 var USER_PROFILE_MARKER = "<user-profile>";
+var KEY_FILES_MARKER = "<key-files>";
 var cachedUserProfileBySession = new Map;
+var cachedKeyFilesBySession = new Map;
 var DOC_FILES = ["ARCHITECTURE.md", "STRUCTURE.md"];
 function readProjectDocs(directory) {
   const sections = [];
@@ -32268,6 +32631,72 @@ ${items}
         output.system.push(profileBlock);
       }
     }
+    if (deps.experimentalPinKeyFiles) {
+      const hasCachedKeyFiles = cachedKeyFilesBySession.has(sessionId);
+      if (!hasCachedKeyFiles || isCacheBusting) {
+        const keyFileEntries = getKeyFiles(deps.db, sessionId);
+        if (keyFileEntries.length > 0) {
+          const sections = [];
+          const projectRoot = resolve2(deps.directory);
+          let remainingBudgetTokens = deps.experimentalPinKeyFilesTokenBudget ?? 1e4;
+          for (const entry of keyFileEntries) {
+            try {
+              const absPath = resolve2(deps.directory, entry.filePath);
+              if (!absPath.startsWith(projectRoot + sep) && absPath !== projectRoot) {
+                log(`[magic-context] key file path escapes project root, skipping: ${entry.filePath}`);
+                continue;
+              }
+              if (!existsSync5(absPath))
+                continue;
+              let realPath;
+              try {
+                realPath = realpathSync(absPath);
+              } catch {
+                continue;
+              }
+              if (!realPath.startsWith(projectRoot + sep) && realPath !== projectRoot) {
+                log(`[magic-context] key file symlink escapes project root, skipping: ${entry.filePath} \u2192 ${realPath}`);
+                continue;
+              }
+              const content = readFileSync4(realPath, "utf-8").trim();
+              if (content.length === 0)
+                continue;
+              const fileTokens = estimateTokens(content);
+              if (fileTokens > remainingBudgetTokens) {
+                log(`[magic-context] key file ${entry.filePath} exceeds remaining budget (${fileTokens} > ${remainingBudgetTokens}), skipping`);
+                continue;
+              }
+              remainingBudgetTokens -= fileTokens;
+              sections.push(`<file path="${escapeXmlAttr(entry.filePath)}">
+${escapeXmlContent(content)}
+</file>`);
+            } catch (error48) {
+              log(`[magic-context] failed to read key file ${entry.filePath}:`, error48);
+            }
+          }
+          if (sections.length > 0) {
+            cachedKeyFilesBySession.set(sessionId, `${KEY_FILES_MARKER}
+${sections.join(`
+
+`)}
+</key-files>`);
+            if (!hasCachedKeyFiles) {
+              sessionLog(sessionId, `loaded ${sections.length} key file(s) into system prompt`);
+            } else {
+              sessionLog(sessionId, "refreshed key files (cache-busting pass)");
+            }
+          } else {
+            cachedKeyFilesBySession.set(sessionId, null);
+          }
+        } else {
+          cachedKeyFilesBySession.set(sessionId, null);
+        }
+      }
+      const keyFilesBlock = cachedKeyFilesBySession.get(sessionId);
+      if (keyFilesBlock && !fullPrompt.includes(KEY_FILES_MARKER)) {
+        output.system.push(keyFilesBlock);
+      }
+    }
     const DATE_PATTERN = /Today's date: .+/;
     for (let i = 0;i < output.system.length; i++) {
       const match = output.system[i].match(DATE_PATTERN);
@@ -32308,7 +32737,7 @@ ${items}
     } else if (previousHash === "" || previousHash === "0") {
       sessionLog(sessionId, `system prompt hash initialized: ${currentHash} (len=${systemContent.length})`);
     }
-    const systemPromptTokens = Math.ceil(systemContent.length / 4);
+    const systemPromptTokens = estimateTokens(systemContent);
     if (currentHash !== previousHash) {
       updateSessionMeta(deps.db, sessionId, {
         systemPromptHash: currentHash,
@@ -32442,6 +32871,11 @@ function createMagicContextHook(deps) {
       experimentalUserMemories: deps.config.experimental?.user_memories?.enabled ? {
         enabled: true,
         promotionThreshold: deps.config.experimental.user_memories?.promotion_threshold
+      } : undefined,
+      experimentalPinKeyFiles: deps.config.experimental?.pin_key_files?.enabled ? {
+        enabled: true,
+        token_budget: deps.config.experimental.pin_key_files?.token_budget,
+        min_reads: deps.config.experimental.pin_key_files?.min_reads
       } : undefined
     }).catch((error48) => {
       log("[dreamer] scheduled queue processing failed:", error48);
@@ -32488,6 +32922,11 @@ function createMagicContextHook(deps) {
       experimentalUserMemories: deps.config.experimental?.user_memories?.enabled ? {
         enabled: true,
         promotionThreshold: deps.config.experimental.user_memories?.promotion_threshold
+      } : undefined,
+      experimentalPinKeyFiles: deps.config.experimental?.pin_key_files?.enabled ? {
+        enabled: true,
+        token_budget: deps.config.experimental.pin_key_files?.token_budget,
+        min_reads: deps.config.experimental.pin_key_files?.min_reads
       } : undefined
     } : undefined
   });
@@ -32501,7 +32940,9 @@ function createMagicContextHook(deps) {
     directory: deps.directory,
     flushedSessions,
     lastHeuristicsTurnId,
-    experimentalUserMemories: deps.config.experimental?.user_memories?.enabled
+    experimentalUserMemories: deps.config.experimental?.user_memories?.enabled,
+    experimentalPinKeyFiles: deps.config.experimental?.pin_key_files?.enabled ?? false,
+    experimentalPinKeyFilesTokenBudget: deps.config.experimental?.pin_key_files?.token_budget
   });
   const eventHook = createEventHook({
     eventHandler,
@@ -32818,6 +33259,7 @@ function createCtxMemoryTool(deps) {
           memoryId: memory.id,
           content
         });
+        invalidateAllMemoryBlockCaches(deps.db);
         return `Saved memory [ID: ${memory.id}] in ${category}.`;
       }
       if (args.action === "delete") {
@@ -32829,6 +33271,7 @@ function createCtxMemoryTool(deps) {
           return `Error: Memory with ID ${args.id} was not found.`;
         }
         archiveMemory(deps.db, args.id);
+        invalidateAllMemoryBlockCaches(deps.db);
         return `Archived memory [ID: ${args.id}].`;
       }
       if (args.action === "list") {
@@ -32861,6 +33304,7 @@ function createCtxMemoryTool(deps) {
           memoryId: memory.id,
           content
         });
+        invalidateAllMemoryBlockCaches(deps.db);
         return `Updated memory [ID: ${memory.id}] in ${memory.category}.`;
       }
       if (args.action === "merge") {
@@ -32933,6 +33377,7 @@ function createCtxMemoryTool(deps) {
           memoryId: canonicalMemory.id,
           content
         });
+        invalidateAllMemoryBlockCaches(deps.db);
         const supersededIds = sourceMemories.map((memory) => memory.id).filter((id) => id !== canonicalMemory.id);
         return `Merged memories [${ids.join(", ")}] into canonical memory [ID: ${canonicalMemory.id}] in ${category}; superseded [${supersededIds.join(", ")}].`;
       }
@@ -32945,6 +33390,7 @@ function createCtxMemoryTool(deps) {
           return `Error: Memory with ID ${args.id} was not found.`;
         }
         archiveMemory(deps.db, args.id, args.reason);
+        invalidateAllMemoryBlockCaches(deps.db);
         return args.reason?.trim() ? `Archived memory [ID: ${args.id}] (${args.reason.trim()}).` : `Archived memory [ID: ${args.id}].`;
       }
       return "Error: Unknown action.";
@@ -32975,15 +33421,17 @@ Historian reads these notes, deduplicates them, and rewrites the remaining usefu
 import { tool as tool3 } from "@opencode-ai/plugin";
 function formatNoteLine(note) {
   const statusSuffix = note.status === "active" ? "" : ` (${note.status})`;
-  const dismissHint = note.status === "dismissed" ? "" : ` _(dismiss with \`ctx_note(action="dismiss", note_id=${note.id})\`)_`;
   if (note.type === "session") {
-    return `- **#${note.id}**${statusSuffix}: ${note.content}${dismissHint}`;
+    return `- **#${note.id}**${statusSuffix}: ${note.content}`;
   }
   const conditionText = note.status === "ready" ? note.readyReason ?? note.surfaceCondition ?? "Condition satisfied" : note.surfaceCondition ?? "No condition recorded";
   const conditionLabel = note.status === "ready" ? "Condition met" : "Condition";
   return `- **#${note.id}**${statusSuffix}: ${note.content}
-  ${conditionLabel}: ${conditionText}${dismissHint}`;
+  ${conditionLabel}: ${conditionText}`;
 }
+var DISMISS_FOOTER = `
+
+To dismiss a stale note: ctx_note(action="dismiss", note_id=N)`;
 function buildReadSections(args) {
   if (args.filter === undefined) {
     const sessionNotes2 = getSessionNotes(args.db, args.sessionId);
@@ -33122,7 +33570,7 @@ No session notes or smart notes.`;
       }
       return sections.join(`
 
-`);
+`) + DISMISS_FOOTER;
     }
   });
 }
@@ -33893,6 +34341,11 @@ var plugin = async (ctx) => {
       experimentalUserMemories: pluginConfig.experimental?.user_memories?.enabled ? {
         enabled: true,
         promotionThreshold: pluginConfig.experimental.user_memories?.promotion_threshold
+      } : undefined,
+      experimentalPinKeyFiles: pluginConfig.experimental?.pin_key_files?.enabled ? {
+        enabled: true,
+        token_budget: pluginConfig.experimental.pin_key_files?.token_budget,
+        min_reads: pluginConfig.experimental.pin_key_files?.min_reads
       } : undefined
     });
     startTuiActionConsumer({