@cortexkit/opencode-magic-context 0.47.0 → 0.48.0

package/dist/v2/{server-e0c1b7a7.js → server-psqc7e9n.js}

@@ -1,19 +1,11 @@
 import {
-  log
-} from "./server-1qbnzc80.js";
+  log2
+} from "./server-5m3dt5r1.js";
 import {
-  resolveWorkspaceShareCategories,
-  resolveWorkspaceIdentitySet,
-  expandWorkspaceIdentitySetWithAliases,
-  resolveStoredPathWorkspaceIdentity,
-  sourceNameForMemory
-} from "./server-njt3np1k.js";
+  loadCompartmentChunkEmbeddingsForSearch
+} from "./server-ezhze64f.js";
 import {
-  loadCompartmentChunkEmbeddingsForSearch,
-  getIndexedMessageCorpusSize,
   recordEmbeddingMeasurement,
-  getNotes,
-  getActivePrimers,
   saveCommitEmbedding,
   loadProjectCommitEmbeddings,
   loadUnembeddedCommits,
@@ -21,30 +13,50 @@ import {
   upsertCommits,
   getLatestIndexedCommitSha,
   enforceProjectCap,
-  getProjectEmbeddings,
-  contentSha256,
-  getShadowEmbeddingMeasurementCohort,
-  getPrimaryEmbeddingMeasurementCohort,
-  embedShadowTextForProject,
-  enqueueShadowEmbeddingItems,
-  getProjectEmbeddingSnapshot,
-  embedItemsForProject,
+  contentSha2562,
+  getShadowEmbeddingMeasurementCohort2,
+  getPrimaryEmbeddingMeasurementCohort2,
+  embedShadowTextForProject2,
+  enqueueShadowEmbeddingItems2,
+  getProjectEmbeddingSnapshot2,
+  embedItemsForProject2
+} from "./server-7wwc2nga.js";
+import {
+  getProjectEmbeddings2
+} from "./server-4dhv7mqz.js";
+import {
   cosineSimilarity,
   isEmbeddingEnabled,
   embedText,
-  ensureMemoryEmbeddings,
-  ModuleMemoryAuthorityError,
-  getMemoriesByProject,
-  getMemoriesByProjects,
-  updateMemoryRetrievalCount,
+  ensureMemoryEmbeddings2
+} from "./server-gjcr4w98.js";
+import {
+  ModuleMemoryAuthorityError2,
+  getMemoriesByProject2,
+  getMemoriesByProjects2,
+  updateMemoryRetrievalCount2
+} from "./server-7jzrrxap.js";
+import {
+  getNotes,
+  getActivePrimers,
   relaxedFtsQuery,
   sanitizeFtsQuery,
   searchMemoriesFTS,
   searchMemoriesFTSUnion
-} from "./server-3trjk1hx.js";
+} from "./server-8tqanswc.js";
+import {
+  getIndexedMessageCorpusSize
+} from "./server-sggvvzhb.js";
+import {
+  resolveWorkspaceShareCategories,
+  resolveWorkspaceIdentitySet,
+  expandWorkspaceIdentitySetWithAliases,
+  resolveStoredPathWorkspaceIdentity,
+  sourceNameForMemory
+} from "./server-e0vdaae2.js";
 import {
   isKnownAutocommit
-} from "./server-ajzeteqw.js";
+} from "./server-8ajstryz.js";
 
 // src/features/magic-context/git-commits/git-log-reader.ts
 import { execFile } from "node:child_process";
