bosun 0.31.4 → 0.31.6

package/error-detector.mjs

@@ -240,6 +240,22 @@ export const PATTERN_SEVERITY = {
   unknown: "low",
 };
 
+// ── Remediation hints ──────────────────────────────────────────────────────
+
+/**
+ * Human-readable remediation hints for each error type.
+ * Surfaced in UI and Telegram notifications to guide users.
+ */
+const REMEDIATION_HINTS = {
+  rate_limit: "Wait a few minutes before retrying. Consider reducing MAX_PARALLEL.",
+  oom: "Reduce MAX_PARALLEL or increase available memory. Use --max-old-space-size.",
+  oom_kill: "Process was killed by the OS. Reduce memory usage or increase system RAM.",
+  git_conflict: "Manual conflict resolution required. Run: git mergetool",
+  push_failure: "Rebase failed or push rejected. Run: git rebase --abort then try again.",
+  auth_error: "Authentication failed. Check your API tokens and credentials.",
+  api_error: "Network connectivity issue. Check your internet connection.",
+};
+
 // ── Helpers ─────────────────────────────────────────────────────────────────
 
 /** Safely truncate a string for logging / details. */
@@ -364,6 +380,7 @@ export class ErrorDetector {
     return {
       ...result,
       severity: PATTERN_SEVERITY[result.pattern] ?? "low",
+      remediation: REMEDIATION_HINTS[result.pattern] || null,
     };
   }
 

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.4",
+  "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/task-executor.mjs

@@ -68,7 +68,7 @@ import {
   collectDiffStats,
 } from "./diff-stats.mjs";
 import { createAnomalyDetector } from "./anomaly-detector.mjs";
-import { normalizeDedupKey, yieldToEventLoop } from "./utils.mjs";
+import { normalizeDedupKey, yieldToEventLoop, withRetry } from "./utils.mjs";
 import {
   resolveExecutorForTask,
   executorToSdk,
@@ -3169,10 +3169,20 @@ class TaskExecutor {
         return;
       }
 
-      // Fetch todo tasks
+      // Fetch todo tasks (with transient-error retry)
       let tasks;
       try {
-        tasks = await listTasks(projectId, { status: "todo" });
+        tasks = await withRetry(
+          () => listTasks(projectId, { status: "todo" }),
+          {
+            maxAttempts: 3,
+            baseMs: 2000,
+            retryIf: (err) => {
+              const cat = categorizeError(err);
+              return cat === "transient" || cat === "network";
+            },
+          },
+        );
         this._resetListTasksBackoff();
       } catch (err) {
         this._noteListTasksFailure(err);
@@ -3252,14 +3262,19 @@ class TaskExecutor {
       for (const task of toDispatch) {
         // Normalize task id
         task.id = task.id || task.task_id;
-        // Fire and forget — executeTask handles its own lifecycle
-        this.executeTask(task).catch((err) => {
-          console.error(
-            `${TAG} unhandled error in executeTask for "${task.title}": ${err.message}`,
-          );
-        });
-        // Yield between slot dispatches so WebSocket/HTTP work can proceed
-        await yieldToEventLoop();
+        try {
+          // Fire and forget — executeTask handles its own lifecycle
+          this.executeTask(task).catch((err) => {
+            console.error(
+              `${TAG} unhandled error in executeTask for "${task.title}": ${err.message}`,
+            );
+          });
+        } catch (err) {
+          console.warn(`${TAG} slot ${task.id} dispatch error: ${err.message}`);
+        } finally {
+          // ALWAYS yield, even on error, to prevent event loop starvation
+          await yieldToEventLoop();
+        }
       }
     } catch (err) {
       console.error(`${TAG} poll loop error: ${err.message}`);

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 },