@shuyhere/takotako 0.0.1

package/dist/cache/tool-cache.js

@@ -0,0 +1,173 @@
+/**
+ * Tool Execution Cache — caches command results keyed by SHA256(command+args+cwd).
+ *
+ * Features:
+ * - Per-command TTL overrides (git status 10s, ls 30s, grep 15s, etc.)
+ * - Blocklist for side-effect commands (test, build, make, etc.)
+ * - Auto-invalidation on file writes in the same cwd
+ */
+import { createHash } from 'node:crypto';
+// ─── Default TTL overrides by command prefix ────────────────────────
+const DEFAULT_TTL_OVERRIDES = {
+    'git status': 10,
+    'git log': 15,
+    'git diff': 10,
+    'git branch': 15,
+    'ls': 30,
+    'find': 15,
+    'grep': 15,
+    'rg': 15,
+    'wc': 30,
+    'cat': 60,
+    'head': 60,
+    'tail': 60,
+    'file': 60,
+    'which': 120,
+    'type': 120,
+};
+// ─── Tool Execution Cache ───────────────────────────────────────────
+export class ToolCache {
+    config;
+    cache = new Map();
+    hits = 0;
+    misses = 0;
+    blocked = 0;
+    evictions = 0;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Build a cache key from command, args, and cwd.
+     */
+    static buildKey(command, cwd) {
+        return createHash('sha256')
+            .update(`${command}\0${cwd}`)
+            .digest('hex');
+    }
+    /**
+     * Check if a command is blocklisted (should never be cached).
+     */
+    isBlocked(command) {
+        const trimmed = command.trim();
+        return this.config.blocklist.some((pattern) => trimmed.startsWith(pattern) || trimmed.includes(` && ${pattern}`) || trimmed.includes(`; ${pattern}`));
+    }
+    /**
+     * Get the TTL for a command in milliseconds.
+     */
+    getTtlMs(command) {
+        const trimmed = command.trim();
+        const overrides = { ...DEFAULT_TTL_OVERRIDES, ...this.config.ttlOverrides };
+        // Match longest prefix first
+        let bestMatch = '';
+        let bestTtl = this.config.defaultTtlSeconds;
+        for (const [prefix, ttlSeconds] of Object.entries(overrides)) {
+            if (trimmed.startsWith(prefix) && prefix.length > bestMatch.length) {
+                bestMatch = prefix;
+                bestTtl = ttlSeconds;
+            }
+        }
+        return bestTtl * 1000;
+    }
+    /**
+     * Get a cached result if valid, or null if stale/missing/blocked.
+     */
+    get(command, cwd) {
+        if (!this.config.enabled)
+            return null;
+        if (this.isBlocked(command)) {
+            this.blocked++;
+            return null;
+        }
+        const key = ToolCache.buildKey(command, cwd);
+        const entry = this.cache.get(key);
+        if (!entry) {
+            this.misses++;
+            return null;
+        }
+        // Check TTL
+        if (Date.now() - entry.cachedAt > entry.ttlMs) {
+            this.cache.delete(key);
+            this.misses++;
+            return null;
+        }
+        this.hits++;
+        return entry;
+    }
+    /**
+     * Store a command result in cache.
+     */
+    set(command, cwd, output, success, error) {
+        if (!this.config.enabled)
+            return;
+        if (this.isBlocked(command))
+            return;
+        const key = ToolCache.buildKey(command, cwd);
+        const ttlMs = this.getTtlMs(command);
+        this.cache.set(key, {
+            output,
+            success,
+            error,
+            cachedAt: Date.now(),
+            ttlMs,
+            commandKey: command.slice(0, 80),
+        });
+    }
+    /**
+     * Invalidate all cached commands for a given cwd (e.g. after file write).
+     */
+    invalidateCwd(cwd) {
+        // We can't reconstruct keys from cwd alone, so scan all entries
+        for (const [key, entry] of this.cache) {
+            // commandKey is the truncated command; we hash with cwd
+            // Since we can't reverse the hash, mark all entries as expired by setting cachedAt to 0
+            // Actually, let's just clear all — simpler and correct since writes affect the directory
+        }
+        // Clear all entries — writes can affect any command's output
+        this.cache.clear();
+    }
+    /**
+     * Clear the entire cache.
+     */
+    clear() {
+        this.cache.clear();
+    }
+    /**
+     * Run auto-clean: remove expired entries.
+     */
+    autoClean() {
+        const now = Date.now();
+        let cleaned = 0;
+        for (const [key, entry] of this.cache) {
+            if (now - entry.cachedAt > entry.ttlMs) {
+                this.cache.delete(key);
+                cleaned++;
+                this.evictions++;
+            }
+        }
+        return cleaned;
+    }
+    /**
+     * Get cache statistics.
+     */
+    getStats() {
+        const total = this.hits + this.misses;
+        return {
+            entries: this.cache.size,
+            hits: this.hits,
+            misses: this.misses,
+            blocked: this.blocked,
+            evictions: this.evictions,
+            hitRate: total > 0 ? this.hits / total : 0,
+        };
+    }
+    /**
+     * Reset counters (for testing).
+     */
+    resetStats() {
+        this.hits = 0;
+        this.misses = 0;
+        this.blocked = 0;
+        this.evictions = 0;
+    }
+}
+//# sourceMappingURL=tool-cache.js.map

