overmind-mcp 2.2.4 → 2.3.0

package/dist/tools/stream_agent_output.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const streamAgentOutputSchema: z.ZodObject<{
+    agentName: z.ZodString;
+    runner: z.ZodOptional<z.ZodEnum<{
+        claude: "claude";
+        gemini: "gemini";
+        kilo: "kilo";
+        qwencli: "qwencli";
+        hermes: "hermes";
+        openclaw: "openclaw";
+        cline: "cline";
+        opencode: "opencode";
+    }>>;
+    sinceTimestamp: z.ZodOptional<z.ZodNumber>;
+    config: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function streamAgentOutputTool(args: z.infer<typeof streamAgentOutputSchema>): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError?: undefined;
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: boolean;
+}>;
+//# sourceMappingURL=stream_agent_output.d.ts.map

package/dist/tools/stream_agent_output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream_agent_output.d.ts","sourceRoot":"","sources":["../../src/tools/stream_agent_output.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;iBAWlC,CAAC;AAEH,wBAAsB,qBAAqB,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC;;;;;;;;;;;;GAiCxF"}

package/dist/tools/stream_agent_output.js

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import { getProcessStatus } from '../lib/processRegistry.js';
+export const streamAgentOutputSchema = z.object({
+    agentName: z.string().describe('Nom de l agent'),
+    runner: z
+        .enum(['claude', 'gemini', 'kilo', 'qwencli', 'openclaw', 'cline', 'opencode', 'hermes'])
+        .optional()
+        .describe('Type de runner (optionnel, défaut: any)'),
+    sinceTimestamp: z
+        .number()
+        .optional()
+        .describe('Ne retourner que la sortie après ce timestamp (ms)'),
+    config: z.string().optional().describe('Chemin du fichier de configuration'),
+});
+export async function streamAgentOutputTool(args) {
+    const { agentName, runner, sinceTimestamp, config: configPath } = args;
+    const entry = await getProcessStatus(agentName, runner, configPath);
+    if (!entry) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Agent "${agentName}" non trouvé dans le registre.`,
+                },
+            ],
+        };
+    }
+    const isComplete = entry.status === 'done' || entry.status === 'failed' || entry.status === 'orphaned';
+    const output = entry.outputBuffer || '';
+    if (sinceTimestamp && entry.lastOutputAt && entry.lastOutputAt > sinceTimestamp) {
+        // For now, return all output if there was output after the timestamp
+        // (per-chunk timestamps not yet implemented)
+    }
+    return {
+        content: [
+            {
+                type: 'text',
+                text: output || '(no output yet)',
+            },
+        ],
+        isError: isComplete && entry.status === 'failed',
+    };
+}
+//# sourceMappingURL=stream_agent_output.js.map

package/dist/tools/stream_agent_output.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream_agent_output.js","sourceRoot":"","sources":["../../src/tools/stream_agent_output.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAE7D,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC9C,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,gBAAgB,CAAC;IAChD,MAAM,EAAE,CAAC;SACN,IAAI,CAAC,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC;SACxF,QAAQ,EAAE;SACV,QAAQ,CAAC,yCAAyC,CAAC;IACtD,cAAc,EAAE,CAAC;SACd,MAAM,EAAE;SACR,QAAQ,EAAE;SACV,QAAQ,CAAC,oDAAoD,CAAC;IACjE,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,oCAAoC,CAAC;CAC7E,CAAC,CAAC;AAEH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CAAC,IAA6C;IACvF,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC;IAEvE,MAAM,KAAK,GAAG,MAAM,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC;IAEpE,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,OAAO;YACL,OAAO,EAAE;gBACP;oBACE,IAAI,EAAE,MAAe;oBACrB,IAAI,EAAE,UAAU,SAAS,gCAAgC;iBAC1D;aACF;SACF,CAAC;IACJ,CAAC;IAED,MAAM,UAAU,GAAG,KAAK,CAAC,MAAM,KAAK,MAAM,IAAI,KAAK,CAAC,MAAM,KAAK,QAAQ,IAAI,KAAK,CAAC,MAAM,KAAK,UAAU,CAAC;IACvG,MAAM,MAAM,GAAG,KAAK,CAAC,YAAY,IAAI,EAAE,CAAC;IAExC,IAAI,cAAc,IAAI,KAAK,CAAC,YAAY,IAAI,KAAK,CAAC,YAAY,GAAG,cAAc,EAAE,CAAC;QAChF,qEAAqE;QACrE,6CAA6C;IAC/C,CAAC;IAED,OAAO;QACL,OAAO,EAAE;YACP;gBACE,IAAI,EAAE,MAAe;gBACrB,IAAI,EAAE,MAAM,IAAI,iBAAiB;aAClC;SACF;QACD,OAAO,EAAE,UAAU,IAAI,KAAK,CAAC,MAAM,KAAK,QAAQ;KACjD,CAAC;AACJ,CAAC"}

package/dist/tools/wait_agent.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const waitAgentSchema: z.ZodObject<{
+    agentName: z.ZodString;
+    runner: z.ZodOptional<z.ZodEnum<{
+        claude: "claude";
+        gemini: "gemini";
+        kilo: "kilo";
+        qwencli: "qwencli";
+        hermes: "hermes";
+        openclaw: "openclaw";
+        cline: "cline";
+        opencode: "opencode";
+    }>>;
+    timeoutMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    config: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function waitAgentTool(args: z.infer<typeof waitAgentSchema>): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: boolean;
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError?: undefined;
+}>;
+//# sourceMappingURL=wait_agent.d.ts.map

package/dist/tools/wait_agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait_agent.d.ts","sourceRoot":"","sources":["../../src/tools/wait_agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;iBAY1B,CAAC;AAEH,wBAAsB,aAAa,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC;;;;;;;;;;;;GA0DxE"}

package/dist/tools/wait_agent.js

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+import { getProcessStatus } from '../lib/processRegistry.js';
+export const waitAgentSchema = z.object({
+    agentName: z.string().describe('Nom de l agent'),
+    runner: z
+        .enum(['claude', 'gemini', 'kilo', 'qwencli', 'openclaw', 'cline', 'opencode', 'hermes'])
+        .optional()
+        .describe('Type de runner (optionnel, défaut: any)'),
+    timeoutMs: z
+        .number()
+        .optional()
+        .default(900000)
+        .describe('Timeout en ms (défaut: 900000 = 15 min)'),
+    config: z.string().optional().describe('Chemin du fichier de configuration'),
+});
+export async function waitAgentTool(args) {
+    const { agentName, runner, timeoutMs, config: configPath } = args;
+    const start = Date.now();
+    const pollInterval = 1000; // 1 second
+    while (Date.now() - start < timeoutMs) {
+        const entry = await getProcessStatus(agentName, runner, configPath);
+        if (!entry) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Agent "${agentName}" n existe plus dans le registre.`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        if (entry.status === 'done') {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: entry.outputBuffer || 'Agent terminé avec succès.',
+                    },
+                ],
+            };
+        }
+        if (entry.status === 'failed' || entry.status === 'orphaned') {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Agent terminé avec erreur: ${entry.status}\n\nSortie:\n${entry.outputBuffer || 'N/A'}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Still running — wait before next poll
+        await new Promise((r) => setTimeout(r, pollInterval));
+    }
+    // Timeout reached
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Timeout de ${timeoutMs}ms atteint. L'agent est toujours en cours d exécution.`,
+            },
+        ],
+        isError: true,
+    };
+}
+//# sourceMappingURL=wait_agent.js.map

