fix(cli): status uses /memories?count=true instead of /export

src/cli.ts

@@ -41,6 +41,7 @@ import {
 import { renderSplash } from "./cli/splash.js";
 import { isFirstRun, readPrefs, resetPrefs, writePrefs } from "./cli/preferences.js";
 import { runOnboarding } from "./cli/onboarding.js";
+import { countMemories, countSessionObservations } from "./cli/status-metrics.js";
 import { setBootVerbose } from "./logger.js";
 import { VERSION } from "./version.js";
 
@@ -1153,7 +1154,7 @@ async function runStatus() {
       apiFetch<any>(base, "health"),
       apiFetch<any>(base, "sessions"),
       apiFetch<any>(base, "graph/stats"),
-      apiFetch<any>(base, "export"),
+      apiFetch<any>(base, "memories?count=true"),
       apiFetch<any>(base, "config/flags"),
     ]);
 
@@ -1163,15 +1164,18 @@ async function runStatus() {
     const h = healthRes?.health;
     const status = healthRes?.status || "unknown";
     const version = healthRes?.version || "?";
-    const sessions = Array.isArray(sessionsRes?.sessions) ? sessionsRes.sessions.length : 0;
+    const sessionItems = Array.isArray(sessionsRes?.sessions)
+      ? sessionsRes.sessions
+      : [];
+    const sessions = sessionItems.length;
     const nodes = Number(graphRes?.totalNodes ?? graphRes?.nodes ?? graphRes?.nodeCount ?? 0);
     const edges = Number(graphRes?.totalEdges ?? graphRes?.edges ?? graphRes?.edgeCount ?? 0);
     const cb = healthRes?.circuitBreaker?.state || "closed";
     const heapMB = h?.memory ? Math.round(h.memory.heapUsed / 1048576) : 0;
     const uptime = h?.uptimeSeconds ? Math.round(h.uptimeSeconds) : 0;
 
-    const obsCount = memoriesRes?.observations?.length || 0;
-    const memCount = memoriesRes?.memories?.length || 0;
+    const obsCount = countSessionObservations(sessionItems);
+    const memCount = countMemories(memoriesRes);
     const estFullTokens = obsCount * 80;
     const estInjectedTokens = Math.min(obsCount, 50) * 38;
     const tokensSaved = estFullTokens - estInjectedTokens;

src/cli/status-metrics.ts

@@ -0,0 +1,26 @@
+export function countSessionObservations(
+  sessions: Array<{ observationCount?: unknown }> | undefined,
+): number {
+  if (!Array.isArray(sessions)) return 0;
+  return sessions.reduce((sum, session) => {
+    const value = session?.observationCount;
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+      return sum;
+    }
+    return sum + Math.floor(value);
+  }, 0);
+}
+
+export function countMemories(
+  response: { total?: unknown; memories?: unknown } | undefined,
+): number {
+  if (!response || typeof response !== "object") return 0;
+  if (
+    typeof response.total === "number" &&
+    Number.isFinite(response.total) &&
+    response.total >= 0
+  ) {
+    return Math.floor(response.total);
+  }
+  return Array.isArray(response.memories) ? response.memories.length : 0;
+}

test/status-metrics.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from "vitest";
+import {
+  countMemories,
+  countSessionObservations,
+} from "../src/cli/status-metrics.js";
+
+describe("countSessionObservations", () => {
+  it("sums observationCount across sessions", () => {
+    expect(
+      countSessionObservations([
+        { observationCount: 2 },
+        { observationCount: 3 },
+        { observationCount: 0 },
+      ]),
+    ).toBe(5);
+  });
+
+  it("ignores missing and invalid observation counts", () => {
+    expect(
+      countSessionObservations([
+        {},
+        { observationCount: -1 },
+        { observationCount: "4" },
+        { observationCount: Number.NaN },
+        { observationCount: 1.9 },
+      ]),
+    ).toBe(1);
+  });
+});
+
+describe("countMemories", () => {
+  it("prefers the count endpoint total when present", () => {
+    expect(countMemories({ total: 7 })).toBe(7);
+  });
+
+  it("falls back to memories array length", () => {
+    expect(countMemories({ memories: [{}, {}, {}] })).toBe(3);
+  });
+
+  it("returns zero for unknown shapes", () => {
+    expect(countMemories(undefined)).toBe(0);
+    expect(countMemories({ total: -1 })).toBe(0);
+    expect(countMemories({ memories: "nope" })).toBe(0);
+  });
+});