@askmesh/mcp 0.9.0 → 0.10.1

package/README.md

@@ -25,22 +25,21 @@ npx -y @askmesh/mcp
 }
 ```
 
-**Step 2** — Add your token in `.env` (never committed):
+**Step 2** — Restart Claude Code, then type: `/ask-setup`
 
-```
-ASKMESH_TOKEN=your_token_here
-ASKMESH_URL=https://api.askmesh.dev
-```
-
-**Step 3** — Restart Claude Code, then type: `setup askmesh`
+That's it. The setup wizard will:
+- Ask for your token (from [askmesh.dev](https://askmesh.dev) → Settings)
+- Save it in `.env` (auto-added to `.gitignore`)
+- Install slash commands (`/ask-inbox`, `/ask-broadcast`, etc.)
+- Configure the status line
 
-This installs slash commands (`/inbox`, `/broadcast`, etc.) and configures the status line.
+No env vars needed in `.mcp.json` — everything lives in your `.env`.
 
 ## Get your token
 
 1. Sign up at [askmesh.dev](https://askmesh.dev)
 2. Go to **Settings** → create an agent → copy the API token
-3. Paste it in your `.env`
+3. Run `/ask-setup` and paste it when prompted
 
 ## Usage
 
@@ -76,16 +75,17 @@ One single tool `askmesh` — Claude understands natural language:
 
 ### Slash commands (skills)
 
-Add these as `.claude/commands/*.md` in your project for quick access:
+Installed automatically by `/ask-setup`:
 
 | Command | Description |
 |---|---|
-| `/inbox` | Check pending + sent messages |
-| `/broadcast <msg>` | Broadcast to your team |
-| `/reply <id> <msg>` | Reply to a thread |
-| `/board` | View team kanban board |
-| `/threads` | List active conversations |
-| `/mesh-status` | See who's online |
+| `/ask-inbox` | Check pending + sent messages |
+| `/ask-broadcast <msg>` | Broadcast to your team |
+| `/ask-reply <id> <msg>` | Reply to a thread |
+| `/ask-board` | View team kanban board |
+| `/ask-threads` | List active conversations |
+| `/ask-status` | See who's online |
+| `/ask-setup` | Install or update AskMesh config |
 
 ## Status line
 
@@ -101,18 +101,7 @@ mesh 3↓ 1~ 2>
 
 ### Setup
 
-Add to your Claude Code settings (`~/.claude/settings.json`):
-
-```json
-{
-  "statusLine": {
-    "type": "command",
-    "command": "/path/to/node_modules/@askmesh/mcp/statusline.sh"
-  }
-}
-```
-
-The MCP server updates a local cache file in real-time via SSE events. The status line script reads it — no polling, no API calls.
+Configured automatically by `/ask-setup`. The MCP server updates a local cache file in real-time via SSE events. The status line script reads it — no polling, no API calls.
 
 ## Auto-responder
 

package/dist/index.d.ts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-export {};
+import 'dotenv/config';

package/dist/index.js

@@ -1,70 +1,73 @@
 #!/usr/bin/env node
+import 'dotenv/config';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { AskMeshClient } from './client/askmesh_client.js';
 import { SseListener } from './sse/sse_listener.js';
 import { AutoResponder } from './agent/auto_responder.js';
-import { registerAskMesh } from './tools/askmesh.js';
+import { registerAskMesh, registerSetupOnly } from './tools/askmesh.js';
 import * as statusCache from './statusline/cache.js';
 const TOKEN = process.env.ASKMESH_TOKEN;
 const URL = process.env.ASKMESH_URL || 'https://api.askmesh.dev';
-if (!TOKEN) {
-    console.error('[AskMesh] ASKMESH_TOKEN is required');
-    process.exit(1);
-}
-const client = new AskMeshClient(URL, TOKEN);
-const autoResponder = new AutoResponder(client);
 const server = new McpServer({
     name: 'askmesh',
-    version: '0.9.0',
+    version: '0.10.1',
 });
-// Single unified tool
-registerAskMesh(server, client);
-// Give the auto-responder access to the underlying MCP server for sampling
-autoResponder.setServer(server.server);
-// Start SSE listener — auto-respond to incoming questions + receive answers
-const sse = new SseListener();
-sse.start(URL, TOKEN, async (request) => {
-    statusCache.onRequestIncoming();
-    await autoResponder.handleRequest(request);
-}, (answer) => {
-    console.error(`[AskMesh] Answer received for request #${answer.id}: "${answer.answer.slice(0, 100)}${answer.answer.length > 100 ? '...' : ''}"`);
-}, (_reply) => {
-    statusCache.onReplyAdded();
-}, (_closed) => {
-    statusCache.onThreadClosed();
-});
-// Polling fallback — fetch pending requests periodically
-// Useful for server agents that may miss SSE events
-const POLL_INTERVAL = Number(process.env.ASKMESH_POLL_INTERVAL || 0); // seconds, 0 = disabled
-if (POLL_INTERVAL > 0) {
-    console.error(`[AskMesh] Polling enabled every ${POLL_INTERVAL}s`);
-    setInterval(async () => {
-        try {
-            const { requests } = await client.getPendingRequests();
-            for (const req of requests) {
-                console.error(`[AskMesh] Polled pending #${req.id}: "${req.question}"`);
-                await autoResponder.handleRequest({
-                    id: req.id,
-                    fromAgentId: req.fromAgentId,
-                    fromUsername: `agent#${req.fromAgentId}`,
-                    question: req.question,
-                    context: req.context,
-                });
+if (!TOKEN) {
+    // No token — start in setup-only mode
+    console.error('[AskMesh] No ASKMESH_TOKEN found. Starting in setup mode.');
+    registerSetupOnly(server);
+}
+else {
+    // Full mode
+    statusCache.init(TOKEN);
+    const client = new AskMeshClient(URL, TOKEN);
+    const autoResponder = new AutoResponder(client);
+    registerAskMesh(server, client);
+    autoResponder.setServer(server.server);
+    // Start SSE listener
+    const sse = new SseListener();
+    sse.start(URL, TOKEN, async (request) => {
+        statusCache.onRequestIncoming();
+        await autoResponder.handleRequest(request);
+    }, (answer) => {
+        console.error(`[AskMesh] Answer received for request #${answer.id}: "${answer.answer.slice(0, 100)}${answer.answer.length > 100 ? '...' : ''}"`);
+    }, (_reply) => {
+        statusCache.onReplyAdded();
+    }, (_closed) => {
+        statusCache.onThreadClosed();
+    });
+    // Polling fallback
+    const POLL_INTERVAL = Number(process.env.ASKMESH_POLL_INTERVAL || 0);
+    if (POLL_INTERVAL > 0) {
+        console.error(`[AskMesh] Polling enabled every ${POLL_INTERVAL}s`);
+        setInterval(async () => {
+            try {
+                const { requests } = await client.getPendingRequests();
+                for (const req of requests) {
+                    console.error(`[AskMesh] Polled pending #${req.id}: "${req.question}"`);
+                    await autoResponder.handleRequest({
+                        id: req.id,
+                        fromAgentId: req.fromAgentId,
+                        fromUsername: `agent#${req.fromAgentId}`,
+                        question: req.question,
+                        context: req.context,
+                    });
+                }
             }
-        }
-        catch { }
-    }, POLL_INTERVAL * 1000);
+            catch { }
+        }, POLL_INTERVAL * 1000);
+    }
+    // Cleanup on exit
+    process.on('SIGINT', () => {
+        sse.stop();
+        process.exit(0);
+    });
+    process.on('SIGTERM', () => {
+        sse.stop();
+        process.exit(0);
+    });
 }
-// Cleanup on exit
-process.on('SIGINT', () => {
-    sse.stop();
-    process.exit(0);
-});
-process.on('SIGTERM', () => {
-    sse.stop();
-    process.exit(0);
-});
 // Start MCP server via stdio
 const transport = new StdioServerTransport();
 await server.connect(transport);

package/dist/statusline/cache.d.ts

@@ -4,6 +4,9 @@ interface StatusCache {
     unread_replies: number;
     last_update: string;
 }
+/** Call once at startup with the agent token to isolate the cache file per agent */
+export declare function init(token: string): void;
+export declare function getCacheFile(): string;
 export declare function load(): StatusCache;
 export declare function onRequestIncoming(): void;
 export declare function onReplyAdded(): void;