package/dist/cache/tool-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-cache.js","sourceRoot":"","sources":["../../src/cache/tool-cache.ts"],"names":[],"mappings":"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"}

package/dist/channels/channel.d.ts

@@ -0,0 +1,156 @@
+/**
+ * Channel — messaging I/O trait.
+ *
+ * One interface, many adapters (Discord, Telegram, CLI, WebChat, etc.).
+ * Channels run simultaneously through the Gateway, each handling its own
+ * authentication, rate limiting, and message formatting.
+ *
+ * Each channel:
+ * - Connects to a platform and listens for messages
+ * - Converts platform-specific payloads to InboundMessage
+ * - Sends OutboundMessage back through the platform
+ * - Handles reconnection and error recovery independently
+ *
+ * @example
+ * ```typescript
+ * const cli = new CLIChannel();
+ * cli.onMessage(async (msg) => {
+ *   console.log(`User said: ${msg.content}`);
+ *   await cli.send({ target: msg.channelId, content: 'Hello!' });
+ * });
+ * await cli.connect();
+ * ```
+ */
+/** An inbound message received from any channel. */
+export interface InboundMessage {
+    /** Unique message ID (platform-specific, e.g. Discord snowflake) */
+    id: string;
+    /** Channel identifier with optional platform prefix (e.g. 'cli', 'discord:123') */
+    channelId: string;
+    /** Author information */
+    author: {
+        /** Platform-specific user ID */
+        id: string;
+        /** Display name */
+        name: string;
+        /** Additional platform-specific metadata */
+        meta?: Record<string, unknown>;
+    };
+    /** Message text content */
+    content: string;
+    /** File or media attachments */
+    attachments?: Attachment[];
+    /** ISO-8601 timestamp of when the message was sent */
+    timestamp: string;
+    /** Platform-specific raw payload (for advanced use) */
+    raw?: unknown;
+    /** Platform thread/topic ID (e.g., Telegram forum topic). */
+    threadId?: string;
+}
+/** An outbound message to send through a channel. */
+export interface OutboundMessage {
+    /** Target conversation, thread, or chat ID */
+    target: string;
+    /** Text content to send */
+    content: string;
+    /** Optional message ID to reply to */
+    replyTo?: string;
+    /** Optional file or media attachments */
+    attachments?: Attachment[];
+}
+/** A file or media attachment on a message. */
+export interface Attachment {
+    /** Attachment type */
+    type: 'image' | 'file' | 'audio' | 'video';
+    /** URL to the attachment (if hosted) */
+    url?: string;
+    /** Raw binary data (for inline attachments) */
+    data?: Buffer;
+    /** Original filename */
+    filename?: string;
+    /** MIME type (e.g. 'image/png', 'application/pdf') */
+    mimeType?: string;
+}
+/** Callback for handling inbound messages. */
+export type MessageHandler = (msg: InboundMessage) => void | Promise<void>;
+/**
+ * Channel — the messaging I/O trait.
+ *
+ * Implementations adapt a specific messaging platform into Tako's
+ * unified message handling interface. Multiple channels can run
+ * simultaneously, each receiving and sending messages independently.
+ *
+ * Built-in implementations:
+ * - {@link CLIChannel} — terminal readline interface
+ * - {@link DiscordChannel} — Discord bot via discord.js
+ * - {@link TelegramChannel} — Telegram bot via grammY
+ */
+export interface Channel {
+    /** Unique channel identifier (e.g. 'discord', 'telegram', 'cli') */
+    id: string;
+    /** If set, all messages on this channel route to this specific agent. */
+    agentId?: string;
+    /**
+     * Connect to the messaging platform.
+     * For CLI, this starts the readline interface (blocking).
+     * For Discord/Telegram, this authenticates and starts listening.
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect cleanly from the platform.
+     * Releases resources and stops listening for messages.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Send an outbound message through the channel.
+     * Handles platform-specific formatting (message splitting, Markdown, etc.).
+     *
+     * @param msg - The message to send
+     */
+    send(msg: OutboundMessage): Promise<void>;
+    /**
+     * Register a handler for inbound messages.
+     * Only one handler is typically registered (the agent loop router).
+     *
+     * @param handler - Callback invoked for each incoming message
+     */
+    onMessage(handler: MessageHandler): void;
+    /**
+     * Send a typing indicator to the given chat/channel.
+     * Optional — channels that don't support typing can omit this.
+     */
+    sendTyping?(chatId: string): Promise<void>;
+    /**
+     * Add a reaction emoji to a message.
+     * Optional — channels that don't support reactions can omit this.
+     */
+    addReaction?(chatId: string, messageId: string, emoji: string): Promise<void>;
+    /**
+     * Remove a reaction emoji from a message.
+     * Optional — channels that don't support reactions can omit this.
+     */
+    removeReaction?(chatId: string, messageId: string, emoji: string): Promise<void>;
+    /**
+     * Broadcast a system message to all configured default channels.
+     * Used for startup/shutdown notices. Optional — CLI can omit.
+     */
+    broadcast?(text: string): Promise<void>;
+    /**
+     * Edit an existing message (for streaming updates).
+     * Optional — channels that don't support editing can omit this.
+     *
+     * @param chatId - Target chat/channel ID
+     * @param messageId - The message to edit
+     * @param content - New content for the message
+     */
+    editMessage?(chatId: string, messageId: string, content: string): Promise<void>;
+    /**
+     * Send a message and return the message ID (for subsequent edits).
+     * Optional — channels that don't support message IDs can omit this.
+     *
+     * @param msg - The message to send
+     * @returns Platform-specific message ID
+     */
+    sendAndGetId?(msg: OutboundMessage): Promise<string>;
+}
+//# sourceMappingURL=channel.d.ts.map

