@dalmasonto/taskflow-mcp 1.0.32 → 1.0.35

package/dist/agent-registry.d.ts

@@ -18,7 +18,8 @@ export declare function registerAgent(options?: {
 }): string;
 /** Mark an agent as disconnected */
 export declare function unregisterAgent(name: string): void;
-/** Check all registered agents and mark dead ones as disconnected */
+/** Check all registered agents and mark dead ones as disconnected.
+ *  Also purges entries that have been disconnected for more than 24 hours. */
 export declare function checkAgentLiveness(): void;
 /** Get a registered agent by name */
 export declare function getAgent(name: string): AgentRow | undefined;

package/dist/agent-registry.js

@@ -129,15 +129,20 @@ export function unregisterAgent(name) {
     broadcast('agent_disconnected', { entity: 'agent', action: 'agent_disconnected', payload: row });
     logActivity('agent_disconnected', `Agent "${name}" disconnected`, { entityType: 'agent' });
 }
-/** Check all registered agents and mark dead ones as disconnected */
+/** Check all registered agents and mark dead ones as disconnected.
+ *  Also purges entries that have been disconnected for more than 24 hours. */
 export function checkAgentLiveness() {
     const db = getDb();
+    // Mark dead connected agents as disconnected
     const liveAgents = db.prepare("SELECT * FROM agent_registry WHERE status = 'connected'").all();
     for (const agent of liveAgents) {
         if (!isAlive(agent.pid)) {
             unregisterAgent(agent.name);
         }
     }
+    // Purge entries that have been disconnected for more than 24 hours
+    const cutoff = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString();
+    db.prepare("DELETE FROM agent_registry WHERE status = 'disconnected' AND disconnected_at IS NOT NULL AND disconnected_at < ?").run(cutoff);
 }
 /** Get a registered agent by name */
 export function getAgent(name) {

package/dist/index.js

@@ -70,6 +70,33 @@ if (!httpOnly) {
             'Use log_debug to document your work — it is shared memory visible to the user and other agents.',
         ].join('\n'),
     });
