memorix 1.2.9 → 1.3.0

package/dist/cli/index.js

@@ -3212,7 +3212,7 @@ ${import_picocolors.default.gray(m3)}  ${s2}
 
 // src/cli/version.ts
 function getCliVersion() {
-  return true ? "1.2.9" : pkg.version;
+  return true ? "1.3.0" : pkg.version;
 }
 var init_version = __esm({
   "src/cli/version.ts"() {
@@ -3529,15 +3529,15 @@ function getDocumentProperties(doc, paths) {
   const properties = {};
   const pathsLength = paths.length;
   for (let i2 = 0; i2 < pathsLength; i2++) {
-    const path37 = paths[i2];
-    const pathTokens = path37.split(".");
+    const path38 = paths[i2];
+    const pathTokens = path38.split(".");
     let current = doc;
     const pathTokensLength = pathTokens.length;
     for (let j3 = 0; j3 < pathTokensLength; j3++) {
       current = current[pathTokens[j3]];
       if (typeof current === "object") {
         if (current !== null && "lat" in current && "lon" in current && typeof current.lat === "number" && typeof current.lon === "number") {
-          current = properties[path37] = current;
+          current = properties[path38] = current;
           break;
         } else if (!Array.isArray(current) && current !== null && j3 === pathTokensLength - 1) {
           current = void 0;
@@ -3549,14 +3549,14 @@ function getDocumentProperties(doc, paths) {
       }
     }
     if (typeof current !== "undefined") {
-      properties[path37] = current;
+      properties[path38] = current;
     }
   }
   return properties;
 }
-function getNested(obj, path37) {
-  const props = getDocumentProperties(obj, [path37]);
-  return props[path37];
+function getNested(obj, path38) {
+  const props = getDocumentProperties(obj, [path38]);
+  return props[path38];
 }
 function convertDistanceToMeters(distance, unit) {
   const ratio = mapDistanceToMeters[unit];
@@ -3572,10 +3572,10 @@ function removeVectorsFromHits(searchResult, vectorProperties) {
       ...result.document,
       // Remove embeddings from the result
       ...vectorProperties.reduce((acc, prop) => {
-        const path37 = prop.split(".");
-        const lastKey = path37.pop();
+        const path38 = prop.split(".");
+        const lastKey = path38.pop();
         let obj = acc;
-        for (const key of path37) {
+        for (const key of path38) {
           obj[key] = obj[key] ?? {};
           obj = obj[key];
         }
@@ -4307,15 +4307,15 @@ var init_avl = __esm({
         if (node === null) {
           return new AVLNode(key, [value]);
         }
-        const path37 = [];
+        const path38 = [];
         let current = node;
         let parent = null;
         while (current !== null) {
-          path37.push({ parent, node: current });
+          path38.push({ parent, node: current });
           if (key < current.k) {
             if (current.l === null) {
               current.l = new AVLNode(key, [value]);
-              path37.push({ parent: current, node: current.l });
+              path38.push({ parent: current, node: current.l });
               break;
             } else {
               parent = current;
@@ -4324,7 +4324,7 @@ var init_avl = __esm({
           } else if (key > current.k) {
             if (current.r === null) {
               current.r = new AVLNode(key, [value]);
-              path37.push({ parent: current, node: current.r });
+              path38.push({ parent: current, node: current.r });
               break;
             } else {
               parent = current;
@@ -4339,8 +4339,8 @@ var init_avl = __esm({
         if (this.insertCount++ % rebalanceThreshold === 0) {
           needRebalance = true;
         }
-        for (let i2 = path37.length - 1; i2 >= 0; i2--) {
-          const { parent: parent2, node: currentNode } = path37[i2];
+        for (let i2 = path38.length - 1; i2 >= 0; i2--) {
+          const { parent: parent2, node: currentNode } = path38[i2];
           currentNode.updateHeight();
           if (needRebalance) {
             const rebalancedNode = this.rebalanceNode(currentNode);
@@ -4446,10 +4446,10 @@ var init_avl = __esm({
       removeNode(node, key) {
         if (node === null)
           return null;
-        const path37 = [];
+        const path38 = [];
         let current = node;
         while (current !== null && current.k !== key) {
-          path37.push(current);
+          path38.push(current);
           if (key < current.k) {
             current = current.l;
           } else {
@@ -4461,10 +4461,10 @@ var init_avl = __esm({
         }
         if (current.l === null || current.r === null) {
           const child = current.l ? current.l : current.r;
-          if (path37.length === 0) {
+          if (path38.length === 0) {
             node = child;
           } else {
-            const parent = path37[path37.length - 1];
+            const parent = path38[path38.length - 1];
             if (parent.l === current) {
               parent.l = child;
             } else {
@@ -4487,13 +4487,13 @@ var init_avl = __esm({
           }
           current = successorParent;
         }
-        path37.push(current);
-        for (let i2 = path37.length - 1; i2 >= 0; i2--) {
-          const currentNode = path37[i2];
+        path38.push(current);
+        for (let i2 = path38.length - 1; i2 >= 0; i2--) {
+          const currentNode = path38[i2];
           currentNode.updateHeight();
           const rebalancedNode = this.rebalanceNode(currentNode);
           if (i2 > 0) {
-            const parent = path37[i2 - 1];
+            const parent = path38[i2 - 1];
             if (parent.l === currentNode) {
               parent.l = rebalancedNode;
             } else if (parent.r === currentNode) {
@@ -5660,15 +5660,15 @@ function create2(orama, sharedInternalDocumentStore, schema, index, prefix = "")
     };
   }
   for (const [prop, type] of Object.entries(schema)) {
-    const path37 = `${prefix}${prefix ? "." : ""}${prop}`;
+    const path38 = `${prefix}${prefix ? "." : ""}${prop}`;
     if (typeof type === "object" && !Array.isArray(type)) {
-      create2(orama, sharedInternalDocumentStore, type, index, path37);
+      create2(orama, sharedInternalDocumentStore, type, index, path38);
       continue;
     }
     if (isVectorType(type)) {
-      index.searchableProperties.push(path37);
-      index.searchablePropertiesWithTypes[path37] = type;
-      index.vectorIndexes[path37] = {
+      index.searchableProperties.push(path38);
+      index.searchablePropertiesWithTypes[path38] = type;
+      index.vectorIndexes[path38] = {
         type: "Vector",
         node: new VectorIndex(getVectorSize(type)),
         isArray: false
@@ -5678,32 +5678,32 @@ function create2(orama, sharedInternalDocumentStore, schema, index, prefix = "")
       switch (type) {
         case "boolean":
         case "boolean[]":
-          index.indexes[path37] = { type: "Bool", node: new BoolNode(), isArray };
+          index.indexes[path38] = { type: "Bool", node: new BoolNode(), isArray };
           break;
         case "number":
         case "number[]":
-          index.indexes[path37] = { type: "AVL", node: new AVLTree(0, []), isArray };
+          index.indexes[path38] = { type: "AVL", node: new AVLTree(0, []), isArray };
           break;
         case "string":
         case "string[]":
-          index.indexes[path37] = { type: "Radix", node: new RadixTree(), isArray };
-          index.avgFieldLength[path37] = 0;
-          index.frequencies[path37] = {};
-          index.tokenOccurrences[path37] = {};
-          index.fieldLengths[path37] = {};
+          index.indexes[path38] = { type: "Radix", node: new RadixTree(), isArray };
+          index.avgFieldLength[path38] = 0;
+          index.frequencies[path38] = {};
+          index.tokenOccurrences[path38] = {};
+          index.fieldLengths[path38] = {};
           break;
         case "enum":
         case "enum[]":
-          index.indexes[path37] = { type: "Flat", node: new FlatTree(), isArray };
+          index.indexes[path38] = { type: "Flat", node: new FlatTree(), isArray };
           break;
         case "geopoint":
-          index.indexes[path37] = { type: "BKD", node: new BKDTree(), isArray };
+          index.indexes[path38] = { type: "BKD", node: new BKDTree(), isArray };
           break;
         default:
-          throw createError("INVALID_SCHEMA_TYPE", Array.isArray(type) ? "array" : type, path37);
+          throw createError("INVALID_SCHEMA_TYPE", Array.isArray(type) ? "array" : type, path38);
       }
-      index.searchableProperties.push(path37);
-      index.searchablePropertiesWithTypes[path37] = type;
+      index.searchableProperties.push(path38);
+      index.searchablePropertiesWithTypes[path38] = type;
     }
   }
   return index;
@@ -6274,12 +6274,12 @@ function innerCreate(orama, sharedInternalDocumentStore, schema, sortableDeniedP
     sorts: {}
   };
   for (const [prop, type] of Object.entries(schema)) {
-    const path37 = `${prefix}${prefix ? "." : ""}${prop}`;
-    if (sortableDeniedProperties.includes(path37)) {
+    const path38 = `${prefix}${prefix ? "." : ""}${prop}`;
+    if (sortableDeniedProperties.includes(path38)) {
       continue;
     }
     if (typeof type === "object" && !Array.isArray(type)) {
-      const ret = innerCreate(orama, sharedInternalDocumentStore, type, sortableDeniedProperties, path37);
+      const ret = innerCreate(orama, sharedInternalDocumentStore, type, sortableDeniedProperties, path38);
       safeArrayPush(sorter.sortableProperties, ret.sortableProperties);
       sorter.sorts = {
         ...sorter.sorts,
@@ -6296,9 +6296,9 @@ function innerCreate(orama, sharedInternalDocumentStore, schema, sortableDeniedP
         case "boolean":
         case "number":
         case "string":
-          sorter.sortableProperties.push(path37);
-          sorter.sortablePropertiesWithTypes[path37] = type;
-          sorter.sorts[path37] = {
+          sorter.sortableProperties.push(path38);
+          sorter.sortablePropertiesWithTypes[path38] = type;
+          sorter.sorts[path38] = {
             docs: /* @__PURE__ */ new Map(),
             orderedDocsToRemove: /* @__PURE__ */ new Map(),
             orderedDocs: [],
@@ -6314,7 +6314,7 @@ function innerCreate(orama, sharedInternalDocumentStore, schema, sortableDeniedP
         case "string[]":
           continue;
         default:
-          throw createError("INVALID_SORT_SCHEMA_TYPE", Array.isArray(type) ? "array" : type, path37);
+          throw createError("INVALID_SORT_SCHEMA_TYPE", Array.isArray(type) ? "array" : type, path38);
       }
     }
   }
@@ -8159,8 +8159,8 @@ function innerFullTextSearch(orama, params, language) {
 function escapeRegex(str2) {
   return str2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function getPropValue(obj, path37) {
-  const keys = path37.split(".");
+function getPropValue(obj, path38) {
+  const keys = path38.split(".");
   let value = obj;
   for (const key of keys) {
     if (value && typeof value === "object" && key in value) {
@@ -9219,15 +9219,15 @@ function loadSqlite() {
     throw new Error("[memorix] SQLite is unavailable (better-sqlite3, node:sqlite, and bun:sqlite failed)");
   }
 }
-function createDatabase(path37, options2) {
+function createDatabase(path38, options2) {
   const Sqlite = loadSqlite();
   try {
-    return addCompatibility(instantiateDatabase(Sqlite, path37, options2));
+    return addCompatibility(instantiateDatabase(Sqlite, path38, options2));
   } catch (error2) {
     if (driver !== "better-sqlite3" || !isNativeBindingFailure(error2)) throw error2;
     Database = loadNodeSqlite();
     driver = "node:sqlite";
-    return addCompatibility(instantiateDatabase(Database, path37, options2));
+    return addCompatibility(instantiateDatabase(Database, path38, options2));
   }
 }
 var Database, driver, requireFromHere;
@@ -9354,7 +9354,7 @@ function closeAllDatabases() {
     _dbCache.delete(key);
   }
 }
-var BetterSqlite3, CREATE_OBSERVATIONS_TABLE, CREATE_MINI_SKILLS_TABLE, CREATE_SESSIONS_TABLE, CREATE_META_TABLE, CREATE_TEAM_AGENTS_TABLE, CREATE_TEAM_MESSAGES_TABLE, CREATE_TEAM_TASKS_TABLE, CREATE_TEAM_TASK_DEPS_TABLE, CREATE_TEAM_LOCKS_TABLE, CREATE_TEAM_ROLES_TABLE, CREATE_CHAT_TRANSCRIPT_TABLE, CREATE_GRAPH_ENTITIES_TABLE, CREATE_GRAPH_RELATIONS_TABLE, CREATE_CODE_FILES_TABLE, CREATE_CODE_SYMBOLS_TABLE, CREATE_CODE_EDGES_TABLE, CREATE_OBSERVATION_CODE_REFS_TABLE, CREATE_SCHEMA_MIGRATIONS_TABLE, CREATE_CODE_STATE_SNAPSHOTS_TABLE, CREATE_KNOWLEDGE_CLAIMS_TABLE, CREATE_KNOWLEDGE_CLAIM_EVIDENCE_TABLE, CREATE_KNOWLEDGE_CLAIM_EVENTS_TABLE, CREATE_KNOWLEDGE_WORKSPACES_TABLE, CREATE_KNOWLEDGE_PAGES_TABLE, CREATE_KNOWLEDGE_PAGE_CLAIMS_TABLE, CREATE_KNOWLEDGE_PAGE_LINKS_TABLE, CREATE_KNOWLEDGE_PROPOSALS_TABLE, CREATE_KNOWLEDGE_WORKFLOWS_TABLE, CREATE_KNOWLEDGE_WORKFLOW_RUNS_TABLE, CREATE_MAINTENANCE_JOBS_TABLE, CREATE_MAINTENANCE_TARGETS_TABLE, CREATE_COMPACTION_CHECKPOINTS_TABLE, CREATE_INDEXES, SCHEMA_MIGRATIONS, _dbCache;
+var BetterSqlite3, CREATE_OBSERVATIONS_TABLE, CREATE_MINI_SKILLS_TABLE, CREATE_SESSIONS_TABLE, CREATE_META_TABLE, CREATE_TEAM_AGENTS_TABLE, CREATE_TEAM_MESSAGES_TABLE, CREATE_TEAM_TASKS_TABLE, CREATE_TEAM_TASK_DEPS_TABLE, CREATE_TEAM_LOCKS_TABLE, CREATE_TEAM_ROLES_TABLE, CREATE_CHAT_TRANSCRIPT_TABLE, CREATE_GRAPH_ENTITIES_TABLE, CREATE_GRAPH_RELATIONS_TABLE, CREATE_CODE_FILES_TABLE, CREATE_CODE_SYMBOLS_TABLE, CREATE_CODE_EDGES_TABLE, CREATE_OBSERVATION_CODE_REFS_TABLE, CREATE_SCHEMA_MIGRATIONS_TABLE, CREATE_CODE_STATE_SNAPSHOTS_TABLE, CREATE_KNOWLEDGE_CLAIMS_TABLE, CREATE_KNOWLEDGE_CLAIM_EVIDENCE_TABLE, CREATE_KNOWLEDGE_CLAIM_EVENTS_TABLE, CREATE_KNOWLEDGE_WORKSPACES_TABLE, CREATE_KNOWLEDGE_PAGES_TABLE, CREATE_KNOWLEDGE_PAGE_CLAIMS_TABLE, CREATE_KNOWLEDGE_PAGE_LINKS_TABLE, CREATE_KNOWLEDGE_PROPOSALS_TABLE, CREATE_KNOWLEDGE_WORKFLOWS_TABLE, CREATE_KNOWLEDGE_WORKFLOW_RUNS_TABLE, CREATE_LONG_TERM_MEMORIES_TABLE, CREATE_LONG_TERM_MEMORY_EVIDENCE_TABLE, CREATE_LONG_TERM_MEMORY_EVENTS_TABLE, CREATE_MAINTENANCE_JOBS_TABLE, CREATE_MAINTENANCE_TARGETS_TABLE, CREATE_COMPACTION_CHECKPOINTS_TABLE, CREATE_INDEXES, SCHEMA_MIGRATIONS, _dbCache;
 var init_sqlite_db = __esm({
   "src/store/sqlite-db.ts"() {
     "use strict";
@@ -9780,6 +9780,57 @@ CREATE TABLE IF NOT EXISTS knowledge_claim_events (
       "  FOREIGN KEY (workflowId) REFERENCES knowledge_workflows(id) ON DELETE CASCADE",
       ");"
     ].join("\n");
+    CREATE_LONG_TERM_MEMORIES_TABLE = `
+CREATE TABLE IF NOT EXISTS long_term_memories (
+  id                TEXT PRIMARY KEY,
+  originProjectId   TEXT NOT NULL,
+  ownerId           TEXT NOT NULL,
+  scope             TEXT NOT NULL,
+  kind              TEXT NOT NULL,
+  state             TEXT NOT NULL,
+  portability       TEXT NOT NULL DEFAULT 'project-bound',
+  title             TEXT NOT NULL,
+  content           TEXT NOT NULL,
+  factsJson         TEXT NOT NULL DEFAULT '[]',
+  tagsJson          TEXT NOT NULL DEFAULT '[]',
+  applicability     TEXT,
+  origin            TEXT NOT NULL,
+  createdAt         TEXT NOT NULL,
+  updatedAt         TEXT NOT NULL,
+  qualifiedAt       TEXT,
+  approvedAt        TEXT,
+  archivedAt        TEXT,
+  supersededBy      TEXT,
+  lastValidatedAt   TEXT,
+  accessCount       INTEGER NOT NULL DEFAULT 0,
+  lastAccessedAt    TEXT
+);
+`;
+    CREATE_LONG_TERM_MEMORY_EVIDENCE_TABLE = `
+CREATE TABLE IF NOT EXISTS long_term_memory_evidence (
+  id             TEXT PRIMARY KEY,
+  memoryId       TEXT NOT NULL,
+  kind           TEXT NOT NULL,
+  referenceId    TEXT NOT NULL,
+  relation       TEXT NOT NULL,
+  locator        TEXT,
+  capturedHash   TEXT,
+  createdAt      TEXT NOT NULL,
+  FOREIGN KEY (memoryId) REFERENCES long_term_memories(id) ON DELETE CASCADE
+);
+`;
+    CREATE_LONG_TERM_MEMORY_EVENTS_TABLE = `
+CREATE TABLE IF NOT EXISTS long_term_memory_events (
+  id          TEXT PRIMARY KEY,
+  memoryId    TEXT NOT NULL,
+  kind        TEXT NOT NULL,
+  fromState   TEXT,
+  toState     TEXT,
+  detail      TEXT,
+  createdAt   TEXT NOT NULL,
+  FOREIGN KEY (memoryId) REFERENCES long_term_memories(id) ON DELETE CASCADE
+);
+`;
     CREATE_MAINTENANCE_JOBS_TABLE = `
 CREATE TABLE IF NOT EXISTS maintenance_jobs (
   id               TEXT PRIMARY KEY,
@@ -9875,6 +9926,11 @@ CREATE INDEX IF NOT EXISTS idx_knowledge_page_claims_claim ON knowledge_page_cla
 CREATE INDEX IF NOT EXISTS idx_knowledge_proposals_workspace_status ON knowledge_proposals(workspaceId, status, createdAt DESC);
 CREATE INDEX IF NOT EXISTS idx_knowledge_workflows_workspace_status ON knowledge_workflows(workspaceId, status, updatedAt DESC);
 CREATE INDEX IF NOT EXISTS idx_knowledge_workflow_runs_project_workflow ON knowledge_workflow_runs(projectId, workflowId, startedAt DESC);
+CREATE INDEX IF NOT EXISTS idx_long_term_memories_owner_state ON long_term_memories(ownerId, state, updatedAt DESC);
+CREATE INDEX IF NOT EXISTS idx_long_term_memories_project_state ON long_term_memories(originProjectId, state, updatedAt DESC);
+CREATE INDEX IF NOT EXISTS idx_long_term_memories_scope_portability ON long_term_memories(scope, portability, state, updatedAt DESC);
+CREATE INDEX IF NOT EXISTS idx_long_term_memory_evidence_memory ON long_term_memory_evidence(memoryId, createdAt);
+CREATE INDEX IF NOT EXISTS idx_long_term_memory_events_memory ON long_term_memory_events(memoryId, createdAt);
 CREATE INDEX IF NOT EXISTS idx_maintenance_jobs_ready ON maintenance_jobs(status, run_after);
 CREATE INDEX IF NOT EXISTS idx_maintenance_jobs_project ON maintenance_jobs(project_id, status, run_after);
 CREATE INDEX IF NOT EXISTS idx_maintenance_targets_updated ON maintenance_targets(updated_at);
@@ -9963,6 +10019,19 @@ CREATE UNIQUE INDEX IF NOT EXISTS idx_maintenance_jobs_active_dedupe
           db2.exec("CREATE INDEX IF NOT EXISTS idx_compaction_checkpoints_session_pending ON compaction_checkpoints(project_id, session_id, agent, phase, status, pre_captured_at DESC)");
           db2.exec("CREATE INDEX IF NOT EXISTS idx_compaction_checkpoints_source ON compaction_checkpoints(project_id, source_key)");
         }
+      },
+      {
+        id: "1.3-long-term-memory",
+        apply: (db2) => {
+          db2.exec(CREATE_LONG_TERM_MEMORIES_TABLE);
+          db2.exec(CREATE_LONG_TERM_MEMORY_EVIDENCE_TABLE);
+          db2.exec(CREATE_LONG_TERM_MEMORY_EVENTS_TABLE);
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_long_term_memories_owner_state ON long_term_memories(ownerId, state, updatedAt DESC)");
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_long_term_memories_project_state ON long_term_memories(originProjectId, state, updatedAt DESC)");
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_long_term_memories_scope_portability ON long_term_memories(scope, portability, state, updatedAt DESC)");
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_long_term_memory_evidence_memory ON long_term_memory_evidence(memoryId, createdAt)");
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_long_term_memory_events_memory ON long_term_memory_events(memoryId, createdAt)");
+        }
       }
     ];
     _dbCache = /* @__PURE__ */ new Map();
@@ -13292,9 +13361,9 @@ function parseTomlConfig(content, filePath) {
   }
   return root;
 }
-function ensureTable(root, path37) {
+function ensureTable(root, path38) {
   let cursor = root;
-  for (const part of path37) {
+  for (const part of path38) {
     const value = cursor[part];
     if (!value || typeof value !== "object" || Array.isArray(value)) {
       cursor[part] = {};
@@ -13428,8 +13497,8 @@ var require_main = __commonJS({
   "node_modules/dotenv/lib/main.js"(exports2, module2) {
     "use strict";
     init_esm_shims();
-    var fs27 = __require("fs");
-    var path37 = __require("path");
+    var fs28 = __require("fs");
+    var path38 = __require("path");
     var os5 = __require("os");
     var crypto3 = __require("crypto");
     var packageJson = require_package();
@@ -13567,7 +13636,7 @@ var require_main = __commonJS({
       if (options2 && options2.path && options2.path.length > 0) {
         if (Array.isArray(options2.path)) {
           for (const filepath of options2.path) {
-            if (fs27.existsSync(filepath)) {
+            if (fs28.existsSync(filepath)) {
               possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
             }
           }
@@ -13575,15 +13644,15 @@ var require_main = __commonJS({
           possibleVaultPath = options2.path.endsWith(".vault") ? options2.path : `${options2.path}.vault`;
         }
       } else {
-        possibleVaultPath = path37.resolve(process.cwd(), ".env.vault");
+        possibleVaultPath = path38.resolve(process.cwd(), ".env.vault");
       }
-      if (fs27.existsSync(possibleVaultPath)) {
+      if (fs28.existsSync(possibleVaultPath)) {
         return possibleVaultPath;
       }
       return null;
     }
     function _resolveHome(envPath) {
-      return envPath[0] === "~" ? path37.join(os5.homedir(), envPath.slice(1)) : envPath;
+      return envPath[0] === "~" ? path38.join(os5.homedir(), envPath.slice(1)) : envPath;
     }
     function _configVault(options2) {
       const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options2 && options2.debug);
@@ -13600,7 +13669,7 @@ var require_main = __commonJS({
       return { parsed };
     }
     function configDotenv(options2) {
-      const dotenvPath = path37.resolve(process.cwd(), ".env");
+      const dotenvPath = path38.resolve(process.cwd(), ".env");
       let encoding = "utf8";
       let processEnv = process.env;
       if (options2 && options2.processEnv != null) {
@@ -13628,13 +13697,13 @@ var require_main = __commonJS({
       }
       let lastError;
       const parsedAll = {};
-      for (const path38 of optionPaths) {
+      for (const path39 of optionPaths) {
         try {
-          const parsed = DotenvModule.parse(fs27.readFileSync(path38, { encoding }));
+          const parsed = DotenvModule.parse(fs28.readFileSync(path39, { encoding }));
           DotenvModule.populate(parsedAll, parsed, options2);
         } catch (e3) {
           if (debug) {
-            _debug(`Failed to load ${path38} ${e3.message}`);
+            _debug(`Failed to load ${path39} ${e3.message}`);
           }
           lastError = e3;
         }
@@ -13647,7 +13716,7 @@ var require_main = __commonJS({
         const shortPaths = [];
         for (const filePath of optionPaths) {
           try {
-            const relative3 = path37.relative(process.cwd(), filePath);
+            const relative3 = path38.relative(process.cwd(), filePath);
             shortPaths.push(relative3);
           } catch (e3) {
             if (debug) {
@@ -14566,9 +14635,10 @@ function parseBatchLimit(error2) {
   }
   return null;
 }
-async function fetchWithRetry(url, apiKey, body, attempt = 0) {
+async function fetchWithRetry(url, apiKey, body, options2 = {}, attempt = 0) {
   const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), 1e4);
+  const timeoutMs = typeof options2.timeoutMs === "number" && Number.isFinite(options2.timeoutMs) ? Math.max(100, Math.min(Math.floor(options2.timeoutMs), 6e4)) : 1e4;
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
   let response;
   try {
     response = await fetch(url, {
@@ -14583,7 +14653,7 @@ async function fetchWithRetry(url, apiKey, body, attempt = 0) {
   } catch (err) {
     clearTimeout(timeout);
     if (err instanceof Error && err.name === "AbortError") {
-      throw new Error(`Embedding API timeout after 10s: ${url}`);
+      throw new Error(`Embedding API timeout after ${timeoutMs}ms: ${url}`);
     }
     throw err;
   }
@@ -14591,13 +14661,13 @@ async function fetchWithRetry(url, apiKey, body, attempt = 0) {
   if (response.ok) {
     return response.json();
   }
-  if ((response.status === 429 || response.status >= 500) && attempt < MAX_RETRIES2) {
+  if (options2.retry !== false && (response.status === 429 || response.status >= 500) && attempt < MAX_RETRIES2) {
     const delay = BASE_DELAY_MS * Math.pow(2, attempt);
     const retryAfter = response.headers.get("retry-after");
     const waitMs = retryAfter ? parseInt(retryAfter, 10) * 1e3 : delay;
     console.error(`[memorix] Embedding API ${response.status}, retry ${attempt + 1}/${MAX_RETRIES2} in ${waitMs}ms`);
     await new Promise((resolve6) => setTimeout(resolve6, waitMs));
-    return fetchWithRetry(url, apiKey, body, attempt + 1);
+    return fetchWithRetry(url, apiKey, body, options2, attempt + 1);
   }
   const errorText2 = await response.text().catch(() => "unknown error");
   throw new Error(`Embedding API error (${response.status}): ${errorText2}`);
@@ -14653,7 +14723,10 @@ var init_api_provider = __esm({
           }
         } else {
           if (!allowNetworkProbe) return null;
-          probeDimensions = await _APIEmbeddingProvider.probeAPI(config2);
+          probeDimensions = await _APIEmbeddingProvider.probeAPI(config2, {
+            timeoutMs: options2.requestTimeoutMs,
+            retry: options2.retry
+          });
           console.error(`[memorix] API embedding: ${config2.model} @ ${config2.baseUrl} (${probeDimensions}d)`);
           saveCachedDims(config2, probeDimensions).catch(() => {
           });
@@ -14695,7 +14768,7 @@ var init_api_provider = __esm({
         baseUrl = baseUrl.replace(/\/+$/, "");
         return { apiKey, baseUrl, model, requestedDimensions };
       }
-      static async probeAPI(config2) {
+      static async probeAPI(config2, options2) {
         const body = {
           model: config2.model,
           input: "dimension probe"
@@ -14706,14 +14779,15 @@ var init_api_provider = __esm({
         const response = await fetchWithRetry(
           `${config2.baseUrl}/embeddings`,
           config2.apiKey,
-          body
+          body,
+          options2
         );
         if (response.data.length === 0 || !response.data[0].embedding) {
           throw new Error("API probe returned no embeddings; check model name and API key");
         }
         return response.data[0].embedding.length;
       }
-      async embed(text) {
+      async embed(text, options2) {
         const normalized = normalizeText(text);
         const hash4 = textHash2(normalized, this.cacheKeyNamespace);
         if (diskCacheLoaded) {
@@ -14731,7 +14805,8 @@ var init_api_provider = __esm({
           const response = await fetchWithRetry(
             `${this.config.baseUrl}/embeddings`,
             this.config.apiKey,
-            body
+            body,
+            options2
           );
           const embedding2 = response.data[0].embedding;
           if (embedding2.length !== this.dimensions) {
@@ -14765,7 +14840,7 @@ var init_api_provider = __esm({
         scheduleDiskSave();
         return embedding;
       }
-      async embedBatch(texts) {
+      async embedBatch(texts, options2) {
         await ensureDiskCacheLoaded();
         const normalizedTexts = texts.map(normalizeText);
         const results = new Array(texts.length);
@@ -14799,7 +14874,8 @@ var init_api_provider = __esm({
             const response = await fetchWithRetry(
               `${this.config.baseUrl}/embeddings`,
               this.config.apiKey,
-              body
+              body,
+              options2
             );
             this.trackUsage(response);
             for (const item of response.data) {
@@ -14976,9 +15052,9 @@ function wrapProvider(candidate2) {
   return {
     name: candidate2.name,
     dimensions: candidate2.dimensions,
-    async embed(text) {
+    async embed(text, options2) {
       try {
-        return await candidate2.embed(text);
+        return await candidate2.embed(text, options2);
       } catch (error2) {
         if (kind === "api" && getEmbeddingMode2() === "auto" && isTemporaryEmbeddingFailure(error2)) {
           warnOnce("[memorix] API embedding temporarily unavailable \u2014 switching to local fallback provider");
@@ -14986,7 +15062,7 @@ function wrapProvider(candidate2) {
           if (fallback) {
             provider = wrapProvider(fallback);
             warnOnce(`[memorix] Embedding fallback activated: ${provider.name} (${provider.dimensions}d)`);
-            return provider.embed(text);
+            return provider.embed(text, options2);
           }
         }
         if (isTemporaryEmbeddingFailure(error2)) {
@@ -14995,9 +15071,9 @@ function wrapProvider(candidate2) {
         throw error2;
       }
     },
-    async embedBatch(texts) {
+    async embedBatch(texts, options2) {
       try {
-        return await candidate2.embedBatch(texts);
+        return await candidate2.embedBatch(texts, options2);
       } catch (error2) {
         if (kind === "api" && getEmbeddingMode2() === "auto" && isTemporaryEmbeddingFailure(error2)) {
           warnOnce("[memorix] API embedding temporarily unavailable \u2014 switching to local fallback provider");
@@ -15005,7 +15081,7 @@ function wrapProvider(candidate2) {
           if (fallback) {
             provider = wrapProvider(fallback);
             warnOnce(`[memorix] Embedding fallback activated: ${provider.name} (${provider.dimensions}d)`);
-            return provider.embedBatch(texts);
+            return provider.embedBatch(texts, options2);
           }
         }
         if (isTemporaryEmbeddingFailure(error2)) {
@@ -15061,14 +15137,14 @@ async function getEmbeddingProvider(options2 = {}) {
       return provider;
     }
     if (mode === "api") {
-      const initialized = await createAPIProvider();
+      const initialized = await createAPIProvider(options2);
       if (!initialized) return null;
       provider = wrapProvider(initialized);
       warnOnce(`[memorix] Embedding provider: ${provider.name} (${provider.dimensions}d)`);
       return provider;
     }
     if (hasAPIEmbeddingConfig()) {
-      const initialized = await createAPIProvider();
+      const initialized = await createAPIProvider(options2);
       if (initialized) {
         provider = wrapProvider(initialized);
         warnOnce(`[memorix] Embedding provider: ${provider.name} (${provider.dimensions}d)`);
@@ -18967,12 +19043,12 @@ import { createHash as createHash4 } from "crypto";
 function digest(input) {
   return createHash4("sha256").update(input).digest("hex").slice(0, 16);
 }
-function normalizeCodePath(path37) {
-  return path37.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+/g, "/");
+function normalizeCodePath(path38) {
+  return path38.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+/g, "/");
 }
-function makeCodeFileId(projectId, path37) {
+function makeCodeFileId(projectId, path38) {
   return `file:${digest(`${projectId}
-${normalizeCodePath(path37)}`)}`;
+${normalizeCodePath(path38)}`)}`;
 }
 function makeCodeSymbolId(input) {
   return `symbol:${digest([
@@ -19446,8 +19522,8 @@ var init_store = __esm({
         });
         tx();
       }
-      getFile(projectId, path37) {
-        const row = this.db.prepare(`SELECT * FROM code_files WHERE projectId = ? AND path = ?`).get(projectId, normalizeCodePath(path37));
+      getFile(projectId, path38) {
+        const row = this.db.prepare(`SELECT * FROM code_files WHERE projectId = ? AND path = ?`).get(projectId, normalizeCodePath(path38));
         return row ? rowToFile(row) : null;
       }
       listFiles(projectId) {
@@ -19682,30 +19758,30 @@ function normalizeCodeGraphExcludePatterns(exclude) {
     ...(exclude ?? []).map((pattern) => pattern.trim()).filter(Boolean)
   ])];
 }
-function isCodeGraphExcludedPath(path37, exclude) {
-  const normalized = normalizeCodePath2(path37);
+function isCodeGraphExcludedPath(path38, exclude) {
+  const normalized = normalizeCodePath2(path38);
   return normalizeCodeGraphExcludePatterns(exclude).some((pattern) => matchesPattern(normalized, normalizeCodePath2(pattern)));
 }
-function normalizeCodePath2(path37) {
-  return path37.replace(/\\/g, "/").replace(/^\.\/+/, "");
+function normalizeCodePath2(path38) {
+  return path38.replace(/\\/g, "/").replace(/^\.\/+/, "");
 }
-function matchesPattern(path37, pattern) {
+function matchesPattern(path38, pattern) {
   if (pattern.endsWith("/**")) {
     const base = pattern.slice(0, -3);
     if (base.startsWith("**/")) {
       const suffix = base.slice(3);
-      return path37 === suffix || path37.endsWith(`/${suffix}`) || path37.includes(`/${suffix}/`);
+      return path38 === suffix || path38.endsWith(`/${suffix}`) || path38.includes(`/${suffix}/`);
     }
     if (!base.includes("/")) {
-      return path37 === base || path37.startsWith(`${base}/`) || path37.includes(`/${base}/`);
+      return path38 === base || path38.startsWith(`${base}/`) || path38.includes(`/${base}/`);
     }
-    return path37 === base || path37.startsWith(`${base}/`);
+    return path38 === base || path38.startsWith(`${base}/`);
   }
   if (pattern.startsWith("**/")) {
     const suffix = pattern.slice(3);
-    return path37 === suffix || path37.endsWith(`/${suffix}`);
+    return path38 === suffix || path38.endsWith(`/${suffix}`);
   }
-  return path37 === pattern || path37.startsWith(`${pattern}/`);
+  return path38 === pattern || path38.startsWith(`${pattern}/`);
 }
 var DEFAULT_CODEGRAPH_EXCLUDES;
 var init_exclude = __esm({
@@ -19750,12 +19826,12 @@ import { join as join5, relative } from "path";
 function hashText(text) {
   return createHash6("sha256").update(text).digest("hex");
 }
-function extension(path37) {
-  const index = path37.lastIndexOf(".");
-  return index === -1 ? "" : path37.slice(index);
+function extension(path38) {
+  const index = path38.lastIndexOf(".");
+  return index === -1 ? "" : path38.slice(index);
 }
-function languageForPath(path37) {
-  const ext = extension(path37);
+function languageForPath(path38) {
+  const ext = extension(path38);
   return LANGUAGE_BY_EXTENSION.get(ext) ?? "unknown";
 }
 function resolveMaxFileBytes(value) {
@@ -20236,7 +20312,7 @@ function resolveObservationCodeRefs(obs, lookup) {
 }
 function createStoreLookup(store2, projectId) {
   return {
-    findFile: (path37) => store2.getFile(projectId, path37) ?? void 0,
+    findFile: (path38) => store2.getFile(projectId, path38) ?? void 0,
     findSymbols: (names, hintedFileIds) => store2.findSymbolsByNames(projectId, names, hintedFileIds)
   };
 }
@@ -20249,7 +20325,7 @@ function createSnapshotLookup(files, symbols) {
     symbolsByName.set(symbol.name, group);
   }
   return {
-    findFile: (path37) => filesByPath.get(normalizeCodePath(path37)),
+    findFile: (path38) => filesByPath.get(normalizeCodePath(path38)),
     findSymbols: (names, hintedFileIds) => {
       const hinted = new Set(hintedFileIds);
       const found = [];
@@ -24448,7 +24524,7 @@ var require_gray_matter = __commonJS({
   "node_modules/gray-matter/index.js"(exports2, module2) {
     "use strict";
     init_esm_shims();
-    var fs27 = __require("fs");
+    var fs28 = __require("fs");
     var sections = require_section_matter();
     var defaults = require_defaults();
     var stringify = require_stringify();
@@ -24532,7 +24608,7 @@ var require_gray_matter = __commonJS({
       return stringify(file, data, options2);
     };
     matter12.read = function(filepath, options2) {
-      const str2 = fs27.readFileSync(filepath, "utf8");
+      const str2 = fs28.readFileSync(filepath, "utf8");
       const file = matter12(str2, options2);
       file.path = filepath;
       return file;
@@ -25399,8 +25475,8 @@ __export(task_lens_exports, {
   scoreLensSource: () => scoreLensSource,
   shouldShowLensSource: () => shouldShowLensSource
 });
-function normalizePath2(path37) {
-  return path37.replace(/\\/g, "/");
+function normalizePath2(path38) {
+  return path38.replace(/\\/g, "/");
 }
 function tokenize3(text) {
   return (text.toLowerCase().match(/[a-z0-9_./-]+|[\u4e00-\u9fff]+/g) ?? []).map((token) => token.trim()).filter((token) => token.length > 1 && !STOP_WORDS.has(token));
@@ -25462,8 +25538,8 @@ function isContinuationTask(task) {
     (keyword) => containsTaskKeyword(normalized, keyword)
   );
 }
-function pathKindScore(path37, lens) {
-  const normalized = normalizePath2(path37).toLowerCase();
+function pathKindScore(path38, lens) {
+  const normalized = normalizePath2(path38).toLowerCase();
   const name = normalized.split("/").pop() ?? normalized;
   const inDocs = normalized.startsWith("docs/") || name === "readme.md" || name.includes("readme");
   const isTest = /(^|\/)(tests?|__tests__|spec|fixtures?)\//.test(normalized) || /\.(test|spec)\.[cm]?[jt]sx?$/.test(normalized) || /\.(test|spec)\.py$/.test(normalized);
@@ -25511,8 +25587,8 @@ function sourceTaskMatchScore(source, task) {
   if (matches === 1) return 24;
   return 0;
 }
-function fallbackPathRank(path37) {
-  const normalized = normalizePath2(path37);
+function fallbackPathRank(path38) {
+  const normalized = normalizePath2(path38);
   if (normalized.startsWith("src/")) return 0;
   if (normalized.startsWith("tests/") || normalized.startsWith("test/")) return 1;
   if (normalized.startsWith("packages/") && normalized.includes("/src/")) return 2;
@@ -25521,11 +25597,11 @@ function fallbackPathRank(path37) {
 }
 function rankLensPaths(paths, lens, task) {
   const tokens = tokenize3(task ?? "");
-  return [...new Set(paths.map(normalizePath2))].map((path37, index) => ({
-    path: path37,
+  return [...new Set(paths.map(normalizePath2))].map((path38, index) => ({
+    path: path38,
     index,
-    score: pathKindScore(path37, lens) + tokenScore(path37, tokens),
-    fallback: fallbackPathRank(path37)
+    score: pathKindScore(path38, lens) + tokenScore(path38, tokens),
+    fallback: fallbackPathRank(path38)
   })).sort((a3, b3) => b3.score - a3.score || a3.fallback - b3.fallback || a3.index - b3.index || a3.path.localeCompare(b3.path)).map((item) => item.path);
 }
 function lensPathCandidates(lens) {
@@ -32139,6 +32215,827 @@ var init_operator_shared = __esm({
   }
 });
 
+// src/memory/owner.ts
+var owner_exports = {};
+__export(owner_exports, {
+  resolveLocalMemoryOwner: () => resolveLocalMemoryOwner
+});
+import { randomUUID as randomUUID9 } from "crypto";
+import { promises as fs15 } from "fs";
+import path19 from "path";
+function ownerPath(dataDir) {
+  const resolved = path19.resolve(dataDir);
+  const home = path19.basename(resolved).toLocaleLowerCase("en-US") === "data" ? path19.dirname(resolved) : resolved;
+  return path19.join(home, "memorix-user.json");
+}
+function normalizedOwnerId(value) {
+  const trimmed = value?.trim();
+  return trimmed && ID_PATTERN.test(trimmed) ? trimmed : void 0;
+}
+async function readOwnerFile(filePath) {
+  try {
+    const value = JSON.parse(await fs15.readFile(filePath, "utf8"));
+    const id = typeof value.id === "string" ? normalizedOwnerId(value.id) : void 0;
+    return id ? { id, source: "local-file" } : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function resolveLocalMemoryOwner(dataDir, options2 = {}) {
+  const configured = normalizedOwnerId(process.env.MEMORIX_USER_ID);
+  if (configured) return { id: configured, source: "environment" };
+  const filePath = ownerPath(dataDir);
+  const existing = await readOwnerFile(filePath);
+  if (existing || !options2.create) return existing;
+  await fs15.mkdir(path19.dirname(filePath), { recursive: true });
+  const created = {
+    version: 1,
+    id: "local-" + randomUUID9(),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  try {
+    await fs15.writeFile(filePath, JSON.stringify(created, null, 2) + "\n", { encoding: "utf8", flag: "wx" });
+    return { id: created.id, source: "local-file" };
+  } catch (error2) {
+    if (error2?.code !== "EEXIST") throw error2;
+    const concurrent = await readOwnerFile(filePath);
+    if (concurrent) return concurrent;
+    throw new Error("Memorix could not establish a valid local memory owner identity.");
+  }
+}
+var ID_PATTERN;
+var init_owner = __esm({
+  "src/memory/owner.ts"() {
+    "use strict";
+    init_esm_shims();
+    ID_PATTERN = /^[A-Za-z0-9:_-]{3,160}$/;
+  }
+});
+
+// src/memory/long-term-store.ts
+import { randomUUID as randomUUID10 } from "crypto";
+function optionalText5(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function arrayValue2(value) {
+  if (typeof value !== "string" || !value) return [];
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function rowToMemory(row) {
+  return {
+    id: row.id,
+    originProjectId: row.originProjectId,
+    ownerId: row.ownerId,
+    scope: row.scope,
+    kind: row.kind,
+    state: row.state,
+    portability: row.portability,
+    title: row.title,
+    content: row.content,
+    facts: arrayValue2(row.factsJson),
+    tags: arrayValue2(row.tagsJson),
+    ...optionalText5(row.applicability) ? { applicability: row.applicability } : {},
+    origin: row.origin,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+    ...optionalText5(row.qualifiedAt) ? { qualifiedAt: row.qualifiedAt } : {},
+    ...optionalText5(row.approvedAt) ? { approvedAt: row.approvedAt } : {},
+    ...optionalText5(row.archivedAt) ? { archivedAt: row.archivedAt } : {},
+    ...optionalText5(row.supersededBy) ? { supersededBy: row.supersededBy } : {},
+    ...optionalText5(row.lastValidatedAt) ? { lastValidatedAt: row.lastValidatedAt } : {},
+    accessCount: Number(row.accessCount ?? 0),
+    ...optionalText5(row.lastAccessedAt) ? { lastAccessedAt: row.lastAccessedAt } : {}
+  };
+}
+function rowToEvidence2(row) {
+  return {
+    id: row.id,
+    memoryId: row.memoryId,
+    kind: row.kind,
+    referenceId: row.referenceId,
+    relation: row.relation,
+    ...optionalText5(row.locator) ? { locator: row.locator } : {},
+    ...optionalText5(row.capturedHash) ? { capturedHash: row.capturedHash } : {},
+    createdAt: row.createdAt
+  };
+}
+function rowToEvent2(row) {
+  return {
+    id: row.id,
+    memoryId: row.memoryId,
+    kind: row.kind,
+    ...optionalText5(row.fromState) ? { fromState: row.fromState } : {},
+    ...optionalText5(row.toState) ? { toState: row.toState } : {},
+    ...optionalText5(row.detail) ? { detail: row.detail } : {},
+    createdAt: row.createdAt
+  };
+}
+var LongTermMemoryStore;
+var init_long_term_store = __esm({
+  "src/memory/long-term-store.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_sqlite_db();
+    LongTermMemoryStore = class {
+      db = null;
+      async init(dataDir) {
+        this.db = getDatabase(dataDir);
+      }
+      transaction(fn) {
+        return this.db.transaction(fn)();
+      }
+      get(id) {
+        const row = this.db.prepare("SELECT * FROM long_term_memories WHERE id = ?").get(id);
+        return row ? rowToMemory(row) : void 0;
+      }
+      list(options2 = {}) {
+        const limit = Math.max(1, Math.min(1e3, Math.floor(options2.limit ?? 500)));
+        const clauses = [];
+        const params = [];
+        if (options2.ownerId) {
+          clauses.push("ownerId = ?");
+          params.push(options2.ownerId);
+        }
+        if (options2.originProjectId) {
+          clauses.push("originProjectId = ?");
+          params.push(options2.originProjectId);
+        }
+        const where = clauses.length ? " WHERE " + clauses.join(" AND ") : "";
+        const rows = this.db.prepare(
+          "SELECT * FROM long_term_memories" + where + " ORDER BY updatedAt DESC, id LIMIT ?"
+        ).all(...params, limit);
+        return rows.map(rowToMemory);
+      }
+      insert(memory) {
+        this.db.prepare(`
+      INSERT INTO long_term_memories (
+        id, originProjectId, ownerId, scope, kind, state, portability,
+        title, content, factsJson, tagsJson, applicability, origin,
+        createdAt, updatedAt, qualifiedAt, approvedAt, archivedAt,
+        supersededBy, lastValidatedAt, accessCount, lastAccessedAt
+      ) VALUES (
+        @id, @originProjectId, @ownerId, @scope, @kind, @state, @portability,
+        @title, @content, @factsJson, @tagsJson, @applicability, @origin,
+        @createdAt, @updatedAt, @qualifiedAt, @approvedAt, @archivedAt,
+        @supersededBy, @lastValidatedAt, @accessCount, @lastAccessedAt
+      )
+    `).run({
+          ...memory,
+          factsJson: JSON.stringify(memory.facts),
+          tagsJson: JSON.stringify(memory.tags),
+          applicability: memory.applicability ?? null,
+          qualifiedAt: memory.qualifiedAt ?? null,
+          approvedAt: memory.approvedAt ?? null,
+          archivedAt: memory.archivedAt ?? null,
+          supersededBy: memory.supersededBy ?? null,
+          lastValidatedAt: memory.lastValidatedAt ?? null,
+          lastAccessedAt: memory.lastAccessedAt ?? null
+        });
+      }
+      update(memory) {
+        this.db.prepare(`
+      UPDATE long_term_memories SET
+        scope = @scope,
+        kind = @kind,
+        state = @state,
+        portability = @portability,
+        title = @title,
+        content = @content,
+        factsJson = @factsJson,
+        tagsJson = @tagsJson,
+        applicability = @applicability,
+        updatedAt = @updatedAt,
+        qualifiedAt = @qualifiedAt,
+        approvedAt = @approvedAt,
+        archivedAt = @archivedAt,
+        supersededBy = @supersededBy,
+        lastValidatedAt = @lastValidatedAt,
+        accessCount = @accessCount,
+        lastAccessedAt = @lastAccessedAt
+      WHERE id = @id
+    `).run({
+          ...memory,
+          factsJson: JSON.stringify(memory.facts),
+          tagsJson: JSON.stringify(memory.tags),
+          applicability: memory.applicability ?? null,
+          qualifiedAt: memory.qualifiedAt ?? null,
+          approvedAt: memory.approvedAt ?? null,
+          archivedAt: memory.archivedAt ?? null,
+          supersededBy: memory.supersededBy ?? null,
+          lastValidatedAt: memory.lastValidatedAt ?? null,
+          lastAccessedAt: memory.lastAccessedAt ?? null
+        });
+      }
+      insertEvidence(input) {
+        const evidence = {
+          id: randomUUID10(),
+          ...input,
+          createdAt: input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+        };
+        this.db.prepare(`
+      INSERT INTO long_term_memory_evidence (
+        id, memoryId, kind, referenceId, relation, locator, capturedHash, createdAt
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+          evidence.id,
+          evidence.memoryId,
+          evidence.kind,
+          evidence.referenceId,
+          evidence.relation,
+          evidence.locator ?? null,
+          evidence.capturedHash ?? null,
+          evidence.createdAt
+        );
+        return evidence;
+      }
+      listEvidence(memoryId) {
+        return this.db.prepare(`
+      SELECT * FROM long_term_memory_evidence WHERE memoryId = ? ORDER BY createdAt ASC, id
+    `).all(memoryId).map(rowToEvidence2);
+      }
+      recordEvent(input) {
+        const event = {
+          id: randomUUID10(),
+          ...input,
+          createdAt: input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+        };
+        this.db.prepare(`
+      INSERT INTO long_term_memory_events (id, memoryId, kind, fromState, toState, detail, createdAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(
+          event.id,
+          event.memoryId,
+          event.kind,
+          event.fromState ?? null,
+          event.toState ?? null,
+          event.detail ?? null,
+          event.createdAt
+        );
+        return event;
+      }
+      listEvents(memoryId) {
+        return this.db.prepare(`
+      SELECT * FROM long_term_memory_events WHERE memoryId = ? ORDER BY createdAt ASC, rowid ASC
+    `).all(memoryId).map(rowToEvent2);
+      }
+      markAccess(ids, at = (/* @__PURE__ */ new Date()).toISOString()) {
+        const unique3 = [...new Set(ids.filter(Boolean))];
+        if (unique3.length === 0) return;
+        const statement = this.db.prepare(`
+      UPDATE long_term_memories
+      SET accessCount = accessCount + 1, lastAccessedAt = ?
+      WHERE id = ?
+    `);
+        this.db.transaction(() => {
+          for (const id of unique3) statement.run(at, id);
+        })();
+      }
+    };
+  }
+});
+
+// src/memory/long-term-types.ts
+var LONG_TERM_MEMORY_KINDS, LONG_TERM_MEMORY_SCOPES, LONG_TERM_MEMORY_PORTABILITIES, LONG_TERM_MEMORY_EVIDENCE_KINDS, LONG_TERM_MEMORY_EVIDENCE_RELATIONS;
+var init_long_term_types = __esm({
+  "src/memory/long-term-types.ts"() {
+    "use strict";
+    init_esm_shims();
+    LONG_TERM_MEMORY_KINDS = ["episodic", "semantic", "procedural"];
+    LONG_TERM_MEMORY_SCOPES = ["project", "user", "team"];
+    LONG_TERM_MEMORY_PORTABILITIES = ["project-bound", "portable"];
+    LONG_TERM_MEMORY_EVIDENCE_KINDS = [
+      "observation",
+      "claim",
+      "workflow",
+      "session",
+      "checkpoint",
+      "git",
+      "code",
+      "test",
+      "run",
+      "document",
+      "manual",
+      "user"
+    ];
+    LONG_TERM_MEMORY_EVIDENCE_RELATIONS = [
+      "supports",
+      "verifies",
+      "derives",
+      "user-confirmed"
+    ];
+  }
+});
+
+// src/memory/long-term.ts
+var long_term_exports = {};
+__export(long_term_exports, {
+  approveLongTermMemory: () => approveLongTermMemory,
+  archiveLongTermMemory: () => archiveLongTermMemory,
+  canReadLongTermMemory: () => canReadLongTermMemory,
+  createLongTermMemoryCandidate: () => createLongTermMemoryCandidate,
+  createManualLongTermMemory: () => createManualLongTermMemory,
+  getLongTermMemoryDetail: () => getLongTermMemoryDetail,
+  isEligibleLongTermMemory: () => isEligibleLongTermMemory,
+  listLongTermMemories: () => listLongTermMemories,
+  promoteObservationToLongTermMemory: () => promoteObservationToLongTermMemory,
+  qualifyLongTermMemory: () => qualifyLongTermMemory,
+  renderLongTermMemorySummary: () => renderLongTermMemorySummary,
+  selectLongTermMemoriesForTask: () => selectLongTermMemoriesForTask,
+  supersedeLongTermMemory: () => supersedeLongTermMemory
+});
+import { randomUUID as randomUUID11 } from "crypto";
+function isOneOf(value, values) {
+  return typeof value === "string" && values.includes(value);
+}
+function compactText2(value, field, max = MAX_TEXT_LENGTH) {
+  if (typeof value !== "string") throw new Error("Long-term memory " + field + " must be text.");
+  const safe = sanitizeCredentials(value).replace(/\s+/g, " ").trim();
+  if (!safe) throw new Error("Long-term memory " + field + " is required.");
+  if (safe.length > max) throw new Error("Long-term memory " + field + " is too long.");
+  return safe;
+}
+function compactList(values, field) {
+  if (!values) return [];
+  if (!Array.isArray(values)) throw new Error("Long-term memory " + field + " must be an array.");
+  return [...new Set(values.filter((value) => typeof value === "string").map((value) => compactText2(value, field, 500)))].slice(0, MAX_LIST_ITEMS);
+}
+function normalizeEvidence(input) {
+  if (!Array.isArray(input) || input.length === 0) {
+    throw new Error("A long-term memory requires at least one source evidence reference.");
+  }
+  return input.map((evidence) => {
+    if (!evidence || !isOneOf(evidence.kind, LONG_TERM_MEMORY_EVIDENCE_KINDS)) {
+      throw new Error("Long-term memory evidence kind is invalid.");
+    }
+    if (!isOneOf(evidence.relation, LONG_TERM_MEMORY_EVIDENCE_RELATIONS)) {
+      throw new Error("Long-term memory evidence relation is invalid.");
+    }
+    return {
+      kind: evidence.kind,
+      referenceId: compactText2(evidence.referenceId, "evidence reference", 1e3),
+      relation: evidence.relation,
+      ...evidence.locator ? { locator: compactText2(evidence.locator, "evidence locator", 1e3) } : {},
+      ...evidence.capturedHash ? { capturedHash: compactText2(evidence.capturedHash, "evidence hash", 1e3) } : {}
+    };
+  });
+}
+function assertScope(scope) {
+  if (!isOneOf(scope, LONG_TERM_MEMORY_SCOPES)) throw new Error("Long-term memory scope is invalid.");
+}
+function assertKind(kind) {
+  if (!isOneOf(kind, LONG_TERM_MEMORY_KINDS)) throw new Error("Long-term memory kind is invalid.");
+}
+function assertPortability(value) {
+  if (!isOneOf(value, LONG_TERM_MEMORY_PORTABILITIES)) {
+    throw new Error("Long-term memory portability is invalid.");
+  }
+}
+function assertPortableEvidence(scope, portability, evidence) {
+  if (portability !== "portable") return;
+  if (scope !== "user") {
+    throw new Error("Only user-scoped long-term memories may be portable across projects.");
+  }
+  if (evidence.some((item) => !PORTABLE_EVIDENCE_KINDS.has(item.kind))) {
+    throw new Error("Portable user memory may only use manual or user-confirmed evidence; project code, Git, observation, test, session, claim, and workflow evidence must remain project-bound.");
+  }
+}
+function requireTeamReader(scope, reader) {
+  if (scope === "team" && reader?.isTeamMember !== true) {
+    throw new Error("Team long-term memory requires an explicit active team identity for this project.");
+  }
+}
+function matchesScope(memory, reader) {
+  if (memory.scope === "project") return memory.originProjectId === reader.projectId;
+  if (memory.scope === "team") {
+    return memory.originProjectId === reader.projectId && reader.isTeamMember === true;
+  }
+  if (!reader.ownerId || memory.ownerId !== reader.ownerId) return false;
+  return memory.portability === "portable" || memory.originProjectId === reader.projectId;
+}
+function canReadLongTermMemory(memory, reader) {
+  return matchesScope(memory, reader);
+}
+function isEligibleLongTermMemory(memory) {
+  return memory.state === "qualified" || memory.state === "approved";
+}
+function taskTerms(task) {
+  const matches = task.toLocaleLowerCase("en-US").match(/[\p{L}\p{N}_./:-]+/gu) ?? [];
+  return [...new Set(matches.filter((term) => term.length > 1 && !STOP_TERMS.has(term)))].slice(0, 16);
+}
+function kindFitScore(kind, task) {
+  const normalized = task.toLocaleLowerCase("en-US");
+  const hints = {
+    episodic: ["resume", "continue", "handoff", "previous", "session", "\u63A5\u624B", "\u7EE7\u7EED", "\u4EA4\u63A5", "\u4E0A\u6B21", "\u4F1A\u8BDD"],
+    semantic: ["why", "what", "architecture", "design", "decision", "reason", "\u4E3A\u4EC0\u4E48", "\u662F\u4EC0\u4E48", "\u67B6\u6784", "\u8BBE\u8BA1", "\u51B3\u7B56", "\u539F\u56E0"],
+    procedural: ["how", "steps", "procedure", "run", "release", "publish", "verify", "implement", "\u6D41\u7A0B", "\u6B65\u9AA4", "\u53D1\u5E03", "\u9A8C\u8BC1", "\u4FEE\u590D", "\u5B9E\u73B0"]
+  };
+  return hints[kind].some((hint) => normalized.includes(hint)) ? 1 : 0;
+}
+function validationFreshnessScore(memory) {
+  const validatedAt = memory.lastValidatedAt ?? memory.approvedAt ?? memory.qualifiedAt;
+  if (!validatedAt) return 0;
+  const time3 = Date.parse(validatedAt);
+  if (!Number.isFinite(time3)) return 0;
+  const ageDays = Math.max(0, Date.now() - time3) / (24 * 60 * 60 * 1e3);
+  if (ageDays <= 30) return 0.35;
+  if (ageDays <= 90) return 0.15;
+  return 0;
+}
+function scoreForTask(memory, task) {
+  const terms = taskTerms(task);
+  if (terms.length === 0) return void 0;
+  const title = memory.title.toLocaleLowerCase("en-US");
+  const content = memory.content.toLocaleLowerCase("en-US");
+  const facts = memory.facts.join(" ").toLocaleLowerCase("en-US");
+  const tags = memory.tags.join(" ").toLocaleLowerCase("en-US");
+  const applicability = (memory.applicability ?? "").toLocaleLowerCase("en-US");
+  let score = memory.state === "approved" ? 0.5 : 0;
+  const matched = [];
+  for (const term of terms) {
+    let termScore = 0;
+    if (title.includes(term)) termScore += 5;
+    if (tags.includes(term)) termScore += 4;
+    if (applicability.includes(term)) termScore += 3;
+    if (facts.includes(term)) termScore += 2;
+    if (content.includes(term)) termScore += 1;
+    if (termScore > 0) {
+      score += termScore;
+      matched.push(term);
+    }
+  }
+  if (matched.length === 0) return void 0;
+  score += kindFitScore(memory.kind, task);
+  score += validationFreshnessScore(memory);
+  const kindLabel = memory.kind === "procedural" ? "procedure" : memory.kind === "semantic" ? "fact" : "episode";
+  const freshness = validationFreshnessScore(memory) > 0 ? "; recently validated" : "";
+  return { score, reason: kindLabel + " matches " + matched.slice(0, 3).join(", ") + freshness };
+}
+function semanticText(memory) {
+  return sanitizeCredentials([
+    memory.title,
+    memory.applicability,
+    memory.tags.join(" "),
+    memory.facts.join(" "),
+    memory.content
+  ].filter((value) => Boolean(value)).join("\n")).replace(/\s+/g, " ").trim().slice(0, MAX_TEXT_LENGTH);
+}
+function cosineSimilarity(left, right) {
+  if (left.length === 0 || left.length !== right.length) return 0;
+  let dot = 0;
+  let leftMagnitude = 0;
+  let rightMagnitude = 0;
+  for (let index = 0; index < left.length; index += 1) {
+    const a3 = left[index];
+    const b3 = right[index];
+    if (!Number.isFinite(a3) || !Number.isFinite(b3)) return 0;
+    dot += a3 * b3;
+    leftMagnitude += a3 * a3;
+    rightMagnitude += b3 * b3;
+  }
+  if (leftMagnitude === 0 || rightMagnitude === 0) return 0;
+  return dot / Math.sqrt(leftMagnitude * rightMagnitude);
+}
+function semanticSelection(memory, similarity, task) {
+  if (similarity < MIN_SEMANTIC_SIMILARITY) return void 0;
+  const kindLabel = memory.kind === "procedural" ? "procedure" : memory.kind === "semantic" ? "fact" : "episode";
+  const freshness = validationFreshnessScore(memory) > 0 ? "; recently validated" : "";
+  return {
+    score: similarity * 10 + (memory.state === "approved" ? 0.5 : 0) + kindFitScore(memory.kind, task) + validationFreshnessScore(memory),
+    reason: kindLabel + " semantic match " + similarity.toFixed(2) + freshness
+  };
+}
+async function resolveSemanticProvider(explicit) {
+  if (explicit !== void 0) return explicit;
+  try {
+    const { getEmbeddingProvider: getEmbeddingProvider2 } = await Promise.resolve().then(() => (init_provider(), provider_exports));
+    return await withTimeout(
+      getEmbeddingProvider2({ requestTimeoutMs: SEMANTIC_RETRIEVAL_TIMEOUT_MS, retry: false }),
+      SEMANTIC_RETRIEVAL_TIMEOUT_MS,
+      "Long-term semantic provider initialization"
+    );
+  } catch {
+    return null;
+  }
+}
+function createStore(dataDir) {
+  const store2 = new LongTermMemoryStore();
+  return store2.init(dataDir).then(() => store2);
+}
+async function createManualLongTermMemory(input) {
+  const owner = await resolveLocalMemoryOwner(input.dataDir, { create: true });
+  if (!owner) throw new Error("Memorix could not resolve a local memory owner.");
+  assertScope(input.scope);
+  const evidence = input.scope === "user" ? [{ kind: "user", referenceId: owner.id, relation: "user-confirmed" }] : [{ kind: "manual", referenceId: "manual:" + randomUUID11(), relation: "supports" }];
+  return createLongTermMemoryWithDataDir({
+    dataDir: input.dataDir,
+    originProjectId: input.projectId,
+    ownerId: owner.id,
+    scope: input.scope,
+    kind: input.kind,
+    portability: input.portability,
+    title: input.title,
+    content: input.content,
+    facts: input.facts,
+    tags: input.tags,
+    applicability: input.applicability,
+    origin: "manual",
+    evidence,
+    reader: input.reader
+  });
+}
+async function promoteObservationToLongTermMemory(input) {
+  const owner = await resolveLocalMemoryOwner(input.dataDir, { create: true });
+  if (!owner) throw new Error("Memorix could not resolve a local memory owner.");
+  return createLongTermMemoryWithDataDir({
+    dataDir: input.dataDir,
+    originProjectId: input.observation.projectId,
+    ownerId: owner.id,
+    scope: input.scope,
+    kind: input.kind,
+    portability: "project-bound",
+    title: input.observation.title,
+    content: input.observation.narrative,
+    facts: input.observation.facts,
+    tags: input.tags ?? input.observation.concepts,
+    applicability: input.applicability,
+    origin: input.observation.source === "git" ? "git" : "agent",
+    evidence: [{
+      kind: "observation",
+      referenceId: "obs:" + input.observation.projectId + ":" + input.observation.id,
+      relation: "derives"
+    }],
+    reader: input.reader
+  });
+}
+async function createLongTermMemoryCandidate(input) {
+  return createLongTermMemoryWithDataDir(input);
+}
+async function createLongTermMemoryWithDataDir(input) {
+  assertScope(input.scope);
+  assertKind(input.kind);
+  const portability = input.portability ?? "project-bound";
+  assertPortability(portability);
+  requireTeamReader(input.scope, input.reader);
+  const evidenceInputs = normalizeEvidence(input.evidence);
+  assertPortableEvidence(input.scope, portability, evidenceInputs);
+  const now3 = (/* @__PURE__ */ new Date()).toISOString();
+  const memory = {
+    id: randomUUID11(),
+    originProjectId: compactText2(input.originProjectId, "origin project id", 1e3),
+    ownerId: compactText2(input.ownerId, "owner id", 160),
+    scope: input.scope,
+    kind: input.kind,
+    state: "candidate",
+    portability,
+    title: compactText2(input.title, "title", 500),
+    content: compactText2(input.content, "content"),
+    facts: compactList(input.facts, "facts"),
+    tags: compactList(input.tags, "tags"),
+    ...input.applicability ? { applicability: compactText2(input.applicability, "applicability", 1e3) } : {},
+    origin: input.origin ?? "manual",
+    createdAt: now3,
+    updatedAt: now3,
+    accessCount: 0
+  };
+  const store2 = await createStore(input.dataDir);
+  const evidence = store2.transaction(() => {
+    store2.insert(memory);
+    const written = evidenceInputs.map((item) => store2.insertEvidence({ memoryId: memory.id, ...item, createdAt: now3 }));
+    store2.recordEvent({
+      memoryId: memory.id,
+      kind: "created",
+      toState: "candidate",
+      detail: "Created as a source-backed long-term memory candidate.",
+      createdAt: now3
+    });
+    return written;
+  });
+  return { memory, evidence };
+}
+function transitionDetail(value) {
+  return compactText2(value, "transition reason", 1e3);
+}
+async function transitionMemory(input) {
+  const store2 = await createStore(input.dataDir);
+  return store2.transaction(() => {
+    const current = store2.get(input.id);
+    if (!current) throw new Error("Long-term memory was not found.");
+    if (current.state !== input.expected) {
+      throw new Error("Long-term memory must be " + input.expected + " before it can be " + input.next + ".");
+    }
+    const evidence = store2.listEvidence(current.id);
+    if (evidence.length === 0) throw new Error("Long-term memory cannot advance without source evidence.");
+    const now3 = (/* @__PURE__ */ new Date()).toISOString();
+    const next = {
+      ...current,
+      state: input.next,
+      updatedAt: now3,
+      lastValidatedAt: now3,
+      ...input.next === "qualified" ? { qualifiedAt: now3 } : { approvedAt: now3 }
+    };
+    store2.update(next);
+    store2.recordEvent({
+      memoryId: next.id,
+      kind: input.event,
+      fromState: current.state,
+      toState: next.state,
+      detail: transitionDetail(input.reason),
+      createdAt: now3
+    });
+    return next;
+  });
+}
+async function qualifyLongTermMemory(input) {
+  return transitionMemory({ ...input, expected: "candidate", next: "qualified", event: "qualified" });
+}
+async function approveLongTermMemory(input) {
+  return transitionMemory({ ...input, expected: "qualified", next: "approved", event: "approved" });
+}
+async function archiveLongTermMemory(input) {
+  const store2 = await createStore(input.dataDir);
+  return store2.transaction(() => {
+    const current = store2.get(input.id);
+    if (!current) throw new Error("Long-term memory was not found.");
+    if (current.state === "archived" || current.state === "superseded") {
+      throw new Error("Long-term memory is already inactive.");
+    }
+    const now3 = (/* @__PURE__ */ new Date()).toISOString();
+    const next = { ...current, state: "archived", archivedAt: now3, updatedAt: now3 };
+    store2.update(next);
+    store2.recordEvent({
+      memoryId: next.id,
+      kind: "archived",
+      fromState: current.state,
+      toState: "archived",
+      detail: transitionDetail(input.reason),
+      createdAt: now3
+    });
+    return next;
+  });
+}
+async function supersedeLongTermMemory(input) {
+  const store2 = await createStore(input.dataDir);
+  return store2.transaction(() => {
+    const current = store2.get(input.id);
+    if (!current) throw new Error("Long-term memory was not found.");
+    if (current.state === "archived" || current.state === "superseded") {
+      throw new Error("Long-term memory is already inactive.");
+    }
+    if (current.id === input.supersededBy) {
+      throw new Error("Long-term memory cannot supersede itself.");
+    }
+    const replacement = store2.get(input.supersededBy);
+    if (!replacement || !isEligibleLongTermMemory(replacement)) {
+      throw new Error("Replacement long-term memory must be qualified or approved.");
+    }
+    if (replacement.scope !== current.scope) {
+      throw new Error("Replacement long-term memory must use the same scope.");
+    }
+    if (current.scope === "user" && replacement.ownerId !== current.ownerId) {
+      throw new Error("User long-term memory may only be superseded by the same local owner.");
+    }
+    if (current.scope !== "user" && replacement.originProjectId !== current.originProjectId) {
+      throw new Error("Project and team long-term memory may only be superseded within the same project.");
+    }
+    const now3 = (/* @__PURE__ */ new Date()).toISOString();
+    const next = {
+      ...current,
+      state: "superseded",
+      supersededBy: replacement.id,
+      updatedAt: now3
+    };
+    store2.update(next);
+    store2.recordEvent({
+      memoryId: next.id,
+      kind: "superseded",
+      fromState: current.state,
+      toState: "superseded",
+      detail: transitionDetail(input.reason),
+      createdAt: now3
+    });
+    return next;
+  });
+}
+async function listLongTermMemories(input) {
+  const store2 = await createStore(input.dataDir);
+  return store2.list({ limit: input.limit ?? 100 }).filter((memory) => canReadLongTermMemory(memory, input.reader)).filter((memory) => input.includeInactive || memory.state !== "archived" && memory.state !== "superseded").map((memory) => ({ memory, evidence: store2.listEvidence(memory.id) }));
+}
+async function getLongTermMemoryDetail(input) {
+  const store2 = await createStore(input.dataDir);
+  const memory = store2.get(input.id);
+  if (!memory || !canReadLongTermMemory(memory, input.reader)) {
+    throw new Error("Long-term memory was not found in the active scope.");
+  }
+  store2.markAccess([memory.id]);
+  return { memory, evidence: store2.listEvidence(memory.id), events: store2.listEvents(memory.id) };
+}
+async function selectLongTermMemoriesForTask(input) {
+  const task = input.task?.trim();
+  if (!task) return [];
+  const owner = await resolveLocalMemoryOwner(input.dataDir, { create: false });
+  const reader = {
+    projectId: input.projectId,
+    ...owner ? { ownerId: owner.id } : {},
+    ...input.agentId ? { agentId: input.agentId } : {},
+    ...input.isTeamMember ? { isTeamMember: true } : {}
+  };
+  const store2 = await createStore(input.dataDir);
+  const eligible = store2.list({ limit: 1e3 }).filter((memory) => isEligibleLongTermMemory(memory) && canReadLongTermMemory(memory, reader));
+  let selected = eligible.map((memory) => {
+    const ranked = scoreForTask(memory, task);
+    return ranked ? {
+      memory,
+      evidence: store2.listEvidence(memory.id),
+      score: ranked.score,
+      reason: ranked.reason
+    } : void 0;
+  }).filter((item) => Boolean(item)).sort((left, right) => right.score - left.score || right.memory.updatedAt.localeCompare(left.memory.updatedAt) || left.memory.id.localeCompare(right.memory.id));
+  if (selected.length === 0 && eligible.length > 0) {
+    const provider2 = await resolveSemanticProvider(input.embeddingProvider);
+    const candidates = eligible.slice(0, MAX_SEMANTIC_CANDIDATES);
+    if (provider2 && candidates.length > 0) {
+      try {
+        const vectors = await withTimeout(
+          provider2.embedBatch([task, ...candidates.map(semanticText)], {
+            timeoutMs: SEMANTIC_RETRIEVAL_TIMEOUT_MS,
+            retry: false
+          }),
+          SEMANTIC_RETRIEVAL_TIMEOUT_MS,
+          "Long-term semantic retrieval"
+        );
+        const query = vectors[0];
+        if (Array.isArray(query)) {
+          selected = candidates.map((memory, index) => {
+            const vector = vectors[index + 1];
+            const ranked = Array.isArray(vector) ? semanticSelection(memory, cosineSimilarity(query, vector), task) : void 0;
+            return ranked ? {
+              memory,
+              evidence: store2.listEvidence(memory.id),
+              score: ranked.score,
+              reason: ranked.reason
+            } : void 0;
+          }).filter((item) => Boolean(item)).sort((left, right) => right.score - left.score || right.memory.updatedAt.localeCompare(left.memory.updatedAt) || left.memory.id.localeCompare(right.memory.id));
+        }
+      } catch {
+      }
+    }
+  }
+  selected = selected.slice(0, Math.max(1, Math.min(input.limit ?? 3, 5)));
+  store2.markAccess(selected.map((item) => item.memory.id));
+  return selected;
+}
+function renderLongTermMemorySummary(memory, maxTokens = 22) {
+  const source = [memory.title, memory.applicability, memory.content].filter(Boolean).join(": ");
+  const safe = sanitizeCredentials(source).replace(/\s+/g, " ").trim();
+  return countTextTokens(safe) <= maxTokens ? safe : truncateToTokenBudget(safe, maxTokens);
+}
+var MAX_TEXT_LENGTH, MAX_LIST_ITEMS, MAX_SEMANTIC_CANDIDATES, SEMANTIC_RETRIEVAL_TIMEOUT_MS, MIN_SEMANTIC_SIMILARITY, PORTABLE_EVIDENCE_KINDS, STOP_TERMS;
+var init_long_term = __esm({
+  "src/memory/long-term.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_token_budget();
+    init_timeout();
+    init_secret_filter();
+    init_owner();
+    init_long_term_store();
+    init_long_term_types();
+    MAX_TEXT_LENGTH = 12e3;
+    MAX_LIST_ITEMS = 40;
+    MAX_SEMANTIC_CANDIDATES = 48;
+    SEMANTIC_RETRIEVAL_TIMEOUT_MS = 1800;
+    MIN_SEMANTIC_SIMILARITY = 0.58;
+    PORTABLE_EVIDENCE_KINDS = /* @__PURE__ */ new Set(["manual", "user"]);
+    STOP_TERMS = /* @__PURE__ */ new Set([
+      "the",
+      "and",
+      "for",
+      "with",
+      "from",
+      "that",
+      "this",
+      "into",
+      "when",
+      "what",
+      "\u5982\u4F55",
+      "\u4EC0\u4E48",
+      "\u8FD9\u4E2A",
+      "\u90A3\u4E2A",
+      "\u6211\u4EEC",
+      "\u9879\u76EE",
+      "\u8FDB\u884C",
+      "\u9700\u8981",
+      "\u7EE7\u7EED",
+      "\u5904\u7406"
+    ]);
+  }
+});
+
 // src/cli/commands/memory.ts
 var memory_exports = {};
 __export(memory_exports, {
@@ -32151,6 +33048,26 @@ function getStringArg(named, positional) {
 function getIdArg(args, positional) {
   return args.ids || args.id || positional.join(",");
 }
+function longTermKind(value) {
+  const normalized = (value ?? "semantic").trim().toLowerCase();
+  if (normalized === "episodic" || normalized === "semantic" || normalized === "procedural") return normalized;
+  throw new Error("long-term kind must be episodic, semantic, or procedural.");
+}
+function longTermScope(value) {
+  const normalized = (value ?? "project").trim().toLowerCase();
+  if (normalized === "project" || normalized === "user" || normalized === "team") return normalized;
+  throw new Error("long-term scope must be project, user, or team.");
+}
+function longTermPortability(value) {
+  const normalized = (value ?? "project-bound").trim().toLowerCase();
+  if (normalized === "project-bound" || normalized === "portable") return normalized;
+  throw new Error("long-term portability must be project-bound or portable.");
+}
+function requiredLongTermReason(value) {
+  const reason = value?.trim();
+  if (!reason) throw new Error("reason is required for this long-term memory transition.");
+  return reason;
+}
 var memory_default;
 var init_memory = __esm({
   "src/cli/commands/memory.ts"() {
@@ -32197,16 +33114,27 @@ var init_memory = __esm({
         instruction: { type: "string", description: "Custom instruction for promoted mini-skills" },
         tags: { type: "string", description: "Comma-separated extra tags for promoted mini-skills" },
         skillId: { type: "string", description: "Mini-skill ID for list/delete actions" },
+        kind: { type: "string", description: "Long-term memory kind: episodic, semantic, or procedural" },
+        scope: { type: "string", description: "Long-term memory scope: project, user, or team" },
+        portability: { type: "string", description: "Long-term memory portability: project-bound or portable" },
+        applicability: { type: "string", description: "When a long-term memory applies" },
+        fromObservation: { type: "string", description: "Observation ID to promote into long-term memory" },
+        supersededBy: { type: "string", description: "Qualified or approved long-term memory that replaces the current record" },
+        "superseded-by": { type: "string", description: "Kebab-case alias for --supersededBy" },
+        reason: { type: "string", description: "Evidence review reason for qualify, approve, or archive" },
+        all: { type: "boolean", description: "Include archived and superseded long-term memories in list output" },
         json: { type: "boolean", description: "Emit machine-readable JSON output" }
       },
       run: async ({ args }) => {
         const action = args._?.[0] || "";
         const positional = (args._ ?? []).slice(1);
+        const longTermAction = action === "long-term" ? (positional[0] || args.action || "list").trim().toLowerCase() : void 0;
         const asJson = !!args.json;
         try {
           const readOnlyActions = /* @__PURE__ */ new Set(["", "search", "graph-context", "recent", "suggest-topic-key", "detail", "timeline"]);
           const needsSearchIndex = action === "search" || action === "detail" || action === "timeline";
-          const context = readOnlyActions.has(action) ? await getCliReadContext({ searchIndex: needsSearchIndex }) : await getCliProjectContext({ searchIndex: true });
+          const longTermReadOnly = longTermAction === "list" || longTermAction === "show";
+          const context = readOnlyActions.has(action) || longTermReadOnly ? await getCliReadContext({ searchIndex: needsSearchIndex }) : await getCliProjectContext({ searchIndex: true });
           const { project, dataDir, reader, identity } = context;
           switch (action) {
             case "search": {
@@ -32518,6 +33446,160 @@ var init_memory = __esm({
               );
               return;
             }
+            case "long-term": {
+              const resolvedLongTermAction = longTermAction ?? "list";
+              const longTermPositional = positional.slice(1);
+              const {
+                archiveLongTermMemory: archiveLongTermMemory2,
+                approveLongTermMemory: approveLongTermMemory2,
+                createManualLongTermMemory: createManualLongTermMemory2,
+                getLongTermMemoryDetail: getLongTermMemoryDetail2,
+                listLongTermMemories: listLongTermMemories2,
+                promoteObservationToLongTermMemory: promoteObservationToLongTermMemory2,
+                qualifyLongTermMemory: qualifyLongTermMemory2,
+                supersedeLongTermMemory: supersedeLongTermMemory2
+              } = await Promise.resolve().then(() => (init_long_term(), long_term_exports));
+              const { resolveLocalMemoryOwner: resolveLocalMemoryOwner2 } = await Promise.resolve().then(() => (init_owner(), owner_exports));
+              const owner = await resolveLocalMemoryOwner2(dataDir, { create: false });
+              const longTermReader = {
+                projectId: project.id,
+                ...owner ? { ownerId: owner.id } : {},
+                ...reader.agentId ? { agentId: reader.agentId } : {},
+                ...reader.isTeamMember ? { isTeamMember: true } : {}
+              };
+              const memoryId = () => {
+                const id = args.id?.trim() || args.fromObservation?.trim() || longTermPositional[0]?.trim();
+                if (!id) throw new Error("long-term memory id is required.");
+                return id;
+              };
+              const scope = () => longTermScope(args.scope);
+              const kind = () => longTermKind(args.kind);
+              const portability = () => longTermPortability(args.portability);
+              const reason = () => requiredLongTermReason(args.reason);
+              switch (resolvedLongTermAction) {
+                case "list": {
+                  const memories = await listLongTermMemories2({
+                    dataDir,
+                    reader: longTermReader,
+                    includeInactive: !!args.all,
+                    limit: parsePositiveInt(args.limit, 50)
+                  });
+                  emitResult(
+                    { project, memories },
+                    memories.length === 0 ? "No long-term memories are visible in the active scope." : memories.map((item) => `- ${item.memory.id} [${item.memory.state}/${item.memory.kind}/${item.memory.scope}] ${item.memory.title}`).join("\n"),
+                    asJson
+                  );
+                  return;
+                }
+                case "show": {
+                  const detail = await getLongTermMemoryDetail2({ dataDir, id: memoryId(), reader: longTermReader });
+                  emitResult(
+                    { project, ...detail },
+                    [
+                      `${detail.memory.id} [${detail.memory.state}/${detail.memory.kind}/${detail.memory.scope}]`,
+                      detail.memory.title,
+                      detail.memory.content,
+                      `Evidence: ${detail.evidence.length}`,
+                      `Audit events: ${detail.events.length}`
+                    ].join("\n"),
+                    asJson
+                  );
+                  return;
+                }
+                case "add": {
+                  const content = getStringArg(args.text, longTermPositional);
+                  if (!content) {
+                    emitError('text is required for "memorix memory long-term add"', asJson);
+                    return;
+                  }
+                  const result = await createManualLongTermMemory2({
+                    dataDir,
+                    projectId: project.id,
+                    scope: scope(),
+                    kind: kind(),
+                    title: args.title?.trim() || content.slice(0, 100),
+                    content,
+                    facts: parseCsvList(args.facts),
+                    tags: parseCsvList(args.tags),
+                    applicability: args.applicability?.trim(),
+                    portability: portability(),
+                    reader: longTermReader
+                  });
+                  emitResult(
+                    { project, ...result },
+                    `Created long-term memory candidate ${result.memory.id}. Qualify it after checking its evidence.`,
+                    asJson
+                  );
+                  return;
+                }
+                case "promote": {
+                  const rawId = args.fromObservation?.trim() || args.id?.trim() || longTermPositional[0]?.trim();
+                  const observationId2 = Number.parseInt(rawId || "", 10);
+                  if (!Number.isFinite(observationId2)) {
+                    emitError('fromObservation or id must be an observation ID for "memorix memory long-term promote"', asJson);
+                    return;
+                  }
+                  const observation = getObservation(observationId2, project.id);
+                  if (!observation || !canManageObservation(observation, reader)) {
+                    emitError("Observation was not found or is outside the active write scope.", asJson);
+                    return;
+                  }
+                  const result = await promoteObservationToLongTermMemory2({
+                    dataDir,
+                    observation,
+                    scope: scope(),
+                    kind: kind(),
+                    tags: parseCsvList(args.tags),
+                    applicability: args.applicability?.trim(),
+                    reader: longTermReader
+                  });
+                  emitResult(
+                    { project, sourceObservationId: observation.id, ...result },
+                    `Promoted observation #${observation.id} to long-term memory candidate ${result.memory.id}.`,
+                    asJson
+                  );
+                  return;
+                }
+                case "qualify": {
+                  await getLongTermMemoryDetail2({ dataDir, id: memoryId(), reader: longTermReader });
+                  const memory = await qualifyLongTermMemory2({ dataDir, id: memoryId(), reason: reason() });
+                  emitResult({ project, memory }, `Qualified long-term memory ${memory.id}.`, asJson);
+                  return;
+                }
+                case "approve": {
+                  await getLongTermMemoryDetail2({ dataDir, id: memoryId(), reader: longTermReader });
+                  const memory = await approveLongTermMemory2({ dataDir, id: memoryId(), reason: reason() });
+                  emitResult({ project, memory }, `Approved long-term memory ${memory.id}.`, asJson);
+                  return;
+                }
+                case "archive": {
+                  await getLongTermMemoryDetail2({ dataDir, id: memoryId(), reader: longTermReader });
+                  const memory = await archiveLongTermMemory2({ dataDir, id: memoryId(), reason: reason() });
+                  emitResult({ project, memory }, `Archived long-term memory ${memory.id}.`, asJson);
+                  return;
+                }
+                case "supersede": {
+                  const supersededBy = args.supersededBy?.trim() || args["superseded-by"]?.trim();
+                  if (!supersededBy) {
+                    emitError('supersededBy is required for "memorix memory long-term supersede"', asJson);
+                    return;
+                  }
+                  await getLongTermMemoryDetail2({ dataDir, id: memoryId(), reader: longTermReader });
+                  await getLongTermMemoryDetail2({ dataDir, id: supersededBy, reader: longTermReader });
+                  const memory = await supersedeLongTermMemory2({
+                    dataDir,
+                    id: memoryId(),
+                    supersededBy,
+                    reason: reason()
+                  });
+                  emitResult({ project, memory }, `Superseded long-term memory ${memory.id} with ${supersededBy}.`, asJson);
+                  return;
+                }
+                default:
+                  emitError("long-term action must be list, show, add, promote, qualify, approve, archive, or supersede.", asJson);
+              }
+              return;
+            }
             default:
               console.log("Memorix Memory Commands");
               console.log("");
@@ -32533,6 +33615,13 @@ var init_memory = __esm({
               console.log('  memorix memory deduplicate [--query "..."] [--dryRun]');
               console.log("  memorix memory consolidate [--action preview|execute] [--threshold 0.45]");
               console.log('  memorix memory promote --ids 42,43 [--trigger "..."] [--instruction "..."]');
+              console.log("  memorix memory long-term list [--all]");
+              console.log('  memorix memory long-term add --kind semantic --scope user --portability portable --title "..." --text "..." [--tags "..."] [--applicability "..."]');
+              console.log("  memorix memory long-term promote --fromObservation 42 --kind procedural --scope project");
+              console.log('  memorix memory long-term qualify --id <id> --reason "verified against evidence"');
+              console.log('  memorix memory long-term approve --id <id> --reason "reviewed by operator"');
+              console.log('  memorix memory long-term archive --id <id> --reason "no longer current"');
+              console.log('  memorix memory long-term supersede --id <old-id> --superseded-by <qualified-id> --reason "replaced"');
           }
         } catch (error2) {
           emitError(error2 instanceof Error ? error2.message : String(error2), asJson);
@@ -32543,7 +33632,7 @@ var init_memory = __esm({
 });
 
 // src/cli/commands/init-shared.ts
-import path19 from "path";
+import path20 from "path";
 function resolveInitScope(args, selectedScope) {
   if (args.global && args.project) {
     throw new Error("Choose either --global or --project, not both.");
@@ -32557,7 +33646,7 @@ function resolveInitScope(args, selectedScope) {
   return selectedScope ?? "global";
 }
 function getInitTargetDir(scope, cwd, homeDir) {
-  return scope === "global" ? path19.join(homeDir, ".memorix") : cwd;
+  return scope === "global" ? path20.join(homeDir, ".memorix") : cwd;
 }
 function getInitScopeDescription(scope) {
   return scope === "global" ? "Global defaults for all projects on this machine" : "Project-level overrides for the current repository";
@@ -32567,7 +33656,7 @@ function shouldOfferDotenv(scope) {
 }
 function getEnvTemplateTarget(targetDir, options2) {
   const filename = options2.hasDotenvExample ? ".env.memorix-example" : ".env.example";
-  return path19.join(targetDir, filename);
+  return path20.join(targetDir, filename);
 }
 function getInitConfigFilename() {
   return "config.toml";
@@ -32590,7 +33679,7 @@ __export(init_exports, {
 });
 import { existsSync as existsSync11, mkdirSync, writeFileSync } from "fs";
 import { homedir as homedir8 } from "os";
-import path20 from "path";
+import path21 from "path";
 function buildInitTomlConfig(options2) {
   const isGlobal = options2.scope === "global";
   const lines = [
@@ -32724,8 +33813,8 @@ var init_init = __esm({
         }
         const isGlobal = scope === "global";
         const targetDir = getInitTargetDir(scope, process.cwd(), homedir8());
-        const targetPath = path20.join(targetDir, isGlobal ? getInitConfigFilename() : getInitProjectConfigFilename());
-        const envPath = path20.join(targetDir, ".env");
+        const targetPath = path21.join(targetDir, isGlobal ? getInitConfigFilename() : getInitProjectConfigFilename());
+        const envPath = path21.join(targetDir, ".env");
         v3.info(getInitScopeDescription(scope));
         if (existsSync11(targetPath)) {
           const overwrite = await me({
@@ -32829,7 +33918,7 @@ var init_init = __esm({
         v3.success(`Created ${targetPath}`);
         if (shouldOfferDotenv(scope)) {
           const envExamplePath = getEnvTemplateTarget(targetDir, {
-            hasDotenvExample: existsSync11(path20.join(targetDir, ".env.example"))
+            hasDotenvExample: existsSync11(path21.join(targetDir, ".env.example"))
           });
           const envContent = envLines.join("\n");
           if (existsSync11(envExamplePath)) {
@@ -32845,7 +33934,7 @@ var init_init = __esm({
           writeFileSync(envExamplePath, envContent, "utf-8");
           v3.success(`Created ${envExamplePath}`);
           const createEnv = !existsSync11(envPath) ? await me({
-            message: `Create .env from ${path20.basename(envExamplePath)} now? (you can fill in keys later)`,
+            message: `Create .env from ${path21.basename(envExamplePath)} now? (you can fill in keys later)`,
             initialValue: true
           }) : false;
           if (!BD(createEnv) && createEnv) {
@@ -34286,15 +35375,15 @@ __export(audit_exports, {
   removeFile: () => removeFile,
   saveAudit: () => saveAudit
 });
-import * as fs15 from "fs/promises";
-import * as path21 from "path";
+import * as fs16 from "fs/promises";
+import * as path22 from "path";
 import { homedir as homedir22 } from "os";
 function getAuditFilePath() {
-  return process.env.MEMORIX_AUDIT_FILE || path21.join(homedir22(), ".memorix", "audit.json");
+  return process.env.MEMORIX_AUDIT_FILE || path22.join(homedir22(), ".memorix", "audit.json");
 }
 async function loadAudit() {
   try {
-    const content = await fs15.readFile(getAuditFilePath(), "utf-8");
+    const content = await fs16.readFile(getAuditFilePath(), "utf-8");
     return JSON.parse(content);
   } catch {
     return {
@@ -34305,9 +35394,9 @@ async function loadAudit() {
 }
 async function saveAudit(data) {
   const auditFile = getAuditFilePath();
-  const dir = path21.dirname(auditFile);
-  await fs15.mkdir(dir, { recursive: true });
-  await fs15.writeFile(auditFile, JSON.stringify(data, null, 2), "utf-8");
+  const dir = path22.dirname(auditFile);
+  await fs16.mkdir(dir, { recursive: true });
+  await fs16.writeFile(auditFile, JSON.stringify(data, null, 2), "utf-8");
 }
 function getProjectId(projectRoot) {
   try {
@@ -34389,8 +35478,8 @@ __export(installers_exports, {
   resolveOpenCodeHookCommand: () => resolveOpenCodeHookCommand,
   uninstallHooks: () => uninstallHooks
 });
-import * as fs16 from "fs/promises";
-import * as path22 from "path";
+import * as fs17 from "fs/promises";
+import * as path23 from "path";
 import * as os3 from "os";
 import { execSync as execSync2 } from "child_process";
 function resolveHookCommand() {
@@ -34406,7 +35495,7 @@ function resolveWindowsMemorixShim() {
       stdio: ["ignore", "pipe", "ignore"],
       windowsHide: true
     }));
-    return output.split(/\r?\n/).map((candidate2) => candidate2.trim()).find((candidate2) => path22.isAbsolute(candidate2)) ?? null;
+    return output.split(/\r?\n/).map((candidate2) => candidate2.trim()).find((candidate2) => path23.isAbsolute(candidate2)) ?? null;
   } catch {
     return null;
   }
@@ -34601,9 +35690,9 @@ async function installOfficialSkillsForAgent(agent, projectRoot, global2 = false
   const root = global2 ? os3.homedir() : projectRoot;
   const skillPaths = [];
   for (const skillEntry of OFFICIAL_MEMORIX_SKILLS) {
-    const skillPath = path22.join(root, relativeDir, skillEntry.name, "SKILL.md");
-    await fs16.mkdir(path22.dirname(skillPath), { recursive: true });
-    await fs16.writeFile(skillPath, skillEntry.content, "utf-8");
+    const skillPath = path23.join(root, relativeDir, skillEntry.name, "SKILL.md");
+    await fs17.mkdir(path23.dirname(skillPath), { recursive: true });
+    await fs17.writeFile(skillPath, skillEntry.content, "utf-8");
     skillPaths.push(skillPath);
     try {
       const { recordFile: recordFile2 } = await Promise.resolve().then(() => (init_audit(), audit_exports));
@@ -34816,124 +35905,124 @@ async function installOpenCodeSkills(projectRoot, global2 = false) {
 function getProjectConfigPath(agent, projectRoot) {
   switch (agent) {
     case "claude":
-      return path22.join(projectRoot, ".claude", "settings.local.json");
+      return path23.join(projectRoot, ".claude", "settings.local.json");
     case "copilot":
-      return path22.join(projectRoot, ".github", "hooks", "memorix.json");
+      return path23.join(projectRoot, ".github", "hooks", "memorix.json");
     case "windsurf":
-      return path22.join(projectRoot, ".windsurf", "hooks.json");
+      return path23.join(projectRoot, ".windsurf", "hooks.json");
     case "cursor":
-      return path22.join(projectRoot, ".cursor", "hooks.json");
+      return path23.join(projectRoot, ".cursor", "hooks.json");
     case "kiro":
-      return path22.join(projectRoot, ".kiro", "hooks", "memorix-agent-stop.kiro.hook");
+      return path23.join(projectRoot, ".kiro", "hooks", "memorix-agent-stop.kiro.hook");
     case "codex":
-      return path22.join(projectRoot, "AGENTS.md");
+      return path23.join(projectRoot, "AGENTS.md");
     case "trae":
-      return path22.join(projectRoot, ".trae", "rules", "project_rules.md");
+      return path23.join(projectRoot, ".trae", "rules", "project_rules.md");
     case "opencode":
-      return path22.join(projectRoot, ".opencode", "plugins", "memorix.js");
+      return path23.join(projectRoot, ".opencode", "plugins", "memorix.js");
     case "pi":
-      return path22.join(projectRoot, ".pi", "packages", "memorix", "extensions", "memorix.js");
+      return path23.join(projectRoot, ".pi", "packages", "memorix", "extensions", "memorix.js");
     case "openclaw":
-      return path22.join(os3.homedir(), ".openclaw", "extensions", "memorix", "hooks", "memorix", "HOOK.md");
+      return path23.join(os3.homedir(), ".openclaw", "extensions", "memorix", "hooks", "memorix", "HOOK.md");
     case "hermes":
-      return path22.join(os3.homedir(), ".hermes", "plugins", "memorix", "plugin.yaml");
+      return path23.join(os3.homedir(), ".hermes", "plugins", "memorix", "plugin.yaml");
     case "omp":
-      return path22.join(projectRoot, ".omp", "packages", "memorix", "extensions", "memorix.js");
+      return path23.join(projectRoot, ".omp", "packages", "memorix", "extensions", "memorix.js");
     case "antigravity":
-      return path22.join(projectRoot, ".agents", "hooks.json");
+      return path23.join(projectRoot, ".agents", "hooks.json");
     case "gemini-cli":
-      return path22.join(projectRoot, ".gemini", "settings.json");
+      return path23.join(projectRoot, ".gemini", "settings.json");
     default:
-      return path22.join(projectRoot, ".memorix", "hooks.json");
+      return path23.join(projectRoot, ".memorix", "hooks.json");
   }
 }
 function getGlobalConfigPath(agent) {
   const home = os3.homedir();
   switch (agent) {
     case "claude":
-      return path22.join(home, ".claude", "settings.json");
+      return path23.join(home, ".claude", "settings.json");
     case "copilot":
       return "";
     case "windsurf":
-      return path22.join(home, ".codeium", "windsurf", "hooks.json");
+      return path23.join(home, ".codeium", "windsurf", "hooks.json");
     case "cursor":
-      return path22.join(home, ".cursor", "hooks.json");
+      return path23.join(home, ".cursor", "hooks.json");
     case "antigravity":
-      return path22.join(home, ".gemini", "config", "hooks.json");
+      return path23.join(home, ".gemini", "config", "hooks.json");
     case "gemini-cli":
-      return path22.join(home, ".gemini", "settings.json");
+      return path23.join(home, ".gemini", "settings.json");
     case "opencode":
-      return path22.join(home, ".config", "opencode", "plugins", "memorix.js");
+      return path23.join(home, ".config", "opencode", "plugins", "memorix.js");
     case "pi":
-      return path22.join(home, ".pi", "agent", "packages", "memorix", "extensions", "memorix.js");
+      return path23.join(home, ".pi", "agent", "packages", "memorix", "extensions", "memorix.js");
     case "openclaw":
-      return path22.join(home, ".openclaw", "extensions", "memorix", "hooks", "memorix", "HOOK.md");
+      return path23.join(home, ".openclaw", "extensions", "memorix", "hooks", "memorix", "HOOK.md");
     case "hermes":
-      return path22.join(home, ".hermes", "plugins", "memorix", "plugin.yaml");
+      return path23.join(home, ".hermes", "plugins", "memorix", "plugin.yaml");
     case "omp":
-      return path22.join(home, ".omp", "agent", "packages", "memorix", "extensions", "memorix.js");
+      return path23.join(home, ".omp", "agent", "packages", "memorix", "extensions", "memorix.js");
     case "trae":
-      return path22.join(home, ".trae", "rules", "project_rules.md");
+      return path23.join(home, ".trae", "rules", "project_rules.md");
     default:
-      return path22.join(home, ".memorix", "hooks.json");
+      return path23.join(home, ".memorix", "hooks.json");
   }
 }
 function getAgentRulesPath(agent, root, global2 = false) {
   if (global2) {
     switch (agent) {
       case "windsurf":
-        return path22.join(root, ".codeium", "windsurf", "rules", "memorix.md");
+        return path23.join(root, ".codeium", "windsurf", "rules", "memorix.md");
       case "cursor":
-        return path22.join(root, ".cursor", "rules", "memorix.mdc");
+        return path23.join(root, ".cursor", "rules", "memorix.mdc");
       case "claude":
-        return path22.join(root, ".claude", "CLAUDE.md");
+        return path23.join(root, ".claude", "CLAUDE.md");
       case "codex":
-        return path22.join(root, ".codex", "AGENTS.md");
+        return path23.join(root, ".codex", "AGENTS.md");
       case "kiro":
-        return path22.join(root, ".kiro", "steering", "memorix.md");
+        return path23.join(root, ".kiro", "steering", "memorix.md");
       case "opencode":
-        return path22.join(root, ".config", "opencode", "AGENTS.md");
+        return path23.join(root, ".config", "opencode", "AGENTS.md");
       case "antigravity":
       case "gemini-cli":
-        return path22.join(root, ".gemini", "GEMINI.md");
+        return path23.join(root, ".gemini", "GEMINI.md");
       case "trae":
-        return path22.join(root, ".trae", "rules", "project_rules.md");
+        return path23.join(root, ".trae", "rules", "project_rules.md");
       default:
-        return path22.join(root, ".agent", "rules", "memorix.md");
+        return path23.join(root, ".agent", "rules", "memorix.md");
     }
   }
   switch (agent) {
     case "windsurf":
-      return path22.join(root, ".windsurf", "rules", "memorix.md");
+      return path23.join(root, ".windsurf", "rules", "memorix.md");
     case "cursor":
-      return path22.join(root, ".cursor", "rules", "memorix.mdc");
+      return path23.join(root, ".cursor", "rules", "memorix.mdc");
     case "claude":
-      return path22.join(root, "CLAUDE.md");
+      return path23.join(root, "CLAUDE.md");
     case "copilot":
-      return path22.join(root, ".github", "copilot-instructions.md");
+      return path23.join(root, ".github", "copilot-instructions.md");
     case "codex":
-      return path22.join(root, "AGENTS.md");
+      return path23.join(root, "AGENTS.md");
     case "kiro":
-      return path22.join(root, ".kiro", "steering", "memorix.md");
+      return path23.join(root, ".kiro", "steering", "memorix.md");
     case "opencode":
-      return path22.join(root, "AGENTS.md");
+      return path23.join(root, "AGENTS.md");
     case "antigravity":
     case "gemini-cli":
-      return path22.join(root, "GEMINI.md");
+      return path23.join(root, "GEMINI.md");
     case "trae":
-      return path22.join(root, ".trae", "rules", "project_rules.md");
+      return path23.join(root, ".trae", "rules", "project_rules.md");
     default:
-      return path22.join(root, ".agent", "rules", "memorix.md");
+      return path23.join(root, ".agent", "rules", "memorix.md");
   }
 }
 async function detectCopilotExtension(home) {
   const extDirs = [
-    path22.join(home, ".vscode", "extensions"),
-    path22.join(home, ".vscode-insiders", "extensions")
+    path23.join(home, ".vscode", "extensions"),
+    path23.join(home, ".vscode-insiders", "extensions")
   ];
   for (const extDir of extDirs) {
     try {
-      const entries = await fs16.readdir(extDir);
+      const entries = await fs17.readdir(extDir);
       if (entries.some((e3) => e3.startsWith("github.copilot-"))) {
         return true;
       }
@@ -34945,21 +36034,21 @@ async function detectCopilotExtension(home) {
 async function detectInstalledAgents() {
   const agents = [];
   const home = os3.homedir();
-  const claudeDir = path22.join(home, ".claude");
+  const claudeDir = path23.join(home, ".claude");
   try {
-    await fs16.access(claudeDir);
+    await fs17.access(claudeDir);
     agents.push("claude");
   } catch {
   }
-  const windsurfDir = path22.join(home, ".codeium", "windsurf");
+  const windsurfDir = path23.join(home, ".codeium", "windsurf");
   try {
-    await fs16.access(windsurfDir);
+    await fs17.access(windsurfDir);
     agents.push("windsurf");
   } catch {
   }
-  const cursorDir = path22.join(home, ".cursor");
+  const cursorDir = path23.join(home, ".cursor");
   try {
-    await fs16.access(cursorDir);
+    await fs17.access(cursorDir);
     agents.push("cursor");
   } catch {
   }
@@ -34967,21 +36056,21 @@ async function detectInstalledAgents() {
   if (copilotDetected) {
     agents.push("copilot");
   }
-  const kiroConfig = path22.join(home, ".kiro");
+  const kiroConfig = path23.join(home, ".kiro");
   try {
-    await fs16.access(kiroConfig);
+    await fs17.access(kiroConfig);
     agents.push("kiro");
   } catch {
   }
-  const codexDir = path22.join(home, ".codex");
+  const codexDir = path23.join(home, ".codex");
   try {
-    await fs16.access(codexDir);
+    await fs17.access(codexDir);
     agents.push("codex");
   } catch {
   }
-  const antigravityDir = path22.join(home, ".gemini", "config");
+  const antigravityDir = path23.join(home, ".gemini", "config");
   try {
-    await fs16.access(antigravityDir);
+    await fs17.access(antigravityDir);
     agents.push("antigravity");
   } catch {
   }
@@ -34992,15 +36081,15 @@ async function detectInstalledAgents() {
     agents.push("gemini-cli");
   } catch {
   }
-  const opencodeDir = path22.join(home, ".config", "opencode");
+  const opencodeDir = path23.join(home, ".config", "opencode");
   try {
-    await fs16.access(opencodeDir);
+    await fs17.access(opencodeDir);
     agents.push("opencode");
   } catch {
   }
-  const traeDir = path22.join(home, ".trae");
+  const traeDir = path23.join(home, ".trae");
   try {
-    await fs16.access(traeDir);
+    await fs17.access(traeDir);
     agents.push("trae");
   } catch {
   }
@@ -35034,7 +36123,7 @@ async function installHooks(agent, projectRoot, global2 = false) {
       try {
         const { access: access3, unlink: unlink2 } = await import("fs/promises");
         await access3(entry.path);
-        const basename5 = path22.basename(entry.path);
+        const basename5 = path23.basename(entry.path);
         if (basename5 === "AGENTS.md" || basename5 === "GEMINI.md" || basename5 === "CONTEXT.md") {
           continue;
         }
@@ -35089,8 +36178,8 @@ async function installHooks(agent, projectRoot, global2 = false) {
     case "opencode": {
       const pluginContent = generateOpenCodePlugin();
       const pluginPath = global2 ? getGlobalConfigPath(agent) : getProjectConfigPath(agent, projectRoot);
-      await fs16.mkdir(path22.dirname(pluginPath), { recursive: true });
-      await fs16.writeFile(pluginPath, pluginContent, "utf-8");
+      await fs17.mkdir(path23.dirname(pluginPath), { recursive: true });
+      await fs17.writeFile(pluginPath, pluginContent, "utf-8");
       try {
         const { recordFile: recordFile2 } = await Promise.resolve().then(() => (init_audit(), audit_exports));
         await recordFile2(projectRoot, "hook", pluginPath, agent);
@@ -35119,14 +36208,14 @@ async function installHooks(agent, projectRoot, global2 = false) {
     default:
       generated = generateClaudeConfig();
   }
-  await fs16.mkdir(path22.dirname(configPath), { recursive: true });
+  await fs17.mkdir(path23.dirname(configPath), { recursive: true });
   if (agent === "kiro") {
     const hookFiles = generateKiroHookFiles();
-    const hooksDir = path22.join(path22.dirname(configPath));
-    await fs16.mkdir(hooksDir, { recursive: true });
+    const hooksDir = path23.join(path23.dirname(configPath));
+    await fs17.mkdir(hooksDir, { recursive: true });
     for (const hf of hookFiles) {
-      const hookPath = path22.join(hooksDir, hf.filename);
-      await fs16.writeFile(hookPath, hf.content, "utf-8");
+      const hookPath = path23.join(hooksDir, hf.filename);
+      await fs17.writeFile(hookPath, hf.content, "utf-8");
       try {
         const { recordFile: recordFile2 } = await Promise.resolve().then(() => (init_audit(), audit_exports));
         await recordFile2(projectRoot, "hook", hookPath, agent);
@@ -35136,7 +36225,7 @@ async function installHooks(agent, projectRoot, global2 = false) {
   } else {
     let existing = {};
     try {
-      const content = await fs16.readFile(configPath, "utf-8");
+      const content = await fs17.readFile(configPath, "utf-8");
       existing = JSON.parse(content);
     } catch {
     }
@@ -35171,7 +36260,7 @@ async function installHooks(agent, projectRoot, global2 = false) {
       const h3 = merged.hooks;
       if (h3) delete h3.preToolUse;
     }
-    await fs16.writeFile(configPath, JSON.stringify(merged, null, 2), "utf-8");
+    await fs17.writeFile(configPath, JSON.stringify(merged, null, 2), "utf-8");
     try {
       const { recordFile: recordFile2 } = await Promise.resolve().then(() => (init_audit(), audit_exports));
       await recordFile2(projectRoot, "hook", configPath, agent);
@@ -35219,18 +36308,18 @@ async function installAgentRules(agent, projectRoot, global2 = false) {
   const rulesRoot = global2 ? os3.homedir() : projectRoot;
   const rulesPath = getAgentRulesPath(agent, rulesRoot, global2);
   try {
-    await fs16.mkdir(path22.dirname(rulesPath), { recursive: true });
+    await fs17.mkdir(path23.dirname(rulesPath), { recursive: true });
     if (agent === "claude" || agent === "codex" || agent === "opencode" || agent === "antigravity" || agent === "gemini-cli") {
       try {
-        const existing = await fs16.readFile(rulesPath, "utf-8");
-        await fs16.writeFile(rulesPath, mergeMemorixRulesContent(existing, rulesContent), "utf-8");
+        const existing = await fs17.readFile(rulesPath, "utf-8");
+        await fs17.writeFile(rulesPath, mergeMemorixRulesContent(existing, rulesContent), "utf-8");
         try {
           const { recordFile: recordFile2 } = await Promise.resolve().then(() => (init_audit(), audit_exports));
           await recordFile2(projectRoot, "rule", rulesPath, agent);
         } catch {
         }
       } catch {
-        await fs16.writeFile(rulesPath, rulesContent, "utf-8");
+        await fs17.writeFile(rulesPath, rulesContent, "utf-8");
         try {
           const { recordFile: recordFile2 } = await Promise.resolve().then(() => (init_audit(), audit_exports));
           await recordFile2(projectRoot, "rule", rulesPath, agent);
@@ -35239,9 +36328,9 @@ async function installAgentRules(agent, projectRoot, global2 = false) {
       }
     } else {
       try {
-        await fs16.access(rulesPath);
+        await fs17.access(rulesPath);
       } catch {
-        await fs16.writeFile(rulesPath, rulesContent, "utf-8");
+        await fs17.writeFile(rulesPath, rulesContent, "utf-8");
         try {
           const { recordFile: recordFile2 } = await Promise.resolve().then(() => (init_audit(), audit_exports));
           await recordFile2(projectRoot, "rule", rulesPath, agent);
@@ -35331,6 +36420,8 @@ alwaysApply: true
     "- Include `filesModified` when relevant",
     "- Use `topicKey` for topics that evolve over time (prevents duplicates)",
     '- For "why" decisions, use `memorix_store_reasoning`',
+    '- For a stable fact, reusable procedure, or completed episode that merits deliberate long-term review, include `longTerm` in `memorix_store` with the appropriate kind and normally `scope: "project"`. It creates a candidate only: do not use it for routine updates, do not make project-derived evidence portable user memory, and do not assume it enters context until an operator qualifies and approves it through `memorix memory long-term`.',
+    "- A `user` + `portable` durable memory delivered in a task brief is intentionally available across projects. When it matches the task, use it as reusable background even if its origin differs; do not treat it as a current-project fact. Expand it only when needed with `memorix_detail` using its `durable:<id>` reference and a specific purpose.",
     "",
     "**Don't store:** greetings, simple file reads, trivial commands (ls, pwd, git status).",
     "",
@@ -35367,16 +36458,16 @@ async function uninstallHooks(agent, projectRoot, global2 = false) {
   let success = false;
   try {
     if (agent === "kiro" || agent === "opencode") {
-      await fs16.unlink(configPath);
+      await fs17.unlink(configPath);
       success = true;
     } else {
-      const content = await fs16.readFile(configPath, "utf-8");
+      const content = await fs17.readFile(configPath, "utf-8");
       const config2 = JSON.parse(content);
       delete config2.hooks;
       if (Object.keys(config2).length === 0) {
-        await fs16.unlink(configPath);
+        await fs17.unlink(configPath);
       } else {
-        await fs16.writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
+        await fs17.writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
       }
       success = true;
     }
@@ -35389,10 +36480,10 @@ async function uninstallHooks(agent, projectRoot, global2 = false) {
     const agentFiles = prevFiles.filter((e3) => e3.agent === agent);
     for (const entry of agentFiles) {
       try {
-        const basename5 = path22.basename(entry.path);
+        const basename5 = path23.basename(entry.path);
         if (basename5 === "AGENTS.md" || basename5 === "GEMINI.md" || basename5 === "CONTEXT.md") {
           try {
-            const content = await fs16.readFile(entry.path, "utf-8");
+            const content = await fs17.readFile(entry.path, "utf-8");
             const memorixStart = content.indexOf("# Memorix");
             if (memorixStart >= 0) {
               const afterMemorix = content.substring(memorixStart);
@@ -35404,9 +36495,9 @@ async function uninstallHooks(agent, projectRoot, global2 = false) {
               }
               const cleaned = (before + "\n" + after).trim();
               if (cleaned.length === 0) {
-                await fs16.unlink(entry.path);
+                await fs17.unlink(entry.path);
               } else {
-                await fs16.writeFile(entry.path, cleaned + "\n", "utf-8");
+                await fs17.writeFile(entry.path, cleaned + "\n", "utf-8");
               }
             }
           } catch {
@@ -35415,7 +36506,7 @@ async function uninstallHooks(agent, projectRoot, global2 = false) {
           auditCleaned = true;
           continue;
         }
-        await fs16.unlink(entry.path);
+        await fs17.unlink(entry.path);
         await removeFile2(projectRoot, entry.path);
         auditCleaned = true;
       } catch {
@@ -35427,14 +36518,14 @@ async function uninstallHooks(agent, projectRoot, global2 = false) {
   if (success) {
     try {
       const { rm: rm2 } = await import("fs/promises");
-      const dir = path22.dirname(configPath);
+      const dir = path23.dirname(configPath);
       let current = dir;
       for (let i2 = 0; i2 < 3; i2++) {
         try {
-          const entries = await fs16.readdir(current);
+          const entries = await fs17.readdir(current);
           if (entries.length === 0) {
             await rm2(current, { recursive: true });
-            current = path22.dirname(current);
+            current = path23.dirname(current);
           } else {
             break;
           }
@@ -35458,12 +36549,12 @@ async function getHookStatus(projectRoot) {
     let usedPath = projectPath;
     const verifiedByDefault = agent !== "opencode" && agent !== "pi";
     try {
-      await fs16.access(projectPath);
+      await fs17.access(projectPath);
       installed = true;
     } catch {
       if (globalPath) {
         try {
-          await fs16.access(globalPath);
+          await fs17.access(globalPath);
           installed = true;
           usedPath = globalPath;
         } catch {
@@ -35472,7 +36563,7 @@ async function getHookStatus(projectRoot) {
     }
     if (installed && agent === "opencode") {
       try {
-        const content = await fs16.readFile(usedPath, "utf-8");
+        const content = await fs17.readFile(usedPath, "utf-8");
         const match = content.match(/@generated-version\s+(\d+)/);
         const installedVersion = match ? parseInt(match[1], 10) : 0;
         outdated = installedVersion < OPENCODE_PLUGIN_VERSION;
@@ -35503,11 +36594,11 @@ var init_installers = __esm({
     init_official_skills();
     OPENCODE_PLUGIN_VERSION = 7;
     AGENT_SKILL_DIRS = {
-      cursor: { project: path22.join(".cursor", "skills"), global: path22.join(".cursor", "skills") },
-      windsurf: { project: path22.join(".windsurf", "skills"), global: path22.join(".windsurf", "skills") },
-      kiro: { project: path22.join(".kiro", "skills"), global: path22.join(".kiro", "skills") },
-      opencode: { project: path22.join(".opencode", "skills"), global: path22.join(".config", "opencode", "skills") },
-      trae: { project: path22.join(".trae", "skills"), global: path22.join(".trae", "skills") }
+      cursor: { project: path23.join(".cursor", "skills"), global: path23.join(".cursor", "skills") },
+      windsurf: { project: path23.join(".windsurf", "skills"), global: path23.join(".windsurf", "skills") },
+      kiro: { project: path23.join(".kiro", "skills"), global: path23.join(".kiro", "skills") },
+      opencode: { project: path23.join(".opencode", "skills"), global: path23.join(".config", "opencode", "skills") },
+      trae: { project: path23.join(".trae", "skills"), global: path23.join(".trae", "skills") }
     };
     PACKAGE_OWNED_HOOK_AGENTS = /* @__PURE__ */ new Set(["openclaw", "hermes", "omp"]);
   }
@@ -35531,6 +36622,8 @@ __export(setup_exports, {
   installOpenClawBundlePackage: () => installOpenClawBundlePackage,
   installPiPackage: () => installPiPackage,
   installPluginPackage: () => installPluginPackage,
+  migrateLegacyCodexIntegration: () => migrateLegacyCodexIntegration,
+  parseCodexPluginState: () => parseCodexPluginState,
   removeLegacyCodexMemorixMcpConfig: () => removeLegacyCodexMemorixMcpConfig,
   tryInstallCodexPlugin: () => tryInstallCodexPlugin
 });
@@ -35539,7 +36632,7 @@ import { existsSync as existsSync12 } from "fs";
 import { copyFile, mkdir as mkdir5, readFile as readFile5, readdir as readdir2, rm, writeFile as writeFile5 } from "fs/promises";
 import { createRequire as createRequire5 } from "module";
 import { homedir as homedir24 } from "os";
-import path23 from "path";
+import path24 from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 function getSetupAgentTargets() {
   return [...SUPPORTED_SETUP_AGENTS];
@@ -35576,13 +36669,13 @@ function buildSetupPlan(options2) {
   if (!isPackageOwnedAgent && includeHooks) actions.push("hooks");
   return { agent: options2.agent, mcp, actions, includeHooks, includeRules, includePlugin: wantsPlugin };
 }
-function findPackageRoot(start = path23.dirname(fileURLToPath5(import.meta.url))) {
+function findPackageRoot(start = path24.dirname(fileURLToPath5(import.meta.url))) {
   let dir = start;
   for (let i2 = 0; i2 < 8; i2++) {
-    if (existsSync12(path23.join(dir, "package.json")) && existsSync12(path23.join(dir, "plugins"))) {
+    if (existsSync12(path24.join(dir, "package.json")) && existsSync12(path24.join(dir, "plugins"))) {
       return dir;
     }
-    const parent = path23.dirname(dir);
+    const parent = path24.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -35593,12 +36686,12 @@ async function copyDir(source, destination) {
   await mkdir5(destination, { recursive: true });
   const entries = await readdir2(source, { withFileTypes: true });
   for (const entry of entries) {
-    const src2 = path23.join(source, entry.name);
-    const dest = path23.join(destination, entry.name);
+    const src2 = path24.join(source, entry.name);
+    const dest = path24.join(destination, entry.name);
     if (entry.isDirectory()) {
       await copyDir(src2, dest);
     } else {
-      await mkdir5(path23.dirname(dest), { recursive: true });
+      await mkdir5(path24.dirname(dest), { recursive: true });
       await copyFile(src2, dest);
     }
   }
@@ -35606,16 +36699,16 @@ async function copyDir(source, destination) {
 async function writeOfficialSkills(skillsRoot) {
   const written = [];
   for (const skill2 of OFFICIAL_MEMORIX_SKILLS) {
-    const skillPath = path23.join(skillsRoot, skill2.name, "SKILL.md");
-    await mkdir5(path23.dirname(skillPath), { recursive: true });
+    const skillPath = path24.join(skillsRoot, skill2.name, "SKILL.md");
+    await mkdir5(path24.dirname(skillPath), { recursive: true });
     await writeFile5(skillPath, skill2.content, "utf-8");
     written.push(skillPath);
   }
   return written;
 }
 async function stripHookCaptureFromPlugin(pluginPath, agent) {
-  await rm(path23.join(pluginPath, "hooks"), { recursive: true, force: true });
-  const manifestPath = agent === "claude" ? path23.join(pluginPath, ".claude-plugin", "plugin.json") : agent === "codex" ? path23.join(pluginPath, ".codex-plugin", "plugin.json") : path23.join(pluginPath, "plugin.json");
+  await rm(path24.join(pluginPath, "hooks"), { recursive: true, force: true });
+  const manifestPath = agent === "claude" ? path24.join(pluginPath, ".claude-plugin", "plugin.json") : agent === "codex" ? path24.join(pluginPath, ".codex-plugin", "plugin.json") : path24.join(pluginPath, "plugin.json");
   try {
     const manifest = JSON.parse(await readFile5(manifestPath, "utf-8"));
     delete manifest.hooks;
@@ -35631,7 +36724,7 @@ async function stripHookCaptureFromPlugin(pluginPath, agent) {
   }
 }
 async function stampCodexPluginVersion(pluginPath) {
-  const manifestPath = path23.join(pluginPath, ".codex-plugin", "plugin.json");
+  const manifestPath = path24.join(pluginPath, ".codex-plugin", "plugin.json");
   const manifest = JSON.parse(await readFile5(manifestPath, "utf-8"));
   if (manifest.name !== "memorix") {
     throw new Error(`Unexpected Codex plugin manifest at ${manifestPath}`);
@@ -35641,8 +36734,8 @@ async function stampCodexPluginVersion(pluginPath) {
 `, "utf-8");
 }
 async function stripHookCaptureFromOpenClawBundle(bundlePath) {
-  await rm(path23.join(bundlePath, "hooks"), { recursive: true, force: true });
-  const manifestPath = path23.join(bundlePath, ".codex-plugin", "plugin.json");
+  await rm(path24.join(bundlePath, "hooks"), { recursive: true, force: true });
+  const manifestPath = path24.join(bundlePath, ".codex-plugin", "plugin.json");
   try {
     const manifest = JSON.parse(await readFile5(manifestPath, "utf-8"));
     delete manifest.hooks;
@@ -35678,7 +36771,7 @@ function mergeHermesPluginEnabled(existingContent, pluginName) {
   }, { lineWidth: -1 });
 }
 function relativePosix(from, to) {
-  let rel = path23.relative(from, to).replace(/\\/g, "/");
+  let rel = path24.relative(from, to).replace(/\\/g, "/");
   if (!rel.startsWith("./") && !rel.startsWith("../")) rel = `./${rel}`;
   return rel;
 }
@@ -35779,6 +36872,21 @@ function mergeTomlMcpConfig(existingContent, generatedContent) {
   return `${parts.join("\n\n")}
 `;
 }
+function getTomlSection(content, section) {
+  const lines = content.split(/\r?\n/);
+  const header = `[${section}]`;
+  const start = lines.findIndex((line) => line.trim() === header);
+  if (start < 0) return null;
+  let end = lines.length;
+  for (let index = start + 1; index < lines.length; index += 1) {
+    const trimmed = lines[index].trim();
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+      end = index;
+      break;
+    }
+  }
+  return lines.slice(start + 1, end).join("\n");
+}
 function isLegacyCodexMemorixNodeServer(server) {
   if (server.name !== "memorix" || server.command.trim().toLowerCase() !== "node") return false;
   const startsMemorixStdio = server.args.some((arg) => arg.trim().toLowerCase() === "serve");
@@ -35788,22 +36896,102 @@ function isLegacyCodexMemorixNodeServer(server) {
   });
   return startsMemorixStdio && sourceEntry;
 }
-async function removeLegacyCodexMemorixMcpConfig(configPath = path23.join(homedir24(), ".codex", "config.toml")) {
+function isOwnedLegacyCodexMcp(content) {
+  const section = getTomlSection(content, "mcp_servers.memorix");
+  if (section === null || getTomlSection(content, "mcp_servers.memorix.env") !== null) return false;
+  const allowedKeys = /* @__PURE__ */ new Set(["command", "args", "type", "startup_timeout_sec", "tool_timeout_sec", "enabled"]);
+  for (const rawLine of section.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const key = line.match(/^([A-Za-z0-9_]+)\s*=/)?.[1];
+    if (!key || !allowedKeys.has(key)) return false;
+  }
+  const server = new CodexMCPAdapter().parse(content).find((entry) => entry.name === "memorix");
+  return Boolean(server && isLegacyCodexMemorixNodeServer(server));
+}
+async function removeLegacyCodexMemorixMcpConfig(configPath = path24.join(homedir24(), ".codex", "config.toml")) {
   let existingContent;
   try {
     existingContent = await readFile5(configPath, "utf-8");
   } catch {
     return { configPath, removed: false };
   }
-  const adapter = new CodexMCPAdapter();
-  const legacyServer = adapter.parse(existingContent).find(isLegacyCodexMemorixNodeServer);
-  if (!legacyServer) return { configPath, removed: false };
+  if (!isOwnedLegacyCodexMcp(existingContent)) return { configPath, removed: false };
   let nextContent = removeTomlSection(existingContent, "mcp_servers.memorix.env");
   nextContent = removeTomlSection(nextContent, "mcp_servers.memorix");
   await writeFile5(configPath, nextContent ? `${nextContent}
 ` : "", "utf-8");
   return { configPath, removed: true };
 }
+function collectHookCommands(value, commands) {
+  if (Array.isArray(value)) {
+    for (const item of value) collectHookCommands(item, commands);
+    return;
+  }
+  if (!value || typeof value !== "object") return;
+  for (const [key, child] of Object.entries(value)) {
+    if ((key === "command" || key === "commandWindows") && typeof child === "string") {
+      commands.push(child);
+    } else {
+      collectHookCommands(child, commands);
+    }
+  }
+}
+function isOwnedLegacyCodexHooks(content) {
+  try {
+    const parsed = JSON.parse(content);
+    if (!parsed.hooks || typeof parsed.hooks !== "object") return false;
+    const commands = [];
+    collectHookCommands(parsed.hooks, commands);
+    return commands.length > 0 && commands.every((command) => /^memorix(?:\.cmd)?\s+hook(?:\s|$)/i.test(command.trim()));
+  } catch {
+    return false;
+  }
+}
+async function removeOwnedLegacyCodexPluginFolder(homeDir) {
+  const canonicalPath = path24.join(homeDir, "plugins", "memorix");
+  const legacyPath = path24.join(homeDir, ".codex", "plugins", "memorix");
+  if (!existsSync12(legacyPath)) return "missing";
+  if (!existsSync12(canonicalPath)) return "preserved";
+  try {
+    const manifest = JSON.parse(await readFile5(path24.join(legacyPath, ".codex-plugin", "plugin.json"), "utf-8"));
+    const repository = String(manifest.repository ?? "");
+    if (manifest.name !== "memorix" || !repository.includes("github.com/AVIDS2/memorix")) return "preserved";
+    await rm(legacyPath, { recursive: true, force: true });
+    return "removed";
+  } catch {
+    return "preserved";
+  }
+}
+async function migrateLegacyCodexIntegration(options2 = {}) {
+  const homeDir = options2.homeDir ?? homedir24();
+  const projectRoot = options2.projectRoot ?? process.cwd();
+  const configPath = path24.join(homeDir, ".codex", "config.toml");
+  let mcp = "missing";
+  try {
+    const content = await readFile5(configPath, "utf-8");
+    if (getTomlSection(content, "mcp_servers.memorix") !== null) {
+      mcp = (await removeLegacyCodexMemorixMcpConfig(configPath)).removed ? "removed" : "preserved";
+    }
+  } catch {
+    mcp = "missing";
+  }
+  const hooksPath = path24.join(projectRoot, ".codex", "hooks.json");
+  let projectHooks = "missing";
+  try {
+    const content = await readFile5(hooksPath, "utf-8");
+    if (isOwnedLegacyCodexHooks(content)) {
+      await rm(hooksPath, { force: true });
+      projectHooks = "removed";
+    } else {
+      projectHooks = "preserved";
+    }
+  } catch {
+    projectHooks = "missing";
+  }
+  const pluginFolder = await removeOwnedLegacyCodexPluginFolder(homeDir);
+  return { mcp, projectHooks, pluginFolder };
+}
 function mergeYamlMcpConfig(existingContent, generatedContent) {
   let existing = {};
   try {
@@ -35848,12 +37036,12 @@ async function installMcpConfig(options2) {
   }
   const generated = adapter.generate([server]);
   const content = options2.agent === "codex" ? mergeTomlMcpConfig(existingContent, generated) : options2.agent === "hermes" ? mergeYamlMcpConfig(existingContent, generated) : mergeJsonMcpConfig(existingContent, generated);
-  await mkdir5(path23.dirname(configPath), { recursive: true });
+  await mkdir5(path24.dirname(configPath), { recursive: true });
   await writeFile5(configPath, content, "utf-8");
   return { agent: options2.agent, configPath, transport: options2.mcp };
 }
 async function upsertCodexMarketplace(marketplacePath, pluginPath) {
-  await mkdir5(path23.dirname(marketplacePath), { recursive: true });
+  await mkdir5(path24.dirname(marketplacePath), { recursive: true });
   let catalog;
   try {
     catalog = JSON.parse(await readFile5(marketplacePath, "utf-8"));
@@ -35866,9 +37054,9 @@ async function upsertCodexMarketplace(marketplacePath, pluginPath) {
       plugins: []
     };
   }
-  const marketplaceDir = path23.dirname(marketplacePath);
-  const agentsDir = path23.dirname(marketplaceDir);
-  const marketplaceRoot = path23.basename(agentsDir) === ".agents" ? path23.dirname(agentsDir) : marketplaceDir;
+  const marketplaceDir = path24.dirname(marketplacePath);
+  const agentsDir = path24.dirname(marketplaceDir);
+  const marketplaceRoot = path24.basename(agentsDir) === ".agents" ? path24.dirname(agentsDir) : marketplaceDir;
   const sourcePath = relativePosix(marketplaceRoot, pluginPath);
   const entry = {
     name: "memorix",
@@ -35891,7 +37079,7 @@ async function upsertCodexMarketplace(marketplacePath, pluginPath) {
   await writeFile5(marketplacePath, JSON.stringify(catalog, null, 2) + "\n", "utf-8");
 }
 async function writeClaudeMarketplace(marketplacePath) {
-  await mkdir5(path23.dirname(marketplacePath), { recursive: true });
+  await mkdir5(path24.dirname(marketplacePath), { recursive: true });
   const catalog = {
     $schema: "https://anthropic.com/claude-code/marketplace.schema.json",
     name: "memorix-local",
@@ -35920,18 +37108,18 @@ async function writeClaudeMarketplace(marketplacePath) {
 async function installPluginPackage(options2) {
   const home = options2.homeDir ?? homedir24();
   const packageRoot = findPackageRoot();
-  const source = path23.join(packageRoot, "plugins", options2.agent, "memorix");
+  const source = path24.join(packageRoot, "plugins", options2.agent, "memorix");
   const includeHooks = options2.includeHooks ?? true;
   if (!existsSync12(source)) {
     throw new Error(`Plugin package template not found: ${source}`);
   }
   if (options2.agent === "codex") {
-    const pluginPath2 = path23.join(home, ".codex", "plugins", "memorix");
-    const marketplacePath2 = path23.join(home, ".agents", "plugins", "marketplace.json");
+    const pluginPath2 = path24.join(home, "plugins", "memorix");
+    const marketplacePath2 = path24.join(home, ".agents", "plugins", "marketplace.json");
     await copyDir(source, pluginPath2);
     await stampCodexPluginVersion(pluginPath2);
     if (!includeHooks) await stripHookCaptureFromPlugin(pluginPath2, "codex");
-    await writeOfficialSkills(path23.join(pluginPath2, "skills"));
+    await writeOfficialSkills(path24.join(pluginPath2, "skills"));
     await upsertCodexMarketplace(marketplacePath2, pluginPath2);
     return {
       agent: "codex",
@@ -35941,22 +37129,22 @@ async function installPluginPackage(options2) {
     };
   }
   if (options2.agent === "copilot") {
-    const pluginPath2 = path23.join(home, ".copilot", "plugins", "local", "memorix");
+    const pluginPath2 = path24.join(home, ".copilot", "plugins", "local", "memorix");
     await copyDir(source, pluginPath2);
     if (!includeHooks) await stripHookCaptureFromPlugin(pluginPath2, "copilot");
-    await writeOfficialSkills(path23.join(pluginPath2, "skills"));
+    await writeOfficialSkills(path24.join(pluginPath2, "skills"));
     return {
       agent: "copilot",
       pluginPath: pluginPath2,
       installHint: "Run `copilot plugin install <path>` if automatic install is unavailable, then restart Copilot CLI."
     };
   }
-  const marketplaceRoot = path23.join(home, ".claude", "plugins", "marketplaces", "memorix-local");
-  const marketplacePath = path23.join(marketplaceRoot, ".claude-plugin", "marketplace.json");
-  const pluginPath = path23.join(marketplaceRoot, "plugins", "memorix");
+  const marketplaceRoot = path24.join(home, ".claude", "plugins", "marketplaces", "memorix-local");
+  const marketplacePath = path24.join(marketplaceRoot, ".claude-plugin", "marketplace.json");
+  const pluginPath = path24.join(marketplaceRoot, "plugins", "memorix");
   await copyDir(source, pluginPath);
   if (!includeHooks) await stripHookCaptureFromPlugin(pluginPath, "claude");
-  await writeOfficialSkills(path23.join(pluginPath, "skills"));
+  await writeOfficialSkills(path24.join(pluginPath, "skills"));
   await writeClaudeMarketplace(marketplacePath);
   return {
     agent: "claude",
@@ -35969,11 +37157,11 @@ async function installPluginPackage(options2) {
 async function installGeminiExtensionPackage(options2 = {}) {
   const home = options2.homeDir ?? homedir24();
   const packageRoot = findPackageRoot();
-  const source = path23.join(packageRoot, "plugins", "gemini", "memorix");
+  const source = path24.join(packageRoot, "plugins", "gemini", "memorix");
   if (!existsSync12(source)) {
     throw new Error(`Gemini extension template not found: ${source}`);
   }
-  const extensionPath = path23.join(home, ".gemini", "extensions", "memorix");
+  const extensionPath = path24.join(home, ".gemini", "extensions", "memorix");
   await copyDir(source, extensionPath);
   return {
     agent: "gemini-cli",
@@ -35983,16 +37171,16 @@ async function installGeminiExtensionPackage(options2 = {}) {
 }
 async function installAntigravityPluginPackage(options2 = {}) {
   const packageRoot = findPackageRoot();
-  const source = path23.join(packageRoot, "plugins", "antigravity", "memorix");
+  const source = path24.join(packageRoot, "plugins", "antigravity", "memorix");
   if (!existsSync12(source)) {
     throw new Error(`Antigravity plugin template not found: ${source}`);
   }
-  const pluginPath = options2.global === false ? path23.join(options2.projectRoot ?? process.cwd(), ".agents", "plugins", "memorix") : path23.join(options2.homeDir ?? homedir24(), ".gemini", "config", "plugins", "memorix");
+  const pluginPath = options2.global === false ? path24.join(options2.projectRoot ?? process.cwd(), ".agents", "plugins", "memorix") : path24.join(options2.homeDir ?? homedir24(), ".gemini", "config", "plugins", "memorix");
   await copyDir(source, pluginPath);
   if (options2.includeHooks === false) {
-    await rm(path23.join(pluginPath, "hooks.json"), { force: true });
+    await rm(path24.join(pluginPath, "hooks.json"), { force: true });
   }
-  await writeOfficialSkills(path23.join(pluginPath, "skills"));
+  await writeOfficialSkills(path24.join(pluginPath, "skills"));
   return {
     agent: "antigravity",
     pluginPath,
@@ -36001,14 +37189,14 @@ async function installAntigravityPluginPackage(options2 = {}) {
 }
 async function installPiPackage(options2 = {}) {
   const packageRoot = findPackageRoot();
-  const source = path23.join(packageRoot, "plugins", "pi", "memorix");
+  const source = path24.join(packageRoot, "plugins", "pi", "memorix");
   if (!existsSync12(source)) {
     throw new Error(`Pi package template not found: ${source}`);
   }
-  const defaultRoot = options2.global ? path23.join(options2.homeDir ?? homedir24(), ".pi", "agent", "packages") : path23.join(process.cwd(), ".pi", "packages");
-  const packagePath = options2.packageDir ?? path23.join(defaultRoot, "memorix");
+  const defaultRoot = options2.global ? path24.join(options2.homeDir ?? homedir24(), ".pi", "agent", "packages") : path24.join(process.cwd(), ".pi", "packages");
+  const packagePath = options2.packageDir ?? path24.join(defaultRoot, "memorix");
   await copyDir(source, packagePath);
-  await writeOfficialSkills(path23.join(packagePath, "skills"));
+  await writeOfficialSkills(path24.join(packagePath, "skills"));
   const installHint = options2.global ? `Setup runs \`pi install "${packagePath}" --approve\`. If Pi is unavailable, run that command after installing Pi.` : `Setup runs \`pi install "${packagePath}" -l --approve\`. If Pi is unavailable, run that command from the project root after installing Pi.`;
   return {
     agent: "pi",
@@ -36019,14 +37207,14 @@ async function installPiPackage(options2 = {}) {
 async function installOpenClawBundlePackage(options2 = {}) {
   const home = options2.homeDir ?? homedir24();
   const packageRoot = findPackageRoot();
-  const source = path23.join(packageRoot, "plugins", "openclaw", "memorix");
+  const source = path24.join(packageRoot, "plugins", "openclaw", "memorix");
   if (!existsSync12(source)) {
     throw new Error(`OpenClaw bundle template not found: ${source}`);
   }
-  const bundlePath = path23.join(home, ".openclaw", "extensions", "memorix");
+  const bundlePath = path24.join(home, ".openclaw", "extensions", "memorix");
   await copyDir(source, bundlePath);
   if (options2.includeHooks === false) await stripHookCaptureFromOpenClawBundle(bundlePath);
-  await writeOfficialSkills(path23.join(bundlePath, "skills"));
+  await writeOfficialSkills(path24.join(bundlePath, "skills"));
   return {
     agent: "openclaw",
     bundlePath,
@@ -36035,22 +37223,22 @@ async function installOpenClawBundlePackage(options2 = {}) {
 }
 async function installHermesPluginPackage(options2 = {}) {
   const packageRoot = findPackageRoot();
-  const source = path23.join(packageRoot, "plugins", "hermes", "memorix");
+  const source = path24.join(packageRoot, "plugins", "hermes", "memorix");
   if (!existsSync12(source)) {
     throw new Error(`Hermes plugin template not found: ${source}`);
   }
   const hermesHome = resolveHermesHome(options2.homeDir);
-  const pluginPath = path23.join(hermesHome, "plugins", "memorix");
+  const pluginPath = path24.join(hermesHome, "plugins", "memorix");
   await copyDir(source, pluginPath);
-  await writeOfficialSkills(path23.join(pluginPath, "skills"));
-  const configPath = path23.join(hermesHome, "config.yaml");
+  await writeOfficialSkills(path24.join(pluginPath, "skills"));
+  const configPath = path24.join(hermesHome, "config.yaml");
   let existingContent = null;
   try {
     existingContent = await readFile5(configPath, "utf-8");
   } catch {
     existingContent = null;
   }
-  await mkdir5(path23.dirname(configPath), { recursive: true });
+  await mkdir5(path24.dirname(configPath), { recursive: true });
   await writeFile5(configPath, mergeHermesPluginEnabled(existingContent, "memorix"), "utf-8");
   return {
     agent: "hermes",
@@ -36062,14 +37250,14 @@ async function installHermesPluginPackage(options2 = {}) {
 }
 async function installOmpPackage(options2 = {}) {
   const packageRoot = findPackageRoot();
-  const source = path23.join(packageRoot, "plugins", "omp", "memorix");
+  const source = path24.join(packageRoot, "plugins", "omp", "memorix");
   if (!existsSync12(source)) {
     throw new Error(`Oh-my-Pi package template not found: ${source}`);
   }
-  const defaultRoot = options2.global ? path23.join(options2.homeDir ?? homedir24(), ".omp", "agent", "packages") : path23.join(process.cwd(), ".omp", "packages");
-  const packagePath = options2.packageDir ?? path23.join(defaultRoot, "memorix");
+  const defaultRoot = options2.global ? path24.join(options2.homeDir ?? homedir24(), ".omp", "agent", "packages") : path24.join(process.cwd(), ".omp", "packages");
+  const packagePath = options2.packageDir ?? path24.join(defaultRoot, "memorix");
   await copyDir(source, packagePath);
-  await writeOfficialSkills(path23.join(packagePath, "skills"));
+  await writeOfficialSkills(path24.join(packagePath, "skills"));
   return {
     agent: "omp",
     packagePath,
@@ -36110,19 +37298,56 @@ ${install.stdout || ""}`.toLowerCase();
     message: installDetail ? `claude: marketplace registered, but automatic plugin install did not finish: ${installDetail}` : "claude: marketplace registered. Run `claude plugin install memorix@memorix-local`."
   };
 }
+function parseCodexPluginState(content) {
+  try {
+    const start = content.indexOf("{");
+    const end = content.lastIndexOf("}");
+    if (start < 0 || end < start) return "unknown";
+    const parsed = JSON.parse(content.slice(start, end + 1));
+    if (!Array.isArray(parsed.installed)) return "unknown";
+    const plugin = parsed.installed.find((entry) => Boolean(entry) && typeof entry === "object" && entry.pluginId === "memorix@personal");
+    if (!plugin || plugin.installed !== true) return "missing";
+    return plugin.enabled === true ? "ready" : "disabled";
+  } catch {
+    return "unknown";
+  }
+}
+function getCodexPluginState() {
+  const result = spawnSync("codex", ["plugin", "list", "--json"], {
+    encoding: "utf-8",
+    stdio: "pipe",
+    shell: process.platform === "win32"
+  });
+  if (result.status !== 0) return "unknown";
+  return parseCodexPluginState(result.stdout || "");
+}
 function tryInstallCodexPlugin() {
   const result = spawnSync("codex", ["plugin", "add", "memorix@personal", "--json"], {
     encoding: "utf-8",
     stdio: "pipe",
     shell: process.platform === "win32"
   });
-  if (result.status === 0) {
-    return { ok: true, message: "codex: plugin installed from Personal marketplace" };
-  }
   const output = `${result.stderr || ""}
 ${result.stdout || ""}`.toLowerCase();
-  if (output.includes("already")) {
-    return { ok: true, message: "codex: plugin already installed from Personal marketplace" };
+  const addFinished = result.status === 0 || output.includes("already");
+  if (addFinished) {
+    const pluginState = getCodexPluginState();
+    if (pluginState === "ready") {
+      return {
+        ok: true,
+        message: result.status === 0 ? "codex: plugin installed and enabled from Personal marketplace" : "codex: plugin already installed and enabled from Personal marketplace"
+      };
+    }
+    if (pluginState === "disabled") {
+      return {
+        ok: false,
+        message: "codex: Memorix plugin is installed but disabled. Enable it in Codex Plugins before any legacy MCP or project hooks are removed."
+      };
+    }
+    return {
+      ok: false,
+      message: "codex: plugin registration finished, but Codex did not confirm an enabled Memorix plugin. Legacy MCP and project hooks were kept unchanged."
+    };
   }
   const detail = (result.stderr || result.stdout || result.error?.message || "").trim();
   return {
@@ -36211,7 +37436,7 @@ ${hook.stdout || ""}`.toLowerCase();
 }
 function resolveHermesCommand(hermesHome) {
   if (process.platform === "win32") {
-    const localHermes = path23.join(hermesHome, "hermes-agent", "venv", "Scripts", "hermes.exe");
+    const localHermes = path24.join(hermesHome, "hermes-agent", "venv", "Scripts", "hermes.exe");
     if (existsSync12(localHermes)) return localHermes;
   }
   return "hermes";
@@ -36268,14 +37493,14 @@ async function installAgentSetup(agent, plan, global2) {
   const hasAntigravityPlugin = plan.actions.includes("antigravity-plugin") && agent === "antigravity";
   const hasHermesPlugin = plan.actions.includes("hermes-plugin") && agent === "hermes";
   const hasOmpPackage = plan.actions.includes("omp-package") && agent === "omp";
-  const wantsMcpConfig = plan.mcp !== "none" && agent !== "pi";
+  const wantsMcpConfig = plan.mcp !== "none" && agent !== "pi" && !(agent === "codex" && !global2);
   if (PLUGIN_PACKAGE_AGENTS.has(agent) && plan.includePlugin && !global2) {
     v3.info(`${agent}: project setup leaves user-level plugins untouched. Run \`memorix setup --agent ${agent} --global\` to install its plugin, skills, and lifecycle hooks.`);
   }
   if (hasPluginPackage) {
     const result = await installPluginPackage({
       agent,
-      includeHooks: plan.actions.includes("hooks")
+      includeHooks: plan.includeHooks
     });
     v3.success(`${agent}: plugin package -> ${result.pluginPath}`);
     if (result.marketplacePath) {
@@ -36283,17 +37508,16 @@ async function installAgentSetup(agent, plan, global2) {
     }
     if (agent === "codex") {
       const install = tryInstallCodexPlugin();
-      if (install.ok) v3.success(install.message);
-      else v3.warn(install.message);
       if (install.ok) {
-        try {
-          const migration = await removeLegacyCodexMemorixMcpConfig();
-          if (migration.removed) {
-            v3.info(`codex: removed legacy source-path MCP config from ${migration.configPath}`);
-          }
-        } catch {
-          v3.warn("codex: plugin installed, but the legacy MCP config could not be checked");
-        }
+        v3.success(install.message);
+        const migration = await migrateLegacyCodexIntegration({ projectRoot: process.cwd() });
+        if (migration.mcp === "removed") v3.info("codex: removed the legacy source-path MCP block; the enabled plugin now owns MCP.");
+        if (migration.mcp === "preserved") v3.warn("codex: kept a customized legacy Memorix MCP block; remove it manually only after confirming plugin MCP works.");
+        if (migration.projectHooks === "removed") v3.info("codex: removed a legacy project-local Memorix hooks.json; plugin hooks now own lifecycle capture.");
+        if (migration.projectHooks === "preserved") v3.warn("codex: kept a project .codex/hooks.json because it contains non-Memorix commands.");
+        if (migration.pluginFolder === "removed") v3.info("codex: removed the migrated legacy plugin folder under ~/.codex/plugins.");
+      } else {
+        v3.warn(install.message);
       }
     } else if (agent === "claude" && result.marketplaceRoot) {
       const install = tryInstallClaudePlugin(result.marketplaceRoot);
@@ -36371,6 +37595,8 @@ async function installAgentSetup(agent, plan, global2) {
       const result = await installMcpConfig({ agent, projectRoot: targetRoot, global: global2, mcp });
       v3.success(`${agent}: MCP config -> ${result.configPath}`);
     }
+  } else if (agent === "codex" && !global2 && plan.mcp !== "none") {
+    v3.info("codex: project-local .codex config is intentionally untouched. Run `memorix setup --agent codex --global` to install the user-level plugin.");
   }
   if (hasPluginPackage) {
     if (plan.actions.includes("project-guidance") && (agent === "claude" || agent === "codex")) {
@@ -36463,7 +37689,7 @@ var init_setup = __esm({
     ANTIGRAVITY_PLUGIN_AGENTS = /* @__PURE__ */ new Set(["antigravity"]);
     HERMES_PLUGIN_AGENTS = /* @__PURE__ */ new Set(["hermes"]);
     OMP_PACKAGE_AGENTS = /* @__PURE__ */ new Set(["omp"]);
-    PACKAGE_OWNED_INTEGRATION_AGENTS = /* @__PURE__ */ new Set(["antigravity", "openclaw", "hermes", "omp"]);
+    PACKAGE_OWNED_INTEGRATION_AGENTS = /* @__PURE__ */ new Set(["codex", "antigravity", "openclaw", "hermes", "omp"]);
     SUPPORTED_SETUP_AGENTS = [
       "claude",
       "codex",
@@ -37022,6 +38248,7 @@ function receiptOmissionKind(raw) {
   if (raw.includes("state")) return "code-state";
   if (raw.includes("semantic")) return "semantic-code";
   if (raw.includes("start")) return "start-here";
+  if (raw.includes("durable-memory")) return "durable-memory";
   if (raw.includes("memory")) return "memory";
   if (raw.includes("claim")) return "claim";
   if (raw.includes("knowledge-page")) return "knowledge-page";
@@ -37280,6 +38507,26 @@ function renderTaskWorksetPrompt(input) {
       });
     }
   }
+  if (input.durableMemory.length > 0) {
+    appendLine(lines, "", maxTokens, omitted, "durable-memory-heading");
+    appendLine(lines, "Durable memory", maxTokens, omitted, "durable-memory-heading");
+    for (const memory of input.durableMemory.slice(0, 3)) {
+      appendLine(
+        lines,
+        "- " + memory.kind + " (" + memory.scope + ", " + memory.state + "; ref durable:" + memory.id + "): " + memory.summary,
+        maxTokens,
+        omitted,
+        "durable-memory",
+        selected,
+        {
+          kind: "durable-memory",
+          id: "durable:" + memory.id,
+          reason: memory.reason,
+          trust: "source-backed"
+        }
+      );
+    }
+  }
   if (input.workflows.length > 0) {
     appendLine(lines, "", maxTokens, omitted, "workflow-heading");
     appendLine(lines, "Project workflow", maxTokens, omitted, "workflow-heading");
@@ -37349,6 +38596,32 @@ async function buildTaskWorkset(input) {
     evidenceRefs: evidenceByClaim.get(claim.id).map((item) => item.id),
     reason: selection.reasons[claim.id] ?? "source-qualified task match"
   }));
+  let durableMemory = [];
+  let durableEvidence = [];
+  if (task) {
+    try {
+      const selected = await selectLongTermMemoriesForTask({
+        dataDir: input.dataDir,
+        projectId: input.projectId,
+        task,
+        ...input.reader?.agentId ? { agentId: input.reader.agentId } : {},
+        ...input.reader?.isTeamMember ? { isTeamMember: true } : {},
+        limit: 3
+      });
+      durableMemory = selected.map((item) => ({
+        id: item.memory.id,
+        kind: item.memory.kind,
+        scope: item.memory.scope,
+        state: item.memory.state,
+        title: item.memory.title,
+        summary: renderLongTermMemorySummary(item.memory, 20),
+        evidenceRefs: item.evidence.map((evidence) => evidence.id),
+        reason: item.reason
+      }));
+      durableEvidence = selected.flatMap((item) => item.evidence);
+    } catch {
+    }
+  }
   let workspace;
   let pages = [];
   let workflows = [];
@@ -37388,7 +38661,10 @@ async function buildTaskWorkset(input) {
   const evidenceIds = unique(selection.claims.flatMap((claim) => evidenceIdsForClaim(
     claim,
     evidenceByClaim.get(claim.id) ?? []
-  )));
+  )).concat(
+    durableMemory.map((memory) => "durable:" + memory.id),
+    durableEvidence.map((evidence) => "durable-evidence:" + evidence.id)
+  ));
   const verification = unique([
     ...workflows.flatMap((workflow) => workflow.verificationGates),
     ...input.verificationHints
@@ -37414,7 +38690,7 @@ async function buildTaskWorkset(input) {
     } : {}
   } : void 0;
   const base = {
-    version: "1.2",
+    version: "1.3",
     task,
     lens: input.lens,
     currentFacts: input.currentFacts?.map((fact) => fact.startsWith("Historical note:") ? short(fact, 48) : short(fact, 28)).slice(0, 4) ?? [],
@@ -37427,6 +38703,7 @@ async function buildTaskWorkset(input) {
     hiddenCautionMemoryCount: input.hiddenCautionMemoryCount ?? 0,
     claims,
     pages,
+    durableMemory,
     workflows,
     cautions: normalizedCautions,
     verification,
@@ -37443,7 +38720,7 @@ async function buildTaskWorkset(input) {
     budget: { maxTokens }
   });
   const receipt = {
-    version: "1.2.4",
+    version: "1.3",
     target: input.deliveryTarget ?? "project-context",
     elapsedMs: Math.max(0, Date.now() - startedAt),
     budget: {
@@ -37478,6 +38755,7 @@ var init_workset = __esm({
     init_workspace();
     init_workflow_store();
     init_workflows();
+    init_long_term();
     CONTINUATION_DETAIL_TOKEN_BUDGET = 20;
   }
 });
@@ -37490,7 +38768,7 @@ __export(current_facts_exports, {
 });
 import { execFileSync } from "child_process";
 import { existsSync as existsSync13, readFileSync as readFileSync8 } from "fs";
-import path24 from "path";
+import path25 from "path";
 function readTextIfExists(filePath) {
   try {
     if (!existsSync13(filePath)) return null;
@@ -37500,7 +38778,7 @@ function readTextIfExists(filePath) {
   }
 }
 function readPackageVersion(rootPath) {
-  const text = readTextIfExists(path24.join(rootPath, "package.json"));
+  const text = readTextIfExists(path25.join(rootPath, "package.json"));
   if (!text) return void 0;
   try {
     const parsed = JSON.parse(text);
@@ -37510,7 +38788,7 @@ function readPackageVersion(rootPath) {
   }
 }
 function readLatestChangelog(rootPath) {
-  const text = readTextIfExists(path24.join(rootPath, "CHANGELOG.md"));
+  const text = readTextIfExists(path25.join(rootPath, "CHANGELOG.md"));
   if (!text) return void 0;
   const match = text.match(/^##\s+\[?v?([^\]\s]+)\]?\s*(?:-\s*(\d{4}-\d{2}-\d{2}))?/m);
   if (!match) return void 0;
@@ -37580,7 +38858,7 @@ function detectStaleProgressNotes(input) {
   ];
   const notes = [];
   for (const relPath of candidates) {
-    const content = readTextIfExists(path24.join(input.rootPath, relPath));
+    const content = readTextIfExists(path25.join(input.rootPath, relPath));
     if (!content) continue;
     const parsed = parseProgressNote(content);
     const olderThanChangelog = compareDateStrings(parsed.lastUpdated, input.latestChangelog?.date);
@@ -37831,9 +39109,9 @@ async function inspectExternalCodeGraph(input) {
   return { health, quality: providerQuality({ mode, health }) };
 }
 function safeRelativePath(projectRoot, value, exclude) {
-  const path37 = safeText(value, 1024);
-  if (!path37 || isAbsolute2(path37)) return void 0;
-  const absolute = resolve3(projectRoot, path37);
+  const path38 = safeText(value, 1024);
+  if (!path38 || isAbsolute2(path38)) return void 0;
+  const absolute = resolve3(projectRoot, path38);
   const fromRoot = relative2(projectRoot, absolute);
   if (!fromRoot || fromRoot === ".." || fromRoot.startsWith("..\\") || fromRoot.startsWith("../") || isAbsolute2(fromRoot)) return void 0;
   const normalized = normalizeCodePath(fromRoot);
@@ -38115,15 +39393,15 @@ function countLanguages(files) {
   }
   return [...counts.entries()].map(([language, files2]) => ({ language, files: files2 })).sort((a3, b3) => a3.language.localeCompare(b3.language));
 }
-function suggestedReadRank(path37) {
-  const normalized = path37.replace(/\\/g, "/");
+function suggestedReadRank(path38) {
+  const normalized = path38.replace(/\\/g, "/");
   if (normalized.startsWith("src/")) return 0;
   if (normalized.startsWith("tests/") || normalized.startsWith("test/")) return 0;
   if (normalized.startsWith("packages/") && normalized.includes("/src/")) return 2;
   return 3;
 }
 function compactSuggestedReads(paths, limit = 8, exclude) {
-  return uniq(paths).filter((path37) => !isCodeGraphExcludedPath(path37, exclude)).sort((a3, b3) => suggestedReadRank(a3) - suggestedReadRank(b3)).slice(0, limit);
+  return uniq(paths).filter((path38) => !isCodeGraphExcludedPath(path38, exclude)).sort((a3, b3) => suggestedReadRank(a3) - suggestedReadRank(b3)).slice(0, limit);
 }
 function collectGraph(store2, projectId, observations2, exclude) {
   const files = store2.listFiles(projectId);
@@ -38163,14 +39441,14 @@ function collectGraph(store2, projectId, observations2, exclude) {
   }
   if (files.length === 0) {
     for (const observation of observations2) {
-      for (const path37 of observation.filesModified ?? []) {
-        if (!path37 || isCodeGraphExcludedPath(path37, exclude)) continue;
-        suggestedReads.push(path37);
+      for (const path38 of observation.filesModified ?? []) {
+        if (!path38 || isCodeGraphExcludedPath(path38, exclude)) continue;
+        suggestedReads.push(path38);
         sources.push({
           observationId: observation.id,
           title: observation.title,
           type: observation.type,
-          path: path37,
+          path: path38,
           status: "unbound",
           reason: "Recorded file hint; Code Memory refresh is pending."
         });
@@ -38254,7 +39532,7 @@ function formatProjectContextOverview(overview) {
   if (overview.suggestedReads.length === 0) {
     lines.push("- none yet");
   } else {
-    overview.suggestedReads.slice(0, 8).forEach((path37, index) => lines.push(`${index + 1}. ${path37}`));
+    overview.suggestedReads.slice(0, 8).forEach((path38, index) => lines.push(`${index + 1}. ${path38}`));
   }
   return lines.join("\n");
 }
@@ -38295,8 +39573,8 @@ __export(graph_store_exports, {
   initGraphStore: () => initGraphStore,
   resetGraphStore: () => resetGraphStore
 });
-import path25 from "path";
-import fs17 from "fs";
+import path26 from "path";
+import fs18 from "fs";
 function safeJsonParse3(val, fallback) {
   if (val == null || val === "") return fallback;
   try {
@@ -38386,8 +39664,8 @@ var init_graph_store = __esm({
       async migrateFromJsonlIfNeeded() {
         const count3 = this.db.prepare(`SELECT COUNT(*) AS cnt FROM graph_entities`).get();
         if (count3.cnt > 0) return;
-        const jsonlPath = path25.join(this.dataDir, "graph.jsonl");
-        if (!fs17.existsSync(jsonlPath)) return;
+        const jsonlPath = path26.join(this.dataDir, "graph.jsonl");
+        if (!fs18.existsSync(jsonlPath)) return;
         try {
           const data = await loadGraphJsonl(this.dataDir);
           if (data.entities.length === 0 && data.relations.length === 0) return;
@@ -39129,8 +40407,8 @@ var compaction_checkpoint_store_exports = {};
 __export(compaction_checkpoint_store_exports, {
   CompactionCheckpointStore: () => CompactionCheckpointStore
 });
-import { createHash as createHash12, randomUUID as randomUUID9 } from "crypto";
-function optionalText5(value) {
+import { createHash as createHash12, randomUUID as randomUUID12 } from "crypto";
+function optionalText6(value) {
   return typeof value === "string" && value ? value : void 0;
 }
 function optionalNumber2(value) {
@@ -39184,15 +40462,15 @@ function rowToCheckpoint(row) {
     reason: row.reason,
     sourceEvent: row.source_event,
     sourceKey: row.source_key,
-    ...optionalText5(row.summary) ? { summary: row.summary } : {},
+    ...optionalText6(row.summary) ? { summary: row.summary } : {},
     ...optionalNumber2(row.tokens_before) !== void 0 ? { tokensBefore: Number(row.tokens_before) } : {},
-    ...optionalText5(row.first_kept_entry_id) ? { firstKeptEntryId: row.first_kept_entry_id } : {},
+    ...optionalText6(row.first_kept_entry_id) ? { firstKeptEntryId: row.first_kept_entry_id } : {},
     ...parseDetails(row.details_json) ? { details: parseDetails(row.details_json) } : {},
     transcriptAvailable: Boolean(row.transcript_available),
     status: row.status,
     preCapturedAt: row.pre_captured_at,
-    ...optionalText5(row.completed_at) ? { completedAt: row.completed_at } : {},
-    ...optionalText5(row.delivered_at) ? { deliveredAt: row.delivered_at } : {},
+    ...optionalText6(row.completed_at) ? { completedAt: row.completed_at } : {},
+    ...optionalText6(row.delivered_at) ? { deliveredAt: row.delivered_at } : {},
     deliveryCount: Number(row.delivery_count ?? 0),
     createdAt: row.created_at,
     updatedAt: row.updated_at
@@ -39230,7 +40508,7 @@ var init_compaction_checkpoint_store = __esm({
         if (pending) return rowToCheckpoint(pending);
         const now3 = input.capturedAt ?? (/* @__PURE__ */ new Date()).toISOString();
         const checkpoint = {
-          id: randomUUID9(),
+          id: randomUUID12(),
           projectId: input.projectId,
           sessionId: input.sessionId,
           agent: input.agent,
@@ -39238,7 +40516,7 @@ var init_compaction_checkpoint_store = __esm({
           captureKind: "preflight",
           reason: safeReason(input.reason),
           sourceEvent: input.sourceEvent,
-          sourceKey: `pre:${randomUUID9()}`,
+          sourceKey: `pre:${randomUUID12()}`,
           transcriptAvailable: Boolean(input.transcriptAvailable),
           status: "active",
           preCapturedAt: now3,
@@ -39304,7 +40582,7 @@ var init_compaction_checkpoint_store = __esm({
           return this.get(checkpoint2.id);
         }
         const checkpoint = {
-          id: randomUUID9(),
+          id: randomUUID12(),
           projectId: input.projectId,
           sessionId: input.sessionId,
           agent: input.agent,
@@ -39439,7 +40717,7 @@ __export(auto_context_exports, {
   formatLegacyAutoProjectContextPrompt: () => formatLegacyAutoProjectContextPrompt
 });
 import { existsSync as existsSync15, statSync as statSync4 } from "fs";
-import path26 from "path";
+import path27 from "path";
 function activeProjectObservations(observations2, projectId) {
   return observations2.filter((obs) => obs.projectId === projectId && (obs.status ?? "active") === "active");
 }
@@ -39674,6 +40952,7 @@ async function buildAutoProjectContext(input) {
       stale: overview.freshness.stale
     },
     runtimeCautions,
+    ...input.reader ? { reader: input.reader } : {},
     ...input.deliveryTarget ? { deliveryTarget: input.deliveryTarget } : {}
   });
   return {
@@ -39718,7 +40997,7 @@ function dedupeSourcesByObservation(sources) {
 function existingLensCandidates(rootPath, lens) {
   const out = [];
   for (const candidate2 of lensPathCandidates(lens)) {
-    const absolute = path26.join(rootPath, candidate2);
+    const absolute = path27.join(rootPath, candidate2);
     try {
       if (!existsSync15(absolute)) continue;
       const stat = statSync4(absolute);
@@ -39828,7 +41107,7 @@ function formatAutoProjectContextSummary(context) {
     "Start here"
   ].filter(Boolean);
   if (startHere.length > 0) {
-    startHere.forEach((path37, index) => lines.push(`${index + 1}. ${path37}`));
+    startHere.forEach((path38, index) => lines.push(`${index + 1}. ${path38}`));
   } else {
     lines.push("- no code-bound reads yet; inspect the task-relevant files directly");
   }
@@ -39837,6 +41116,14 @@ function formatAutoProjectContextSummary(context) {
     "Reliable memory",
     reliableSources.length > 0 ? `- ${reliableSources.length} current code-bound memory link(s)` : "- none yet"
   );
+  if (context.workset.durableMemory.length > 0) {
+    lines.push("", "Durable memory");
+    for (const memory of context.workset.durableMemory.slice(0, 3)) {
+      lines.push(
+        "- " + memory.kind + " (" + memory.scope + ", " + memory.state + "): " + compactContinuationText(memory.summary, 28)
+      );
+    }
+  }
   const continuation = context.workset.continuation;
   if (continuation?.previousSession || continuation?.memories.length || continuation?.compactCheckpoint) {
     lines.push("", "Resume from prior work");
@@ -39886,7 +41173,7 @@ function formatLegacyAutoProjectContextPrompt(context) {
   if (startHere.length === 0) {
     lines.push("- no code-bound reads yet; inspect the task-relevant code directly");
   } else {
-    startHere.forEach((path37, index) => lines.push(`${index + 1}. ${path37}`));
+    startHere.forEach((path38, index) => lines.push(`${index + 1}. ${path38}`));
   }
   const { reliableSources, cautionSources, hiddenReliableCount, hiddenCautionCount } = lensSourceSets(context);
   lines.push("", "Reliable memory");
@@ -40354,6 +41641,7 @@ async function attachTaskWorkset(input) {
       stale: input.pack.warnings.filter((warning) => warning.status === "stale").length
     },
     runtimeCautions: input.runtimeCautions,
+    ...input.reader ? { reader: input.reader } : {},
     deliveryTarget: "context-pack"
   });
   return { ...input.pack, workset };
@@ -40364,7 +41652,7 @@ function buildContextPackPrompt(pack) {
   const unboundMemories = pack.memories.filter((memory) => memory.status === "unbound");
   const lines = ["## Task", pack.task, "", "## Reliable Memories"];
   const visibleCodeFacts = pack.codeFacts.filter((fact) => !isCodeGraphExcludedPath(fact.path)).slice(0, 5);
-  const visibleSuggestedReads = pack.suggestedReads.filter((path37) => !isCodeGraphExcludedPath(path37)).slice(0, 5);
+  const visibleSuggestedReads = pack.suggestedReads.filter((path38) => !isCodeGraphExcludedPath(path38)).slice(0, 5);
   if (reliableMemories.length === 0) lines.push("- none");
   for (const memory of reliableMemories) {
     lines.push(`- #${memory.id} ${memory.status}: [${memory.type}] ${memory.title} (${memory.reason})`);
@@ -40388,7 +41676,7 @@ function buildContextPackPrompt(pack) {
   }
   lines.push("", "## Suggested Next Reads");
   if (visibleSuggestedReads.length === 0) lines.push("- none");
-  visibleSuggestedReads.forEach((path37, index) => lines.push(`${index + 1}. ${path37}`));
+  visibleSuggestedReads.forEach((path38, index) => lines.push(`${index + 1}. ${path38}`));
   lines.push("", "## Suggested Verification");
   if (pack.suggestedVerification.length === 0) lines.push("- none");
   for (const command of pack.suggestedVerification) lines.push(`- ${command}`);
@@ -40601,7 +41889,8 @@ ${formatUsageHint()}`;
                 } : {},
                 ...external.outline ? { semanticCode: external.outline } : {},
                 providerQuality: external.quality,
-                ...external.caution ? { runtimeCautions: [{ kind: "external-codegraph-fallback", message: external.caution }] } : {}
+                ...external.caution ? { runtimeCautions: [{ kind: "external-codegraph-fallback", message: external.caution }] } : {},
+                reader
               });
               emitResult({ project, pack, providerQuality: external.quality }, buildContextPackPrompt(pack), asJson);
               return;
@@ -42787,8 +44076,8 @@ var transfer_exports = {};
 __export(transfer_exports, {
   default: () => transfer_default
 });
-import { promises as fs18 } from "fs";
-import path27 from "path";
+import { promises as fs19 } from "fs";
+import path28 from "path";
 async function readStandardInput() {
   return new Promise((resolve6, reject) => {
     let content = "";
@@ -42809,13 +44098,13 @@ async function readImportPayload(args, projectRoot) {
     throw new Error("Choose exactly one import source: --data <json>, --file <path>, or --stdin.");
   }
   if (readFromStdin) return readStandardInput();
-  if (file) return fs18.readFile(path27.resolve(projectRoot, file), "utf8");
+  if (file) return fs19.readFile(path28.resolve(projectRoot, file), "utf8");
   return data;
 }
 async function writeExportPayload(projectRoot, output, payload) {
-  const outputPath = path27.resolve(projectRoot, output);
-  await fs18.mkdir(path27.dirname(outputPath), { recursive: true });
-  await fs18.writeFile(outputPath, payload, "utf8");
+  const outputPath = path28.resolve(projectRoot, output);
+  await fs19.mkdir(path28.dirname(outputPath), { recursive: true });
+  await fs19.writeFile(outputPath, payload, "utf8");
   return outputPath;
 }
 var transfer_default;
@@ -44389,8 +45678,8 @@ var init_parseUtil = __esm({
     init_errors2();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path37, errorMaps, issueData } = params;
-      const fullPath = [...path37, ...issueData.path || []];
+      const { data, path: path38, errorMaps, issueData } = params;
+      const fullPath = [...path38, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -44427,15 +45716,15 @@ var init_parseUtil = __esm({
           this.value = "aborted";
       }
       static mergeArray(status, results) {
-        const arrayValue2 = [];
+        const arrayValue3 = [];
         for (const s2 of results) {
           if (s2.status === "aborted")
             return INVALID;
           if (s2.status === "dirty")
             status.dirty();
-          arrayValue2.push(s2.value);
+          arrayValue3.push(s2.value);
         }
-        return { status: status.value, value: arrayValue2 };
+        return { status: status.value, value: arrayValue3 };
       }
       static async mergeObjectAsync(status, pairs) {
         const syncPairs = [];
@@ -44704,11 +45993,11 @@ var init_types3 = __esm({
     init_parseUtil();
     init_util2();
     ParseInputLazyPath = class {
-      constructor(parent, value, path37, key) {
+      constructor(parent, value, path38, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path37;
+        this._path = path38;
         this._key = key;
       }
       get path() {
@@ -48461,7 +49750,7 @@ function collectCodeMemory(opts) {
     if (status.indexedAt) lines.push(`Last scan: ${status.indexedAt}`);
     if (suggestedReads.length > 0) {
       lines.push("Suggested reads:");
-      suggestedReads.forEach((path37, index) => lines.push(`${index + 1}. ${path37}`));
+      suggestedReads.forEach((path38, index) => lines.push(`${index + 1}. ${path38}`));
     }
     return lines.join("\n");
   } catch {
@@ -48486,7 +49775,7 @@ __export(planner_exports, {
   materializeTaskGraph: () => materializeTaskGraph,
   seedAutonomousPipeline: () => seedAutonomousPipeline
 });
-import { randomUUID as randomUUID10 } from "crypto";
+import { randomUUID as randomUUID13 } from "crypto";
 function isPlannerTask(metadata) {
   if (!metadata) return null;
   try {
@@ -48544,7 +49833,7 @@ function seedAutonomousPipeline(teamStore, projectId, config2, opts) {
   const maxIterations = config2.maxIterations ?? 3;
   const taskBudget = config2.taskBudget ?? 15;
   const structuredPlan = opts?.structuredPlan ?? true;
-  const pipelineId = randomUUID10();
+  const pipelineId = randomUUID13();
   const meta = {
     plannerType: "plan",
     pipelineId,
@@ -49465,7 +50754,7 @@ __export(receipt_service_exports, {
 });
 import { createHash as createHash13 } from "crypto";
 import { existsSync as existsSync18, readFileSync as readFileSync12 } from "fs";
-import path28 from "path";
+import path29 from "path";
 function sha256(value) {
   return `sha256:${createHash13("sha256").update(value).digest("hex")}`;
 }
@@ -49494,7 +50783,7 @@ function safeJsonArray(value) {
   }
 }
 async function loadReceiptObservations(dataDir, projectId) {
-  const dbPath = path28.join(dataDir, "memorix.db");
+  const dbPath = path29.join(dataDir, "memorix.db");
   if (existsSync18(dbPath)) {
     try {
       const DB = loadBetterSqlite3();
@@ -49511,7 +50800,7 @@ async function loadReceiptObservations(dataDir, projectId) {
     } catch {
     }
   }
-  const jsonPath = path28.join(dataDir, "observations.json");
+  const jsonPath = path29.join(dataDir, "observations.json");
   if (!existsSync18(jsonPath)) return [];
   try {
     const parsed = JSON.parse(readFileSync12(jsonPath, "utf-8"));
@@ -49932,10 +51221,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path37) {
-  if (!path37)
+function getElementAtPath(obj, path38) {
+  if (!path38)
     return obj;
-  return path37.reduce((acc, key) => acc?.[key], obj);
+  return path38.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -50184,11 +51473,11 @@ function aborted(x3, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path37, issues) {
+function prefixIssues(path38, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path37);
+    iss.path.unshift(path38);
     return iss;
   });
 }
@@ -62494,8 +63783,8 @@ var require_utils2 = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path37) {
-      let input = path37;
+    function removeDotSegments(path38) {
+      let input = path38;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -62748,8 +64037,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path37, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path37 && path37 !== "/" ? path37 : void 0;
+        const [path38, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path38 && path38 !== "/" ? path38 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -66188,12 +67477,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f4;
     };
-    function addFormats(ajv, list, fs27, exportName) {
+    function addFormats(ajv, list, fs28, exportName) {
       var _a;
       var _b;
       (_a = (_b = ajv.opts.code).formats) !== null && _a !== void 0 ? _a : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f4 of list)
-        ajv.addFormat(f4, fs27[f4]);
+        ajv.addFormat(f4, fs28[f4]);
     }
     module2.exports = exports2 = formatsPlugin;
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -68669,8 +69958,8 @@ var syncer_exports = {};
 __export(syncer_exports, {
   RulesSyncer: () => RulesSyncer
 });
-import { promises as fs19 } from "fs";
-import path29 from "path";
+import { promises as fs20 } from "fs";
+import path30 from "path";
 var RulesSyncer;
 var init_syncer = __esm({
   "src/rules/syncer.ts"() {
@@ -68715,8 +70004,8 @@ var init_syncer = __esm({
             const found = await this.findFiles(scanPath);
             for (const filePath of found) {
               try {
-                const content = await fs19.readFile(filePath, "utf-8");
-                const relativePath = path29.relative(this.projectRoot, filePath).replace(/\\/g, "/");
+                const content = await fs20.readFile(filePath, "utf-8");
+                const relativePath = path30.relative(this.projectRoot, filePath).replace(/\\/g, "/");
                 const parsed = entry.adapter.parse(relativePath, content);
                 rules.push(...parsed);
               } catch {
@@ -68784,7 +70073,7 @@ var init_syncer = __esm({
         const entries = [];
         for (const adapter of this.adapters.values()) {
           const absolutePaths = adapter.filePatterns.map(
-            (p2) => path29.join(this.projectRoot, p2)
+            (p2) => path30.join(this.projectRoot, p2)
           );
           entries.push({ adapter, paths: absolutePaths });
         }
@@ -68792,13 +70081,13 @@ var init_syncer = __esm({
       }
       /** Find files matching a glob-like path (simple implementation) */
       async findFiles(pattern) {
-        const dir = path29.dirname(pattern);
-        const fileGlob = path29.basename(pattern);
+        const dir = path30.dirname(pattern);
+        const fileGlob = path30.basename(pattern);
         try {
-          const stat = await fs19.stat(dir);
+          const stat = await fs20.stat(dir);
           if (!stat.isDirectory()) {
             try {
-              await fs19.access(pattern);
+              await fs20.access(pattern);
               return [pattern];
             } catch {
               return [];
@@ -68806,7 +70095,7 @@ var init_syncer = __esm({
           }
         } catch {
           try {
-            await fs19.access(pattern);
+            await fs20.access(pattern);
             return [pattern];
           } catch {
             return [];
@@ -68814,16 +70103,16 @@ var init_syncer = __esm({
         }
         if (fileGlob.includes("*")) {
           try {
-            const files = await fs19.readdir(dir);
+            const files = await fs20.readdir(dir);
             const ext = fileGlob.replace("*", "");
-            return files.filter((f4) => ext ? f4.endsWith(ext) : true).map((f4) => path29.join(dir, f4));
+            return files.filter((f4) => ext ? f4.endsWith(ext) : true).map((f4) => path30.join(dir, f4));
           } catch {
             return [];
           }
         }
         try {
-          await fs19.access(path29.join(dir, fileGlob));
-          return [path29.join(dir, fileGlob)];
+          await fs20.access(path30.join(dir, fileGlob));
+          return [path30.join(dir, fileGlob)];
         } catch {
           return [];
         }
@@ -69058,10 +70347,10 @@ var init_engine3 = __esm({
             pathsToCheck.push(join25(homedir29(), ".gemini", "antigravity", "mcp_config.json"));
           }
           const merged = /* @__PURE__ */ new Map();
-          for (const path37 of pathsToCheck) {
-            if (existsSync20(path37)) {
+          for (const path38 of pathsToCheck) {
+            if (existsSync20(path38)) {
               try {
-                const content = readFileSync13(path37, "utf-8");
+                const content = readFileSync13(path38, "utf-8");
                 const servers = adapter.parse(content);
                 for (const s2 of servers) {
                   if (!merged.has(s2.name)) merged.set(s2.name, s2);
@@ -70038,8 +71327,8 @@ __export(server_exports, {
   startDashboard: () => startDashboard
 });
 import { createServer } from "http";
-import { promises as fs20 } from "fs";
-import path30 from "path";
+import { promises as fs21 } from "fs";
+import path31 from "path";
 import { exec } from "child_process";
 function sendJson(res, data, status = 200) {
   res.writeHead(status, {
@@ -70517,7 +71806,7 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
           const aliasModule = await Promise.resolve().then(() => (init_aliases(), aliases_exports));
           canonicalId = await aliasModule.getCanonicalId(effectiveProjectId);
           const { promises: fsP } = await import("fs");
-          const registryPath = path30.join(baseDir, ".project-aliases.json");
+          const registryPath = path31.join(baseDir, ".project-aliases.json");
           const raw = await fsP.readFile(registryPath, "utf-8");
           const registry2 = JSON.parse(raw);
           aliasGroups = registry2.groups || [];
@@ -70632,14 +71921,14 @@ async function serveStatic(req, res, staticDir) {
   if (urlPath === "/" || !urlPath.includes(".")) {
     urlPath = "/index.html";
   }
-  const filePath = path30.join(staticDir, urlPath);
+  const filePath = path31.join(staticDir, urlPath);
   if (!filePath.startsWith(staticDir)) {
     sendError(res, "Forbidden", 403);
     return;
   }
   try {
-    const data = await fs20.readFile(filePath);
-    const ext = path30.extname(filePath);
+    const data = await fs21.readFile(filePath);
+    const ext = path31.extname(filePath);
     res.writeHead(200, {
       "Content-Type": MIME_TYPES[ext] || "application/octet-stream",
       "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0",
@@ -70649,7 +71938,7 @@ async function serveStatic(req, res, staticDir) {
     res.end(data);
   } catch {
     try {
-      const indexData = await fs20.readFile(path30.join(staticDir, "index.html"));
+      const indexData = await fs21.readFile(path31.join(staticDir, "index.html"));
       res.writeHead(200, {
         "Content-Type": "text/html; charset=utf-8",
         "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0",
@@ -71090,9 +72379,9 @@ __export(hooks_path_exports, {
   resolveHooksDir: () => resolveHooksDir
 });
 import { existsSync as existsSync22, readFileSync as readFileSync15, statSync as statSync5, mkdirSync as mkdirSync6 } from "fs";
-import path31 from "path";
+import path32 from "path";
 function resolveGitDir(projectRoot) {
-  const dotGit = path31.join(projectRoot, ".git");
+  const dotGit = path32.join(projectRoot, ".git");
   if (!existsSync22(dotGit)) return null;
   const stat = statSync5(dotGit);
   if (stat.isDirectory()) {
@@ -71104,7 +72393,7 @@ function resolveGitDir(projectRoot) {
       const match = content.match(/^gitdir:\s*(.+)$/);
       if (match) {
         const gitdir = match[1].trim();
-        const resolved = path31.isAbsolute(gitdir) ? gitdir : path31.resolve(projectRoot, gitdir);
+        const resolved = path32.isAbsolute(gitdir) ? gitdir : path32.resolve(projectRoot, gitdir);
         if (existsSync22(resolved)) {
           return resolved;
         }
@@ -71117,10 +72406,10 @@ function resolveGitDir(projectRoot) {
 function resolveHooksDir(projectRoot) {
   const gitDir = resolveGitDir(projectRoot);
   if (!gitDir) return null;
-  const hooksDir = path31.join(gitDir, "hooks");
+  const hooksDir = path32.join(gitDir, "hooks");
   return {
     hooksDir,
-    hookPath: path31.join(hooksDir, "post-commit")
+    hookPath: path32.join(hooksDir, "post-commit")
   };
 }
 function ensureHooksDir(projectRoot) {
@@ -71498,7 +72787,7 @@ The path should point to a directory containing a .git folder.`
   };
   const server = existingServer ?? new McpServer({
     name: "memorix",
-    version: true ? "1.2.9" : "1.0.1"
+    version: true ? "1.3.0" : "1.0.1"
   });
   const originalRegisterTool = server.registerTool.bind(server);
   server.registerTool = ((name, ...args) => {
@@ -71578,7 +72867,7 @@ The path should point to a directory containing a .git folder.`
     "memorix_store",
     {
       title: "Store Memory",
-      description: "Store a new observation/memory. Automatically indexed for search. Use type to classify: gotcha ([GOTCHA] critical pitfall), decision ([DECISION] architecture choice), problem-solution ([FIX] bug fix), how-it-works ([INFO] explanation), what-changed ([CHANGE] change), discovery ([DISCOVERY] insight), why-it-exists ([WHY] rationale), trade-off ([TRADEOFF] compromise), session-request ([SESSION] original goal). Project visibility is the default. Personal or team visibility requires an explicitly joined coordination identity. For a read-only task, do not store unless the user explicitly asks to save a record.",
+      description: "Store a new observation/memory. Automatically indexed for search. Use type to classify: gotcha ([GOTCHA] critical pitfall), decision ([DECISION] architecture choice), problem-solution ([FIX] bug fix), how-it-works ([INFO] explanation), what-changed ([CHANGE] change), discovery ([DISCOVERY] insight), why-it-exists ([WHY] rationale), trade-off ([TRADEOFF] compromise), session-request ([SESSION] original goal). Project visibility is the default. Personal or team visibility requires an explicitly joined coordination identity. Set longTerm only when the caller explicitly wants an additional source-backed long-term candidate; it is never injected until an operator records a review through the CLI. For a read-only task, do not store unless the user explicitly asks to save a record.",
       inputSchema: {
         entityName: external_exports.string().describe('The entity this observation belongs to (e.g., "auth-module", "port-config")'),
         type: external_exports.enum(OBSERVATION_TYPES2).describe("Observation type for classification"),
@@ -71600,30 +72889,43 @@ The path should point to a directory containing a .git folder.`
         visibility: external_exports.enum(["personal", "project", "team"]).optional().describe(
           "Retrieval scope. Project is the normal shared default; personal/team require memorix_session_start with joinTeam=true."
         ),
+        longTerm: external_exports.object({
+          kind: external_exports.enum(["episodic", "semantic", "procedural"]).describe("Cognitive kind for an additional long-term candidate."),
+          scope: external_exports.enum(["project", "user", "team"]).optional().default("project").describe("Long-term scope. User capture is private source evidence and needs a bound agent identity."),
+          tags: external_exports.array(external_exports.string()).optional().describe("Small set of retrieval tags for the candidate."),
+          applicability: external_exports.string().optional().describe("When this durable fact or procedure applies.")
+        }).optional().describe("Optional explicit request to create a source-backed long-term candidate alongside this observation. Candidates are not automatically injected."),
         overrideReadOnly: external_exports.boolean().optional().describe(
           "Use only when the user explicitly asks to save memory during a read-only or no-modification task."
         )
       }
     },
-    async ({ entityName: rawEntityName, type: rawType, title: rawTitle, narrative, facts, filesModified, concepts, topicKey, progress, relatedCommits, relatedEntities, visibility, overrideReadOnly }) => {
+    async ({ entityName: rawEntityName, type: rawType, title: rawTitle, narrative, facts, filesModified, concepts, topicKey, progress, relatedCommits, relatedEntities, visibility, longTerm, overrideReadOnly }) => {
       const unresolved = requireResolvedProject("store memory in the current project");
       if (unresolved) return unresolved;
       const readOnlyBoundary = blockReadOnlyAutopilotWrite(overrideReadOnly);
       if (readOnlyBoundary) return readOnlyBoundary;
-      const requestedVisibility = visibility ?? "project";
+      const requestedVisibility = longTerm?.scope === "user" ? "personal" : longTerm?.scope === "team" ? "team" : visibility;
+      const effectiveVisibility = requestedVisibility ?? "project";
       const reader = getObservationReader();
-      if (requestedVisibility !== "project" && !currentAgentId) {
+      if (effectiveVisibility !== "project" && !currentAgentId) {
         return {
           content: [{ type: "text", text: "Personal or team memory requires memorix_session_start with joinTeam=true so Memorix can bind an owner." }],
           isError: true
         };
       }
-      if (requestedVisibility === "team" && !reader.isTeamMember) {
+      if (effectiveVisibility === "team" && !reader.isTeamMember) {
         return {
           content: [{ type: "text", text: "Team memory requires an active coordination membership in the current project." }],
           isError: true
         };
       }
+      if (longTerm?.scope === "team" && !reader.isTeamMember) {
+        return {
+          content: [{ type: "text", text: "Team long-term memory requires an active coordination membership in the current project." }],
+          isError: true
+        };
+      }
       try {
         return await withFreshIndex(async () => {
           let entityName = rawEntityName;
@@ -71645,7 +72947,7 @@ The path should point to a directory containing a .git folder.`
           const useFormation = formationMode === "active";
           let formationResult = null;
           let formationNote = "";
-          if (useFormation && !topicKey && !progress) {
+          if (useFormation && !topicKey && !progress && !longTerm) {
             let currentFormationStage = "setup";
             const completedFormationStages = {};
             const formationStartTime = Date.now();
@@ -71796,7 +73098,7 @@ ${modeIcon} Formation[active]: ${formationResult.evaluation.category} (${formati
           }
           let compactAction = "";
           let compactMerged = false;
-          if (!useFormation && !topicKey && !progress) {
+          if (!useFormation && !topicKey && !progress && !longTerm) {
             try {
               const searchResult = await compactSearch({
                 query: `${title} ${narrative.substring(0, 200)}`,
@@ -71953,9 +73255,33 @@ Mode: ${decision.usedLLM ? "LLM" : "heuristic"}`
             sourceDetail: "explicit",
             valueCategory: formationResult?.evaluation.category,
             createdByAgentId: currentAgentId,
-            visibility,
+            visibility: requestedVisibility,
             visibilityReader: reader
           });
+          let longTermNote = "";
+          if (longTerm) {
+            try {
+              const { promoteObservationToLongTermMemory: promoteObservationToLongTermMemory2 } = await Promise.resolve().then(() => (init_long_term(), long_term_exports));
+              const promoted = await promoteObservationToLongTermMemory2({
+                dataDir: projectDir2,
+                observation: obs,
+                scope: longTerm.scope,
+                kind: longTerm.kind,
+                tags: longTerm.tags,
+                applicability: longTerm.applicability,
+                reader: {
+                  projectId: project.id,
+                  ...reader.agentId ? { agentId: reader.agentId } : {},
+                  ...reader.isTeamMember ? { isTeamMember: true } : {}
+                }
+              });
+              longTermNote = `
+Long-term candidate: ${promoted.memory.id} (${promoted.memory.kind}/${promoted.memory.scope}). Review it with the CLI before it is delivered automatically.`;
+            } catch (longTermError) {
+              longTermNote = `
+[WARN] Observation stored, but long-term candidate was not created: ${longTermError instanceof Error ? longTermError.message : "unknown error"}`;
+            }
+          }
           await graphManager.addObservations([
             { entityName, contents: [`[#${obs.id}] ${title}`] }
           ]);
@@ -71972,7 +73298,7 @@ Mode: ${decision.usedLLM ? "LLM" : "heuristic"}`
           const enrichment = enrichmentParts.length > 0 ? `
 Auto-enriched: ${enrichmentParts.join(", ")}` : "";
           const action = upserted ? "[UPDATED] Updated" : "[OK] Stored";
-          if (!useFormation && !topicKey && !progress) {
+          if (!useFormation && !topicKey && !progress && !longTerm) {
             const shadowFormation = async () => {
               let oldCompactDecision = null;
               try {
@@ -72062,7 +73388,7 @@ Auto-enriched: ${enrichmentParts.join(", ")}` : "";
               {
                 type: "text",
                 text: `${action} observation #${obs.id} "${title}" (~${obs.tokens} tokens)
-Entity: ${entityName} | Type: ${type} | Project: ${project.id}${obs.topicKey ? ` | Topic: ${obs.topicKey}` : ""}${compactAction}${compressionNote}${enrichment}${formationNote}${attributionWarning}`
+Entity: ${entityName} | Type: ${type} | Project: ${project.id}${obs.topicKey ? ` | Topic: ${obs.topicKey}` : ""}${compactAction}${compressionNote}${enrichment}${formationNote}${attributionWarning}${longTermNote}`
               }
             ]
           };
@@ -72435,7 +73761,8 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
         } : {},
         ...external.outline ? { semanticCode: external.outline } : {},
         providerQuality: external.quality,
-        ...external.caution ? { runtimeCautions: [{ kind: "external-codegraph-fallback", message: external.caution }] } : {}
+        ...external.caution ? { runtimeCautions: [{ kind: "external-codegraph-fallback", message: external.caution }] } : {},
+        reader: getObservationReader()
       });
       const text = buildContextPackPrompt2(pack);
       return {
@@ -73109,7 +74436,7 @@ ${actions.join("\n")}`
     "memorix_detail",
     {
       title: "Memory Details",
-      description: 'Fetch full observation or mini-skill details \u2014 includes source kind (explicit memory / hook trace / git evidence), value category, and cross-references (~500-1000 tokens each). Do not re-fetch content already covered by a complete memorix_project_context brief unless a specific fact is still missing or the user asks for deeper history; provide purpose when intentionally expanding. Always use memorix_search first to find relevant IDs, then fetch only what you need. Accepts typed refs from search results (e.g. "obs:42", "skill:3") via the typedRefs field, or legacy numeric ids / object refs for backward compatibility.',
+      description: 'Fetch full observation, mini-skill, or curated durable-memory details \u2014 includes source kind (explicit memory / hook trace / git evidence), value category, and cross-references (~500-1000 tokens each). Do not re-fetch content already covered by a complete memorix_project_context brief unless a specific fact is still missing or the user asks for deeper history; provide purpose when intentionally expanding. Always use memorix_search first to find relevant IDs, then fetch only what you need. Accepts typed refs from search results (e.g. "obs:42", "skill:3") and durable refs from a project brief (e.g. "durable:<uuid>") via the typedRefs field, or legacy numeric ids / object refs for backward compatibility.',
       inputSchema: {
         ids: external_exports.array(external_exports.number()).optional().describe("Observation IDs to fetch (legacy, from memorix_search results)"),
         refs: external_exports.array(
@@ -73118,7 +74445,7 @@ ${actions.join("\n")}`
             projectId: external_exports.string().optional().describe("Project ID for global-search disambiguation")
           })
         ).optional().describe("Explicit observation refs. Prefer this for global search results."),
-        typedRefs: external_exports.array(external_exports.string()).optional().describe('Typed memory refs from search results, e.g. "obs:42", "skill:3", "obs:42@org/proj"'),
+        typedRefs: external_exports.array(external_exports.string()).optional().describe('Typed memory refs from search results or a project brief, e.g. "obs:42", "skill:3", "durable:<uuid>", "obs:42@org/proj"'),
         purpose: external_exports.string().optional().describe(
           "Why this must expand beyond the latest Autopilot brief. Name the missing fact or the user's explicit request."
         ),
@@ -73131,14 +74458,19 @@ ${actions.join("\n")}`
       const safeIds = coerceNumberArray(ids);
       const safeRefs = coerceObservationRefs(refs);
       const safeTypedRefs = coerceStringArray(typedRefs);
-      const hasCrossProjectRef = safeRefs.some((ref) => ref.projectId && ref.projectId !== project.id) || safeTypedRefs.some((ref) => ref.includes("@") && !ref.endsWith(`@${project.id}`));
+      const durableIds = safeTypedRefs.flatMap((ref) => {
+        const match = /^durable:([0-9a-f-]{36})$/i.exec(ref.trim());
+        return match ? [match[1]] : [];
+      });
+      const observationTypedRefs = safeTypedRefs.filter((ref) => !/^durable:/i.test(ref.trim()));
+      const hasCrossProjectRef = safeRefs.some((ref) => ref.projectId && ref.projectId !== project.id) || observationTypedRefs.some((ref) => ref.includes("@") && !ref.endsWith(`@${project.id}`));
       if (!hasCrossProjectRef) {
         const boundary = requireExplicitAutopilotExpansion("memorix_detail", purpose);
         if (boundary) return boundary;
         const requestedObservationIds = [
           ...safeIds,
           ...safeRefs.map((ref) => ref.id),
-          ...safeTypedRefs.flatMap((ref) => {
+          ...observationTypedRefs.flatMap((ref) => {
             const match = /^obs:(\d+)(?:@.+)?$/i.exec(ref.trim());
             return match ? [Number(match[1])] : [];
           })
@@ -73146,15 +74478,36 @@ ${actions.join("\n")}`
         const duplicate = blockCoveredAutopilotEvidence("memorix_detail", requestedObservationIds, force);
         if (duplicate) return duplicate;
       }
-      let result;
+      const formatted = [];
       try {
-        const reader = getObservationReader(hasCrossProjectRef ? "global" : "project");
-        if (safeTypedRefs.length > 0) {
-          result = await compactDetail(safeTypedRefs, { reader });
-        } else if (safeRefs.length > 0) {
-          result = await compactDetail(safeRefs, { reader });
-        } else {
-          result = await compactDetail(safeIds.map((id) => ({ id, projectId: project.id })), { reader });
+        if (durableIds.length > 0) {
+          const [{ getLongTermMemoryDetail: getLongTermMemoryDetail2 }, { resolveLocalMemoryOwner: resolveLocalMemoryOwner2 }] = await Promise.all([
+            Promise.resolve().then(() => (init_long_term(), long_term_exports)),
+            Promise.resolve().then(() => (init_owner(), owner_exports))
+          ]);
+          const owner = await resolveLocalMemoryOwner2(projectDir2, { create: false });
+          const observationReader = getObservationReader();
+          const durableReader = {
+            projectId: project.id,
+            ...owner ? { ownerId: owner.id } : {},
+            ...observationReader.agentId ? { agentId: observationReader.agentId } : {},
+            ...observationReader.isTeamMember ? { isTeamMember: true } : {}
+          };
+          const details = await Promise.all(durableIds.slice(0, 5).map(async (id) => {
+            try {
+              return await getLongTermMemoryDetail2({ dataDir: projectDir2, id, reader: durableReader });
+            } catch (error2) {
+              return { error: error2 instanceof Error ? error2.message : String(error2), id };
+            }
+          }));
+          formatted.push(JSON.stringify({ durableMemory: details }, null, 2));
+        }
+        if (observationTypedRefs.length > 0 || safeRefs.length > 0 || safeIds.length > 0) {
+          const reader = getObservationReader(hasCrossProjectRef ? "global" : "project");
+          const result = observationTypedRefs.length > 0 ? await compactDetail(observationTypedRefs, { reader }) : safeRefs.length > 0 ? await compactDetail(safeRefs, { reader }) : await compactDetail(safeIds.map((id) => ({ id, projectId: project.id })), { reader });
+          formatted.push(
+            result.documents.length > 0 ? result.formatted : observationTypedRefs.length > 0 ? `No memories found for refs: ${observationTypedRefs.join(", ")}` : safeRefs.length > 0 ? `No memories found for refs: ${safeRefs.map((ref) => `${ref.projectId ?? "current"}#${ref.id}`).join(", ")}` : `No memories found for IDs: ${safeIds.join(", ")}`
+          );
         }
       } catch (err) {
         return { content: [{ type: "text", text: err instanceof Error ? err.message : String(err) }], isError: true };
@@ -73163,7 +74516,7 @@ ${actions.join("\n")}`
         content: [
           {
             type: "text",
-            text: result.documents.length > 0 ? result.formatted : safeTypedRefs.length > 0 ? `No memories found for refs: ${safeTypedRefs.join(", ")}` : safeRefs.length > 0 ? `No memories found for refs: ${safeRefs.map((ref) => `${ref.projectId ?? "current"}#${ref.id}`).join(", ")}` : `No memories found for IDs: ${safeIds.join(", ")}`
+            text: formatted.length > 0 ? formatted.join("\n\n") : safeTypedRefs.length > 0 ? `No memories found for refs: ${safeTypedRefs.join(", ")}` : safeRefs.length > 0 ? `No memories found for refs: ${safeRefs.map((ref) => `${ref.projectId ?? "current"}#${ref.id}`).join(", ")}` : `No memories found for IDs: ${safeIds.join(", ")}`
           }
         ]
       };
@@ -73883,9 +75236,9 @@ ${skill2.content}` }]
         lines.push(`- **Description**: ${sk.description}`);
         lines.push(`- **Observations**: ${sk.content.split("\n").length} lines of knowledge`);
         if (write && target) {
-          const path37 = engine.writeSkill(sk, target);
-          if (path37) {
-            lines.push(`- [OK] **Written**: \`${path37}\``);
+          const path38 = engine.writeSkill(sk, target);
+          if (path38) {
+            lines.push(`- [OK] **Written**: \`${path38}\``);
           } else {
             lines.push(`- [ERROR] Failed to write`);
           }
@@ -75717,8 +77070,8 @@ var init_serve = __esm({
           safeCwd = homedir34();
         }
         const { existsSync: existsSync31, readFileSync: readFileSync23 } = await import("fs");
-        const path37 = await import("path");
-        const lastRootFile = path37.join(homedir34(), ".memorix", "last-project-root");
+        const path38 = await import("path");
+        const lastRootFile = path38.join(homedir34(), ".memorix", "last-project-root");
         let lastKnownProjectRoot;
         if (existsSync31(lastRootFile)) {
           try {
@@ -75753,9 +77106,9 @@ var init_serve = __esm({
         if (detected) {
           try {
             const { writeFileSync: writeFileSync11, mkdirSync: mkdirSync11 } = await import("fs");
-            const memorixDir = path37.join(homedir34(), ".memorix");
+            const memorixDir = path38.join(homedir34(), ".memorix");
             mkdirSync11(memorixDir, { recursive: true });
-            writeFileSync11(path37.join(memorixDir, "last-project-root"), detected.rootPath, "utf-8");
+            writeFileSync11(path38.join(memorixDir, "last-project-root"), detected.rootPath, "utf-8");
           } catch {
           }
         }
@@ -77296,7 +78649,7 @@ var init_serve_http = __esm({
       },
       run: async ({ args }) => {
         const { createServer: createServer2 } = await import("http");
-        const { randomUUID: randomUUID11 } = await import("crypto");
+        const { randomUUID: randomUUID14 } = await import("crypto");
         const { StreamableHTTPServerTransport: StreamableHTTPServerTransport2 } = await Promise.resolve().then(() => (init_streamableHttp(), streamableHttp_exports));
         const { isInitializeRequest: isInitializeRequest2 } = await Promise.resolve().then(() => (init_types4(), types_exports));
         const { createMemorixServer: createMemorixServer2 } = await Promise.resolve().then(() => (init_server4(), server_exports2));
@@ -77480,7 +78833,7 @@ var init_serve_http = __esm({
           if (!sessionId && isInitializeRequest2(body)) {
             let createdState = null;
             const transport = new StreamableHTTPServerTransport2({
-              sessionIdGenerator: () => randomUUID11(),
+              sessionIdGenerator: () => randomUUID14(),
               enableJsonResponse: true,
               onsessioninitialized: (sid) => {
                 if (createdState) sessions.set(sid, createdState);
@@ -78847,8 +80200,8 @@ var init_sync = __esm({
         }
         const { detectProject: detectProject2 } = await Promise.resolve().then(() => (init_detector(), detector_exports));
         const { RulesSyncer: RulesSyncer2 } = await Promise.resolve().then(() => (init_syncer(), syncer_exports));
-        const { promises: fs27 } = await import("fs");
-        const path37 = await import("path");
+        const { promises: fs28 } = await import("fs");
+        const path38 = await import("path");
         we("memorix sync");
         const project = detectProject2();
         if (!project) {
@@ -78920,9 +80273,9 @@ var init_sync = __esm({
           process.exit(0);
         }
         for (const file of files) {
-          const fullPath = path37.join(project.rootPath, file.filePath);
-          await fs27.mkdir(path37.dirname(fullPath), { recursive: true });
-          await fs27.writeFile(fullPath, file.content, "utf-8");
+          const fullPath = path38.join(project.rootPath, file.filePath);
+          await fs28.mkdir(path38.dirname(fullPath), { recursive: true });
+          await fs28.writeFile(fullPath, file.content, "utf-8");
           v3.success(`Written: ${file.filePath}`);
         }
         fe2(`Synced ${files.length} rule(s) to ${target} format`);
@@ -80809,8 +82162,8 @@ var hooks_preview_exports = {};
 __export(hooks_preview_exports, {
   default: () => hooks_preview_default
 });
-import * as fs21 from "fs/promises";
-import * as path32 from "path";
+import * as fs22 from "fs/promises";
+import * as path33 from "path";
 function estimateFileSize(agent, configPath) {
   const sizes = {
     claude: "~2KB",
@@ -80830,30 +82183,30 @@ function getRulesPath(agent, cwd, global2) {
   if (global2) {
     switch (agent) {
       case "cursor":
-        return path32.join(home, ".cursor", "rules", "memorix.mdc");
+        return path33.join(home, ".cursor", "rules", "memorix.mdc");
       case "codex":
-        return path32.join(home, ".codex", "AGENTS.md");
+        return path33.join(home, ".codex", "AGENTS.md");
       case "opencode":
-        return path32.join(home, ".config", "opencode", "AGENTS.md");
+        return path33.join(home, ".config", "opencode", "AGENTS.md");
       case "antigravity":
-        return path32.join(home, ".gemini", "GEMINI.md");
+        return path33.join(home, ".gemini", "GEMINI.md");
       case "trae":
-        return path32.join(home, ".trae", "rules", "project_rules.md");
+        return path33.join(home, ".trae", "rules", "project_rules.md");
       default:
         return "";
     }
   } else {
     switch (agent) {
       case "cursor":
-        return path32.join(cwd, ".cursor", "rules", "memorix.mdc");
+        return path33.join(cwd, ".cursor", "rules", "memorix.mdc");
       case "codex":
-        return path32.join(cwd, "AGENTS.md");
+        return path33.join(cwd, "AGENTS.md");
       case "opencode":
-        return path32.join(cwd, "AGENTS.md");
+        return path33.join(cwd, "AGENTS.md");
       case "antigravity":
-        return path32.join(cwd, "GEMINI.md");
+        return path33.join(cwd, "GEMINI.md");
       case "trae":
-        return path32.join(cwd, ".trae", "rules", "project_rules.md");
+        return path33.join(cwd, ".trae", "rules", "project_rules.md");
       default:
         return "";
     }
@@ -80910,7 +82263,7 @@ var init_hooks_preview = __esm({
           const configPath = global2 ? getGlobalConfigPath2(agent) : getProjectConfigPath2(agent, cwd);
           let action;
           try {
-            await fs21.access(configPath);
+            await fs22.access(configPath);
             action = "modify";
           } catch {
             action = "create";
@@ -80925,7 +82278,7 @@ var init_hooks_preview = __esm({
           if (["cursor", "codex", "opencode", "antigravity", "trae"].includes(agent)) {
             const rulesPath = getRulesPath(agent, cwd, global2);
             try {
-              await fs21.access(rulesPath);
+              await fs22.access(rulesPath);
               previewItems.push({
                 agent,
                 path: rulesPath,
@@ -80942,10 +82295,10 @@ var init_hooks_preview = __esm({
             }
           }
           if (agent === "kiro") {
-            const hooksDir = path32.dirname(configPath);
+            const hooksDir = path33.dirname(configPath);
             previewItems.push({
               agent,
-              path: path32.join(hooksDir, "*.kiro.hook"),
+              path: path33.join(hooksDir, "*.kiro.hook"),
               action: "create",
               size: "~500B each"
             });
@@ -81716,9 +83069,9 @@ __export(ingest_image_exports, {
   default: () => ingest_image_default
 });
 import { readFileSync as readFileSync16 } from "fs";
-import path33 from "path";
+import path34 from "path";
 function inferMimeType(filePath) {
-  const ext = path33.extname(filePath).toLowerCase();
+  const ext = path34.extname(filePath).toLowerCase();
   switch (ext) {
     case ".jpg":
     case ".jpeg":
@@ -81761,9 +83114,9 @@ var init_ingest_image = __esm({
             return;
           }
           const { project, reader, identity } = await getCliProjectContext();
-          const resolvedPath = path33.resolve(project.rootPath, imagePath);
+          const resolvedPath = path34.resolve(project.rootPath, imagePath);
           const base642 = readFileSync16(resolvedPath).toString("base64");
-          const filename = path33.basename(resolvedPath);
+          const filename = path34.basename(resolvedPath);
           const analysis = await analyzeImage({
             base64: base642,
             filename,
@@ -82027,7 +83380,7 @@ __export(background_exports, {
   doStart: () => doStart,
   doStop: () => doStop
 });
-import * as fs22 from "fs";
+import * as fs23 from "fs";
 import { spawn as spawn4, execSync as execSync5 } from "child_process";
 import { randomBytes } from "crypto";
 function getMemorixDir() {
@@ -82045,7 +83398,7 @@ function getLogFilePath() {
 }
 function loadState() {
   try {
-    const data = fs22.readFileSync(getStateFilePath(), "utf-8");
+    const data = fs23.readFileSync(getStateFilePath(), "utf-8");
     return JSON.parse(data);
   } catch {
     return null;
@@ -82053,12 +83406,12 @@ function loadState() {
 }
 function saveState(state) {
   const dir = getMemorixDir();
-  if (!fs22.existsSync(dir)) fs22.mkdirSync(dir, { recursive: true });
-  fs22.writeFileSync(getStateFilePath(), JSON.stringify(state, null, 2));
+  if (!fs23.existsSync(dir)) fs23.mkdirSync(dir, { recursive: true });
+  fs23.writeFileSync(getStateFilePath(), JSON.stringify(state, null, 2));
 }
 function clearState() {
   try {
-    fs22.unlinkSync(getStateFilePath());
+    fs23.unlinkSync(getStateFilePath());
   } catch {
   }
 }
@@ -82125,7 +83478,7 @@ async function doStart(port) {
   } else {
     try {
       const heartbeatPath = getMemorixDir() + "/background.heartbeat";
-      const hbData = fs22.readFileSync(heartbeatPath, "utf-8");
+      const hbData = fs23.readFileSync(heartbeatPath, "utf-8");
       const hb = JSON.parse(hbData);
       const age = Date.now() - hb.heartbeatAt;
       if (age < 12e4) {
@@ -82133,7 +83486,7 @@ async function doStart(port) {
         console.log("  The control plane likely crashed. Auto-restarting...");
       }
       try {
-        fs22.unlinkSync(heartbeatPath);
+        fs23.unlinkSync(heartbeatPath);
       } catch {
       }
     } catch {
@@ -82154,19 +83507,19 @@ async function doStart(port) {
   }
   try {
     const readyFile = getMemorixDir() + "/background.ready";
-    if (fs22.existsSync(readyFile)) fs22.unlinkSync(readyFile);
+    if (fs23.existsSync(readyFile)) fs23.unlinkSync(readyFile);
   } catch {
   }
   const logFile = getLogFilePath();
   const dir = getMemorixDir();
-  if (!fs22.existsSync(dir)) fs22.mkdirSync(dir, { recursive: true });
-  if (fs22.existsSync(logFile)) {
+  if (!fs23.existsSync(dir)) fs23.mkdirSync(dir, { recursive: true });
+  if (fs23.existsSync(logFile)) {
     try {
-      fs22.renameSync(logFile, logFile + ".prev");
+      fs23.renameSync(logFile, logFile + ".prev");
     } catch {
     }
   }
-  const logFd = fs22.openSync(logFile, "a");
+  const logFd = fs23.openSync(logFile, "a");
   const cliEntry = process.argv[1];
   const child = spawn4(process.execPath, [cliEntry, "serve-http", "--port", String(port)], {
     detached: true,
@@ -82176,7 +83529,7 @@ async function doStart(port) {
     windowsHide: true
   });
   child.unref();
-  fs22.closeSync(logFd);
+  fs23.closeSync(logFd);
   const pid = child.pid;
   if (!pid) {
     console.error("[ERROR] Failed to spawn background process");
@@ -82246,7 +83599,7 @@ async function doStop() {
     console.log(`Background process (PID ${state.pid}) is not running. Cleaning up state.`);
     clearState();
     try {
-      fs22.unlinkSync(getMemorixDir() + "/background.ready");
+      fs23.unlinkSync(getMemorixDir() + "/background.ready");
     } catch {
     }
     return;
@@ -82265,7 +83618,7 @@ async function doStop() {
     }
     clearState();
     try {
-      fs22.unlinkSync(getMemorixDir() + "/background.ready");
+      fs23.unlinkSync(getMemorixDir() + "/background.ready");
     } catch {
     }
     return;
@@ -82302,7 +83655,7 @@ async function doStop() {
   }
   clearState();
   try {
-    fs22.unlinkSync(getMemorixDir() + "/background.ready");
+    fs23.unlinkSync(getMemorixDir() + "/background.ready");
   } catch {
   }
   console.log("[OK] Control plane stopped.");
@@ -82378,7 +83731,7 @@ async function doStatus() {
     console.log("  Process has exited. Cleaning up stale state...");
     try {
       const heartbeatPath = getMemorixDir() + "/background.heartbeat";
-      const hbData = fs22.readFileSync(heartbeatPath, "utf-8");
+      const hbData = fs23.readFileSync(heartbeatPath, "utf-8");
       const hb = JSON.parse(hbData);
       const age = Date.now() - hb.heartbeatAt;
       if (age < 3e5) {
@@ -82419,26 +83772,26 @@ async function doEnsure(port) {
 }
 function doLogs(follow, lines) {
   const logFile = getLogFilePath();
-  if (!fs22.existsSync(logFile)) {
+  if (!fs23.existsSync(logFile)) {
     console.log("No log file found. Start the background service first:");
     console.log("  memorix background start");
     return;
   }
   if (follow) {
-    const content = fs22.readFileSync(logFile, "utf-8");
+    const content = fs23.readFileSync(logFile, "utf-8");
     const existingLines = content.split("\n");
     const tail = existingLines.slice(-lines);
     console.log(tail.join("\n"));
     console.log("--- Following log (Ctrl+C to stop) ---");
-    let position = fs22.statSync(logFile).size;
-    const watcher = fs22.watch(logFile, () => {
+    let position = fs23.statSync(logFile).size;
+    const watcher = fs23.watch(logFile, () => {
       try {
-        const stat = fs22.statSync(logFile);
+        const stat = fs23.statSync(logFile);
         if (stat.size > position) {
-          const fd = fs22.openSync(logFile, "r");
+          const fd = fs23.openSync(logFile, "r");
           const buf = Buffer.alloc(stat.size - position);
-          fs22.readSync(fd, buf, 0, buf.length, position);
-          fs22.closeSync(fd);
+          fs23.readSync(fd, buf, 0, buf.length, position);
+          fs23.closeSync(fd);
           process.stdout.write(buf.toString("utf-8"));
           position = stat.size;
         }
@@ -82448,7 +83801,7 @@ function doLogs(follow, lines) {
     setInterval(() => {
     }, 6e4);
   } else {
-    const content = fs22.readFileSync(logFile, "utf-8");
+    const content = fs23.readFileSync(logFile, "utf-8");
     const allLines = content.split("\n");
     const tail = allLines.slice(-lines);
     console.log(tail.join("\n"));
@@ -82633,7 +83986,7 @@ function asRecordArray(value) {
   return Array.isArray(value) ? value.map(asRecord2).filter((entry) => entry !== null) : [];
 }
 function codexPluginPath() {
-  return `${homedir32()}/.codex/plugins/${CODEX_PLUGIN_NAME}`;
+  return `${homedir32()}/plugins/${CODEX_PLUGIN_NAME}`;
 }
 function codexPluginMcpPath() {
   return `${codexPluginPath()}/.mcp.json`;
@@ -82652,7 +84005,10 @@ function isMemorixCodexPlugin(value) {
 }
 function parseCodexPluginList(output) {
   try {
-    const parsed = asRecord2(JSON.parse(output));
+    const start = output.indexOf("{");
+    const end = output.lastIndexOf("}");
+    if (start < 0 || end < start) return null;
+    const parsed = asRecord2(JSON.parse(output.slice(start, end + 1)));
     if (!parsed) return null;
     const entries = [...asRecordArray(parsed.installed), ...asRecordArray(parsed.available)];
     const plugin = entries.find(isMemorixCodexPlugin);
@@ -82795,7 +84151,7 @@ async function inspectCodexMarketplace() {
   }
   const source = asRecord2(entry.source);
   const sourcePath = typeof source?.path === "string" ? source.path : "";
-  const issues = source?.source === "local" && normalizeMarketplacePath(sourcePath) === ".codex/plugins/memorix" ? [] : ["codex-marketplace-entry-stale"];
+  const issues = source?.source === "local" && normalizeMarketplacePath(sourcePath) === "plugins/memorix" ? [] : ["codex-marketplace-entry-stale"];
   return {
     scope: "global",
     kind: "marketplace",
@@ -83362,9 +84718,11 @@ async function repairAgentIntegrations(options2 = {}) {
         } else {
           if (!options2.dry) {
             await installPluginPackage({ agent: "codex" });
-            if (needsInstall) {
-              const install = tryInstallCodexPlugin();
-              if (!install.ok) skipped.push("codex:plugin:global:install-pending");
+            const install = tryInstallCodexPlugin();
+            if (install.ok) {
+              await migrateLegacyCodexIntegration({ projectRoot });
+            } else {
+              skipped.push("codex:plugin:global:install-pending");
             }
           }
           changed.push("codex:plugin:global");
@@ -84023,7 +85381,7 @@ __export(dashboard_exports, {
   default: () => dashboard_default
 });
 import { fileURLToPath as fileURLToPath6 } from "url";
-import path34 from "path";
+import path35 from "path";
 var dashboard_default;
 var init_dashboard = __esm({
   "src/cli/commands/dashboard.ts"() {
@@ -84053,8 +85411,8 @@ var init_dashboard = __esm({
         }
         const dataDir = await getProjectDataDir2(project.id);
         const port = parseInt(args.port, 10) || 3210;
-        const cliDir = path34.dirname(fileURLToPath6(import.meta.url));
-        const staticDir = path34.join(cliDir, "..", "dashboard", "static");
+        const cliDir = path35.dirname(fileURLToPath6(import.meta.url));
+        const staticDir = path35.join(cliDir, "..", "dashboard", "static");
         await startDashboard2(dataDir, port, staticDir, project.id, project.name, true, void 0, project.rootPath, true);
         await new Promise(() => {
         });
@@ -84310,12 +85668,12 @@ var uninstall_exports = {};
 __export(uninstall_exports, {
   default: () => uninstall_default
 });
-import * as fs23 from "fs";
-import * as path35 from "path";
+import * as fs24 from "fs";
+import * as path36 from "path";
 import * as os4 from "os";
 function exists(p2) {
   try {
-    fs23.accessSync(p2);
+    fs24.accessSync(p2);
     return true;
   } catch {
     return false;
@@ -84324,7 +85682,7 @@ function exists(p2) {
 function checkJSON(p2) {
   if (!exists(p2)) return false;
   try {
-    const content = fs23.readFileSync(p2, "utf-8");
+    const content = fs24.readFileSync(p2, "utf-8");
     const cfg = JSON.parse(content);
     const servers = cfg.mcpServers ?? cfg.mcp_servers ?? cfg.servers ?? {};
     return Object.keys(servers).some((k5) => k5.toLowerCase().includes("memorix"));
@@ -84335,7 +85693,7 @@ function checkJSON(p2) {
 function checkTOML(p2) {
   if (!exists(p2)) return false;
   try {
-    const content = fs23.readFileSync(p2, "utf-8");
+    const content = fs24.readFileSync(p2, "utf-8");
     return /\[mcp_servers\.(?:memorix|Memorix)\]/.test(content);
   } catch {
     return false;
@@ -84345,124 +85703,124 @@ function getMCPConfigEntries(home, cwd) {
   const entries = [];
   entries.push({
     agent: "Claude Code",
-    path: path35.join(home, ".claude.json"),
+    path: path36.join(home, ".claude.json"),
     kind: "global",
     format: "json",
-    detected: checkJSON(path35.join(home, ".claude.json")),
+    detected: checkJSON(path36.join(home, ".claude.json")),
     note: 'Remove the "memorix" key from mcpServers in this file.'
   });
   entries.push({
     agent: "Claude Code",
-    path: path35.join(cwd, ".claude", "settings.json"),
+    path: path36.join(cwd, ".claude", "settings.json"),
     kind: "project",
     format: "json",
-    detected: checkJSON(path35.join(cwd, ".claude", "settings.json")),
+    detected: checkJSON(path36.join(cwd, ".claude", "settings.json")),
     note: 'Remove the "memorix" key from mcpServers in this file.'
   });
   entries.push({
     agent: "Cursor",
-    path: path35.join(home, ".cursor", "mcp.json"),
+    path: path36.join(home, ".cursor", "mcp.json"),
     kind: "global",
     format: "json",
-    detected: checkJSON(path35.join(home, ".cursor", "mcp.json")),
+    detected: checkJSON(path36.join(home, ".cursor", "mcp.json")),
     note: 'Remove the "memorix" key from mcpServers in this file.'
   });
   entries.push({
     agent: "Cursor",
-    path: path35.join(cwd, ".cursor", "mcp.json"),
+    path: path36.join(cwd, ".cursor", "mcp.json"),
     kind: "project",
     format: "json",
-    detected: checkJSON(path35.join(cwd, ".cursor", "mcp.json")),
+    detected: checkJSON(path36.join(cwd, ".cursor", "mcp.json")),
     note: 'Remove the "memorix" key from mcpServers in this file.'
   });
   entries.push({
     agent: "Windsurf",
-    path: path35.join(home, ".codeium", "windsurf", "mcp_config.json"),
+    path: path36.join(home, ".codeium", "windsurf", "mcp_config.json"),
     kind: "global",
     format: "json",
-    detected: checkJSON(path35.join(home, ".codeium", "windsurf", "mcp_config.json")),
+    detected: checkJSON(path36.join(home, ".codeium", "windsurf", "mcp_config.json")),
     note: 'Remove the "memorix" key from mcpServers in this file.'
   });
   entries.push({
     agent: "Codex",
-    path: path35.join(home, ".codex", "config.toml"),
+    path: path36.join(home, ".codex", "config.toml"),
     kind: "global",
     format: "toml",
-    detected: checkTOML(path35.join(home, ".codex", "config.toml")),
+    detected: checkTOML(path36.join(home, ".codex", "config.toml")),
     note: "Remove the [mcp_servers.memorix] section from this file."
   });
   entries.push({
     agent: "VS Code / Copilot",
-    path: path35.join(home, ".vscode", "mcp.json"),
+    path: path36.join(home, ".vscode", "mcp.json"),
     kind: "global",
     format: "json",
-    detected: checkJSON(path35.join(home, ".vscode", "mcp.json")),
+    detected: checkJSON(path36.join(home, ".vscode", "mcp.json")),
     note: 'Remove the "memorix" key from servers in this file.'
   });
   entries.push({
     agent: "VS Code / Copilot",
-    path: path35.join(cwd, ".vscode", "mcp.json"),
+    path: path36.join(cwd, ".vscode", "mcp.json"),
     kind: "project",
     format: "json",
-    detected: checkJSON(path35.join(cwd, ".vscode", "mcp.json")),
+    detected: checkJSON(path36.join(cwd, ".vscode", "mcp.json")),
     note: 'Remove the "memorix" key from servers in this file.'
   });
   entries.push({
     agent: "Kiro",
-    path: path35.join(home, ".kiro", "settings", "mcp.json"),
+    path: path36.join(home, ".kiro", "settings", "mcp.json"),
     kind: "global",
     format: "json",
-    detected: checkJSON(path35.join(home, ".kiro", "settings", "mcp.json")),
+    detected: checkJSON(path36.join(home, ".kiro", "settings", "mcp.json")),
     note: 'Remove the "memorix" key from mcpServers in this file.'
   });
   entries.push({
     agent: "Kiro",
-    path: path35.join(cwd, ".kiro", "settings", "mcp.json"),
+    path: path36.join(cwd, ".kiro", "settings", "mcp.json"),
     kind: "project",
     format: "json",
-    detected: checkJSON(path35.join(cwd, ".kiro", "settings", "mcp.json")),
+    detected: checkJSON(path36.join(cwd, ".kiro", "settings", "mcp.json")),
     note: 'Remove the "memorix" key from mcpServers in this file.'
   });
   entries.push({
     agent: "Gemini CLI",
-    path: path35.join(home, ".gemini", "settings.json"),
+    path: path36.join(home, ".gemini", "settings.json"),
     kind: "global",
     format: "json",
-    detected: checkJSON(path35.join(home, ".gemini", "settings.json")),
+    detected: checkJSON(path36.join(home, ".gemini", "settings.json")),
     note: 'Remove the "memorix" key from mcpServers in this file.'
   });
   entries.push({
     agent: "Antigravity",
-    path: path35.join(home, ".gemini", "config", "mcp_config.json"),
+    path: path36.join(home, ".gemini", "config", "mcp_config.json"),
     kind: "global",
     format: "json",
-    detected: checkJSON(path35.join(home, ".gemini", "config", "mcp_config.json")),
+    detected: checkJSON(path36.join(home, ".gemini", "config", "mcp_config.json")),
     note: 'Remove the "memorix" key from mcpServers in this file.'
   });
   entries.push({
     agent: "Antigravity",
-    path: path35.join(home, ".gemini", "config", "hooks.json"),
+    path: path36.join(home, ".gemini", "config", "hooks.json"),
     kind: "global",
     format: "json",
-    detected: exists(path35.join(home, ".gemini", "config", "hooks.json")),
+    detected: exists(path36.join(home, ".gemini", "config", "hooks.json")),
     note: 'Remove the "memorix" hook group from this file.'
   });
   entries.push({
     agent: "Antigravity",
-    path: path35.join(home, ".gemini", "config", "plugins", "memorix", "plugin.json"),
+    path: path36.join(home, ".gemini", "config", "plugins", "memorix", "plugin.json"),
     kind: "global",
     format: "json",
-    detected: exists(path35.join(home, ".gemini", "config", "plugins", "memorix", "plugin.json")),
+    detected: exists(path36.join(home, ".gemini", "config", "plugins", "memorix", "plugin.json")),
     note: "Delete the containing ~/.gemini/config/plugins/memorix plugin directory if you want to remove the Antigravity plugin package."
   });
   const traeCfg = (() => {
     if (process.platform === "win32") {
-      return path35.join(process.env.APPDATA || path35.join(home, "AppData", "Roaming"), "Trae", "User", "mcp.json");
+      return path36.join(process.env.APPDATA || path36.join(home, "AppData", "Roaming"), "Trae", "User", "mcp.json");
     }
     if (process.platform === "darwin") {
-      return path35.join(home, "Library", "Application Support", "Trae", "User", "mcp.json");
+      return path36.join(home, "Library", "Application Support", "Trae", "User", "mcp.json");
     }
-    return path35.join(home, ".config", "Trae", "User", "mcp.json");
+    return path36.join(home, ".config", "Trae", "User", "mcp.json");
   })();
   entries.push({
     agent: "Trae",
@@ -84475,9 +85833,9 @@ function getMCPConfigEntries(home, cwd) {
   return entries;
 }
 function checkBackground(home) {
-  const statePath = path35.join(home, ".memorix", "background.json");
+  const statePath = path36.join(home, ".memorix", "background.json");
   try {
-    const data = fs23.readFileSync(statePath, "utf-8");
+    const data = fs24.readFileSync(statePath, "utf-8");
     const state = JSON.parse(data);
     try {
       process.kill(state.pid, 0);
@@ -84616,7 +85974,7 @@ var init_uninstall = __esm({
       },
       async run({ args }) {
         const home = os4.homedir();
-        const memorixDir = path35.join(home, ".memorix");
+        const memorixDir = path36.join(home, ".memorix");
         const dryRun = args["dry-run"];
         const yes = args.yes;
         const doHooks = args.hooks;
@@ -84744,7 +86102,7 @@ var init_uninstall = __esm({
           if (exists(memorixDir)) {
             console.log(`[DELETE] Removing ${memorixDir}...`);
             try {
-              fs23.rmSync(memorixDir, { recursive: true, force: true });
+              fs24.rmSync(memorixDir, { recursive: true, force: true });
               console.log("[OK] Data directory deleted.");
               changes++;
             } catch (err) {
@@ -85115,24 +86473,24 @@ var init_claude_stream = __esm({
 });
 
 // src/orchestrate/adapters/claude.ts
-import * as fs24 from "fs";
-import * as path36 from "path";
+import * as fs25 from "fs";
+import * as path37 from "path";
 function resolveMcpConfigPath(projectDir2) {
-  const localPath = path36.join(projectDir2, ".claude", "settings.local.json");
+  const localPath = path37.join(projectDir2, ".claude", "settings.local.json");
   try {
-    if (fs24.existsSync(localPath)) return localPath;
+    if (fs25.existsSync(localPath)) return localPath;
   } catch {
   }
-  const settingsPath = path36.join(projectDir2, ".claude", "settings.json");
+  const settingsPath = path37.join(projectDir2, ".claude", "settings.json");
   try {
-    if (fs24.existsSync(settingsPath)) return settingsPath;
+    if (fs25.existsSync(settingsPath)) return settingsPath;
   } catch {
   }
   const mcpConfig = {
     mcpServers: {
       memorix: {
         command: process.execPath,
-        args: [path36.resolve(path36.dirname(process.execPath), "..", "lib", "node_modules", "memorix", "dist", "index.js"), "serve", "--transport", "stdio"]
+        args: [path37.resolve(path37.dirname(process.execPath), "..", "lib", "node_modules", "memorix", "dist", "index.js"), "serve", "--transport", "stdio"]
       }
     }
   };
@@ -85142,10 +86500,10 @@ function resolveMcpConfigPath(projectDir2) {
     args: ["serve", "--transport", "stdio"]
   };
   try {
-    const claudeDir = path36.join(projectDir2, ".claude");
-    fs24.mkdirSync(claudeDir, { recursive: true });
-    const tempPath = path36.join(claudeDir, "settings.local.json");
-    fs24.writeFileSync(tempPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
+    const claudeDir = path37.join(projectDir2, ".claude");
+    fs25.mkdirSync(claudeDir, { recursive: true });
+    const tempPath = path37.join(claudeDir, "settings.local.json");
+    fs25.writeFileSync(tempPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
     return tempPath;
   } catch {
     return null;
@@ -86561,9 +87919,9 @@ function writePipelineSummary(projectDir2, summary) {
     return null;
   }
 }
-function safeWrite(path37, content) {
+function safeWrite(path38, content) {
   try {
-    writeFileSync9(path37, content, "utf-8");
+    writeFileSync9(path38, content, "utf-8");
   } catch {
   }
 }
@@ -88034,8 +89392,8 @@ var init_orchestrate = __esm({
         const { getProjectDataDir: getProjectDataDir2 } = await Promise.resolve().then(() => (init_persistence(), persistence_exports));
         const { resolveAdapters: resolveAdapters2, parseAgentQuotas: parseAgentQuotas2, buildQuotaMap: buildQuotaMap2 } = await Promise.resolve().then(() => (init_adapters(), adapters_exports));
         const { runCoordinationLoop: runCoordinationLoop2 } = await Promise.resolve().then(() => (init_coordinator(), coordinator_exports));
-        const path37 = await import("path");
-        const projectDir2 = args.project ? path37.resolve(args.project) : process.cwd();
+        const path38 = await import("path");
+        const projectDir2 = args.project ? path38.resolve(args.project) : process.cwd();
         const proj = detectProject2(projectDir2);
         if (!proj) {
           console.error("[ERROR] Not a git repository. Run `git init` first.");
@@ -89145,7 +90503,7 @@ var init_Panels = __esm({
 // src/cli/tui/ConfigureView.tsx
 import { useState as useState2, useEffect as useEffect2 } from "react";
 import { Box as Box6, Text as Text6, useInput as useInput2 } from "ink";
-import * as fs25 from "fs";
+import * as fs26 from "fs";
 import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
 function getConfigPath() {
   return `${process.env.HOME || process.env.USERPROFILE}/.memorix/config.json`;
@@ -89153,15 +90511,15 @@ function getConfigPath() {
 function loadConfig() {
   try {
     const p2 = getConfigPath();
-    if (fs25.existsSync(p2)) return JSON.parse(fs25.readFileSync(p2, "utf-8"));
+    if (fs26.existsSync(p2)) return JSON.parse(fs26.readFileSync(p2, "utf-8"));
   } catch {
   }
   return {};
 }
 function saveConfig(config2) {
   const dir = `${process.env.HOME || process.env.USERPROFILE}/.memorix`;
-  if (!fs25.existsSync(dir)) fs25.mkdirSync(dir, { recursive: true });
-  fs25.writeFileSync(getConfigPath(), JSON.stringify(config2, null, 2));
+  if (!fs26.existsSync(dir)) fs26.mkdirSync(dir, { recursive: true });
+  fs26.writeFileSync(getConfigPath(), JSON.stringify(config2, null, 2));
 }
 function separator2(w3 = 50) {
   return SEP.thin.repeat(w3);
@@ -89874,7 +91232,7 @@ var init_session_service = __esm({
 });
 
 // src/cli/tui/data.ts
-import * as fs26 from "fs";
+import * as fs27 from "fs";
 function formatSearchModeLabel(mode) {
   const normalized = (mode || "").toLowerCase();
   if (!normalized) return "Unknown";
@@ -90081,7 +91439,7 @@ async function getBackgroundStatus() {
   try {
     const home = process.env.HOME || process.env.USERPROFILE || "";
     const statePath = `${home.replace(/\\/g, "/")}/.memorix/background.json`;
-    if (!fs26.existsSync(statePath)) {
+    if (!fs27.existsSync(statePath)) {
       try {
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), 2e3);
@@ -90102,7 +91460,7 @@ async function getBackgroundStatus() {
       }
       return result;
     }
-    const state = JSON.parse(fs26.readFileSync(statePath, "utf-8"));
+    const state = JSON.parse(fs27.readFileSync(statePath, "utf-8"));
     result.pid = state.pid;
     result.port = state.port;
     result.startedAt = state.startedAt;
@@ -90193,8 +91551,8 @@ function detectMode() {
   try {
     const home = process.env.HOME || process.env.USERPROFILE || "";
     const statePath = `${home.replace(/\\/g, "/")}/.memorix/background.json`;
-    if (fs26.existsSync(statePath)) {
-      const state = JSON.parse(fs26.readFileSync(statePath, "utf-8"));
+    if (fs27.existsSync(statePath)) {
+      const state = JSON.parse(fs27.readFileSync(statePath, "utf-8"));
       try {
         process.kill(state.pid, 0);
         return { mode: "Background", detail: `port ${state.port}` };
@@ -92735,9 +94093,17 @@ var GUIDES = {
       "memorix memory recent [--limit 10]",
       "memorix memory resolve --ids 42,43 [--status resolved|archived]",
       "memorix memory consolidate --action preview|execute",
-      'memorix memory promote --ids 42,43 [--trigger "..."] [--instruction "..."]'
+      'memorix memory promote --ids 42,43 [--trigger "..."] [--instruction "..."]',
+      "memorix memory long-term list [--all]",
+      'memorix memory long-term add --kind semantic --scope user --portability portable --title "..." --text "..." [--tags "..."] [--applicability "..."]',
+      "memorix memory long-term promote --from-observation 42 --kind procedural --scope project",
+      'memorix memory long-term qualify|approve|archive --id <id> --reason "..."',
+      'memorix memory long-term supersede --id <old-id> --superseded-by <qualified-id> --reason "..."'
     ],
-    notes: ["Personal and team visibility require `memorix identity join` or `memorix identity use` first."]
+    notes: [
+      "Personal and team visibility require `memorix identity join` or `memorix identity use` first.",
+      "Candidates never enter a task Workset. Only manual or user-confirmed `user + portable` memory may cross local projects."
+    ]
   },
   identity: {
     summary: "Select the active local actor for private memory and coordination commands.",