memorix 1.4.5 → 1.5.0

package/dist/sdk.js

@@ -3377,6 +3377,7 @@ var init_resolved_config = __esm({
 // src/config.ts
 var config_exports = {};
 __export(config_exports, {
+  defaultEmbeddingModelFor: () => defaultEmbeddingModelFor,
   getAgentLLMApiKey: () => getAgentLLMApiKey,
   getAgentLLMBaseUrl: () => getAgentLLMBaseUrl,
   getAgentLLMModel: () => getAgentLLMModel,
@@ -3393,7 +3394,6 @@ __export(config_exports, {
   getLLMProvider: () => getLLMProvider,
   getLoadedEnvFiles: () => getLoadedEnvFiles,
   getServerConfig: () => getServerConfig,
-  getTeamConfig: () => getTeamConfig,
   loadDotenv: () => loadDotenv,
   loadFileConfig: () => loadFileConfig,
   loadYamlConfig: () => loadYamlConfig,
@@ -3440,7 +3440,19 @@ function getEmbeddingBaseUrl() {
   return getResolvedEmbeddingLane().baseUrl || "https://api.openai.com/v1";
 }
 function getEmbeddingModel() {
-  return getResolvedEmbeddingLane().model || "text-embedding-3-small";
+  const lane = getResolvedEmbeddingLane();
+  return defaultEmbeddingModelFor(lane.baseUrl, lane.model);
+}
+function defaultEmbeddingModelFor(baseUrl, explicitModel) {
+  if (explicitModel) return explicitModel;
+  try {
+    const url = baseUrl ? new URL(baseUrl) : null;
+    if (url && (url.hostname === "openrouter.ai" || url.hostname.endsWith(".openrouter.ai"))) {
+      return "qwen/qwen3-embedding-8b";
+    }
+  } catch {
+  }
+  return "text-embedding-3-small";
 }
 function getEmbeddingDimensions() {
   return getResolvedEmbeddingLane().dimensions ?? null;
@@ -3465,14 +3477,10 @@ function getServerConfig() {
     port: server.port
   };
 }
-function getTeamConfig() {
-  return loadYamlConfig().team ?? {};
-}
 var init_config = __esm({
   "src/config.ts"() {
     "use strict";
     init_esm_shims();
-    init_yaml_loader();
     init_resolved_config();
     init_dotenv_loader();
     init_legacy_loader();
@@ -5757,9 +5765,9 @@ async function saveRegistry(baseDir) {
   await fs7.mkdir(path9.dirname(filePath), { recursive: true });
   await fs7.writeFile(filePath, JSON.stringify(registryCache, null, 2), "utf-8");
 }
-function findMatchingGroup(registry, projectInfo) {
+function findMatchingGroup(registry2, projectInfo) {
   const normalizedRoot = normalizePath(projectInfo.rootPath);
-  for (const group of registry.groups) {
+  for (const group of registry2.groups) {
     if (group.aliases.includes(projectInfo.id)) return group;
     if (group.rootPaths.some((rp) => rp === normalizedRoot)) return group;
     if (projectInfo.gitRemote && group.gitRemote && group.gitRemote === projectInfo.gitRemote) {
@@ -5772,9 +5780,9 @@ function selectCanonical(aliases) {
   return [...aliases].sort((a, b) => idPriority(b) - idPriority(a))[0];
 }
 async function registerAlias(projectInfo, baseDir) {
-  const registry = await loadRegistry(baseDir);
+  const registry2 = await loadRegistry(baseDir);
   const normalizedRoot = normalizePath(projectInfo.rootPath);
-  const existingGroup = findMatchingGroup(registry, projectInfo);
+  const existingGroup = findMatchingGroup(registry2, projectInfo);
   if (existingGroup) {
     let changed = false;
     if (!existingGroup.aliases.includes(projectInfo.id)) {
@@ -5805,13 +5813,13 @@ async function registerAlias(projectInfo, baseDir) {
     rootPaths: [normalizedRoot],
     ...projectInfo.gitRemote ? { gitRemote: projectInfo.gitRemote } : {}
   };
-  registry.groups.push(newGroup);
+  registry2.groups.push(newGroup);
   await saveRegistry(baseDir);
   return newGroup.canonical;
 }
 async function resolveAliases(projectId, baseDir) {
-  const registry = await loadRegistry(baseDir);
-  for (const group of registry.groups) {
+  const registry2 = await loadRegistry(baseDir);
+  for (const group of registry2.groups) {
     if (group.aliases.includes(projectId) || group.canonical === projectId) {
       return [...group.aliases];
     }
@@ -5819,8 +5827,8 @@ async function resolveAliases(projectId, baseDir) {
   return [projectId];
 }
 async function getCanonicalId(projectId, baseDir) {
-  const registry = await loadRegistry(baseDir);
-  for (const group of registry.groups) {
+  const registry2 = await loadRegistry(baseDir);
+  for (const group of registry2.groups) {
     if (group.aliases.includes(projectId) || group.canonical === projectId) {
       return group.canonical;
     }
@@ -5828,12 +5836,12 @@ async function getCanonicalId(projectId, baseDir) {
   return projectId;
 }
 async function getAllAliasGroups(baseDir) {
-  const registry = await loadRegistry(baseDir);
-  return registry.groups;
+  const registry2 = await loadRegistry(baseDir);
+  return registry2.groups;
 }
 async function autoMergeByBaseName(observedIds, baseDir) {
   if (observedIds.length <= 1) return 0;
-  const registry = await loadRegistry(baseDir);
+  const registry2 = await loadRegistry(baseDir);
   const byBaseName = /* @__PURE__ */ new Map();
   for (const id of observedIds) {
     const baseName = id.split("/").pop() ?? id;
@@ -5846,7 +5854,7 @@ async function autoMergeByBaseName(observedIds, baseDir) {
     const existingGroups = /* @__PURE__ */ new Set();
     const ungroupedIds = [];
     for (const id of ids) {
-      const groupIdx = registry.groups.findIndex(
+      const groupIdx = registry2.groups.findIndex(
         (g) => g.aliases.includes(id) || g.canonical === id
       );
       if (groupIdx >= 0) {
@@ -5860,7 +5868,7 @@ async function autoMergeByBaseName(observedIds, baseDir) {
     const canonical = selectCanonical(allIdsInGroup);
     if (existingGroups.size > 0) {
       const primaryIdx = [...existingGroups][0];
-      const primaryGroup = registry.groups[primaryIdx];
+      const primaryGroup = registry2.groups[primaryIdx];
       for (const id of allIdsInGroup) {
         if (!primaryGroup.aliases.includes(id)) {
           primaryGroup.aliases.push(id);
@@ -5868,7 +5876,7 @@ async function autoMergeByBaseName(observedIds, baseDir) {
       }
       const otherIdxs = [...existingGroups].slice(1).sort((a, b) => b - a);
       for (const idx of otherIdxs) {
-        const other = registry.groups[idx];
+        const other = registry2.groups[idx];
         for (const alias of other.aliases) {
           if (!primaryGroup.aliases.includes(alias)) {
             primaryGroup.aliases.push(alias);
@@ -5882,12 +5890,12 @@ async function autoMergeByBaseName(observedIds, baseDir) {
         if (other.gitRemote && !primaryGroup.gitRemote) {
           primaryGroup.gitRemote = other.gitRemote;
         }
-        registry.groups.splice(idx, 1);
+        registry2.groups.splice(idx, 1);
       }
       primaryGroup.canonical = selectCanonical(primaryGroup.aliases);
       mergeCount++;
     } else {
-      registry.groups.push({
+      registry2.groups.push({
         canonical,
         aliases: allIdsInGroup,
         rootPaths: []
@@ -6523,7 +6531,7 @@ async function searchObservations(options) {
   const expandedEmbeddingQuery = quality === "thorough" && tier === "heavy" ? await maybeExpandSearchQuery(options.query) : options.query;
   mark("queryExpansion");
   const intentResult = quality === "fast" || !hasQuery ? null : detectQueryIntent(originalQuery);
-  const requestLimit = projectIds ? (options.limit ?? 20) * 3 : options.limit ?? 20;
+  const requestLimit = projectIds || options.surfacedIds && options.surfacedIds.length > 0 ? (options.limit ?? 20) * 3 : options.limit ?? 20;
   const defaultBoost = {
     title: 3,
     entityName: 2,
@@ -6755,6 +6763,14 @@ async function searchObservations(options) {
     });
     intermediate.sort((a, b) => b.score - a.score);
   }
+  if (options.surfacedIds && options.surfacedIds.length > 0) {
+    const SURFACED_PENALTY = 0.5;
+    const surfaced = new Set(options.surfacedIds);
+    intermediate = intermediate.map(
+      (entry) => surfaced.has(entry.id) ? { ...entry, score: (entry.score ?? 0) * SURFACED_PENALTY } : entry
+    );
+    intermediate.sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
+  }
   if (options.since) {
     const sinceDate = new Date(options.since).getTime();
     intermediate = intermediate.filter((e2) => new Date(e2.rawTime).getTime() >= sinceDate);
@@ -7746,7 +7762,8 @@ var init_maintenance_jobs = __esm({
       "claim-requalification",
       "knowledge-compile",
       "knowledge-lint",
-      "workflow-index"
+      "workflow-index",
+      "long-term-maintenance"
     ];
     DEFAULT_MAX_ATTEMPTS = 8;
     DEFAULT_LEASE_MS = 3e4;
@@ -8155,6 +8172,7 @@ __export(lifecycle_exports, {
   enqueueClaimRequalification: () => enqueueClaimRequalification,
   enqueueCodegraphRefresh: () => enqueueCodegraphRefresh,
   enqueueKnowledgeFollowups: () => enqueueKnowledgeFollowups,
+  enqueueLongTermMaintenance: () => enqueueLongTermMaintenance,
   enqueueObservationQualification: () => enqueueObservationQualification
 });
 function queueFor(input) {
@@ -8198,6 +8216,14 @@ function enqueueObservationQualification(input) {
     payload: { source: input.source, limit: 100 }
   });
 }
+function enqueueLongTermMaintenance(input) {
+  queueFor(input).enqueue({
+    projectId: input.projectId,
+    kind: "long-term-maintenance",
+    dedupeKey: "long-term-maintenance",
+    payload: { source: input.source }
+  });
+}
 function enqueueKnowledgeFollowups(input) {
   const queue = queueFor(input);
   const payload = {
@@ -8377,7 +8403,8 @@ var init_isolated_maintenance = __esm({
       "claim-requalification",
       "knowledge-compile",
       "knowledge-lint",
-      "workflow-index"
+      "workflow-index",
+      "long-term-maintenance"
     ];
     DEFAULT_TIMEOUT_MS = 5 * 6e4;
     MAX_CHILD_OUTPUT_BYTES = 1e6;
@@ -144224,6 +144251,889 @@ var init_retention = __esm({
   }
 });
 
+// src/memory/owner.ts
+var owner_exports = {};
+__export(owner_exports, {
+  resolveLocalMemoryOwner: () => resolveLocalMemoryOwner
+});
+import { randomUUID as randomUUID6 } from "crypto";
+import { promises as fs12 } 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 fs12.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 fs12.mkdir(path19.dirname(filePath), { recursive: true });
+  const created = {
+    version: 1,
+    id: "local-" + randomUUID6(),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  try {
+    await fs12.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 randomUUID7 } from "crypto";
+function optionalText2(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),
+    ...optionalText2(row.applicability) ? { applicability: row.applicability } : {},
+    origin: row.origin,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+    ...optionalText2(row.qualifiedAt) ? { qualifiedAt: row.qualifiedAt } : {},
+    ...optionalText2(row.approvedAt) ? { approvedAt: row.approvedAt } : {},
+    ...optionalText2(row.archivedAt) ? { archivedAt: row.archivedAt } : {},
+    ...optionalText2(row.supersededBy) ? { supersededBy: row.supersededBy } : {},
+    ...optionalText2(row.lastValidatedAt) ? { lastValidatedAt: row.lastValidatedAt } : {},
+    accessCount: Number(row.accessCount ?? 0),
+    ...optionalText2(row.lastAccessedAt) ? { lastAccessedAt: row.lastAccessedAt } : {}
+  };
+}
+function rowToEvidence(row) {
+  return {
+    id: row.id,
+    memoryId: row.memoryId,
+    kind: row.kind,
+    referenceId: row.referenceId,
+    relation: row.relation,
+    ...optionalText2(row.locator) ? { locator: row.locator } : {},
+    ...optionalText2(row.capturedHash) ? { capturedHash: row.capturedHash } : {},
+    createdAt: row.createdAt
+  };
+}
+function rowToEvent(row) {
+  return {
+    id: row.id,
+    memoryId: row.memoryId,
+    kind: row.kind,
+    ...optionalText2(row.fromState) ? { fromState: row.fromState } : {},
+    ...optionalText2(row.toState) ? { toState: row.toState } : {},
+    ...optionalText2(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 limit2 = 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, limit2);
+        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: randomUUID7(),
+          ...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(rowToEvidence);
+      }
+      recordEvent(input) {
+        const event = {
+          id: randomUUID7(),
+          ...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(rowToEvent);
+      }
+      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,
+  maintainLongTermMemories: () => maintainLongTermMemories,
+  maybeAutoQualifyLongTermMemory: () => maybeAutoQualifyLongTermMemory,
+  promoteObservationToLongTermMemory: () => promoteObservationToLongTermMemory,
+  qualifyLongTermMemory: () => qualifyLongTermMemory,
+  renderLongTermMemorySummary: () => renderLongTermMemorySummary,
+  selectLongTermMemoriesForTask: () => selectLongTermMemoriesForTask,
+  supersedeLongTermMemory: () => supersedeLongTermMemory
+});
+import { randomUUID as randomUUID8 } from "crypto";
+function isOneOf(value, values) {
+  return typeof value === "string" && values.includes(value);
+}
+function compactText(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) => compactText(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: compactText(evidence.referenceId, "evidence reference", 1e3),
+      relation: evidence.relation,
+      ...evidence.locator ? { locator: compactText(evidence.locator, "evidence locator", 1e3) } : {},
+      ...evidence.capturedHash ? { capturedHash: compactText(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:" + randomUUID8(), 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: randomUUID8(),
+    originProjectId: compactText(input.originProjectId, "origin project id", 1e3),
+    ownerId: compactText(input.ownerId, "owner id", 160),
+    scope: input.scope,
+    kind: input.kind,
+    state: "candidate",
+    portability,
+    title: compactText(input.title, "title", 500),
+    content: compactText(input.content, "content"),
+    facts: compactList(input.facts, "facts"),
+    tags: compactList(input.tags, "tags"),
+    ...input.applicability ? { applicability: compactText(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 compactText(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 maybeAutoQualifyLongTermMemory(input) {
+  if (input.source !== "manual" && input.sourceDetail !== "explicit") return null;
+  try {
+    return await qualifyLongTermMemory({
+      dataDir: input.dataDir,
+      id: input.id,
+      reason: "auto-qualified: explicit request carries its own source evidence"
+    });
+  } catch {
+    return null;
+  }
+}
+async function maintainLongTermMemories(input) {
+  const now3 = input.now ?? /* @__PURE__ */ new Date();
+  const decayDays = input.decayDays ?? 30;
+  const cutoff = now3.getTime() - decayDays * 24 * 60 * 60 * 1e3;
+  const result = { archived: 0, superseded: 0 };
+  const store = await createStore(input.dataDir);
+  const all = store.list({ originProjectId: input.projectId });
+  for (const memory of all) {
+    if (memory.state !== "qualified" && memory.state !== "approved") continue;
+    const lastActivity = Date.parse(memory.lastAccessedAt ?? memory.updatedAt);
+    if (!Number.isFinite(lastActivity) || lastActivity >= cutoff) continue;
+    try {
+      await archiveLongTermMemory({
+        dataDir: input.dataDir,
+        id: memory.id,
+        reason: "auto-archive: no activity since " + new Date(lastActivity).toISOString().slice(0, 10)
+      });
+      result.archived += 1;
+    } catch {
+    }
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const memory of store.list({ originProjectId: input.projectId })) {
+    if (memory.state !== "qualified" && memory.state !== "approved") continue;
+    const key = memory.scope + "\0" + memory.kind + "\0" + memory.title.trim().toLowerCase();
+    const group = groups.get(key) ?? [];
+    group.push(memory);
+    groups.set(key, group);
+  }
+  for (const group of groups.values()) {
+    if (group.length < 2) continue;
+    group.sort((a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt));
+    const newest = group[0];
+    for (const older of group.slice(1)) {
+      try {
+        await supersedeLongTermMemory({
+          dataDir: input.dataDir,
+          id: older.id,
+          supersededBy: newest.id,
+          reason: "auto-supersede: a newer record shares the same title"
+        });
+        result.superseded += 1;
+      } catch {
+      }
+    }
+  }
+  return result;
+}
+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/codegraph/ids.ts
 import { createHash as createHash5 } from "crypto";
 function digest(input) {
@@ -144262,7 +145172,7 @@ var store_exports = {};
 __export(store_exports, {
   CodeGraphStore: () => CodeGraphStore
 });
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 import { posix as pathPosix } from "path";
 function rowToFile(row) {
   return {
@@ -144979,7 +145889,7 @@ var init_store = __esm({
        * so an interrupted scan cannot be advertised as complete.
        */
       recordCodeStateSnapshot(input) {
-        const id = randomUUID6();
+        const id = randomUUID9();
         let snapshot;
         const tx = this.db.transaction(() => {
           const previous = this.db.prepare(
@@ -145757,8 +146667,8 @@ var claim_store_exports = {};
 __export(claim_store_exports, {
   ClaimStore: () => ClaimStore
 });
-import { createHash as createHash8, randomUUID as randomUUID7 } from "crypto";
-function optionalText2(value) {
+import { createHash as createHash8, randomUUID as randomUUID10 } from "crypto";
+function optionalText3(value) {
   return typeof value === "string" && value ? value : void 0;
 }
 function rowToClaim(row) {
@@ -145774,38 +146684,38 @@ function rowToClaim(row) {
     status: row.status,
     confidence: Number(row.confidence),
     observedAt: row.observedAt,
-    ...optionalText2(row.validFrom) ? { validFrom: row.validFrom } : {},
-    ...optionalText2(row.validTo) ? { validTo: row.validTo } : {},
-    ...optionalText2(row.supersededBy) ? { supersededBy: row.supersededBy } : {},
+    ...optionalText3(row.validFrom) ? { validFrom: row.validFrom } : {},
+    ...optionalText3(row.validTo) ? { validTo: row.validTo } : {},
+    ...optionalText3(row.supersededBy) ? { supersededBy: row.supersededBy } : {},
     reviewState: row.reviewState,
     origin: row.origin,
     createdAt: row.createdAt,
     updatedAt: row.updatedAt
   };
 }
-function rowToEvidence(row) {
+function rowToEvidence2(row) {
   return {
     id: row.id,
     claimId: row.claimId,
     evidenceKind: row.evidenceKind,
     evidenceId: row.evidenceId,
     relation: row.relation,
-    ...optionalText2(row.snapshotId) ? { snapshotId: row.snapshotId } : {},
-    ...optionalText2(row.locator) ? { locator: row.locator } : {},
-    ...optionalText2(row.capturedHash) ? { capturedHash: row.capturedHash } : {},
+    ...optionalText3(row.snapshotId) ? { snapshotId: row.snapshotId } : {},
+    ...optionalText3(row.locator) ? { locator: row.locator } : {},
+    ...optionalText3(row.capturedHash) ? { capturedHash: row.capturedHash } : {},
     createdAt: row.createdAt
   };
 }
-function rowToEvent(row) {
+function rowToEvent2(row) {
   return {
     id: row.id,
     projectId: row.projectId,
     claimId: row.claimId,
     kind: row.kind,
-    ...optionalText2(row.fromStatus) ? { fromStatus: row.fromStatus } : {},
-    ...optionalText2(row.toStatus) ? { toStatus: row.toStatus } : {},
-    ...optionalText2(row.relatedClaimId) ? { relatedClaimId: row.relatedClaimId } : {},
-    ...optionalText2(row.detail) ? { detail: row.detail } : {},
+    ...optionalText3(row.fromStatus) ? { fromStatus: row.fromStatus } : {},
+    ...optionalText3(row.toStatus) ? { toStatus: row.toStatus } : {},
+    ...optionalText3(row.relatedClaimId) ? { relatedClaimId: row.relatedClaimId } : {},
+    ...optionalText3(row.detail) ? { detail: row.detail } : {},
     createdAt: row.createdAt
   };
 }
@@ -145941,7 +146851,7 @@ var init_claim_store = __esm({
         locator, capturedHash, evidenceKey, createdAt
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `).run(
-          randomUUID7(),
+          randomUUID10(),
           input.claimId,
           input.evidenceKind,
           input.evidenceId,
@@ -145959,11 +146869,11 @@ var init_claim_store = __esm({
       SELECT * FROM knowledge_claim_evidence
       WHERE claimId = ?
       ORDER BY createdAt ASC, id
-    `).all(claimId).map(rowToEvidence);
+    `).all(claimId).map(rowToEvidence2);
       }
       recordEvent(input) {
         const event = {
-          id: randomUUID7(),
+          id: randomUUID10(),
           ...input,
           ...input.detail ? { detail: sanitizeCredentials(input.detail) } : {},
           createdAt: input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
@@ -145991,7 +146901,7 @@ var init_claim_store = __esm({
       SELECT * FROM knowledge_claim_events
       WHERE claimId = ?
       ORDER BY createdAt ASC, id
-    `).all(claimId).map(rowToEvent);
+    `).all(claimId).map(rowToEvent2);
       }
     };
   }
@@ -146008,8 +146918,8 @@ __export(claims_exports, {
   supersedeClaim: () => supersedeClaim,
   writeClaim: () => writeClaim
 });
-import { createHash as createHash9, randomUUID as randomUUID8 } from "crypto";
-function compactText(value, field) {
+import { createHash as createHash9, randomUUID as randomUUID11 } from "crypto";
+function compactText2(value, field) {
   if (typeof value !== "string") throw new Error("Claim " + field + " must be text");
   const sanitized = sanitizeCredentials(value).trim().replace(/\s+/g, " ");
   if (!sanitized) throw new Error("Claim " + field + " is required");
@@ -146017,7 +146927,7 @@ function compactText(value, field) {
   return sanitized;
 }
 function normalizedTerm(value) {
-  return compactText(value, "identity").toLocaleLowerCase("en-US");
+  return compactText2(value, "identity").toLocaleLowerCase("en-US");
 }
 function hashIdentity(parts) {
   return createHash9("sha256").update(parts.join(String.fromCharCode(31))).digest("hex");
@@ -146046,7 +146956,7 @@ function validateEvidence(input) {
     if (!evidence || typeof evidence !== "object") {
       throw new Error("Claim evidence must be an object");
     }
-    const evidenceId = compactText(evidence.evidenceId, "evidence id");
+    const evidenceId = compactText2(evidence.evidenceId, "evidence id");
     if (evidenceId.length > MAX_EVIDENCE_ID_LENGTH) {
       throw new Error("Claim evidence id is too long");
     }
@@ -146060,9 +146970,9 @@ function validateEvidence(input) {
       evidenceKind: evidence.evidenceKind,
       evidenceId,
       relation: evidence.relation,
-      ...evidence.snapshotId ? { snapshotId: compactText(evidence.snapshotId, "evidence snapshot id") } : {},
-      ...evidence.locator ? { locator: compactText(evidence.locator, "evidence locator") } : {},
-      ...evidence.capturedHash ? { capturedHash: compactText(evidence.capturedHash, "evidence hash") } : {}
+      ...evidence.snapshotId ? { snapshotId: compactText2(evidence.snapshotId, "evidence snapshot id") } : {},
+      ...evidence.locator ? { locator: compactText2(evidence.locator, "evidence locator") } : {},
+      ...evidence.capturedHash ? { capturedHash: compactText2(evidence.capturedHash, "evidence hash") } : {}
     };
   });
 }
@@ -146070,10 +146980,10 @@ function normalizeClaimInput(input) {
   if (!["project", "workspace", "team", "workflow", "task"].includes(input.scope)) {
     throw new Error("Claim scope is invalid");
   }
-  const projectId = compactText(input.projectId, "project id");
-  const subject = compactText(input.subject, "subject");
-  const predicate = compactText(input.predicate, "predicate");
-  const objectValue = compactText(input.objectValue, "object value");
+  const projectId = compactText2(input.projectId, "project id");
+  const subject = compactText2(input.subject, "subject");
+  const predicate = compactText2(input.predicate, "predicate");
+  const objectValue = compactText2(input.objectValue, "object value");
   const identity = buildClaimIdentity({ subject, predicate, objectValue, scope: input.scope });
   const origin = input.origin ?? "explicit";
   let reviewState = input.reviewState ?? "approved";
@@ -146094,7 +147004,7 @@ function normalizeClaimInput(input) {
   const now3 = (/* @__PURE__ */ new Date()).toISOString();
   return {
     claim: {
-      id: randomUUID8(),
+      id: randomUUID11(),
       projectId,
       subject,
       predicate,
@@ -146194,7 +147104,7 @@ function reviewClaim(store, input) {
   if (input.reviewState !== "approved" && input.reviewState !== "rejected") {
     throw new Error("A claim review must approve or reject the claim");
   }
-  const detail = compactText(input.detail, "review detail");
+  const detail = compactText2(input.detail, "review detail");
   return store.transaction(() => {
     const claim = store.getClaim(input.claimId);
     if (!claim) throw new Error("Claim was not found");
@@ -146506,8 +147416,8 @@ var init_frontmatter = __esm({
 
 // src/knowledge/markdown.ts
 import { createHash as createHash10 } from "crypto";
-import { promises as fs12 } from "fs";
-import path19 from "path";
+import { promises as fs13 } from "fs";
+import path20 from "path";
 function hashContent(content) {
   return createHash10("sha256").update(content).digest("hex");
 }
@@ -146565,8 +147475,8 @@ function extractInternalMarkdownLinks(body) {
   return [...links].sort();
 }
 function resolvePageLink(sourceRelativePath, target) {
-  const sourceDir = path19.posix.dirname(sourceRelativePath.replace(/\\/g, "/"));
-  const normalized = path19.posix.normalize(path19.posix.join(sourceDir, target.replace(/\\/g, "/")));
+  const sourceDir = path20.posix.dirname(sourceRelativePath.replace(/\\/g, "/"));
+  const normalized = path20.posix.normalize(path20.posix.join(sourceDir, target.replace(/\\/g, "/")));
   if (!normalized || normalized === "." || normalized === ".." || normalized.startsWith("../")) return void 0;
   return normalized;
 }
@@ -146588,13 +147498,13 @@ function renderKnowledgePage(frontmatter, body) {
   });
 }
 async function readKnowledgePage(absolutePath, workspaceRoot) {
-  const raw = await fs12.readFile(absolutePath, "utf8");
+  const raw = await fs13.readFile(absolutePath, "utf8");
   try {
     const parsed = frontmatter_default(raw);
     const frontmatter = validateKnowledgePageFrontmatter(parsed.data);
     return {
       absolutePath,
-      relativePath: workspaceRoot ? path19.relative(workspaceRoot, absolutePath).split(path19.sep).join("/") : path19.basename(absolutePath),
+      relativePath: workspaceRoot ? path20.relative(workspaceRoot, absolutePath).split(path20.sep).join("/") : path20.basename(absolutePath),
       frontmatter,
       body: parsed.content.trim(),
       contentHash: hashContent(raw),
@@ -146606,7 +147516,7 @@ async function readKnowledgePage(absolutePath, workspaceRoot) {
   }
 }
 async function writeKnowledgePage(absolutePath, content) {
-  await fs12.mkdir(path19.dirname(absolutePath), { recursive: true });
+  await fs13.mkdir(path20.dirname(absolutePath), { recursive: true });
   await atomicWriteFile(absolutePath, content);
   return hashContent(content);
 }
@@ -146636,8 +147546,8 @@ __export(wiki_exports, {
   readKnowledgePage: () => readKnowledgePage
 });
 import { createHash as createHash11 } from "crypto";
-import { promises as fs13 } from "fs";
-import path20 from "path";
+import { promises as fs14 } from "fs";
+import path21 from "path";
 function hash2(value) {
   return createHash11("sha256").update(value).digest("hex");
 }
@@ -146769,7 +147679,7 @@ function candidatePage(workspace, title, claims, store) {
 }
 async function fileHashIfPresent(filePath) {
   try {
-    return pageContentHash(await fs13.readFile(filePath, "utf8"));
+    return pageContentHash(await fs14.readFile(filePath, "utf8"));
   } catch (error) {
     const code = error && typeof error === "object" && "code" in error ? error.code : void 0;
     if (code === "ENOENT") return void 0;
@@ -146793,8 +147703,8 @@ async function writeIndex(workspace, store) {
     lines.push("No pending proposals.");
   } else {
     for (const proposal of pending) {
-      const relative3 = path20.relative(paths.root, proposal.proposalPath).split(path20.sep).join("/");
-      lines.push("- [" + path20.basename(proposal.proposalPath, ".md") + "](" + relative3 + ")");
+      const relative3 = path21.relative(paths.root, proposal.proposalPath).split(path21.sep).join("/");
+      lines.push("- [" + path21.basename(proposal.proposalPath, ".md") + "](" + relative3 + ")");
     }
   }
   lines.push("");
@@ -146802,7 +147712,7 @@ async function writeIndex(workspace, store) {
 }
 async function appendLog(workspace, line) {
   const logPath = getKnowledgeWorkspacePaths(workspace).log;
-  await fs13.appendFile(logPath, "- " + now() + " " + line + "\n", "utf8");
+  await fs14.appendFile(logPath, "- " + now() + " " + line + "\n", "utf8");
 }
 function toPageRecord(workspace, page, status, contentHash, manualContentHash) {
   return {
@@ -146887,9 +147797,9 @@ async function applyKnowledgeProposal(input) {
   }
   if (proposal.status !== "pending") throw new Error("Knowledge proposal is not pending review");
   const root = getKnowledgeWorkspacePaths(input.workspace).root;
-  const targetPath = path20.resolve(proposal.targetPath);
-  const proposalPath = path20.resolve(proposal.proposalPath);
-  if (!targetPath.startsWith(root + path20.sep) || !proposalPath.startsWith(root + path20.sep)) {
+  const targetPath = path21.resolve(proposal.targetPath);
+  const proposalPath = path21.resolve(proposal.proposalPath);
+  if (!targetPath.startsWith(root + path21.sep) || !proposalPath.startsWith(root + path21.sep)) {
     throw new Error("Knowledge proposal path escapes its workspace");
   }
   await withFileLock(root, async () => {
@@ -146927,12 +147837,12 @@ async function markdownFiles(directory) {
   const files = [];
   let entries;
   try {
-    entries = await fs13.readdir(directory, { withFileTypes: true });
+    entries = await fs14.readdir(directory, { withFileTypes: true });
   } catch {
     return files;
   }
   for (const entry of entries) {
-    const filePath = path20.join(directory, entry.name);
+    const filePath = path21.join(directory, entry.name);
     if (entry.isDirectory()) {
       files.push(...await markdownFiles(filePath));
     } else if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) {
@@ -146955,13 +147865,13 @@ async function lintKnowledgeWorkspace(input) {
         kind: "malformed-frontmatter",
         severity: "error",
         message: error instanceof Error ? error.message : "Malformed knowledge page.",
-        relativePath: path20.relative(paths.root, filePath).split(path20.sep).join("/")
+        relativePath: path21.relative(paths.root, filePath).split(path21.sep).join("/")
       });
     }
   }
   const indexed = /* @__PURE__ */ new Set();
   try {
-    const index = await fs13.readFile(paths.index, "utf8");
+    const index = await fs14.readFile(paths.index, "utf8");
     for (const link of extractInternalMarkdownLinks(index)) {
       const resolved = resolvePageLink("index.md", link);
       if (resolved) indexed.add(resolved);
@@ -147050,7 +147960,7 @@ async function lintKnowledgeWorkspace(input) {
         kind: "manual-edit-protected",
         severity: "warning",
         message: "A newer proposal was held because the target page has manual edits.",
-        relativePath: path20.relative(paths.root, proposal.targetPath).split(path20.sep).join("/")
+        relativePath: path21.relative(paths.root, proposal.targetPath).split(path21.sep).join("/")
       });
     }
   }
@@ -147183,7 +148093,7 @@ var workflow_store_exports = {};
 __export(workflow_store_exports, {
   WorkflowStore: () => WorkflowStore
 });
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID12 } from "crypto";
 function parseJson(value, fallback) {
   if (typeof value !== "string" || !value) return fallback;
   try {
@@ -147192,7 +148102,7 @@ function parseJson(value, fallback) {
     return fallback;
   }
 }
-function optionalText3(value) {
+function optionalText4(value) {
   return typeof value === "string" && value.trim() ? value : void 0;
 }
 function rowToWorkflow(row) {
@@ -147229,14 +148139,14 @@ function rowToRun(row) {
     workflowId: row.workflowId,
     projectId: row.projectId,
     task: row.task,
-    ...optionalText3(row.startingSnapshotId) ? { startingSnapshotId: row.startingSnapshotId } : {},
+    ...optionalText4(row.startingSnapshotId) ? { startingSnapshotId: row.startingSnapshotId } : {},
     selectedEvidence: parseJson(row.selectedEvidenceJson, []),
     phaseState: parseJson(row.phaseStateJson, {}),
     outcome: row.outcome,
     verificationVerdict: row.verificationVerdict,
-    ...optionalText3(row.failureReason) ? { failureReason: row.failureReason } : {},
+    ...optionalText4(row.failureReason) ? { failureReason: row.failureReason } : {},
     startedAt: row.startedAt,
-    ...optionalText3(row.completedAt) ? { completedAt: row.completedAt } : {}
+    ...optionalText4(row.completedAt) ? { completedAt: row.completedAt } : {}
   };
 }
 var WorkflowStore;
@@ -147283,7 +148193,7 @@ var init_workflow_store = __esm({
       }
       recordRun(input) {
         const run = {
-          id: randomUUID9(),
+          id: randomUUID12(),
           workflowId: input.workflowId,
           projectId: input.projectId,
           task: input.task.trim(),
@@ -147361,8 +148271,8 @@ var init_outcome_types = __esm({
 });
 
 // src/knowledge/outcome-store.ts
-import { randomUUID as randomUUID10 } from "crypto";
-function optionalText4(value) {
+import { randomUUID as randomUUID13 } from "crypto";
+function optionalText5(value) {
   return typeof value === "string" && value.trim() ? value : void 0;
 }
 function text(value, field, max = 1e3) {
@@ -147385,8 +148295,8 @@ function rowToSignal(row) {
     candidateId: row.candidateId,
     kind: row.kind,
     sourceRef: row.sourceRef,
-    ...optionalText4(row.snapshotId) ? { snapshotId: row.snapshotId } : {},
-    ...optionalText4(row.detail) ? { detail: row.detail } : {},
+    ...optionalText5(row.snapshotId) ? { snapshotId: row.snapshotId } : {},
+    ...optionalText5(row.detail) ? { detail: row.detail } : {},
     observedAt: row.observedAt
   };
 }
@@ -147405,7 +148315,7 @@ var init_outcome_store = __esm({
       }
       record(input) {
         const signal = {
-          id: randomUUID10(),
+          id: randomUUID13(),
           projectId: text(input.projectId, "project id"),
           candidateKind: oneOf(input.candidateKind, MEMORY_OUTCOME_CANDIDATE_KINDS, "candidate kind"),
           candidateId: text(input.candidateId, "candidate id"),
@@ -147832,8 +148742,8 @@ __export(workflows_exports, {
   writeCanonicalWorkflow: () => writeCanonicalWorkflow
 });
 import { createHash as createHash12 } from "crypto";
-import { promises as fs14 } from "fs";
-import path21 from "path";
+import { promises as fs15 } from "fs";
+import path22 from "path";
 function hash3(value) {
   return createHash12("sha256").update(value).digest("hex");
 }
@@ -147854,7 +148764,7 @@ function requiredText(data, key) {
   }
   return value.trim();
 }
-function optionalText5(data, key) {
+function optionalText6(data, key) {
   const value = data[key];
   if (value === void 0 || value === null || value === "") return void 0;
   if (typeof value !== "string") throw new Error("workflow frontmatter field " + key + " must be text");
@@ -147897,11 +148807,11 @@ function phaseFromValue(value, index) {
   }
   const data = value;
   const title = requiredText(data, "title");
-  const phaseId = optionalText5(data, "id") ?? slug(title) + "-" + (index + 1);
+  const phaseId = optionalText6(data, "id") ?? slug(title) + "-" + (index + 1);
   return {
     id: phaseId,
     title,
-    instructions: optionalText5(data, "instructions") ?? "",
+    instructions: optionalText6(data, "instructions") ?? "",
     branches: optionalStringArray(data, "branches"),
     expectedOutputs: optionalStringArray(data, "expectedOutputs"),
     verificationGates: optionalStringArray(data, "verificationGates")
@@ -147936,7 +148846,7 @@ function phasesFromBody(body) {
 }
 function normalizeSourcePath(sourcePath) {
   const normalized = sourcePath.replace(/\\/g, "/");
-  if (!normalized.startsWith("workflows/") || !normalized.toLowerCase().endsWith(".md") || normalized.includes("../") || path21.posix.normalize(normalized) !== normalized) {
+  if (!normalized.startsWith("workflows/") || !normalized.toLowerCase().endsWith(".md") || normalized.includes("../") || path22.posix.normalize(normalized) !== normalized) {
     throw new Error("workflow source path must be a safe workflows/*.md path");
   }
   return normalized;
@@ -148010,7 +148920,7 @@ function parsedWorkflow(data, body, input) {
     id: requiredText(data, "id"),
     workspaceId: input.workspaceId,
     title: requiredText(data, "title"),
-    description: optionalText5(data, "description") ?? "",
+    description: optionalText6(data, "description") ?? "",
     status: optionalStatus(data),
     version: optionalNumber(data, "version", 1),
     taskLenses: optionalStringArray(data, "taskLenses"),
@@ -148029,9 +148939,9 @@ function parsedWorkflow(data, body, input) {
     sourcePath: normalizeSourcePath(input.sourcePath),
     sourceHash: "",
     contentHash: input.contentHash,
-    createdAt: optionalText5(data, "createdAt") ?? now2(),
-    updatedAt: optionalText5(data, "updatedAt") ?? now2(),
-    ...optionalText5(data, "importedFrom") ? { importedFrom: optionalText5(data, "importedFrom") } : {}
+    createdAt: optionalText6(data, "createdAt") ?? now2(),
+    updatedAt: optionalText6(data, "updatedAt") ?? now2(),
+    ...optionalText6(data, "importedFrom") ? { importedFrom: optionalText6(data, "importedFrom") } : {}
   };
   if (candidate.phases.length === 0) {
     throw new Error("workflow must contain at least one phase or a non-empty body");
@@ -148085,7 +148995,7 @@ async function writeCanonicalWorkflow(input) {
   const filePath = resolveKnowledgeWorkspaceFile(input.workspace, workflow.sourcePath);
   const content = renderWorkflowMarkdown(workflow);
   await withFileLock(paths.root, async () => {
-    await fs14.mkdir(path21.dirname(filePath), { recursive: true });
+    await fs15.mkdir(path22.dirname(filePath), { recursive: true });
     await atomicWriteFile(filePath, content);
   });
   const store = await storeFor2(input.workspace);
@@ -148094,13 +149004,13 @@ async function writeCanonicalWorkflow(input) {
 async function markdownFiles2(directory) {
   let entries;
   try {
-    entries = await fs14.readdir(directory, { withFileTypes: true });
+    entries = await fs15.readdir(directory, { withFileTypes: true });
   } catch {
     return [];
   }
   const files = [];
   for (const entry of entries) {
-    const absolutePath = path21.join(directory, entry.name);
+    const absolutePath = path22.join(directory, entry.name);
     if (entry.isDirectory()) {
       files.push(...await markdownFiles2(absolutePath));
     } else if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) {
@@ -148115,9 +149025,9 @@ async function syncCanonicalWorkflows(workspace) {
   const workflows = [];
   const errors = [];
   for (const absolutePath of await markdownFiles2(paths.workflows)) {
-    const sourcePath = path21.relative(paths.root, absolutePath).split(path21.sep).join("/");
+    const sourcePath = path22.relative(paths.root, absolutePath).split(path22.sep).join("/");
     try {
-      const raw = await fs14.readFile(absolutePath, "utf8");
+      const raw = await fs15.readFile(absolutePath, "utf8");
       const workflow = parseWorkflowMarkdown(raw, { workspaceId: workspace.id, sourcePath });
       workflows.push(store.upsertWorkflow(workflow));
     } catch (error) {
@@ -148229,21 +149139,21 @@ function importedWorkflowSpec(input) {
   return materializeWorkflow(spec);
 }
 async function importWindsurfWorkflows(input) {
-  const sourceDirectory = path21.join(path21.resolve(input.projectRoot), ".windsurf", "workflows");
+  const sourceDirectory = path22.join(path22.resolve(input.projectRoot), ".windsurf", "workflows");
   const paths = getKnowledgeWorkspacePaths(input.workspace);
   const imported = [];
   const skipped = [];
   let entries;
   try {
-    entries = await fs14.readdir(sourceDirectory, { withFileTypes: true });
+    entries = await fs15.readdir(sourceDirectory, { withFileTypes: true });
   } catch {
     return { imported, skipped };
   }
   for (const entry of entries.filter((item) => item.isFile() && item.name.toLowerCase().endsWith(".md"))) {
-    const originalPath = path21.join(sourceDirectory, entry.name);
-    const sourcePath = path21.relative(path21.resolve(input.projectRoot), originalPath).split(path21.sep).join("/");
+    const originalPath = path22.join(sourceDirectory, entry.name);
+    const sourcePath = path22.relative(path22.resolve(input.projectRoot), originalPath).split(path22.sep).join("/");
     try {
-      const raw = await fs14.readFile(originalPath, "utf8");
+      const raw = await fs15.readFile(originalPath, "utf8");
       const workflow = importedWorkflowSpec({
         workspace: input.workspace,
         sourceName: entry.name,
@@ -148252,7 +149162,7 @@ async function importWindsurfWorkflows(input) {
       });
       const targetPath = resolveKnowledgeWorkspaceFile(input.workspace, workflow.sourcePath);
       try {
-        await fs14.access(targetPath);
+        await fs15.access(targetPath);
         skipped.push({ sourcePath, reason: "canonical workflow already exists and was preserved" });
         continue;
       } catch {
@@ -148265,12 +149175,12 @@ async function importWindsurfWorkflows(input) {
       });
     }
   }
-  await fs14.mkdir(paths.workflows, { recursive: true });
+  await fs15.mkdir(paths.workflows, { recursive: true });
   return { imported, skipped };
 }
 function isWithin2(root, candidate) {
-  const relative3 = path21.relative(root, candidate);
-  return relative3 !== "" && relative3 !== ".." && !relative3.startsWith(".." + path21.sep) && !path21.isAbsolute(relative3);
+  const relative3 = path22.relative(root, candidate);
+  return relative3 !== "" && relative3 !== ".." && !relative3.startsWith(".." + path22.sep) && !path22.isAbsolute(relative3);
 }
 function adapterRelativePath(workflow, agent) {
   const name = "memorix-workflow-" + slug(workflow.id.replace(/^workflow:/, ""));
@@ -148356,15 +149266,15 @@ async function previewWorkflowAdapter(input) {
       reason: "The canonical workflow does not declare compatibility with this agent."
     };
   }
-  const projectRoot = path21.resolve(input.projectRoot);
-  const targetPath = path21.resolve(projectRoot, adapterRelativePath(input.workflow, input.agent));
+  const projectRoot = path22.resolve(input.projectRoot);
+  const targetPath = path22.resolve(projectRoot, adapterRelativePath(input.workflow, input.agent));
   if (!isWithin2(projectRoot, targetPath)) {
     throw new Error("Workflow adapter target escapes the project root");
   }
   const content = adapterContent(input.workflow, input.agent);
   let existing;
   try {
-    existing = await fs14.readFile(targetPath, "utf8");
+    existing = await fs15.readFile(targetPath, "utf8");
   } catch (error) {
     const code = error && typeof error === "object" && "code" in error ? error.code : void 0;
     if (code !== "ENOENT") throw error;
@@ -148385,11 +149295,11 @@ async function applyWorkflowAdapter(input) {
   if (initial.status === "unsupported" || initial.status === "conflict" || initial.status === "unchanged") {
     return initial;
   }
-  const projectRoot = path21.resolve(input.projectRoot);
+  const projectRoot = path22.resolve(input.projectRoot);
   return withFileLock(projectRoot, async () => {
     const current = await previewWorkflowAdapter(input);
     if (current.status !== "create" && current.status !== "update") return current;
-    await fs14.mkdir(path21.dirname(current.targetPath), { recursive: true });
+    await fs15.mkdir(path22.dirname(current.targetPath), { recursive: true });
     await atomicWriteFile(current.targetPath, current.content);
     return current;
   });
@@ -148679,6 +149589,11 @@ function createProjectMaintenanceHandler(projectId, projectDir2, projectRoot, op
       }
       return { action: "complete" };
     }
+    if (job.kind === "long-term-maintenance") {
+      const { maintainLongTermMemories: maintainLongTermMemories2 } = await Promise.resolve().then(() => (init_long_term(), long_term_exports));
+      await maintainLongTermMemories2({ dataDir: projectDir2, projectId });
+      return { action: "reschedule", delayMs: 24 * 60 * 60 * 1e3, resetAttempts: true };
+    }
     if (job.kind === "consolidation") {
       const limit2 = consolidationBatchSize(job.payload);
       const result2 = await runAutomaticConsolidation(projectId, projectDir2, {
@@ -149020,15 +149935,15 @@ __export(vector_backfill_runner_exports, {
 });
 import { spawn as spawn4 } from "child_process";
 import { existsSync as existsSync10 } from "fs";
-import path22 from "path";
+import path23 from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 function isNonEmptyString(value) {
   return typeof value === "string" && value.trim().length > 0;
 }
 function resolveVectorBackfillRunnerPath(moduleUrl = import.meta.url) {
-  const moduleDir = path22.dirname(fileURLToPath5(moduleUrl));
-  const distDir = path22.basename(moduleDir) === "cli" ? path22.dirname(moduleDir) : path22.basename(moduleDir) === "runtime" && path22.basename(path22.dirname(moduleDir)) === "src" ? path22.join(path22.dirname(path22.dirname(moduleDir)), "dist") : moduleDir;
-  return path22.join(distDir, "vector-backfill-runner.js");
+  const moduleDir = path23.dirname(fileURLToPath5(moduleUrl));
+  const distDir = path23.basename(moduleDir) === "cli" ? path23.dirname(moduleDir) : path23.basename(moduleDir) === "runtime" && path23.basename(path23.dirname(moduleDir)) === "src" ? path23.join(path23.dirname(path23.dirname(moduleDir)), "dist") : moduleDir;
+  return path23.join(distDir, "vector-backfill-runner.js");
 }
 function parseVectorBackfillRequest(raw) {
   let value;
@@ -149037,7 +149952,7 @@ function parseVectorBackfillRequest(raw) {
   } catch {
     throw new Error("Vector backfill runner received invalid JSON input");
   }
-  if (!value || typeof value !== "object" || !isNonEmptyString(value.projectId) || !isNonEmptyString(value.projectRoot) || !isNonEmptyString(value.dataDir) || !path22.isAbsolute(value.projectRoot) || !path22.isAbsolute(value.dataDir)) {
+  if (!value || typeof value !== "object" || !isNonEmptyString(value.projectId) || !isNonEmptyString(value.projectRoot) || !isNonEmptyString(value.dataDir) || !path23.isAbsolute(value.projectRoot) || !path23.isAbsolute(value.dataDir)) {
     throw new Error("Vector backfill runner received an invalid request");
   }
   return {
@@ -150119,8 +151034,16 @@ var init_observations = __esm({
 });
 
 // src/store/session-store.ts
-import path23 from "path";
-import fs15 from "fs";
+var session_store_exports = {};
+__export(session_store_exports, {
+  SessionGracefulDegrade: () => SessionGracefulDegrade,
+  SessionSqliteStore: () => SessionSqliteStore,
+  getSessionStore: () => getSessionStore,
+  initSessionStore: () => initSessionStore,
+  resetSessionStore: () => resetSessionStore
+});
+import path24 from "path";
+import fs16 from "fs";
 function sessionToRow(session) {
   return {
     id: session.id,
@@ -150149,6 +151072,10 @@ function getSessionStore() {
   }
   return _store3;
 }
+function resetSessionStore() {
+  _store3 = null;
+  _storeDataDir3 = null;
+}
 async function initSessionStore(dataDir) {
   if (_store3 && _storeDataDir3 === dataDir) return _store3;
   _store3 = null;
@@ -150202,10 +151129,10 @@ var init_session_store = __esm({
       async migrateFromJsonIfNeeded() {
         const count2 = this.db.prepare(`SELECT COUNT(*) AS cnt FROM sessions`).get();
         if (count2.cnt > 0) return;
-        const jsonPath = path23.join(this.dataDir, "sessions.json");
-        if (!fs15.existsSync(jsonPath)) return;
+        const jsonPath = path24.join(this.dataDir, "sessions.json");
+        if (!fs16.existsSync(jsonPath)) return;
         try {
-          const raw = fs15.readFileSync(jsonPath, "utf-8");
+          const raw = fs16.readFileSync(jsonPath, "utf-8");
           const sessions = JSON.parse(raw);
           if (!Array.isArray(sessions) || sessions.length === 0) return;
           console.error(`[memorix] Migrating ${sessions.length} sessions from JSON to SQLite...`);
@@ -152001,827 +152928,6 @@ var init_session = __esm({
   }
 });
 
-// src/memory/owner.ts
-var owner_exports = {};
-__export(owner_exports, {
-  resolveLocalMemoryOwner: () => resolveLocalMemoryOwner
-});
-import { randomUUID as randomUUID11 } from "crypto";
-import { promises as fs17 } from "fs";
-import path26 from "path";
-function ownerPath(dataDir) {
-  const resolved = path26.resolve(dataDir);
-  const home = path26.basename(resolved).toLocaleLowerCase("en-US") === "data" ? path26.dirname(resolved) : resolved;
-  return path26.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 fs17.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 fs17.mkdir(path26.dirname(filePath), { recursive: true });
-  const created = {
-    version: 1,
-    id: "local-" + randomUUID11(),
-    createdAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  try {
-    await fs17.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 randomUUID12 } from "crypto";
-function optionalText6(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),
-    ...optionalText6(row.applicability) ? { applicability: row.applicability } : {},
-    origin: row.origin,
-    createdAt: row.createdAt,
-    updatedAt: row.updatedAt,
-    ...optionalText6(row.qualifiedAt) ? { qualifiedAt: row.qualifiedAt } : {},
-    ...optionalText6(row.approvedAt) ? { approvedAt: row.approvedAt } : {},
-    ...optionalText6(row.archivedAt) ? { archivedAt: row.archivedAt } : {},
-    ...optionalText6(row.supersededBy) ? { supersededBy: row.supersededBy } : {},
-    ...optionalText6(row.lastValidatedAt) ? { lastValidatedAt: row.lastValidatedAt } : {},
-    accessCount: Number(row.accessCount ?? 0),
-    ...optionalText6(row.lastAccessedAt) ? { lastAccessedAt: row.lastAccessedAt } : {}
-  };
-}
-function rowToEvidence2(row) {
-  return {
-    id: row.id,
-    memoryId: row.memoryId,
-    kind: row.kind,
-    referenceId: row.referenceId,
-    relation: row.relation,
-    ...optionalText6(row.locator) ? { locator: row.locator } : {},
-    ...optionalText6(row.capturedHash) ? { capturedHash: row.capturedHash } : {},
-    createdAt: row.createdAt
-  };
-}
-function rowToEvent2(row) {
-  return {
-    id: row.id,
-    memoryId: row.memoryId,
-    kind: row.kind,
-    ...optionalText6(row.fromState) ? { fromState: row.fromState } : {},
-    ...optionalText6(row.toState) ? { toState: row.toState } : {},
-    ...optionalText6(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 limit2 = 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, limit2);
-        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: randomUUID12(),
-          ...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: randomUUID12(),
-          ...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 randomUUID13 } 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:" + randomUUID13(), 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: randomUUID13(),
-    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))];
@@ -153029,6 +153135,37 @@ function renderTaskWorksetPrompt(input) {
     trust: "source-backed"
   });
   appendLine(lines, "Task lens: " + input.lens, maxTokens, omitted, "lens");
+  if (input.alwaysOn) {
+    const hasAlwaysOn = input.alwaysOn.profile.length > 0 || Boolean(input.alwaysOn.state) || input.alwaysOn.durable.length > 0;
+    if (hasAlwaysOn) {
+      appendLine(lines, "", maxTokens, omitted, "always-on-heading");
+      appendLine(lines, "You and this workspace", maxTokens, omitted, "always-on-heading");
+      for (const profile of input.alwaysOn.profile.slice(0, 2)) {
+        appendLine(lines, "- " + short(profile, 26), maxTokens, omitted, "always-on-profile", selected, {
+          kind: "memory",
+          id: "profile",
+          reason: "user profile memory",
+          trust: "source-backed"
+        });
+      }
+      if (input.alwaysOn.state) {
+        appendLine(lines, "- Recently: " + short(input.alwaysOn.state, 40), maxTokens, omitted, "always-on-state", selected, {
+          kind: "continuation",
+          id: "workspace-state",
+          reason: "latest session summary for this workspace",
+          trust: "historical"
+        });
+      }
+      for (const durable of input.alwaysOn.durable.slice(0, 2)) {
+        appendLine(lines, "- " + short(durable, 28), maxTokens, omitted, "always-on-durable", selected, {
+          kind: "durable-memory",
+          id: "durable-always",
+          reason: "recent durable memory for this workspace",
+          trust: "source-backed"
+        });
+      }
+    }
+  }
   const hasContinuation = Boolean(
     input.continuation?.previousSession || (input.continuation?.memories.length ?? 0) > 0 || input.continuation?.compactCheckpoint
   );
@@ -153499,6 +153636,7 @@ async function buildTaskWorkset(input) {
     version: "1.3",
     task,
     lens: input.lens,
+    ...input.alwaysOn && (input.alwaysOn.profile.length > 0 || input.alwaysOn.state || input.alwaysOn.durable.length > 0) ? { alwaysOn: input.alwaysOn } : {},
     currentFacts: input.currentFacts?.map((fact) => fact.startsWith("Historical note:") ? short(fact, 48) : short(fact, 28)).slice(0, 4) ?? [],
     ...continuation ? { continuation } : {},
     ...input.codeState ? { codeState: short(input.codeState, 28) } : {},
@@ -154651,6 +154789,33 @@ function activeProjectObservations(observations2, projectId) {
 function deliveryEligibleProjectObservations(observations2, projectId) {
   return activeProjectObservations(observations2, projectId).filter((observation) => isEligibleForAutomaticDelivery(observation));
 }
+async function buildAlwaysOnBlock(input) {
+  const profile = filterReadableObservations(input.eligible, input.reader).filter((observation) => observation.visibility === "personal" && observation.entityName === "user-profile").slice(0, 2).map((observation) => compactContinuationText(observation.title, 22));
+  let state;
+  try {
+    await initSessionStore(input.dataDir);
+    const { getSessionStore: getSessionStore2 } = await Promise.resolve().then(() => (init_session_store(), session_store_exports));
+    const sessions = await getSessionStore2().loadByProject(input.projectId);
+    const latest = sessions.filter((session) => session.endedAt && session.summary?.trim()).sort((a, b) => Date.parse(b.endedAt ?? "") - Date.parse(a.endedAt ?? ""))[0];
+    if (latest?.summary) state = compactContinuationText(latest.summary, 40);
+  } catch {
+  }
+  const durable = [];
+  try {
+    const items = await listLongTermMemories({
+      dataDir: input.dataDir,
+      reader: {
+        projectId: input.projectId,
+        ...input.reader.agentId ? { agentId: input.reader.agentId } : {},
+        ...input.reader.isTeamMember ? { isTeamMember: true } : {}
+      },
+      limit: 10
+    });
+    durable.push(...items.filter((item) => item.memory.state === "approved").sort((a, b) => (b.memory.updatedAt ?? "").localeCompare(a.memory.updatedAt ?? "")).slice(0, 2).map((item) => item.memory.kind + ": " + compactContinuationText(item.memory.title, 22)));
+  } catch {
+  }
+  return { profile, state, durable };
+}
 function decideRefresh(input) {
   if (input.mode === "never") {
     return { performed: false, reason: "disabled", message: "Automatic project scan disabled." };
@@ -154855,12 +155020,19 @@ async function buildAutoProjectContext(input) {
       };
     }
   }
+  const alwaysOn = await buildAlwaysOnBlock({
+    dataDir: input.dataDir,
+    projectId: input.project.id,
+    reader: input.reader ?? { projectId: input.project.id },
+    eligible: deliveryEligibleProjectObservations(input.observations, input.project.id)
+  });
   const workset = await buildTaskWorkset({
     projectId: input.project.id,
     dataDir: input.dataDir,
     ...task ? { task } : {},
     lens: lens.id,
     startHere,
+    ...alwaysOn.profile.length > 0 || alwaysOn.state || alwaysOn.durable.length > 0 ? { alwaysOn } : {},
     ...externalOutline ? { semanticCode: externalOutline } : {},
     providerQuality: providerQuality2,
     currentFacts: worksetFactLines(currentFacts),
@@ -155043,7 +155215,16 @@ function formatAutoProjectContextSummary(context) {
     lensLine(context),
     "",
     ...formatCurrentFactsLines(context.currentFacts),
-    "",
+    ""
+  ].filter(Boolean);
+  if (context.workset.alwaysOn && (context.workset.alwaysOn.profile.length > 0 || context.workset.alwaysOn.state || context.workset.alwaysOn.durable.length > 0)) {
+    lines.push("You and this workspace");
+    for (const profile of context.workset.alwaysOn.profile.slice(0, 2)) lines.push(`- ${profile}`);
+    if (context.workset.alwaysOn.state) lines.push(`- Recently: ${context.workset.alwaysOn.state}`);
+    for (const durable of context.workset.alwaysOn.durable.slice(0, 2)) lines.push(`- ${durable}`);
+    lines.push("");
+  }
+  lines.push(...[
     `- Code memory: ${context.overview.code.files} files / ${context.overview.code.symbols} symbols / ${context.overview.code.refs} memory links`,
     `- Code provider: ${context.providerQuality.selected} (${context.providerQuality.selectedQuality})`,
     `- Languages: ${formatLanguages(context.overview)}`,
@@ -155052,7 +155233,7 @@ function formatAutoProjectContextSummary(context) {
     `- Refresh: ${context.refresh.message}`,
     "",
     "Start here"
-  ].filter(Boolean);
+  ].filter(Boolean));
   if (startHere.length > 0) {
     startHere.forEach((path34, index) => lines.push(`${index + 1}. ${path34}`));
   } else {
@@ -155176,6 +155357,8 @@ var init_auto_context = __esm({
     init_store();
     init_admission();
     init_session();
+    init_long_term();
+    init_visibility();
     init_session_store();
     init_task_lens();
     DEFAULT_MAX_AGE_MS = 10 * 60 * 1e3;
@@ -158126,8 +158309,8 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
           const { promises: fsP } = await import("fs");
           const registryPath = path30.join(baseDir, ".project-aliases.json");
           const raw = await fsP.readFile(registryPath, "utf-8");
-          const registry = JSON.parse(raw);
-          aliasGroups = registry.groups || [];
+          const registry2 = JSON.parse(raw);
+          aliasGroups = registry2.groups || [];
         } catch {
         }
         const currentGroup = aliasGroups.find((g) => g.aliases?.includes(effectiveProjectId) || g.canonical === effectiveProjectId);
@@ -161043,13 +161226,28 @@ alwaysApply: true
     '- 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.",
+    '- Record the user profile: the user\u2019s role, expertise, preferences, and goals. Save these with `entityName: "user-profile"` and `visibility: "personal"` so they stay private and appear in every brief as the "who you are" context.',
     "",
     "**Don't store:** greetings, simple file reads, trivial commands (ls, pwd, git status).",
     "",
+    "**Only store what a future session cannot re-derive.** Code structure, file contents, and Git history are live in the checkout \u2014 do not store facts already visible there. A memory earns its place by capturing the why, the context, or a conclusion the checkout alone cannot show.",
+    "",
+    `**Record what worked, not only what failed.** Store validated approaches and explicit user confirmations alongside corrections. Saving only failures drifts behavior away from what the user already accepted; a clear "yes, that's right" is feedback worth keeping too.`,
+    "",
+    "**Recalled memory is a claim about the past.** A memory naming a specific file, function, or flag describes the past at write time \u2014 check the file exists or grep the symbol before recommending it. If the user says to ignore or not use memory, proceed as if memory were empty: do not apply, cite, compare, or mention stored content.",
+    "",
     "## When to resolve memory",
     "",
     "Use `memorix_resolve` when a task is done or a bug is fixed. This keeps future searches focused on active work instead of surfacing completed items.",
     "",
+    "## End sessions with a summary",
+    "",
+    "When a session finishes, call `memorix_session_end` with a short structured summary so the next agent can resume. Recommended sections:",
+    "- **Goal** \u2014 what this session was working on",
+    "- **Discoveries** \u2014 findings, gotchas, learnings",
+    "- **Accomplished** \u2014 completed items, plus PENDING items for the next session",
+    "- **Relevant Files** \u2014 paths and what changed",
+    "",
     "## Tools quick reference",
     "",
     "| Tool | Use when |",
@@ -162644,8 +162842,8 @@ init_persistence();
 
 // src/rules/syncer.ts
 init_esm_shims();
-import { promises as fs16 } from "fs";
-import path24 from "path";
+import { promises as fs17 } from "fs";
+import path25 from "path";
 
 // src/rules/adapters/cursor.ts
 init_esm_shims();
@@ -163308,8 +163506,8 @@ var RulesSyncer = class {
         const found = await this.findFiles(scanPath);
         for (const filePath of found) {
           try {
-            const content = await fs16.readFile(filePath, "utf-8");
-            const relativePath = path24.relative(this.projectRoot, filePath).replace(/\\/g, "/");
+            const content = await fs17.readFile(filePath, "utf-8");
+            const relativePath = path25.relative(this.projectRoot, filePath).replace(/\\/g, "/");
             const parsed = entry.adapter.parse(relativePath, content);
             rules.push(...parsed);
           } catch {
@@ -163377,7 +163575,7 @@ var RulesSyncer = class {
     const entries = [];
     for (const adapter of this.adapters.values()) {
       const absolutePaths = adapter.filePatterns.map(
-        (p) => path24.join(this.projectRoot, p)
+        (p) => path25.join(this.projectRoot, p)
       );
       entries.push({ adapter, paths: absolutePaths });
     }
@@ -163385,13 +163583,13 @@ var RulesSyncer = class {
   }
   /** Find files matching a glob-like path (simple implementation) */
   async findFiles(pattern) {
-    const dir = path24.dirname(pattern);
-    const fileGlob = path24.basename(pattern);
+    const dir = path25.dirname(pattern);
+    const fileGlob = path25.basename(pattern);
     try {
-      const stat4 = await fs16.stat(dir);
+      const stat4 = await fs17.stat(dir);
       if (!stat4.isDirectory()) {
         try {
-          await fs16.access(pattern);
+          await fs17.access(pattern);
           return [pattern];
         } catch {
           return [];
@@ -163399,7 +163597,7 @@ var RulesSyncer = class {
       }
     } catch {
       try {
-        await fs16.access(pattern);
+        await fs17.access(pattern);
         return [pattern];
       } catch {
         return [];
@@ -163407,16 +163605,16 @@ var RulesSyncer = class {
     }
     if (fileGlob.includes("*")) {
       try {
-        const files = await fs16.readdir(dir);
+        const files = await fs17.readdir(dir);
         const ext = fileGlob.replace("*", "");
-        return files.filter((f3) => ext ? f3.endsWith(ext) : true).map((f3) => path24.join(dir, f3));
+        return files.filter((f3) => ext ? f3.endsWith(ext) : true).map((f3) => path25.join(dir, f3));
       } catch {
         return [];
       }
     }
     try {
-      await fs16.access(path24.join(dir, fileGlob));
-      return [path24.join(dir, fileGlob)];
+      await fs17.access(path25.join(dir, fileGlob));
+      return [path25.join(dir, fileGlob)];
     } catch {
       return [];
     }
@@ -164958,13 +165156,47 @@ function parseFormationTimeoutMs(raw) {
 init_timeout();
 init_secret_filter();
 
+// src/search/surfaced-registry.ts
+init_esm_shims();
+var MAX_KEYS = 64;
+var MAX_IDS = 200;
+var registry = /* @__PURE__ */ new Map();
+function touch(key) {
+  const ids = registry.get(key);
+  if (!ids) return [];
+  registry.delete(key);
+  registry.set(key, ids);
+  return ids;
+}
+function getSurfacedIds(key) {
+  return [...touch(key)];
+}
+function recordSurfacedIds(key, ids) {
+  if (ids.length === 0) return;
+  let list = registry.get(key) ?? [];
+  const known = new Set(list);
+  for (const id of ids) {
+    if (known.has(id)) continue;
+    known.add(id);
+    list.push(id);
+  }
+  if (list.length > MAX_IDS) {
+    list = list.slice(list.length - MAX_IDS);
+  }
+  registry.set(key, list);
+  if (registry.size > MAX_KEYS) {
+    const oldestKey = registry.keys().next().value;
+    if (oldestKey !== void 0 && oldestKey !== key) registry.delete(oldestKey);
+  }
+}
+
 // src/server/request-context.ts
 init_esm_shims();
-import path25 from "path";
+import path26 from "path";
 function resolveRoot(projectRoot) {
   const value = projectRoot.trim();
   if (!value) throw new Error("Project binding requires a non-empty project root");
-  return path25.resolve(value);
+  return path26.resolve(value);
 }
 var ProjectBindingController = class {
   current;
@@ -165355,6 +165587,12 @@ async function createMemorixServer(cwd, existingServer, sharedTeam, options = {}
         kind: "consolidation",
         dedupeKey: "startup-consolidation"
       });
+      lifecycle.enqueueLongTermMaintenance({
+        dataDir: projectDir2,
+        projectId: project.id,
+        source: "startup",
+        queue
+      });
     }
     try {
       const { CodeGraphStore: CodeGraphStore2 } = await Promise.resolve().then(() => (init_store(), store_exports));
@@ -165404,7 +165642,7 @@ The path should point to a directory containing a .git folder.`
   };
   const server = existingServer ?? new McpServer({
     name: "memorix",
-    version: true ? "1.4.5" : "1.0.1"
+    version: true ? "1.5.0" : "1.0.1"
   });
   const originalRegisterTool = server.registerTool.bind(server);
   server.registerTool = ((name, ...args) => {
@@ -165889,7 +166127,7 @@ Mode: ${decision.usedLLM ? "LLM" : "heuristic"}`
           let longTermNote = "";
           if (longTerm) {
             try {
-              const { promoteObservationToLongTermMemory: promoteObservationToLongTermMemory2 } = await Promise.resolve().then(() => (init_long_term(), long_term_exports));
+              const { promoteObservationToLongTermMemory: promoteObservationToLongTermMemory2, maybeAutoQualifyLongTermMemory: maybeAutoQualifyLongTermMemory2 } = await Promise.resolve().then(() => (init_long_term(), long_term_exports));
               const promoted = await promoteObservationToLongTermMemory2({
                 dataDir: projectDir2,
                 observation: obs,
@@ -165903,7 +166141,24 @@ Mode: ${decision.usedLLM ? "LLM" : "heuristic"}`
                   ...reader.isTeamMember ? { isTeamMember: true } : {}
                 }
               });
-              longTermNote = `
+              const autoQualified = await maybeAutoQualifyLongTermMemory2({
+                dataDir: projectDir2,
+                id: promoted.memory.id,
+                sourceDetail: "explicit"
+              });
+              if (autoQualified) {
+                try {
+                  const { enqueueLongTermMaintenance: enqueueLongTermMaintenance2 } = await Promise.resolve().then(() => (init_lifecycle(), lifecycle_exports));
+                  enqueueLongTermMaintenance2({
+                    dataDir: projectDir2,
+                    projectId: project.id,
+                    source: "long-term:" + promoted.memory.id
+                  });
+                } catch {
+                }
+              }
+              longTermNote = autoQualified ? `
+Long-term memory: ${promoted.memory.id} (${promoted.memory.kind}/${promoted.memory.scope}, auto-qualified) and now enters briefs as durable context. Audit with \`memorix memory long-term list\`.` : `
 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 = `
@@ -166099,6 +166354,13 @@ Use this as the \`topicKey\` parameter in \`memorix_store\` to enable upsert beh
         const boundary = requireExplicitAutopilotExpansion("memorix_search", purpose);
         if (boundary) return boundary;
       }
+      let surfacedKey = `project:${project.id}`;
+      try {
+        const { getActiveSession: getActiveSession2 } = await Promise.resolve().then(() => (init_session(), session_exports));
+        const active = await getActiveSession2(projectDir2, project.id);
+        if (active) surfacedKey = `session:${active.id}`;
+      } catch {
+      }
       return withFreshIndex(async () => {
         const safeLimit2 = limit2 != null ? coerceNumber(limit2, 20) : void 0;
         const safeMaxTokens = maxTokens != null ? coerceNumber(maxTokens, 0) : void 0;
@@ -166116,7 +166378,8 @@ Use this as the \`topicKey\` parameter in \`memorix_store\` to enable upsert beh
           status: status ?? "active",
           source,
           quality,
-          reader: getObservationReader(scope === "global" ? "global" : "project")
+          reader: getObservationReader(scope === "global" ? "global" : "project"),
+          surfacedIds: getSurfacedIds(surfacedKey)
         });
         let result;
         try {
@@ -166135,6 +166398,7 @@ Use this as the \`topicKey\` parameter in \`memorix_store\` to enable upsert beh
           }
           throw error;
         }
+        recordSurfacedIds(surfacedKey, result.entries.map((entry) => entry.id));
         const activeBoundary = getActiveAutopilotRetrievalBoundary();
         if (scope !== "global" && activeBoundary && !force && result.entries.length > 0 && result.entries.every((entry) => activeBoundary.coveredObservationIds.has(entry.id))) {
           const duplicate = blockCoveredAutopilotEvidence("memorix_search", result.entries.map((entry) => entry.id), force);
@@ -169097,13 +169361,26 @@ ${lines.join("\n")}` }] };
     if (bytes.length >= 12 && Buffer.from(bytes.subarray(0, 4)).toString("ascii") === "RIFF" && Buffer.from(bytes.subarray(8, 12)).toString("ascii") === "WEBP") return "image/webp";
     return void 0;
   }
+  const mediaGenerationEnabled = process.env.MEMORIX_MCP_MEDIA_GENERATION === "1";
+  const mediaTranscriptionEnabled = process.env.MEMORIX_MCP_MEDIA_TRANSCRIPTION === "1";
+  const mediaGenerationOrTranscription = mediaGenerationEnabled || mediaTranscriptionEnabled;
   server.registerTool(
     "memorix_media",
     {
       title: "Manage Controlled Media",
       description: "Use the controlled local media library for an explicit import, attachment, inspection, or MiniMax generation request. Assets stay outside the Git worktree and enter normal memory only when attach is explicitly true. Use the CLI for destructive removal, quota cleanup, and direct generation. MCP generation is disabled by default and requires MEMORIX_MCP_MEDIA_GENERATION=1 after the operator reviews provider billing.",
       inputSchema: {
-        action: z626.enum(["import", "attach", "list", "show", "derive-pdf", "derive-audio", "generate-image", "generate-video", "status", "cancel"]),
+        action: z626.enum([
+          "import",
+          "attach",
+          "list",
+          "show",
+          "derive-pdf",
+          "status",
+          "cancel",
+          ...mediaTranscriptionEnabled ? ["derive-audio"] : [],
+          ...mediaGenerationEnabled ? ["generate-image", "generate-video"] : []
+        ]),
         path: z626.string().optional().describe("Explicit local image/audio/video/PDF path for import."),
         assetId: z626.string().optional().describe("Controlled MediaAsset ID for attach/show."),
         jobId: z626.string().optional().describe("Durable media job ID for status."),
@@ -169111,20 +169388,26 @@ ${lines.join("\n")}` }] };
         limit: z626.number().int().min(1).max(100).optional().describe("Maximum assets to list."),
         title: z626.string().optional().describe("Observation title when attaching generated/imported output."),
         narrative: z626.string().optional().describe("Short retrieval text when attaching an asset."),
-        prompt: z626.string().optional().describe("Explicit MiniMax generation prompt."),
-        image: z626.string().optional().describe("Base64-encoded reference image for image-to-image generation."),
-        model: z626.string().max(160).optional().describe("Provider model for the selected media action."),
-        provider: z626.enum(["openai", "groq"]).optional().describe("Explicit audio transcription provider."),
-        language: z626.string().max(32).optional().describe("Optional ISO-639-1 hint for audio transcription."),
-        region: z626.enum(["global", "cn"]).optional().describe("MiniMax deployment region."),
-        n: z626.number().int().min(1).max(4).optional().describe("Image output count."),
-        ratio: z626.enum(["adaptive", "1:1", "16:9", "4:3", "3:2", "2:3", "3:4", "9:16", "21:9"]).optional().describe("Image or video aspect ratio."),
-        width: z626.number().int().min(1).max(8192).optional().describe("Requested image width."),
-        height: z626.number().int().min(1).max(8192).optional().describe("Requested image height."),
-        duration: z626.union([z626.literal(5), z626.literal(10)]).optional().describe("MiniMax video duration in seconds."),
         maxPages: z626.number().int().min(1).max(100).optional().describe("Bounded PDF extraction page limit."),
         maxChars: z626.number().int().min(1).max(6e4).optional().describe("Bounded PDF extraction character limit."),
-        attach: z626.boolean().optional().describe("Attach generated/imported output to normal project memory explicitly.")
+        attach: z626.boolean().optional().describe("Attach generated/imported output to normal project memory explicitly."),
+        ...mediaGenerationOrTranscription ? {
+          model: z626.string().max(160).optional().describe("Provider model for the selected media action."),
+          prompt: z626.string().optional().describe("Explicit prompt for generation or transcription.")
+        } : {},
+        ...mediaTranscriptionEnabled ? {
+          provider: z626.enum(["openai", "groq"]).optional().describe("Explicit audio transcription provider."),
+          language: z626.string().max(32).optional().describe("Optional ISO-639-1 hint for audio transcription.")
+        } : {},
+        ...mediaGenerationEnabled ? {
+          image: z626.string().optional().describe("Base64-encoded reference image for image-to-image generation."),
+          region: z626.enum(["global", "cn"]).optional().describe("MiniMax deployment region."),
+          n: z626.number().int().min(1).max(4).optional().describe("Image output count."),
+          ratio: z626.enum(["adaptive", "1:1", "16:9", "4:3", "3:2", "2:3", "3:4", "9:16", "21:9"]).optional().describe("Image or video aspect ratio."),
+          width: z626.number().int().min(1).max(8192).optional().describe("Requested image width."),
+          height: z626.number().int().min(1).max(8192).optional().describe("Requested image height."),
+          duration: z626.union([z626.literal(5), z626.literal(10)]).optional().describe("MiniMax video duration in seconds.")
+        } : {}
       }
     },
     async ({ action, path: assetPath, assetId, jobId, kind, limit: limit2, title, narrative, prompt, image, model, provider: provider2, language, region, n, ratio, width, height, duration, maxPages, maxChars, attach }) => {