@cortexkit/pi-magic-context 0.23.1 → 0.24.1

package/dist/subagent-entry.js

@@ -8164,9 +8164,470 @@ function isRelativeProjectFile(projectPath, relativePath) {
 
 // ../plugin/src/features/magic-context/migrations.ts
 init_logger();
-function tableExists(db, name) {
+
+// ../plugin/src/features/magic-context/workspaces.ts
+import { createHash as createHash3 } from "node:crypto";
+
+// ../plugin/src/features/magic-context/memory/constants.ts
+var V2_MEMORY_CATEGORIES = [
+  "PROJECT_RULES",
+  "ARCHITECTURE",
+  "CONSTRAINTS",
+  "CONFIG_VALUES",
+  "NAMING"
+];
+var PROMOTABLE_CATEGORIES = [
+  "PROJECT_RULES",
+  "ARCHITECTURE",
+  "CONSTRAINTS",
+  "CONFIG_VALUES",
+  "NAMING",
+  "ARCHITECTURE_DECISIONS",
+  "CONFIG_DEFAULTS",
+  "USER_PREFERENCES",
+  "USER_DIRECTIVES",
+  "ENVIRONMENT",
+  "WORKFLOW_RULES",
+  "KNOWN_ISSUES"
+];
+var CATEGORY_PRIORITY = [
+  "PROJECT_RULES",
+  "ARCHITECTURE",
+  "CONSTRAINTS",
+  "CONFIG_VALUES",
+  "NAMING",
+  "USER_DIRECTIVES",
+  "USER_PREFERENCES",
+  "CONFIG_DEFAULTS",
+  "ARCHITECTURE_DECISIONS",
+  "ENVIRONMENT",
+  "WORKFLOW_RULES",
+  "KNOWN_ISSUES"
+];
+var MEMORY_CATEGORY_ORDER_UNKNOWN = 99;
+var MEMORY_CATEGORY_ORDER_PRIORITY = CATEGORY_PRIORITY.reduce((acc, category, index) => {
+  acc[category] = index;
+  return acc;
+}, {});
+var MEMORY_CATEGORY_ORDER_SQL = `CASE category ${CATEGORY_PRIORITY.map((category, index) => `WHEN '${category}' THEN ${index}`).join(" ")} ELSE ${MEMORY_CATEGORY_ORDER_UNKNOWN} END`;
+var CATEGORY_DEFAULT_TTL = {
+  WORKFLOW_RULES: 90 * 24 * 60 * 60 * 1000,
+  KNOWN_ISSUES: 30 * 24 * 60 * 60 * 1000
+};
+
+// ../plugin/src/features/magic-context/memory/project-identity.ts
+import { execFileSync } from "node:child_process";
+import { createHash as createHash2 } from "node:crypto";
+import { statSync } from "node:fs";
+import path3 from "node:path";
+var GIT_TIMEOUT_MS = 5000;
+var identityCache = new Map;
+var directoryFallbackCache = new Map;
+
+class ProjectIdentityError extends Error {
+  errorClass;
+  rawDirectory;
+  constructor(errorClass, rawDirectory, message, cause) {
+    super(message);
+    this.name = "ProjectIdentityError";
+    this.errorClass = errorClass;
+    this.rawDirectory = rawDirectory;
+    if (cause) {
+      this.cause = cause;
+    }
+  }
+}
+function asError(error) {
+  return error instanceof Error ? error : undefined;
+}
+function getErrorCode(error) {
+  if (error === null || typeof error !== "object" || !("code" in error)) {
+    return;
+  }
+  const code = error.code;
+  return typeof code === "string" ? code : undefined;
+}
+function getErrorSignal(error) {
+  if (error === null || typeof error !== "object" || !("signal" in error)) {
+    return;
+  }
+  const signal = error.signal;
+  return typeof signal === "string" ? signal : undefined;
+}
+function getErrorKilled(error) {
+  if (error === null || typeof error !== "object" || !("killed" in error)) {
+    return false;
+  }
+  return error.killed === true;
+}
+function getErrorStderr(error) {
+  if (error === null || typeof error !== "object" || !("stderr" in error)) {
+    return "";
+  }
+  const stderr = error.stderr;
+  if (typeof stderr === "string") {
+    return stderr;
+  }
+  if (Buffer.isBuffer(stderr)) {
+    return stderr.toString("utf8");
+  }
+  return "";
+}
+function directoryFallback(directory) {
+  const canonical = path3.resolve(directory);
+  const hash = createHash2("md5").update(canonical, "utf8").digest("hex").slice(0, 12);
+  return `dir:${hash}`;
+}
+function assertDirectoryUsable(canonicalDirectory, rawDirectory) {
+  try {
+    const stat = statSync(canonicalDirectory);
+    if (!stat.isDirectory()) {
+      throw new ProjectIdentityError("unknown", rawDirectory, `Project path is not a directory: ${canonicalDirectory}`);
+    }
+  } catch (error) {
+    if (error instanceof ProjectIdentityError) {
+      throw error;
+    }
+    const code = getErrorCode(error);
+    if (code === "EACCES" || code === "EPERM") {
+      throw new ProjectIdentityError("permission_denied", rawDirectory, `Permission denied while accessing project directory: ${canonicalDirectory}`, asError(error));
+    }
+    throw new ProjectIdentityError("unknown", rawDirectory, `Unable to access project directory: ${canonicalDirectory}`, asError(error));
+  }
+}
+function isGitTimeoutError(error) {
+  const code = getErrorCode(error);
+  const signal = getErrorSignal(error);
+  return code === "ETIMEDOUT" || signal === "SIGTERM" || signal === "SIGKILL" || getErrorKilled(error);
+}
+function classifyGitError(error, rawDirectory) {
+  if (isGitTimeoutError(error)) {
+    return new ProjectIdentityError("git_timeout", rawDirectory, `git rev-list timed out after ${GIT_TIMEOUT_MS}ms`, asError(error));
+  }
+  const code = getErrorCode(error);
+  if (code === "ENOENT") {
+    return new ProjectIdentityError("git_missing", rawDirectory, "git binary is not available in PATH", asError(error));
+  }
+  if (code === "EACCES" || code === "EPERM") {
+    return new ProjectIdentityError("permission_denied", rawDirectory, "Permission denied while spawning git", asError(error));
+  }
+  const stderr = getErrorStderr(error).toLowerCase();
+  if (stderr.includes("not a git repository") || stderr.includes("does not have any commits yet") || stderr.includes("ambiguous argument 'head'") || stderr.includes("unknown revision or path")) {
+    return new ProjectIdentityError("not_git_repo", rawDirectory, "Directory has no git root commit; caller may use directory fallback", asError(error));
+  }
+  return new ProjectIdentityError("unknown", rawDirectory, "git rev-list failed while resolving project identity", asError(error));
+}
+function resolveProjectIdentityStrict(directory) {
+  const canonical = path3.resolve(directory);
+  const cached = identityCache.get(canonical);
+  if (cached !== undefined) {
+    return cached;
+  }
+  assertDirectoryUsable(canonical, directory);
+  let output;
+  try {
+    output = execFileSync("git", ["rev-list", "--max-parents=0", "HEAD"], {
+      cwd: canonical,
+      encoding: "utf8",
+      env: { ...process.env, LC_ALL: "C", LANG: "C" },
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: GIT_TIMEOUT_MS
+    });
+  } catch (error) {
+    throw classifyGitError(error, directory);
+  }
+  const firstLine = output.split(`
+`)[0]?.trim() ?? "";
+  const rootCommit = firstLine.slice(0, 64);
+  if (rootCommit.length < 7) {
+    throw new ProjectIdentityError("unknown", directory, "git rev-list returned no valid root commit hash");
+  }
+  const identity = `git:${rootCommit}`;
+  identityCache.set(canonical, identity);
+  return identity;
+}
+function shouldUseDirectoryFallback(error) {
+  return error.errorClass === "not_git_repo" || error.errorClass === "unknown" && error.message.startsWith("Unable to access project directory:");
+}
+function resolveProjectIdentity(directory) {
+  const canonical = path3.resolve(directory);
+  const cachedFallback = directoryFallbackCache.get(canonical);
+  if (cachedFallback !== undefined) {
+    if (!hasGitDir(canonical)) {
+      return cachedFallback;
+    }
+    directoryFallbackCache.delete(canonical);
+  }
+  try {
+    return resolveProjectIdentityStrict(directory);
+  } catch (error) {
+    if (error instanceof ProjectIdentityError && shouldUseDirectoryFallback(error)) {
+      const fallback = directoryFallback(canonical);
+      if (!hasGitDir(canonical)) {
+        directoryFallbackCache.set(canonical, fallback);
+      }
+      return fallback;
+    }
+    throw error;
+  }
+}
+function hasGitDir(canonical) {
+  try {
+    statSync(path3.join(canonical, ".git"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function normalizeStoredProjectPath(rawOrStored) {
+  if (rawOrStored.startsWith("git:") || rawOrStored.startsWith("dir:")) {
+    return rawOrStored;
+  }
+  try {
+    return resolveProjectIdentity(rawOrStored);
+  } catch {
+    return directoryFallback(rawOrStored);
+  }
+}
+function storedPathBelongsToIdentity(storedProjectPath, projectIdentity) {
+  return storedProjectPath === projectIdentity || normalizeStoredProjectPath(storedProjectPath) === projectIdentity;
+}
+// ../plugin/src/features/magic-context/workspaces.ts
+var VALID_SHARE_CATEGORIES = new Set(V2_MEMORY_CATEGORIES);
+function tableExists(db, tableName) {
+  const row = db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name = ? LIMIT 1").get(tableName);
+  return Boolean(row);
+}
+function columnExists(db, tableName, columnName) {
+  const rows = db.prepare(`PRAGMA table_info(${tableName})`).all();
+  return rows.some((row) => row.name === columnName);
+}
+function uniqueSorted(values) {
+  return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+function placeholders(values) {
+  return values.map(() => "?").join(", ");
+}
+function normalizeShareCategories(raw) {
+  if (raw === null || raw === undefined)
+    return null;
+  if (typeof raw !== "string")
+    return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(parsed))
+    return null;
+  const categories = [];
+  for (const value of parsed) {
+    if (typeof value !== "string" || !VALID_SHARE_CATEGORIES.has(value)) {
+      return null;
+    }
+    if (!categories.includes(value))
+      categories.push(value);
+  }
+  return categories.sort((left, right) => left.localeCompare(right));
+}
+function selectWorkspaceShareCategories(db, identities) {
+  const candidates = uniqueSorted(identities.filter((identity) => identity.length > 0));
+  if (candidates.length === 0 || !tableExists(db, "workspace_members") || !tableExists(db, "workspaces") || !columnExists(db, "workspaces", "share_categories")) {
+    return null;
+  }
+  const row = db.prepare(`SELECT workspace.share_categories AS shareCategories
+               FROM workspace_members AS member
+               JOIN workspaces AS workspace ON workspace.id = member.workspace_id
+              WHERE member.project_path IN (${placeholders(candidates)})
+              ORDER BY workspace.id ASC
+              LIMIT 1`).get(...candidates);
+  return normalizeShareCategories(row?.shareCategories ?? null);
+}
+function resolveWorkspaceShareCategories(db, projectIdentity) {
+  return selectWorkspaceShareCategories(db, [projectIdentity]);
+}
+function resolveWorkspaceIdentitySet(db, projectIdentity) {
+  if (!tableExists(db, "workspace_members")) {
+    return { identities: [projectIdentity], namesByIdentity: new Map };
+  }
+  const rows = db.prepare(`SELECT member.project_path AS identity, member.display_name AS displayName
+               FROM workspace_members AS anchor
+               JOIN workspace_members AS member ON member.workspace_id = anchor.workspace_id
+              WHERE anchor.project_path = ?
+              ORDER BY member.display_name ASC, member.project_path ASC`).all(projectIdentity);
+  if (rows.length === 0) {
+    return { identities: [projectIdentity], namesByIdentity: new Map };
+  }
+  const namesByIdentity = new Map;
+  const identities = [];
+  for (const row of rows) {
+    if (typeof row.identity !== "string" || row.identity.length === 0)
+      continue;
+    if (identities.includes(row.identity))
+      continue;
+    identities.push(row.identity);
+    if (typeof row.displayName === "string" && row.displayName.length > 0) {
+      namesByIdentity.set(row.identity, row.displayName);
+    }
+  }
+  return identities.length > 0 ? { identities, namesByIdentity } : { identities: [projectIdentity], namesByIdentity: new Map };
+}
+function expandWorkspaceIdentitySetWithAliases(db, identities) {
+  const canonical = uniqueSorted(identities.filter((identity) => identity.length > 0));
+  const expanded = new Set(canonical);
+  const canonicalIdentityByStoredPath = new Map;
+  for (const identity of canonical) {
+    canonicalIdentityByStoredPath.set(identity, identity);
+  }
+  if (canonical.length === 0 || !tableExists(db, "v22_identity_rekey_map")) {
+    return { expandedIdentities: [...expanded], canonicalIdentityByStoredPath };
+  }
+  const rows = db.prepare(`SELECT old_project_path AS oldProjectPath, new_project_path AS newProjectPath
+               FROM v22_identity_rekey_map
+              WHERE new_project_path IN (${placeholders(canonical)})
+              ORDER BY old_project_path ASC`).all(...canonical);
+  for (const row of rows) {
+    if (typeof row.oldProjectPath !== "string" || typeof row.newProjectPath !== "string") {
+      continue;
+    }
+    if (!canonicalIdentityByStoredPath.has(row.newProjectPath))
+      continue;
+    expanded.add(row.oldProjectPath);
+    canonicalIdentityByStoredPath.set(row.oldProjectPath, row.newProjectPath);
+  }
+  return { expandedIdentities: [...expanded], canonicalIdentityByStoredPath };
+}
+function resolveStoredPathWorkspaceIdentity(storedProjectPath, memberIdentities, canonicalIdentityByStoredPath) {
+  const direct = canonicalIdentityByStoredPath.get(storedProjectPath);
+  if (direct)
+    return direct;
+  const normalized = normalizeStoredProjectPath(storedProjectPath);
+  const normalizedDirect = canonicalIdentityByStoredPath.get(normalized);
+  if (normalizedDirect)
+    return normalizedDirect;
+  if (memberIdentities.includes(normalized))
+    return normalized;
+  for (const identity of memberIdentities) {
+    if (storedPathBelongsToIdentity(storedProjectPath, identity)) {
+      return identity;
+    }
+  }
+  return null;
+}
+function storedPathBelongsToWorkspace(storedProjectPath, memberIdentities, expandedIdentities, canonicalIdentityByStoredPath) {
+  if (expandedIdentities.includes(storedProjectPath))
+    return true;
+  return resolveStoredPathWorkspaceIdentity(storedProjectPath, memberIdentities, canonicalIdentityByStoredPath) !== null;
+}
+function sourceNameForMemory(storedProjectPath, ownIdentity, memberIdentities, namesByIdentity, canonicalIdentityByStoredPath) {
+  const canonicalIdentity = resolveStoredPathWorkspaceIdentity(storedProjectPath, memberIdentities, canonicalIdentityByStoredPath);
+  if (!canonicalIdentity || canonicalIdentity === ownIdentity)
+    return;
+  return namesByIdentity.get(canonicalIdentity);
+}
+function getEpochMap(db, identities) {
+  if (identities.length === 0)
+    return new Map;
+  const rows = db.prepare(`SELECT project_path AS projectPath, project_memory_epoch AS epoch
+               FROM project_state
+              WHERE project_path IN (${placeholders(identities)})`).all(...identities);
+  const epochs = new Map;
+  for (const row of rows) {
+    if (typeof row.projectPath !== "string" || typeof row.epoch !== "number")
+      continue;
+    epochs.set(row.projectPath, row.epoch);
+  }
+  return epochs;
+}
+function computeWorkspaceEpochFingerprint(db, identities) {
+  const canonical = uniqueSorted(identities.filter((identity) => identity.length > 0));
+  const epochs = getEpochMap(db, canonical);
+  const shareCategories = selectWorkspaceShareCategories(db, canonical);
+  const hash = createHash3("sha256");
+  hash.update("share_categories", "utf8");
+  hash.update("\x00");
+  hash.update(shareCategories === null ? "ALL" : JSON.stringify(shareCategories), "utf8");
+  hash.update(`
+`);
+  for (const identity of canonical) {
+    hash.update(identity, "utf8");
+    hash.update("\x00");
+    hash.update(String(epochs.get(identity) ?? 0), "utf8");
+    hash.update(`
+`);
+  }
+  return hash.digest("hex");
+}
+function isInTransaction(db) {
+  const candidate = db;
+  return candidate.inTransaction === true || candidate.isTransaction === true;
+}
+function workspaceMembersForIdentity(db, identity) {
+  if (!tableExists(db, "workspace_members"))
+    return [identity];
+  const rows = db.prepare(`SELECT member.project_path AS identity
+               FROM workspace_members AS anchor
+               JOIN workspace_members AS member ON member.workspace_id = anchor.workspace_id
+              WHERE anchor.project_path = ?
+              ORDER BY member.project_path ASC`).all(identity);
+  const identities = rows.map((row) => typeof row.identity === "string" ? row.identity : "").filter((value) => value.length > 0);
+  return identities.length > 0 ? uniqueSorted(identities) : [identity];
+}
+function bumpEpochRows(db, identities, now) {
+  const stmt = db.prepare(`INSERT INTO project_state
+            (project_path, project_memory_epoch, project_user_profile_version, updated_at)
+         VALUES (?, 1, 0, ?)
+         ON CONFLICT(project_path) DO UPDATE SET
+            project_memory_epoch = project_memory_epoch + 1,
+            updated_at = excluded.updated_at`);
+  for (const identity of uniqueSorted(identities)) {
+    stmt.run(identity, now);
+  }
+}
+function bumpEpochsForWorkspaceMembers(db, identity, now = Date.now()) {
+  const run = () => bumpEpochRows(db, workspaceMembersForIdentity(db, identity), now);
+  if (isInTransaction(db)) {
+    run();
+    return;
+  }
+  db.exec("BEGIN IMMEDIATE");
+  try {
+    run();
+    db.exec("COMMIT");
+  } catch (error) {
+    try {
+      db.exec("ROLLBACK");
+    } catch {}
+    throw error;
+  }
+}
+function bumpEpochsForWorkspaceMemberSet(db, identities, now = Date.now()) {
+  const run = () => bumpEpochRows(db, identities, now);
+  if (isInTransaction(db)) {
+    run();
+    return;
+  }
+  db.exec("BEGIN IMMEDIATE");
+  try {
+    run();
+    db.exec("COMMIT");
+  } catch (error) {
+    try {
+      db.exec("ROLLBACK");
+    } catch {}
+    throw error;
+  }
+}
+
+// ../plugin/src/features/magic-context/migrations.ts
+function tableExists2(db, name) {
   return Boolean(db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name = ?").get(name));
 }
+function columnExists2(db, table, column) {
+  const rows = db.prepare(`PRAGMA table_info(${table})`).all();
+  return rows.some((row) => row.name === column);
+}
 var MIGRATIONS = [
   {
     version: 1,
@@ -8625,9 +9086,9 @@ var MIGRATIONS = [
     version: 22,
     description: "v2.0 cache architecture schema foundation",
     up: (db) => {
-      const hasSessionMetaTable = tableExists(db, "session_meta");
-      const hasCompartmentsTable = tableExists(db, "compartments");
-      const hasMemoriesTable = tableExists(db, "memories");
+      const hasSessionMetaTable = tableExists2(db, "session_meta");
+      const hasCompartmentsTable = tableExists2(db, "compartments");
+      const hasMemoriesTable = tableExists2(db, "memories");
       if (hasSessionMetaTable) {
         ensureColumn(db, "session_meta", "cached_m0_bytes", "BLOB");
         ensureColumn(db, "session_meta", "cached_m0_project_memory_epoch", "INTEGER");
@@ -8652,7 +9113,7 @@ var MIGRATIONS = [
         ensureColumn(db, "compartments", "p1_embedding_model_id", "TEXT");
         ensureColumn(db, "compartments", "legacy", "INTEGER NOT NULL DEFAULT 0");
       }
-      const hasRecompCompartmentsTable = tableExists(db, "recomp_compartments");
+      const hasRecompCompartmentsTable = tableExists2(db, "recomp_compartments");
       if (hasRecompCompartmentsTable) {
         ensureColumn(db, "recomp_compartments", "p1", "TEXT");
         ensureColumn(db, "recomp_compartments", "p2", "TEXT");
@@ -8963,6 +9424,156 @@ var MIGRATIONS = [
       db.prepare("UPDATE session_meta SET force_emergency_bypass_used = 0 WHERE force_emergency_bypass_used IS NULL").run();
       db.prepare("UPDATE session_meta SET last_usage_context_limit = 0 WHERE last_usage_context_limit IS NULL").run();
     }
+  },
+  {
+    version: 33,
+    description: "Compartment chunk embeddings for semantic message-history search",
+    up: (db) => {
+      db.exec(`
+                CREATE TABLE IF NOT EXISTS compartment_chunk_embeddings (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    compartment_id INTEGER NOT NULL REFERENCES compartments(id) ON DELETE CASCADE,
+                    session_id TEXT NOT NULL,
+                    project_path TEXT NOT NULL,
+                    harness TEXT NOT NULL DEFAULT 'opencode',
+                    window_index INTEGER NOT NULL DEFAULT 0,
+                    start_ordinal INTEGER NOT NULL,
+                    end_ordinal INTEGER NOT NULL,
+                    chunk_hash TEXT NOT NULL,
+                    model_id TEXT NOT NULL,
+                    dims INTEGER NOT NULL,
+                    vector BLOB NOT NULL,
+                    created_at INTEGER NOT NULL,
+                    UNIQUE(compartment_id, window_index)
+                );
+                CREATE INDEX IF NOT EXISTS idx_cce_session
+                    ON compartment_chunk_embeddings(session_id);
+                CREATE INDEX IF NOT EXISTS idx_cce_project_model
+                    ON compartment_chunk_embeddings(project_path, model_id);
+            `);
+    }
+  },
+  {
+    version: 34,
+    description: "workspace tables and m[0] workspace fingerprint cache reset",
+    up: (db) => {
+      db.exec(`
+                CREATE TABLE IF NOT EXISTS workspaces (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    name TEXT NOT NULL UNIQUE,
+                    created_at INTEGER NOT NULL,
+                    updated_at INTEGER NOT NULL
+                );
+                CREATE TABLE IF NOT EXISTS workspace_members (
+                    workspace_id INTEGER NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+                    project_path TEXT NOT NULL,
+                    display_name TEXT NOT NULL,
+                    display_path TEXT NOT NULL,
+                    added_at INTEGER NOT NULL,
+                    PRIMARY KEY (workspace_id, project_path)
+                );
+                CREATE UNIQUE INDEX IF NOT EXISTS idx_workspace_member_unique
+                    ON workspace_members(project_path);
+                CREATE UNIQUE INDEX IF NOT EXISTS idx_workspace_member_name
+                    ON workspace_members(workspace_id, display_name);
+            `);
+      const hasSessionMeta = db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='session_meta' LIMIT 1").get();
+      if (!hasSessionMeta)
+        return;
+      ensureColumn(db, "session_meta", "cached_m0_workspace_fingerprint", "TEXT");
+      const columns = new Set(db.prepare("PRAGMA table_info(session_meta)").all().map((column) => column.name));
+      const clears = [
+        ["cached_m0_bytes", null],
+        ["cached_m1_bytes", null],
+        ["cached_m0_project_memory_epoch", null],
+        ["cached_m0_workspace_fingerprint", null],
+        ["cached_m0_project_user_profile_version", null],
+        ["cached_m0_max_compartment_seq", null],
+        ["cached_m0_max_memory_id", null],
+        ["cached_m0_max_mutation_id", null],
+        ["cached_m0_max_memory_mutation_id", null],
+        ["cached_m0_project_docs_hash", null],
+        ["cached_m0_materialized_at", null],
+        ["cached_m0_session_facts_version", null],
+        ["cached_m0_upgrade_state", null],
+        ["cached_m0_system_hash", null],
+        ["cached_m0_tool_set_hash", null],
+        ["cached_m0_model_key", null],
+        ["cached_m0_last_baseline_end_message_id", null],
+        ["memory_block_cache", ""],
+        ["memory_block_ids", ""],
+        ["memory_block_count", 0]
+      ];
+      const setClauses = [];
+      const values = [];
+      for (const [column, value] of clears) {
+        if (!columns.has(column))
+          continue;
+        setClauses.push(`${column} = ?`);
+        values.push(value);
+      }
+      if (setClauses.length > 0) {
+        db.prepare(`UPDATE session_meta SET ${setClauses.join(", ")}`).run(...values);
+      }
+    }
+  },
+  {
+    version: 35,
+    description: "workspace per-category share defaults and epoch refresh",
+    up: (db) => {
+      db.exec(`
+                CREATE TABLE IF NOT EXISTS workspaces (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    name TEXT NOT NULL UNIQUE,
+                    created_at INTEGER NOT NULL,
+                    updated_at INTEGER NOT NULL,
+                    share_categories TEXT NOT NULL DEFAULT '["CONSTRAINTS"]'
+                );
+            `);
+      if (!columnExists2(db, "workspaces", "share_categories")) {
+        db.exec(`ALTER TABLE workspaces ADD COLUMN share_categories TEXT NOT NULL DEFAULT '["CONSTRAINTS"]'`);
+      }
+      db.prepare(`UPDATE workspaces
+                    SET share_categories = '["CONSTRAINTS"]'
+                  WHERE share_categories IS NULL OR share_categories = ''`).run();
+      if (!tableExists2(db, "workspace_members"))
+        return;
+      const rows = db.prepare(`SELECT DISTINCT project_path AS identity
+                       FROM workspace_members
+                      WHERE project_path IS NOT NULL AND project_path <> ''
+                      ORDER BY project_path ASC`).all();
+      const identities = rows.map((row) => typeof row.identity === "string" ? row.identity : "").filter((identity) => identity.length > 0);
+      if (identities.length > 0) {
+        bumpEpochsForWorkspaceMemberSet(db, identities, Date.now());
+      }
+    }
+  },
+  {
+    version: 36,
+    description: "session project ownership map for compartment chunk backfill scoping",
+    up: (db) => {
+      db.exec(`
+                CREATE TABLE IF NOT EXISTS session_projects (
+                    session_id TEXT NOT NULL,
+                    harness TEXT NOT NULL DEFAULT 'opencode',
+                    project_path TEXT NOT NULL,
+                    updated_at INTEGER NOT NULL,
+                    PRIMARY KEY(session_id, harness)
+                );
+                CREATE INDEX IF NOT EXISTS idx_session_projects_project
+                    ON session_projects(project_path);
+            `);
+      const hasChunkTable = db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='compartment_chunk_embeddings'").get();
+      if (hasChunkTable) {
+        db.exec(`
+                    INSERT OR IGNORE INTO session_projects (session_id, harness, project_path, updated_at)
+                    SELECT session_id, harness, MIN(project_path), 0
+                    FROM compartment_chunk_embeddings
+                    GROUP BY session_id, harness
+                    HAVING COUNT(DISTINCT project_path) = 1;
+                `);
+      }
+    }
   }
 ];
 var LATEST_MIGRATION_VERSION = MIGRATIONS.reduce((max, m) => Math.max(max, m.version), 0);
@@ -141940,7 +142551,7 @@ var databases = new Map;
 var persistenceByDatabase = new WeakMap;
 var persistenceErrorByDatabase = new WeakMap;
 var lastSchemaFenceRejection = null;
-var LATEST_SUPPORTED_VERSION = 32;
+var LATEST_SUPPORTED_VERSION = 36;
 function resolveDatabasePath(dbPathOverride) {
   if (dbPathOverride) {
     return { dbDir: dirname2(dbPathOverride), dbPath: dbPathOverride };
@@ -142106,6 +142717,35 @@ function initializeDatabase(db) {
     );
     CREATE INDEX IF NOT EXISTS idx_compartments_session ON compartments(session_id);
 
+    CREATE TABLE IF NOT EXISTS compartment_chunk_embeddings (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      compartment_id INTEGER NOT NULL REFERENCES compartments(id) ON DELETE CASCADE,
+      session_id TEXT NOT NULL,
+      project_path TEXT NOT NULL,
+      harness TEXT NOT NULL DEFAULT 'opencode',
+      window_index INTEGER NOT NULL DEFAULT 0,
+      start_ordinal INTEGER NOT NULL,
+      end_ordinal INTEGER NOT NULL,
+      chunk_hash TEXT NOT NULL,
+      model_id TEXT NOT NULL,
+      dims INTEGER NOT NULL,
+      vector BLOB NOT NULL,
+      created_at INTEGER NOT NULL,
+      UNIQUE(compartment_id, window_index)
+    );
+    CREATE INDEX IF NOT EXISTS idx_cce_session ON compartment_chunk_embeddings(session_id);
+    CREATE INDEX IF NOT EXISTS idx_cce_project_model ON compartment_chunk_embeddings(project_path, model_id);
+
+    CREATE TABLE IF NOT EXISTS session_projects (
+      session_id TEXT NOT NULL,
+      harness TEXT NOT NULL DEFAULT 'opencode',
+      project_path TEXT NOT NULL,
+      updated_at INTEGER NOT NULL,
+      PRIMARY KEY(session_id, harness)
+    );
+    CREATE INDEX IF NOT EXISTS idx_session_projects_project
+      ON session_projects(project_path);
+
     CREATE TABLE IF NOT EXISTS compartment_events (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       session_id TEXT NOT NULL,
@@ -142291,6 +142931,25 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
       rekeyed_at INTEGER NOT NULL
     );
 
+    CREATE TABLE IF NOT EXISTS workspaces (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL UNIQUE,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      share_categories TEXT NOT NULL DEFAULT '["CONSTRAINTS"]'
+    );
+
+    CREATE TABLE IF NOT EXISTS workspace_members (
+      workspace_id INTEGER NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+      project_path TEXT NOT NULL,
+      display_name TEXT NOT NULL,
+      display_path TEXT NOT NULL,
+      added_at INTEGER NOT NULL,
+      PRIMARY KEY (workspace_id, project_path)
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_workspace_member_unique ON workspace_members(project_path);
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_workspace_member_name ON workspace_members(workspace_id, display_name);
+
     CREATE TABLE IF NOT EXISTS v22_backfill_failures (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       table_name TEXT NOT NULL,
@@ -142402,6 +143061,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
       deferred_execute_state TEXT,
       cached_m0_bytes BLOB,
       cached_m0_project_memory_epoch INTEGER,
+      cached_m0_workspace_fingerprint TEXT,
       cached_m0_project_user_profile_version INTEGER,
       cached_m0_max_compartment_seq INTEGER,
       cached_m0_max_memory_id INTEGER,
@@ -142560,6 +143220,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   ensureColumn(db, "session_meta", "cleared_reasoning_through_tag", "INTEGER DEFAULT 0");
   ensureColumn(db, "session_meta", "stripped_placeholder_ids", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "stale_reduce_stripped_ids", "TEXT DEFAULT ''");
+  ensureColumn(db, "session_meta", "processed_image_stripped_ids", "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");
@@ -142613,6 +143274,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   ensureColumn(db, "memories", "importance", "INTEGER");
   ensureColumn(db, "session_meta", "cached_m0_bytes", "BLOB");
   ensureColumn(db, "session_meta", "cached_m0_project_memory_epoch", "INTEGER");
+  ensureColumn(db, "session_meta", "cached_m0_workspace_fingerprint", "TEXT");
   ensureColumn(db, "session_meta", "cached_m0_project_user_profile_version", "INTEGER");
   ensureColumn(db, "session_meta", "cached_m0_max_compartment_seq", "INTEGER");
   ensureColumn(db, "session_meta", "cached_m0_max_memory_id", "INTEGER");
@@ -142644,6 +143306,15 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
         project_user_profile_version INTEGER NOT NULL DEFAULT 0,
         updated_at INTEGER NOT NULL DEFAULT 0
       );
+      CREATE TABLE IF NOT EXISTS session_projects (
+        session_id TEXT NOT NULL,
+        harness TEXT NOT NULL DEFAULT 'opencode',
+        project_path TEXT NOT NULL,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY(session_id, harness)
+      );
+      CREATE INDEX IF NOT EXISTS idx_session_projects_project
+        ON session_projects(project_path);
       CREATE TABLE IF NOT EXISTS m0_mutation_log (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         session_id TEXT NOT NULL,
@@ -142671,6 +143342,23 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
         new_project_path TEXT NOT NULL,
         rekeyed_at INTEGER NOT NULL
       );
+      CREATE TABLE IF NOT EXISTS workspaces (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL UNIQUE,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        share_categories TEXT NOT NULL DEFAULT '["CONSTRAINTS"]'
+      );
+      CREATE TABLE IF NOT EXISTS workspace_members (
+        workspace_id INTEGER NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+        project_path TEXT NOT NULL,
+        display_name TEXT NOT NULL,
+        display_path TEXT NOT NULL,
+        added_at INTEGER NOT NULL,
+        PRIMARY KEY (workspace_id, project_path)
+      );
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_workspace_member_unique ON workspace_members(project_path);
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_workspace_member_name ON workspace_members(workspace_id, display_name);
       CREATE TABLE IF NOT EXISTS v22_backfill_failures (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         table_name TEXT NOT NULL,
@@ -142692,6 +143380,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   ensureColumn(db, "recomp_compartments", "harness", "TEXT NOT NULL DEFAULT 'opencode'");
   ensureColumn(db, "recomp_facts", "harness", "TEXT NOT NULL DEFAULT 'opencode'");
   ensureColumn(db, "message_history_index", "harness", "TEXT NOT NULL DEFAULT 'opencode'");
+  ensureColumn(db, "workspaces", "share_categories", `TEXT NOT NULL DEFAULT '["CONSTRAINTS"]'`);
 }
 function healAllNullColumns(db) {
   healNullTextColumns(db);
@@ -142730,6 +143419,7 @@ function healNullTextColumns(db) {
     ["system_prompt_hash", ""],
     ["stripped_placeholder_ids", ""],
     ["stale_reduce_stripped_ids", ""],
+    ["processed_image_stripped_ids", ""],
     ["memory_block_cache", ""],
     ["memory_block_ids", ""],
     ["compaction_marker_state", ""],
@@ -142774,7 +143464,7 @@ function healNullIntegerColumns(db) {
   }
 }
 function ensureColumn(db, table, column, definition) {
-  if (!/^[a-z][a-z0-9_]*$/.test(table) || !/^[a-z][a-z0-9_]*$/.test(column) || !/^[A-Z0-9_'(),[\]\s]+$/i.test(definition)) {
+  if (!/^[a-z][a-z0-9_]*$/.test(table) || !/^[a-z][a-z0-9_]*$/.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();
@@ -143852,10 +144542,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path3) {
-  if (!path3)
+function getElementAtPath(obj, path4) {
+  if (!path4)
     return obj;
-  return path3.reduce((acc, key) => acc?.[key], obj);
+  return path4.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -144263,11 +144953,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path3, issues) {
+function prefixIssues(path4, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path3);
+    iss.path.unshift(path4);
     return iss;
   });
 }
@@ -144414,16 +145104,16 @@ function flattenError(error, mapper = (issue2) => issue2.message) {
 }
 function formatError(error, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error2, path3 = []) => {
+  const processError = (error2, path4 = []) => {
     for (const issue2 of error2.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path3, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path4, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path4, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path4, ...issue2.path]);
       } else {
-        const fullpath = [...path3, ...issue2.path];
+        const fullpath = [...path4, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -144450,17 +145140,17 @@ function formatError(error, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error2, path3 = []) => {
+  const processError = (error2, path4 = []) => {
     var _a2, _b;
     for (const issue2 of error2.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path3, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path4, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path4, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path4, ...issue2.path]);
       } else {
-        const fullpath = [...path3, ...issue2.path];
+        const fullpath = [...path4, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -144492,8 +145182,8 @@ function treeifyError(error, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path3 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path3) {
+  const path4 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path4) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -156952,13 +157642,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path3 = ref.slice(1).split("/").filter(Boolean);
-  if (path3.length === 0) {
+  const path4 = ref.slice(1).split("/").filter(Boolean);
+  if (path4.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path3[0] === defsKey) {
-    const key = path3[1];
+  if (path4[0] === defsKey) {
+    const key = path4[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -157446,7 +158136,8 @@ var BaseEmbeddingConfigSchema = exports_external.object({
   endpoint: exports_external.string().optional().describe("API endpoint URL. Required when provider is openai-compatible."),
   api_key: exports_external.string().optional().describe("API key for remote embedding provider (optional)"),
   input_type: exports_external.string().optional().describe("Optional input_type sent in the embedding request body. Required by some openai-compatible providers (e.g. NVIDIA NIM expects 'query' or 'passage'). Omitted from the request when unset."),
-  truncate: exports_external.string().optional().describe("Optional truncate mode sent in the embedding request body (e.g. NVIDIA NIM accepts 'NONE' | 'START' | 'END'). Omitted from the request when unset.")
+  truncate: exports_external.string().optional().describe("Optional truncate mode sent in the embedding request body (e.g. NVIDIA NIM accepts 'NONE' | 'START' | 'END'). Omitted from the request when unset."),
+  max_input_tokens: exports_external.number().int().positive().optional().describe("Optional maximum input tokens for chunk embeddings. Defaults conservatively to 512 when omitted.")
 }).superRefine((data, ctx) => {
   if (data.provider === "openai-compatible" && !data.endpoint?.trim()) {
     ctx.addIssue({
@@ -157467,7 +158158,8 @@ var EmbeddingConfigSchema = BaseEmbeddingConfigSchema.transform((data) => {
   if (data.provider === "local") {
     return {
       provider: "local",
-      model: data.model?.trim() || DEFAULT_LOCAL_EMBEDDING_MODEL
+      model: data.model?.trim() || DEFAULT_LOCAL_EMBEDDING_MODEL,
+      ...data.max_input_tokens ? { max_input_tokens: data.max_input_tokens } : {}
     };
   }
   if (data.provider === "openai-compatible") {
@@ -157480,7 +158172,8 @@ var EmbeddingConfigSchema = BaseEmbeddingConfigSchema.transform((data) => {
       endpoint: data.endpoint?.trim() ?? "",
       ...apiKey ? { api_key: apiKey } : {},
       ...inputType ? { input_type: inputType } : {},
-      ...truncate ? { truncate } : {}
+      ...truncate ? { truncate } : {},
+      ...data.max_input_tokens ? { max_input_tokens: data.max_input_tokens } : {}
     };
   }
   return { provider: "off" };
@@ -157726,31 +158419,31 @@ function getUserConfigPaths() {
   return [`${basePath}.jsonc`, `${basePath}.json`];
 }
 function resolveFirstExisting(paths) {
-  return paths.find((path3) => existsSync5(path3));
+  return paths.find((path4) => existsSync5(path4));
 }
-function loadConfigFile(path3, scope) {
+function loadConfigFile(path4, scope) {
   try {
-    const rawText = readFileSync3(path3, "utf-8");
+    const rawText = readFileSync3(path4, "utf-8");
     const substituted = substituteConfigVariables({
       text: rawText,
-      configPath: path3,
+      configPath: path4,
       isProjectConfig: scope === "project"
     });
     return {
-      path: path3,
+      path: path4,
       scope,
       config: import_comment_json.parse(substituted.text),
-      warnings: substituted.warnings.map((warning) => `${path3}: ${warning}`),
+      warnings: substituted.warnings.map((warning) => `${path4}: ${warning}`),
       loadOutcome: substituted.warnings.length > 0 ? "substitution-failure" : "ok"
     };
   } catch (error51) {
     const message = error51 instanceof Error ? error51.message : String(error51);
     return {
-      path: path3,
+      path: path4,
       scope,
       config: {},
       warnings: [
-        `${path3}: failed to load config: ${message}; using defaults for this file.`
+        `${path4}: failed to load config: ${message}; using defaults for this file.`
       ],
       loadOutcome: typeof error51.code === "string" ? "project-file-io-error" : "project-file-parse-error"
     };
@@ -157916,9 +158609,9 @@ function bindSubstitutionFailures(loaded) {
   }
   const emptyPaths = collectEmptyStringPaths(loaded.config);
   return loaded.warnings.map((message) => {
-    const matchedPath = emptyPaths.find((path3) => {
-      const tail = path3.split(".").at(-1) ?? path3;
-      return message.includes(path3) || message.toLowerCase().includes(tail.toLowerCase());
+    const matchedPath = emptyPaths.find((path4) => {
+      const tail = path4.split(".").at(-1) ?? path4;
+      return message.includes(path4) || message.toLowerCase().includes(tail.toLowerCase());
     });
     return {
       keyPath: matchedPath ?? "<unknown>",
@@ -158006,6 +158699,443 @@ function loadPiConfigDetailed(opts = {}) {
 // ../plugin/src/features/magic-context/memory/embedding.ts
 init_logger();
 
+// ../plugin/src/features/magic-context/compartment-chunk-embedding.ts
+import { createHash as createHash4 } from "node:crypto";
+var DEFAULT_COMPARTMENT_CHUNK_MAX_INPUT_TOKENS = 512;
+var CHUNK_WINDOW_SAFETY_RATIO = 0.9;
+var loadFtsRowsStatements = new WeakMap;
+var existingHashStatements = new WeakMap;
+var existingHashByProjectStatements = new WeakMap;
+var deleteByCompartmentStatements = new WeakMap;
+var insertEmbeddingStatements = new WeakMap;
+var distinctModelStatements = new WeakMap;
+var clearProjectStatements = new WeakMap;
+var clearProjectModelStatements = new WeakMap;
+var searchRowsStatements = new WeakMap;
+var searchRowsByModelStatements = new WeakMap;
+var backfillCandidateStatements = new WeakMap;
+function getLoadFtsRowsStatement(db) {
+  let stmt = loadFtsRowsStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`SELECT message_ordinal AS messageOrdinal, role, content
+             FROM message_history_fts
+             WHERE session_id = ?
+               AND message_ordinal >= ?
+               AND message_ordinal <= ?
+               AND role IN ('user', 'assistant')
+             ORDER BY message_ordinal ASC`);
+    loadFtsRowsStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getExistingHashStatement(db, scopedToProject) {
+  const map2 = scopedToProject ? existingHashByProjectStatements : existingHashStatements;
+  let stmt = map2.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`SELECT window_index AS windowIndex, chunk_hash AS chunkHash
+             FROM compartment_chunk_embeddings
+             WHERE compartment_id = ?
+               AND model_id = ?
+               ${scopedToProject ? "AND project_path = ?" : ""}
+             ORDER BY window_index ASC`);
+    map2.set(db, stmt);
+  }
+  return stmt;
+}
+function getDeleteByCompartmentStatement(db) {
+  let stmt = deleteByCompartmentStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("DELETE FROM compartment_chunk_embeddings WHERE compartment_id = ?");
+    deleteByCompartmentStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getInsertEmbeddingStatement(db) {
+  let stmt = insertEmbeddingStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`INSERT INTO compartment_chunk_embeddings (
+                compartment_id, session_id, project_path, harness, window_index,
+                start_ordinal, end_ordinal, chunk_hash, model_id, dims, vector, created_at
+             ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+    insertEmbeddingStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getDistinctModelStatement(db) {
+  let stmt = distinctModelStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`SELECT DISTINCT model_id AS modelId
+             FROM compartment_chunk_embeddings
+             WHERE project_path = ?`);
+    distinctModelStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getClearProjectStatement(db) {
+  let stmt = clearProjectStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("DELETE FROM compartment_chunk_embeddings WHERE project_path = ?");
+    clearProjectStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getClearProjectModelStatement(db) {
+  let stmt = clearProjectModelStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("DELETE FROM compartment_chunk_embeddings WHERE project_path = ? AND model_id = ?");
+    clearProjectModelStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getSearchRowsStatement(db, withModel) {
+  const map2 = withModel ? searchRowsByModelStatements : searchRowsStatements;
+  let stmt = map2.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`SELECT e.compartment_id AS compartmentId,
+                    e.session_id AS sessionId,
+                    c.title AS title,
+                    c.start_message AS compartmentStart,
+                    c.end_message AS compartmentEnd,
+                    e.window_index AS windowIndex,
+                    e.start_ordinal AS windowStart,
+                    e.end_ordinal AS windowEnd,
+                    e.chunk_hash AS chunkHash,
+                    e.model_id AS modelId,
+                    e.dims AS dims,
+                    e.vector AS vector
+             FROM compartment_chunk_embeddings e
+             JOIN compartments c ON c.id = e.compartment_id
+             WHERE e.session_id = ?
+               AND e.project_path = ?
+               ${withModel ? "AND e.model_id = ?" : ""}
+             ORDER BY e.compartment_id ASC, e.window_index ASC`);
+    map2.set(db, stmt);
+  }
+  return stmt;
+}
+function isFinitePositiveInteger(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function normalizeCompartmentChunkMaxInputTokens(value) {
+  if (!isFinitePositiveInteger(value)) {
+    return DEFAULT_COMPARTMENT_CHUNK_MAX_INPUT_TOKENS;
+  }
+  return Math.max(1, Math.floor(value));
+}
+function normalizeContent(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function formatOrdinalRange(start, end) {
+  return start === end ? `[${start}]` : `[${start}-${end}]`;
+}
+function rolePrefix(role) {
+  if (role === "user")
+    return "U";
+  if (role === "assistant")
+    return "A";
+  return null;
+}
+function parseOrdinal(value) {
+  const parsed = typeof value === "number" ? value : Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+}
+function parseCanonicalLineRange(line) {
+  const match = /^\[(\d+)(?:-(\d+))?\]\s+[UA]:/.exec(line.trim());
+  if (!match)
+    return null;
+  const start = Number.parseInt(match[1], 10);
+  const end = match[2] ? Number.parseInt(match[2], 10) : start;
+  if (!Number.isFinite(start) || !Number.isFinite(end))
+    return null;
+  return { start, end };
+}
+function hashChunkText(text) {
+  return createHash4("sha256").update(text).digest("hex");
+}
+function vectorBlob(vector) {
+  return new Uint8Array(vector.buffer, vector.byteOffset, vector.byteLength);
+}
+function toFloat32Array(blob) {
+  if (blob instanceof Uint8Array) {
+    const buffer2 = blob.buffer.slice(blob.byteOffset, blob.byteOffset + blob.byteLength);
+    return new Float32Array(buffer2);
+  }
+  return new Float32Array(blob.slice(0));
+}
+function buildCanonicalChunkTextFromFts(db, sessionId, startOrdinal, endOrdinal) {
+  if (endOrdinal < startOrdinal)
+    return "";
+  const rows = getLoadFtsRowsStatement(db).all(sessionId, startOrdinal, endOrdinal).map((row) => row);
+  const lines = [];
+  let current = null;
+  const flush2 = () => {
+    if (!current || current.parts.length === 0)
+      return;
+    lines.push(`${formatOrdinalRange(current.start, current.end)} ${current.role}: ${current.parts.join(" / ")}`);
+    current = null;
+  };
+  for (const row of rows) {
+    const ordinal = parseOrdinal(row.messageOrdinal);
+    const prefix = rolePrefix(row.role);
+    const content = typeof row.content === "string" ? normalizeContent(row.content) : "";
+    if (ordinal === null || prefix === null || content.length === 0)
+      continue;
+    if (current && current.role === prefix) {
+      current.end = ordinal;
+      current.parts.push(content);
+      continue;
+    }
+    flush2();
+    current = { role: prefix, start: ordinal, end: ordinal, parts: [content] };
+  }
+  flush2();
+  return lines.join(`
+`);
+}
+function canonicalizeInMemoryChunkTextForEmbedding(chunkText, startOrdinal, endOrdinal) {
+  const lines = [];
+  for (const rawLine of chunkText.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    const match = /^(\[(\d+)(?:-(\d+))?\]\s+[UA]:)\s*(.*)$/.exec(line);
+    if (!match)
+      continue;
+    const lineStart = Number.parseInt(match[2], 10);
+    const lineEnd = match[3] ? Number.parseInt(match[3], 10) : lineStart;
+    if (startOrdinal != null && lineEnd < startOrdinal)
+      continue;
+    if (endOrdinal != null && lineStart > endOrdinal)
+      continue;
+    const rawParts = match[4].split(" / ").map((part) => normalizeContent(part)).filter((part) => part.length > 0);
+    const ordinalSpan = lineEnd - lineStart + 1;
+    const roleLabel = match[1].slice(match[1].indexOf("]") + 2);
+    if (ordinalSpan === rawParts.length) {
+      const retained = rawParts.map((part, index) => ({ ordinal: lineStart + index, part })).filter(({ ordinal, part }) => {
+        if (part.startsWith("TC:"))
+          return false;
+        if (startOrdinal != null && ordinal < startOrdinal)
+          return false;
+        if (endOrdinal != null && ordinal > endOrdinal)
+          return false;
+        return true;
+      });
+      if (retained.length === 0)
+        continue;
+      const retainedStart = retained[0].ordinal;
+      const retainedEnd = retained[retained.length - 1].ordinal;
+      lines.push(`${formatOrdinalRange(retainedStart, retainedEnd)} ${roleLabel} ${retained.map(({ part }) => part).join(" / ")}`);
+      continue;
+    }
+    const parts = rawParts.filter((part) => !part.startsWith("TC:"));
+    if (parts.length === 0)
+      continue;
+    lines.push(`${match[1]} ${parts.join(" / ")}`);
+  }
+  return lines.join(`
+`);
+}
+function chunkCanonicalText(canonicalText, startOrdinal, endOrdinal, maxInputTokens) {
+  const lines = canonicalText.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+  if (lines.length === 0 || endOrdinal < startOrdinal)
+    return [];
+  const normalizedMax = normalizeCompartmentChunkMaxInputTokens(maxInputTokens);
+  const effectiveMax = Math.max(1, Math.floor(normalizedMax * CHUNK_WINDOW_SAFETY_RATIO));
+  const fullText = lines.join(`
+`);
+  if (estimateTokens(fullText) <= effectiveMax) {
+    return [
+      {
+        windowIndex: 0,
+        startOrdinal,
+        endOrdinal,
+        text: fullText,
+        chunkHash: hashChunkText(fullText)
+      }
+    ];
+  }
+  const windows = [];
+  let currentLines = [];
+  let currentStart = null;
+  let currentEnd = null;
+  let currentTokens = 0;
+  const flush2 = () => {
+    if (currentLines.length === 0 || currentStart === null || currentEnd === null)
+      return;
+    const text = currentLines.join(`
+`);
+    windows.push({
+      windowIndex: windows.length + 1,
+      startOrdinal: currentStart,
+      endOrdinal: currentEnd,
+      text,
+      chunkHash: hashChunkText(text)
+    });
+    currentLines = [];
+    currentStart = null;
+    currentEnd = null;
+    currentTokens = 0;
+  };
+  for (const line of lines) {
+    const range = parseCanonicalLineRange(line);
+    const lineStart = range?.start ?? startOrdinal;
+    const lineEnd = range?.end ?? lineStart;
+    const lineTokens = estimateTokens(line);
+    if (currentLines.length > 0 && currentTokens + lineTokens > effectiveMax) {
+      flush2();
+    }
+    if (currentLines.length === 0) {
+      currentStart = lineStart;
+    }
+    currentLines.push(line);
+    currentEnd = lineEnd;
+    currentTokens += lineTokens;
+  }
+  flush2();
+  return windows;
+}
+function getExistingChunkHashes(db, compartmentId, modelId, projectPath) {
+  const scoped = typeof projectPath === "string" && projectPath.length > 0;
+  const rows = scoped ? getExistingHashStatement(db, true).all(compartmentId, modelId, projectPath) : getExistingHashStatement(db, false).all(compartmentId, modelId);
+  return new Map(rows.filter((row) => typeof row.windowIndex === "number" && typeof row.chunkHash === "string").map((row) => [row.windowIndex, row.chunkHash]));
+}
+function chunkEmbeddingWindowsAreCurrent(db, compartmentId, modelId, windows, projectPath) {
+  const existing = getExistingChunkHashes(db, compartmentId, modelId, projectPath);
+  if (existing.size !== windows.length)
+    return false;
+  return windows.every((window) => existing.get(window.windowIndex) === window.chunkHash);
+}
+function replaceCompartmentChunkEmbeddings(db, rows) {
+  if (rows.length === 0)
+    return;
+  const compartmentId = rows[0].compartmentId;
+  const now = Date.now();
+  db.transaction(() => {
+    getDeleteByCompartmentStatement(db).run(compartmentId);
+    const insert = getInsertEmbeddingStatement(db);
+    for (const row of rows) {
+      insert.run(row.compartmentId, row.sessionId, row.projectPath, getHarness(), row.window.windowIndex, row.window.startOrdinal, row.window.endOrdinal, row.window.chunkHash, row.modelId, row.vector.length, vectorBlob(row.vector), row.createdAt ?? now);
+    }
+  })();
+}
+function getDistinctChunkEmbeddingModelIds(db, projectPath) {
+  const rows = getDistinctModelStatement(db).all(projectPath);
+  return new Set(rows.map((row) => typeof row.modelId === "string" ? row.modelId : null));
+}
+function clearChunkEmbeddingsForProject(db, projectPath, modelId) {
+  if (modelId) {
+    return getClearProjectModelStatement(db).run(projectPath, modelId).changes;
+  }
+  return getClearProjectStatement(db).run(projectPath).changes;
+}
+function loadCompartmentChunkEmbeddingsForSearch(db, sessionId, projectPath, modelId) {
+  const rows = modelId ? getSearchRowsStatement(db, true).all(sessionId, projectPath, modelId) : getSearchRowsStatement(db, false).all(sessionId, projectPath);
+  return rows.filter((row) => typeof row.compartmentId === "number" && typeof row.sessionId === "string" && typeof row.title === "string" && typeof row.compartmentStart === "number" && typeof row.compartmentEnd === "number" && typeof row.windowIndex === "number" && typeof row.windowStart === "number" && typeof row.windowEnd === "number" && typeof row.chunkHash === "string" && typeof row.modelId === "string" && typeof row.dims === "number" && (row.vector instanceof Uint8Array || row.vector instanceof ArrayBuffer)).map((row) => ({
+    compartmentId: row.compartmentId,
+    sessionId: row.sessionId,
+    title: row.title,
+    startOrdinal: row.compartmentStart,
+    endOrdinal: row.compartmentEnd,
+    windowIndex: row.windowIndex,
+    windowStartOrdinal: row.windowStart,
+    windowEndOrdinal: row.windowEnd,
+    chunkHash: row.chunkHash,
+    modelId: row.modelId,
+    dims: row.dims,
+    vector: toFloat32Array(row.vector)
+  }));
+}
+function mapBackfillCandidateRows(rows) {
+  return rows.filter((row) => {
+    if (row === null || typeof row !== "object")
+      return false;
+    const candidate = row;
+    return typeof candidate.id === "number" && typeof candidate.sessionId === "string" && typeof candidate.startMessage === "number" && typeof candidate.endMessage === "number" && typeof candidate.title === "string";
+  }).map((row) => ({
+    id: row.id,
+    sessionId: row.sessionId,
+    startMessage: row.startMessage,
+    endMessage: row.endMessage,
+    title: row.title
+  }));
+}
+var sessionBackfillCandidateStatements = new WeakMap;
+function loadUnembeddedSessionChunkCandidates(db, projectPath, sessionId, modelId, limit, excludeIds) {
+  if (excludeIds && excludeIds.length > 0) {
+    const placeholders2 = excludeIds.map(() => "?").join(", ");
+    const stmt2 = db.prepare(`SELECT c.id AS id,
+                    c.session_id AS sessionId,
+                    c.start_message AS startMessage,
+                    c.end_message AS endMessage,
+                    c.title AS title
+             FROM compartments c
+             JOIN session_projects sp
+               ON sp.session_id = c.session_id
+              AND sp.harness = c.harness
+              AND sp.project_path = ?
+             WHERE c.session_id = ?
+               AND c.start_message IS NOT NULL
+               AND c.end_message IS NOT NULL
+               AND c.id NOT IN (${placeholders2})
+               AND NOT EXISTS (
+                   SELECT 1
+                   FROM compartment_chunk_embeddings current
+                   WHERE current.compartment_id = c.id
+                     AND current.project_path = ?
+                     AND current.model_id = ?
+               )
+             ORDER BY c.start_message ASC, c.id ASC
+             LIMIT ?`);
+    const rows2 = stmt2.all(projectPath, sessionId, ...excludeIds, projectPath, modelId, Math.max(1, limit));
+    return mapBackfillCandidateRows(rows2);
+  }
+  let stmt = sessionBackfillCandidateStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`SELECT c.id AS id,
+                    c.session_id AS sessionId,
+                    c.start_message AS startMessage,
+                    c.end_message AS endMessage,
+                    c.title AS title
+             FROM compartments c
+             JOIN session_projects sp
+               ON sp.session_id = c.session_id
+              AND sp.harness = c.harness
+              AND sp.project_path = ?
+             WHERE c.session_id = ?
+               AND c.start_message IS NOT NULL
+               AND c.end_message IS NOT NULL
+               AND NOT EXISTS (
+                   SELECT 1
+                   FROM compartment_chunk_embeddings current
+                   WHERE current.compartment_id = c.id
+                     AND current.project_path = ?
+                     AND current.model_id = ?
+               )
+             ORDER BY c.start_message ASC, c.id ASC
+             LIMIT ?`);
+    sessionBackfillCandidateStatements.set(db, stmt);
+  }
+  const rows = stmt.all(projectPath, sessionId, projectPath, modelId, Math.max(1, limit));
+  return mapBackfillCandidateRows(rows);
+}
+function countUnembeddedSessionCompartments(db, projectPath, sessionId, modelId) {
+  const row = db.prepare(`SELECT COUNT(*) AS n
+             FROM compartments c
+             JOIN session_projects sp
+               ON sp.session_id = c.session_id
+              AND sp.harness = c.harness
+              AND sp.project_path = ?
+             WHERE c.session_id = ?
+               AND c.start_message IS NOT NULL
+               AND c.end_message IS NOT NULL
+               AND NOT EXISTS (
+                   SELECT 1
+                   FROM compartment_chunk_embeddings current
+                   WHERE current.compartment_id = c.id
+                     AND current.project_path = ?
+                     AND current.model_id = ?
+               )`).get(projectPath, sessionId, projectPath, modelId);
+  return typeof row?.n === "number" ? row.n : 0;
+}
+
 // ../plugin/src/features/magic-context/memory/cosine-similarity.ts
 function cosineSimilarity(a, b) {
   if (a.length !== b.length) {
@@ -158024,13 +159154,13 @@ function cosineSimilarity(a, b) {
 }
 
 // ../plugin/src/features/magic-context/memory/normalize-hash.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 function normalizeMemoryContent(content) {
   return content.toLowerCase().replace(/\s+/g, " ").trim();
 }
 function computeNormalizedHash(content) {
   const normalized = normalizeMemoryContent(content);
-  return createHash2("md5").update(normalized).digest("hex");
+  return createHash5("md5").update(normalized).digest("hex");
 }
 
 // ../plugin/src/features/magic-context/memory/embedding-identity.ts
@@ -158174,19 +159304,19 @@ function isArrayLikeNumber(value) {
   }
   return arr.length === 0 || typeof arr[0] === "number";
 }
-function toFloat32Array(values) {
+function toFloat32Array2(values) {
   return values instanceof Float32Array ? new Float32Array(values) : Float32Array.from(Array.from(values));
 }
 function extractBatchEmbeddings(result, expectedCount) {
   const { data } = result;
   if (Array.isArray(data) && data.length === expectedCount && data.every((entry) => typeof entry !== "number" && isArrayLikeNumber(entry))) {
-    return data.map((entry) => toFloat32Array(entry));
+    return data.map((entry) => toFloat32Array2(entry));
   }
   if (!isArrayLikeNumber(data)) {
     log("[magic-context] embedding batch returned unexpected data shape");
     return Array.from({ length: expectedCount }, () => null);
   }
-  const flatData = toFloat32Array(data);
+  const flatData = toFloat32Array2(data);
   const dimension = result.dims?.at(-1) ?? flatData.length / expectedCount;
   if (!Number.isInteger(dimension) || dimension <= 0 || flatData.length !== expectedCount * dimension) {
     log("[magic-context] embedding batch returned invalid dimensions");
@@ -158201,6 +159331,7 @@ function extractBatchEmbeddings(result, expectedCount) {
 
 class LocalEmbeddingProvider {
   modelId;
+  maxInputTokens;
   model;
   pipeline = null;
   initPromise = null;
@@ -158208,8 +159339,9 @@ class LocalEmbeddingProvider {
   disposing = false;
   disposePromise = null;
   inFlightWaiters = [];
-  constructor(model = DEFAULT_LOCAL_EMBEDDING_MODEL) {
+  constructor(model = DEFAULT_LOCAL_EMBEDDING_MODEL, maxInputTokens = 512) {
     this.model = model;
+    this.maxInputTokens = maxInputTokens;
     this.modelId = getEmbeddingProviderIdentity({ provider: "local", model });
   }
   async initialize() {
@@ -158457,6 +159589,13 @@ function blockedEmbeddingEndpointReason(endpoint) {
 function normalizeEndpoint3(endpoint) {
   return endpoint?.trim().replace(/\/+$/, "") ?? "";
 }
+function embeddingModelsMatch(served, requested) {
+  const a = served.trim().toLowerCase();
+  const b = requested.trim().toLowerCase();
+  if (a.length === 0 || b.length === 0)
+    return true;
+  return a === b || a.includes(b) || b.includes(a);
+}
 var FAILURE_THRESHOLD = 3;
 var FAILURE_WINDOW_MS = 60000;
 var OPEN_DURATION_MS = 5 * 60000;
@@ -158464,6 +159603,7 @@ var FETCH_TIMEOUT_MS = 30000;
 
 class OpenAICompatibleEmbeddingProvider {
   modelId;
+  maxInputTokens;
   endpoint;
   model;
   apiKey;
@@ -158473,6 +159613,7 @@ class OpenAICompatibleEmbeddingProvider {
   failureTimes = [];
   circuitOpenUntil = 0;
   openLogged = false;
+  modelMismatchLogged = false;
   halfOpenProbeInFlight = false;
   constructor(options) {
     this.endpoint = normalizeEndpoint3(options.endpoint);
@@ -158480,11 +159621,13 @@ class OpenAICompatibleEmbeddingProvider {
     this.apiKey = options.apiKey?.trim() ?? "";
     this.inputType = options.inputType?.trim() ?? "";
     this.truncate = options.truncate?.trim() ?? "";
+    this.maxInputTokens = typeof options.maxInputTokens === "number" && Number.isFinite(options.maxInputTokens) ? Math.max(1, Math.floor(options.maxInputTokens)) : 512;
     this.modelId = getEmbeddingProviderIdentity({
       provider: "openai-compatible",
       endpoint: this.endpoint,
       model: this.model,
-      ...this.apiKey ? { api_key: this.apiKey } : {}
+      ...this.apiKey ? { api_key: this.apiKey } : {},
+      ...this.inputType ? { input_type: this.inputType } : {}
     });
   }
   async initialize() {
@@ -158569,6 +159712,15 @@ class OpenAICompatibleEmbeddingProvider {
         this.recordFailure(isProbe);
         return Array.from({ length: texts.length }, () => null);
       }
+      const servedModel = typeof body.model === "string" ? body.model : "";
+      if (this.model && servedModel && !embeddingModelsMatch(servedModel, this.model)) {
+        if (!this.modelMismatchLogged) {
+          log(`[magic-context] embedding endpoint served a DIFFERENT model than requested — refusing the substituted vectors (they have the wrong dimensions/space). requested="${this.model}" served="${servedModel}". The endpoint likely substituted a loaded model; load/select "${this.model}" on the endpoint, or set embedding.model to the served model.`);
+          this.modelMismatchLogged = true;
+        }
+        this.recordFailure(isProbe);
+        return Array.from({ length: texts.length }, () => null);
+      }
       const items = Array.isArray(body.data) ? body.data : [];
       const results = Array.from({ length: texts.length }, (_, index) => {
         const embedding = items[index]?.embedding;
@@ -158688,9 +159840,9 @@ function isEmbeddingRow(row) {
   if (row === null || typeof row !== "object")
     return false;
   const candidate = row;
-  return typeof candidate.memoryId === "number" && isEmbeddingBlob(candidate.embedding);
+  return typeof candidate.memoryId === "number" && isEmbeddingBlob(candidate.embedding) && (candidate.modelId === null || typeof candidate.modelId === "string");
 }
-function toFloat32Array2(blob) {
+function toFloat32Array3(blob) {
   if (blob instanceof Uint8Array) {
     const buffer2 = blob.buffer.slice(blob.byteOffset, blob.byteOffset + blob.byteLength);
     return new Float32Array(buffer2);
@@ -158708,7 +159860,7 @@ function getSaveEmbeddingStatement(db) {
 function getLoadAllEmbeddingsStatement(db) {
   let stmt = loadAllEmbeddingsStatements.get(db);
   if (!stmt) {
-    stmt = db.prepare("SELECT memory_embeddings.memory_id AS memoryId, memory_embeddings.embedding AS embedding FROM memory_embeddings INNER JOIN memories ON memories.id = memory_embeddings.memory_id WHERE memories.project_path = ? ORDER BY memory_embeddings.memory_id ASC");
+    stmt = db.prepare("SELECT memory_embeddings.memory_id AS memoryId, memory_embeddings.embedding AS embedding, memory_embeddings.model_id AS modelId FROM memory_embeddings INNER JOIN memories ON memories.id = memory_embeddings.memory_id WHERE memories.project_path = ? ORDER BY memory_embeddings.memory_id ASC");
     loadAllEmbeddingsStatements.set(db, stmt);
   }
   return stmt;
@@ -158737,7 +159889,10 @@ function loadAllEmbeddings(db, projectPath) {
   const rows = getLoadAllEmbeddingsStatement(db).all(projectPath).filter(isEmbeddingRow);
   const embeddings = new Map;
   for (const row of rows) {
-    embeddings.set(row.memoryId, toFloat32Array2(row.embedding));
+    embeddings.set(row.memoryId, {
+      embedding: toFloat32Array3(row.embedding),
+      modelId: row.modelId
+    });
   }
   return embeddings;
 }
@@ -158750,7 +159905,7 @@ function getDistinctStoredModelIds(db, projectPath) {
 }
 
 // ../plugin/src/features/magic-context/project-embedding-registry.ts
-import { createHash as createHash3, randomUUID } from "node:crypto";
+import { createHash as createHash6, randomUUID } from "node:crypto";
 init_logger();
 
 // ../plugin/src/features/magic-context/git-commits/storage-git-commit-embeddings.ts
@@ -158758,7 +159913,7 @@ var saveStatements = new WeakMap;
 var loadProjectStatements = new WeakMap;
 var loadUnembeddedStatements = new WeakMap;
 var countEmbeddedStatements = new WeakMap;
-var clearProjectStatements = new WeakMap;
+var clearProjectStatements2 = new WeakMap;
 var distinctModelIdStatements = new WeakMap;
 function getSaveStatement(db) {
   let stmt = saveStatements.get(db);
@@ -158806,12 +159961,12 @@ function getCountEmbeddedStatement(db) {
   }
   return stmt;
 }
-function getClearProjectStatement(db) {
-  let stmt = clearProjectStatements.get(db);
+function getClearProjectStatement2(db) {
+  let stmt = clearProjectStatements2.get(db);
   if (!stmt) {
     stmt = db.prepare(`DELETE FROM git_commit_embeddings
              WHERE sha IN (SELECT sha FROM git_commits WHERE project_path = ?)`);
-    clearProjectStatements.set(db, stmt);
+    clearProjectStatements2.set(db, stmt);
   }
   return stmt;
 }
@@ -158847,7 +160002,7 @@ function countEmbeddedCommits(db, projectPath) {
   return row?.count ?? 0;
 }
 function clearProjectCommitEmbeddings(db, projectPath) {
-  return getClearProjectStatement(db).run(projectPath).changes;
+  return getClearProjectStatement2(db).run(projectPath).changes;
 }
 function getDistinctCommitEmbeddingModelIds(db, projectPath) {
   const rows = getDistinctModelIdStatement(db).all(projectPath);
@@ -159011,9 +160166,83 @@ function invalidateMemory(projectPath, memoryId) {
   cached2?.embeddings.delete(memoryId);
 }
 
+// ../plugin/src/features/magic-context/session-project-storage.ts
+var upsertSessionProjectStatements = new WeakMap;
+var repairSessionChunkProjectStatements = new WeakMap;
+var repairProjectChunkProjectStatements = new WeakMap;
+function getUpsertSessionProjectStatement(db) {
+  let stmt = upsertSessionProjectStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`INSERT INTO session_projects (session_id, harness, project_path, updated_at)
+             VALUES (?, ?, ?, ?)
+             ON CONFLICT(session_id, harness) DO UPDATE SET
+                 project_path = excluded.project_path,
+                 updated_at = excluded.updated_at
+             WHERE session_projects.project_path <> excluded.project_path`);
+    upsertSessionProjectStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getRepairSessionChunkProjectStatement(db) {
+  let stmt = repairSessionChunkProjectStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`UPDATE compartment_chunk_embeddings
+             SET project_path = ?
+             WHERE session_id = ?
+               AND harness = ?
+               AND project_path <> ?`);
+    repairSessionChunkProjectStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getRepairProjectChunkProjectStatement(db) {
+  let stmt = repairProjectChunkProjectStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`UPDATE compartment_chunk_embeddings
+             SET project_path = (
+                 SELECT sp.project_path
+                 FROM session_projects sp
+                 WHERE sp.session_id = compartment_chunk_embeddings.session_id
+                   AND sp.harness = compartment_chunk_embeddings.harness
+                 LIMIT 1
+             )
+             WHERE EXISTS (
+                 SELECT 1
+                 FROM session_projects sp
+                 WHERE sp.session_id = compartment_chunk_embeddings.session_id
+                   AND sp.harness = compartment_chunk_embeddings.harness
+                   AND sp.project_path <> compartment_chunk_embeddings.project_path
+                   AND (
+                       sp.project_path = ?
+                       OR compartment_chunk_embeddings.project_path = ?
+                   )
+             )`);
+    repairProjectChunkProjectStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function recordSessionProjectIdentity(db, sessionId, projectPath) {
+  if (!sessionId || !projectPath)
+    return;
+  const harness = getHarness();
+  const now = Date.now();
+  db.transaction(() => {
+    getUpsertSessionProjectStatement(db).run(sessionId, harness, projectPath, now);
+    getRepairSessionChunkProjectStatement(db).run(projectPath, sessionId, harness, projectPath);
+  })();
+}
+function repairMisScopedCompartmentChunkEmbeddingsForProject(db, projectPath) {
+  if (!projectPath)
+    return 0;
+  return getRepairProjectChunkProjectStatement(db).run(projectPath, projectPath).changes;
+}
+
 // ../plugin/src/features/magic-context/project-embedding-registry.ts
 var OFF_PROVIDER_IDENTITY = "embedding-provider:off";
 var SWEEP_MAX_WALL_CLOCK_MS = 10 * 60 * 1000;
+var CHUNK_DRAIN_BATCH_SIZE = 8;
+var MAX_WINDOWS_PER_EMBED_CALL = 16;
+var SESSION_EMBED_LEASE_RENEWAL_MS = 60 * 1000;
 var projectRegistrations = new Map;
 var loadUnembeddedMemoriesStatements = new WeakMap;
 var globalRegistrationGeneration = 0;
@@ -159022,7 +160251,10 @@ function resolveEmbeddingConfig(config2) {
   if (!config2 || config2.provider === "local") {
     return {
       provider: "local",
-      model: config2?.model?.trim() || DEFAULT_LOCAL_EMBEDDING_MODEL
+      model: config2?.model?.trim() || DEFAULT_LOCAL_EMBEDDING_MODEL,
+      ...config2?.max_input_tokens ? {
+        max_input_tokens: normalizeCompartmentChunkMaxInputTokens(config2.max_input_tokens)
+      } : {}
     };
   }
   if (config2.provider === "openai-compatible") {
@@ -159035,7 +160267,10 @@ function resolveEmbeddingConfig(config2) {
       endpoint: config2.endpoint.trim(),
       ...apiKey ? { api_key: apiKey } : {},
       ...inputType ? { input_type: inputType } : {},
-      ...truncate ? { truncate } : {}
+      ...truncate ? { truncate } : {},
+      ...config2.max_input_tokens ? {
+        max_input_tokens: normalizeCompartmentChunkMaxInputTokens(config2.max_input_tokens)
+      } : {}
     };
   }
   return { provider: "off" };
@@ -159053,10 +160288,11 @@ function createProvider(config2) {
       model: config2.model,
       apiKey: config2.api_key,
       inputType: config2.input_type,
-      truncate: config2.truncate
+      truncate: config2.truncate,
+      maxInputTokens: config2.max_input_tokens
     });
   }
-  return new LocalEmbeddingProvider(config2.model);
+  return new LocalEmbeddingProvider(config2.model, config2.max_input_tokens);
 }
 function stableStringify2(value) {
   if (Array.isArray(value)) {
@@ -159069,7 +160305,7 @@ function stableStringify2(value) {
   return JSON.stringify(value);
 }
 function sha256Prefix(value, length = 16) {
-  return createHash3("sha256").update(value).digest("hex").slice(0, length);
+  return createHash6("sha256").update(value).digest("hex").slice(0, length);
 }
 function getRuntimeFingerprint(config2) {
   if (config2.provider === "off") {
@@ -159077,6 +160313,18 @@ function getRuntimeFingerprint(config2) {
   }
   return `${getEmbeddingProviderIdentity(config2)}:${sha256Prefix(stableStringify2(config2))}`;
 }
+function getChunkEmbeddingModelId(config2, providerIdentity) {
+  if (config2.provider === "off") {
+    return OFF_PROVIDER_IDENTITY;
+  }
+  const chunkIdentity = {
+    providerIdentity,
+    chunkerVersion: 2,
+    maxInputTokens: normalizeCompartmentChunkMaxInputTokens("max_input_tokens" in config2 ? config2.max_input_tokens : undefined),
+    truncate: config2.provider === "openai-compatible" ? config2.truncate ?? "" : ""
+  };
+  return `${providerIdentity}:chunk:${sha256Prefix(stableStringify2(chunkIdentity))}`;
+}
 function sameFeatures(a, b) {
   return a.memoryEnabled === b.memoryEnabled && a.gitCommitEnabled === b.gitCommitEnabled;
 }
@@ -159093,7 +160341,8 @@ function snapshotFor(registration) {
     features: { ...registration.features },
     enabled,
     gitCommitEnabled,
-    modelId: registration.observationMode || !providerIsOn ? "off" : registration.modelId
+    modelId: registration.observationMode || !providerIsOn ? "off" : registration.modelId,
+    chunkModelId: registration.observationMode || !providerIsOn ? "off" : registration.chunkModelId
   };
 }
 function disposeProvider(provider) {
@@ -159113,7 +160362,7 @@ function anyStoredModelIdIsStale(storedIds, currentId) {
   }
   return false;
 }
-function maybeWipeStaleEmbeddings(db, projectIdentity, currentProviderIdentity, features) {
+function maybeWipeStaleEmbeddings(db, projectIdentity, currentProviderIdentity, currentChunkIdentity, features) {
   if (currentProviderIdentity === OFF_PROVIDER_IDENTITY) {
     return false;
   }
@@ -159134,6 +160383,14 @@ function maybeWipeStaleEmbeddings(db, projectIdentity, currentProviderIdentity,
         wiped = true;
       }
     }
+    if (features.memoryEnabled) {
+      repairMisScopedCompartmentChunkEmbeddingsForProject(db, projectIdentity);
+      const chunkIds = getDistinctChunkEmbeddingModelIds(db, projectIdentity);
+      if (anyStoredModelIdIsStale(chunkIds, currentChunkIdentity)) {
+        clearChunkEmbeddingsForProject(db, projectIdentity);
+        wiped = true;
+      }
+    }
   })();
   return wiped;
 }
@@ -159141,10 +160398,11 @@ function registerProjectEmbeddingAndMaybeWipe(db, projectIdentity, config2, feat
   const resolvedConfig = resolveEmbeddingConfig(config2);
   const providerIdentity = getEmbeddingProviderIdentity(resolvedConfig);
   const runtimeFingerprint = getRuntimeFingerprint(resolvedConfig);
+  const chunkModelId = getChunkEmbeddingModelId(resolvedConfig, providerIdentity);
   const prior = projectRegistrations.get(projectIdentity);
   const canReuseProvider = prior !== undefined && !prior.observationMode && prior.runtimeFingerprint === runtimeFingerprint && prior.providerIdentity === providerIdentity;
-  const wiped = maybeWipeStaleEmbeddings(db, projectIdentity, providerIdentity, features);
-  const generationChanged = prior === undefined || prior.observationMode || prior.runtimeFingerprint !== runtimeFingerprint || !sameFeatures(prior.features, features) || wiped;
+  const wiped = maybeWipeStaleEmbeddings(db, projectIdentity, providerIdentity, chunkModelId, features);
+  const generationChanged = prior === undefined || prior.observationMode || prior.runtimeFingerprint !== runtimeFingerprint || prior.chunkModelId !== chunkModelId || !sameFeatures(prior.features, features) || wiped;
   const generation = generationChanged ? ++globalRegistrationGeneration : prior.generation;
   const registration = {
     projectIdentity,
@@ -159156,6 +160414,7 @@ function registerProjectEmbeddingAndMaybeWipe(db, projectIdentity, config2, feat
     generation,
     features: { ...features },
     modelId: providerIdentity === OFF_PROVIDER_IDENTITY ? "off" : providerIdentity,
+    chunkModelId: providerIdentity === OFF_PROVIDER_IDENTITY ? "off" : chunkModelId,
     observationMode: false
   };
   projectRegistrations.set(projectIdentity, registration);
@@ -159178,6 +160437,7 @@ function registerProjectInObservationMode(db, projectIdentity, sourceDirectory,
     generation,
     features: { memoryEnabled: false, gitCommitEnabled: false },
     modelId: "off",
+    chunkModelId: "off",
     observationMode: true
   };
   projectRegistrations.set(projectIdentity, registration);
@@ -159188,6 +160448,15 @@ function getProjectEmbeddingSnapshot(projectIdentity) {
   const registration = projectRegistrations.get(projectIdentity);
   return registration ? snapshotFor(registration) : null;
 }
+function getProjectChunkEmbeddingModelId(projectIdentity) {
+  const registration = projectRegistrations.get(projectIdentity);
+  return registration && !registration.observationMode ? registration.chunkModelId : "off";
+}
+function getProjectEmbeddingMaxInputTokens(projectIdentity) {
+  const registration = projectRegistrations.get(projectIdentity);
+  const configMax = registration?.config && "max_input_tokens" in registration.config ? registration.config.max_input_tokens : undefined;
+  return normalizeCompartmentChunkMaxInputTokens(registration?.provider?.maxInputTokens ?? configMax);
+}
 function getOrCreateProjectProvider(registration) {
   if (registration.providerIdentity === OFF_PROVIDER_IDENTITY || registration.observationMode) {
     return null;
@@ -159282,6 +160551,131 @@ async function embedUnembeddedMemoriesForProject(db, projectIdentity, batchSize
     return 0;
   }
 }
+async function embedCandidateChunkBatch(db, projectIdentity, modelId, candidates, signal) {
+  const noWork = [];
+  if (candidates.length === 0)
+    return { embedded: 0, noWork };
+  const maxInputTokens = getProjectEmbeddingMaxInputTokens(projectIdentity);
+  const prepared = [];
+  for (const candidate of candidates) {
+    const canonicalText = buildCanonicalChunkTextFromFts(db, candidate.sessionId, candidate.startMessage, candidate.endMessage);
+    if (canonicalText.length === 0) {
+      noWork.push(candidate.id);
+      continue;
+    }
+    const windows = chunkCanonicalText(canonicalText, candidate.startMessage, candidate.endMessage, maxInputTokens);
+    if (windows.length === 0 || chunkEmbeddingWindowsAreCurrent(db, candidate.id, modelId, windows, projectIdentity)) {
+      noWork.push(candidate.id);
+      continue;
+    }
+    prepared.push({ candidate, windows });
+  }
+  if (prepared.length === 0)
+    return { embedded: 0, noWork };
+  let embedded = 0;
+  let i = 0;
+  while (i < prepared.length) {
+    if (signal?.aborted)
+      break;
+    const slice = [];
+    let windowCount = 0;
+    do {
+      const item = prepared[i];
+      slice.push(item);
+      windowCount += item.windows.length;
+      i += 1;
+    } while (i < prepared.length && windowCount + prepared[i].windows.length <= MAX_WINDOWS_PER_EMBED_CALL);
+    const texts = [];
+    for (const item of slice)
+      texts.push(...item.windows.map((w) => w.text));
+    try {
+      const result = await embedBatchForProject(projectIdentity, texts, signal);
+      if (!result)
+        continue;
+      if (signal?.aborted)
+        break;
+      let offset = 0;
+      for (const item of slice) {
+        const vectors = result.vectors.slice(offset, offset + item.windows.length);
+        offset += item.windows.length;
+        if (vectors.length !== item.windows.length || vectors.some((v) => !v)) {
+          continue;
+        }
+        const rows = item.windows.map((window, index) => ({
+          compartmentId: item.candidate.id,
+          sessionId: item.candidate.sessionId,
+          projectPath: projectIdentity,
+          window,
+          modelId,
+          vector: vectors[index]
+        }));
+        replaceCompartmentChunkEmbeddings(db, rows);
+        embedded += 1;
+      }
+    } catch (error51) {
+      log("[magic-context] failed to proactively embed compartment chunks:", error51);
+    }
+  }
+  return { embedded, noWork };
+}
+async function embedSessionCompartmentChunks(db, projectIdentity, sessionId, options) {
+  const snapshot = getProjectEmbeddingSnapshot(projectIdentity);
+  if (!snapshot?.enabled || snapshot.chunkModelId === "off") {
+    return { status: "disabled", embedded: 0, total: 0 };
+  }
+  recordSessionProjectIdentity(db, sessionId, projectIdentity);
+  const total = countUnembeddedSessionCompartments(db, projectIdentity, sessionId, snapshot.chunkModelId);
+  if (total === 0)
+    return { status: "nothing", embedded: 0, total: 0 };
+  const holderId = `session-embed-${randomUUID()}`;
+  const lease = acquireGitSweepLease(db, projectIdentity, holderId, { ignoreCooldown: true });
+  if (!lease.acquired)
+    return { status: "busy", embedded: 0, total };
+  const renewal = setInterval(() => {
+    try {
+      renewGitSweepLease(db, projectIdentity, holderId);
+    } catch {}
+  }, SESSION_EMBED_LEASE_RENEWAL_MS);
+  renewal.unref?.();
+  const batchSize = Math.max(1, options?.batchSize ?? CHUNK_DRAIN_BATCH_SIZE);
+  const skipIds = [];
+  let embedded = 0;
+  let aborted2 = false;
+  let providerStalled = false;
+  try {
+    options?.onProgress?.({ embedded, total });
+    for (;; ) {
+      if (options?.signal?.aborted) {
+        aborted2 = true;
+        break;
+      }
+      const candidates = loadUnembeddedSessionChunkCandidates(db, projectIdentity, sessionId, snapshot.chunkModelId, batchSize, skipIds);
+      if (candidates.length === 0)
+        break;
+      const { embedded: n, noWork } = await embedCandidateChunkBatch(db, projectIdentity, snapshot.chunkModelId, candidates, options?.signal);
+      for (const id of noWork)
+        skipIds.push(id);
+      if (n === 0 && noWork.length === 0) {
+        providerStalled = true;
+        break;
+      }
+      embedded += n;
+      options?.onProgress?.({ embedded: Math.min(embedded, total), total });
+      await new Promise((resolve3) => setTimeout(resolve3, 0));
+    }
+  } finally {
+    clearInterval(renewal);
+    releaseGitSweepLease(db, projectIdentity, holderId);
+  }
+  if (aborted2)
+    return { status: "aborted", embedded, total };
+  if (providerStalled) {
+    const remaining = Math.max(0, countUnembeddedSessionCompartments(db, projectIdentity, sessionId, snapshot.chunkModelId) - skipIds.length);
+    if (remaining > 0)
+      return { status: "stalled", embedded, total, remaining };
+  }
+  return { status: "done", embedded, total };
+}
 
 // ../plugin/src/features/magic-context/memory/embedding.ts
 var DEFAULT_EMBEDDING_CONFIG = {
@@ -159301,10 +160695,11 @@ function createProvider2(config2) {
       model: config2.model,
       apiKey: config2.api_key,
       inputType: config2.input_type,
-      truncate: config2.truncate
+      truncate: config2.truncate,
+      maxInputTokens: config2.max_input_tokens
     });
   }
-  return new LocalEmbeddingProvider(config2.model);
+  return new LocalEmbeddingProvider(config2.model, config2.max_input_tokens);
 }
 function getOrCreateProvider() {
   if (provider) {
@@ -159328,186 +160723,8 @@ async function embedText(text, signal) {
 }
 var SWEEP_MAX_WALL_CLOCK_MS2 = 10 * 60 * 1000;
 
-// ../plugin/src/features/magic-context/memory/project-identity.ts
-import { execFileSync } from "node:child_process";
-import { createHash as createHash4 } from "node:crypto";
-import { statSync } from "node:fs";
-import path3 from "node:path";
-var GIT_TIMEOUT_MS = 5000;
-var identityCache = new Map;
-var directoryFallbackCache = new Map;
-
-class ProjectIdentityError extends Error {
-  errorClass;
-  rawDirectory;
-  constructor(errorClass, rawDirectory, message, cause) {
-    super(message);
-    this.name = "ProjectIdentityError";
-    this.errorClass = errorClass;
-    this.rawDirectory = rawDirectory;
-    if (cause) {
-      this.cause = cause;
-    }
-  }
-}
-function asError(error51) {
-  return error51 instanceof Error ? error51 : undefined;
-}
-function getErrorCode(error51) {
-  if (error51 === null || typeof error51 !== "object" || !("code" in error51)) {
-    return;
-  }
-  const code = error51.code;
-  return typeof code === "string" ? code : undefined;
-}
-function getErrorSignal(error51) {
-  if (error51 === null || typeof error51 !== "object" || !("signal" in error51)) {
-    return;
-  }
-  const signal = error51.signal;
-  return typeof signal === "string" ? signal : undefined;
-}
-function getErrorKilled(error51) {
-  if (error51 === null || typeof error51 !== "object" || !("killed" in error51)) {
-    return false;
-  }
-  return error51.killed === true;
-}
-function getErrorStderr(error51) {
-  if (error51 === null || typeof error51 !== "object" || !("stderr" in error51)) {
-    return "";
-  }
-  const stderr = error51.stderr;
-  if (typeof stderr === "string") {
-    return stderr;
-  }
-  if (Buffer.isBuffer(stderr)) {
-    return stderr.toString("utf8");
-  }
-  return "";
-}
-function directoryFallback(directory) {
-  const canonical = path3.resolve(directory);
-  const hash2 = createHash4("md5").update(canonical, "utf8").digest("hex").slice(0, 12);
-  return `dir:${hash2}`;
-}
-function assertDirectoryUsable(canonicalDirectory, rawDirectory) {
-  try {
-    const stat2 = statSync(canonicalDirectory);
-    if (!stat2.isDirectory()) {
-      throw new ProjectIdentityError("unknown", rawDirectory, `Project path is not a directory: ${canonicalDirectory}`);
-    }
-  } catch (error51) {
-    if (error51 instanceof ProjectIdentityError) {
-      throw error51;
-    }
-    const code = getErrorCode(error51);
-    if (code === "EACCES" || code === "EPERM") {
-      throw new ProjectIdentityError("permission_denied", rawDirectory, `Permission denied while accessing project directory: ${canonicalDirectory}`, asError(error51));
-    }
-    throw new ProjectIdentityError("unknown", rawDirectory, `Unable to access project directory: ${canonicalDirectory}`, asError(error51));
-  }
-}
-function isGitTimeoutError(error51) {
-  const code = getErrorCode(error51);
-  const signal = getErrorSignal(error51);
-  return code === "ETIMEDOUT" || signal === "SIGTERM" || signal === "SIGKILL" || getErrorKilled(error51);
-}
-function classifyGitError(error51, rawDirectory) {
-  if (isGitTimeoutError(error51)) {
-    return new ProjectIdentityError("git_timeout", rawDirectory, `git rev-list timed out after ${GIT_TIMEOUT_MS}ms`, asError(error51));
-  }
-  const code = getErrorCode(error51);
-  if (code === "ENOENT") {
-    return new ProjectIdentityError("git_missing", rawDirectory, "git binary is not available in PATH", asError(error51));
-  }
-  if (code === "EACCES" || code === "EPERM") {
-    return new ProjectIdentityError("permission_denied", rawDirectory, "Permission denied while spawning git", asError(error51));
-  }
-  const stderr = getErrorStderr(error51).toLowerCase();
-  if (stderr.includes("not a git repository") || stderr.includes("does not have any commits yet") || stderr.includes("ambiguous argument 'head'") || stderr.includes("unknown revision or path")) {
-    return new ProjectIdentityError("not_git_repo", rawDirectory, "Directory has no git root commit; caller may use directory fallback", asError(error51));
-  }
-  return new ProjectIdentityError("unknown", rawDirectory, "git rev-list failed while resolving project identity", asError(error51));
-}
-function resolveProjectIdentityStrict(directory) {
-  const canonical = path3.resolve(directory);
-  const cached2 = identityCache.get(canonical);
-  if (cached2 !== undefined) {
-    return cached2;
-  }
-  assertDirectoryUsable(canonical, directory);
-  let output;
-  try {
-    output = execFileSync("git", ["rev-list", "--max-parents=0", "HEAD"], {
-      cwd: canonical,
-      encoding: "utf8",
-      env: { ...process.env, LC_ALL: "C", LANG: "C" },
-      stdio: ["ignore", "pipe", "pipe"],
-      timeout: GIT_TIMEOUT_MS
-    });
-  } catch (error51) {
-    throw classifyGitError(error51, directory);
-  }
-  const firstLine = output.split(`
-`)[0]?.trim() ?? "";
-  const rootCommit = firstLine.slice(0, 64);
-  if (rootCommit.length < 7) {
-    throw new ProjectIdentityError("unknown", directory, "git rev-list returned no valid root commit hash");
-  }
-  const identity = `git:${rootCommit}`;
-  identityCache.set(canonical, identity);
-  return identity;
-}
-function shouldUseDirectoryFallback(error51) {
-  return error51.errorClass === "not_git_repo" || error51.errorClass === "unknown" && error51.message.startsWith("Unable to access project directory:");
-}
-function resolveProjectIdentity(directory) {
-  const canonical = path3.resolve(directory);
-  const cachedFallback = directoryFallbackCache.get(canonical);
-  if (cachedFallback !== undefined) {
-    if (!hasGitDir(canonical)) {
-      return cachedFallback;
-    }
-    directoryFallbackCache.delete(canonical);
-  }
-  try {
-    return resolveProjectIdentityStrict(directory);
-  } catch (error51) {
-    if (error51 instanceof ProjectIdentityError && shouldUseDirectoryFallback(error51)) {
-      const fallback = directoryFallback(canonical);
-      if (!hasGitDir(canonical)) {
-        directoryFallbackCache.set(canonical, fallback);
-      }
-      return fallback;
-    }
-    throw error51;
-  }
-}
-function hasGitDir(canonical) {
-  try {
-    statSync(path3.join(canonical, ".git"));
-    return true;
-  } catch {
-    return false;
-  }
-}
-function normalizeStoredProjectPath(rawOrStored) {
-  if (rawOrStored.startsWith("git:") || rawOrStored.startsWith("dir:")) {
-    return rawOrStored;
-  }
-  try {
-    return resolveProjectIdentity(rawOrStored);
-  } catch {
-    return directoryFallback(rawOrStored);
-  }
-}
-function storedPathBelongsToIdentity(storedProjectPath, projectIdentity) {
-  return storedProjectPath === projectIdentity || normalizeStoredProjectPath(storedProjectPath) === projectIdentity;
-}
-
 // ../plugin/src/plugin/embedding-bootstrap-helpers.ts
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 init_logger();
 var EMBEDDING_AFFECTING_KEYS = new Set([
   "embedding.api_key",
@@ -159529,7 +160746,7 @@ var EMBEDDING_WARNING_TERMS = [
 ];
 var loggedFailureSignatures = new Map;
 function sha256Prefix2(value, length = 16) {
-  return createHash5("sha256").update(value).digest("hex").slice(0, length);
+  return createHash7("sha256").update(value).digest("hex").slice(0, length);
 }
 function warningLooksEmbeddingRelated(message) {
   const lower = message.toLowerCase();
@@ -159690,6 +160907,7 @@ var SESSION_META_SELECT_COLUMNS = [
   "cached_m0_bytes",
   "cached_m1_bytes",
   "cached_m0_project_memory_epoch",
+  "cached_m0_workspace_fingerprint",
   "cached_m0_project_user_profile_version",
   "cached_m0_max_compartment_seq",
   "cached_m0_max_memory_id",
@@ -159737,6 +160955,7 @@ var META_COLUMNS = {
   cachedM0Bytes: "cached_m0_bytes",
   cachedM1Bytes: "cached_m1_bytes",
   cachedM0ProjectMemoryEpoch: "cached_m0_project_memory_epoch",
+  cachedM0WorkspaceFingerprint: "cached_m0_workspace_fingerprint",
   cachedM0ProjectUserProfileVersion: "cached_m0_project_user_profile_version",
   cachedM0MaxCompartmentSeq: "cached_m0_max_compartment_seq",
   cachedM0MaxMemoryId: "cached_m0_max_memory_id",
@@ -159766,6 +160985,7 @@ var NULL_BIND_META_KEYS = new Set([
   "cachedM0Bytes",
   "cachedM1Bytes",
   "cachedM0ProjectMemoryEpoch",
+  "cachedM0WorkspaceFingerprint",
   "cachedM0ProjectUserProfileVersion",
   "cachedM0MaxCompartmentSeq",
   "cachedM0MaxMemoryId",
@@ -159799,7 +161019,7 @@ 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" && isStringOrNull(r.cache_ttl) && typeof r.counter === "number" && typeof r.last_nudge_tokens === "number" && isStringOrNull(r.last_nudge_band) && isStringOrNull(r.last_transform_error) && typeof r.is_subagent === "number" && typeof r.last_context_percentage === "number" && typeof r.last_input_tokens === "number" && isNumberOrNull(r.observed_safe_input_tokens) && isNumberOrNull(r.cache_alert_sent) && isNumberOrNull(r.times_execute_threshold_reached) && isNumberOrNull(r.compartment_in_progress) && (r.system_prompt_hash === null || typeof r.system_prompt_hash === "string" || typeof r.system_prompt_hash === "number") && isNumberOrNull(r.system_prompt_tokens) && isNumberOrNull(r.conversation_tokens) && isNumberOrNull(r.tool_call_tokens) && isNumberOrNull(r.cleared_reasoning_through_tag) && isStringOrNull(r.last_todo_state) && isBlobOrNull(r.cached_m0_bytes) && isBlobOrNull(r.cached_m1_bytes) && isNumberOrNull(r.cached_m0_project_memory_epoch) && isNumberOrNull(r.cached_m0_project_user_profile_version) && isNumberOrNull(r.cached_m0_max_compartment_seq) && isNumberOrNull(r.cached_m0_max_memory_id) && isNumberOrNull(r.cached_m0_max_mutation_id) && isNumberOrNull(r.cached_m0_max_memory_mutation_id) && isStringOrNull(r.cached_m0_project_docs_hash) && isNumberOrNull(r.cached_m0_materialized_at) && isNumberOrNull(r.cached_m0_session_facts_version) && isStringOrNull(r.cached_m0_upgrade_state) && isStringOrNull(r.cached_m0_system_hash) && isStringOrNull(r.cached_m0_tool_set_hash) && isStringOrNull(r.cached_m0_model_key) && isStringOrNull(r.last_observed_model_key) && isNumberOrNull(r.last_usage_context_limit) && isNumberOrNull(r.prior_boundary_ordinal) && isNumberOrNull(r.protected_tail_policy_version) && isNumberOrNull(r.protected_tail_drain_window_started_at) && isNumberOrNull(r.protected_tail_drain_tokens) && isNumberOrNull(r.recovery_no_eligible_head_count) && isNumberOrNull(r.force_emergency_bypass_window_start) && isNumberOrNull(r.force_emergency_bypass_used) && isNumberOrNull(r.upgrade_reminded_at) && isNumberOrNull(r.pi_stable_id_scheme);
+  return typeof r.session_id === "string" && typeof r.last_response_time === "number" && isStringOrNull(r.cache_ttl) && typeof r.counter === "number" && typeof r.last_nudge_tokens === "number" && isStringOrNull(r.last_nudge_band) && isStringOrNull(r.last_transform_error) && typeof r.is_subagent === "number" && typeof r.last_context_percentage === "number" && typeof r.last_input_tokens === "number" && isNumberOrNull(r.observed_safe_input_tokens) && isNumberOrNull(r.cache_alert_sent) && isNumberOrNull(r.times_execute_threshold_reached) && isNumberOrNull(r.compartment_in_progress) && (r.system_prompt_hash === null || typeof r.system_prompt_hash === "string" || typeof r.system_prompt_hash === "number") && isNumberOrNull(r.system_prompt_tokens) && isNumberOrNull(r.conversation_tokens) && isNumberOrNull(r.tool_call_tokens) && isNumberOrNull(r.cleared_reasoning_through_tag) && isStringOrNull(r.last_todo_state) && isBlobOrNull(r.cached_m0_bytes) && isBlobOrNull(r.cached_m1_bytes) && isNumberOrNull(r.cached_m0_project_memory_epoch) && isStringOrNull(r.cached_m0_workspace_fingerprint) && isNumberOrNull(r.cached_m0_project_user_profile_version) && isNumberOrNull(r.cached_m0_max_compartment_seq) && isNumberOrNull(r.cached_m0_max_memory_id) && isNumberOrNull(r.cached_m0_max_mutation_id) && isNumberOrNull(r.cached_m0_max_memory_mutation_id) && isStringOrNull(r.cached_m0_project_docs_hash) && isNumberOrNull(r.cached_m0_materialized_at) && isNumberOrNull(r.cached_m0_session_facts_version) && isStringOrNull(r.cached_m0_upgrade_state) && isStringOrNull(r.cached_m0_system_hash) && isStringOrNull(r.cached_m0_tool_set_hash) && isStringOrNull(r.cached_m0_model_key) && isStringOrNull(r.last_observed_model_key) && isNumberOrNull(r.last_usage_context_limit) && isNumberOrNull(r.prior_boundary_ordinal) && isNumberOrNull(r.protected_tail_policy_version) && isNumberOrNull(r.protected_tail_drain_window_started_at) && isNumberOrNull(r.protected_tail_drain_tokens) && isNumberOrNull(r.recovery_no_eligible_head_count) && isNumberOrNull(r.force_emergency_bypass_window_start) && isNumberOrNull(r.force_emergency_bypass_used) && isNumberOrNull(r.upgrade_reminded_at) && isNumberOrNull(r.pi_stable_id_scheme);
 }
 function getDefaultSessionMeta(sessionId) {
   return {
@@ -159826,6 +161046,7 @@ function getDefaultSessionMeta(sessionId) {
     cachedM0Bytes: null,
     cachedM1Bytes: null,
     cachedM0ProjectMemoryEpoch: null,
+    cachedM0WorkspaceFingerprint: null,
     cachedM0ProjectUserProfileVersion: null,
     cachedM0MaxCompartmentSeq: null,
     cachedM0MaxMemoryId: null,
@@ -159888,6 +161109,7 @@ function toSessionMeta(row) {
     cachedM0Bytes: toBufferOrNull(row.cached_m0_bytes),
     cachedM1Bytes: toBufferOrNull(row.cached_m1_bytes),
     cachedM0ProjectMemoryEpoch: numOrNull(row.cached_m0_project_memory_epoch),
+    cachedM0WorkspaceFingerprint: stringOrNull(row.cached_m0_workspace_fingerprint),
     cachedM0ProjectUserProfileVersion: numOrNull(row.cached_m0_project_user_profile_version),
     cachedM0MaxCompartmentSeq: numOrNull(row.cached_m0_max_compartment_seq),
     cachedM0MaxMemoryId: numOrNull(row.cached_m0_max_memory_id),
@@ -159918,6 +161140,7 @@ function persistCachedM0(db, sessionId, payload) {
   db.prepare(`UPDATE session_meta SET
             cached_m0_bytes = ?,
             cached_m0_project_memory_epoch = ?,
+            cached_m0_workspace_fingerprint = ?,
             cached_m0_project_user_profile_version = ?,
             cached_m0_max_compartment_seq = ?,
             cached_m0_max_memory_id = ?,
@@ -159930,7 +161153,7 @@ function persistCachedM0(db, sessionId, payload) {
             cached_m0_upgrade_state = ?,
             cached_m0_system_hash = ?,
             cached_m0_model_key = ?
-         WHERE session_id = ?`).run(Buffer2.from(payload.m0Bytes), payload.projectMemoryEpoch, payload.projectUserProfileVersion, payload.maxCompartmentSeq, payload.maxMemoryId, payload.maxMutationId, payload.maxMemoryMutationId ?? null, payload.m1Bytes ? Buffer2.from(payload.m1Bytes) : null, payload.projectDocsHash, payload.materializedAt, payload.sessionFactsVersion, payload.upgradeState, payload.systemHash ?? "", payload.modelKey ?? "", sessionId);
+         WHERE session_id = ?`).run(Buffer2.from(payload.m0Bytes), payload.projectMemoryEpoch, payload.workspaceFingerprint ?? null, payload.projectUserProfileVersion, payload.maxCompartmentSeq, payload.maxMemoryId, payload.maxMutationId, payload.maxMemoryMutationId ?? null, payload.m1Bytes ? Buffer2.from(payload.m1Bytes) : null, payload.projectDocsHash, payload.materializedAt, payload.sessionFactsVersion, payload.upgradeState, payload.systemHash ?? "", payload.modelKey ?? "", sessionId);
 }
 function clearCachedM0M1(db, sessionId) {
   ensureSessionMetaRow(db, sessionId);
@@ -159939,6 +161162,7 @@ function clearCachedM0M1(db, sessionId) {
     ["cached_m0_bytes", null],
     ["cached_m1_bytes", null],
     ["cached_m0_project_memory_epoch", null],
+    ["cached_m0_workspace_fingerprint", null],
     ["cached_m0_project_user_profile_version", null],
     ["cached_m0_max_compartment_seq", null],
     ["cached_m0_max_memory_id", null],
@@ -160274,8 +161498,8 @@ function readRawSessionTailFromDb(db, sessionId, baseOrdinal, anchorMessageId) {
     const CHUNK = 800;
     for (let i = 0;i < ids.length; i += CHUNK) {
       const slice = ids.slice(i, i + CHUNK);
-      const placeholders = slice.map(() => "?").join(",");
-      const partRows = db.prepare(`SELECT message_id, data, time_updated FROM part WHERE session_id = ? AND message_id IN (${placeholders}) ORDER BY time_created ASC, id ASC`).all(sessionId, ...slice).filter(isRawPartRow);
+      const placeholders2 = slice.map(() => "?").join(",");
+      const partRows = db.prepare(`SELECT message_id, data, time_updated FROM part WHERE session_id = ? AND message_id IN (${placeholders2}) ORDER BY time_created ASC, id ASC`).all(sessionId, ...slice).filter(isRawPartRow);
       for (const part of partRows) {
         const list = partsByMessageId.get(part.message_id) ?? [];
         list.push(attachRawPartVersion(parseJsonUnknown(part.data), part.time_updated));
@@ -165172,53 +166396,6 @@ function createCtxExpandTool(deps) {
     }
   };
 }
-
-// ../plugin/src/features/magic-context/memory/constants.ts
-var V2_MEMORY_CATEGORIES = [
-  "PROJECT_RULES",
-  "ARCHITECTURE",
-  "CONSTRAINTS",
-  "CONFIG_VALUES",
-  "NAMING"
-];
-var PROMOTABLE_CATEGORIES = [
-  "PROJECT_RULES",
-  "ARCHITECTURE",
-  "CONSTRAINTS",
-  "CONFIG_VALUES",
-  "NAMING",
-  "ARCHITECTURE_DECISIONS",
-  "CONFIG_DEFAULTS",
-  "USER_PREFERENCES",
-  "USER_DIRECTIVES",
-  "ENVIRONMENT",
-  "WORKFLOW_RULES",
-  "KNOWN_ISSUES"
-];
-var CATEGORY_PRIORITY = [
-  "PROJECT_RULES",
-  "ARCHITECTURE",
-  "CONSTRAINTS",
-  "CONFIG_VALUES",
-  "NAMING",
-  "USER_DIRECTIVES",
-  "USER_PREFERENCES",
-  "CONFIG_DEFAULTS",
-  "ARCHITECTURE_DECISIONS",
-  "ENVIRONMENT",
-  "WORKFLOW_RULES",
-  "KNOWN_ISSUES"
-];
-var MEMORY_CATEGORY_ORDER_UNKNOWN = 99;
-var MEMORY_CATEGORY_ORDER_PRIORITY = CATEGORY_PRIORITY.reduce((acc, category, index) => {
-  acc[category] = index;
-  return acc;
-}, {});
-var MEMORY_CATEGORY_ORDER_SQL = `CASE category ${CATEGORY_PRIORITY.map((category, index) => `WHEN '${category}' THEN ${index}`).join(" ")} ELSE ${MEMORY_CATEGORY_ORDER_UNKNOWN} END`;
-var CATEGORY_DEFAULT_TTL = {
-  WORKFLOW_RULES: 90 * 24 * 60 * 60 * 1000,
-  KNOWN_ISSUES: 30 * 24 * 60 * 60 * 1000
-};
 // ../plugin/src/features/magic-context/memory/embedding-backfill.ts
 init_logger();
 async function ensureMemoryEmbeddings(args) {
@@ -165243,7 +166420,7 @@ async function ensureMemoryEmbeddings(args) {
           continue;
         }
         saveEmbedding(args.db, memory2.id, embedding, result.modelId);
-        staged.set(memory2.id, embedding);
+        staged.set(memory2.id, { embedding, modelId: result.modelId });
       }
     })();
     const currentSnapshot = getProjectEmbeddingSnapshot(args.projectIdentity);
@@ -165446,8 +166623,8 @@ function getMemoriesByProjectStatement(db, statuses) {
   }
   let stmt = statements.get(db);
   if (!stmt) {
-    const placeholders = statuses.map(() => "?").join(", ");
-    stmt = db.prepare(`SELECT ${getMemorySelectColumns(db)} FROM memories WHERE project_path = ? AND status IN (${placeholders}) AND (expires_at IS NULL OR expires_at > ?) ORDER BY category ASC, updated_at DESC, id ASC`);
+    const placeholders2 = statuses.map(() => "?").join(", ");
+    stmt = db.prepare(`SELECT ${getMemorySelectColumns(db)} FROM memories WHERE project_path = ? AND status IN (${placeholders2}) AND (expires_at IS NULL OR expires_at > ?) ORDER BY category ASC, updated_at DESC, id ASC`);
     statements.set(db, stmt);
   }
   return stmt;
@@ -165592,6 +166769,97 @@ function getMemoriesByProject(db, projectPath, statuses = ["active", "permanent"
   const rows = getMemoriesByProjectStatement(db, statuses).all(projectPath, ...statuses, expiryCutoff).filter(isMemoryRow);
   return rows.map(toMemory);
 }
+function sqlPlaceholders(values) {
+  return values.map(() => "?").join(", ");
+}
+function uniqueValues(values) {
+  return [...new Set(values.filter((value) => value.length > 0))];
+}
+function buildWorkspaceMemorySqlFilter(args) {
+  if (args.shareCategories === null || args.shareCategories === undefined) {
+    return { clause: "", params: [], active: false };
+  }
+  const identities = uniqueValues(args.identities);
+  const identitySet = new Set(identities);
+  const ownSet = new Set(uniqueValues(args.ownIdentities ?? []).filter((identity) => identitySet.has(identity)));
+  const foreignIdentities = identities.filter((identity) => !ownSet.has(identity));
+  if (foreignIdentities.length === 0) {
+    return { clause: "", params: [], active: false };
+  }
+  const ownIdentities = identities.filter((identity) => ownSet.has(identity));
+  const shareCategories = uniqueValues([...args.shareCategories]);
+  const qualifier = args.tableName ? `${args.tableName}.` : "";
+  const predicates = [];
+  const params = [];
+  if (ownIdentities.length > 0) {
+    predicates.push(`${qualifier}project_path IN (${sqlPlaceholders(ownIdentities)})`);
+    params.push(...ownIdentities);
+  }
+  if (foreignIdentities.length > 0 && shareCategories.length > 0) {
+    predicates.push(`(${qualifier}project_path IN (${sqlPlaceholders(foreignIdentities)}) AND ${qualifier}category IN (${sqlPlaceholders(shareCategories)}))`);
+    params.push(...foreignIdentities, ...shareCategories);
+  }
+  if (predicates.length === 0) {
+    return { clause: " AND 0 = 1", params: [], active: true };
+  }
+  return { clause: ` AND (${predicates.join(" OR ")})`, params, active: true };
+}
+function getMemoriesByProjects(db, projectPaths, statuses = ["active", "permanent"], expiryCutoff = Date.now(), ownIdentities, shareCategories) {
+  const identities = uniqueValues(projectPaths);
+  if (identities.length === 0 || statuses.length === 0)
+    return [];
+  const sharingFilter = buildWorkspaceMemorySqlFilter({
+    identities,
+    ownIdentities,
+    shareCategories
+  });
+  if (identities.length === 1 && !sharingFilter.active) {
+    return getMemoriesByProject(db, identities[0], statuses, expiryCutoff);
+  }
+  const rows = db.prepare(`SELECT ${getMemorySelectColumns(db)}
+               FROM memories
+              WHERE project_path IN (${sqlPlaceholders(identities)})
+                AND status IN (${sqlPlaceholders(statuses)})
+                AND (expires_at IS NULL OR expires_at > ?)${sharingFilter.clause}
+              ORDER BY category ASC, updated_at DESC, id ASC`).all(...identities, ...statuses, expiryCutoff, ...sharingFilter.params).filter(isMemoryRow);
+  return rows.map(toMemory);
+}
+function getMaxMemoryIdForProjects(db, projectPaths, ownIdentities, shareCategories) {
+  const identities = uniqueValues(projectPaths);
+  if (identities.length === 0)
+    return 0;
+  const sharingFilter = buildWorkspaceMemorySqlFilter({
+    identities,
+    ownIdentities,
+    shareCategories
+  });
+  if (identities.length === 1 && !sharingFilter.active) {
+    const row2 = db.prepare("SELECT COALESCE(MAX(id), 0) AS max_id FROM memories WHERE project_path = ?").get(identities[0]);
+    return typeof row2?.max_id === "number" ? row2.max_id : 0;
+  }
+  const row = db.prepare(`SELECT COALESCE(MAX(id), 0) AS max_id
+               FROM memories
+              WHERE project_path IN (${sqlPlaceholders(identities)})${sharingFilter.clause}`).get(...identities, ...sharingFilter.params);
+  return typeof row?.max_id === "number" ? row.max_id : 0;
+}
+function readNewMemoriesForM1Union(db, projectPaths, afterId, expiryCutoff, ownIdentities, shareCategories) {
+  const identities = uniqueValues(projectPaths);
+  if (identities.length === 0)
+    return [];
+  const sharingFilter = buildWorkspaceMemorySqlFilter({
+    identities,
+    ownIdentities,
+    shareCategories
+  });
+  const rows = db.prepare(`SELECT ${getMemorySelectColumns(db)}
+               FROM memories
+              WHERE project_path IN (${sqlPlaceholders(identities)})
+                AND id > ?
+                AND status IN ('active', 'permanent')
+                AND (expires_at IS NULL OR expires_at > ?)${sharingFilter.clause}
+              ORDER BY ${MEMORY_CATEGORY_ORDER_SQL}, id ASC`).all(...identities, afterId, expiryCutoff, ...sharingFilter.params).filter(isMemoryRow);
+  return rows.map(toMemory);
+}
 function getAllActiveMemoriesForMigration(db, projectPath) {
   const rows = getActiveMemoriesNoExpiryStatement(db).all(projectPath).filter(isMemoryRow);
   return rows.map(toMemory);
@@ -165759,6 +167027,7 @@ async function embedAndStoreMemory(db, sessionId, projectPath, memoryId, content
 // ../plugin/src/features/magic-context/memory/storage-memory-fts.ts
 var DEFAULT_SEARCH_LIMIT = 10;
 var searchStatements = new WeakMap;
+var unionSearchStatements = new Map;
 function getSearchStatement(db) {
   let stmt = searchStatements.get(db);
   if (!stmt) {
@@ -165767,6 +167036,23 @@ function getSearchStatement(db) {
   }
   return stmt;
 }
+function getUnionSearchStatement(db, arity) {
+  let statements = unionSearchStatements.get(arity);
+  if (!statements) {
+    statements = new WeakMap;
+    unionSearchStatements.set(arity, statements);
+  }
+  let stmt = statements.get(db);
+  if (!stmt) {
+    const placeholders2 = Array.from({ length: arity }, () => "?").join(", ");
+    stmt = db.prepare(`SELECT ${getMemorySelectColumns(db)} FROM memories_fts INNER JOIN memories ON memories.id = memories_fts.rowid WHERE memories.project_path IN (${placeholders2}) AND memories.status IN ('active', 'permanent') AND (memories.expires_at IS NULL OR memories.expires_at > ?) AND memories_fts MATCH ? ORDER BY bm25(memories_fts), memories.updated_at DESC, memories.id ASC LIMIT ?`);
+    statements.set(db, stmt);
+  }
+  return stmt;
+}
+function uniqueProjectPaths(projectPaths) {
+  return [...new Set(projectPaths.filter((path4) => path4.length > 0))];
+}
 function sanitizeFtsQuery(query) {
   const tokens = query.split(/\s+/).filter((token) => token.length > 0);
   if (tokens.length === 0)
@@ -165785,6 +167071,28 @@ function searchMemoriesFTS(db, projectPath, query, limit = DEFAULT_SEARCH_LIMIT)
   const rows = getSearchStatement(db).all(projectPath, Date.now(), sanitized, limit).filter(isMemoryRow);
   return rows.map(toMemory);
 }
+function searchMemoriesFTSUnion(db, projectPaths, query, limit = DEFAULT_SEARCH_LIMIT, ownIdentities, shareCategories) {
+  const identities = uniqueProjectPaths(projectPaths);
+  if (identities.length === 0)
+    return [];
+  const sharingFilter = buildWorkspaceMemorySqlFilter({
+    identities,
+    ownIdentities,
+    shareCategories,
+    tableName: "memories"
+  });
+  if (identities.length === 1 && !sharingFilter.active) {
+    return searchMemoriesFTS(db, identities[0], query, limit);
+  }
+  const trimmedQuery = query.trim();
+  if (trimmedQuery.length === 0 || limit <= 0)
+    return [];
+  const sanitized = sanitizeFtsQuery(trimmedQuery);
+  if (sanitized.length === 0)
+    return [];
+  const rows = sharingFilter.active ? db.prepare(`SELECT ${getMemorySelectColumns(db)} FROM memories_fts INNER JOIN memories ON memories.id = memories_fts.rowid WHERE memories.project_path IN (${identities.map(() => "?").join(", ")}) AND memories.status IN ('active', 'permanent') AND (memories.expires_at IS NULL OR memories.expires_at > ?) AND memories_fts MATCH ?${sharingFilter.clause} ORDER BY bm25(memories_fts), memories.updated_at DESC, memories.id ASC LIMIT ?`).all(...identities, Date.now(), sanitized, ...sharingFilter.params, limit).filter(isMemoryRow) : getUnionSearchStatement(db, identities.length).all(...identities, Date.now(), sanitized, limit).filter(isMemoryRow);
+  return rows.map(toMemory);
+}
 // ../plugin/src/features/magic-context/message-index.ts
 var lastIndexedStatements = new WeakMap;
 var insertMessageStatements = new WeakMap;
@@ -165931,7 +167239,7 @@ function indexMessagesAfterOrdinal(db, sessionId, messages, lastIndexedOrdinal,
   return inserted;
 }
 // ../plugin/src/features/magic-context/project-docs-hash.ts
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 import { lstatSync, readFileSync as readFileSync4, statSync as statSync2 } from "node:fs";
 import path4 from "node:path";
 var PROJECT_DOC_FILES = ["ARCHITECTURE.md", "STRUCTURE.md"];
@@ -166029,7 +167337,7 @@ function hashCanonicalPieces(hashPieces) {
   if (hashPieces.length === 0) {
     return "";
   }
-  return createHash6("sha256").update(hashPieces.join(PROJECT_DOCS_DELIMITER), "utf8").digest("hex");
+  return createHash8("sha256").update(hashPieces.join(PROJECT_DOCS_DELIMITER), "utf8").digest("hex");
 }
 function readProjectDocsCanonical(projectDirectory) {
   const canonicalDirectory = path4.resolve(projectDirectory);
@@ -166135,18 +167443,13 @@ function getMemoryMutation(db, id) {
               WHERE id = ?`).get(id);
   return row ? toMemoryMutation(row) : null;
 }
-function getMemoryMutationsForRender(db, projectPath, afterId, renderedMemoryIds) {
-  if (renderedMemoryIds.length === 0)
-    return [];
-  const uniqueIds = [...new Set(renderedMemoryIds)].sort((left, right) => left - right);
-  const placeholders = uniqueIds.map(() => "?").join(", ");
-  const rows = db.prepare(`SELECT id, project_path, mutation_type, target_memory_id,
-                    superseded_by_id, category, new_content, queued_at
-               FROM memory_mutation_log
-              WHERE project_path = ?
-                AND id > ?
-                AND target_memory_id IN (${placeholders})
-              ORDER BY id ASC`).all(projectPath, afterId ?? 0, ...uniqueIds);
+function uniqueProjectPaths2(projectPaths) {
+  return [...new Set(projectPaths.filter((path5) => path5.length > 0))];
+}
+function placeholders2(values) {
+  return values.map(() => "?").join(", ");
+}
+function coalesceMutations(rows) {
   const chosenByTarget = new Map;
   for (const dbRow of rows) {
     const candidate = toMemoryMutation(dbRow);
@@ -166167,10 +167470,54 @@ function getMemoryMutationsForRender(db, projectPath, afterId, renderedMemoryIds
   }
   return [...chosenByTarget.values()].sort((left, right) => left.id - right.id);
 }
+function getMemoryMutationsForRender(db, projectPath, afterId, renderedMemoryIds) {
+  if (renderedMemoryIds.length === 0)
+    return [];
+  const uniqueIds = [...new Set(renderedMemoryIds)].sort((left, right) => left - right);
+  const placeholders3 = uniqueIds.map(() => "?").join(", ");
+  const rows = db.prepare(`SELECT id, project_path, mutation_type, target_memory_id,
+                    superseded_by_id, category, new_content, queued_at
+               FROM memory_mutation_log
+              WHERE project_path = ?
+                AND id > ?
+                AND target_memory_id IN (${placeholders3})
+              ORDER BY id ASC`).all(projectPath, afterId ?? 0, ...uniqueIds);
+  return coalesceMutations(rows);
+}
+function getMemoryMutationsForRenderByProjects(db, projectPaths, afterId, renderedMemoryIds) {
+  if (renderedMemoryIds.length === 0)
+    return [];
+  const identities = uniqueProjectPaths2(projectPaths);
+  if (identities.length === 0)
+    return [];
+  if (identities.length === 1) {
+    return getMemoryMutationsForRender(db, identities[0], afterId, renderedMemoryIds);
+  }
+  const uniqueIds = [...new Set(renderedMemoryIds)].sort((left, right) => left - right);
+  const rows = db.prepare(`SELECT id, project_path, mutation_type, target_memory_id,
+                    superseded_by_id, category, new_content, queued_at
+               FROM memory_mutation_log
+              WHERE project_path IN (${placeholders2(identities)})
+                AND id > ?
+                AND target_memory_id IN (${placeholders2(uniqueIds)})
+              ORDER BY id ASC`).all(...identities, afterId ?? 0, ...uniqueIds);
+  return coalesceMutations(rows);
+}
 function getMaxMemoryMutationId(db, projectPath) {
   const row = db.prepare("SELECT MAX(id) AS max_id FROM memory_mutation_log WHERE project_path = ?").get(projectPath);
   return row?.max_id ?? null;
 }
+function getMaxMemoryMutationIdForProjects(db, projectPaths) {
+  const identities = uniqueProjectPaths2(projectPaths);
+  if (identities.length === 0)
+    return null;
+  if (identities.length === 1)
+    return getMaxMemoryMutationId(db, identities[0]);
+  const row = db.prepare(`SELECT MAX(id) AS max_id
+               FROM memory_mutation_log
+              WHERE project_path IN (${placeholders2(identities)})`).get(...identities);
+  return row?.max_id ?? null;
+}
 // ../plugin/src/features/magic-context/storage-meta-persisted.ts
 init_logger();
 var CAS_RETRY_LIMIT = 5;
@@ -167016,9 +168363,9 @@ function buildStatusClause(status) {
   if (statuses.length === 0) {
     return null;
   }
-  const placeholders = statuses.map(() => "?").join(", ");
+  const placeholders3 = statuses.map(() => "?").join(", ");
   return {
-    sql: `status IN (${placeholders})`,
+    sql: `status IN (${placeholders3})`,
     params: statuses
   };
 }
@@ -167214,19 +168561,6 @@ function getProjectState(db, projectPath) {
              WHERE project_path = ?`).get(projectPath);
   return row ? toProjectState(row) : null;
 }
-function bumpProjectMemoryEpoch(db, projectPath, now = Date.now()) {
-  db.prepare(`INSERT INTO project_state
-            (project_path, project_memory_epoch, project_user_profile_version, updated_at)
-         VALUES (?, 1, 0, ?)
-         ON CONFLICT(project_path) DO UPDATE SET
-            project_memory_epoch = project_memory_epoch + 1,
-            updated_at = excluded.updated_at`).run(projectPath, now);
-  const state = getProjectState(db, projectPath);
-  if (!state) {
-    throw new Error(`Failed to bump project memory epoch for ${projectPath}`);
-  }
-  return state;
-}
 function bumpProjectUserProfileVersion(db, projectPath = GLOBAL_USER_PROFILE_PROJECT_PATH, now = Date.now()) {
   db.prepare(`INSERT INTO project_state
             (project_path, project_memory_epoch, project_user_profile_version, updated_at)
@@ -167260,8 +168594,8 @@ function getSourceContents(db, sessionId, tagIds) {
   if (tagIds.length === 0) {
     return new Map;
   }
-  const placeholders = tagIds.map(() => "?").join(", ");
-  const rows = db.prepare(`SELECT tag_id, content FROM source_contents WHERE session_id = ? AND tag_id IN (${placeholders})`).all(sessionId, ...tagIds).filter(isSourceContentRow);
+  const placeholders3 = tagIds.map(() => "?").join(", ");
+  const rows = db.prepare(`SELECT tag_id, content FROM source_contents WHERE session_id = ? AND tag_id IN (${placeholders3})`).all(sessionId, ...tagIds).filter(isSourceContentRow);
   const sources = new Map;
   for (const row of rows) {
     sources.set(row.tag_id, row.content);
@@ -167352,15 +168686,22 @@ function ownerMessageIdForTagRow(row) {
   }
   return row.message_id.replace(CONTENT_ID_SUFFIX, "");
 }
-function getActiveTagTokenAggregate(db, sessionId) {
-  const row = db.prepare(`SELECT
+function getActiveTagTokenAggregate(db, sessionId, protectedTags = 0) {
+  const toolOutputExpr = protectedTags > 0 ? `COALESCE(SUM(CASE WHEN type = 'tool' AND tag_number < (
+                    SELECT tag_number FROM tags
+                    WHERE session_id = ? AND status = 'active'
+                    ORDER BY tag_number DESC LIMIT 1 OFFSET ?
+                ) THEN COALESCE(token_count, 0) ELSE 0 END), 0)` : `COALESCE(SUM(CASE WHEN type = 'tool' THEN COALESCE(token_count, 0) ELSE 0 END), 0)`;
+  const sql = `SELECT
                 COALESCE(SUM(CASE WHEN type != 'tool' THEN COALESCE(token_count, 0) ELSE 0 END), 0)
                     + COALESCE(SUM(COALESCE(reasoning_token_count, 0)), 0) AS conversation,
                 COALESCE(SUM(CASE WHEN type = 'tool' THEN COALESCE(token_count, 0) + COALESCE(input_token_count, 0) ELSE 0 END), 0) AS tool_call,
-                COALESCE(SUM(CASE WHEN type = 'tool' THEN COALESCE(token_count, 0) ELSE 0 END), 0) AS tool_output,
+                ${toolOutputExpr} AS tool_output,
                 COALESCE(SUM(CASE WHEN token_count IS NULL THEN 1 ELSE 0 END), 0) AS null_count
              FROM tags
-             WHERE session_id = ? AND status = 'active'`).get(sessionId);
+             WHERE session_id = ? AND status = 'active'`;
+  const params = protectedTags > 0 ? [sessionId, protectedTags - 1, sessionId] : [sessionId];
+  const row = db.prepare(sql).get(...params);
   return {
     conversation: row?.conversation ?? 0,
     toolCall: row?.tool_call ?? 0,
@@ -167551,8 +168892,8 @@ function getTagsByNumbers(db, sessionId, tagNumbers) {
     }
     return all;
   }
-  const placeholders = tagNumbers.map(() => "?").join(",");
-  const rows = db.prepare(`SELECT ${TAG_SELECT_COLUMNS} FROM tags WHERE session_id = ? AND tag_number IN (${placeholders}) ORDER BY tag_number ASC, id ASC`).all(sessionId, ...tagNumbers).filter(isTagRow);
+  const placeholders3 = tagNumbers.map(() => "?").join(",");
+  const rows = db.prepare(`SELECT ${TAG_SELECT_COLUMNS} FROM tags WHERE session_id = ? AND tag_number IN (${placeholders3}) ORDER BY tag_number ASC, id ASC`).all(sessionId, ...tagNumbers).filter(isTagRow);
   return rows.map(toTagEntry);
 }
 var getToolTagNumberByOwnerStatements = new WeakMap;
@@ -167742,6 +169083,23 @@ function createCtxMemoryTool(deps) {
       }
       const projectIdentity = resolveProjectIdentity(ctx.cwd);
       await deps.ensureProjectRegistered?.(ctx.cwd, deps.db);
+      const workspaceIdentitySet = resolveWorkspaceIdentitySet(deps.db, projectIdentity);
+      const expandedWorkspace = expandWorkspaceIdentitySetWithAliases(deps.db, workspaceIdentitySet.identities);
+      const workspaceVisibleIdentities = workspaceIdentitySet.identities.length > 1 ? expandedWorkspace.expandedIdentities : workspaceIdentitySet.identities;
+      const targetIdentityForStoredPath = (rawProjectPath) => workspaceIdentitySet.identities.length > 1 ? resolveStoredPathWorkspaceIdentity(rawProjectPath, workspaceIdentitySet.identities, expandedWorkspace.canonicalIdentityByStoredPath) ?? normalizeStoredProjectPath(rawProjectPath) : normalizeStoredProjectPath(rawProjectPath);
+      const toolShareCategories = workspaceIdentitySet.identities.length > 1 ? resolveWorkspaceShareCategories(deps.db, projectIdentity) : null;
+      const memoryVisibleToTool = (memory2) => {
+        if (workspaceIdentitySet.identities.length <= 1) {
+          return storedPathBelongsToIdentity(memory2.projectPath, projectIdentity);
+        }
+        if (!storedPathBelongsToWorkspace(memory2.projectPath, workspaceIdentitySet.identities, workspaceVisibleIdentities, expandedWorkspace.canonicalIdentityByStoredPath)) {
+          return false;
+        }
+        const isOwn = targetIdentityForStoredPath(memory2.projectPath) === projectIdentity;
+        if (isOwn)
+          return true;
+        return toolShareCategories === null || toolShareCategories.includes(memory2.category);
+      };
       const snapshot = getProjectEmbeddingSnapshot(projectIdentity);
       if (snapshot ? !snapshot.features.memoryEnabled : deps.memoryEnabled === false) {
         return err2("Cross-session memory is disabled for this project.");
@@ -167788,28 +169146,34 @@ function createCtxMemoryTool(deps) {
           return err2("Error: 'content' is required when action is 'update'.");
         }
         const memory2 = getMemoryById(deps.db, updateId);
-        if (!memory2 || !storedPathBelongsToIdentity(memory2.projectPath, projectIdentity)) {
+        if (!memory2 || !memoryVisibleToTool(memory2)) {
           return err2(`Error: Memory with ID ${updateId} was not found.`);
         }
         if (!dreamerAllowed && !isPrimaryMutableMemory(memory2)) {
           return err2(inactiveMemoryError(updateId, "updating"));
         }
         const normalizedHash = computeNormalizedHash(content);
-        const duplicate = getMemoryByHash(deps.db, projectIdentity, memory2.category, normalizedHash);
+        const targetIdentity = targetIdentityForStoredPath(memory2.projectPath);
+        const duplicate = getMemoryByHash(deps.db, targetIdentity, memory2.category, normalizedHash);
         if (duplicate && duplicate.id !== memory2.id) {
           return err2(`Error: Memory content already exists as ID ${duplicate.id}; merge or archive duplicates instead.`);
         }
         deps.db.transaction(() => {
           updateMemoryContent(deps.db, memory2.id, content, normalizedHash);
           queueMemoryMutation(deps.db, {
-            projectPath: projectIdentity,
+            projectPath: targetIdentity,
             mutationType: "update",
             targetMemoryId: memory2.id,
             category: memory2.category,
             newContent: content
           });
         })();
-        queueEmbedding({ deps, projectIdentity, memoryId: memory2.id, content });
+        queueEmbedding({
+          deps,
+          projectIdentity: targetIdentity,
+          memoryId: memory2.id,
+          content
+        });
         return ok2(`Updated memory [ID: ${memory2.id}] in ${memory2.category}.`);
       }
       if (params.action === "merge") {
@@ -167829,7 +169193,7 @@ function createCtxMemoryTool(deps) {
           return err2("Error: One or more source memories were not found.");
         }
         if (!dreamerAllowed) {
-          const foreign = sourceMemories.find((memory2) => !storedPathBelongsToIdentity(memory2.projectPath, projectIdentity));
+          const foreign = sourceMemories.find((memory2) => !memoryVisibleToTool(memory2));
           if (foreign) {
             return err2(`Error: Memory with ID ${foreign.id} was not found.`);
           }
@@ -167918,26 +169282,36 @@ function createCtxMemoryTool(deps) {
         return ok2(`Merged memories [${ids.join(", ")}] into canonical memory [ID: ${canonicalMemory.id}] in ${category}; superseded [${supersededIds.join(", ")}].`);
       }
       if (params.action === "archive") {
-        const archiveIds = params.ids;
-        if (!archiveIds || archiveIds.length === 0 || !archiveIds.every(Number.isInteger)) {
+        const rawArchiveIds = params.ids;
+        if (!rawArchiveIds || rawArchiveIds.length === 0 || !rawArchiveIds.every(Number.isInteger)) {
           return err2("Error: 'ids' must contain at least one integer memory ID when action is 'archive'.");
         }
+        const archiveIds = [...new Set(rawArchiveIds)];
         for (const memoryId of archiveIds) {
           const memory2 = getMemoryById(deps.db, memoryId);
-          if (!memory2 || !storedPathBelongsToIdentity(memory2.projectPath, projectIdentity)) {
+          if (!memory2 || !memoryVisibleToTool(memory2)) {
             return err2(`Error: Memory with ID ${memoryId} was not found.`);
           }
           if (!dreamerAllowed && !isPrimaryMutableMemory(memory2)) {
             return err2(inactiveMemoryError(memoryId, "archiving"));
           }
         }
+        const targets = archiveIds.map((memoryId) => {
+          const memory2 = getMemoryById(deps.db, memoryId);
+          if (!memory2)
+            throw new Error(`validated memory ${memoryId} disappeared`);
+          return {
+            memoryId,
+            projectIdentity: targetIdentityForStoredPath(memory2.projectPath)
+          };
+        });
         deps.db.transaction(() => {
-          for (const memoryId of archiveIds) {
-            archiveMemory(deps.db, memoryId, params.reason);
+          for (const target2 of targets) {
+            archiveMemory(deps.db, target2.memoryId, params.reason);
             queueMemoryMutation(deps.db, {
-              projectPath: projectIdentity,
+              projectPath: target2.projectIdentity,
               mutationType: "archive",
-              targetMemoryId: memoryId
+              targetMemoryId: target2.memoryId
             });
           }
         })();
@@ -168909,6 +170283,37 @@ function previewText(text) {
   }
   return `${normalized.slice(0, RESULT_PREVIEW_LIMIT - 1).trimEnd()}…`;
 }
+function resolveSearchWorkspaceContext(db, projectPath, identitySet) {
+  const resolved = identitySet ?? resolveWorkspaceIdentitySet(db, projectPath);
+  const isWorkspaced = resolved.identities.length > 1;
+  const expanded = expandWorkspaceIdentitySetWithAliases(db, resolved.identities);
+  const expandedIdentities = isWorkspaced ? expanded.expandedIdentities : resolved.identities;
+  const canonicalIdentityByStoredPath = isWorkspaced ? expanded.canonicalIdentityByStoredPath : new Map(resolved.identities.map((identity) => [identity, identity]));
+  const ownIdentities = expandedIdentities.filter((identity) => canonicalIdentityByStoredPath.get(identity) === projectPath);
+  return {
+    identities: resolved.identities,
+    expandedIdentities,
+    ownIdentities,
+    shareCategories: isWorkspaced ? resolveWorkspaceShareCategories(db, projectPath) : null,
+    namesByIdentity: resolved.namesByIdentity,
+    canonicalIdentityByStoredPath,
+    isWorkspaced
+  };
+}
+function memoryWorkspaceIdentity(memory2, workspace) {
+  return resolveStoredPathWorkspaceIdentity(memory2.projectPath, workspace.identities, workspace.canonicalIdentityByStoredPath);
+}
+function sourceNamesForSearchMemories(args) {
+  if (!args.workspace.isWorkspaced)
+    return;
+  const sourceNames = new Map;
+  for (const memory2 of args.memories) {
+    const source = sourceNameForMemory(memory2.projectPath, args.projectPath, args.workspace.identities, args.workspace.namesByIdentity, args.workspace.canonicalIdentityByStoredPath);
+    if (source)
+      sourceNames.set(memory2.id, source);
+  }
+  return sourceNames.size > 0 ? sourceNames : undefined;
+}
 function getMessageSearchStatement(db) {
   let stmt = messageSearchStatements.get(db);
   if (!stmt) {
@@ -168917,6 +170322,30 @@ function getMessageSearchStatement(db) {
   }
   return stmt;
 }
+var ftsRowCountStatements = new WeakMap;
+var ftsMatchCountStatements = new WeakMap;
+function getSessionFtsRowCount(db, sessionId) {
+  let stmt = ftsRowCountStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("SELECT COUNT(*) AS n FROM message_history_fts WHERE session_id = ?");
+    ftsRowCountStatements.set(db, stmt);
+  }
+  const row = stmt.get(sessionId);
+  return typeof row?.n === "number" ? row.n : 0;
+}
+function countSessionFtsMatches(db, sessionId, ftsQuery) {
+  let stmt = ftsMatchCountStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("SELECT COUNT(*) AS n FROM message_history_fts WHERE session_id = ? AND message_history_fts MATCH ?");
+    ftsMatchCountStatements.set(db, stmt);
+  }
+  try {
+    const row = stmt.get(sessionId, ftsQuery);
+    return typeof row?.n === "number" ? row.n : 0;
+  } catch {
+    return 0;
+  }
+}
 function getMessageOrdinal(value) {
   if (typeof value === "number" && Number.isFinite(value)) {
     return value;
@@ -168932,25 +170361,63 @@ async function getSemanticScores(args) {
   if (!args.queryEmbedding || args.memories.length === 0) {
     return semanticScores;
   }
-  const cachedEmbeddings = getProjectEmbeddings(args.db, args.projectPath);
-  const embeddings = await ensureMemoryEmbeddings({
-    db: args.db,
-    projectIdentity: args.projectPath,
-    memories: args.memories,
-    existingEmbeddings: cachedEmbeddings
-  });
+  if (!args.workspace?.isWorkspaced) {
+    const cachedEmbeddings = getProjectEmbeddings(args.db, args.projectPath);
+    const embeddings = await ensureMemoryEmbeddings({
+      db: args.db,
+      projectIdentity: args.projectPath,
+      memories: args.memories,
+      existingEmbeddings: cachedEmbeddings
+    });
+    for (const memory2 of args.memories) {
+      const memoryEmbedding = embeddings.get(memory2.id);
+      if (!memoryEmbedding) {
+        continue;
+      }
+      semanticScores.set(memory2.id, normalizeCosineScore(cosineSimilarity(args.queryEmbedding, memoryEmbedding.embedding)));
+    }
+    return semanticScores;
+  }
+  if (!args.queryModelId || args.queryModelId === "off") {
+    return semanticScores;
+  }
+  const workspace = args.workspace;
+  const memoriesByIdentity = new Map;
   for (const memory2 of args.memories) {
-    const memoryEmbedding = embeddings.get(memory2.id);
-    if (!memoryEmbedding) {
+    const identity = memoryWorkspaceIdentity(memory2, workspace);
+    if (!identity)
       continue;
+    const list = memoriesByIdentity.get(identity) ?? [];
+    list.push(memory2);
+    memoriesByIdentity.set(identity, list);
+  }
+  const ownMemories = memoriesByIdentity.get(args.projectPath) ?? [];
+  if (ownMemories.length > 0) {
+    const ownEmbeddings = getProjectEmbeddings(args.db, args.projectPath);
+    await ensureMemoryEmbeddings({
+      db: args.db,
+      projectIdentity: args.projectPath,
+      memories: ownMemories,
+      existingEmbeddings: ownEmbeddings
+    });
+  }
+  for (const identity of workspace.identities) {
+    const memberMemories = memoriesByIdentity.get(identity) ?? [];
+    if (memberMemories.length === 0)
+      continue;
+    const cachedEmbeddings = getProjectEmbeddings(args.db, identity);
+    for (const memory2 of memberMemories) {
+      const memoryEmbedding = cachedEmbeddings.get(memory2.id);
+      if (!memoryEmbedding || memoryEmbedding.modelId !== args.queryModelId)
+        continue;
+      semanticScores.set(memory2.id, normalizeCosineScore(cosineSimilarity(args.queryEmbedding, memoryEmbedding.embedding)));
     }
-    semanticScores.set(memory2.id, normalizeCosineScore(cosineSimilarity(args.queryEmbedding, memoryEmbedding)));
   }
   return semanticScores;
 }
 function getFtsMatches(args) {
   try {
-    return searchMemoriesFTS(args.db, args.projectPath, args.query, args.limit);
+    return args.workspace?.isWorkspaced ? searchMemoriesFTSUnion(args.db, args.workspace.expandedIdentities, args.query, args.limit, args.workspace.ownIdentities, args.workspace.shareCategories) : searchMemoriesFTS(args.db, args.projectPath, args.query, args.limit);
   } catch (error51) {
     log(`[search] FTS query failed for "${args.query}": ${error51 instanceof Error ? error51.message : String(error51)}`);
     return [];
@@ -168964,8 +170431,11 @@ function selectSemanticCandidates(args) {
     return args.memories;
   }
   const candidateIds = new Set(args.ftsMatches.map((memory2) => memory2.id));
-  const cachedEmbeddings = peekProjectEmbeddings(args.projectPath);
-  if (cachedEmbeddings) {
+  const embeddingProjects = args.workspace?.isWorkspaced ? args.workspace.identities : [args.projectPath];
+  for (const projectPath of embeddingProjects) {
+    const cachedEmbeddings = peekProjectEmbeddings(projectPath);
+    if (!cachedEmbeddings)
+      continue;
     for (const memoryId of cachedEmbeddings.keys()) {
       candidateIds.add(memoryId);
     }
@@ -169007,7 +170477,8 @@ function mergeMemoryResults(args) {
       score,
       memoryId: memory2.id,
       category: memory2.category,
-      matchType
+      matchType,
+      sourceName: args.sourceNameByMemoryId?.get(memory2.id)
     });
   }
   return results.sort((left, right) => {
@@ -169021,7 +170492,7 @@ async function searchMemories(args) {
   if (!args.memoryEnabled) {
     return [];
   }
-  const memories = getMemoriesByProject(args.db, args.projectPath);
+  const memories = args.workspace?.isWorkspaced ? getMemoriesByProjects(args.db, args.workspace.expandedIdentities, ["active", "permanent"], Date.now(), args.workspace.ownIdentities, args.workspace.shareCategories) : getMemoriesByProject(args.db, args.projectPath);
   if (memories.length === 0) {
     return [];
   }
@@ -169029,26 +170500,43 @@ async function searchMemories(args) {
     db: args.db,
     projectPath: args.projectPath,
     query: args.query,
-    limit: FTS_SEMANTIC_CANDIDATE_LIMIT
+    limit: FTS_SEMANTIC_CANDIDATE_LIMIT,
+    workspace: args.workspace
   });
   const ftsScores = getFtsScores(ftsMatches);
   const semanticCandidates = selectSemanticCandidates({
     memories,
     projectPath: args.projectPath,
-    ftsMatches
+    ftsMatches,
+    workspace: args.workspace
   });
   const semanticScores = await getSemanticScores({
     db: args.db,
     projectPath: args.projectPath,
     memories: semanticCandidates,
-    queryEmbedding: args.queryEmbedding
+    queryEmbedding: args.queryEmbedding,
+    queryModelId: args.queryModelId,
+    workspace: args.workspace
   });
   return mergeMemoryResults({
     memories,
     semanticScores,
     ftsScores,
     limit: args.limit,
-    visibleMemoryIds: args.visibleMemoryIds
+    visibleMemoryIds: args.visibleMemoryIds,
+    sourceNameByMemoryId: sourceNamesForSearchMemories({
+      memories,
+      projectPath: args.projectPath,
+      workspace: args.workspace ?? {
+        identities: [args.projectPath],
+        expandedIdentities: [args.projectPath],
+        namesByIdentity: new Map,
+        canonicalIdentityByStoredPath: new Map([[args.projectPath, args.projectPath]]),
+        ownIdentities: [args.projectPath],
+        shareCategories: null,
+        isWorkspaced: false
+      }
+    })
   });
 }
 function linearDecayScore(rank, total) {
@@ -169079,7 +170567,13 @@ function runMessageFtsQuery(db, sessionId, ftsQuery, fetchLimit, cutoff) {
   return result;
 }
 var RRF_K = 60;
-var VERBATIM_PROBE_BONUS = 0.5;
+var VERBATIM_RANK_BONUS = 1 / RRF_K;
+var IDF_FALLOFF = 100;
+function probeDiscriminationWeight(df, corpusSize) {
+  if (corpusSize <= 0 || df <= 0)
+    return 1;
+  return 1 / (1 + IDF_FALLOFF * df / corpusSize);
+}
 function searchMessages(args) {
   const cutoff = args.maxOrdinal != null && args.maxOrdinal >= 0 ? args.maxOrdinal : null;
   const fetchLimit = args.maxOrdinal != null && args.maxOrdinal >= 0 ? args.limit * 3 : args.limit;
@@ -169096,20 +170590,31 @@ function searchMessages(args) {
       role: row.role
     }));
   }
+  const corpusSize = getSessionFtsRowCount(args.db, args.sessionId);
   const queryLists = [];
   if (baseQuery.length > 0) {
-    queryLists.push(runMessageFtsQuery(args.db, args.sessionId, baseQuery, fetchLimit, cutoff));
+    queryLists.push({
+      rows: runMessageFtsQuery(args.db, args.sessionId, baseQuery, fetchLimit, cutoff),
+      weight: 1
+    });
   }
+  const probeWeights = new Map;
   for (const probe of probes) {
     const probeQuery = sanitizeFtsQuery(probe);
     if (probeQuery.length === 0)
       continue;
-    queryLists.push(runMessageFtsQuery(args.db, args.sessionId, probeQuery, fetchLimit, cutoff));
+    const df = countSessionFtsMatches(args.db, args.sessionId, probeQuery);
+    const weight = probeDiscriminationWeight(df, corpusSize);
+    probeWeights.set(probe, weight);
+    queryLists.push({
+      rows: runMessageFtsQuery(args.db, args.sessionId, probeQuery, fetchLimit, cutoff),
+      weight
+    });
   }
   const fused = new Map;
   for (const list of queryLists) {
-    list.forEach((row, rank) => {
-      const rrf = 1 / (RRF_K + rank);
+    list.rows.forEach((row, rank) => {
+      const rrf = list.weight / (RRF_K + rank);
       const existing = fused.get(row.messageId);
       if (existing) {
         existing.score += rrf;
@@ -169119,26 +170624,107 @@ function searchMessages(args) {
     });
   }
   for (const entry of fused.values()) {
-    if (containsProbeVerbatim(entry.row.content, probes)) {
-      entry.score += VERBATIM_PROBE_BONUS;
+    let best = 0;
+    for (const probe of probes) {
+      const weight = probeWeights.get(probe) ?? 0;
+      if (weight > best && containsProbeVerbatim(entry.row.content, [probe])) {
+        best = weight;
+      }
+    }
+    if (best > 0) {
+      entry.score += best * VERBATIM_RANK_BONUS;
     }
   }
   const ranked = [...fused.values()].sort((a, b) => b.score !== a.score ? b.score - a.score : a.row.messageOrdinal - b.row.messageOrdinal).slice(0, args.limit);
-  const maxScore = ranked.length > 0 ? ranked[0].score : 1;
-  return ranked.map((entry) => ({
+  return ranked.map((entry, rank) => ({
     source: "message",
     content: previewText(entry.row.content),
-    score: maxScore > 0 ? entry.score / maxScore : 0,
+    score: linearDecayScore(rank, ranked.length),
     messageOrdinal: entry.row.messageOrdinal,
     messageId: entry.row.messageId,
     role: entry.row.role
   }));
 }
+function searchCompartmentChunks(args) {
+  if (!args.queryEmbedding || args.limit <= 0)
+    return [];
+  const cutoff = args.maxOrdinal != null && args.maxOrdinal >= 0 ? args.maxOrdinal : null;
+  const rows = loadCompartmentChunkEmbeddingsForSearch(args.db, args.sessionId, args.projectPath, args.modelId);
+  if (rows.length === 0)
+    return [];
+  const byCompartment = new Map;
+  for (const row of rows) {
+    if (cutoff !== null && row.endOrdinal > cutoff) {
+      continue;
+    }
+    const score = normalizeCosineScore(cosineSimilarity(args.queryEmbedding, row.vector));
+    if (score <= 0)
+      continue;
+    const existing = byCompartment.get(row.compartmentId);
+    if (!existing || score > existing.score) {
+      byCompartment.set(row.compartmentId, { row, score });
+    }
+  }
+  return [...byCompartment.values()].sort((left, right) => right.score !== left.score ? right.score - left.score : left.row.startOrdinal - right.row.startOrdinal).slice(0, args.limit).map(({ row, score }) => ({
+    source: "compartment",
+    content: previewText(row.title),
+    score: score * SINGLE_SOURCE_PENALTY,
+    compartmentId: row.compartmentId,
+    sessionId: row.sessionId,
+    title: row.title,
+    startOrdinal: row.startOrdinal,
+    endOrdinal: row.endOrdinal,
+    matchType: "semantic"
+  }));
+}
+function mergeMessageAndCompartmentResults(args) {
+  if (args.compartments.length === 0)
+    return args.messages;
+  if (args.messages.length === 0)
+    return args.compartments;
+  const fused = new Map;
+  const add = (key, result, score, tieOrdinal) => {
+    const existing = fused.get(key);
+    if (existing) {
+      existing.score += score;
+      return existing;
+    }
+    const entry = { result, score, tieOrdinal, snippetScore: -1 };
+    fused.set(key, entry);
+    return entry;
+  };
+  args.compartments.forEach((compartment, rank) => {
+    add(`compartment:${compartment.compartmentId}`, compartment, 1 / (RRF_K + rank), compartment.startOrdinal);
+  });
+  for (const [rank, message] of args.messages.entries()) {
+    const containing = args.compartments.find((compartment) => message.messageOrdinal >= compartment.startOrdinal && message.messageOrdinal <= compartment.endOrdinal);
+    const contribution = 1 / (RRF_K + rank);
+    if (!containing) {
+      add(`message:${message.messageId}`, message, contribution, message.messageOrdinal);
+      continue;
+    }
+    const entry = add(`compartment:${containing.compartmentId}`, containing, contribution, containing.startOrdinal);
+    if (message.score > entry.snippetScore && entry.result.source === "compartment") {
+      entry.snippetScore = message.score;
+      entry.result = {
+        ...entry.result,
+        matchType: "hybrid",
+        snippet: message.content
+      };
+    }
+  }
+  const ranked = [...fused.values()].sort((left, right) => right.score !== left.score ? right.score - left.score : left.tieOrdinal - right.tieOrdinal).slice(0, args.limit);
+  return ranked.map((entry, rank) => ({
+    ...entry.result,
+    score: linearDecayScore(rank, ranked.length)
+  }));
+}
 function getSourceBoost(result) {
   switch (result.source) {
     case "memory":
       return MEMORY_SOURCE_BOOST;
     case "message":
+    case "compartment":
       return MESSAGE_SOURCE_BOOST;
     case "git_commit":
       return GIT_COMMIT_SOURCE_BOOST;
@@ -169156,6 +170742,9 @@ function compareUnifiedResults(left, right) {
   if (left.source === "message" && right.source === "message") {
     return left.messageOrdinal - right.messageOrdinal;
   }
+  if (left.source === "compartment" && right.source === "compartment") {
+    return left.startOrdinal - right.startOrdinal;
+  }
   if (left.source === "git_commit" && right.source === "git_commit") {
     return right.committedAtMs - left.committedAtMs;
   }
@@ -169206,10 +170795,12 @@ async function unifiedSearch(db, sessionId, projectPath, query, options3 = {}) {
   const isEmbeddingRuntimeEnabled = options3.isEmbeddingRuntimeEnabled ?? isEmbeddingEnabled;
   const gitCommitsEnabled = options3.gitCommitsEnabled ?? false;
   const activeSources = resolveSources(options3.sources);
-  const runMemory = activeSources.has("memory") && (options3.memoryEnabled ?? true);
+  const memoryFeatureEnabled = options3.memoryEnabled ?? true;
+  const runMemory = activeSources.has("memory") && memoryFeatureEnabled;
   const runMessages = activeSources.has("message");
   const runGitCommits = activeSources.has("git_commit") && gitCommitsEnabled;
-  const needsEmbedding = (runMemory || runGitCommits) && embeddingEnabled && isEmbeddingRuntimeEnabled();
+  const runCompartmentChunks = runMessages && memoryFeatureEnabled && embeddingEnabled;
+  const needsEmbedding = (runMemory || runGitCommits || runCompartmentChunks) && embeddingEnabled && isEmbeddingRuntimeEnabled();
   const queryEmbeddingPromise = needsEmbedding ? embedQuery(trimmedQuery, options3.signal).catch((error51) => {
     log(`[search] query embedding failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
     return null;
@@ -169225,6 +170816,24 @@ async function unifiedSearch(db, sessionId, projectPath, query, options3 = {}) {
     probes: messageProbes
   }) : [];
   const queryEmbedding = await queryEmbeddingPromise;
+  const workspace = resolveSearchWorkspaceContext(db, projectPath);
+  const embeddingSnapshot = getProjectEmbeddingSnapshot(projectPath);
+  const embeddingModelId = embeddingSnapshot?.modelId;
+  const chunkModelId = embeddingSnapshot?.chunkModelId;
+  const compartmentResults = runCompartmentChunks ? searchCompartmentChunks({
+    db,
+    sessionId,
+    projectPath,
+    queryEmbedding,
+    limit: tierLimit,
+    maxOrdinal: options3.maxMessageOrdinal,
+    modelId: chunkModelId && chunkModelId !== "off" ? chunkModelId : null
+  }) : [];
+  const messageLikeResults = mergeMessageAndCompartmentResults({
+    messages: messageResults,
+    compartments: compartmentResults,
+    limit: tierLimit
+  });
   const [memoryResults, gitCommitResults] = await Promise.all([
     runMemory ? searchMemories({
       db,
@@ -169233,6 +170842,8 @@ async function unifiedSearch(db, sessionId, projectPath, query, options3 = {}) {
       limit: tierLimit,
       memoryEnabled: true,
       queryEmbedding,
+      queryModelId: embeddingModelId && embeddingModelId !== "off" ? embeddingModelId : null,
+      workspace,
       visibleMemoryIds: options3.visibleMemoryIds
     }) : Promise.resolve([]),
     runGitCommits ? Promise.resolve(searchGitCommits({
@@ -169243,7 +170854,7 @@ async function unifiedSearch(db, sessionId, projectPath, query, options3 = {}) {
       queryEmbedding
     })) : Promise.resolve([])
   ]);
-  const results = [...memoryResults, ...messageResults, ...gitCommitResults].sort(compareUnifiedResults).slice(0, limit);
+  const results = [...memoryResults, ...messageLikeResults, ...gitCommitResults].sort(compareUnifiedResults).slice(0, limit);
   const countRetrievals = options3.countRetrievals ?? true;
   if (countRetrievals) {
     const memoryIds = results.filter((result) => result.source === "memory").map((result) => result.memoryId);
@@ -169284,8 +170895,8 @@ function getUserMemoryCandidates(db) {
 function deleteUserMemoryCandidates(db, ids) {
   if (ids.length === 0)
     return;
-  const placeholders = ids.map(() => "?").join(",");
-  db.prepare(`DELETE FROM user_memory_candidates WHERE id IN (${placeholders})`).run(...ids);
+  const placeholders3 = ids.map(() => "?").join(",");
+  db.prepare(`DELETE FROM user_memory_candidates WHERE id IN (${placeholders3})`).run(...ids);
 }
 function insertUserMemory(db, content, sourceCandidateIds) {
   const now = Date.now();
@@ -169837,26 +171448,40 @@ ${sections.join(`
 var DEFAULT_MEMORY_BUDGET_TOKENS = 8000;
 var MEMORY_BLOCK_WRAPPER_TOKENS = 6;
 var DEFAULT_USER_PROFILE_BUDGET_TOKENS = 4000;
+function memoryCanonicalIdentity(memory2, workspace) {
+  return resolveStoredPathWorkspaceIdentity(memory2.projectPath, workspace.identities, workspace.canonicalIdentityByStoredPath);
+}
+function memorySelectionOrder(left, right) {
+  if (left.status === "permanent" && right.status !== "permanent")
+    return -1;
+  if (right.status === "permanent" && left.status !== "permanent")
+    return 1;
+  const leftImportance = left.importance ?? Number.NEGATIVE_INFINITY;
+  const rightImportance = right.importance ?? Number.NEGATIVE_INFINITY;
+  const importanceDiff = rightImportance - leftImportance;
+  if (importanceDiff !== 0)
+    return importanceDiff;
+  return left.id - right.id;
+}
+function memoryRenderOrder(left, right) {
+  const aPriority = MEMORY_CATEGORY_ORDER_PRIORITY[left.category] ?? MEMORY_CATEGORY_ORDER_UNKNOWN;
+  const bPriority = MEMORY_CATEGORY_ORDER_PRIORITY[right.category] ?? MEMORY_CATEGORY_ORDER_UNKNOWN;
+  const categoryDiff = aPriority - bPriority;
+  if (categoryDiff !== 0)
+    return categoryDiff;
+  return left.id - right.id;
+}
 var maxCompartmentSeqStatements = new WeakMap;
 var maxMemoryIdStatements = new WeakMap;
 var legacyCompartmentCountStatements = new WeakMap;
 var m0CompartmentStatements = new WeakMap;
 var newCompartmentStatements = new WeakMap;
-function trimMemoriesToBudgetV2(sessionId, memories, budgetTokens) {
-  const selectionOrder = [...memories].sort((a, b) => {
-    if (a.status === "permanent" && b.status !== "permanent")
-      return -1;
-    if (b.status === "permanent" && a.status !== "permanent")
-      return 1;
-    const importanceDiff = (b.importance ?? 50) - (a.importance ?? 50);
-    if (importanceDiff !== 0)
-      return importanceDiff;
-    return a.id - b.id;
-  });
+function trimMemoriesToBudgetV2(sessionId, memories, budgetTokens, renderOptions = {}) {
+  const selectionOrder = [...memories].sort(memorySelectionOrder);
   const selected = [];
   let usedTokens = MEMORY_BLOCK_WRAPPER_TOKENS;
   for (const memory2 of selectionOrder) {
-    const memoryTokens = estimateTokens(renderMemoryLineV2(memory2));
+    const memoryTokens = estimateTokens(renderMemoryLineV2(memory2, renderOptions.sourceNameByMemoryId?.get(memory2.id)));
     if (usedTokens + memoryTokens > budgetTokens)
       continue;
     selected.push(memory2);
@@ -169865,16 +171490,70 @@ function trimMemoriesToBudgetV2(sessionId, memories, budgetTokens) {
   if (selected.length < memories.length) {
     sessionLog(sessionId, `v2 trimmed memories from ${memories.length} to ${selected.length} to fit injection budget of ${budgetTokens} tokens`);
   }
-  const renderOrder = [...selected].sort((a, b) => {
-    const aPriority = MEMORY_CATEGORY_ORDER_PRIORITY[a.category] ?? MEMORY_CATEGORY_ORDER_UNKNOWN;
-    const bPriority = MEMORY_CATEGORY_ORDER_PRIORITY[b.category] ?? MEMORY_CATEGORY_ORDER_UNKNOWN;
-    const categoryDiff = aPriority - bPriority;
-    if (categoryDiff !== 0)
-      return categoryDiff;
-    return a.id - b.id;
-  });
+  const renderOrder = [...selected].sort(memoryRenderOrder);
   return { selected, renderOrder };
 }
+function trimWorkspaceMemoriesToBudgetV2(sessionId, memories, budgetTokens, workspace, renderOptions = {}) {
+  if (!workspace.isWorkspaced) {
+    return trimMemoriesToBudgetV2(sessionId, memories, budgetTokens, renderOptions);
+  }
+  const selected = [];
+  const selectedIds = new Set;
+  let usedTokens = MEMORY_BLOCK_WRAPPER_TOKENS;
+  const tokenCost = (memory2) => estimateTokens(renderMemoryLineV2(memory2, renderOptions.sourceNameByMemoryId?.get(memory2.id)));
+  const trySelect = (memory2) => {
+    if (selectedIds.has(memory2.id))
+      return false;
+    const tokens = tokenCost(memory2);
+    if (usedTokens + tokens > budgetTokens)
+      return false;
+    selected.push(memory2);
+    selectedIds.add(memory2.id);
+    usedTokens += tokens;
+    return true;
+  };
+  for (const memory2 of memories.filter((candidate) => candidate.status === "permanent").sort(memorySelectionOrder)) {
+    trySelect(memory2);
+  }
+  const remainingAfterPermanent = Math.max(0, budgetTokens - usedTokens);
+  const floorTokens = remainingAfterPermanent / Math.max(1, workspace.identities.length);
+  const byIdentity = new Map;
+  for (const memory2 of memories) {
+    if (memory2.status === "permanent")
+      continue;
+    const identity = memoryCanonicalIdentity(memory2, workspace);
+    if (!identity)
+      continue;
+    const list = byIdentity.get(identity) ?? [];
+    list.push(memory2);
+    byIdentity.set(identity, list);
+  }
+  for (const identity of workspace.identities) {
+    let memberTokens = 0;
+    const candidates2 = (byIdentity.get(identity) ?? []).sort(memorySelectionOrder);
+    for (const memory2 of candidates2) {
+      if (selectedIds.has(memory2.id))
+        continue;
+      const tokens = tokenCost(memory2);
+      if (memberTokens + tokens > floorTokens)
+        continue;
+      if (usedTokens + tokens > budgetTokens)
+        continue;
+      selected.push(memory2);
+      selectedIds.add(memory2.id);
+      usedTokens += tokens;
+      memberTokens += tokens;
+    }
+  }
+  const remaining = memories.filter((memory2) => !selectedIds.has(memory2.id)).sort(memorySelectionOrder);
+  for (const memory2 of remaining) {
+    trySelect(memory2);
+  }
+  if (selected.length < memories.length) {
+    sessionLog(sessionId, `v2 trimmed memories from ${memories.length} to ${selected.length} to fit injection budget of ${budgetTokens} tokens`);
+  }
+  return { selected, renderOrder: [...selected].sort(memoryRenderOrder) };
+}
 function trimUserMemoriesToBudget(memories, budgetTokens) {
   const selected = [];
   let usedTokens = 0;
@@ -169887,15 +171566,16 @@ function trimUserMemoriesToBudget(memories, budgetTokens) {
   }
   return selected;
 }
-function renderMemoryLineV2(memory2) {
-  return `  <memory id="${memory2.id}" category="${escapeXmlAttr(memory2.category)}" importance="${memory2.importance ?? 50}">${escapeXmlContent(memory2.content)}</memory>`;
+function renderMemoryLineV2(memory2, sourceName) {
+  const sourceAttr = sourceName ? ` source="${escapeXmlAttr(sourceName)}"` : "";
+  return `  <memory id="${memory2.id}" category="${escapeXmlAttr(memory2.category)}"${sourceAttr} importance="${memory2.importance ?? 50}">${escapeXmlContent(memory2.content)}</memory>`;
 }
-function renderMemoryBlockV2(memories, wrapper = "project-memory") {
+function renderMemoryBlockV2(memories, wrapper = "project-memory", renderOptions = {}) {
   if (memories.length === 0)
     return "";
   const lines = [`<${wrapper}>`];
   for (const memory2 of memories) {
-    lines.push(renderMemoryLineV2(memory2));
+    lines.push(renderMemoryLineV2(memory2, renderOptions.sourceNameByMemoryId?.get(memory2.id)));
   }
   lines.push(`</${wrapper}>`);
   return lines.join(`
@@ -169960,8 +171640,9 @@ function formatAge(committedAtMs) {
 }
 function formatResult(result, index) {
   if (result.source === "memory") {
+    const source = result.sourceName ? ` source=${result.sourceName}` : "";
     return [
-      `[${index}] [memory] score=${result.score.toFixed(2)} id=${result.memoryId} category=${result.category} match=${result.matchType}`,
+      `[${index}] [memory] score=${result.score.toFixed(2)} id=${result.memoryId} category=${result.category}${source} match=${result.matchType}`,
       result.content
     ].join(`
 `);
@@ -169971,6 +171652,13 @@ function formatResult(result, index) {
       `[${index}] [git_commit] score=${result.score.toFixed(2)} sha=${result.shortSha} ${formatAge(result.committedAtMs)} match=${result.matchType}`,
       result.content
     ].join(`
+`);
+  }
+  if (result.source === "compartment") {
+    return [
+      `[${index}] [message] score=${result.score.toFixed(2)} compartment_id=${result.compartmentId} range=${result.startOrdinal}-${result.endOrdinal} match=${result.matchType} title=${result.title}`,
+      result.snippet ? `Snippet: ${result.snippet}` : result.content
+    ].join(`
 `);
   }
   const expandStart = Math.max(1, result.messageOrdinal - 3);
@@ -169986,7 +171674,7 @@ function formatSearchResults(query, results) {
     return `No results found for "${query}" across memories, git commits, or message history.`;
   }
   const bodyParts = results.map((result, index) => formatResult(result, index + 1));
-  if (results.some((result) => result.source === "message")) {
+  if (results.some((result) => result.source === "message" || result.source === "compartment")) {
     bodyParts.push("Use ctx_expand(start, end) with the range from any message result above to read the full conversation context.");
   }
   const body = bodyParts.join(`