memorix 1.4.4 → 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.4" : 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;
@@ -190538,9 +190634,116 @@ var init_trae = __esm({
   }
 });
 
-// src/workspace/mcp-adapters/codebuddy.ts
+// src/workspace/mcp-adapters/dsh.ts
 import { homedir as homedir22 } from "os";
 import { join as join19 } from "path";
+function resolveDshHome() {
+  const configured = process.env.DSH_HOME?.trim();
+  if (configured) return configured;
+  return join19(homedir22(), ".dsh");
+}
+function isMemorixRow(row) {
+  if (!row || typeof row !== "object" || Array.isArray(row)) return false;
+  const record2 = row;
+  if (record2.name !== MCP_CLIENT_PLUGIN) return false;
+  const config2 = record2.config;
+  return Boolean(
+    config2 && typeof config2 === "object" && !Array.isArray(config2) && config2.serverName === "memorix"
+  );
+}
+function rowToEntry(row) {
+  const config2 = row.config;
+  if (!config2 || typeof config2 !== "object") return null;
+  const entry = {
+    name: "memorix",
+    command: typeof config2.command === "string" ? config2.command : "",
+    args: Array.isArray(config2.args) ? config2.args.filter((arg) => typeof arg === "string") : []
+  };
+  if (typeof config2.url === "string" && config2.url) entry.url = config2.url;
+  if (config2.env && typeof config2.env === "object" && !Array.isArray(config2.env)) {
+    const env3 = {};
+    for (const [key, value] of Object.entries(config2.env)) {
+      if (typeof value === "string") env3[key] = value;
+    }
+    if (Object.keys(env3).length > 0) entry.env = env3;
+  }
+  if (config2.disabled === true) entry.disabled = true;
+  return entry;
+}
+function patchRows(document2) {
+  const rows = [];
+  if (!Array.isArray(document2)) return rows;
+  for (const item of document2) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) continue;
+    const record2 = item;
+    if (Array.isArray(record2.insert)) {
+      for (const row of record2.insert) {
+        if (row && typeof row === "object" && !Array.isArray(row)) {
+          rows.push(row);
+        }
+      }
+      continue;
+    }
+    rows.push(record2);
+  }
+  return rows;
+}
+var import_yaml4, MCP_CLIENT_PLUGIN, MEMORIX_ROW_ID, DshMCPAdapter;
+var init_dsh = __esm({
+  "src/workspace/mcp-adapters/dsh.ts"() {
+    "use strict";
+    init_esm_shims();
+    import_yaml4 = __toESM(require_dist(), 1);
+    MCP_CLIENT_PLUGIN = "@deepseek-ai/dsh-mcp-client";
+    MEMORIX_ROW_ID = "memory-memorix";
+    DshMCPAdapter = class {
+      source = "dsh";
+      parse(content) {
+        if (!content.trim()) return [];
+        let document2;
+        try {
+          document2 = (0, import_yaml4.parse)(content);
+        } catch {
+          return [];
+        }
+        return patchRows(document2).filter(isMemorixRow).map(rowToEntry).filter((entry) => entry !== null);
+      }
+      generate(servers) {
+        const rows = servers.filter((server) => server.name === "memorix").map((server) => {
+          const config2 = {
+            serverName: server.name
+          };
+          if (server.url) {
+            config2.transport = "streamable-http";
+            config2.url = server.url;
+            if (server.headers && Object.keys(server.headers).length > 0) config2.headers = server.headers;
+          } else {
+            config2.transport = "stdio";
+            config2.command = server.command;
+            if (server.args && server.args.length > 0) config2.args = server.args;
+            if (server.env && Object.keys(server.env).length > 0) config2.env = server.env;
+          }
+          const row = {
+            id: MEMORIX_ROW_ID,
+            name: MCP_CLIENT_PLUGIN,
+            config: config2
+          };
+          if (server.disabled === true) row.disabled = true;
+          return row;
+        });
+        if (rows.length === 0) return "";
+        return (0, import_yaml4.stringify)([{ insert: rows }], { lineWidth: 0 }) + "\n";
+      }
+      getConfigPath(_projectRoot) {
+        return join19(resolveDshHome(), "cordis.patch.yml");
+      }
+    };
+  }
+});
+
+// src/workspace/mcp-adapters/codebuddy.ts
+import { homedir as homedir23 } from "os";
+import { join as join20 } from "path";
 var CodeBuddyMCPAdapter;
 var init_codebuddy = __esm({
   "src/workspace/mcp-adapters/codebuddy.ts"() {
@@ -190572,7 +190775,7 @@ var init_codebuddy = __esm({
         return JSON.stringify({ mcpServers }, null, 2);
       }
       getConfigPath(projectRoot) {
-        return projectRoot ? join19(projectRoot, ".mcp.json") : join19(homedir22(), ".codebuddy", ".mcp.json");
+        return projectRoot ? join20(projectRoot, ".mcp.json") : join20(homedir23(), ".codebuddy", ".mcp.json");
       }
     };
   }
@@ -190713,6 +190916,15 @@ var init_registry2 = __esm({
         install: "memorix setup --agent trae",
         surfaces: ["MCP", "rules"]
       },
+      {
+        agent: "dsh",
+        name: "DeepSeek Harness",
+        entry: "official-config",
+        status: "ready",
+        install: "memorix setup --agent dsh",
+        surfaces: ["MCP", "AGENTS.md", "skills"],
+        note: "DeepSeek Harness support writes a @deepseek-ai/dsh-mcp-client row into $DSH_HOME/cordis.patch.yml (default ~/.dsh/cordis.patch.yml), guidance into the harness AGENTS.md, and skills under $DSH_HOME/skills."
+      },
       {
         agent: "memcode",
         name: "memcode",
@@ -191006,9 +191218,9 @@ __export(audit_exports, {
 });
 import * as fs18 from "fs/promises";
 import * as path28 from "path";
-import { homedir as homedir23 } from "os";
+import { homedir as homedir24 } from "os";
 function getAuditFilePath() {
-  return process.env.MEMORIX_AUDIT_FILE || path28.join(homedir23(), ".memorix", "audit.json");
+  return process.env.MEMORIX_AUDIT_FILE || path28.join(homedir24(), ".memorix", "audit.json");
 }
 async function loadAudit() {
   try {
@@ -191321,7 +191533,7 @@ async function installOfficialSkillsForAgent(agent, projectRoot, global2 = false
   const dirs = AGENT_SKILL_DIRS[agent];
   const relativeDir = global2 ? dirs?.global : dirs?.project;
   if (!relativeDir) return [];
-  const root = global2 ? os3.homedir() : projectRoot;
+  const root = global2 ? agent === "dsh" ? process.env.DSH_HOME?.trim() || path29.join(os3.homedir(), ".dsh") : os3.homedir() : projectRoot;
   const skillPaths = [];
   for (const skillEntry of OFFICIAL_MEMORIX_SKILLS) {
     const skillPath = path29.join(root, relativeDir, skillEntry.name, "SKILL.md");
@@ -191553,6 +191765,8 @@ function getProjectConfigPath(agent, projectRoot) {
       return path29.join(projectRoot, "AGENTS.md");
     case "trae":
       return path29.join(projectRoot, ".trae", "rules", "project_rules.md");
+    case "dsh":
+      return path29.join(projectRoot, "AGENTS.md");
     case "opencode":
       return path29.join(projectRoot, ".opencode", "plugins", "memorix.js");
     case "pi":
@@ -191598,6 +191812,8 @@ function getGlobalConfigPath(agent) {
       return path29.join(home, ".omp", "agent", "packages", "memorix", "extensions", "memorix.js");
     case "trae":
       return path29.join(home, ".trae", "rules", "project_rules.md");
+    case "dsh":
+      return path29.join(process.env.DSH_HOME?.trim() || path29.join(home, ".dsh"), "AGENTS.md");
     default:
       return path29.join(home, ".memorix", "hooks.json");
   }
@@ -191622,6 +191838,8 @@ function getAgentRulesPath(agent, root, global2 = false) {
         return path29.join(root, ".gemini", "GEMINI.md");
       case "trae":
         return path29.join(root, ".trae", "rules", "project_rules.md");
+      case "dsh":
+        return path29.join(process.env.DSH_HOME?.trim() || path29.join(root, ".dsh"), "AGENTS.md");
       default:
         return path29.join(root, ".agent", "rules", "memorix.md");
     }
@@ -191646,6 +191864,8 @@ function getAgentRulesPath(agent, root, global2 = false) {
       return path29.join(root, "GEMINI.md");
     case "trae":
       return path29.join(root, ".trae", "rules", "project_rules.md");
+    case "dsh":
+      return path29.join(root, "AGENTS.md");
     default:
       return path29.join(root, ".agent", "rules", "memorix.md");
   }
@@ -191728,6 +191948,12 @@ async function detectInstalledAgents() {
     agents.push("trae");
   } catch {
   }
+  const dshDir = process.env.DSH_HOME?.trim() || path29.join(home, ".dsh");
+  try {
+    await fs19.access(dshDir);
+    agents.push("dsh");
+  } catch {
+  }
   return agents;
 }
 async function installHooks(agent, projectRoot, global2 = false) {
@@ -191810,6 +192036,19 @@ async function installHooks(agent, projectRoot, global2 = false) {
         generated: { note: "Trae has no hooks system, only rules (.trae/rules/project_rules.md) installed" }
       };
     }
+    case "dsh": {
+      const rulesPath = await installAgentRules(agent, projectRoot, global2);
+      const skillPaths2 = await installOfficialSkillsForAgent(agent, projectRoot, global2);
+      return {
+        agent,
+        configPath: rulesPath,
+        events: [],
+        generated: {
+          note: "DeepSeek Harness has no hook system \u2014 installed AGENTS.md guidance and skills; the MCP row is installed by `memorix setup --agent dsh`.",
+          ...skillPaths2.length > 0 ? { skillPaths: skillPaths2, skillPath: skillPaths2[0] } : {}
+        }
+      };
+    }
     case "opencode": {
       const pluginContent = generateOpenCodePlugin();
       const pluginPath = global2 ? getGlobalConfigPath(agent) : getProjectConfigPath(agent, projectRoot);
@@ -191944,7 +192183,7 @@ async function installAgentRules(agent, projectRoot, global2 = false) {
   const rulesPath = getAgentRulesPath(agent, rulesRoot, global2);
   try {
     await fs19.mkdir(path29.dirname(rulesPath), { recursive: true });
-    if (agent === "claude" || agent === "codex" || agent === "opencode" || agent === "antigravity" || agent === "gemini-cli") {
+    if (agent === "claude" || agent === "codex" || agent === "opencode" || agent === "antigravity" || agent === "gemini-cli" || agent === "dsh") {
       try {
         const existing = await fs19.readFile(rulesPath, "utf-8");
         await fs19.writeFile(rulesPath, mergeMemorixRulesContent(existing, rulesContent), "utf-8");
@@ -192057,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 |",
@@ -192233,7 +192487,10 @@ var init_installers = __esm({
       windsurf: { project: path29.join(".windsurf", "skills"), global: path29.join(".windsurf", "skills") },
       kiro: { project: path29.join(".kiro", "skills"), global: path29.join(".kiro", "skills") },
       opencode: { project: path29.join(".opencode", "skills"), global: path29.join(".config", "opencode", "skills") },
-      trae: { project: path29.join(".trae", "skills"), global: path29.join(".trae", "skills") }
+      trae: { project: path29.join(".trae", "skills"), global: path29.join(".trae", "skills") },
+      // DSH's user skill root is <harness home>/skills; the global root below is
+      // resolved to $DSH_HOME (or ~/.dsh) for dsh by installOfficialSkillsForAgent.
+      dsh: { project: path29.join(".dsh", "skills"), global: "skills" }
     };
     PACKAGE_OWNED_HOOK_AGENTS = /* @__PURE__ */ new Set(["openclaw", "hermes", "omp"]);
   }
@@ -192266,7 +192523,7 @@ __export(setup_exports, {
 import { spawnSync } from "child_process";
 import { existsSync as existsSync14 } from "fs";
 import { copyFile as copyFile2, mkdir as mkdir6, readFile as readFile6, readdir as readdir3, rm as rm2, writeFile as writeFile7 } from "fs/promises";
-import { homedir as homedir25 } from "os";
+import { homedir as homedir26 } from "os";
 import path30 from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 function getSetupAgentTargets() {
@@ -192390,7 +192647,7 @@ async function stripHookCaptureFromOpenClawBundle(bundlePath) {
 function mergeHermesPluginEnabled(existingContent, pluginName) {
   let config2 = {};
   try {
-    const loaded = existingContent ? (0, import_yaml4.parse)(existingContent) : {};
+    const loaded = existingContent ? (0, import_yaml5.parse)(existingContent) : {};
     config2 = loaded && typeof loaded === "object" && !Array.isArray(loaded) ? loaded : {};
   } catch {
     config2 = {};
@@ -192399,7 +192656,7 @@ function mergeHermesPluginEnabled(existingContent, pluginName) {
   const plugins = pluginsValue && typeof pluginsValue === "object" && !Array.isArray(pluginsValue) ? pluginsValue : {};
   const enabled = Array.isArray(plugins.enabled) ? plugins.enabled.filter((value) => typeof value === "string") : [];
   if (!enabled.includes(pluginName)) enabled.push(pluginName);
-  return (0, import_yaml4.stringify)({
+  return (0, import_yaml5.stringify)({
     ...config2,
     plugins: {
       ...plugins,
@@ -192427,7 +192684,8 @@ function getMcpAdapter(agent) {
     omp: new OmpMCPAdapter(),
     kiro: new KiroMCPAdapter(),
     opencode: new OpenCodeMCPAdapter(),
-    trae: new TraeMCPAdapter()
+    trae: new TraeMCPAdapter(),
+    dsh: new DshMCPAdapter()
   };
   return adapters[agent];
 }
@@ -192443,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) {
@@ -192547,7 +192807,7 @@ function isOwnedLegacyCodexMcp(content) {
   const server = new CodexMCPAdapter().parse(content).find((entry) => entry.name === "memorix");
   return Boolean(server && isLegacyCodexMemorixNodeServer(server));
 }
-async function removeLegacyCodexMemorixMcpConfig(configPath = path30.join(homedir25(), ".codex", "config.toml")) {
+async function removeLegacyCodexMemorixMcpConfig(configPath = path30.join(homedir26(), ".codex", "config.toml")) {
   let existingContent;
   try {
     existingContent = await readFile6(configPath, "utf-8");
@@ -192604,7 +192864,7 @@ async function removeOwnedLegacyCodexPluginFolder(homeDir) {
   }
 }
 async function migrateLegacyCodexIntegration(options = {}) {
-  const homeDir = options.homeDir ?? homedir25();
+  const homeDir = options.homeDir ?? homedir26();
   const projectRoot = options.projectRoot ?? process.cwd();
   const configPath = path30.join(homeDir, ".codex", "config.toml");
   let mcp = "missing";
@@ -192635,14 +192895,14 @@ async function migrateLegacyCodexIntegration(options = {}) {
 function mergeYamlMcpConfig(existingContent, generatedContent) {
   let existing = {};
   try {
-    const loaded = existingContent ? (0, import_yaml4.parse)(existingContent) : {};
+    const loaded = existingContent ? (0, import_yaml5.parse)(existingContent) : {};
     existing = loaded && typeof loaded === "object" && !Array.isArray(loaded) ? loaded : {};
   } catch {
     existing = {};
   }
   let generated = {};
   try {
-    const loaded = (0, import_yaml4.parse)(generatedContent);
+    const loaded = (0, import_yaml5.parse)(generatedContent);
     generated = loaded && typeof loaded === "object" && !Array.isArray(loaded) ? loaded : {};
   } catch {
     return generatedContent.endsWith("\n") ? generatedContent : `${generatedContent}
@@ -192658,7 +192918,46 @@ function mergeYamlMcpConfig(existingContent, generatedContent) {
       ...generatedServers
     }
   };
-  return (0, import_yaml4.stringify)(merged, { lineWidth: 0 });
+  return (0, import_yaml5.stringify)(merged, { lineWidth: 0 });
+}
+function mergeDshPatchConfig(existingContent, generatedContent) {
+  const generatedTrimmed = generatedContent.trimEnd();
+  if (!existingContent?.trim()) {
+    return generatedTrimmed.endsWith("\n") ? generatedTrimmed : `${generatedTrimmed}
+`;
+  }
+  const isMemorixInsertRow = (row) => {
+    if (!row || typeof row !== "object" || Array.isArray(row)) return false;
+    const record2 = row;
+    if (record2.name !== "@deepseek-ai/dsh-mcp-client") return false;
+    const config2 = record2.config;
+    return Boolean(
+      config2 && typeof config2 === "object" && !Array.isArray(config2) && config2.serverName === "memorix"
+    );
+  };
+  const opContainsMemorixRow = (op) => {
+    if (!op || typeof op !== "object" || Array.isArray(op)) return false;
+    const insert4 = op.insert;
+    return Array.isArray(insert4) && insert4.some(isMemorixInsertRow);
+  };
+  let existingDocument;
+  try {
+    existingDocument = (0, import_yaml5.parse)(existingContent);
+  } catch {
+    return `${existingContent.trimEnd()}
+
+${generatedTrimmed}
+`;
+  }
+  if (!Array.isArray(existingDocument)) {
+    return `${existingContent.trimEnd()}
+
+${generatedTrimmed}
+`;
+  }
+  const kept = existingDocument.filter((op) => !opContainsMemorixRow(op));
+  const merged = [...kept, ...(0, import_yaml5.parse)(generatedContent)];
+  return (0, import_yaml5.stringify)(merged, { lineWidth: 0 }) + "\n";
 }
 async function installMcpConfig(options) {
   const adapter = getMcpAdapter(options.agent);
@@ -192675,7 +192974,7 @@ async function installMcpConfig(options) {
     existingContent = null;
   }
   const generated = adapter.generate([server]);
-  const content = options.agent === "codex" ? mergeTomlMcpConfig(existingContent, generated) : options.agent === "hermes" ? mergeYamlMcpConfig(existingContent, generated) : mergeJsonMcpConfig(existingContent, generated);
+  const content = options.agent === "codex" ? mergeTomlMcpConfig(existingContent, generated) : options.agent === "hermes" ? mergeYamlMcpConfig(existingContent, generated) : options.agent === "dsh" ? mergeDshPatchConfig(existingContent, generated) : mergeJsonMcpConfig(existingContent, generated);
   await mkdir6(path30.dirname(configPath), { recursive: true });
   await writeFile7(configPath, content, "utf-8");
   return { agent: options.agent, configPath, transport: options.mcp };
@@ -192766,7 +193065,7 @@ async function stripCodeBuddyHookCapture(pluginPath) {
   await writeFile7(manifestPath, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
 }
 async function installCodeBuddyPluginPackage(options = {}) {
-  const home = options.homeDir ?? homedir25();
+  const home = options.homeDir ?? homedir26();
   const packageRoot = findPackageRoot();
   const source = path30.join(packageRoot, "plugins", "codebuddy", "memorix");
   if (!existsSync14(source)) throw new Error(`CodeBuddy plugin template not found: ${source}`);
@@ -192786,7 +193085,7 @@ async function installCodeBuddyPluginPackage(options = {}) {
   };
 }
 async function installPluginPackage(options) {
-  const home = options.homeDir ?? homedir25();
+  const home = options.homeDir ?? homedir26();
   const packageRoot = findPackageRoot();
   const source = path30.join(packageRoot, "plugins", options.agent, "memorix");
   const includeHooks = options.includeHooks ?? true;
@@ -192835,7 +193134,7 @@ async function installPluginPackage(options) {
   };
 }
 async function installGeminiExtensionPackage(options = {}) {
-  const home = options.homeDir ?? homedir25();
+  const home = options.homeDir ?? homedir26();
   const packageRoot = findPackageRoot();
   const source = path30.join(packageRoot, "plugins", "gemini", "memorix");
   if (!existsSync14(source)) {
@@ -192855,7 +193154,7 @@ async function installAntigravityPluginPackage(options = {}) {
   if (!existsSync14(source)) {
     throw new Error(`Antigravity plugin template not found: ${source}`);
   }
-  const pluginPath = options.global === false ? path30.join(options.projectRoot ?? process.cwd(), ".agents", "plugins", "memorix") : path30.join(options.homeDir ?? homedir25(), ".gemini", "config", "plugins", "memorix");
+  const pluginPath = options.global === false ? path30.join(options.projectRoot ?? process.cwd(), ".agents", "plugins", "memorix") : path30.join(options.homeDir ?? homedir26(), ".gemini", "config", "plugins", "memorix");
   await copyDir(source, pluginPath);
   if (options.includeHooks === false) {
     await rm2(path30.join(pluginPath, "hooks.json"), { force: true });
@@ -192873,7 +193172,7 @@ async function installPiPackage(options = {}) {
   if (!existsSync14(source)) {
     throw new Error(`Pi package template not found: ${source}`);
   }
-  const defaultRoot = options.global ? path30.join(options.homeDir ?? homedir25(), ".pi", "agent", "packages") : path30.join(process.cwd(), ".pi", "packages");
+  const defaultRoot = options.global ? path30.join(options.homeDir ?? homedir26(), ".pi", "agent", "packages") : path30.join(process.cwd(), ".pi", "packages");
   const packagePath = options.packageDir ?? path30.join(defaultRoot, "memorix");
   await copyDir(source, packagePath);
   await writeOfficialSkills(path30.join(packagePath, "skills"));
@@ -192885,7 +193184,7 @@ async function installPiPackage(options = {}) {
   };
 }
 async function installOpenClawBundlePackage(options = {}) {
-  const home = options.homeDir ?? homedir25();
+  const home = options.homeDir ?? homedir26();
   const packageRoot = findPackageRoot();
   const source = path30.join(packageRoot, "plugins", "openclaw", "memorix");
   if (!existsSync14(source)) {
@@ -192934,7 +193233,7 @@ async function installOmpPackage(options = {}) {
   if (!existsSync14(source)) {
     throw new Error(`Oh-my-Pi package template not found: ${source}`);
   }
-  const defaultRoot = options.global ? path30.join(options.homeDir ?? homedir25(), ".omp", "agent", "packages") : path30.join(process.cwd(), ".omp", "packages");
+  const defaultRoot = options.global ? path30.join(options.homeDir ?? homedir26(), ".omp", "agent", "packages") : path30.join(process.cwd(), ".omp", "packages");
   const packagePath = options.packageDir ?? path30.join(defaultRoot, "memorix");
   await copyDir(source, packagePath);
   await writeOfficialSkills(path30.join(packagePath, "skills"));
@@ -193208,7 +193507,7 @@ ${result.stdout || ""}`.toLowerCase();
 }
 async function installAgentSetup(agent, plan, global2) {
   const { installAgentGuidance: installAgentGuidance2, installHooks: installHooks2 } = await Promise.resolve().then(() => (init_installers(), installers_exports));
-  const targetRoot = global2 ? homedir25() : process.cwd();
+  const targetRoot = global2 ? homedir26() : process.cwd();
   const hasPluginPackage = plan.actions.includes("plugin-package") && PLUGIN_PACKAGE_AGENTS.has(agent);
   const hasExtensionPackage = plan.actions.includes("extension-package") && agent === "gemini-cli";
   const hasPiPackage = plan.actions.includes("pi-package") && agent === "pi";
@@ -193394,14 +193693,14 @@ function printSetupIntegrationRows() {
   ].join("\n");
   ye2(table, "Memorix integrations");
 }
-var import_yaml4, PLUGIN_PACKAGE_AGENTS, EXTENSION_PACKAGE_AGENTS, PI_PACKAGE_AGENTS, OPENCLAW_BUNDLE_AGENTS, ANTIGRAVITY_PLUGIN_AGENTS, HERMES_PLUGIN_AGENTS, OMP_PACKAGE_AGENTS, CODEBUDDY_PLUGIN_AGENTS, PACKAGE_OWNED_INTEGRATION_AGENTS, SUPPORTED_SETUP_AGENTS, getSetupIntegrationRows2, setup_default;
+var import_yaml5, PLUGIN_PACKAGE_AGENTS, EXTENSION_PACKAGE_AGENTS, PI_PACKAGE_AGENTS, OPENCLAW_BUNDLE_AGENTS, ANTIGRAVITY_PLUGIN_AGENTS, HERMES_PLUGIN_AGENTS, OMP_PACKAGE_AGENTS, CODEBUDDY_PLUGIN_AGENTS, PACKAGE_OWNED_INTEGRATION_AGENTS, SUPPORTED_SETUP_AGENTS, getSetupIntegrationRows2, setup_default;
 var init_setup = __esm({
   "src/cli/commands/setup.ts"() {
     "use strict";
     init_esm_shims();
     init_dist2();
     init_dist4();
-    import_yaml4 = __toESM(require_dist(), 1);
+    import_yaml5 = __toESM(require_dist(), 1);
     init_claude_code();
     init_codex();
     init_cursor();
@@ -193415,6 +193714,7 @@ var init_setup = __esm({
     init_kiro();
     init_opencode();
     init_trae();
+    init_dsh();
     init_codebuddy();
     init_registry2();
     init_official_skills();
@@ -193443,6 +193743,7 @@ var init_setup = __esm({
       "omp",
       "kiro",
       "trae",
+      "dsh",
       "pi"
     ];
     getSetupIntegrationRows2 = getSetupIntegrationRows;
@@ -193454,7 +193755,7 @@ var init_setup = __esm({
       args: {
         agent: {
           type: "string",
-          description: "Target agent (claude, codex, codebuddy, opencode, cursor, windsurf, copilot, gemini-cli, antigravity, openclaw, hermes, omp, kiro, trae, pi, all)",
+          description: "Target agent (claude, codex, codebuddy, opencode, cursor, windsurf, copilot, gemini-cli, antigravity, openclaw, hermes, omp, kiro, trae, dsh, pi, all)",
           required: false
         },
         mcp: {
@@ -193526,6 +193827,7 @@ var init_setup = __esm({
               { value: "hermes", label: "Hermes Agent", hint: "plugin + hooks + commands + skills + MCP" },
               { value: "omp", label: "Oh-my-Pi", hint: "package + extension + command + MCP" },
               { value: "pi", label: "Pi coding agent", hint: "package + extension + skill" },
+              { value: "dsh", label: "DeepSeek Harness", hint: "MCP patch + AGENTS.md + skills" },
               { value: "opencode", label: "OpenCode", hint: "local plugin + AGENTS.md + MCP" },
               { value: "windsurf", label: "Windsurf", hint: "rules + hooks + MCP" },
               { value: "all", label: "All supported agents", hint: "install detected-compatible files" }
@@ -193585,7 +193887,7 @@ var config_path_exports = {};
 __export(config_path_exports, {
   default: () => config_path_default
 });
-import { homedir as homedir26 } from "os";
+import { homedir as homedir27 } from "os";
 var config_path_default;
 var init_config_path = __esm({
   "src/cli/commands/config-path.ts"() {
@@ -193603,7 +193905,7 @@ var init_config_path = __esm({
       run: async () => {
         const project = detectProject(process.cwd());
         ye2([
-          `Global:  ${getGlobalConfigTomlPath(homedir26())}`,
+          `Global:  ${getGlobalConfigTomlPath(homedir27())}`,
           `Project: ${project ? getProjectConfigTomlPath(project.rootPath) : "not inside a git project"}`
         ].join("\n"), "Memorix config");
       }
@@ -193679,7 +193981,7 @@ __export(config_migrate_exports, {
   serializeResolvedConfigToToml: () => serializeResolvedConfigToToml
 });
 import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { homedir as homedir27 } from "os";
+import { homedir as homedir28 } from "os";
 import { dirname as dirname4 } from "path";
 function serializeResolvedConfigToToml(config2, options = {}) {
   const includeSecrets = options.includeSecrets === true;
@@ -193772,7 +194074,7 @@ var init_config_migrate = __esm({
           v3.error("Not inside a git project. Use `memorix config migrate --global` for global config.");
           return;
         }
-        const target = isGlobal ? getGlobalConfigTomlPath(homedir27()) : getProjectConfigTomlPath(project.rootPath);
+        const target = isGlobal ? getGlobalConfigTomlPath(homedir28()) : getProjectConfigTomlPath(project.rootPath);
         const resolved = getResolvedConfig({ projectRoot: project?.rootPath ?? null });
         const content = serializeResolvedConfigToToml(resolved, { includeSecrets: isGlobal });
         mkdirSync2(dirname4(target), { recursive: true });
@@ -193784,8 +194086,8 @@ var init_config_migrate = __esm({
 });
 
 // src/cli/commands/integrate-shared.ts
-import { homedir as homedir28 } from "os";
-function getIntegrationTargetRoot(useGlobalDefaults, cwd, homeDir = homedir28()) {
+import { homedir as homedir29 } from "os";
+function getIntegrationTargetRoot(useGlobalDefaults, cwd, homeDir = homedir29()) {
   return useGlobalDefaults ? homeDir : cwd;
 }
 function getIntegrationScopeLabel(useGlobalDefaults) {
@@ -193822,7 +194124,8 @@ function getAgentLabel(agent) {
     codex: "Codex",
     antigravity: "Antigravity",
     "gemini-cli": "Gemini CLI",
-    trae: "Trae"
+    trae: "Trae",
+    dsh: "DeepSeek Harness"
   };
   return labels[agent] || agent;
 }
@@ -193837,7 +194140,8 @@ function getAgentHint(agent) {
     codex: "AGENTS.md",
     antigravity: "plugin + MCP + hooks + skills",
     "gemini-cli": "settings + GEMINI.md",
-    trae: "rules"
+    trae: "rules",
+    dsh: "MCP patch + AGENTS.md + skills"
   };
   return hints[agent] || "integration files";
 }
@@ -194122,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
   );
@@ -194592,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) } : {},
@@ -194830,7 +195166,7 @@ __export(external_provider_exports, {
 });
 import { spawn as spawn5 } from "child_process";
 import { existsSync as existsSync16, readFileSync as readFileSync9 } from "fs";
-import { delimiter, dirname as dirname5, extname, isAbsolute as isAbsolute2, join as join22, relative as relative2, resolve as resolve3, sep as sep2 } from "path";
+import { delimiter, dirname as dirname5, extname, isAbsolute as isAbsolute2, join as join23, relative as relative2, resolve as resolve3, sep as sep2 } from "path";
 function boundedTimeout(value) {
   if (!Number.isFinite(value)) return DEFAULT_EXTERNAL_CODEGRAPH_TIMEOUT_MS;
   return Math.max(100, Math.min(Math.floor(value), MAX_EXTERNAL_CODEGRAPH_TIMEOUT_MS));
@@ -194859,10 +195195,10 @@ function resolveCommandCandidates(command) {
   }
   const names = extname(requested) ? [requested] : process.platform === "win32" ? [requested + ".exe", requested + ".cmd", requested + ".js", requested] : [requested];
   const directories = [
-    ...process.platform === "win32" && process.env.LOCALAPPDATA ? [join22(process.env.LOCALAPPDATA, "codegraph", "current", "bin")] : [],
+    ...process.platform === "win32" && process.env.LOCALAPPDATA ? [join23(process.env.LOCALAPPDATA, "codegraph", "current", "bin")] : [],
     ...(process.env.PATH ?? "").split(delimiter).filter(Boolean)
   ];
-  return [...new Set(directories.flatMap((directory) => names.map((name) => join22(directory, name))))];
+  return [...new Set(directories.flatMap((directory) => names.map((name) => join23(directory, name))))];
 }
 function resolveLaunch(command) {
   for (const candidate2 of resolveCommandCandidates(command)) {
@@ -194870,8 +195206,8 @@ function resolveLaunch(command) {
     const extension3 = extname(candidate2).toLowerCase();
     if (extension3 === ".cmd") {
       const bundleRoot = resolve3(dirname5(candidate2), "..");
-      const node = join22(bundleRoot, "node.exe");
-      const entry = join22(bundleRoot, "lib", "dist", "bin", "codegraph.js");
+      const node = join23(bundleRoot, "node.exe");
+      const entry = join23(bundleRoot, "lib", "dist", "bin", "codegraph.js");
       if (existsSync16(node) && existsSync16(entry)) {
         return { executable: node, prefixArgs: ["--liftoff-only", entry] };
       }
@@ -195002,7 +195338,7 @@ async function inspectExternalCodeGraph(input) {
     const health2 = { state: "disabled", reason: "External CodeGraph is disabled by configuration." };
     return { health: health2, quality: providerQuality({ mode, health: health2 }) };
   }
-  if (!existsSync16(join22(input.projectRoot, ".codegraph"))) {
+  if (!existsSync16(join23(input.projectRoot, ".codegraph"))) {
     const health2 = { state: "not-detected", reason: "No local .codegraph index is present for this project." };
     return { health: health2, quality: providerQuality({ mode, health: health2 }) };
   }
@@ -196641,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." };
@@ -196845,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),
@@ -197033,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)}`,
@@ -197042,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 {
@@ -197166,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;
@@ -200229,8 +200610,8 @@ __export(engine_exports2, {
   SkillsEngine: () => SkillsEngine
 });
 import { existsSync as existsSync18, readFileSync as readFileSync10, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, readdirSync as readdirSync3 } from "fs";
-import { join as join23 } from "path";
-import { homedir as homedir29 } from "os";
+import { join as join24 } from "path";
+import { homedir as homedir30 } from "os";
 var SKILLS_DIRS, SKILL_WORTHY_TYPES, MIN_OBS_FOR_SKILL, MIN_SCORE_FOR_SKILL, LOW_SIGNAL_TITLE_PATTERNS, LOW_SIGNAL_ENTITY_PATTERNS, COMMAND_TRACE_PATTERNS2, SkillsEngine;
 var init_engine4 = __esm({
   "src/skills/engine.ts"() {
@@ -200301,12 +200682,12 @@ var init_engine4 = __esm({
       listSkills() {
         const skills = [];
         const seen = /* @__PURE__ */ new Set();
-        const home = homedir29();
+        const home = homedir30();
         for (const [agent, dirs] of Object.entries(SKILLS_DIRS)) {
           for (const dir of dirs) {
-            const paths = [join23(this.projectRoot, dir)];
+            const paths = [join24(this.projectRoot, dir)];
             if (!this.skipGlobal) {
-              paths.push(join23(home, dir));
+              paths.push(join24(home, dir));
             }
             for (const skillsRoot of paths) {
               if (!existsSync18(skillsRoot)) continue;
@@ -200316,7 +200697,7 @@ var init_engine4 = __esm({
                   if (!entry.isDirectory()) continue;
                   const name = entry.name;
                   if (seen.has(name)) continue;
-                  const skillMd = join23(skillsRoot, name, "SKILL.md");
+                  const skillMd = join24(skillsRoot, name, "SKILL.md");
                   if (!existsSync18(skillMd)) continue;
                   try {
                     const content = readFileSync10(skillMd, "utf-8");
@@ -200324,7 +200705,7 @@ var init_engine4 = __esm({
                     skills.push({
                       name,
                       description,
-                      sourcePath: join23(skillsRoot, name),
+                      sourcePath: join24(skillsRoot, name),
                       sourceAgent: agent,
                       content,
                       generated: false
@@ -200367,11 +200748,11 @@ var init_engine4 = __esm({
       writeSkill(skill2, target) {
         const dirs = SKILLS_DIRS[target];
         if (!dirs || dirs.length === 0) return null;
-        const targetDir = join23(this.projectRoot, dirs[0], skill2.name);
+        const targetDir = join24(this.projectRoot, dirs[0], skill2.name);
         try {
           mkdirSync3(targetDir, { recursive: true });
-          writeFileSync3(join23(targetDir, "SKILL.md"), skill2.content, "utf-8");
-          return join23(dirs[0], skill2.name, "SKILL.md");
+          writeFileSync3(join24(targetDir, "SKILL.md"), skill2.content, "utf-8");
+          return join24(dirs[0], skill2.name, "SKILL.md");
         } catch {
           return null;
         }
@@ -201540,7 +201921,7 @@ var init_task_graph = __esm({
 // src/orchestrate/context-collector.ts
 import { execFileSync as execFileSync2 } from "child_process";
 import { readFileSync as readFileSync11, existsSync as existsSync19 } from "fs";
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 function normalizeEntryLimit(value, fallback) {
   if (!Number.isSafeInteger(value) || value < 1) return fallback;
   return Math.min(value, 500);
@@ -201615,7 +201996,7 @@ function collectFileTree(projectDir2, maxEntries) {
 }
 function collectDependencies(projectDir2) {
   try {
-    const pkgPath = join24(projectDir2, "package.json");
+    const pkgPath = join25(projectDir2, "package.json");
     if (!existsSync19(pkgPath)) return "";
     const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
     const parts = [];
@@ -215855,8 +216236,8 @@ __export(engine_exports3, {
   WorkspaceSyncEngine: () => WorkspaceSyncEngine
 });
 import { readFileSync as readFileSync13, readdirSync as readdirSync4, existsSync as existsSync22, cpSync, mkdirSync as mkdirSync5 } from "fs";
-import { join as join26 } from "path";
-import { homedir as homedir30 } from "os";
+import { join as join27 } from "path";
+import { homedir as homedir31 } from "os";
 var WorkspaceSyncEngine;
 var init_engine5 = __esm({
   "src/workspace/engine.ts"() {
@@ -215928,9 +216309,9 @@ var init_engine5 = __esm({
           const globalPath = adapter.getConfigPath();
           const pathsToCheck = [configPath, globalPath];
           if (target === "antigravity") {
-            pathsToCheck.push(join26(this.projectRoot, ".gemini", "settings.json"));
-            pathsToCheck.push(join26(homedir30(), ".gemini", "settings.json"));
-            pathsToCheck.push(join26(homedir30(), ".gemini", "antigravity", "mcp_config.json"));
+            pathsToCheck.push(join27(this.projectRoot, ".gemini", "settings.json"));
+            pathsToCheck.push(join27(homedir31(), ".gemini", "settings.json"));
+            pathsToCheck.push(join27(homedir31(), ".gemini", "antigravity", "mcp_config.json"));
           }
           const merged = /* @__PURE__ */ new Map();
           for (const path47 of pathsToCheck) {
@@ -216047,7 +216428,7 @@ var init_engine5 = __esm({
       getTargetSkillsDir(target) {
         const dirs = _WorkspaceSyncEngine.SKILLS_DIRS[target];
         if (!dirs || dirs.length === 0) return null;
-        return join26(this.projectRoot, dirs[0]);
+        return join27(this.projectRoot, dirs[0]);
       }
       /**
        * Scan all agent skills directories and collect unique skills.
@@ -216056,12 +216437,12 @@ var init_engine5 = __esm({
         const skills = [];
         const conflicts = [];
         const seen = /* @__PURE__ */ new Map();
-        const home = homedir30();
+        const home = homedir31();
         for (const [agent, dirs] of Object.entries(_WorkspaceSyncEngine.SKILLS_DIRS)) {
           for (const dir of dirs) {
             const paths = [
-              join26(this.projectRoot, dir),
-              join26(home, dir)
+              join27(this.projectRoot, dir),
+              join27(home, dir)
             ];
             for (const skillsRoot of paths) {
               if (!existsSync22(skillsRoot)) continue;
@@ -216069,7 +216450,7 @@ var init_engine5 = __esm({
                 const entries = readdirSync4(skillsRoot, { withFileTypes: true });
                 for (const entry of entries) {
                   if (!entry.isDirectory()) continue;
-                  const skillMd = join26(skillsRoot, entry.name, "SKILL.md");
+                  const skillMd = join27(skillsRoot, entry.name, "SKILL.md");
                   if (!existsSync22(skillMd)) continue;
                   let description = "";
                   try {
@@ -216081,7 +216462,7 @@ var init_engine5 = __esm({
                   const newEntry = {
                     name: entry.name,
                     description,
-                    sourcePath: join26(skillsRoot, entry.name),
+                    sourcePath: join27(skillsRoot, entry.name),
                     sourceAgent: agent
                   };
                   const existing = seen.get(entry.name);
@@ -216118,7 +216499,7 @@ var init_engine5 = __esm({
         }
         for (const skill2 of skills) {
           if (skill2.sourceAgent === target) continue;
-          const dest = join26(targetDir, skill2.name);
+          const dest = join27(targetDir, skill2.name);
           if (existsSync22(dest)) {
             skipped.push(`${skill2.name} (already exists in ${target})`);
             continue;
@@ -216134,13 +216515,13 @@ var init_engine5 = __esm({
       }
       scanWorkflows() {
         const workflows = [];
-        const wfDir = join26(this.projectRoot, ".windsurf", "workflows");
+        const wfDir = join27(this.projectRoot, ".windsurf", "workflows");
         if (!existsSync22(wfDir)) return workflows;
         try {
           const files = readdirSync4(wfDir).filter((f7) => f7.endsWith(".md"));
           for (const file2 of files) {
             try {
-              const content = readFileSync13(join26(wfDir, file2), "utf-8");
+              const content = readFileSync13(join27(wfDir, file2), "utf-8");
               workflows.push(this.workflowSyncer.parseWindsurfWorkflow(file2, content));
             } catch {
             }
@@ -216266,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, {
@@ -216348,7 +216769,7 @@ __export(behavior_exports, {
   resetBehaviorConfigCache: () => resetBehaviorConfigCache
 });
 import { existsSync as existsSync23, readFileSync as readFileSync14 } from "fs";
-import { homedir as homedir31 } from "os";
+import { homedir as homedir32 } from "os";
 function isSessionInject(value) {
   return value === "full" || value === "minimal" || value === "silent";
 }
@@ -216366,7 +216787,7 @@ function legacyBehavior(homeDir) {
   }
 }
 function getBehaviorConfig(options = {}) {
-  const homeDir = options.homeDir ?? homedir31();
+  const homeDir = options.homeDir ?? homedir32();
   const projectRoot = options.projectRoot === void 0 ? detectProject()?.rootPath ?? null : options.projectRoot;
   const cacheKey2 = `${homeDir}\0${projectRoot ?? ""}`;
   const cached2 = cache4.get(cacheKey2);
@@ -217335,7 +217756,7 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
       case "/config": {
         const os6 = await import("os");
         const { existsSync: existsSync33 } = await import("fs");
-        const { join: join33 } = await import("path");
+        const { join: join34 } = await import("path");
         let yml = {};
         const configProjectRoot = effectiveProjectRoot;
         try {
@@ -217360,11 +217781,11 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
         try {
           const home = os6.homedir();
           const paths = {
-            "project memorix.yml": configProjectRoot ? join33(configProjectRoot, "memorix.yml") : null,
-            "user memorix.yml": join33(home, ".memorix", "memorix.yml"),
-            "project .env": configProjectRoot ? join33(configProjectRoot, ".env") : null,
-            "user .env": join33(home, ".memorix", ".env"),
-            "legacy config.json": join33(home, ".memorix", "config.json")
+            "project memorix.yml": configProjectRoot ? join34(configProjectRoot, "memorix.yml") : null,
+            "user memorix.yml": join34(home, ".memorix", "memorix.yml"),
+            "project .env": configProjectRoot ? join34(configProjectRoot, ".env") : null,
+            "user .env": join34(home, ".memorix", ".env"),
+            "legacy config.json": join34(home, ".memorix", "config.json")
           };
           for (const [key, fpath] of Object.entries(paths)) {
             if (fpath === null) {
@@ -217469,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);
@@ -258219,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));
@@ -258268,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.4" : "1.0.1"
+    version: true ? "1.4.6" : "1.0.1"
   });
   const originalRegisterTool = server.registerTool.bind(server);
   server.registerTool = ((name, ...args) => {
@@ -258753,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,
@@ -258767,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 = `
@@ -258963,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;
@@ -258980,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 {
@@ -258999,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);
@@ -260270,10 +260723,10 @@ ${Math.max(0, managedIds.size - result.resolved.length)} visible writable observ
   );
   let enableKG = isToolInProfile("create_entities", toolProfile);
   try {
-    const { homedir: homedir35 } = await import("os");
-    const { join: join33 } = await import("path");
+    const { homedir: homedir36 } = await import("os");
+    const { join: join34 } = await import("path");
     const { readFile: readFile10 } = await import("fs/promises");
-    const raw = await readFile10(join33(homedir35(), ".memorix", "settings.json"), "utf-8");
+    const raw = await readFile10(join34(homedir36(), ".memorix", "settings.json"), "utf-8");
     const s4 = JSON.parse(raw);
     if (s4.knowledgeGraph === true) enableKG = true;
   } catch {
@@ -261961,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."),
@@ -261975,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 }) => {
@@ -262474,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;
@@ -262576,8 +263049,8 @@ __export(update_checker_exports, {
 });
 import { execFile as execFile3 } from "child_process";
 import { readFile as readFile7, writeFile as writeFile8, mkdir as mkdir7 } from "fs/promises";
-import { join as join27 } from "path";
-import { homedir as homedir32 } from "os";
+import { join as join28 } from "path";
+import { homedir as homedir33 } from "os";
 function getCurrentVersion() {
   try {
     return getCliVersion();
@@ -262756,8 +263229,8 @@ var init_update_checker = __esm({
     MIN_AUTO_UPDATE_TIMEOUT_MS = 5e3;
     MAX_AUTO_UPDATE_TIMEOUT_MS = 30 * 60 * 1e3;
     REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
-    CACHE_DIR2 = join27(homedir32(), ".memorix");
-    CACHE_FILE2 = join27(CACHE_DIR2, "update-check.json");
+    CACHE_DIR2 = join28(homedir33(), ".memorix");
+    CACHE_FILE2 = join28(CACHE_DIR2, "update-check.json");
     _testing = {
       CACHE_FILE: CACHE_FILE2,
       CHECK_INTERVAL_MS,
@@ -262813,7 +263286,7 @@ var init_serve = __esm({
         const { StdioServerTransport: StdioServerTransport2 } = await Promise.resolve().then(() => (init_stdio2(), stdio_exports));
         const { createMemorixServer: createMemorixServer2 } = await Promise.resolve().then(() => (init_server4(), server_exports2));
         const { detectProject: detectProject2, findGitInSubdirs: findGitInSubdirs2, isSystemDirectory: isSystemDirectory2 } = await Promise.resolve().then(() => (init_detector(), detector_exports));
-        const { homedir: homedir35 } = await import("os");
+        const { homedir: homedir36 } = await import("os");
         const { resolveServeProject: resolveServeProject2 } = await Promise.resolve().then(() => (init_serve_shared(), serve_shared_exports));
         process.stdin.on("end", () => {
           console.error("[memorix] stdin closed \u2014 exiting");
@@ -262823,7 +263296,7 @@ var init_serve = __esm({
         try {
           safeCwd = process.cwd();
         } catch {
-          safeCwd = homedir35();
+          safeCwd = homedir36();
         }
         const resolution = resolveServeProject2(
           {
@@ -262831,7 +263304,7 @@ var init_serve = __esm({
             envProjectRoot: process.env.MEMORIX_PROJECT_ROOT,
             initCwd: process.env.INIT_CWD,
             processCwd: safeCwd,
-            homeDir: homedir35()
+            homeDir: homedir36()
           },
           { detectProject: detectProject2, findGitInSubdirs: findGitInSubdirs2, isSystemDirectory: isSystemDirectory2 }
         );
@@ -265052,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;
   }
@@ -265064,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();
@@ -265073,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"() {
@@ -265122,19 +265606,23 @@ var init_serve_http = __esm({
         const { createProjectBindingController: createProjectBindingController2 } = await Promise.resolve().then(() => (init_request_context(), request_context_exports));
         const { findGitInSubdirs: findGitInSubdirs2 } = await Promise.resolve().then(() => (init_detector(), detector_exports));
         const { writeFileSync: writeFileSync11, mkdirSync: mkdirSync11 } = await import("fs");
-        const { homedir: homedir35 } = await import("os");
-        const port = parseTcpPortOrReport(args.port, 3211);
-        if (port === void 0) {
-          process.exitCode = 1;
-          return;
+        const { homedir: homedir36 } = await import("os");
+        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;
         try {
           safeCwd = process.cwd();
         } catch {
-          safeCwd = homedir35();
+          safeCwd = homedir36();
         }
         let projectRoot = args.cwd || process.env.MEMORIX_PROJECT_ROOT || safeCwd;
         console.error(`[memorix] HTTP transport starting on ${host}:${port}`);
@@ -265844,7 +266332,7 @@ var init_serve_http = __esm({
               const { projectId: configProjectId } = await resolveRequestProject(url2);
               const os6 = await import("os");
               const { existsSync: existsSync33 } = await import("fs");
-              const { join: join33 } = await import("path");
+              const { join: join34 } = await import("path");
               const { loadYamlConfig: loadYamlConfig2 } = await Promise.resolve().then(() => (init_yaml_loader(), yaml_loader_exports));
               const { loadFileConfig: loadFileConfig2, loadDotenv: loadDotenv2, getLoadedEnvFiles: getLoadedEnvFiles2 } = await Promise.resolve().then(() => (init_config(), config_exports));
               const isStartupProject = configProjectId === defaultProject.id;
@@ -265858,11 +266346,11 @@ var init_serve_http = __esm({
               const home = os6.homedir();
               if (effectiveRoot) {
                 const paths = {
-                  "project memorix.yml": join33(effectiveRoot, "memorix.yml"),
-                  "user memorix.yml": join33(home, ".memorix", "memorix.yml"),
-                  "project .env": join33(effectiveRoot, ".env"),
-                  "user .env": join33(home, ".memorix", ".env"),
-                  "legacy config.json": join33(home, ".memorix", "config.json")
+                  "project memorix.yml": join34(effectiveRoot, "memorix.yml"),
+                  "user memorix.yml": join34(home, ".memorix", "memorix.yml"),
+                  "project .env": join34(effectiveRoot, ".env"),
+                  "user .env": join34(home, ".memorix", ".env"),
+                  "legacy config.json": join34(home, ".memorix", "config.json")
                 };
                 for (const [key, fpath] of Object.entries(paths)) {
                   files[key] = { exists: existsSync33(fpath), path: fpath };
@@ -265871,9 +266359,9 @@ var init_serve_http = __esm({
                 files["project memorix.yml"] = { exists: false, path: "unavailable", unavailable: true };
                 files["project .env"] = { exists: false, path: "unavailable", unavailable: true };
                 const userPaths = {
-                  "user memorix.yml": join33(home, ".memorix", "memorix.yml"),
-                  "user .env": join33(home, ".memorix", ".env"),
-                  "legacy config.json": join33(home, ".memorix", "config.json")
+                  "user memorix.yml": join34(home, ".memorix", "memorix.yml"),
+                  "user .env": join34(home, ".memorix", ".env"),
+                  "legacy config.json": join34(home, ".memorix", "config.json")
                 };
                 for (const [key, fpath] of Object.entries(userPaths)) {
                   files[key] = { exists: existsSync33(fpath), path: fpath };
@@ -265999,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);
@@ -268550,6 +269038,7 @@ var init_types9 = __esm({
       hermes: "community",
       opencode: "community",
       trae: "community",
+      dsh: "community",
       pi: "community",
       omp: "community",
       antigravity: "community"
@@ -268608,7 +269097,8 @@ function getAgentLabel2(agent) {
     openclaw: "OpenClaw",
     hermes: "Hermes Agent",
     omp: "Oh-my-Pi",
-    trae: "Trae"
+    trae: "Trae",
+    dsh: "DeepSeek Harness"
   };
   return labels[agent] || agent;
 }
@@ -268626,6 +269116,7 @@ function getAgentHint2(agent) {
     hermes: "Hermes plugin hooks; use `memorix setup --agent hermes`",
     omp: "Oh-my-Pi package hooks; use `memorix setup --agent omp`",
     trae: ".trae/rules/project_rules.md (rules only, no hooks system)",
+    dsh: "~/.dsh/cordis.patch.yml MCP row via `memorix setup --agent dsh` (no hooks system)",
     codex: "Codex plugin hooks; use `memorix setup --agent codex`"
   };
   return hints[agent] || "";
@@ -268733,7 +269224,8 @@ function estimateFileSize(agent, configPath) {
     codex: "~1KB",
     antigravity: "~2KB",
     opencode: "~3KB",
-    trae: "~1KB"
+    trae: "~1KB",
+    dsh: "~1KB"
   };
   return sizes[agent] || "~2KB";
 }
@@ -268751,6 +269243,8 @@ function getRulesPath(agent, cwd, global2) {
         return path42.join(home, ".gemini", "GEMINI.md");
       case "trae":
         return path42.join(home, ".trae", "rules", "project_rules.md");
+      case "dsh":
+        return path42.join(process.env.DSH_HOME?.trim() || path42.join(home, ".dsh"), "AGENTS.md");
       default:
         return "";
     }
@@ -268766,6 +269260,8 @@ function getRulesPath(agent, cwd, global2) {
         return path42.join(cwd, "GEMINI.md");
       case "trae":
         return path42.join(cwd, ".trae", "rules", "project_rules.md");
+      case "dsh":
+        return path42.join(cwd, "AGENTS.md");
       default:
         return "";
     }
@@ -269063,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();
@@ -269091,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 {
@@ -269342,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"() {
@@ -269386,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,
@@ -271256,7 +271778,7 @@ import { spawnSync as spawnSync2 } from "child_process";
 import { existsSync as existsSync28 } from "fs";
 import { mkdir as mkdir8, readFile as readFile9, writeFile as writeFile9 } from "fs/promises";
 import { basename as basename5, dirname as dirname8, resolve as resolve4 } from "path";
-import { homedir as homedir33 } from "os";
+import { homedir as homedir34 } from "os";
 function requestedAgents(agent) {
   const all = getSetupAgentTargets();
   if (!agent || agent === "all") return all;
@@ -271334,16 +271856,16 @@ function asRecordArray(value) {
   return Array.isArray(value) ? value.map(asRecord3).filter((entry) => entry !== null) : [];
 }
 function codexPluginPath() {
-  return `${homedir33()}/plugins/${CODEX_PLUGIN_NAME}`;
+  return `${homedir34()}/plugins/${CODEX_PLUGIN_NAME}`;
 }
 function codexPluginMcpPath() {
   return `${codexPluginPath()}/.mcp.json`;
 }
 function codexMarketplacePath() {
-  return `${homedir33()}/.agents/plugins/marketplace.json`;
+  return `${homedir34()}/.agents/plugins/marketplace.json`;
 }
 function codexConfigPath() {
-  return `${homedir33()}/.codex/config.toml`;
+  return `${homedir34()}/.codex/config.toml`;
 }
 function normalizeMarketplacePath(value) {
   return value.replace(/\\/g, "/").replace(/^\.\//, "");
@@ -271653,7 +272175,7 @@ function defaultClaudeProjectKey(projectRoot) {
   return resolve4(projectRoot).replace(/\\/g, "/");
 }
 function getClaudeLocalConfigPath() {
-  return `${homedir33()}/.claude.json`;
+  return `${homedir34()}/.claude.json`;
 }
 function coerceMcpServer(name, value) {
   const entry = asRecord3(value);
@@ -271834,7 +272356,9 @@ async function inspectMcp(agent, projectRoot, scope) {
       }
     }
     const configPath = adapter.getConfigPath(targetScope === "project" ? projectRoot : void 0);
-    if (targetScope === "global" && configPath === adapter.getConfigPath(projectRoot)) continue;
+    if (targetScope === "global" && configPath === adapter.getConfigPath(projectRoot) && scope === "all") {
+      continue;
+    }
     if (!existsSync28(configPath)) {
       checks.push({
         scope: targetScope,
@@ -271910,7 +272434,7 @@ async function inspectGuidance(agent, projectRoot, scope) {
   }
   const checks = [];
   for (const targetScope of requestedGuidanceScopes(scope)) {
-    const root = targetScope === "project" ? projectRoot : homedir33();
+    const root = targetScope === "project" ? projectRoot : homedir34();
     const rulesPath = getAgentRulesPath(agent, root, targetScope === "global");
     if (!existsSync28(rulesPath)) {
       checks.push({
@@ -272126,7 +272650,8 @@ var init_agent_integrations = __esm({
       "antigravity",
       "kiro",
       "opencode",
-      "trae"
+      "trae",
+      "dsh"
     ]);
     CODEX_PLUGIN_NAME = "memorix";
     CODEX_PLUGIN_MARKETPLACE = "personal";
@@ -272188,8 +272713,8 @@ var init_doctor = __esm({
           return;
         }
         const { existsSync: existsSync33, readFileSync: readFileSync22 } = await import("fs");
-        const { join: join33, basename: basename7 } = await import("path");
-        const { homedir: homedir35 } = await import("os");
+        const { join: join34, basename: basename7 } = await import("path");
+        const { homedir: homedir36 } = await import("os");
         const { execSync: execSync5 } = await import("child_process");
         const report = {};
         const issues = [];
@@ -272251,8 +272776,8 @@ var init_doctor = __esm({
         }
         lines.push("");
         lines.push("\u250C\u2500 Runtime Mode \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
-        const memorixDir = join33(homedir35(), ".memorix");
-        const bgStatePath = join33(memorixDir, "background.json");
+        const memorixDir = join34(homedir36(), ".memorix");
+        const bgStatePath = join34(memorixDir, "background.json");
         let bgRunning = false;
         let bgPort = 0;
         let bgPid = 0;
@@ -272349,7 +272874,7 @@ var init_doctor = __esm({
               report.embedding = { mode, status: "temporarily_unavailable" };
             }
             try {
-              const cachePath = join33(memorixDir, "embedding-cache.json");
+              const cachePath = join34(memorixDir, "embedding-cache.json");
               if (existsSync33(cachePath)) {
                 const cache5 = JSON.parse(readFileSync22(cachePath, "utf-8"));
                 const cacheCount = Object.keys(cache5).length;
@@ -272543,7 +273068,7 @@ var init_doctor = __esm({
         lines.push("\u250C\u2500 Conflict Check \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
         let conflictsFound = false;
         if (dataDir) {
-          const lockFile = join33(dataDir, ".memorix.lock");
+          const lockFile = join34(dataDir, ".memorix.lock");
           if (existsSync33(lockFile)) {
             try {
               const lockData = JSON.parse(readFileSync22(lockFile, "utf-8"));
@@ -272746,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;
@@ -273017,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, {
@@ -273053,6 +273695,16 @@ function checkTOML(p3) {
     return false;
   }
 }
+function checkDshPatch(p3) {
+  if (!exists(p3)) return false;
+  try {
+    const content = fs27.readFileSync(p3, "utf-8");
+    if (!content.includes("memory-memorix")) return false;
+    return /serverName:\s*['"]?memorix['"]?/.test(content);
+  } catch {
+    return false;
+  }
+}
 function getMCPConfigEntries(home, cwd) {
   const entries = [];
   entries.push({
@@ -273184,6 +273836,15 @@ function getMCPConfigEntries(home, cwd) {
     detected: checkJSON(traeCfg),
     note: 'Remove the "memorix" key from mcpServers in this file.'
   });
+  const dshPatchPath = path45.join(process.env.DSH_HOME?.trim() || path45.join(home, ".dsh"), "cordis.patch.yml");
+  entries.push({
+    agent: "DeepSeek Harness",
+    path: dshPatchPath,
+    kind: "global",
+    format: "json",
+    detected: checkDshPatch(dshPatchPath),
+    note: "Remove the memory-memorix insert row from this patch file."
+  });
   return entries;
 }
 function checkBackground(home) {
@@ -274688,7 +275349,7 @@ var init_pipeline_trace = __esm({
 // src/orchestrate/worktree.ts
 import { execFileSync as execFileSync5 } from "child_process";
 import { existsSync as existsSync30, rmSync as rmSync2 } from "fs";
-import { join as join31, basename as basename6 } from "path";
+import { join as join32, basename as basename6 } from "path";
 function runGit4(cwd, args, timeout = 5e3) {
   return String(execFileSync5("git", args, {
     cwd,
@@ -274727,7 +275388,7 @@ function isManagedWorktreePath(worktreePath, worktreeBase) {
 function createWorktree(projectDir2, taskId, pipelineId) {
   const shortId2 = taskId.slice(0, 8);
   const shortPipeline = pipelineId.slice(0, 8);
-  const worktreeBase = join31(projectDir2, WORKTREE_DIR, `task-${shortId2}`);
+  const worktreeBase = join32(projectDir2, WORKTREE_DIR, `task-${shortId2}`);
   const branchBase = `pipeline/${shortPipeline}/task-${shortId2}`;
   for (let attempt = 1; attempt <= 100; attempt++) {
     const suffix = attempt === 1 ? "" : `-${attempt}`;
@@ -274817,7 +275478,7 @@ function listWorktrees(projectDir2) {
       }
     }
     if (current) worktrees.push(current);
-    const worktreeBase = join31(projectDir2, WORKTREE_DIR);
+    const worktreeBase = join32(projectDir2, WORKTREE_DIR);
     return worktrees.filter((w4) => isManagedWorktreePath(w4.path, worktreeBase));
   } catch {
     return [];
@@ -275239,16 +275900,16 @@ var init_cost_tracker = __esm({
 
 // src/orchestrate/evidence.ts
 import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync9 } from "fs";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 function writeTaskEvidence(projectDir2, pipelineId, evidence) {
   try {
-    const dir = join32(projectDir2, ".pipeline", pipelineId, "evidence", evidence.taskId.slice(0, 12));
+    const dir = join33(projectDir2, ".pipeline", pipelineId, "evidence", evidence.taskId.slice(0, 12));
     mkdirSync9(dir, { recursive: true });
     if (evidence.prompt) {
-      safeWrite(join32(dir, "prompt.md"), evidence.prompt);
+      safeWrite(join33(dir, "prompt.md"), evidence.prompt);
     }
     if (evidence.tailOutput) {
-      safeWrite(join32(dir, "output.txt"), evidence.tailOutput);
+      safeWrite(join33(dir, "output.txt"), evidence.tailOutput);
     }
     if (evidence.gateResults) {
       for (const g4 of evidence.gateResults) {
@@ -275257,7 +275918,7 @@ Status: ${g4.passed ? "PASS" : "FAIL"}
 Duration: ${(g4.durationMs / 1e3).toFixed(1)}s
 
 ${g4.output}`;
-        safeWrite(join32(dir, `${g4.gate}.txt`), content);
+        safeWrite(join33(dir, `${g4.gate}.txt`), content);
       }
     }
     const resultJson = {
@@ -275271,7 +275932,7 @@ ${g4.output}`;
       tokenUsage: evidence.tokenUsage,
       costUSD: evidence.costUSD
     };
-    safeWrite(join32(dir, "result.json"), JSON.stringify(resultJson, null, 2));
+    safeWrite(join33(dir, "result.json"), JSON.stringify(resultJson, null, 2));
     return dir;
   } catch {
     return null;
@@ -275279,7 +275940,7 @@ ${g4.output}`;
 }
 function writePipelineSummary(projectDir2, summary) {
   try {
-    const dir = join32(projectDir2, ".pipeline", summary.pipelineId);
+    const dir = join33(projectDir2, ".pipeline", summary.pipelineId);
     mkdirSync9(dir, { recursive: true });
     const elapsed = (summary.elapsedMs / 1e3).toFixed(0);
     const lines = [
@@ -275300,8 +275961,8 @@ function writePipelineSummary(projectDir2, summary) {
       lines.push(`- [${status}] ${t4.taskDescription.slice(0, 80)} \u2014 ${t4.agentName}, ${dur}s${fixes}`);
     }
     const content = lines.join("\n") + "\n";
-    safeWrite(join32(dir, "summary.md"), content);
-    return join32(dir, "summary.md");
+    safeWrite(join33(dir, "summary.md"), content);
+    return join33(dir, "summary.md");
   } catch {
     return null;
   }
@@ -281898,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({
@@ -281973,6 +282635,7 @@ var main2 = defineCommand({
       "repair",
       "dashboard",
       "cleanup",
+      "purge",
       "uninstall",
       "orchestrate"
     ];
@@ -282036,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.");