@wolfx/pi-magic-context 0.23.1 → 0.24.1

package/dist/index.js

@@ -141961,6 +141961,7 @@ var SESSION_META_SELECT_COLUMNS = [
   "cached_m0_bytes",
   "cached_m1_bytes",
   "cached_m0_project_memory_epoch",
+  "cached_m0_workspace_fingerprint",
   "cached_m0_project_user_profile_version",
   "cached_m0_max_compartment_seq",
   "cached_m0_max_memory_id",
@@ -142008,6 +142009,7 @@ var META_COLUMNS = {
   cachedM0Bytes: "cached_m0_bytes",
   cachedM1Bytes: "cached_m1_bytes",
   cachedM0ProjectMemoryEpoch: "cached_m0_project_memory_epoch",
+  cachedM0WorkspaceFingerprint: "cached_m0_workspace_fingerprint",
   cachedM0ProjectUserProfileVersion: "cached_m0_project_user_profile_version",
   cachedM0MaxCompartmentSeq: "cached_m0_max_compartment_seq",
   cachedM0MaxMemoryId: "cached_m0_max_memory_id",
@@ -142037,6 +142039,7 @@ var NULL_BIND_META_KEYS = new Set([
   "cachedM0Bytes",
   "cachedM1Bytes",
   "cachedM0ProjectMemoryEpoch",
+  "cachedM0WorkspaceFingerprint",
   "cachedM0ProjectUserProfileVersion",
   "cachedM0MaxCompartmentSeq",
   "cachedM0MaxMemoryId",
@@ -142070,7 +142073,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 {
@@ -142097,6 +142100,7 @@ function getDefaultSessionMeta(sessionId) {
     cachedM0Bytes: null,
     cachedM1Bytes: null,
     cachedM0ProjectMemoryEpoch: null,
+    cachedM0WorkspaceFingerprint: null,
     cachedM0ProjectUserProfileVersion: null,
     cachedM0MaxCompartmentSeq: null,
     cachedM0MaxMemoryId: null,
@@ -142159,6 +142163,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),
@@ -142189,6 +142194,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 = ?,
@@ -142201,7 +142207,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);
@@ -142210,6 +142216,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],
@@ -142924,7 +142931,7 @@ var databases = new Map;
 var persistenceByDatabase = new WeakMap;
 var persistenceErrorByDatabase = new WeakMap;
 var lastSchemaFenceRejection = null;
-var LATEST_SUPPORTED_VERSION = 32;
+var LATEST_SUPPORTED_VERSION = 36;
 function resolveDatabasePath(dbPathOverride) {
   if (dbPathOverride) {
     return { dbDir: dirname2(dbPathOverride), dbPath: dbPathOverride };
@@ -143090,6 +143097,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,
@@ -143275,6 +143311,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,
@@ -143386,6 +143441,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,
@@ -143544,6 +143600,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");
@@ -143597,6 +143654,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");
@@ -143628,6 +143686,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,
@@ -143655,6 +143722,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,
@@ -143676,6 +143760,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);
@@ -143714,6 +143799,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", ""],
@@ -143758,7 +143844,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();
@@ -143835,10 +143921,291 @@ function openDatabase(dbPathOrOptions) {
   }
 }
 
+// ../plugin/src/features/magic-context/workspaces.ts
+import { createHash as createHash3 } from "node:crypto";
+
+// ../plugin/src/features/magic-context/memory/constants.ts
+var V2_MEMORY_CATEGORIES = [
+  "PROJECT_RULES",
+  "ARCHITECTURE",
+  "CONSTRAINTS",
+  "CONFIG_VALUES",
+  "NAMING"
+];
+var PROMOTABLE_CATEGORIES = [
+  "PROJECT_RULES",
+  "ARCHITECTURE",
+  "CONSTRAINTS",
+  "CONFIG_VALUES",
+  "NAMING",
+  "ARCHITECTURE_DECISIONS",
+  "CONFIG_DEFAULTS",
+  "USER_PREFERENCES",
+  "USER_DIRECTIVES",
+  "ENVIRONMENT",
+  "WORKFLOW_RULES",
+  "KNOWN_ISSUES"
+];
+var CATEGORY_PRIORITY = [
+  "PROJECT_RULES",
+  "ARCHITECTURE",
+  "CONSTRAINTS",
+  "CONFIG_VALUES",
+  "NAMING",
+  "USER_DIRECTIVES",
+  "USER_PREFERENCES",
+  "CONFIG_DEFAULTS",
+  "ARCHITECTURE_DECISIONS",
+  "ENVIRONMENT",
+  "WORKFLOW_RULES",
+  "KNOWN_ISSUES"
+];
+var MEMORY_CATEGORY_ORDER_UNKNOWN = 99;
+var MEMORY_CATEGORY_ORDER_PRIORITY = CATEGORY_PRIORITY.reduce((acc, category, index) => {
+  acc[category] = index;
+  return acc;
+}, {});
+var MEMORY_CATEGORY_ORDER_SQL = `CASE category ${CATEGORY_PRIORITY.map((category, index) => `WHEN '${category}' THEN ${index}`).join(" ")} ELSE ${MEMORY_CATEGORY_ORDER_UNKNOWN} END`;
+var CATEGORY_DEFAULT_TTL = {
+  WORKFLOW_RULES: 90 * 24 * 60 * 60 * 1000,
+  KNOWN_ISSUES: 30 * 24 * 60 * 60 * 1000
+};
+// ../plugin/src/features/magic-context/workspaces.ts
+var VALID_SHARE_CATEGORIES = new Set(V2_MEMORY_CATEGORIES);
+function tableExists(db, tableName) {
+  const row = db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name = ? LIMIT 1").get(tableName);
+  return Boolean(row);
+}
+function columnExists(db, tableName, columnName) {
+  const rows = db.prepare(`PRAGMA table_info(${tableName})`).all();
+  return rows.some((row) => row.name === columnName);
+}
+function uniqueSorted(values) {
+  return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+function placeholders(values) {
+  return values.map(() => "?").join(", ");
+}
+function normalizeShareCategories(raw) {
+  if (raw === null || raw === undefined)
+    return null;
+  if (typeof raw !== "string")
+    return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(parsed))
+    return null;
+  const categories = [];
+  for (const value of parsed) {
+    if (typeof value !== "string" || !VALID_SHARE_CATEGORIES.has(value)) {
+      return null;
+    }
+    if (!categories.includes(value))
+      categories.push(value);
+  }
+  return categories.sort((left, right) => left.localeCompare(right));
+}
+function selectWorkspaceShareCategories(db, identities) {
+  const candidates = uniqueSorted(identities.filter((identity) => identity.length > 0));
+  if (candidates.length === 0 || !tableExists(db, "workspace_members") || !tableExists(db, "workspaces") || !columnExists(db, "workspaces", "share_categories")) {
+    return null;
+  }
+  const row = db.prepare(`SELECT workspace.share_categories AS shareCategories
+               FROM workspace_members AS member
+               JOIN workspaces AS workspace ON workspace.id = member.workspace_id
+              WHERE member.project_path IN (${placeholders(candidates)})
+              ORDER BY workspace.id ASC
+              LIMIT 1`).get(...candidates);
+  return normalizeShareCategories(row?.shareCategories ?? null);
+}
+function resolveWorkspaceShareCategories(db, projectIdentity) {
+  return selectWorkspaceShareCategories(db, [projectIdentity]);
+}
+function resolveWorkspaceIdentitySet(db, projectIdentity) {
+  if (!tableExists(db, "workspace_members")) {
+    return { identities: [projectIdentity], namesByIdentity: new Map };
+  }
+  const rows = db.prepare(`SELECT member.project_path AS identity, member.display_name AS displayName
+               FROM workspace_members AS anchor
+               JOIN workspace_members AS member ON member.workspace_id = anchor.workspace_id
+              WHERE anchor.project_path = ?
+              ORDER BY member.display_name ASC, member.project_path ASC`).all(projectIdentity);
+  if (rows.length === 0) {
+    return { identities: [projectIdentity], namesByIdentity: new Map };
+  }
+  const namesByIdentity = new Map;
+  const identities = [];
+  for (const row of rows) {
+    if (typeof row.identity !== "string" || row.identity.length === 0)
+      continue;
+    if (identities.includes(row.identity))
+      continue;
+    identities.push(row.identity);
+    if (typeof row.displayName === "string" && row.displayName.length > 0) {
+      namesByIdentity.set(row.identity, row.displayName);
+    }
+  }
+  return identities.length > 0 ? { identities, namesByIdentity } : { identities: [projectIdentity], namesByIdentity: new Map };
+}
+function expandWorkspaceIdentitySetWithAliases(db, identities) {
+  const canonical = uniqueSorted(identities.filter((identity) => identity.length > 0));
+  const expanded = new Set(canonical);
+  const canonicalIdentityByStoredPath = new Map;
+  for (const identity of canonical) {
+    canonicalIdentityByStoredPath.set(identity, identity);
+  }
+  if (canonical.length === 0 || !tableExists(db, "v22_identity_rekey_map")) {
+    return { expandedIdentities: [...expanded], canonicalIdentityByStoredPath };
+  }
+  const rows = db.prepare(`SELECT old_project_path AS oldProjectPath, new_project_path AS newProjectPath
+               FROM v22_identity_rekey_map
+              WHERE new_project_path IN (${placeholders(canonical)})
+              ORDER BY old_project_path ASC`).all(...canonical);
+  for (const row of rows) {
+    if (typeof row.oldProjectPath !== "string" || typeof row.newProjectPath !== "string") {
+      continue;
+    }
+    if (!canonicalIdentityByStoredPath.has(row.newProjectPath))
+      continue;
+    expanded.add(row.oldProjectPath);
+    canonicalIdentityByStoredPath.set(row.oldProjectPath, row.newProjectPath);
+  }
+  return { expandedIdentities: [...expanded], canonicalIdentityByStoredPath };
+}
+function resolveStoredPathWorkspaceIdentity(storedProjectPath, memberIdentities, canonicalIdentityByStoredPath) {
+  const direct = canonicalIdentityByStoredPath.get(storedProjectPath);
+  if (direct)
+    return direct;
+  const normalized = normalizeStoredProjectPath(storedProjectPath);
+  const normalizedDirect = canonicalIdentityByStoredPath.get(normalized);
+  if (normalizedDirect)
+    return normalizedDirect;
+  if (memberIdentities.includes(normalized))
+    return normalized;
+  for (const identity of memberIdentities) {
+    if (storedPathBelongsToIdentity(storedProjectPath, identity)) {
+      return identity;
+    }
+  }
+  return null;
+}
+function storedPathBelongsToWorkspace(storedProjectPath, memberIdentities, expandedIdentities, canonicalIdentityByStoredPath) {
+  if (expandedIdentities.includes(storedProjectPath))
+    return true;
+  return resolveStoredPathWorkspaceIdentity(storedProjectPath, memberIdentities, canonicalIdentityByStoredPath) !== null;
+}
+function sourceNameForMemory(storedProjectPath, ownIdentity, memberIdentities, namesByIdentity, canonicalIdentityByStoredPath) {
+  const canonicalIdentity = resolveStoredPathWorkspaceIdentity(storedProjectPath, memberIdentities, canonicalIdentityByStoredPath);
+  if (!canonicalIdentity || canonicalIdentity === ownIdentity)
+    return;
+  return namesByIdentity.get(canonicalIdentity);
+}
+function getEpochMap(db, identities) {
+  if (identities.length === 0)
+    return new Map;
+  const rows = db.prepare(`SELECT project_path AS projectPath, project_memory_epoch AS epoch
+               FROM project_state
+              WHERE project_path IN (${placeholders(identities)})`).all(...identities);
+  const epochs = new Map;
+  for (const row of rows) {
+    if (typeof row.projectPath !== "string" || typeof row.epoch !== "number")
+      continue;
+    epochs.set(row.projectPath, row.epoch);
+  }
+  return epochs;
+}
+function computeWorkspaceEpochFingerprint(db, identities) {
+  const canonical = uniqueSorted(identities.filter((identity) => identity.length > 0));
+  const epochs = getEpochMap(db, canonical);
+  const shareCategories = selectWorkspaceShareCategories(db, canonical);
+  const hash = createHash3("sha256");
+  hash.update("share_categories", "utf8");
+  hash.update("\x00");
+  hash.update(shareCategories === null ? "ALL" : JSON.stringify(shareCategories), "utf8");
+  hash.update(`
+`);
+  for (const identity of canonical) {
+    hash.update(identity, "utf8");
+    hash.update("\x00");
+    hash.update(String(epochs.get(identity) ?? 0), "utf8");
+    hash.update(`
+`);
+  }
+  return hash.digest("hex");
+}
+function isInTransaction(db) {
+  const candidate = db;
+  return candidate.inTransaction === true || candidate.isTransaction === true;
+}
+function workspaceMembersForIdentity(db, identity) {
+  if (!tableExists(db, "workspace_members"))
+    return [identity];
+  const rows = db.prepare(`SELECT member.project_path AS identity
+               FROM workspace_members AS anchor
+               JOIN workspace_members AS member ON member.workspace_id = anchor.workspace_id
+              WHERE anchor.project_path = ?
+              ORDER BY member.project_path ASC`).all(identity);
+  const identities = rows.map((row) => typeof row.identity === "string" ? row.identity : "").filter((value) => value.length > 0);
+  return identities.length > 0 ? uniqueSorted(identities) : [identity];
+}
+function bumpEpochRows(db, identities, now) {
+  const stmt = db.prepare(`INSERT INTO project_state
+            (project_path, project_memory_epoch, project_user_profile_version, updated_at)
+         VALUES (?, 1, 0, ?)
+         ON CONFLICT(project_path) DO UPDATE SET
+            project_memory_epoch = project_memory_epoch + 1,
+            updated_at = excluded.updated_at`);
+  for (const identity of uniqueSorted(identities)) {
+    stmt.run(identity, now);
+  }
+}
+function bumpEpochsForWorkspaceMembers(db, identity, now = Date.now()) {
+  const run = () => bumpEpochRows(db, workspaceMembersForIdentity(db, identity), now);
+  if (isInTransaction(db)) {
+    run();
+    return;
+  }
+  db.exec("BEGIN IMMEDIATE");
+  try {
+    run();
+    db.exec("COMMIT");
+  } catch (error) {
+    try {
+      db.exec("ROLLBACK");
+    } catch {}
+    throw error;
+  }
+}
+function bumpEpochsForWorkspaceMemberSet(db, identities, now = Date.now()) {
+  const run = () => bumpEpochRows(db, identities, now);
+  if (isInTransaction(db)) {
+    run();
+    return;
+  }
+  db.exec("BEGIN IMMEDIATE");
+  try {
+    run();
+    db.exec("COMMIT");
+  } catch (error) {
+    try {
+      db.exec("ROLLBACK");
+    } catch {}
+    throw error;
+  }
+}
+
 // ../plugin/src/features/magic-context/migrations.ts
-function 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);
+}
 var MIGRATIONS = [
   {
     version: 1,
@@ -144297,9 +144664,9 @@ var MIGRATIONS = [
     version: 22,
     description: "v2.0 cache architecture schema foundation",
     up: (db) => {
-      const hasSessionMetaTable = tableExists(db, "session_meta");
-      const hasCompartmentsTable = tableExists(db, "compartments");
-      const hasMemoriesTable = tableExists(db, "memories");
+      const hasSessionMetaTable = tableExists2(db, "session_meta");
+      const hasCompartmentsTable = tableExists2(db, "compartments");
+      const hasMemoriesTable = tableExists2(db, "memories");
       if (hasSessionMetaTable) {
         ensureColumn(db, "session_meta", "cached_m0_bytes", "BLOB");
         ensureColumn(db, "session_meta", "cached_m0_project_memory_epoch", "INTEGER");
@@ -144324,7 +144691,7 @@ var MIGRATIONS = [
         ensureColumn(db, "compartments", "p1_embedding_model_id", "TEXT");
         ensureColumn(db, "compartments", "legacy", "INTEGER NOT NULL DEFAULT 0");
       }
-      const hasRecompCompartmentsTable = tableExists(db, "recomp_compartments");
+      const hasRecompCompartmentsTable = tableExists2(db, "recomp_compartments");
       if (hasRecompCompartmentsTable) {
         ensureColumn(db, "recomp_compartments", "p1", "TEXT");
         ensureColumn(db, "recomp_compartments", "p2", "TEXT");
@@ -144635,6 +145002,156 @@ var MIGRATIONS = [
       db.prepare("UPDATE session_meta SET force_emergency_bypass_used = 0 WHERE force_emergency_bypass_used IS NULL").run();
       db.prepare("UPDATE session_meta SET last_usage_context_limit = 0 WHERE last_usage_context_limit IS NULL").run();
     }
+  },
+  {
+    version: 33,
+    description: "Compartment chunk embeddings for semantic message-history search",
+    up: (db) => {
+      db.exec(`
+                CREATE TABLE IF NOT EXISTS compartment_chunk_embeddings (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    compartment_id INTEGER NOT NULL REFERENCES compartments(id) ON DELETE CASCADE,
+                    session_id TEXT NOT NULL,
+                    project_path TEXT NOT NULL,
+                    harness TEXT NOT NULL DEFAULT 'opencode',
+                    window_index INTEGER NOT NULL DEFAULT 0,
+                    start_ordinal INTEGER NOT NULL,
+                    end_ordinal INTEGER NOT NULL,
+                    chunk_hash TEXT NOT NULL,
+                    model_id TEXT NOT NULL,
+                    dims INTEGER NOT NULL,
+                    vector BLOB NOT NULL,
+                    created_at INTEGER NOT NULL,
+                    UNIQUE(compartment_id, window_index)
+                );
+                CREATE INDEX IF NOT EXISTS idx_cce_session
+                    ON compartment_chunk_embeddings(session_id);
+                CREATE INDEX IF NOT EXISTS idx_cce_project_model
+                    ON compartment_chunk_embeddings(project_path, model_id);
+            `);
+    }
+  },
+  {
+    version: 34,
+    description: "workspace tables and m[0] workspace fingerprint cache reset",
+    up: (db) => {
+      db.exec(`
+                CREATE TABLE IF NOT EXISTS workspaces (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    name TEXT NOT NULL UNIQUE,
+                    created_at INTEGER NOT NULL,
+                    updated_at INTEGER NOT NULL
+                );
+                CREATE TABLE IF NOT EXISTS workspace_members (
+                    workspace_id INTEGER NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+                    project_path TEXT NOT NULL,
+                    display_name TEXT NOT NULL,
+                    display_path TEXT NOT NULL,
+                    added_at INTEGER NOT NULL,
+                    PRIMARY KEY (workspace_id, project_path)
+                );
+                CREATE UNIQUE INDEX IF NOT EXISTS idx_workspace_member_unique
+                    ON workspace_members(project_path);
+                CREATE UNIQUE INDEX IF NOT EXISTS idx_workspace_member_name
+                    ON workspace_members(workspace_id, display_name);
+            `);
+      const hasSessionMeta = db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='session_meta' LIMIT 1").get();
+      if (!hasSessionMeta)
+        return;
+      ensureColumn(db, "session_meta", "cached_m0_workspace_fingerprint", "TEXT");
+      const columns = new Set(db.prepare("PRAGMA table_info(session_meta)").all().map((column) => column.name));
+      const clears = [
+        ["cached_m0_bytes", null],
+        ["cached_m1_bytes", null],
+        ["cached_m0_project_memory_epoch", null],
+        ["cached_m0_workspace_fingerprint", null],
+        ["cached_m0_project_user_profile_version", null],
+        ["cached_m0_max_compartment_seq", null],
+        ["cached_m0_max_memory_id", null],
+        ["cached_m0_max_mutation_id", null],
+        ["cached_m0_max_memory_mutation_id", null],
+        ["cached_m0_project_docs_hash", null],
+        ["cached_m0_materialized_at", null],
+        ["cached_m0_session_facts_version", null],
+        ["cached_m0_upgrade_state", null],
+        ["cached_m0_system_hash", null],
+        ["cached_m0_tool_set_hash", null],
+        ["cached_m0_model_key", null],
+        ["cached_m0_last_baseline_end_message_id", null],
+        ["memory_block_cache", ""],
+        ["memory_block_ids", ""],
+        ["memory_block_count", 0]
+      ];
+      const setClauses = [];
+      const values = [];
+      for (const [column, value] of clears) {
+        if (!columns.has(column))
+          continue;
+        setClauses.push(`${column} = ?`);
+        values.push(value);
+      }
+      if (setClauses.length > 0) {
+        db.prepare(`UPDATE session_meta SET ${setClauses.join(", ")}`).run(...values);
+      }
+    }
+  },
+  {
+    version: 35,
+    description: "workspace per-category share defaults and epoch refresh",
+    up: (db) => {
+      db.exec(`
+                CREATE TABLE IF NOT EXISTS workspaces (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    name TEXT NOT NULL UNIQUE,
+                    created_at INTEGER NOT NULL,
+                    updated_at INTEGER NOT NULL,
+                    share_categories TEXT NOT NULL DEFAULT '["CONSTRAINTS"]'
+                );
+            `);
+      if (!columnExists2(db, "workspaces", "share_categories")) {
+        db.exec(`ALTER TABLE workspaces ADD COLUMN share_categories TEXT NOT NULL DEFAULT '["CONSTRAINTS"]'`);
+      }
+      db.prepare(`UPDATE workspaces
+                    SET share_categories = '["CONSTRAINTS"]'
+                  WHERE share_categories IS NULL OR share_categories = ''`).run();
+      if (!tableExists2(db, "workspace_members"))
+        return;
+      const rows = db.prepare(`SELECT DISTINCT project_path AS identity
+                       FROM workspace_members
+                      WHERE project_path IS NOT NULL AND project_path <> ''
+                      ORDER BY project_path ASC`).all();
+      const identities = rows.map((row) => typeof row.identity === "string" ? row.identity : "").filter((identity) => identity.length > 0);
+      if (identities.length > 0) {
+        bumpEpochsForWorkspaceMemberSet(db, identities, Date.now());
+      }
+    }
+  },
+  {
+    version: 36,
+    description: "session project ownership map for compartment chunk backfill scoping",
+    up: (db) => {
+      db.exec(`
+                CREATE TABLE IF NOT EXISTS session_projects (
+                    session_id TEXT NOT NULL,
+                    harness TEXT NOT NULL DEFAULT 'opencode',
+                    project_path TEXT NOT NULL,
+                    updated_at INTEGER NOT NULL,
+                    PRIMARY KEY(session_id, harness)
+                );
+                CREATE INDEX IF NOT EXISTS idx_session_projects_project
+                    ON session_projects(project_path);
+            `);
+      const hasChunkTable = db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='compartment_chunk_embeddings'").get();
+      if (hasChunkTable) {
+        db.exec(`
+                    INSERT OR IGNORE INTO session_projects (session_id, harness, project_path, updated_at)
+                    SELECT session_id, harness, MIN(project_path), 0
+                    FROM compartment_chunk_embeddings
+                    GROUP BY session_id, harness
+                    HAVING COUNT(DISTINCT project_path) = 1;
+                `);
+      }
+    }
   }
 ];
 var LATEST_MIGRATION_VERSION = MIGRATIONS.reduce((max, m) => Math.max(max, m.version), 0);
@@ -144704,7 +145221,7 @@ function runMigrations(db) {
   log(`[migrations] schema version now: ${MIGRATIONS[MIGRATIONS.length - 1].version}`);
 }
 // ../plugin/src/features/magic-context/project-docs-hash.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 import { lstatSync, readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
 import path4 from "node:path";
 var PROJECT_DOC_FILES = ["ARCHITECTURE.md", "STRUCTURE.md"];
@@ -144802,7 +145319,7 @@ function hashCanonicalPieces(hashPieces) {
   if (hashPieces.length === 0) {
     return "";
   }
-  return createHash3("sha256").update(hashPieces.join(PROJECT_DOCS_DELIMITER), "utf8").digest("hex");
+  return createHash4("sha256").update(hashPieces.join(PROJECT_DOCS_DELIMITER), "utf8").digest("hex");
 }
 function readProjectDocsCanonical(projectDirectory) {
   const canonicalDirectory = path4.resolve(projectDirectory);
@@ -144908,18 +145425,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);
@@ -144940,10 +145452,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;
+}
 // ../plugin/src/features/magic-context/storage-meta-persisted.ts
 init_logger();
 var CAS_RETRY_LIMIT = 5;
@@ -145789,9 +146345,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
   };
 }
@@ -145987,19 +146543,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)
@@ -146033,8 +146576,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);
@@ -146125,15 +146668,22 @@ function ownerMessageIdForTagRow(row) {
   }
   return row.message_id.replace(CONTENT_ID_SUFFIX, "");
 }
