memorix 1.4.5 → 1.4.6

package/dist/cli/index.js

@@ -3221,7 +3221,7 @@ ${import_picocolors.default.gray(m3)}  ${s4}
 
 // src/cli/version.ts
 function getCliVersion() {
-  return true ? "1.4.5" : pkg.version;
+  return true ? "1.4.6" : pkg.version;
 }
 var init_version = __esm({
   "src/cli/version.ts"() {
@@ -21729,7 +21729,6 @@ __export(config_exports, {
   getLLMProvider: () => getLLMProvider,
   getLoadedEnvFiles: () => getLoadedEnvFiles,
   getServerConfig: () => getServerConfig,
-  getTeamConfig: () => getTeamConfig,
   loadDotenv: () => loadDotenv,
   loadFileConfig: () => loadFileConfig,
   loadYamlConfig: () => loadYamlConfig,
@@ -21801,14 +21800,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();
@@ -24093,9 +24088,9 @@ async function saveRegistry(baseDir) {
   await fs6.mkdir(path8.dirname(filePath), { recursive: true });
   await fs6.writeFile(filePath, JSON.stringify(registryCache, null, 2), "utf-8");
 }
-function findMatchingGroup(registry2, projectInfo) {
+function findMatchingGroup(registry3, projectInfo) {
   const normalizedRoot = normalizePath(projectInfo.rootPath);
-  for (const group of registry2.groups) {
+  for (const group of registry3.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) {
@@ -24108,9 +24103,9 @@ function selectCanonical(aliases) {
   return [...aliases].sort((a4, b4) => idPriority(b4) - idPriority(a4))[0];
 }
 async function registerAlias(projectInfo, baseDir) {
-  const registry2 = await loadRegistry(baseDir);
+  const registry3 = await loadRegistry(baseDir);
   const normalizedRoot = normalizePath(projectInfo.rootPath);
-  const existingGroup = findMatchingGroup(registry2, projectInfo);
+  const existingGroup = findMatchingGroup(registry3, projectInfo);
   if (existingGroup) {
     let changed = false;
     if (!existingGroup.aliases.includes(projectInfo.id)) {
@@ -24141,13 +24136,13 @@ async function registerAlias(projectInfo, baseDir) {
     rootPaths: [normalizedRoot],
     ...projectInfo.gitRemote ? { gitRemote: projectInfo.gitRemote } : {}
   };
-  registry2.groups.push(newGroup);
+  registry3.groups.push(newGroup);
   await saveRegistry(baseDir);
   return newGroup.canonical;
 }
 async function resolveAliases(projectId, baseDir) {
-  const registry2 = await loadRegistry(baseDir);
-  for (const group of registry2.groups) {
+  const registry3 = await loadRegistry(baseDir);
+  for (const group of registry3.groups) {
     if (group.aliases.includes(projectId) || group.canonical === projectId) {
       return [...group.aliases];
     }
@@ -24155,8 +24150,8 @@ async function resolveAliases(projectId, baseDir) {
   return [projectId];
 }
 async function getCanonicalId(projectId, baseDir) {
-  const registry2 = await loadRegistry(baseDir);
-  for (const group of registry2.groups) {
+  const registry3 = await loadRegistry(baseDir);
+  for (const group of registry3.groups) {
     if (group.aliases.includes(projectId) || group.canonical === projectId) {
       return group.canonical;
     }
@@ -24164,12 +24159,12 @@ async function getCanonicalId(projectId, baseDir) {
   return projectId;
 }
 async function getAllAliasGroups(baseDir) {
-  const registry2 = await loadRegistry(baseDir);
-  return registry2.groups;
+  const registry3 = await loadRegistry(baseDir);
+  return registry3.groups;
 }
 async function autoMergeByBaseName(observedIds, baseDir) {
   if (observedIds.length <= 1) return 0;
-  const registry2 = await loadRegistry(baseDir);
+  const registry3 = await loadRegistry(baseDir);
   const byBaseName = /* @__PURE__ */ new Map();
   for (const id of observedIds) {
     const baseName = id.split("/").pop() ?? id;
@@ -24182,7 +24177,7 @@ async function autoMergeByBaseName(observedIds, baseDir) {
     const existingGroups = /* @__PURE__ */ new Set();
     const ungroupedIds = [];
     for (const id of ids) {
-      const groupIdx = registry2.groups.findIndex(
+      const groupIdx = registry3.groups.findIndex(
         (g4) => g4.aliases.includes(id) || g4.canonical === id
       );
       if (groupIdx >= 0) {
@@ -24196,7 +24191,7 @@ async function autoMergeByBaseName(observedIds, baseDir) {
     const canonical = selectCanonical(allIdsInGroup);
     if (existingGroups.size > 0) {
       const primaryIdx = [...existingGroups][0];
-      const primaryGroup = registry2.groups[primaryIdx];
+      const primaryGroup = registry3.groups[primaryIdx];
       for (const id of allIdsInGroup) {
         if (!primaryGroup.aliases.includes(id)) {
           primaryGroup.aliases.push(id);
@@ -24204,7 +24199,7 @@ async function autoMergeByBaseName(observedIds, baseDir) {
       }
       const otherIdxs = [...existingGroups].slice(1).sort((a4, b4) => b4 - a4);
       for (const idx of otherIdxs) {
-        const other = registry2.groups[idx];
+        const other = registry3.groups[idx];
         for (const alias of other.aliases) {
           if (!primaryGroup.aliases.includes(alias)) {
             primaryGroup.aliases.push(alias);
@@ -24218,12 +24213,12 @@ async function autoMergeByBaseName(observedIds, baseDir) {
         if (other.gitRemote && !primaryGroup.gitRemote) {
           primaryGroup.gitRemote = other.gitRemote;
         }
-        registry2.groups.splice(idx, 1);
+        registry3.groups.splice(idx, 1);
       }
       primaryGroup.canonical = selectCanonical(primaryGroup.aliases);
       mergeCount++;
     } else {
-      registry2.groups.push({
+      registry3.groups.push({
         canonical,
         aliases: allIdsInGroup,
         rootPaths: []
@@ -25105,7 +25100,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;
@@ -25514,6 +25510,7 @@ __export(lifecycle_exports, {
   enqueueClaimRequalification: () => enqueueClaimRequalification,
   enqueueCodegraphRefresh: () => enqueueCodegraphRefresh,
   enqueueKnowledgeFollowups: () => enqueueKnowledgeFollowups,
+  enqueueLongTermMaintenance: () => enqueueLongTermMaintenance,
   enqueueObservationQualification: () => enqueueObservationQualification
 });
 function queueFor(input) {
@@ -25557,6 +25554,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 queue2 = queueFor(input);
   const payload = {
@@ -25736,7 +25741,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;
@@ -177446,6 +177452,893 @@ 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 fs11 } from "fs";
+import path18 from "path";
+function ownerPath(dataDir) {
+  const resolved = path18.resolve(dataDir);
+  const home = path18.basename(resolved).toLocaleLowerCase("en-US") === "data" ? path18.dirname(resolved) : resolved;
+  return path18.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 fs11.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 fs11.mkdir(path18.dirname(filePath), { recursive: true });
+  const created = {
+    version: 1,
+    id: "local-" + randomUUID6(),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  try {
+    await fs11.writeFile(filePath, JSON.stringify(created, null, 2) + "\n", { encoding: "utf8", flag: "wx" });
+    return { id: created.id, source: "local-file" };
+  } catch (error40) {
+    if (error40?.code !== "EEXIST") throw error40;
+    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
+var long_term_store_exports = {};
+__export(long_term_store_exports, {
+  LongTermMemoryStore: () => LongTermMemoryStore
+});
+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(fn2) {
+        return this.db.transaction(fn2)();
+      }
+      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, at2 = (/* @__PURE__ */ new Date()).toISOString()) {
+        const unique3 = [...new Set(ids.filter(Boolean))];
+        if (unique3.length === 0) return;
+        const statement = this.db.prepare(`
+      UPDATE long_term_memories
+      SET accessCount = accessCount + 1, lastAccessedAt = ?
+      WHERE id = ?
+    `);
+        this.db.transaction(() => {
+          for (const id of unique3) statement.run(at2, 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 time3 = Date.parse(validatedAt);
+  if (!Number.isFinite(time3)) return 0;
+  const ageDays = Math.max(0, Date.now() - time3) / (24 * 60 * 60 * 1e3);
+  if (ageDays <= 30) return 0.35;
+  if (ageDays <= 90) return 0.15;
+  return 0;
+}
+function scoreForTask(memory, task) {
+  const terms = taskTerms(task);
+  if (terms.length === 0) return void 0;
+  const title = memory.title.toLocaleLowerCase("en-US");
+  const content = memory.content.toLocaleLowerCase("en-US");
+  const facts = memory.facts.join(" ").toLocaleLowerCase("en-US");
+  const tags = memory.tags.join(" ").toLocaleLowerCase("en-US");
+  const applicability = (memory.applicability ?? "").toLocaleLowerCase("en-US");
+  let score = memory.state === "approved" ? 0.5 : 0;
+  const matched = [];
+  for (const term of terms) {
+    let termScore = 0;
+    if (title.includes(term)) termScore += 5;
+    if (tags.includes(term)) termScore += 4;
+    if (applicability.includes(term)) termScore += 3;
+    if (facts.includes(term)) termScore += 2;
+    if (content.includes(term)) termScore += 1;
+    if (termScore > 0) {
+      score += termScore;
+      matched.push(term);
+    }
+  }
+  if (matched.length === 0) return void 0;
+  score += kindFitScore(memory.kind, task);
+  score += validationFreshnessScore(memory);
+  const kindLabel = memory.kind === "procedural" ? "procedure" : memory.kind === "semantic" ? "fact" : "episode";
+  const freshness = validationFreshnessScore(memory) > 0 ? "; recently validated" : "";
+  return { score, reason: kindLabel + " matches " + matched.slice(0, 3).join(", ") + freshness };
+}
+function semanticText(memory) {
+  return sanitizeCredentials([
+    memory.title,
+    memory.applicability,
+    memory.tags.join(" "),
+    memory.facts.join(" "),
+    memory.content
+  ].filter((value) => Boolean(value)).join("\n")).replace(/\s+/g, " ").trim().slice(0, MAX_TEXT_LENGTH);
+}
+function cosineSimilarity(left, right) {
+  if (left.length === 0 || left.length !== right.length) return 0;
+  let dot = 0;
+  let leftMagnitude = 0;
+  let rightMagnitude = 0;
+  for (let index = 0; index < left.length; index += 1) {
+    const a4 = left[index];
+    const b4 = right[index];
+    if (!Number.isFinite(a4) || !Number.isFinite(b4)) return 0;
+    dot += a4 * b4;
+    leftMagnitude += a4 * a4;
+    rightMagnitude += b4 * b4;
+  }
+  if (leftMagnitude === 0 || rightMagnitude === 0) return 0;
+  return dot / Math.sqrt(leftMagnitude * rightMagnitude);
+}
+function semanticSelection(memory, similarity, task) {
+  if (similarity < MIN_SEMANTIC_SIMILARITY) return void 0;
+  const kindLabel = memory.kind === "procedural" ? "procedure" : memory.kind === "semantic" ? "fact" : "episode";
+  const freshness = validationFreshnessScore(memory) > 0 ? "; recently validated" : "";
+  return {
+    score: similarity * 10 + (memory.state === "approved" ? 0.5 : 0) + kindFitScore(memory.kind, task) + validationFreshnessScore(memory),
+    reason: kindLabel + " semantic match " + similarity.toFixed(2) + freshness
+  };
+}
+async function resolveSemanticProvider(explicit) {
+  if (explicit !== void 0) return explicit;
+  try {
+    const { getEmbeddingProvider: getEmbeddingProvider2 } = await Promise.resolve().then(() => (init_provider(), provider_exports));
+    return await withTimeout(
+      getEmbeddingProvider2({ requestTimeoutMs: SEMANTIC_RETRIEVAL_TIMEOUT_MS, retry: false }),
+      SEMANTIC_RETRIEVAL_TIMEOUT_MS,
+      "Long-term semantic provider initialization"
+    );
+  } catch {
+    return null;
+  }
+}
+function createStore(dataDir) {
+  const store2 = new LongTermMemoryStore();
+  return store2.init(dataDir).then(() => store2);
+}
+async function createManualLongTermMemory(input) {
+  const owner = await resolveLocalMemoryOwner(input.dataDir, { create: true });
+  if (!owner) throw new Error("Memorix could not resolve a local memory owner.");
+  assertScope(input.scope);
+  const evidence = input.scope === "user" ? [{ kind: "user", referenceId: owner.id, relation: "user-confirmed" }] : [{ kind: "manual", referenceId: "manual:" + 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 store2 = await createStore(input.dataDir);
+  const evidence = store2.transaction(() => {
+    store2.insert(memory);
+    const written = evidenceInputs.map((item) => store2.insertEvidence({ memoryId: memory.id, ...item, createdAt: now3 }));
+    store2.recordEvent({
+      memoryId: memory.id,
+      kind: "created",
+      toState: "candidate",
+      detail: "Created as a source-backed long-term memory candidate.",
+      createdAt: now3
+    });
+    return written;
+  });
+  return { memory, evidence };
+}
+function transitionDetail(value) {
+  return compactText(value, "transition reason", 1e3);
+}
+async function transitionMemory(input) {
+  const store2 = await createStore(input.dataDir);
+  return store2.transaction(() => {
+    const current = store2.get(input.id);
+    if (!current) throw new Error("Long-term memory was not found.");
+    if (current.state !== input.expected) {
+      throw new Error("Long-term memory must be " + input.expected + " before it can be " + input.next + ".");
+    }
+    const evidence = store2.listEvidence(current.id);
+    if (evidence.length === 0) throw new Error("Long-term memory cannot advance without source evidence.");
+    const now3 = (/* @__PURE__ */ new Date()).toISOString();
+    const next = {
+      ...current,
+      state: input.next,
+      updatedAt: now3,
+      lastValidatedAt: now3,
+      ...input.next === "qualified" ? { qualifiedAt: now3 } : { approvedAt: now3 }
+    };
+    store2.update(next);
+    store2.recordEvent({
+      memoryId: next.id,
+      kind: input.event,
+      fromState: current.state,
+      toState: next.state,
+      detail: transitionDetail(input.reason),
+      createdAt: now3
+    });
+    return next;
+  });
+}
+async function qualifyLongTermMemory(input) {
+  return transitionMemory({ ...input, expected: "candidate", next: "qualified", event: "qualified" });
+}
+async function approveLongTermMemory(input) {
+  return transitionMemory({ ...input, expected: "qualified", next: "approved", event: "approved" });
+}
+async function archiveLongTermMemory(input) {
+  const store2 = await createStore(input.dataDir);
+  return store2.transaction(() => {
+    const current = store2.get(input.id);
+    if (!current) throw new Error("Long-term memory was not found.");
+    if (current.state === "archived" || current.state === "superseded") {
+      throw new Error("Long-term memory is already inactive.");
+    }
+    const now3 = (/* @__PURE__ */ new Date()).toISOString();
+    const next = { ...current, state: "archived", archivedAt: now3, updatedAt: now3 };
+    store2.update(next);
+    store2.recordEvent({
+      memoryId: next.id,
+      kind: "archived",
+      fromState: current.state,
+      toState: "archived",
+      detail: transitionDetail(input.reason),
+      createdAt: now3
+    });
+    return next;
+  });
+}
+async function supersedeLongTermMemory(input) {
+  const store2 = await createStore(input.dataDir);
+  return store2.transaction(() => {
+    const current = store2.get(input.id);
+    if (!current) throw new Error("Long-term memory was not found.");
+    if (current.state === "archived" || current.state === "superseded") {
+      throw new Error("Long-term memory is already inactive.");
+    }
+    if (current.id === input.supersededBy) {
+      throw new Error("Long-term memory cannot supersede itself.");
+    }
+    const replacement = store2.get(input.supersededBy);
+    if (!replacement || !isEligibleLongTermMemory(replacement)) {
+      throw new Error("Replacement long-term memory must be qualified or approved.");
+    }
+    if (replacement.scope !== current.scope) {
+      throw new Error("Replacement long-term memory must use the same scope.");
+    }
+    if (current.scope === "user" && replacement.ownerId !== current.ownerId) {
+      throw new Error("User long-term memory may only be superseded by the same local owner.");
+    }
+    if (current.scope !== "user" && replacement.originProjectId !== current.originProjectId) {
+      throw new Error("Project and team long-term memory may only be superseded within the same project.");
+    }
+    const now3 = (/* @__PURE__ */ new Date()).toISOString();
+    const next = {
+      ...current,
+      state: "superseded",
+      supersededBy: replacement.id,
+      updatedAt: now3
+    };
+    store2.update(next);
+    store2.recordEvent({
+      memoryId: next.id,
+      kind: "superseded",
+      fromState: current.state,
+      toState: "superseded",
+      detail: transitionDetail(input.reason),
+      createdAt: now3
+    });
+    return next;
+  });
+}
+async function 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 store2 = await createStore(input.dataDir);
+  const all = store2.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 store2.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((a4, b4) => Date.parse(b4.createdAt) - Date.parse(a4.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 store2 = await createStore(input.dataDir);
+  return store2.list({ limit: input.limit ?? 100 }).filter((memory) => canReadLongTermMemory(memory, input.reader)).filter((memory) => input.includeInactive || memory.state !== "archived" && memory.state !== "superseded").map((memory) => ({ memory, evidence: store2.listEvidence(memory.id) }));
+}
+async function getLongTermMemoryDetail(input) {
+  const store2 = await createStore(input.dataDir);
+  const memory = store2.get(input.id);
+  if (!memory || !canReadLongTermMemory(memory, input.reader)) {
+    throw new Error("Long-term memory was not found in the active scope.");
+  }
+  store2.markAccess([memory.id]);
+  return { memory, evidence: store2.listEvidence(memory.id), events: store2.listEvents(memory.id) };
+}
+async function selectLongTermMemoriesForTask(input) {
+  const task = input.task?.trim();
+  if (!task) return [];
+  const owner = await resolveLocalMemoryOwner(input.dataDir, { create: false });
+  const reader = {
+    projectId: input.projectId,
+    ...owner ? { ownerId: owner.id } : {},
+    ...input.agentId ? { agentId: input.agentId } : {},
+    ...input.isTeamMember ? { isTeamMember: true } : {}
+  };
+  const store2 = await createStore(input.dataDir);
+  const eligible = store2.list({ limit: 1e3 }).filter((memory) => isEligibleLongTermMemory(memory) && canReadLongTermMemory(memory, reader));
+  let selected = eligible.map((memory) => {
+    const ranked = scoreForTask(memory, task);
+    return ranked ? {
+      memory,
+      evidence: store2.listEvidence(memory.id),
+      score: ranked.score,
+      reason: ranked.reason
+    } : void 0;
+  }).filter((item) => Boolean(item)).sort((left, right) => right.score - left.score || right.memory.updatedAt.localeCompare(left.memory.updatedAt) || left.memory.id.localeCompare(right.memory.id));
+  if (selected.length === 0 && eligible.length > 0) {
+    const provider2 = await resolveSemanticProvider(input.embeddingProvider);
+    const candidates = eligible.slice(0, MAX_SEMANTIC_CANDIDATES);
+    if (provider2 && candidates.length > 0) {
+      try {
+        const vectors = await withTimeout(
+          provider2.embedBatch([task, ...candidates.map(semanticText)], {
+            timeoutMs: SEMANTIC_RETRIEVAL_TIMEOUT_MS,
+            retry: false
+          }),
+          SEMANTIC_RETRIEVAL_TIMEOUT_MS,
+          "Long-term semantic retrieval"
+        );
+        const query = vectors[0];
+        if (Array.isArray(query)) {
+          selected = candidates.map((memory, index) => {
+            const vector = vectors[index + 1];
+            const ranked = Array.isArray(vector) ? semanticSelection(memory, cosineSimilarity(query, vector), task) : void 0;
+            return ranked ? {
+              memory,
+              evidence: store2.listEvidence(memory.id),
+              score: ranked.score,
+              reason: ranked.reason
+            } : void 0;
+          }).filter((item) => Boolean(item)).sort((left, right) => right.score - left.score || right.memory.updatedAt.localeCompare(left.memory.updatedAt) || left.memory.id.localeCompare(right.memory.id));
+        }
+      } catch {
+      }
+    }
+  }
+  selected = selected.slice(0, Math.max(1, Math.min(input.limit ?? 3, 5)));
+  store2.markAccess(selected.map((item) => item.memory.id));
+  return selected;
+}
+function renderLongTermMemorySummary(memory, maxTokens = 22) {
+  const source = [memory.title, memory.applicability, memory.content].filter(Boolean).join(": ");
+  const safe = sanitizeCredentials(source).replace(/\s+/g, " ").trim();
+  return countTextTokens(safe) <= maxTokens ? safe : truncateToTokenBudget(safe, maxTokens);
+}
+var MAX_TEXT_LENGTH, MAX_LIST_ITEMS, MAX_SEMANTIC_CANDIDATES, SEMANTIC_RETRIEVAL_TIMEOUT_MS, MIN_SEMANTIC_SIMILARITY, PORTABLE_EVIDENCE_KINDS, STOP_TERMS;
+var init_long_term = __esm({
+  "src/memory/long-term.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_token_budget();
+    init_timeout();
+    init_secret_filter();
+    init_owner();
+    init_long_term_store();
+    init_long_term_types();
+    MAX_TEXT_LENGTH = 12e3;
+    MAX_LIST_ITEMS = 40;
+    MAX_SEMANTIC_CANDIDATES = 48;
+    SEMANTIC_RETRIEVAL_TIMEOUT_MS = 1800;
+    MIN_SEMANTIC_SIMILARITY = 0.58;
+    PORTABLE_EVIDENCE_KINDS = /* @__PURE__ */ new Set(["manual", "user"]);
+    STOP_TERMS = /* @__PURE__ */ new Set([
+      "the",
+      "and",
+      "for",
+      "with",
+      "from",
+      "that",
+      "this",
+      "into",
+      "when",
+      "what",
+      "\u5982\u4F55",
+      "\u4EC0\u4E48",
+      "\u8FD9\u4E2A",
+      "\u90A3\u4E2A",
+      "\u6211\u4EEC",
+      "\u9879\u76EE",
+      "\u8FDB\u884C",
+      "\u9700\u8981",
+      "\u7EE7\u7EED",
+      "\u5904\u7406"
+    ]);
+  }
+});
+
 // src/codegraph/ids.ts
 import { createHash as createHash5 } from "crypto";
 function digest(input) {
@@ -177484,7 +178377,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 {
@@ -178201,7 +179094,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(
@@ -178979,8 +179872,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) {
@@ -178996,38 +179889,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
   };
 }
@@ -179163,7 +180056,7 @@ var init_claim_store = __esm({
         locator, capturedHash, evidenceKey, createdAt
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `).run(
-          randomUUID7(),
+          randomUUID10(),
           input.claimId,
           input.evidenceKind,
           input.evidenceId,
@@ -179181,11 +180074,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()
@@ -179213,7 +180106,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);
       }
     };
   }
@@ -179230,8 +180123,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");
@@ -179239,7 +180132,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");
@@ -179268,7 +180161,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");
     }
@@ -179282,9 +180175,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") } : {}
     };
   });
 }
@@ -179292,10 +180185,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";
@@ -179316,7 +180209,7 @@ function normalizeClaimInput(input) {
   const now3 = (/* @__PURE__ */ new Date()).toISOString();
   return {
     claim: {
-      id: randomUUID8(),
+      id: randomUUID11(),
       projectId,
       subject,
       predicate,
@@ -179416,7 +180309,7 @@ function reviewClaim(store2, 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 store2.transaction(() => {
     const claim = store2.getClaim(input.claimId);
     if (!claim) throw new Error("Claim was not found");
@@ -179728,8 +180621,8 @@ var init_frontmatter = __esm({
 
 // src/knowledge/markdown.ts
 import { createHash as createHash10 } from "crypto";
-import { promises as fs11 } from "fs";
-import path18 from "path";
+import { promises as fs12 } from "fs";
+import path19 from "path";
 function hashContent(content) {
   return createHash10("sha256").update(content).digest("hex");
 }
@@ -179787,8 +180680,8 @@ function extractInternalMarkdownLinks(body) {
   return [...links].sort();
 }
 function resolvePageLink(sourceRelativePath, target) {
-  const sourceDir = path18.posix.dirname(sourceRelativePath.replace(/\\/g, "/"));
-  const normalized = path18.posix.normalize(path18.posix.join(sourceDir, target.replace(/\\/g, "/")));
+  const sourceDir = path19.posix.dirname(sourceRelativePath.replace(/\\/g, "/"));
+  const normalized = path19.posix.normalize(path19.posix.join(sourceDir, target.replace(/\\/g, "/")));
   if (!normalized || normalized === "." || normalized === ".." || normalized.startsWith("../")) return void 0;
   return normalized;
 }
@@ -179810,13 +180703,13 @@ function renderKnowledgePage(frontmatter, body) {
   });
 }
 async function readKnowledgePage(absolutePath, workspaceRoot) {
-  const raw = await fs11.readFile(absolutePath, "utf8");
+  const raw = await fs12.readFile(absolutePath, "utf8");
   try {
     const parsed = frontmatter_default(raw);
     const frontmatter = validateKnowledgePageFrontmatter(parsed.data);
     return {
       absolutePath,
-      relativePath: workspaceRoot ? path18.relative(workspaceRoot, absolutePath).split(path18.sep).join("/") : path18.basename(absolutePath),
+      relativePath: workspaceRoot ? path19.relative(workspaceRoot, absolutePath).split(path19.sep).join("/") : path19.basename(absolutePath),
       frontmatter,
       body: parsed.content.trim(),
       contentHash: hashContent(raw),
@@ -179828,7 +180721,7 @@ async function readKnowledgePage(absolutePath, workspaceRoot) {
   }
 }
 async function writeKnowledgePage(absolutePath, content) {
-  await fs11.mkdir(path18.dirname(absolutePath), { recursive: true });
+  await fs12.mkdir(path19.dirname(absolutePath), { recursive: true });
   await atomicWriteFile(absolutePath, content);
   return hashContent(content);
 }
@@ -179858,8 +180751,8 @@ __export(wiki_exports, {
   readKnowledgePage: () => readKnowledgePage
 });
 import { createHash as createHash11 } from "crypto";
-import { promises as fs12 } from "fs";
-import path19 from "path";
+import { promises as fs13 } from "fs";
+import path20 from "path";
 function hash2(value) {
   return createHash11("sha256").update(value).digest("hex");
 }
@@ -179991,7 +180884,7 @@ function candidatePage(workspace, title, claims, store2) {
 }
 async function fileHashIfPresent(filePath) {
   try {
-    return pageContentHash(await fs12.readFile(filePath, "utf8"));
+    return pageContentHash(await fs13.readFile(filePath, "utf8"));
   } catch (error40) {
     const code = error40 && typeof error40 === "object" && "code" in error40 ? error40.code : void 0;
     if (code === "ENOENT") return void 0;
@@ -180015,8 +180908,8 @@ async function writeIndex(workspace, store2) {
     lines.push("No pending proposals.");
   } else {
     for (const proposal of pending) {
-      const relative3 = path19.relative(paths.root, proposal.proposalPath).split(path19.sep).join("/");
-      lines.push("- [" + path19.basename(proposal.proposalPath, ".md") + "](" + relative3 + ")");
+      const relative3 = path20.relative(paths.root, proposal.proposalPath).split(path20.sep).join("/");
+      lines.push("- [" + path20.basename(proposal.proposalPath, ".md") + "](" + relative3 + ")");
     }
   }
   lines.push("");
@@ -180024,7 +180917,7 @@ async function writeIndex(workspace, store2) {
 }
 async function appendLog(workspace, line) {
   const logPath = getKnowledgeWorkspacePaths(workspace).log;
-  await fs12.appendFile(logPath, "- " + now() + " " + line + "\n", "utf8");
+  await fs13.appendFile(logPath, "- " + now() + " " + line + "\n", "utf8");
 }
 function toPageRecord(workspace, page, status, contentHash, manualContentHash) {
   return {
@@ -180109,9 +181002,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 = path19.resolve(proposal.targetPath);
-  const proposalPath = path19.resolve(proposal.proposalPath);
-  if (!targetPath.startsWith(root + path19.sep) || !proposalPath.startsWith(root + path19.sep)) {
+  const targetPath = path20.resolve(proposal.targetPath);
+  const proposalPath = path20.resolve(proposal.proposalPath);
+  if (!targetPath.startsWith(root + path20.sep) || !proposalPath.startsWith(root + path20.sep)) {
     throw new Error("Knowledge proposal path escapes its workspace");
   }
   await withFileLock(root, async () => {
@@ -180149,12 +181042,12 @@ async function markdownFiles(directory) {
   const files = [];
   let entries;
   try {
-    entries = await fs12.readdir(directory, { withFileTypes: true });
+    entries = await fs13.readdir(directory, { withFileTypes: true });
   } catch {
     return files;
   }
   for (const entry of entries) {
-    const filePath = path19.join(directory, entry.name);
+    const filePath = path20.join(directory, entry.name);
     if (entry.isDirectory()) {
       files.push(...await markdownFiles(filePath));
     } else if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) {
@@ -180177,13 +181070,13 @@ async function lintKnowledgeWorkspace(input) {
         kind: "malformed-frontmatter",
         severity: "error",
         message: error40 instanceof Error ? error40.message : "Malformed knowledge page.",
-        relativePath: path19.relative(paths.root, filePath).split(path19.sep).join("/")
+        relativePath: path20.relative(paths.root, filePath).split(path20.sep).join("/")
       });
     }
   }
   const indexed = /* @__PURE__ */ new Set();
   try {
-    const index = await fs12.readFile(paths.index, "utf8");
+    const index = await fs13.readFile(paths.index, "utf8");
     for (const link of extractInternalMarkdownLinks(index)) {
       const resolved = resolvePageLink("index.md", link);
       if (resolved) indexed.add(resolved);
@@ -180272,7 +181165,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: path19.relative(paths.root, proposal.targetPath).split(path19.sep).join("/")
+        relativePath: path20.relative(paths.root, proposal.targetPath).split(path20.sep).join("/")
       });
     }
   }
@@ -180405,7 +181298,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 {
@@ -180414,7 +181307,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) {
@@ -180451,14 +181344,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;
@@ -180505,7 +181398,7 @@ var init_workflow_store = __esm({
       }
       recordRun(input) {
         const run = {
-          id: randomUUID9(),
+          id: randomUUID12(),
           workflowId: input.workflowId,
           projectId: input.projectId,
           task: input.task.trim(),
@@ -180583,8 +181476,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) {
@@ -180607,8 +181500,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
   };
 }
@@ -180627,7 +181520,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"),
@@ -181054,8 +181947,8 @@ __export(workflows_exports, {
   writeCanonicalWorkflow: () => writeCanonicalWorkflow
 });
 import { createHash as createHash12 } from "crypto";
-import { promises as fs13 } from "fs";
-import path20 from "path";
+import { promises as fs14 } from "fs";
+import path21 from "path";
 function hash3(value) {
   return createHash12("sha256").update(value).digest("hex");
 }
@@ -181076,7 +181969,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");
@@ -181119,11 +182012,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")
@@ -181158,7 +182051,7 @@ function phasesFromBody(body) {
 }
 function normalizeSourcePath(sourcePath) {
   const normalized = sourcePath.replace(/\\/g, "/");
-  if (!normalized.startsWith("workflows/") || !normalized.toLowerCase().endsWith(".md") || normalized.includes("../") || path20.posix.normalize(normalized) !== normalized) {
+  if (!normalized.startsWith("workflows/") || !normalized.toLowerCase().endsWith(".md") || normalized.includes("../") || path21.posix.normalize(normalized) !== normalized) {
     throw new Error("workflow source path must be a safe workflows/*.md path");
   }
   return normalized;
@@ -181232,7 +182125,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"),
@@ -181251,9 +182144,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 (candidate2.phases.length === 0) {
     throw new Error("workflow must contain at least one phase or a non-empty body");
@@ -181307,7 +182200,7 @@ async function writeCanonicalWorkflow(input) {
   const filePath = resolveKnowledgeWorkspaceFile(input.workspace, workflow.sourcePath);
   const content = renderWorkflowMarkdown(workflow);
   await withFileLock(paths.root, async () => {
-    await fs13.mkdir(path20.dirname(filePath), { recursive: true });
+    await fs14.mkdir(path21.dirname(filePath), { recursive: true });
     await atomicWriteFile(filePath, content);
   });
   const store2 = await storeFor2(input.workspace);
@@ -181316,13 +182209,13 @@ async function writeCanonicalWorkflow(input) {
 async function markdownFiles2(directory) {
   let entries;
   try {
-    entries = await fs13.readdir(directory, { withFileTypes: true });
+    entries = await fs14.readdir(directory, { withFileTypes: true });
   } catch {
     return [];
   }
   const files = [];
   for (const entry of entries) {
-    const absolutePath = path20.join(directory, entry.name);
+    const absolutePath = path21.join(directory, entry.name);
     if (entry.isDirectory()) {
       files.push(...await markdownFiles2(absolutePath));
     } else if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) {
@@ -181337,9 +182230,9 @@ async function syncCanonicalWorkflows(workspace) {
   const workflows = [];
   const errors2 = [];
   for (const absolutePath of await markdownFiles2(paths.workflows)) {
-    const sourcePath = path20.relative(paths.root, absolutePath).split(path20.sep).join("/");
+    const sourcePath = path21.relative(paths.root, absolutePath).split(path21.sep).join("/");
     try {
-      const raw = await fs13.readFile(absolutePath, "utf8");
+      const raw = await fs14.readFile(absolutePath, "utf8");
       const workflow = parseWorkflowMarkdown(raw, { workspaceId: workspace.id, sourcePath });
       workflows.push(store2.upsertWorkflow(workflow));
     } catch (error40) {
@@ -181451,21 +182344,21 @@ function importedWorkflowSpec(input) {
   return materializeWorkflow(spec);
 }
 async function importWindsurfWorkflows(input) {
-  const sourceDirectory = path20.join(path20.resolve(input.projectRoot), ".windsurf", "workflows");
+  const sourceDirectory = path21.join(path21.resolve(input.projectRoot), ".windsurf", "workflows");
   const paths = getKnowledgeWorkspacePaths(input.workspace);
   const imported = [];
   const skipped = [];
   let entries;
   try {
-    entries = await fs13.readdir(sourceDirectory, { withFileTypes: true });
+    entries = await fs14.readdir(sourceDirectory, { withFileTypes: true });
   } catch {
     return { imported, skipped };
   }
   for (const entry of entries.filter((item) => item.isFile() && item.name.toLowerCase().endsWith(".md"))) {
-    const originalPath = path20.join(sourceDirectory, entry.name);
-    const sourcePath = path20.relative(path20.resolve(input.projectRoot), originalPath).split(path20.sep).join("/");
+    const originalPath = path21.join(sourceDirectory, entry.name);
+    const sourcePath = path21.relative(path21.resolve(input.projectRoot), originalPath).split(path21.sep).join("/");
     try {
-      const raw = await fs13.readFile(originalPath, "utf8");
+      const raw = await fs14.readFile(originalPath, "utf8");
       const workflow = importedWorkflowSpec({
         workspace: input.workspace,
         sourceName: entry.name,
@@ -181474,7 +182367,7 @@ async function importWindsurfWorkflows(input) {
       });
       const targetPath = resolveKnowledgeWorkspaceFile(input.workspace, workflow.sourcePath);
       try {
-        await fs13.access(targetPath);
+        await fs14.access(targetPath);
         skipped.push({ sourcePath, reason: "canonical workflow already exists and was preserved" });
         continue;
       } catch {
@@ -181487,12 +182380,12 @@ async function importWindsurfWorkflows(input) {
       });
     }
   }
-  await fs13.mkdir(paths.workflows, { recursive: true });
+  await fs14.mkdir(paths.workflows, { recursive: true });
   return { imported, skipped };
 }
 function isWithin2(root, candidate2) {
-  const relative3 = path20.relative(root, candidate2);
-  return relative3 !== "" && relative3 !== ".." && !relative3.startsWith(".." + path20.sep) && !path20.isAbsolute(relative3);
+  const relative3 = path21.relative(root, candidate2);
+  return relative3 !== "" && relative3 !== ".." && !relative3.startsWith(".." + path21.sep) && !path21.isAbsolute(relative3);
 }
 function adapterRelativePath(workflow, agent) {
   const name = "memorix-workflow-" + slug(workflow.id.replace(/^workflow:/, ""));
@@ -181578,15 +182471,15 @@ async function previewWorkflowAdapter(input) {
       reason: "The canonical workflow does not declare compatibility with this agent."
     };
   }
-  const projectRoot = path20.resolve(input.projectRoot);
-  const targetPath = path20.resolve(projectRoot, adapterRelativePath(input.workflow, input.agent));
+  const projectRoot = path21.resolve(input.projectRoot);
+  const targetPath = path21.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 fs13.readFile(targetPath, "utf8");
+    existing = await fs14.readFile(targetPath, "utf8");
   } catch (error40) {
     const code = error40 && typeof error40 === "object" && "code" in error40 ? error40.code : void 0;
     if (code !== "ENOENT") throw error40;
@@ -181607,11 +182500,11 @@ async function applyWorkflowAdapter(input) {
   if (initial.status === "unsupported" || initial.status === "conflict" || initial.status === "unchanged") {
     return initial;
   }
-  const projectRoot = path20.resolve(input.projectRoot);
+  const projectRoot = path21.resolve(input.projectRoot);
   return withFileLock(projectRoot, async () => {
     const current = await previewWorkflowAdapter(input);
     if (current.status !== "create" && current.status !== "update") return current;
-    await fs13.mkdir(path20.dirname(current.targetPath), { recursive: true });
+    await fs14.mkdir(path21.dirname(current.targetPath), { recursive: true });
     await atomicWriteFile(current.targetPath, current.content);
     return current;
   });
@@ -181901,6 +182794,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, {
@@ -182242,15 +183140,15 @@ __export(vector_backfill_runner_exports, {
 });
 import { spawn as spawn4 } from "child_process";
 import { existsSync as existsSync12 } from "fs";
-import path21 from "path";
+import path22 from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 function isNonEmptyString(value) {
   return typeof value === "string" && value.trim().length > 0;
 }
 function resolveVectorBackfillRunnerPath(moduleUrl = import.meta.url) {
-  const moduleDir = path21.dirname(fileURLToPath6(moduleUrl));
-  const distDir = path21.basename(moduleDir) === "cli" ? path21.dirname(moduleDir) : path21.basename(moduleDir) === "runtime" && path21.basename(path21.dirname(moduleDir)) === "src" ? path21.join(path21.dirname(path21.dirname(moduleDir)), "dist") : moduleDir;
-  return path21.join(distDir, "vector-backfill-runner.js");
+  const moduleDir = path22.dirname(fileURLToPath6(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");
 }
 function parseVectorBackfillRequest(raw) {
   let value;
@@ -182259,7 +183157,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) || !path21.isAbsolute(value.projectRoot) || !path21.isAbsolute(value.dataDir)) {
+  if (!value || typeof value !== "object" || !isNonEmptyString(value.projectId) || !isNonEmptyString(value.projectRoot) || !isNonEmptyString(value.dataDir) || !path22.isAbsolute(value.projectRoot) || !path22.isAbsolute(value.dataDir)) {
     throw new Error("Vector backfill runner received an invalid request");
   }
   return {
@@ -183783,7 +184681,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,
@@ -184015,6 +184913,14 @@ async function searchObservations(options) {
     });
     intermediate.sort((a4, b4) => b4.score - a4.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((a4, b4) => (b4.score ?? 0) - (a4.score ?? 0));
+  }
   if (options.since) {
     const sinceDate = new Date(options.since).getTime();
     intermediate = intermediate.filter((e5) => new Date(e5.rawTime).getTime() >= sinceDate);
@@ -185021,9 +185927,9 @@ __export(team_store_exports, {
   isTeamStoreInitialized: () => isTeamStoreInitialized,
   resetTeamStore: () => resetTeamStore
 });
-import { randomUUID as randomUUID11 } from "crypto";
-import path22 from "path";
-import fs14 from "fs";
+import { randomUUID as randomUUID14 } from "crypto";
+import path23 from "path";
+import fs15 from "fs";
 function getTeamStore() {
   if (!_teamStore) {
     throw new Error("[memorix] TeamStore not initialized \u2014 call initTeamStore() first");
@@ -185310,7 +186216,7 @@ var init_team_store = __esm({
        * reactivate it (preserving agent_id). Otherwise create a new one.
        */
       registerAgent(input) {
-        const instanceId = input.instanceId || randomUUID11();
+        const instanceId = input.instanceId || randomUUID14();
         const now3 = Date.now();
         const existing = this.stmtAgentFindByInstance.get(
           input.projectId,
@@ -185336,7 +186242,7 @@ var init_team_store = __esm({
           this.eventBus?.emit("agent:joined", { agentId: row2.agent_id, projectId: input.projectId, agentType: input.agentType });
           return row2;
         }
-        const agentId = randomUUID11();
+        const agentId = randomUUID14();
         this.stmtAgentUpsert.run({
           agent_id: agentId,
           project_id: input.projectId,
@@ -185438,7 +186344,7 @@ var init_team_store = __esm({
             return { error: `Recipient agent '${input.recipientAgentId}' not found \u2014 cannot send to unknown agent` };
           }
         }
-        const id = randomUUID11();
+        const id = randomUUID14();
         const now3 = Date.now();
         const row = {
           id,
@@ -185488,7 +186394,7 @@ var init_team_store = __esm({
       // Task Operations (with atomic claim semantics)
       // ═══════════════════════════════════════════════════════════════════
       createTask(input) {
-        const taskId = randomUUID11();
+        const taskId = randomUUID14();
         const now3 = Date.now();
         const row = {
           task_id: taskId,
@@ -185713,19 +186619,19 @@ var init_team_store = __esm({
         const agentCount = this.db.prepare(`SELECT COUNT(*) AS cnt FROM team_agents`).get();
         if (agentCount.cnt > 0) return;
         const candidates = [
-          path22.join(this.dataDir, "team-state.json"),
-          path22.join(this.dataDir, "..", "team-state.json")
+          path23.join(this.dataDir, "team-state.json"),
+          path23.join(this.dataDir, "..", "team-state.json")
         ];
         let jsonPath = null;
         for (const p3 of candidates) {
-          if (fs14.existsSync(p3)) {
+          if (fs15.existsSync(p3)) {
             jsonPath = p3;
             break;
           }
         }
         if (!jsonPath) return;
         try {
-          const raw = fs14.readFileSync(jsonPath, "utf-8");
+          const raw = fs15.readFileSync(jsonPath, "utf-8");
           const snap = JSON.parse(raw);
           if (snap.version !== 1) return;
           console.error(`[memorix] Migrating team-state.json to SQLite...`);
@@ -185760,7 +186666,7 @@ var init_team_store = __esm({
               for (const [agentId, msgs] of Object.entries(snap.messages.inboxes)) {
                 for (const msg of msgs) {
                   this.stmtMsgInsert.run({
-                    id: msg.id ?? randomUUID11(),
+                    id: msg.id ?? randomUUID14(),
                     project_id: "migrated",
                     sender_agent_id: msg.from ?? "unknown",
                     recipient_agent_id: msg.to === "__broadcast__" ? null : msg.to ?? agentId,
@@ -185819,7 +186725,7 @@ var init_team_store = __esm({
             `[memorix] Team migration complete: ${agentsMigrated} agents, ${messagesMigrated} messages, ${tasksMigrated} tasks, ${locksMigrated} locks.`
           );
           try {
-            fs14.renameSync(jsonPath, jsonPath + ".migrated");
+            fs15.renameSync(jsonPath, jsonPath + ".migrated");
           } catch {
           }
         } catch (err) {
@@ -185854,7 +186760,7 @@ var init_team_store = __esm({
        * Uses projectId derived from the dataDir path.
        */
       seedDefaultRoles(dataDir) {
-        const projectId = path22.basename(path22.resolve(dataDir, ".."));
+        const projectId = path23.basename(path23.resolve(dataDir, ".."));
         const count3 = this.stmtRoleCountByProject.get(projectId).cnt;
         if (count3 > 0) return;
         const now3 = Date.now();
@@ -185948,10 +186854,10 @@ var init_team_store = __esm({
 });
 
 // src/cli/identity.ts
-import { promises as fs15 } from "fs";
-import path23 from "path";
+import { promises as fs16 } from "fs";
+import path24 from "path";
 function identityPath(dataDir) {
-  return path23.join(dataDir, "cli-identity.json");
+  return path24.join(dataDir, "cli-identity.json");
 }
 function isCliIdentity(value) {
   if (!value || typeof value !== "object") return false;
@@ -185960,18 +186866,18 @@ function isCliIdentity(value) {
 }
 async function loadCliIdentity(dataDir, projectId) {
   try {
-    const parsed = JSON.parse(await fs15.readFile(identityPath(dataDir), "utf8"));
+    const parsed = JSON.parse(await fs16.readFile(identityPath(dataDir), "utf8"));
     return isCliIdentity(parsed) && parsed.projectId === projectId ? parsed : null;
   } catch {
     return null;
   }
 }
 async function saveCliIdentity(dataDir, identity) {
-  await fs15.writeFile(identityPath(dataDir), `${JSON.stringify(identity, null, 2)}
+  await fs16.writeFile(identityPath(dataDir), `${JSON.stringify(identity, null, 2)}
 `, "utf8");
 }
 async function clearCliIdentity(dataDir) {
-  await fs15.rm(identityPath(dataDir), { force: true });
+  await fs16.rm(identityPath(dataDir), { force: true });
 }
 async function resolveCliIdentity(options) {
   const stored = await loadCliIdentity(options.dataDir, options.project.id);
@@ -187321,8 +188227,8 @@ __export(session_store_exports, {
   initSessionStore: () => initSessionStore,
   resetSessionStore: () => resetSessionStore
 });
-import path24 from "path";
-import fs16 from "fs";
+import path25 from "path";
+import fs17 from "fs";
 function sessionToRow(session) {
   return {
     id: session.id,
@@ -187408,10 +188314,10 @@ var init_session_store = __esm({
       async migrateFromJsonIfNeeded() {
         const count3 = this.db.prepare(`SELECT COUNT(*) AS cnt FROM sessions`).get();
         if (count3.cnt > 0) return;
-        const jsonPath = path24.join(this.dataDir, "sessions.json");
-        if (!fs16.existsSync(jsonPath)) return;
+        const jsonPath = path25.join(this.dataDir, "sessions.json");
+        if (!fs17.existsSync(jsonPath)) return;
         try {
-          const raw = fs16.readFileSync(jsonPath, "utf-8");
+          const raw = fs17.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...`);
@@ -187753,827 +188659,6 @@ var init_operator_shared = __esm({
   }
 });
 
-// src/memory/owner.ts
-var owner_exports = {};
-__export(owner_exports, {
-  resolveLocalMemoryOwner: () => resolveLocalMemoryOwner
-});
-import { randomUUID as randomUUID12 } from "crypto";
-import { promises as fs17 } from "fs";
-import path25 from "path";
-function ownerPath(dataDir) {
-  const resolved = path25.resolve(dataDir);
-  const home = path25.basename(resolved).toLocaleLowerCase("en-US") === "data" ? path25.dirname(resolved) : resolved;
-  return path25.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(path25.dirname(filePath), { recursive: true });
-  const created = {
-    version: 1,
-    id: "local-" + randomUUID12(),
-    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 (error40) {
-    if (error40?.code !== "EEXIST") throw error40;
-    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 randomUUID13 } 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(fn2) {
-        return this.db.transaction(fn2)();
-      }
-      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: randomUUID13(),
-          ...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: randomUUID13(),
-          ...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, at2 = (/* @__PURE__ */ new Date()).toISOString()) {
-        const unique3 = [...new Set(ids.filter(Boolean))];
-        if (unique3.length === 0) return;
-        const statement = this.db.prepare(`
-      UPDATE long_term_memories
-      SET accessCount = accessCount + 1, lastAccessedAt = ?
-      WHERE id = ?
-    `);
-        this.db.transaction(() => {
-          for (const id of unique3) statement.run(at2, 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 randomUUID14 } from "crypto";
-function isOneOf(value, values) {
-  return typeof value === "string" && values.includes(value);
-}
-function compactText2(value, field, max = MAX_TEXT_LENGTH) {
-  if (typeof value !== "string") throw new Error("Long-term memory " + field + " must be text.");
-  const safe = sanitizeCredentials(value).replace(/\s+/g, " ").trim();
-  if (!safe) throw new Error("Long-term memory " + field + " is required.");
-  if (safe.length > max) throw new Error("Long-term memory " + field + " is too long.");
-  return safe;
-}
-function compactList(values, field) {
-  if (!values) return [];
-  if (!Array.isArray(values)) throw new Error("Long-term memory " + field + " must be an array.");
-  return [...new Set(values.filter((value) => typeof value === "string").map((value) => compactText2(value, field, 500)))].slice(0, MAX_LIST_ITEMS);
-}
-function normalizeEvidence(input) {
-  if (!Array.isArray(input) || input.length === 0) {
-    throw new Error("A long-term memory requires at least one source evidence reference.");
-  }
-  return input.map((evidence) => {
-    if (!evidence || !isOneOf(evidence.kind, LONG_TERM_MEMORY_EVIDENCE_KINDS)) {
-      throw new Error("Long-term memory evidence kind is invalid.");
-    }
-    if (!isOneOf(evidence.relation, LONG_TERM_MEMORY_EVIDENCE_RELATIONS)) {
-      throw new Error("Long-term memory evidence relation is invalid.");
-    }
-    return {
-      kind: evidence.kind,
-      referenceId: compactText2(evidence.referenceId, "evidence reference", 1e3),
-      relation: evidence.relation,
-      ...evidence.locator ? { locator: compactText2(evidence.locator, "evidence locator", 1e3) } : {},
-      ...evidence.capturedHash ? { capturedHash: compactText2(evidence.capturedHash, "evidence hash", 1e3) } : {}
-    };
-  });
-}
-function assertScope(scope) {
-  if (!isOneOf(scope, LONG_TERM_MEMORY_SCOPES)) throw new Error("Long-term memory scope is invalid.");
-}
-function assertKind(kind) {
-  if (!isOneOf(kind, LONG_TERM_MEMORY_KINDS)) throw new Error("Long-term memory kind is invalid.");
-}
-function assertPortability(value) {
-  if (!isOneOf(value, LONG_TERM_MEMORY_PORTABILITIES)) {
-    throw new Error("Long-term memory portability is invalid.");
-  }
-}
-function assertPortableEvidence(scope, portability, evidence) {
-  if (portability !== "portable") return;
-  if (scope !== "user") {
-    throw new Error("Only user-scoped long-term memories may be portable across projects.");
-  }
-  if (evidence.some((item) => !PORTABLE_EVIDENCE_KINDS.has(item.kind))) {
-    throw new Error("Portable user memory may only use manual or user-confirmed evidence; project code, Git, observation, test, session, claim, and workflow evidence must remain project-bound.");
-  }
-}
-function requireTeamReader(scope, reader) {
-  if (scope === "team" && reader?.isTeamMember !== true) {
-    throw new Error("Team long-term memory requires an explicit active team identity for this project.");
-  }
-}
-function matchesScope(memory, reader) {
-  if (memory.scope === "project") return memory.originProjectId === reader.projectId;
-  if (memory.scope === "team") {
-    return memory.originProjectId === reader.projectId && reader.isTeamMember === true;
-  }
-  if (!reader.ownerId || memory.ownerId !== reader.ownerId) return false;
-  return memory.portability === "portable" || memory.originProjectId === reader.projectId;
-}
-function canReadLongTermMemory(memory, reader) {
-  return matchesScope(memory, reader);
-}
-function isEligibleLongTermMemory(memory) {
-  return memory.state === "qualified" || memory.state === "approved";
-}
-function taskTerms(task) {
-  const matches = task.toLocaleLowerCase("en-US").match(/[\p{L}\p{N}_./:-]+/gu) ?? [];
-  return [...new Set(matches.filter((term) => term.length > 1 && !STOP_TERMS.has(term)))].slice(0, 16);
-}
-function kindFitScore(kind, task) {
-  const normalized = task.toLocaleLowerCase("en-US");
-  const hints = {
-    episodic: ["resume", "continue", "handoff", "previous", "session", "\u63A5\u624B", "\u7EE7\u7EED", "\u4EA4\u63A5", "\u4E0A\u6B21", "\u4F1A\u8BDD"],
-    semantic: ["why", "what", "architecture", "design", "decision", "reason", "\u4E3A\u4EC0\u4E48", "\u662F\u4EC0\u4E48", "\u67B6\u6784", "\u8BBE\u8BA1", "\u51B3\u7B56", "\u539F\u56E0"],
-    procedural: ["how", "steps", "procedure", "run", "release", "publish", "verify", "implement", "\u6D41\u7A0B", "\u6B65\u9AA4", "\u53D1\u5E03", "\u9A8C\u8BC1", "\u4FEE\u590D", "\u5B9E\u73B0"]
-  };
-  return hints[kind].some((hint) => normalized.includes(hint)) ? 1 : 0;
-}
-function validationFreshnessScore(memory) {
-  const validatedAt = memory.lastValidatedAt ?? memory.approvedAt ?? memory.qualifiedAt;
-  if (!validatedAt) return 0;
-  const time3 = Date.parse(validatedAt);
-  if (!Number.isFinite(time3)) return 0;
-  const ageDays = Math.max(0, Date.now() - time3) / (24 * 60 * 60 * 1e3);
-  if (ageDays <= 30) return 0.35;
-  if (ageDays <= 90) return 0.15;
-  return 0;
-}
-function scoreForTask(memory, task) {
-  const terms = taskTerms(task);
-  if (terms.length === 0) return void 0;
-  const title = memory.title.toLocaleLowerCase("en-US");
-  const content = memory.content.toLocaleLowerCase("en-US");
-  const facts = memory.facts.join(" ").toLocaleLowerCase("en-US");
-  const tags = memory.tags.join(" ").toLocaleLowerCase("en-US");
-  const applicability = (memory.applicability ?? "").toLocaleLowerCase("en-US");
-  let score = memory.state === "approved" ? 0.5 : 0;
-  const matched = [];
-  for (const term of terms) {
-    let termScore = 0;
-    if (title.includes(term)) termScore += 5;
-    if (tags.includes(term)) termScore += 4;
-    if (applicability.includes(term)) termScore += 3;
-    if (facts.includes(term)) termScore += 2;
-    if (content.includes(term)) termScore += 1;
-    if (termScore > 0) {
-      score += termScore;
-      matched.push(term);
-    }
-  }
-  if (matched.length === 0) return void 0;
-  score += kindFitScore(memory.kind, task);
-  score += validationFreshnessScore(memory);
-  const kindLabel = memory.kind === "procedural" ? "procedure" : memory.kind === "semantic" ? "fact" : "episode";
-  const freshness = validationFreshnessScore(memory) > 0 ? "; recently validated" : "";
-  return { score, reason: kindLabel + " matches " + matched.slice(0, 3).join(", ") + freshness };
-}
-function semanticText(memory) {
-  return sanitizeCredentials([
-    memory.title,
-    memory.applicability,
-    memory.tags.join(" "),
-    memory.facts.join(" "),
-    memory.content
-  ].filter((value) => Boolean(value)).join("\n")).replace(/\s+/g, " ").trim().slice(0, MAX_TEXT_LENGTH);
-}
-function cosineSimilarity(left, right) {
-  if (left.length === 0 || left.length !== right.length) return 0;
-  let dot = 0;
-  let leftMagnitude = 0;
-  let rightMagnitude = 0;
-  for (let index = 0; index < left.length; index += 1) {
-    const a4 = left[index];
-    const b4 = right[index];
-    if (!Number.isFinite(a4) || !Number.isFinite(b4)) return 0;
-    dot += a4 * b4;
-    leftMagnitude += a4 * a4;
-    rightMagnitude += b4 * b4;
-  }
-  if (leftMagnitude === 0 || rightMagnitude === 0) return 0;
-  return dot / Math.sqrt(leftMagnitude * rightMagnitude);
-}
-function semanticSelection(memory, similarity, task) {
-  if (similarity < MIN_SEMANTIC_SIMILARITY) return void 0;
-  const kindLabel = memory.kind === "procedural" ? "procedure" : memory.kind === "semantic" ? "fact" : "episode";
-  const freshness = validationFreshnessScore(memory) > 0 ? "; recently validated" : "";
-  return {
-    score: similarity * 10 + (memory.state === "approved" ? 0.5 : 0) + kindFitScore(memory.kind, task) + validationFreshnessScore(memory),
-    reason: kindLabel + " semantic match " + similarity.toFixed(2) + freshness
-  };
-}
-async function resolveSemanticProvider(explicit) {
-  if (explicit !== void 0) return explicit;
-  try {
-    const { getEmbeddingProvider: getEmbeddingProvider2 } = await Promise.resolve().then(() => (init_provider(), provider_exports));
-    return await withTimeout(
-      getEmbeddingProvider2({ requestTimeoutMs: SEMANTIC_RETRIEVAL_TIMEOUT_MS, retry: false }),
-      SEMANTIC_RETRIEVAL_TIMEOUT_MS,
-      "Long-term semantic provider initialization"
-    );
-  } catch {
-    return null;
-  }
-}
-function createStore(dataDir) {
-  const store2 = new LongTermMemoryStore();
-  return store2.init(dataDir).then(() => store2);
-}
-async function createManualLongTermMemory(input) {
-  const owner = await resolveLocalMemoryOwner(input.dataDir, { create: true });
-  if (!owner) throw new Error("Memorix could not resolve a local memory owner.");
-  assertScope(input.scope);
-  const evidence = input.scope === "user" ? [{ kind: "user", referenceId: owner.id, relation: "user-confirmed" }] : [{ kind: "manual", referenceId: "manual:" + randomUUID14(), 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: randomUUID14(),
-    originProjectId: compactText2(input.originProjectId, "origin project id", 1e3),
-    ownerId: compactText2(input.ownerId, "owner id", 160),
-    scope: input.scope,
-    kind: input.kind,
-    state: "candidate",
-    portability,
-    title: compactText2(input.title, "title", 500),
-    content: compactText2(input.content, "content"),
-    facts: compactList(input.facts, "facts"),
-    tags: compactList(input.tags, "tags"),
-    ...input.applicability ? { applicability: compactText2(input.applicability, "applicability", 1e3) } : {},
-    origin: input.origin ?? "manual",
-    createdAt: now3,
-    updatedAt: now3,
-    accessCount: 0
-  };
-  const store2 = await createStore(input.dataDir);
-  const evidence = store2.transaction(() => {
-    store2.insert(memory);
-    const written = evidenceInputs.map((item) => store2.insertEvidence({ memoryId: memory.id, ...item, createdAt: now3 }));
-    store2.recordEvent({
-      memoryId: memory.id,
-      kind: "created",
-      toState: "candidate",
-      detail: "Created as a source-backed long-term memory candidate.",
-      createdAt: now3
-    });
-    return written;
-  });
-  return { memory, evidence };
-}
-function transitionDetail(value) {
-  return compactText2(value, "transition reason", 1e3);
-}
-async function transitionMemory(input) {
-  const store2 = await createStore(input.dataDir);
-  return store2.transaction(() => {
-    const current = store2.get(input.id);
-    if (!current) throw new Error("Long-term memory was not found.");
-    if (current.state !== input.expected) {
-      throw new Error("Long-term memory must be " + input.expected + " before it can be " + input.next + ".");
-    }
-    const evidence = store2.listEvidence(current.id);
-    if (evidence.length === 0) throw new Error("Long-term memory cannot advance without source evidence.");
-    const now3 = (/* @__PURE__ */ new Date()).toISOString();
-    const next = {
-      ...current,
-      state: input.next,
-      updatedAt: now3,
-      lastValidatedAt: now3,
-      ...input.next === "qualified" ? { qualifiedAt: now3 } : { approvedAt: now3 }
-    };
-    store2.update(next);
-    store2.recordEvent({
-      memoryId: next.id,
-      kind: input.event,
-      fromState: current.state,
-      toState: next.state,
-      detail: transitionDetail(input.reason),
-      createdAt: now3
-    });
-    return next;
-  });
-}
-async function qualifyLongTermMemory(input) {
-  return transitionMemory({ ...input, expected: "candidate", next: "qualified", event: "qualified" });
-}
-async function approveLongTermMemory(input) {
-  return transitionMemory({ ...input, expected: "qualified", next: "approved", event: "approved" });
-}
-async function archiveLongTermMemory(input) {
-  const store2 = await createStore(input.dataDir);
-  return store2.transaction(() => {
-    const current = store2.get(input.id);
-    if (!current) throw new Error("Long-term memory was not found.");
-    if (current.state === "archived" || current.state === "superseded") {
-      throw new Error("Long-term memory is already inactive.");
-    }
-    const now3 = (/* @__PURE__ */ new Date()).toISOString();
-    const next = { ...current, state: "archived", archivedAt: now3, updatedAt: now3 };
-    store2.update(next);
-    store2.recordEvent({
-      memoryId: next.id,
-      kind: "archived",
-      fromState: current.state,
-      toState: "archived",
-      detail: transitionDetail(input.reason),
-      createdAt: now3
-    });
-    return next;
-  });
-}
-async function supersedeLongTermMemory(input) {
-  const store2 = await createStore(input.dataDir);
-  return store2.transaction(() => {
-    const current = store2.get(input.id);
-    if (!current) throw new Error("Long-term memory was not found.");
-    if (current.state === "archived" || current.state === "superseded") {
-      throw new Error("Long-term memory is already inactive.");
-    }
-    if (current.id === input.supersededBy) {
-      throw new Error("Long-term memory cannot supersede itself.");
-    }
-    const replacement = store2.get(input.supersededBy);
-    if (!replacement || !isEligibleLongTermMemory(replacement)) {
-      throw new Error("Replacement long-term memory must be qualified or approved.");
-    }
-    if (replacement.scope !== current.scope) {
-      throw new Error("Replacement long-term memory must use the same scope.");
-    }
-    if (current.scope === "user" && replacement.ownerId !== current.ownerId) {
-      throw new Error("User long-term memory may only be superseded by the same local owner.");
-    }
-    if (current.scope !== "user" && replacement.originProjectId !== current.originProjectId) {
-      throw new Error("Project and team long-term memory may only be superseded within the same project.");
-    }
-    const now3 = (/* @__PURE__ */ new Date()).toISOString();
-    const next = {
-      ...current,
-      state: "superseded",
-      supersededBy: replacement.id,
-      updatedAt: now3
-    };
-    store2.update(next);
-    store2.recordEvent({
-      memoryId: next.id,
-      kind: "superseded",
-      fromState: current.state,
-      toState: "superseded",
-      detail: transitionDetail(input.reason),
-      createdAt: now3
-    });
-    return next;
-  });
-}
-async function listLongTermMemories(input) {
-  const store2 = await createStore(input.dataDir);
-  return store2.list({ limit: input.limit ?? 100 }).filter((memory) => canReadLongTermMemory(memory, input.reader)).filter((memory) => input.includeInactive || memory.state !== "archived" && memory.state !== "superseded").map((memory) => ({ memory, evidence: store2.listEvidence(memory.id) }));
-}
-async function getLongTermMemoryDetail(input) {
-  const store2 = await createStore(input.dataDir);
-  const memory = store2.get(input.id);
-  if (!memory || !canReadLongTermMemory(memory, input.reader)) {
-    throw new Error("Long-term memory was not found in the active scope.");
-  }
-  store2.markAccess([memory.id]);
-  return { memory, evidence: store2.listEvidence(memory.id), events: store2.listEvents(memory.id) };
-}
-async function selectLongTermMemoriesForTask(input) {
-  const task = input.task?.trim();
-  if (!task) return [];
-  const owner = await resolveLocalMemoryOwner(input.dataDir, { create: false });
-  const reader = {
-    projectId: input.projectId,
-    ...owner ? { ownerId: owner.id } : {},
-    ...input.agentId ? { agentId: input.agentId } : {},
-    ...input.isTeamMember ? { isTeamMember: true } : {}
-  };
-  const store2 = await createStore(input.dataDir);
-  const eligible = store2.list({ limit: 1e3 }).filter((memory) => isEligibleLongTermMemory(memory) && canReadLongTermMemory(memory, reader));
-  let selected = eligible.map((memory) => {
-    const ranked = scoreForTask(memory, task);
-    return ranked ? {
-      memory,
-      evidence: store2.listEvidence(memory.id),
-      score: ranked.score,
-      reason: ranked.reason
-    } : void 0;
-  }).filter((item) => Boolean(item)).sort((left, right) => right.score - left.score || right.memory.updatedAt.localeCompare(left.memory.updatedAt) || left.memory.id.localeCompare(right.memory.id));
-  if (selected.length === 0 && eligible.length > 0) {
-    const provider2 = await resolveSemanticProvider(input.embeddingProvider);
-    const candidates = eligible.slice(0, MAX_SEMANTIC_CANDIDATES);
-    if (provider2 && candidates.length > 0) {
-      try {
-        const vectors = await withTimeout(
-          provider2.embedBatch([task, ...candidates.map(semanticText)], {
-            timeoutMs: SEMANTIC_RETRIEVAL_TIMEOUT_MS,
-            retry: false
-          }),
-          SEMANTIC_RETRIEVAL_TIMEOUT_MS,
-          "Long-term semantic retrieval"
-        );
-        const query = vectors[0];
-        if (Array.isArray(query)) {
-          selected = candidates.map((memory, index) => {
-            const vector = vectors[index + 1];
-            const ranked = Array.isArray(vector) ? semanticSelection(memory, cosineSimilarity(query, vector), task) : void 0;
-            return ranked ? {
-              memory,
-              evidence: store2.listEvidence(memory.id),
-              score: ranked.score,
-              reason: ranked.reason
-            } : void 0;
-          }).filter((item) => Boolean(item)).sort((left, right) => right.score - left.score || right.memory.updatedAt.localeCompare(left.memory.updatedAt) || left.memory.id.localeCompare(right.memory.id));
-        }
-      } catch {
-      }
-    }
-  }
-  selected = selected.slice(0, Math.max(1, Math.min(input.limit ?? 3, 5)));
-  store2.markAccess(selected.map((item) => item.memory.id));
-  return selected;
-}
-function renderLongTermMemorySummary(memory, maxTokens = 22) {
-  const source = [memory.title, memory.applicability, memory.content].filter(Boolean).join(": ");
-  const safe = sanitizeCredentials(source).replace(/\s+/g, " ").trim();
-  return countTextTokens(safe) <= maxTokens ? safe : truncateToTokenBudget(safe, maxTokens);
-}
-var MAX_TEXT_LENGTH, MAX_LIST_ITEMS, MAX_SEMANTIC_CANDIDATES, SEMANTIC_RETRIEVAL_TIMEOUT_MS, MIN_SEMANTIC_SIMILARITY, PORTABLE_EVIDENCE_KINDS, STOP_TERMS;
-var init_long_term = __esm({
-  "src/memory/long-term.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_token_budget();
-    init_timeout();
-    init_secret_filter();
-    init_owner();
-    init_long_term_store();
-    init_long_term_types();
-    MAX_TEXT_LENGTH = 12e3;
-    MAX_LIST_ITEMS = 40;
-    MAX_SEMANTIC_CANDIDATES = 48;
-    SEMANTIC_RETRIEVAL_TIMEOUT_MS = 1800;
-    MIN_SEMANTIC_SIMILARITY = 0.58;
-    PORTABLE_EVIDENCE_KINDS = /* @__PURE__ */ new Set(["manual", "user"]);
-    STOP_TERMS = /* @__PURE__ */ new Set([
-      "the",
-      "and",
-      "for",
-      "with",
-      "from",
-      "that",
-      "this",
-      "into",
-      "when",
-      "what",
-      "\u5982\u4F55",
-      "\u4EC0\u4E48",
-      "\u8FD9\u4E2A",
-      "\u90A3\u4E2A",
-      "\u6211\u4EEC",
-      "\u9879\u76EE",
-      "\u8FDB\u884C",
-      "\u9700\u8981",
-      "\u7EE7\u7EED",
-      "\u5904\u7406"
-    ]);
-  }
-});
-
 // src/cli/commands/memory.ts
 var memory_exports2 = {};
 __export(memory_exports2, {
@@ -189052,6 +189137,7 @@ var init_memory3 = __esm({
                 createManualLongTermMemory: createManualLongTermMemory2,
                 getLongTermMemoryDetail: getLongTermMemoryDetail2,
                 listLongTermMemories: listLongTermMemories2,
+                maybeAutoQualifyLongTermMemory: maybeAutoQualifyLongTermMemory2,
                 promoteObservationToLongTermMemory: promoteObservationToLongTermMemory2,
                 qualifyLongTermMemory: qualifyLongTermMemory2,
                 supersedeLongTermMemory: supersedeLongTermMemory2
@@ -189122,9 +189208,14 @@ var init_memory3 = __esm({
                     portability: portability(),
                     reader: longTermReader
                   });
+                  const qualified = await maybeAutoQualifyLongTermMemory2({
+                    dataDir,
+                    id: result.memory.id,
+                    source: "manual"
+                  });
                   emitResult(
-                    { project, ...result },
-                    `Created long-term memory candidate ${result.memory.id}. Qualify it after checking its evidence.`,
+                    { project, ...result, memory: qualified ?? result.memory },
+                    `Created long-term memory ${result.memory.id}.`,
                     asJson
                   );
                   return;
@@ -189150,9 +189241,14 @@ var init_memory3 = __esm({
                     applicability: asStringArg(args.applicability),
                     reader: longTermReader
                   });
+                  const qualified = await maybeAutoQualifyLongTermMemory2({
+                    dataDir,
+                    id: result.memory.id,
+                    sourceDetail: "explicit"
+                  });
                   emitResult(
-                    { project, sourceObservationId: observation.id, ...result },
-                    `Promoted observation #${observation.id} to long-term memory candidate ${result.memory.id}.`,
+                    { project, sourceObservationId: observation.id, ...result, memory: qualified ?? result.memory },
+                    `Promoted observation #${observation.id} to long-term memory ${result.memory.id}.`,
                     asJson
                   );
                   return;
@@ -192200,13 +192296,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 |",
@@ -192590,7 +192701,9 @@ function buildMemorixServer(mcp) {
   return {
     name: "memorix",
     command: "memorix",
-    args: ["serve"]
+    // The installed surface must expose every tool the generated guidance
+    // teaches. lite covers the full taught set; micro would hide half of it.
+    args: ["serve", "--mode", "lite"]
   };
 }
 function mergeJsonMcpConfig(existingContent, generatedContent) {
@@ -194313,6 +194426,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
   );
@@ -194783,6 +194927,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) } : {},
@@ -196832,6 +196977,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((a4, b4) => Date.parse(b4.endedAt ?? "") - Date.parse(a4.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((a4, b4) => (b4.memory.updatedAt ?? "").localeCompare(a4.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." };
@@ -197036,12 +197208,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),
@@ -197224,7 +197403,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)}`,
@@ -197233,7 +197421,7 @@ function formatAutoProjectContextSummary(context) {
     `- Refresh: ${context.refresh.message}`,
     "",
     "Start here"
-  ].filter(Boolean);
+  ].filter(Boolean));
   if (startHere.length > 0) {
     startHere.forEach((path47, index) => lines.push(`${index + 1}. ${path47}`));
   } else {
@@ -197357,6 +197545,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;
@@ -216457,6 +216647,46 @@ var init_formation_timeout = __esm({
   }
 });
 
+// src/search/surfaced-registry.ts
+function touch(key) {
+  const ids = registry2.get(key);
+  if (!ids) return [];
+  registry2.delete(key);
+  registry2.set(key, ids);
+  return ids;
+}
+function getSurfacedIds(key) {
+  return [...touch(key)];
+}
+function recordSurfacedIds(key, ids) {
+  if (ids.length === 0) return;
+  let list = registry2.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);
+  }
+  registry2.set(key, list);
+  if (registry2.size > MAX_KEYS) {
+    const oldestKey = registry2.keys().next().value;
+    if (oldestKey !== void 0 && oldestKey !== key) registry2.delete(oldestKey);
+  }
+}
+var MAX_KEYS, MAX_IDS, registry2;
+var init_surfaced_registry = __esm({
+  "src/search/surfaced-registry.ts"() {
+    "use strict";
+    init_esm_shims();
+    MAX_KEYS = 64;
+    MAX_IDS = 200;
+    registry2 = /* @__PURE__ */ new Map();
+  }
+});
+
 // src/server/request-context.ts
 var request_context_exports = {};
 __export(request_context_exports, {
@@ -217660,8 +217890,8 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
           const { promises: fsP } = await import("fs");
           const registryPath = path39.join(baseDir, ".project-aliases.json");
           const raw = await fsP.readFile(registryPath, "utf-8");
-          const registry2 = JSON.parse(raw);
-          aliasGroups = registry2.groups || [];
+          const registry3 = JSON.parse(raw);
+          aliasGroups = registry3.groups || [];
         } catch {
         }
         const currentGroup = aliasGroups.find((g4) => g4.aliases?.includes(effectiveProjectId) || g4.canonical === effectiveProjectId);
@@ -258410,6 +258640,12 @@ async function createMemorixServer(cwd, existingServer, sharedTeam, options = {}
         kind: "consolidation",
         dedupeKey: "startup-consolidation"
       });
+      lifecycle.enqueueLongTermMaintenance({
+        dataDir: projectDir2,
+        projectId: project.id,
+        source: "startup",
+        queue: queue2
+      });
     }
     try {
       const { CodeGraphStore: CodeGraphStore2 } = await Promise.resolve().then(() => (init_store(), store_exports));
@@ -258459,7 +258695,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.4.6" : "1.0.1"
   });
   const originalRegisterTool = server.registerTool.bind(server);
   server.registerTool = ((name, ...args) => {
@@ -258944,7 +259180,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,
@@ -258958,7 +259194,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 = `
@@ -259154,6 +259407,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;
@@ -259171,7 +259431,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 {
@@ -259190,6 +259451,7 @@ Use this as the \`topicKey\` parameter in \`memorix_store\` to enable upsert beh
           }
           throw error40;
         }
+        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);
@@ -262152,13 +262414,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: external_exports2.enum(["import", "attach", "list", "show", "derive-pdf", "derive-audio", "generate-image", "generate-video", "status", "cancel"]),
+        action: external_exports2.enum([
+          "import",
+          "attach",
+          "list",
+          "show",
+          "derive-pdf",
+          "status",
+          "cancel",
+          ...mediaTranscriptionEnabled ? ["derive-audio"] : [],
+          ...mediaGenerationEnabled ? ["generate-image", "generate-video"] : []
+        ]),
         path: external_exports2.string().optional().describe("Explicit local image/audio/video/PDF path for import."),
         assetId: external_exports2.string().optional().describe("Controlled MediaAsset ID for attach/show."),
         jobId: external_exports2.string().optional().describe("Durable media job ID for status."),
@@ -262166,20 +262441,26 @@ ${lines.join("\n")}` }] };
         limit: external_exports2.number().int().min(1).max(100).optional().describe("Maximum assets to list."),
         title: external_exports2.string().optional().describe("Observation title when attaching generated/imported output."),
         narrative: external_exports2.string().optional().describe("Short retrieval text when attaching an asset."),
-        prompt: external_exports2.string().optional().describe("Explicit MiniMax generation prompt."),
-        image: external_exports2.string().optional().describe("Base64-encoded reference image for image-to-image generation."),
-        model: external_exports2.string().max(160).optional().describe("Provider model for the selected media action."),
-        provider: external_exports2.enum(["openai", "groq"]).optional().describe("Explicit audio transcription provider."),
-        language: external_exports2.string().max(32).optional().describe("Optional ISO-639-1 hint for audio transcription."),
-        region: external_exports2.enum(["global", "cn"]).optional().describe("MiniMax deployment region."),
-        n: external_exports2.number().int().min(1).max(4).optional().describe("Image output count."),
-        ratio: external_exports2.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: external_exports2.number().int().min(1).max(8192).optional().describe("Requested image width."),
-        height: external_exports2.number().int().min(1).max(8192).optional().describe("Requested image height."),
-        duration: external_exports2.union([external_exports2.literal(5), external_exports2.literal(10)]).optional().describe("MiniMax video duration in seconds."),
         maxPages: external_exports2.number().int().min(1).max(100).optional().describe("Bounded PDF extraction page limit."),
         maxChars: external_exports2.number().int().min(1).max(6e4).optional().describe("Bounded PDF extraction character limit."),
-        attach: external_exports2.boolean().optional().describe("Attach generated/imported output to normal project memory explicitly.")
+        attach: external_exports2.boolean().optional().describe("Attach generated/imported output to normal project memory explicitly."),
+        ...mediaGenerationOrTranscription ? {
+          model: external_exports2.string().max(160).optional().describe("Provider model for the selected media action."),
+          prompt: external_exports2.string().optional().describe("Explicit prompt for generation or transcription.")
+        } : {},
+        ...mediaTranscriptionEnabled ? {
+          provider: external_exports2.enum(["openai", "groq"]).optional().describe("Explicit audio transcription provider."),
+          language: external_exports2.string().max(32).optional().describe("Optional ISO-639-1 hint for audio transcription.")
+        } : {},
+        ...mediaGenerationEnabled ? {
+          image: external_exports2.string().optional().describe("Base64-encoded reference image for image-to-image generation."),
+          region: external_exports2.enum(["global", "cn"]).optional().describe("MiniMax deployment region."),
+          n: external_exports2.number().int().min(1).max(4).optional().describe("Image output count."),
+          ratio: external_exports2.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: external_exports2.number().int().min(1).max(8192).optional().describe("Requested image width."),
+          height: external_exports2.number().int().min(1).max(8192).optional().describe("Requested image height."),
+          duration: external_exports2.union([external_exports2.literal(5), external_exports2.literal(10)]).optional().describe("MiniMax video duration in seconds.")
+        } : {}
       }
     },
     async ({ action, path: assetPath, assetId, jobId, kind, limit: limit2, title, narrative, prompt: prompt2, image, model, provider: provider2, language, region, n: n3, ratio, width, height, duration: duration3, maxPages, maxChars, attach }) => {
@@ -262665,6 +262946,7 @@ var init_server4 = __esm({
     init_formation_timeout();
     init_timeout();
     init_secret_filter();
+    init_surfaced_registry();
     init_request_context();
     FORMATION_TIMEOUT_MS = parseFormationTimeoutMs(process.env.MEMORIX_FORMATION_TIMEOUT_MS);
     COMPACT_ON_WRITE_TIMEOUT_MS = 12e3;
@@ -265243,7 +265525,8 @@ var init_control_plane_maintenance = __esm({
       "claim-requalification",
       "knowledge-compile",
       "knowledge-lint",
-      "workflow-index"
+      "workflow-index",
+      "long-term-maintenance"
     ];
     TARGET_WAIT_RETRY_MS = 3e4;
   }
@@ -265255,7 +265538,8 @@ __export(serve_http_exports, {
   DEFAULT_SESSION_TIMEOUT_MS: () => DEFAULT_SESSION_TIMEOUT_MS,
   _testing: () => _testing2,
   default: () => serve_http_default,
-  parseSessionTimeoutMs: () => parseSessionTimeoutMs
+  parseSessionTimeoutMs: () => parseSessionTimeoutMs,
+  resolveServeHttpDefaults: () => resolveServeHttpDefaults
 });
 function parseSessionTimeoutMs(raw) {
   const value = raw?.trim();
@@ -265264,6 +265548,15 @@ function parseSessionTimeoutMs(raw) {
   if (!Number.isFinite(parsed) || parsed <= 0) return DEFAULT_SESSION_TIMEOUT_MS;
   return Math.floor(parsed);
 }
+function resolveServeHttpDefaults(argsPort, configured) {
+  const configuredPort = typeof configured.port === "number" && Number.isFinite(configured.port) ? configured.port : void 0;
+  const port = parseTcpPortOrReport(argsPort, configuredPort ?? 3211);
+  if (port === void 0) {
+    return { port: 3211 };
+  }
+  const transportNotice = configured.transport === "stdio" ? '[memorix] config server.transport = "stdio"; serve-http continues on HTTP (the explicit command wins).' : void 0;
+  return { port, transportNotice };
+}
 var DEFAULT_SESSION_TIMEOUT_MS, serve_http_default, _testing2;
 var init_serve_http = __esm({
   "src/cli/commands/serve-http.ts"() {
@@ -265314,11 +265607,15 @@ var init_serve_http = __esm({
         const { findGitInSubdirs: findGitInSubdirs2 } = await Promise.resolve().then(() => (init_detector(), detector_exports));
         const { writeFileSync: writeFileSync11, mkdirSync: mkdirSync11 } = await import("fs");
         const { homedir: homedir36 } = await import("os");
-        const port = parseTcpPortOrReport(args.port, 3211);
-        if (port === void 0) {
-          process.exitCode = 1;
-          return;
+        let configuredDefaults = {};
+        try {
+          const { getServerConfig: getServerConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+          configuredDefaults = getServerConfig2();
+        } catch {
         }
+        const resolved = resolveServeHttpDefaults(args.port, configuredDefaults);
+        if (resolved.transportNotice) console.error(resolved.transportNotice);
+        const port = resolved.port;
         const host = args.host || "127.0.0.1";
         const toolProfile = resolveToolProfile({ explicit: args.mode, envValue: process.env.MEMORIX_MODE, fallback: "team" });
         let safeCwd;
@@ -266190,8 +266487,8 @@ var init_serve_http = __esm({
                 canonicalId = await aliasModule.getCanonicalId(idProjectId);
                 const registryPath = pathModule.default.join(baseDir, ".project-aliases.json");
                 const raw = await fsPromises.readFile(registryPath, "utf-8");
-                const registry2 = JSON.parse(raw);
-                aliasGroups = registry2.groups || [];
+                const registry3 = JSON.parse(raw);
+                aliasGroups = registry3.groups || [];
               } catch {
               }
               const currentGroup = aliasGroups.find((g4) => g4.aliases?.includes(idProjectId) || g4.canonical === idProjectId);
@@ -269262,7 +269559,8 @@ function normalizeCommitCount(count3) {
   }
   return count3;
 }
-function getCommitInfo(cwd, ref = "HEAD") {
+function getCommitInfo(cwd, ref = "HEAD", maxDiffChars = 500) {
+  const cap = Number.isFinite(maxDiffChars) ? Math.max(0, Math.floor(maxDiffChars)) : 500;
   const FORMAT = "%H%n%h%n%aN%n%aI%n%s%n%b";
   const revision = normalizeCommitRef(ref);
   const raw = runGit3(cwd, ["log", "-1", `--format=${FORMAT}`, "--end-of-options", revision]).trim();
@@ -269290,7 +269588,7 @@ function getCommitInfo(cwd, ref = "HEAD") {
   let diffSummary = "";
   try {
     const diff = runGit3(cwd, ["diff-tree", "-p", "--no-commit-id", hash4], 1024 * 100);
-    diffSummary = diff.substring(0, 500);
+    diffSummary = diff.substring(0, cap);
   } catch {
   }
   return {
@@ -269541,8 +269839,23 @@ var init_noise_filter = __esm({
 // src/cli/commands/ingest-commit.ts
 var ingest_commit_exports = {};
 __export(ingest_commit_exports, {
+  applyGitIngestPolicy: () => applyGitIngestPolicy,
   default: () => ingest_commit_default
 });
+function applyGitIngestPolicy(commit, policy) {
+  if (policy.ingestOnCommit === false) {
+    return {
+      skip: true,
+      reason: "ingest_on_commit is disabled",
+      diffSummary: commit.diffSummary
+    };
+  }
+  const cap = policy.maxDiffSize;
+  return {
+    skip: false,
+    diffSummary: typeof cap === "number" && Number.isFinite(cap) ? commit.diffSummary.slice(0, Math.max(0, Math.floor(cap))) : commit.diffSummary
+  };
+}
 var ingest_commit_default;
 var init_ingest_commit = __esm({
   "src/cli/commands/ingest-commit.ts"() {
@@ -269585,11 +269898,21 @@ var init_ingest_commit = __esm({
         const force = !!args.force;
         if (!auto) we(`Ingest commit: ${ref}`);
         try {
-          const { getCommitInfo: getCommitInfo2, ingestCommit: ingestCommit2 } = await Promise.resolve().then(() => (init_extractor(), extractor_exports));
-          const commit = getCommitInfo2(cwd, ref);
-          const { shouldFilterCommit: shouldFilterCommit2 } = await Promise.resolve().then(() => (init_noise_filter(), noise_filter_exports));
           const { getGitConfig: getGitConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
           const gitCfg = getGitConfig2();
+          const { getCommitInfo: getCommitInfo2, ingestCommit: ingestCommit2 } = await Promise.resolve().then(() => (init_extractor(), extractor_exports));
+          const commit = getCommitInfo2(cwd, ref, gitCfg.maxDiffSize ?? 500);
+          const policy = applyGitIngestPolicy(commit, {
+            ingestOnCommit: gitCfg.ingestOnCommit,
+            maxDiffSize: gitCfg.maxDiffSize
+          });
+          if (policy.skip && auto) {
+            console.error(`[memorix] Skipped ${commit.shortHash}: ${policy.reason}`);
+            process.exit(0);
+            return;
+          }
+          commit.diffSummary = policy.diffSummary;
+          const { shouldFilterCommit: shouldFilterCommit2 } = await Promise.resolve().then(() => (init_noise_filter(), noise_filter_exports));
           const filterResult = shouldFilterCommit2(commit, {
             skipMergeCommits: gitCfg.skipMergeCommits,
             excludePatterns: gitCfg.excludePatterns,
@@ -272948,21 +273271,28 @@ var init_dashboard = __esm({
       args: {
         port: {
           type: "string",
-          description: "Port to run the dashboard on (default: 3210)",
-          default: "3210"
+          description: "Port to run the dashboard on (default: [server].dashboardPort or 3210)",
+          required: false
         }
       },
       run: async ({ args }) => {
         const { detectProject: detectProject2 } = await Promise.resolve().then(() => (init_detector(), detector_exports));
         const { getProjectDataDir: getProjectDataDir2 } = await Promise.resolve().then(() => (init_persistence(), persistence_exports));
         const { startDashboard: startDashboard2 } = await Promise.resolve().then(() => (init_server3(), server_exports));
+        let configuredDashboardPort;
+        try {
+          const { getServerConfig: getServerConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+          const serverConfig = getServerConfig2();
+          configuredDashboardPort = typeof serverConfig.dashboardPort === "number" ? serverConfig.dashboardPort : void 0;
+        } catch {
+        }
         const project = detectProject2();
         if (!project) {
           console.error("Memorix requires a git repo to establish project identity. Run `git init` in this workspace first.");
           process.exit(1);
         }
         const dataDir = await getProjectDataDir2(project.id);
-        const port = parseTcpPortOrReport(args.port, 3210);
+        const port = parseTcpPortOrReport(args.port, configuredDashboardPort ?? 3210);
         if (port === void 0) {
           process.exitCode = 1;
           return;
@@ -273219,6 +273549,116 @@ Project: ${projectName} (${projectId})
   }
 });
 
+// src/cli/commands/purge.ts
+var purge_exports = {};
+__export(purge_exports, {
+  default: () => purge_default
+});
+var purge_default;
+var init_purge = __esm({
+  "src/cli/commands/purge.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_dist2();
+    init_detector();
+    init_persistence();
+    purge_default = defineCommand({
+      meta: {
+        name: "purge",
+        description: "Retire memories from retrieval (current project by default, --all for every project)"
+      },
+      args: {
+        all: {
+          type: "boolean",
+          description: "Purge every project instead of the current one",
+          default: false
+        },
+        yes: {
+          type: "boolean",
+          description: "Skip the interactive confirmation",
+          default: false
+        },
+        json: {
+          type: "boolean",
+          description: "Emit a machine-readable result",
+          default: false
+        }
+      },
+      async run({ args }) {
+        const purgeAll = Boolean(args.all);
+        const yes = Boolean(args.yes);
+        const asJson = Boolean(args.json);
+        if (!yes && !process.stdin.isTTY) {
+          console.error("[ERROR] Non-interactive environment. Add --yes to confirm.");
+          console.error("[ERROR] Refusing to purge memories without confirmation.");
+          process.exitCode = 1;
+          return;
+        }
+        if (!yes) {
+          const readline = await import("readline");
+          const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+          const question = purgeAll ? "Retire ALL memories from every project? (y/N) " : "Retire all memories for this project? (y/N) ";
+          const answer = await new Promise((resolve6) => rl.question(question, resolve6));
+          rl.close();
+          if (answer.trim().toLowerCase() !== "y") {
+            console.log("Cancelled.");
+            return;
+          }
+        }
+        let projectId = null;
+        if (!purgeAll) {
+          const project = detectProject();
+          if (!project) {
+            console.error("[ERROR] No .git found \u2014 run from a project directory or pass --all.");
+            process.exitCode = 1;
+            return;
+          }
+          projectId = project.id;
+        }
+        const dataDir = await getProjectDataDir(projectId ?? "");
+        const { initObservationStore: initObservationStore2 } = await Promise.resolve().then(() => (init_obs_store(), obs_store_exports));
+        const { getAllObservations: getAllObservations2, resolveObservations: resolveObservations2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
+        const { withFreshIndex: withFreshIndex2 } = await Promise.resolve().then(() => (init_freshness(), freshness_exports));
+        await initObservationStore2(dataDir);
+        const observations2 = await withFreshIndex2(() => getAllObservations2());
+        const target = purgeAll ? observations2 : observations2.filter((o4) => o4.projectId === projectId);
+        const ids = target.map((o4) => o4.id).filter((id) => typeof id === "number");
+        const archived = ids.length > 0 ? (await resolveObservations2(ids, "archived")).resolved.length : 0;
+        const { LongTermMemoryStore: LongTermMemoryStore2 } = await Promise.resolve().then(() => (init_long_term_store(), long_term_store_exports));
+        const { archiveLongTermMemory: archiveLongTermMemory2 } = await Promise.resolve().then(() => (init_long_term(), long_term_exports));
+        const longTermStore = new LongTermMemoryStore2();
+        await longTermStore.init(dataDir);
+        let longTermArchived = 0;
+        for (const memory of longTermStore.list()) {
+          if (memory.state === "archived" || memory.state === "superseded") continue;
+          if (!purgeAll && memory.originProjectId !== projectId) continue;
+          try {
+            await archiveLongTermMemory2({
+              dataDir,
+              id: memory.id,
+              reason: purgeAll ? "purge --all" : "purge (project) " + (projectId ?? "")
+            });
+            longTermArchived += 1;
+          } catch {
+          }
+        }
+        const result = {
+          scope: purgeAll ? "all" : projectId,
+          observationsArchived: archived,
+          longTermArchived
+        };
+        if (asJson) {
+          console.log(JSON.stringify(result));
+        } else {
+          console.log(
+            `[OK] Purged ${purgeAll ? "all projects" : result.scope}: archived ${archived} observations and ${longTermArchived} long-term memories.`
+          );
+        }
+      }
+    });
+  }
+});
+
 // src/cli/commands/uninstall.ts
 var uninstall_exports = {};
 __export(uninstall_exports, {
@@ -282119,6 +282559,7 @@ var main2 = defineCommand({
     repair: () => Promise.resolve().then(() => (init_repair3(), repair_exports)).then((m6) => m6.default),
     dashboard: () => Promise.resolve().then(() => (init_dashboard(), dashboard_exports)).then((m6) => m6.default),
     cleanup: () => Promise.resolve().then(() => (init_cleanup(), cleanup_exports)).then((m6) => m6.default),
+    purge: () => Promise.resolve().then(() => (init_purge(), purge_exports)).then((m6) => m6.default),
     uninstall: () => Promise.resolve().then(() => (init_uninstall(), uninstall_exports)).then((m6) => m6.default),
     orchestrate: () => Promise.resolve().then(() => (init_orchestrate(), orchestrate_exports)).then((m6) => m6.default),
     workbench: () => Promise.resolve(defineCommand({
@@ -282194,6 +282635,7 @@ var main2 = defineCommand({
       "repair",
       "dashboard",
       "cleanup",
+      "purge",
       "uninstall",
       "orchestrate"
     ];
@@ -282257,6 +282699,7 @@ var main2 = defineCommand({
       console.error("  dashboard  Open standalone dashboard (read-mostly)");
       console.error("  hooks      Open legacy hook installer menu");
       console.error("  cleanup    Remove old memories");
+      console.error("  purge      Retire all memories (project by default, --all for everything)");
       console.error("  sync       Rules/workspace sync plus interactive wizard");
       console.error("  ingest     Ingest commit, log, or image knowledge");
       console.error("\nRun `memorix` in an interactive terminal for memcode TUI.");