package/dist/statusline/cache.js

@@ -1,8 +1,14 @@
 import { writeFileSync, readFileSync } from 'fs';
+import { createHash } from 'crypto';
 import { tmpdir } from 'os';
 import { join } from 'path';
-const CACHE_FILE = join(tmpdir(), 'askmesh_status.json');
+let CACHE_FILE = join(tmpdir(), 'askmesh_status.json');
 let cache = { pending: 0, active: 0, unread_replies: 0, last_update: '' };
+/** Call once at startup with the agent token to isolate the cache file per agent */
+export function init(token) {
+    const hash = createHash('md5').update(token).digest('hex').slice(0, 8);
+    CACHE_FILE = join(tmpdir(), `askmesh_status_${hash}.json`);
+}
 function flush() {
     cache.last_update = new Date().toISOString();
     try {
@@ -10,6 +16,9 @@ function flush() {
     }
     catch { }
 }
+export function getCacheFile() {
+    return CACHE_FILE;
+}
 export function load() {
     try {
         const raw = readFileSync(CACHE_FILE, 'utf-8');

package/dist/tools/askmesh.d.ts

@@ -1,3 +1,4 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { AskMeshClient } from '../client/askmesh_client.js';
 export declare function registerAskMesh(server: McpServer, client: AskMeshClient): void;
+export declare function registerSetupOnly(server: McpServer): void;

package/dist/tools/askmesh.js

@@ -1,6 +1,7 @@
 import { z } from 'zod';
-import { mkdirSync, writeFileSync, readFileSync, appendFileSync, existsSync } from 'fs';
+import { mkdirSync, writeFileSync, readFileSync, appendFileSync, existsSync, unlinkSync, copyFileSync, chmodSync } from 'fs';
 import { join, dirname } from 'path';
+import { homedir } from 'os';
 import { fileURLToPath } from 'url';
 import * as statusCache from '../statusline/cache.js';
 export function registerAskMesh(server, client) {
@@ -40,7 +41,8 @@ Actions disponibles :
         message: z.string().optional().describe('Réponse ou contexte à envoyer (pour answer/reply/context)'),
         parentThreadId: z.number().optional().describe('ID du thread parent (pour ask, lie les threads entre eux)'),
         teamId: z.number().optional().describe('ID de la team (pour board)'),
-    }, async ({ action, username, question, requestId, message, parentThreadId, teamId }) => {
+        token: z.string().optional().describe('API token AskMesh (pour setup — depuis askmesh.dev > Settings)'),
+    }, async ({ action, username, question, requestId, message, parentThreadId, teamId, token }) => {
         switch (action) {
             case 'ask': {
                 if (!username || !question) {
@@ -208,56 +210,109 @@ Actions disponibles :
                 return text(`Contexte mis à jour (${message.length} caractères).`);
             }
             case 'setup': {
-                return setupSkillsAndStatusLine();
+                return setupSkillsAndStatusLine(token);
             }
             default:
                 return text('Action inconnue. Actions disponibles : ask, list, status, pending, answer, context, setup');
         }
     });
 }
+export function registerSetupOnly(server) {
+    server.tool('askmesh', `AskMesh — première configuration requise.
+Aucun token trouvé. Utilise cet outil pour configurer AskMesh dans ce projet.
+
+Actions disponibles :
+- "setup" : configurer le projet (crée le .env, installe les slash commands, configure la status line)
+
+Pour commencer :
+1. Inscris-toi sur https://askmesh.dev
+2. Copie ton API token depuis Settings
+3. Lance l'action "setup" avec ton token pour tout installer`, {
+        action: z.enum(['setup']).describe('Action à effectuer'),
+        token: z.string().optional().describe('Ton API token AskMesh (depuis askmesh.dev > Settings)'),
+    }, async ({ action, token }) => {
+        if (action === 'setup') {
+            return setupSkillsAndStatusLine(token);
+        }
+        return text('Action inconnue.');
+    });
+}
 function text(t) {
     return { content: [{ type: 'text', text: t }] };
 }
-function setupSkillsAndStatusLine() {
+function setupSkillsAndStatusLine(token) {
     const cwd = process.cwd();
     const commandsDir = join(cwd, '.claude', 'commands');
     const installed = [];
     const skipped = [];
     // Skills definitions
     const skills = {
-        'inbox.md': `Utilise l'outil MCP askmesh avec l'action "pending" pour vérifier les messages reçus en attente, puis avec l'action "inbox" pour voir les réponses à mes messages envoyés.\n\nAffiche un résumé clair :\n1. D'abord les messages reçus à traiter (pending)\n2. Ensuite les réponses reçues (inbox)\n\nSi tout est vide, dis simplement "Aucun message en attente."`,
-        'broadcast.md': `Utilise l'outil MCP askmesh avec l'action "broadcast" pour envoyer un message à toute l'équipe.\n\nLe message à diffuser : $ARGUMENTS\n\nSi aucun message n'est fourni, demande à l'utilisateur quel message il souhaite broadcaster.`,
-        'reply.md': `Utilise l'outil MCP askmesh pour répondre à un thread.\n\nArguments attendus : $ARGUMENTS (format: <requestId> <message>)\n\nExemple : /reply 42 Voici ma réponse détaillée...\n\nSi le requestId n'est pas fourni, utilise d'abord l'action "pending" pour lister les threads en attente et demande à l'utilisateur lequel traiter.\n\nUtilise l'action "reply" avec le requestId et le message.`,
-        'board.md': `Utilise l'outil MCP askmesh avec l'action "board" pour afficher le tableau kanban de l'équipe.\n\nSi un teamId est fourni dans les arguments ($ARGUMENTS), utilise-le directement.\nSinon, utilise d'abord l'action "list" pour identifier les teams disponibles, puis affiche le board de la première team.\n\nPrésente le résultat de manière claire avec les colonnes : Pending, In Progress, Active, Done.`,
-        'threads.md': `Utilise l'outil MCP askmesh avec l'action "my-threads" pour afficher toutes mes conversations actives.\n\nPrésente les threads regroupés par statut :\n- En attente (pending)\n- En cours (in_progress)\n- Actifs (active)\n\nIgnore les threads clos. Pour chaque thread, montre : l'ID, qui a posé la question, le sujet, et le nombre de réponses.`,
-        'mesh-status.md': `Utilise l'outil MCP askmesh avec l'action "list" pour voir qui est connecté sur le réseau.\n\nAffiche la liste des membres de l'équipe avec leur statut (online/offline) de manière claire et concise.`,
+        'ask-inbox.md': `Utilise l'outil MCP askmesh avec l'action "pending" pour vérifier les messages reçus en attente, puis avec l'action "inbox" pour voir les réponses à mes messages envoyés.\n\nAffiche un résumé clair :\n1. D'abord les messages reçus à traiter (pending)\n2. Ensuite les réponses reçues (inbox)\n\nSi tout est vide, dis simplement "Aucun message en attente."`,
+        'ask-broadcast.md': `Utilise l'outil MCP askmesh avec l'action "broadcast" pour envoyer un message à toute l'équipe.\n\nLe message à diffuser : $ARGUMENTS\n\nSi aucun message n'est fourni, demande à l'utilisateur quel message il souhaite broadcaster.`,
+        'ask-reply.md': `Utilise l'outil MCP askmesh pour répondre à un thread.\n\nArguments attendus : $ARGUMENTS (format: <requestId> <message>)\n\nExemple : /ask-reply 42 Voici ma réponse détaillée...\n\nSi le requestId n'est pas fourni, utilise d'abord l'action "pending" pour lister les threads en attente et demande à l'utilisateur lequel traiter.\n\nUtilise l'action "reply" avec le requestId et le message.`,
+        'ask-board.md': `Utilise l'outil MCP askmesh avec l'action "board" pour afficher le tableau kanban de l'équipe.\n\nSi un teamId est fourni dans les arguments ($ARGUMENTS), utilise-le directement.\nSinon, utilise d'abord l'action "list" pour identifier les teams disponibles, puis affiche le board de la première team.\n\nPrésente le résultat de manière claire avec les colonnes : Pending, In Progress, Active, Done.`,
+        'ask-threads.md': `Utilise l'outil MCP askmesh avec l'action "my-threads" pour afficher toutes mes conversations actives.\n\nPrésente les threads regroupés par statut :\n- En attente (pending)\n- En cours (in_progress)\n- Actifs (active)\n\nIgnore les threads clos. Pour chaque thread, montre : l'ID, qui a posé la question, le sujet, et le nombre de réponses.`,
+        'ask-status.md': `Utilise l'outil MCP askmesh avec l'action "list" pour voir qui est connecté sur le réseau.\n\nAffiche la liste des membres de l'équipe avec leur statut (online/offline) de manière claire et concise.`,
+        'ask-setup.md': `Utilise l'outil MCP askmesh avec l'action "setup" pour installer ou mettre à jour la configuration AskMesh dans ce projet.\n\nCela va :\n- Créer ou vérifier le .env avec le token AskMesh\n- Installer les slash commands (/ask-inbox, /ask-broadcast, etc.)\n- Configurer la status line\n- Ajouter .env au .gitignore\n\nSi l'utilisateur fournit un token dans les arguments ($ARGUMENTS), passe-le en paramètre "token".`,
     };
     // Create commands directory
     try {
         mkdirSync(commandsDir, { recursive: true });
     }
     catch { }
-    // Write skills
+    // Write skills (always overwrite to keep them up to date)
     for (const [filename, content] of Object.entries(skills)) {
         const filepath = join(commandsDir, filename);
-        if (existsSync(filepath)) {
+        const existed = existsSync(filepath);
+        writeFileSync(filepath, content);
+        if (existed) {
             skipped.push(filename);
         }
         else {
-            writeFileSync(filepath, content);
             installed.push(filename);
         }
     }
-    // Check .env for token
+    // Remove old skill names (migration from pre-0.10)
+    const oldSkills = ['inbox.md', 'broadcast.md', 'reply.md', 'board.md', 'threads.md', 'mesh-status.md'];
+    const removed = [];
+    for (const old of oldSkills) {
+        const oldPath = join(commandsDir, old);
+        if (existsSync(oldPath)) {
+            try {
+                unlinkSync(oldPath);
+                removed.push(old);
+            }
+            catch { }
+        }
+    }
+    // Handle .env token
     const envPath = join(cwd, '.env');
     let envStatus = '';
-    if (existsSync(envPath)) {
+    if (token) {
+        if (existsSync(envPath)) {
+            const content = readFileSync(envPath, 'utf-8');
+            if (content.includes('ASKMESH_TOKEN')) {
+                const updated = content.replace(/ASKMESH_TOKEN=.*/, `ASKMESH_TOKEN=${token}`);
+                writeFileSync(envPath, updated);
+                envStatus = '.env : ASKMESH_TOKEN mis à jour';
+            }
+            else {
+                appendFileSync(envPath, `\nASKMESH_TOKEN=${token}\nASKMESH_URL=https://api.askmesh.dev\n`);
+                envStatus = '.env : ASKMESH_TOKEN ajouté';
+            }
+        }
+        else {
+            writeFileSync(envPath, `ASKMESH_TOKEN=${token}\nASKMESH_URL=https://api.askmesh.dev\n`);
+            envStatus = '.env créé avec le token';
+        }
+    }
+    else if (existsSync(envPath)) {
         const envContent = readFileSync(envPath, 'utf-8');
-        if (envContent.includes('ASKMESH_TOKEN')) {
-            envStatus = '.env : ASKMESH_TOKEN déjà présent';
+        if (envContent.includes('ASKMESH_TOKEN') && !envContent.includes('your_token_here')) {
+            envStatus = '.env : ASKMESH_TOKEN présent';
         }
         else {
-            envStatus = '.env : ASKMESH_TOKEN absent — ajoute-le manuellement';
+            envStatus = '.env : ASKMESH_TOKEN absent — ajoute-le ou relance /ask-setup avec ton token';
         }
     }
     else {
@@ -274,29 +329,61 @@ function setupSkillsAndStatusLine() {
             gitignoreStatus = '.gitignore : .env ajouté';
         }
     }
-    // Status line info
+    // Auto-configure status line
+    // Copy statusline.sh to a stable location (~/.claude/) so it survives npx cache clears
     const mcpDir = dirname(fileURLToPath(import.meta.url));
-    const statusLineScript = join(mcpDir, '..', 'statusline.sh');
-    const statusLineExists = existsSync(statusLineScript);
+    const sourceScript = join(mcpDir, '..', 'statusline.sh');
+    const claudeSettingsDir = join(homedir(), '.claude');
+    const stableScript = join(claudeSettingsDir, 'askmesh-statusline.sh');
+    const claudeSettingsPath = join(claudeSettingsDir, 'settings.json');
+    let statusLineStatus = '';
+    try {
+        mkdirSync(claudeSettingsDir, { recursive: true });
+        // Copy script to stable location
+        if (existsSync(sourceScript)) {
+            copyFileSync(sourceScript, stableScript);
+            chmodSync(stableScript, 0o755);
+        }
+        if (existsSync(stableScript)) {
+            let settings = {};
+            if (existsSync(claudeSettingsPath)) {
+                settings = JSON.parse(readFileSync(claudeSettingsPath, 'utf-8'));
+            }
+            if (settings.statusLine?.command === stableScript) {
+                statusLineStatus = 'Status line : déjà configurée';
+            }
+            else {
+                settings.statusLine = { type: 'command', command: stableScript };
+                writeFileSync(claudeSettingsPath, JSON.stringify(settings, null, 2) + '\n');
+                statusLineStatus = 'Status line : configurée automatiquement';
+            }
+        }
+        else {
+            statusLineStatus = 'Status line : script source non trouvé';
+        }
+    }
+    catch (e) {
+        statusLineStatus = `Status line : erreur — ${e}`;
+    }
+    // Build report
     const lines = ['Setup AskMesh terminé !\n'];
     if (installed.length > 0) {
         lines.push(`Slash commands installées : ${installed.map((f) => '/' + f.replace('.md', '')).join(', ')}`);
     }
     if (skipped.length > 0) {
-        lines.push(`Déjà présentes (non écrasées) : ${skipped.map((f) => '/' + f.replace('.md', '')).join(', ')}`);
+        lines.push(`Mises à jour : ${skipped.map((f) => '/' + f.replace('.md', '')).join(', ')}`);
+    }
+    if (removed.length > 0) {
+        lines.push(`Anciennes skills supprimées : ${removed.map((f) => '/' + f.replace('.md', '')).join(', ')}`);
     }
     lines.push('');
     lines.push(envStatus);
     if (gitignoreStatus)
         lines.push(gitignoreStatus);
-    lines.push('');
-    if (statusLineExists) {
-        lines.push(`Status line disponible : ${statusLineScript}`);
-        lines.push(`Pour l'activer, ajoute dans ~/.claude/settings.json :`);
-        lines.push(`  "statusLine": { "type": "command", "command": "${statusLineScript}" }`);
-    }
-    else {
-        lines.push('Status line script non trouvé (sera disponible après npm install)');
+    lines.push(statusLineStatus);
+    if (token) {
+        lines.push('');
+        lines.push('Redémarre Claude Code pour activer AskMesh complètement.');
     }
     return text(lines.join('\n'));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askmesh/mcp",
-  "version": "0.9.0",
+  "version": "0.10.1",
   "description": "AskMesh MCP server — connect your AI coding agent to your team's mesh network",
   "type": "module",
   "bin": {
@@ -34,6 +34,7 @@
   "license": "MIT",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
+    "dotenv": "^17.4.0",
     "eventsource": "^2.0.2",
     "zod": "^4.3.6"
   },

package/statusline.sh

@@ -1,29 +1,36 @@
 #!/bin/bash
 # AskMesh status line for Claude Code
-# Reads cached notification counts from the MCP server
-# Install: add to settings.json → statusLine.command
+# Reads cached notification counts from MCP server(s)
+# Aggregates across all active agent caches
 
 input=$(cat)
-model=$(echo "$input" | jq -r '.model.display_name // "Claude"' 2>/dev/null)
 
-cache_file="${TMPDIR:-/tmp}/askmesh_status.json"
+tmpdir="${TMPDIR:-/tmp}"
+pending=0
+active=0
+replies=0
 
-parts=()
+# Aggregate all agent cache files
+for f in "$tmpdir"/askmesh_status_*.json; do
+  [ -f "$f" ] || continue
+  p=$(jq -r '.pending // 0' "$f" 2>/dev/null)
+  a=$(jq -r '.active // 0' "$f" 2>/dev/null)
+  r=$(jq -r '.unread_replies // 0' "$f" 2>/dev/null)
+  pending=$((pending + p))
+  active=$((active + a))
+  replies=$((replies + r))
+done
 
-if [ -f "$cache_file" ]; then
-  pending=$(jq -r '.pending // 0' "$cache_file" 2>/dev/null)
-  active=$(jq -r '.active // 0' "$cache_file" 2>/dev/null)
-  replies=$(jq -r '.unread_replies // 0' "$cache_file" 2>/dev/null)
+parts=()
 
-  if [ "$pending" -gt 0 ] 2>/dev/null; then
-    parts+=("\033[33m${pending}↓\033[0m")
-  fi
-  if [ "$active" -gt 0 ] 2>/dev/null; then
-    parts+=("\033[32m${active}~\033[0m")
-  fi
-  if [ "$replies" -gt 0 ] 2>/dev/null; then
-    parts+=("\033[36m${replies}>\033[0m")
-  fi
+if [ "$pending" -gt 0 ] 2>/dev/null; then
+  parts+=("\033[33m${pending}↓\033[0m")
+fi
+if [ "$active" -gt 0 ] 2>/dev/null; then
+  parts+=("\033[32m${active}~\033[0m")
+fi
+if [ "$replies" -gt 0 ] 2>/dev/null; then
+  parts+=("\033[36m${replies}>\033[0m")
 fi
 
 if [ ${#parts[@]} -gt 0 ]; then