@@ -96,19 +108,19 @@ async function readGitCommitsResult(directory, options = {}) {
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     if (exclusion && message.includes("bad object")) {
-      log(`[git-commits] indexed tip ${exclusion.slice(0, 7)} is missing for ${projectLabel}; reading the full window`);
+      log2(`[git-commits] indexed tip ${exclusion.slice(0, 7)} is missing for ${projectLabel}; reading the full window`);
       return readGitCommitsResult(directory, { ...options, excludeReachableFrom: undefined });
     }
     const failure = classifyGitLogFailure(message);
     if (failure === "transient") {
-      log(`[git-commits] readGitCommits failed for ${projectLabel}: ${message.slice(0, 500)}`);
+      log2(`[git-commits] readGitCommits failed for ${projectLabel}: ${message.slice(0, 500)}`);
     } else {
-      log(`[git-commits] ${projectLabel} is not indexable (${failure})`);
+      log2(`[git-commits] ${projectLabel} is not indexable (${failure})`);
     }
     return { commits: [], failure };
   }
   if (stdout.trim().length === 0) {
-    log(`[git-commits] readGitCommits returned empty stdout for ${projectLabel} (sinceMs=${options.sinceMs ?? "none"} args=${args.slice(0, 4).join(" ")})`);
+    log2(`[git-commits] readGitCommits returned empty stdout for ${projectLabel} (sinceMs=${options.sinceMs ?? "none"} args=${args.slice(0, 4).join(" ")})`);
   }
   return { commits: parseGitLogOutput(stdout), failure: null };
 }
@@ -169,7 +181,7 @@ async function indexCommitsForProject(db, projectPath, directory, options) {
     nonIndexable: false
   };
   if (indexInProgress.has(projectPath)) {
-    log(`[git-commits] index already in progress for ${projectPath}, skipping`);
+    log2(`[git-commits] index already in progress for ${projectPath}, skipping`);
     return result;
   }
   indexInProgress.add(projectPath);
@@ -190,21 +202,21 @@ async function indexCommitsForProject(db, projectPath, directory, options) {
     }
     if (commits.length === 0) {
       result.evicted = enforceProjectCap(db, projectPath, options.maxCommits);
-      log(`[git-commits] no new commits for ${projectPath} (sinceMs=${sinceMs} latestIndexed=${latestIndexed?.slice(0, 7) ?? "none"} evicted=${result.evicted})`);
+      log2(`[git-commits] no new commits for ${projectPath} (sinceMs=${sinceMs} latestIndexed=${latestIndexed?.slice(0, 7) ?? "none"} evicted=${result.evicted})`);
       return result;
     }
-    log(`[git-commits] read ${commits.length} commits for ${projectPath} (sinceMs=${sinceMs} latestIndexed=${latestIndexed?.slice(0, 7) ?? "none"})`);
+    log2(`[git-commits] read ${commits.length} commits for ${projectPath} (sinceMs=${sinceMs} latestIndexed=${latestIndexed?.slice(0, 7) ?? "none"})`);
     const upsert = upsertCommits(db, projectPath, commits);
     result.inserted = upsert.inserted;
     result.updated = upsert.updated;
     result.evicted = enforceProjectCap(db, projectPath, options.maxCommits);
-    const snapshot = getProjectEmbeddingSnapshot(projectPath);
+    const snapshot = getProjectEmbeddingSnapshot2(projectPath);
     if (options.skipEmbed || !snapshot?.gitCommitEnabled) {
-      log(`[git-commits] indexed ${projectPath}: scanned=${result.scanned} inserted=${result.inserted} updated=${result.updated} evicted=${result.evicted} embedded=0 (embedding skipped: skipEmbed=${options.skipEmbed === true} gitCommitEnabled=${snapshot?.gitCommitEnabled === true})`);
+      log2(`[git-commits] indexed ${projectPath}: scanned=${result.scanned} inserted=${result.inserted} updated=${result.updated} evicted=${result.evicted} embedded=0 (embedding skipped: skipEmbed=${options.skipEmbed === true} gitCommitEnabled=${snapshot?.gitCommitEnabled === true})`);
       return result;
     }
     result.embedded = await embedUnembeddedCommits(db, projectPath);
