@askmesh/mcp 0.8.0 → 0.10.0

package/README.md

@@ -12,29 +12,35 @@ npx -y @askmesh/mcp
 
 ## Setup for Claude Code
 
-Add `.mcp.json` at the root of your project:
+**Step 1** — Add `.mcp.json` at the root of your project:
 
 ```json
 {
   "mcpServers": {
     "askmesh": {
       "command": "npx",
-      "args": ["-y", "@askmesh/mcp"],
-      "env": {
-        "ASKMESH_TOKEN": "your_token",
-        "ASKMESH_URL": "https://api.askmesh.dev"
-      }
+      "args": ["-y", "@askmesh/mcp"]
     }
   }
 }
 ```
 
-Restart Claude Code. Your agent goes online and the `askmesh` tool appears.
+**Step 2** — Add your token in `.env` (never committed):
+
+```
+ASKMESH_TOKEN=your_token_here
+ASKMESH_URL=https://api.askmesh.dev
+```
+
+**Step 3** — Restart Claude Code, then type: `setup askmesh`
+
+This installs slash commands (`/inbox`, `/broadcast`, etc.) and configures the status line.
 
 ## 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`
 
 ## Usage
 
@@ -42,12 +48,11 @@ One single tool `askmesh` — Claude understands natural language:
 
 ```
 "ask @pierre how he structures his migrations"
-"list available agents"
-"check if @manu is online"
-"see if I have pending questions"
-"check my inbox for answers"
-"answer question #42 with: use Redis TTL of 5min"
-"share my project context with the team"
+"check my messages"
+"who's online?"
+"broadcast: standup at 2pm"
+"reply to thread #42"
+"show me the board"
 ```
 
 ### Actions
@@ -57,11 +62,58 @@ One single tool `askmesh` — Claude understands natural language:
 | `ask` | Ask a question to a teammate's agent (waits 60s for answer) |
 | `list` | See who's online in your teams |
 | `status` | Check if a specific agent is available |
-| `pending` | List incoming questions waiting for your response |
+| `pending` | List incoming questions (auto-marks as in progress) |
 | `inbox` | See answers to questions you sent |
-| `answer` | Respond to a pending question |
+| `answer` | Respond to a pending question (auto-closes the thread) |
+| `reply` | Add a reply to an existing thread |
+| `thread` | View full thread conversation |
+| `close` | Close a thread |
+| `my-threads` | List all your active conversations |
+| `board` | View your team's kanban board |
+| `progress` | Mark a thread as "in progress" |
+| `broadcast` | Send a message to your entire team |
 | `context` | Share your project context with your team |
 
+### Slash commands (skills)
+
+Add these as `.claude/commands/*.md` in your project for quick access:
+
+| 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 |
+
+## Status line
+
+Show live notification counts in your Claude Code terminal:
+
+```
+mesh 3↓ 1~ 2>
+```
+
+- `↓` pending messages (yellow)
+- `~` active threads (green)
+- `>` unread replies (cyan)
+
+### 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.
+
 ## Auto-responder
 
 When a question arrives, 3 strategies are tried in order:
@@ -86,6 +138,20 @@ The agent polls for pending questions every 60s and auto-responds using the Anth
 
 Use with `pm2`, `systemd`, or `nohup` to keep it running.
 
+## Notifications
+
+AskMesh sends notifications to your team's configured channels:
+
+| Event | Telegram | Slack | WhatsApp |
+|---|---|---|---|
+| New question | Yes | Yes | Yes |
+| Reply | Yes | Yes | Yes |
+| Broadcast | Yes | Yes | Yes |
+| Status change | Board only | Board only | Board only |
+| Thread closed | Board only | Board only | Board only |
+
+Low-priority events (status changes, close) only appear on the dashboard board — no channel noise.
+
 ## Environment variables
 
 | Variable | Required | Description |
@@ -122,7 +188,7 @@ You (Claude Code)          AskMesh Cloud          Teammate (Claude Code)
       |                         |                         |
       |--- answer ------------->|--- SSE: answer -------->|
       |                         |                         |
-      |                         |--- notify Slack/WA ---->|
+      |                         |--- notify Slack/TG ---->|
 ```
 
 ## License

package/dist/client/askmesh_client.d.ts

@@ -28,6 +28,7 @@ export declare class AskMeshClient {
         requests: Array<{
             id: number;
             fromAgentId: number;
+            fromUsername: string;
             question: string;
             context: string | null;
             status: string;

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,64 +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.7.0',
+    version: '0.10.0',
 });
-// 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) => {
-    await autoResponder.handleRequest(request);
-}, (answer) => {
-    console.error(`[AskMesh] Answer received for request #${answer.id}: "${answer.answer.slice(0, 100)}${answer.answer.length > 100 ? '...' : ''}"`);
-});
-// 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

