@pixelbyte-software/pixcode 1.36.4 → 1.38.0

package/server/routes/taskmaster.js

@@ -17,6 +17,12 @@ import express from 'express';
 import { orchestrationTaskService } from '@/modules/orchestration/tasks/orchestration-task.service.js';
 
 import { extractProjectDirectory } from '../projects.js';
+import {
+    cancelInstallJob,
+    createInstallJob,
+    getInstallJob,
+    snapshotDonePayload
+} from '../services/install-jobs.js';
 import { broadcastTaskMasterProjectUpdate, broadcastTaskMasterTasksUpdate } from '../utils/taskmaster-websocket.js';
 import { detectTaskMasterMCPServer } from '../utils/mcp-detector.js';
 
@@ -144,6 +150,17 @@ async function readTaskMasterTasks(projectName) {
     return { projectPath, transformedTasks, currentTag };
 }
 
+function taskMasterExecutionDescription(task) {
+    return [
+        task.description ? `Description:\n${task.description}` : '',
+        task.details ? `Details:\n${task.details}` : '',
+        task.testStrategy ? `Test strategy:\n${task.testStrategy}` : '',
+        Array.isArray(task.dependencies) && task.dependencies.length
+            ? `Dependencies: ${task.dependencies.join(', ')}`
+            : '',
+    ].filter(Boolean).join('\n\n');
+}
+
 // API Routes
 
 /**
@@ -181,6 +198,121 @@ router.get('/installation-status', async (req, res) => {
     }
 });
 
+/**
+ * POST /api/taskmaster/install
+ * Install TaskMaster CLI into Pixcode's sandboxed CLI bin.
+ */
+router.post('/install', async (req, res) => {
+    try {
+        const job = createInstallJob({
+            provider: 'taskmaster',
+            installCmd: 'npm install -g task-master',
+            packageName: 'task-master'
+        });
+
+        res.json({
+            success: true,
+            jobId: job.id,
+            provider: 'taskmaster',
+            packageName: 'task-master',
+            startedAt: job.startedAt
+        });
+    } catch (error) {
+        console.error('TaskMaster install start error:', error);
+        res.status(500).json({
+            success: false,
+            error: 'Failed to start TaskMaster install',
+            message: error.message
+        });
+    }
+});
+
+/**
+ * GET /api/taskmaster/install/:jobId/stream
+ * Replay and stream TaskMaster install output.
+ */
+router.get('/install/:jobId/stream', async (req, res) => {
+    const job = getInstallJob(req.params.jobId);
+    if (!job || job.provider !== 'taskmaster') {
+        return res.status(404).json({
+            success: false,
+            error: 'Install job not found or already expired'
+        });
+    }
+
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache, no-transform');
+    res.setHeader('Connection', 'keep-alive');
+    res.setHeader('X-Accel-Buffering', 'no');
+    if (typeof res.flushHeaders === 'function') res.flushHeaders();
+
+    let closed = false;
+    const write = (event, payload) => {
+        if (closed) return;
+        try {
+            res.write(`event: ${event}\n`);
+            res.write(`data: ${JSON.stringify(payload)}\n\n`);
+        } catch {
+            // Socket is gone.
+        }
+    };
+
+    try { res.write(': start\n\n'); } catch { /* noop */ }
+    const heartbeat = setInterval(() => {
+        if (!closed) {
+            try { res.write(': ping\n\n'); } catch { /* noop */ }
+        }
+    }, 5000);
+
+    for (const entry of job.logs) {
+        write('log', { stream: entry.stream, chunk: entry.chunk });
+    }
+
+    const cleanup = () => {
+        if (closed) return;
+        closed = true;
+        clearInterval(heartbeat);
+        job.emitter.off('log', onLog);
+        job.emitter.off('done', onDone);
+    };
+    const onLog = (entry) => {
+        write('log', { stream: entry.stream, chunk: entry.chunk });
+    };
+    const onDone = (payload) => {
+        write('done', payload);
+        cleanup();
+        try { res.end(); } catch { /* noop */ }
+    };
+
+    if (job.status !== 'running') {
+        write('done', snapshotDonePayload(job));
+        cleanup();
+        try { res.end(); } catch { /* noop */ }
+        return;
+    }
+
+    job.emitter.on('log', onLog);
+    job.emitter.once('done', onDone);
+
+    req.on('close', cleanup);
+});
+
+/**
+ * DELETE /api/taskmaster/install/:jobId
+ * Cancel a running TaskMaster install job.
+ */
+router.delete('/install/:jobId', async (req, res) => {
+    const job = getInstallJob(req.params.jobId);
+    if (!job || job.provider !== 'taskmaster') {
+        return res.status(404).json({
+            success: false,
+            error: 'Install job not found'
+        });
+    }
+
+    res.json({ success: true, cancelled: cancelInstallJob(req.params.jobId) });
+});
+
 /**
  * GET /api/taskmaster/tasks/:projectName
  * Load actual tasks from .taskmaster/tasks/tasks.json
@@ -230,6 +362,75 @@ router.get('/tasks/:projectName', async (req, res) => {
     }
 });
 
+/**
+ * POST /api/taskmaster/execute/:projectName/:taskId
+ * Import a TaskMaster task into orchestration and dispatch it to a CLI agent.
+ */
+router.post('/execute/:projectName/:taskId', async (req, res) => {
+    try {
+        const { projectName, taskId } = req.params;
+        const adapterId = typeof req.body?.adapterId === 'string'
+            ? req.body.adapterId
+            : typeof req.body?.provider === 'string'
+                ? req.body.provider
+                : '';
+        const model = typeof req.body?.model === 'string' ? req.body.model : undefined;
+        const permissionMode = typeof req.body?.permissionMode === 'string' ? req.body.permissionMode : undefined;
+        const isolation = ['host', 'worktree', 'docker'].includes(req.body?.isolation)
+            ? req.body.isolation
+            : 'worktree';
+        const projectId = typeof req.body?.projectId === 'string' ? req.body.projectId : projectName;
+
+        if (!adapterId) {
+            return res.status(400).json({
+                success: false,
+                error: 'Missing adapterId',
+                message: 'adapterId or provider is required'
+            });
+        }
+
+        const { projectPath, transformedTasks } = await readTaskMasterTasks(projectName);
+        const task = transformedTasks.find((candidate) => String(candidate.id) === String(taskId));
+        if (!task) {
+            return res.status(404).json({
+                success: false,
+                error: 'TaskMaster task not found',
+                message: `Task "${taskId}" was not found in project "${projectName}"`
+            });
+        }
+
+        const orchestrationTask = orchestrationTaskService.upsertFromTaskMaster({
+            projectId,
+            taskmasterId: String(task.id),
+            title: `TaskMaster #${task.id}: ${task.title}`,
+            description: taskMasterExecutionDescription(task)
+        });
+
+        const dispatchedTask = await orchestrationTaskService.dispatch(orchestrationTask.id, {
+            adapterId,
+            isolation,
+            projectPath,
+            model,
+            permissionMode
+        });
+
+        res.json({
+            success: true,
+            projectName,
+            projectPath,
+            taskmasterTask: task,
+            task: dispatchedTask
+        });
+    } catch (error) {
+        console.error('TaskMaster execute error:', error);
+        res.status(500).json({
+            success: false,
+            error: 'Failed to execute TaskMaster task',
+            message: error.message
+        });
+    }
+});
+
 /**
  * POST /api/taskmaster/sync-orchestration/:projectName
  * One-way sync: TaskMaster -> Orchestration tasks

package/server/services/diagnostics.js

@@ -0,0 +1,105 @@
+const SAFE_ENV_KEYS = [
+  'NODE_ENV',
+  'SERVER_PORT',
+  'VITE_PORT',
+  'HOST',
+  'PORT',
+  'DATABASE_PATH',
+  'PIXCODE_NO_DAEMON',
+  'PIXCODE_DISABLE_UPDATE_CHECK',
+  'GITHUB_TOKEN',
+  'NPM_TOKEN',
+  'TELEGRAM_BOT_TOKEN',
+  'ANTHROPIC_API_KEY',
+  'OPENAI_API_KEY',
+  'GEMINI_API_KEY',
+];
+
+const SENSITIVE_KEY_PATTERN = /(authorization|cookie|credential|password|secret|token|api[_-]?key)/i;
+
+function isSensitiveKey(key) {
+  return SENSITIVE_KEY_PATTERN.test(key);
+}
+
+function redactEnv(env = process.env) {
+  return SAFE_ENV_KEYS.reduce((acc, key) => {
+    if (!(key in env)) {
+      return acc;
+    }
+    acc[key] = isSensitiveKey(key) ? '[redacted]' : String(env[key]);
+    return acc;
+  }, {});
+}
+
+function providerCredentialState(env = process.env) {
+  return {
+    claude: Boolean(env.ANTHROPIC_API_KEY || env.CLAUDE_API_KEY),
+    codex: Boolean(env.OPENAI_API_KEY),
+    gemini: Boolean(env.GEMINI_API_KEY || env.GOOGLE_API_KEY),
+    telegram: Boolean(env.TELEGRAM_BOT_TOKEN),
+    github: Boolean(env.GITHUB_TOKEN),
+    npm: Boolean(env.NPM_TOKEN),
+  };
+}
+
+function normalizeMemory(memory) {
+  return Object.fromEntries(
+    Object.entries(memory).map(([key, value]) => [key, Number.isFinite(value) ? value : 0])
+  );
+}
+
+function resolveWebSocketClientCount(options) {
+  if (Number.isInteger(options.wsClientCount)) {
+    return options.wsClientCount;
+  }
+  return options.wss?.clients?.size || 0;
+}
+
+export function collectDiagnostics(options = {}) {
+  const now = options.now || new Date();
+  const env = options.env || process.env;
+  const versions = options.versions || process.versions;
+  const memoryUsage = options.memoryUsage || process.memoryUsage;
+  const uptime = options.uptime ?? process.uptime();
+
+  return {
+    status: 'ok',
+    timestamp: now.toISOString(),
+    version: options.serverVersion || '0.0.0',
+    installMode: options.installMode || 'unknown',
+    runtime: {
+      node: versions.node,
+      v8: versions.v8,
+      platform: options.platform || process.platform,
+      arch: options.arch || process.arch,
+      uptimeSeconds: Math.round(uptime),
+    },
+    memory: normalizeMemory(memoryUsage()),
+    websocket: {
+      clients: resolveWebSocketClientCount(options),
+    },
+    environment: redactEnv(env),
+    credentials: providerCredentialState(env),
+    notifications: {
+      telegramConfigured: Boolean(env.TELEGRAM_BOT_TOKEN),
+      webPushConfigured: Boolean(env.VAPID_PUBLIC_KEY && env.VAPID_PRIVATE_KEY),
+    },
+  };
+}
+
+export function redactDiagnostics(input) {
+  if (Array.isArray(input)) {
+    return input.map(item => redactDiagnostics(item));
+  }
+
+  if (!input || typeof input !== 'object') {
+    return input;
+  }
+
+  return Object.fromEntries(
+    Object.entries(input).map(([key, value]) => [
+      key,
+      isSensitiveKey(key) ? '[redacted]' : redactDiagnostics(value),
+    ])
+  );
+}

package/server/services/install-jobs.js

@@ -63,6 +63,7 @@ const PACKAGE_BINARIES = {
     '@google/gemini-cli': 'gemini',
     '@qwen-code/qwen-code': 'qwen',
     'opencode-ai': 'opencode',
+    'task-master': 'task-master',
 };
 
 /**

package/server/services/notification-orchestrator.js

@@ -23,6 +23,11 @@ const PROVIDER_LABELS = {
 
 const recentEventKeys = new Map();
 const DEDUPE_WINDOW_MS = 20000;
+let notificationWebSocketServer = null;
+
+function setNotificationWebSocketServer(wss) {
+  notificationWebSocketServer = wss;
+}
 
 const cleanupOldEventKeys = () => {
   const now = Date.now();
@@ -41,6 +46,22 @@ function shouldSendPush(preferences, event) {
   return webPushEnabled && eventEnabled;
 }
 
+function shouldSendInApp(preferences, event) {
+  const inAppEnabled = preferences?.channels?.inApp !== false;
+  const prefEventKey = KIND_TO_PREF_KEY[event.kind];
+  const eventEnabled = prefEventKey ? preferences?.events?.[prefEventKey] !== false : true;
+
+  return inAppEnabled && eventEnabled;
+}
+
+function shouldSendTelegram(preferences, event) {
+  const telegramEnabled = preferences?.channels?.telegram !== false;
+  const prefEventKey = KIND_TO_PREF_KEY[event.kind];
+  const eventEnabled = prefEventKey ? preferences?.events?.[prefEventKey] !== false : true;
+
+  return telegramEnabled && eventEnabled;
+}
+
 function isDuplicate(event) {
   cleanupOldEventKeys();
   const key = event.dedupeKey || `${event.provider}:${event.kind || 'info'}:${event.code || 'generic'}:${event.sessionId || 'none'}`;
@@ -149,6 +170,41 @@ function buildPushBody(event) {
   };
 }
 
+function buildNotificationPayload(event) {
+  const pushBody = buildPushBody(event);
+  return {
+    id: event.dedupeKey || `${event.provider || 'system'}:${event.kind || 'info'}:${event.code || 'generic'}:${event.sessionId || 'none'}:${event.createdAt}`,
+    title: pushBody.title,
+    body: pushBody.body,
+    kind: event.kind || 'info',
+    code: event.code || 'generic.info',
+    severity: event.severity || 'info',
+    provider: event.provider || null,
+    sessionId: event.sessionId || null,
+    createdAt: event.createdAt,
+    requiresUserAction: Boolean(event.requiresUserAction),
+    data: pushBody.data
+  };
+}
+
+function broadcastInAppNotification(userId, event) {
+  if (!notificationWebSocketServer || !userId || !event) {
+    return;
+  }
+
+  const message = JSON.stringify({
+    type: 'notification:event',
+    notification: buildNotificationPayload(event)
+  });
+  const normalizedUserId = String(userId);
+
+  notificationWebSocketServer.clients.forEach((client) => {
+    if (client.readyState === 1 && String(client.userId || '') === normalizedUserId) {
+      client.send(message);
+    }
+  });
+}
+
 async function sendWebPush(userId, event) {
   const subscriptions = pushSubscriptionsDb.getSubscriptions(userId);
   if (!subscriptions.length) return;
@@ -191,6 +247,14 @@ function notifyUserIfEnabled({ userId, event }) {
     return;
   }
 
+  if (shouldSendInApp(preferences, event)) {
+    try {
+      broadcastInAppNotification(userId, event);
+    } catch (err) {
+      console.error('In-app notification send error:', err);
+    }
+  }
+
   if (shouldSendPush(preferences, event)) {
     sendWebPush(userId, event).catch((err) => {
       console.error('Web push send error:', err);
@@ -203,14 +267,16 @@ function notifyUserIfEnabled({ userId, event }) {
   const providerLabel = PROVIDER_LABELS[event.provider] || event.provider || 'Session';
   const sessionTitle = event.meta?.sessionName || providerLabel;
   const errorText = event.meta?.error || '';
-  notifyTelegramUser({
-    userId,
-    kind: event.kind,
-    title: sessionTitle,
-    error: errorText,
-  }).catch((err) => {
-    console.warn('[telegram] notify failed:', err?.message || err);
-  });
+  if (shouldSendTelegram(preferences, event)) {
+    notifyTelegramUser({
+      userId,
+      kind: event.kind,
+      title: sessionTitle,
+      error: errorText,
+    }).catch((err) => {
+      console.warn('[telegram] notify failed:', err?.message || err);
+    });
+  }
 }
 
 function notifyRunStopped({ userId, provider, sessionId = null, stopReason = 'completed', sessionName = null }) {
@@ -247,6 +313,8 @@ function notifyRunFailed({ userId, provider, sessionId = null, error, sessionNam
 
 export {
   createNotificationEvent,
+  setNotificationWebSocketServer,
+  broadcastInAppNotification,
   notifyUserIfEnabled,
   notifyRunStopped,
   notifyRunFailed

package/server/services/telegram/control-center.js

@@ -49,6 +49,8 @@ const CONTROL_COMMANDS = new Set([
   '/workflows',
   '/orchestration',
   '/runs',
+  '/tasks',
+  '/task',
   '/settings',
   '/install',
   '/auth',
@@ -210,8 +212,9 @@ function mainMenuKeyboard(lang) {
   return [
     [button(t(lang, 'control.button.projects'), 'projects'), button(t(lang, 'control.button.provider'), 'providers')],
     [button(t(lang, 'control.button.models'), 'models'), button(t(lang, 'control.button.workflows'), 'workflows')],
-    [button(t(lang, 'control.button.runs'), 'runs'), button(t(lang, 'control.button.install'), 'install_menu')],
-    [button(t(lang, 'control.button.auth'), 'auth_menu'), button(t(lang, 'control.button.settings'), 'settings')],
+    [button(t(lang, 'control.button.tasks'), 'tasks'), button(t(lang, 'control.button.runs'), 'runs')],
+    [button(t(lang, 'control.button.install'), 'install_menu'), button(t(lang, 'control.button.auth'), 'auth_menu')],
+    [button(t(lang, 'control.button.settings'), 'settings')],
   ];
 }
 
@@ -344,6 +347,37 @@ async function showRuns({ bot, chatId, link, editMessageId }) {
   });
 }
 
+async function showTaskMasterTasks({ bot, chatId, link, editMessageId }) {
+  const lang = languageFor(link);
+  const state = getState(link.user_id);
+  if (!state.selectedProjectName) {
+    await send(bot, chatId, t(lang, 'control.selectProjectFirst'), { editMessageId });
+    await showProjectMenu({ bot, chatId, link });
+    return;
+  }
+
+  const data = await localApi(link.user_id, `/api/taskmaster/tasks/${encodeURIComponent(state.selectedProjectName)}`);
+  const tasks = Array.isArray(data?.tasks) ? data.tasks : [];
+  const activeTasks = tasks.filter((task) => !['done', 'completed', 'cancelled', 'canceled'].includes(String(task.status || '').toLowerCase()));
+  if (activeTasks.length === 0) {
+    await send(bot, chatId, t(lang, 'control.noTaskMasterTasks'), {
+      editMessageId,
+      reply_markup: { inline_keyboard: [[button(t(lang, 'control.button.mainMenu'), 'menu')]] },
+    });
+    return;
+  }
+
+  const buttons = activeTasks.slice(0, 12).map((task) => button(
+    `#${task.id} ${compact(task.title, 38)}`,
+    'task_run',
+    { taskId: String(task.id) },
+  ));
+  await send(bot, chatId, t(lang, 'control.pickTaskMasterTask'), {
+    editMessageId,
+    reply_markup: { inline_keyboard: rows(buttons, 1) },
+  });
+}
+
 function extractAssistantText(response) {
   const messages = Array.isArray(response?.messages) ? response.messages : [];
   const chunks = [];
@@ -437,6 +471,10 @@ async function fetchRun(userId, runId) {
   return localApi(userId, `/api/orchestration/workflows/runs/${runId}`);
 }
 
+async function fetchA2ATask(userId, taskId) {
+  return localApi(userId, `/a2a/tasks/${encodeURIComponent(taskId)}`);
+}
+
 function summarizeRun(run, mode) {
   const lines = [
     `Run ${run.id}`,
@@ -485,6 +523,100 @@ async function monitorWorkflowRun({ bot, chatId, link, runId }) {
   }
 }
 
+function extractA2ATaskText(task) {
+  const chunks = [];
+  const artifacts = Array.isArray(task?.artifacts) ? task.artifacts : [];
+  for (const artifact of artifacts) {
+    for (const part of Array.isArray(artifact?.parts) ? artifact.parts : []) {
+      if (part?.kind === 'text' && typeof part.text === 'string') chunks.push(part.text);
+      if (part?.type === 'text' && typeof part.text === 'string') chunks.push(part.text);
+    }
+  }
+  const history = Array.isArray(task?.history) ? task.history : [];
+  for (const message of history) {
+    if (message?.role !== 'assistant') continue;
+    for (const part of Array.isArray(message?.parts) ? message.parts : []) {
+      if (part?.kind === 'text' && typeof part.text === 'string') chunks.push(part.text);
+      if (part?.type === 'text' && typeof part.text === 'string') chunks.push(part.text);
+    }
+  }
+  return chunks.join('\n\n').trim();
+}
+
+function summarizeA2ATask(task) {
+  const text = extractA2ATaskText(task);
+  const error = task?.error?.message || task?.metadata?.error?.message || '';
+  return truncate([
+    `Task ${task?.id || ''}`,
+    `Status: ${task?.state || 'unknown'}`,
+    error ? `Error: ${error}` : '',
+    text,
+  ].filter(Boolean).join('\n\n'));
+}
+
+async function monitorA2ATask({ bot, chatId, link, taskId }) {
+  const key = `a2a:${taskId}`;
+  if (runMonitors.has(key)) return;
+  runMonitors.set(key, true);
+  const lang = languageFor(link);
+  try {
+    for (;;) {
+      await new Promise((resolve) => setTimeout(resolve, 5000));
+      const task = await fetchA2ATask(link.user_id, taskId);
+      if (TERMINAL_RUN_STATES.has(task?.state)) {
+        await send(bot, chatId, t(lang, 'control.taskFinished', {
+          taskId,
+          status: task.state,
+          summary: summarizeA2ATask(task),
+        }));
+        return;
+      }
+    }
+  } finally {
+    runMonitors.delete(key);
+  }
+}
+
+async function runTaskMasterTask({ bot, chatId, link, taskId }) {
+  const lang = languageFor(link);
+  const state = getState(link.user_id);
+  if (!state.remoteControlEnabled) {
+    await send(bot, chatId, t(lang, 'control.disabled'));
+    return;
+  }
+  if (!state.selectedProjectName) {
+    await send(bot, chatId, t(lang, 'control.selectProjectFirst'));
+    await showProjectMenu({ bot, chatId, link });
+    return;
+  }
+
+  const result = await localApi(
+    link.user_id,
+    `/api/taskmaster/execute/${encodeURIComponent(state.selectedProjectName)}/${encodeURIComponent(taskId)}`,
+    {
+      method: 'POST',
+      body: {
+        projectId: state.selectedProjectName,
+        adapterId: state.selectedProvider,
+        model: state.selectedModel || undefined,
+        isolation: 'worktree',
+      },
+    },
+  );
+  const a2aTaskId = result?.task?.a2aTaskId;
+  await send(bot, chatId, t(lang, 'control.taskStarted', {
+    taskId,
+    provider: state.selectedProvider,
+    a2aTaskId: a2aTaskId || result?.task?.id || 'unknown',
+  }));
+
+  if (a2aTaskId) {
+    monitorA2ATask({ bot, chatId, link, taskId: a2aTaskId }).catch((error) => {
+      console.warn('[telegram-control] task monitor failed:', error?.message || error);
+    });
+  }
+}
+
 export async function startCliInstall({ bot, chatId, link, provider }) {
   const lang = languageFor(link);
   const data = await localApi(link.user_id, `/api/providers/${provider}/install`, { method: 'POST' });
@@ -568,6 +700,10 @@ async function handleAwaitingInput({ bot, chatId, link, text }) {
     await runWorkflow({ bot, chatId, link, input: text });
     return true;
   }
+  if (awaiting.type === 'task_id') {
+    await runTaskMasterTask({ bot, chatId, link, taskId: text });
+    return true;
+  }
   return false;
 }
 
@@ -605,6 +741,19 @@ async function handleCommand({ bot, chatId, link, text }) {
     await showRuns({ bot, chatId, link });
     return true;
   }
+  if (command === '/tasks') {
+    await showTaskMasterTasks({ bot, chatId, link });
+    return true;
+  }
+  if (command === '/task') {
+    if (!argText) {
+      updateTelegramControlState(link.user_id, { awaiting: { type: 'task_id' } });
+      await send(bot, chatId, t(lang, 'control.sendTaskId'));
+      return true;
+    }
+    await runTaskMasterTask({ bot, chatId, link, taskId: argText });
+    return true;
+  }
   if (command === '/settings') {
     await showSettings({ bot, chatId, link });
     return true;
@@ -728,6 +877,7 @@ export async function handleTelegramControlCallback({ bot, query, link }) {
   if (action === 'models_refresh') return showModelMenu({ bot, chatId, link, refresh: true, editMessageId });
   if (action === 'workflows') return showWorkflowMenu({ bot, chatId, link, editMessageId });
   if (action === 'runs') return showRuns({ bot, chatId, link, editMessageId });
+  if (action === 'tasks') return showTaskMasterTasks({ bot, chatId, link, editMessageId });
   if (action === 'install_menu') return showInstallMenu({ bot, chatId, link, editMessageId });
   if (action === 'auth_menu') return showAuthMenu({ bot, chatId, link, editMessageId });
   if (action === 'settings') return showSettings({ bot, chatId, link, editMessageId });
@@ -787,6 +937,7 @@ export async function handleTelegramControlCallback({ bot, query, link }) {
     await send(bot, chatId, t(languageFor(link), 'control.runStatus', { runId: run.id, status: run.status }), { editMessageId });
     return;
   }
+  if (action === 'task_run') return runTaskMasterTask({ bot, chatId, link, taskId: payload.taskId });
   if (action === 'install_provider') return startCliInstall({ bot, chatId, link, provider: payload.provider });
   if (action === 'auth_provider') {
     await send(bot, chatId, `${payload.provider} login:\n${AUTH_HELP[payload.provider] || t(languageFor(link), 'control.providerAuthFallback')}`, { editMessageId });