@fuzeelogik/myflo 1.0.0-rc.4

package/lib/mcp-server.js

@@ -0,0 +1,459 @@
+// MCP stdio server exposing flo capabilities as tools.
+// Protocol: https://spec.modelcontextprotocol.io/specification/
+
+import { createInterface } from 'node:readline';
+import { readCheckpoints } from './sessions.js';
+import { readSwarmState, recordVote, tallyVotes, listVotes } from './swarm.js';
+import {
+  storeEntry,
+  listEntries,
+  searchEntries,
+  namespaceStats,
+} from './memory-store.js';
+import { listInboxes } from './inbox-registry.js';
+import { listAllMailboxes } from './messages.js';
+import { transcribe, detectTool } from './transcribe.js';
+import {
+  createTask,
+  updateTask,
+  completeTask,
+  listTasks,
+  taskCounts,
+} from './tasks-store.js';
+import {
+  spawnAgent,
+  listAgents,
+  getAgent,
+  agentHealth,
+} from './agents-store.js';
+
+const PROTOCOL_VERSION = '2024-11-05';
+const SERVER_INFO = { name: 'flo', version: '0.4.0' };
+
+const TOOLS = [
+  {
+    name: 'flo_sessions_list',
+    description: 'List Claude Code session checkpoints from .claude/checkpoints/ in the current project.',
+    inputSchema: {
+      type: 'object',
+      properties: { limit: { type: 'number', description: 'Max results (default: 25)' } },
+    },
+  },
+  {
+    name: 'flo_guidance_audit',
+    description: 'Scan ~/.claude/{skills,commands,agents}/ and project .claude/ for duplicate or undocumented capabilities. Returns markdown report.',
+    inputSchema: {
+      type: 'object',
+      properties: { scope: { type: 'string', enum: ['all', 'user', 'project'] } },
+    },
+  },
+  {
+    name: 'flo_memory_store',
+    description: 'Append an entry to flo memory (~/.flo/memory/<namespace>.jsonl). Returns the new entry with its id.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        value: { type: 'string', description: 'Entry value (required)' },
+        key: { type: 'string', description: 'Optional human-readable key' },
+        namespace: { type: 'string', description: 'Namespace (default: "default")' },
+        tags: { type: 'array', items: { type: 'string' } },
+        metadata: { type: 'object' },
+      },
+      required: ['value'],
+    },
+  },
+  {
+    name: 'flo_memory_search',
+    description: 'Substring + tag search across flo memory namespaces. Returns scored matches.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string' },
+        namespace: { type: 'string' },
+        tags: { type: 'array', items: { type: 'string' } },
+        limit: { type: 'number' },
+      },
+    },
+  },
+  {
+    name: 'flo_memory_list',
+    description: 'List the most recent entries in a flo memory namespace.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        namespace: { type: 'string', description: 'Namespace (default: "default")' },
+        limit: { type: 'number' },
+      },
+    },
+  },
+  {
+    name: 'flo_memory_namespaces',
+    description: 'List all flo memory namespaces with entry counts and last-entry timestamps.',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'flo_inbox_list',
+    description: 'List registered flo inboxes from ~/.flo/inboxes.json with pending/processed/failed counts.',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'flo_messages_list',
+    description: 'List inbox-bridged messages from ~/.flo/messages/<recipient>/. Returns one entry per recipient with their messages.',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'flo_swarm_status',
+    description: 'Read .swarm/state.json and .swarm/q-learning-model.json from the project. Returns swarm objective, agent plan, and q-learning stats.',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'flo_transcribe',
+    description: 'Transcribe a local audio file (m4a/wav/mp3/aiff/flac). Auto-detects mlx-whisper / openai-whisper / whisper-cpp. No cloud calls.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        file: { type: 'string', description: 'Absolute path to audio file' },
+        model: { type: 'string', description: 'Whisper model (base/small/medium/large; default: base)' },
+      },
+      required: ['file'],
+    },
+  },
+  {
+    name: 'flo_transcribe_detect',
+    description: 'Report which local transcription tool would be used (mlx-whisper / openai-whisper / whisper-cpp).',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'flo_tasks_create',
+    description: 'Create a persistent task in flo. Survives across sessions. Stored in ~/.flo/tasks.jsonl.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        subject: { type: 'string' },
+        description: { type: 'string' },
+        tags: { type: 'array', items: { type: 'string' } },
+        owner: { type: 'string' },
+        parent: { type: 'string', description: 'Parent task id for subtasks' },
+        status: { type: 'string', enum: ['pending', 'in_progress', 'completed'] },
+      },
+      required: ['subject'],
+    },
+  },
+  {
+    name: 'flo_tasks_list',
+    description: 'List flo tasks. Optional filters: status / owner / tag.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        status: { type: 'string', enum: ['pending', 'in_progress', 'completed'] },
+        owner: { type: 'string' },
+        tag: { type: 'string' },
+        limit: { type: 'number' },
+      },
+    },
+  },
+  {
+    name: 'flo_tasks_update',
+    description: 'Update a flo task. Can change status, subject, description, tags, owner.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'string' },
+        subject: { type: 'string' },
+        description: { type: 'string' },
+        tags: { type: 'array', items: { type: 'string' } },
+        owner: { type: 'string' },
+        status: { type: 'string', enum: ['pending', 'in_progress', 'completed'] },
+      },
+      required: ['id'],
+    },
+  },
+  {
+    name: 'flo_tasks_complete',
+    description: 'Mark a flo task as completed.',
+    inputSchema: {
+      type: 'object',
+      properties: { id: { type: 'string' } },
+      required: ['id'],
+    },
+  },
+  {
+    name: 'flo_tasks_counts',
+    description: 'Get counts of flo tasks by status.',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'flo_agent_spawn',
+    description: 'Register a named agent in flo (~/.flo/agents.jsonl). Does NOT spawn a process — Claude Code\'s Task tool does that. This is a coordination record so multiple agents can discover each other.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        type: { type: 'string', description: 'Agent type (e.g. coder, tester, reviewer)' },
+        name: { type: 'string' },
+        role: { type: 'string' },
+        tags: { type: 'array', items: { type: 'string' } },
+        parent: { type: 'string', description: 'Parent agent id' },
+      },
+      required: ['type'],
+    },
+  },
+  {
+    name: 'flo_agent_list',
+    description: 'List registered flo agents with optional filters.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        status: { type: 'string', enum: ['idle', 'busy', 'completed', 'failed', 'stopped'] },
+        type: { type: 'string' },
+      },
+    },
+  },
+  {
+    name: 'flo_agent_status',
+    description: 'Get a single agent by id.',
+    inputSchema: {
+      type: 'object',
+      properties: { id: { type: 'string' } },
+      required: ['id'],
+    },
+  },
+  {
+    name: 'flo_agent_health',
+    description: 'Heartbeat-age health view of all live (non-stopped) agents.',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'flo_swarm_vote',
+    description: 'Record a weighted vote on a proposal in .swarm/consensus.jsonl. Last vote per voter wins on tally.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        proposal: { type: 'string' },
+        voter: { type: 'string' },
+        vote: { type: 'string', description: 'yes / no / abstain / any string' },
+        weight: { type: 'number' },
+      },
+      required: ['proposal', 'voter'],
+    },
+  },
+  {
+    name: 'flo_swarm_tally',
+    description: 'Tally weighted votes on a proposal. Returns total voters, total weight, and per-vote weight.',
+    inputSchema: {
+      type: 'object',
+      properties: { proposal: { type: 'string' } },
+      required: ['proposal'],
+    },
+  },
+];
+
+export async function mcpServe() {
+  const rl = createInterface({ input: process.stdin });
+  const inFlight = new Set();
+  let stdinClosed = false;
+
+  rl.on('line', (line) => {
+    if (!line.trim()) return;
+    const task = (async () => {
+      let req;
+      try { req = JSON.parse(line); }
+      catch { return send(null, null, { code: -32700, message: 'parse error' }); }
+      try {
+        const result = await handle(req);
+        if (req.id !== undefined && req.id !== null) {
+          send(req.id, result, null);
+        }
+      } catch (err) {
+        send(req?.id ?? null, null, { code: -32603, message: err.message || String(err) });
+      }
+    })();
+    inFlight.add(task);
+    task.finally(() => {
+      inFlight.delete(task);
+      if (stdinClosed && inFlight.size === 0) process.exit(0);
+    });
+  });
+
+  rl.on('close', () => {
+    stdinClosed = true;
+    if (inFlight.size === 0) process.exit(0);
+  });
+}
+
+async function handle(req) {
+  switch (req.method) {
+    case 'initialize':
+      return {
+        protocolVersion: PROTOCOL_VERSION,
+        capabilities: { tools: {} },
+        serverInfo: SERVER_INFO,
+      };
+    case 'notifications/initialized':
+    case 'notifications/cancelled':
+      return null;
+    case 'tools/list':
+      return { tools: TOOLS };
+    case 'tools/call':
+      return await callTool(req.params);
+    case 'ping':
+      return {};
+    default:
+      throw new Error(`method not implemented: ${req.method}`);
+  }
+}
+
+async function callTool({ name, arguments: args = {} }) {
+  switch (name) {
+    case 'flo_sessions_list': {
+      const records = await readCheckpoints(undefined, typeof args.limit === 'number' ? args.limit : 25);
+      return textResult(JSON.stringify(records, null, 2));
+    }
+    case 'flo_guidance_audit': {
+      const { runAuditJson } = await loadAuditRunner();
+      const json = await runAuditJson({ scope: args.scope || 'all' });
+      return textResult(json);
+    }
+    case 'flo_memory_store': {
+      if (!args.value) throw new Error('flo_memory_store: value is required');
+      const entry = await storeEntry({
+        namespace: args.namespace,
+        key: args.key,
+        value: args.value,
+        tags: args.tags,
+        metadata: args.metadata,
+      });
+      return textResult(JSON.stringify(entry, null, 2));
+    }
+    case 'flo_memory_search': {
+      const results = await searchEntries({
+        namespace: args.namespace,
+        query: args.query || '',
+        tags: args.tags || [],
+        limit: typeof args.limit === 'number' ? args.limit : 20,
+      });
+      return textResult(JSON.stringify(results, null, 2));
+    }
+    case 'flo_memory_list': {
+      const entries = await listEntries({
+        namespace: args.namespace || 'default',
+        limit: typeof args.limit === 'number' ? args.limit : 50,
+      });
+      return textResult(JSON.stringify(entries, null, 2));
+    }
+    case 'flo_memory_namespaces': {
+      const stats = await namespaceStats();
+      return textResult(JSON.stringify(stats, null, 2));
+    }
+    case 'flo_inbox_list': {
+      const list = await listInboxes();
+      return textResult(JSON.stringify(list, null, 2));
+    }
+    case 'flo_messages_list': {
+      const list = await listAllMailboxes();
+      return textResult(JSON.stringify(list, null, 2));
+    }
+    case 'flo_swarm_status': {
+      const state = await readSwarmState();
+      return textResult(JSON.stringify(state, null, 2));
+    }
+    case 'flo_transcribe': {
+      if (!args.file) throw new Error('flo_transcribe: file is required');
+      const result = await transcribe(args.file, { model: args.model });
+      return textResult(JSON.stringify(result, null, 2));
+    }
+    case 'flo_transcribe_detect': {
+      const tool = await detectTool();
+      return textResult(JSON.stringify({ tool: tool?.name || null, binary: tool?.binary || null }));
+    }
+    case 'flo_tasks_create': {
+      if (!args.subject) throw new Error('flo_tasks_create: subject is required');
+      const task = await createTask(args);
+      return textResult(JSON.stringify(task, null, 2));
+    }
+    case 'flo_tasks_list': {
+      const tasks = await listTasks({
+        status: args.status,
+        owner: args.owner,
+        tag: args.tag,
+        limit: typeof args.limit === 'number' ? args.limit : 100,
+      });
+      return textResult(JSON.stringify(tasks, null, 2));
+    }
+    case 'flo_tasks_update': {
+      if (!args.id) throw new Error('flo_tasks_update: id is required');
+      const task = await updateTask(args);
+      return textResult(JSON.stringify(task, null, 2));
+    }
+    case 'flo_tasks_complete': {
+      if (!args.id) throw new Error('flo_tasks_complete: id is required');
+      const task = await completeTask(args.id);
+      return textResult(JSON.stringify(task, null, 2));
+    }
+    case 'flo_tasks_counts': {
+      const counts = await taskCounts();
+      return textResult(JSON.stringify(counts, null, 2));
+    }
+    case 'flo_agent_spawn': {
+      if (!args.type) throw new Error('flo_agent_spawn: type is required');
+      const agent = await spawnAgent(args);
+      return textResult(JSON.stringify(agent, null, 2));
+    }
+    case 'flo_agent_list': {
+      const agents = await listAgents({ status: args.status, type: args.type });
+      return textResult(JSON.stringify(agents, null, 2));
+    }
+    case 'flo_agent_status': {
+      if (!args.id) throw new Error('flo_agent_status: id is required');
+      const agent = await getAgent(args.id);
+      return textResult(JSON.stringify(agent, null, 2));
+    }
+    case 'flo_agent_health': {
+      const health = await agentHealth();
+      return textResult(JSON.stringify(health, null, 2));
+    }
+    case 'flo_swarm_vote': {
+      if (!args.proposal) throw new Error('flo_swarm_vote: proposal is required');
+      if (!args.voter) throw new Error('flo_swarm_vote: voter is required');
+      const event = await recordVote(args);
+      return textResult(JSON.stringify(event, null, 2));
+    }
+    case 'flo_swarm_tally': {
+      if (!args.proposal) throw new Error('flo_swarm_tally: proposal is required');
+      const result = await tallyVotes({ proposal: args.proposal });
+      return textResult(JSON.stringify(result, null, 2));
+    }
+    default:
+      throw new Error(`unknown tool: ${name}`);
+  }
+}
+
+function textResult(text) {
+  return { content: [{ type: 'text', text }] };
+}
+
+async function loadAuditRunner() {
+  // Spawn ourselves with `guidance audit --json --quiet` to reuse the markdown
+  // renderer side. Uses execFile with an argument array (no shell).
+  const { execFile } = await import('node:child_process');
+  const { promisify } = await import('node:util');
+  const execFileAsync = promisify(execFile);
+  return {
+    async runAuditJson({ scope }) {
+      const binPath = new URL('../bin/flo.js', import.meta.url).pathname;
+      const args = ['guidance', 'audit', '--json', '--quiet'];
+      if (scope && scope !== 'all') args.push('--scope', scope);
+      const { stdout } = await execFileAsync(process.execPath, [binPath, ...args], {
+        maxBuffer: 16 * 1024 * 1024,
+        timeout: 30_000,
+      });
+      return stdout;
+    },
+  };
+}
+
+function send(id, result, error) {
+  const msg = { jsonrpc: '2.0', id };
+  if (error) msg.error = error;
+  else msg.result = result;
+  process.stdout.write(JSON.stringify(msg) + '\n');
+}

