@ai-matrx/agents 0.9.0 → 0.9.1

package/CHANGELOG.md

@@ -1,5 +1,113 @@
 # Changelog
 
+## 0.9.1 — 2026-09-08
+
+**TWO SCREENS TOLD THE SAME USER TWO DIFFERENT TRUTHS. BOTH ARE FIXED HERE, IN
+THE PACKAGE, AT THE CLASS.**
+
+Independent final verification of the picker unification (2026-09-08, same
+account signed in on both surfaces) found the tab strip, the counts, the
+Mine/Shared/All order, the five sort options, the tri-state favourites control,
+the 42 categories, the 871 tags and four tag-only searches identical between
+`aimatrx.com/chat/new` and `workflows.aimatrx.com`. Two things were not.
+
+### Consumer action: none
+
+No export was removed, renamed or re-signed. Three symbols were ADDED —
+`compareAgentIds`, `agentMatchesArchiveFilter`, `selectAgentTabCounts` — and the
+web `AgentRow` gained a `data-testid` matching the native row's `testID`.
+Every host adopts this by taking `latest`; there is nothing to change.
+
+### Behavioural deltas (both deliberate, both were defects)
+
+**F1 — every sort is now a TOTAL order, ending on `id` ASC.**
+
+The Public tab diverged at index 10. 17 rows tied on
+`updated_at = 2026-09-08T06:52:46.430326+00:00`, and the two hosts fetch the
+same RPC through different transports:
+
+| host | request | order of tied rows |
+|---|---|---|
+| matrx-frontend | `POST /rpc/agx_get_list_full` (one shot) | the RPC's own |
+| workflow-studio | `…?order=id.asc&offset=0&limit=1000` (`readAllRows`) | id ASC |
+
+Neither client was wrong about the ROWS. The sort was not total: each
+comparator branch returned `0` for tied rows, so `Array.prototype.sort` left
+them wherever the transport had put them. `sortFilteredAgents` and
+`applyAgentSortComparator` now end on the same final key the database itself
+ends on — `public.agx_get_list` is
+`ORDER BY is_favorite DESC, updated_at DESC, id` — giving:
+
+    searching:     score DESC -> server rank ASC -> sort key -> id ASC
+    not searching: favourites first (when asked) -> sort key -> id ASC
+
+Comparison is a codepoint `<`/`>`, never `localeCompare`: Postgres orders
+`uuid` by its raw bytes and a collator is free to fold case or ignore the
+dashes, which would diverge from the server on exactly these ties. A sort key
+that yields `NaN` (an unparseable timestamp) now collapses to the id key
+instead of defeating it.
+
+*What the frontend used to do on ties: whatever order the RPC page came back
+in.* That was never a decision — it was the absence of one, and it happened to
+look stable only until a second host fetched the same rows a different way. The
+order is now DEFINED, is the server's own, and is a function of the rows alone.
+
+**F5 — a tab badge counts exactly what the tab renders.**
+
+The Mine badge said 416 while the list rendered 412 rows and the footer said
+"412 agents": 4 owned and 2 shared ARCHIVED agents were counted by the badge
+and (correctly) hidden by the list. One screen, three numbers, one of them
+untrue about agents the user cannot see or reach from there. This is "a screen
+never lies", so it is a fix and not a knob.
+
+`selectAgentTabCounts(rows, archFilter)` is the new consumer-aware badge
+source used by `useAgentListCore`, and the four plain aggregate counts
+(`selectTotalUserAgentsCount`, `…Owned…`, `…Shared…`, `…Favorite…`) now honour
+the same archive rule the list uses. Flip the archive filter and the badges
+follow the list into the archive. `selectTotalBuiltinAgentsCount` is
+deliberately unchanged: `filterBuiltinTypeAgents` applies no archive filter
+(a builtin belongs to the platform and is never the user's to archive), so it
+already counted exactly what it rendered.
+
+### The proof
+
+`catalog/__tests__/parity.test.ts`'s 66-row fixture had NO ties, which is why
+293 green cases never saw F1. The new fixture does:
+`catalog/__tests__/total-order-fixture.json` — 42 rows, every one on that exact
+live `updated_at`, 26 of them also tied on `created_at`, with name and category
+tie groups on top, ids deliberately uncorrelated with emission order.
+
+`total-order-expected.json` is generated **from the RULE** by
+`scripts/generate-total-order-fixture.mjs` — favourites -> key -> id ASC,
+written out independently and importing nothing from `catalog/selectors.ts`.
+Regenerating it by running the shipped comparator would have made the test a
+mirror of the code; it measures the specification instead.
+
+720 cases (tab x sort x favouritesFirst x archive x favourite x access) are
+asserted three times over — kernel (`catalog/__tests__/total-order.test.ts`),
+web shell (`catalog/react/total-order.test.tsx`) and native shell
+(`catalog/native/__tests__/total-order.test.tsx`) — each reading the RENDERED
+row ids, not the selector's return value.
+
+Falsifiability, on every leg:
+
+- the same rows are fed in four different input orders (identity, two seeded
+  shuffles, reversed) and the answer must be byte-identical — this is the live
+  defect, reproduced as a test;
+- both shells mount the picker twice with the row array reversed and compare
+  screen to screen;
+- deleting the id tiebreaker turns 4 of the 10 kernel tests red (verified
+  before shipping), and a key-only sort of the same fixture is asserted to
+  disagree with itself under reversal;
+- the F5 legs assert the OLD counting rule produces a DIFFERENT number on this
+  fixture, so "badge == rows" cannot pass vacuously.
+
+`parity.test.ts`'s count assertion now states the F5 delta explicitly — the
+recorded matrx-frontend number minus the archived rows the list hides — rather
+than reproducing a screen that lies. Its 293-case ordering matrix and the
+native shell's 293-case matrix are UNCHANGED and still green: the old fixture
+had no ties, so F1 moved nothing that was already defined.
+
 ## 0.9.0 — 2026-09-08
 
 **THE ONE PICKER NOW RENDERS ON REACT NATIVE — `@ai-matrx/agents/catalog/native`.**

package/dist/catalog/index.cjs

@@ -34,10 +34,12 @@ __export(catalog_exports, {
   _resetCatalogGlobalState: () => _resetCatalogGlobalState,
   agentConsumerHasActiveFilters: () => agentConsumerHasActiveFilters,
   agentListEmptyLabel: () => agentListEmptyLabel,
+  agentMatchesArchiveFilter: () => agentMatchesArchiveFilter,
   agentMatchesSearch: () => agentMatchesSearch,
   applyAgentSortComparator: () => applyAgentSortComparator,
   asAgentId: () => asAgentId,
   assertAgentCatalogSchema: () => assertAgentCatalogSchema,
+  compareAgentIds: () => compareAgentIds,
   computeAgentSearchScore: () => computeAgentSearchScore,
   createAgentCatalog: () => createAgentCatalog,
   createMemoryStorage: () => createMemoryStorage,
@@ -73,6 +75,7 @@ __export(catalog_exports, {
   readSingleAgentRow: () => readSingleAgentRow,
   resolveDefaultRow: () => resolveDefaultRow,
   searchAgentsOnServer: () => searchAgentsOnServer,
+  selectAgentTabCounts: () => selectAgentTabCounts,
   selectAllAgentCategories: () => selectAllAgentCategories,
   selectAllAgentTags: () => selectAllAgentTags,
   selectAllSystemAgentCategories: () => selectAllSystemAgentCategories,
@@ -314,8 +317,8 @@ async function readSingleAgentRow(client, agentId) {
   }
   return null;
 }
-async function writeAgentFavorite(client, agentId, isFavorite) {
-  const { error } = await client.schema("agent").from("definition").update({ is_favorite: isFavorite }).eq("id", agentId);
+async function writeAgentFavorite(client, agentId, isFavorite2) {
+  const { error } = await client.schema("agent").from("definition").update({ is_favorite: isFavorite2 }).eq("id", agentId);
   if (error) {
     throw new AgentCatalogReadError(
       "agent.definition.is_favorite",
@@ -893,7 +896,7 @@ function createAgentCatalog(config) {
     mergeRows(result.rows);
     return result.ids;
   }
-  async function setFavorite(agentId, isFavorite) {
+  async function setFavorite(agentId, isFavorite2) {
     const existing = state.byId[agentId];
     if (!existing) {
       errorSink({
@@ -902,15 +905,15 @@ function createAgentCatalog(config) {
       });
       return;
     }
-    mergeRows([{ ...existing, isFavorite }]);
+    mergeRows([{ ...existing, isFavorite: isFavorite2 }]);
     try {
-      await writeAgentFavorite(client, agentId, isFavorite);
+      await writeAgentFavorite(client, agentId, isFavorite2);
     } catch (e) {
       mergeRows([existing]);
       errorSink({
         code: "favorite_write_failed",
         message: `the favorite could not be saved: ${errorMessage(e)}`,
-        context: { agentId, isFavorite }
+        context: { agentId, isFavorite: isFavorite2 }
       });
       notifier?.({
         level: "error",
@@ -1189,7 +1192,19 @@ function memoize3(fn) {
     return last;
   };
 }
+function compareAgentIds(a, b) {
+  const idA = a.id ?? "";
+  const idB = b.id ?? "";
+  if (idA < idB) return -1;
+  if (idA > idB) return 1;
+  return 0;
+}
 function applyAgentSortComparator(a, b, sortBy) {
+  const primary = compareAgentSortKey(a, b, sortBy);
+  if (!Number.isFinite(primary) || primary === 0) return compareAgentIds(a, b);
+  return primary;
+}
+function compareAgentSortKey(a, b, sortBy) {
   switch (sortBy) {
     case "name-asc":
       return (a.name ?? "").localeCompare(b.name ?? "");
@@ -1437,21 +1452,45 @@ var makeSelectFilteredBuiltinAgentsCount = () => {
 function agentConsumerHasActiveFilters(consumer, defaults) {
   return consumer.tab !== defaults.tab || consumer.sortBy !== defaults.sortBy || consumer.searchTerm !== "" || consumer.includedCats.length > 0 || consumer.includedTags.length > 0 || consumer.favFilter !== defaults.favFilter || consumer.archFilter !== defaults.archFilter || consumer.accessFilter !== defaults.accessFilter || consumer.favoritesFirst !== defaults.favoritesFirst;
 }
+function agentMatchesArchiveFilter(agent, archFilter) {
+  if (archFilter === "active") return !agent.isArchived;
+  if (archFilter === "archived") return Boolean(agent.isArchived);
+  return true;
+}
+function countUserRows(agents, archFilter, predicate) {
+  let n = 0;
+  for (const a of agents) {
+    if (a.agentType !== "user") continue;
+    if (!agentMatchesArchiveFilter(a, archFilter)) continue;
+    if (predicate(a)) n += 1;
+  }
+  return n;
+}
+var isOwned = (a) => a.isOwner === true;
+var isShared = (a) => a.isOwner === false && a.accessLevel != null;
+var isAny = () => true;
+var isFavorite = (a) => Boolean(a.isFavorite);
+var selectAgentTabCounts = memoize2(
+  (agents, archFilter) => ({
+    mine: countUserRows(agents, archFilter, isOwned),
+    shared: countUserRows(agents, archFilter, isShared),
+    all: countUserRows(agents, archFilter, isAny),
+    system: selectBuiltinTypeAgents(agents).length
+  })
+);
 var selectTotalUserAgentsCount = memoize1(
-  (agents) => selectUserTypeAgents(agents).length
+  (agents) => countUserRows(agents, "active", isAny)
 );
 var selectTotalOwnedAgentsCount = memoize1(
-  (agents) => selectUserTypeAgents(agents).filter((a) => a.isOwner === true).length
+  (agents) => countUserRows(agents, "active", isOwned)
 );
 var selectTotalSharedAgentsCount = memoize1(
-  (agents) => selectUserTypeAgents(agents).filter(
-    (a) => a.isOwner === false && a.accessLevel != null
-  ).length
+  (agents) => countUserRows(agents, "active", isShared)
 );
 var selectTotalBuiltinAgentsCount = memoize1(
   (agents) => selectBuiltinTypeAgents(agents).length
 );
 var selectTotalFavoriteAgentsCount = memoize1(
-  (agents) => selectUserTypeAgents(agents).filter((a) => a.isFavorite).length
+  (agents) => countUserRows(agents, "active", isFavorite)
 );
 //# sourceMappingURL=index.cjs.map