@pixelbyte-software/pixcode 1.53.13 → 1.53.15

package/server/index.js

@@ -1237,6 +1237,7 @@ function appendPtySessionBuffer(session, data) {
         valueBytes = Buffer.byteLength(value, 'utf8');
     }
 
+    session.totalOutputBytes = (session.totalOutputBytes || 0) + valueBytes;
     session.buffer.push(value);
     session.bufferBytes = (session.bufferBytes || 0) + valueBytes;
 
@@ -1247,10 +1248,39 @@ function appendPtySessionBuffer(session, data) {
     if (session.bufferBytes < 0) session.bufferBytes = 0;
 }
 
+function readPtySessionBufferedOutput(session, { maxChars = 12000, sinceCursor = null } = {}) {
+    const rawBuffer = (session?.buffer || []).join('');
+    const bufferBytes = session?.bufferBytes || Buffer.byteLength(rawBuffer, 'utf8');
+    const outputCursor = session?.totalOutputBytes || bufferBytes;
+    const bufferStartCursor = Math.max(0, outputCursor - bufferBytes);
+    let rawOutput = rawBuffer;
+
+    if (Number.isFinite(sinceCursor)) {
+        const skipBytes = Math.max(0, sinceCursor - bufferStartCursor);
+        if (skipBytes > 0) {
+            rawOutput = Buffer.from(rawBuffer, 'utf8').slice(skipBytes).toString('utf8');
+        }
+    }
+
+    if (rawOutput.length > maxChars) {
+        rawOutput = rawOutput.slice(-maxChars);
+    }
+
+    return {
+        rawOutput,
+        outputCursor,
+        bufferStartCursor,
+    };
+}
+
 function normalizeTerminalStartupInput(input) {
     return `\x15${String(input || '').replace(/(?:\r\n|\r|\n)+$/u, '')}\r`;
 }
 
+function normalizeTerminalBufferedInput(input) {
+    return `\x15${String(input || '').replace(/(?:\r\n|\r|\n)+$/u, '')}`;
+}
+
 function readSessionOutputForState(session, maxChars = 12000) {
     return stripAnsiSequences((session?.buffer || []).join('').slice(-maxChars));
 }
@@ -1627,6 +1657,8 @@ app.get('/api/shell/sessions/provider-output', authenticateToken, requireProject
         20000,
         Math.max(1000, Number.parseInt(String(req.query.maxChars || '12000'), 10) || 12000)
     );
+    const sinceCursorRaw = Number.parseInt(String(req.query.sinceCursor ?? ''), 10);
+    const sinceCursor = Number.isFinite(sinceCursorRaw) ? Math.max(0, sinceCursorRaw) : null;
 
     if (!SHELL_CLI_PROVIDERS.has(provider)) {
         return res.status(400).json({ error: 'Unsupported provider' });
@@ -1643,6 +1675,8 @@ app.get('/api/shell/sessions/provider-output', authenticateToken, requireProject
                 tabId,
                 sessionId,
                 output: '',
+                outputCursor: 0,
+                bufferStartCursor: 0,
                 message: 'Multiple provider terminal sessions match this target. Pick a specific tab.',
             });
         }
@@ -1653,14 +1687,21 @@ app.get('/api/shell/sessions/provider-output', authenticateToken, requireProject
             tabId,
             sessionId,
             output: '',
+            outputCursor: 0,
+            bufferStartCursor: 0,
             message: 'No active provider terminal session found for this project.',
         });
     }
 
     const matchedSession = match.session;
-    const rawOutput = matchedSession.buffer.join('').slice(-maxChars);
+    const {
+        rawOutput,
+        outputCursor,
+        bufferStartCursor,
+    } = readPtySessionBufferedOutput(matchedSession, { maxChars, sinceCursor });
     const output = stripAnsiSequences(rawOutput);
-    const terminalState = resolveProviderTerminalState(matchedSession, provider, output);
+    const fullOutput = readSessionOutputForState(matchedSession);
+    const terminalState = resolveProviderTerminalState(matchedSession, provider, fullOutput);
     res.json({
         active: true,
         provider,
@@ -1671,6 +1712,9 @@ app.get('/api/shell/sessions/provider-output', authenticateToken, requireProject
         matchStatus: match.status,
         ...terminalState,
         output,
+        outputCursor,
+        bufferStartCursor,
+        sinceCursor,
     });
 });
 