-function getActiveTagTokenAggregate(db, sessionId) {
-  const row = db.prepare(`SELECT
+function getActiveTagTokenAggregate(db, sessionId, protectedTags = 0) {
+  const toolOutputExpr = protectedTags > 0 ? `COALESCE(SUM(CASE WHEN type = 'tool' AND tag_number < (
+                    SELECT tag_number FROM tags
+                    WHERE session_id = ? AND status = 'active'
+                    ORDER BY tag_number DESC LIMIT 1 OFFSET ?
+                ) THEN COALESCE(token_count, 0) ELSE 0 END), 0)` : `COALESCE(SUM(CASE WHEN type = 'tool' THEN COALESCE(token_count, 0) ELSE 0 END), 0)`;
+  const sql = `SELECT
                 COALESCE(SUM(CASE WHEN type != 'tool' THEN COALESCE(token_count, 0) ELSE 0 END), 0)
                     + COALESCE(SUM(COALESCE(reasoning_token_count, 0)), 0) AS conversation,
                 COALESCE(SUM(CASE WHEN type = 'tool' THEN COALESCE(token_count, 0) + COALESCE(input_token_count, 0) ELSE 0 END), 0) AS tool_call,
-                COALESCE(SUM(CASE WHEN type = 'tool' THEN COALESCE(token_count, 0) ELSE 0 END), 0) AS tool_output,
+                ${toolOutputExpr} AS tool_output,
                 COALESCE(SUM(CASE WHEN token_count IS NULL THEN 1 ELSE 0 END), 0) AS null_count
              FROM tags
-             WHERE session_id = ? AND status = 'active'`).get(sessionId);
+             WHERE session_id = ? AND status = 'active'`;
+  const params = protectedTags > 0 ? [sessionId, protectedTags - 1, sessionId] : [sessionId];
+  const row = db.prepare(sql).get(...params);
   return {
     conversation: row?.conversation ?? 0,
     toolCall: row?.tool_call ?? 0,
@@ -146324,8 +146874,8 @@ function getTagsByNumbers(db, sessionId, tagNumbers) {
     }
     return all;
   }
-  const placeholders = tagNumbers.map(() => "?").join(",");
-  const rows = db.prepare(`SELECT ${TAG_SELECT_COLUMNS} FROM tags WHERE session_id = ? AND tag_number IN (${placeholders}) ORDER BY tag_number ASC, id ASC`).all(sessionId, ...tagNumbers).filter(isTagRow);
+  const placeholders3 = tagNumbers.map(() => "?").join(",");
+  const rows = db.prepare(`SELECT ${TAG_SELECT_COLUMNS} FROM tags WHERE session_id = ? AND tag_number IN (${placeholders3}) ORDER BY tag_number ASC, id ASC`).all(sessionId, ...tagNumbers).filter(isTagRow);
   return rows.map(toTagEntry);
 }
 var getToolTagNumberByOwnerStatements = new WeakMap;
@@ -146395,7 +146945,7 @@ var ERROR_CLASSES = new Set([
 ]);
 // ../plugin/src/features/magic-context/v22-deferred-backfill.ts
 init_logger();
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 import { realpathSync as realpathSync2 } from "node:fs";
 import path5 from "node:path";
 var BATCH_SIZE = 25;
@@ -146449,7 +146999,7 @@ function computeLegacyRustDirIdentity(rawProjectPath) {
   } catch {
     canonical = path5.isAbsolute(rawProjectPath) ? rawProjectPath : path5.join(process.cwd(), rawProjectPath);
   }
-  return `dir:${createHash4("sha256").update(canonical, "utf8").digest("hex")}`;
+  return `dir:${createHash5("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)
@@ -147007,7 +147557,7 @@ function clearNoteNudgeTriggerOnly(db, sessionId) {
 }
 
 // ../plugin/src/hooks/magic-context/todo-view.ts
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } 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_";
@@ -147052,7 +147602,7 @@ function buildSyntheticTodoPart(stateJson) {
   };
 }
 function computeSyntheticCallId(stateJson) {
-  const hash = createHash5("sha256").update(stateJson).digest("hex").slice(0, 16);
+  const hash = createHash6("sha256").update(stateJson).digest("hex").slice(0, 16);
   return `${SYNTHETIC_CALL_ID_PREFIX}${hash}`;
 }
 function parseTodoState(stateJson) {
@@ -147193,13 +147743,13 @@ async function maybeSendUpgradeReminder(deps, sessionId) {
 init_data_path();
 import * as fs2 from "node:fs";
 import * as path6 from "node:path";
-var ANNOUNCEMENT_VERSION = "0.23.0";
+var ANNOUNCEMENT_VERSION = "0.24.0";
 var 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)."
 ];
 var ANNOUNCEMENT_FOOTER = "Join us on Discord: https://discord.gg/F2uWxjGnU";
 var STATE_FILENAME = "last_announced_version";
@@ -149082,7 +149632,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) {
@@ -149102,7 +149652,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;
@@ -149131,7 +149681,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;
 }
@@ -149182,13 +149735,13 @@ function invalidateMemory(projectPath, memoryId) {
 }
 
 // ../plugin/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");
 }
 
 // ../plugin/src/features/magic-context/memory/storage-memory.ts
@@ -149376,8 +149929,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;
@@ -149522,6 +150075,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);
@@ -150043,8 +150687,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();
@@ -165534,7 +166178,8 @@ var BaseEmbeddingConfigSchema = exports_external.object({
   endpoint: exports_external.string().optional().describe("API endpoint URL. Required when provider is openai-compatible."),
   api_key: exports_external.string().optional().describe("API key for remote embedding provider (optional)"),
   input_type: exports_external.string().optional().describe("Optional input_type sent in the embedding request body. Required by some openai-compatible providers (e.g. NVIDIA NIM expects 'query' or 'passage'). Omitted from the request when unset."),
-  truncate: exports_external.string().optional().describe("Optional truncate mode sent in the embedding request body (e.g. NVIDIA NIM accepts 'NONE' | 'START' | 'END'). Omitted from the request when unset.")
+  truncate: exports_external.string().optional().describe("Optional truncate mode sent in the embedding request body (e.g. NVIDIA NIM accepts 'NONE' | 'START' | 'END'). Omitted from the request when unset."),
+  max_input_tokens: exports_external.number().int().positive().optional().describe("Optional maximum input tokens for chunk embeddings. Defaults conservatively to 512 when omitted.")
 }).superRefine((data, ctx) => {
   if (data.provider === "openai-compatible" && !data.endpoint?.trim()) {
     ctx.addIssue({
@@ -165555,7 +166200,8 @@ var EmbeddingConfigSchema = BaseEmbeddingConfigSchema.transform((data) => {
   if (data.provider === "local") {
     return {
       provider: "local",
-      model: data.model?.trim() || DEFAULT_LOCAL_EMBEDDING_MODEL
+      model: data.model?.trim() || DEFAULT_LOCAL_EMBEDDING_MODEL,
+      ...data.max_input_tokens ? { max_input_tokens: data.max_input_tokens } : {}
     };
   }
   if (data.provider === "openai-compatible") {
@@ -165568,7 +166214,8 @@ var EmbeddingConfigSchema = BaseEmbeddingConfigSchema.transform((data) => {
       endpoint: data.endpoint?.trim() ?? "",
       ...apiKey ? { api_key: apiKey } : {},
       ...inputType ? { input_type: inputType } : {},
-      ...truncate ? { truncate } : {}
+      ...truncate ? { truncate } : {},
+      ...data.max_input_tokens ? { max_input_tokens: data.max_input_tokens } : {}
     };
   }
   return { provider: "off" };
@@ -165653,6 +166300,443 @@ var MagicContextConfigSchema = exports_external.object({
 // ../plugin/src/features/magic-context/memory/embedding.ts
 init_logger();
 
+// ../plugin/src/features/magic-context/compartment-chunk-embedding.ts
+import { createHash as createHash8 } from "node:crypto";
+var DEFAULT_COMPARTMENT_CHUNK_MAX_INPUT_TOKENS = 512;
+var CHUNK_WINDOW_SAFETY_RATIO = 0.9;
+var loadFtsRowsStatements = new WeakMap;
+var existingHashStatements = new WeakMap;
+var existingHashByProjectStatements = new WeakMap;
+var deleteByCompartmentStatements = new WeakMap;
+var insertEmbeddingStatements = new WeakMap;
+var distinctModelStatements = new WeakMap;
+var clearProjectStatements = new WeakMap;
+var clearProjectModelStatements = new WeakMap;
+var searchRowsStatements = new WeakMap;
+var searchRowsByModelStatements = new WeakMap;
+var backfillCandidateStatements = new WeakMap;
+function getLoadFtsRowsStatement(db) {
+  let stmt = loadFtsRowsStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`SELECT message_ordinal AS messageOrdinal, role, content
+             FROM message_history_fts
+             WHERE session_id = ?
+               AND message_ordinal >= ?
+               AND message_ordinal <= ?
+               AND role IN ('user', 'assistant')
+             ORDER BY message_ordinal ASC`);
+    loadFtsRowsStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getExistingHashStatement(db, scopedToProject) {
+  const map2 = scopedToProject ? existingHashByProjectStatements : existingHashStatements;
+  let stmt = map2.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`SELECT window_index AS windowIndex, chunk_hash AS chunkHash
+             FROM compartment_chunk_embeddings
+             WHERE compartment_id = ?
+               AND model_id = ?
+               ${scopedToProject ? "AND project_path = ?" : ""}
+             ORDER BY window_index ASC`);
+    map2.set(db, stmt);
+  }
+  return stmt;
+}
+function getDeleteByCompartmentStatement(db) {
+  let stmt = deleteByCompartmentStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("DELETE FROM compartment_chunk_embeddings WHERE compartment_id = ?");
+    deleteByCompartmentStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getInsertEmbeddingStatement(db) {
+  let stmt = insertEmbeddingStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`INSERT INTO compartment_chunk_embeddings (
+                compartment_id, session_id, project_path, harness, window_index,
+                start_ordinal, end_ordinal, chunk_hash, model_id, dims, vector, created_at
+             ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+    insertEmbeddingStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getDistinctModelStatement(db) {
+  let stmt = distinctModelStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`SELECT DISTINCT model_id AS modelId
+             FROM compartment_chunk_embeddings
+             WHERE project_path = ?`);
+    distinctModelStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getClearProjectStatement(db) {
+  let stmt = clearProjectStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("DELETE FROM compartment_chunk_embeddings WHERE project_path = ?");
+    clearProjectStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getClearProjectModelStatement(db) {
+  let stmt = clearProjectModelStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("DELETE FROM compartment_chunk_embeddings WHERE project_path = ? AND model_id = ?");
+    clearProjectModelStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getSearchRowsStatement(db, withModel) {
+  const map2 = withModel ? searchRowsByModelStatements : searchRowsStatements;
+  let stmt = map2.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`SELECT e.compartment_id AS compartmentId,
+                    e.session_id AS sessionId,
+                    c.title AS title,
+                    c.start_message AS compartmentStart,
+                    c.end_message AS compartmentEnd,
+                    e.window_index AS windowIndex,
+                    e.start_ordinal AS windowStart,
+                    e.end_ordinal AS windowEnd,
+                    e.chunk_hash AS chunkHash,
+                    e.model_id AS modelId,
+                    e.dims AS dims,
+                    e.vector AS vector
+             FROM compartment_chunk_embeddings e
+             JOIN compartments c ON c.id = e.compartment_id
+             WHERE e.session_id = ?
+               AND e.project_path = ?
+               ${withModel ? "AND e.model_id = ?" : ""}
+             ORDER BY e.compartment_id ASC, e.window_index ASC`);
+    map2.set(db, stmt);
+  }
+  return stmt;
+}
+function isFinitePositiveInteger(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function normalizeCompartmentChunkMaxInputTokens(value) {
+  if (!isFinitePositiveInteger(value)) {
+    return DEFAULT_COMPARTMENT_CHUNK_MAX_INPUT_TOKENS;
+  }
+  return Math.max(1, Math.floor(value));
+}
+function normalizeContent(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function formatOrdinalRange(start, end) {
+  return start === end ? `[${start}]` : `[${start}-${end}]`;
+}
+function rolePrefix(role) {
+  if (role === "user")
+    return "U";
+  if (role === "assistant")
+    return "A";
+  return null;
+}
+function parseOrdinal(value) {
+  const parsed = typeof value === "number" ? value : Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+}
+function parseCanonicalLineRange(line) {
+  const match = /^\[(\d+)(?:-(\d+))?\]\s+[UA]:/.exec(line.trim());
+  if (!match)
+    return null;
+  const start = Number.parseInt(match[1], 10);
+  const end = match[2] ? Number.parseInt(match[2], 10) : start;
+  if (!Number.isFinite(start) || !Number.isFinite(end))
+    return null;
+  return { start, end };
+}
+function hashChunkText(text) {
+  return 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 effectiveMax = Math.max(1, Math.floor(normalizedMax * CHUNK_WINDOW_SAFETY_RATIO));
+  const fullText = lines.join(`
+`);
+  if (estimateTokens(fullText) <= effectiveMax) {
+    return [
+      {
+        windowIndex: 0,
+        startOrdinal,
+        endOrdinal,
+        text: fullText,
+        chunkHash: hashChunkText(fullText)
+      }
+    ];
+  }
+  const windows = [];
+  let currentLines = [];
+  let currentStart = null;
+  let currentEnd = null;
+  let currentTokens = 0;
+  const flush2 = () => {
+    if (currentLines.length === 0 || currentStart === null || currentEnd === null)
+      return;
+    const text = currentLines.join(`
+`);
+    windows.push({
+      windowIndex: windows.length + 1,
+      startOrdinal: currentStart,
+      endOrdinal: currentEnd,
+      text,
+      chunkHash: hashChunkText(text)
+    });
+    currentLines = [];
+    currentStart = null;
+    currentEnd = null;
+    currentTokens = 0;
+  };
+  for (const line of lines) {
+    const range = parseCanonicalLineRange(line);
+    const lineStart = range?.start ?? startOrdinal;
+    const lineEnd = range?.end ?? lineStart;
+    const lineTokens = estimateTokens(line);
+    if (currentLines.length > 0 && currentTokens + lineTokens > effectiveMax) {
+      flush2();
+    }
+    if (currentLines.length === 0) {
+      currentStart = lineStart;
+    }
+    currentLines.push(line);
+    currentEnd = lineEnd;
+    currentTokens += lineTokens;
+  }
+  flush2();
+  return windows;
+}
+function getExistingChunkHashes(db, compartmentId, modelId, projectPath) {
+  const scoped = typeof projectPath === "string" && projectPath.length > 0;
+  const rows = scoped ? getExistingHashStatement(db, true).all(compartmentId, modelId, projectPath) : getExistingHashStatement(db, false).all(compartmentId, modelId);
+  return new Map(rows.filter((row) => typeof row.windowIndex === "number" && typeof row.chunkHash === "string").map((row) => [row.windowIndex, row.chunkHash]));
+}
+function chunkEmbeddingWindowsAreCurrent(db, compartmentId, modelId, windows, projectPath) {
+  const existing = getExistingChunkHashes(db, compartmentId, modelId, projectPath);
+  if (existing.size !== windows.length)
+    return false;
+  return windows.every((window) => existing.get(window.windowIndex) === window.chunkHash);
+}
+function replaceCompartmentChunkEmbeddings(db, rows) {
+  if (rows.length === 0)
+    return;
+  const compartmentId = rows[0].compartmentId;
+  const now = Date.now();
+  db.transaction(() => {
+    getDeleteByCompartmentStatement(db).run(compartmentId);
+    const insert = getInsertEmbeddingStatement(db);
+    for (const row of rows) {
+      insert.run(row.compartmentId, row.sessionId, row.projectPath, getHarness(), row.window.windowIndex, row.window.startOrdinal, row.window.endOrdinal, row.window.chunkHash, row.modelId, row.vector.length, vectorBlob(row.vector), row.createdAt ?? now);
+    }
+  })();
+}
+function getDistinctChunkEmbeddingModelIds(db, projectPath) {
+  const rows = getDistinctModelStatement(db).all(projectPath);
+  return new Set(rows.map((row) => typeof row.modelId === "string" ? row.modelId : null));
+}
+function clearChunkEmbeddingsForProject(db, projectPath, modelId) {
+  if (modelId) {
+    return getClearProjectModelStatement(db).run(projectPath, modelId).changes;
+  }
+  return getClearProjectStatement(db).run(projectPath).changes;
+}
+function loadCompartmentChunkEmbeddingsForSearch(db, sessionId, projectPath, modelId) {
+  const rows = modelId ? getSearchRowsStatement(db, true).all(sessionId, projectPath, modelId) : getSearchRowsStatement(db, false).all(sessionId, projectPath);
+  return rows.filter((row) => typeof row.compartmentId === "number" && typeof row.sessionId === "string" && typeof row.title === "string" && typeof row.compartmentStart === "number" && typeof row.compartmentEnd === "number" && typeof row.windowIndex === "number" && typeof row.windowStart === "number" && typeof row.windowEnd === "number" && typeof row.chunkHash === "string" && typeof row.modelId === "string" && typeof row.dims === "number" && (row.vector instanceof Uint8Array || row.vector instanceof ArrayBuffer)).map((row) => ({
+    compartmentId: row.compartmentId,
+    sessionId: row.sessionId,
+    title: row.title,
+    startOrdinal: row.compartmentStart,
+    endOrdinal: row.compartmentEnd,
+    windowIndex: row.windowIndex,
+    windowStartOrdinal: row.windowStart,
+    windowEndOrdinal: row.windowEnd,
+    chunkHash: row.chunkHash,
+    modelId: row.modelId,
+    dims: row.dims,
+    vector: 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
+  }));
+}
+var sessionBackfillCandidateStatements = new WeakMap;
+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;
+}
+
 // ../plugin/src/features/magic-context/memory/cosine-similarity.ts
 function cosineSimilarity(a, b) {
   if (a.length !== b.length) {
@@ -165811,19 +166895,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");
@@ -165838,6 +166922,7 @@ function extractBatchEmbeddings(result, expectedCount) {
 
 class LocalEmbeddingProvider {
   modelId;
+  maxInputTokens;
   model;
   pipeline = null;
   initPromise = null;
@@ -165845,8 +166930,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() {
@@ -166094,6 +167180,13 @@ function blockedEmbeddingEndpointReason(endpoint) {
 function normalizeEndpoint2(endpoint) {
   return endpoint?.trim().replace(/\/+$/, "") ?? "";
 }
+function embeddingModelsMatch(served, requested) {
+  const a = served.trim().toLowerCase();
+  const b = requested.trim().toLowerCase();
+  if (a.length === 0 || b.length === 0)
+    return true;
+  return a === b || a.includes(b) || b.includes(a);
+}
 var FAILURE_THRESHOLD = 3;
 var FAILURE_WINDOW_MS = 60000;
 var OPEN_DURATION_MS = 5 * 60000;
@@ -166101,6 +167194,7 @@ var FETCH_TIMEOUT_MS = 30000;
 
 class OpenAICompatibleEmbeddingProvider {
   modelId;
+  maxInputTokens;
   endpoint;
   model;
   apiKey;
@@ -166110,6 +167204,7 @@ class OpenAICompatibleEmbeddingProvider {
   failureTimes = [];
   circuitOpenUntil = 0;
   openLogged = false;
+  modelMismatchLogged = false;
   halfOpenProbeInFlight = false;
   constructor(options) {
     this.endpoint = normalizeEndpoint2(options.endpoint);
@@ -166117,11 +167212,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() {
@@ -166206,6 +167303,15 @@ class OpenAICompatibleEmbeddingProvider {
         this.recordFailure(isProbe);
         return Array.from({ length: texts.length }, () => null);
       }
+      const servedModel = typeof body.model === "string" ? body.model : "";
+      if (this.model && servedModel && !embeddingModelsMatch(servedModel, this.model)) {
+        if (!this.modelMismatchLogged) {
+          log(`[magic-context] embedding endpoint served a DIFFERENT model than requested — refusing the substituted vectors (they have the wrong dimensions/space). requested="${this.model}" served="${servedModel}". The endpoint likely substituted a loaded model; load/select "${this.model}" on the endpoint, or set embedding.model to the served model.`);
+          this.modelMismatchLogged = true;
+        }
+        this.recordFailure(isProbe);
+        return Array.from({ length: texts.length }, () => null);
+      }
       const items = Array.isArray(body.data) ? body.data : [];
       const results = Array.from({ length: texts.length }, (_, index) => {
         const embedding = items[index]?.embedding;
@@ -166312,7 +167418,7 @@ class OpenAICompatibleEmbeddingProvider {
 }
 
 // ../plugin/src/features/magic-context/project-embedding-registry.ts
-import { createHash as createHash7, randomUUID } from "node:crypto";
+import { createHash as createHash9, randomUUID } from "node:crypto";
 init_logger();
 
 // ../plugin/src/features/magic-context/git-commits/storage-git-commit-embeddings.ts
@@ -166320,7 +167426,7 @@ var saveStatements = new WeakMap;
 var loadProjectStatements = new WeakMap;
 var loadUnembeddedStatements = new WeakMap;
 var countEmbeddedStatements = new WeakMap;
-var clearProjectStatements = new WeakMap;
+var clearProjectStatements2 = new WeakMap;
 var distinctModelIdStatements = new WeakMap;
 function getSaveStatement(db) {
   let stmt = saveStatements.get(db);
@@ -166368,12 +167474,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;
 }
@@ -166409,7 +167515,7 @@ function countEmbeddedCommits(db, projectPath) {
   return row?.count ?? 0;
 }
 function clearProjectCommitEmbeddings(db, projectPath) {
-  return getClearProjectStatement(db).run(projectPath).changes;
+  return getClearProjectStatement2(db).run(projectPath).changes;
 }
 function getDistinctCommitEmbeddingModelIds(db, projectPath) {
   const rows = getDistinctModelIdStatement(db).all(projectPath);
@@ -166535,9 +167641,83 @@ function releaseGitSweepLease(db, projectPath, holderId) {
   });
 }
 
+// ../plugin/src/features/magic-context/session-project-storage.ts
+var upsertSessionProjectStatements = new WeakMap;
+var repairSessionChunkProjectStatements = new WeakMap;
+var repairProjectChunkProjectStatements = new WeakMap;
+function getUpsertSessionProjectStatement(db) {
+  let stmt = upsertSessionProjectStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`INSERT INTO session_projects (session_id, harness, project_path, updated_at)
+             VALUES (?, ?, ?, ?)
+             ON CONFLICT(session_id, harness) DO UPDATE SET
+                 project_path = excluded.project_path,
+                 updated_at = excluded.updated_at
+             WHERE session_projects.project_path <> excluded.project_path`);
+    upsertSessionProjectStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getRepairSessionChunkProjectStatement(db) {
+  let stmt = repairSessionChunkProjectStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`UPDATE compartment_chunk_embeddings
+             SET project_path = ?
+             WHERE session_id = ?
+               AND harness = ?
+               AND project_path <> ?`);
+    repairSessionChunkProjectStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getRepairProjectChunkProjectStatement(db) {
+  let stmt = repairProjectChunkProjectStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`UPDATE compartment_chunk_embeddings
+             SET project_path = (
+                 SELECT sp.project_path
+                 FROM session_projects sp
+                 WHERE sp.session_id = compartment_chunk_embeddings.session_id
+                   AND sp.harness = compartment_chunk_embeddings.harness
+                 LIMIT 1
+             )
+             WHERE EXISTS (
+                 SELECT 1
+                 FROM session_projects sp
+                 WHERE sp.session_id = compartment_chunk_embeddings.session_id
+                   AND sp.harness = compartment_chunk_embeddings.harness
+                   AND sp.project_path <> compartment_chunk_embeddings.project_path
+                   AND (
+                       sp.project_path = ?
+                       OR compartment_chunk_embeddings.project_path = ?
+                   )
+             )`);
+    repairProjectChunkProjectStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function recordSessionProjectIdentity(db, sessionId, projectPath) {
+  if (!sessionId || !projectPath)
+    return;
+  const harness = getHarness();
+  const now = Date.now();
+  db.transaction(() => {
+    getUpsertSessionProjectStatement(db).run(sessionId, harness, projectPath, now);
+    getRepairSessionChunkProjectStatement(db).run(projectPath, sessionId, harness, projectPath);
+  })();
+}
+function repairMisScopedCompartmentChunkEmbeddingsForProject(db, projectPath) {
+  if (!projectPath)
+    return 0;
+  return getRepairProjectChunkProjectStatement(db).run(projectPath, projectPath).changes;
+}
+
 // ../plugin/src/features/magic-context/project-embedding-registry.ts
 var OFF_PROVIDER_IDENTITY = "embedding-provider:off";
 var SWEEP_MAX_WALL_CLOCK_MS = 10 * 60 * 1000;
+var CHUNK_DRAIN_BATCH_SIZE = 8;
+var MAX_WINDOWS_PER_EMBED_CALL = 16;
+var SESSION_EMBED_LEASE_RENEWAL_MS = 60 * 1000;
 var projectRegistrations = new Map;
 var loadUnembeddedMemoriesStatements = new WeakMap;
 var globalRegistrationGeneration = 0;
@@ -166546,7 +167726,10 @@ function resolveEmbeddingConfig(config2) {
   if (!config2 || config2.provider === "local") {
     return {
       provider: "local",
-      model: config2?.model?.trim() || DEFAULT_LOCAL_EMBEDDING_MODEL
+      model: config2?.model?.trim() || DEFAULT_LOCAL_EMBEDDING_MODEL,
+      ...config2?.max_input_tokens ? {
+        max_input_tokens: normalizeCompartmentChunkMaxInputTokens(config2.max_input_tokens)
+      } : {}
     };
   }
   if (config2.provider === "openai-compatible") {
@@ -166559,7 +167742,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" };
@@ -166577,10 +167763,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)) {
@@ -166593,7 +167780,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") {
@@ -166601,6 +167788,18 @@ function getRuntimeFingerprint(config2) {
   }
   return `${getEmbeddingProviderIdentity(config2)}:${sha256Prefix(stableStringify2(config2))}`;
 }
+function getChunkEmbeddingModelId(config2, providerIdentity) {
+  if (config2.provider === "off") {
+    return OFF_PROVIDER_IDENTITY;
+  }
+  const chunkIdentity = {
+    providerIdentity,
+    chunkerVersion: 2,
+    maxInputTokens: normalizeCompartmentChunkMaxInputTokens("max_input_tokens" in config2 ? config2.max_input_tokens : undefined),
+    truncate: config2.provider === "openai-compatible" ? config2.truncate ?? "" : ""
+  };
+  return `${providerIdentity}:chunk:${sha256Prefix(stableStringify2(chunkIdentity))}`;
+}
 function sameFeatures(a, b) {
   return a.memoryEnabled === b.memoryEnabled && a.gitCommitEnabled === b.gitCommitEnabled;
 }
@@ -166617,7 +167816,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) {
@@ -166637,7 +167837,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;
   }
@@ -166658,6 +167858,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;
 }
@@ -166665,10 +167873,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,
@@ -166680,6 +167889,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);
@@ -166702,6 +167912,7 @@ function registerProjectInObservationMode(db, projectIdentity, sourceDirectory,
     generation,
     features: { memoryEnabled: false, gitCommitEnabled: false },
     modelId: "off",
+    chunkModelId: "off",
     observationMode: true
   };
   projectRegistrations.set(projectIdentity, registration);
@@ -166712,6 +167923,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;
@@ -166806,6 +168026,131 @@ async function embedUnembeddedMemoriesForProject(db, projectIdentity, batchSize
     return 0;
   }
 }
+async function embedCandidateChunkBatch(db, projectIdentity, modelId, candidates, signal) {
+  const noWork = [];
+  if (candidates.length === 0)
+    return { embedded: 0, noWork };
+  const maxInputTokens = getProjectEmbeddingMaxInputTokens(projectIdentity);
+  const prepared = [];
+  for (const candidate of candidates) {
+    const canonicalText = buildCanonicalChunkTextFromFts(db, candidate.sessionId, candidate.startMessage, candidate.endMessage);
+    if (canonicalText.length === 0) {
+      noWork.push(candidate.id);
+      continue;
+    }
+    const windows = chunkCanonicalText(canonicalText, candidate.startMessage, candidate.endMessage, maxInputTokens);
+    if (windows.length === 0 || chunkEmbeddingWindowsAreCurrent(db, candidate.id, modelId, windows, projectIdentity)) {
+      noWork.push(candidate.id);
+      continue;
+    }
+    prepared.push({ candidate, windows });
+  }
+  if (prepared.length === 0)
+    return { embedded: 0, noWork };
+  let embedded = 0;
+  let i = 0;
+  while (i < prepared.length) {
+    if (signal?.aborted)
+      break;
+    const slice = [];
+    let windowCount = 0;
+    do {
+      const item = prepared[i];
+      slice.push(item);
+      windowCount += item.windows.length;
+      i += 1;
+    } while (i < prepared.length && windowCount + prepared[i].windows.length <= MAX_WINDOWS_PER_EMBED_CALL);
+    const texts = [];
+    for (const item of slice)
+      texts.push(...item.windows.map((w) => w.text));
+    try {
+      const result = await embedBatchForProject(projectIdentity, texts, signal);
+      if (!result)
+        continue;
+      if (signal?.aborted)
+        break;
+      let offset = 0;
+      for (const item of slice) {
+        const vectors = result.vectors.slice(offset, offset + item.windows.length);
+        offset += item.windows.length;
+        if (vectors.length !== item.windows.length || vectors.some((v) => !v)) {
+          continue;
+        }
+        const rows = item.windows.map((window, index) => ({
+          compartmentId: item.candidate.id,
+          sessionId: item.candidate.sessionId,
+          projectPath: projectIdentity,
+          window,
+          modelId,
+          vector: vectors[index]
+        }));
+        replaceCompartmentChunkEmbeddings(db, rows);
+        embedded += 1;
+      }
+    } catch (error51) {
+      log("[magic-context] failed to proactively embed compartment chunks:", error51);
+    }
+  }
+  return { embedded, noWork };
+}
+async function embedSessionCompartmentChunks(db, projectIdentity, sessionId, options) {
+  const snapshot = getProjectEmbeddingSnapshot(projectIdentity);
+  if (!snapshot?.enabled || snapshot.chunkModelId === "off") {
+    return { status: "disabled", embedded: 0, total: 0 };
+  }
+  recordSessionProjectIdentity(db, sessionId, projectIdentity);
+  const total = countUnembeddedSessionCompartments(db, projectIdentity, sessionId, snapshot.chunkModelId);
+  if (total === 0)
+    return { status: "nothing", embedded: 0, total: 0 };
+  const holderId = `session-embed-${randomUUID()}`;
+  const 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((resolve4) => setTimeout(resolve4, 0));
+    }
+  } finally {
+    clearInterval(renewal);
+    releaseGitSweepLease(db, projectIdentity, holderId);
+  }
+  if (aborted2)
+    return { status: "aborted", embedded, total };
+  if (providerStalled) {
+    const remaining = Math.max(0, countUnembeddedSessionCompartments(db, projectIdentity, sessionId, snapshot.chunkModelId) - skipIds.length);
+    if (remaining > 0)
+      return { status: "stalled", embedded, total, remaining };
+  }
+  return { status: "done", embedded, total };
+}
 
 // ../plugin/src/features/magic-context/memory/embedding.ts
 var DEFAULT_EMBEDDING_CONFIG = {
@@ -166825,10 +168170,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) {
@@ -167071,6 +168417,7 @@ init_logger();
 // ../plugin/src/features/magic-context/memory/storage-memory-fts.ts
 var DEFAULT_SEARCH_LIMIT = 10;
 var searchStatements = new WeakMap;
+var unionSearchStatements = new Map;
 function getSearchStatement(db) {
   let stmt = searchStatements.get(db);
   if (!stmt) {
@@ -167079,6 +168426,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((path7) => path7.length > 0))];
+}
 function sanitizeFtsQuery(query) {
   const tokens = query.split(/\s+/).filter((token) => token.length > 0);
   if (tokens.length === 0)
@@ -167097,6 +168461,28 @@ function searchMemoriesFTS(db, projectPath, query, limit = DEFAULT_SEARCH_LIMIT)
   const rows = getSearchStatement(db).all(projectPath, Date.now(), sanitized, limit).filter(isMemoryRow);
   return rows.map(toMemory);
 }
+function searchMemoriesFTSUnion(db, projectPaths, query, limit = DEFAULT_SEARCH_LIMIT, ownIdentities, shareCategories) {
+  const identities = 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);
+}
 
 // ../plugin/src/features/magic-context/git-commits/search-git-commits.ts
 var ftsStatements = new WeakMap;
@@ -167389,7 +168775,7 @@ async function sweepGitCommits(args) {
 }
 
 // ../plugin/src/plugin/embedding-bootstrap-helpers.ts
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 init_logger();
 var EMBEDDING_AFFECTING_KEYS = new Set([
   "embedding.api_key",
@@ -167411,7 +168797,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();
@@ -168457,6 +169843,88 @@ function registerCtxDreamCommand(pi, deps) {
   });
 }
 
+// src/commands/ctx-embed-history.ts
+function registerCtxEmbedHistoryCommand(pi, deps) {
+  pi.registerCommand("ctx-embed-history", {
+    description: "Embed all of this session's history compartments for semantic search, in one pass",
+    handler: async (_args, ctx) => {
+      const sessionId = resolveSessionId(ctx);
+      if (!sessionId) {
+        sendCtxStatusMessage(pi, {
+          title: "/ctx-embed-history",
+          text: `## /ctx-embed-history
+
+No active Pi session is available.`,
+          level: "error"
+        });
+        return;
+      }
+      if (deps.memoryEnabled === false) {
+        sendCtxStatusMessage(pi, {
+          title: "/ctx-embed-history",
+          text: `## /ctx-embed-history
+
+Memory is disabled for this project, so there is no semantic embedding to backfill.`,
+          level: "info"
+        });
+        return;
+      }
+      const project = deps.resolveProject?.(ctx) ?? {
+        projectDir: deps.projectDir,
+        projectIdentity: deps.projectIdentity
+      };
+      await ensureProjectRegisteredFromPiDirectory(project.projectDir, deps.db);
+      const outcome = await embedSessionCompartmentChunks(deps.db, project.projectIdentity, sessionId);
+      const { text, level } = (() => {
+        switch (outcome.status) {
+          case "nothing":
+            return {
+              text: `## /ctx-embed-history
+
+All of this session's history is already embedded.`,
+              level: "info"
+            };
+          case "disabled":
+            return {
+              text: `## /ctx-embed-history
+
+No embedding provider is configured, so there is nothing to embed.`,
+              level: "info"
+            };
+          case "busy":
+            return {
+              text: `## /ctx-embed-history
+
+Embedding is already running for this project — ${outcome.total} compartment${outcome.total === 1 ? "" : "s"} still pending. Try again shortly.`,
+              level: "info"
+            };
+          case "stalled":
+            return {
+              text: `## /ctx-embed-history
+
+Embedded ${outcome.embedded} compartment${outcome.embedded === 1 ? "" : "s"}; ${outcome.remaining} could not be embedded (the provider returned no result). Run /ctx-embed-history again to retry them.`,
+              level: "info"
+            };
+          default:
+            return {
+              text: `## /ctx-embed-history
+
+Embedded ${outcome.embedded} compartment${outcome.embedded === 1 ? "" : "s"} of history for semantic search.`,
+              level: "success"
+            };
+        }
+      })();
+      sendCtxStatusMessage(pi, { title: "/ctx-embed-history", text, level }, {
+        sessionId,
+        projectIdentity: project.projectIdentity,
+        status: outcome.status,
+        embedded: outcome.embedded,
+        total: outcome.total
+      });
+    }
+  });
+}
+
 // ../plugin/src/hooks/magic-context/execute-flush.ts
 init_logger();
 function executeFlush(db, sessionId) {
@@ -168870,6 +170338,51 @@ function computePiWorkMetrics(sessionEntries) {
   return { newWorkTokens, totalInputTokens };
 }
 
+// ../plugin/src/hooks/magic-context/system-injection-stripper.ts
+var SYSTEM_INJECTION_MARKERS = [
+  "<!-- OMO_INTERNAL_INITIATOR -->",
+  "[SYSTEM DIRECTIVE: MAGIC-CONTEXT",
+  "[SYSTEM DIRECTIVE: OH-MY-OPENCODE",
+  "[Category+Skill Reminder]",
+  "[EDIT ERROR - IMMEDIATE ACTION REQUIRED]",
+  "[task CALL FAILED - IMMEDIATE RETRY REQUIRED]",
+  "[EMERGENCY CONTEXT WINDOW WARNING]",
+  "Unstable background agent appears idle",
+  "**THE SUBAGENT JUST CLAIMED THIS TASK IS DONE."
+];
+var SYSTEM_REMINDER_REGEX = /<system-reminder>[\s\S]*?<\/system-reminder>/gi;
+var OMO_MARKER_REGEX = /<!-- OMO_INTERNAL_INITIATOR -->/g;
+function stripSystemInjection(text) {
+  let hasInjection = false;
+  for (const marker of SYSTEM_INJECTION_MARKERS) {
+    if (text.includes(marker)) {
+      hasInjection = true;
+      break;
+    }
+  }
+  if (SYSTEM_REMINDER_REGEX.test(text))
+    hasInjection = true;
+  SYSTEM_REMINDER_REGEX.lastIndex = 0;
+  if (!hasInjection)
+    return null;
+  let cleaned = text;
+  cleaned = cleaned.replace(SYSTEM_REMINDER_REGEX, "");
+  cleaned = cleaned.replace(OMO_MARKER_REGEX, "");
+  cleaned = cleaned.replace(/\[SYSTEM DIRECTIVE: OH-MY-(?:OPENCODE|CLAUDE)[^\]]*\][\s\S]*?(?=\n\n(?!\s*[-*])|$)/g, "");
+  for (const marker of SYSTEM_INJECTION_MARKERS) {
+    if (marker.startsWith("<!-- ") || marker.startsWith("[SYSTEM DIRECTIVE"))
+      continue;
+    const idx = cleaned.indexOf(marker);
+    if (idx === -1)
+      continue;
+    const blockEnd = cleaned.indexOf(`
+
+`, idx + marker.length);
+    cleaned = blockEnd !== -1 ? cleaned.slice(0, idx) + cleaned.slice(blockEnd) : cleaned.slice(0, idx);
+  }
+  return cleaned.trim();
+}
+
 // ../plugin/src/hooks/magic-context/apply-operations.ts
 var USER_DROP_PREVIEW_CHARS = 250;
 var RECENT_TOOL_SKELETON_WINDOW = 20;
@@ -168879,6 +170392,10 @@ function buildReplacementContent(tagId, target) {
     return `[dropped §${tagId}§]`;
   }
   const currentContent = target.getContent?.() ?? "";
+  const strippedInjection = stripSystemInjection(currentContent);
+  if (strippedInjection !== null && stripTagPrefix(strippedInjection).trim().length === 0) {
+    return `[dropped §${tagId}§]`;
+  }
   const originalText = stripTagPrefix(currentContent);
   if (originalText.length <= USER_DROP_PREVIEW_CHARS) {
     return `[truncated §${tagId}§]
@@ -170487,8 +172004,8 @@ var CHANNEL1_SENTINEL = "<system-reminder>";
 var TOKENS_PER_BYTE = 0.25;
 var CHANNEL1_FLOOR_TOKENS = 1e4;
 var CHANNEL1_REFIRE_FLOOR_TOKENS = 1e4;
-function channel1RefireTokens(historyBudgetTokens) {
-  const scaled = Math.round(0.05 * Math.max(0, historyBudgetTokens));
+function channel1RefireTokens(workingWindowTokens) {
+  const scaled = Math.round(0.05 * Math.max(0, workingWindowTokens));
   return Math.max(CHANNEL1_REFIRE_FLOOR_TOKENS, scaled);
 }
 var S_GENTLE = 0.2;
@@ -170504,7 +172021,7 @@ function toolOutputTokens(output) {
   return Math.round(byteSize(output) * TOKENS_PER_BYTE);
 }
 function decideChannel1(input) {
-  const { undroppedTokens, pressure, historyBudgetTokens, hasRecentReduce } = input;
+  const { undroppedTokens, pressure, workingWindowTokens, hasRecentReduce } = input;
   const resetCycle = hasRecentReduce || undroppedTokens < input.lastNudgeUndropped;
   const lastNudge = resetCycle ? 0 : input.lastNudgeUndropped;
   const lastLevel = resetCycle ? "" : input.lastNudgeLevel;
@@ -170519,7 +172036,7 @@ function decideChannel1(input) {
     return quiet();
   if (undroppedTokens < CHANNEL1_FLOOR_TOKENS)
     return quiet();
-  const budget = historyBudgetTokens > 0 ? historyBudgetTokens : undroppedTokens || 1;
+  const budget = workingWindowTokens > 0 ? workingWindowTokens : undroppedTokens || 1;
   const severity = undroppedTokens / budget * pressure;
   if (severity < S_GENTLE)
     return quiet();
@@ -170531,7 +172048,7 @@ function decideChannel1(input) {
   else
     level = "gentle";
   if (lastLevel === "") {
-    if (undroppedTokens < lastNudge + channel1RefireTokens(historyBudgetTokens)) {
+    if (undroppedTokens < lastNudge + channel1RefireTokens(workingWindowTokens)) {
       return quiet();
     }
   } else if (LEVEL_RANK[level] <= LEVEL_RANK[lastLevel]) {
@@ -170576,13 +172093,13 @@ function buildChannel1Reminder(level, undroppedTokens) {
   let body;
   switch (level) {
     case "gentle":
-      body = `You have ~${amount} tokens of tool output you have not reduced. ` + `Once you are done with earlier outputs, drop them with ctx_reduce to keep context lean.`;
+      body = `You have ~${amount} tokens of tool output you have not reduced. ` + `When you are done with earlier outputs, dropping them with ctx_reduce keeps context lean.`;
       break;
     case "firm":
-      body = `~${amount} tokens of unreduced tool output is accumulating. ` + `Drop what you have already processed with ctx_reduce before continuing.`;
+      body = `~${amount} tokens of unreduced tool output has built up. ` + `At your next natural stopping point, consider dropping what you have already processed with ctx_reduce.`;
       break;
     case "urgent":
-      body = `~${amount} tokens of unreduced tool output remain. ` + `A large span of this session will be comparted soon; drop spent outputs with ctx_reduce first so the archived span is the part that matters.`;
+      body = `~${amount} tokens of unreduced tool output remain, and a large span of this session will be comparted before long. ` + `Consider dropping spent outputs with ctx_reduce so the archived span is the part that matters.`;
       break;
   }
   return `
@@ -170592,53 +172109,6 @@ ${body}
 </system-reminder>`;
 }
 
-// ../plugin/src/features/magic-context/memory/constants.ts
-var V2_MEMORY_CATEGORIES = [
-  "PROJECT_RULES",
-  "ARCHITECTURE",
-  "CONSTRAINTS",
-  "CONFIG_VALUES",
-  "NAMING"
-];
-var PROMOTABLE_CATEGORIES = [
-  "PROJECT_RULES",
-  "ARCHITECTURE",
-  "CONSTRAINTS",
-  "CONFIG_VALUES",
-  "NAMING",
-  "ARCHITECTURE_DECISIONS",
-  "CONFIG_DEFAULTS",
-  "USER_PREFERENCES",
-  "USER_DIRECTIVES",
-  "ENVIRONMENT",
-  "WORKFLOW_RULES",
-  "KNOWN_ISSUES"
-];
-var CATEGORY_PRIORITY = [
-  "PROJECT_RULES",
-  "ARCHITECTURE",
-  "CONSTRAINTS",
-  "CONFIG_VALUES",
-  "NAMING",
-  "USER_DIRECTIVES",
-  "USER_PREFERENCES",
-  "CONFIG_DEFAULTS",
-  "ARCHITECTURE_DECISIONS",
-  "ENVIRONMENT",
-  "WORKFLOW_RULES",
-  "KNOWN_ISSUES"
-];
-var MEMORY_CATEGORY_ORDER_UNKNOWN = 99;
-var MEMORY_CATEGORY_ORDER_PRIORITY = CATEGORY_PRIORITY.reduce((acc, category, index) => {
-  acc[category] = index;
-  return acc;
-}, {});
-var MEMORY_CATEGORY_ORDER_SQL = `CASE category ${CATEGORY_PRIORITY.map((category, index) => `WHEN '${category}' THEN ${index}`).join(" ")} ELSE ${MEMORY_CATEGORY_ORDER_UNKNOWN} END`;
-var CATEGORY_DEFAULT_TTL = {
-  WORKFLOW_RULES: 90 * 24 * 60 * 60 * 1000,
-  KNOWN_ISSUES: 30 * 24 * 60 * 60 * 1000
-};
-
 // ../plugin/src/shared/bounded-session-map.ts
 class BoundedSessionMap {
   maxEntries;
@@ -171049,26 +172519,40 @@ ${sections.join(`
 var DEFAULT_MEMORY_BUDGET_TOKENS = 8000;
 var MEMORY_BLOCK_WRAPPER_TOKENS = 6;
 var DEFAULT_USER_PROFILE_BUDGET_TOKENS = 4000;
+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;
+}
 var maxCompartmentSeqStatements = new WeakMap;
 var maxMemoryIdStatements = new WeakMap;
 var legacyCompartmentCountStatements = new WeakMap;
 var m0CompartmentStatements = new WeakMap;
 var newCompartmentStatements = new WeakMap;
-function trimMemoriesToBudgetV2(sessionId, memories, budgetTokens) {
-  const selectionOrder = [...memories].sort((a, b) => {
-    if (a.status === "permanent" && b.status !== "permanent")
-      return -1;
-    if (b.status === "permanent" && a.status !== "permanent")
-      return 1;
-    const importanceDiff = (b.importance ?? 50) - (a.importance ?? 50);
-    if (importanceDiff !== 0)
-      return importanceDiff;
-    return a.id - b.id;
-  });
+function trimMemoriesToBudgetV2(sessionId, memories, budgetTokens, renderOptions = {}) {
+  const selectionOrder = [...memories].sort(memorySelectionOrder);
   const selected = [];
   let usedTokens = MEMORY_BLOCK_WRAPPER_TOKENS;
   for (const 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);
@@ -171077,16 +172561,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 trimUserMemoriesToBudget(memories, budgetTokens) {
   const selected = [];
   let usedTokens = 0;
@@ -171099,15 +172637,16 @@ function trimUserMemoriesToBudget(memories, budgetTokens) {
   }
   return selected;
 }
-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(`
@@ -171701,7 +173240,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);
@@ -171792,6 +173331,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) {
@@ -171800,6 +173370,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;
@@ -171815,25 +173409,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 [];
@@ -171847,8 +173479,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);
     }
@@ -171890,7 +173525,8 @@ function mergeMemoryResults(args) {
       score,
       memoryId: memory.id,
       category: memory.category,
-      matchType
+      matchType,
+      sourceName: args.sourceNameByMemoryId?.get(memory.id)
     });
   }
   return results.sort((left, right) => {
@@ -171904,7 +173540,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 [];
   }
@@ -171912,26 +173548,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) {
@@ -171962,7 +173615,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;
@@ -171979,20 +173638,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;
@@ -172002,26 +173672,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;
@@ -172039,6 +173790,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;
   }
@@ -172089,10 +173843,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;
@@ -172108,6 +173864,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,
@@ -172116,6 +173890,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({
@@ -172126,7 +173902,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);
@@ -172186,6 +173962,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 = {}) {
@@ -172637,10 +174418,11 @@ function maybeChannel1ReminderForToolResult(args) {
     contextLimit: state.contextLimit,
     executeThresholdPercentage: state.executeThresholdPercentage
   });
+  const workingWindowTokens = Math.round(state.contextLimit * state.executeThresholdPercentage / 100);
   const decision = decideChannel1({
     undroppedTokens,
     pressure,
-    historyBudgetTokens: state.historyBudgetTokens,
+    workingWindowTokens,
     lastNudgeUndropped: getLastNudgeUndropped(db, sessionId),
     lastNudgeLevel: getLastNudgeLevel(db, sessionId),
     hasRecentReduce: false
@@ -172875,51 +174657,6 @@ function planEmergencyDrop(input) {
   };
 }
 
-// ../plugin/src/hooks/magic-context/system-injection-stripper.ts
-var SYSTEM_INJECTION_MARKERS = [
-  "<!-- OMO_INTERNAL_INITIATOR -->",
-  "[SYSTEM DIRECTIVE: MAGIC-CONTEXT",
-  "[SYSTEM DIRECTIVE: OH-MY-OPENCODE",
-  "[Category+Skill Reminder]",
-  "[EDIT ERROR - IMMEDIATE ACTION REQUIRED]",
-  "[task CALL FAILED - IMMEDIATE RETRY REQUIRED]",
-  "[EMERGENCY CONTEXT WINDOW WARNING]",
-  "Unstable background agent appears idle",
-  "**THE SUBAGENT JUST CLAIMED THIS TASK IS DONE."
-];
-var SYSTEM_REMINDER_REGEX = /<system-reminder>[\s\S]*?<\/system-reminder>/gi;
-var OMO_MARKER_REGEX = /<!-- OMO_INTERNAL_INITIATOR -->/g;
-function stripSystemInjection(text) {
-  let hasInjection = false;
-  for (const marker of SYSTEM_INJECTION_MARKERS) {
-    if (text.includes(marker)) {
-      hasInjection = true;
-      break;
-    }
-  }
-  if (SYSTEM_REMINDER_REGEX.test(text))
-    hasInjection = true;
-  SYSTEM_REMINDER_REGEX.lastIndex = 0;
-  if (!hasInjection)
-    return null;
-  let cleaned = text;
-  cleaned = cleaned.replace(SYSTEM_REMINDER_REGEX, "");
-  cleaned = cleaned.replace(OMO_MARKER_REGEX, "");
-  cleaned = cleaned.replace(/\[SYSTEM DIRECTIVE: OH-MY-(?:OPENCODE|CLAUDE)[^\]]*\][\s\S]*?(?=\n\n(?!\s*[-*])|$)/g, "");
-  for (const marker of SYSTEM_INJECTION_MARKERS) {
-    if (marker.startsWith("<!-- ") || marker.startsWith("[SYSTEM DIRECTIVE"))
-      continue;
-    const idx = cleaned.indexOf(marker);
-    if (idx === -1)
-      continue;
-    const blockEnd = cleaned.indexOf(`
-
-`, idx + marker.length);
-    cleaned = blockEnd !== -1 ? cleaned.slice(0, idx) + cleaned.slice(blockEnd) : cleaned.slice(0, idx);
-  }
-  return cleaned.trim();
-}
-
 // src/heuristic-cleanup-pi.ts
 init_logger();
 var DEDUP_SAFE_TOOLS = new Set([
@@ -173609,6 +175346,49 @@ function safeGetActiveUserMemoriesPi(db) {
 function memoryProjectPath(state) {
   return state.memoryEnabled === false ? undefined : state.projectIdentity;
 }
+function resolveWorkspaceRenderContextPi(state, db) {
+  const memPath = memoryProjectPath(state);
+  if (!memPath) {
+    return {
+      identities: [],
+      expandedIdentities: [],
+      ownIdentities: [],
+      shareCategories: null,
+      namesByIdentity: new Map,
+      canonicalIdentityByStoredPath: new Map,
+      isWorkspaced: false
+    };
+  }
+  const identitySet = resolveWorkspaceIdentitySet(db, memPath);
+  const isWorkspaced = identitySet.identities.length > 1;
+  const expanded = expandWorkspaceIdentitySetWithAliases(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) === memPath);
+  if (ownIdentities.length === 0 && expandedIdentities.includes(memPath)) {
+    ownIdentities = [memPath];
+  }
+  return {
+    identities: identitySet.identities,
+    expandedIdentities,
+    ownIdentities,
+    shareCategories: isWorkspaced ? resolveWorkspaceShareCategories(db, memPath) : null,
+    namesByIdentity: identitySet.namesByIdentity,
+    canonicalIdentityByStoredPath,
+    isWorkspaced
+  };
+}
+function sourceNamesForPiMemories(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;
+}
 var EMPTY_PI_HARD_SIGNALS = {
   systemHash: "",
   modelKey: "",
@@ -173656,6 +175436,7 @@ function getCachedMarkers(db, state, compartmentsForNormalization) {
     maxMutationId: meta3.cachedM0MaxMutationId,
     maxMemoryMutationId: meta3.cachedM0MaxMemoryMutationId,
     projectMemoryEpoch: meta3.cachedM0ProjectMemoryEpoch,
+    workspaceFingerprint: meta3.cachedM0WorkspaceFingerprint,
     projectUserProfileVersion: meta3.cachedM0ProjectUserProfileVersion,
     projectDocsHash: meta3.cachedM0ProjectDocsHash,
     sessionFactsVersion: meta3.cachedM0SessionFactsVersion,
@@ -173675,15 +175456,17 @@ function readCurrentMarkers(db, state, projectDocsHash) {
 }
 function readCurrentMarkersFromCompartments(db, state, compartments, projectDocsHash) {
   const memPath = memoryProjectPath(state);
-  const memories = memPath ? getMemoriesByProject(db, memPath, ["active", "permanent"]) : [];
+  const workspace = resolveWorkspaceRenderContextPi(state, db);
+  const maxMemoryId = memPath ? workspace.isWorkspaced ? getMaxMemoryIdForProjects(db, workspace.expandedIdentities, workspace.ownIdentities, workspace.shareCategories) : getMaxMemoryIdForProjects(db, [memPath]) : 0;
   const projectState = memPath ? getProjectState(db, memPath) : undefined;
   const globalState = getProjectState(db, GLOBAL_USER_PROFILE_PROJECT_PATH);
   return {
     maxCompartmentSeq: compartments.length > 0 ? compartments.reduce((max, compartment) => compartment.sequence > max ? compartment.sequence : max, EMPTY_MAX_COMPARTMENT_SEQ) : EMPTY_MAX_COMPARTMENT_SEQ,
-    maxMemoryId: memories.length > 0 ? memories.reduce((max, memory) => memory.id > max ? memory.id : max, 0) : 0,
+    maxMemoryId,
     maxMutationId: getMaxM0MutationId(db, state.sessionId) ?? 0,
-    maxMemoryMutationId: memPath ? getMaxMemoryMutationId(db, memPath) ?? 0 : 0,
+    maxMemoryMutationId: memPath ? workspace.isWorkspaced ? getMaxMemoryMutationIdForProjects(db, workspace.expandedIdentities) ?? 0 : getMaxMemoryMutationId(db, memPath) ?? 0 : 0,
     projectMemoryEpoch: projectState?.projectMemoryEpoch ?? 0,
+    workspaceFingerprint: workspace.isWorkspaced ? computeWorkspaceEpochFingerprint(db, workspace.identities) : null,
     projectUserProfileVersion: globalState?.projectUserProfileVersion ?? 0,
     projectDocsHash: projectDocsHash ?? readProjectDocsCanonical(state.projectDirectory).canonicalHash,
     sessionFactsVersion: getSessionFactsVersion(db, state.sessionId),
@@ -173721,10 +175504,11 @@ function mustMaterializePi(state, db, currentCompartmentsOverride) {
   if (meta3.cachedM0UpgradeState !== current.upgradeState) {
     return { value: true, reason: "renderer_upgrade" };
   }
-  if (current.projectDocsHash !== (meta3.cachedM0ProjectDocsHash ?? "")) {
-    return { value: true, reason: "project_docs_change" };
-  }
-  if (current.projectMemoryEpoch !== (meta3.cachedM0ProjectMemoryEpoch ?? 0)) {
+  if (current.workspaceFingerprint !== null || (meta3.cachedM0WorkspaceFingerprint ?? null) !== null) {
+    if (current.workspaceFingerprint !== (meta3.cachedM0WorkspaceFingerprint ?? null)) {
+      return { value: true, reason: "project_memory_change" };
+    }
+  } else if (current.projectMemoryEpoch !== (meta3.cachedM0ProjectMemoryEpoch ?? 0)) {
     return { value: true, reason: "project_memory_change" };
   }
   if (current.maxMutationId !== (meta3.cachedM0MaxMutationId ?? 0)) {
@@ -173741,11 +175525,19 @@ ${memories.map((memory) => `- ${escapeXmlContent(memory.content)}`).join(`
 `)}
 </${wrapper}>`;
 }
-function renderM0Pi(state, db, projectDocs = readProjectDocsCanonical(state.projectDirectory).renderedBlock, decayPressureMultiplier = 1, memoriesOverride, compartmentsOverride, userProfileOverride) {
+function renderM0Pi(state, db, projectDocs = readProjectDocsCanonical(state.projectDirectory).renderedBlock, decayPressureMultiplier = 1, memoriesOverride, compartmentsOverride, userProfileOverride, workspaceOverride) {
   const memPath = memoryProjectPath(state);
-  const allMemories = memoriesOverride ?? (memPath ? getMemoriesByProject(db, memPath, ["active", "permanent"]) : []);
-  const memories = allMemories.length > 0 ? trimMemoriesToBudgetV2(state.sessionId, allMemories, state.injectionBudgetTokens ?? DEFAULT_MEMORY_BUDGET_TOKENS).renderOrder : allMemories;
-  const memoryBlock = memories.length > 0 ? renderMemoryBlockV2(memories) : undefined;
+  const workspace = workspaceOverride ?? resolveWorkspaceRenderContextPi(state, db);
+  const allMemories = memoriesOverride ?? (memPath ? workspace.isWorkspaced ? getMemoriesByProjects(db, workspace.expandedIdentities, ["active", "permanent"], Date.now(), workspace.ownIdentities, workspace.shareCategories) : getMemoriesByProject(db, memPath, ["active", "permanent"]) : []);
+  const memoryRenderOptions = {
+    sourceNameByMemoryId: sourceNamesForPiMemories({
+      memories: allMemories,
+      projectPath: memPath,
+      workspace
+    })
+  };
+  const memories = allMemories.length > 0 ? workspace.isWorkspaced ? trimWorkspaceMemoriesToBudgetV2(state.sessionId, allMemories, state.injectionBudgetTokens ?? DEFAULT_MEMORY_BUDGET_TOKENS, workspace, memoryRenderOptions).renderOrder : trimMemoriesToBudgetV2(state.sessionId, allMemories, state.injectionBudgetTokens ?? DEFAULT_MEMORY_BUDGET_TOKENS).renderOrder : allMemories;
+  const memoryBlock = memories.length > 0 ? renderMemoryBlockV2(memories, "project-memory", memoryRenderOptions) : undefined;
   const baseHistoryBudget = state.historyBudgetTokens ?? DEFAULT_HISTORY_BUDGET_TOKENS;
   const decayed = renderDecayedCompartments({
     compartments: compartmentsOverride ?? getCompartments(db, state.sessionId),
@@ -173767,10 +175559,19 @@ ${decayed}
 
 `).trim();
 }
-function renderedMemoryIdsForPi(state, memories) {
+function renderedMemoryIdsForPi(state, memories, workspace, db) {
   if (memories.length === 0)
     return [];
-  return trimMemoriesToBudgetV2(state.sessionId, [...memories], state.injectionBudgetTokens ?? DEFAULT_MEMORY_BUDGET_TOKENS).renderOrder.map((memory) => memory.id);
+  const resolvedWorkspace = workspace ?? (db ? resolveWorkspaceRenderContextPi(state, db) : undefined);
+  const renderOptions = resolvedWorkspace ? {
+    sourceNameByMemoryId: sourceNamesForPiMemories({
+      memories,
+      projectPath: memoryProjectPath(state),
+      workspace: resolvedWorkspace
+    })
+  } : {};
+  const trimmed = resolvedWorkspace?.isWorkspaced ? trimWorkspaceMemoriesToBudgetV2(state.sessionId, [...memories], state.injectionBudgetTokens ?? DEFAULT_MEMORY_BUDGET_TOKENS, resolvedWorkspace, renderOptions) : trimMemoriesToBudgetV2(state.sessionId, [...memories], state.injectionBudgetTokens ?? DEFAULT_MEMORY_BUDGET_TOKENS);
+  return trimmed.renderOrder.map((memory) => memory.id);
 }
 function isTransientSqliteLockError(error51) {
   if (!error51 || typeof error51 !== "object")
@@ -173795,17 +175596,19 @@ class PiMaterializeContentionError extends Error {
 function readFrozenM0InputsPi(state, db, docs = readProjectDocsCanonical(state.projectDirectory), memoryCutoff) {
   const memPath = memoryProjectPath(state);
   const read = db.transaction(() => {
+    const workspace = resolveWorkspaceRenderContextPi(state, db);
     const compartments = getCompartments(db, state.sessionId);
-    const memories = memPath ? getMemoriesByProject(db, memPath, ["active", "permanent"], memoryCutoff) : [];
+    const memories = memPath ? workspace.isWorkspaced ? getMemoriesByProjects(db, workspace.expandedIdentities, ["active", "permanent"], memoryCutoff, workspace.ownIdentities, workspace.shareCategories) : getMemoriesByProject(db, memPath, ["active", "permanent"], memoryCutoff) : [];
     const userProfile = safeGetActiveUserMemoriesPi(db);
     const projectState = memPath ? getProjectState(db, memPath) : undefined;
     const globalState = getProjectState(db, GLOBAL_USER_PROFILE_PROJECT_PATH);
     const markers = {
       maxCompartmentSeq: compartments.reduce((max, compartment) => compartment.sequence > max ? compartment.sequence : max, EMPTY_MAX_COMPARTMENT_SEQ),
-      maxMemoryId: memories.reduce((max, memory) => memory.id > max ? memory.id : max, 0),
+      maxMemoryId: memPath ? workspace.isWorkspaced ? getMaxMemoryIdForProjects(db, workspace.expandedIdentities, workspace.ownIdentities, workspace.shareCategories) : getMaxMemoryIdForProjects(db, [memPath]) : 0,
       maxMutationId: getMaxM0MutationId(db, state.sessionId) ?? 0,
-      maxMemoryMutationId: memPath ? getMaxMemoryMutationId(db, memPath) ?? 0 : 0,
+      maxMemoryMutationId: memPath ? workspace.isWorkspaced ? getMaxMemoryMutationIdForProjects(db, workspace.expandedIdentities) ?? 0 : getMaxMemoryMutationId(db, memPath) ?? 0 : 0,
       projectMemoryEpoch: projectState?.projectMemoryEpoch ?? 0,
+      workspaceFingerprint: workspace.isWorkspaced ? computeWorkspaceEpochFingerprint(db, workspace.identities) : null,
       projectUserProfileVersion: globalState?.projectUserProfileVersion ?? 0,
       projectDocsHash: docs.canonicalHash,
       sessionFactsVersion: getSessionFactsVersion(db, state.sessionId),
@@ -173815,7 +175618,7 @@ function readFrozenM0InputsPi(state, db, docs = readProjectDocsCanonical(state.p
       systemHash: (state.hardSignals ?? EMPTY_PI_HARD_SIGNALS).systemHash,
       modelKey: (state.hardSignals ?? EMPTY_PI_HARD_SIGNALS).modelKey
     };
-    return { docs, markers, compartments, memories, userProfile };
+    return { docs, markers, compartments, memories, userProfile, workspace };
   });
   return read();
 }
@@ -173826,17 +175629,17 @@ function renderFreshM0PiNonPersisted(state, db) {
   frozen.markers.materializedAt = cachedMaterializedAt;
   const historyBudget = state.historyBudgetTokens ?? DEFAULT_HISTORY_BUDGET_TOKENS;
   let dpm = 1;
-  let m0 = renderM0Pi(state, db, docs.renderedBlock, dpm, frozen.memories, frozen.compartments, frozen.userProfile);
+  let m0 = renderM0Pi(state, db, docs.renderedBlock, dpm, frozen.memories, frozen.compartments, frozen.userProfile, frozen.workspace);
   let attempts = 0;
   while (historyBudget > 0 && historySliceTokensPi(m0) > historyBudget * 1.05 && attempts < 3) {
     dpm *= 1.15;
-    m0 = renderM0Pi(state, db, docs.renderedBlock, dpm, frozen.memories, frozen.compartments, frozen.userProfile);
+    m0 = renderM0Pi(state, db, docs.renderedBlock, dpm, frozen.memories, frozen.compartments, frozen.userProfile, frozen.workspace);
     attempts += 1;
   }
   return {
     m0,
     snapshotMarkers: frozen.markers,
-    renderedMemoryIds: renderedMemoryIdsForPi(state, frozen.memories)
+    renderedMemoryIds: renderedMemoryIdsForPi(state, frozen.memories, frozen.workspace, db)
   };
 }
 function materializeM0Pi(state, db) {
@@ -173846,14 +175649,14 @@ function materializeM0Pi(state, db) {
   const snapshotMemories = frozen.memories;
   const snapshotCompartments = frozen.compartments;
   const snapshotUserProfile = frozen.userProfile;
-  const renderedMemoryIds = renderedMemoryIdsForPi(state, snapshotMemories);
+  const renderedMemoryIds = renderedMemoryIdsForPi(state, snapshotMemories, frozen.workspace, db);
   let decayPressureMultiplier = 1;
-  let m0 = renderM0Pi(state, db, docs.renderedBlock, decayPressureMultiplier, snapshotMemories, snapshotCompartments, snapshotUserProfile);
+  let m0 = renderM0Pi(state, db, docs.renderedBlock, decayPressureMultiplier, snapshotMemories, snapshotCompartments, snapshotUserProfile, frozen.workspace);
   const historyBudget = state.historyBudgetTokens ?? DEFAULT_HISTORY_BUDGET_TOKENS;
   let attempts = 0;
   while (historyBudget > 0 && historySliceTokensPi(m0) > historyBudget * 1.05 && attempts < 3) {
     decayPressureMultiplier *= 1.15;
-    m0 = renderM0Pi(state, db, docs.renderedBlock, decayPressureMultiplier, snapshotMemories, snapshotCompartments, snapshotUserProfile);
+    m0 = renderM0Pi(state, db, docs.renderedBlock, decayPressureMultiplier, snapshotMemories, snapshotCompartments, snapshotUserProfile, frozen.workspace);
     attempts += 1;
   }
   const m0Bytes = Buffer.from(m0, "utf8");
@@ -173869,7 +175672,8 @@ function materializeM0Pi(state, db) {
   }
   try {
     const current = readCurrentMarkers(db, state, phase3ProjectDocsHash);
-    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) {
       db.exec("ROLLBACK");
       throw new PiMaterializeContentionError("snapshot changed before persist");
@@ -173880,6 +175684,7 @@ function materializeM0Pi(state, db) {
     persistCachedM0(db, state.sessionId, {
       m0Bytes,
       projectMemoryEpoch: snapshotMarkers.projectMemoryEpoch,
+      workspaceFingerprint: snapshotMarkers.workspaceFingerprint,
       projectUserProfileVersion: snapshotMarkers.projectUserProfileVersion,
       maxCompartmentSeq: snapshotMarkers.maxCompartmentSeq,
       maxMemoryId: snapshotMarkers.maxMemoryId,
@@ -173944,7 +175749,7 @@ function renderMemoryUpdatesBlockPi(args) {
   if (args.renderedMemoryIds.length === 0)
     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 = [
@@ -173975,6 +175780,7 @@ ${lines.join(`
 }
 function renderM1PiWithMetadata(state, db, markers, renderedMemoryIds, preRenderedKeyFilesBlock, compartmentsOverride) {
   const sections = [];
+  const workspace = resolveWorkspaceRenderContextPi(state, db);
   const keyFiles = renderedKeyFilesBlockPi(state, db, preRenderedKeyFilesBlock);
   if (keyFiles)
     sections.push(keyFiles);
@@ -173982,6 +175788,7 @@ function renderM1PiWithMetadata(state, db, markers, renderedMemoryIds, preRender
   const memoryUpdates = memPath ? renderMemoryUpdatesBlockPi({
     db,
     projectPath: memPath,
+    workspace,
     afterId: markers.maxMemoryMutationId,
     renderedMemoryIds
   }) : { block: undefined, count: 0 };
@@ -173996,11 +175803,18 @@ function renderM1PiWithMetadata(state, db, markers, renderedMemoryIds, preRender
 ${body}
 </new-compartments>`);
   }
-  const newMemories = memPath ? getMemoriesByProject(db, memPath, ["active", "permanent"], markers.materializedAt).filter((memory) => memory.id > markers.maxMemoryId) : [];
+  const newMemories = memPath ? workspace.isWorkspaced ? readNewMemoriesForM1Union(db, workspace.expandedIdentities, markers.maxMemoryId, markers.materializedAt, workspace.ownIdentities, workspace.shareCategories) : getMemoriesByProject(db, memPath, ["active", "permanent"], markers.materializedAt).filter((memory) => memory.id > markers.maxMemoryId) : [];
   if (newMemories.length > 0) {
     const memoryBudget = state.injectionBudgetTokens ?? DEFAULT_MEMORY_BUDGET_TOKENS;
-    const trimmedNewMemories = trimMemoriesToBudgetV2(state.sessionId, newMemories, Math.max(1, Math.floor(memoryBudget * 0.25))).renderOrder;
-    const newMemoriesBlock = renderMemoryBlockV2(trimmedNewMemories, "new-memories");
+    const memoryRenderOptions = {
+      sourceNameByMemoryId: sourceNamesForPiMemories({
+        memories: newMemories,
+        projectPath: memPath,
+        workspace
+      })
+    };
+    const trimmedNewMemories = trimMemoriesToBudgetV2(state.sessionId, newMemories, Math.max(1, Math.floor(memoryBudget * 0.25)), memoryRenderOptions).renderOrder;
+    const newMemoriesBlock = renderMemoryBlockV2(trimmedNewMemories, "new-memories", memoryRenderOptions);
     if (newMemoriesBlock)
       sections.push(newMemoriesBlock);
   }
@@ -174049,6 +175863,7 @@ function parseMemoryBlockIds(raw) {
 function readCachedPiM0M1Row(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,
@@ -174092,6 +175907,7 @@ function markersFromCachedPiRow(row, compartmentsForNormalization) {
     maxMutationId: row.cached_m0_max_mutation_id,
     maxMemoryMutationId: row.cached_m0_max_memory_mutation_id,
     projectMemoryEpoch: row.cached_m0_project_memory_epoch,
+    workspaceFingerprint: row.cached_m0_workspace_fingerprint,
     projectUserProfileVersion: row.cached_m0_project_user_profile_version,
     projectDocsHash: row.cached_m0_project_docs_hash ?? "",
     materializedAt: row.cached_m0_materialized_at,
@@ -174106,7 +175922,7 @@ function cachedPiRowMatchesSnapshot(args) {
   const rowMarkers = markersFromCachedPiRow(args.row, args.compartmentsForNormalization);
   if (!rowMarkers)
     return false;
-  return bufferEqualsNullable(args.row.cached_m0_bytes, args.m0Bytes) && rowMarkers.projectMemoryEpoch === args.markers.projectMemoryEpoch && rowMarkers.projectUserProfileVersion === args.markers.projectUserProfileVersion && rowMarkers.maxCompartmentSeq === args.markers.maxCompartmentSeq && rowMarkers.maxMemoryId === args.markers.maxMemoryId && rowMarkers.maxMutationId === args.markers.maxMutationId && rowMarkers.maxMemoryMutationId === args.markers.maxMemoryMutationId && (rowMarkers.projectDocsHash ?? "") === (args.markers.projectDocsHash ?? "") && rowMarkers.materializedAt === args.markers.materializedAt && rowMarkers.sessionFactsVersion === args.markers.sessionFactsVersion && (rowMarkers.upgradeState ?? null) === (args.markers.upgradeState ?? null) && (rowMarkers.systemHash ?? "") === (args.markers.systemHash ?? "") && (rowMarkers.modelKey ?? "") === (args.markers.modelKey ?? "");
+  return bufferEqualsNullable(args.row.cached_m0_bytes, args.m0Bytes) && rowMarkers.projectMemoryEpoch === args.markers.projectMemoryEpoch && rowMarkers.projectUserProfileVersion === args.markers.projectUserProfileVersion && rowMarkers.maxCompartmentSeq === args.markers.maxCompartmentSeq && rowMarkers.maxMemoryId === args.markers.maxMemoryId && rowMarkers.maxMutationId === args.markers.maxMutationId && rowMarkers.maxMemoryMutationId === args.markers.maxMemoryMutationId && rowMarkers.materializedAt === args.markers.materializedAt && rowMarkers.sessionFactsVersion === args.markers.sessionFactsVersion && (rowMarkers.upgradeState ?? null) === (args.markers.upgradeState ?? null) && (rowMarkers.systemHash ?? "") === (args.markers.systemHash ?? "") && (rowMarkers.modelKey ?? "") === (args.markers.modelKey ?? "") && (rowMarkers.workspaceFingerprint ?? null) === (args.markers.workspaceFingerprint ?? null);
 }
 function decodeCachedM1(row, sessionId) {
   if (!row.cached_m1_bytes) {
@@ -174317,14 +176133,14 @@ function injectM0M1Pi(state, db, piMessages, entryIds, recomputeM1ThisPass = fal
   const skippedVisibleMessages = boundaryId ? trimPiMessagesToBoundary(piMessages, entryIds, boundaryId) : 0;
   prependM0M1Messages(piMessages, m0, m1);
   sessionLog(state.sessionId, `injected m[0]/m[1] into Pi messages (${m0.length} + ${m1.length} bytes, materialized=${materialized}${decision.reason ? ` reason=${decision.reason}` : ""})`);
+  const memPath = memoryProjectPath(state);
+  const workspace = resolveWorkspaceRenderContextPi(state, db);
+  const memoryCount = memPath ? workspace.isWorkspaced ? getMemoriesByProjects(db, workspace.expandedIdentities, ["active", "permanent"], Date.now(), workspace.ownIdentities, workspace.shareCategories).length : getMemoriesByProject(db, memPath, ["active", "permanent"]).length : 0;
   return {
     injected: true,
     compartmentCount: getCompartments(db, state.sessionId).length,
     factCount: 0,
-    memoryCount: memoryProjectPath(state) ? getMemoriesByProject(db, memoryProjectPath(state), [
-      "active",
-      "permanent"
-    ]).length : 0,
+    memoryCount,
     skippedVisibleMessages,
     m0Materialized: materialized,
     m0Reason: decision.reason,
@@ -174385,21 +176201,48 @@ import * as crypto2 from "node:crypto";
 
 // ../plugin/src/features/magic-context/compartment-embedding.ts
 init_logger();
-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);
     }
   }
 }
@@ -177468,6 +179311,7 @@ async function runPiHistorian(deps) {
     fallbackModels,
     historianChunkTokens,
     boundarySnapshot: providedBoundarySnapshot,
+    refreshBoundarySnapshot,
     currentContextLimit,
     historianTimeoutMs = DEFAULT_HISTORIAN_TIMEOUT_MS2,
     twoPass,
@@ -177521,16 +179365,29 @@ async function runPiHistorian(deps) {
         return;
       }
       const offset = priorCompartments.length > 0 ? priorCompartments[priorCompartments.length - 1].endMessage + 1 : 1;
-      const boundarySnapshot = providedBoundarySnapshot ?? null;
+      let boundarySnapshot = providedBoundarySnapshot ?? null;
       if (!boundarySnapshot) {
         sessionLog(sessionId, "historian no-op: missing protected-tail boundary snapshot from Pi trigger decision");
         return;
       }
-      const validation = boundarySnapshot.rawRangeFingerprint.length > 0 ? validateBoundarySnapshot({
+      let validation = boundarySnapshot.rawRangeFingerprint.length > 0 ? validateBoundarySnapshot({
         db,
         snapshot: boundarySnapshot,
         currentContextLimit: currentContextLimit ?? boundarySnapshot.contextLimit
       }) : { ok: true };
+      if (!validation.ok && validation.reason === "stale_snapshot" && refreshBoundarySnapshot) {
+        try {
+          const refreshed = refreshBoundarySnapshot();
+          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 };
+          }
+        } catch (error51) {
+          const desc = describeError(error51);
+          sessionLog(sessionId, `historian: failed to refresh stale protected-tail snapshot at run time (${validation.detail ?? "stale"}): ${desc.brief}`);
+        }
+      }
       if (!validation.ok) {
         sessionLog(sessionId, `historian no-op: stale protected-tail snapshot (${validation.detail ?? validation.reason ?? "unknown"})`);
         return;
@@ -177859,8 +179716,13 @@ ${chunkText}`,
         }
       }
       if (embeddingActive) {
-        const toEmbed = newCompartments.map((c, i) => ({ id: persistedIds[i], p1: c.p1 ?? c.content })).filter((c) => typeof c.id === "number" && c.p1.length > 0);
-        embedAndStoreCompartments(db, sessionId, projectPath, toEmbed);
+        const chunksToEmbed = newCompartments.map((c, i) => ({
+          id: persistedIds[i],
+          startMessage: c.startMessage,
+          endMessage: c.endMessage,
+          sourceChunkText: chunk.text
+        })).filter((c) => typeof c.id === "number");
+        embedAndStoreCompartmentChunks(db, sessionId, projectPath, chunksToEmbed);
       }
       onPublished?.();
       completedSuccessfully = true;
@@ -178408,7 +180270,7 @@ function stripPiDroppedPlaceholderMessages(args) {
 }
 
 // src/system-prompt.ts
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash11 } from "node:crypto";
 
 // ../plugin/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
@@ -178559,7 +180421,7 @@ function processSystemPromptForCache(args) {
       sessionLog(sessionId, `system prompt date frozen: real=${liveDate}, using=${stickyDate} (cache-stable pass)`);
     }
   }
-  const currentHash = createHash9("md5").update(frozenPrompt).digest("hex");
+  const currentHash = createHash11("md5").update(frozenPrompt).digest("hex");
   const hashChanged = !isFirstHash && currentHash !== previousHash;
   if (hashChanged) {
     sessionLog(sessionId, `system prompt hash changed: ${previousHash} → ${currentHash} (len=${frozenPrompt.length})`);
@@ -179186,6 +181048,19 @@ function extractStableId(msg, index, entryIds) {
 // src/context-handler.ts
 var FORCE_MATERIALIZATION_PERCENTAGE = 85;
 var EMERGENCY_BLOCK_PERCENTAGE = 95;
+var FORWARD_PRESSURE_LIMIT_FACTOR = 0.85;
+function applyForwardPressureFloor(trailingPercentage, trailingInputTokens, piUsageTokens, correctedLimit) {
+  const forwardTokens = typeof piUsageTokens === "number" && piUsageTokens > 0 ? piUsageTokens : 0;
+  if (forwardTokens === 0 || !isSaneLimit(correctedLimit)) {
+    return { percentage: trailingPercentage, inputTokens: trailingInputTokens };
+  }
+  const forwardPressureLimit = correctedLimit * FORWARD_PRESSURE_LIMIT_FACTOR;
+  const forwardPercentage = forwardTokens / forwardPressureLimit * 100;
+  return forwardPercentage > trailingPercentage ? {
+    percentage: forwardPercentage,
+    inputTokens: Math.max(trailingInputTokens, forwardTokens)
+  } : { percentage: trailingPercentage, inputTokens: trailingInputTokens };
+}
 var DEFAULT_CLEAR_REASONING_AGE = 50;
 var PI_STABLE_ID_SCHEME = 1;
 var lastEmergencyNotificationAtMs = new Map;
@@ -179270,7 +181145,7 @@ function trackSessionForProject(projectIdentity, sessionId) {
 function isContextHandlerSessionActive(sessionId) {
   return activeContextHandlerSessions.has(sessionId);
 }
-function updateSessionProjectTracking(sessionId, projectIdentity) {
+function updateSessionProjectTracking(sessionId, projectIdentity, db) {
   const prev = lastSeenProjectIdentityBySession.get(sessionId);
   if (prev && prev !== projectIdentity) {
     const prevSessions = sessionsByProject.get(prev);
@@ -179279,6 +181154,11 @@ function updateSessionProjectTracking(sessionId, projectIdentity) {
       sessionsByProject.delete(prev);
     clearPiSystemPromptSession(sessionId);
   }
+  if (db && prev !== projectIdentity) {
+    try {
+      recordSessionProjectIdentity(db, sessionId, projectIdentity);
+    } catch {}
+  }
   trackSessionForProject(projectIdentity, sessionId);
   lastSeenProjectIdentityBySession.set(sessionId, projectIdentity);
 }
@@ -179559,7 +181439,7 @@ function registerPiContextHandler(pi, baseOptions) {
       const schedulerConfig = options.scheduler ?? DEFAULT_SCHEDULER_CONFIG;
       const scheduler2 = schedulerFor(options);
       const projectIdentity = resolveProjectIdentity(projectDirectory);
-      updateSessionProjectTracking(sessionId, projectIdentity);
+      updateSessionProjectTracking(sessionId, projectIdentity, options.db);
       logTransformTiming(sessionId, "findSessionId", tFindSession, `messages=${event.messages.length}`);
       const branchEntries = readPiBranchEntriesForContext(ctx, sessionId);
       const rawMessageProvider = {
@@ -179668,9 +181548,10 @@ function registerPiContextHandler(pi, baseOptions) {
       if (!usedPersistedUsage && isSaneLimit(usageContextLimit) && usageInputTokens > 0) {
         usagePercentage = usageInputTokens / usageContextLimit * 100;
       }
+      ({ percentage: usagePercentage, inputTokens: usageInputTokens } = applyForwardPressureFloor(usagePercentage, usageInputTokens, piUsage?.tokens, usageContextLimit));
       if (needsEmergencyBump) {
         sessionLog(sessionId, `transform: overflow recovery flag set — bumping percentage to 95% (detectedLimit=${usageContextLimit ?? "unknown"})`);
-        usagePercentage = 95;
+        usagePercentage = Math.max(usagePercentage, 95);
       }
       let schedulerDecision;
       const tScheduler = performance.now();
@@ -179895,7 +181776,7 @@ function registerPiContextHandler(pi, baseOptions) {
           let tailToolTokens;
           let liveTailTokens;
           try {
-            const agg = getActiveTagTokenAggregate(options.db, sessionId);
+            const agg = getActiveTagTokenAggregate(options.db, sessionId, options.protectedTags ?? 20);
             tailToolTokens = agg.toolOutput;
             liveTailTokens = agg.conversation + agg.toolCall;
           } catch {
@@ -180054,6 +181935,7 @@ function spawnPiHistorianRun(args) {
     provider: provider2,
     unregister,
     boundarySnapshot,
+    refreshBoundarySnapshot,
     currentContextLimit
   } = args;
   const holderId = crypto3.randomUUID();
@@ -180077,6 +181959,7 @@ function spawnPiHistorianRun(args) {
         fallbackModels: historian.fallbackModels,
         historianChunkTokens: historian.historianChunkTokens,
         boundarySnapshot,
+        refreshBoundarySnapshot,
         currentContextLimit,
         historianTimeoutMs: historian.timeoutMs,
         twoPass: historian.twoPass,
@@ -180143,6 +182026,7 @@ function maybeFireHistorian(args) {
   let usageContextLimit;
   try {
     const piUsage = ctx.getContextUsage?.();
+    let usageSource;
     usageContextLimit = isSaneLimit(piUsage?.contextWindow) ? piUsage.contextWindow : undefined;
     if (usageContextLimit === undefined && isSaneLimit(ctx.model?.contextWindow)) {
       usageContextLimit = ctx.model.contextWindow;
@@ -180159,7 +182043,7 @@ function maybeFireHistorian(args) {
         percentage: sessionMetaForUsage.lastContextPercentage,
         inputTokens: sessionMetaForUsage.lastInputTokens
       };
-      sessionLog(sessionId, `historian trigger eval: usage=${usage.percentage.toFixed(1)}% (${usage.inputTokens} tokens) [from session_meta], checking trigger...`);
+      usageSource = "session_meta";
     } else {
       if (!piUsage || piUsage.tokens === null || piUsage.percent === null || piUsage.contextWindow === 0) {
         sessionLog(sessionId, `historian trigger eval: no usage info yet (tokens=${piUsage?.tokens ?? "<no piUsage>"}, percent=${piUsage?.percent ?? "<no piUsage>"}, contextWindow=${piUsage?.contextWindow ?? "<no piUsage>"})`);
@@ -180170,8 +182054,10 @@ function maybeFireHistorian(args) {
         percentage: fallbackPercentage,
         inputTokens: piUsage.tokens
       };
-      sessionLog(sessionId, `historian trigger eval: usage=${usage.percentage.toFixed(1)}% (${usage.inputTokens} tokens) [piUsage fallback], checking trigger...`);
+      usageSource = "piUsage fallback";
     }
+    usage = applyForwardPressureFloor(usage.percentage, usage.inputTokens, piUsage?.tokens, usageContextLimit);
+    sessionLog(sessionId, `historian trigger eval: usage=${usage.percentage.toFixed(1)}% (${usage.inputTokens} tokens) [${usageSource}], checking trigger...`);
   } catch (err) {
     sessionLog(sessionId, `historian trigger eval: getContextUsage threw: ${err instanceof Error ? err.message : String(err)}`);
     return;
@@ -180202,10 +182088,14 @@ function maybeFireHistorian(args) {
     cacheNamespace: `pi:${sessionId}`,
     emergencyTailScale
   }));
-  let boundarySnapshot = ensureRunnablePiBoundaryForTests(resolvePiBoundarySnapshot());
-  if (!hasRunnableCompartmentWindow(boundarySnapshot) && usage.percentage >= 80) {
-    boundarySnapshot = ensureRunnablePiBoundaryForTests(resolvePiBoundarySnapshot(usage.percentage >= 95 ? 0.25 : 0.5));
-  }
+  const resolveRunnablePiBoundarySnapshot = () => {
+    let snapshot = ensureRunnablePiBoundaryForTests(resolvePiBoundarySnapshot());
+    if (!hasRunnableCompartmentWindow(snapshot) && usage.percentage >= 80) {
+      snapshot = ensureRunnablePiBoundaryForTests(resolvePiBoundarySnapshot(usage.percentage >= 95 ? 0.25 : 0.5));
+    }
+    return snapshot;
+  };
+  const boundarySnapshot = resolveRunnablePiBoundarySnapshot();
   let triggered = false;
   try {
     if (isFirstContextPassForSession) {
@@ -180230,6 +182120,7 @@ Historian previously failed ${failureState.failureCount} time(s), so Magic Conte
           provider: provider2,
           unregister,
           boundarySnapshot,
+          refreshBoundarySnapshot: resolveRunnablePiBoundarySnapshot,
           currentContextLimit: boundaryContextLimit
         });
         return;
@@ -180238,6 +182129,15 @@ Historian previously failed ${failureState.failureCount} time(s), so Magic Conte
     const trigger = checkCompartmentTrigger(db, sessionId, sessionMeta, usage, 0, triggerInputs.executeThresholdPercentage, triggerInputs.triggerBudget, triggerInputs.clearReasoningAge, triggerInputs.commitClusterTrigger, args.activeTags, boundaryContextLimit);
     if (!trigger.shouldFire) {
       sessionLog(sessionId, `historian trigger eval: shouldFire=false (no trigger condition met)`);
+      try {
+        const overflowState = getOverflowState(db, sessionId);
+        if (overflowState.needsEmergencyRecovery && usage.percentage < FORCE_MATERIALIZATION_PERCENTAGE && !inFlightHistorian.has(sessionId) && !hasRunnableCompartmentWindow(boundarySnapshot)) {
+          clearEmergencyRecovery(db, sessionId);
+          sessionLog(sessionId, `historian: disarming stale emergency recovery — real pressure ${usage.percentage.toFixed(1)}% with no runnable compartment window (would otherwise bump to 95% every pass)`);
+        }
+      } catch (err) {
+        sessionLog(sessionId, `historian: emergency-recovery disarm check failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
       return;
     }
     triggered = true;
@@ -180253,6 +182153,7 @@ Historian previously failed ${failureState.failureCount} time(s), so Magic Conte
         resolvedBoundarySnapshot: boundarySnapshot,
         triggerBoundarySnapshot: trigger.boundarySnapshot
       }),
+      refreshBoundarySnapshot: resolveRunnablePiBoundarySnapshot,
       currentContextLimit: boundaryContextLimit
     });
   } catch (err) {
@@ -180293,7 +182194,31 @@ async function runPipeline(args) {
   const alreadyRanHeuristicsThisTurn = currentTurnId !== null && lastHeuristicsTurnIdBySession.get(args.sessionId) === currentTurnId;
   const canConsumeDeferredLate = args.schedulerDecision === "execute" || args.forceMaterialization === true || args.contextUsage.percentage >= FORCE_MATERIALIZATION_PERCENTAGE;
   const deferredMaterializeEligible = canConsumeDeferredLate && deferredMaterializationSessions.has(args.sessionId);
-  const shouldRunHeuristics = args.heuristics !== undefined && (args.forceMaterialization === true || hasPendingMaterialization(args.sessionId) || deferredMaterializeEligible || args.schedulerDecision === "execute" && !alreadyRanHeuristicsThisTurn);
+  const piHardSignals = args.injection ? (() => {
+    const hardMeta = getOrCreateSessionMeta(args.db, args.sessionId);
+    let piTtlMs = 5 * 60 * 1000;
+    try {
+      piTtlMs = parseCacheTtl(hardMeta.cacheTtl);
+    } catch {}
+    return {
+      systemHash: typeof hardMeta.systemPromptHash === "string" ? hardMeta.systemPromptHash : "",
+      modelKey: liveModelBySession.get(args.sessionId) ?? "",
+      cacheExpired: hardMeta.lastResponseTime > 0 && Date.now() - hardMeta.lastResponseTime >= piTtlMs,
+      lastResponseTime: hardMeta.lastResponseTime
+    };
+  })() : undefined;
+  const m0HardFoldThisPass = args.injection && piHardSignals ? mustMaterializePi({
+    sessionId: args.sessionId,
+    projectIdentity: args.projectIdentity,
+    projectDirectory: args.projectDirectory,
+    memoryEnabled: args.injection.memoryEnabled,
+    injectionBudgetTokens: args.injection.injectionBudgetTokens,
+    historyBudgetTokens: args.injection.historyBudgetTokens,
+    keyFilesEnabled: args.injection.keyFilesEnabled,
+    keyFilesTokenBudget: args.injection.keyFilesTokenBudget,
+    hardSignals: piHardSignals
+  }, args.db, getCompartments(args.db, args.sessionId)).value : false;
+  const shouldRunHeuristics = args.heuristics !== undefined && (args.forceMaterialization === true || hasPendingMaterialization(args.sessionId) || deferredMaterializeEligible || m0HardFoldThisPass || args.schedulerDecision === "execute" && !alreadyRanHeuristicsThisTurn);
   const entryFingerprintByMessageId = buildEntryFingerprintMap(args.messages, stableIdResolver);
   adoptPiFallbackTags(args.db, args.sessionId, args.tagger, entryFingerprintByMessageId);
   const tTag = performance.now();
@@ -180320,12 +182245,12 @@ async function runPipeline(args) {
   const deferredMaterializationWasPending = deferredMaterializationSessions.has(args.sessionId);
   const deferredHistoryRefreshWasPending = deferredHistoryWasPendingAtPassStart;
   const pendingOps = getPendingOps(args.db, args.sessionId);
-  const baseShouldApplyPendingOps = args.schedulerDecision === "execute" || args.forceMaterialization || hasPendingMaterializeSignal;
+  const baseShouldApplyPendingOps = args.schedulerDecision === "execute" || args.forceMaterialization || hasPendingMaterializeSignal || m0HardFoldThisPass;
   const deferredMaterialize = canConsumeDeferredLate && deferredMaterializationWasPending;
   const deferredHistoryRefresh = canConsumeDeferredLate && deferredHistoryRefreshWasPending;
   const shouldApplyPendingOps = baseShouldApplyPendingOps || deferredMaterialize;
   if (shouldApplyPendingOps) {
-    const applyReason = hasPendingMaterializeSignal ? "explicit_flush" : deferredMaterialize ? "deferred_publication" : args.forceMaterialization ? "force_materialization" : `scheduler_execute (scheduler=${args.schedulerDecision})`;
+    const applyReason = hasPendingMaterializeSignal ? "explicit_flush" : deferredMaterialize ? "deferred_publication" : args.forceMaterialization ? "force_materialization" : m0HardFoldThisPass && args.schedulerDecision !== "execute" ? `m0_hard_fold (drain folded into known m[0] bust, scheduler=${args.schedulerDecision})` : `scheduler_execute (scheduler=${args.schedulerDecision})`;
     sessionLog(args.sessionId, `pending ops WILL APPLY — reason=${applyReason}, pendingOps=${pendingOps.length}, context=${args.contextUsage.percentage.toFixed(1)}%`);
     try {
       const tApplyPending = performance.now();
@@ -180396,7 +182321,7 @@ async function runPipeline(args) {
   const activeTags = getActiveTagsBySession(args.db, args.sessionId);
   logTransformTiming(args.sessionId, "getActiveTagsBySession", tActiveTags, `count=${activeTags.length}`);
   if (shouldRunHeuristics) {
-    const reason = args.forceMaterialization ? "force_materialization" : `scheduler_execute (pendingOps=${pendingOps.length}, scheduler=${args.schedulerDecision})`;
+    const reason = args.forceMaterialization ? "force_materialization" : m0HardFoldThisPass && args.schedulerDecision !== "execute" ? `m0_hard_fold (drain folded into known m[0] bust, 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=n/a`);
   } else {
     const reason = args.heuristics === undefined ? "disabled" : "scheduler_defer";
@@ -180484,17 +182409,6 @@ async function runPipeline(args) {
   if (args.injection) {
     try {
       const tInjection = performance.now();
-      const hardMeta = getOrCreateSessionMeta(args.db, args.sessionId);
-      let piTtlMs = 5 * 60 * 1000;
-      try {
-        piTtlMs = parseCacheTtl(hardMeta.cacheTtl);
-      } catch {}
-      const piHardSignals = {
-        systemHash: typeof hardMeta.systemPromptHash === "string" ? hardMeta.systemPromptHash : "",
-        modelKey: liveModelBySession.get(args.sessionId) ?? "",
-        cacheExpired: hardMeta.lastResponseTime > 0 && Date.now() - hardMeta.lastResponseTime >= piTtlMs,
-        lastResponseTime: hardMeta.lastResponseTime
-      };
       injectionResult = injectM0M1Pi({
         sessionId: args.sessionId,
         projectIdentity: args.projectIdentity,
@@ -181584,8 +183498,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) {
@@ -181798,8 +183716,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);
@@ -181956,8 +183878,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) {
@@ -182403,7 +184329,7 @@ function renderStatusText(ctx, db, sessionId) {
   const pct = typeof usage?.percent === "number" ? usage.percent : undefined;
   const meta3 = readSessionMetaStatus(db, sessionId);
   const state = renderHistorianState(meta3, recompSessions.has(sessionId));
-  return `mc: ${inputTokens === undefined ? "--" : fmt(inputTokens)} (${pct === undefined ? "--" : `${Math.round(pct)}%`}) · ${state}`;
+  return `MC: ${inputTokens === undefined ? "--" : fmt(inputTokens)} (${pct === undefined ? "--" : `${Math.round(pct)}%`}) · ${state}`;
 }
 function renderHistorianState(meta3, recompActive) {
   const failureCount = meta3?.historian_failure_count ?? 0;
@@ -182592,6 +184518,11 @@ Historian recomp started. Rebuilding compartments and facts from raw Pi session
             fallbackModelId: ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined
           }, parsed.kind === "partial" ? { range: parsed.range } : {});
           if (result.published) {
+            try {
+              clearEmergencyRecovery(deps.db, sessionId);
+            } catch (recoveryError) {
+              sessionLog(sessionId, `/ctx-recomp: clearEmergencyRecovery failed (continuing): ${describeError(recoveryError).brief}`);
+            }
             try {
               stagePiRecompMarker({ db: deps.db, sessionId, ctx });
             } catch (markerError) {
@@ -182769,7 +184700,7 @@ function applyMemoryMigration(db, projectPath, result) {
       inserted++;
     }
     if (removed > 0 || inserted > 0) {
-      bumpProjectMemoryEpoch(db, projectPath);
+      bumpEpochsForWorkspaceMembers(db, projectPath);
     }
   })();
   return { removed, inserted };
@@ -183245,7 +185176,7 @@ function formatThresholdPercent(value) {
 // package.json
 var package_default = {
   name: "@wolfx/pi-magic-context",
-  version: "0.23.1",
+  version: "0.24.1",
   type: "module",
   description: "Pi coding agent extension for Magic Context — cross-session memory and context management",
   main: "dist/index.js",
@@ -188136,6 +190067,23 @@ function createCtxMemoryTool(deps) {
       }
       const projectIdentity = resolveProjectIdentity(ctx.cwd);
       await deps.ensureProjectRegistered?.(ctx.cwd, deps.db);
+      const workspaceIdentitySet = resolveWorkspaceIdentitySet(deps.db, projectIdentity);
+      const expandedWorkspace = expandWorkspaceIdentitySetWithAliases(deps.db, workspaceIdentitySet.identities);
+      const workspaceVisibleIdentities = workspaceIdentitySet.identities.length > 1 ? expandedWorkspace.expandedIdentities : workspaceIdentitySet.identities;
+      const targetIdentityForStoredPath = (rawProjectPath) => workspaceIdentitySet.identities.length > 1 ? resolveStoredPathWorkspaceIdentity(rawProjectPath, workspaceIdentitySet.identities, expandedWorkspace.canonicalIdentityByStoredPath) ?? normalizeStoredProjectPath(rawProjectPath) : normalizeStoredProjectPath(rawProjectPath);
+      const toolShareCategories = workspaceIdentitySet.identities.length > 1 ? resolveWorkspaceShareCategories(deps.db, projectIdentity) : null;
+      const memoryVisibleToTool = (memory2) => {
+        if (workspaceIdentitySet.identities.length <= 1) {
+          return storedPathBelongsToIdentity(memory2.projectPath, projectIdentity);
+        }
+        if (!storedPathBelongsToWorkspace(memory2.projectPath, workspaceIdentitySet.identities, workspaceVisibleIdentities, expandedWorkspace.canonicalIdentityByStoredPath)) {
+          return false;
+        }
+        const isOwn = targetIdentityForStoredPath(memory2.projectPath) === projectIdentity;
+        if (isOwn)
+          return true;
+        return toolShareCategories === null || toolShareCategories.includes(memory2.category);
+      };
       const snapshot = getProjectEmbeddingSnapshot(projectIdentity);
       if (snapshot ? !snapshot.features.memoryEnabled : deps.memoryEnabled === false) {
         return err2("Cross-session memory is disabled for this project.");
@@ -188182,28 +190130,34 @@ function createCtxMemoryTool(deps) {
           return err2("Error: 'content' is required when action is 'update'.");
         }
         const memory2 = getMemoryById(deps.db, updateId);
-        if (!memory2 || !storedPathBelongsToIdentity(memory2.projectPath, projectIdentity)) {
+        if (!memory2 || !memoryVisibleToTool(memory2)) {
           return err2(`Error: Memory with ID ${updateId} was not found.`);
         }
         if (!dreamerAllowed && !isPrimaryMutableMemory(memory2)) {
           return err2(inactiveMemoryError(updateId, "updating"));
         }
         const normalizedHash = computeNormalizedHash(content);
-        const duplicate = getMemoryByHash(deps.db, projectIdentity, memory2.category, normalizedHash);
+        const targetIdentity = targetIdentityForStoredPath(memory2.projectPath);
+        const duplicate = getMemoryByHash(deps.db, targetIdentity, memory2.category, normalizedHash);
         if (duplicate && duplicate.id !== memory2.id) {
           return err2(`Error: Memory content already exists as ID ${duplicate.id}; merge or archive duplicates instead.`);
         }
         deps.db.transaction(() => {
           updateMemoryContent(deps.db, memory2.id, content, normalizedHash);
           queueMemoryMutation(deps.db, {
-            projectPath: projectIdentity,
+            projectPath: targetIdentity,
             mutationType: "update",
             targetMemoryId: memory2.id,
             category: memory2.category,
             newContent: content
           });
         })();
-        queueEmbedding({ deps, projectIdentity, memoryId: memory2.id, content });
+        queueEmbedding({
+          deps,
+          projectIdentity: targetIdentity,
+          memoryId: memory2.id,
+          content
+        });
         return ok2(`Updated memory [ID: ${memory2.id}] in ${memory2.category}.`);
       }
       if (params.action === "merge") {
@@ -188223,7 +190177,7 @@ function createCtxMemoryTool(deps) {
           return err2("Error: One or more source memories were not found.");
         }
         if (!dreamerAllowed) {
-          const foreign = sourceMemories.find((memory2) => !storedPathBelongsToIdentity(memory2.projectPath, projectIdentity));
+          const foreign = sourceMemories.find((memory2) => !memoryVisibleToTool(memory2));
           if (foreign) {
             return err2(`Error: Memory with ID ${foreign.id} was not found.`);
           }
@@ -188312,26 +190266,36 @@ function createCtxMemoryTool(deps) {
         return ok2(`Merged memories [${ids.join(", ")}] into canonical memory [ID: ${canonicalMemory.id}] in ${category}; superseded [${supersededIds.join(", ")}].`);
       }
       if (params.action === "archive") {
-        const archiveIds = params.ids;
-        if (!archiveIds || archiveIds.length === 0 || !archiveIds.every(Number.isInteger)) {
+        const rawArchiveIds = params.ids;
+        if (!rawArchiveIds || rawArchiveIds.length === 0 || !rawArchiveIds.every(Number.isInteger)) {
           return err2("Error: 'ids' must contain at least one integer memory ID when action is 'archive'.");
         }
+        const archiveIds = [...new Set(rawArchiveIds)];
         for (const memoryId of archiveIds) {
           const memory2 = getMemoryById(deps.db, memoryId);
-          if (!memory2 || !storedPathBelongsToIdentity(memory2.projectPath, projectIdentity)) {
+          if (!memory2 || !memoryVisibleToTool(memory2)) {
             return err2(`Error: Memory with ID ${memoryId} was not found.`);
           }
           if (!dreamerAllowed && !isPrimaryMutableMemory(memory2)) {
             return err2(inactiveMemoryError(memoryId, "archiving"));
           }
         }
+        const targets = archiveIds.map((memoryId) => {
+          const memory2 = getMemoryById(deps.db, memoryId);
+          if (!memory2)
+            throw new Error(`validated memory ${memoryId} disappeared`);
+          return {
+            memoryId,
+            projectIdentity: targetIdentityForStoredPath(memory2.projectPath)
+          };
+        });
         deps.db.transaction(() => {
-          for (const memoryId of archiveIds) {
-            archiveMemory(deps.db, memoryId, params.reason);
+          for (const target2 of targets) {
+            archiveMemory(deps.db, target2.memoryId, params.reason);
             queueMemoryMutation(deps.db, {
-              projectPath: projectIdentity,
+              projectPath: target2.projectIdentity,
               mutationType: "archive",
-              targetMemoryId: memoryId
+              targetMemoryId: target2.memoryId
             });
           }
         })();
@@ -188839,8 +190803,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(`
 `);
@@ -188850,6 +190815,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);
@@ -188865,7 +190837,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(`
@@ -189361,6 +191333,14 @@ async function src_default2(pi) {
     onProjectSeen: (identity) => seenDreamerProjectIdentities.add(identity)
   });
   info("registered /ctx-dream");
+  registerCtxEmbedHistoryCommand(pi, {
+    db,
+    projectDir,
+    projectIdentity,
+    memoryEnabled: config2.memory.enabled,
+    resolveProject: resolveCurrentProject
+  });
+  info("registered /ctx-embed-history");
   const dreamerConfig = resolveDreamerFromConfig(config2);
   if (dreamerConfig) {
     registerPiDreamerProject({