package/dist/channels/channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel.d.ts","sourceRoot":"","sources":["../../src/channels/channel.ts"],"names":[],"mappings":"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"}

package/dist/channels/channel.js

@@ -0,0 +1,25 @@
+/**
+ * Channel — messaging I/O trait.
+ *
+ * One interface, many adapters (Discord, Telegram, CLI, WebChat, etc.).
+ * Channels run simultaneously through the Gateway, each handling its own
+ * authentication, rate limiting, and message formatting.
+ *
+ * Each channel:
+ * - Connects to a platform and listens for messages
+ * - Converts platform-specific payloads to InboundMessage
+ * - Sends OutboundMessage back through the platform
+ * - Handles reconnection and error recovery independently
+ *
+ * @example
+ * ```typescript
+ * const cli = new CLIChannel();
+ * cli.onMessage(async (msg) => {
+ *   console.log(`User said: ${msg.content}`);
+ *   await cli.send({ target: msg.channelId, content: 'Hello!' });
+ * });
+ * await cli.connect();
+ * ```
+ */
+export {};
+//# sourceMappingURL=channel.js.map

package/dist/channels/channel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel.js","sourceRoot":"","sources":["../../src/channels/channel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG"}

package/dist/channels/cli.d.ts

@@ -0,0 +1,35 @@
+/**
+ * CLI channel — terminal/stdin adapter.
+ *
+ * The simplest channel: reads from stdin, writes to stdout.
+ * Properly awaits async message handlers and re-prompts after completion.
+ */
+import type { Channel, OutboundMessage, MessageHandler } from './channel.js';
+export declare class CLIChannel implements Channel {
+    id: string;
+    private rl;
+    private handlers;
+    private promptStr;
+    private busy;
+    constructor(opts?: {
+        prompt?: string;
+    });
+    connect(): Promise<void>;
+    /** Display the prompt. */
+    showPrompt(): void;
+    disconnect(): Promise<void>;
+    send(msg: OutboundMessage): Promise<void>;
+    /**
+     * Send a message and return a synthetic ID.
+     * CLI doesn't have real message IDs, but this enables the streaming
+     * interface. Subsequent editMessage calls overwrite the current line.
+     */
+    sendAndGetId(msg: OutboundMessage): Promise<string>;
+    /**
+     * Edit the current streaming message by clearing and rewriting.
+     * For CLI, we use carriage return to overwrite the current output.
+     */
+    editMessage(_chatId: string, _messageId: string, content: string): Promise<void>;
+    onMessage(handler: MessageHandler): void;
+}
+//# sourceMappingURL=cli.d.ts.map

