agentfeed 0.1.11 → 0.1.14

package/dist/api-client.d.ts

@@ -30,4 +30,8 @@ export declare class AgentFeedClient {
     }, agentId?: string): Promise<void>;
     getAgentConfig(agentId: string): Promise<AgentConfig>;
     reportSession(sessionName: string, claudeSessionId: string, agentId?: string): Promise<void>;
+    getSettings(): Promise<{
+        bot_mention_limit: number;
+        bot_mention_window_minutes: number;
+    }>;
 }

package/dist/api-client.js

@@ -112,4 +112,7 @@ export class AgentFeedClient {
             agentId,
         });
     }
+    async getSettings() {
+        return this.request("/api/settings");
+    }
 }

package/dist/backends/claude.js

@@ -24,7 +24,7 @@ export class ClaudeBackend {
         fs.writeFileSync(this.mcpConfigPath, JSON.stringify(config, null, 2));
     }
     buildArgs(options) {
-        const { prompt, systemPrompt, sessionId, permissionMode, extraAllowedTools, model } = options;
+        const { prompt, systemPrompt, sessionId, permissionMode, extraAllowedTools, model, chrome } = options;
         const args = [
             "-p", prompt,
             "--append-system-prompt", systemPrompt,
@@ -33,11 +33,17 @@ export class ClaudeBackend {
         if (model) {
             args.push("--model", model);
         }
+        if (chrome) {
+            args.push("--chrome");
+        }
         if (permissionMode === "yolo") {
             args.push("--dangerously-skip-permissions");
         }
         else {
             const allowedTools = ["mcp__agentfeed__*", ...(extraAllowedTools ?? [])];
+            if (chrome) {
+                allowedTools.push("mcp__claude-in-chrome__*");
+            }
             for (const tool of allowedTools) {
                 args.push("--allowedTools", tool);
             }

package/dist/backends/types.d.ts

@@ -7,6 +7,7 @@ export interface BuildArgsOptions {
     permissionMode: PermissionMode;
     extraAllowedTools?: string[];
     model?: string;
+    chrome?: boolean;
 }
 export interface CLIBackend {
     readonly name: BackendType;

package/dist/cli.js

@@ -100,6 +100,16 @@ export function probeBackend(type) {
     });
 }
 export function confirmYolo() {
+    // --yes flag skips the interactive confirmation
+    if (process.argv.includes("--yes") || process.argv.includes("-y")) {
+        console.log("");
+        console.log("  \x1b[33m⚠️  YOLO mode enabled. The agent can do literally anything.\x1b[0m");
+        console.log("  \x1b[33m   No prompt sandboxing. No trust boundaries.\x1b[0m");
+        console.log("  \x1b[33m   Prompt injection? Not your problem today.\x1b[0m");
+        console.log("");
+        console.log("  Continue? (y/N): y (auto-confirmed via --yes)");
+        return Promise.resolve(true);
+    }
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     return new Promise((resolve) => {
         console.log("");

package/dist/index.js

@@ -10,7 +10,7 @@ import { QueueStore } from "./queue-store.js";
 import { PostSessionStore } from "./post-session-store.js";
 import { AgentRegistryStore } from "./agent-registry-store.js";
 import { createBackend } from "./backends/index.js";
-import { handleTriggers } from "./processor.js";
+import { handleTriggers, loadSettings } from "./processor.js";
 import { getRequiredEnv, parsePermissionMode, parseAllowedTools, detectInstalledBackends, probeBackend, confirmYolo, migrateSessionFile, } from "./cli.js";
 const serverUrl = getRequiredEnv("AGENTFEED_URL");
 const apiKey = getRequiredEnv("AGENTFEED_API_KEY");
@@ -131,16 +131,12 @@ async function main() {
         agentRegistry.set(agentName, agent.id);
     }
     backendAgents = Array.from(backendAgentMap.values());
-    // Confirm yolo if any server config overrides to yolo (and CLI didn't already confirm)
+    // Server config yolo is pre-authorized by admin — no confirmation needed
+    // Only confirm if CLI explicitly requests yolo via --permission flag
     if (permissionMode !== "yolo") {
         const hasServerYolo = backendAgents.some((ba) => ba.config?.permission_mode === "yolo");
         if (hasServerYolo) {
-            console.log("\nServer config has yolo permission for one or more agents.");
-            const confirmed = await confirmYolo();
-            if (!confirmed) {
-                console.log("Cancelled. Update agent permissions on the server to use safe mode.");
-                process.exit(0);
-            }
+            console.log("\nServer config has yolo permission for one or more agents (auto-confirmed by server settings).");
         }
     }
     // Register Named Session agents for all backends
@@ -159,6 +155,12 @@ async function main() {
         }
     }
     const deps = getProcessorDeps();
+    // Load bot mention limit settings from server
+    await loadSettings(client);
+    // Refresh settings every 5 minutes
+    setInterval(async () => {
+        await loadSettings(client);
+    }, 5 * 60 * 1000);
     // Step 1: Startup scan for unprocessed items
     console.log("Scanning for unprocessed items...");
     const ownAgentIds = agentRegistry.getAllIds();

package/dist/invoker.d.ts

@@ -9,6 +9,7 @@ export interface InvokeOptions {
     permissionMode: PermissionMode;
     extraAllowedTools?: string[];
     model?: string;
+    chrome?: boolean;
     sessionId?: string;
     agentId?: string;
     timeoutMs?: number;
@@ -16,5 +17,6 @@ export interface InvokeOptions {
 export interface InvokeResult {
     exitCode: number;
     sessionId?: string;
+    timedOut: boolean;
 }
 export declare function invokeAgent(backend: CLIBackend, options: InvokeOptions): Promise<InvokeResult>;

package/dist/invoker.js

@@ -42,6 +42,7 @@ export function invokeAgent(backend, options) {
             permissionMode: options.permissionMode,
             extraAllowedTools: options.extraAllowedTools,
             model: options.model,
+            chrome: options.chrome,
         });
         const env = backend.buildEnv({
             ...agentfeedEnv,
@@ -55,12 +56,14 @@ export function invokeAgent(backend, options) {
         console.log(`Invoking ${backend.name}...`);
         const child = spawn(backend.binaryName, args, {
             env,
-            stdio: isNewSession ? ["inherit", "pipe", "inherit"] : "inherit",
+            stdio: isNewSession ? ["ignore", "pipe", "inherit"] : ["ignore", "inherit", "inherit"],
         });
         // Timeout watchdog
         let killTimer = null;
+        let timedOut = false;
         if (options.timeoutMs) {
             killTimer = setTimeout(() => {
+                timedOut = true;
                 console.warn(`Agent timed out after ${options.timeoutMs / 1000}s, killing process...`);
                 child.kill("SIGTERM");
                 setTimeout(() => { if (!child.killed)
@@ -81,6 +84,7 @@ export function invokeAgent(backend, options) {
                     const sid = backend.parseSessionId(line);
                     if (sid) {
                         sessionId = sid;
+                        console.log(`Session ID parsed: ${sid}`);
                     }
                     // Try to extract displayable text
                     const text = backend.parseStreamText(line);
@@ -104,7 +108,7 @@ export function invokeAgent(backend, options) {
             if (isNewSession)
                 process.stdout.write("\n");
             console.log(`Agent exited (code ${code ?? "unknown"})`);
-            resolve({ exitCode: code ?? 1, sessionId: sessionId ?? options.sessionId });
+            resolve({ exitCode: code ?? 1, sessionId: sessionId ?? options.sessionId, timedOut });
         });
     });
 }
@@ -138,7 +142,15 @@ function buildSystemPrompt(options) {
 - agentfeed_create_post - Create a new post in a feed
 - agentfeed_get_comments - Get comments on a post (use since/author_type filters)
 - agentfeed_post_comment - Post a comment (Korean and emoji supported!)
-- agentfeed_download_file - Download and view uploaded files (images, etc.)${statusTool}`;
+- agentfeed_download_file - Download and view uploaded files (images, etc.)
+- agentfeed_upload_file - Upload a local file and get markdown URL${statusTool}`;
+    const chromeSection = options.chrome
+        ? `\n\n# Chrome Browser
+
+You have Chrome browser automation tools (mcp__claude-in-chrome__*) available.
+Use these to navigate web pages, take screenshots, and interact with browser content.
+To capture and share a web page: take a screenshot, save to /tmp, then upload via agentfeed_upload_file.`
+        : "";
     const imageGuidance = `IMPORTANT: When content contains image URLs like ![name](/api/uploads/up_xxx.png), use agentfeed_download_file to view the image before responding about it.`;
     if (options.permissionMode === "yolo") {
         return `# AgentFeed
@@ -149,7 +161,7 @@ ${toolList}
 
 Use these tools to interact with the feed. All content encoding is handled automatically.
 
-${imageGuidance}`;
+${imageGuidance}${chromeSection}`;
     }
     return `${SECURITY_POLICY}
 
@@ -161,7 +173,7 @@ ${toolList}
 
 Use these tools to interact with the feed. All content encoding is handled automatically.
 
-${imageGuidance}`;
+${imageGuidance}${chromeSection}`;
 }
 function wrapUntrusted(text) {
     return `<untrusted_content>\n${escapeXml(text)}\n</untrusted_content>`;

package/dist/mcp-server.js

@@ -1,3 +1,5 @@
+import { readFile } from "node:fs/promises";
+import { basename } from "node:path";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
@@ -82,6 +84,22 @@ const TOOLS = [
             required: ["url"],
         },
     },
+    {
+        name: "agentfeed_upload_file",
+        description: "Upload a file to AgentFeed. Returns the URL that can be used in markdown. " +
+            "For images: ![alt](/api/uploads/up_xxx.png), for others: [filename](/api/uploads/up_xxx.ext). " +
+            "Use this to share generated charts, images, or any files in posts and comments.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                file_path: {
+                    type: "string",
+                    description: "Absolute path to the file to upload (e.g. /tmp/chart.svg)",
+                },
+            },
+            required: ["file_path"],
+        },
+    },
     {
         name: "agentfeed_set_status",
         description: "Report agent status (thinking/idle)",
@@ -184,6 +202,56 @@ async function handleToolCall(name, args, ctx) {
                 ],
             };
         }
+        case "agentfeed_upload_file": {
+            const { file_path } = args;
+            const fileBuffer = await readFile(file_path);
+            const fileName = basename(file_path);
+            const ext = fileName.includes(".") ? fileName.split(".").pop().toLowerCase() : "";
+            const mimeTypes = {
+                svg: "image/svg+xml",
+                png: "image/png",
+                jpg: "image/jpeg",
+                jpeg: "image/jpeg",
+                gif: "image/gif",
+                webp: "image/webp",
+                pdf: "application/pdf",
+                json: "application/json",
+                csv: "text/csv",
+                txt: "text/plain",
+                md: "text/markdown",
+                html: "text/html",
+                mp4: "video/mp4",
+                webm: "video/webm",
+            };
+            const mimeType = mimeTypes[ext] || "application/octet-stream";
+            const blob = new Blob([fileBuffer], { type: mimeType });
+            const formData = new FormData();
+            formData.append("file", blob, fileName);
+            const uploadRes = await fetch(`${serverUrl}/api/uploads`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${client.apiKey}`,
+                    Origin: serverUrl,
+                    ...(client.agentId ? { "X-Agent-Id": client.agentId } : {}),
+                },
+                body: formData,
+            });
+            if (!uploadRes.ok)
+                throw new Error(`Failed to upload file: ${uploadRes.status} ${await uploadRes.text()}`);
+            const upload = (await uploadRes.json());
+            const isImage = upload.mime_type.startsWith("image/");
+            const markdown = isImage
+                ? `![${fileName}](${upload.url})`
+                : `[${fileName}](${upload.url})`;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `File uploaded successfully.\nURL: ${upload.url}\nMarkdown: ${markdown}\nSize: ${upload.size} bytes`,
+                    },
+                ],
+            };
+        }
         case "agentfeed_set_status": {
             const { status, feed_id, post_id } = args;
             await client.setAgentStatus({ status, feed_id, post_id });

package/dist/post-session-store.d.ts

@@ -11,10 +11,14 @@ export declare class PostSessionStore extends PersistentStore {
     protected deserialize(raw: string): void;
     /** Get raw sessionName (legacy compat — for callers that don't need backendType) */
     get(postId: string): string | undefined;
-    /** Get both backendType and sessionName. Legacy values without colon default to claude. */
+    /** Get both backendType and sessionName for first entry (legacy compat) */
     getWithType(postId: string): PostSessionInfo | undefined;
+    /** Get all backend sessions for a post */
+    getAll(postId: string): PostSessionInfo[];
     private static readonly MAX_SIZE;
-    /** Store as "backendType:sessionName" */
+    /** Add backend session (legacy compat: set = add) */
     set(postId: string, backendType: BackendType, sessionName: string): void;
+    /** Add backend session to post (prevents duplicates) */
+    add(postId: string, backendType: BackendType, sessionName: string): void;
     removeBySessionName(sessionName: string): void;
 }

package/dist/post-session-store.js

@@ -11,37 +11,56 @@ export class PostSessionStore extends PersistentStore {
     deserialize(raw) {
         const data = JSON.parse(raw);
         for (const [k, v] of Object.entries(data)) {
-            this.map.set(k, v);
+            // Support both legacy single value and new array format
+            this.map.set(k, Array.isArray(v) ? v : [v]);
         }
     }
     /** Get raw sessionName (legacy compat — for callers that don't need backendType) */
     get(postId) {
-        const raw = this.map.get(postId);
-        if (!raw)
+        const raws = this.map.get(postId);
+        if (!raws || raws.length === 0)
             return undefined;
-        // Parse "backendType:sessionName" or plain "sessionName"
-        const colonIdx = raw.indexOf(":");
-        return colonIdx >= 0 ? raw.slice(colonIdx + 1) : raw;
+        // Return first sessionName
+        const first = raws[0];
+        const colonIdx = first.indexOf(":");
+        return colonIdx >= 0 ? first.slice(colonIdx + 1) : first;
     }
-    /** Get both backendType and sessionName. Legacy values without colon default to claude. */
+    /** Get both backendType and sessionName for first entry (legacy compat) */
     getWithType(postId) {
-        const raw = this.map.get(postId);
-        if (!raw)
-            return undefined;
-        const colonIdx = raw.indexOf(":");
-        if (colonIdx >= 0) {
-            return {
-                backendType: raw.slice(0, colonIdx),
-                sessionName: raw.slice(colonIdx + 1),
-            };
-        }
-        // Legacy: no colon → assume claude
-        return { backendType: "claude", sessionName: raw };
+        const all = this.getAll(postId);
+        return all.length > 0 ? all[0] : undefined;
+    }
+    /** Get all backend sessions for a post */
+    getAll(postId) {
+        const raws = this.map.get(postId);
+        if (!raws)
+            return [];
+        return raws.map((raw) => {
+            const colonIdx = raw.indexOf(":");
+            if (colonIdx >= 0) {
+                return {
+                    backendType: raw.slice(0, colonIdx),
+                    sessionName: raw.slice(colonIdx + 1),
+                };
+            }
+            // Legacy: no colon → assume claude
+            return { backendType: "claude", sessionName: raw };
+        });
     }
     static MAX_SIZE = 1000;
-    /** Store as "backendType:sessionName" */
+    /** Add backend session (legacy compat: set = add) */
     set(postId, backendType, sessionName) {
-        this.map.set(postId, `${backendType}:${sessionName}`);
+        this.add(postId, backendType, sessionName);
+    }
+    /** Add backend session to post (prevents duplicates) */
+    add(postId, backendType, sessionName) {
+        const entry = `${backendType}:${sessionName}`;
+        const existing = this.map.get(postId) ?? [];
+        // Prevent duplicates
+        if (!existing.includes(entry)) {
+            existing.push(entry);
+            this.map.set(postId, existing);
+        }
         // Evict oldest entries if over limit
         if (this.map.size > PostSessionStore.MAX_SIZE) {
             const iter = this.map.keys();
@@ -57,12 +76,19 @@ export class PostSessionStore extends PersistentStore {
     }
     removeBySessionName(sessionName) {
         let changed = false;
-        for (const [postId, raw] of this.map) {
-            // Match both "backendType:sessionName" and legacy "sessionName"
-            const colonIdx = raw.indexOf(":");
-            const name = colonIdx >= 0 ? raw.slice(colonIdx + 1) : raw;
-            if (name === sessionName) {
-                this.map.delete(postId);
+        for (const [postId, raws] of this.map) {
+            const filtered = raws.filter((raw) => {
+                const colonIdx = raw.indexOf(":");
+                const name = colonIdx >= 0 ? raw.slice(colonIdx + 1) : raw;
+                return name !== sessionName;
+            });
+            if (filtered.length !== raws.length) {
+                if (filtered.length === 0) {
+                    this.map.delete(postId);
+                }
+                else {
+                    this.map.set(postId, filtered);
+                }
                 changed = true;
             }
         }

package/dist/processor.d.ts

@@ -18,4 +18,5 @@ export interface ProcessorDeps {
     agentRegistry: AgentRegistryStore;
     ensureSessionAgent: (sessionName: string, agentName: string, backendType: BackendType) => Promise<string>;
 }
+export declare function loadSettings(client: AgentFeedClient): Promise<void>;
 export declare function handleTriggers(triggers: TriggerContext[], deps: ProcessorDeps): void;

package/dist/processor.js

@@ -4,25 +4,58 @@ const MAX_WAKE_ATTEMPTS = 3;
 const MAX_CRASH_RETRIES = 3;
 const AGENT_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
 const MAX_CONCURRENT = 5;
-const MAX_BOT_MENTIONS_PER_POST = 4;
+// Time-window based bot mention limits (loaded from server)
+let botMentionLimit = 4;
+let botMentionWindowMs = 5 * 60 * 1000; // 5 minutes
 const wakeAttempts = new Map();
-const botMentionCounts = new Map();
+const botMentionTimestamps = new Map();
 const runningKeys = new Set();
+let retryTimer = null;
+const RETRY_DELAY_MS = 3000;
 // Periodic cleanup to prevent memory growth
-setInterval(() => { wakeAttempts.clear(); botMentionCounts.clear(); }, 10 * 60 * 1000);
+setInterval(() => {
+    wakeAttempts.clear();
+    // Clean up old timestamps beyond the window
+    const now = Date.now();
+    for (const [postId, timestamps] of botMentionTimestamps.entries()) {
+        const recent = timestamps.filter((ts) => now - ts < botMentionWindowMs);
+        if (recent.length === 0) {
+            botMentionTimestamps.delete(postId);
+        }
+        else {
+            botMentionTimestamps.set(postId, recent);
+        }
+    }
+}, 10 * 60 * 1000);
 function triggerKey(t) {
     return `${t.backendType}:${t.sessionName}`;
 }
+export async function loadSettings(client) {
+    try {
+        const settings = await client.getSettings();
+        botMentionLimit = settings.bot_mention_limit;
+        botMentionWindowMs = settings.bot_mention_window_minutes * 60 * 1000;
+        console.log(`Loaded settings: bot_mention_limit=${botMentionLimit}, bot_mention_window_minutes=${settings.bot_mention_window_minutes}`);
+    }
+    catch (err) {
+        console.error("Failed to load settings from server, using defaults:", err);
+    }
+}
 export function handleTriggers(triggers, deps) {
+    const now = Date.now();
     for (const t of triggers) {
-        // Prevent bot-to-bot mention loops
+        // Prevent bot-to-bot mention loops (time-window based)
         if (t.authorIsBot && t.triggerType === "mention") {
-            const count = botMentionCounts.get(t.postId) ?? 0;
-            if (count >= MAX_BOT_MENTIONS_PER_POST) {
-                console.log(`Skipping bot mention on ${t.postId}: loop limit (${MAX_BOT_MENTIONS_PER_POST}) reached`);
+            const timestamps = botMentionTimestamps.get(t.postId) ?? [];
+            // Filter timestamps within the current window
+            const recentTimestamps = timestamps.filter((ts) => now - ts < botMentionWindowMs);
+            if (recentTimestamps.length >= botMentionLimit) {
+                console.log(`Skipping bot mention on ${t.postId}: loop limit (${botMentionLimit} mentions in ${botMentionWindowMs / 1000 / 60} minutes) reached`);
                 continue;
             }
-            botMentionCounts.set(t.postId, count + 1);
+            // Record this mention
+            recentTimestamps.push(now);
+            botMentionTimestamps.set(t.postId, recentTimestamps);
         }
         deps.queueStore.push(t);
         console.log(`Queued trigger: ${t.triggerType} on ${t.postId} [${t.backendType}] (queue size: ${deps.queueStore.size})`);
@@ -34,6 +67,7 @@ function scheduleQueue(deps) {
     if (queued.length === 0)
         return;
     const toRun = [];
+    let hasRequeued = false;
     for (const t of queued) {
         const attempts = wakeAttempts.get(t.eventId) ?? 0;
         if (attempts >= MAX_WAKE_ATTEMPTS) {
@@ -44,12 +78,22 @@ function scheduleQueue(deps) {
         if (runningKeys.size >= MAX_CONCURRENT || runningKeys.has(key)) {
             // Same backend+session already running — re-queue
             deps.queueStore.push(t);
+            hasRequeued = true;
         }
         else {
             toRun.push(t);
             runningKeys.add(key);
         }
     }
+    // Schedule retry for re-queued items so they don't wait for next SSE event
+    if (hasRequeued) {
+        if (retryTimer)
+            clearTimeout(retryTimer);
+        retryTimer = setTimeout(() => {
+            retryTimer = null;
+            scheduleQueue(deps);
+        }, RETRY_DELAY_MS);
+    }
     for (const trigger of toRun) {
         processItem(trigger, deps).catch((err) => {
             console.error(`Error processing ${trigger.postId}:`, err);
@@ -86,6 +130,7 @@ async function processItem(trigger, deps) {
             ? ba.config.allowed_tools
             : deps.extraAllowedTools;
         const effectiveModel = ba.config?.model;
+        const effectiveChrome = ba.config?.chrome ?? false;
         let retries = 0;
         let success = false;
         try {
@@ -100,6 +145,7 @@ async function processItem(trigger, deps) {
                         permissionMode: effectivePermission,
                         extraAllowedTools: effectiveTools,
                         model: effectiveModel ?? undefined,
+                        chrome: effectiveChrome,
                         sessionId: ba.sessionStore.get(trigger.sessionName),
                         agentId: sessionAgentId,
                         timeoutMs: AGENT_TIMEOUT_MS,
@@ -107,14 +153,22 @@ async function processItem(trigger, deps) {
                     if (result.sessionId) {
                         ba.sessionStore.set(trigger.sessionName, result.sessionId);
                         deps.postSessionStore.set(trigger.postId, trigger.backendType, trigger.sessionName);
+                        console.log(`Saved post-session mapping: ${trigger.postId} → [${trigger.backendType}] ${trigger.sessionName}`);
                         await deps.client.reportSession(trigger.sessionName, result.sessionId, sessionAgentId).catch((err) => {
                             console.warn("Failed to report session:", err);
                         });
                     }
+                    else {
+                        console.warn(`No session ID returned by ${trigger.backendType}, post-session mapping not saved`);
+                    }
                     if (result.exitCode === 0) {
                         success = true;
                         break;
                     }
+                    if (result.timedOut) {
+                        console.warn("Agent timed out, skipping retry");
+                        break;
+                    }
                     if (result.exitCode !== 0 && ba.sessionStore.get(trigger.sessionName)) {
                         console.log("Session may be stale, clearing and retrying as new session...");
                         ba.sessionStore.delete(trigger.sessionName);

package/dist/trigger.js

@@ -45,19 +45,36 @@ export function detectTriggers(event, backendAgents, followStore, postSessionSto
             return mentions;
         // Trigger 3: Comment in a followed thread (human-authored only — prevents bot loop)
         if (!authorIsOwnBot && followStore?.has(event.post_id)) {
-            const postSession = postSessionStore?.getWithType(event.post_id);
-            return [{
-                    triggerType: "thread_follow_up",
-                    eventId: event.id,
-                    feedId: event.feed_id,
-                    feedName: "",
-                    postId: event.post_id,
-                    content: event.content,
-                    authorName: event.author_name,
-                    authorIsBot: event.author_type === "bot",
-                    sessionName: postSession?.sessionName ?? "default",
-                    backendType: postSession?.backendType ?? defaultBackendType,
-                }];
+            const postSessions = postSessionStore?.getAll(event.post_id) ?? [];
+            if (postSessions.length === 0) {
+                console.log(`Thread follow-up on ${event.post_id}: no post-session found, using default [${defaultBackendType}]`);
+                return [{
+                        triggerType: "thread_follow_up",
+                        eventId: event.id,
+                        feedId: event.feed_id,
+                        feedName: "",
+                        postId: event.post_id,
+                        content: event.content,
+                        authorName: event.author_name,
+                        authorIsBot: event.author_type === "bot",
+                        sessionName: "default",
+                        backendType: defaultBackendType,
+                    }];
+            }
+            // Trigger ALL backends that participated in this thread
+            console.log(`Thread follow-up on ${event.post_id}: triggering ${postSessions.length} backend(s) [${postSessions.map(s => s.backendType).join(", ")}]`);
+            return postSessions.map((ps) => ({
+                triggerType: "thread_follow_up",
+                eventId: `${event.id}:${ps.backendType}`,
+                feedId: event.feed_id,
+                feedName: "",
+                postId: event.post_id,
+                content: event.content,
+                authorName: event.author_name,
+                authorIsBot: event.author_type === "bot",
+                sessionName: ps.sessionName,
+                backendType: ps.backendType,
+            }));
         }
     }
     if (event.type === "post_created") {

package/dist/types.d.ts

@@ -9,6 +9,7 @@ export interface AgentConfig {
     permission_mode: PermissionMode;
     allowed_tools: string[];
     model: string | null;
+    chrome: boolean;
 }
 export interface BackendAgent {
     backendType: BackendType;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentfeed",
-  "version": "0.1.11",
+  "version": "0.1.14",
   "description": "Worker daemon for AgentFeed - watches feeds and wakes AI agents via claude -p",
   "type": "module",
   "bin": {