@dotsetlabs/dotclaw 1.1.0 → 1.3.0

package/dist/index.js

@@ -6,8 +6,9 @@ import path from 'path';
 import { DATA_DIR, MAIN_GROUP_FOLDER, GROUPS_DIR, IPC_POLL_INTERVAL, TIMEZONE, CONTAINER_MODE, WARM_START_ENABLED, ENV_PATH } from './config.js';
 // Load .env from the canonical location (~/.dotclaw/.env)
 dotenv.config({ path: ENV_PATH });
-import { initDatabase, storeMessage, getMessagesSinceCursor, getChatState, updateChatState, createTask, updateTask, deleteTask, getTaskById, getAllGroupSessions, setGroupSession, deleteGroupSession, pauseTasksForGroup, linkMessageToTrace, getTraceIdForMessage, recordUserFeedback } from './db.js';
-import { startSchedulerLoop } from './task-scheduler.js';
+import { initDatabase, storeMessage, upsertChat, getMessagesSinceCursor, getChatState, updateChatState, createTask, updateTask, deleteTask, getTaskById, getAllGroupSessions, setGroupSession, deleteGroupSession, pauseTasksForGroup, linkMessageToTrace, getTraceIdForMessage, recordUserFeedback } from './db.js';
+import { startSchedulerLoop, runTaskNow } from './task-scheduler.js';
+import { startBackgroundJobLoop, spawnBackgroundJob, getBackgroundJobStatus, listBackgroundJobsForGroup, cancelBackgroundJob, recordBackgroundJobUpdate } from './background-jobs.js';
 import { loadJson, saveJson, isSafeGroupFolder } from './utils.js';
 import { writeTrace } from './trace-writer.js';
 import { formatTelegramMessage, TELEGRAM_PARSE_MODE } from './telegram-format.js';