+    // Filled in after agent registration — used by the inbox drain below
+    let agentNameGetter = () => 'unknown';
+    // Drain any undelivered inbox messages for this agent and prepend them to a
+    // tool result. This is the non-tmux delivery path: since we can't inject into
+    // stdin, we piggyback pending messages onto the next tool response so Claude
+    // sees them in its context without any terminal tricks.
+    function drainInboxNotice() {
+        try {
+            const name = agentNameGetter();
+            if (name === 'unknown')
+                return '';
+            const db = getDb();
+            const pending = db.prepare(`SELECT id, sender_name, question FROM agent_messages
+         WHERE recipient_name = ? AND status = 'pending' AND delivered IS NULL
+         ORDER BY created_at ASC`).all(name);
+            if (pending.length === 0)
+                return '';
+            for (const msg of pending) {
+                db.prepare('UPDATE agent_messages SET delivered = 1 WHERE id = ?').run(msg.id);
+            }
+            const lines = pending.map(m => `  [Inbox #${m.id} from ${m.sender_name}]: ${m.question}`).join('\n');
+            return `\n⚠️ INBOX MESSAGE(S) — respond before continuing:\n${lines}\n`;
+        }
+        catch {
+            return '';
+        }
+    }
     // Wrap server.tool() to track execution time and log failures
     const originalTool = server.tool.bind(server);
     server.tool = function (...args) {
@@ -114,6 +141,13 @@ if (!httpOnly) {
                         broadcast('tool_executed', { entity: 'tool', action: 'tool_executed', payload: { tool_name: toolName, duration_ms: duration, success: true, created_at: ts } });
                     }
                     catch { /* don't break tool execution */ }
+                    // Non-tmux inbox delivery: prepend any pending messages to the result
+                    const notice = drainInboxNotice();
+                    if (notice && result?.content) {
+                        const first = result.content.find((c) => c.type === 'text');
+                        if (first)
+                            first.text = notice + first.text;
+                    }
                     return result;
                 }
                 catch (err) {
@@ -150,6 +184,7 @@ if (!httpOnly) {
     // Auto-register this agent and sync name to agent-inbox tools
     const agentName = registerAgent();
     setAgentName(agentName);
+    agentNameGetter = getAgentName; // wire up inbox drain now that we have a name
     const agentPid = process.ppid;
     console.error(`[agent] registered as "${agentName}"`);
     let cleanup = () => { try {
@@ -175,13 +210,18 @@ if (!httpOnly) {
     catch {
         console.error('[bridge] tmux not available');
     }
-    if (tmuxTarget) {
+    // Always start the bridge — tmuxPane may be null for non-tmux sessions,
+    // in which case messages are delivered via stderr instead of tmux injection.
+    {
         const { startTmuxBridge } = await import('./tmux-bridge.js');
         const stopBridge = startTmuxBridge({
             getAgentName,
             agentPid,
             tmuxPane: tmuxTarget,
         });
+        if (!tmuxTarget) {
+            console.error('[bridge] agent not in tmux — using stderr delivery for inbox messages');
+        }
         const originalCleanup = cleanup;
         cleanup = () => { stopBridge(); originalCleanup(); };
         process.removeListener('SIGINT', originalCleanup);
@@ -189,7 +229,4 @@ if (!httpOnly) {
         process.on('SIGINT', cleanup);
         process.on('SIGTERM', cleanup);
     }
-    else {
-        console.error('[bridge] agent not in tmux — bridge disabled');
-    }
 }

package/dist/retry.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Retry policy engine for TaskFlow.
+ * Provides exponential backoff with jitter for network/external calls.
+ */
+export interface RetryPolicy {
+    maxRetries: number;
+    initialBackoffMs: number;
+    maxBackoffMs: number;
+}
+export declare const DEFAULT_RETRY_POLICY: RetryPolicy;
+/** Thrown when an HTTP response has a retryable status code */
+export declare class RetryableHttpError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+/** Thrown when all retry attempts are exhausted */
+export declare class RetriesExhaustedError extends Error {
+    readonly attempts: number;
+    readonly lastError: unknown;
+    constructor(attempts: number, lastError: unknown);
+}
+/**
+ * Execute `fn` with automatic retry on transient errors.
+ *
+ * @param label  Short description for activity log entries (e.g. "relay push")
+ * @param fn     Async function to execute. Should throw RetryableHttpError for bad HTTP responses.
+ * @param policy Retry configuration (defaults to DEFAULT_RETRY_POLICY)
+ */
+export declare function withRetry<T>(label: string, fn: () => Promise<T>, policy?: RetryPolicy): Promise<T>;
+/**
+ * Wrapper around fetch() that throws RetryableHttpError for transient HTTP failures.
+ * Drop-in for fetch() calls that should participate in retry logic.
+ */
+export declare function fetchWithRetry(label: string, url: string, options?: RequestInit, policy?: RetryPolicy): Promise<Response>;

package/dist/retry.js

@@ -0,0 +1,94 @@
+/**
+ * Retry policy engine for TaskFlow.
+ * Provides exponential backoff with jitter for network/external calls.
+ */
+import { logActivity } from './helpers.js';
+export const DEFAULT_RETRY_POLICY = {
+    maxRetries: 2,
+    initialBackoffMs: 200,
+    maxBackoffMs: 2000,
+};
+/** HTTP status codes considered transient and safe to retry */
+const RETRYABLE_STATUS_CODES = new Set([408, 429, 500, 502, 503, 504]);
+/** Classify whether an error is worth retrying */
+function isRetryable(err) {
+    if (err instanceof RetriesExhaustedError)
+        return false;
+    if (err instanceof TypeError)
+        return true; // network failure, DNS, ECONNREFUSED
+    if (err instanceof RetryableHttpError)
+        return true;
+    return false;
+}
+/** Thrown when an HTTP response has a retryable status code */
+export class RetryableHttpError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = 'RetryableHttpError';
+    }
+}
+/** Thrown when all retry attempts are exhausted */
+export class RetriesExhaustedError extends Error {
+    attempts;
+    lastError;
+    constructor(attempts, lastError) {
+        const cause = lastError instanceof Error ? lastError.message : String(lastError);
+        super(`Retries exhausted after ${attempts} attempt(s): ${cause}`);
+        this.attempts = attempts;
+        this.lastError = lastError;
+        this.name = 'RetriesExhaustedError';
+    }
+}
+/**
+ * Compute the next backoff delay with full jitter.
+ * delay = min(initial * 2^attempt, max) * random(0.5, 1.0)
+ */
+function backoffMs(policy, attempt) {
+    const base = Math.min(policy.initialBackoffMs * Math.pow(2, attempt), policy.maxBackoffMs);
+    return Math.floor(base * (0.5 + Math.random() * 0.5));
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Execute `fn` with automatic retry on transient errors.
+ *
+ * @param label  Short description for activity log entries (e.g. "relay push")
+ * @param fn     Async function to execute. Should throw RetryableHttpError for bad HTTP responses.
+ * @param policy Retry configuration (defaults to DEFAULT_RETRY_POLICY)
+ */
+export async function withRetry(label, fn, policy = DEFAULT_RETRY_POLICY) {
+    let lastError;
+    for (let attempt = 0; attempt <= policy.maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            lastError = err;
+            if (!isRetryable(err) || attempt === policy.maxRetries) {
+                break;
+            }
+            const delay = backoffMs(policy, attempt);
+            logActivity('debug_log', `[retry] ${label} — attempt ${attempt + 1} failed, retrying in ${delay}ms`, {
+                entityType: 'system',
+            });
+            await sleep(delay);
+        }
+    }
+    throw new RetriesExhaustedError(policy.maxRetries + 1, lastError);
+}
+/**
+ * Wrapper around fetch() that throws RetryableHttpError for transient HTTP failures.
+ * Drop-in for fetch() calls that should participate in retry logic.
+ */
+export async function fetchWithRetry(label, url, options, policy) {
+    return withRetry(label, async () => {
+        const res = await fetch(url, options);
+        if (RETRYABLE_STATUS_CODES.has(res.status)) {
+            throw new RetryableHttpError(res.status, `${label}: HTTP ${res.status}`);
+        }
+        return res;
+    }, policy);
+}

package/dist/sse.js

@@ -4,6 +4,7 @@ import { getDb } from './db.js';
 import { logActivity } from './helpers.js';
 import { getConfig } from './config.js';
 import { validateKeys } from './tools/terminal.js';
+import { fetchWithRetry } from './retry.js';
 const SERVICE_ID = 'taskflow-mcp';
 const PROBE_TIMEOUT_MS = 2000;
 // ─── Relay upstream config (from config file, env vars, or .env) ────
@@ -48,10 +49,11 @@ function jsonResponse(res, status, data) {
     res.end(JSON.stringify(data));
 }
 function readBody(req) {
-    return new Promise((resolve) => {
+    return new Promise((resolve, reject) => {
         let body = '';
         req.on('data', (chunk) => { body += chunk.toString(); });
         req.on('end', () => resolve(body));
+        req.on('error', reject);
     });
 }
 /**
@@ -289,7 +291,14 @@ export async function startSSEServer() {
                 jsonResponse(res, 404, { error: 'Task not found' });
                 return;
             }
-            const body = JSON.parse(await readBody(req));
+            let body;
+            try {
+                body = JSON.parse(await readBody(req));
+            }
+            catch {
+                jsonResponse(res, 400, { error: 'Invalid JSON body' });
+                return;
+            }
             const fieldMap = {
                 title: 'title', description: 'description', status: 'status',
                 priority: 'priority', projectId: 'project_id', dueDate: 'due_date',
@@ -348,7 +357,14 @@ export async function startSSEServer() {
         // POST /api/tasks — create a task
         if (req.url === '/api/tasks' && req.method === 'POST') {
             const db = getDb();
-            const body = JSON.parse(await readBody(req));
+            let body;
+            try {
+                body = JSON.parse(await readBody(req));
+            }
+            catch {
+                jsonResponse(res, 400, { error: 'Invalid JSON body' });
+                return;
+            }
             const ts = new Date().toISOString();
             const result = db.prepare(`INSERT INTO tasks (title, description, status, priority, project_id, dependencies, links, tags, due_date, estimated_time, created_at, updated_at)
          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(body.title, body.description ?? null, body.status ?? 'not_started', body.priority ?? 'medium', body.projectId ?? null, JSON.stringify(body.dependencies ?? []), JSON.stringify(body.links ?? []), JSON.stringify(body.tags ?? []), body.dueDate ? new Date(body.dueDate).toISOString() : null, body.estimatedTime ?? null, ts, ts);
@@ -361,7 +377,14 @@ export async function startSSEServer() {
         // POST /api/sessions — create a timer session
         if (req.url === '/api/sessions' && req.method === 'POST') {
             const db = getDb();
-            const body = JSON.parse(await readBody(req));
+            let body;
+            try {
+                body = JSON.parse(await readBody(req));
+            }
+            catch {
+                jsonResponse(res, 400, { error: 'Invalid JSON body' });
+                return;
+            }
             const ts = new Date().toISOString();
             const result = db.prepare('INSERT INTO sessions (task_id, start, end) VALUES (?, ?, ?)').run(body.taskId, body.start ? new Date(body.start).toISOString() : ts, body.end ? new Date(body.end).toISOString() : null);
             const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get(result.lastInsertRowid);
@@ -374,7 +397,14 @@ export async function startSSEServer() {
         if (sessionPatchMatch && req.method === 'PATCH') {
             const db = getDb();
             const id = Number(sessionPatchMatch[1]);
-            const body = JSON.parse(await readBody(req));
+            let body;
+            try {
+                body = JSON.parse(await readBody(req));
+            }
+            catch {
+                jsonResponse(res, 400, { error: 'Invalid JSON body' });
+                return;
+            }
             if (body.end) {
                 db.prepare('UPDATE sessions SET end = ? WHERE id = ?').run(new Date(body.end).toISOString(), id);
             }
@@ -392,7 +422,14 @@ export async function startSSEServer() {
                 jsonResponse(res, 404, { error: 'Project not found' });
                 return;
             }
-            const body = JSON.parse(await readBody(req));
+            let body;
+            try {
+                body = JSON.parse(await readBody(req));
+            }
+            catch {
+                jsonResponse(res, 400, { error: 'Invalid JSON body' });
+                return;
+            }
             const fieldMap = {
                 name: 'name', color: 'color', type: 'type', description: 'description',
             };
@@ -432,7 +469,14 @@ export async function startSSEServer() {
         }
         // POST /api/broadcast — relay SSE events from other processes (e.g. MCP)
         if (req.url === '/api/broadcast' && req.method === 'POST') {
-            const body = JSON.parse(await readBody(req));
+            let body;
+            try {
+                body = JSON.parse(await readBody(req));
+            }
+            catch {
+                jsonResponse(res, 400, { error: 'Invalid JSON body' });
+                return;
+            }
             if (body.event && body.data) {
                 broadcastLocal(body.event, body.data);
             }
@@ -453,7 +497,14 @@ export async function startSSEServer() {
                 jsonResponse(res, 400, { error: 'Already answered' });
                 return;
             }
-            const body = JSON.parse(await readBody(req));
+            let body;
+            try {
+                body = JSON.parse(await readBody(req));
+            }
+            catch {
+                jsonResponse(res, 400, { error: 'Invalid JSON body' });
+                return;
+            }
             const response = body.response;
             if (!response) {
                 jsonResponse(res, 400, { error: 'Response is required' });
@@ -493,7 +544,14 @@ export async function startSSEServer() {
         // POST /api/agent-messages/send — send a message (from user UI or capture system)
         if (req.url === '/api/agent-messages/send' && req.method === 'POST') {
             const db = getDb();
-            const body = JSON.parse(await readBody(req));
+            let body;
+            try {
+                body = JSON.parse(await readBody(req));
+            }
+            catch {
+                jsonResponse(res, 400, { error: 'Invalid JSON body' });
+                return;
+            }
             const { recipient, message: msgText, projectId, source: msgSource, senderName } = body;
             if (!recipient || !msgText) {
                 jsonResponse(res, 400, { error: 'recipient and message are required' });
@@ -690,7 +748,7 @@ export async function startSSEServer() {
                     // Poll for commands every 2s
                     setInterval(async () => {
                         try {
-                            const res = await fetch(`${RELAY_URL}/commands/pending`, {
+                            const res = await fetchWithRetry('relay commands/pending', `${RELAY_URL}/commands/pending`, {
                                 headers: { 'Authorization': `Bearer ${RELAY_PUSH_TOKEN}` },
                             });
                             if (!res.ok)
@@ -734,13 +792,13 @@ export function markSSEActive() {
  * Also pushes to the remote relay server if configured.
  */
 export function broadcast(event, data) {
-    if (sseServerActive && clients.size > 0) {
+    if (sseServerActive) {
         broadcastLocal(event, data);
     }
     else {
-        // Relay to the SSE server owner via HTTP
+        // Relay to the SSE server owner via HTTP (with retry for transient failures)
         const body = JSON.stringify({ event, data });
-        fetch(`http://localhost:${activePort}/api/broadcast`, {
+        fetchWithRetry('broadcast relay', `http://localhost:${activePort}/api/broadcast`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body,

package/dist/tmux-bridge.d.ts

@@ -2,7 +2,8 @@ interface BridgeOptions {
     /** Returns the current agent name — must be a getter so renames are picked up */
     getAgentName: () => string;
     agentPid: number;
-    tmuxPane: string;
+    /** Null when not running inside tmux — falls back to stderr delivery */
+    tmuxPane: string | null;
 }
 /**
  * Start the tmux bridge: SSE listener for instant message delivery.

package/dist/tmux-bridge.js

@@ -1,7 +1,23 @@
 import { execFileSync } from 'child_process';
+import { appendFileSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
 import { getDb } from './db.js';
 import { getActivePort } from './sse.js';
 import http from 'http';
+const LOG_FILE = join(homedir(), '.taskflow', 'bridge.log');
+try {
+    mkdirSync(join(homedir(), '.taskflow'), { recursive: true });
+}
+catch { }
+function blogLog(msg) {
+    const line = `${new Date().toISOString()} ${msg}\n`;
+    console.error(`[bridge] ${msg}`);
+    try {
+        appendFileSync(LOG_FILE, line);
+    }
+    catch { }
+}
 // ─── SSE Listener (replaces the 3s poller) ───────────────────────────
 function startSSEListener(options) {
     const port = getActivePort();
@@ -32,16 +48,16 @@ function startSSEListener(options) {
                 }
             });
             res.on('end', () => {
-                console.error('[bridge] SSE connection closed, reconnecting in 3s...');
+                blogLog('SSE connection closed, reconnecting in 3s...');
                 setTimeout(connect, 3000);
             });
             res.on('error', () => {
-                console.error('[bridge] SSE connection error, reconnecting in 3s...');
+                blogLog('SSE connection error, reconnecting in 3s...');
                 setTimeout(connect, 3000);
             });
         });
         req.on('error', () => {
-            console.error('[bridge] SSE connect failed, retrying in 3s...');
+            blogLog('SSE connect failed, retrying in 3s...');
             setTimeout(connect, 3000);
         });
     }
@@ -88,33 +104,76 @@ function handleSSEEvent(event, data, options) {
         injectAndMarkDelivered(id, text, tmuxPane);
     }
 }
+// TIOCSTI Python script — injects each character of `text` + newline into the
+// controlling terminal's input queue via ioctl(TIOCSTI). Passed as a CLI arg
+// (not inline) so special characters in the message are never shell-interpreted.
+const TIOCSTI_SCRIPT = `
+import fcntl, sys
+TIOCSTI = 0x5412
+with open('/dev/tty', 'rb+', buffering=0) as tty:
+    for c in (sys.argv[1] + '\\n').encode():
+        fcntl.ioctl(tty, TIOCSTI, bytes([c]))
+`.trim();
+function injectViaTiocsti(text) {
+    try {
+        execFileSync('python3', ['-c', TIOCSTI_SCRIPT, text], { timeout: 5000 });
+        return null;
+    }
+    catch (err) {
+        // Capture stderr from the Python process (where the real error lives)
+        const stderr = err?.stderr?.toString().trim() || '';
+        const stdout = err?.stdout?.toString().trim() || '';
+        const msg = err?.message || String(err);
+        return [msg, stderr, stdout].filter(Boolean).join(' | ');
+    }
+}
 function injectAndMarkDelivered(id, text, tmuxPane) {
     const db = getDb();
     db.prepare('UPDATE agent_messages SET delivered = 1 WHERE id = ?').run(id);
-    try {
-        // Send text literally (-l) so special chars are safe and tmux doesn't interpret them
-        execFileSync('tmux', ['send-keys', '-t', tmuxPane, '-l', text], { stdio: 'ignore', timeout: 5000 });
-        // Delay before Enter — gives the CLI time to fully process the bracketed paste.
-        // Without this, Codex (and similar TUIs) may only show partial text because
-        // the Enter arrives inside the paste bracket and gets swallowed.
-        setTimeout(() => {
-            try {
-                execFileSync('tmux', ['send-keys', '-t', tmuxPane, 'Enter'], { stdio: 'ignore', timeout: 5000 });
-            }
-            catch { /* pane may have closed */ }
-            // Second Enter after another delay — catches CLIs that need an extra nudge
-            // after bracketed paste ends (e.g. long messages that trigger paste mode)
+    if (tmuxPane) {
+        try {
+            // Send text literally (-l) so special chars are safe and tmux doesn't interpret them
+            execFileSync('tmux', ['send-keys', '-t', tmuxPane, '-l', text], { stdio: 'ignore', timeout: 5000 });
+            // Delay before Enter — gives the CLI time to fully process the bracketed paste.
+            // Without this, Codex (and similar TUIs) may only show partial text because
+            // the Enter arrives inside the paste bracket and gets swallowed.
             setTimeout(() => {
                 try {
                     execFileSync('tmux', ['send-keys', '-t', tmuxPane, 'Enter'], { stdio: 'ignore', timeout: 5000 });
                 }
                 catch { /* pane may have closed */ }
-            }, 500);
-        }, 300);
-        console.error(`[bridge] delivered message ${id} to tmux pane ${tmuxPane}`);
+                // Second Enter after another delay — catches CLIs that need an extra nudge
+                // after bracketed paste ends (e.g. long messages that trigger paste mode)
+                setTimeout(() => {
+                    try {
+                        execFileSync('tmux', ['send-keys', '-t', tmuxPane, 'Enter'], { stdio: 'ignore', timeout: 5000 });
+                    }
+                    catch { /* pane may have closed */ }
+                }, 500);
+            }, 300);
+            blogLog(`delivered message ${id} to tmux pane ${tmuxPane}`);
+        }
+        catch (err) {
+            blogLog(`tmux send-keys failed for message ${id}: ${err}`);
+        }
     }
-    catch (err) {
-        console.error(`[bridge] tmux send-keys failed for message ${id}:`, err);
+    else {
+        // Non-tmux: try TIOCSTI to inject text into the controlling terminal's input
+        // queue. TIOCSTI (0x5412) works when the caller shares the controlling terminal
+        // with the target process — which is true here since the MCP server is a child
+        // of Claude Code and inherits its tty session.
+        // Falls back to stderr if python3 is unavailable or the ioctl is denied.
+        const tiocError = injectViaTiocsti(text);
+        if (tiocError !== null) {
+            blogLog(`TIOCSTI failed for message ${id}: ${tiocError}`);
+            // Last-resort visual: at least make the message visible in the terminal output.
+            // The tool-response piggyback in index.ts will also deliver it on the next call.
+            process.stderr.write(`\n\x1b[33m[INBOX #${id}]: ${text}\x1b[0m\n`);
+            blogLog(`message ${id} visible in stderr, will appear in next tool response`);
+        }
+        else {
+            blogLog(`delivered message ${id} via TIOCSTI`);
+        }
     }
 }
 function deliverUndelivered(options) {
@@ -150,7 +209,8 @@ function deliverUndelivered(options) {
  */
 export function startTmuxBridge(options) {
     startSSEListener(options);
-    console.error(`[bridge] tmux bridge active for agent "${options.getAgentName()}" on pane ${options.tmuxPane}`);
+    const pane = options.tmuxPane;
+    blogLog(`bridge active for agent "${options.getAgentName()}"${pane ? ` on tmux pane ${pane}` : ' (TIOCSTI mode — no tmux pane)'}`);
     return () => {
         // SSE connection will close when process exits
     };

package/dist/tools/agent-inbox.js

@@ -41,6 +41,21 @@ export function registerAgentInboxTools(server) {
         myAgentName = doRegister({ customName: params.name });
         return successResponse({ name: myAgentName, message: `Registered as "${myAgentName}"` });
     });
+    server.tool('delete_agent', 'Delete a stale or disconnected agent entry from the registry. Only disconnected agents can be deleted. Use this to clean up ghost entries left by crashed or renamed sessions.', {
+        name: z.string().describe('Name of the agent entry to delete'),
+    }, { destructiveHint: true }, async (params) => {
+        const db = getDb();
+        const agent = getAgent(params.name);
+        if (!agent)
+            return errorResponse(`Agent "${params.name}" not found`, 'NOT_FOUND');
+        if (agent.status === 'connected') {
+            return errorResponse(`Agent "${params.name}" is currently connected. Disconnect it first or wait for it to go offline.`, 'CONFLICT');
+        }
+        db.prepare('DELETE FROM agent_registry WHERE name = ?').run(params.name);
+        broadcastChange('agent', 'agent_deleted', { name: params.name });
+        logActivity('agent_deleted', `Agent "${params.name}" deleted from registry`, { entityType: 'agent' });
+        return successResponse({ deleted: true, name: params.name });
+    });
     server.tool('ask_user', 'Post a question to the TaskFlow Agent Inbox for the user to answer remotely. Returns immediately with the message ID. The question appears in the Agent Inbox UI with full context and optional quick-tap choices. After posting, use check_response to retrieve the user\'s answer. Always tell the user you posted a question so they know to check the inbox.', {
         project_id: z.number().describe('Project ID to attach the question to'),
         question: z.string().describe('The question to ask the user'),

package/dist/types.d.ts

@@ -68,6 +68,7 @@ export declare const ActivityAction: z.ZodEnum<{
     agent_connected: "agent_connected";
     agent_disconnected: "agent_disconnected";
     agent_renamed: "agent_renamed";
+    agent_deleted: "agent_deleted";
     terminal_send_keys: "terminal_send_keys";
     terminal_captured: "terminal_captured";
     compaction_summary: "compaction_summary";
@@ -75,7 +76,7 @@ export declare const ActivityAction: z.ZodEnum<{
 }>;
 export type ActivityAction = z.infer<typeof ActivityAction>;
 export declare const VALID_TRANSITIONS: Record<TaskStatus, TaskStatus[]>;
-export type ErrorCode = 'NOT_FOUND' | 'INVALID_TRANSITION' | 'VALIDATION_ERROR' | 'CYCLE_DETECTED' | 'SESSION_ALREADY_ACTIVE' | 'NO_ACTIVE_SESSION' | 'ALREADY_ANSWERED';
+export type ErrorCode = 'NOT_FOUND' | 'INVALID_TRANSITION' | 'VALIDATION_ERROR' | 'CYCLE_DETECTED' | 'SESSION_ALREADY_ACTIVE' | 'NO_ACTIVE_SESSION' | 'ALREADY_ANSWERED' | 'CONFLICT';
 export declare const LinkSchema: z.ZodObject<{
     label: z.ZodString;
     url: z.ZodString;

package/dist/types.js

@@ -15,7 +15,7 @@ export const ActivityAction = z.enum([
     'task_linked', 'task_unlinked', 'dependency_added', 'dependency_removed',
     'link_added', 'tag_added', 'tag_removed', 'debug_log',
     'agent_question', 'agent_question_answered', 'agent_broadcast',
-    'agent_connected', 'agent_disconnected', 'agent_renamed',
+    'agent_connected', 'agent_disconnected', 'agent_renamed', 'agent_deleted',
     'terminal_send_keys', 'terminal_captured',
     'compaction_summary', 'activity_compacted',
 ]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dalmasonto/taskflow-mcp",
-  "version": "1.0.32",
+  "version": "1.0.35",
   "description": "MCP server for TaskFlow — manage projects, tasks, timers, analytics via AI agents",
   "type": "module",
   "main": "dist/index.js",