-    log(`[git-commits] indexed ${projectPath}: scanned=${result.scanned} inserted=${result.inserted} updated=${result.updated} evicted=${result.evicted} embedded=${result.embedded}`);
+    log2(`[git-commits] indexed ${projectPath}: scanned=${result.scanned} inserted=${result.inserted} updated=${result.updated} evicted=${result.evicted} embedded=${result.embedded}`);
     return result;
   } finally {
     indexInProgress.delete(projectPath);
@@ -214,7 +226,7 @@ async function embedUnembeddedCommits(db, projectPath) {
   if (embedInProgress.has(projectPath)) {
     return 0;
   }
-  const snapshot = getProjectEmbeddingSnapshot(projectPath);
+  const snapshot = getProjectEmbeddingSnapshot2(projectPath);
   if (!snapshot?.gitCommitEnabled) {
     return 0;
   }
@@ -229,10 +241,10 @@ async function embedUnembeddedCommits(db, projectPath) {
         break;
       let embeddedThisBatch = 0;
       try {
-        const result = await embedItemsForProject(projectPath, rows.map((row) => ({
+        const result = await embedItemsForProject2(projectPath, rows.map((row) => ({
           id: `commit:${row.sha}`,
           text: row.message,
-          contentSha256: contentSha256(row.message)
+          contentSha256: contentSha2562(row.message)
         })), undefined, db, projectPath);
         if (!result)
           break;
@@ -245,9 +257,9 @@ async function embedUnembeddedCommits(db, projectPath) {
             embeddedThisBatch += 1;
           }
         }).immediate();
-        enqueueShadowEmbeddingItems(projectPath, "commit", rows.filter((row) => result.vectors.has(`commit:${row.sha}`)).map((row) => row.sha));
+        enqueueShadowEmbeddingItems2(projectPath, "commit", rows.filter((row) => result.vectors.has(`commit:${row.sha}`)).map((row) => row.sha));
       } catch (error) {
-        log(`[git-commits] embed batch failed for ${projectPath}: ${error instanceof Error ? error.message : String(error)}`);
+        log2(`[git-commits] embed batch failed for ${projectPath}: ${error instanceof Error ? error.message : String(error)}`);
         break;
       }
       if (embeddedThisBatch === 0)
@@ -258,7 +270,7 @@ async function embedUnembeddedCommits(db, projectPath) {
     }
     if (total > 0) {
       const totalEmbedded = countEmbeddedCommits(db, projectPath, snapshot.modelId);
-      log(`[git-commits] embedded ${total} commits for ${projectPath} (total embedded: ${totalEmbedded})`);
+      log2(`[git-commits] embedded ${total} commits for ${projectPath} (total embedded: ${totalEmbedded})`);
     }
     return total;
   } finally {
@@ -395,7 +407,7 @@ function searchGitCommitsSync(db, projectPath, query, options) {
         ftsCandidates.push(rowToCommit(row));
       }
     } catch (error) {
-      log(`[git-commits] FTS query failed for "${trimmed}": ${error instanceof Error ? error.message : String(error)}`);
+      log2(`[git-commits] FTS query failed for "${trimmed}": ${error instanceof Error ? error.message : String(error)}`);
     }
   }
   if (ftsCandidates.length === 0) {
@@ -584,15 +596,15 @@ function resultId(result) {
 }
 async function recordShadowMeasurement(args) {
   try {
-    const shadowCohort = getShadowEmbeddingMeasurementCohort(args.projectPath);
+    const shadowCohort = getShadowEmbeddingMeasurementCohort2(args.projectPath);
     if (!shadowCohort)
       return;
-    const primaryCohort = getPrimaryEmbeddingMeasurementCohort(args.projectPath);
+    const primaryCohort = getPrimaryEmbeddingMeasurementCohort2(args.projectPath);
     const shadowStartedAt = Date.now();
     let shadowFailed = false;
     let shadowResults = [];
     try {
-      const vector = await embedShadowTextForProject(args.projectPath, args.query);
+      const vector = await embedShadowTextForProject2(args.projectPath, args.query);
       if (!vector) {
         shadowFailed = true;
       } else {
@@ -648,7 +660,7 @@ async function recordShadowMeasurement(args) {
       }
     });
   } catch (error) {
-    log("[magic-context] shadow embedding measurement failed:", error);
+    log2("[magic-context] shadow embedding measurement failed:", error);
   }
 }
 function sha256(value) {
@@ -677,13 +689,31 @@ var sessionFirstMessageSearchDiagnosticStatements = new WeakMap;
 var messageSearchDiagnosticStatementsWithDateRange = new WeakMap;
 var batchedMessageSearchStatements = new WeakMap;
 var batchedFtsCountStatements = new WeakMap;
-function createUnifiedSearchDiagnostics() {
+function createUnifiedSearchDiagnostics2() {
   return {
     suppressedVisibleMemoryIds: [],
     suppressedLiveMessageMatches: 0,
     gitCommitUnavailable: null
   };
 }
+function searchMessageHistory2(db, request) {
+  const diagnostics = request.collectDiagnostics ? createUnifiedSearchDiagnostics2() : undefined;
+  const results = searchMessages({
+    db,
+    sessionId: request.sessionId,
+    query: request.query,
+    limit: request.limit,
+    maxOrdinal: request.maxOrdinal,
+    probes: request.probes,
+    relaxedRecall: request.relaxedRecall,
+    diagnostics,
+    dateRange: request.dateRange
+  });
+  return {
+    results,
+    suppressedLiveMessageMatches: diagnostics?.suppressedLiveMessageMatches ?? 0
+  };
+}
 function normalizeLimit(limit) {
   if (typeof limit !== "number" || !Number.isFinite(limit)) {
     return DEFAULT_UNIFIED_SEARCH_LIMIT;
@@ -703,7 +733,7 @@ function timestampIsInRange(timestamp, range) {
 }
 var ID_SHAPED_QUERY_MAX_TOKENS = 5;
 var ID_SHAPED_TOKEN = /^#?\d+$/;
-function parseIdShapedQuery(query) {
+function parseIdShapedQuery2(query) {
   const trimmed = query.trim();
   if (trimmed.length === 0) {
     return null;
@@ -978,8 +1008,8 @@ async function getSemanticScores(args) {
     return semanticScores;
   }
   if (!args.workspace?.isWorkspaced) {
-    const cachedEmbeddings = getProjectEmbeddings(args.db, args.projectPath, args.queryModelId);
-    const embeddings = args.backfillMemoryEmbeddings === false ? cachedEmbeddings : await ensureMemoryEmbeddings({
+    const cachedEmbeddings = getProjectEmbeddings2(args.db, args.projectPath, args.queryModelId);
+    const embeddings = args.backfillMemoryEmbeddings === false ? cachedEmbeddings : await ensureMemoryEmbeddings2({
       db: args.db,
       projectIdentity: args.projectPath,
       memories: args.memories,
@@ -1006,8 +1036,8 @@ async function getSemanticScores(args) {
   }
   const ownMemories = memoriesByIdentity.get(args.projectPath) ?? [];
   if (ownMemories.length > 0 && args.backfillMemoryEmbeddings !== false) {
-    const ownEmbeddings = getProjectEmbeddings(args.db, args.projectPath, args.queryModelId);
-    await ensureMemoryEmbeddings({
+    const ownEmbeddings = getProjectEmbeddings2(args.db, args.projectPath, args.queryModelId);
+    await ensureMemoryEmbeddings2({
       db: args.db,
       projectIdentity: args.projectPath,
       memories: ownMemories,
@@ -1018,7 +1048,7 @@ async function getSemanticScores(args) {
     const memberMemories = memoriesByIdentity.get(identity) ?? [];
     if (memberMemories.length === 0)
       continue;
-    const cachedEmbeddings = getProjectEmbeddings(args.db, identity, args.queryModelId);
+    const cachedEmbeddings = getProjectEmbeddings2(args.db, identity, args.queryModelId);
     for (const memory of memberMemories) {
       const memoryEmbedding = cachedEmbeddings.get(memory.id);
       if (!memoryEmbedding || memoryEmbedding.modelId !== args.queryModelId)
@@ -1032,7 +1062,7 @@ function getFtsMatches(args) {
   try {
     return args.workspace?.isWorkspaced ? searchMemoriesFTSUnion(args.db, args.workspace.expandedIdentities, args.query, args.limit, args.workspace.ownIdentities, args.workspace.shareCategories, args.dateRange) : searchMemoriesFTS(args.db, args.projectPath, args.query, args.limit, args.dateRange);
   } catch (error) {
-    log(`[search] FTS query failed for "${args.query}": ${error instanceof Error ? error.message : String(error)}`);
+    log2(`[search] FTS query failed for "${args.query}": ${error instanceof Error ? error.message : String(error)}`);
     return [];
   }
 }
@@ -1047,7 +1077,7 @@ function selectSemanticCandidates(args) {
   if (args.queryModelId && args.queryModelId !== "off") {
     const embeddingProjects = args.workspace?.isWorkspaced ? args.workspace.identities : [args.projectPath];
     for (const projectPath of embeddingProjects) {
-      const storedEmbeddings = getProjectEmbeddings(args.db, projectPath, args.queryModelId);
+      const storedEmbeddings = getProjectEmbeddings2(args.db, projectPath, args.queryModelId);
       for (const memoryId of storedEmbeddings.keys()) {
         candidateIds.add(memoryId);
       }
@@ -1110,7 +1140,7 @@ async function searchMemories(args) {
   if (!args.memoryEnabled) {
     return { results: [], suppressedVisibleIds: [] };
   }
-  const unfilteredMemories = args.workspace?.isWorkspaced ? getMemoriesByProjects(args.db, args.workspace.expandedIdentities, ["active", "permanent"], Date.now(), args.workspace.ownIdentities, args.workspace.shareCategories) : getMemoriesByProject(args.db, args.projectPath);
+  const unfilteredMemories = args.workspace?.isWorkspaced ? getMemoriesByProjects2(args.db, args.workspace.expandedIdentities, ["active", "permanent"], Date.now(), args.workspace.ownIdentities, args.workspace.shareCategories) : getMemoriesByProject2(args.db, args.projectPath);
   const memories = unfilteredMemories.filter((memory) => timestampIsInRange(memory.createdAt, args.dateRange));
   if (memories.length === 0) {
     return { results: [], suppressedVisibleIds: [] };
@@ -1737,7 +1767,7 @@ function memoriesToIdLookupResults(args) {
     sourceName: args.sourceNameByMemoryId?.get(memory.id)
   }));
 }
-function resolveMemoriesByIdsForSearch(args) {
+function resolveMemoriesByIdsForSearch2(args) {
   if (args.diagnostics) {
     args.diagnostics.suppressedVisibleMemoryIds = [];
   }
@@ -1745,7 +1775,7 @@ function resolveMemoriesByIdsForSearch(args) {
     return null;
   }
   const workspace = resolveSearchWorkspaceContext(args.db, args.projectPath);
-  const fetched = workspace.isWorkspaced ? getMemoriesByProjects(args.db, workspace.expandedIdentities, ["active", "permanent", "archived"], Date.now(), workspace.ownIdentities, workspace.shareCategories) : getMemoriesByProject(args.db, args.projectPath, ["active", "permanent", "archived"]);
+  const fetched = workspace.isWorkspaced ? getMemoriesByProjects2(args.db, workspace.expandedIdentities, ["active", "permanent", "archived"], Date.now(), workspace.ownIdentities, workspace.shareCategories) : getMemoriesByProject2(args.db, args.projectPath, ["active", "permanent", "archived"]);
   if (fetched.length === 0) {
     return null;
   }
@@ -1781,7 +1811,7 @@ function resolveMemoriesByIdsForSearch(args) {
     })
   });
 }
-async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
+async function unifiedSearch2(db, sessionId, projectPath, query, options = {}) {
   const trimmedQuery = query.trim();
   const measurementStartedAt = Date.now();
   if (trimmedQuery.length === 0 || options.signal?.aborted) {
@@ -1812,28 +1842,41 @@ async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
   const runCompartmentChunks = runMessages && embeddingEnabled;
   const needsEmbedding = (runMemory || runGitCommits || runCompartmentChunks || runPrimers) && embeddingEnabled && isEmbeddingRuntimeEnabled();
   const queryEmbeddingPromise = needsEmbedding ? embedQuery(trimmedQuery, options.signal).catch((error) => {
-    log(`[search] query embedding failed: ${error instanceof Error ? error.message : String(error)}`);
+    log2(`[search] query embedding failed: ${error instanceof Error ? error.message : String(error)}`);
     return null;
   }) : Promise.resolve(null);
   await Promise.resolve();
   if (options.signal?.aborted)
     return [];
   const messageProbes = options.explicitSearch ? extractLiteralProbes(trimmedQuery) : [];
-  const messageResults = runMessages ? searchMessages({
-    db,
-    sessionId,
-    query: trimmedQuery,
-    limit: tierLimit,
-    maxOrdinal: options.maxMessageOrdinal,
-    probes: messageProbes,
-    relaxedRecall: options.explicitSearch,
-    diagnostics: options.diagnostics,
-    dateRange
-  }) : [];
+  let messageResults = [];
+  if (runMessages) {
+    const messageRequest = {
+      sessionId,
+      query: trimmedQuery,
+      limit: tierLimit,
+      maxOrdinal: options.maxMessageOrdinal,
+      probes: messageProbes,
+      relaxedRecall: options.explicitSearch,
+      collectDiagnostics: options.diagnostics !== undefined,
+      dateRange
+    };
+    const delegated = options.searchMessageHistory ? await options.searchMessageHistory(messageRequest).catch((error) => {
+      log2(`[search] off-thread message search failed: ${error instanceof Error ? error.message : String(error)}`);
+      return null;
+    }) : null;
+    if (delegated && options.signal?.aborted)
+      return [];
+    const outcome = delegated ?? searchMessageHistory2(db, messageRequest);
+    if (options.diagnostics) {
+      options.diagnostics.suppressedLiveMessageMatches = outcome.suppressedLiveMessageMatches;
+    }
+    messageResults = outcome.results;
+  }
   const capturedQuery = await queryEmbeddingPromise;
   if (options.signal?.aborted)
     return [];
-  const embeddingSnapshot = getProjectEmbeddingSnapshot(projectPath);
+  const embeddingSnapshot = getProjectEmbeddingSnapshot2(projectPath);
   const queryContract = capturedQuery instanceof Float32Array || capturedQuery === null ? null : capturedQuery;
   const generationIsCurrent = queryContract === null || embeddingSnapshot !== null && embeddingSnapshot.generation === queryContract.generation;
   const queryEmbedding = generationIsCurrent ? queryContract?.vector ?? (capturedQuery instanceof Float32Array ? capturedQuery : null) : null;
@@ -1920,7 +1963,7 @@ async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
       primaryResults: results,
       primaryQuery: queryContract,
       primaryLatencyMs: Date.now() - measurementStartedAt,
-      search: unifiedSearch
+      search: unifiedSearch2
     });
   }
   const countRetrievals = options.countRetrievals ?? true;
@@ -1930,9 +1973,9 @@ async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
       db.transaction(() => {
         for (const memoryId of memoryIds) {
           try {
-            updateMemoryRetrievalCount(db, memoryId);
+            updateMemoryRetrievalCount2(db, memoryId);
           } catch (error) {
-            if (error instanceof ModuleMemoryAuthorityError)
+            if (error instanceof ModuleMemoryAuthorityError2)
               continue;
             throw error;
           }
@@ -2032,7 +2075,7 @@ function formatSearchDiagnosticLines(results, diagnostics) {
   }
   return lines;
 }
-function formatSearchResults(query, results, currentSessionId, diagnostics) {
+function formatSearchResults2(query, results, currentSessionId, diagnostics) {
   const diagnosticLines = formatSearchDiagnosticLines(results, diagnostics);
   if (results.length === 0) {
     if (diagnosticLines.length > 0) {
@@ -2060,4 +2103,4 @@ ${bodyParts.join(`
 `)}`;
 }
 
-export { indexCommitsForProject, embedUnembeddedCommits, createUnifiedSearchDiagnostics, parseIdShapedQuery, resolveMemoriesByIdsForSearch, unifiedSearch, formatSearchResults };
+export { indexCommitsForProject, embedUnembeddedCommits, createUnifiedSearchDiagnostics2, searchMessageHistory2, parseIdShapedQuery2, resolveMemoriesByIdsForSearch2, unifiedSearch2, formatSearchResults2 };

package/dist/{index-yr3zj7e7.js → v2/server-qt1qqasc.js}

@@ -1,23 +1,22 @@
 // src/shared/embedding-activity.ts
 var busySessions = new Set;
-function setEmbeddingSessionBusy(sessionId, busy) {
+function setEmbeddingSessionBusy2(sessionId, busy) {
   if (busy)
     busySessions.add(sessionId);
   else
     busySessions.delete(sessionId);
 }
-function observeEmbeddingActivity(event) {
+function observeEmbeddingActivity2(event) {
   const props = event.properties;
   if (!props || typeof props.sessionID !== "string")
     return;
   if (event.type === "session.idle" || event.type === "session.deleted" || event.type === "session.status" && props.status?.type === "idle") {
-    setEmbeddingSessionBusy(props.sessionID, false);
+    setEmbeddingSessionBusy2(props.sessionID, false);
   } else if (event.type === "session.status" && props.status?.type) {
-    setEmbeddingSessionBusy(props.sessionID, true);
+    setEmbeddingSessionBusy2(props.sessionID, true);
   }
 }
-function isEmbeddingHostBusy() {
+function isEmbeddingHostBusy2() {
   return busySessions.size > 0;
 }
-
-export { setEmbeddingSessionBusy, observeEmbeddingActivity, isEmbeddingHostBusy };
+export { setEmbeddingSessionBusy2, observeEmbeddingActivity2, isEmbeddingHostBusy2 };

package/dist/v2/server-qye6ykf7.js

@@ -0,0 +1,120 @@
+import {
+  estimateTokens
+} from "./server-1r6pmz4f.js";
+import {
+  stableStringify
+} from "./server-52awr2mw.js";
+
+// src/features/magic-context/tool-definition-tokens.ts
+import { createHash } from "node:crypto";
+var measurements = new Map;
+var fingerprints = new Map;
+var persistenceDb = null;
+var cachedInsertStmt = null;
+function keyFor(providerID, modelID, agentName) {
+  const agent = agentName && agentName.length > 0 ? agentName : "default";
+  return `${providerID}/${modelID}/${agent}`;
+}
+function fingerprintFor(description, parameters) {
+  return createHash("sha256").update(description).update("\x00").update(stableStringify(parameters)).digest("hex");
+}
+function getCurrentToolSetHash(providerID, modelID, agentName) {
+  if (!providerID || !modelID)
+    return "";
+  const toolIds = measurements.get(keyFor(providerID, modelID, agentName));
+  if (!toolIds || toolIds.size === 0)
+    return "";
+  return createHash("sha256").update(Array.from(toolIds.keys()).sort().join("\x00")).digest("hex");
+}
+function getToolDefinitionMeasurementSignature(providerID, modelID, agentName) {
+  const key = keyFor(providerID, modelID, agentName);
+  const measured = measurements.get(key);
+  const observed = fingerprints.get(key);
+  if (!measured || !observed || [...measured.keys()].some((id) => !observed.has(id)))
+    return;
+  return createHash("sha256").update(JSON.stringify([...measured.keys()].sort().map((id) => [id, observed.get(id)]))).digest("hex");
+}
+function setDatabase(db) {
+  persistenceDb = db;
+  cachedInsertStmt = null;
+}
+function loadToolDefinitionMeasurements(db) {
+  let rows = [];
+  try {
+    rows = db.prepare("SELECT provider_id, model_id, agent_name, tool_id, token_count FROM tool_definition_measurements").all();
+  } catch {
+    return;
+  }
+  for (const row of rows) {
+    const key = keyFor(row.provider_id, row.model_id, row.agent_name);
+    let inner = measurements.get(key);
+    if (!inner) {
+      inner = new Map;
+      measurements.set(key, inner);
+    }
+    inner.set(row.tool_id, row.token_count);
+  }
+}
+function recordToolDefinition(providerID, modelID, agentName, toolID, description, parameters) {
+  if (!providerID || !modelID || !toolID)
+    return;
+  const key = keyFor(providerID, modelID, agentName);
+  const fp = fingerprintFor(description ?? "", parameters);
+  let innerFp = fingerprints.get(key);
+  if (innerFp && innerFp.get(toolID) === fp)
+    return;
+  let paramsText = "";
+  try {
+    paramsText = parameters === undefined ? "" : JSON.stringify(parameters);
+  } catch {
+    paramsText = "";
+  }
+  const tokens = estimateTokens(description ?? "") + estimateTokens(paramsText);
+  let inner = measurements.get(key);
+  if (!inner) {
+    inner = new Map;
+    measurements.set(key, inner);
+  }
+  inner.set(toolID, tokens);
+  if (!innerFp) {
+    innerFp = new Map;
+    fingerprints.set(key, innerFp);
+  }
+  innerFp.set(toolID, fp);
+  if (persistenceDb) {
+    try {
+      const agent = agentName && agentName.length > 0 ? agentName : "default";
+      if (!cachedInsertStmt) {
+        cachedInsertStmt = persistenceDb.prepare(`INSERT OR REPLACE INTO tool_definition_measurements
+                     (provider_id, model_id, agent_name, tool_id, token_count, recorded_at)
+                     VALUES (?, ?, ?, ?, ?, ?)`);
+      }
+      cachedInsertStmt.run(providerID, modelID, agent, toolID, tokens, Date.now());
+    } catch {
+      cachedInsertStmt = null;
+    }
+  }
+}
+function getLargestMeasuredToolDefinitionTokens() {
+  let largest = 0;
+  for (const tools of measurements.values()) {
+    let total = 0;
+    for (const tokens of tools.values())
+      total += tokens;
+    largest = Math.max(largest, total);
+  }
+  return largest > 0 ? largest : undefined;
+}
+function getMeasuredToolDefinitionTokens(providerID, modelID, agentName) {
+  if (!providerID || !modelID)
+    return;
+  const inner = measurements.get(keyFor(providerID, modelID, agentName));
+  if (!inner || inner.size === 0)
+    return;
+  let total = 0;
+  for (const tokens of inner.values())
+    total += tokens;
+  return total;
+}
+
+export { getCurrentToolSetHash, getToolDefinitionMeasurementSignature, setDatabase, loadToolDefinitionMeasurements, recordToolDefinition, getLargestMeasuredToolDefinitionTokens, getMeasuredToolDefinitionTokens };

package/dist/v2/{server-qdjnb2z1.js → server-r5p3b1wy.js}

@@ -1,6 +1,6 @@
 import {
   resolveDreamerTaskModel2
-} from "./server-sfpzqvdz.js";
+} from "./server-8cd2j99z.js";
 
 // src/features/magic-context/dreamer/task-registry.ts
 var CANONICAL_DREAM_TASKS = [
@@ -17,6 +17,9 @@ var CANONICAL_DREAM_TASKS = [
   "promote-primers",
   "refresh-primers"
 ];
+function availableDreamTasks(smartNotesEnabled = true) {
+  return CANONICAL_DREAM_TASKS.filter((task) => smartNotesEnabled || task !== "evaluate-smart-notes");
+}
 var DREAM_TOOL_LOOP_TOKEN_BUDGETS = {
   "map-memories": 2500000,
   verify: 2500000,
@@ -132,13 +135,12 @@ function compareTaskOrder(a, b) {
 }
 
 // src/features/magic-context/dreamer/task-config.ts
-function buildDreamTaskRuntimeConfigs2(dreamer, harness, language, muralModel) {
-  return CANONICAL_DREAM_TASKS.map((task) => {
+function buildDreamTaskRuntimeConfigs2(dreamer, harness, language, smartNotesEnabled = true) {
+  return availableDreamTasks(smartNotesEnabled).map((task) => {
     const resolved = resolveDreamerTaskModel2({
       config: { dreamer },
       harness,
-      task,
-      muralModel
+      task
     });
     return {
       task,
@@ -166,13 +168,13 @@ function dreamTaskScheduled2(dreamer, task) {
   const schedule = dreamer?.tasks?.[task]?.schedule;
   return typeof schedule === "string" && schedule.trim() !== "";
 }
-function enabledDreamTasks2(dreamer) {
+function enabledDreamTasks2(dreamer, smartNotesEnabled = true) {
   if (!dreamer?.tasks)
     return [];
-  return CANONICAL_DREAM_TASKS.filter((t) => dreamer.tasks[t]?.schedule?.trim());
+  return availableDreamTasks(smartNotesEnabled).filter((t) => dreamer.tasks[t]?.schedule?.trim());
 }
-function summarizeDreamSchedule2(dreamer) {
-  const enabled = enabledDreamTasks2(dreamer);
+function summarizeDreamSchedule2(dreamer, smartNotesEnabled = true) {
+  const enabled = enabledDreamTasks2(dreamer, smartNotesEnabled);
   if (enabled.length === 0)
     return "manual-only";
   return enabled.map((t) => `${t} ${dreamer?.tasks[t]?.schedule}`).join(", ");