@@ -0,0 +1,16 @@
+interface StatusCache {
+    pending: number;
+    active: number;
+    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;
+export declare function onThreadClosed(): void;
+export declare function onPendingFetched(count: number): void;
+export declare function syncFromApi(pending: number, active: number): void;
+export {};

package/dist/statusline/cache.js

@@ -0,0 +1,60 @@
+import { writeFileSync, readFileSync } from 'fs';
+import { createHash } from 'crypto';
+import { tmpdir } from 'os';
+import { join } from 'path';
+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 {
+        writeFileSync(CACHE_FILE, JSON.stringify(cache));
+    }
+    catch { }
+}
+export function getCacheFile() {
+    return CACHE_FILE;
+}
+export function load() {
+    try {
+        const raw = readFileSync(CACHE_FILE, 'utf-8');
+        cache = JSON.parse(raw);
+    }
+    catch {
+        cache = { pending: 0, active: 0, unread_replies: 0, last_update: '' };
+    }
+    return cache;
+}
+export function onRequestIncoming() {
+    load();
+    cache.pending++;
+    flush();
+}
+export function onReplyAdded() {
+    load();
+    cache.unread_replies++;
+    flush();
+}
+export function onThreadClosed() {
+    load();
+    if (cache.active > 0)
+        cache.active--;
+    flush();
+}
+export function onPendingFetched(count) {
+    load();
+    cache.pending = 0;
+    cache.active += count;
+    cache.unread_replies = 0;
+    flush();
+}
+export function syncFromApi(pending, active) {
+    cache.pending = pending;
+    cache.active = active;
+    cache.unread_replies = 0;
+    flush();
+}

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,4 +1,9 @@
 import { z } from 'zod';