package/dist/channels/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/channels/cli.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAkB,eAAe,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAE7F,qBAAa,UAAW,YAAW,OAAO;IACxC,EAAE,SAAS;IACX,OAAO,CAAC,EAAE,CAAkC;IAC5C,OAAO,CAAC,QAAQ,CAAwB;IACxC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,IAAI,CAAS;gBAET,IAAI,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE;IAIhC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAiD9B,0BAA0B;IAC1B,UAAU,IAAI,IAAI;IAIZ,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAK3B,IAAI,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAI/C;;;;OAIG;IACG,YAAY,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC;IAKzD;;;OAGG;IACG,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKtF,SAAS,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;CAGzC"}

package/dist/channels/cli.js

@@ -0,0 +1,94 @@
+/**
+ * CLI channel — terminal/stdin adapter.
+ *
+ * The simplest channel: reads from stdin, writes to stdout.
+ * Properly awaits async message handlers and re-prompts after completion.
+ */
+import { createInterface } from 'node:readline';
+export class CLIChannel {
+    id = 'cli';
+    rl = null;
+    handlers = [];
+    promptStr;
+    busy = false;
+    constructor(opts) {
+        this.promptStr = opts?.prompt ?? 'tako> ';
+    }
+    async connect() {
+        this.rl = createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            prompt: this.promptStr,
+        });
+        this.rl.on('line', async (line) => {
+            const trimmed = line.trim();
+            if (!trimmed) {
+                this.showPrompt();
+                return;
+            }
+            // Prevent overlapping handler executions
+            if (this.busy)
+                return;
+            this.busy = true;
+            const msg = {
+                id: crypto.randomUUID(),
+                channelId: 'cli',
+                author: { id: 'local', name: 'user' },
+                content: trimmed,
+                timestamp: new Date().toISOString(),
+            };
+            try {
+                for (const handler of this.handlers) {
+                    await handler(msg);
+                }
+            }
+            catch (err) {
+                console.error('[tako] Error:', err instanceof Error ? err.message : err);
+            }
+            finally {
+                this.busy = false;
+                this.showPrompt();
+            }
+        });
+        this.rl.on('close', () => {
+            // Only exit if CLI is the sole channel (no Discord/Telegram).
+            // In Docker or daemon mode, stdin closes immediately — don't kill the process.
+            if (!process.env['TAKO_KEEP_ALIVE']) {
+                process.exit(0);
+            }
+        });
+        this.showPrompt();
+    }
+    /** Display the prompt. */
+    showPrompt() {
+        this.rl?.prompt();
+    }
+    async disconnect() {
+        this.rl?.close();
+        this.rl = null;
+    }
+    async send(msg) {
+        process.stdout.write(msg.content + '\n');
+    }
+    /**
+     * Send a message and return a synthetic ID.
+     * CLI doesn't have real message IDs, but this enables the streaming
+     * interface. Subsequent editMessage calls overwrite the current line.
+     */
+    async sendAndGetId(msg) {
+        process.stdout.write(msg.content);
+        return 'cli-stream';
+    }
+    /**
+     * Edit the current streaming message by clearing and rewriting.
+     * For CLI, we use carriage return to overwrite the current output.
+     */
+    async editMessage(_chatId, _messageId, content) {
+        // Move cursor to start of line, clear, and rewrite
+        process.stdout.write('\r\x1b[K' + content);
+    }
+    onMessage(handler) {
+        this.handlers.push(handler);
+    }
+}
+//# sourceMappingURL=cli.js.map