package/dist/tools/wait_agent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait_agent.js","sourceRoot":"","sources":["../../src/tools/wait_agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAE7D,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC;IACtC,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,gBAAgB,CAAC;IAChD,MAAM,EAAE,CAAC;SACN,IAAI,CAAC,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC;SACxF,QAAQ,EAAE;SACV,QAAQ,CAAC,yCAAyC,CAAC;IACtD,SAAS,EAAE,CAAC;SACT,MAAM,EAAE;SACR,QAAQ,EAAE;SACV,OAAO,CAAC,MAAM,CAAC;SACf,QAAQ,CAAC,yCAAyC,CAAC;IACtD,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,oCAAoC,CAAC;CAC7E,CAAC,CAAC;AAEH,MAAM,CAAC,KAAK,UAAU,aAAa,CAAC,IAAqC;IACvE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC;IAElE,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IACzB,MAAM,YAAY,GAAG,IAAI,CAAC,CAAC,WAAW;IAEtC,OAAO,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,GAAG,SAAS,EAAE,CAAC;QACtC,MAAM,KAAK,GAAG,MAAM,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC;QAEpE,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO;gBACL,OAAO,EAAE;oBACP;wBACE,IAAI,EAAE,MAAe;wBACrB,IAAI,EAAE,UAAU,SAAS,mCAAmC;qBAC7D;iBACF;gBACD,OAAO,EAAE,IAAI;aACd,CAAC;QACJ,CAAC;QAED,IAAI,KAAK,CAAC,MAAM,KAAK,MAAM,EAAE,CAAC;YAC5B,OAAO;gBACL,OAAO,EAAE;oBACP;wBACE,IAAI,EAAE,MAAe;wBACrB,IAAI,EAAE,KAAK,CAAC,YAAY,IAAI,4BAA4B;qBACzD;iBACF;aACF,CAAC;QACJ,CAAC;QAED,IAAI,KAAK,CAAC,MAAM,KAAK,QAAQ,IAAI,KAAK,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;YAC7D,OAAO;gBACL,OAAO,EAAE;oBACP;wBACE,IAAI,EAAE,MAAe;wBACrB,IAAI,EAAE,8BAA8B,KAAK,CAAC,MAAM,gBAAgB,KAAK,CAAC,YAAY,IAAI,KAAK,EAAE;qBAC9F;iBACF;gBACD,OAAO,EAAE,IAAI;aACd,CAAC;QACJ,CAAC;QAED,wCAAwC;QACxC,MAAM,IAAI,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC;IACxD,CAAC;IAED,kBAAkB;IAClB,OAAO;QACL,OAAO,EAAE;YACP;gBACE,IAAI,EAAE,MAAe;gBACrB,IAAI,EAAE,cAAc,SAAS,wDAAwD;aACtF;SACF;QACD,OAAO,EAAE,IAAI;KACd,CAAC;AACJ,CAAC"}

