memorix 0.9.33 → 0.9.35

package/dist/cli/index.js

@@ -2615,10 +2615,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path9) {
-  if (!path9)
+function getElementAtPath(obj, path10) {
+  if (!path10)
     return obj;
-  return path9.reduce((acc, key) => acc?.[key], obj);
+  return path10.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -2867,11 +2867,11 @@ function aborted(x3, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path9, issues) {
+function prefixIssues(path10, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path9);
+    iss.path.unshift(path10);
     return iss;
   });
 }
@@ -9225,8 +9225,8 @@ var init_parseUtil = __esm({
     init_errors3();
     init_en2();
     makeIssue = (params) => {
-      const { data, path: path9, errorMaps, issueData } = params;
-      const fullPath = [...path9, ...issueData.path || []];
+      const { data, path: path10, errorMaps, issueData } = params;
+      const fullPath = [...path10, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -9540,11 +9540,11 @@ var init_types2 = __esm({
     init_parseUtil();
     init_util2();
     ParseInputLazyPath = class {
-      constructor(parent, value, path9, key) {
+      constructor(parent, value, path10, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path9;
+        this._path = path10;
         this._key = key;
       }
       get path() {
@@ -19090,8 +19090,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path9) {
-      let input = path9;
+    function removeDotSegments(path10) {
+      let input = path10;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -19291,8 +19291,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path9, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path9 && path9 !== "/" ? path9 : void 0;
+        const [path10, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path10 && path10 !== "/" ? path10 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -22691,12 +22691,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f4;
     };
-    function addFormats(ajv, list, fs6, exportName) {
+    function addFormats(ajv, list, fs7, exportName) {
       var _a;
       var _b;
       (_a = (_b = ajv.opts.code).formats) !== null && _a !== void 0 ? _a : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f4 of list)
-        ajv.addFormat(f4, fs6[f4]);
+        ajv.addFormat(f4, fs7[f4]);
     }
     module2.exports = exports2 = formatsPlugin;
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -24563,9 +24563,6 @@ import { promises as fs2 } from "fs";
 import path3 from "path";
 import os from "os";
 async function getProjectDataDir(_projectId, baseDir) {
-  if (_projectId === "__invalid__") {
-    throw new Error("Cannot create data directory for invalid project");
-  }
   const base = baseDir ?? DEFAULT_DATA_DIR;
   await fs2.mkdir(base, { recursive: true });
   return base;
@@ -25252,15 +25249,15 @@ function getDocumentProperties(doc, paths) {
   const properties = {};
   const pathsLength = paths.length;
   for (let i2 = 0; i2 < pathsLength; i2++) {
-    const path9 = paths[i2];
-    const pathTokens = path9.split(".");
+    const path10 = paths[i2];
+    const pathTokens = path10.split(".");
     let current = doc;
     const pathTokensLength = pathTokens.length;
     for (let j3 = 0; j3 < pathTokensLength; j3++) {
       current = current[pathTokens[j3]];
       if (typeof current === "object") {
         if (current !== null && "lat" in current && "lon" in current && typeof current.lat === "number" && typeof current.lon === "number") {
-          current = properties[path9] = current;
+          current = properties[path10] = current;
           break;
         } else if (!Array.isArray(current) && current !== null && j3 === pathTokensLength - 1) {
           current = void 0;
@@ -25272,14 +25269,14 @@ function getDocumentProperties(doc, paths) {
       }
     }
     if (typeof current !== "undefined") {
-      properties[path9] = current;
+      properties[path10] = current;
     }
   }
   return properties;
 }
-function getNested(obj, path9) {
-  const props = getDocumentProperties(obj, [path9]);
-  return props[path9];
+function getNested(obj, path10) {
+  const props = getDocumentProperties(obj, [path10]);
+  return props[path10];
 }
 function convertDistanceToMeters(distance, unit) {
   const ratio = mapDistanceToMeters[unit];
@@ -25295,10 +25292,10 @@ function removeVectorsFromHits(searchResult, vectorProperties) {
       ...result.document,
       // Remove embeddings from the result
       ...vectorProperties.reduce((acc, prop) => {
-        const path9 = prop.split(".");
-        const lastKey = path9.pop();
+        const path10 = prop.split(".");
+        const lastKey = path10.pop();
         let obj = acc;
-        for (const key of path9) {
+        for (const key of path10) {
           obj[key] = obj[key] ?? {};
           obj = obj[key];
         }
@@ -26030,15 +26027,15 @@ var init_avl = __esm({
         if (node === null) {
           return new AVLNode(key, [value]);
         }
-        const path9 = [];
+        const path10 = [];
         let current = node;
         let parent = null;
         while (current !== null) {
-          path9.push({ parent, node: current });
+          path10.push({ parent, node: current });
           if (key < current.k) {
             if (current.l === null) {
               current.l = new AVLNode(key, [value]);
-              path9.push({ parent: current, node: current.l });
+              path10.push({ parent: current, node: current.l });
               break;
             } else {
               parent = current;
@@ -26047,7 +26044,7 @@ var init_avl = __esm({
           } else if (key > current.k) {
             if (current.r === null) {
               current.r = new AVLNode(key, [value]);
-              path9.push({ parent: current, node: current.r });
+              path10.push({ parent: current, node: current.r });
               break;
             } else {
               parent = current;
@@ -26062,8 +26059,8 @@ var init_avl = __esm({
         if (this.insertCount++ % rebalanceThreshold === 0) {
           needRebalance = true;
         }
-        for (let i2 = path9.length - 1; i2 >= 0; i2--) {
-          const { parent: parent2, node: currentNode } = path9[i2];
+        for (let i2 = path10.length - 1; i2 >= 0; i2--) {
+          const { parent: parent2, node: currentNode } = path10[i2];
           currentNode.updateHeight();
           if (needRebalance) {
             const rebalancedNode = this.rebalanceNode(currentNode);
@@ -26169,10 +26166,10 @@ var init_avl = __esm({
       removeNode(node, key) {
         if (node === null)
           return null;
-        const path9 = [];
+        const path10 = [];
         let current = node;
         while (current !== null && current.k !== key) {
-          path9.push(current);
+          path10.push(current);
           if (key < current.k) {
             current = current.l;
           } else {
@@ -26184,10 +26181,10 @@ var init_avl = __esm({
         }
         if (current.l === null || current.r === null) {
           const child = current.l ? current.l : current.r;
-          if (path9.length === 0) {
+          if (path10.length === 0) {
             node = child;
           } else {
-            const parent = path9[path9.length - 1];
+            const parent = path10[path10.length - 1];
             if (parent.l === current) {
               parent.l = child;
             } else {
@@ -26210,13 +26207,13 @@ var init_avl = __esm({
           }
           current = successorParent;
         }
-        path9.push(current);
-        for (let i2 = path9.length - 1; i2 >= 0; i2--) {
-          const currentNode = path9[i2];
+        path10.push(current);
+        for (let i2 = path10.length - 1; i2 >= 0; i2--) {
+          const currentNode = path10[i2];
           currentNode.updateHeight();
           const rebalancedNode = this.rebalanceNode(currentNode);
           if (i2 > 0) {
-            const parent = path9[i2 - 1];
+            const parent = path10[i2 - 1];
             if (parent.l === currentNode) {
               parent.l = rebalancedNode;
             } else if (parent.r === currentNode) {
@@ -27383,15 +27380,15 @@ function create2(orama, sharedInternalDocumentStore, schema, index, prefix = "")
     };
   }
   for (const [prop, type] of Object.entries(schema)) {
-    const path9 = `${prefix}${prefix ? "." : ""}${prop}`;
+    const path10 = `${prefix}${prefix ? "." : ""}${prop}`;
     if (typeof type === "object" && !Array.isArray(type)) {
-      create2(orama, sharedInternalDocumentStore, type, index, path9);
+      create2(orama, sharedInternalDocumentStore, type, index, path10);
       continue;
     }
     if (isVectorType(type)) {
-      index.searchableProperties.push(path9);
-      index.searchablePropertiesWithTypes[path9] = type;
-      index.vectorIndexes[path9] = {
+      index.searchableProperties.push(path10);
+      index.searchablePropertiesWithTypes[path10] = type;
+      index.vectorIndexes[path10] = {
         type: "Vector",
         node: new VectorIndex(getVectorSize(type)),
         isArray: false
@@ -27401,32 +27398,32 @@ function create2(orama, sharedInternalDocumentStore, schema, index, prefix = "")
       switch (type) {
         case "boolean":
         case "boolean[]":
-          index.indexes[path9] = { type: "Bool", node: new BoolNode(), isArray };
+          index.indexes[path10] = { type: "Bool", node: new BoolNode(), isArray };
           break;
         case "number":
         case "number[]":
-          index.indexes[path9] = { type: "AVL", node: new AVLTree(0, []), isArray };
+          index.indexes[path10] = { type: "AVL", node: new AVLTree(0, []), isArray };
           break;
         case "string":
         case "string[]":
-          index.indexes[path9] = { type: "Radix", node: new RadixTree(), isArray };
-          index.avgFieldLength[path9] = 0;
-          index.frequencies[path9] = {};
-          index.tokenOccurrences[path9] = {};
-          index.fieldLengths[path9] = {};
+          index.indexes[path10] = { type: "Radix", node: new RadixTree(), isArray };
+          index.avgFieldLength[path10] = 0;
+          index.frequencies[path10] = {};
+          index.tokenOccurrences[path10] = {};
+          index.fieldLengths[path10] = {};
           break;
         case "enum":
         case "enum[]":
-          index.indexes[path9] = { type: "Flat", node: new FlatTree(), isArray };
+          index.indexes[path10] = { type: "Flat", node: new FlatTree(), isArray };
           break;
         case "geopoint":
-          index.indexes[path9] = { type: "BKD", node: new BKDTree(), isArray };
+          index.indexes[path10] = { type: "BKD", node: new BKDTree(), isArray };
           break;
         default:
-          throw createError("INVALID_SCHEMA_TYPE", Array.isArray(type) ? "array" : type, path9);
+          throw createError("INVALID_SCHEMA_TYPE", Array.isArray(type) ? "array" : type, path10);
       }
-      index.searchableProperties.push(path9);
-      index.searchablePropertiesWithTypes[path9] = type;
+      index.searchableProperties.push(path10);
+      index.searchablePropertiesWithTypes[path10] = type;
     }
   }
   return index;
@@ -27997,12 +27994,12 @@ function innerCreate(orama, sharedInternalDocumentStore, schema, sortableDeniedP
     sorts: {}
   };
   for (const [prop, type] of Object.entries(schema)) {
-    const path9 = `${prefix}${prefix ? "." : ""}${prop}`;
-    if (sortableDeniedProperties.includes(path9)) {
+    const path10 = `${prefix}${prefix ? "." : ""}${prop}`;
+    if (sortableDeniedProperties.includes(path10)) {
       continue;
     }
     if (typeof type === "object" && !Array.isArray(type)) {
-      const ret = innerCreate(orama, sharedInternalDocumentStore, type, sortableDeniedProperties, path9);
+      const ret = innerCreate(orama, sharedInternalDocumentStore, type, sortableDeniedProperties, path10);
       safeArrayPush(sorter.sortableProperties, ret.sortableProperties);
       sorter.sorts = {
         ...sorter.sorts,
@@ -28019,9 +28016,9 @@ function innerCreate(orama, sharedInternalDocumentStore, schema, sortableDeniedP
         case "boolean":
         case "number":
         case "string":
-          sorter.sortableProperties.push(path9);
-          sorter.sortablePropertiesWithTypes[path9] = type;
-          sorter.sorts[path9] = {
+          sorter.sortableProperties.push(path10);
+          sorter.sortablePropertiesWithTypes[path10] = type;
+          sorter.sorts[path10] = {
             docs: /* @__PURE__ */ new Map(),
             orderedDocsToRemove: /* @__PURE__ */ new Map(),
             orderedDocs: [],
@@ -28037,7 +28034,7 @@ function innerCreate(orama, sharedInternalDocumentStore, schema, sortableDeniedP
         case "string[]":
           continue;
         default:
-          throw createError("INVALID_SORT_SCHEMA_TYPE", Array.isArray(type) ? "array" : type, path9);
+          throw createError("INVALID_SORT_SCHEMA_TYPE", Array.isArray(type) ? "array" : type, path10);
       }
     }
   }
@@ -29882,8 +29879,8 @@ function innerFullTextSearch(orama, params, language) {
 function escapeRegex2(str2) {
   return str2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function getPropValue(obj, path9) {
-  const keys = path9.split(".");
+function getPropValue(obj, path10) {
+  const keys = path10.split(".");
   let value = obj;
   for (const key of keys) {
     if (value && typeof value === "object" && key in value) {
@@ -31045,6 +31042,217 @@ var init_provider = __esm({
   }
 });
 
+// src/project/aliases.ts
+var aliases_exports = {};
+__export(aliases_exports, {
+  autoMergeByBaseName: () => autoMergeByBaseName,
+  getAllAliasGroups: () => getAllAliasGroups,
+  getCanonicalId: () => getCanonicalId,
+  initAliasRegistry: () => initAliasRegistry,
+  registerAlias: () => registerAlias,
+  resetAliasCache: () => resetAliasCache,
+  resolveAliases: () => resolveAliases
+});
+import { promises as fs3 } from "fs";
+import path4 from "path";
+import os2 from "os";
+function normalizePath(p2) {
+  let normalized = p2.replace(/\\/g, "/").replace(/\/+$/, "");
+  if (process.platform === "win32") {
+    normalized = normalized.toLowerCase();
+  }
+  return normalized;
+}
+function idPriority(id) {
+  if (id.startsWith("placeholder/")) return 0;
+  if (id.startsWith("local/")) return 1;
+  return 2;
+}
+function getRegistryPath(baseDir) {
+  return path4.join(baseDir ?? registryDir ?? DEFAULT_DATA_DIR2, ALIAS_FILE);
+}
+async function loadRegistry(baseDir) {
+  if (registryCache) return registryCache;
+  try {
+    const data = await fs3.readFile(getRegistryPath(baseDir), "utf-8");
+    const parsed = JSON.parse(data);
+    if (parsed.version === 1 && Array.isArray(parsed.groups)) {
+      registryCache = parsed;
+      return registryCache;
+    }
+  } catch {
+  }
+  registryCache = { version: 1, groups: [] };
+  return registryCache;
+}
+async function saveRegistry(baseDir) {
+  if (!registryCache) return;
+  const filePath = getRegistryPath(baseDir);
+  await fs3.mkdir(path4.dirname(filePath), { recursive: true });
+  await fs3.writeFile(filePath, JSON.stringify(registryCache, null, 2), "utf-8");
+}
+function findMatchingGroup(registry2, projectInfo) {
+  const normalizedRoot = normalizePath(projectInfo.rootPath);
+  for (const group of registry2.groups) {
+    if (group.aliases.includes(projectInfo.id)) return group;
+    if (group.rootPaths.some((rp) => rp === normalizedRoot)) return group;
+    if (projectInfo.gitRemote && group.gitRemote && group.gitRemote === projectInfo.gitRemote) {
+      return group;
+    }
+  }
+  return null;
+}
+function selectCanonical(aliases) {
+  return [...aliases].sort((a3, b3) => idPriority(b3) - idPriority(a3))[0];
+}
+async function registerAlias(projectInfo, baseDir) {
+  const registry2 = await loadRegistry(baseDir);
+  const normalizedRoot = normalizePath(projectInfo.rootPath);
+  const existingGroup = findMatchingGroup(registry2, projectInfo);
+  if (existingGroup) {
+    let changed = false;
+    if (!existingGroup.aliases.includes(projectInfo.id)) {
+      existingGroup.aliases.push(projectInfo.id);
+      changed = true;
+    }
+    if (!existingGroup.rootPaths.includes(normalizedRoot)) {
+      existingGroup.rootPaths.push(normalizedRoot);
+      changed = true;
+    }
+    if (projectInfo.gitRemote && !existingGroup.gitRemote) {
+      existingGroup.gitRemote = projectInfo.gitRemote;
+      changed = true;
+    }
+    const newCanonical = selectCanonical(existingGroup.aliases);
+    if (newCanonical !== existingGroup.canonical) {
+      existingGroup.canonical = newCanonical;
+      changed = true;
+    }
+    if (changed) {
+      await saveRegistry(baseDir);
+    }
+    return existingGroup.canonical;
+  }
+  const newGroup = {
+    canonical: projectInfo.id,
+    aliases: [projectInfo.id],
+    rootPaths: [normalizedRoot],
+    ...projectInfo.gitRemote ? { gitRemote: projectInfo.gitRemote } : {}
+  };
+  registry2.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) {
+    if (group.aliases.includes(projectId) || group.canonical === projectId) {
+      return [...group.aliases];
+    }
+  }
+  return [projectId];
+}
+async function getCanonicalId(projectId, baseDir) {
+  const registry2 = await loadRegistry(baseDir);
+  for (const group of registry2.groups) {
+    if (group.aliases.includes(projectId) || group.canonical === projectId) {
+      return group.canonical;
+    }
+  }
+  return projectId;
+}
+async function getAllAliasGroups(baseDir) {
+  const registry2 = await loadRegistry(baseDir);
+  return registry2.groups;
+}
+async function autoMergeByBaseName(observedIds, baseDir) {
+  if (observedIds.length <= 1) return 0;
+  const registry2 = await loadRegistry(baseDir);
+  const byBaseName = /* @__PURE__ */ new Map();
+  for (const id of observedIds) {
+    const baseName = id.split("/").pop() ?? id;
+    if (!byBaseName.has(baseName)) byBaseName.set(baseName, []);
+    byBaseName.get(baseName).push(id);
+  }
+  let mergeCount = 0;
+  for (const [_baseName, ids] of byBaseName) {
+    if (ids.length <= 1) continue;
+    const existingGroups = /* @__PURE__ */ new Set();
+    const ungroupedIds = [];
+    for (const id of ids) {
+      const groupIdx = registry2.groups.findIndex(
+        (g3) => g3.aliases.includes(id) || g3.canonical === id
+      );
+      if (groupIdx >= 0) {
+        existingGroups.add(groupIdx);
+      } else {
+        ungroupedIds.push(id);
+      }
+    }
+    if (existingGroups.size <= 1 && ungroupedIds.length === 0) continue;
+    const allIdsInGroup = [...ids];
+    const canonical = selectCanonical(allIdsInGroup);
+    if (existingGroups.size > 0) {
+      const primaryIdx = [...existingGroups][0];
+      const primaryGroup = registry2.groups[primaryIdx];
+      for (const id of allIdsInGroup) {
+        if (!primaryGroup.aliases.includes(id)) {
+          primaryGroup.aliases.push(id);
+        }
+      }
+      const otherIdxs = [...existingGroups].slice(1).sort((a3, b3) => b3 - a3);
+      for (const idx of otherIdxs) {
+        const other = registry2.groups[idx];
+        for (const alias of other.aliases) {
+          if (!primaryGroup.aliases.includes(alias)) {
+            primaryGroup.aliases.push(alias);
+          }
+        }
+        for (const rp of other.rootPaths) {
+          if (!primaryGroup.rootPaths.includes(rp)) {
+            primaryGroup.rootPaths.push(rp);
+          }
+        }
+        if (other.gitRemote && !primaryGroup.gitRemote) {
+          primaryGroup.gitRemote = other.gitRemote;
+        }
+        registry2.groups.splice(idx, 1);
+      }
+      primaryGroup.canonical = selectCanonical(primaryGroup.aliases);
+      mergeCount++;
+    } else {
+      registry2.groups.push({
+        canonical,
+        aliases: allIdsInGroup,
+        rootPaths: []
+      });
+      mergeCount++;
+    }
+  }
+  if (mergeCount > 0) {
+    await saveRegistry(baseDir);
+  }
+  return mergeCount;
+}
+function initAliasRegistry(dataDir) {
+  registryDir = dataDir;
+  registryCache = null;
+}
+function resetAliasCache() {
+  registryCache = null;
+}
+var DEFAULT_DATA_DIR2, ALIAS_FILE, registryCache, registryDir;
+var init_aliases = __esm({
+  "src/project/aliases.ts"() {
+    "use strict";
+    init_esm_shims();
+    DEFAULT_DATA_DIR2 = path4.join(os2.homedir(), ".memorix", "data");
+    ALIAS_FILE = ".project-aliases.json";
+    registryCache = null;
+    registryDir = null;
+  }
+});
+
 // src/store/orama-store.ts
 var orama_store_exports = {};
 __export(orama_store_exports, {
@@ -31116,17 +31324,27 @@ async function removeObservation(oramaId) {
 }
 async function searchObservations(options2) {
   const database = await getDb();
-  const filters = {};
+  let projectIds = null;
   if (options2.projectId) {
-    filters["projectId"] = options2.projectId;
+    try {
+      const { resolveAliases: resolveAliases3 } = await Promise.resolve().then(() => (init_aliases(), aliases_exports));
+      projectIds = await resolveAliases3(options2.projectId);
+    } catch {
+      projectIds = [options2.projectId];
+    }
+  }
+  const filters = {};
+  if (projectIds && projectIds.length === 1) {
+    filters["projectId"] = projectIds[0];
   }
   if (options2.type) {
     filters["type"] = options2.type;
   }
   const hasQuery = options2.query && options2.query.trim().length > 0;
+  const requestLimit = projectIds && projectIds.length > 1 ? (options2.limit ?? 20) * 3 : options2.limit ?? 20;
   let searchParams = {
     term: options2.query,
-    limit: options2.limit ?? 20,
+    limit: requestLimit,
     ...Object.keys(filters).length > 0 ? { where: filters } : {},
     // Search specific fields (not tokens, accessCount, etc.)
     properties: ["title", "entityName", "narrative", "facts", "concepts", "filesModified"],
@@ -31165,7 +31383,11 @@ async function searchObservations(options2) {
     }
   }
   const results = await search2(database, searchParams);
-  let intermediate = results.hits.map((hit) => {
+  let intermediate = results.hits.filter((hit) => {
+    if (!projectIds || projectIds.length <= 1) return true;
+    const doc = hit.document;
+    return projectIds.includes(doc.projectId);
+  }).map((hit) => {
     const doc = hit.document;
     const obsType = doc.type;
     return {
@@ -31186,50 +31408,30 @@ async function searchObservations(options2) {
     const untilDate = new Date(options2.until).getTime();
     intermediate = intermediate.filter((e3) => new Date(e3.rawTime).getTime() <= untilDate);
   }
+  if (projectIds && projectIds.length > 1) {
+    intermediate = intermediate.slice(0, options2.limit ?? 20);
+  }
   let entries = intermediate.map(({ rawTime: _4, ...rest }) => rest);
   if (hasQuery && options2.query) {
     const queryLower = options2.query.toLowerCase();
     const queryTokens = queryLower.split(/\s+/).filter((t2) => t2.length > 1);
+    const entryMap = new Map(entries.map((e3) => [e3.id, e3]));
     for (const hit of results.hits) {
       const doc = hit.document;
-      const entry = entries.find((e3) => e3.id === doc.observationId);
+      const entry = entryMap.get(doc.observationId);
       if (!entry) continue;
       const reasons = [];
-      for (const token of queryTokens) {
-        if (doc.title.toLowerCase().includes(token)) {
-          reasons.push("title");
-          break;
-        }
-      }
-      for (const token of queryTokens) {
-        if (doc.entityName.toLowerCase().includes(token)) {
-          reasons.push("entity");
-          break;
-        }
-      }
-      for (const token of queryTokens) {
-        if (doc.concepts.toLowerCase().includes(token)) {
-          reasons.push("concept");
-          break;
-        }
-      }
-      for (const token of queryTokens) {
-        if (doc.narrative.toLowerCase().includes(token)) {
-          reasons.push("narrative");
-          break;
-        }
-      }
-      for (const token of queryTokens) {
-        if (doc.facts.toLowerCase().includes(token)) {
-          reasons.push("fact");
-          break;
-        }
-      }
-      for (const token of queryTokens) {
-        if (doc.filesModified.toLowerCase().includes(token)) {
-          reasons.push("file");
-          break;
-        }
+      const fields = [
+        ["title", doc.title],
+        ["entity", doc.entityName],
+        ["concept", doc.concepts],
+        ["narrative", doc.narrative],
+        ["fact", doc.facts],
+        ["file", doc.filesModified]
+      ];
+      for (const [name, value] of fields) {
+        const valueLower = value.toLowerCase();
+        if (queryTokens.some((t2) => valueLower.includes(t2))) reasons.push(name);
       }
       if (reasons.length === 0) reasons.push("fuzzy");
       entry["matchedFields"] = reasons;
@@ -31238,8 +31440,8 @@ async function searchObservations(options2) {
   if (options2.maxTokens && options2.maxTokens > 0) {
     entries = applyTokenBudget(entries, options2.maxTokens);
   }
-  const hitIds = results.hits.map((h3) => h3.document.id);
-  recordAccessBatch(hitIds).catch(() => {
+  const hitDocs = results.hits.map((h3) => ({ id: h3.id, doc: h3.document }));
+  recordAccessBatch(hitDocs).catch(() => {
   });
   return entries;
 }
@@ -31288,20 +31490,12 @@ async function getTimeline(anchorId, _projectId, depthBefore = 3, depthAfter = 3
     after
   };
 }
-async function recordAccessBatch(oramaIds) {
+async function recordAccessBatch(hitDocs) {
   const database = await getDb();
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  for (const id of oramaIds) {
+  for (const { id, doc } of hitDocs) {
     try {
-      const result = await search2(database, {
-        term: "",
-        where: { id },
-        limit: 1
-      });
-      if (result.hits.length === 0) continue;
-      const doc = result.hits[0].document;
-      await remove4(database, id);
-      await insert3(database, {
+      await update(database, id, {
         ...doc,
         accessCount: (doc.accessCount ?? 0) + 1,
         lastAccessedAt: now
@@ -33355,6 +33549,7 @@ __export(observations_exports, {
   getObservationCount: () => getObservationCount2,
   getProjectObservations: () => getProjectObservations,
   initObservations: () => initObservations,
+  migrateProjectIds: () => migrateProjectIds,
   reindexObservations: () => reindexObservations,
   storeObservation: () => storeObservation,
   suggestTopicKey: () => suggestTopicKey
@@ -33516,8 +33711,29 @@ function getObservation(id) {
   return observations.find((o3) => o3.id === id);
 }
 function getProjectObservations(projectId) {
+  if (Array.isArray(projectId)) {
+    const idSet = new Set(projectId);
+    return observations.filter((o3) => idSet.has(o3.projectId));
+  }
   return observations.filter((o3) => o3.projectId === projectId);
 }
+async function migrateProjectIds(aliasIds, canonicalId) {
+  const nonCanonical = new Set(aliasIds.filter((id) => id !== canonicalId));
+  if (nonCanonical.size === 0) return 0;
+  let migrated = 0;
+  for (const obs of observations) {
+    if (nonCanonical.has(obs.projectId)) {
+      obs.projectId = canonicalId;
+      migrated++;
+    }
+  }
+  if (migrated > 0 && projectDir) {
+    await withFileLock(projectDir, async () => {
+      await saveObservationsJson(projectDir, observations);
+    });
+  }
+  return migrated;
+}
 function getAllObservations() {
   return [...observations];
 }
@@ -33857,31 +34073,34 @@ __export(detector_exports, {
 });
 import { execSync } from "child_process";
 import { existsSync, readFileSync } from "fs";
-import os2 from "os";
-import path4 from "path";
+import os3 from "os";
+import path5 from "path";
 function detectProject(cwd) {
   const basePath = cwd ?? process.cwd();
   const rootPath = getGitRoot(basePath) ?? findPackageRoot(basePath) ?? basePath;
   const gitRemote = getGitRemote(rootPath);
   if (gitRemote) {
     const id2 = normalizeGitRemote(gitRemote);
-    const name2 = id2.split("/").pop() ?? path4.basename(rootPath);
+    const name2 = id2.split("/").pop() ?? path5.basename(rootPath);
     return { id: id2, name: name2, gitRemote, rootPath };
   }
   if (isDangerousRoot(rootPath)) {
-    console.error(`[memorix] Skipped invalid project root: ${rootPath}`);
-    return { id: "__invalid__", name: "unknown", rootPath };
+    const name2 = path5.basename(rootPath) || "unknown";
+    const id2 = `placeholder/${name2}`;
+    console.error(`[memorix] WARNING: cwd "${rootPath}" is not a project directory \u2014 using degraded mode (${id2})`);
+    console.error(`[memorix] For best results, set MEMORIX_PROJECT_ROOT or --cwd to your project path.`);
+    return { id: id2, name: name2, rootPath };
   }
-  const name = path4.basename(rootPath);
+  const name = path5.basename(rootPath);
   const id = `local/${name}`;
   return { id, name, rootPath };
 }
 function isDangerousRoot(dirPath) {
-  const resolved = path4.resolve(dirPath);
-  const home = path4.resolve(os2.homedir());
+  const resolved = path5.resolve(dirPath);
+  const home = path5.resolve(os3.homedir());
   if (resolved === home) return true;
-  if (resolved === path4.parse(resolved).root) return true;
-  const basename2 = path4.basename(resolved).toLowerCase();
+  if (resolved === path5.parse(resolved).root) return true;
+  const basename2 = path5.basename(resolved).toLowerCase();
   const knownNonProjectDirs = /* @__PURE__ */ new Set([
     // IDE / editor config dirs
     ".vscode",
@@ -33915,31 +34134,31 @@ function isDangerousRoot(dirPath) {
     ".memorix"
   ]);
   if (knownNonProjectDirs.has(basename2)) {
-    const parent = path4.resolve(path4.dirname(resolved));
-    if (parent === home || parent === path4.parse(parent).root) {
+    const parent = path5.resolve(path5.dirname(resolved));
+    if (parent === home || parent === path5.parse(parent).root) {
       return true;
     }
   }
   return false;
 }
 function findPackageRoot(cwd) {
-  let dir = path4.resolve(cwd);
-  const root = path4.parse(dir).root;
+  let dir = path5.resolve(cwd);
+  const root = path5.parse(dir).root;
   while (dir !== root) {
     if (isDangerousRoot(dir)) return null;
-    if (existsSync(path4.join(dir, "package.json"))) {
+    if (existsSync(path5.join(dir, "package.json"))) {
       return dir;
     }
-    dir = path4.dirname(dir);
+    dir = path5.dirname(dir);
   }
   return null;
 }
 function getGitRoot(cwd) {
-  let dir = path4.resolve(cwd);
-  const fsRoot = path4.parse(dir).root;
+  let dir = path5.resolve(cwd);
+  const fsRoot = path5.parse(dir).root;
   while (dir !== fsRoot) {
-    if (existsSync(path4.join(dir, ".git"))) return dir;
-    dir = path4.dirname(dir);
+    if (existsSync(path5.join(dir, ".git"))) return dir;
+    dir = path5.dirname(dir);
   }
   try {
     const root = execSync("git -c safe.directory=* rev-parse --show-toplevel", {
@@ -33970,7 +34189,7 @@ function getGitRemote(cwd) {
 }
 function readGitConfigRemote(cwd) {
   try {
-    const configPath = path4.join(cwd, ".git", "config");
+    const configPath = path5.join(cwd, ".git", "config");
     if (!existsSync(configPath)) return null;
     const content = readFileSync(configPath, "utf-8");
     const remoteMatch = content.match(/\[remote\s+"origin"\]([\s\S]*?)(?=\n\[|$)/);
@@ -37419,7 +37638,7 @@ var require_gray_matter = __commonJS({
   "node_modules/gray-matter/index.js"(exports2, module2) {
     "use strict";
     init_esm_shims();
-    var fs6 = __require("fs");
+    var fs7 = __require("fs");
     var sections = require_section_matter();
     var defaults = require_defaults2();
     var stringify = require_stringify();
@@ -37503,7 +37722,7 @@ var require_gray_matter = __commonJS({
       return stringify(file, data, options2);
     };
     matter9.read = function(filepath, options2) {
-      const str2 = fs6.readFileSync(filepath, "utf8");
+      const str2 = fs7.readFileSync(filepath, "utf8");
       const file = matter9(str2, options2);
       file.path = filepath;
       return file;
@@ -38123,8 +38342,8 @@ var syncer_exports = {};
 __export(syncer_exports, {
   RulesSyncer: () => RulesSyncer
 });
-import { promises as fs3 } from "fs";
-import path5 from "path";
+import { promises as fs4 } from "fs";
+import path6 from "path";
 var RulesSyncer;
 var init_syncer = __esm({
   "src/rules/syncer.ts"() {
@@ -38165,8 +38384,8 @@ var init_syncer = __esm({
             const found = await this.findFiles(scanPath);
             for (const filePath of found) {
               try {
-                const content = await fs3.readFile(filePath, "utf-8");
-                const relativePath = path5.relative(this.projectRoot, filePath).replace(/\\/g, "/");
+                const content = await fs4.readFile(filePath, "utf-8");
+                const relativePath = path6.relative(this.projectRoot, filePath).replace(/\\/g, "/");
                 const parsed = entry.adapter.parse(relativePath, content);
                 rules.push(...parsed);
               } catch {
@@ -38234,7 +38453,7 @@ var init_syncer = __esm({
         const entries = [];
         for (const adapter of this.adapters.values()) {
           const absolutePaths = adapter.filePatterns.map(
-            (p2) => path5.join(this.projectRoot, p2)
+            (p2) => path6.join(this.projectRoot, p2)
           );
           entries.push({ adapter, paths: absolutePaths });
         }
@@ -38242,13 +38461,13 @@ var init_syncer = __esm({
       }
       /** Find files matching a glob-like path (simple implementation) */
       async findFiles(pattern) {
-        const dir = path5.dirname(pattern);
-        const fileGlob = path5.basename(pattern);
+        const dir = path6.dirname(pattern);
+        const fileGlob = path6.basename(pattern);
         try {
-          const stat = await fs3.stat(dir);
+          const stat = await fs4.stat(dir);
           if (!stat.isDirectory()) {
             try {
-              await fs3.access(pattern);
+              await fs4.access(pattern);
               return [pattern];
             } catch {
               return [];
@@ -38256,7 +38475,7 @@ var init_syncer = __esm({
           }
         } catch {
           try {
-            await fs3.access(pattern);
+            await fs4.access(pattern);
             return [pattern];
           } catch {
             return [];
@@ -38264,16 +38483,16 @@ var init_syncer = __esm({
         }
         if (fileGlob.includes("*")) {
           try {
-            const files = await fs3.readdir(dir);
+            const files = await fs4.readdir(dir);
             const ext = fileGlob.replace("*", "");
-            return files.filter((f4) => ext ? f4.endsWith(ext) : true).map((f4) => path5.join(dir, f4));
+            return files.filter((f4) => ext ? f4.endsWith(ext) : true).map((f4) => path6.join(dir, f4));
           } catch {
             return [];
           }
         }
         try {
-          await fs3.access(path5.join(dir, fileGlob));
-          return [path5.join(dir, fileGlob)];
+          await fs4.access(path6.join(dir, fileGlob));
+          return [path6.join(dir, fileGlob)];
         } catch {
           return [];
         }
@@ -39108,10 +39327,10 @@ var init_engine2 = __esm({
         for (const [target, adapter] of this.adapters) {
           const configPath = adapter.getConfigPath(this.projectRoot);
           const globalPath = adapter.getConfigPath();
-          for (const path9 of [configPath, globalPath]) {
-            if (existsSync3(path9)) {
+          for (const path10 of [configPath, globalPath]) {
+            if (existsSync3(path10)) {
               try {
-                const content = readFileSync2(path9, "utf-8");
+                const content = readFileSync2(path10, "utf-8");
                 const servers = adapter.parse(content);
                 if (servers.length > 0) {
                   mcpConfigs[target] = servers;
@@ -40314,8 +40533,8 @@ __export(server_exports, {
   startDashboard: () => startDashboard
 });
 import { createServer } from "http";
-import { promises as fs4 } from "fs";
-import path6 from "path";
+import { promises as fs5 } from "fs";
+import path7 from "path";
 import { exec } from "child_process";
 function sendJson(res, data, status = 200) {
   res.writeHead(status, {
@@ -40338,31 +40557,37 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir) {
   let effectiveProjectId = projectId;
   let effectiveProjectName = projectName;
   if (requestedProject && requestedProject !== projectId) {
-    const sanitized = requestedProject.replace(/\//g, "--").replace(/[<>:"|?*\\]/g, "_");
-    const candidateDir = path6.join(baseDir, sanitized);
-    try {
-      await fs4.access(candidateDir);
-      effectiveDataDir = candidateDir;
-      effectiveProjectId = requestedProject;
-      effectiveProjectName = requestedProject.split("/").pop() || requestedProject;
-    } catch {
-    }
+    effectiveDataDir = baseDir;
+    effectiveProjectId = requestedProject;
+    effectiveProjectName = requestedProject.split("/").pop() || requestedProject;
   }
   try {
     switch (apiPath) {
       case "/projects": {
         try {
-          const entries = await fs4.readdir(baseDir, { withFileTypes: true });
-          const projects = entries.filter((e3) => e3.isDirectory() && e3.name.includes("--") && !e3.name.startsWith("local--")).map((e3) => {
-            const dirName = e3.name;
-            const id = dirName.replace(/--/g, "/");
-            return {
-              id,
-              name: id.split("/").pop() || id,
-              dirName,
-              isCurrent: id === projectId
-            };
-          });
+          const allObs = await loadObservationsJson(baseDir);
+          const projectSet = /* @__PURE__ */ new Map();
+          for (const obs of allObs) {
+            if (obs.projectId) {
+              projectSet.set(obs.projectId, (projectSet.get(obs.projectId) || 0) + 1);
+            }
+          }
+          let mergedSet = projectSet;
+          try {
+            const { getCanonicalId: getCanonicalId2 } = await Promise.resolve().then(() => (init_aliases(), aliases_exports));
+            mergedSet = /* @__PURE__ */ new Map();
+            for (const [id, count3] of projectSet) {
+              const canonical = await getCanonicalId2(id);
+              mergedSet.set(canonical, (mergedSet.get(canonical) || 0) + count3);
+            }
+          } catch {
+          }
+          const projects = Array.from(mergedSet.entries()).sort((a3, b3) => b3[1] - a3[1]).map(([id, count3]) => ({
+            id,
+            name: id.split("/").pop() || id,
+            count: count3,
+            isCurrent: id === projectId
+          }));
           sendJson(res, projects);
         } catch {
           sendJson(res, []);
@@ -40522,14 +40747,14 @@ async function serveStatic(req, res, staticDir) {
   if (urlPath === "/" || !urlPath.includes(".")) {
     urlPath = "/index.html";
   }
-  const filePath = path6.join(staticDir, urlPath);
+  const filePath = path7.join(staticDir, urlPath);
   if (!filePath.startsWith(staticDir)) {
     sendError(res, "Forbidden", 403);
     return;
   }
   try {
-    const data = await fs4.readFile(filePath);
-    const ext = path6.extname(filePath);
+    const data = await fs5.readFile(filePath);
+    const ext = path7.extname(filePath);
     res.writeHead(200, {
       "Content-Type": MIME_TYPES[ext] || "application/octet-stream",
       "Cache-Control": "no-cache"
@@ -40537,7 +40762,7 @@ async function serveStatic(req, res, staticDir) {
     res.end(data);
   } catch {
     try {
-      const indexData = await fs4.readFile(path6.join(staticDir, "index.html"));
+      const indexData = await fs5.readFile(path7.join(staticDir, "index.html"));
       res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
       res.end(indexData);
     } catch {
@@ -40568,17 +40793,9 @@ async function startDashboard(dataDir, port, staticDir, projectId, projectName,
       try {
         const body = JSON.parse(await readBody(req));
         if (body.projectId) {
-          const sanitized = body.projectId.replace(/\//g, "--").replace(/[<>:"|?*\\]/g, "_");
-          const candidateDir = path6.join(baseDir, sanitized);
-          try {
-            await fs4.access(candidateDir);
-          } catch {
-            sendError(res, `Project data directory not found: ${candidateDir}`, 404);
-            return;
-          }
           state.projectId = body.projectId;
           state.projectName = body.projectName || body.projectId.split("/").pop() || body.projectId;
-          state.dataDir = candidateDir;
+          state.dataDir = baseDir;
           console.error(`[dashboard] Switched current project to: ${state.projectId}`);
           sendJson(res, { ok: true, projectId: state.projectId, projectName: state.projectName });
         } else {
@@ -40647,9 +40864,9 @@ __export(installers_exports, {
   installHooks: () => installHooks,
   uninstallHooks: () => uninstallHooks
 });
-import * as fs5 from "fs/promises";
-import * as path7 from "path";
-import * as os3 from "os";
+import * as fs6 from "fs/promises";
+import * as path8 from "path";
+import * as os4 from "os";
 function resolveHookCommand() {
   if (process.platform === "win32") {
     return "cmd /c memorix";
@@ -40797,81 +41014,81 @@ function generateKiroHookFiles() {
 function getProjectConfigPath(agent, projectRoot) {
   switch (agent) {
     case "claude":
-      return path7.join(projectRoot, ".claude", "settings.local.json");
+      return path8.join(projectRoot, ".claude", "settings.local.json");
     case "copilot":
-      return path7.join(projectRoot, ".github", "hooks", "memorix.json");
+      return path8.join(projectRoot, ".github", "hooks", "memorix.json");
     case "windsurf":
-      return path7.join(projectRoot, ".windsurf", "hooks.json");
+      return path8.join(projectRoot, ".windsurf", "hooks.json");
     case "cursor":
-      return path7.join(projectRoot, ".cursor", "hooks.json");
+      return path8.join(projectRoot, ".cursor", "hooks.json");
     case "kiro":
-      return path7.join(projectRoot, ".kiro", "hooks", "memorix-agent-stop.kiro.hook");
+      return path8.join(projectRoot, ".kiro", "hooks", "memorix-agent-stop.kiro.hook");
     case "codex":
-      return path7.join(projectRoot, "AGENTS.md");
+      return path8.join(projectRoot, "AGENTS.md");
     case "antigravity":
-      return path7.join(projectRoot, ".gemini", "settings.json");
+      return path8.join(projectRoot, ".gemini", "settings.json");
     default:
-      return path7.join(projectRoot, ".memorix", "hooks.json");
+      return path8.join(projectRoot, ".memorix", "hooks.json");
   }
 }
 function getGlobalConfigPath(agent) {
-  const home = os3.homedir();
+  const home = os4.homedir();
   switch (agent) {
     case "claude":
     case "copilot":
-      return path7.join(home, ".claude", "settings.json");
+      return path8.join(home, ".claude", "settings.json");
     case "windsurf":
-      return path7.join(home, ".codeium", "windsurf", "hooks.json");
+      return path8.join(home, ".codeium", "windsurf", "hooks.json");
     case "cursor":
-      return path7.join(home, ".cursor", "hooks.json");
+      return path8.join(home, ".cursor", "hooks.json");
     case "antigravity":
-      return path7.join(home, ".gemini", "settings.json");
+      return path8.join(home, ".gemini", "settings.json");
     default:
-      return path7.join(home, ".memorix", "hooks.json");
+      return path8.join(home, ".memorix", "hooks.json");
   }
 }
 async function detectInstalledAgents() {
   const agents = [];
-  const home = os3.homedir();
-  const claudeDir = path7.join(home, ".claude");
+  const home = os4.homedir();
+  const claudeDir = path8.join(home, ".claude");
   try {
-    await fs5.access(claudeDir);
+    await fs6.access(claudeDir);
     agents.push("claude");
   } catch {
   }
-  const windsurfDir = path7.join(home, ".codeium", "windsurf");
+  const windsurfDir = path8.join(home, ".codeium", "windsurf");
   try {
-    await fs5.access(windsurfDir);
+    await fs6.access(windsurfDir);
     agents.push("windsurf");
   } catch {
   }
-  const cursorDir = path7.join(home, ".cursor");
+  const cursorDir = path8.join(home, ".cursor");
   try {
-    await fs5.access(cursorDir);
+    await fs6.access(cursorDir);
     agents.push("cursor");
   } catch {
   }
-  const vscodeDir = path7.join(home, ".vscode");
+  const vscodeDir = path8.join(home, ".vscode");
   try {
-    await fs5.access(vscodeDir);
+    await fs6.access(vscodeDir);
     agents.push("copilot");
   } catch {
   }
-  const kiroConfig = path7.join(home, ".kiro");
+  const kiroConfig = path8.join(home, ".kiro");
   try {
-    await fs5.access(kiroConfig);
+    await fs6.access(kiroConfig);
     agents.push("kiro");
   } catch {
   }
-  const codexDir = path7.join(home, ".codex");
+  const codexDir = path8.join(home, ".codex");
   try {
-    await fs5.access(codexDir);
+    await fs6.access(codexDir);
     agents.push("codex");
   } catch {
   }
-  const geminiDir = path7.join(home, ".gemini");
+  const geminiDir = path8.join(home, ".gemini");
   try {
-    await fs5.access(geminiDir);
+    await fs6.access(geminiDir);
     agents.push("antigravity");
   } catch {
   }
@@ -40910,18 +41127,18 @@ async function installHooks(agent, projectRoot, global = false) {
     default:
       generated = generateClaudeConfig();
   }
-  await fs5.mkdir(path7.dirname(configPath), { recursive: true });
+  await fs6.mkdir(path8.dirname(configPath), { recursive: true });
   if (agent === "kiro") {
     const hookFiles = generateKiroHookFiles();
-    const hooksDir = path7.join(path7.dirname(configPath));
-    await fs5.mkdir(hooksDir, { recursive: true });
+    const hooksDir = path8.join(path8.dirname(configPath));
+    await fs6.mkdir(hooksDir, { recursive: true });
     for (const hf of hookFiles) {
-      await fs5.writeFile(path7.join(hooksDir, hf.filename), hf.content, "utf-8");
+      await fs6.writeFile(path8.join(hooksDir, hf.filename), hf.content, "utf-8");
     }
   } else {
     let existing = {};
     try {
-      const content = await fs5.readFile(configPath, "utf-8");
+      const content = await fs6.readFile(configPath, "utf-8");
       existing = JSON.parse(content);
     } catch {
     }
@@ -40948,7 +41165,7 @@ async function installHooks(agent, projectRoot, global = false) {
       const h3 = merged.hooks;
       if (h3) delete h3.preToolUse;
     }
-    await fs5.writeFile(configPath, JSON.stringify(merged, null, 2), "utf-8");
+    await fs6.writeFile(configPath, JSON.stringify(merged, null, 2), "utf-8");
   }
   const events = [];
   switch (agent) {
@@ -40984,45 +41201,45 @@ async function installAgentRules(agent, projectRoot) {
   let rulesPath;
   switch (agent) {
     case "windsurf":
-      rulesPath = path7.join(projectRoot, ".windsurf", "rules", "memorix.md");
+      rulesPath = path8.join(projectRoot, ".windsurf", "rules", "memorix.md");
       break;
     case "cursor":
-      rulesPath = path7.join(projectRoot, ".cursor", "rules", "memorix.mdc");
+      rulesPath = path8.join(projectRoot, ".cursor", "rules", "memorix.mdc");
       break;
     case "claude":
     case "copilot":
-      rulesPath = path7.join(projectRoot, ".github", "copilot-instructions.md");
+      rulesPath = path8.join(projectRoot, ".github", "copilot-instructions.md");
       break;
     case "codex":
-      rulesPath = path7.join(projectRoot, "AGENTS.md");
+      rulesPath = path8.join(projectRoot, "AGENTS.md");
       break;
     case "kiro":
-      rulesPath = path7.join(projectRoot, ".kiro", "steering", "memorix.md");
+      rulesPath = path8.join(projectRoot, ".kiro", "steering", "memorix.md");
       break;
     case "antigravity":
-      rulesPath = path7.join(projectRoot, "GEMINI.md");
+      rulesPath = path8.join(projectRoot, "GEMINI.md");
       break;
     default:
-      rulesPath = path7.join(projectRoot, ".agent", "rules", "memorix.md");
+      rulesPath = path8.join(projectRoot, ".agent", "rules", "memorix.md");
       break;
   }
   try {
-    await fs5.mkdir(path7.dirname(rulesPath), { recursive: true });
+    await fs6.mkdir(path8.dirname(rulesPath), { recursive: true });
     if (agent === "codex" || agent === "antigravity") {
       try {
-        const existing = await fs5.readFile(rulesPath, "utf-8");
+        const existing = await fs6.readFile(rulesPath, "utf-8");
         if (existing.includes("Memorix")) {
           return;
         }
-        await fs5.writeFile(rulesPath, existing + "\n\n" + rulesContent, "utf-8");
+        await fs6.writeFile(rulesPath, existing + "\n\n" + rulesContent, "utf-8");
       } catch {
-        await fs5.writeFile(rulesPath, rulesContent, "utf-8");
+        await fs6.writeFile(rulesPath, rulesContent, "utf-8");
       }
     } else {
       try {
-        await fs5.access(rulesPath);
+        await fs6.access(rulesPath);
       } catch {
-        await fs5.writeFile(rulesPath, rulesContent, "utf-8");
+        await fs6.writeFile(rulesPath, rulesContent, "utf-8");
       }
     }
   } catch {
@@ -41107,15 +41324,15 @@ async function uninstallHooks(agent, projectRoot, global = false) {
   const configPath = global ? getGlobalConfigPath(agent) : getProjectConfigPath(agent, projectRoot);
   try {
     if (agent === "kiro") {
-      await fs5.unlink(configPath);
+      await fs6.unlink(configPath);
     } else {
-      const content = await fs5.readFile(configPath, "utf-8");
+      const content = await fs6.readFile(configPath, "utf-8");
       const config2 = JSON.parse(content);
       delete config2.hooks;
       if (Object.keys(config2).length === 0) {
-        await fs5.unlink(configPath);
+        await fs6.unlink(configPath);
       } else {
-        await fs5.writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
+        await fs6.writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
       }
     }
     return true;
@@ -41132,11 +41349,11 @@ async function getHookStatus(projectRoot) {
     let installed = false;
     let usedPath = projectPath;
     try {
-      await fs5.access(projectPath);
+      await fs6.access(projectPath);
       installed = true;
     } catch {
       try {
-        await fs5.access(globalPath);
+        await fs6.access(globalPath);
         installed = true;
         usedPath = globalPath;
       } catch {
@@ -41212,18 +41429,7 @@ function coerceObjectArray(val) {
   return [];
 }
 async function createMemorixServer(cwd, existingServer) {
-  const project = detectProject(cwd);
-  if (project.id === "__invalid__") {
-    const resolvedCwd = cwd ?? process.cwd();
-    console.error(`[memorix] ERROR: Could not detect a valid project at: ${resolvedCwd}`);
-    console.error(`[memorix] The directory is not a git repository and has no project indicator files.`);
-    console.error(`[memorix] Fix: set --cwd to your project directory, or set MEMORIX_PROJECT_ROOT env var.`);
-    console.error(`[memorix] Example: memorix serve --cwd /path/to/your/project`);
-    console.error(`[memorix] Example: "env": { "MEMORIX_PROJECT_ROOT": "/path/to/your/project" }`);
-    throw new Error(
-      `Cannot start Memorix: no valid project detected at "${resolvedCwd}". Set --cwd or MEMORIX_PROJECT_ROOT to your project directory.`
-    );
-  }
+  const rawProject = detectProject(cwd);
   try {
     const { migrateSubdirsToFlat: migrateSubdirsToFlat2 } = await Promise.resolve().then(() => (init_persistence(), persistence_exports));
     const migrated = await migrateSubdirsToFlat2();
@@ -41232,10 +41438,44 @@ async function createMemorixServer(cwd, existingServer) {
     }
   } catch {
   }
-  const projectDir2 = await getProjectDataDir(project.id);
+  const projectDir2 = await getProjectDataDir(rawProject.id);
+  initAliasRegistry(projectDir2);
+  const canonicalId = await registerAlias(rawProject);
+  const project = { ...rawProject, id: canonicalId };
+  if (canonicalId !== rawProject.id) {
+    console.error(`[memorix] Alias resolved: ${rawProject.id} \u2192 ${canonicalId}`);
+  }
   const graphManager = new KnowledgeGraphManager(projectDir2);
   await graphManager.init();
   await initObservations(projectDir2);
+  try {
+    const { getAllObservations: getAllObservations2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
+    const allObs = getAllObservations2();
+    const observedIds = [...new Set(allObs.map((o3) => o3.projectId))];
+    const merged = await autoMergeByBaseName(observedIds);
+    if (merged > 0) {
+      console.error(`[memorix] Auto-merged ${merged} alias group(s) by base name`);
+    }
+  } catch {
+  }
+  try {
+    const { getAllAliasGroups: getAllAliasGroups2 } = await Promise.resolve().then(() => (init_aliases(), aliases_exports));
+    const groups = await getAllAliasGroups2();
+    let totalMigrated = 0;
+    for (const group of groups) {
+      if (group.aliases.length > 1) {
+        const migrated = await migrateProjectIds(group.aliases, group.canonical);
+        if (migrated > 0) {
+          console.error(`[memorix] Migrated ${migrated} observations \u2192 ${group.canonical}`);
+          totalMigrated += migrated;
+        }
+      }
+    }
+    if (totalMigrated > 0) {
+      console.error(`[memorix] Total migrated: ${totalMigrated} observations across ${groups.filter((g3) => g3.aliases.length > 1).length} project(s)`);
+    }
+  } catch {
+  }
   const reindexed = await reindexObservations();
   if (reindexed > 0) {
     console.error(`[memorix] Reindexed ${reindexed} observations for project: ${project.id}`);
@@ -41947,9 +42187,9 @@ ${skill.content}` }]
         lines.push(`- **Description**: ${sk.description}`);
         lines.push(`- **Observations**: ${sk.content.split("\n").length} lines of knowledge`);
         if (write && target) {
-          const path9 = engine.writeSkill(sk, target);
-          if (path9) {
-            lines.push(`- \u2705 **Written**: \`${path9}\``);
+          const path10 = engine.writeSkill(sk, target);
+          if (path10) {
+            lines.push(`- \u2705 **Written**: \`${path10}\``);
           } else {
             lines.push(`- \u274C Failed to write`);
           }
@@ -42398,6 +42638,7 @@ var init_server4 = __esm({
     init_entity_extractor();
     init_engine();
     init_detector();
+    init_aliases();
     init_persistence();
     init_syncer();
     init_engine2();
@@ -42456,7 +42697,8 @@ var init_serve = __esm({
         const looksValid = existsSync5(join13(projectRoot, ".git")) || existsSync5(join13(projectRoot, "package.json")) || existsSync5(join13(projectRoot, "Cargo.toml")) || existsSync5(join13(projectRoot, "go.mod")) || existsSync5(join13(projectRoot, "pyproject.toml"));
         if (!looksValid) {
           const earlyDetect = detectProject2(projectRoot);
-          if (earlyDetect.id !== "__invalid__") {
+          const isDegraded = earlyDetect.id.startsWith("placeholder/");
+          if (!isDegraded) {
             console.error(`[memorix] detectProject succeeded without standard indicators`);
             const { server, projectId, deferredInit } = await createMemorixServer2(projectRoot);
             const transport = new StdioServerTransport2();
@@ -42475,7 +42717,6 @@ var init_serve = __esm({
             }));
             const transport = new StdioServerTransport2();
             await mcpServer.connect(transport);
-            let rootResolved = false;
             try {
               const rootsResult = await Promise.race([
                 mcpServer.server.listRoots(),
@@ -42488,20 +42729,11 @@ var init_serve = __esm({
                   const normalizedPath = process.platform === "win32" && urlPath.match(/^\/[A-Za-z]:/) ? urlPath.slice(1) : urlPath;
                   console.error(`[memorix] MCP client root: ${normalizedPath}`);
                   projectRoot = normalizedPath;
-                  rootResolved = true;
                 }
               }
             } catch {
               console.error(`[memorix] MCP roots not available (client may not support it)`);
             }
-            if (!rootResolved) {
-              const retryDetect = detectProject2(projectRoot);
-              if (retryDetect.id === "__invalid__") {
-                console.error(`[memorix] ERROR: Could not detect a valid project.`);
-                console.error(`[memorix] Fix: set --cwd or MEMORIX_PROJECT_ROOT, or use an IDE that supports MCP roots.`);
-                process.exit(1);
-              }
-            }
             const { projectId, deferredInit } = await createMemorixServer2(projectRoot, mcpServer);
             console.error(`[memorix] MCP Server running on stdio (project: ${projectId})`);
             console.error(`[memorix] Project root: ${projectRoot}`);
@@ -43367,8 +43599,8 @@ var init_sync = __esm({
       run: async ({ args }) => {
         const { detectProject: detectProject2 } = await Promise.resolve().then(() => (init_detector(), detector_exports));
         const { RulesSyncer: RulesSyncer2 } = await Promise.resolve().then(() => (init_syncer(), syncer_exports));
-        const { promises: fs6 } = await import("fs");
-        const path9 = await import("path");
+        const { promises: fs7 } = await import("fs");
+        const path10 = await import("path");
         we("memorix sync");
         const project = detectProject2();
         v4.info(`Project: ${project.name} (${project.id})`);
@@ -43436,9 +43668,9 @@ var init_sync = __esm({
           process.exit(0);
         }
         for (const file of files) {
-          const fullPath = path9.join(project.rootPath, file.filePath);
-          await fs6.mkdir(path9.dirname(fullPath), { recursive: true });
-          await fs6.writeFile(fullPath, file.content, "utf-8");
+          const fullPath = path10.join(project.rootPath, file.filePath);
+          await fs7.mkdir(path10.dirname(fullPath), { recursive: true });
+          await fs7.writeFile(fullPath, file.content, "utf-8");
           v4.success(`Written: ${file.filePath}`);
         }
         fe2(`Synced ${files.length} rule(s) to ${target} format`);
@@ -44259,12 +44491,12 @@ var init_hooks_install = __esm({
       },
       run: async ({ args }) => {
         const { detectInstalledAgents: detectInstalledAgents2, installHooks: installHooks2 } = await Promise.resolve().then(() => (init_installers(), installers_exports));
-        const os4 = await import("os");
+        const os5 = await import("os");
         let cwd;
         try {
           cwd = process.cwd();
         } catch {
-          cwd = os4.homedir();
+          cwd = os5.homedir();
           console.log(`\u26A0\uFE0F Could not access current directory, using home: ${cwd}`);
         }
         let agents;
@@ -44327,12 +44559,12 @@ var init_hooks_uninstall = __esm({
       },
       run: async ({ args }) => {
         const { detectInstalledAgents: detectInstalledAgents2, uninstallHooks: uninstallHooks2 } = await Promise.resolve().then(() => (init_installers(), installers_exports));
-        const os4 = await import("os");
+        const os5 = await import("os");
         let cwd;
         try {
           cwd = process.cwd();
         } catch {
-          cwd = os4.homedir();
+          cwd = os5.homedir();
         }
         let agents;
         if (args.agent) {
@@ -44375,12 +44607,12 @@ var init_hooks_status = __esm({
       },
       run: async () => {
         const { getHookStatus: getHookStatus2 } = await Promise.resolve().then(() => (init_installers(), installers_exports));
-        const os4 = await import("os");
+        const os5 = await import("os");
         let cwd;
         try {
           cwd = process.cwd();
         } catch {
-          cwd = os4.homedir();
+          cwd = os5.homedir();
         }
         const statuses = await getHookStatus2(cwd);
         console.log("\nMemorix Hooks Status");
@@ -44429,7 +44661,7 @@ __export(dashboard_exports, {
   default: () => dashboard_default
 });
 import { fileURLToPath as fileURLToPath2 } from "url";
-import path8 from "path";
+import path9 from "path";
 var dashboard_default;
 var init_dashboard = __esm({
   "src/cli/commands/dashboard.ts"() {
@@ -44455,8 +44687,8 @@ var init_dashboard = __esm({
         const project = detectProject2();
         const dataDir = await getProjectDataDir2(project.id);
         const port = parseInt(args.port, 10) || 3210;
-        const cliDir = path8.dirname(fileURLToPath2(import.meta.url));
-        const staticDir = path8.join(cliDir, "..", "dashboard", "static");
+        const cliDir = path9.dirname(fileURLToPath2(import.meta.url));
+        const staticDir = path9.join(cliDir, "..", "dashboard", "static");
         await startDashboard2(dataDir, port, staticDir, project.id, project.name);
         await new Promise(() => {
         });
@@ -44509,9 +44741,9 @@ var init_cleanup = __esm({
       },
       async run({ args }) {
         const project = detectProject();
-        if (project.id === "__invalid__") {
-          console.error("\u274C Not in a valid project directory.");
-          process.exit(1);
+        if (project.id.startsWith("placeholder/")) {
+          console.error("\u26A0\uFE0F Not in a valid project directory \u2014 using degraded mode.");
+          console.error("Set MEMORIX_PROJECT_ROOT or --cwd for best results.");
         }
         console.log(`
 \u{1F4E6} Project: ${project.name} (${project.id})