package/dist/channels/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../src/channels/cli.ts"],"names":[],"mappings":"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"}

package/dist/channels/delivery-queue.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Delivery queue — async message delivery with retry.
+ *
+ * When channel.send() fails, the message is queued as a JSON file
+ * in ~/.tako/delivery-queue/. A background worker retries every 30s
+ * with max 3 attempts. Failed messages move to ~/.tako/delivery-queue/failed/.
+ */
+import type { Channel, OutboundMessage } from './channel.js';
+export declare class DeliveryQueue {
+    private channels;
+    private retryTimer;
+    private queueDir;
+    private failedDir;
+    constructor();
+    /** Register a channel for retry delivery. */
+    registerChannel(channel: Channel): void;
+    /** Start the background retry worker. */
+    start(): Promise<void>;
+    /** Stop the background retry worker. */
+    stop(): void;
+    /**
+     * Enqueue a failed message for retry.
+     * Called when channel.send() throws.
+     */
+    enqueue(channelId: string, message: OutboundMessage, error: string): Promise<void>;
+    /** Process all queued messages, retrying delivery. */
+    private processQueue;
+    /** Move a message to the failed directory. */
+    private moveFailed;
+}
+//# sourceMappingURL=delivery-queue.d.ts.map

package/dist/channels/delivery-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delivery-queue.d.ts","sourceRoot":"","sources":["../../src/channels/delivery-queue.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,KAAK,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AA8B7D,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAA8B;IAC9C,OAAO,CAAC,UAAU,CAA+C;IACjE,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,SAAS,CAAS;;IAO1B,6CAA6C;IAC7C,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAIvC,yCAAyC;IACnC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAW5B,wCAAwC;IACxC,IAAI,IAAI,IAAI;IAOZ;;;OAGG;IACG,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAkBxF,sDAAsD;YACxC,YAAY;IA+C1B,8CAA8C;YAChC,UAAU;CAOzB"}

package/dist/channels/delivery-queue.js

