@indigoai-us/hq-cli 5.194.0 → 5.194.1

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [Unreleased]
 
+## [5.194.1] — 2026-09-25
+
+### Fixed
+
+- `hq core ontology apply` no longer creates a new entity that is probably an
+  existing one. A candidate whose alias is already another entity's name or
+  alias, or a person whose name contains every word of an existing person's
+  full name (for example "Chaudhry Hassaan Saleem" and "Hassaan Saleem"), is
+  held back and reported as a suspect duplicate.
+
 ## [5.194.0] — 2026-09-25
 
 ### Added

package/dist/lib/checkpoint-ontology/apply.d.ts

@@ -108,6 +108,13 @@ type Resolution = {
 };
 /** Design section 5.3, tiers 1 to 4. */
 export declare function resolveCandidate(index: EntityIndex, type: string, canonical: string): Resolution;
+/**
+ * Existing entities of `type` that a new candidate probably is: one of the
+ * candidate's aliases is already their name or alias, or, for people, every
+ * word of their name (two words or more) is in the candidate's name
+ * (`Chaudhry Hassaan Saleem` and `Hassaan Saleem`).
+ */
+export declare function overlappingEntities(index: EntityIndex, type: string, canonical: string, aliases: string[]): string[];
 export declare function applyOntologyRun(options: ApplyOptions): ApplyReport;
 export {};
 //# sourceMappingURL=apply.d.ts.map

package/dist/lib/checkpoint-ontology/apply.js

@@ -81,6 +81,38 @@ export function resolveCandidate(index, type, canonical) {
         return { tier: "type_conflict", types: otherTypes };
     return { tier: "new" };
 }
+/**
+ * Existing entities of `type` that a new candidate probably is: one of the
+ * candidate's aliases is already their name or alias, or, for people, every
+ * word of their name (two words or more) is in the candidate's name
+ * (`Chaudhry Hassaan Saleem` and `Hassaan Saleem`).
+ */
+export function overlappingEntities(index, type, canonical, aliases) {
+    const paths = new Set();
+    for (const alias of aliases) {
+        const normalized = normalizeEntityName(alias, type);
+        // A generic alias still counts when an existing entity already holds it.
+        if (!normalized)
+            continue;
+        for (const rel of index.canonical.get(key(type, normalized)) ?? [])
+            paths.add(rel);
+        for (const rel of index.alias.get(key(type, normalized)) ?? [])
+            paths.add(rel);
+    }
+    if (type === "person") {
+        const words = new Set(normalizeEntityName(canonical, type).split(" "));
+        const prefix = key(type, "");
+        for (const [name, rels] of index.canonical) {
+            if (!name.startsWith(prefix))
+                continue;
+            const other = name.slice(prefix.length).split(" ");
+            if (other.length >= 2 && other.every((word) => words.has(word)))
+                for (const rel of rels)
+                    paths.add(rel);
+        }
+    }
+    return [...paths].sort();
+}
 /**
  * Aliases worth adding to the entity at `self`: new to it, and held by no
  * other entity of any type, so an alias can never make a later match
@@ -301,6 +333,12 @@ export function applyOntologyRun(options) {
             note(report.rejected, "type_conflict");
             continue;
         }
+        const overlap = overlappingEntities(index, candidate.type, canonical, candidate.aliases);
+        if (overlap.length > 0) {
+            note(report.deferred, "suspect_duplicate");
+            report.suspect_duplicates.push({ name: canonical, type: candidate.type, paths: overlap });
+            continue;
+        }
         // Tier 5: create.
         if (candidate.confidence < MIN_CREATE_CONFIDENCE) {
             note(report.rejected, "low_confidence");

package/dist/lib/lanes/reconcile.js

@@ -569,7 +569,7 @@ async function withReconcileLock(hqRoot, fn) {
         }
     }
 }
-function classifyDeadLocalLane(hqRoot, laneId) {
+function classifyDeadLocalLane(hqRoot, laneId, now) {
     const runDir = laneRunDir(hqRoot, laneId);
     const manifest = readSpawnManifest(runDir);
     const minEnvelopeName = manifest.envelope_path ? path.basename(manifest.envelope_path) : undefined;
@@ -586,7 +586,6 @@ function classifyDeadLocalLane(hqRoot, laneId) {
     // the quota signal, any other becomes provider_rejected, and only a stream
     // with no failure object falls back to the quota reader.
     const workerOutOffset = readSpawnManifest(runDir).worker_out_offset ?? 0;
-    const now = new Date();
     const routed = envelope
         ? { quota: null, rejection: null }
         : routeProviderFailure(readProviderRejection(runDir, lane.provider, workerOutOffset), () => readQuotaSignal(runDir, lane.model, now, workerOutOffset), lane.model, now);
@@ -894,7 +893,7 @@ async function heartbeatAndDeadHosts(hqRoot, lanes, summary, deps, now) {
                 continue;
             }
             try {
-                const { classification, latest, quota, providerRejection, lane: classified } = classifyDeadLocalLane(hqRoot, lane.lane_id);
+                const { classification, latest, quota, providerRejection, lane: classified } = classifyDeadLocalLane(hqRoot, lane.lane_id, now);
                 // Match the watcher's one-repair decision before classifying an
                 // unparseable envelope after both processes have died. As in the
                 // watcher, a provider rejection or a quota signal skips the repair.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.194.0",
+  "version": "5.194.1",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {