@pixelbyte-software/pixcode 1.53.5 → 1.53.6

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

@@ -8,11 +8,12 @@ import {
   TELEGRAM_CONTROL_SCOPES,
   TELEGRAM_PROVIDERS,
   buildTelegramAgentPrompt,
-  classifyTelegramIntent,
+  buildTelegramIntentPrompt,
   clearTelegramConfirmation,
   consumeTelegramConfirmation,
   createTelegramConfirmation,
   enqueueTelegramJob,
+  parseTelegramAiIntentResponse,
   resolveTelegramModel,
   resolveTelegramProvider,
   retryWithBackoff,
@@ -26,6 +27,9 @@ const TERMINAL_RUN_STATES = new Set(['completed', 'failed', 'canceled']);
 const CALLBACK_TTL_MS = 10 * 60 * 1000;
 const MAX_CALLBACK_ACTIONS = 1000;
 const MAX_TELEGRAM_TEXT = 3600;
+const ACTIVITY_EDIT_THROTTLE_MS = 1200;
+const ACTIVITY_HEARTBEAT_MS = 8000;
+const INTENT_ROUTER_TIMEOUT_MS = 45_000;
 const callbackActions = new Map();
 const runMonitors = new Map();
 
@@ -230,16 +234,23 @@ function getOrCreateTelegramApiKey(userId) {
   return apiKeysDb.createApiKey(userId, 'Telegram Control', TELEGRAM_CONTROL_SCOPES).apiKey;
 }
 
-async function localApi(userId, path, { method = 'GET', body } = {}) {
+async function localApi(userId, path, { method = 'GET', body, timeoutMs = 0 } = {}) {
   const apiKey = getOrCreateTelegramApiKey(userId);
   const response = await retryWithBackoff(async () => {
+    const controller = timeoutMs > 0 ? new AbortController() : null;
+    const timeoutId = controller
+      ? setTimeout(() => controller.abort(new Error(`HTTP request timed out after ${timeoutMs}ms`)), timeoutMs)
+      : null;
     const res = await fetch(`${localApiBase()}${path}`, {
       method,
       headers: {
         'Content-Type': 'application/json',
         'X-API-Key': apiKey,
       },
+      signal: controller?.signal,
       body: body === undefined ? undefined : JSON.stringify(body),
+    }).finally(() => {
+      if (timeoutId) clearTimeout(timeoutId);
     });
     if ([408, 429, 500, 502, 503, 504].includes(res.status)) {
       const error = new Error(`HTTP ${res.status}`);
@@ -256,10 +267,197 @@ async function localApi(userId, path, { method = 'GET', body } = {}) {
   return data?.data ?? data;
 }
 
+async function localAgentStream(userId, body, onEvent) {
+  const apiKey = getOrCreateTelegramApiKey(userId);
+  const response = await fetch(`${localApiBase()}/api/agent`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'X-API-Key': apiKey,
+    },
+    body: JSON.stringify({
+      ...body,
+      stream: true,
+    }),
+  });
+
+  if (!response.ok) {
+    const data = await response.json().catch(() => ({}));
+    const error = data?.error?.message || data?.error || `HTTP ${response.status}`;
+    throw new Error(typeof error === 'string' ? error : JSON.stringify(error));
+  }
+
+  if (!response.body) return;
+
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+
+  const consumeBlock = async (block) => {
+    const lines = String(block || '').split('\n');
+    for (const line of lines) {
+      if (!line.startsWith('data:')) continue;
+      const payload = line.slice(5).trim();
+      if (!payload) continue;
+      let event;
+      try {
+        event = JSON.parse(payload);
+      } catch {
+        continue;
+      }
+      await onEvent?.(event);
+    }
+  };
+
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    let boundary = buffer.indexOf('\n\n');
+    while (boundary !== -1) {
+      const block = buffer.slice(0, boundary);
+      buffer = buffer.slice(boundary + 2);
+      await consumeBlock(block);
+      boundary = buffer.indexOf('\n\n');
+    }
+  }
+
+  const rest = `${buffer}${decoder.decode()}`;
+  if (rest.trim()) await consumeBlock(rest);
+}
+
 function checked(label) {
   return `${label} ✓`;
 }
 
+function formatElapsed(startedAt) {
+  const seconds = Math.max(0, Math.round((Date.now() - startedAt) / 1000));
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const rest = seconds % 60;
+  return `${minutes}m ${rest}s`;
+}
+
+function projectLabel(state) {
+  return state.selectedProjectName || state.selectedProjectPath || '-';
+}
+
+function createActivityState({ lang, type = 'agent', provider, project, prompt, mode = 'final' }) {
+  return {
+    lang,
+    type,
+    status: 'starting',
+    phase: t(lang, 'control.activity.starting'),
+    provider,
+    project,
+    prompt: compact(prompt, 120),
+    mode,
+    startedAt: Date.now(),
+    lastEditAt: 0,
+    messageId: null,
+    sessionId: null,
+    runId: null,
+    workflowId: null,
+    events: [],
+    output: '',
+    error: null,
+  };
+}
+
+function pushActivityEvent(activity, text) {
+  const value = String(text || '').trim();
+  if (!value) return;
+  if (activity.events.at(-1) === value) return;
+  activity.events.push(value);
+  if (activity.events.length > 8) activity.events.splice(0, activity.events.length - 8);
+}
+
+function activityTitle(activity) {
+  if (activity.type === 'workflow') return t(activity.lang, 'control.activity.workflowTitle');
+  if (activity.type === 'router') return t(activity.lang, 'control.activity.routerTitle');
+  return t(activity.lang, 'control.activity.agentTitle');
+}
+
+function renderActivity(activity, { finalText = null } = {}) {
+  const output = finalText || activity.output;
+  const lines = [
+    `${activity.status === 'failed' ? '❌' : activity.status === 'done' ? '✅' : activity.status === 'running' ? '🔧' : '⏳'} ${activityTitle(activity)}`,
+    '',
+    `🤖 ${t(activity.lang, 'control.activity.provider')}: ${activity.provider || '-'}`,
+    `📁 ${t(activity.lang, 'control.activity.project')}: ${compact(activity.project, 90)}`,
+  ];
+
+  if (activity.sessionId) lines.push(`🧵 ${t(activity.lang, 'control.activity.session')}: ${activity.sessionId}`);
+  if (activity.runId) lines.push(`🧭 ${t(activity.lang, 'control.activity.run')}: ${activity.runId}`);
+  if (activity.workflowId) lines.push(`🧩 ${t(activity.lang, 'control.activity.workflow')}: ${activity.workflowId}`);
+  lines.push(`⏱ ${t(activity.lang, 'control.activity.elapsed')}: ${formatElapsed(activity.startedAt)}`);
+  lines.push(`📌 ${t(activity.lang, 'control.activity.status')}: ${activity.phase}`);
+
+  const visibleEvents = activity.mode === 'final'
+    ? activity.events.slice(-4)
+    : activity.events;
+  if (visibleEvents.length > 0) {
+    lines.push('', `🛠 ${t(activity.lang, 'control.activity.work')}:`);
+    for (const event of visibleEvents) lines.push(`• ${event}`);
+  }
+
+  if (activity.error) {
+    lines.push('', `⚠️ ${truncate(activity.error, 700)}`);
+  } else if (output) {
+    lines.push('', `💬 ${t(activity.lang, 'control.activity.output')}:`);
+    lines.push(truncate(output, 1800));
+  } else if (activity.prompt) {
+    lines.push('', `📝 ${compact(activity.prompt, 220)}`);
+  }
+
+  return truncate(lines.join('\n'), 3400);
+}
+
+async function createTelegramActivity({ bot, chatId, link, type = 'agent', prompt = '', phase = null }) {
+  const lang = languageFor(link);
+  const state = getState(link.user_id);
+  const activity = createActivityState({
+    lang,
+    type,
+    provider: resolveTelegramProvider(state),
+    project: projectLabel(state),
+    prompt,
+    mode: state.progressMode,
+  });
+  if (phase) activity.phase = phase;
+  const sent = await send(bot, chatId, renderActivity(activity), { parse_mode: undefined });
+  activity.messageId = sent?.message_id || sent?.message?.message_id || null;
+  activity.lastEditAt = Date.now();
+  return activity;
+}
+
+async function editTelegramActivity({ bot, chatId, activity, force = false, reply_markup }) {
+  if (!activity) return null;
+  const now = Date.now();
+  if (!force && now - activity.lastEditAt < ACTIVITY_EDIT_THROTTLE_MS) return null;
+  const sent = await send(bot, chatId, renderActivity(activity), {
+    editMessageId: activity.messageId,
+    parse_mode: undefined,
+    reply_markup,
+  });
+  activity.messageId = sent?.message_id || sent?.message?.message_id || activity.messageId;
+  activity.lastEditAt = now;
+  return sent;
+}
+
+function startActivityHeartbeat({ bot, chatId, activity }) {
+  return setInterval(() => {
+    if (!activity || activity.status === 'done' || activity.status === 'failed') return;
+    if (activity.status === 'starting') {
+      activity.status = 'running';
+      activity.phase = t(activity.lang, 'control.activity.thinking');
+    }
+    editTelegramActivity({ bot, chatId, activity }).catch((error) => {
+      console.warn('[telegram-control] activity heartbeat failed:', error?.message || error);
+    });
+  }, ACTIVITY_HEARTBEAT_MS);
+}
+
 function stateSummary(lang, state) {
   return [
     `${t(lang, 'control.summary.project')}: ${state.selectedProjectName || t(lang, 'control.notSelected')}`,
@@ -310,11 +508,12 @@ async function listProjects() {
   return projects.slice(0, 20);
 }
 
-async function showProjectMenu({ bot, chatId, link, editMessageId }) {
+async function showProjectMenu({ bot, chatId, link, editMessageId, notice }) {
   const lang = languageFor(link);
   const projects = await listProjects();
   if (projects.length === 0) {
-    await send(bot, chatId, t(lang, 'control.noProjects'), { editMessageId });
+    const prefix = notice ? `${notice}\n\n` : '';
+    await send(bot, chatId, `${prefix}${t(lang, 'control.noProjects')}`, { editMessageId });
     return;
   }
 
@@ -327,7 +526,8 @@ async function showProjectMenu({ bot, chatId, link, editMessageId }) {
       displayName: project.displayName || project.name,
     },
   ));
-  await send(bot, chatId, t(lang, 'control.pickProject'), {
+  const prefix = notice ? `${notice}\n\n` : '';
+  await send(bot, chatId, `${prefix}${t(lang, 'control.pickProject')}`, {
     editMessageId,
     reply_markup: { inline_keyboard: rows(buttons, 1) },
   });
@@ -539,6 +739,119 @@ function extractAssistantText(response) {
   return chunks.join('\n\n').trim();
 }
 
+function extractTextFromEvent(event) {
+  if (!event || typeof event !== 'object') return '';
+  if (typeof event.content === 'string') return event.content;
+  if (Array.isArray(event.content)) {
+    return event.content
+      .map((part) => (typeof part === 'string' ? part : part?.text || ''))
+      .join('');
+  }
+  const legacyContent = event.data?.message?.content || event.message?.content;
+  if (Array.isArray(legacyContent)) {
+    return legacyContent
+      .map((part) => (typeof part === 'string' ? part : part?.text || ''))
+      .join('');
+  }
+  if (typeof legacyContent === 'string') return legacyContent;
+  return '';
+}
+
+function describeToolInput(toolName, input) {
+  if (!input || typeof input !== 'object') return '';
+  if (toolName === 'Bash' && typeof input.command === 'string') {
+    return compact(input.command, 110);
+  }
+  if (toolName === 'WebSearch' && typeof input.query === 'string') {
+    return compact(input.query, 110);
+  }
+  if (toolName === 'FileChanges') {
+    return compact(JSON.stringify(input), 110);
+  }
+  const keys = Object.keys(input).slice(0, 3);
+  if (keys.length === 0) return '';
+  return compact(keys.map((key) => `${key}: ${String(input[key])}`).join(', '), 110);
+}
+
+function applyAgentStreamEvent(activity, event) {
+  if (!event || typeof event !== 'object') return;
+
+  const sessionId = event.actualSessionId || event.newSessionId || event.sessionId || event.threadId;
+  if (sessionId) activity.sessionId = sessionId;
+
+  if (event.type === 'status' && event.message) {
+    activity.status = 'running';
+    activity.phase = compact(event.message, 120);
+    pushActivityEvent(activity, `⏳ ${compact(event.message, 120)}`);
+    return;
+  }
+  if (event.type === 'done' || event.kind === 'complete' || event.kind === 'stream_end') {
+    activity.status = 'done';
+    activity.phase = t(activity.lang, 'control.activity.done');
+    return;
+  }
+  if (event.type === 'error' || event.kind === 'error') {
+    activity.status = 'failed';
+    activity.phase = t(activity.lang, 'control.activity.failed');
+    activity.error = event.error || event.message || event.content || t(activity.lang, 'error.generic');
+    pushActivityEvent(activity, `❌ ${compact(activity.error, 120)}`);
+    return;
+  }
+  if (event.kind === 'session_created') {
+    activity.status = 'running';
+    activity.phase = t(activity.lang, 'control.activity.sessionStarted');
+    pushActivityEvent(activity, `🧵 ${t(activity.lang, 'control.activity.sessionStarted')}`);
+    return;
+  }
+  if (event.kind === 'thinking') {
+    activity.status = 'running';
+    activity.phase = t(activity.lang, 'control.activity.thinking');
+    const thought = extractTextFromEvent(event);
+    if (thought) pushActivityEvent(activity, `🧠 ${compact(thought, 120)}`);
+    return;
+  }
+  if (event.kind === 'stream_delta' || event.kind === 'text') {
+    activity.status = 'running';
+    activity.phase = t(activity.lang, 'control.activity.responding');
+    activity.output = `${activity.output}${extractTextFromEvent(event)}`;
+    return;
+  }
+  if (event.type === 'claude-response' && event.data?.type === 'assistant') {
+    activity.status = 'running';
+    activity.phase = t(activity.lang, 'control.activity.responding');
+    activity.output = `${activity.output}${extractTextFromEvent(event)}`;
+    return;
+  }
+  if (event.kind === 'tool_use') {
+    activity.status = 'running';
+    activity.phase = t(activity.lang, 'control.activity.working');
+    const toolName = event.toolName || 'Tool';
+    const input = describeToolInput(toolName, event.toolInput);
+    const icon = toolName === 'Bash'
+      ? '💻'
+      : toolName === 'FileChanges'
+        ? '📝'
+        : toolName === 'WebSearch'
+          ? '🔎'
+          : '🔧';
+    pushActivityEvent(activity, `${icon} ${toolName}${input ? `: ${input}` : ''}`);
+    return;
+  }
+  if (event.kind === 'tool_result') {
+    activity.status = 'running';
+    activity.phase = t(activity.lang, 'control.activity.working');
+    const label = event.isError
+      ? t(activity.lang, 'control.activity.toolFailed')
+      : t(activity.lang, 'control.activity.toolDone');
+    pushActivityEvent(activity, `${event.isError ? '⚠️' : '✅'} ${label}`);
+    return;
+  }
+  if (event.kind === 'status' && event.text === 'token_budget') {
+    const used = event.tokenBudget?.used;
+    if (used) pushActivityEvent(activity, `📊 ${t(activity.lang, 'control.activity.tokens')}: ${used}`);
+  }
+}
+
 function confirmationLabel(lang, action, payload = {}) {
   if (action === 'install_provider') {
     return t(lang, 'control.confirmInstall', { provider: payload.provider || '' });
@@ -572,78 +885,105 @@ async function sendToolFailure({ bot, chatId, link, result, editMessageId }) {
   await send(bot, chatId, message, { editMessageId });
 }
 
-async function runAgent({ bot, chatId, link, prompt }) {
+async function runAgent({ bot, chatId, link, prompt, activity = null }) {
   const lang = languageFor(link);
   const state = getState(link.user_id);
   if (!state.remoteControlEnabled) {
-    await send(bot, chatId, t(lang, 'control.disabled'));
+    await send(bot, chatId, t(lang, 'control.disabled'), { editMessageId: activity?.messageId });
     return;
   }
   if (!state.selectedProjectPath) {
-    await send(bot, chatId, t(lang, 'control.selectProjectFirst'));
-    await showProjectMenu({ bot, chatId, link });
+    await showProjectMenu({ bot, chatId, link, editMessageId: activity?.messageId, notice: t(lang, 'control.selectProjectFirst') });
     return;
   }
 
   const provider = resolveTelegramProvider(state);
   const model = resolveTelegramModel(state);
-  if (state.progressMode !== 'final') {
-    await send(bot, chatId, t(lang, 'control.agentStarted', {
+  const active = activity || await createTelegramActivity({
+    bot,
+    chatId,
+    link,
+    type: 'agent',
+    prompt,
+    phase: t(lang, 'control.activity.startingProvider', { provider }),
+  });
+  active.type = 'agent';
+  active.provider = provider;
+  active.project = projectLabel(state);
+  active.status = 'running';
+  active.phase = t(lang, 'control.activity.startingProvider', { provider });
+  await editTelegramActivity({ bot, chatId, activity: active, force: true });
+
+  const heartbeat = startActivityHeartbeat({ bot, chatId, activity: active });
+  let streamFailed = null;
+  try {
+    await localAgentStream(link.user_id, {
+      projectPath: state.selectedProjectPath,
       provider,
-      project: state.selectedProjectName || state.selectedProjectPath,
-    }));
+      model: model || undefined,
+      message: buildTelegramAgentPrompt(prompt, state),
+      cleanup: false,
+      permissionMode: 'default',
+    }, async (event) => {
+      applyAgentStreamEvent(active, event);
+      await editTelegramActivity({ bot, chatId, activity: active });
+    });
+  } catch (error) {
+    streamFailed = error;
+  } finally {
+    clearInterval(heartbeat);
   }
 
-  const result = await runTelegramTool({
-    userId: link.user_id,
-    action: 'run_agent',
-    retries: 0,
-    execute: () => localApi(link.user_id, '/api/agent', {
-      method: 'POST',
-      body: {
-        projectPath: state.selectedProjectPath,
-        provider,
-        model: model || undefined,
-        message: buildTelegramAgentPrompt(prompt, state),
-        cleanup: false,
-        stream: false,
-      },
-    }),
-  });
-  if (!result.ok) {
-    await sendToolFailure({ bot, chatId, link, result });
+  if (streamFailed) {
+    active.status = 'failed';
+    active.phase = t(lang, 'control.activity.failed');
+    active.error = streamFailed.message || t(lang, 'error.generic');
+    await editTelegramActivity({ bot, chatId, activity: active, force: true });
     return;
   }
 
-  const response = result.data;
-  const assistantText = extractAssistantText(response);
-  const statusLine = response.success === false
-    ? t(lang, 'control.agentFailed', { error: response.error || 'provider returned no answer' })
-    : t(lang, 'control.agentDone', { provider, session: response.sessionId ? ` (${response.sessionId})` : '' });
-  await send(bot, chatId, `${statusLine}\n\n${assistantText || response.error || t(lang, 'control.noAssistantText')}`);
+  active.status = active.error ? 'failed' : 'done';
+  active.phase = active.error ? t(lang, 'control.activity.failed') : t(lang, 'control.activity.done');
+  if (!active.output && !active.error) active.output = t(lang, 'control.noAssistantText');
+  await editTelegramActivity({ bot, chatId, activity: active, force: true });
 }
 
-export async function runWorkflow({ bot, chatId, link, input }) {
+export async function runWorkflow({ bot, chatId, link, input, activity = null }) {
   const lang = languageFor(link);
   const state = getState(link.user_id);
   const workflowId = state.selectedWorkflowId;
   if (!state.remoteControlEnabled) {
-    await send(bot, chatId, t(lang, 'control.disabled'));
+    await send(bot, chatId, t(lang, 'control.disabled'), { editMessageId: activity?.messageId });
     return;
   }
   if (!workflowId) {
-    await send(bot, chatId, t(lang, 'control.selectWorkflowFirst'));
-    await showWorkflowMenu({ bot, chatId, link });
+    await send(bot, chatId, t(lang, 'control.selectWorkflowFirst'), { editMessageId: activity?.messageId });
+    await showWorkflowMenu({ bot, chatId, link, editMessageId: activity?.messageId });
     return;
   }
   if (!state.selectedProjectPath) {
-    await send(bot, chatId, t(lang, 'control.selectProjectFirst'));
-    await showProjectMenu({ bot, chatId, link });
+    await showProjectMenu({ bot, chatId, link, editMessageId: activity?.messageId, notice: t(lang, 'control.selectProjectFirst') });
     return;
   }
 
   const provider = resolveTelegramProvider(state);
   const model = resolveTelegramModel(state);
+  const active = activity || await createTelegramActivity({
+    bot,
+    chatId,
+    link,
+    type: 'workflow',
+    prompt: input,
+    phase: t(lang, 'control.activity.startingWorkflow'),
+  });
+  active.type = 'workflow';
+  active.provider = provider;
+  active.project = projectLabel(state);
+  active.workflowId = workflowId;
+  active.status = 'running';
+  active.phase = t(lang, 'control.activity.startingWorkflow');
+  await editTelegramActivity({ bot, chatId, activity: active, force: true });
+
   const result = await runTelegramTool({
     userId: link.user_id,
     action: 'run_workflow',
@@ -664,12 +1004,15 @@ export async function runWorkflow({ bot, chatId, link, input }) {
     }),
   });
   if (!result.ok) {
-    await sendToolFailure({ bot, chatId, link, result });
+    await sendToolFailure({ bot, chatId, link, result, editMessageId: active.messageId });
     return;
   }
   const run = result.data;
-  await send(bot, chatId, t(lang, 'control.workflowStarted', { runId: run.id, workflowId }));
-  monitorWorkflowRun({ bot, chatId, link, runId: run.id }).catch((error) => {
+  active.runId = run.id;
+  active.phase = t(lang, 'control.activity.workflowRunning');
+  pushActivityEvent(active, `🧭 ${t(lang, 'control.workflowStarted', { runId: run.id, workflowId }).replace('\n', ' ')}`);
+  await editTelegramActivity({ bot, chatId, activity: active, force: true });
+  monitorWorkflowRun({ bot, chatId, link, runId: run.id, activity: active }).catch((error) => {
     console.warn('[telegram-control] workflow monitor failed:', error?.message || error);
   });
 }
@@ -750,21 +1093,96 @@ async function findProjectByQuery(query) {
   }) || null;
 }
 
-async function handleRoutedIntent({ bot, chatId, link, text }) {
+async function listWorkflowSummaries(userId) {
+  try {
+    const data = await localApi(userId, '/api/orchestration/workflows', { timeoutMs: 10_000 });
+    if (Array.isArray(data)) return data;
+    if (Array.isArray(data?.workflows)) return data.workflows;
+  } catch {
+    // Workflow context is helpful for routing but should never block chat input.
+  }
+  return [];
+}
+
+async function resolveTelegramAiIntent({ bot, chatId, link, text, activity }) {
   const state = getState(link.user_id);
-  const intent = classifyTelegramIntent(text, state);
-  if (!intent) return false;
+  if (state.routerEnabled === false || state.routerMode !== 'hybrid') {
+    return { action: 'agent_prompt', prompt: text, confidence: 1 };
+  }
 
-  if (intent.action === 'projects') {
-    await showProjectMenu({ bot, chatId, link });
+  const provider = resolveTelegramProvider(state);
+  const model = resolveTelegramModel(state);
+  if (activity) {
+    activity.type = 'router';
+    activity.provider = provider;
+    activity.project = projectLabel(state);
+    activity.status = 'running';
+    activity.phase = t(activity.lang, 'control.activity.interpreting');
+    pushActivityEvent(activity, `🧠 ${t(activity.lang, 'control.activity.interpreting')}`);
+    await editTelegramActivity({ bot, chatId, activity, force: true });
+  }
+
+  try {
+    const projects = await listProjects().catch(() => []);
+    const workflows = await listWorkflowSummaries(link.user_id);
+    const response = await localApi(link.user_id, '/api/agent', {
+      method: 'POST',
+      timeoutMs: INTENT_ROUTER_TIMEOUT_MS,
+      body: {
+        projectPath: state.selectedProjectPath || process.cwd(),
+        provider,
+        model: model || undefined,
+        message: buildTelegramIntentPrompt(text, state, { projects, workflows }),
+        cleanup: false,
+        stream: false,
+        permissionMode: 'plan',
+      },
+    });
+    const assistantText = extractAssistantText(response);
+    const intent = parseTelegramAiIntentResponse(assistantText, text);
+    if (activity) {
+      pushActivityEvent(activity, `🧭 ${intent.action} (${Math.round(intent.confidence * 100)}%)`);
+      await editTelegramActivity({ bot, chatId, activity });
+    }
+    return intent;
+  } catch (error) {
+    if (activity) {
+      pushActivityEvent(activity, `⚠️ ${t(activity.lang, 'control.activity.routerFallback')}`);
+      await editTelegramActivity({ bot, chatId, activity });
+    }
+    console.warn('[telegram-control] AI intent router fallback:', error?.message || error);
+    return { action: 'agent_prompt', prompt: text, confidence: 0 };
+  }
+}
+
+async function handleRoutedIntent({ bot, chatId, link, text, activity }) {
+  const intent = await resolveTelegramAiIntent({ bot, chatId, link, text, activity });
+  const editMessageId = activity?.messageId;
+
+  if (intent.action === 'agent_prompt') {
+    await runAgent({ bot, chatId, link, prompt: intent.prompt || text, activity });
+    return true;
+  }
+  if (intent.action === 'show_menu') {
+    await showMainMenu({ bot, chatId, link, editMessageId });
+    return true;
+  }
+  if (intent.action === 'show_projects') {
+    await showProjectMenu({ bot, chatId, link, editMessageId });
     return true;
   }
-  if (intent.action === 'project_select_query') {
-    const project = await findProjectByQuery(intent.query);
+  if (intent.action === 'select_project') {
+    const query = intent.projectQuery || intent.prompt || text;
+    const project = await findProjectByQuery(query);
     const lang = languageFor(link);
     if (!project) {
-      await send(bot, chatId, t(lang, 'control.projectNotFound', { query: intent.query }));
-      await showProjectMenu({ bot, chatId, link });
+      await showProjectMenu({
+        bot,
+        chatId,
+        link,
+        editMessageId,
+        notice: t(lang, 'control.projectNotFound', { query }),
+      });
       return true;
     }
     updateTelegramControlState(link.user_id, {
@@ -775,6 +1193,7 @@ async function handleRoutedIntent({ bot, chatId, link, text }) {
       bot,
       chatId,
       link,
+      editMessageId,
       notice: t(lang, 'control.projectSelected', {
         project: project.displayName || project.name,
         path: project.fullPath || project.path,
@@ -782,36 +1201,56 @@ async function handleRoutedIntent({ bot, chatId, link, text }) {
     });
     return true;
   }
-  if (intent.action === 'provider_menu') {
-    await showProviderMenu({ bot, chatId, link });
+  if (intent.action === 'show_provider_menu') {
+    await showProviderMenu({ bot, chatId, link, editMessageId });
     return true;
   }
-  if (intent.action === 'provider_select') {
+  if (intent.action === 'select_provider' && intent.provider) {
     updateTelegramControlState(link.user_id, { selectedProvider: intent.provider, selectedModel: null });
-    await showModelMenu({ bot, chatId, link });
+    await showModelMenu({ bot, chatId, link, editMessageId });
     return true;
   }
-  if (intent.action === 'model_menu') {
-    await showModelMenu({ bot, chatId, link });
+  if (intent.action === 'show_model_menu') {
+    await showModelMenu({ bot, chatId, link, editMessageId });
     return true;
   }
-  if (intent.action === 'runs') {
-    await showRuns({ bot, chatId, link });
+  if (intent.action === 'select_model' && intent.model) {
+    updateTelegramControlState(link.user_id, { selectedModel: intent.model });
+    await showMainMenu({
+      bot,
+      chatId,
+      link,
+      editMessageId,
+      notice: t(languageFor(link), 'control.modelSelected', { model: intent.model }),
+    });
     return true;
   }
-  if (intent.action === 'approvals') {
-    await showApprovalQueue({ bot, chatId, link });
+  if (intent.action === 'show_runs') {
+    await showRuns({ bot, chatId, link, editMessageId });
     return true;
   }
-  if (intent.action === 'workflows') {
-    await showWorkflowMenu({ bot, chatId, link });
+  if (intent.action === 'show_approvals') {
+    await showApprovalQueue({ bot, chatId, link, editMessageId });
+    return true;
+  }
+  if (intent.action === 'show_workflows') {
+    await showWorkflowMenu({ bot, chatId, link, editMessageId });
+    return true;
+  }
+  if (intent.action === 'run_workflow') {
+    await runWorkflow({ bot, chatId, link, input: intent.workflowInput || text, activity });
+    return true;
+  }
+  if (intent.action === 'show_sessions') {
+    await showSessions({ bot, chatId, link, editMessageId });
     return true;
   }
   if (intent.action === 'new_chat') {
-    await startNewChat({ bot, chatId, link });
+    await startNewChat({ bot, chatId, link, editMessageId });
     return true;
   }
-  return false;
+  await runAgent({ bot, chatId, link, prompt: text, activity });
+  return true;
 }
 
 async function fetchRun(userId, runId) {
@@ -819,10 +1258,17 @@ async function fetchRun(userId, runId) {
 }
 
 function summarizeRun(run, mode) {
+  const statusIcon = run.status === 'completed'
+    ? '✅'
+    : run.status === 'failed'
+      ? '❌'
+      : run.status === 'canceled'
+        ? '⏹'
+        : '🔧';
   const lines = [
-    `Run ${run.id}`,
-    `Workflow: ${run.workflowId}`,
-    `Status: ${run.status}`,
+    `${statusIcon} Run ${run.id}`,
+    `🧩 Workflow: ${run.workflowId}`,
+    `📌 Status: ${run.status}`,
   ];
   const nodeRuns = Array.isArray(run.nodeRuns) ? run.nodeRuns : [];
   if (mode !== 'final') {
@@ -830,7 +1276,14 @@ function summarizeRun(run, mode) {
       ? nodeRuns.filter((node) => node.error || node.status === 'failed')
       : nodeRuns;
     for (const node of visibleNodes) {
-      lines.push(`- ${node.status}: ${node.agentLabel || node.nodeId}${node.error ? ` — ${node.error}` : ''}`);
+      const nodeIcon = node.status === 'completed'
+        ? '✅'
+        : node.status === 'failed'
+          ? '❌'
+          : node.status === 'running'
+            ? '🔧'
+            : '⏳';
+      lines.push(`${nodeIcon} ${node.status}: ${node.agentLabel || node.nodeId}${node.error ? ` - ${node.error}` : ''}`);
     }
   }
   const outputs = nodeRuns
@@ -840,7 +1293,7 @@ function summarizeRun(run, mode) {
   return truncate(`${lines.join('\n')}${outputs.join('\n')}`);
 }
 
-async function monitorWorkflowRun({ bot, chatId, link, runId }) {
+async function monitorWorkflowRun({ bot, chatId, link, runId, activity = null }) {
   if (runMonitors.has(runId)) return;
   runMonitors.set(runId, true);
   const state = getState(link.user_id);
@@ -850,12 +1303,23 @@ async function monitorWorkflowRun({ bot, chatId, link, runId }) {
       await new Promise((resolve) => setTimeout(resolve, 5000));
       const run = await fetchRun(link.user_id, runId);
       const nodeRuns = Array.isArray(run.nodeRuns) ? run.nodeRuns : [];
+      if (activity && !TERMINAL_RUN_STATES.has(run.status)) {
+        activity.status = 'running';
+        activity.phase = `${t(activity.lang, 'control.activity.workflowRunning')} (${run.status})`;
+        await editTelegramActivity({ bot, chatId, activity });
+      }
       if (state.progressMode === 'all') {
         for (const node of nodeRuns) {
           const key = `${node.nodeId}:${node.status}`;
           if (!seenNodeStatus.has(key)) {
             seenNodeStatus.set(key, true);
-            await send(bot, chatId, `${node.agentLabel || node.nodeId}: ${node.status}${node.error ? `\n${node.error}` : ''}`);
+            if (activity) {
+              pushActivityEvent(activity, `${node.status === 'completed' ? '✅' : node.status === 'failed' ? '❌' : '🔧'} ${node.agentLabel || node.nodeId}: ${node.status}${node.error ? ` - ${node.error}` : ''}`);
+              activity.phase = t(activity.lang, 'control.activity.workflowRunning');
+              await editTelegramActivity({ bot, chatId, activity });
+            } else {
+              await send(bot, chatId, `${node.agentLabel || node.nodeId}: ${node.status}${node.error ? `\n${node.error}` : ''}`);
+            }
           }
         }
       }
@@ -864,12 +1328,27 @@ async function monitorWorkflowRun({ bot, chatId, link, runId }) {
           const key = `${node.nodeId}:${node.status}:${node.error || ''}`;
           if (!seenNodeStatus.has(key)) {
             seenNodeStatus.set(key, true);
-            await send(bot, chatId, `${node.agentLabel || node.nodeId}: ${node.status}\n${node.error || ''}`);
+            if (activity) {
+              pushActivityEvent(activity, `❌ ${node.agentLabel || node.nodeId}: ${node.status}${node.error ? ` - ${node.error}` : ''}`);
+              activity.phase = t(activity.lang, 'control.activity.workflowRunning');
+              await editTelegramActivity({ bot, chatId, activity });
+            } else {
+              await send(bot, chatId, `${node.agentLabel || node.nodeId}: ${node.status}\n${node.error || ''}`);
+            }
           }
         }
       }
       if (TERMINAL_RUN_STATES.has(run.status)) {
-        await send(bot, chatId, summarizeRun(run, state.progressMode));
+        if (activity) {
+          activity.status = run.status === 'completed' ? 'done' : 'failed';
+          activity.phase = run.status === 'completed'
+            ? t(activity.lang, 'control.activity.done')
+            : t(activity.lang, 'control.activity.failed');
+          activity.output = summarizeRun(run, state.progressMode);
+          await editTelegramActivity({ bot, chatId, activity, force: true });
+        } else {
+          await send(bot, chatId, summarizeRun(run, state.progressMode));
+        }
         return;
       }
     }
@@ -1124,7 +1603,6 @@ async function handleTelegramControlMessageInternal({ bot, msg, link }) {
 
   if (await handleAwaitingInput({ bot, chatId, link, text })) return true;
   if (await handleCommand({ bot, chatId, link, text })) return true;
-  if (await handleRoutedIntent({ bot, chatId, link, text })) return true;
 
   const state = getState(link.user_id);
   if (state.routerEnabled === false) return false;
@@ -1133,8 +1611,15 @@ async function handleTelegramControlMessageInternal({ bot, msg, link }) {
     return true;
   }
 
-  await runAgent({ bot, chatId, link, prompt: text });
-  return true;
+  const activity = await createTelegramActivity({
+    bot,
+    chatId,
+    link,
+    type: 'router',
+    prompt: text,
+    phase: t(languageFor(link), 'control.activity.interpreting'),
+  });
+  return handleRoutedIntent({ bot, chatId, link, text, activity });
 }
 
 export async function handleTelegramControlMessage(args) {