@@ -0,0 +1,127 @@
+/**
+ * Delivery queue — async message delivery with retry.
+ *
+ * When channel.send() fails, the message is queued as a JSON file
+ * in ~/.tako/delivery-queue/. A background worker retries every 30s
+ * with max 3 attempts. Failed messages move to ~/.tako/delivery-queue/failed/.
+ */
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { mkdir, readFile, writeFile, readdir, unlink } from 'node:fs/promises';
+// ─── Paths ──────────────────────────────────────────────────────────
+function getQueueDir() {
+    return join(homedir(), '.tako', 'delivery-queue');
+}
+function getFailedDir() {
+    return join(getQueueDir(), 'failed');
+}
+// ─── DeliveryQueue ──────────────────────────────────────────────────
+const RETRY_INTERVAL_MS = 30_000;
+const MAX_ATTEMPTS = 3;
+export class DeliveryQueue {
+    channels = new Map();
+    retryTimer = null;
+    queueDir;
+    failedDir;
+    constructor() {
+        this.queueDir = getQueueDir();
+        this.failedDir = getFailedDir();
+    }
+    /** Register a channel for retry delivery. */
+    registerChannel(channel) {
+        this.channels.set(channel.id, channel);
+    }
+    /** Start the background retry worker. */
+    async start() {
+        await mkdir(this.queueDir, { recursive: true });
+        await mkdir(this.failedDir, { recursive: true });
+        this.retryTimer = setInterval(() => {
+            this.processQueue().catch((err) => {
+                console.error('[delivery-queue] Retry error:', err instanceof Error ? err.message : err);
+            });
+        }, RETRY_INTERVAL_MS);
+    }
+    /** Stop the background retry worker. */
+    stop() {
+        if (this.retryTimer) {
+            clearInterval(this.retryTimer);
+            this.retryTimer = null;
+        }
+    }
+    /**
+     * Enqueue a failed message for retry.
+     * Called when channel.send() throws.
+     */
+    async enqueue(channelId, message, error) {
+        const id = crypto.randomUUID();
+        const queued = {
+            id,
+            channelId,
+            message,
+            attempts: 1, // already tried once
+            maxAttempts: MAX_ATTEMPTS,
+            createdAt: new Date().toISOString(),
+            lastAttemptAt: new Date().toISOString(),
+            lastError: error,
+        };
+        const filePath = join(this.queueDir, `${id}.json`);
+        await writeFile(filePath, JSON.stringify(queued, null, 2) + '\n', 'utf-8');
+        console.log(`[delivery-queue] Queued message ${id} for ${channelId} (error: ${error.slice(0, 100)})`);
+    }
+    /** Process all queued messages, retrying delivery. */
+    async processQueue() {
+        let files;
+        try {
+            files = await readdir(this.queueDir);
+        }
+        catch {
+            return;
+        }
+        const jsonFiles = files.filter((f) => f.endsWith('.json'));
+        if (jsonFiles.length === 0)
+            return;
+        for (const file of jsonFiles) {
+            const filePath = join(this.queueDir, file);
+            try {
+                const raw = await readFile(filePath, 'utf-8');
+                const queued = JSON.parse(raw);
+                const channel = this.channels.get(queued.channelId);
+                if (!channel) {
+                    // Channel not registered — move to failed
+                    await this.moveFailed(filePath, queued, 'Channel not registered');
+                    continue;
+                }
+                try {
+                    await channel.send(queued.message);
+                    // Success — remove from queue
+                    await unlink(filePath);
+                    console.log(`[delivery-queue] Delivered queued message ${queued.id}`);
+                }
+                catch (err) {
+                    queued.attempts++;
+                    queued.lastAttemptAt = new Date().toISOString();
+                    queued.lastError = err instanceof Error ? err.message : String(err);
+                    if (queued.attempts >= queued.maxAttempts) {
+                        await this.moveFailed(filePath, queued, queued.lastError);
+                    }
+                    else {
+                        await writeFile(filePath, JSON.stringify(queued, null, 2) + '\n', 'utf-8');
+                        console.log(`[delivery-queue] Retry ${queued.attempts}/${queued.maxAttempts} for ${queued.id}`);
+                    }
+                }
+            }
+            catch (err) {
+                console.error(`[delivery-queue] Error processing ${file}:`, err instanceof Error ? err.message : err);
+            }
+        }
+    }
+    /** Move a message to the failed directory. */
+    async moveFailed(filePath, queued, reason) {
+        queued.lastError = reason;
+        const failedPath = join(this.failedDir, `${queued.id}.json`);
+        await writeFile(failedPath, JSON.stringify(queued, null, 2) + '\n', 'utf-8');
+        await unlink(filePath);
+        console.log(`[delivery-queue] Message ${queued.id} moved to failed (${reason.slice(0, 100)})`);
+    }
+}
+//# sourceMappingURL=delivery-queue.js.map