package/docs/ASYNC_AGENT_INTEGRATION.md

@@ -0,0 +1,311 @@
+# OverMind Async Agent Integration — Process Registry & PID Tracking
+
+> **Problème résolu** : Les agents IA sont invoked en async via MCP, mais le seul lien avec le processus fils est le `sessionId` (généré par le runner, opaque pour OverMind). Si le processus parent meurt, le `sessionId` est perdu et le child process devient orphelin.
+>
+> **Solution** : Un **Process Registry** qui stocke le mapping `pid ↔ sessionId ↔ agentName`, persistant dans `sessions.json`, permettant de :
+> - Se rattacher à un agent en cours via son PID
+> - Vérifier si un agent est encore vivant
+> - Tuer un agent par son PID
+> - Streamer output en temps réel
+
+---
+
+## 1. Architecture
+
+```
+┌──────────────────────────────────────────────────────────────┐
+│  MCP Tool: run_agent() (async, non-blocking)                  │
+│                                                              │
+│  1. Spawn child process (claude/kilo/gemini/etc.)           │
+│  2. Register { pid, sessionId, agentName, runner, ts }     │
+│  3. Return immediately with { sessionId, pid }             │
+│     → Client can poll / attach to PID                       │
+│                                                              │
+│  ┌──────────────────┐    ┌──────────────────────────────┐  │
+│  │  Process Registry │◄──│  child.on('data')             │  │
+│  │  (sessions.json)  │    │  → buffers output            │  │
+│  │                   │    │  → checks liveliness         │  │
+│  │  { pid, sessionId,│    └──────────────────────────────┘  │
+│  │    agentName,     │                                     │
+│  │    runner, status,│    ┌──────────────────────────────┐  │
+│  │    startedAt }    │    │  MCP Tool: get_agent_status() │  │
+│  └──────────────────┘    │  → returns live output        │  │
+│                          │  → pid / alive / output so far │  │
+│                          └──────────────────────────────┘  │
+└──────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 2. Sessions JSON — Nouveau Format
+
+**Avant** (sessions.json) :
+```json
+{
+  "kilo:sniper_analyst": { "id": "sess_abc123", "ts": 1746892800000 }
+}
+```
+
+**Après** (sessions.json + process registry) :
+```json
+{
+  "kilo:sniper_analyst": {
+    "id": "sess_abc123",
+    "ts": 1746892800000,
+    "pid": 12345,
+    "status": "running",
+    "outputBuffer": ""
+  },
+  "claude:planner": {
+    "id": "sess_def456",
+    "ts": 1746892900000,
+    "pid": 67890,
+    "status": "running",
+    "outputBuffer": "Thinking...\n"
+  }
+}
+```
+
+Le champ `status` peut être :
+- `running` — processus actif, PID valide
+- `done` — terminé avec succès (garde le last output pour retrieval)
+- `failed` — terminé avec erreur
+- `orphaned` — le parent a crash mais le child tourne encore
+
+---
+
+## 3. Runner Changes — Spawn & Register
+
+Chaque runner (Claude, Kilo, Gemini, Hermes, etc.) doit :
+
+1. **Stocker le PID** dès le `spawn()` :
+```typescript
+const child = spawn(command, args, options);
+// Immediately register
+await registerProcess(child.pid, {
+  sessionId: undefined,      // filled when runner gives us sessionId
+  agentName,
+  runner,
+  startedAt: Date.now(),
+  status: 'running',
+});
+```
+
+2. **Mettre à jour avec le sessionId** dès qu'il est reçu :
+```typescript
+child.stdout?.on('data', (d) => {
+  const chunk = d.toString();
+  outputBuffer += chunk;
+  // Si le sessionId arrive pour la première fois
+  if (sessionId && !currentSessionId) {
+    currentSessionId = sessionId;
+    await updateProcessSession(sessionId, child.pid);
+  }
+});
+```
+
+3. **Marquer `done/failed`** à `child.on('close')` :
+```typescript
+child.on('close', async (code) => {
+  await updateProcessStatus(child.pid, code === 0 ? 'done' : 'failed');
+});
+```
+
+4. **Cleanup à la terminaison** :
+```typescript
+// Supprimer après 1h ( TTL ) ou sur explicit delete
+await unregisterProcess(pid);
+```
+
+---
+
+## 4. Nouvelles Fonctions Registry
+
+```typescript
+// ─── Register a new running process ───────────────────────────
+/**
+ * Called immediately after spawn(). Records the PID before the sessionId
+ * is known (sessionId arrives later from stdout).
+ */
+export async function registerProcess(
+  pid: number,
+  meta: {
+    agentName: string;
+    runner: string;
+    startedAt: number;
+    configPath?: string;
+  },
+): Promise<void> { ... }
+
+/**
+ * Called when the runner emits a sessionId for the first time.
+ * Links sessionId ↔ pid in the registry.
+ */
+export async function linkSessionToPid(
+  sessionId: string,
+  pid: number,
+  configPath?: string,
+): Promise<void> { ... }
+
+/**
+ * Update output buffer for live streaming.
+ */
+export async function appendOutput(
+  pid: number,
+  chunk: string,
+  configPath?: string,
+): Promise<void> { ... }
+
+/**
+ * Get current status + output buffer for a process.
+ */
+export async function getProcessStatus(
+  agentName: string,
+  runner?: string,
+  configPath?: string,
+): Promise<ProcessStatus | null> { ... }
+
+/**
+ * Kill a running agent by PID (Windows: taskkill /F /T /PID; Unix: SIGKILL).
+ */
+export async function killAgent(
+  agentName: string,
+  runner?: string,
+  configPath?: string,
+): Promise<boolean> { ... }
+
+/**
+ * Unregister (cleanup) a process entry.
+ */
+export async function unregisterProcess(
+  pid: number,
+  configPath?: string,
+): Promise<void> { ... }
+```
+
+---
+
+## 5. TTL & Cleanup
+
+```typescript
+const PROCESS_TTL_MS = 60 * 60 * 1000; // 1 hour after 'done'/'failed'
+const ORPHAN_CHECK_INTERVAL = 5 * 60 * 1000; // 5 minutes
+
+// On startup, scan for:
+// 1. 'running' entries where the PID no longer exists → mark 'orphaned'
+// 2. 'done'/'failed' entries older than PROCESS_TTL_MS → unregister
+```
+
+---
+
+## 6. Nouveaux Outils MCP
+
+### `get_agent_status`
+```typescript
+{
+  agentName: string;
+  runner?: string; // defaults to 'claude' if omitted
+}
+// Returns:
+// { status, pid, outputBuffer, startedAt, sessionId }
+```
+
+### `stream_agent_output`
+```typescript
+{
+  agentName: string;
+  runner?: string;
+  sinceTimestamp?: number; // only return output after this ts
+}
+// Returns:
+// { output: string, status, isComplete: boolean }
+```
+
+### `kill_agent`
+```typescript
+{
+  agentName: string;
+  runner?: string;
+}
+// Returns:
+// { killed: boolean, pid: number }
+```
+
+### `wait_agent`
+```typescript
+{
+  agentName: string;
+  runner?: string;
+  timeoutMs?: number; // default: 900000 (15 min)
+}
+// Polls until status !== 'running', returns final result
+// Returns:
+// { status, result, exitCode }
+```
+
+---
+
+## 7. Flux Complet — Async Agent Lifecycle
+
+```
+Client                    OverMind MCP                   Runner
+  │                           │                            │
+  │  run_agent()              │                            │
+  │─────────────────────────►│                            │
+  │                           │  spawn(child)               │
+  │                           │───────────────────────────►│
+  │                           │  registerProcess(pid)      │
+  │                           │  Return { sessionId, pid } │
+  │  { sessionId, pid }       │                            │
+  │◄──────────────────────────│                            │
+  │                           │                            │
+  │  get_agent_status()        │                            │
+  │─────────────────────────►│                            │
+  │                           │  getProcessStatus()        │
+  │  { status, outputBuffer }│                            │
+  │◄──────────────────────────│                            │
+  │                           │  stdout.on('data')         │
+  │                           │◄──────────────────────────│
+  │                           │  appendOutput(pid, chunk) │
+  │                           │                            │
+  │  stream_agent_output()    │                            │
+  │─────────────────────────►│                            │
+  │  { output, status }       │                            │
+  │◄──────────────────────────│                            │
+  │                           │  child.on('close')        │
+  │                           │◄──────────────────────────│
+  │                           │  updateProcessStatus(done) │
+  │                           │                            │
+  │  wait_agent()              │                            │
+  │─────────────────────────►│                            │
+  │  Polls until done          │                            │
+  │  { status, result }       │                            │
+  │◄──────────────────────────│                            │
+```
+
+---
+
+## 8. Backward Compatibility
+
+- Les champs existants (`id`, `ts`) dans `sessions.json` ne changent pas
+- `status`, `pid`, `outputBuffer` sont **ajoutés** (optionnels)
+- Le `sessionId` reste le même — les outils existants (`autoResume`) continuent de fonctionner
+- Si `pid` n'existe pas dans une entrée (sessions anciennes), le status est déduit de `ts` :
+  - `ts` < 30 jours + pas de `pid` → `done` (legacy)
+  - `ts` récent + pas de `pid` → `running` (legacy, mais incertain)
+
+---
+
+## 9. Implémentation Minimale — Checklist
+
+- [ ] `src/lib/processRegistry.ts` — nouvelles fonctions (register, link, append, status, kill, unregister)
+- [ ] `src/lib/sessions.ts` — ajout champs `pid`, `status`, `outputBuffer`
+- [ ] Chaque runner (8 fichiers) — ajouter `registerProcess()` après `spawn()`
+- [ ] Chaque runner — ajouter `appendOutput()` dans `stdout.on('data')`
+- [ ] Chaque runner — ajouter `updateProcessStatus()` dans `child.on('close')`
+- [ ] `src/tools/get_agent_status.ts` — nouvel outil MCP
+- [ ] `src/tools/stream_agent_output.ts` — nouvel outil MCP
+- [ ] `src/tools/kill_agent.ts` — nouvel outil MCP
+- [ ] `src/tools/wait_agent.ts` — nouvel outil MCP
+- [ ] `server.ts` — register les 4 nouveaux outils
+- [ ] Tests dans `src/__tests__/processRegistry.test.ts`