memorix 1.2.10 → 1.3.0

package/dist/sdk.js

@@ -200,15 +200,15 @@ function loadSqlite() {
     throw new Error("[memorix] SQLite is unavailable (better-sqlite3, node:sqlite, and bun:sqlite failed)");
   }
 }
-function createDatabase(path26, options) {
+function createDatabase(path27, options) {
   const Sqlite = loadSqlite();
   try {
-    return addCompatibility(instantiateDatabase(Sqlite, path26, options));
+    return addCompatibility(instantiateDatabase(Sqlite, path27, options));
   } catch (error) {
     if (driver !== "better-sqlite3" || !isNativeBindingFailure(error)) throw error;
     Database = loadNodeSqlite();
     driver = "node:sqlite";
-    return addCompatibility(instantiateDatabase(Database, path26, options));
+    return addCompatibility(instantiateDatabase(Database, path27, options));
   }
 }
 var Database, driver, requireFromHere;
@@ -335,7 +335,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";
@@ -761,6 +761,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,
@@ -856,6 +907,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);
@@ -944,6 +1000,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();
@@ -2732,9 +2801,9 @@ function parseTomlConfig(content, filePath) {
   }
   return root;
 }
-function ensureTable(root, path26) {
+function ensureTable(root, path27) {
   let cursor = root;
-  for (const part of path26) {
+  for (const part of path27) {
     const value = cursor[part];
     if (!value || typeof value !== "object" || Array.isArray(value)) {
       cursor[part] = {};
@@ -3610,9 +3679,10 @@ function parseBatchLimit(error) {
   }
   return null;
 }
-async function fetchWithRetry(url, apiKey, body, attempt = 0) {
+async function fetchWithRetry(url, apiKey, body, options = {}, attempt = 0) {
   const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), 1e4);
+  const timeoutMs = typeof options.timeoutMs === "number" && Number.isFinite(options.timeoutMs) ? Math.max(100, Math.min(Math.floor(options.timeoutMs), 6e4)) : 1e4;
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
   let response;
   try {
     response = await fetch(url, {
@@ -3627,7 +3697,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;
   }
@@ -3635,13 +3705,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 (options.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((resolve2) => setTimeout(resolve2, waitMs));
-    return fetchWithRetry(url, apiKey, body, attempt + 1);
+    return fetchWithRetry(url, apiKey, body, options, attempt + 1);
   }
   const errorText2 = await response.text().catch(() => "unknown error");
   throw new Error(`Embedding API error (${response.status}): ${errorText2}`);
@@ -3697,7 +3767,10 @@ var init_api_provider = __esm({
           }
         } else {
           if (!allowNetworkProbe) return null;
-          probeDimensions = await _APIEmbeddingProvider.probeAPI(config);
+          probeDimensions = await _APIEmbeddingProvider.probeAPI(config, {
+            timeoutMs: options.requestTimeoutMs,
+            retry: options.retry
+          });
           console.error(`[memorix] API embedding: ${config.model} @ ${config.baseUrl} (${probeDimensions}d)`);
           saveCachedDims(config, probeDimensions).catch(() => {
           });
@@ -3739,7 +3812,7 @@ var init_api_provider = __esm({
         baseUrl = baseUrl.replace(/\/+$/, "");
         return { apiKey, baseUrl, model, requestedDimensions };
       }
-      static async probeAPI(config) {
+      static async probeAPI(config, options) {
         const body = {
           model: config.model,
           input: "dimension probe"
@@ -3750,14 +3823,15 @@ var init_api_provider = __esm({
         const response = await fetchWithRetry(
           `${config.baseUrl}/embeddings`,
           config.apiKey,
-          body
+          body,
+          options
         );
         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, options) {
         const normalized = normalizeText(text);
         const hash4 = textHash2(normalized, this.cacheKeyNamespace);
         if (diskCacheLoaded) {
@@ -3775,7 +3849,8 @@ var init_api_provider = __esm({
           const response = await fetchWithRetry(
             `${this.config.baseUrl}/embeddings`,
             this.config.apiKey,
-            body
+            body,
+            options
           );
           const embedding2 = response.data[0].embedding;
           if (embedding2.length !== this.dimensions) {
@@ -3809,7 +3884,7 @@ var init_api_provider = __esm({
         scheduleDiskSave();
         return embedding;
       }
-      async embedBatch(texts) {
+      async embedBatch(texts, options) {
         await ensureDiskCacheLoaded();
         const normalizedTexts = texts.map(normalizeText);
         const results = new Array(texts.length);
@@ -3843,7 +3918,8 @@ var init_api_provider = __esm({
             const response = await fetchWithRetry(
               `${this.config.baseUrl}/embeddings`,
               this.config.apiKey,
-              body
+              body,
+              options
             );
             this.trackUsage(response);
             for (const item of response.data) {
@@ -4020,9 +4096,9 @@ function wrapProvider(candidate) {
   return {
     name: candidate.name,
     dimensions: candidate.dimensions,
-    async embed(text) {
+    async embed(text, options) {
       try {
-        return await candidate.embed(text);
+        return await candidate.embed(text, options);
       } catch (error) {
         if (kind === "api" && getEmbeddingMode2() === "auto" && isTemporaryEmbeddingFailure(error)) {
           warnOnce("[memorix] API embedding temporarily unavailable \u2014 switching to local fallback provider");
@@ -4030,7 +4106,7 @@ function wrapProvider(candidate) {
           if (fallback) {
             provider = wrapProvider(fallback);
             warnOnce(`[memorix] Embedding fallback activated: ${provider.name} (${provider.dimensions}d)`);
-            return provider.embed(text);
+            return provider.embed(text, options);
           }
         }
         if (isTemporaryEmbeddingFailure(error)) {
@@ -4039,9 +4115,9 @@ function wrapProvider(candidate) {
         throw error;
       }
     },
-    async embedBatch(texts) {
+    async embedBatch(texts, options) {
       try {
-        return await candidate.embedBatch(texts);
+        return await candidate.embedBatch(texts, options);
       } catch (error) {
         if (kind === "api" && getEmbeddingMode2() === "auto" && isTemporaryEmbeddingFailure(error)) {
           warnOnce("[memorix] API embedding temporarily unavailable \u2014 switching to local fallback provider");
@@ -4049,7 +4125,7 @@ function wrapProvider(candidate) {
           if (fallback) {
             provider = wrapProvider(fallback);
             warnOnce(`[memorix] Embedding fallback activated: ${provider.name} (${provider.dimensions}d)`);
-            return provider.embedBatch(texts);
+            return provider.embedBatch(texts, options);
           }
         }
         if (isTemporaryEmbeddingFailure(error)) {
@@ -4105,14 +4181,14 @@ async function getEmbeddingProvider(options = {}) {
       return provider;
     }
     if (mode === "api") {
-      const initialized = await createAPIProvider();
+      const initialized = await createAPIProvider(options);
       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(options);
       if (initialized) {
         provider = wrapProvider(initialized);
         warnOnce(`[memorix] Embedding provider: ${provider.name} (${provider.dimensions}d)`);
@@ -8968,12 +9044,12 @@ import { createHash as createHash4 } from "crypto";
 function digest(input) {
   return createHash4("sha256").update(input).digest("hex").slice(0, 16);
 }
-function normalizeCodePath(path26) {
-  return path26.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+/g, "/");
+function normalizeCodePath(path27) {
+  return path27.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+/g, "/");
 }
-function makeCodeFileId(projectId, path26) {
+function makeCodeFileId(projectId, path27) {
   return `file:${digest(`${projectId}
-${normalizeCodePath(path26)}`)}`;
+${normalizeCodePath(path27)}`)}`;
 }
 function makeCodeSymbolId(input) {
   return `symbol:${digest([
@@ -9447,8 +9523,8 @@ var init_store = __esm({
         });
         tx();
       }
-      getFile(projectId, path26) {
-        const row = this.db.prepare(`SELECT * FROM code_files WHERE projectId = ? AND path = ?`).get(projectId, normalizeCodePath(path26));
+      getFile(projectId, path27) {
+        const row = this.db.prepare(`SELECT * FROM code_files WHERE projectId = ? AND path = ?`).get(projectId, normalizeCodePath(path27));
         return row ? rowToFile(row) : null;
       }
       listFiles(projectId) {
@@ -9683,30 +9759,30 @@ function normalizeCodeGraphExcludePatterns(exclude) {
     ...(exclude ?? []).map((pattern) => pattern.trim()).filter(Boolean)
   ])];
 }
-function isCodeGraphExcludedPath(path26, exclude) {
-  const normalized = normalizeCodePath2(path26);
+function isCodeGraphExcludedPath(path27, exclude) {
+  const normalized = normalizeCodePath2(path27);
   return normalizeCodeGraphExcludePatterns(exclude).some((pattern) => matchesPattern(normalized, normalizeCodePath2(pattern)));
 }
-function normalizeCodePath2(path26) {
-  return path26.replace(/\\/g, "/").replace(/^\.\/+/, "");
+function normalizeCodePath2(path27) {
+  return path27.replace(/\\/g, "/").replace(/^\.\/+/, "");
 }
-function matchesPattern(path26, pattern) {
+function matchesPattern(path27, pattern) {
   if (pattern.endsWith("/**")) {
     const base = pattern.slice(0, -3);
     if (base.startsWith("**/")) {
       const suffix = base.slice(3);
-      return path26 === suffix || path26.endsWith(`/${suffix}`) || path26.includes(`/${suffix}/`);
+      return path27 === suffix || path27.endsWith(`/${suffix}`) || path27.includes(`/${suffix}/`);
     }
     if (!base.includes("/")) {
-      return path26 === base || path26.startsWith(`${base}/`) || path26.includes(`/${base}/`);
+      return path27 === base || path27.startsWith(`${base}/`) || path27.includes(`/${base}/`);
     }
-    return path26 === base || path26.startsWith(`${base}/`);
+    return path27 === base || path27.startsWith(`${base}/`);
   }
   if (pattern.startsWith("**/")) {
     const suffix = pattern.slice(3);
-    return path26 === suffix || path26.endsWith(`/${suffix}`);
+    return path27 === suffix || path27.endsWith(`/${suffix}`);
   }
-  return path26 === pattern || path26.startsWith(`${pattern}/`);
+  return path27 === pattern || path27.startsWith(`${pattern}/`);
 }
 var DEFAULT_CODEGRAPH_EXCLUDES;
 var init_exclude = __esm({
@@ -9751,12 +9827,12 @@ import { join as join4, relative } from "path";
 function hashText(text) {
   return createHash6("sha256").update(text).digest("hex");
 }
-function extension(path26) {
-  const index = path26.lastIndexOf(".");
-  return index === -1 ? "" : path26.slice(index);
+function extension(path27) {
+  const index = path27.lastIndexOf(".");
+  return index === -1 ? "" : path27.slice(index);
 }
-function languageForPath(path26) {
-  const ext = extension(path26);
+function languageForPath(path27) {
+  const ext = extension(path27);
   return LANGUAGE_BY_EXTENSION.get(ext) ?? "unknown";
 }
 function resolveMaxFileBytes(value) {
@@ -10237,7 +10313,7 @@ function resolveObservationCodeRefs(obs, lookup) {
 }
 function createStoreLookup(store, projectId) {
   return {
-    findFile: (path26) => store.getFile(projectId, path26) ?? void 0,
+    findFile: (path27) => store.getFile(projectId, path27) ?? void 0,
     findSymbols: (names, hintedFileIds) => store.findSymbolsByNames(projectId, names, hintedFileIds)
   };
 }
@@ -10250,7 +10326,7 @@ function createSnapshotLookup(files, symbols) {
     symbolsByName.set(symbol.name, group);
   }
   return {
-    findFile: (path26) => filesByPath.get(normalizeCodePath(path26)),
+    findFile: (path27) => filesByPath.get(normalizeCodePath(path27)),
     findSymbols: (names, hintedFileIds) => {
       const hinted = new Set(hintedFileIds);
       const found = [];
@@ -11867,8 +11943,8 @@ __export(task_lens_exports, {
   scoreLensSource: () => scoreLensSource,
   shouldShowLensSource: () => shouldShowLensSource
 });
-function normalizePath2(path26) {
-  return path26.replace(/\\/g, "/");
+function normalizePath2(path27) {
+  return path27.replace(/\\/g, "/");
 }
 function tokenize2(text) {
   return (text.toLowerCase().match(/[a-z0-9_./-]+|[\u4e00-\u9fff]+/g) ?? []).map((token) => token.trim()).filter((token) => token.length > 1 && !STOP_WORDS.has(token));
@@ -11930,8 +12006,8 @@ function isContinuationTask(task) {
     (keyword) => containsTaskKeyword(normalized, keyword)
   );
 }
-function pathKindScore(path26, lens) {
-  const normalized = normalizePath2(path26).toLowerCase();
+function pathKindScore(path27, lens) {
+  const normalized = normalizePath2(path27).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);
@@ -11979,8 +12055,8 @@ function sourceTaskMatchScore(source, task) {
   if (matches === 1) return 24;
   return 0;
 }
-function fallbackPathRank(path26) {
-  const normalized = normalizePath2(path26);
+function fallbackPathRank(path27) {
+  const normalized = normalizePath2(path27);
   if (normalized.startsWith("src/")) return 0;
   if (normalized.startsWith("tests/") || normalized.startsWith("test/")) return 1;
   if (normalized.startsWith("packages/") && normalized.includes("/src/")) return 2;
@@ -11989,11 +12065,11 @@ function fallbackPathRank(path26) {
 }
 function rankLensPaths(paths, lens, task) {
   const tokens = tokenize2(task ?? "");
-  return [...new Set(paths.map(normalizePath2))].map((path26, index) => ({
-    path: path26,
+  return [...new Set(paths.map(normalizePath2))].map((path27, index) => ({
+    path: path27,
     index,
-    score: pathKindScore(path26, lens) + tokenScore(path26, tokens),
-    fallback: fallbackPathRank(path26)
+    score: pathKindScore(path27, lens) + tokenScore(path27, tokens),
+    fallback: fallbackPathRank(path27)
   })).sort((a, b) => b.score - a.score || a.fallback - b.fallback || a.index - b.index || a.path.localeCompare(b.path)).map((item) => item.path);
 }
 function lensPathCandidates(lens) {
@@ -16245,6 +16321,827 @@ var init_session = __esm({
   }
 });
 
+// src/memory/owner.ts
+var owner_exports = {};
+__export(owner_exports, {
+  resolveLocalMemoryOwner: () => resolveLocalMemoryOwner
+});
+import { randomUUID as randomUUID8 } 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, options = {}) {
+  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 || !options.create) return existing;
+  await fs15.mkdir(path19.dirname(filePath), { recursive: true });
+  const created = {
+    version: 1,
+    id: "local-" + randomUUID8(),
+    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 (error) {
+    if (error?.code !== "EEXIST") throw error;
+    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 randomUUID9 } 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(options = {}) {
+        const limit = Math.max(1, Math.min(1e3, Math.floor(options.limit ?? 500)));
+        const clauses = [];
+        const params = [];
+        if (options.ownerId) {
+          clauses.push("ownerId = ?");
+          params.push(options.ownerId);
+        }
+        if (options.originProjectId) {
+          clauses.push("originProjectId = ?");
+          params.push(options.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: randomUUID9(),
+          ...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: randomUUID9(),
+          ...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 unique2 = [...new Set(ids.filter(Boolean))];
+        if (unique2.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 unique2) 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 randomUUID10 } 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 time = Date.parse(validatedAt);
+  if (!Number.isFinite(time)) return 0;
+  const ageDays = Math.max(0, Date.now() - time) / (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 a = left[index];
+    const b = right[index];
+    if (!Number.isFinite(a) || !Number.isFinite(b)) return 0;
+    dot += a * b;
+    leftMagnitude += a * a;
+    rightMagnitude += b * b;
+  }
+  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 store = new LongTermMemoryStore();
+  return store.init(dataDir).then(() => store);
+}
+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:" + randomUUID10(), 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: randomUUID10(),
+    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 store = await createStore(input.dataDir);
+  const evidence = store.transaction(() => {
+    store.insert(memory);
+    const written = evidenceInputs.map((item) => store.insertEvidence({ memoryId: memory.id, ...item, createdAt: now3 }));
+    store.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 store = await createStore(input.dataDir);
+  return store.transaction(() => {
+    const current = store.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 = store.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 }
+    };
+    store.update(next);
+    store.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 store = await createStore(input.dataDir);
+  return store.transaction(() => {
+    const current = store.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 };
+    store.update(next);
+    store.recordEvent({
+      memoryId: next.id,
+      kind: "archived",
+      fromState: current.state,
+      toState: "archived",
+      detail: transitionDetail(input.reason),
+      createdAt: now3
+    });
+    return next;
+  });
+}
+async function supersedeLongTermMemory(input) {
+  const store = await createStore(input.dataDir);
+  return store.transaction(() => {
+    const current = store.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 = store.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
+    };
+    store.update(next);
+    store.recordEvent({
+      memoryId: next.id,
+      kind: "superseded",
+      fromState: current.state,
+      toState: "superseded",
+      detail: transitionDetail(input.reason),
+      createdAt: now3
+    });
+    return next;
+  });
+}
+async function listLongTermMemories(input) {
+  const store = await createStore(input.dataDir);
+  return store.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: store.listEvidence(memory.id) }));
+}
+async function getLongTermMemoryDetail(input) {
+  const store = await createStore(input.dataDir);
+  const memory = store.get(input.id);
+  if (!memory || !canReadLongTermMemory(memory, input.reader)) {
+    throw new Error("Long-term memory was not found in the active scope.");
+  }
+  store.markAccess([memory.id]);
+  return { memory, evidence: store.listEvidence(memory.id), events: store.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 store = await createStore(input.dataDir);
+  const eligible = store.list({ limit: 1e3 }).filter((memory) => isEligibleLongTermMemory(memory) && canReadLongTermMemory(memory, reader));
+  let selected = eligible.map((memory) => {
+    const ranked = scoreForTask(memory, task);
+    return ranked ? {
+      memory,
+      evidence: store.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: store.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)));
+  store.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/knowledge/workset.ts
 function unique(values) {
   return [...new Set(values.filter(Boolean))];
@@ -16348,6 +17245,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";
@@ -16606,6 +17504,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");
@@ -16675,6 +17593,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 = [];
@@ -16714,7 +17658,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
@@ -16740,7 +17687,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) ?? [],
@@ -16753,6 +17700,7 @@ async function buildTaskWorkset(input) {
     hiddenCautionMemoryCount: input.hiddenCautionMemoryCount ?? 0,
     claims,
     pages,
+    durableMemory,
     workflows,
     cautions: normalizedCautions,
     verification,
@@ -16769,7 +17717,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: {
@@ -16804,6 +17752,7 @@ var init_workset = __esm({
     init_workspace();
     init_workflow_store();
     init_workflows();
+    init_long_term();
     CONTINUATION_DETAIL_TOKEN_BUDGET = 20;
   }
 });
@@ -16816,7 +17765,7 @@ __export(current_facts_exports, {
 });
 import { execFileSync } from "child_process";
 import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
-import path19 from "path";
+import path20 from "path";
 function readTextIfExists(filePath) {
   try {
     if (!existsSync12(filePath)) return null;
@@ -16826,7 +17775,7 @@ function readTextIfExists(filePath) {
   }
 }
 function readPackageVersion(rootPath) {
-  const text = readTextIfExists(path19.join(rootPath, "package.json"));
+  const text = readTextIfExists(path20.join(rootPath, "package.json"));
   if (!text) return void 0;
   try {
     const parsed = JSON.parse(text);
@@ -16836,7 +17785,7 @@ function readPackageVersion(rootPath) {
   }
 }
 function readLatestChangelog(rootPath) {
-  const text = readTextIfExists(path19.join(rootPath, "CHANGELOG.md"));
+  const text = readTextIfExists(path20.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;
@@ -16906,7 +17855,7 @@ function detectStaleProgressNotes(input) {
   ];
   const notes = [];
   for (const relPath of candidates) {
-    const content = readTextIfExists(path19.join(input.rootPath, relPath));
+    const content = readTextIfExists(path20.join(input.rootPath, relPath));
     if (!content) continue;
     const parsed = parseProgressNote(content);
     const olderThanChangelog = compareDateStrings(parsed.lastUpdated, input.latestChangelog?.date);
@@ -17157,9 +18106,9 @@ async function inspectExternalCodeGraph(input) {
   return { health, quality: providerQuality({ mode, health }) };
 }
 function safeRelativePath(projectRoot, value, exclude) {
-  const path26 = safeText(value, 1024);
-  if (!path26 || isAbsolute(path26)) return void 0;
-  const absolute = resolve(projectRoot, path26);
+  const path27 = safeText(value, 1024);
+  if (!path27 || isAbsolute(path27)) return void 0;
+  const absolute = resolve(projectRoot, path27);
   const fromRoot = relative2(projectRoot, absolute);
   if (!fromRoot || fromRoot === ".." || fromRoot.startsWith("..\\") || fromRoot.startsWith("../") || isAbsolute(fromRoot)) return void 0;
   const normalized = normalizeCodePath(fromRoot);
@@ -17434,15 +18383,15 @@ function countLanguages(files) {
   }
   return [...counts.entries()].map(([language, files2]) => ({ language, files: files2 })).sort((a, b) => a.language.localeCompare(b.language));
 }
-function suggestedReadRank(path26) {
-  const normalized = path26.replace(/\\/g, "/");
+function suggestedReadRank(path27) {
+  const normalized = path27.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((path26) => !isCodeGraphExcludedPath(path26, exclude)).sort((a, b) => suggestedReadRank(a) - suggestedReadRank(b)).slice(0, limit);
+  return uniq(paths).filter((path27) => !isCodeGraphExcludedPath(path27, exclude)).sort((a, b) => suggestedReadRank(a) - suggestedReadRank(b)).slice(0, limit);
 }
 function collectGraph(store, projectId, observations2, exclude) {
   const files = store.listFiles(projectId);
@@ -17482,14 +18431,14 @@ function collectGraph(store, projectId, observations2, exclude) {
   }
   if (files.length === 0) {
     for (const observation of observations2) {
-      for (const path26 of observation.filesModified ?? []) {
-        if (!path26 || isCodeGraphExcludedPath(path26, exclude)) continue;
-        suggestedReads.push(path26);
+      for (const path27 of observation.filesModified ?? []) {
+        if (!path27 || isCodeGraphExcludedPath(path27, exclude)) continue;
+        suggestedReads.push(path27);
         sources.push({
           observationId: observation.id,
           title: observation.title,
           type: observation.type,
-          path: path26,
+          path: path27,
           status: "unbound",
           reason: "Recorded file hint; Code Memory refresh is pending."
         });
@@ -17558,8 +18507,8 @@ var compaction_checkpoint_store_exports = {};
 __export(compaction_checkpoint_store_exports, {
   CompactionCheckpointStore: () => CompactionCheckpointStore
 });
-import { createHash as createHash13, randomUUID as randomUUID8 } from "crypto";
-function optionalText5(value) {
+import { createHash as createHash13, randomUUID as randomUUID11 } from "crypto";
+function optionalText6(value) {
   return typeof value === "string" && value ? value : void 0;
 }
 function optionalNumber2(value) {
@@ -17613,15 +18562,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
@@ -17659,7 +18608,7 @@ var init_compaction_checkpoint_store = __esm({
         if (pending) return rowToCheckpoint(pending);
         const now3 = input.capturedAt ?? (/* @__PURE__ */ new Date()).toISOString();
         const checkpoint = {
-          id: randomUUID8(),
+          id: randomUUID11(),
           projectId: input.projectId,
           sessionId: input.sessionId,
           agent: input.agent,
@@ -17667,7 +18616,7 @@ var init_compaction_checkpoint_store = __esm({
           captureKind: "preflight",
           reason: safeReason(input.reason),
           sourceEvent: input.sourceEvent,
-          sourceKey: `pre:${randomUUID8()}`,
+          sourceKey: `pre:${randomUUID11()}`,
           transcriptAvailable: Boolean(input.transcriptAvailable),
           status: "active",
           preCapturedAt: now3,
@@ -17733,7 +18682,7 @@ var init_compaction_checkpoint_store = __esm({
           return this.get(checkpoint2.id);
         }
         const checkpoint = {
-          id: randomUUID8(),
+          id: randomUUID11(),
           projectId: input.projectId,
           sessionId: input.sessionId,
           agent: input.agent,
@@ -17868,7 +18817,7 @@ __export(auto_context_exports, {
   formatLegacyAutoProjectContextPrompt: () => formatLegacyAutoProjectContextPrompt
 });
 import { existsSync as existsSync14, statSync as statSync3 } from "fs";
-import path20 from "path";
+import path21 from "path";
 function activeProjectObservations(observations2, projectId) {
   return observations2.filter((obs) => obs.projectId === projectId && (obs.status ?? "active") === "active");
 }
@@ -18103,6 +19052,7 @@ async function buildAutoProjectContext(input) {
       stale: overview.freshness.stale
     },
     runtimeCautions,
+    ...input.reader ? { reader: input.reader } : {},
     ...input.deliveryTarget ? { deliveryTarget: input.deliveryTarget } : {}
   });
   return {
@@ -18147,7 +19097,7 @@ function dedupeSourcesByObservation(sources) {
 function existingLensCandidates(rootPath, lens) {
   const out = [];
   for (const candidate of lensPathCandidates(lens)) {
-    const absolute = path20.join(rootPath, candidate);
+    const absolute = path21.join(rootPath, candidate);
     try {
       if (!existsSync14(absolute)) continue;
       const stat = statSync3(absolute);
@@ -18257,7 +19207,7 @@ function formatAutoProjectContextSummary(context) {
     "Start here"
   ].filter(Boolean);
   if (startHere.length > 0) {
-    startHere.forEach((path26, index) => lines.push(`${index + 1}. ${path26}`));
+    startHere.forEach((path27, index) => lines.push(`${index + 1}. ${path27}`));
   } else {
     lines.push("- no code-bound reads yet; inspect the task-relevant files directly");
   }
@@ -18266,6 +19216,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");
@@ -18315,7 +19273,7 @@ function formatLegacyAutoProjectContextPrompt(context) {
   if (startHere.length === 0) {
     lines.push("- no code-bound reads yet; inspect the task-relevant code directly");
   } else {
-    startHere.forEach((path26, index) => lines.push(`${index + 1}. ${path26}`));
+    startHere.forEach((path27, index) => lines.push(`${index + 1}. ${path27}`));
   }
   const { reliableSources, cautionSources, hiddenReliableCount, hiddenCautionCount } = lensSourceSets(context);
   lines.push("", "Reliable memory");
@@ -18566,6 +19524,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 };
@@ -18576,7 +19535,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((path26) => !isCodeGraphExcludedPath(path26)).slice(0, 5);
+  const visibleSuggestedReads = pack.suggestedReads.filter((path27) => !isCodeGraphExcludedPath(path27)).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})`);
@@ -18600,7 +19559,7 @@ function buildContextPackPrompt(pack) {
   }
   lines.push("", "## Suggested Next Reads");
   if (visibleSuggestedReads.length === 0) lines.push("- none");
-  visibleSuggestedReads.forEach((path26, index) => lines.push(`${index + 1}. ${path26}`));
+  visibleSuggestedReads.forEach((path27, index) => lines.push(`${index + 1}. ${path27}`));
   lines.push("", "## Suggested Verification");
   if (pack.suggestedVerification.length === 0) lines.push("- none");
   for (const command of pack.suggestedVerification) lines.push(`- ${command}`);
@@ -18992,9 +19951,9 @@ __export(team_store_exports, {
   isTeamStoreInitialized: () => isTeamStoreInitialized,
   resetTeamStore: () => resetTeamStore
 });
-import { randomUUID as randomUUID9 } from "crypto";
-import path21 from "path";
-import fs15 from "fs";
+import { randomUUID as randomUUID12 } from "crypto";
+import path22 from "path";
+import fs16 from "fs";
 function getTeamStore() {
   if (!_teamStore) {
     throw new Error("[memorix] TeamStore not initialized \u2014 call initTeamStore() first");
@@ -19281,7 +20240,7 @@ var init_team_store = __esm({
        * reactivate it (preserving agent_id). Otherwise create a new one.
        */
       registerAgent(input) {
-        const instanceId = input.instanceId || randomUUID9();
+        const instanceId = input.instanceId || randomUUID12();
         const now3 = Date.now();
         const existing = this.stmtAgentFindByInstance.get(
           input.projectId,
@@ -19307,7 +20266,7 @@ var init_team_store = __esm({
           this.eventBus?.emit("agent:joined", { agentId: row2.agent_id, projectId: input.projectId, agentType: input.agentType });
           return row2;
         }
-        const agentId = randomUUID9();
+        const agentId = randomUUID12();
         this.stmtAgentUpsert.run({
           agent_id: agentId,
           project_id: input.projectId,
@@ -19409,7 +20368,7 @@ var init_team_store = __esm({
             return { error: `Recipient agent '${input.recipientAgentId}' not found \u2014 cannot send to unknown agent` };
           }
         }
-        const id = randomUUID9();
+        const id = randomUUID12();
         const now3 = Date.now();
         const row = {
           id,
@@ -19459,7 +20418,7 @@ var init_team_store = __esm({
       // Task Operations (with atomic claim semantics)
       // ═══════════════════════════════════════════════════════════════════
       createTask(input) {
-        const taskId = randomUUID9();
+        const taskId = randomUUID12();
         const now3 = Date.now();
         const row = {
           task_id: taskId,
@@ -19684,19 +20643,19 @@ var init_team_store = __esm({
         const agentCount = this.db.prepare(`SELECT COUNT(*) AS cnt FROM team_agents`).get();
         if (agentCount.cnt > 0) return;
         const candidates = [
-          path21.join(this.dataDir, "team-state.json"),
-          path21.join(this.dataDir, "..", "team-state.json")
+          path22.join(this.dataDir, "team-state.json"),
+          path22.join(this.dataDir, "..", "team-state.json")
         ];
         let jsonPath = null;
         for (const p of candidates) {
-          if (fs15.existsSync(p)) {
+          if (fs16.existsSync(p)) {
             jsonPath = p;
             break;
           }
         }
         if (!jsonPath) return;
         try {
-          const raw = fs15.readFileSync(jsonPath, "utf-8");
+          const raw = fs16.readFileSync(jsonPath, "utf-8");
           const snap = JSON.parse(raw);
           if (snap.version !== 1) return;
           console.error(`[memorix] Migrating team-state.json to SQLite...`);
@@ -19731,7 +20690,7 @@ var init_team_store = __esm({
               for (const [agentId, msgs] of Object.entries(snap.messages.inboxes)) {
                 for (const msg of msgs) {
                   this.stmtMsgInsert.run({
-                    id: msg.id ?? randomUUID9(),
+                    id: msg.id ?? randomUUID12(),
                     project_id: "migrated",
                     sender_agent_id: msg.from ?? "unknown",
                     recipient_agent_id: msg.to === "__broadcast__" ? null : msg.to ?? agentId,
@@ -19790,7 +20749,7 @@ var init_team_store = __esm({
             `[memorix] Team migration complete: ${agentsMigrated} agents, ${messagesMigrated} messages, ${tasksMigrated} tasks, ${locksMigrated} locks.`
           );
           try {
-            fs15.renameSync(jsonPath, jsonPath + ".migrated");
+            fs16.renameSync(jsonPath, jsonPath + ".migrated");
           } catch {
           }
         } catch (err) {
@@ -19825,7 +20784,7 @@ var init_team_store = __esm({
        * Uses projectId derived from the dataDir path.
        */
       seedDefaultRoles(dataDir) {
-        const projectId = path21.basename(path21.resolve(dataDir, ".."));
+        const projectId = path22.basename(path22.resolve(dataDir, ".."));
         const count2 = this.stmtRoleCountByProject.get(projectId).cnt;
         if (count2 > 0) return;
         const now3 = Date.now();
@@ -20839,8 +21798,8 @@ __export(server_exports, {
   startDashboard: () => startDashboard
 });
 import { createServer } from "http";
-import { promises as fs16 } from "fs";
-import path22 from "path";
+import { promises as fs17 } from "fs";
+import path23 from "path";
 import { exec } from "child_process";
 function sendJson(res, data, status = 200) {
   res.writeHead(status, {
@@ -21318,7 +22277,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 = path22.join(baseDir, ".project-aliases.json");
+          const registryPath = path23.join(baseDir, ".project-aliases.json");
           const raw = await fsP.readFile(registryPath, "utf-8");
           const registry = JSON.parse(raw);
           aliasGroups = registry.groups || [];
@@ -21433,14 +22392,14 @@ async function serveStatic(req, res, staticDir) {
   if (urlPath === "/" || !urlPath.includes(".")) {
     urlPath = "/index.html";
   }
-  const filePath = path22.join(staticDir, urlPath);
+  const filePath = path23.join(staticDir, urlPath);
   if (!filePath.startsWith(staticDir)) {
     sendError(res, "Forbidden", 403);
     return;
   }
   try {
-    const data = await fs16.readFile(filePath);
-    const ext = path22.extname(filePath);
+    const data = await fs17.readFile(filePath);
+    const ext = path23.extname(filePath);
     res.writeHead(200, {
       "Content-Type": MIME_TYPES[ext] || "application/octet-stream",
       "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0",
@@ -21450,7 +22409,7 @@ async function serveStatic(req, res, staticDir) {
     res.end(data);
   } catch {
     try {
-      const indexData = await fs16.readFile(path22.join(staticDir, "index.html"));
+      const indexData = await fs17.readFile(path23.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",
@@ -22163,7 +23122,7 @@ function collectCodeMemory(opts) {
     if (status.indexedAt) lines.push(`Last scan: ${status.indexedAt}`);
     if (suggestedReads.length > 0) {
       lines.push("Suggested reads:");
-      suggestedReads.forEach((path26, index) => lines.push(`${index + 1}. ${path26}`));
+      suggestedReads.forEach((path27, index) => lines.push(`${index + 1}. ${path27}`));
     }
     return lines.join("\n");
   } catch {
@@ -22188,7 +23147,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 {
@@ -22246,7 +23205,7 @@ function seedAutonomousPipeline(teamStore, projectId, config, opts) {
   const maxIterations = config.maxIterations ?? 3;
   const taskBudget = config.taskBudget ?? 15;
   const structuredPlan = opts?.structuredPlan ?? true;
-  const pipelineId = randomUUID10();
+  const pipelineId = randomUUID13();
   const meta = {
     plannerType: "plan",
     pipelineId,
@@ -22936,15 +23895,15 @@ __export(audit_exports, {
   removeFile: () => removeFile,
   saveAudit: () => saveAudit
 });
-import * as fs17 from "fs/promises";
-import * as path23 from "path";
+import * as fs18 from "fs/promises";
+import * as path24 from "path";
 import { homedir as homedir24 } from "os";
 function getAuditFilePath() {
-  return process.env.MEMORIX_AUDIT_FILE || path23.join(homedir24(), ".memorix", "audit.json");
+  return process.env.MEMORIX_AUDIT_FILE || path24.join(homedir24(), ".memorix", "audit.json");
 }
 async function loadAudit() {
   try {
-    const content = await fs17.readFile(getAuditFilePath(), "utf-8");
+    const content = await fs18.readFile(getAuditFilePath(), "utf-8");
     return JSON.parse(content);
   } catch {
     return {
@@ -22955,9 +23914,9 @@ async function loadAudit() {
 }
 async function saveAudit(data) {
   const auditFile = getAuditFilePath();
-  const dir = path23.dirname(auditFile);
-  await fs17.mkdir(dir, { recursive: true });
-  await fs17.writeFile(auditFile, JSON.stringify(data, null, 2), "utf-8");
+  const dir = path24.dirname(auditFile);
+  await fs18.mkdir(dir, { recursive: true });
+  await fs18.writeFile(auditFile, JSON.stringify(data, null, 2), "utf-8");
 }
 function getProjectId(projectRoot) {
   try {
@@ -23039,8 +23998,8 @@ __export(installers_exports, {
   resolveOpenCodeHookCommand: () => resolveOpenCodeHookCommand,
   uninstallHooks: () => uninstallHooks
 });
-import * as fs18 from "fs/promises";
-import * as path24 from "path";
+import * as fs19 from "fs/promises";
+import * as path25 from "path";
 import * as os3 from "os";
 import { execSync as execSync3 } from "child_process";
 function resolveHookCommand() {
@@ -23056,7 +24015,7 @@ function resolveWindowsMemorixShim() {
       stdio: ["ignore", "pipe", "ignore"],
       windowsHide: true
     }));
-    return output.split(/\r?\n/).map((candidate) => candidate.trim()).find((candidate) => path24.isAbsolute(candidate)) ?? null;
+    return output.split(/\r?\n/).map((candidate) => candidate.trim()).find((candidate) => path25.isAbsolute(candidate)) ?? null;
   } catch {
     return null;
   }
@@ -23251,9 +24210,9 @@ async function installOfficialSkillsForAgent(agent, projectRoot, global = false)
   const root = global ? os3.homedir() : projectRoot;
   const skillPaths = [];
   for (const skillEntry of OFFICIAL_MEMORIX_SKILLS) {
-    const skillPath = path24.join(root, relativeDir, skillEntry.name, "SKILL.md");
-    await fs18.mkdir(path24.dirname(skillPath), { recursive: true });
-    await fs18.writeFile(skillPath, skillEntry.content, "utf-8");
+    const skillPath = path25.join(root, relativeDir, skillEntry.name, "SKILL.md");
+    await fs19.mkdir(path25.dirname(skillPath), { recursive: true });
+    await fs19.writeFile(skillPath, skillEntry.content, "utf-8");
     skillPaths.push(skillPath);
     try {
       const { recordFile: recordFile2 } = await Promise.resolve().then(() => (init_audit(), audit_exports));
@@ -23466,124 +24425,124 @@ async function installOpenCodeSkills(projectRoot, global = false) {
 function getProjectConfigPath(agent, projectRoot) {
   switch (agent) {
     case "claude":
-      return path24.join(projectRoot, ".claude", "settings.local.json");
+      return path25.join(projectRoot, ".claude", "settings.local.json");
     case "copilot":
-      return path24.join(projectRoot, ".github", "hooks", "memorix.json");
+      return path25.join(projectRoot, ".github", "hooks", "memorix.json");
     case "windsurf":
-      return path24.join(projectRoot, ".windsurf", "hooks.json");
+      return path25.join(projectRoot, ".windsurf", "hooks.json");
     case "cursor":
-      return path24.join(projectRoot, ".cursor", "hooks.json");
+      return path25.join(projectRoot, ".cursor", "hooks.json");
     case "kiro":
-      return path24.join(projectRoot, ".kiro", "hooks", "memorix-agent-stop.kiro.hook");
+      return path25.join(projectRoot, ".kiro", "hooks", "memorix-agent-stop.kiro.hook");
     case "codex":
-      return path24.join(projectRoot, "AGENTS.md");
+      return path25.join(projectRoot, "AGENTS.md");
     case "trae":
-      return path24.join(projectRoot, ".trae", "rules", "project_rules.md");
+      return path25.join(projectRoot, ".trae", "rules", "project_rules.md");
     case "opencode":
-      return path24.join(projectRoot, ".opencode", "plugins", "memorix.js");
+      return path25.join(projectRoot, ".opencode", "plugins", "memorix.js");
     case "pi":
-      return path24.join(projectRoot, ".pi", "packages", "memorix", "extensions", "memorix.js");
+      return path25.join(projectRoot, ".pi", "packages", "memorix", "extensions", "memorix.js");
     case "openclaw":
-      return path24.join(os3.homedir(), ".openclaw", "extensions", "memorix", "hooks", "memorix", "HOOK.md");
+      return path25.join(os3.homedir(), ".openclaw", "extensions", "memorix", "hooks", "memorix", "HOOK.md");
     case "hermes":
-      return path24.join(os3.homedir(), ".hermes", "plugins", "memorix", "plugin.yaml");
+      return path25.join(os3.homedir(), ".hermes", "plugins", "memorix", "plugin.yaml");
     case "omp":
-      return path24.join(projectRoot, ".omp", "packages", "memorix", "extensions", "memorix.js");
+      return path25.join(projectRoot, ".omp", "packages", "memorix", "extensions", "memorix.js");
     case "antigravity":
-      return path24.join(projectRoot, ".agents", "hooks.json");
+      return path25.join(projectRoot, ".agents", "hooks.json");
     case "gemini-cli":
-      return path24.join(projectRoot, ".gemini", "settings.json");
+      return path25.join(projectRoot, ".gemini", "settings.json");
     default:
-      return path24.join(projectRoot, ".memorix", "hooks.json");
+      return path25.join(projectRoot, ".memorix", "hooks.json");
   }
 }
 function getGlobalConfigPath(agent) {
   const home = os3.homedir();
   switch (agent) {
     case "claude":
-      return path24.join(home, ".claude", "settings.json");
+      return path25.join(home, ".claude", "settings.json");
     case "copilot":
       return "";
     case "windsurf":
-      return path24.join(home, ".codeium", "windsurf", "hooks.json");
+      return path25.join(home, ".codeium", "windsurf", "hooks.json");
     case "cursor":
-      return path24.join(home, ".cursor", "hooks.json");
+      return path25.join(home, ".cursor", "hooks.json");
     case "antigravity":
-      return path24.join(home, ".gemini", "config", "hooks.json");
+      return path25.join(home, ".gemini", "config", "hooks.json");
     case "gemini-cli":
-      return path24.join(home, ".gemini", "settings.json");
+      return path25.join(home, ".gemini", "settings.json");
     case "opencode":
-      return path24.join(home, ".config", "opencode", "plugins", "memorix.js");
+      return path25.join(home, ".config", "opencode", "plugins", "memorix.js");
     case "pi":
-      return path24.join(home, ".pi", "agent", "packages", "memorix", "extensions", "memorix.js");
+      return path25.join(home, ".pi", "agent", "packages", "memorix", "extensions", "memorix.js");
     case "openclaw":
-      return path24.join(home, ".openclaw", "extensions", "memorix", "hooks", "memorix", "HOOK.md");
+      return path25.join(home, ".openclaw", "extensions", "memorix", "hooks", "memorix", "HOOK.md");
     case "hermes":
-      return path24.join(home, ".hermes", "plugins", "memorix", "plugin.yaml");
+      return path25.join(home, ".hermes", "plugins", "memorix", "plugin.yaml");
     case "omp":
-      return path24.join(home, ".omp", "agent", "packages", "memorix", "extensions", "memorix.js");
+      return path25.join(home, ".omp", "agent", "packages", "memorix", "extensions", "memorix.js");
     case "trae":
-      return path24.join(home, ".trae", "rules", "project_rules.md");
+      return path25.join(home, ".trae", "rules", "project_rules.md");
     default:
-      return path24.join(home, ".memorix", "hooks.json");
+      return path25.join(home, ".memorix", "hooks.json");
   }
 }
 function getAgentRulesPath(agent, root, global = false) {
   if (global) {
     switch (agent) {
       case "windsurf":
-        return path24.join(root, ".codeium", "windsurf", "rules", "memorix.md");
+        return path25.join(root, ".codeium", "windsurf", "rules", "memorix.md");
       case "cursor":
-        return path24.join(root, ".cursor", "rules", "memorix.mdc");
+        return path25.join(root, ".cursor", "rules", "memorix.mdc");
       case "claude":
-        return path24.join(root, ".claude", "CLAUDE.md");
+        return path25.join(root, ".claude", "CLAUDE.md");
       case "codex":
-        return path24.join(root, ".codex", "AGENTS.md");
+        return path25.join(root, ".codex", "AGENTS.md");
       case "kiro":
-        return path24.join(root, ".kiro", "steering", "memorix.md");
+        return path25.join(root, ".kiro", "steering", "memorix.md");
       case "opencode":
-        return path24.join(root, ".config", "opencode", "AGENTS.md");
+        return path25.join(root, ".config", "opencode", "AGENTS.md");
       case "antigravity":
       case "gemini-cli":
-        return path24.join(root, ".gemini", "GEMINI.md");
+        return path25.join(root, ".gemini", "GEMINI.md");
       case "trae":
-        return path24.join(root, ".trae", "rules", "project_rules.md");
+        return path25.join(root, ".trae", "rules", "project_rules.md");
       default:
-        return path24.join(root, ".agent", "rules", "memorix.md");
+        return path25.join(root, ".agent", "rules", "memorix.md");
     }
   }
   switch (agent) {
     case "windsurf":
-      return path24.join(root, ".windsurf", "rules", "memorix.md");
+      return path25.join(root, ".windsurf", "rules", "memorix.md");
     case "cursor":
-      return path24.join(root, ".cursor", "rules", "memorix.mdc");
+      return path25.join(root, ".cursor", "rules", "memorix.mdc");
     case "claude":
-      return path24.join(root, "CLAUDE.md");
+      return path25.join(root, "CLAUDE.md");
     case "copilot":
-      return path24.join(root, ".github", "copilot-instructions.md");
+      return path25.join(root, ".github", "copilot-instructions.md");
     case "codex":
-      return path24.join(root, "AGENTS.md");
+      return path25.join(root, "AGENTS.md");
     case "kiro":
-      return path24.join(root, ".kiro", "steering", "memorix.md");
+      return path25.join(root, ".kiro", "steering", "memorix.md");
     case "opencode":
-      return path24.join(root, "AGENTS.md");
+      return path25.join(root, "AGENTS.md");
     case "antigravity":
     case "gemini-cli":
-      return path24.join(root, "GEMINI.md");
+      return path25.join(root, "GEMINI.md");
     case "trae":
-      return path24.join(root, ".trae", "rules", "project_rules.md");
+      return path25.join(root, ".trae", "rules", "project_rules.md");
     default:
-      return path24.join(root, ".agent", "rules", "memorix.md");
+      return path25.join(root, ".agent", "rules", "memorix.md");
   }
 }
 async function detectCopilotExtension(home) {
   const extDirs = [
-    path24.join(home, ".vscode", "extensions"),
-    path24.join(home, ".vscode-insiders", "extensions")
+    path25.join(home, ".vscode", "extensions"),
+    path25.join(home, ".vscode-insiders", "extensions")
   ];
   for (const extDir of extDirs) {
     try {
-      const entries = await fs18.readdir(extDir);
+      const entries = await fs19.readdir(extDir);
       if (entries.some((e) => e.startsWith("github.copilot-"))) {
         return true;
       }
@@ -23595,21 +24554,21 @@ async function detectCopilotExtension(home) {
 async function detectInstalledAgents() {
   const agents = [];
   const home = os3.homedir();
-  const claudeDir = path24.join(home, ".claude");
+  const claudeDir = path25.join(home, ".claude");
   try {
-    await fs18.access(claudeDir);
+    await fs19.access(claudeDir);
     agents.push("claude");
   } catch {
   }
-  const windsurfDir = path24.join(home, ".codeium", "windsurf");
+  const windsurfDir = path25.join(home, ".codeium", "windsurf");
   try {
-    await fs18.access(windsurfDir);
+    await fs19.access(windsurfDir);
     agents.push("windsurf");
   } catch {
   }
-  const cursorDir = path24.join(home, ".cursor");
+  const cursorDir = path25.join(home, ".cursor");
   try {
-    await fs18.access(cursorDir);
+    await fs19.access(cursorDir);
     agents.push("cursor");
   } catch {
   }
@@ -23617,21 +24576,21 @@ async function detectInstalledAgents() {
   if (copilotDetected) {
     agents.push("copilot");
   }
-  const kiroConfig = path24.join(home, ".kiro");
+  const kiroConfig = path25.join(home, ".kiro");
   try {
-    await fs18.access(kiroConfig);
+    await fs19.access(kiroConfig);
     agents.push("kiro");
   } catch {
   }
-  const codexDir = path24.join(home, ".codex");
+  const codexDir = path25.join(home, ".codex");
   try {
-    await fs18.access(codexDir);
+    await fs19.access(codexDir);
     agents.push("codex");
   } catch {
   }
-  const antigravityDir = path24.join(home, ".gemini", "config");
+  const antigravityDir = path25.join(home, ".gemini", "config");
   try {
-    await fs18.access(antigravityDir);
+    await fs19.access(antigravityDir);
     agents.push("antigravity");
   } catch {
   }
@@ -23642,15 +24601,15 @@ async function detectInstalledAgents() {
     agents.push("gemini-cli");
   } catch {
   }
-  const opencodeDir = path24.join(home, ".config", "opencode");
+  const opencodeDir = path25.join(home, ".config", "opencode");
   try {
-    await fs18.access(opencodeDir);
+    await fs19.access(opencodeDir);
     agents.push("opencode");
   } catch {
   }
-  const traeDir = path24.join(home, ".trae");
+  const traeDir = path25.join(home, ".trae");
   try {
-    await fs18.access(traeDir);
+    await fs19.access(traeDir);
     agents.push("trae");
   } catch {
   }
@@ -23684,7 +24643,7 @@ async function installHooks(agent, projectRoot, global = false) {
       try {
         const { access: access2, unlink: unlink2 } = await import("fs/promises");
         await access2(entry.path);
-        const basename3 = path24.basename(entry.path);
+        const basename3 = path25.basename(entry.path);
         if (basename3 === "AGENTS.md" || basename3 === "GEMINI.md" || basename3 === "CONTEXT.md") {
           continue;
         }
@@ -23739,8 +24698,8 @@ async function installHooks(agent, projectRoot, global = false) {
     case "opencode": {
       const pluginContent = generateOpenCodePlugin();
       const pluginPath = global ? getGlobalConfigPath(agent) : getProjectConfigPath(agent, projectRoot);
-      await fs18.mkdir(path24.dirname(pluginPath), { recursive: true });
-      await fs18.writeFile(pluginPath, pluginContent, "utf-8");
+      await fs19.mkdir(path25.dirname(pluginPath), { recursive: true });
+      await fs19.writeFile(pluginPath, pluginContent, "utf-8");
       try {
         const { recordFile: recordFile2 } = await Promise.resolve().then(() => (init_audit(), audit_exports));
         await recordFile2(projectRoot, "hook", pluginPath, agent);
@@ -23769,14 +24728,14 @@ async function installHooks(agent, projectRoot, global = false) {
     default:
       generated = generateClaudeConfig();
   }
-  await fs18.mkdir(path24.dirname(configPath), { recursive: true });
+  await fs19.mkdir(path25.dirname(configPath), { recursive: true });
   if (agent === "kiro") {
     const hookFiles = generateKiroHookFiles();
-    const hooksDir = path24.join(path24.dirname(configPath));
-    await fs18.mkdir(hooksDir, { recursive: true });
+    const hooksDir = path25.join(path25.dirname(configPath));
+    await fs19.mkdir(hooksDir, { recursive: true });
     for (const hf of hookFiles) {
-      const hookPath = path24.join(hooksDir, hf.filename);
-      await fs18.writeFile(hookPath, hf.content, "utf-8");
+      const hookPath = path25.join(hooksDir, hf.filename);
+      await fs19.writeFile(hookPath, hf.content, "utf-8");
       try {
         const { recordFile: recordFile2 } = await Promise.resolve().then(() => (init_audit(), audit_exports));
         await recordFile2(projectRoot, "hook", hookPath, agent);
@@ -23786,7 +24745,7 @@ async function installHooks(agent, projectRoot, global = false) {
   } else {
     let existing = {};
     try {
-      const content = await fs18.readFile(configPath, "utf-8");
+      const content = await fs19.readFile(configPath, "utf-8");
       existing = JSON.parse(content);
     } catch {
     }
@@ -23821,7 +24780,7 @@ async function installHooks(agent, projectRoot, global = false) {
       const h = merged.hooks;
       if (h) delete h.preToolUse;
     }
-    await fs18.writeFile(configPath, JSON.stringify(merged, null, 2), "utf-8");
+    await fs19.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);
@@ -23869,18 +24828,18 @@ async function installAgentRules(agent, projectRoot, global = false) {
   const rulesRoot = global ? os3.homedir() : projectRoot;
   const rulesPath = getAgentRulesPath(agent, rulesRoot, global);
   try {
-    await fs18.mkdir(path24.dirname(rulesPath), { recursive: true });
+    await fs19.mkdir(path25.dirname(rulesPath), { recursive: true });
     if (agent === "claude" || agent === "codex" || agent === "opencode" || agent === "antigravity" || agent === "gemini-cli") {
       try {
-        const existing = await fs18.readFile(rulesPath, "utf-8");
-        await fs18.writeFile(rulesPath, mergeMemorixRulesContent(existing, rulesContent), "utf-8");
+        const existing = await fs19.readFile(rulesPath, "utf-8");
+        await fs19.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 fs18.writeFile(rulesPath, rulesContent, "utf-8");
+        await fs19.writeFile(rulesPath, rulesContent, "utf-8");
         try {
           const { recordFile: recordFile2 } = await Promise.resolve().then(() => (init_audit(), audit_exports));
           await recordFile2(projectRoot, "rule", rulesPath, agent);
@@ -23889,9 +24848,9 @@ async function installAgentRules(agent, projectRoot, global = false) {
       }
     } else {
       try {
-        await fs18.access(rulesPath);
+        await fs19.access(rulesPath);
       } catch {
-        await fs18.writeFile(rulesPath, rulesContent, "utf-8");
+        await fs19.writeFile(rulesPath, rulesContent, "utf-8");
         try {
           const { recordFile: recordFile2 } = await Promise.resolve().then(() => (init_audit(), audit_exports));
           await recordFile2(projectRoot, "rule", rulesPath, agent);
@@ -23981,6 +24940,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).",
     "",
@@ -24017,16 +24978,16 @@ async function uninstallHooks(agent, projectRoot, global = false) {
   let success = false;
   try {
     if (agent === "kiro" || agent === "opencode") {
-      await fs18.unlink(configPath);
+      await fs19.unlink(configPath);
       success = true;
     } else {
-      const content = await fs18.readFile(configPath, "utf-8");
+      const content = await fs19.readFile(configPath, "utf-8");
       const config = JSON.parse(content);
       delete config.hooks;
       if (Object.keys(config).length === 0) {
-        await fs18.unlink(configPath);
+        await fs19.unlink(configPath);
       } else {
-        await fs18.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
+        await fs19.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
       }
       success = true;
     }
@@ -24039,10 +25000,10 @@ async function uninstallHooks(agent, projectRoot, global = false) {
     const agentFiles = prevFiles.filter((e) => e.agent === agent);
     for (const entry of agentFiles) {
       try {
-        const basename3 = path24.basename(entry.path);
+        const basename3 = path25.basename(entry.path);
         if (basename3 === "AGENTS.md" || basename3 === "GEMINI.md" || basename3 === "CONTEXT.md") {
           try {
-            const content = await fs18.readFile(entry.path, "utf-8");
+            const content = await fs19.readFile(entry.path, "utf-8");
             const memorixStart = content.indexOf("# Memorix");
             if (memorixStart >= 0) {
               const afterMemorix = content.substring(memorixStart);
@@ -24054,9 +25015,9 @@ async function uninstallHooks(agent, projectRoot, global = false) {
               }
               const cleaned = (before + "\n" + after).trim();
               if (cleaned.length === 0) {
-                await fs18.unlink(entry.path);
+                await fs19.unlink(entry.path);
               } else {
-                await fs18.writeFile(entry.path, cleaned + "\n", "utf-8");
+                await fs19.writeFile(entry.path, cleaned + "\n", "utf-8");
               }
             }
           } catch {
@@ -24065,7 +25026,7 @@ async function uninstallHooks(agent, projectRoot, global = false) {
           auditCleaned = true;
           continue;
         }
-        await fs18.unlink(entry.path);
+        await fs19.unlink(entry.path);
         await removeFile2(projectRoot, entry.path);
         auditCleaned = true;
       } catch {
@@ -24077,14 +25038,14 @@ async function uninstallHooks(agent, projectRoot, global = false) {
   if (success) {
     try {
       const { rm } = await import("fs/promises");
-      const dir = path24.dirname(configPath);
+      const dir = path25.dirname(configPath);
       let current = dir;
       for (let i = 0; i < 3; i++) {
         try {
-          const entries = await fs18.readdir(current);
+          const entries = await fs19.readdir(current);
           if (entries.length === 0) {
             await rm(current, { recursive: true });
-            current = path24.dirname(current);
+            current = path25.dirname(current);
           } else {
             break;
           }
@@ -24108,12 +25069,12 @@ async function getHookStatus(projectRoot) {
     let usedPath = projectPath;
     const verifiedByDefault = agent !== "opencode" && agent !== "pi";
     try {
-      await fs18.access(projectPath);
+      await fs19.access(projectPath);
       installed = true;
     } catch {
       if (globalPath) {
         try {
-          await fs18.access(globalPath);
+          await fs19.access(globalPath);
           installed = true;
           usedPath = globalPath;
         } catch {
@@ -24122,7 +25083,7 @@ async function getHookStatus(projectRoot) {
     }
     if (installed && agent === "opencode") {
       try {
-        const content = await fs18.readFile(usedPath, "utf-8");
+        const content = await fs19.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;
@@ -24153,11 +25114,11 @@ var init_installers = __esm({
     init_official_skills();
     OPENCODE_PLUGIN_VERSION = 7;
     AGENT_SKILL_DIRS = {
-      cursor: { project: path24.join(".cursor", "skills"), global: path24.join(".cursor", "skills") },
-      windsurf: { project: path24.join(".windsurf", "skills"), global: path24.join(".windsurf", "skills") },
-      kiro: { project: path24.join(".kiro", "skills"), global: path24.join(".kiro", "skills") },
-      opencode: { project: path24.join(".opencode", "skills"), global: path24.join(".config", "opencode", "skills") },
-      trae: { project: path24.join(".trae", "skills"), global: path24.join(".trae", "skills") }
+      cursor: { project: path25.join(".cursor", "skills"), global: path25.join(".cursor", "skills") },
+      windsurf: { project: path25.join(".windsurf", "skills"), global: path25.join(".windsurf", "skills") },
+      kiro: { project: path25.join(".kiro", "skills"), global: path25.join(".kiro", "skills") },
+      opencode: { project: path25.join(".opencode", "skills"), global: path25.join(".config", "opencode", "skills") },
+      trae: { project: path25.join(".trae", "skills"), global: path25.join(".trae", "skills") }
     };
     PACKAGE_OWNED_HOOK_AGENTS = /* @__PURE__ */ new Set(["openclaw", "hermes", "omp"]);
   }
@@ -24171,9 +25132,9 @@ __export(hooks_path_exports, {
   resolveHooksDir: () => resolveHooksDir
 });
 import { existsSync as existsSync17, readFileSync as readFileSync13, statSync as statSync4, mkdirSync as mkdirSync4 } from "fs";
-import path25 from "path";
+import path26 from "path";
 function resolveGitDir(projectRoot) {
-  const dotGit = path25.join(projectRoot, ".git");
+  const dotGit = path26.join(projectRoot, ".git");
   if (!existsSync17(dotGit)) return null;
   const stat = statSync4(dotGit);
   if (stat.isDirectory()) {
@@ -24185,7 +25146,7 @@ function resolveGitDir(projectRoot) {
       const match = content.match(/^gitdir:\s*(.+)$/);
       if (match) {
         const gitdir = match[1].trim();
-        const resolved = path25.isAbsolute(gitdir) ? gitdir : path25.resolve(projectRoot, gitdir);
+        const resolved = path26.isAbsolute(gitdir) ? gitdir : path26.resolve(projectRoot, gitdir);
         if (existsSync17(resolved)) {
           return resolved;
         }
@@ -24198,10 +25159,10 @@ function resolveGitDir(projectRoot) {
 function resolveHooksDir(projectRoot) {
   const gitDir = resolveGitDir(projectRoot);
   if (!gitDir) return null;
-  const hooksDir = path25.join(gitDir, "hooks");
+  const hooksDir = path26.join(gitDir, "hooks");
   return {
     hooksDir,
-    hookPath: path25.join(hooksDir, "post-commit")
+    hookPath: path26.join(hooksDir, "post-commit")
   };
 }
 function ensureHooksDir(projectRoot) {
@@ -27353,10 +28314,10 @@ var WorkspaceSyncEngine = class _WorkspaceSyncEngine {
         pathsToCheck.push(join19(homedir21(), ".gemini", "antigravity", "mcp_config.json"));
       }
       const merged = /* @__PURE__ */ new Map();
-      for (const path26 of pathsToCheck) {
-        if (existsSync10(path26)) {
+      for (const path27 of pathsToCheck) {
+        if (existsSync10(path27)) {
           try {
-            const content = readFileSync7(path26, "utf-8");
+            const content = readFileSync7(path27, "utf-8");
             const servers = adapter.parse(content);
             for (const s of servers) {
               if (!merged.has(s.name)) merged.set(s.name, s);
@@ -28147,7 +29108,7 @@ The path should point to a directory containing a .git folder.`
   };
   const server = existingServer ?? new McpServer({
     name: "memorix",
-    version: true ? "1.2.10" : "1.0.1"
+    version: true ? "1.3.0" : "1.0.1"
   });
   const originalRegisterTool = server.registerTool.bind(server);
   server.registerTool = ((name, ...args) => {
@@ -28227,7 +29188,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: z2.string().describe('The entity this observation belongs to (e.g., "auth-module", "port-config")'),
         type: z2.enum(OBSERVATION_TYPES).describe("Observation type for classification"),
@@ -28249,30 +29210,43 @@ The path should point to a directory containing a .git folder.`
         visibility: z2.enum(["personal", "project", "team"]).optional().describe(
           "Retrieval scope. Project is the normal shared default; personal/team require memorix_session_start with joinTeam=true."
         ),
+        longTerm: z2.object({
+          kind: z2.enum(["episodic", "semantic", "procedural"]).describe("Cognitive kind for an additional long-term candidate."),
+          scope: z2.enum(["project", "user", "team"]).optional().default("project").describe("Long-term scope. User capture is private source evidence and needs a bound agent identity."),
+          tags: z2.array(z2.string()).optional().describe("Small set of retrieval tags for the candidate."),
+          applicability: z2.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: z2.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;
@@ -28294,7 +29268,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();
@@ -28445,7 +29419,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)}`,
@@ -28602,9 +29576,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}`] }
           ]);
@@ -28621,7 +29619,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 {
@@ -28711,7 +29709,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}`
               }
             ]
           };
@@ -29084,7 +30082,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 {
@@ -29758,7 +30757,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: z2.array(z2.number()).optional().describe("Observation IDs to fetch (legacy, from memorix_search results)"),
         refs: z2.array(
@@ -29767,7 +30766,7 @@ ${actions.join("\n")}`
             projectId: z2.string().optional().describe("Project ID for global-search disambiguation")
           })
         ).optional().describe("Explicit observation refs. Prefer this for global search results."),
-        typedRefs: z2.array(z2.string()).optional().describe('Typed memory refs from search results, e.g. "obs:42", "skill:3", "obs:42@org/proj"'),
+        typedRefs: z2.array(z2.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: z2.string().optional().describe(
           "Why this must expand beyond the latest Autopilot brief. Name the missing fact or the user's explicit request."
         ),
@@ -29780,14 +30779,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])] : [];
           })
@@ -29795,15 +30799,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 (error) {
+              return { error: error instanceof Error ? error.message : String(error), 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 };
@@ -29812,7 +30837,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(", ")}`
           }
         ]
       };
@@ -30532,9 +31557,9 @@ ${skill2.content}` }]
         lines.push(`- **Description**: ${sk.description}`);
         lines.push(`- **Observations**: ${sk.content.split("\n").length} lines of knowledge`);
         if (write && target) {
-          const path26 = engine.writeSkill(sk, target);
-          if (path26) {
-            lines.push(`- [OK] **Written**: \`${path26}\``);
+          const path27 = engine.writeSkill(sk, target);
+          if (path27) {
+            lines.push(`- [OK] **Written**: \`${path27}\``);
           } else {
             lines.push(`- [ERROR] Failed to write`);
           }
@@ -32153,11 +33178,11 @@ async function createMemoryClient(options) {
       `[memorix-sdk] No Git repository found at "${projectRoot}". Memorix requires a Git-tracked project for identity resolution.`
     );
   }
-  const path26 = await import("path");
+  const path27 = await import("path");
   const os4 = await import("os");
-  const dataDir = path26.join(os4.homedir(), ".memorix", "data", project.id.replace(/\//g, path26.sep));
-  const fs19 = await import("fs");
-  fs19.mkdirSync(dataDir, { recursive: true });
+  const dataDir = path27.join(os4.homedir(), ".memorix", "data", project.id.replace(/\//g, path27.sep));
+  const fs20 = await import("fs");
+  fs20.mkdirSync(dataDir, { recursive: true });
   const client = new MemoryClient(project.id, projectRoot, dataDir);
   await client._init(silent);
   return client;