akm-cli 0.9.15 → 0.9.16-alpha.1

package/dist/indexer/lookup/adapter-concept-owner.js

@@ -96,7 +96,7 @@ function inspectCandidate(sourcePath, realRoot, adapterId, candidate) {
     catch {
         return undefined;
     }
-    return { path: authoredPath, realPath, conceptId: candidate.conceptId, adapterId };
+    return { path: authoredPath, realPath, conceptId: candidate.conceptId, adapterId, priority: candidate.priority };
 }
 function claimsWithoutContent(adapter, component, owner) {
     const file = buildFileContext(component.root, owner.path);
@@ -186,16 +186,30 @@ export function resolveAdapterConceptOwner(sourcePath, adapterId, conceptId, opt
         if (claimsWithoutContent(adapter, component, candidate))
             ownersByIdentity.set(identity, candidate);
     }
+    // Rank ascending by declared priority first (undefined — no declared rank —
+    // compares as 0, so candidates that never opted in keep tying with each
+    // other exactly as before this field existed), then by path within a rank
+    // for deterministic tie-break output.
     const owners = [...ownersByIdentity.values()]
         .filter((owner) => owner.conceptId === resolutionConceptId)
-        .sort((left, right) => compareCodePoints(left.path, right.path));
+        .sort((left, right) => (left.priority ?? 0) - (right.priority ?? 0) || compareCodePoints(left.path, right.path));
     if (owners.length > 1) {
+        // Only owners tied on the BEST (lowest) priority present are competing —
+        // a lower-priority owner is shadowed by a higher-priority one that
+        // exists, per the adapter's own declared candidate order (#882), not a
+        // collision with it. Only a genuine tie at that best priority — e.g. the
+        // memory `.md`/`.derived.md` pair resolves here with no throw, while
+        // case-only filesystem siblings (same declared rank) still collide.
+        const bestPriority = owners[0].priority ?? 0;
+        const tied = owners.filter((owner) => (owner.priority ?? 0) === bestPriority);
+        if (tied.length === 1)
+            return tied[0];
         if (options?.mode !== "read") {
-            throw new AdapterConceptCollisionError(adapterId, resolutionConceptId, owners.map((owner) => path.relative(sourcePath, owner.path).replaceAll("\\", "/")));
+            throw new AdapterConceptCollisionError(adapterId, resolutionConceptId, tied.map((owner) => path.relative(sourcePath, owner.path).replaceAll("\\", "/")));
         }
-        const [winner, ...losers] = owners;
+        const [winner, ...losers] = tied;
         warnOnce(`adapter-concept-collision:${adapterId}:${resolutionConceptId}`, `Adapter "${adapterId}" has multiple physical owners for "${resolutionConceptId}": ` +
-            `${owners.map((owner) => path.relative(sourcePath, owner.path).replaceAll("\\", "/")).join(", ")}. ` +
+            `${tied.map((owner) => path.relative(sourcePath, owner.path).replaceAll("\\", "/")).join(", ")}. ` +
             `Reading "${path.relative(sourcePath, winner.path).replaceAll("\\", "/")}" and ignoring ` +
             `${losers.map((owner) => path.relative(sourcePath, owner.path).replaceAll("\\", "/")).join(", ")}.`);
         return winner;

package/dist/indexer/passes/metadata.js

@@ -1349,7 +1349,24 @@ export function applyPostContributorFields(entry, file, canonicalName, dirPath)
     // filename word. `normalizeTerms` below dedupes author-restated tokens.
     entry.tags = [...(entry.tags ?? []), ...extractDirTagsFromName(canonicalName)];
     entry.tags = normalizeTerms(entry.tags ?? []);
-    entry.aliases = mergeAliases(entry.aliases, buildAliases(canonicalName, entry.tags));
+    // fix-ranking-derived-outranks-primary: `.derived` is a structural marker
+    // on a memory's OWN filename (memory-inference.ts's `derivedChildPath`/
+    // `isDerivedByName` convention: `<parent>.derived.md`), not a topical
+    // word — `extractTagsFromPath` above tokenizes on `.` alongside `-`/`_`,
+    // so every derived twin's filename contributes a "derived" tag purely as
+    // an artifact of that convention (kept in `entry.tags` itself; only the
+    // ALIAS input below is filtered, so anything else keyed on the raw tag
+    // set is unaffected). Left in, `buildAliases`' tags.join(" ") mints a
+    // SYNTHETIC "<base> derived" alias purely because tags.length > 1, which
+    // then wins `alias-ranking` credit any time the base name is a query
+    // token — see `exactNameRankingContributor`, which already strips this
+    // exact suffix before treating a derived twin's name as content, for the
+    // identical reason. Scoped to memory so a coincidentally
+    // ".derived"-suffixed asset of another type is untouched.
+    const aliasTagInput = entry.type === "memory" && canonicalName.toLowerCase().endsWith(".derived")
+        ? entry.tags.filter((tag) => tag !== "derived")
+        : entry.tags;
+    entry.aliases = mergeAliases(entry.aliases, buildAliases(canonicalName, aliasTagInput));
     // Search hints are only generated when LLM is configured (via enhanceStashWithLlm)
     // Heuristic search hints are too noisy to be useful for search quality
     entry.filename = path.basename(file);