bosun 0.42.2 → 0.42.4

package/.env.example

@@ -802,6 +802,11 @@ VK_RECOVERY_PORT=54089
 # BOSUN_HOOKS_DISABLE_TASK_COMPLETE=false
 # BOSUN_HOOKS_DISABLE_HEALTH_CHECK=false
 
+# ── OpenTelemetry Tracing & Metrics ───────────────────────────────────────────
+# External orchestration-layer observability only; never affects agent context.
+# BOSUN_OTEL_ENDPOINT=http://localhost:4318/v1/traces
+# Configure tracing.sampleRate in bosun.config.json to tune sampling.
+
 # Force hooks to fire even for non-managed sessions (debug only):
 # BOSUN_HOOKS_FORCE=false
 
@@ -1175,3 +1180,7 @@ COPILOT_CLOUD_DISABLED=true
 # AGENT_STUCK_THRESHOLD_MS=300000
 # Alert if session costs more than $N (default: 1.0)
 # AGENT_COST_ANOMALY_THRESHOLD=1.0
+
+# OpenTelemetry tracing (optional)
+# BOSUN_OTEL_ENDPOINT=http://localhost:4318/v1/traces
+

package/agent/agent-event-bus.mjs

@@ -25,6 +25,7 @@ import {
   reduceRetryQueue,
   snapshotRetryQueue,
 } from "./retry-queue.mjs";
+import { addSpanEvent, recordAgentError, recordIntervention } from "../infra/tracing.mjs";
 
 const TAG = "[agent-event-bus]";
 
