@ai-matrx/agents 0.9.0 → 0.9.2

package/CHANGELOG.md

@@ -1,10 +1,205 @@
 # Changelog
 
+## 0.9.2 — 2026-09-09
+
+**THE ARCHIVED-ITEMS LAW, APPLIED TO THE PICKER — the first instance of a
+platform-wide class.**
+
+Arman, 2026-09-09, asked whether the Public tab should hide archived agents
+like its other tabs (`common-docs/policies/archived-items.md`):
+
+> "Archived agents should be treated like all other archived items everywhere
+> within our codebase. … why does agents have to be any different than
+> workflows or employees or HR documents or anything else that we have?
+> They're not any different. They are the same, and they should be treated the
+> same. … everything should have an archive filter, and the default should
+> always hide archived, but seeing archived items should be one or two clicks
+> away. But don't go and do this for agents and forget that this is a system
+> wide decision for every single item everywhere in our system."
+
+### Consumer action: none
+
+No export was removed, renamed or re-signed. Additive only:
+`ARCHIVE_FILTER_OPTIONS`, `ARCHIVE_FILTER_ORDER`, `nextArchFilter`,
+`isAgentArchFilter`, `AgentArchFilterOption`, `AgentCatalogDefaults`,
+`agentArchiveFilterChipLabel` / `…StateLabel` / `…ControlLabel`,
+`agentListFooterLabel`, `AgentCatalog.consumerDefaults`,
+`useAgentListCore({ initialArchFilter })` and its `archivedHiddenCount` /
+`footerLabel` returns, plus `data-testid="agent-archive-filter"` /
+`"agent-list-footer"` (and their native `testID` twins). Every host adopts this
+by taking `latest`.
+
+### Behavioural deltas (all deliberate, the first was the defect)
+
+**THE BUILTIN ARCHIVE EXEMPTION IS DELETED.** `filterBuiltinTypeAgents` applied
+no archive filter, on the theory that "a builtin belongs to the platform and is
+never the user's to archive". The database disagreed: `Foundry Planner`
+(`001b22f6-fa4d-40c6-a1a4-8575d4d04379`) is an archived builtin, and it
+rendered at Public index 216, sat inside the "413 agents" badge and footer, and
+was pickable — while Mine / Shared / All hid their archived rows. One picker,
+two rules. `selectAgentTabCounts(...).system` and
+`selectTotalBuiltinAgentsCount` now count under the same rule the tab renders
+under, so badge == footer == rows holds on Public too.
+
+**THE ARCHIVE FILTER IS NOW A VISIBLE CONTROL, on web and native.** One chip on
+the filter bar with the platform's three states — *hide archived* (default) →
+*show all* → *archived only* → back — one click from opening the picker, on
+every tab, and present even for a consumer whose `visibleTabs` removes the tab
+strip. Its accessible name always says the state it is in and the state one
+click moves it to. It counts toward `activeFilterCount`, so a list showing
+archived rows offers the reset control that puts them away.
+
+**THE FOOTER IS HONEST ABOUT WHAT IT IS HIDING.** `agentListFooterLabel` prints
+`"412 agents · 4 archived hidden"`, `"416 agents · archived shown"` or
+`"3 archived shown"` — never a bare count that implies the list is everything.
+
+**THE DEFAULT IS A KNOB** (root law 6; law clause 6):
+`createAgentCatalog({ defaults: { archiveFilter } })` catalog-wide, platform
+default `"active"`, with a per-consumer override
+(`useAgentListCore({ initialArchFilter })`). An illegal value throws
+`AgentCatalogConfigError` rather than being silently ignored. `resetFilters`
+returns to the KNOB's value, not to the hardcoded platform one.
+
+### Proof, and how it can fail
+
+`catalog/__tests__/archive-law.test.ts` asserts, per archive state × per tab,
+that the rendered rows are exactly what the law says, that the badge and the
+footer are that same number, that the default hides archived rows on EVERY tab
+(Public included), that one action reveals them, and that the knob works and
+screams. The expectation is restated from the policy text and imports nothing
+from `catalog/selectors.ts`. Both shells (`catalog/react/archive-law.test.tsx`,
+`catalog/native/__tests__/archive-law.test.tsx`) measure the RENDERED screen.
+
+Falsifiability: reinstating the deleted exemption in `filterBuiltinTypeAgents`
+was verified to turn 6 of the 11 kernel tests red before shipping, and the old
+rule is written out in the suite so its answers are asserted to differ.
+`total-order-fixture.json` now carries an archived builtin, generated from the
+rule by `scripts/generate-total-order-fixture.mjs`.
+`parity-expected.json` is left byte-identical — it is a RECORDING of
+matrx-frontend, whose exemption is the defect — and the law is applied to that
+recording in exactly one place, with a test proving the transform changes 30
+cases and drops only builtin ids.
+
+## 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`.**
 