@@ -1683,6 +1727,7 @@ app.post('/api/shell/sessions/provider-input', authenticateToken, requireProject
     const sessionId = readPtyTarget(req.body?.sessionId);
     const input = typeof req.body?.input === 'string' ? req.body.input : '';
     const submit = req.body?.submit !== false;
+    const submitMode = req.body?.submitMode === 'deferred-enter' ? 'deferred-enter' : 'inline';
 
     if (!SHELL_CLI_PROVIDERS.has(provider)) {
         return res.status(400).json({ error: 'Unsupported provider' });
@@ -1722,9 +1767,31 @@ app.post('/api/shell/sessions/provider-input', authenticateToken, requireProject
     }
 
     const matchedSession = match.session;
-    const data = submit ? normalizeTerminalStartupInput(input) : input;
+    const data = submit
+        ? (submitMode === 'deferred-enter' ? normalizeTerminalBufferedInput(input) : normalizeTerminalStartupInput(input))
+        : input;
+    const outputCursorBefore = matchedSession.totalOutputBytes || matchedSession.bufferBytes || 0;
     try {
         writeTerminalInputChunks(matchedSession.pty, data);
+        if (submit && submitMode === 'deferred-enter') {
+            setTimeout(() => {
+                const currentSession = findProviderPtySession({
+                    provider,
+                    projectPath,
+                    user: req.user,
+                    tabId,
+                    sessionId,
+                    requireRunning: true,
+                    requirePty: true,
+                }).session;
+                try {
+                    writeTerminalInputChunks(currentSession?.pty, '\r');
+                    if (currentSession) currentSession.updatedAt = Date.now();
+                } catch (error) {
+                    console.warn('Deferred terminal submit failed:', error?.message || error);
+                }
+            }, 120);
+        }
         matchedSession.updatedAt = Date.now();
         res.json({
             ok: true,
@@ -1734,8 +1801,11 @@ app.post('/api/shell/sessions/provider-input', authenticateToken, requireProject
             tabId: matchedSession.tabId || null,
             wrote: true,
             submitted: submit,
+            submitMode,
             bytes: Buffer.byteLength(data),
             matchStatus: match.status,
+            outputCursorBefore,
+            outputCursorAfter: matchedSession.totalOutputBytes || matchedSession.bufferBytes || 0,
         });
     } catch (error) {
         res.status(500).json({
@@ -4152,6 +4222,7 @@ function handleShellConnection(ws, request) {
                         ws: ws,
                         buffer: [],
                         bufferBytes: 0,
+                        totalOutputBytes: 0,
                         droppedOutputBytes: 0,
                         timeoutId: null,
                         userId: ownerUserId,

package/server/routes/git.js

@@ -46,9 +46,11 @@ router.use((req, res, next) => {
 });
 
 function isNotGitRepositoryMessage(message = '') {
-  return message.includes('Not a git repository')
-    || message.includes('not a git repository')
-    || message.includes('Project directory is not a git repository');
+  const normalized = String(message || '').toLowerCase();
+  return normalized.includes('not a git repository')
+    || normalized.includes('not inside a git work tree')
+    || normalized.includes('does not contain a .git folder')
+    || normalized.includes('project directory is not a git repository');
 }
 
 function isMissingFileError(error) {
@@ -178,6 +180,35 @@ async function buildFilesystemStatus(projectPath) {
   };
 }
 
+async function readFilesystemFileWithDiff(projectPath, filePath) {
+  const projectRoot = path.resolve(projectPath);
+  const resolvedFilePath = path.resolve(projectRoot, String(filePath || ''));
+  const relativePath = path.relative(projectRoot, resolvedFilePath);
+
+  if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
+    const error = new Error('Invalid file path: path traversal detected');
+    error.statusCode = 400;
+    throw error;
+  }
+
+  const stats = await fs.stat(resolvedFilePath);
+  if (stats.isDirectory()) {
+    const error = new Error('Cannot show diff for directories');
+    error.statusCode = 400;
+    throw error;
+  }
+
+  const currentContent = await fs.readFile(resolvedFilePath, 'utf-8');
+  return {
+    currentContent,
+    oldContent: currentContent,
+    isDeleted: false,
+    isUntracked: false,
+    isGitRepository: false,
+    trackingMode: 'filesystem',
+  };
+}
+
 function spawnAsync(command, args, options = {}) {
   return new Promise((resolve, reject) => {
     const child = spawn(command, args, {
@@ -634,6 +665,14 @@ router.get('/diff', async (req, res) => {
 
     res.json({ diff });
   } catch (error) {
+    if (isNotGitRepositoryMessage(getGitErrorDetails(error))) {
+      return res.json({
+        diff: '',
+        isGitRepository: false,
+        trackingMode: 'filesystem',
+      });
+    }
+
     console.error('Git diff error:', error);
     res.json({ error: error.message });
   }
@@ -763,6 +802,34 @@ router.get('/file-with-diff', async (req, res) => {
         isUntracked: false,
       });
     }
+
+    if (isNotGitRepositoryMessage(getGitErrorDetails(error))) {
+      try {
+        return res.json(await readFilesystemFileWithDiff(
+          await getActualProjectPath(project),
+          file,
+        ));
+      } catch (fallbackError) {
+        if (isMissingFileError(fallbackError)) {
+          return res.status(404).json({
+            error: 'File not found',
+            currentContent: '',
+            oldContent: '',
+            isDeleted: true,
+            isUntracked: false,
+            isGitRepository: false,
+            trackingMode: 'filesystem',
+          });
+        }
+
+        return res.status(fallbackError.statusCode || 500).json({
+          error: fallbackError.message || 'Failed to read file',
+          isGitRepository: false,
+          trackingMode: 'filesystem',
+        });
+      }
+    }
+
     console.error('Git file-with-diff error:', error);
     res.json({ error: error.message });
   }

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

@@ -32,9 +32,14 @@ const MAX_SSE_BUFFER_CHARS = 256_000;
 const ACTIVITY_EDIT_THROTTLE_MS = 1200;
 const ACTIVITY_HEARTBEAT_MS = 8000;
 const INTENT_ROUTER_TIMEOUT_MS = 45_000;
+const TERMINAL_BRIDGE_TIMEOUT_MS = 5 * 60 * 1000;
+const TERMINAL_BRIDGE_POLL_MS = 1500;
+const TERMINAL_BRIDGE_EDIT_THROTTLE_MS = 3500;
+const TERMINAL_BRIDGE_SETTLE_MS = 6000;
 const callbackActions = new Map();
 const runMonitors = new Map();
 const activeLongTasks = new Map();
+const terminalBridgeMonitors = new Map();
 
 const MODEL_FALLBACKS = Object.fromEntries(
   PROVIDERS.map((provider) => [provider, getStaticProviderModels(provider)]),
@@ -587,7 +592,7 @@ function terminalProjectLabel(terminal) {
   return terminal?.projectLabel || terminal?.projectName || terminal?.projectPath || '-';
 }
 
-function terminalOutputUrl(terminal, maxChars = 3200) {
+function terminalOutputUrl(terminal, maxChars = 3200, sinceCursor = null) {
   const params = new URLSearchParams({
     provider: terminal.provider,
     projectPath: terminal.projectPath,
@@ -595,6 +600,7 @@ function terminalOutputUrl(terminal, maxChars = 3200) {
   });
   if (terminal.tabId) params.set('tabId', terminal.tabId);
   if (terminal.sessionId) params.set('sessionId', terminal.sessionId);
+  if (Number.isFinite(sinceCursor)) params.set('sinceCursor', String(sinceCursor));
   return `/api/shell/sessions/provider-output?${params.toString()}`;
 }
 
@@ -621,6 +627,193 @@ function renderTerminalSnapshot(lang, terminal, data, { prefix = '', includeOutp
   return truncate(lines.join('\n'), 3400);
 }
 
+function terminalBridgeMonitorKey(chatId, terminal) {
+  return [
+    chatId,
+    terminal.provider,
+    terminal.projectPath,
+    terminal.tabId || '-',
+    terminal.sessionId || '-',
+  ].join(':');
+}
+
+function normalizeBridgeLine(value) {
+  return String(value || '').replace(/\s+/g, ' ').trim();
+}
+
+function isNoisyTerminalBridgeLine(line, prompt) {
+  const normalized = normalizeBridgeLine(line);
+  if (!normalized || normalized.length <= 1) return true;
+  if (/^[╭╮╰╯│─═┌┐└┘├┤┬┴┼\s]+$/u.test(normalized)) return true;
+  if (/^[●✶✻✽✢✳⠂⠐⏵·\s0;:()\-|/\\]+$/u.test(normalized)) return true;
+
+  const lower = normalized.toLowerCase();
+  const promptNeedle = normalizeBridgeLine(prompt).toLowerCase();
+  if (promptNeedle && lower.includes(promptNeedle.slice(0, 120))) return true;
+  if (/^[›❯>]\s*/u.test(normalized)) return true;
+  if (lower.includes('welcome back')) return true;
+  if (lower.includes('api usage billing')) return true;
+  if (lower.includes('bypass permissions')) return true;
+  if (lower.includes('try "')) return true;
+  if (lower.includes('esc to interrupt') || lower.includes('press esc')) return true;
+  if (lower.includes('/effort')) return true;
+  if (lower.includes('determining')) return true;
+  if (/^(?:claude code|codex)\b/i.test(normalized) && normalized.length < 80) return true;
+  if (/^\(?\d+s\s*·\s*[↓↑]?\d*\s*tokens?\)?$/iu.test(normalized)) return true;
+  return false;
+}
+
+function cleanTerminalBridgeOutput(output, prompt) {
+  const text = String(output || '')
+    .replace(/\r/g, '\n')
+    .replace(/[\x00-\x08\x0B-\x1F\x7F]/g, '')
+    .replace(/\u00a0/g, ' ');
+  const lines = text
+    .split('\n')
+    .map((line) => line.replace(/[ \t]+/g, ' ').trim())
+    .filter((line) => !isNoisyTerminalBridgeLine(line, prompt));
+  const deduped = [];
+  for (const line of lines) {
+    if (deduped.at(-1) === line) continue;
+    deduped.push(line);
+  }
+  return deduped.join('\n').trim();
+}
+
+function renderTerminalBridgeProgress(lang, terminal, {
+  output = '',
+  statusKey = 'control.terminalWaiting',
+  startedAt = Date.now(),
+  final = false,
+  terminalState = null,
+} = {}) {
+  const lines = [
+    `${final ? '✅' : '⏳'} ${t(lang, statusKey)}`,
+    '',
+    `🤖 ${t(lang, 'control.activity.provider')}: ${terminal.provider}`,
+    `📁 ${t(lang, 'control.activity.project')}: ${compact(terminalProjectLabel(terminal), 90)}`,
+  ];
+  if (terminal.sessionId) {
+    lines.push(`🧵 ${t(lang, 'control.activity.session')}: ${terminal.sessionId}`);
+  }
+  if (terminalState) {
+    lines.push(`📌 ${t(lang, 'control.activity.status')}: ${terminalState}`);
+  }
+  if (output) {
+    lines.push('', `💬 ${t(lang, 'control.activity.output')}:`);
+    lines.push(truncate(output, final ? 2800 : 2200));
+  } else {
+    lines.push('', t(lang, 'control.terminalWaitingHint'));
+  }
+  if (!final) {
+    lines.push('', `⏱ ${t(lang, 'control.activity.elapsed')}: ${formatElapsed(startedAt)}`);
+  }
+  return truncate(lines.join('\n'), 3400);
+}
+
+async function monitorTerminalBridgeResponse({
+  bot,
+  chatId,
+  link,
+  terminal,
+  prompt,
+  sinceCursor,
+  editMessageId,
+  monitorKey,
+  monitorToken,
+}) {
+  const lang = languageFor(link);
+  const startedAt = Date.now();
+  let lastCleanOutput = '';
+  let lastOutputChangeAt = startedAt;
+  let lastEditAt = 0;
+
+  const isCurrent = () => terminalBridgeMonitors.get(monitorKey) === monitorToken;
+
+  try {
+    while (isCurrent() && Date.now() - startedAt < TERMINAL_BRIDGE_TIMEOUT_MS) {
+      await new Promise((resolve) => setTimeout(resolve, TERMINAL_BRIDGE_POLL_MS));
+      if (!isCurrent()) return;
+
+      const data = await localApi(
+        link.user_id,
+        terminalOutputUrl(terminal, 12000, sinceCursor),
+        { timeoutMs: 12_000 },
+      );
+      if (data?.active === false) {
+        await send(bot, chatId, renderTerminalBridgeProgress(lang, terminal, {
+          output: lastCleanOutput,
+          statusKey: 'control.terminalNotRunning',
+          startedAt,
+          final: true,
+          terminalState: 'not running',
+        }), {
+          editMessageId,
+          parse_mode: undefined,
+          reply_markup: { inline_keyboard: terminalControlKeyboard(lang) },
+        });
+        return;
+      }
+      const cleanOutput = cleanTerminalBridgeOutput(data?.output, prompt);
+      const terminalState = data?.terminalState || data?.lifecycleState || 'unknown';
+      const now = Date.now();
+
+      if (cleanOutput && cleanOutput !== lastCleanOutput) {
+        lastCleanOutput = cleanOutput;
+        lastOutputChangeAt = now;
+      }
+
+      const finishedByState = ['idle', 'completed', 'failed', 'exited'].includes(terminalState);
+      const finishedByQuietOutput = Boolean(lastCleanOutput) && now - lastOutputChangeAt >= TERMINAL_BRIDGE_SETTLE_MS;
+      const shouldFinish = Boolean(lastCleanOutput) && (finishedByState || finishedByQuietOutput);
+
+      if (shouldFinish) {
+        await send(bot, chatId, renderTerminalBridgeProgress(lang, terminal, {
+          output: lastCleanOutput,
+          statusKey: 'control.terminalResponseReady',
+          startedAt,
+          final: true,
+          terminalState,
+        }), {
+          editMessageId,
+          parse_mode: undefined,
+          reply_markup: { inline_keyboard: terminalControlKeyboard(lang) },
+        });
+        return;
+      }
+
+      if (now - lastEditAt >= TERMINAL_BRIDGE_EDIT_THROTTLE_MS) {
+        lastEditAt = now;
+        await send(bot, chatId, renderTerminalBridgeProgress(lang, terminal, {
+          output: lastCleanOutput,
+          statusKey: lastCleanOutput ? 'control.terminalResponding' : 'control.terminalWaiting',
+          startedAt,
+          terminalState,
+        }), {
+          editMessageId,
+          parse_mode: undefined,
+          reply_markup: { inline_keyboard: terminalControlKeyboard(lang) },
+        });
+      }
+    }
+
+    if (!isCurrent()) return;
+    await send(bot, chatId, renderTerminalBridgeProgress(lang, terminal, {
+      output: lastCleanOutput,
+      statusKey: lastCleanOutput ? 'control.terminalStillRunning' : 'control.terminalNoReadableOutput',
+      startedAt,
+      final: Boolean(lastCleanOutput),
+      terminalState: 'running',
+    }), {
+      editMessageId,
+      parse_mode: undefined,
+      reply_markup: { inline_keyboard: terminalControlKeyboard(lang) },
+    });
+  } finally {
+    if (isCurrent()) terminalBridgeMonitors.delete(monitorKey);
+  }
+}
+
 export async function sendActiveTerminalAttachedNotice({ bot, chatId, link, terminal }) {
   const lang = languageFor(link);
   const lines = [
@@ -695,7 +888,7 @@ async function sendToActiveTerminal({ bot, chatId, link, text }) {
   const editMessageId = sent?.message_id || sent?.message?.message_id || null;
 
   try {
-    await localApi(link.user_id, '/api/shell/sessions/provider-input', {
+    const inputResult = await localApi(link.user_id, '/api/shell/sessions/provider-input', {
       method: 'POST',
       timeoutMs: 15_000,
       body: {
@@ -705,17 +898,38 @@ async function sendToActiveTerminal({ bot, chatId, link, text }) {
         sessionId: terminal.sessionId,
         input: text,
         submit: true,
+        submitMode: 'deferred-enter',
       },
     });
-    await new Promise((resolve) => setTimeout(resolve, 700));
-    const data = await localApi(link.user_id, terminalOutputUrl(terminal), { timeoutMs: 12_000 });
-    await send(bot, chatId, renderTerminalSnapshot(lang, terminal, data, {
-      prefix: t(lang, 'control.terminalSent'),
+    const sinceCursor = Number.isFinite(inputResult?.outputCursorBefore)
+      ? inputResult.outputCursorBefore
+      : null;
+    const monitorKey = terminalBridgeMonitorKey(chatId, terminal);
+    const monitorToken = crypto.randomUUID();
+    terminalBridgeMonitors.set(monitorKey, monitorToken);
+
+    await send(bot, chatId, renderTerminalBridgeProgress(lang, terminal, {
+      statusKey: 'control.terminalWaiting',
+      startedAt: Date.now(),
+      terminalState: 'running',
     }), {
       editMessageId,
       parse_mode: undefined,
       reply_markup: { inline_keyboard: terminalControlKeyboard(lang) },
     });
+    monitorTerminalBridgeResponse({
+      bot,
+      chatId,
+      link,
+      terminal,
+      prompt: text,
+      sinceCursor,
+      editMessageId,
+      monitorKey,
+      monitorToken,
+    }).catch((error) => {
+      console.warn('[telegram-control] terminal bridge monitor failed:', error?.message || error);
+    });
   } catch (error) {
     await send(bot, chatId, t(lang, 'control.terminalSendFailed', {
       error: error?.message || String(error),

package/server/services/telegram/translations.js

@@ -86,6 +86,13 @@ const EN = {
   'control.terminalOutputHidden': 'Live CLI screen output is not dumped into Telegram because full-screen terminal UIs are noisy. Keep sending messages here, or open Pixcode for the live terminal.',
   'control.terminalSending': '📲 Sending to {{provider}} terminal on {{project}}...',
   'control.terminalSent': '📲 Sent to the active terminal.',
+  'control.terminalSentHint': 'I will not dump the live terminal screen here because full-screen CLI UIs are noisy. Keep sending messages here, or open Pixcode for the live terminal.',
+  'control.terminalWaiting': 'Message sent to the active terminal. Waiting for the CLI response...',
+  'control.terminalWaitingHint': 'The same web CLI session is still attached. I will edit this message when readable output arrives.',
+  'control.terminalResponding': 'CLI response is streaming.',
+  'control.terminalResponseReady': 'CLI response is ready.',
+  'control.terminalStillRunning': 'The CLI is still running. I am leaving this Telegram bridge attached.',
+  'control.terminalNoReadableOutput': 'The message was sent, but I could not extract a clean Telegram reply yet.',
   'control.terminalSendFailed': 'Could not send to the active terminal: {{error}}',
   'control.terminalStatusFailed': 'Could not read the active terminal: {{error}}',
   'control.terminalDetached': 'Telegram is detached from the web CLI session. Plain messages will use the normal AI router again.',
@@ -246,6 +253,13 @@ const TR = {
   'control.terminalOutputHidden': 'Canlı CLI ekran çıktısı Telegrama dökülmez; tam ekran terminal arayüzleri burada gürültülü görünür. Buradan mesaj göndermeye devam et veya canlı terminal için Pixcodeu aç.',
   'control.terminalSending': '📲 {{project}} üzerinde {{provider}} terminaline gönderiliyor...',
   'control.terminalSent': '📲 Aktif terminale gönderildi.',
+  'control.terminalSentHint': 'Canlı terminal ekranını buraya dökmeyeceğim; tam ekran CLI arayüzleri Telegramda bozuk görünebilir. Buradan mesaj göndermeye devam et veya canlı terminal için Pixcodeu aç.',
+  'control.terminalWaiting': 'Mesaj aktif terminale gönderildi. CLI yanıtı bekleniyor...',
+  'control.terminalWaitingHint': 'Aynı web CLI oturumu bağlı kalıyor. Okunabilir çıktı gelince bu mesajı düzenleyeceğim.',
+  'control.terminalResponding': 'CLI yanıtı geliyor.',
+  'control.terminalResponseReady': 'CLI yanıtı hazır.',
+  'control.terminalStillRunning': 'CLI hâlâ çalışıyor. Telegram köprüsünü bağlı bırakıyorum.',
+  'control.terminalNoReadableOutput': 'Mesaj gönderildi ama henüz temiz bir Telegram yanıtı çıkaramadım.',
   'control.terminalSendFailed': 'Aktif terminale gönderilemedi: {{error}}',
   'control.terminalStatusFailed': 'Aktif terminal okunamadı: {{error}}',
   'control.terminalDetached': 'Telegram web CLI oturumundan ayrıldı. Düz mesajlar tekrar normal AI router akışına gidecek.',