@@ -24,6 +25,7 @@ import { createTraceBase, executeAgentRun, recordAgentTelemetry, AgentExecutionE
 import { logger } from './logger.js';
 import { startDashboard, setTelegramConnected, setLastMessageTime, setMessageQueueDepth } from './dashboard.js';
 import { humanizeError } from './error-messages.js';
+import { classifyBackgroundJob } from './background-job-classifier.js';
 const runtime = loadRuntimeConfig();
 function buildTriggerRegex(pattern) {
     if (!pattern)
@@ -35,10 +37,6 @@ function buildTriggerRegex(pattern) {
         return null;
     }
 }
-function isPreemptedError(err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return message.toLowerCase().includes('preempt');
-}
 function buildAvailableGroupsSnapshot() {
     return Object.entries(registeredGroups).map(([jid, info]) => ({
         jid,
@@ -158,22 +156,14 @@ const PROGRESS_MESSAGES = runtime.host.progress.messages.length > 0
 const HEARTBEAT_ENABLED = runtime.host.heartbeat.enabled;
 const HEARTBEAT_INTERVAL_MS = runtime.host.heartbeat.intervalMs;
 const HEARTBEAT_GROUP_FOLDER = (runtime.host.heartbeat.groupFolder || MAIN_GROUP_FOLDER).trim() || MAIN_GROUP_FOLDER;
-const BACKGROUND_TASKS_ENABLED = runtime.host.backgroundTasks.enabled;
-const BACKGROUND_TRIGGER_REGEX = runtime.host.backgroundTasks.triggerRegex;
-const BACKGROUND_TRIGGER = buildTriggerRegex(BACKGROUND_TRIGGER_REGEX);
-const BACKGROUND_ACK_MESSAGE = runtime.host.backgroundTasks.ackMessage;
-const BACKGROUND_TOOL_DENY = runtime.host.backgroundTasks.toolDeny;
-const PREEMPT_ON_NEW_MESSAGE = runtime.host.backgroundTasks.preemptOnNewMessage;
-function shouldRunInBackground(content) {
-    if (!BACKGROUND_TASKS_ENABLED)
-        return false;
-    const trimmed = content.trim();
-    if (!trimmed)
-        return false;
-    if (BACKGROUND_TRIGGER && BACKGROUND_TRIGGER.test(trimmed))
-        return true;
-    return false;
-}
+const BACKGROUND_JOBS_ENABLED = runtime.host.backgroundJobs.enabled;
+const AUTO_SPAWN_CONFIG = runtime.host.backgroundJobs.autoSpawn;
+const AUTO_SPAWN_ENABLED = BACKGROUND_JOBS_ENABLED && AUTO_SPAWN_CONFIG.enabled;
+const AUTO_SPAWN_FOREGROUND_TIMEOUT_MS = AUTO_SPAWN_CONFIG.foregroundTimeoutMs;
+const AUTO_SPAWN_ON_TIMEOUT = AUTO_SPAWN_CONFIG.onTimeout;
+const AUTO_SPAWN_ON_TOOL_LIMIT = AUTO_SPAWN_CONFIG.onToolLimit;
+const AUTO_SPAWN_CLASSIFIER_ENABLED = AUTO_SPAWN_CONFIG.classifier.enabled;
+const TOOL_CALL_FALLBACK_PATTERN = /tool calls? but did not get a final response/i;
 // Initialize Telegram bot with extended timeout for long-running agent tasks
 const telegrafBot = new Telegraf(process.env.TELEGRAM_BOT_TOKEN, {
     handlerTimeout: TELEGRAM_HANDLER_TIMEOUT_MS
@@ -186,7 +176,6 @@ let registeredGroups = {};
 const TELEGRAM_MAX_MESSAGE_LENGTH = 4000;
 const TELEGRAM_SEND_DELAY_MS = 250;
 const messageQueues = new Map();
-const inFlightRuns = new Map();
 const draftSessions = new Map();
 function parseTelegramStreamMode(value) {
     const normalized = value.trim().toLowerCase();
@@ -577,13 +566,6 @@ async function finalizeStreamedMessage(msg, draftId, text) {
     clearDraftSession(msg.chatId, draftId);
 }
 function enqueueMessage(msg) {
-    if (PREEMPT_ON_NEW_MESSAGE) {
-        const inFlight = inFlightRuns.get(msg.chatId);
-        if (inFlight && !inFlight.controller.signal.aborted) {
-            logger.warn({ chatId: msg.chatId }, 'Preempting in-flight agent run');
-            inFlight.controller.abort();
-        }
-    }
     const existing = messageQueues.get(msg.chatId);
     if (existing) {
         existing.pendingMessage = msg;
@@ -659,18 +641,6 @@ async function processMessage(msg) {
 ${lines.join('\n')}
 </messages>`;
     const lastMessage = missedMessages[missedMessages.length - 1];
-    if (lastMessage && shouldRunInBackground(lastMessage.content)) {
-        logger.info({ group: group.name }, 'Routing message to background task');
-        updateChatState(msg.chatId, lastMessage.timestamp, lastMessage.id);
-        await sendMessage(msg.chatId, BACKGROUND_ACK_MESSAGE, { messageThreadId: msg.messageThreadId });
-        void runBackgroundTask({
-            msg,
-            group,
-            prompt,
-            missedMessages
-        });
-        return true;
-    }
     const traceBase = createTraceBase({
         chatId: msg.chatId,
         groupFolder: group.folder,
@@ -687,6 +657,69 @@ ${lines.join('\n')}
     let output = null;
     let context = null;
     let errorMessage = null;
+    const isTimeoutError = (value) => {
+        if (!value)
+            return false;
+        return /timed out|timeout/i.test(value);
+    };
+    const maybeAutoSpawn = async (reason, detail) => {
+        if (!AUTO_SPAWN_ENABLED)
+            return false;
+        if (reason === 'timeout' && !AUTO_SPAWN_ON_TIMEOUT)
+            return false;
+        if (reason === 'tool_limit' && !AUTO_SPAWN_ON_TOOL_LIMIT)
+            return false;
+        const result = spawnBackgroundJob({
+            prompt,
+            groupFolder: group.folder,
+            chatJid: msg.chatId,
+            contextMode: 'group',
+            tags: ['auto-spawn', reason],
+            parentTraceId: traceBase.trace_id,
+            parentMessageId: msg.messageId
+        });
+        if (!result.ok || !result.jobId) {
+            logger.warn({ chatId: msg.chatId, reason, error: result.error }, 'Auto-spawn background job failed');
+            return false;
+        }
+        const detailLine = detail ? `\n\nReason: ${detail}` : '';
+        await sendMessage(msg.chatId, `Queued this as background job ${result.jobId}. I'll report back when it's done. You can keep chatting while it runs.${detailLine}`, { messageThreadId: msg.messageThreadId });
+        if (lastMessage) {
+            updateChatState(msg.chatId, lastMessage.timestamp, lastMessage.id);
+        }
+        if (draftId) {
+            clearDraftSession(msg.chatId, draftId);
+        }
+        return true;
+    };
+    if (AUTO_SPAWN_ENABLED && AUTO_SPAWN_CLASSIFIER_ENABLED && lastMessage) {
+        try {
+            const classifierResult = await classifyBackgroundJob({
+                lastMessage,
+                recentMessages: missedMessages,
+                isGroup: msg.isGroup,
+                chatType: msg.chatType
+            });
+            logger.info({
+                chatId: msg.chatId,
+                decision: classifierResult.shouldBackground,
+                confidence: classifierResult.confidence,
+                latencyMs: classifierResult.latencyMs,
+                model: classifierResult.model,
+                reason: classifierResult.reason,
+                error: classifierResult.error
+            }, 'Background job classifier decision');
+            if (classifierResult.shouldBackground) {
+                const autoSpawned = await maybeAutoSpawn('classifier');
+                if (autoSpawned) {
+                    return true;
+                }
+            }
+        }
+        catch (err) {
+            logger.warn({ chatId: msg.chatId, err }, 'Background job classifier failed');
+        }
+    }
     const progressNotifier = createProgressNotifier({
         enabled: PROGRESS_ENABLED && !streamingEnabled,
         initialDelayMs: PROGRESS_INITIAL_MS,
@@ -717,7 +750,10 @@ ${lines.join('\n')}
                     minChars: TELEGRAM_STREAM_MIN_CHARS
                 }
                 : undefined,
-            availableGroups: buildAvailableGroupsSnapshot()
+            availableGroups: buildAvailableGroupsSnapshot(),
+            timeoutMs: AUTO_SPAWN_ENABLED && AUTO_SPAWN_FOREGROUND_TIMEOUT_MS > 0
+                ? AUTO_SPAWN_FOREGROUND_TIMEOUT_MS
+                : undefined
         });
         output = execution.output;
         context = execution.context;
@@ -768,6 +804,12 @@ ${lines.join('\n')}
                 source: traceBase.source
             });
         }
+        if (isTimeoutError(message)) {
+            const autoSpawned = await maybeAutoSpawn('timeout', message);
+            if (autoSpawned) {
+                return true;
+            }
+        }
         const userMessage = humanizeError(errorMessage || 'Unknown error');
         await sendMessage(msg.chatId, userMessage, { messageThreadId: msg.messageThreadId });
         if (draftId) {
@@ -788,7 +830,14 @@ ${lines.join('\n')}
             });
         }
         logger.error({ group: group.name, error: output.error }, 'Container agent error');
-        const userMessage = humanizeError(errorMessage || output.error || 'Unknown error');
+        const errorText = errorMessage || output.error || 'Unknown error';
+        if (isTimeoutError(errorText)) {
+            const autoSpawned = await maybeAutoSpawn('timeout', errorText);
+            if (autoSpawned) {
+                return true;
+            }
+        }
+        const userMessage = humanizeError(errorText);
         await sendMessage(msg.chatId, userMessage, { messageThreadId: msg.messageThreadId });
         if (draftId) {
             clearDraftSession(msg.chatId, draftId);
@@ -819,6 +868,22 @@ ${lines.join('\n')}
         }
     }
     else if (output.tool_calls && output.tool_calls.length > 0) {
+        const toolLimitHit = !output.result || !output.result.trim() || TOOL_CALL_FALLBACK_PATTERN.test(output.result);
+        if (toolLimitHit) {
+            const autoSpawned = await maybeAutoSpawn('tool_limit', 'Tool-call step limit reached');
+            if (autoSpawned) {
+                if (context) {
+                    recordAgentTelemetry({
+                        traceBase,
+                        output,
+                        context,
+                        metricsSource: 'telegram',
+                        toolAuditSource: 'message'
+                    });
+                }
+                return true;
+            }
+        }
         await sendMessage(msg.chatId, 'I hit my tool-call step limit before I could finish. If you want me to keep going, please narrow the scope or ask for a specific subtask.', { messageThreadId: msg.messageThreadId });
         if (draftId) {
             clearDraftSession(msg.chatId, draftId);
@@ -841,186 +906,6 @@ ${lines.join('\n')}
     }
     return true;
 }
-async function runBackgroundTask(params) {
-    const { msg, group, prompt, missedMessages } = params;
-    const traceBase = createTraceBase({
-        chatId: msg.chatId,
-        groupFolder: group.folder,
-        userId: msg.senderId,
-        inputText: prompt,
-        source: 'dotclaw-background'
-    });
-    const recallQuery = missedMessages.map(entry => entry.content).join('\n');
-    const runId = `bg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-    const abortController = new AbortController();
-    if (PREEMPT_ON_NEW_MESSAGE) {
-        inFlightRuns.set(msg.chatId, { controller: abortController, runId });
-    }
-    let output = null;
-    let context = null;
-    let errorMessage = null;
-    try {
-        const execution = await executeAgentRun({
-            group,
-            prompt,
-            chatJid: msg.chatId,
-            userId: msg.senderId,
-            userName: msg.senderName,
-            recallQuery: recallQuery || msg.content,
-            recallMaxResults: MEMORY_RECALL_MAX_RESULTS,
-            recallMaxTokens: MEMORY_RECALL_MAX_TOKENS,
-            toolDeny: BACKGROUND_TOOL_DENY,
-            sessionId: runId,
-            persistSession: false,
-            useGroupLock: false,
-            abortSignal: abortController.signal,
-            isBackgroundTask: true,
-            availableGroups: buildAvailableGroupsSnapshot()
-        });
-        output = execution.output;
-        context = execution.context;
-        if (output.status === 'error') {
-            errorMessage = output.error || 'Unknown error';
-        }
-    }
-    catch (err) {
-        if (err instanceof AgentExecutionError) {
-            context = err.context;
-            errorMessage = err.message;
-        }
-        else {
-            errorMessage = err instanceof Error ? err.message : String(err);
-        }
-        if (abortController.signal.aborted || isPreemptedError(err)) {
-            if (context) {
-                recordAgentTelemetry({
-                    traceBase,
-                    output,
-                    context,
-                    metricsSource: 'telegram',
-                    toolAuditSource: 'background',
-                    errorMessage: 'preempted'
-                });
-            }
-            else {
-                writeTrace({
-                    trace_id: traceBase.trace_id,
-                    timestamp: traceBase.timestamp,
-                    created_at: traceBase.created_at,
-                    chat_id: traceBase.chat_id,
-                    group_folder: traceBase.group_folder,
-                    user_id: traceBase.user_id,
-                    input_text: traceBase.input_text,
-                    output_text: null,
-                    model_id: 'unknown',
-                    memory_recall: [],
-                    error_code: 'preempted',
-                    source: traceBase.source
-                });
-            }
-            logger.warn({ chatId: msg.chatId }, 'Background run preempted; skipping response');
-            return;
-        }
-        logger.error({ group: group.name, err }, 'Background agent error');
-    }
-    finally {
-        if (PREEMPT_ON_NEW_MESSAGE) {
-            const current = inFlightRuns.get(msg.chatId);
-            if (current?.runId === runId) {
-                inFlightRuns.delete(msg.chatId);
-            }
-        }
-    }
-    if (!output) {
-        if (context) {
-            recordAgentTelemetry({
-                traceBase,
-                output: null,
-                context,
-                metricsSource: 'telegram',
-                toolAuditSource: 'background',
-                errorMessage: errorMessage || 'No output from background agent',
-                errorType: 'agent'
-            });
-        }
-        else {
-            recordError('agent');
-            writeTrace({
-                trace_id: traceBase.trace_id,
-                timestamp: traceBase.timestamp,
-                created_at: traceBase.created_at,
-                chat_id: traceBase.chat_id,
-                group_folder: traceBase.group_folder,
-                user_id: traceBase.user_id,
-                input_text: traceBase.input_text,
-                output_text: null,
-                model_id: 'unknown',
-                memory_recall: [],
-                error_code: errorMessage || 'No output from background agent',
-                source: traceBase.source
-            });
-        }
-        return;
-    }
-    if (output.status === 'error') {
-        if (abortController.signal.aborted || isPreemptedError(output.error)) {
-            if (context) {
-                recordAgentTelemetry({
-                    traceBase,
-                    output,
-                    context,
-                    metricsSource: 'telegram',
-                    toolAuditSource: 'background',
-                    errorMessage: 'preempted'
-                });
-            }
-            logger.warn({ chatId: msg.chatId }, 'Background run preempted; skipping response');
-            return;
-        }
-        if (context) {
-            recordAgentTelemetry({
-                traceBase,
-                output,
-                context,
-                metricsSource: 'telegram',
-                toolAuditSource: 'background',
-                errorMessage: errorMessage || output.error || 'Unknown error',
-                errorType: 'agent'
-            });
-        }
-        logger.error({ group: group.name, error: output.error }, 'Background agent error');
-        const userMessage = humanizeError(errorMessage || output.error || 'Unknown error');
-        await sendMessage(msg.chatId, userMessage, { messageThreadId: msg.messageThreadId });
-        return;
-    }
-    if (output.result && output.result.trim()) {
-        const sendResult = await sendMessage(msg.chatId, output.result, { messageThreadId: msg.messageThreadId });
-        // Link the sent message to the trace for feedback tracking
-        if (sendResult.messageId) {
-            try {
-                linkMessageToTrace(sendResult.messageId, msg.chatId, traceBase.trace_id);
-            }
-            catch {
-                // Don't fail if linking fails
-            }
-        }
-    }
-    else if (output.tool_calls && output.tool_calls.length > 0) {
-        await sendMessage(msg.chatId, 'I hit my tool-call step limit before I could finish. If you want me to keep going, please narrow the scope or ask for a specific subtask.', { messageThreadId: msg.messageThreadId });
-    }
-    else {
-        await sendMessage(msg.chatId, "I wasn't able to generate a response this time. Please try again or rephrase your request.", { messageThreadId: msg.messageThreadId });
-    }
-    if (context) {
-        recordAgentTelemetry({
-            traceBase,
-            output,
-            context,
-            metricsSource: 'telegram',
-            toolAuditSource: 'background'
-        });
-    }
-}
 function startIpcWatcher() {
     const ipcBaseDir = path.join(DATA_DIR, 'ipc');
     fs.mkdirSync(ipcBaseDir, { recursive: true });
@@ -1597,6 +1482,139 @@ async function processRequestIpc(data, sourceGroup, isMain) {
                 const groups = listRegisteredGroups();
                 return { id: requestId, ok: true, result: { groups } };
             }
+            case 'run_task': {
+                const taskId = typeof payload.task_id === 'string' ? payload.task_id : '';
+                if (!taskId) {
+                    return { id: requestId, ok: false, error: 'task_id is required.' };
+                }
+                const task = getTaskById(taskId);
+                if (!task) {
+                    return { id: requestId, ok: false, error: 'Task not found.' };
+                }
+                if (!isMain && task.group_folder !== sourceGroup) {
+                    return { id: requestId, ok: false, error: 'Unauthorized task run attempt.' };
+                }
+                const result = await runTaskNow(taskId, {
+                    sendMessage: async (jid, text) => { await sendMessage(jid, text); },
+                    registeredGroups: () => registeredGroups,
+                    getSessions: () => sessions,
+                    setSession: (groupFolder, sessionId) => { sessions[groupFolder] = sessionId; }
+                });
+                return {
+                    id: requestId,
+                    ok: result.ok,
+                    result: { result: result.result ?? null },
+                    error: result.ok ? undefined : result.error
+                };
+            }
+            case 'spawn_job': {
+                const prompt = typeof payload.prompt === 'string' ? payload.prompt.trim() : '';
+                if (!prompt) {
+                    return { id: requestId, ok: false, error: 'prompt is required.' };
+                }
+                const targetGroup = (typeof payload.target_group === 'string' && isMain)
+                    ? payload.target_group
+                    : sourceGroup;
+                const groupEntry = Object.entries(registeredGroups).find(([, group]) => group.folder === targetGroup);
+                if (!groupEntry) {
+                    return { id: requestId, ok: false, error: 'Target group not registered.' };
+                }
+                const [chatId, group] = groupEntry;
+                const result = spawnBackgroundJob({
+                    prompt,
+                    groupFolder: group.folder,
+                    chatJid: chatId,
+                    contextMode: (payload.context_mode === 'group' || payload.context_mode === 'isolated')
+                        ? payload.context_mode
+                        : undefined,
+                    timeoutMs: typeof payload.timeout_ms === 'number' ? payload.timeout_ms : undefined,
+                    maxToolSteps: typeof payload.max_tool_steps === 'number' ? payload.max_tool_steps : undefined,
+                    toolAllow: Array.isArray(payload.tool_allow) ? payload.tool_allow : undefined,
+                    toolDeny: Array.isArray(payload.tool_deny) ? payload.tool_deny : undefined,
+                    modelOverride: typeof payload.model_override === 'string' ? payload.model_override : undefined,
+                    priority: typeof payload.priority === 'number' ? payload.priority : undefined,
+                    tags: Array.isArray(payload.tags) ? payload.tags : undefined,
+                    parentTraceId: typeof payload.parent_trace_id === 'string' ? payload.parent_trace_id : undefined,
+                    parentMessageId: typeof payload.parent_message_id === 'string' ? payload.parent_message_id : undefined
+                });
+                return {
+                    id: requestId,
+                    ok: result.ok,
+                    result: result.ok ? { job_id: result.jobId } : undefined,
+                    error: result.ok ? undefined : result.error
+                };
+            }
+            case 'job_status': {
+                const jobId = typeof payload.job_id === 'string' ? payload.job_id : '';
+                if (!jobId) {
+                    return { id: requestId, ok: false, error: 'job_id is required.' };
+                }
+                const job = getBackgroundJobStatus(jobId);
+                if (!job) {
+                    return { id: requestId, ok: false, error: 'Job not found.' };
+                }
+                if (!isMain && job.group_folder !== sourceGroup) {
+                    return { id: requestId, ok: false, error: 'Unauthorized job status request.' };
+                }
+                return { id: requestId, ok: true, result: { job } };
+            }
+            case 'list_jobs': {
+                const targetGroup = (typeof payload.target_group === 'string' && isMain)
+                    ? payload.target_group
+                    : sourceGroup;
+                const statusRaw = typeof payload.status === 'string' ? payload.status : undefined;
+                const allowedStatuses = ['queued', 'running', 'succeeded', 'failed', 'canceled', 'timed_out'];
+                const status = statusRaw && allowedStatuses.includes(statusRaw)
+                    ? statusRaw
+                    : undefined;
+                const limit = typeof payload.limit === 'number' ? payload.limit : undefined;
+                const jobs = listBackgroundJobsForGroup({ groupFolder: targetGroup, status, limit });
+                return { id: requestId, ok: true, result: { jobs } };
+            }
+            case 'cancel_job': {
+                const jobId = typeof payload.job_id === 'string' ? payload.job_id : '';
+                if (!jobId) {
+                    return { id: requestId, ok: false, error: 'job_id is required.' };
+                }
+                const job = getBackgroundJobStatus(jobId);
+                if (!job) {
+                    return { id: requestId, ok: false, error: 'Job not found.' };
+                }
+                if (!isMain && job.group_folder !== sourceGroup) {
+                    return { id: requestId, ok: false, error: 'Unauthorized job cancel attempt.' };
+                }
+                const result = cancelBackgroundJob(jobId);
+                return { id: requestId, ok: result.ok, error: result.error };
+            }
+            case 'job_update': {
+                const jobId = typeof payload.job_id === 'string' ? payload.job_id : '';
+                const message = typeof payload.message === 'string' ? payload.message.trim() : '';
+                const levelRaw = typeof payload.level === 'string' ? payload.level : 'progress';
+                const allowedLevels = ['info', 'progress', 'warn', 'error'];
+                const level = allowedLevels.includes(levelRaw)
+                    ? levelRaw
+                    : 'progress';
+                if (!jobId || !message) {
+                    return { id: requestId, ok: false, error: 'job_id and message are required.' };
+                }
+                const job = getBackgroundJobStatus(jobId);
+                if (!job) {
+                    return { id: requestId, ok: false, error: 'Job not found.' };
+                }
+                if (!isMain && job.group_folder !== sourceGroup) {
+                    return { id: requestId, ok: false, error: 'Unauthorized job update attempt.' };
+                }
+                const result = recordBackgroundJobUpdate({
+                    jobId,
+                    level,
+                    message,
+                    data: typeof payload.data === 'object' && payload.data ? payload.data : undefined
+                });
+                if (result.ok && payload.notify === true && job.chat_jid) {
+                    await sendMessage(job.chat_jid, `Background job ${job.id} update:\n\n${message}`);
+                }
+                return { id: requestId, ok: result.ok, error: result.error };
+            }
             default:
                 return { id: requestId, ok: false, error: `Unknown request type: ${data.type}` };
         }
@@ -1903,6 +1921,11 @@ function setupTelegramHandlers() {
         const isPrivate = chatType === 'private';
         const senderId = String(ctx.from?.id || ctx.chat.id);
         const senderName = ctx.from?.first_name || ctx.from?.username || 'User';
+        const chatName = ('title' in ctx.chat && ctx.chat.title)
+            || ('username' in ctx.chat && ctx.chat.username)
+            || ctx.from?.first_name
+            || ctx.from?.username
+            || senderName;
         const content = ctx.message.text;
         const timestamp = new Date(ctx.message.date * 1000).toISOString();
         const messageId = String(ctx.message.message_id);
@@ -1911,6 +1934,7 @@ function setupTelegramHandlers() {
         logger.info({ chatId, isGroup, senderName }, `Telegram message: ${content.substring(0, 50)}...`);
         try {
             // Store message in database
+            upsertChat({ chatId, name: chatName, lastMessageTime: timestamp });
             storeMessage(String(ctx.message.message_id), chatId, senderId, senderName, content, timestamp, false);
         }
         catch (error) {
@@ -2054,6 +2078,15 @@ async function main() {
                 setGroupSession(groupFolder, sessionId);
             }
         });
+        startBackgroundJobLoop({
+            sendMessage: sendMessageForScheduler,
+            registeredGroups: () => registeredGroups,
+            getSessions: () => sessions,
+            setSession: (groupFolder, sessionId) => {
+                sessions[groupFolder] = sessionId;
+                setGroupSession(groupFolder, sessionId);
+            }
+        });
         startIpcWatcher();
         startMaintenanceLoop();
         startHeartbeatLoop();