-Matrx Mobile (Expo 54 / RN 0.81) was the last client still hand-rolling its
+> 🚨 **Correction, 2026-09-09 (Arman): this entry has NO CONSUMER.** The `matrx-mobile` repo
+> this release was built against is retired junk and is not a consumer of anything; there is no
+> current mobile package, and the new one has not been started. `./catalog/native` remains
+> published and gate-verified, but nothing ships on it. See common-docs
+> `projects/npm-package-extraction/DECISIONS.md` C32 / `systems/mandates/DECISIONS.md` D24. The
+> release notes below are preserved as written; the repo work they describe is void.
+
+The retired `matrx-mobile` app (Expo 54 / RN 0.81) was the last thing still hand-rolling its
 agent list. Its sheet showed four HARDCODED agents plus a Supabase read of a
 `prompts` table that **does not exist in the platform database** — a read whose
 PostgREST error was swallowed into an empty array, so the list silently never

package/dist/catalog/index.cjs

@@ -25,6 +25,8 @@ __export(catalog_exports, {
   AGENT_LIST_ITEMS_PER_PAGE: () => AGENT_LIST_ITEMS_PER_PAGE,
   AGENT_NONE_SENTINEL: () => AGENT_NONE_SENTINEL,
   AGENT_SEARCH_LIMIT: () => AGENT_SEARCH_LIMIT,
+  ARCHIVE_FILTER_OPTIONS: () => ARCHIVE_FILTER_OPTIONS,
+  ARCHIVE_FILTER_ORDER: () => ARCHIVE_FILTER_ORDER,
   AgentCatalogConfigError: () => AgentCatalogConfigError,
   AgentCatalogReadError: () => AgentCatalogReadError,
   DEFAULT_AGENT_CATALOG_LABELS: () => DEFAULT_AGENT_CATALOG_LABELS,
@@ -32,12 +34,18 @@ __export(catalog_exports, {
   MandateDefaultRowError: () => MandateDefaultRowError,
   SORT_OPTIONS: () => SORT_OPTIONS,
   _resetCatalogGlobalState: () => _resetCatalogGlobalState,
+  agentArchiveFilterChipLabel: () => agentArchiveFilterChipLabel,
+  agentArchiveFilterControlLabel: () => agentArchiveFilterControlLabel,
+  agentArchiveFilterStateLabel: () => agentArchiveFilterStateLabel,
   agentConsumerHasActiveFilters: () => agentConsumerHasActiveFilters,
   agentListEmptyLabel: () => agentListEmptyLabel,
+  agentListFooterLabel: () => agentListFooterLabel,
+  agentMatchesArchiveFilter: () => agentMatchesArchiveFilter,
   agentMatchesSearch: () => agentMatchesSearch,
   applyAgentSortComparator: () => applyAgentSortComparator,
   asAgentId: () => asAgentId,
   assertAgentCatalogSchema: () => assertAgentCatalogSchema,
+  compareAgentIds: () => compareAgentIds,
   computeAgentSearchScore: () => computeAgentSearchScore,
   createAgentCatalog: () => createAgentCatalog,
   createMemoryStorage: () => createMemoryStorage,
@@ -47,6 +55,7 @@ __export(catalog_exports, {
   filterBuiltinTypeAgents: () => filterBuiltinTypeAgents,
   filterUserTypeAgents: () => filterUserTypeAgents,
   getRegisteredAgentCatalog: () => getRegisteredAgentCatalog,
+  isAgentArchFilter: () => isAgentArchFilter,
   isMandateAgentId: () => isMandateAgentId,
   makeSelectFilteredAgents: () => makeSelectFilteredAgents,
   makeSelectFilteredAgentsCount: () => makeSelectFilteredAgentsCount,
@@ -62,6 +71,7 @@ __export(catalog_exports, {
   memoize1: () => memoize1,
   memoize2: () => memoize2,
   memoize3: () => memoize3,
+  nextArchFilter: () => nextArchFilter,
   orchestraDelegatesLine: () => orchestraDelegatesLine,
   orchestraDepthLine: () => orchestraDepthLine,
   orchestraLabel: () => orchestraLabel,
@@ -73,6 +83,7 @@ __export(catalog_exports, {
   readSingleAgentRow: () => readSingleAgentRow,
   resolveDefaultRow: () => resolveDefaultRow,
   searchAgentsOnServer: () => searchAgentsOnServer,
+  selectAgentTabCounts: () => selectAgentTabCounts,
   selectAllAgentCategories: () => selectAllAgentCategories,
   selectAllAgentTags: () => selectAllAgentTags,
   selectAllSystemAgentCategories: () => selectAllSystemAgentCategories,
@@ -110,6 +121,24 @@ var SORT_OPTIONS = [
   { value: "name-desc", label: "Z \u2192 A" },
   { value: "category-asc", label: "Category" }
 ];
+var ARCHIVE_FILTER_ORDER = [
+  "active",
+  "both",
+  "archived"
+];
+var ARCHIVE_FILTER_OPTIONS = [
+  { value: "active", label: "Hide archived", chip: "Archive" },
+  { value: "both", label: "Show all", chip: "All + archived" },
+  { value: "archived", label: "Archived only", chip: "Archived only" }
+];
+function nextArchFilter(current) {
+  const index = ARCHIVE_FILTER_ORDER.indexOf(current);
+  if (index < 0) return ARCHIVE_FILTER_ORDER[0];
+  return ARCHIVE_FILTER_ORDER[(index + 1) % ARCHIVE_FILTER_ORDER.length];
+}
+function isAgentArchFilter(value) {
+  return value === "active" || value === "archived" || value === "both";
+}
 var AGENT_NONE_SENTINEL = "__none__";
 var DEFAULT_AGENT_CONSUMER_STATE = {
   tab: "mine",
@@ -314,8 +343,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",
@@ -732,6 +761,18 @@ function createAgentCatalog(config) {
       remedy: "pass `identity: { requireUserId() }` \u2014 never a silent anonymous read"
     });
   }
+  const archiveDefault = config.defaults?.archiveFilter;
+  if (archiveDefault !== void 0 && !isAgentArchFilter(archiveDefault)) {
+    throw new AgentCatalogConfigError({
+      code: "invalid_archive_default",
+      message: `defaults.archiveFilter was ${JSON.stringify(archiveDefault)}, which is not one of the three states of the platform archive filter`,
+      remedy: 'pass "active" (hide archived), "both" (show all) or "archived" (archived only)'
+    });
+  }
+  const consumerDefaults = {
+    ...DEFAULT_AGENT_CONSUMER_STATE,
+    ...archiveDefault ? { archFilter: archiveDefault } : {}
+  };
   const catalogId = config.catalogId ?? "default";
   const client = config.client;
   const identity = config.identity;
@@ -832,7 +873,7 @@ function createAgentCatalog(config) {
     return run;
   }
   function getConsumer(consumerId) {
-    return state.consumers[consumerId] ?? DEFAULT_AGENT_CONSUMER_STATE;
+    return state.consumers[consumerId] ?? consumerDefaults;
   }
   function writeConsumer(consumerId, next) {
     publish({
@@ -843,7 +884,7 @@ function createAgentCatalog(config) {
   function registerConsumer(consumerId, initial) {
     if (state.consumers[consumerId]) return;
     writeConsumer(consumerId, {
-      ...DEFAULT_AGENT_CONSUMER_STATE,
+      ...consumerDefaults,
       ...initial ?? {}
     });
   }
@@ -854,9 +895,7 @@ function createAgentCatalog(config) {
     publish({ ...state, consumers });
   }
   function setConsumerFilter(consumerId, patch) {
-    const current = state.consumers[consumerId] ?? {
-      ...DEFAULT_AGENT_CONSUMER_STATE
-    };
+    const current = state.consumers[consumerId] ?? { ...consumerDefaults };
     writeConsumer(consumerId, {
       ...current,
       ...patch,
@@ -873,9 +912,7 @@ function createAgentCatalog(config) {
     );
   }
   function setConsumerServerSearch(consumerId, args) {
-    const current = state.consumers[consumerId] ?? {
-      ...DEFAULT_AGENT_CONSUMER_STATE
-    };
+    const current = state.consumers[consumerId] ?? { ...consumerDefaults };
     const next = { ...current };
     if (args.matchedIds !== void 0) next.serverMatchedIds = args.matchedIds;
     if (args.isSearching !== void 0) next.isServerSearching = args.isSearching;
@@ -886,14 +923,14 @@ function createAgentCatalog(config) {
   }
   function resetConsumerFilters(consumerId) {
     if (!state.consumers[consumerId]) return;
-    writeConsumer(consumerId, { ...DEFAULT_AGENT_CONSUMER_STATE });
+    writeConsumer(consumerId, { ...consumerDefaults });
   }
   async function searchServer(query, deep = false) {
     const result = await searchAgentsOnServer(client, { query, deep });
     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 +939,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",
@@ -1016,6 +1053,7 @@ function createAgentCatalog(config) {
     errorSink,
     notifier,
     canResolveMandates: transport !== void 0,
+    consumerDefaults,
     getState: () => state,
     subscribe: (listener) => {
       listeners.add(listener);
@@ -1093,6 +1131,26 @@ function shouldDefaultAgentListToPublicTab(args) {
   if (!args.agentsLoaded) return false;
   return args.ownedCount === 0;
 }
+function agentArchiveFilterChipLabel(archFilter) {
+  return ARCHIVE_FILTER_OPTIONS.find((o) => o.value === archFilter)?.chip ?? "Archive";
+}
+function agentArchiveFilterStateLabel(archFilter) {
+  return ARCHIVE_FILTER_OPTIONS.find((o) => o.value === archFilter)?.label ?? "Hide archived";
+}
+function agentArchiveFilterControlLabel(archFilter) {
+  return `Archive filter: ${agentArchiveFilterStateLabel(
+    archFilter
+  ).toLowerCase()}. Click for ${agentArchiveFilterStateLabel(
+    nextArchFilter(archFilter)
+  ).toLowerCase()}`;
+}
+function agentListFooterLabel(args) {
+  const { count, archFilter, archivedHiddenCount } = args;
+  if (archFilter === "archived") return `${count} archived shown`;
+  const base = `${count} agent${count !== 1 ? "s" : ""}`;
+  if (archFilter === "both") return `${base} \xB7 archived shown`;
+  return archivedHiddenCount > 0 ? `${base} \xB7 ${archivedHiddenCount} archived hidden` : base;
+}
 
 // catalog/score.ts
 function computeAgentSearchScore(agent, query) {
@@ -1189,7 +1247,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 ?? "");
@@ -1291,8 +1361,7 @@ function filterUserTypeAgents(agents, consumer) {
     if (tab === "mine" && agent.isOwner !== true) return false;
     if (tab === "shared" && !(agent.isOwner === false && agent.accessLevel != null))
       return false;
-    if (archFilter === "active" && agent.isArchived) return false;
-    if (archFilter === "archived" && !agent.isArchived) return false;
+    if (!agentMatchesArchiveFilter(agent, archFilter)) return false;
     if (favFilter === "yes" && !agent.isFavorite) return false;
     if (favFilter === "no" && agent.isFavorite) return false;
     if (accessFilter === "owned" && agent.isOwner !== true) return false;
@@ -1322,9 +1391,10 @@ function filterUserTypeAgents(agents, consumer) {
   return sortFilteredAgents(filtered, consumer);
 }
 function filterBuiltinTypeAgents(agents, consumer) {
-  const { searchTerm, favFilter, includedCats, includedTags } = consumer;
+  const { searchTerm, favFilter, archFilter, includedCats, includedTags } = consumer;
   const serverMatched = new Set(consumer.serverMatchedIds);
   const filtered = agents.filter((agent) => {
+    if (!agentMatchesArchiveFilter(agent, archFilter)) return false;
     if (favFilter === "yes" && !agent.isFavorite) return false;
     if (favFilter === "no" && agent.isFavorite) return false;
     if (includedCats.length > 0) {
@@ -1437,21 +1507,54 @@ 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 countBuiltinRows(agents, archFilter) {
+  let n = 0;
+  for (const a of agents) {
+    if (a.agentType !== "builtin") continue;
+    if (!agentMatchesArchiveFilter(a, archFilter)) continue;
+    n += 1;
+  }
+  return n;
+}
+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: countBuiltinRows(agents, archFilter)
+  })
+);
 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
+  (agents) => countBuiltinRows(agents, "active")
 );
 var selectTotalFavoriteAgentsCount = memoize1(
-  (agents) => selectUserTypeAgents(agents).filter((a) => a.isFavorite).length
+  (agents) => countUserRows(agents, "active", isFavorite)
 );
 //# sourceMappingURL=index.cjs.map