bosun 0.31.5 → 0.31.6

package/kanban-adapter.mjs

@@ -903,7 +903,7 @@ class GitHubIssuesAdapter {
       process.env.BOSUN_TASK_LABEL || "bosun";
     this._taskScopeLabels = normalizeLabels(
       process.env.BOSUN_TASK_LABELS ||
-        `${this._canonicalTaskLabel},codex-mointor`,
+        `${this._canonicalTaskLabel},codex-monitor`,
     );
     this._enforceTaskLabel = parseBooleanEnv(
       process.env.BOSUN_ENFORCE_TASK_LABEL,
@@ -915,7 +915,7 @@ class GitHubIssuesAdapter {
       true,
     );
     this._defaultAssignee =
-      process.env.GITHUB_DEFAULT_ASSIGNEE || this._owner || null;
+      String(process.env.GITHUB_DEFAULT_ASSIGNEE || "").trim() || null;
 
     this._projectMode = String(process.env.GITHUB_PROJECT_MODE || "issues")
       .trim()

package/monitor.mjs

@@ -1,4 +1,5 @@
 import { execSync, spawn, spawnSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
 import {
   existsSync,
   mkdirSync,
@@ -7902,10 +7903,8 @@ function extractPlannerTasksFromOutput(output, maxTasks) {
   return normalized;
 }
 
-async function materializePlannerTasksToKanban(projectId, tasks) {
-  const existingOpenTasks = await listKanbanTasks(projectId, {
-    status: "todo",
-  });
+async function materializePlannerTasksToKanban(tasks) {
+  const existingOpenTasks = getInternalTasksByStatus("todo");
   const existingTitles = new Set(
     (Array.isArray(existingOpenTasks) ? existingOpenTasks : [])
       .map((task) => normalizePlannerTitleForComparison(task?.title))
@@ -7925,16 +7924,26 @@ async function materializePlannerTasksToKanban(projectId, tasks) {
       skipped.push({ title: task.title, reason: "duplicate_title" });
       continue;
     }
-    const createdTask = await createKanbanTask(projectId, {
+    const baseBranch = task.baseBranch || task.base_branch || extractModuleBaseBranchFromTitle(task.title);
+    const plannerMeta = {
+      source: "task-planner",
+      plannerMode: "codex-sdk",
+      kind: "planned-task",
+      externalSyncPending: true,
+      createdAt: new Date().toISOString(),
+    };
+    const createdTask = addInternalTask({
+      id: randomUUID(),
       title: task.title,
       description: task.description,
       status: "todo",
-      // Honour explicit baseBranch from planner JSON, then fall back to
-      // module auto-detection via conventional commit scope in the title.
-      ...(() => {
-        const b = task.baseBranch || task.base_branch || extractModuleBaseBranchFromTitle(task.title);
-        return b ? { baseBranch: b } : {};
-      })(),
+      projectId: process.env.INTERNAL_EXECUTOR_PROJECT_ID || "internal",
+      ...(baseBranch ? { baseBranch } : {}),
+      syncDirty: true,
+      meta: {
+        planner: plannerMeta,
+        ...(baseBranch ? { base_branch: baseBranch, baseBranch } : {}),
+      },
     });
     if (createdTask?.id) {
       created.push({ id: createdTask.id, title: task.title });
@@ -8987,13 +8996,6 @@ async function triggerTaskPlannerViaKanban(
     details,
     numTasks,
   );
-  // Get project ID using the kanban adapter
-  const projectId = await findKanbanProjectId();
-  if (!projectId) {
-    throw new Error(
-      `Cannot reach kanban backend (${getActiveKanbanBackend()}) or no project found`,
-    );
-  }
 
   const desiredTitle = userPrompt
     ? `[${plannerTaskSizeLabel}] Plan next tasks (${reason || "backlog-empty"}) — ${userPrompt.slice(0, 60)}${userPrompt.length > 60 ? "…" : ""}`
@@ -9008,7 +9010,7 @@ async function triggerTaskPlannerViaKanban(
 
   // Check for existing planner tasks to avoid duplicates
   // Only block on TODO tasks whose title matches the exact format we create
-  const existingTasks = await listKanbanTasks(projectId, { status: "todo" });
+  const existingTasks = getInternalTasksByStatus("todo");
   const existingPlanner = (
     Array.isArray(existingTasks) ? existingTasks : []
   ).find((t) => {
@@ -9042,7 +9044,7 @@ async function triggerTaskPlannerViaKanban(
       );
     }
 
-    const taskUrl = buildTaskUrl(existingPlanner, projectId);
+    const taskUrl = null;
     if (notify) {
       const suffix = taskUrl ? `\n${taskUrl}` : "";
       await sendTelegramMessage(
@@ -9061,7 +9063,7 @@ async function triggerTaskPlannerViaKanban(
       taskId: existingPlanner.id,
       taskTitle: existingPlanner.title,
       taskUrl,
-      projectId,
+      projectId: process.env.INTERNAL_EXECUTOR_PROJECT_ID || "internal",
     };
   }
 
@@ -9071,7 +9073,24 @@ async function triggerTaskPlannerViaKanban(
     status: "todo",
   };
 
-  const createdTask = await createKanbanTask(projectId, taskData);
+  const createdTask = addInternalTask({
+    id: randomUUID(),
+    title: taskData.title,
+    description: taskData.description,
+    status: "todo",
+    projectId: process.env.INTERNAL_EXECUTOR_PROJECT_ID || "internal",
+    syncDirty: true,
+    meta: {
+      planner: {
+        source: "task-planner",
+        plannerMode: "kanban",
+        kind: "planner-request",
+        triggerReason: reason || "manual",
+        externalSyncPending: true,
+        createdAt: new Date().toISOString(),
+      },
+    },
+  });
 
   if (createdTask && createdTask.id) {
     console.log(`[monitor] task planner task created: ${createdTask.id}`);
@@ -9082,7 +9101,7 @@ async function triggerTaskPlannerViaKanban(
       last_result: "kanban_task_created",
     });
     const createdId = createdTask.id;
-    const createdUrl = buildTaskUrl(createdTask, projectId);
+    const createdUrl = null;
     if (notify) {
       const suffix = createdUrl ? `\n${createdUrl}` : "";
       await sendTelegramMessage(
@@ -9094,7 +9113,7 @@ async function triggerTaskPlannerViaKanban(
       taskId: createdId,
       taskTitle: taskData.title,
       taskUrl: createdUrl,
-      projectId,
+      projectId: process.env.INTERNAL_EXECUTOR_PROJECT_ID || "internal",
     };
   }
   throw new Error("Task creation failed");
@@ -9194,14 +9213,7 @@ async function triggerTaskPlannerViaCodex(
     "utf8",
   );
 
-  const projectId = await findKanbanProjectId();
-  if (!projectId) {
-    throw new Error(
-      `Task planner produced ${parsedTasks.length} tasks, but no kanban project is reachable for backend "${getActiveKanbanBackend()}"`,
-    );
-  }
   const { created, skipped } = await materializePlannerTasksToKanban(
-    projectId,
     parsedTasks,
   );
 
@@ -9228,7 +9240,7 @@ async function triggerTaskPlannerViaCodex(
     status: "completed",
     outputPath: outPath,
     artifactPath,
-    projectId,
+    projectId: process.env.INTERNAL_EXECUTOR_PROJECT_ID || "internal",
     parsedTaskCount: parsedTasks.length,
     createdTaskCount: created.length,
     skippedTaskCount: skipped.length,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bosun",
-  "version": "0.31.5",
+  "version": "0.31.6",
   "description": "AI-powered orchestrator supervisor — manages AI agent executors with failover, auto-restarts on failure, analyzes crashes with Codex SDK, creates PRs via Vibe-Kanban API, and sends Telegram notifications. Supports N executors with weighted distribution, multi-repo projects, and auto-setup.",
   "type": "module",
   "license": "Apache 2.0",

package/sync-engine.mjs

@@ -16,7 +16,6 @@
 import {
   getTask,
   getAllTasks,
-  addTask,
   updateTask,
   getDirtyTasks,
   markSynced,
@@ -29,6 +28,7 @@ import {
   getKanbanAdapter,
   getKanbanBackendName,
   listTasks,
+  createTask as createExternalTask,
   updateTaskStatus as updateExternalStatus,
 } from "./kanban-adapter.mjs";
 
@@ -585,6 +585,11 @@ export class SyncEngine {
         baseBranchCandidate &&
         String(baseBranchCandidate) !== String(metaBaseBranch);
 
+      const shouldCreateExternal = this.#shouldCreateExternalTask(
+        task,
+        backendName,
+      );
+
       // Check shared state for conflicts before pushing
       if (SHARED_STATE_ENABLED) {
         try {
@@ -618,9 +623,48 @@ export class SyncEngine {
           // Continue with push on error (graceful degradation)
         }
       }
+      let pushId = task.externalId || task.id;
+
+      if (shouldCreateExternal) {
+        try {
+          const created = await this.#createExternalTask(task, baseBranchCandidate);
+          const createdId = this.#extractExternalTaskId(created);
+          if (!isIdValidForBackend(createdId, backendName)) {
+            throw new Error(
+              `external create returned incompatible id for ${backendName}: ${createdId || "<empty>"}`,
+            );
+          }
+
+          const plannerMeta = {
+            ...(task.meta?.planner || {}),
+            externalSyncPending: false,
+            externalCreatedAt: new Date().toISOString(),
+            externalTaskId: String(createdId),
+          };
+          updateTask(task.id, {
+            externalId: String(createdId),
+            externalBackend: backendName,
+            meta: {
+              ...(task.meta || {}),
+              planner: plannerMeta,
+            },
+          });
+
+          pushId = String(createdId);
+          console.log(
+            TAG,
+            `Created external task for ${task.id} → ${pushId} (${backendName})`,
+          );
+        } catch (err) {
+          const msg = `External create failed for ${task.id}: ${err.message}`;
+          console.warn(TAG, msg);
+          result.errors.push(msg);
+          continue;
+        }
+      }
+
       // Skip tasks whose IDs are incompatible with the active backend.
       // e.g. VK UUID tasks cannot be pushed to GitHub Issues (needs numeric IDs).
-      const pushId = task.externalId || task.id;
       if (!isIdValidForBackend(pushId, backendName)) {
         // If the task originated from a different backend, silently clear dirty
         // flag — it will be synced when that backend is active.
@@ -973,6 +1017,28 @@ export class SyncEngine {
     return await updateExternalStatus(taskId, status);
   }
 
+  async #createExternalTask(task, baseBranchCandidate = null) {
+    const payload = {
+      title: task.title || "Untitled task",
+      description: task.description || "",
+      status: "todo",
+      assignee: task.assignee || null,
+      priority: task.priority || null,
+      tags: Array.isArray(task.tags) ? task.tags : [],
+      labels: Array.isArray(task.tags) ? task.tags : [],
+      ...(baseBranchCandidate ? { baseBranch: baseBranchCandidate } : {}),
+    };
+
+    if (
+      this.#kanbanAdapter &&
+      typeof this.#kanbanAdapter.createTask === "function"
+    ) {
+      return await this.#kanbanAdapter.createTask(this.#projectId, payload);
+    }
+
+    return await createExternalTask(this.#projectId, payload);
+  }
+
   async #updateExternalPatch(taskId, patch) {
     if (
       this.#kanbanAdapter &&
@@ -1022,6 +1088,25 @@ export class SyncEngine {
     );
   }
 
+  #shouldCreateExternalTask(task, backend) {
+    if (!task || backend === "internal") return false;
+    if (task.externalId) return false;
+    const plannerMeta = task.meta?.planner;
+    if (!plannerMeta || typeof plannerMeta !== "object") return false;
+    return plannerMeta.externalSyncPending === true;
+  }
+
+  #extractExternalTaskId(created) {
+    if (!created) return null;
+    if (created.id != null && String(created.id).trim()) {
+      return String(created.id).trim();
+    }
+    if (created.externalId != null && String(created.externalId).trim()) {
+      return String(created.externalId).trim();
+    }
+    return null;
+  }
+
   /** Simple async sleep. */
   #sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));

package/telegram-bot.mjs

@@ -789,6 +789,20 @@ function getBrowserUiUrl() {
   const base = telegramUiUrl;
   if (!base) return null;
   const token = getSessionToken();
+
+  // Prefer LAN for browser opens when available (same-network path),
+  // and fall back to the configured/public URL.
+  try {
+    const parsed = new URL(base);
+    const lanIp = getLocalLanIp?.();
+    if (lanIp && parsed.port) {
+      const lanBase = `${parsed.protocol}//${lanIp}:${parsed.port}`;
+      return appendTokenToUrl(lanBase, token) || lanBase;
+    }
+  } catch {
+    // fall through to base URL
+  }
+
   if (!token) return base;
   return appendTokenToUrl(base, token) || base;
 }
@@ -3042,6 +3056,7 @@ async function refreshMenuButton() {
 
 const FAST_COMMANDS = new Set([
   "/menu",
+  "/background",
   "/status",
   "/tasks",
   "/agents",
@@ -3063,39 +3078,36 @@ const FAST_COMMANDS = new Set([
 ]);
 
 function getTelegramWebAppUrl(url) {
-  // Prefer cloudflared tunnel URL (valid cert, works in Telegram Mini App)
+  // Telegram Mini App must be HTTPS and publicly reachable.
+  // Priority: explicit env URL -> tunnel URL -> provided URL.
+  const explicit =
+    process.env.TELEGRAM_WEBAPP_URL || process.env.TELEGRAM_UI_BASE_URL || "";
   const tUrl = getTunnelUrl();
-  if (tUrl) {
-    const normalizedTunnel = String(tUrl || "").trim().replace(/\/+$/, "");
-    return appendTokenToUrl(normalizedTunnel, getSessionToken()) || normalizedTunnel;
-  }
+  const candidates = [explicit, tUrl, url];
 
-  const normalized = String(url || "")
-    .trim()
-    .replace(/\/+$/, "");
-  if (!normalized) return null;
-  try {
-    const parsed = new URL(normalized);
-    if (parsed.protocol !== "https:") {
-      if (telegramWebAppUrlWarned !== normalized) {
-        telegramWebAppUrlWarned = normalized;
-        console.warn(
-          `[telegram-bot] mini app URL must be HTTPS for Telegram WebApp buttons; got "${normalized}". Falling back to normal URL buttons only.`,
-        );
-      }
-      return null;
-    }
-    const normalizedUrl = parsed.toString().replace(/\/+$/, "");
-    return appendTokenToUrl(normalizedUrl, getSessionToken()) || normalizedUrl;
-  } catch {
-    if (telegramWebAppUrlWarned !== normalized) {
-      telegramWebAppUrlWarned = normalized;
-      console.warn(
-        `[telegram-bot] mini app URL is invalid: "${normalized}". Falling back to normal URL buttons only.`,
-      );
+  for (const candidate of candidates) {
+    const normalized = String(candidate || "")
+      .trim()
+      .replace(/\/+$/, "");
+    if (!normalized) continue;
+    try {
+      const parsed = new URL(normalized);
+      if (parsed.protocol !== "https:") continue;
+      const normalizedUrl = parsed.toString().replace(/\/+$/, "");
+      return appendTokenToUrl(normalizedUrl, getSessionToken()) || normalizedUrl;
+    } catch {
+      // try next candidate
     }
-    return null;
   }
+
+  const warnSource = String(explicit || tUrl || url || "").trim();
+  if (warnSource && telegramWebAppUrlWarned !== warnSource) {
+    telegramWebAppUrlWarned = warnSource;
+    console.warn(
+      `[telegram-bot] mini app URL requires a valid HTTPS URL. Got "${warnSource}". Falling back to browser URL buttons only.`,
+    );
+  }
+  return null;
 }
 
 function appendTokenToUrl(inputUrl, token) {
@@ -4142,6 +4154,11 @@ Object.assign(UI_SCREENS, {
           },
           uiButton("✖", "cb:close_menu"),
         ]);
+        if (telegramUiUrl) {
+          rows.unshift([
+            { text: "🌐 Open in Browser", url: getBrowserUiUrl() || telegramUiUrl },
+          ]);
+        }
       } else if (telegramUiUrl) {
         rows.unshift([
           { text: "🌐 Open Control Center", url: getBrowserUiUrl() || telegramUiUrl },

package/ui/components/chat-view.js

@@ -210,6 +210,15 @@ function categorizeMessage(msg) {
   return "message";
 }
 
+function isThinkingTraceMessage(msg) {
+  if (!msg) return false;
+  const category = categorizeMessage(msg);
+  if (category === "tool" || category === "result" || category === "error") {
+    return true;
+  }
+  return (msg.type || "").toLowerCase() === "system";
+}
+
 function formatMessageLine(msg) {
   const timestamp = msg?.timestamp || "";
   const kind = msg?.role || msg?.type || "message";
@@ -258,6 +267,38 @@ const ChatBubble = memo(function ChatBubble({ msg }) {
   `;
 }, (prev, next) => prev.msg === next.msg);
 
+const ThinkingPanel = memo(function ThinkingPanel({ entries }) {
+  if (!Array.isArray(entries) || entries.length === 0) return null;
+  return html`
+    <details class="chat-thinking-panel">
+      <summary class="chat-thinking-summary">
+        🧠 Thinking · ${entries.length} ${entries.length === 1 ? "step" : "steps"}
+      </summary>
+      <div class="chat-thinking-body">
+        ${entries.map((entry, index) => {
+          const category = categorizeMessage(entry);
+          const label =
+            category === "tool"
+              ? "Tool"
+              : category === "result"
+                ? "Result"
+                : category === "error"
+                  ? "Error"
+                  : "System";
+          return html`
+            <div class="chat-thinking-item" key=${entry.id || entry.timestamp || `thinking-${index}`}>
+              <div class="chat-thinking-item-label">${label}</div>
+              <div class="chat-thinking-item-content">
+                <${MessageContent} text=${entry.content || ""} />
+              </div>
+            </div>
+          `;
+        })}
+      </div>
+    </details>
+  `;
+});
+
 /* ─── Chat View component ─── */
 export function ChatView({ sessionId, readOnly = false, embedded = false }) {
   const [input, setInput] = useState("");
@@ -351,23 +392,60 @@ export function ChatView({ sessionId, readOnly = false, embedded = false }) {
     }
   }, [messages.length]);
 
-  /* Same approach for status signals — use .peek() to avoid creating signal
-     subscriptions. The status bar cosmetics don't justify re-rendering the
-     entire 200-message list. We piggyback on the messages.length change
-     (which already triggers a re-render) to refresh these values. */
+  /* Keep status indicators fully live while an agent is active. */
   let errorCount = 0;
   let statusState = "idle";
   let statusText = "";
   try {
-    errorCount = totalErrorCount.peek() || 0;
-    statusState = paused ? "paused" : (agentStatus.peek()?.state || "idle");
-    statusText = paused ? "Stream paused" : (agentStatusText.peek() || "Ready");
+    errorCount = totalErrorCount.value || 0;
+    statusState = paused ? "paused" : (agentStatus.value?.state || "idle");
+    statusText = paused ? "Stream paused" : (agentStatusText.value || "Ready");
   } catch (err) {
     console.warn("[ChatView] Failed to read status signals:", err);
     statusState = paused ? "paused" : "idle";
     statusText = paused ? "Stream paused" : "Ready";
   }
 
+  const renderItems = useMemo(() => {
+    const items = [];
+    let pendingThinking = [];
+    let panelIndex = 0;
+
+    const flushThinking = (anchor = "") => {
+      if (pendingThinking.length === 0) return;
+      const seed = pendingThinking[0]?.id || pendingThinking[0]?.timestamp || panelIndex;
+      items.push({
+        kind: "thinking",
+        key: `thinking-${sessionId || "session"}-${seed}-${anchor}-${panelIndex}`,
+        entries: pendingThinking,
+      });
+      pendingThinking = [];
+      panelIndex += 1;
+    };
+
+    for (const msg of visibleMessages) {
+      if (isThinkingTraceMessage(msg)) {
+        pendingThinking.push(msg);
+        continue;
+      }
+
+      const isAssistantMessage =
+        (msg.role || "") === "assistant" || (msg.type || "") === "agent_message";
+      if (isAssistantMessage) {
+        flushThinking(msg.id || msg.timestamp || "assistant");
+      }
+
+      items.push({
+        kind: "message",
+        key: msg.id || msg.timestamp || `msg-${items.length}`,
+        msg,
+      });
+    }
+
+    flushThinking("tail");
+    return items;
+  }, [visibleMessages, sessionId]);
+
   const refreshMessages = useCallback(async () => {
     if (!sessionId) return;
     setLoading(true);
@@ -461,7 +539,7 @@ export function ChatView({ sessionId, readOnly = false, embedded = false }) {
     if (!paused && autoScroll) {
       // Use smooth scroll for small increments, instant for large jumps
       const gap = el.scrollHeight - el.scrollTop - el.clientHeight;
-      el.scrollTo({ top: el.scrollHeight, behavior: gap < 800 ? "smooth" : "instant" });
+      el.scrollTo({ top: el.scrollHeight, behavior: gap < 800 ? "smooth" : "auto" });
       return;
     }
     if (newMessages && !autoScroll) {
@@ -806,12 +884,10 @@ export function ChatView({ sessionId, readOnly = false, embedded = false }) {
             </button>
           </div>
         `}
-        ${visibleMessages.map((msg) => html`
-          <${ChatBubble}
-            key=${msg.id || msg.timestamp}
-            msg=${msg}
-          />`
-        )} 
+        ${renderItems.map((item) => item.kind === "thinking"
+          ? html`<${ThinkingPanel} key=${item.key} entries=${item.entries} />`
+          : html`<${ChatBubble} key=${item.key} msg=${item.msg} />`
+        )}
 
         ${/* Pending messages (optimistic rendering) — use .peek() to avoid
               subscribing ChatView to pendingMessages signal. Pending messages

package/ui/modules/streaming.js

@@ -536,7 +536,7 @@ export const agentStatusText = computed(() => {
 });
 
 let _idleTimer = null;
-const IDLE_TIMEOUT = 5000;
+const IDLE_TIMEOUT = 45000;
 
 /**
  * Internal: transition agent state and reset idle timer.
@@ -600,6 +600,12 @@ export function startAgentStatusTracking() {
     const role = message.role;
     const type = message.type;
     const adapter = payload.session?.type || "";
+    const sessionStatus = payload.session?.status || "active";
+
+    if (sessionStatus !== "active") {
+      _setAgentState("idle", "");
+      return;
+    }
 
     if (role === "assistant" || type === "agent_message") {
       _setAgentState("streaming", adapter);
@@ -607,7 +613,7 @@ export function startAgentStatusTracking() {
       _setAgentState("executing", adapter);
     } else if (type === "tool_result") {
       _setAgentState("streaming", adapter);
-    } else if (type === "error" || type === "system") {
+    } else if (type === "error" || type === "stream_error") {
       _setAgentState("idle", "");
     }
   });

package/ui/styles/sessions.css

@@ -771,6 +771,7 @@
   min-height: 0;
   overflow-y: auto;
   overflow-x: hidden;
+  touch-action: pan-y;
   -webkit-overflow-scrolling: touch;
   overscroll-behavior-y: contain;
   scroll-padding-bottom: 80px;
@@ -952,6 +953,58 @@
   margin-top: 6px;
 }
 
+.chat-thinking-panel {
+  align-self: stretch;
+  border: 1px solid var(--border);
+  border-radius: 12px;
+  background: rgba(255, 255, 255, 0.02);
+  margin: 2px 0 4px;
+  overflow: hidden;
+}
+
+.chat-thinking-summary {
+  cursor: pointer;
+  user-select: none;
+  font-size: 12px;
+  font-weight: 600;
+  color: var(--text-secondary);
+  padding: 8px 12px;
+  list-style: none;
+}
+
+.chat-thinking-summary::-webkit-details-marker {
+  display: none;
+}
+
+.chat-thinking-body {
+  border-top: 1px solid var(--border);
+  padding: 8px 10px;
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+.chat-thinking-item {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  padding: 6px 8px;
+  border-radius: 10px;
+  background: rgba(255, 255, 255, 0.02);
+}
+
+.chat-thinking-item-label {
+  font-size: 10px;
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+  color: var(--text-hint);
+}
+
+.chat-thinking-item-content {
+  font-size: 12px;
+  color: var(--text-secondary);
+}
+
 /* Subtle entrance for bubbles — only the last few get the animation
    (content-visibility: auto on older bubbles skips them for free) */
 .chat-bubble:last-child,
@@ -1441,7 +1494,7 @@ ul.md-list li::before {
   position: sticky;
   bottom: 0;
   z-index: 10;
-  padding: 16px 16px;
+  padding: 16px 16px calc(16px + var(--chat-keyboard-offset, 0px));
   border-top: 1px solid var(--border);
   background: var(--bg-surface, var(--bg-card));
   flex-shrink: 0;
@@ -1466,7 +1519,7 @@ ul.md-list li::before {
 .session-detail > .chat-view-embedded {
   flex: 1;
   min-height: 0;
-  overflow-y: auto;
+  overflow: hidden;
   display: flex;
   flex-direction: column;
 }
@@ -1481,11 +1534,11 @@ ul.md-list li::before {
 }
 
 .app-shell[data-tab="chat"] .chat-view-embedded .chat-messages {
-  padding: 16px 20px 16px;
+  padding: 16px 20px calc(16px + var(--chat-keyboard-offset, 0px));
 }
 
 .app-shell[data-tab="chat"] .chat-input-area {
-  padding: 0 0 calc(12px + var(--safe-bottom, 0px));
+  padding: 0 0 calc(12px + var(--safe-bottom, 0px) + var(--chat-keyboard-offset, 0px));
 }
 
 .chat-input-wrapper {

package/ui/tabs/chat.js

@@ -323,6 +323,52 @@ export function ChatTab() {
     };
   }, []);
 
+  useEffect(() => {
+    if (typeof window === "undefined" || typeof document === "undefined") {
+      return undefined;
+    }
+
+    const root = document.documentElement;
+    const viewport = window.visualViewport;
+
+    const updateKeyboardOffset = () => {
+      if (!viewport) {
+        root.style.setProperty("--chat-keyboard-offset", "0px");
+        return;
+      }
+
+      const keyboardOffset = Math.max(
+        0,
+        Math.round(window.innerHeight - viewport.height - viewport.offsetTop),
+      );
+      root.style.setProperty("--chat-keyboard-offset", `${keyboardOffset}px`);
+      if (keyboardOffset > 0) {
+        root.setAttribute("data-chat-keyboard-open", "true");
+      } else {
+        root.removeAttribute("data-chat-keyboard-open");
+      }
+    };
+
+    updateKeyboardOffset();
+
+    if (!viewport) return () => {
+      root.style.setProperty("--chat-keyboard-offset", "0px");
+      root.removeAttribute("data-chat-keyboard-open");
+    };
+
+    viewport.addEventListener("resize", updateKeyboardOffset);
+    viewport.addEventListener("scroll", updateKeyboardOffset);
+    window.addEventListener("orientationchange", updateKeyboardOffset);
+
+    return () => {
+      viewport.removeEventListener("resize", updateKeyboardOffset);
+      viewport.removeEventListener("scroll", updateKeyboardOffset);
+      window.removeEventListener("orientationchange", updateKeyboardOffset);
+      root.style.setProperty("--chat-keyboard-offset", "0px");
+      root.removeAttribute("data-chat-keyboard-open");
+    };
+  }, []);
+
   useEffect(() => {
     if (typeof document === "undefined") return undefined;
     if (focusMode) {

package/ui/tabs/tasks.js

@@ -1178,30 +1178,23 @@ export function TasksTab() {
 
   const startTask = async ({ taskId, sdk, model }) => {
     haptic("medium");
-    const prev = cloneValue(tasks);
     let res = null;
-    await runOptimistic(
-      () => {
-        tasksData.value = tasksData.value.map((t) =>
-          t.id === taskId ? { ...t, status: "inprogress" } : t,
-        );
-      },
-      async () => {
-        res = await apiFetch("/api/tasks/start", {
-          method: "POST",
-          body: JSON.stringify({
-            taskId,
-            ...(sdk ? { sdk } : {}),
-            ...(model ? { model } : {}),
-          }),
-        });
-        return res;
-      },
-      () => {
-        tasksData.value = prev;
-      },
-    ).catch(() => {});
-    if (res?.wasPaused) {
+    try {
+      res = await apiFetch("/api/tasks/start", {
+        method: "POST",
+        body: JSON.stringify({
+          taskId,
+          ...(sdk ? { sdk } : {}),
+          ...(model ? { model } : {}),
+        }),
+      });
+    } catch {
+      return;
+    }
+
+    if (res?.queued) {
+      showToast("Task queued (waiting for free slot)", "info");
+    } else if (res?.wasPaused) {
       showToast("Task started (executor paused — force-dispatched)", "warning");
     } else if (res) {
       showToast("Task started", "success");

package/ui-server.mjs

@@ -2968,6 +2968,30 @@ async function handleApi(req, res, url) {
         jsonResponse(res, 404, { ok: false, error: "Task not found." });
         return;
       }
+
+      const status = executor.getStatus?.() || {};
+      const freeSlots =
+        (status.maxParallel || 0) - (status.activeSlots || 0);
+
+      if (freeSlots <= 0) {
+        jsonResponse(res, 202, {
+          ok: true,
+          taskId,
+          queued: true,
+          started: false,
+          reason: "No free slots",
+        });
+        broadcastUiEvent(
+          ["tasks", "overview", "executor", "agents"],
+          "invalidate",
+          {
+            reason: "task-queued",
+            taskId,
+          },
+        );
+        return;
+      }
+
       try {
         if (typeof adapter.updateTaskStatus === "function") {
           await adapter.updateTaskStatus(taskId, "inprogress");
@@ -2989,7 +3013,13 @@ async function handleApi(req, res, url) {
           `[telegram-ui] failed to execute task ${taskId}: ${error.message}`,
         );
       });
-      jsonResponse(res, 200, { ok: true, taskId, wasPaused });
+      jsonResponse(res, 200, {
+        ok: true,
+        taskId,
+        queued: false,
+        started: true,
+        wasPaused,
+      });
       broadcastUiEvent(
         ["tasks", "overview", "executor", "agents"],
         "invalidate",