package/lib/memory-backend-agentdb.js

@@ -0,0 +1,240 @@
+// AgentDB-backed memory adapter. Wraps @myflo/memory's UnifiedMemoryService
+// + SqlJsBackend to expose the same API as memory-store.js's JSONL backend:
+//   storeEntry, searchEntries, listEntries, getEntry, deleteEntry,
+//   listNamespaces, namespaceStats
+//
+// Backend: SqlJsBackend (pure WASM SQLite, no native deps — works on any
+// Node 20+ runtime). Vector search is degraded gracefully when no embedding
+// generator is configured (returns FTS5 / keyword results only).
+
+import { mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { randomBytes } from 'node:crypto';
+
+const FLO_HOME = process.env.FLO_HOME || join(homedir(), '.flo');
+const DB_PATH = join(FLO_HOME, 'agentdb.sqlite');
+
+let _backend = null;
+
+async function locateSqlJsWasm() {
+  // sql.js ships its WASM as a file. By default it tries to fetch from
+  // sql.js.org which fails offline. Point it at the bundled file.
+  // sql.js is a transitive dep of @myflo/memory, so we resolve via that
+  // package's location (createRequire from the memory module URL).
+  const { createRequire } = await import('node:module');
+  try {
+    // Resolve @myflo/memory's package.json to find its location
+    const memoryPkgUrl = import.meta.resolve('@myflo/memory/package.json');
+    const req = createRequire(memoryPkgUrl);
+    const sqlJsMain = req.resolve('sql.js');
+    return sqlJsMain.replace(/sql-wasm\.js$/, 'sql-wasm.wasm');
+  } catch {
+    return null;
+  }
+}
+
+async function getBackend() {
+  if (_backend) return _backend;
+  if (!existsSync(FLO_HOME)) await mkdir(FLO_HOME, { recursive: true });
+  // Dynamic import keeps the heavy module out of the load path for the JSONL
+  // codepath. @myflo/memory is an optionalDependency — when missing (e.g. a
+  // bare `npm install myflo` without the optional extras), throw a clear error
+  // so the caller knows to either install the optional dep or stick with the
+  // jsonl backend.
+  let SqlJsBackend;
+  try {
+    ({ SqlJsBackend } = await import('@myflo/memory'));
+  } catch (err) {
+    throw new Error(
+      `agentdb backend requires @myflo/memory (optional dependency). ` +
+      `Install it: npm i @myflo/memory. ` +
+      `Or stick with the default jsonl backend (unset FLO_MEMORY_BACKEND). ` +
+      `Underlying error: ${err.message}`
+    );
+  }
+  const wasmPath = await locateSqlJsWasm();
+  // autoPersistInterval: 0 disables the setInterval that holds the Node event
+  // loop open. We persist explicitly after each write so a one-shot CLI invocation
+  // can exit cleanly.
+  _backend = new SqlJsBackend({ databasePath: DB_PATH, wasmPath, autoPersistInterval: 0 });
+  await _backend.initialize();
+  return _backend;
+}
+
+function sanitizeNs(ns) {
+  return String(ns || 'default').replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 64) || 'default';
+}
+
+function newId() {
+  return `${Date.now()}-${randomBytes(3).toString('hex')}`;
+}
+
+// Map flo-shape entry to @myflo/memory MemoryEntry. SqlJsBackend binds every
+// field via positional ?-params, so undefined is fatal — we provide every
+// expected field with a sensible default.
+function toBackendEntry({ namespace = 'default', key, value, tags = [], metadata = {} }) {
+  const id = newId();
+  const ns = sanitizeNs(namespace);
+  const now = Date.now();
+  return {
+    id,
+    key: key || id,
+    content: String(value ?? ''),
+    type: 'semantic',
+    namespace: ns,
+    tags: Array.isArray(tags) ? tags.map(String) : [],
+    metadata: metadata && typeof metadata === 'object' ? metadata : {},
+    ownerId: null,
+    accessLevel: 'private',
+    createdAt: now,
+    updatedAt: now,
+    expiresAt: null,
+    version: 1,
+    references: [],
+    accessCount: 0,
+    lastAccessedAt: now,
+  };
+}
+
+// Map backend MemoryEntry to the shape callers expect
+function fromBackendEntry(entry) {
+  if (!entry) return null;
+  return {
+    id: entry.id,
+    namespace: entry.namespace,
+    key: entry.key && entry.key !== entry.id ? entry.key : null,
+    value: entry.content || '',
+    tags: entry.tags || [],
+    metadata: entry.metadata || {},
+    createdAt: entry.createdAt
+      ? new Date(typeof entry.createdAt === 'number' ? entry.createdAt : Date.parse(entry.createdAt)).toISOString()
+      : new Date().toISOString(),
+    deleted: false,
+  };
+}
+
+// Public API mirrors memory-store.js (JSONL backend)
+
+export async function storeEntry(input) {
+  const backend = await getBackend();
+  const entry = toBackendEntry(input);
+  await backend.store(entry);
+  await backend.persist();
+  return fromBackendEntry(entry);
+}
+
+export async function deleteEntry({ id }) {
+  if (!id) return;
+  const backend = await getBackend();
+  await backend.delete(id);
+  await backend.persist();
+}
+
+export async function getEntry({ namespace = 'default', id, key }) {
+  const backend = await getBackend();
+  if (id) {
+    const entry = await backend.get(id);
+    return fromBackendEntry(entry);
+  }
+  if (key) {
+    const entry = await backend.getByKey(sanitizeNs(namespace), key);
+    return fromBackendEntry(entry);
+  }
+  return null;
+}
+
+export async function listEntries({ namespace = 'default', limit = 50 } = {}) {
+  const backend = await getBackend();
+  const entries = await backend.query({
+    namespace: sanitizeNs(namespace),
+    limit,
+  });
+  return entries
+    .sort((a, b) => (b.createdAt || 0) - (a.createdAt || 0))
+    .slice(0, limit)
+    .map(fromBackendEntry);
+}
+
+export async function searchEntries({ namespace, query = '', tags = [], limit = 20 }) {
+  const backend = await getBackend();
+  const ns = namespace ? sanitizeNs(namespace) : undefined;
+  const wantTags = new Set(tags.map((t) => String(t).toLowerCase()));
+
+  // Use FTS5 keyword search when a query string is provided (real BM25 ranking
+  // from SQLite). Without a query, fall back to a namespace scan + tag filter.
+  let candidates = [];
+  if (query) {
+    try {
+      // SqlJsBackend.searchKeyword returns SearchResult[] (entry + score)
+      const searchResults = await backend.searchKeyword(query, Math.max(limit * 3, 50));
+      candidates = searchResults
+        .map((r) => ({ entry: r.entry || r, score: r.score ?? 1 }))
+        .filter(({ entry }) => !ns || entry.namespace === ns);
+    } catch {
+      // FTS5 not available in this sql.js build — fall through to scan
+    }
+  }
+
+  if (candidates.length === 0) {
+    const scan = await backend.query({ namespace: ns, limit: 1000 });
+    const q = String(query || '').toLowerCase();
+    candidates = scan
+      .map((entry) => {
+        const tagSet = new Set((entry.tags || []).map((t) => String(t).toLowerCase()));
+        const tagOverlap = [...wantTags].filter((t) => tagSet.has(t)).length;
+        const haystack = `${entry.key || ''} ${entry.content || ''}`.toLowerCase();
+        let score = tagOverlap * 2;
+        if (q && haystack.includes(q)) score += 1 + Math.min(haystack.split(q).length - 1, 4);
+        if (q) {
+          const terms = q.split(/\s+/).filter(Boolean);
+          if (terms.length > 1) {
+            const matched = terms.filter((t) => haystack.includes(t)).length;
+            score += matched;
+          }
+        }
+        if (score <= 0 && !wantTags.size) return null;
+        if (wantTags.size && tagOverlap === 0 && !q) return null;
+        return { entry, score };
+      })
+      .filter(Boolean);
+  }
+
+  // Apply tag boost (post-FTS) and re-sort
+  for (const c of candidates) {
+    const tagSet = new Set((c.entry.tags || []).map((t) => String(t).toLowerCase()));
+    const tagOverlap = [...wantTags].filter((t) => tagSet.has(t)).length;
+    if (tagOverlap > 0) c.score += 2 + tagOverlap * 0.5;
+  }
+  return candidates
+    .sort((a, b) => b.score - a.score)
+    .slice(0, limit)
+    .map(({ entry, score }) => ({ ...fromBackendEntry(entry), _score: Number(score.toFixed(4)) }));
+}
+
+export async function listNamespaces() {
+  const backend = await getBackend();
+  return await backend.listNamespaces();
+}
+
+export async function namespaceStats() {
+  const backend = await getBackend();
+  const namespaces = await backend.listNamespaces();
+  const out = [];
+  for (const ns of namespaces) {
+    const count = await backend.count(ns);
+    // Fetch most recent entry in this namespace for lastEntryAt
+    const latest = await backend.query({ namespace: ns, limit: 1 });
+    const lastTs = latest[0]?.createdAt || null;
+    out.push({
+      namespace: ns,
+      count,
+      lastEntryAt: lastTs ? new Date(lastTs).toISOString() : null,
+    });
+  }
+  out.sort((a, b) => (a.lastEntryAt && b.lastEntryAt ? (a.lastEntryAt < b.lastEntryAt ? 1 : -1) : 0));
+  return out;
+}
+
+export const _internal = { FLO_HOME, DB_PATH, getBackend };