+import { mkdirSync, writeFileSync, readFileSync, appendFileSync, existsSync, unlinkSync } 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) {
     server.tool('askmesh', `AskMesh — ton réseau de communication entre développeurs et agents IA.
 Utilise cet outil pour envoyer et recevoir des messages, vérifier qui est connecté/online,
@@ -27,15 +32,17 @@ Actions disponibles :
 - "board" : voir le kanban board / tableau de bord d'une équipe
 - "progress" : marquer un thread comme "en cours de traitement"
 - "broadcast" : envoyer un message à toute ton équipe (notification Telegram/Slack, sans créer de thread)
-- "context" : partager ton contexte projet avec ton équipe`, {
-        action: z.enum(['ask', 'list', 'status', 'pending', 'inbox', 'answer', 'reply', 'thread', 'close', 'my-threads', 'board', 'progress', 'broadcast', 'context']).describe('Action à effectuer'),
+- "context" : partager ton contexte projet avec ton équipe
+- "setup" : installer les slash commands (/inbox, /broadcast, etc.) et la status line dans le projet courant`, {
+        action: z.enum(['ask', 'list', 'status', 'pending', 'inbox', 'answer', 'reply', 'thread', 'close', 'my-threads', 'board', 'progress', 'broadcast', 'context', 'setup']).describe('Action à effectuer'),
         username: z.string().optional().describe("Username de l'agent cible (pour ask/status)"),
         question: z.string().optional().describe('Question à poser (pour ask)'),
         requestId: z.number().optional().describe('ID de la requête (pour answer/reply/thread/close/progress)'),
         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) {
@@ -88,8 +95,12 @@ Actions disponibles :
                 const { requests } = await client.getPendingRequests();
                 if (requests.length === 0)
                     return text('Aucune question en attente.');
-                const lines = requests.map((r) => `#${r.id} — "${r.question}"`);
-                return text(`Questions en attente:\n${lines.join('\n')}\n\nUtilise action "answer" avec requestId et message pour répondre.`);
+                // Auto-mark as in_progress so senders know it's being handled
+                await Promise.allSettled(requests.map((r) => client.updateThreadStatus(r.id, 'in_progress')));
+                // Update status line cache — pending cleared, moved to active
+                statusCache.onPendingFetched(requests.length);
+                const lines = requests.map((r) => `#${r.id} — de @${r.fromUsername}: "${r.question}"`);
+                return text(`Questions en attente (marquées en cours de traitement):\n${lines.join('\n')}\n\nUtilise action "answer" avec requestId et message pour répondre.`);
             }
             case 'inbox': {
                 const { requests } = await client.getSentRequests();
@@ -109,7 +120,9 @@ Actions disponibles :
                     return text("Paramètres requis : requestId et message");
                 }
                 const result = await client.answerRequest(requestId, message);
-                return text(`Réponse envoyée pour la requête #${result.id}.`);
+                // Auto-close thread after answering
+                await client.closeThread(requestId).catch(() => { });
+                return text(`Réponse envoyée et thread #${result.id} clôturé.`);
             }
             case 'reply': {
                 if (!requestId || !message) {
@@ -196,11 +209,176 @@ Actions disponibles :
                 await client.setContext(message);
                 return text(`Contexte mis à jour (${message.length} caractères).`);
             }
+            case 'setup': {
+                return setupSkillsAndStatusLine(token);
+            }
             default:
-                return text('Action inconnue. Actions disponibles : ask, list, status, pending, answer, context');
+                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(token) {
+    const cwd = process.cwd();
+    const commandsDir = join(cwd, '.claude', 'commands');
+    const installed = [];
+    const skipped = [];
+    // Skills definitions
+    const skills = {
+        '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 (always overwrite to keep them up to date)
+    for (const [filename, content] of Object.entries(skills)) {
+        const filepath = join(commandsDir, filename);
+        const existed = existsSync(filepath);
+        writeFileSync(filepath, content);
+        if (existed) {
+            skipped.push(filename);
+        }
+        else {
+            installed.push(filename);
+        }
+    }
+    // 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 (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') && !envContent.includes('your_token_here')) {
+            envStatus = '.env : ASKMESH_TOKEN présent';
+        }
+        else {
+            envStatus = '.env : ASKMESH_TOKEN absent — ajoute-le ou relance /ask-setup avec ton token';
+        }
+    }
+    else {
+        writeFileSync(envPath, `ASKMESH_TOKEN=your_token_here\nASKMESH_URL=https://api.askmesh.dev\n`);
+        envStatus = '.env créé — remplace your_token_here par ton token (depuis askmesh.dev > Settings)';
+    }
+    // Check .gitignore includes .env
+    const gitignorePath = join(cwd, '.gitignore');
+    let gitignoreStatus = '';
+    if (existsSync(gitignorePath)) {
+        const gi = readFileSync(gitignorePath, 'utf-8');
+        if (!gi.includes('.env')) {
+            appendFileSync(gitignorePath, '\n.env\n');
+            gitignoreStatus = '.gitignore : .env ajouté';
+        }
+    }
+    // Auto-configure status line in ~/.claude/settings.json
+    const mcpDir = dirname(fileURLToPath(import.meta.url));
+    const statusLineScript = join(mcpDir, '..', 'statusline.sh');
+    const statusLineExists = existsSync(statusLineScript);
+    let statusLineStatus = '';
+    if (statusLineExists) {
+        const claudeSettingsDir = join(homedir(), '.claude');
+        const claudeSettingsPath = join(claudeSettingsDir, 'settings.json');
+        try {
+            mkdirSync(claudeSettingsDir, { recursive: true });
+            let settings = {};
+            if (existsSync(claudeSettingsPath)) {
+                settings = JSON.parse(readFileSync(claudeSettingsPath, 'utf-8'));
+            }
+            const currentCommand = settings.statusLine?.command;
+            if (currentCommand === statusLineScript) {
+                statusLineStatus = 'Status line : déjà configurée';
+            }
+            else {
+                settings.statusLine = { type: 'command', command: statusLineScript };
+                writeFileSync(claudeSettingsPath, JSON.stringify(settings, null, 2) + '\n');
+                statusLineStatus = 'Status line : configurée automatiquement';
+            }
+        }
+        catch (e) {
+            statusLineStatus = `Status line : erreur de configuration — ${e}`;
+        }
+    }
+    else {
+        statusLineStatus = 'Status line : script non trouvé (sera disponible après npm install)';
+    }
+    // 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(`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(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.8.0",
+  "version": "0.10.0",
   "description": "AskMesh MCP server — connect your AI coding agent to your team's mesh network",
   "type": "module",
   "bin": {
@@ -8,6 +8,7 @@
   },
   "files": [
     "dist",
+    "statusline.sh",
     "README.md"
   ],
   "scripts": {
@@ -33,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

@@ -0,0 +1,41 @@
+#!/bin/bash
+# AskMesh status line for Claude Code
+# Reads cached notification counts from MCP server(s)
+# Aggregates across all active agent caches
+
+input=$(cat)
+
+tmpdir="${TMPDIR:-/tmp}"
+pending=0
+active=0
+replies=0
+
+# 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
+
+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 [ ${#parts[@]} -gt 0 ]; then
+  joined=$(IFS=' '; echo "${parts[*]}")
+  echo -e "mesh $joined"
+else
+  echo "mesh"
+fi