@@ -232,6 +233,14 @@ export class AgentEventBus {
   emit(type, taskId, payload = {}, opts = {}) {
     const ts = Date.now();
     const event = { type, taskId, payload, ts };
+    addSpanEvent(type, { "bosun.task.id": taskId, ...payload });
+    if (type === AGENT_EVENT.AGENT_ERROR) {
+      recordAgentError(payload?.errorType || payload?.classification || "agent_error", {
+        "bosun.task.id": taskId,
+        "bosun.executor": payload?.executor,
+        "bosun.agent.sdk": payload?.sdk,
+      });
+    }
 
     // ── Dedup
     const key = `${type}:${taskId}`;
@@ -1092,3 +1101,4 @@ export function createAgentEventBus(options) {
   return new AgentEventBus(options);
 }
 
+

package/agent/agent-supervisor.mjs

@@ -29,6 +29,8 @@
  * @module agent-supervisor
  */
 
+import { addSpanEvent, recordIntervention } from "../infra/tracing.mjs";
+
 const TAG = "[agent-supervisor]";
 const API_ERROR_CONTINUE_COOLDOWNS_MS = Object.freeze([
   3 * 60_000,
@@ -473,6 +475,12 @@ export class AgentSupervisor {
     }
 
     this._lastDecision.set(taskId, { situation, intervention, ts: Date.now() });
+    addSpanEvent("bosun.supervisor.assess", {
+      "bosun.task.id": taskId,
+      "bosun.health.score": healthScore,
+      "bosun.situation": situation,
+      "bosun.intervention.type": intervention,
+    });
 
     return { situation, healthScore, intervention, prompt, reason };
   }
@@ -489,6 +497,18 @@ export class AgentSupervisor {
     );
 
     try {
+      if (intervention !== INTERVENTION.NONE) {
+        recordIntervention(intervention, {
+          "bosun.task.id": taskId,
+          "bosun.situation": situation,
+        });
+      }
+      addSpanEvent("bosun.supervisor.intervention", {
+        "bosun.task.id": taskId,
+        "bosun.intervention.type": intervention,
+        "bosun.situation": situation,
+        "bosun.reason": reason,
+      });
       switch (intervention) {
         case INTERVENTION.NONE:
           break;

package/bosun-tui.mjs

@@ -1,142 +1,144 @@
 #!/usr/bin/env node
 
-/**
- * bosun-tui — Terminal User Interface for Bosun
- *
- * A terminal-based UI for monitoring Bosun agents, tasks, and workflows.
- * Built with Ink (React-like CLI framework).
- *
- * Usage:
- *   bosun-tui              # Start the TUI
- *   bosun-tui --help       # Show help
- *   bosun-tui --port 3080  # Connect to specific port
- */
-
-import { resolve, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
 import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import loadConfig from "./config/config.mjs";
+import { resolveWebSocketProtocol } from "./tui/lib/ws-bridge.mjs";
+
+const MIN_COLUMNS = 120;
+const MIN_ROWS = 30;
+
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
 function showHelp() {
-  const version = JSON.parse(
-    readFileSync(resolve(__dirname, "package.json"), "utf8"),
-  ).version;
-
+  const version = JSON.parse(readFileSync(resolve(__dirname, "package.json"), "utf8")).version;
   console.log(`
   bosun-tui v${version}
-  Terminal User Interface for Bosun
+  Terminal UI for Bosun
 
   USAGE
-    bosun-tui [options]
+    bosun tui [options]
+    node bosun-tui.mjs [options]
 
   OPTIONS
-    --port <n>         UI server port to connect (default: 3080 or TELEGRAM_UI_PORT env)
-    --host <host>     UI server host (default: localhost)
-    --connect         Connect to existing UI server (don't start monitor)
-    --screen <name>   Initial screen (tasks|agents|status)
-    --refresh <ms>    Stats refresh interval (default: 2000ms)
-    --help            Show this help
-    --version         Show version
-
-  SCREENS
-    tasks    Kanban board with task CRUD
-    agents   Live agent session table
-    status   System status overview
-
-  KEYBOARD NAVIGATION
-    Tab / Shift+Tab   Navigate between panels
-    ↑↓←→             Navigate within panels
-    Enter            Select / Execute action
-    Esc              Back / Close modal
-    c                Create new task (tasks screen)
-    r                Resume selected agent session (Agents screen)
-    q                Quit
-
-  EXAMPLES
-    bosun-tui --port 3080
-    bosun-tui --screen tasks
-    bosun-tui --connect --port 3080
+    --host <host>       WebSocket host (default: 127.0.0.1)
+    --port <n>          WebSocket/UI port (default: TELEGRAM_UI_PORT or 3080)
+    --screen <name>     Initial screen (agents|tasks|logs|workflows|telemetry|settings|help)
+    --help              Show this help
+    --version           Show version
   `);
 }
 
-function getArgValue(flag, defaultValue = "") {
-  const args = process.argv.slice(2);
-  const match = args.find((arg) => arg.startsWith(`${flag}=`));
-  if (match) {
-    return match.slice(flag.length + 1).trim();
-  }
-  const idx = args.indexOf(flag);
-  if (idx >= 0 && args[idx + 1] && !args[idx + 1].startsWith("--")) {
-    return args[idx + 1].trim();
+function getArgValue(args, flag, defaultValue = "") {
+  const inline = args.find((arg) => arg.startsWith(`${flag}=`));
+  if (inline) return inline.slice(flag.length + 1).trim();
+  const index = args.indexOf(flag);
+  if (index >= 0 && args[index + 1] && !args[index + 1].startsWith("--")) {
+    return args[index + 1].trim();
   }
   return defaultValue;
 }
 
-function getArgFlag(flag) {
-  const args = process.argv.slice(2);
-  return args.includes(flag);
+function hasFlag(args, ...flags) {
+  return flags.some((flag) => args.includes(flag));
+}
+
+function getTerminalSize(stdout = process.stdout) {
+  return {
+    columns: Math.max(0, Number(stdout?.columns || 0)),
+    rows: Math.max(0, Number(stdout?.rows || 0)),
+  };
+}
+
+function resolvePort(config) {
+  return Number(process.env.TELEGRAM_UI_PORT || process.env.BOSUN_PORT || config?.telegramUiPort || "3080") || 3080;
+}
+
+function renderApp(instance, React, App, props) {
+  instance.rerender(React.createElement(App, props));
 }
 
-async function main() {
-  const args = process.argv.slice(2);
+export async function runBosunTui(argv = process.argv.slice(2), options = {}) {
+  const stdout = options.stdout || process.stdout;
+  const stderr = options.stderr || process.stderr;
+  const args = Array.isArray(argv) ? argv : [];
 
-  if (getArgFlag("--help") || args.includes("-h")) {
+  if (hasFlag(args, "--help", "-h")) {
     showHelp();
-    process.exit(0);
+    return 0;
   }
 
-  if (getArgFlag("--version") || args.includes("-v")) {
-    const version = JSON.parse(
-      readFileSync(resolve(__dirname, "package.json"), "utf8"),
-    ).version;
+  if (hasFlag(args, "--version", "-v")) {
+    const version = JSON.parse(readFileSync(resolve(__dirname, "package.json"), "utf8")).version;
     console.log(`bosun-tui v${version}`);
-    process.exit(0);
+    return 0;
   }
 
-  const port = Number(getArgValue("--port", process.env.TELEGRAM_UI_PORT || "3080")) || 3080;
-  const host = getArgValue("--host", "localhost");
-  const connectOnly = getArgFlag("--connect");
-  const initialScreen = getArgValue("--screen", "status");
-  const refreshMs = Number(getArgValue("--refresh", "2000")) || 2000;
+  if (!stdout?.isTTY) {
+    stderr.write("[bosun-tui] Error: stdout is not a TTY. Run `bosun tui` in an interactive terminal.\n");
+    return 1;
+  }
 
-  console.log(`[bosun-tui] Starting...`);
-  console.log(`[bosun-tui] Connecting to ${host}:${port}`);
+  globalThis.WebSocket = globalThis.WebSocket || (await import("ws")).WebSocket;
+
+  const config = loadConfig([process.argv[0], __filename, ...args]);
+  const configDir = String(config?.configDir || process.env.BOSUN_DIR || resolve(process.cwd(), ".bosun")).trim();
+  const host = getArgValue(args, "--host", "127.0.0.1");
+  const port = Number(getArgValue(args, "--port", String(resolvePort(config)))) || resolvePort(config);
+  const protocol = getArgValue(
+    args,
+    "--protocol",
+    resolveWebSocketProtocol({ configDir }),
+  );
+  const initialScreen = getArgValue(args, "--screen", "agents");
+
+  const React = await import("react");
+  const ink = await import("ink");
+  const { default: App } = await import("./ui/tui/App.js");
+
+  let terminalSize = getTerminalSize(stdout);
+  const props = {
+    config,
+    configDir,
+    host,
+    port,
+    protocol,
+    initialScreen,
+    terminalSize,
+  };
+
+  const instance = ink.render(React.createElement(App, props), { exitOnCtrlC: true });
+
+  const onResize = () => {
+    terminalSize = getTerminalSize(stdout);
+    renderApp(instance, React, App, { ...props, terminalSize });
+  };
+
+  stdout.on?.("resize", onResize);
 
   try {
-    const { render } = await import("ink");
-    const importErrors = [];
-
-    let App;
-    try {
-      const appModule = await import("./tui/app.mjs");
-      App = appModule.default;
-    } catch (importErr) {
-      importErrors.push(`App: ${importErr.message}`);
-      console.error(`[bosun-tui] Failed to import TUI app: ${importErr.message}`);
-      console.log(`[bosun-tui] TUI requires ink. Install with: npm install ink`);
-      process.exit(1);
+    if (typeof instance.waitUntilExit === "function") {
+      await instance.waitUntilExit();
     }
-
-    const { waitUntilExit } = await import("ink");
-
-    const app = render(
-      App({
-        host,
-        port,
-        connectOnly,
-        initialScreen,
-        refreshMs,
-      }),
-    );
-
-    process.exitCode = await waitUntilExit(app);
-  } catch (err) {
-    console.error(`[bosun-tui] Failed to start: ${err.message}`);
-    console.log(`[bosun-tui] Ensure bosun is running or use --connect to connect to an existing UI server`);
-    process.exit(1);
+    return 0;
+  } finally {
+    stdout.off?.("resize", onResize);
   }
 }
 
-main();
+if (process.argv[1] && resolve(process.argv[1]) === __filename) {
+  runBosunTui(process.argv.slice(2))
+    .then((code) => {
+      process.exit(code ?? 0);
+    })
+    .catch((error) => {
+      console.error(`[bosun-tui] Failed to start: ${error?.message || error}`);
+      process.exit(1);
+    });
+}
+
+

package/cli.mjs

@@ -79,6 +79,7 @@ function showHelp() {
   COMMANDS
     workflow list              List declarative pipeline workflows
     workflow run <name>        Run a declarative pipeline workflow
+    tui                        Launch the terminal UI
     audit <command>            Run codebase annotation audit tools (scan|generate|warn|manifest|index|trim|conformity|migrate)
     --setup                    Launch the web-based setup wizard (default)
     --setup-terminal            Run the legacy terminal setup wizard
@@ -167,6 +168,7 @@ function showHelp() {
     workflow run <name>         Run a declarative fresh-context workflow
 
     Run 'bosun workflow --help' for workflow CLI examples.
+    Run 'bosun tui' to launch the terminal UI.
 
   VIBE-KANBAN
     --no-vk-spawn               Don't auto-spawn Vibe-Kanban
@@ -1425,6 +1427,12 @@ async function main() {
     process.exit(0);
   }
 
+  if (args[0] === "tui") {
+    const { runBosunTui } = await import("./bosun-tui.mjs");
+    const exitCode = await runBosunTui(args.slice(1));
+    process.exit(exitCode ?? 0);
+  }
+
   // Handle --help
   if (args.includes("--help") || args.includes("-h")) {
     showHelp();
@@ -2710,3 +2718,5 @@ main().catch(async (err) => {
   await sendCrashNotification(1, null).catch(() => {});
   process.exit(1);
 });
+
+

package/config/config.mjs

@@ -1811,6 +1811,10 @@ export function loadConfig(argv = process.argv, options = {}) {
     `http://127.0.0.1:${vkRecoveryPort}`;
   const vkPublicUrl = process.env.VK_PUBLIC_URL || process.env.VK_WEB_URL || "";
   const vkTaskUrlTemplate = process.env.VK_TASK_URL_TEMPLATE || "";
+  const tracingEndpoint =
+    process.env.BOSUN_OTEL_ENDPOINT || configData?.tracing?.endpoint || null;
+  const tracingEnabled = configData?.tracing?.enabled ?? Boolean(tracingEndpoint);
+  const tracingSampleRate = Number(configData?.tracing?.sampleRate ?? 1);
   const vkRecoveryCooldownMin = Number(
     process.env.VK_RECOVERY_COOLDOWN_MIN || "10",
   );
@@ -2127,6 +2131,20 @@ export function loadConfig(argv = process.argv, options = {}) {
     // Voice assistant
     voice: Object.freeze(configData.voice || {}),
 
+    // OpenTelemetry tracing
+    tracing: Object.freeze({
+      enabled:
+        typeof configData.tracing?.enabled === "boolean"
+          ? configData.tracing.enabled
+          : Boolean(configData.tracing?.endpoint || process.env.BOSUN_OTEL_ENDPOINT || ""),
+      endpoint:
+        configData.tracing?.endpoint || process.env.BOSUN_OTEL_ENDPOINT || "",
+      sampleRate:
+        Number.isFinite(Number(configData.tracing?.sampleRate))
+          ? Number(configData.tracing.sampleRate)
+          : 1.0,
+    }),
+
     // Merge Strategy
     codexAnalyzeMergeStrategy:
       codexEnabled &&
@@ -2144,6 +2162,11 @@ export function loadConfig(argv = process.argv, options = {}) {
     vkEndpointUrl,
     vkPublicUrl,
     vkTaskUrlTemplate,
+    tracing: {
+      enabled: tracingEnabled,
+      endpoint: tracingEndpoint,
+      sampleRate: Number.isFinite(tracingSampleRate) ? tracingSampleRate : 1,
+    },
     vkRecoveryCooldownMin,
     vkRuntimeRequired,
     vkSpawnEnabled,
@@ -2318,3 +2341,5 @@ export {
   resolveAgentRepoRoot,
 };
 export default loadConfig;
+
+

package/config/executor-config.mjs

@@ -122,6 +122,84 @@ const DEFAULT_EXECUTORS = {
   distribution: "primary-only",
 };
 
+const DEFAULT_WORKFLOW_OFFLOAD_POLICY = Object.freeze({
+  enabled: true,
+  nodeTypes: ["validation.tests", "validation.build", "validation.lint"],
+  commandTypes: ["test", "build", "qualityGate"],
+  commandPatterns: [
+    "\\b(?:npm|pnpm|yarn|bun)\\s+(?:run\\s+)?test\\b",
+    "\\b(?:npm|pnpm|yarn|bun)\\s+run\\s+build\\b",
+    "\\b(?:npm|pnpm|yarn|bun)\\s+run\\s+lint\\b",
+    "\\bvitest\\b",
+    "\\bjest\\b",
+    "\\btsc\\b",
+    "\\bpre-?push\\b",
+    "\\bgit\\s+diff\\b",
+  ],
+});
+
+function parseBooleanFlag(value, fallback = false) {
+  if (value == null || value === "") return fallback;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return value !== 0;
+  const normalized = String(value || "").trim().toLowerCase();
+  if (!normalized) return fallback;
+  if (["1", "true", "yes", "y", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "n", "off"].includes(normalized)) return false;
+  return fallback;
+}
+
+function normalizeWorkflowOffloadPolicy(configData = {}) {
+  const rawPolicy =
+    configData?.workflowOffloadPolicy && typeof configData.workflowOffloadPolicy === "object"
+      ? configData.workflowOffloadPolicy
+      : configData?.executors?.workflowOffloadPolicy &&
+          typeof configData.executors.workflowOffloadPolicy === "object"
+        ? configData.executors.workflowOffloadPolicy
+        : {};
+
+  const parsePatterns = (value) =>
+    parseListValue(value)
+      .map((entry) => {
+        try {
+          return new RegExp(entry, "i");
+        } catch {
+          return null;
+        }
+      })
+      .filter(Boolean);
+
+  const nodeTypes = parseListValue(
+    process.env.HEAVY_RUNNER_OFFLOAD_NODE_TYPES ??
+      rawPolicy.nodeTypes ??
+      DEFAULT_WORKFLOW_OFFLOAD_POLICY.nodeTypes,
+  );
+  const commandTypes = parseListValue(
+    process.env.HEAVY_RUNNER_OFFLOAD_COMMAND_TYPES ??
+      rawPolicy.commandTypes ??
+      DEFAULT_WORKFLOW_OFFLOAD_POLICY.commandTypes,
+  );
+  const commandPatterns = parsePatterns(
+    process.env.HEAVY_RUNNER_OFFLOAD_COMMAND_PATTERNS ??
+      rawPolicy.commandPatterns ??
+      DEFAULT_WORKFLOW_OFFLOAD_POLICY.commandPatterns,
+  );
+
+  return {
+    enabled: parseBooleanFlag(
+      process.env.HEAVY_RUNNER_OFFLOAD_ENABLED ?? rawPolicy.enabled,
+      DEFAULT_WORKFLOW_OFFLOAD_POLICY.enabled,
+    ),
+    nodeTypes: new Set(
+      nodeTypes.map((entry) => String(entry || "").trim()).filter(Boolean),
+    ),
+    commandTypes: new Set(
+      commandTypes.map((entry) => String(entry || "").trim()).filter(Boolean),
+    ),
+    commandPatterns,
+  };
+}
+
 function parseExecutorsFromEnv() {
   // EXECUTORS=CODEX:DEFAULT:100:gpt-5.2-codex|gpt-5.1-codex-mini
   const raw = process.env.EXECUTORS;
@@ -256,7 +334,12 @@ export function loadExecutorConfig(configDir, configData) {
     process.env.EXECUTOR_DISTRIBUTION ||
     DEFAULT_EXECUTORS.distribution;
 
-  return { executors, failover, distribution };
+  return {
+    executors,
+    failover,
+    distribution,
+    workflowOffloadPolicy: normalizeWorkflowOffloadPolicy(configData),
+  };
 }
 
 // ── Executor Scheduler ───────────────────────────────────────────────────────
@@ -266,6 +349,7 @@ export class ExecutorScheduler {
     this.executors = config.executors.filter((e) => e.enabled !== false);
     this.failover = config.failover;
     this.distribution = config.distribution;
+    this.workflowOffloadPolicy = normalizeWorkflowOffloadPolicy(config);
     this._roundRobinIndex = 0;
     this._failureCounts = new Map(); // name → consecutive failures
     this._disabledUntil = new Map(); // name → timestamp
@@ -273,6 +357,45 @@ export class ExecutorScheduler {
     this._workspaceConfigs = new Map(); // workspaceId → { maxConcurrent, pool, weight }
   }
 
+  selectWorkflowLane({ nodeType = "", commandType = "", command = "" } = {}) {
+    const policy = this.workflowOffloadPolicy || DEFAULT_WORKFLOW_OFFLOAD_POLICY;
+    if (!policy.enabled) {
+      return { lane: "main", reason: "offload_disabled", heavy: false };
+    }
+
+    const normalizedNodeType = String(nodeType || "").trim();
+    if (normalizedNodeType && policy.nodeTypes.has(normalizedNodeType)) {
+      return {
+        lane: "isolated",
+        reason: `workflow_node:${normalizedNodeType}`,
+        heavy: true,
+      };
+    }
+
+    const normalizedCommandType = String(commandType || "").trim();
+    if (normalizedCommandType && policy.commandTypes.has(normalizedCommandType)) {
+      return {
+        lane: "isolated",
+        reason: `command_type:${normalizedCommandType}`,
+        heavy: true,
+      };
+    }
+
+    const rawCommand = String(command || "");
+    if (rawCommand) {
+      const matched = policy.commandPatterns.find((pattern) => pattern.test(rawCommand));
+      if (matched) {
+        return {
+          lane: "isolated",
+          reason: `command_pattern:${matched.source}`,
+          heavy: true,
+        };
+      }
+    }
+
+    return { lane: "main", reason: "lightweight", heavy: false };
+  }
+
   /**
    * Register workspace executor config for concurrency tracking.
    * @param {string} workspaceId