@wolfx/opencode-magic-context 0.23.1 → 0.24.0

package/dist/index.js

@@ -14887,7 +14887,8 @@ var init_magic_context = __esm(() => {
     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({
@@ -14908,7 +14909,8 @@ var init_magic_context = __esm(() => {
     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") {
@@ -14921,7 +14923,8 @@ var init_magic_context = __esm(() => {
         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" };
@@ -15844,7 +15847,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 {
@@ -15871,6 +15874,7 @@ function getDefaultSessionMeta(sessionId) {
     cachedM0Bytes: null,
     cachedM1Bytes: null,
     cachedM0ProjectMemoryEpoch: null,
+    cachedM0WorkspaceFingerprint: null,
     cachedM0ProjectUserProfileVersion: null,
     cachedM0MaxCompartmentSeq: null,
     cachedM0MaxMemoryId: null,
@@ -15933,6 +15937,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),
@@ -15963,6 +15968,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 = ?,
@@ -15975,7 +15981,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);
@@ -15984,6 +15990,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],
@@ -16039,6 +16046,7 @@ var init_storage_meta_shared = __esm(() => {
     "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",
@@ -16086,6 +16094,7 @@ var init_storage_meta_shared = __esm(() => {
     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",
@@ -16115,6 +16124,7 @@ var init_storage_meta_shared = __esm(() => {
     "cachedM0Bytes",
     "cachedM1Bytes",
     "cachedM0ProjectMemoryEpoch",
+    "cachedM0WorkspaceFingerprint",
     "cachedM0ProjectUserProfileVersion",
     "cachedM0MaxCompartmentSeq",
     "cachedM0MaxMemoryId",
@@ -150826,6 +150836,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,
@@ -151011,6 +151050,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,
@@ -151122,6 +151180,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,
@@ -151280,6 +151339,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");
@@ -151333,6 +151393,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");
@@ -151364,6 +151425,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,
@@ -151391,6 +151461,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,
@@ -151412,6 +151499,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);
@@ -151449,6 +151537,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", ""],
@@ -151493,7 +151582,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();
@@ -151579,7 +151668,7 @@ function getDatabasePersistenceError(db) {
     return null;
   return persistenceErrorByDatabase.get(db) ?? null;
 }
-var databases, persistenceByDatabase, persistenceErrorByDatabase, lastSchemaFenceRejection = null, LATEST_SUPPORTED_VERSION = 32, sqlitePragmaConfig, CHANNEL2_CLAIM_TTL_MS = 120000;
+var databases, persistenceByDatabase, persistenceErrorByDatabase, lastSchemaFenceRejection = null, LATEST_SUPPORTED_VERSION = 36, sqlitePragmaConfig, CHANNEL2_CLAIM_TTL_MS = 120000;
 var init_storage_db = __esm(async () => {
   init_data_path();
   init_logger();
@@ -151599,10 +151688,302 @@ var init_storage_db = __esm(async () => {
   };
 });
 
+// src/features/magic-context/memory/constants.ts
+var V2_MEMORY_CATEGORIES, PROMOTABLE_CATEGORIES, CATEGORY_PRIORITY, MEMORY_CATEGORY_ORDER_UNKNOWN = 99, MEMORY_CATEGORY_ORDER_PRIORITY, MEMORY_CATEGORY_ORDER_SQL, CATEGORY_DEFAULT_TTL;
+var init_constants = __esm(() => {
+  V2_MEMORY_CATEGORIES = [
+    "PROJECT_RULES",
+    "ARCHITECTURE",
+    "CONSTRAINTS",
+    "CONFIG_VALUES",
+    "NAMING"
+  ];
+  PROMOTABLE_CATEGORIES = [
+    "PROJECT_RULES",
+    "ARCHITECTURE",
+    "CONSTRAINTS",
+    "CONFIG_VALUES",
+    "NAMING",
+    "ARCHITECTURE_DECISIONS",
+    "CONFIG_DEFAULTS",
+    "USER_PREFERENCES",
+    "USER_DIRECTIVES",
+    "ENVIRONMENT",
+    "WORKFLOW_RULES",
+    "KNOWN_ISSUES"
+  ];
+  CATEGORY_PRIORITY = [
+    "PROJECT_RULES",
+    "ARCHITECTURE",
+    "CONSTRAINTS",
+    "CONFIG_VALUES",
+    "NAMING",
+    "USER_DIRECTIVES",
+    "USER_PREFERENCES",
+    "CONFIG_DEFAULTS",
+    "ARCHITECTURE_DECISIONS",
+    "ENVIRONMENT",
+    "WORKFLOW_RULES",
+    "KNOWN_ISSUES"
+  ];
+  MEMORY_CATEGORY_ORDER_PRIORITY = CATEGORY_PRIORITY.reduce((acc, category, index) => {
+    acc[category] = index;
+    return acc;
+  }, {});
+  MEMORY_CATEGORY_ORDER_SQL = `CASE category ${CATEGORY_PRIORITY.map((category, index) => `WHEN '${category}' THEN ${index}`).join(" ")} ELSE ${MEMORY_CATEGORY_ORDER_UNKNOWN} END`;
+  CATEGORY_DEFAULT_TTL = {
+    WORKFLOW_RULES: 90 * 24 * 60 * 60 * 1000,
+    KNOWN_ISSUES: 30 * 24 * 60 * 60 * 1000
+  };
+});
+
+// src/features/magic-context/project-identity.ts
+var init_project_identity2 = __esm(() => {
+  init_project_identity();
+});
+
+// src/features/magic-context/workspaces.ts
+import { createHash as createHash4 } from "node:crypto";
+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 hash2 = createHash4("sha256");
+  hash2.update("share_categories", "utf8");
+  hash2.update("\x00");
+  hash2.update(shareCategories === null ? "ALL" : JSON.stringify(shareCategories), "utf8");
+  hash2.update(`
+`);
+  for (const identity of canonical) {
+    hash2.update(identity, "utf8");
+    hash2.update("\x00");
+    hash2.update(String(epochs.get(identity) ?? 0), "utf8");
+    hash2.update(`
+`);
+  }
+  return hash2.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 (error51) {
+    try {
+      db.exec("ROLLBACK");
+    } catch {}
+    throw error51;
+  }
+}
+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 (error51) {
+    try {
+      db.exec("ROLLBACK");
+    } catch {}
+    throw error51;
+  }
+}
+var VALID_SHARE_CATEGORIES;
+var init_workspaces = __esm(() => {
+  init_constants();
+  init_project_identity2();
+  VALID_SHARE_CATEGORIES = new Set(V2_MEMORY_CATEGORIES);
+});
+
 // src/features/magic-context/migrations.ts
-function tableExists(db, name2) {
+function tableExists2(db, name2) {
   return Boolean(db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name = ?").get(name2));
 }
+function columnExists2(db, table, column) {
+  const rows = db.prepare(`PRAGMA table_info(${table})`).all();
+  return rows.some((row) => row.name === column);
+}
 function ensureMigrationsTable(db) {
   db.exec(`
 		CREATE TABLE IF NOT EXISTS schema_migrations (
@@ -151671,6 +152052,7 @@ function runMigrations(db) {
 var MIGRATIONS, LATEST_MIGRATION_VERSION;
 var init_migrations = __esm(async () => {
   init_logger();
+  init_workspaces();
   await init_storage_db();
   MIGRATIONS = [
     {
@@ -152130,9 +152512,9 @@ var init_migrations = __esm(async () => {
       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");
@@ -152157,7 +152539,7 @@ var init_migrations = __esm(async () => {
           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");
@@ -152468,13 +152850,163 @@ var init_migrations = __esm(async () => {
         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;
+                `);
+        }
+      }
     }
   ];
   LATEST_MIGRATION_VERSION = MIGRATIONS.reduce((max, m) => Math.max(max, m.version), 0);
 });
 
 // src/features/magic-context/project-docs-hash.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 import { lstatSync, readFileSync as readFileSync5, statSync as statSync2 } from "node:fs";
 import path4 from "node:path";
 function canonicalizeDocContent(raw) {
@@ -152564,7 +153096,7 @@ function hashCanonicalPieces(hashPieces) {
   if (hashPieces.length === 0) {
     return "";
   }
-  return createHash4("sha256").update(hashPieces.join(PROJECT_DOCS_DELIMITER), "utf8").digest("hex");
+  return createHash5("sha256").update(hashPieces.join(PROJECT_DOCS_DELIMITER), "utf8").digest("hex");
 }
 function readProjectDocsCanonical(projectDirectory) {
   const canonicalDirectory = path4.resolve(projectDirectory);
@@ -152602,11 +153134,6 @@ var init_project_docs_hash = __esm(() => {
   MAX_PROJECT_DOC_BYTES = 256 * 1024;
   docsCache = new Map;
 });
-
-// src/features/magic-context/project-identity.ts
-var init_project_identity2 = __esm(() => {
-  init_project_identity();
-});
 // src/features/magic-context/storage-m0-mutation-log.ts
 function assertMutationType(mutationType) {
   if (!M0_MUTATION_TYPES.has(mutationType)) {
@@ -152691,18 +153218,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 uniqueProjectPaths(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);
@@ -152723,10 +153245,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 = uniqueProjectPaths(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 = uniqueProjectPaths(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;
+}
 var MEMORY_MUTATION_TYPES, TERMINAL_MUTATION_TYPES;
 var init_storage_memory_mutation_log = __esm(() => {
   MEMORY_MUTATION_TYPES = new Set(["archive", "delete", "update", "superseded"]);
@@ -153419,6 +153985,36 @@ function addStaleReduceStrippedIds(db, sessionId, ids) {
   sessionLog(sessionId, `stale_reduce_stripped_ids CAS: ${CAS_RETRY_LIMIT} retries exhausted`);
   return false;
 }
+function getProcessedImageStrippedIds(db, sessionId) {
+  const row = db.prepare("SELECT processed_image_stripped_ids FROM session_meta WHERE session_id = ?").get(sessionId);
+  return new Set(parseStrippedBlob(row?.processed_image_stripped_ids));
+}
+function addProcessedImageStrippedIds(db, sessionId, ids) {
+  const add = [...ids];
+  if (add.length === 0)
+    return true;
+  ensureSessionMetaRow(db, sessionId);
+  for (let attempt = 0;attempt < CAS_RETRY_LIMIT; attempt += 1) {
+    const row = db.prepare("SELECT processed_image_stripped_ids FROM session_meta WHERE session_id = ?").get(sessionId);
+    const rawStored = row ? row.processed_image_stripped_ids ?? null : null;
+    const current = new Set(parseStrippedBlob(rawStored));
+    let changed = false;
+    for (const id of add) {
+      if (!current.has(id)) {
+        current.add(id);
+        changed = true;
+      }
+    }
+    if (!changed)
+      return true;
+    const nextBlob = JSON.stringify([...current]);
+    const result = db.prepare("UPDATE session_meta SET processed_image_stripped_ids = ? WHERE session_id = ? AND processed_image_stripped_ids IS ?").run(nextBlob, sessionId, rawStored);
+    if (result.changes > 0)
+      return true;
+  }
+  sessionLog(sessionId, `processed_image_stripped_ids CAS: ${CAS_RETRY_LIMIT} retries exhausted`);
+  return false;
+}
 function isPendingCompactionMarker(value) {
   return typeof value === "object" && value !== null && typeof value.ordinal === "number" && typeof value.endMessageId === "string" && typeof value.publishedAt === "number";
 }
@@ -153597,6 +154193,8 @@ function clearSession(db, sessionId) {
     db.prepare("DELETE FROM source_contents WHERE session_id = ?").run(sessionId);
     db.prepare("DELETE FROM tags WHERE session_id = ?").run(sessionId);
     db.prepare("DELETE FROM session_meta WHERE session_id = ?").run(sessionId);
+    db.prepare("DELETE FROM session_projects WHERE session_id = ?").run(sessionId);
+    db.prepare("DELETE FROM compartment_chunk_embeddings WHERE session_id = ?").run(sessionId);
     db.prepare("DELETE FROM compartments WHERE session_id = ?").run(sessionId);
     clearCompressionDepth(db, sessionId);
     db.prepare("DELETE FROM session_facts WHERE session_id = ?").run(sessionId);
@@ -153703,9 +154301,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
   };
 }
@@ -153911,19 +154509,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)
@@ -153959,8 +154544,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);
@@ -154270,8 +154855,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);
 }
 function getMaxDroppedTagNumber(db, sessionId) {
@@ -154424,6 +155009,7 @@ var init_storage = __esm(async () => {
   init_storage_source();
   init_storage_tags();
   init_storage_v22_backfill_failures();
+  init_workspaces();
   await __promiseAll([
     init_message_index(),
     init_migrations(),
@@ -163875,7 +164461,7 @@ 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 toFloat32Array(blob) {
   if (blob instanceof Uint8Array) {
@@ -163895,7 +164481,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;
@@ -163924,7 +164510,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, toFloat32Array(row.embedding));
+    embeddings.set(row.memoryId, {
+      embedding: toFloat32Array(row.embedding),
+      modelId: row.modelId
+    });
   }
   return embeddings;
 }
@@ -163987,13 +164576,13 @@ var init_embedding_cache = __esm(() => {
 });
 
 // src/features/magic-context/memory/normalize-hash.ts
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 function normalizeMemoryContent(content) {
   return content.toLowerCase().replace(/\s+/g, " ").trim();
 }
 function computeNormalizedHash(content) {
   const normalized = normalizeMemoryContent(content);
-  return createHash6("md5").update(normalized).digest("hex");
+  return createHash7("md5").update(normalized).digest("hex");
 }
 var init_normalize_hash = () => {};
 
@@ -164107,8 +164696,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 placeholders3 = statuses.map(() => "?").join(", ");
+    stmt = db.prepare(`SELECT ${getMemorySelectColumns(db)} FROM memories WHERE project_path = ? AND status IN (${placeholders3}) AND (expires_at IS NULL OR expires_at > ?) ORDER BY category ASC, updated_at DESC, id ASC`);
     statements.set(db, stmt);
   }
   return stmt;
@@ -164229,6 +164818,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);
@@ -164326,6 +165006,7 @@ function getMemoryCountsByStatus(db, projectPath) {
 }
 var COLUMN_MAP, MEMORY_CATEGORY_LOOKUP, MEMORY_STATUS_LOOKUP, MEMORY_SOURCE_TYPE_LOOKUP, VERIFICATION_STATUS_LOOKUP, insertMemoryStatements, getMemoryByHashStatements, getMemoryByIdStatements, activeMemoriesNoExpiryStatements, updateMemorySeenCountStatements, updateMemoryRetrievalCountStatements, updateMemoryStatusStatements, updateArchivedMemoryStatements, updateMemoryVerificationStatements, updateMemoryContentStatements, supersededMemoryStatements, mergeMemoryStatsStatements, deleteMemoryStatements, deleteMemoryEmbeddingStatements, deleteEmbeddingOnContentUpdateStatements, getMemoryCountStatements, getMemoryCountByProjectStatements, getMemoryCountsByStatusStatements, memoriesByProjectStatements, memoryImportanceColumnCache;
 var init_storage_memory = __esm(() => {
+  init_constants();
   init_embedding_cache();
   init_normalize_hash();
   COLUMN_MAP = {
@@ -164431,8 +165112,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();
@@ -164465,6 +165146,444 @@ function parseUserMemoryRow(row) {
   };
 }
 
+// src/features/magic-context/compartment-chunk-embedding.ts
+import { createHash as createHash8 } from "node:crypto";
+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 createHash8("sha256").update(text).digest("hex");
+}
+function vectorBlob(vector) {
+  return new Uint8Array(vector.buffer, vector.byteOffset, vector.byteLength);
+}
+function toFloat32Array2(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 fullText = lines.join(`
+`);
+  if (estimateTokens(fullText) <= normalizedMax) {
+    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 > normalizedMax) {
+      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: toFloat32Array2(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
+  }));
+}
+function loadUnembeddedSessionChunkCandidates(db, projectPath, sessionId, modelId, limit, excludeIds) {
+  if (excludeIds && excludeIds.length > 0) {
+    const placeholders3 = 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 (${placeholders3})
+               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;
+}
+var DEFAULT_COMPARTMENT_CHUNK_MAX_INPUT_TOKENS = 512, loadFtsRowsStatements, existingHashStatements, existingHashByProjectStatements, deleteByCompartmentStatements, insertEmbeddingStatements, distinctModelStatements, clearProjectStatements, clearProjectModelStatements, searchRowsStatements, searchRowsByModelStatements, backfillCandidateStatements, sessionBackfillCandidateStatements;
+var init_compartment_chunk_embedding = __esm(() => {
+  init_read_session_formatting();
+  loadFtsRowsStatements = new WeakMap;
+  existingHashStatements = new WeakMap;
+  existingHashByProjectStatements = new WeakMap;
+  deleteByCompartmentStatements = new WeakMap;
+  insertEmbeddingStatements = new WeakMap;
+  distinctModelStatements = new WeakMap;
+  clearProjectStatements = new WeakMap;
+  clearProjectModelStatements = new WeakMap;
+  searchRowsStatements = new WeakMap;
+  searchRowsByModelStatements = new WeakMap;
+  backfillCandidateStatements = new WeakMap;
+  sessionBackfillCandidateStatements = new WeakMap;
+});
+
 // src/features/magic-context/memory/cosine-similarity.ts
 function cosineSimilarity(a, b) {
   if (a.length !== b.length) {
@@ -164622,19 +165741,19 @@ function isArrayLikeNumber(value) {
   }
   return arr.length === 0 || typeof arr[0] === "number";
 }
-function toFloat32Array2(values) {
+function toFloat32Array3(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) => toFloat32Array2(entry));
+    return data.map((entry) => toFloat32Array3(entry));
   }
   if (!isArrayLikeNumber(data)) {
     log("[magic-context] embedding batch returned unexpected data shape");
     return Array.from({ length: expectedCount }, () => null);
   }
-  const flatData = toFloat32Array2(data);
+  const flatData = toFloat32Array3(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");
@@ -164649,6 +165768,7 @@ function extractBatchEmbeddings(result, expectedCount) {
 
 class LocalEmbeddingProvider {
   modelId;
+  maxInputTokens;
   model;
   pipeline = null;
   initPromise = null;
@@ -164656,8 +165776,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() {
@@ -164917,6 +166038,7 @@ function normalizeEndpoint3(endpoint) {
 
 class OpenAICompatibleEmbeddingProvider {
   modelId;
+  maxInputTokens;
   endpoint;
   model;
   apiKey;
@@ -164933,11 +166055,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() {
@@ -165181,12 +166305,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;
 }
@@ -165222,19 +166346,19 @@ 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);
   return new Set(rows.map((row) => typeof row.modelId === "string" ? row.modelId : null));
 }
-var saveStatements, loadProjectStatements, loadUnembeddedStatements, countEmbeddedStatements, clearProjectStatements, distinctModelIdStatements;
+var saveStatements, loadProjectStatements, loadUnembeddedStatements, countEmbeddedStatements, clearProjectStatements2, distinctModelIdStatements;
 var init_storage_git_commit_embeddings = __esm(() => {
   saveStatements = new WeakMap;
   loadProjectStatements = new WeakMap;
   loadUnembeddedStatements = new WeakMap;
   countEmbeddedStatements = new WeakMap;
-  clearProjectStatements = new WeakMap;
+  clearProjectStatements2 = new WeakMap;
   distinctModelIdStatements = new WeakMap;
 });
 
@@ -165360,13 +166484,90 @@ var init_sweep_coordinator = __esm(() => {
   GIT_SWEEP_LEASE_RENEWAL_MS = 60 * 1000;
 });
 
+// src/features/magic-context/session-project-storage.ts
+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;
+}
+var upsertSessionProjectStatements, repairSessionChunkProjectStatements, repairProjectChunkProjectStatements;
+var init_session_project_storage = __esm(() => {
+  upsertSessionProjectStatements = new WeakMap;
+  repairSessionChunkProjectStatements = new WeakMap;
+  repairProjectChunkProjectStatements = new WeakMap;
+});
+
 // src/features/magic-context/project-embedding-registry.ts
-import { createHash as createHash7, randomUUID } from "node:crypto";
+import { createHash as createHash9, randomUUID } from "node:crypto";
 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") {
@@ -165379,7 +166580,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" };
@@ -165397,10 +166601,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)) {
@@ -165413,7 +166618,7 @@ function stableStringify2(value) {
   return JSON.stringify(value);
 }
 function sha256Prefix(value, length = 16) {
-  return createHash7("sha256").update(value).digest("hex").slice(0, length);
+  return createHash9("sha256").update(value).digest("hex").slice(0, length);
 }
 function getRuntimeFingerprint(config2) {
   if (config2.provider === "off") {
@@ -165421,6 +166626,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: 1,
+    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;
 }
@@ -165437,7 +166654,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) {
@@ -165457,7 +166675,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;
   }
@@ -165478,6 +166696,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;
 }
@@ -165485,10 +166711,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,
@@ -165500,6 +166727,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);
@@ -165522,6 +166750,7 @@ function registerProjectInObservationMode(db, projectIdentity, sourceDirectory,
     generation,
     features: { memoryEnabled: false, gitCommitEnabled: false },
     modelId: "off",
+    chunkModelId: "off",
     observationMode: true
   };
   projectRegistrations.set(projectIdentity, registration);
@@ -165532,6 +166761,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;
@@ -165626,10 +166864,136 @@ async function embedUnembeddedMemoriesForProject(db, projectIdentity, batchSize
     return 0;
   }
 }
-var OFF_PROVIDER_IDENTITY = "embedding-provider:off", SWEEP_MAX_WALL_CLOCK_MS, projectRegistrations, loadUnembeddedMemoriesStatements, globalRegistrationGeneration = 0, testProviderFactory = null;
+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 lease2 = acquireGitSweepLease(db, projectIdentity, holderId, { ignoreCooldown: true });
+  if (!lease2.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((resolve6) => setTimeout(resolve6, 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 };
+}
+var OFF_PROVIDER_IDENTITY = "embedding-provider:off", SWEEP_MAX_WALL_CLOCK_MS, CHUNK_DRAIN_BATCH_SIZE = 8, MAX_WINDOWS_PER_EMBED_CALL = 16, SESSION_EMBED_LEASE_RENEWAL_MS, projectRegistrations, loadUnembeddedMemoriesStatements, globalRegistrationGeneration = 0, testProviderFactory = null;
 var init_project_embedding_registry = __esm(() => {
   init_magic_context();
   init_logger();
+  init_compartment_chunk_embedding();
   init_storage_git_commit_embeddings();
   init_sweep_coordinator();
   init_embedding_cache();
@@ -165637,7 +167001,9 @@ var init_project_embedding_registry = __esm(() => {
   init_embedding_local();
   init_embedding_openai();
   init_storage_memory_embeddings();
+  init_session_project_storage();
   SWEEP_MAX_WALL_CLOCK_MS = 10 * 60 * 1000;
+  SESSION_EMBED_LEASE_RENEWAL_MS = 60 * 1000;
   projectRegistrations = new Map;
   loadUnembeddedMemoriesStatements = new WeakMap;
 });
@@ -165653,10 +167019,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) {
@@ -165682,6 +167049,7 @@ var DEFAULT_EMBEDDING_CONFIG, embeddingConfig, provider = null, loadUnembeddedMe
 var init_embedding = __esm(() => {
   init_magic_context();
   init_logger();
+  init_compartment_chunk_embedding();
   init_embedding_identity();
   init_embedding_local();
   init_embedding_openai();
@@ -165705,6 +167073,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 placeholders3 = 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 (${placeholders3}) 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 uniqueProjectPaths2(projectPaths) {
+  return [...new Set(projectPaths.filter((path6) => path6.length > 0))];
+}
 function sanitizeFtsQuery(query) {
   const tokens = query.split(/\s+/).filter((token) => token.length > 0);
   if (tokens.length === 0)
@@ -165723,10 +167108,33 @@ 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);
 }
-var DEFAULT_SEARCH_LIMIT = 10, searchStatements;
+function searchMemoriesFTSUnion(db, projectPaths, query, limit = DEFAULT_SEARCH_LIMIT, ownIdentities, shareCategories) {
+  const identities = uniqueProjectPaths2(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);
+}
+var DEFAULT_SEARCH_LIMIT = 10, searchStatements, unionSearchStatements;
 var init_storage_memory_fts = __esm(() => {
   init_storage_memory();
   searchStatements = new WeakMap;
+  unionSearchStatements = new Map;
 });
 
 // src/shared/models-dev-cache.ts
@@ -165920,26 +167328,54 @@ var init_rpc_notifications = __esm(() => {
 });
 
 // src/features/magic-context/compartment-embedding.ts
-async function embedAndStoreCompartments(db, sessionId, projectPath, compartments) {
+async function embedAndStoreCompartmentChunks(db, sessionId, projectPath, compartments) {
   if (compartments.length === 0)
     return;
-  const update = db.prepare("UPDATE compartments SET p1_embedding = ?, p1_embedding_model_id = ? WHERE id = ?");
-  for (const c of compartments) {
-    if (!c.p1 || c.p1.length === 0)
-      continue;
+  const maxInputTokens = getProjectEmbeddingMaxInputTokens(projectPath);
+  for (const compartment of compartments) {
     try {
-      const result = await embedTextForProject(projectPath, c.p1);
-      if (result) {
-        const blob = Buffer.from(result.vector.buffer, result.vector.byteOffset, result.vector.byteLength);
-        update.run(blob, result.modelId, c.id);
+      const fromMemory = compartment.sourceChunkText ? canonicalizeInMemoryChunkTextForEmbedding(compartment.sourceChunkText, compartment.startMessage, compartment.endMessage) : "";
+      const canonicalText = fromMemory || buildCanonicalChunkTextFromFts(db, sessionId, compartment.startMessage, compartment.endMessage);
+      if (canonicalText.length === 0)
+        continue;
+      const windows = chunkCanonicalText(canonicalText, compartment.startMessage, compartment.endMessage, maxInputTokens);
+      if (windows.length === 0)
+        continue;
+      const currentModelId = getProjectChunkEmbeddingModelId(projectPath);
+      if (currentModelId !== "off" && chunkEmbeddingWindowsAreCurrent(db, compartment.id, currentModelId, windows, projectPath)) {
+        continue;
+      }
+      const result = await embedBatchForProject(projectPath, windows.map((window) => window.text));
+      if (!result)
+        continue;
+      if (chunkEmbeddingWindowsAreCurrent(db, compartment.id, currentModelId, windows, projectPath)) {
+        continue;
+      }
+      const rows = [];
+      for (const [index, window] of windows.entries()) {
+        const vector = result.vectors[index];
+        if (!vector)
+          continue;
+        rows.push({
+          compartmentId: compartment.id,
+          sessionId,
+          projectPath,
+          window,
+          modelId: currentModelId,
+          vector
+        });
+      }
+      if (rows.length === windows.length) {
+        replaceCompartmentChunkEmbeddings(db, rows);
       }
     } catch (error51) {
-      sessionLog(sessionId, `compartment embedding failed for compartment ${c.id}:`, error51);
+      sessionLog(sessionId, `compartment chunk embedding failed for compartment ${compartment.id}:`, error51);
     }
   }
 }
 var init_compartment_embedding = __esm(() => {
   init_logger();
+  init_compartment_chunk_embedding();
   init_project_embedding_registry();
 });
 
@@ -167053,55 +168489,6 @@ var init_historian_state_file = __esm(() => {
   init_data_path();
 });
 
-// src/features/magic-context/memory/constants.ts
-var V2_MEMORY_CATEGORIES, PROMOTABLE_CATEGORIES, CATEGORY_PRIORITY, MEMORY_CATEGORY_ORDER_UNKNOWN = 99, MEMORY_CATEGORY_ORDER_PRIORITY, MEMORY_CATEGORY_ORDER_SQL, CATEGORY_DEFAULT_TTL;
-var init_constants = __esm(() => {
-  V2_MEMORY_CATEGORIES = [
-    "PROJECT_RULES",
-    "ARCHITECTURE",
-    "CONSTRAINTS",
-    "CONFIG_VALUES",
-    "NAMING"
-  ];
-  PROMOTABLE_CATEGORIES = [
-    "PROJECT_RULES",
-    "ARCHITECTURE",
-    "CONSTRAINTS",
-    "CONFIG_VALUES",
-    "NAMING",
-    "ARCHITECTURE_DECISIONS",
-    "CONFIG_DEFAULTS",
-    "USER_PREFERENCES",
-    "USER_DIRECTIVES",
-    "ENVIRONMENT",
-    "WORKFLOW_RULES",
-    "KNOWN_ISSUES"
-  ];
-  CATEGORY_PRIORITY = [
-    "PROJECT_RULES",
-    "ARCHITECTURE",
-    "CONSTRAINTS",
-    "CONFIG_VALUES",
-    "NAMING",
-    "USER_DIRECTIVES",
-    "USER_PREFERENCES",
-    "CONFIG_DEFAULTS",
-    "ARCHITECTURE_DECISIONS",
-    "ENVIRONMENT",
-    "WORKFLOW_RULES",
-    "KNOWN_ISSUES"
-  ];
-  MEMORY_CATEGORY_ORDER_PRIORITY = CATEGORY_PRIORITY.reduce((acc, category, index) => {
-    acc[category] = index;
-    return acc;
-  }, {});
-  MEMORY_CATEGORY_ORDER_SQL = `CASE category ${CATEGORY_PRIORITY.map((category, index) => `WHEN '${category}' THEN ${index}`).join(" ")} ELSE ${MEMORY_CATEGORY_ORDER_UNKNOWN} END`;
-  CATEGORY_DEFAULT_TTL = {
-    WORKFLOW_RULES: 90 * 24 * 60 * 60 * 1000,
-    KNOWN_ISSUES: 30 * 24 * 60 * 60 * 1000
-  };
-});
-
 // src/features/magic-context/memory/embedding-backfill.ts
 async function ensureMemoryEmbeddings(args) {
   const snapshot = getProjectEmbeddingSnapshot(args.projectIdentity);
@@ -167125,7 +168512,7 @@ async function ensureMemoryEmbeddings(args) {
           continue;
         }
         saveEmbedding(args.db, memory.id, embedding, result.modelId);
-        staged.set(memory.id, embedding);
+        staged.set(memory.id, { embedding, modelId: result.modelId });
       }
     })();
     const currentSnapshot = getProjectEmbeddingSnapshot(args.projectIdentity);
@@ -167922,6 +169309,71 @@ function lastCompartmentBoundaryId(compartments) {
   const last = compartments.at(-1);
   return last?.endMessageId && last.endMessageId.length > 0 ? last.endMessageId : null;
 }
+function resolveWorkspaceRenderContext(args) {
+  if (!args.projectPath) {
+    return {
+      identities: [],
+      expandedIdentities: [],
+      ownIdentities: [],
+      shareCategories: null,
+      namesByIdentity: new Map,
+      canonicalIdentityByStoredPath: new Map,
+      isWorkspaced: false
+    };
+  }
+  const identitySet = args.workspaceIdentitySet ?? resolveWorkspaceIdentitySet(args.db, args.projectPath);
+  const isWorkspaced = identitySet.identities.length > 1;
+  const expanded = expandWorkspaceIdentitySetWithAliases(args.db, identitySet.identities);
+  const expandedIdentities = isWorkspaced ? expanded.expandedIdentities : identitySet.identities;
+  const canonicalIdentityByStoredPath = isWorkspaced ? expanded.canonicalIdentityByStoredPath : new Map(identitySet.identities.map((identity) => [identity, identity]));
+  let ownIdentities = expandedIdentities.filter((identity) => canonicalIdentityByStoredPath.get(identity) === args.projectPath);
+  if (ownIdentities.length === 0 && expandedIdentities.includes(args.projectPath)) {
+    ownIdentities = [args.projectPath];
+  }
+  return {
+    identities: identitySet.identities,
+    expandedIdentities,
+    ownIdentities,
+    shareCategories: isWorkspaced ? resolveWorkspaceShareCategories(args.db, args.projectPath) : null,
+    namesByIdentity: identitySet.namesByIdentity,
+    canonicalIdentityByStoredPath,
+    isWorkspaced
+  };
+}
+function sourceNamesForMemories(args) {
+  if (!args.projectPath || !args.workspace.isWorkspaced)
+    return;
+  const names = new Map;
+  for (const memory of args.memories) {
+    const source = sourceNameForMemory(memory.projectPath, args.projectPath, args.workspace.identities, args.workspace.namesByIdentity, args.workspace.canonicalIdentityByStoredPath);
+    if (source)
+      names.set(memory.id, source);
+  }
+  return names.size > 0 ? names : undefined;
+}
+function memoryCanonicalIdentity(memory, workspace) {
+  return resolveStoredPathWorkspaceIdentity(memory.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;
+}
 function cachedStatement(cache, db, sql) {
   let stmt = cache.get(db);
   if (!stmt) {
@@ -167964,13 +169416,19 @@ function getGlobalUserProfileVersion(db) {
 function readCurrentM0SnapshotMarkers(args) {
   const projectDirectory = args.projectDirectory ?? args.projectPath ?? "";
   const hard = args.hardSignals ?? EMPTY_HARD_SIGNALS;
+  const workspace = resolveWorkspaceRenderContext({
+    db: args.db,
+    projectPath: args.projectPath,
+    workspaceIdentitySet: args.workspaceIdentitySet
+  });
   return {
     projectMemoryEpoch: getProjectMemoryEpoch(args.db, args.projectPath),
+    workspaceFingerprint: workspace.isWorkspaced ? computeWorkspaceEpochFingerprint(args.db, workspace.identities) : null,
     projectUserProfileVersion: getGlobalUserProfileVersion(args.db),
     maxCompartmentSeq: getMaxCompartmentSeq(args.db, args.sessionId),
-    maxMemoryId: getMaxMemoryId(args.db, args.projectPath),
+    maxMemoryId: workspace.isWorkspaced ? getMaxMemoryIdForProjects(args.db, workspace.expandedIdentities, workspace.ownIdentities, workspace.shareCategories) : getMaxMemoryId(args.db, args.projectPath),
     maxMutationId: getMaxM0MutationId(args.db, args.sessionId) ?? 0,
-    maxMemoryMutationId: args.projectPath ? getMaxMemoryMutationId(args.db, args.projectPath) ?? 0 : 0,
+    maxMemoryMutationId: workspace.isWorkspaced ? getMaxMemoryMutationIdForProjects(args.db, workspace.expandedIdentities) ?? 0 : args.projectPath ? getMaxMemoryMutationId(args.db, args.projectPath) ?? 0 : 0,
     projectDocsHash: projectDirectory ? computeProjectDocsHash(projectDirectory) : "",
     materializedAt: Date.now(),
     sessionFactsVersion: getSessionFactsVersion(args.db, args.sessionId),
@@ -167998,6 +169456,7 @@ function snapshotMarkersFromCachedM0(state) {
     return null;
   return {
     projectMemoryEpoch: state.cachedM0ProjectMemoryEpoch,
+    workspaceFingerprint: state.cachedM0WorkspaceFingerprint,
     projectUserProfileVersion: state.cachedM0ProjectUserProfileVersion,
     maxCompartmentSeq: state.cachedM0MaxCompartmentSeq,
     maxMemoryId: state.cachedM0MaxMemoryId,
@@ -168027,35 +169486,27 @@ function mustMaterialize(args) {
   if (hard.cacheExpired && hard.lastResponseTime > 0 && hard.lastResponseTime > (args.state.cachedM0MaterializedAt ?? 0)) {
     return { value: true, reason: "ttl_idle" };
   }
-  if (args.state.cachedM0ProjectMemoryEpoch !== current.projectMemoryEpoch) {
+  if (current.workspaceFingerprint !== null || (args.state.cachedM0WorkspaceFingerprint ?? null) !== null) {
+    if ((args.state.cachedM0WorkspaceFingerprint ?? null) !== current.workspaceFingerprint) {
+      return { value: true, reason: "project_memory_epoch" };
+    }
+  } else if (args.state.cachedM0ProjectMemoryEpoch !== current.projectMemoryEpoch) {
     return { value: true, reason: "project_memory_epoch" };
   }
   if (args.state.cachedM0MaxMutationId !== current.maxMutationId) {
     return { value: true, reason: "max_mutation_id" };
   }
-  if ((args.state.cachedM0ProjectDocsHash ?? "") !== current.projectDocsHash) {
-    return { value: true, reason: "project_docs_hash" };
-  }
   if ((args.state.cachedM0UpgradeState ?? null) !== current.upgradeState) {
     return { value: true, reason: "upgrade_state" };
   }
   return { value: false, reason: null };
 }
-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 memory of selectionOrder) {
-    const memoryTokens = estimateTokens(renderMemoryLineV2(memory));
+    const memoryTokens = estimateTokens(renderMemoryLineV2(memory, renderOptions.sourceNameByMemoryId?.get(memory.id)));
     if (usedTokens + memoryTokens > budgetTokens)
       continue;
     selected.push(memory);
@@ -168064,16 +169515,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 = (memory) => estimateTokens(renderMemoryLineV2(memory, renderOptions.sourceNameByMemoryId?.get(memory.id)));
+  const trySelect = (memory) => {
+    if (selectedIds.has(memory.id))
+      return false;
+    const tokens = tokenCost(memory);
+    if (usedTokens + tokens > budgetTokens)
+      return false;
+    selected.push(memory);
+    selectedIds.add(memory.id);
+    usedTokens += tokens;
+    return true;
+  };
+  for (const memory of memories.filter((candidate) => candidate.status === "permanent").sort(memorySelectionOrder)) {
+    trySelect(memory);
+  }
+  const remainingAfterPermanent = Math.max(0, budgetTokens - usedTokens);
+  const floorTokens = remainingAfterPermanent / Math.max(1, workspace.identities.length);
+  const byIdentity = new Map;
+  for (const memory of memories) {
+    if (memory.status === "permanent")
+      continue;
+    const identity = memoryCanonicalIdentity(memory, workspace);
+    if (!identity)
+      continue;
+    const list = byIdentity.get(identity) ?? [];
+    list.push(memory);
+    byIdentity.set(identity, list);
+  }
+  for (const identity of workspace.identities) {
+    let memberTokens = 0;
+    const candidates = (byIdentity.get(identity) ?? []).sort(memorySelectionOrder);
+    for (const memory of candidates) {
+      if (selectedIds.has(memory.id))
+        continue;
+      const tokens = tokenCost(memory);
+      if (memberTokens + tokens > floorTokens)
+        continue;
+      if (usedTokens + tokens > budgetTokens)
+        continue;
+      selected.push(memory);
+      selectedIds.add(memory.id);
+      usedTokens += tokens;
+      memberTokens += tokens;
+    }
+  }
+  const remaining = memories.filter((memory) => !selectedIds.has(memory.id)).sort(memorySelectionOrder);
+  for (const memory of remaining) {
+    trySelect(memory);
+  }
+  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 safeGetActiveUserMemories(db) {
   try {
     return getActiveUserMemories(db);
@@ -168149,15 +169654,16 @@ function readNewMemoriesForM1(db, projectPath, afterId, expiryCutoff) {
               ORDER BY ${MEMORY_CATEGORY_ORDER_SQL}, id ASC`).all(projectPath, afterId, expiryCutoff).filter(isMemoryRow);
   return rows.map((row) => ({ ...row }));
 }
-function renderMemoryLineV2(memory) {
-  return `  <memory id="${memory.id}" category="${escapeXmlAttr(memory.category)}" importance="${memory.importance ?? 50}">${escapeXmlContent(memory.content)}</memory>`;
+function renderMemoryLineV2(memory, sourceName) {
+  const sourceAttr = sourceName ? ` source="${escapeXmlAttr(sourceName)}"` : "";
+  return `  <memory id="${memory.id}" category="${escapeXmlAttr(memory.category)}"${sourceAttr} importance="${memory.importance ?? 50}">${escapeXmlContent(memory.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 memory of memories) {
-    lines.push(renderMemoryLineV2(memory));
+    lines.push(renderMemoryLineV2(memory, renderOptions.sourceNameByMemoryId?.get(memory.id)));
   }
   lines.push(`</${wrapper}>`);
   return lines.join(`
@@ -168196,7 +169702,7 @@ function renderM0(args) {
   sections.push(sessionHistory.length > 0 ? `<session-history>
 ${sessionHistory}
 </session-history>` : M0_EMPTY_BODY);
-  const memoriesBlock = renderMemoryBlockV2(args.memories);
+  const memoriesBlock = renderMemoryBlockV2(args.memories, "project-memory", args.memoryRenderOptions);
   if (memoriesBlock)
     sections.push(memoriesBlock);
   return sections.join(`
@@ -168208,6 +169714,7 @@ function applyMarkersToState(state, m0Bytes, markers, m1Bytes) {
   if (m1Bytes)
     state.cachedM1Bytes = m1Bytes;
   state.cachedM0ProjectMemoryEpoch = markers.projectMemoryEpoch;
+  state.cachedM0WorkspaceFingerprint = markers.workspaceFingerprint;
   state.cachedM0ProjectUserProfileVersion = markers.projectUserProfileVersion;
   state.cachedM0MaxCompartmentSeq = markers.maxCompartmentSeq;
   state.cachedM0MaxMemoryId = markers.maxMemoryId;
@@ -168233,24 +169740,38 @@ function materializeM0(options) {
   let facts = [];
   let memories = [];
   let userMemories = [];
+  let workspace = resolveWorkspaceRenderContext({
+    db: options.db,
+    projectPath,
+    workspaceIdentitySet: options.workspaceIdentitySet
+  });
   let docs = {
     renderedBlock: "",
     canonicalHash: ""
   };
   options.db.exec("BEGIN");
   try {
+    workspace = resolveWorkspaceRenderContext({
+      db: options.db,
+      projectPath,
+      workspaceIdentitySet: options.workspaceIdentitySet
+    });
     snapshotMarkers = readCurrentM0SnapshotMarkers({
       db: options.db,
       sessionId: options.sessionId,
       projectPath,
       projectDirectory,
-      hardSignals: options.hardSignals
+      hardSignals: options.hardSignals,
+      workspaceIdentitySet: {
+        identities: workspace.identities,
+        namesByIdentity: workspace.namesByIdentity
+      }
     });
     docs = projectDirectory ? readProjectDocsCanonical(projectDirectory) : { renderedBlock: "", canonicalHash: "" };
     snapshotMarkers.projectDocsHash = docs.canonicalHash;
     compartments = readM0Compartments(options.db, options.sessionId);
     facts = [];
-    memories = projectPath ? getMemoriesByProject(options.db, projectPath, ["active", "permanent"]) : [];
+    memories = projectPath ? workspace.isWorkspaced ? getMemoriesByProjects(options.db, workspace.expandedIdentities, ["active", "permanent"], Date.now(), workspace.ownIdentities, workspace.shareCategories) : getMemoriesByProject(options.db, projectPath, ["active", "permanent"]) : [];
     userMemories = safeGetActiveUserMemories(options.db);
     options.db.exec("COMMIT");
   } catch (error51) {
@@ -168260,7 +169781,14 @@ function materializeM0(options) {
     throw error51;
   }
   const memoryBudget = options.memoryInjectionBudgetTokens ?? DEFAULT_MEMORY_BUDGET_TOKENS;
-  const trimmed = trimMemoriesToBudgetV2(options.sessionId, memories, memoryBudget);
+  const memoryRenderOptions = {
+    sourceNameByMemoryId: sourceNamesForMemories({
+      memories,
+      projectPath,
+      workspace
+    })
+  };
+  const trimmed = workspace.isWorkspaced ? trimWorkspaceMemoriesToBudgetV2(options.sessionId, memories, memoryBudget, workspace, memoryRenderOptions) : trimMemoriesToBudgetV2(options.sessionId, memories, memoryBudget);
   let decayPressureMultiplier = 1;
   let m0Text = renderM0({
     projectDocs: docs.renderedBlock,
@@ -168268,6 +169796,7 @@ function materializeM0(options) {
     compartments,
     memories: trimmed.renderOrder,
     facts,
+    memoryRenderOptions,
     historyBudgetTokens: options.historyBudgetTokens ?? DEFAULT_HISTORY_BUDGET_TOKENS,
     userProfileBudgetTokens: options.userProfileBudgetTokens,
     decayPressureMultiplier
@@ -168282,6 +169811,7 @@ function materializeM0(options) {
       compartments,
       memories: trimmed.renderOrder,
       facts,
+      memoryRenderOptions,
       historyBudgetTokens: budget,
       userProfileBudgetTokens: options.userProfileBudgetTokens,
       decayPressureMultiplier
@@ -168300,13 +169830,19 @@ function materializeM0(options) {
   let m1Bytes = Buffer4.from(m1Text, "utf8");
   options.db.exec("BEGIN IMMEDIATE");
   try {
+    const currentWorkspace = resolveWorkspaceRenderContext({
+      db: options.db,
+      projectPath,
+      workspaceIdentitySet: options.workspaceIdentitySet
+    });
     const current = {
       projectMemoryEpoch: getProjectMemoryEpoch(options.db, projectPath),
+      workspaceFingerprint: currentWorkspace.isWorkspaced ? computeWorkspaceEpochFingerprint(options.db, currentWorkspace.identities) : null,
       projectUserProfileVersion: getGlobalUserProfileVersion(options.db),
       maxCompartmentSeq: getMaxCompartmentSeq(options.db, options.sessionId),
-      maxMemoryId: getMaxMemoryId(options.db, projectPath),
+      maxMemoryId: currentWorkspace.isWorkspaced ? getMaxMemoryIdForProjects(options.db, currentWorkspace.expandedIdentities, currentWorkspace.ownIdentities, currentWorkspace.shareCategories) : getMaxMemoryId(options.db, projectPath),
       maxMutationId: getMaxM0MutationId(options.db, options.sessionId) ?? 0,
-      maxMemoryMutationId: projectPath ? getMaxMemoryMutationId(options.db, projectPath) ?? 0 : 0,
+      maxMemoryMutationId: currentWorkspace.isWorkspaced ? getMaxMemoryMutationIdForProjects(options.db, currentWorkspace.expandedIdentities) ?? 0 : projectPath ? getMaxMemoryMutationId(options.db, projectPath) ?? 0 : 0,
       projectDocsHash: phase3ProjectDocsHash,
       materializedAt: Date.now(),
       sessionFactsVersion: getSessionFactsVersion(options.db, options.sessionId),
@@ -168314,17 +169850,26 @@ function materializeM0(options) {
       systemHash: snapshotMarkers.systemHash,
       modelKey: snapshotMarkers.modelKey
     };
-    const stale = current.projectMemoryEpoch !== snapshotMarkers.projectMemoryEpoch || current.projectUserProfileVersion !== snapshotMarkers.projectUserProfileVersion || current.maxCompartmentSeq !== snapshotMarkers.maxCompartmentSeq || current.maxMutationId !== snapshotMarkers.maxMutationId || current.maxMemoryMutationId !== snapshotMarkers.maxMemoryMutationId || current.projectDocsHash !== snapshotMarkers.projectDocsHash || current.sessionFactsVersion !== snapshotMarkers.sessionFactsVersion || current.upgradeState !== snapshotMarkers.upgradeState;
+    const memoryEpochStale = current.workspaceFingerprint !== null || snapshotMarkers.workspaceFingerprint !== null ? current.workspaceFingerprint !== snapshotMarkers.workspaceFingerprint : current.projectMemoryEpoch !== snapshotMarkers.projectMemoryEpoch;
+    const stale = memoryEpochStale || current.projectUserProfileVersion !== snapshotMarkers.projectUserProfileVersion || current.maxCompartmentSeq !== snapshotMarkers.maxCompartmentSeq || current.maxMutationId !== snapshotMarkers.maxMutationId || current.maxMemoryMutationId !== snapshotMarkers.maxMemoryMutationId || current.sessionFactsVersion !== snapshotMarkers.sessionFactsVersion || current.upgradeState !== snapshotMarkers.upgradeState;
     if (stale) {
       options.db.exec("ROLLBACK");
       throw new MaterializeContentionError({ reason: "snapshot changed before Phase 3" });
     }
-    const m1Render = renderM1WithMetadata({ ...options, preRenderedKeyFilesBlock }, snapshotMarkers, renderedMemoryIds);
+    const m1Render = renderM1WithMetadata({
+      ...options,
+      preRenderedKeyFilesBlock,
+      workspaceIdentitySet: {
+        identities: workspace.identities,
+        namesByIdentity: workspace.namesByIdentity
+      }
+    }, snapshotMarkers, renderedMemoryIds);
     m1Text = m1Render.text;
     m1Bytes = Buffer4.from(m1Text, "utf8");
     persistCachedM0(options.db, options.sessionId, {
       m0Bytes,
       projectMemoryEpoch: snapshotMarkers.projectMemoryEpoch,
+      workspaceFingerprint: snapshotMarkers.workspaceFingerprint,
       projectUserProfileVersion: snapshotMarkers.projectUserProfileVersion,
       maxCompartmentSeq: snapshotMarkers.maxCompartmentSeq,
       maxMemoryId: snapshotMarkers.maxMemoryId,
@@ -168387,7 +169932,7 @@ function renderMemoryUpdatesBlock(args) {
     return { block: "", count: 0 };
   }
   const renderedIds = new Set(args.renderedMemoryIds);
-  const mutations = getMemoryMutationsForRender(args.db, args.projectPath, args.afterId, args.renderedMemoryIds);
+  const mutations = args.workspace.isWorkspaced ? getMemoryMutationsForRenderByProjects(args.db, args.workspace.expandedIdentities, args.afterId, args.renderedMemoryIds) : getMemoryMutationsForRender(args.db, args.projectPath, args.afterId, args.renderedMemoryIds);
   if (mutations.length === 0)
     return { block: "", count: 0 };
   const lines = ["These memories changed since the snapshot below — trust these:"];
@@ -168419,12 +169964,18 @@ function renderM1WithMetadata(options, markers, renderedMemoryIds) {
     throw new RenderM1InvalidMarkersError(options.sessionId);
   }
   const blocks = [];
+  const workspace = resolveWorkspaceRenderContext({
+    db: options.db,
+    projectPath: options.projectPath,
+    workspaceIdentitySet: options.workspaceIdentitySet
+  });
   const keyFiles = renderedKeyFilesBlock(options);
   if (keyFiles)
     blocks.push(keyFiles);
   const memoryUpdates = renderMemoryUpdatesBlock({
     db: options.db,
     projectPath: options.projectPath,
+    workspace,
     afterId: markers.maxMemoryMutationId,
     renderedMemoryIds
   });
@@ -168438,9 +169989,16 @@ ${newCompartments.map((compartment) => renderCompartmentAtTier(compartment, 1)).
 `)}
 </new-compartments>`);
   }
-  const newMemories = readNewMemoriesForM1(options.db, options.projectPath, markers.maxMemoryId, markers.materializedAt);
-  const trimmedNewMemories = trimMemoriesToBudgetV2(options.sessionId, newMemories, Math.max(1, Math.floor((options.memoryInjectionBudgetTokens ?? DEFAULT_MEMORY_BUDGET_TOKENS) * 0.25))).renderOrder;
-  const newMemoriesBlock = renderMemoryBlockV2(trimmedNewMemories, "new-memories");
+  const newMemories = workspace.isWorkspaced ? readNewMemoriesForM1Union(options.db, workspace.expandedIdentities, markers.maxMemoryId, markers.materializedAt, workspace.ownIdentities, workspace.shareCategories) : readNewMemoriesForM1(options.db, options.projectPath, markers.maxMemoryId, markers.materializedAt);
+  const newMemoryRenderOptions = {
+    sourceNameByMemoryId: sourceNamesForMemories({
+      memories: newMemories,
+      projectPath: options.projectPath,
+      workspace
+    })
+  };
+  const trimmedNewMemories = trimMemoriesToBudgetV2(options.sessionId, newMemories, Math.max(1, Math.floor((options.memoryInjectionBudgetTokens ?? DEFAULT_MEMORY_BUDGET_TOKENS) * 0.25)), newMemoryRenderOptions).renderOrder;
+  const newMemoriesBlock = renderMemoryBlockV2(trimmedNewMemories, "new-memories", newMemoryRenderOptions);
   if (newMemoriesBlock)
     blocks.push(newMemoriesBlock);
   const currentUserProfileVersion = getGlobalUserProfileVersion(options.db);
@@ -168488,6 +170046,7 @@ function parseMemoryBlockIds(raw) {
 function readCachedM0M1Row(db, sessionId) {
   return db.prepare(`SELECT 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,
@@ -168522,6 +170081,7 @@ function markersFromCachedRow(row) {
     return null;
   return {
     projectMemoryEpoch: row.cached_m0_project_memory_epoch,
+    workspaceFingerprint: row.cached_m0_workspace_fingerprint,
     projectUserProfileVersion: row.cached_m0_project_user_profile_version,
     maxCompartmentSeq: row.cached_m0_max_compartment_seq,
     maxMemoryId: row.cached_m0_max_memory_id,
@@ -168536,7 +170096,7 @@ function markersFromCachedRow(row) {
   };
 }
 function cachedRowMatchesState(row, state) {
-  return bufferEqualsNullable(row.cached_m0_bytes, state.cachedM0Bytes) && row.cached_m0_project_memory_epoch === state.cachedM0ProjectMemoryEpoch && row.cached_m0_project_user_profile_version === state.cachedM0ProjectUserProfileVersion && row.cached_m0_max_compartment_seq === state.cachedM0MaxCompartmentSeq && row.cached_m0_max_memory_id === state.cachedM0MaxMemoryId && row.cached_m0_max_mutation_id === state.cachedM0MaxMutationId && row.cached_m0_max_memory_mutation_id === state.cachedM0MaxMemoryMutationId && (row.cached_m0_project_docs_hash ?? "") === (state.cachedM0ProjectDocsHash ?? "") && row.cached_m0_materialized_at === state.cachedM0MaterializedAt && row.cached_m0_session_facts_version === state.cachedM0SessionFactsVersion && (row.cached_m0_upgrade_state ?? null) === (state.cachedM0UpgradeState ?? null) && (row.cached_m0_system_hash ?? "") === (state.cachedM0SystemHash ?? "") && (row.cached_m0_model_key ?? "") === (state.cachedM0ModelKey ?? "");
+  return bufferEqualsNullable(row.cached_m0_bytes, state.cachedM0Bytes) && row.cached_m0_project_memory_epoch === state.cachedM0ProjectMemoryEpoch && (row.cached_m0_workspace_fingerprint ?? null) === (state.cachedM0WorkspaceFingerprint ?? null) && row.cached_m0_project_user_profile_version === state.cachedM0ProjectUserProfileVersion && row.cached_m0_max_compartment_seq === state.cachedM0MaxCompartmentSeq && row.cached_m0_max_memory_id === state.cachedM0MaxMemoryId && row.cached_m0_max_mutation_id === state.cachedM0MaxMutationId && row.cached_m0_max_memory_mutation_id === state.cachedM0MaxMemoryMutationId && row.cached_m0_materialized_at === state.cachedM0MaterializedAt && row.cached_m0_session_facts_version === state.cachedM0SessionFactsVersion && (row.cached_m0_upgrade_state ?? null) === (state.cachedM0UpgradeState ?? null) && (row.cached_m0_system_hash ?? "") === (state.cachedM0SystemHash ?? "") && (row.cached_m0_model_key ?? "") === (state.cachedM0ModelKey ?? "");
 }
 function applyCachedRowToState(state, row) {
   const markers = markersFromCachedRow(row);
@@ -168546,6 +170106,7 @@ function applyCachedRowToState(state, row) {
   state.cachedM0Bytes = toBuffer(row.cached_m0_bytes);
   state.cachedM1Bytes = toBuffer(row.cached_m1_bytes);
   state.cachedM0ProjectMemoryEpoch = markers.projectMemoryEpoch;
+  state.cachedM0WorkspaceFingerprint = markers.workspaceFingerprint;
   state.cachedM0ProjectUserProfileVersion = markers.projectUserProfileVersion;
   state.cachedM0MaxCompartmentSeq = markers.maxCompartmentSeq;
   state.cachedM0MaxMemoryId = markers.maxMemoryId;
@@ -168609,20 +170170,36 @@ function prependM0M1Messages(sessionId, messages, m0Text, m1Text) {
 function renderFreshM0NonPersisted(options) {
   const projectPath = options.projectPath;
   const projectDirectory = options.projectDirectory;
+  const workspace = resolveWorkspaceRenderContext({
+    db: options.db,
+    projectPath,
+    workspaceIdentitySet: options.workspaceIdentitySet
+  });
   const snapshotMarkers = readCurrentM0SnapshotMarkers({
     db: options.db,
     sessionId: options.sessionId,
     projectPath,
-    projectDirectory
+    projectDirectory,
+    workspaceIdentitySet: {
+      identities: workspace.identities,
+      namesByIdentity: workspace.namesByIdentity
+    }
   });
   const docs = projectDirectory ? readProjectDocsCanonical(projectDirectory) : { renderedBlock: "", canonicalHash: "" };
   snapshotMarkers.projectDocsHash = docs.canonicalHash;
   snapshotMarkers.materializedAt = options.state.cachedM0MaterializedAt ?? 0;
   const compartments = readM0Compartments(options.db, options.sessionId);
-  const memories = projectPath ? getMemoriesByProject(options.db, projectPath, ["active", "permanent"], snapshotMarkers.materializedAt) : [];
+  const memories = projectPath ? workspace.isWorkspaced ? getMemoriesByProjects(options.db, workspace.expandedIdentities, ["active", "permanent"], snapshotMarkers.materializedAt, workspace.ownIdentities, workspace.shareCategories) : getMemoriesByProject(options.db, projectPath, ["active", "permanent"], snapshotMarkers.materializedAt) : [];
   const userMemories = safeGetActiveUserMemories(options.db);
   const memoryBudget = options.memoryInjectionBudgetTokens ?? DEFAULT_MEMORY_BUDGET_TOKENS;
-  const trimmed = trimMemoriesToBudgetV2(options.sessionId, memories, memoryBudget);
+  const memoryRenderOptions = {
+    sourceNameByMemoryId: sourceNamesForMemories({
+      memories,
+      projectPath,
+      workspace
+    })
+  };
+  const trimmed = workspace.isWorkspaced ? trimWorkspaceMemoriesToBudgetV2(options.sessionId, memories, memoryBudget, workspace, memoryRenderOptions) : trimMemoriesToBudgetV2(options.sessionId, memories, memoryBudget);
   const budget = options.historyBudgetTokens ?? DEFAULT_HISTORY_BUDGET_TOKENS;
   let decayPressureMultiplier = 1;
   let m0Text = renderM0({
@@ -168631,6 +170208,7 @@ function renderFreshM0NonPersisted(options) {
     compartments,
     memories: trimmed.renderOrder,
     facts: [],
+    memoryRenderOptions,
     historyBudgetTokens: budget,
     userProfileBudgetTokens: options.userProfileBudgetTokens,
     decayPressureMultiplier
@@ -168644,6 +170222,7 @@ function renderFreshM0NonPersisted(options) {
       compartments,
       memories: trimmed.renderOrder,
       facts: [],
+      memoryRenderOptions,
       historyBudgetTokens: budget,
       userProfileBudgetTokens: options.userProfileBudgetTokens,
       decayPressureMultiplier
@@ -168659,6 +170238,12 @@ function renderFreshM0NonPersisted(options) {
   };
 }
 function injectM0M1(options) {
+  if (!options.workspaceIdentitySet && options.projectPath) {
+    options = {
+      ...options,
+      workspaceIdentitySet: resolveWorkspaceIdentitySet(options.db, options.projectPath)
+    };
+  }
   const skipped = {
     injected: false,
     m0RematerializedThisPass: false,
@@ -168675,7 +170260,8 @@ function injectM0M1(options) {
     state: options.state,
     projectPath: options.projectPath,
     projectDirectory: options.projectDirectory,
-    hardSignals: options.hardSignals
+    hardSignals: options.hardSignals,
+    workspaceIdentitySet: options.workspaceIdentitySet
   });
   let rematerialized = false;
   let contentionExhausted = false;
@@ -168769,6 +170355,7 @@ var init_inject_compartments = __esm(async () => {
   init_compartment_storage();
   init_constants();
   init_storage_memory();
+  init_workspaces();
   init_logger();
   init_decay_render();
   init_key_files_block();
@@ -171908,18 +173495,38 @@ async function runCompartmentAgent(deps) {
       return;
     }
     const offset = priorCompartments.length > 0 ? priorCompartments[priorCompartments.length - 1].endMessage + 1 : 1;
-    const boundarySnapshot = deps.boundarySnapshot ?? null;
+    let boundarySnapshot = deps.boundarySnapshot ?? null;
     if (!boundarySnapshot) {
       telemetry.failureReason = "missing protected-tail boundary snapshot";
       sessionLog(sessionId, "historian no-op: missing protected-tail boundary snapshot from trigger decision");
       rollbackDrainReservation();
       return;
     }
-    const validation = boundarySnapshot.rawRangeFingerprint.length > 0 ? validateBoundarySnapshot({
+    let validation = boundarySnapshot.rawRangeFingerprint.length > 0 ? validateBoundarySnapshot({
       db,
       snapshot: boundarySnapshot,
       currentContextLimit: deps.currentContextLimit ?? boundarySnapshot.contextLimit
     }) : { ok: true };
+    if (!validation.ok && validation.reason === "stale_snapshot") {
+      const refreshed = resolveOpenCodeProtectedTailBoundary({
+        db,
+        sessionId,
+        mode: "incremental-runner",
+        contextLimit: deps.currentContextLimit ?? boundarySnapshot.contextLimit,
+        executeThresholdPercentage: boundarySnapshot.executeThresholdPercentage,
+        usage: {
+          percentage: boundarySnapshot.usagePercentage,
+          inputTokens: boundarySnapshot.usageInputTokens
+        },
+        usageSource: boundarySnapshot.usageSource,
+        emergencyTailScale: boundarySnapshot.emergencyTailScale
+      });
+      if (hasRunnableCompartmentWindow(refreshed)) {
+        sessionLog(sessionId, `historian: refreshed stale protected-tail snapshot at run time (was: ${validation.detail ?? "stale"}) — eligible head ${refreshed.offset}-${refreshed.eligibleEndOrdinal - 1}`);
+        boundarySnapshot = refreshed;
+        validation = { ok: true };
+      }
+    }
     if (!validation.ok) {
       sessionLog(sessionId, `historian no-op: stale protected-tail snapshot (${validation.detail ?? validation.reason ?? "unknown"})`);
       telemetry.status = "noop";
@@ -171988,6 +173595,7 @@ async function runCompartmentAgent(deps) {
       rollbackDrainReservation();
       return;
     }
+    deps.onHistorianRunStarted?.();
     const projectPath = resolveProjectIdentity(directory ?? process.cwd());
     const memories = getMemoriesByProject(db, projectPath, ["active", "permanent"]);
     const projectMemory = renderMemoryBlock(memories) ?? "";
@@ -172120,8 +173728,13 @@ ${chunkText}`,
     }
     if (embeddingActive) {
       const projectIdentity = resolveProjectIdentity(promotionDirectory);
-      const toEmbed = persistedCompartments.map((c, i) => ({ id: persistedIds[i], p1: c.p1 ?? c.content })).filter((c) => typeof c.id === "number" && c.p1.length > 0);
-      embedAndStoreCompartments(db, sessionId, projectIdentity, toEmbed);
+      const chunksToEmbed = persistedCompartments.map((c, i) => ({
+        id: persistedIds[i],
+        startMessage: c.startMessage,
+        endMessage: c.endMessage,
+        sourceChunkText: chunk.text
+      })).filter((c) => typeof c.id === "number");
+      embedAndStoreCompartmentChunks(db, sessionId, projectIdentity, chunksToEmbed);
     }
     queueDropsForCompartmentalizedMessages(db, sessionId, lastCompartmentEnd);
     deps.onCompartmentStatePublished?.(sessionId);
@@ -172352,8 +173965,12 @@ Found ${existingStaging.compartments.length} staged compartment(s) from ${existi
         const projectIdentity = resolveProjectIdentity(sessionDirectory);
         await deps.ensureProjectRegistered?.(sessionDirectory, db);
         const liveCompartments = getCompartments(db, sessionId);
-        const toEmbed = liveCompartments.map((c) => ({ id: c.id, p1: c.p1 ?? c.content })).filter((c) => typeof c.id === "number" && c.p1.length > 0);
-        embedAndStoreCompartments(db, sessionId, projectIdentity, toEmbed);
+        const chunksToEmbed = liveCompartments.map((c) => ({
+          id: c.id,
+          startMessage: c.startMessage,
+          endMessage: c.endMessage
+        }));
+        embedAndStoreCompartmentChunks(db, sessionId, projectIdentity, chunksToEmbed);
       }
       const lastCompartmentEnd2 = promoted2.compartments[promoted2.compartments.length - 1]?.endMessage ?? 0;
       if (lastCompartmentEnd2 > 0) {
@@ -172566,8 +174183,12 @@ Another process acquired the compartment-state lease before recomp could publish
       const projectIdentity = resolveProjectIdentity(sessionDirectory);
       await deps.ensureProjectRegistered?.(sessionDirectory, db);
       const liveCompartments = getCompartments(db, sessionId);
-      const toEmbed = liveCompartments.map((c) => ({ id: c.id, p1: c.p1 ?? c.content })).filter((c) => typeof c.id === "number" && c.p1.length > 0);
-      embedAndStoreCompartments(db, sessionId, projectIdentity, toEmbed);
+      const chunksToEmbed = liveCompartments.map((c) => ({
+        id: c.id,
+        startMessage: c.startMessage,
+        endMessage: c.endMessage
+      }));
+      embedAndStoreCompartmentChunks(db, sessionId, projectIdentity, chunksToEmbed);
     }
     if (lastCompartmentEnd > 0) {
       const markerUpdated = updateCompactionMarkerAfterPublication(db, sessionId, lastCompartmentEnd, deps.directory);
@@ -172748,8 +174369,12 @@ Could not acquire the compartment-state lease for this session.`;
       if (deps.memoryEnabled !== false) {
         const projectIdentity = resolveProjectIdentity(sessionDirectory);
         const liveCompartments = getCompartments(db, sessionId);
-        const toEmbed = liveCompartments.map((c) => ({ id: c.id, p1: c.p1 ?? c.content })).filter((c) => typeof c.id === "number" && c.p1.length > 0);
-        Promise.resolve(deps.ensureProjectRegistered?.(sessionDirectory, db)).then(() => embedAndStoreCompartments(db, sessionId, projectIdentity, toEmbed));
+        const chunksToEmbed = liveCompartments.map((c) => ({
+          id: c.id,
+          startMessage: c.startMessage,
+          endMessage: c.endMessage
+        }));
+        Promise.resolve(deps.ensureProjectRegistered?.(sessionDirectory, db)).then(() => embedAndStoreCompartmentChunks(db, sessionId, projectIdentity, chunksToEmbed));
       }
       const lastEnd = merged[merged.length - 1]?.endMessage ?? snapEnd;
       if (lastEnd > 0) {
@@ -174971,7 +176596,14 @@ function startCompartmentAgent(deps) {
     return;
   }
   const renewal = startLeaseRenewal(deps, holderId);
-  const runnerDeps = withPublishedCallback({ ...deps, compartmentLeaseHolderId: holderId });
+  let realRunStarted = false;
+  const runnerDeps = withPublishedCallback({
+    ...deps,
+    compartmentLeaseHolderId: holderId,
+    onHistorianRunStarted: () => {
+      realRunStarted = true;
+    }
+  });
   const promise2 = runCompartmentAgent(runnerDeps).catch((err) => {
     sessionLog(deps.sessionId, "compartment agent: unhandled rejection:", err);
     try {
@@ -174985,6 +176617,9 @@ function startCompartmentAgent(deps) {
     }
   });
   activeRuns.set(deps.sessionId, { promise: promise2, published: false });
+  if (!realRunStarted && activeRuns.get(deps.sessionId)?.promise === promise2) {
+    activeRuns.delete(deps.sessionId);
+  }
 }
 async function executeContextRecompWithResult(deps, options = {}) {
   const { sessionId } = deps;
@@ -175119,7 +176754,7 @@ function applyMemoryMigration(db, projectPath, result) {
       inserted++;
     }
     if (removed > 0 || inserted > 0) {
-      bumpProjectMemoryEpoch(db, projectPath);
+      bumpEpochsForWorkspaceMembers(db, projectPath);
     }
   })();
   return { removed, inserted };
@@ -175577,15 +177212,15 @@ function shouldShowAnnouncement() {
   }
   return state.version !== ANNOUNCEMENT_VERSION;
 }
-var ANNOUNCEMENT_VERSION = "0.23.0", ANNOUNCEMENT_FEATURES, ANNOUNCEMENT_FOOTER = "Join us on Discord: https://discord.gg/F2uWxjGnU", STATE_FILENAME = "last_announced_version";
+var ANNOUNCEMENT_VERSION = "0.24.0", ANNOUNCEMENT_FEATURES, ANNOUNCEMENT_FOOTER = "Join us on Discord: https://discord.gg/F2uWxjGnU", STATE_FILENAME = "last_announced_version";
 var init_announcement = __esm(() => {
   init_data_path();
   ANNOUNCEMENT_FEATURES = [
-    "Smarter context nudges: gentle <system-reminder> notes on tool outputs replace the old chat nudges — quieter, cache-safe, and they now also help subagents manage their own context.",
-    "The agent can now maintain its own project memories: update, archive (batch), and merge the memories it sees — not just write new ones. Memory categories are schema-enforced.",
-    "Big-session performance: historian trigger and token math moved off the database hot path — multi-second stalls on large sessions are gone (measured 250ms → 2.4ms per pass).",
-    "History compaction unstuck for sparse sessions: the protected-tail boundary is now size-based, so sessions with few user turns compact reliably instead of growing forever (issue #132).",
-    "Fixed: session titles no longer fail to generate in fresh directories (issue #129), plus 20+ correctness fixes from three audit rounds."
+    "Searchable session history: ctx_search can now find older discussion by meaning, not just keywords. New history is embedded automatically — to backfill an EXISTING session's older history, run /ctx-embed-history once (it works in the background).",
+    "Cross-project workspaces: group related repos and share project memories across them, with per-category control over what's shared. Set them up in the dashboard's Workspaces panel.",
+    "Pi: fixed sessions overflowing the model context while still showing moderate usage — Pi now sheds context before a tool-heavy turn overflows.",
+    "Fewer prompt-cache busts: doc edits, processed screenshots, and a rebuild-then-bust-again case no longer re-bill large prompt prefixes.",
+    "Setup wizard now lists your actual models with type-ahead instead of fixed recommendations, and explains the historian/dreamer roles (issue #144). Plus a GitHub Copilot tool-pairing fix (#135)."
   ];
 });
 // src/agents/permissions.ts
@@ -176313,6 +177948,10 @@ function getMagicContextBuiltinCommands() {
     "ctx-dream": {
       template: "ctx-dream",
       description: "Run the hidden dreamer maintenance pass for this project now"
+    },
+    "ctx-embed-history": {
+      template: "ctx-embed-history",
+      description: "Embed all of this session's history compartments for semantic search, in one pass"
     }
   };
 }
@@ -176806,7 +178445,7 @@ await init_storage_db();
 // src/features/magic-context/v22-deferred-backfill.ts
 init_logger();
 init_project_identity();
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 import { realpathSync as realpathSync2 } from "node:fs";
 import path5 from "node:path";
 var BATCH_SIZE = 25;
@@ -176860,7 +178499,7 @@ function computeLegacyRustDirIdentity(rawProjectPath) {
   } catch {
     canonical = path5.isAbsolute(rawProjectPath) ? rawProjectPath : path5.join(process.cwd(), rawProjectPath);
   }
-  return `dir:${createHash5("sha256").update(canonical, "utf8").digest("hex")}`;
+  return `dir:${createHash6("sha256").update(canonical, "utf8").digest("hex")}`;
 }
 function upsertRekeyMap(db, oldProjectPath, newProjectPath, rekeyedAt) {
   db.prepare(`INSERT INTO v22_identity_rekey_map (old_project_path, new_project_path, rekeyed_at)
@@ -179401,7 +181040,7 @@ init_project_identity();
 // src/plugin/embedding-bootstrap-helpers.ts
 init_embedding();
 init_logger();
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 var EMBEDDING_AFFECTING_KEYS = new Set([
   "embedding.api_key",
   "embedding.endpoint",
@@ -179422,7 +181061,7 @@ var EMBEDDING_WARNING_TERMS = [
 ];
 var loggedFailureSignatures = new Map;
 function sha256Prefix2(value, length = 16) {
-  return createHash8("sha256").update(value).digest("hex").slice(0, length);
+  return createHash10("sha256").update(value).digest("hex").slice(0, length);
 }
 function warningLooksEmbeddingRelated(message) {
   const lower = message.toLowerCase();
@@ -180058,6 +181697,7 @@ function createTagger() {
 // src/hooks/magic-context/hook.ts
 init_magic_context();
 init_project_identity();
+init_project_embedding_registry();
 await init_storage();
 init_logger();
 init_resolve_fallbacks();
@@ -180651,6 +182291,7 @@ function createMagicContextCommandHandler(deps) {
   const isAugCommand = (command) => command === "ctx-aug";
   const isDreamCommand = (command) => command === "ctx-dream";
   const isSessionUpgradeCommand = (command) => command === "ctx-session-upgrade";
+  const isEmbedHistoryCommand = (command) => command === "ctx-embed-history";
   return {
     "command.execute.before": async (input, _output, _params) => {
       const isStatus = isStatusCommand(input.command);
@@ -180659,7 +182300,8 @@ function createMagicContextCommandHandler(deps) {
       const isAug = isAugCommand(input.command);
       const isDream = isDreamCommand(input.command);
       const isSessionUpgrade = isSessionUpgradeCommand(input.command);
-      if (!isStatus && !isFlush && !isRecomp && !isAug && !isDream && !isSessionUpgrade) {
+      const isEmbedHistory = isEmbedHistoryCommand(input.command);
+      if (!isStatus && !isFlush && !isRecomp && !isAug && !isDream && !isSessionUpgrade && !isEmbedHistory) {
         return;
       }
       const sessionId = input.sessionID;
@@ -180672,6 +182314,11 @@ function createMagicContextCommandHandler(deps) {
         await executeDreaming(deps, sessionId);
         return;
       }
+      if (isEmbedHistory) {
+        const summary = deps.executeEmbedHistory ? await deps.executeEmbedHistory(sessionId) : "Semantic embedding is not configured for this project, so there is nothing to embed.";
+        await deps.sendNotification(sessionId, summary, {});
+        throwSentinel(input.command);
+      }
       if (isFlush) {
         result = executeFlush(deps.db, sessionId);
         clearCachedM0M1(deps.db, sessionId);
@@ -181412,6 +183059,7 @@ await init_read_session_chunk();
 // src/hooks/magic-context/transform.ts
 init_project_identity();
 import * as crypto2 from "node:crypto";
+init_session_project_storage();
 init_storage_meta_persisted();
 init_logger();
 await init_storage();
@@ -182012,6 +183660,7 @@ await __promiseAll([
   init_read_session_chunk(),
   init_read_session_db()
 ]);
+
 // src/hooks/magic-context/sentinel.ts
 var WHOLE_MESSAGE_PLACEHOLDER_TEXT = "[dropped]";
 function modelAcceptsEmptyContent(providerID) {
@@ -182069,7 +183718,6 @@ function replaySentinelByMessageIds(messages, ids, providerID) {
       missingIds.push(id);
   return { replayed, missingIds };
 }
-
 // src/hooks/magic-context/strip-content.ts
 var DROPPED_PLACEHOLDER_PATTERN = /^\[dropped §\d+§\]$/;
 var TAG_PREFIX_PATTERN = /^§\d+§\s*/;
@@ -182422,8 +184070,10 @@ function stripReasoningFromMergedAssistants(messages, providerID) {
   }
   return stripped;
 }
-function stripProcessedImages(messages, watermark, messageTagNumbers) {
+function stripProcessedImages(messages, frozenIds, options) {
+  const { detect, watermark, messageTagNumbers } = options;
   let stripped = 0;
+  const newlyStrippedIds = [];
   let hasAssistantResponse = false;
   for (let i = messages.length - 1;i >= 0; i--) {
     const msg = messages[i];
@@ -182431,13 +184081,17 @@ function stripProcessedImages(messages, watermark, messageTagNumbers) {
       hasAssistantResponse = true;
       continue;
     }
-    if (msg.info.role !== "user" || !hasAssistantResponse) {
+    if (msg.info.role !== "user") {
       continue;
     }
+    const id = typeof msg.info.id === "string" ? msg.info.id : undefined;
+    const inFrozen = id !== undefined && frozenIds.has(id);
     const maxTag = messageTagNumbers.get(msg) ?? 0;
-    if (maxTag > watermark) {
+    const isNewDetection = !inFrozen && detect && hasAssistantResponse && id !== undefined && maxTag <= watermark;
+    if (!inFrozen && !isNewDetection) {
       continue;
     }
+    let touchedThisMsg = false;
     for (let j = 0;j < msg.parts.length; j++) {
       const part = msg.parts[j];
       if (!isRecord(part) || part.type !== "file") {
@@ -182449,10 +184103,14 @@ function stripProcessedImages(messages, watermark, messageTagNumbers) {
       if (typeof part.url === "string" && part.url.startsWith("data:") && part.url.length > 200) {
         msg.parts[j] = makeSentinel(part);
         stripped++;
+        touchedThisMsg = true;
       }
     }
+    if (touchedThisMsg && isNewDetection && id !== undefined) {
+      newlyStrippedIds.push(id);
+    }
   }
-  return stripped;
+  return { stripped, newlyStrippedIds };
 }
 
 // src/hooks/magic-context/transform.ts
@@ -183395,6 +185053,7 @@ init_embedding();
 
 // src/features/magic-context/search.ts
 init_logger();
+init_compartment_chunk_embedding();
 
 // src/features/magic-context/literal-probes.ts
 var MAX_PROBES = 5;
@@ -183456,6 +185115,7 @@ function containsProbeVerbatim(text, probes) {
 init_memory();
 init_embedding();
 init_storage_memory_fts();
+init_workspaces();
 var DEFAULT_UNIFIED_SEARCH_LIMIT = 10;
 var FTS_SEMANTIC_CANDIDATE_LIMIT = 50;
 var SEMANTIC_WEIGHT = 0.7;
@@ -183485,6 +185145,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(memory, workspace) {
+  return resolveStoredPathWorkspaceIdentity(memory.projectPath, workspace.identities, workspace.canonicalIdentityByStoredPath);
+}
+function sourceNamesForSearchMemories(args) {
+  if (!args.workspace.isWorkspaced)
+    return;
+  const sourceNames = new Map;
+  for (const memory of args.memories) {
+    const source = sourceNameForMemory(memory.projectPath, args.projectPath, args.workspace.identities, args.workspace.namesByIdentity, args.workspace.canonicalIdentityByStoredPath);
+    if (source)
+      sourceNames.set(memory.id, source);
+  }
+  return sourceNames.size > 0 ? sourceNames : undefined;
+}
 function getMessageSearchStatement(db) {
   let stmt = messageSearchStatements.get(db);
   if (!stmt) {
@@ -183493,6 +185184,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;
@@ -183508,25 +185223,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 memory of args.memories) {
+      const memoryEmbedding = embeddings.get(memory.id);
+      if (!memoryEmbedding) {
+        continue;
+      }
+      semanticScores.set(memory.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 memory of args.memories) {
-    const memoryEmbedding = embeddings.get(memory.id);
-    if (!memoryEmbedding) {
+    const identity = memoryWorkspaceIdentity(memory, workspace);
+    if (!identity)
       continue;
+    const list = memoriesByIdentity.get(identity) ?? [];
+    list.push(memory);
+    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 memory of memberMemories) {
+      const memoryEmbedding = cachedEmbeddings.get(memory.id);
+      if (!memoryEmbedding || memoryEmbedding.modelId !== args.queryModelId)
+        continue;
+      semanticScores.set(memory.id, normalizeCosineScore(cosineSimilarity(args.queryEmbedding, memoryEmbedding.embedding)));
     }
-    semanticScores.set(memory.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 [];
@@ -183540,8 +185293,11 @@ function selectSemanticCandidates(args) {
     return args.memories;
   }
   const candidateIds = new Set(args.ftsMatches.map((memory) => memory.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);
     }
@@ -183583,7 +185339,8 @@ function mergeMemoryResults(args) {
       score,
       memoryId: memory.id,
       category: memory.category,
-      matchType
+      matchType,
+      sourceName: args.sourceNameByMemoryId?.get(memory.id)
     });
   }
   return results.sort((left, right) => {
@@ -183597,7 +185354,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 [];
   }
@@ -183605,26 +185362,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) {
@@ -183655,7 +185429,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;
@@ -183672,20 +185452,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;
@@ -183695,26 +185486,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;
@@ -183732,6 +185604,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;
   }
@@ -183782,10 +185657,12 @@ async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
   const isEmbeddingRuntimeEnabled = options.isEmbeddingRuntimeEnabled ?? isEmbeddingEnabled;
   const gitCommitsEnabled = options.gitCommitsEnabled ?? false;
   const activeSources = resolveSources(options.sources);
-  const runMemory = activeSources.has("memory") && (options.memoryEnabled ?? true);
+  const memoryFeatureEnabled = options.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, options.signal).catch((error51) => {
     log(`[search] query embedding failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
     return null;
@@ -183801,6 +185678,24 @@ async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
     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: options.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,
@@ -183809,6 +185704,8 @@ async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
       limit: tierLimit,
       memoryEnabled: true,
       queryEmbedding,
+      queryModelId: embeddingModelId && embeddingModelId !== "off" ? embeddingModelId : null,
+      workspace,
       visibleMemoryIds: options.visibleMemoryIds
     }) : Promise.resolve([]),
     runGitCommits ? Promise.resolve(searchGitCommits({
@@ -183819,7 +185716,7 @@ async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
       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 = options.countRetrievals ?? true;
   if (countRetrievals) {
     const memoryIds = results.filter((result) => result.source === "memory").map((result) => result.memoryId);
@@ -183883,6 +185780,11 @@ function renderFragment(result, charCap) {
       const compressed = cavemanCompress(result.content, "ultra");
       return truncate(compressed, charCap);
     }
+    case "compartment": {
+      const source = result.snippet ?? result.title;
+      const compressed = cavemanCompress(source, "ultra");
+      return truncate(compressed, charCap);
+    }
   }
 }
 function buildAutoSearchHint(results, options = {}) {
@@ -184523,7 +186425,7 @@ function isVisibleNoteReadPart(part) {
 }
 
 // src/hooks/magic-context/todo-view.ts
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash11 } from "node:crypto";
 var TERMINAL_STATUSES = new Set(["completed", "cancelled"]);
 var TITLE_DONE_STATUSES = new Set(["completed"]);
 var SYNTHETIC_CALL_ID_PREFIX = "mc_synthetic_todo_";
@@ -184568,7 +186470,7 @@ function buildSyntheticTodoPart(stateJson) {
   };
 }
 function computeSyntheticCallId(stateJson) {
-  const hash2 = createHash9("sha256").update(stateJson).digest("hex").slice(0, 16);
+  const hash2 = createHash11("sha256").update(stateJson).digest("hex").slice(0, 16);
   return `${SYNTHETIC_CALL_ID_PREFIX}${hash2}`;
 }
 function parseTodoState(stateJson) {
@@ -184619,15 +186521,25 @@ async function runPostTransformPhase(args) {
   const emergencyBypassCompartmentGate = forceMaterialization;
   const deferredMaterialize = args.canConsumeDeferredLate && deferredMaterializationWasPending;
   const materializationRequested = isExplicitFlush || deferredMaterialize;
-  const shouldReadPendingOps = materializationRequested || args.schedulerDecision === "execute" || forceMaterialization || compartmentRunning;
+  const m0M1EnabledForFold = args.fullFeatureMode && args.m0M1 !== undefined && (!!args.m0M1.projectPath || !!args.m0M1.projectDirectory);
+  const m0HardFoldThisPass = m0M1EnabledForFold && args.m0M1 ? mustMaterialize({
+    db: args.db,
+    sessionId: args.sessionId,
+    state: args.sessionMeta,
+    projectPath: args.m0M1.projectPath,
+    projectDirectory: args.m0M1.projectDirectory,
+    hardSignals: args.m0M1.hardSignals
+  }).value : false;
+  const shouldReadPendingOps = materializationRequested || args.schedulerDecision === "execute" || forceMaterialization || m0HardFoldThisPass || compartmentRunning;
   const pendingOps = shouldReadPendingOps ? getPendingOps(args.db, args.sessionId) : [];
   const hasPendingUserOps = pendingOps.length > 0;
-  const shouldApplyPendingOps = (args.schedulerDecision === "execute" || materializationRequested || forceMaterialization) && (!compartmentRunning || emergencyBypassCompartmentGate);
-  const shouldRunHeuristics = (!compartmentRunning || emergencyBypassCompartmentGate) && (materializationRequested || forceMaterialization || emergencyDropEligible || args.schedulerDecision === "execute" && (!alreadyRanThisTurn || !args.fullFeatureMode));
+  const shouldApplyPendingOps = (args.schedulerDecision === "execute" || materializationRequested || forceMaterialization || m0HardFoldThisPass) && (!compartmentRunning || emergencyBypassCompartmentGate);
+  const shouldRunHeuristics = (!compartmentRunning || emergencyBypassCompartmentGate) && (materializationRequested || forceMaterialization || m0HardFoldThisPass || emergencyDropEligible || args.schedulerDecision === "execute" && (!alreadyRanThisTurn || !args.fullFeatureMode));
   const isCacheBustingPass = shouldApplyPendingOps || shouldRunHeuristics;
+  const canUseEmptySentinels = modelAcceptsEmptyContent(args.resolvedProviderID);
   if (shouldRunHeuristics) {
     const subagentRerun = !args.fullFeatureMode && alreadyRanThisTurn && args.schedulerDecision === "execute" && !isExplicitFlush && !forceMaterialization;
-    const reason = isExplicitFlush ? "explicit_flush" : deferredMaterialize ? "deferred_materialization" : forceMaterialization ? `force_materialization (${args.contextUsage.percentage.toFixed(1)}% >= ${args.forceMaterializationPercentage}%)` : subagentRerun ? `scheduler_execute_subagent_rerun (pendingOps=${pendingOps.length}, scheduler=${args.schedulerDecision})` : `scheduler_execute (pendingOps=${pendingOps.length}, scheduler=${args.schedulerDecision})`;
+    const reason = isExplicitFlush ? "explicit_flush" : deferredMaterialize ? "deferred_materialization" : forceMaterialization ? `force_materialization (${args.contextUsage.percentage.toFixed(1)}% >= ${args.forceMaterializationPercentage}%)` : m0HardFoldThisPass && args.schedulerDecision !== "execute" ? `m0_hard_fold (drain folded into known m[0] bust, scheduler=${args.schedulerDecision})` : subagentRerun ? `scheduler_execute_subagent_rerun (pendingOps=${pendingOps.length}, scheduler=${args.schedulerDecision})` : `scheduler_execute (pendingOps=${pendingOps.length}, scheduler=${args.schedulerDecision})`;
     sessionLog(args.sessionId, `heuristics WILL RUN — reason=${reason}, context=${args.contextUsage.percentage.toFixed(1)}%, turn=${args.currentTurnId}`);
   }
   if (alreadyRanThisTurn && args.schedulerDecision === "execute" && !materializationRequested && args.fullFeatureMode) {
@@ -184670,7 +186582,9 @@ async function runPostTransformPhase(args) {
       logTransformTiming(args.sessionId, "applyHeuristicCleanup", t5, `droppedTools=${cleanup.droppedTools} deduplicatedTools=${cleanup.deduplicatedTools} droppedInjections=${cleanup.droppedInjections} compressedTextTags=${cleanup.compressedTextTags}`);
       const t7 = performance.now();
       const clearedReasoning = clearOldReasoning(args.messages, args.reasoningByMessage, args.messageTagNumbers, args.clearReasoningAge);
-      stripClearedReasoning(args.messages);
+      if (canUseEmptySentinels) {
+        stripClearedReasoning(args.messages);
+      }
       const strippedInline = stripInlineThinking(args.messages, args.messageTagNumbers, args.clearReasoningAge);
       if (clearedReasoning > 0 || strippedInline > 0) {
         let maxTag = 0;
@@ -184716,7 +186630,6 @@ async function runPostTransformPhase(args) {
     if (args.watermark > 0) {
       const tWatermarkCleanup = performance.now();
       truncateErroredTools(args.messages, args.watermark, args.messageTagNumbers);
-      stripProcessedImages(args.messages, args.watermark, args.messageTagNumbers);
       logTransformTiming(args.sessionId, "watermarkCleanup", tWatermarkCleanup);
     }
     if (shouldApplyPendingOps) {
@@ -184726,21 +186639,40 @@ async function runPostTransformPhase(args) {
     sessionLog(args.sessionId, "transform failed applying pending operations:", error51);
     updateSessionMeta(args.db, args.sessionId, { lastTransformError: getErrorMessage(error51) });
   }
-  try {
-    const t8 = performance.now();
-    const frozenStaleReduceIds = getStaleReduceStrippedIds(args.db, args.sessionId);
-    const staleReduceResult = dropStaleReduceCalls(args.messages, frozenStaleReduceIds, {
-      detect: isCacheBustingPass,
-      protectedCount: args.protectedTags
-    });
-    if (isCacheBustingPass && staleReduceResult.newlyStrippedIds.length > 0) {
-      addStaleReduceStrippedIds(args.db, args.sessionId, staleReduceResult.newlyStrippedIds);
+  if (canUseEmptySentinels) {
+    try {
+      const t8 = performance.now();
+      const frozenStaleReduceIds = getStaleReduceStrippedIds(args.db, args.sessionId);
+      const staleReduceResult = dropStaleReduceCalls(args.messages, frozenStaleReduceIds, {
+        detect: isCacheBustingPass,
+        protectedCount: args.protectedTags
+      });
+      if (isCacheBustingPass && staleReduceResult.newlyStrippedIds.length > 0) {
+        addStaleReduceStrippedIds(args.db, args.sessionId, staleReduceResult.newlyStrippedIds);
+      }
+      logTransformTiming(args.sessionId, "dropStaleReduceCalls", t8);
+    } catch (error51) {
+      sessionLog(args.sessionId, "transform failed dropping stale ctx_reduce calls:", error51);
+    }
+  }
+  if (canUseEmptySentinels && args.watermark > 0) {
+    try {
+      const tImg = performance.now();
+      const frozenImageIds = getProcessedImageStrippedIds(args.db, args.sessionId);
+      const imageResult = stripProcessedImages(args.messages, frozenImageIds, {
+        detect: isCacheBustingPass,
+        watermark: args.watermark,
+        messageTagNumbers: args.messageTagNumbers
+      });
+      if (isCacheBustingPass && imageResult.newlyStrippedIds.length > 0) {
+        addProcessedImageStrippedIds(args.db, args.sessionId, imageResult.newlyStrippedIds);
+      }
+      logTransformTiming(args.sessionId, "stripProcessedImages", tImg);
+    } catch (error51) {
+      sessionLog(args.sessionId, "transform failed stripping processed images:", error51);
     }
-    logTransformTiming(args.sessionId, "dropStaleReduceCalls", t8);
-  } catch (error51) {
-    sessionLog(args.sessionId, "transform failed dropping stale ctx_reduce calls:", error51);
   }
-  const m0M1Enabled = args.fullFeatureMode && args.m0M1 !== undefined && (!!args.m0M1.projectPath || !!args.m0M1.projectDirectory);
+  const m0M1Enabled = m0M1EnabledForFold;
   if (m0M1Enabled && args.m0M1) {
     const tInjectM0M1 = performance.now();
     try {
@@ -184787,7 +186719,7 @@ async function runPostTransformPhase(args) {
     const tPlaceholder = performance.now();
     const persistedIds = getStrippedPlaceholderIds(args.db, args.sessionId);
     if (persistedIds.size > 0) {
-      const { replayed, missingIds } = replaySentinelByMessageIds(args.messages, persistedIds, args.liveProviderID);
+      const { replayed, missingIds } = replaySentinelByMessageIds(args.messages, persistedIds, args.resolvedProviderID);
       if (replayed > 0) {
         sessionLog(args.sessionId, `sentinel replay: neutralized ${replayed} previously-stripped messages`);
       }
@@ -184798,9 +186730,9 @@ async function runPostTransformPhase(args) {
       }
     }
     if (isCacheBustingPass) {
-      const droppedResult = stripDroppedPlaceholderMessages(args.messages, args.liveProviderID);
+      const droppedResult = stripDroppedPlaceholderMessages(args.messages, args.resolvedProviderID);
       const protectedTailStart = Math.max(0, args.messages.length - args.protectedTags * 2);
-      const systemInjectedResult = stripSystemInjectedMessages(args.messages, protectedTailStart, args.liveProviderID);
+      const systemInjectedResult = stripSystemInjectedMessages(args.messages, protectedTailStart, args.resolvedProviderID);
       const newlyNeutralized = droppedResult.sentineledIds.length + systemInjectedResult.sentineledIds.length;
       if (newlyNeutralized > 0) {
         const addedIds = [
@@ -185000,6 +186932,7 @@ function clearMessageTokensCache(sessionId, messageId) {
   if (cache)
     cache.delete(messageId);
 }
+var recordedSessionProjectIdentity = new BoundedSessionMap(MESSAGE_TOKENS_CACHE_MAX);
 function findLastAssistantModel2(messages) {
   for (let i = messages.length - 1;i >= 0; i--) {
     const info = messages[i].info;
@@ -185047,9 +186980,11 @@ function createTransform(deps) {
     const fullFeatureMode = !reducedMode;
     const ctxReduceEnabledEffective = deps.ctxReduceEnabled !== false && resolveCtxReduceAvailabilityFromMessages(sessionId, messages);
     let sessionDirectory = deps.directory ?? "";
+    let sessionDirectoryResolvedFromHost = false;
     const cachedDirectory = deps.sessionDirectoryBySession?.get(sessionId);
     if (cachedDirectory && cachedDirectory.length > 0) {
       sessionDirectory = cachedDirectory;
+      sessionDirectoryResolvedFromHost = true;
     } else if (deps.client !== undefined) {
       try {
         const sessionResponse = await deps.client.session.get({ path: { id: sessionId } }).catch(() => null);
@@ -185057,6 +186992,7 @@ function createTransform(deps) {
         if (sessionInfo && typeof sessionInfo.directory === "string" && sessionInfo.directory.length > 0) {
           sessionDirectory = sessionInfo.directory;
           deps.sessionDirectoryBySession?.set(sessionId, sessionDirectory);
+          sessionDirectoryResolvedFromHost = true;
         }
       } catch {}
     }
@@ -185151,6 +187087,8 @@ function createTransform(deps) {
         deps.liveModelBySession?.set(sessionId, recovered);
       }
     }
+    const resolvedProviderID = modelForBudget?.providerID;
+    const canUseEmptySentinels = modelAcceptsEmptyContent(resolvedProviderID);
     const resolvedContextLimit = modelForBudget ? resolveTrustedContextLimit(modelForBudget.providerID, modelForBudget.modelID, {
       db,
       sessionID: sessionId
@@ -185315,6 +187253,10 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
     logTransformTiming(sessionId, "emergencyRecoveryBlock", tFirstPass);
     const projectIdentity = deps.memoryConfig?.enabled ? resolveProjectIdentity(compartmentDirectory || process.cwd()) : undefined;
     const sessionProjectIdentity = projectIdentity ?? (sessionDirectory ? resolveProjectIdentity(sessionDirectory) : deps.projectPath);
+    if (sessionProjectIdentity && sessionDirectoryResolvedFromHost && recordedSessionProjectIdentity.get(sessionId) !== sessionProjectIdentity) {
+      recordSessionProjectIdentity(db, sessionId, sessionProjectIdentity);
+      recordedSessionProjectIdentity.set(sessionId, sessionProjectIdentity);
+    }
     let triggerBoundarySnapshot;
     if (fullFeatureMode && historianRunnable && !sessionMeta.compartmentInProgress) {
       const tTrigger = performance.now();
@@ -185409,7 +187351,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       }
     }
     const t3 = performance.now();
-    const strippedStructuralNoise = stripStructuralNoise(messages);
+    const strippedStructuralNoise = canUseEmptySentinels ? stripStructuralNoise(messages) : 0;
     logTransformTiming(sessionId, "stripStructuralNoise", t3, `strippedParts=${strippedStructuralNoise}`);
     const persistedReasoningWatermark = sessionMeta?.clearedReasoningThroughTag ?? 0;
     if (persistedReasoningWatermark > 0) {
@@ -185430,18 +187372,10 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       logTransformTiming(sessionId, "replayCavemanCompression", tCavemanReplay);
     }
     const t4 = performance.now();
-    const strippedClearedReasoning = stripClearedReasoning(messages);
+    const strippedClearedReasoning = canUseEmptySentinels ? stripClearedReasoning(messages) : 0;
     logTransformTiming(sessionId, "stripClearedReasoning", t4, `strippedParts=${strippedClearedReasoning}`);
     const tMergeStrip = performance.now();
-    let liveProviderID = deps.liveModelBySession?.get(sessionId)?.providerID;
-    if (liveProviderID === undefined) {
-      const recovered = findLastAssistantModelFromOpenCodeDb(sessionId);
-      if (recovered) {
-        liveProviderID = recovered.providerID;
-        deps.liveModelBySession?.set(sessionId, recovered);
-      }
-    }
-    const strippedMergedReasoning = stripReasoningFromMergedAssistants(messages, liveProviderID);
+    const strippedMergedReasoning = stripReasoningFromMergedAssistants(messages, resolvedProviderID);
     if (strippedMergedReasoning > 0) {
       sessionLog(sessionId, `stripped ${strippedMergedReasoning} reasoning parts from merged assistants (anthropic groupIntoBlocks workaround)`);
     }
@@ -185560,7 +187494,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       sessionDirectory,
       autoSearch: deps.autoSearch,
       cavemanTextCompression: deps.ctxReduceEnabled === false && !reducedMode ? deps.cavemanTextCompression : undefined,
-      liveProviderID,
+      resolvedProviderID,
       historyRefreshSessions: deps.historyRefreshSessions,
       m0M1: {
         projectPath: projectIdentity,
@@ -186413,7 +188347,7 @@ function createToolExecuteAfterHook(args) {
 init_send_session_notification();
 
 // src/hooks/magic-context/system-prompt-hash.ts
-import { createHash as createHash10 } from "node:crypto";
+import { createHash as createHash12 } from "node:crypto";
 
 // src/agents/magic-context-prompt.ts
 var LONG_TERM_PARTNER_FRAME = `### You are the user's long-term partner on this project — not a one-off hire
@@ -186613,7 +188547,7 @@ function createSystemPromptHashHandler(deps) {
 `);
     if (systemContent.length === 0)
       return;
-    const currentHash = createHash10("md5").update(systemContent).digest("hex");
+    const currentHash = createHash12("md5").update(systemContent).digest("hex");
     if (!sessionMetaEarly) {
       return;
     }
@@ -186874,6 +188808,46 @@ function createMagicContextHook(deps) {
     ensureProjectRegistered: ensureProjectRegisteredFromOpenCodeDirectory,
     getNotificationParams: (sid) => getLiveNotificationParams(sid, liveModelBySession, variantBySession, agentBySession)
   });
+  const executeEmbedHistory = async (sessionId) => {
+    if (deps.config.memory?.enabled === false) {
+      return "Memory is disabled for this project, so there is no semantic embedding to backfill.";
+    }
+    const directory = sessionDirectoryBySession.get(sessionId) ?? deps.directory;
+    await ensureProjectRegisteredFromOpenCodeDirectory(directory, db);
+    const sessionProjectIdentity = resolveProjectIdentity(directory);
+    setRecompStarting({ recompProgressBySession }, sessionId, "Embedding history…", "embed");
+    const outcome = await embedSessionCompartmentChunks(db, sessionProjectIdentity, sessionId, {
+      onProgress: ({ embedded, total }) => {
+        const cur = recompProgressBySession.get(sessionId);
+        if (!cur || cur.phase !== "recomp")
+          return;
+        recompProgressBySession.set(sessionId, {
+          ...cur,
+          processedMessages: embedded,
+          totalMessages: total,
+          updatedAt: Date.now()
+        });
+      }
+    });
+    const terminal = (phase, message) => {
+      setRecompTerminal({ recompProgressBySession }, sessionId, phase, message);
+      return message;
+    };
+    switch (outcome.status) {
+      case "nothing":
+        return terminal("done", "All of this session's history is already embedded.");
+      case "disabled":
+        return terminal("skipped", "No embedding provider is configured, so there is nothing to embed.");
+      case "busy":
+        return terminal("skipped", `Embedding is already running for this project — ${outcome.total} compartment${outcome.total === 1 ? "" : "s"} still pending. Try again shortly.`);
+      case "aborted":
+        return terminal("done", `Embedded ${outcome.embedded} of ${outcome.total} compartments before stopping.`);
+      case "stalled":
+        return terminal("skipped", `Embedded ${outcome.embedded} compartments; ${outcome.remaining} could not be embedded (the provider returned no result). Run /ctx-embed-history again to retry them.`);
+      default:
+        return terminal("done", `Embedded ${outcome.embedded} compartment${outcome.embedded === 1 ? "" : "s"} of history for semantic search.`);
+    }
+  };
   const sidekickRunnable = isSidekickRunnable(deps.config);
   const sidekickConfig = sidekickRunnable ? deps.config.sidekick : undefined;
   const transform2 = createTransform({
@@ -187028,6 +189002,7 @@ function createMagicContextHook(deps) {
     },
     executeRecomp: historianRunnable ? async (sessionId, options) => runManagedRecomp(buildManagedRecompCtx(sessionId), sessionId, options) : undefined,
     runUpgrade: historianRunnable ? async (sessionId) => runManagedUpgrade(buildManagedRecompCtx(sessionId), sessionId) : undefined,
+    executeEmbedHistory,
     sendNotification: async (sessionId, text, params) => {
       await sendIgnoredMessage(deps.client, sessionId, text, {
         ...getLiveNotificationParams(sessionId, liveModelBySession, variantBySession, agentBySession),
@@ -188166,6 +190141,7 @@ init_memory();
 init_embedding();
 init_embedding_cache();
 init_normalize_hash();
+init_workspaces();
 init_logger();
 await init_storage();
 import { tool as tool2 } from "@opencode-ai/plugin";
@@ -188325,6 +190301,23 @@ function createCtxMemoryTool(deps) {
       }
       const projectPath = deps.resolveProjectPath(toolContext.directory);
       await deps.ensureProjectRegistered?.(toolContext.directory, deps.db);
+      const workspaceIdentitySet = resolveWorkspaceIdentitySet(deps.db, projectPath);
+      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) ?? projectIdentityForStoredPath(rawProjectPath) : projectIdentityForStoredPath(rawProjectPath);
+      const toolShareCategories = workspaceIdentitySet.identities.length > 1 ? resolveWorkspaceShareCategories(deps.db, projectPath) : null;
+      const memoryVisibleToTool = (memory) => {
+        if (workspaceIdentitySet.identities.length <= 1) {
+          return memoryBelongsToProject(memory, projectPath);
+        }
+        if (!storedPathBelongsToWorkspace(memory.projectPath, workspaceIdentitySet.identities, workspaceVisibleIdentities, expandedWorkspace.canonicalIdentityByStoredPath)) {
+          return false;
+        }
+        const isOwn = targetIdentityForStoredPath(memory.projectPath) === projectPath;
+        if (isOwn)
+          return true;
+        return toolShareCategories === null || toolShareCategories.includes(memory.category);
+      };
       const embeddingSnapshot = getProjectEmbeddingSnapshot(projectPath);
       if (embeddingSnapshot ? !embeddingSnapshot.features.memoryEnabled : deps.memoryEnabled === false) {
         return getDisabledMessage();
@@ -188381,18 +190374,18 @@ function createCtxMemoryTool(deps) {
         }
         const rawProjectPath = projectPathForMemoryId(deps.db, updateId);
         const memory = getMemoryById(deps.db, updateId);
-        if (!memory || !rawProjectPath || !memoryBelongsToProject(memory, projectPath)) {
+        if (!memory || !rawProjectPath || !memoryVisibleToTool(memory)) {
           return `Error: Memory with ID ${updateId} was not found.`;
         }
         if (toolContext.agent !== DREAMER_AGENT && !isPrimaryMutableMemory(memory)) {
           return inactiveMemoryError(updateId, "updating");
         }
         const normalizedHash = computeNormalizedHash(content);
-        const duplicate = getMemoryByHash(deps.db, projectPath, memory.category, normalizedHash);
+        const duplicate = getMemoryByHash(deps.db, targetIdentityForStoredPath(rawProjectPath), memory.category, normalizedHash);
         if (duplicate && duplicate.id !== memory.id) {
           return `Error: Memory content already exists as ID ${duplicate.id}; merge or archive duplicates instead.`;
         }
-        const projectIdentity = projectIdentityForStoredPath(rawProjectPath);
+        const projectIdentity = targetIdentityForStoredPath(rawProjectPath);
         deps.db.transaction(() => {
           updateMemoryContentInCurrentTransaction(deps.db, memory, content, normalizedHash);
           queueMemoryMutation(deps.db, {
@@ -188406,7 +190399,7 @@ function createCtxMemoryTool(deps) {
         queueMemoryEmbedding({
           deps,
           sessionId: toolContext.sessionID,
-          projectPath,
+          projectPath: projectIdentity,
           memoryId: memory.id,
           content
         });
@@ -188429,7 +190422,7 @@ function createCtxMemoryTool(deps) {
           return "Error: One or more source memories were not found.";
         }
         if (toolContext.agent !== DREAMER_AGENT) {
-          const foreign = sourceMemories.find((memory) => !memoryBelongsToProject(memory, projectPath));
+          const foreign = sourceMemories.find((memory) => !memoryVisibleToTool(memory));
           if (foreign) {
             return `Error: Memory with ID ${foreign.id} was not found.`;
           }
@@ -188513,15 +190506,16 @@ function createCtxMemoryTool(deps) {
         return `Merged memories [${ids.join(", ")}] into canonical memory [ID: ${canonicalMemory.id}] in ${category}; superseded [${supersededIds.join(", ")}].`;
       }
       if (args.action === "archive") {
-        const archiveIds = args.ids;
-        if (!archiveIds || archiveIds.length === 0 || !archiveIds.every(Number.isInteger)) {
+        const rawArchiveIds = args.ids;
+        if (!rawArchiveIds || rawArchiveIds.length === 0 || !rawArchiveIds.every(Number.isInteger)) {
           return "Error: 'ids' must contain at least one integer memory ID when action is 'archive'.";
         }
+        const archiveIds = [...new Set(rawArchiveIds)];
         const targets = [];
         for (const memoryId of archiveIds) {
           const rawProjectPath = projectPathForMemoryId(deps.db, memoryId);
           const memory = getMemoryById(deps.db, memoryId);
-          if (!memory || !rawProjectPath || !memoryBelongsToProject(memory, projectPath)) {
+          if (!memory || !rawProjectPath || !memoryVisibleToTool(memory)) {
             return `Error: Memory with ID ${memoryId} was not found.`;
           }
           if (toolContext.agent !== DREAMER_AGENT && !isPrimaryMutableMemory(memory)) {
@@ -188529,7 +190523,7 @@ function createCtxMemoryTool(deps) {
           }
           targets.push({
             memoryId,
-            projectIdentity: projectIdentityForStoredPath(rawProjectPath)
+            projectIdentity: targetIdentityForStoredPath(rawProjectPath)
           });
         }
         deps.db.transaction(() => {
@@ -189003,8 +190997,9 @@ function formatAge2(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(`
 `);
@@ -189014,6 +191009,13 @@ function formatResult(result, index) {
       `[${index}] [git_commit] score=${result.score.toFixed(2)} sha=${result.shortSha} ${formatAge2(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);
@@ -189029,7 +191031,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(`
@@ -189187,11 +191189,11 @@ import { createServer } from "node:http";
 import { dirname as dirname5 } from "node:path";
 
 // src/shared/rpc-utils.ts
-import { createHash as createHash11 } from "node:crypto";
+import { createHash as createHash13 } from "node:crypto";
 import { join as join20 } from "node:path";
 function projectHash(directory) {
   const normalized = directory.replace(/\/+$/, "");
-  return createHash11("sha256").update(normalized).digest("hex").slice(0, 16);
+  return createHash13("sha256").update(normalized).digest("hex").slice(0, 16);
 }
 function rpcPortDir(storageDir, directory) {
   return join20(storageDir, "rpc", projectHash(directory));