bosun 0.31.6 → 0.31.8

package/.env.example

@@ -244,8 +244,8 @@ TELEGRAM_MINIAPP_ENABLED=false
 
 # ─── Executor Configuration ──────────────────────────────────────────────────
 # Define AI executors that work on tasks.
-# Format: EXECUTOR_TYPE:VARIANT:WEIGHT,EXECUTOR_TYPE:VARIANT:WEIGHT
-# Example: COPILOT:CLAUDE_OPUS_4_6:50,CODEX:DEFAULT:50
+# Format: EXECUTOR_TYPE:VARIANT:WEIGHT[:MODEL|MODEL],EXECUTOR_TYPE:VARIANT:WEIGHT[:MODEL|MODEL]
+# Example: COPILOT:CLAUDE_OPUS_4_6:50:claude-opus-4.6,CODEX:DEFAULT:50:gpt-5.2-codex|gpt-5.1-codex-mini
 # For full config, use bosun.config.json instead.
 # EXECUTORS=CODEX:DEFAULT:100
 
@@ -345,31 +345,42 @@ TELEGRAM_MINIAPP_ENABLED=false
 # OAuth Client Secret (only needed for callback-based OAuth, not for Device Flow):
 # BOSUN_GITHUB_CLIENT_SECRET=
 #
-# Webhook secret (set this in App settings → Webhook, and keep in sync):
+# Webhook secret (VirtEngine relay signs forwarded events with this — leave blank
+# until VirtEngine’s relay server is live; Bosun polls GitHub API in the meantime):
 # BOSUN_GITHUB_WEBHOOK_SECRET=
 #
 # Path to the PEM private key downloaded from App settings → Generate a private key:
 # BOSUN_GITHUB_PRIVATE_KEY_PATH=/path/to/bosun-botswain.pem
 #
+# ─── GitHub App Settings (enable all three in https://github.com/settings/apps/bosun-botswain) ────
+# ✅ Callback URL  →  http://127.0.0.1:54317/github/callback  (set this FIRST, then Save)
+# ✅ "Request user authorization (OAuth) during installation"  →  ON
+#      GitHub does OAuth at install time, redirecting to the Callback URL with
+#      installation_id + setup_action=install. Setup URL is DISABLED — that's fine.
+# ✅ "Enable Device Flow"  →  ON  (only available AFTER Callback URL is saved)
+#      Allows CLI/terminal auth without a public URL (like VS Code / Roo Code)
+# ✕ Setup URL  →  leave BLANK (GitHub disables this field when OAuth-at-install is ON)
+# ✕ "Redirect on update"  →  leave OFF (disabled alongside Setup URL)
+#
 # ─── Authentication Method ───────────────────────────────────────────────
 # RECOMMENDED: Device Flow (like VS Code / Roo Code — no public URL needed!)
 #   1. Set BOSUN_GITHUB_CLIENT_ID above
-#   2. Enable "Device Flow" in GitHub App settings (Settings → Optional features)
-#   3. Go to Settings → GitHub in the Bosun UI and click "Sign in with GitHub"
-#   4. That's it — no callback URL, no tunnel URL, no client secret needed
+#   2. Enable “Device Flow” in GitHub App settings (only clickable after Callback URL is saved)
+#   3. Go to Settings → GitHub in the Bosun UI and click “Sign in with GitHub”
+#   4. That’s it — no webhook URL, no tunnel, no public server needed
 #
-# ALTERNATIVE: OAuth Callback (requires a stable public URL)
+# ALTERNATIVE: OAuth Callback
 #   Set BOSUN_GITHUB_CLIENT_ID + BOSUN_GITHUB_CLIENT_SECRET
-#   Register callback URL in App settings:
-#     https://<your-bosun-public-url>/api/github/callback
+#   Register callback URL: http://127.0.0.1:54317/github/callback
 #
-# WEBHOOKS (optional — for real-time PR/issue sync):
-#   Register webhook URL in App settings:
-#     https://<your-bosun-public-url>/api/webhooks/github/app
-#   Webhooks require a stable public URL. Without them, Bosun polls instead.
+# NOTE on webhooks:
+#   Real-time GitHub events (PR comments, issue mentions) are received via
+#   VirtEngine’s relay server and forwarded to your Bosun instance.
+#   Until the relay is live, Bosun polls the GitHub API every few minutes instead.
+#   Users do NOT need to configure a webhook URL or run any tunnel.
 #
 # Leave BOSUN_GITHUB_APP_ID unset to disable co-author trailer injection.
-# BOSUN_GITHUB_APP_ID=
+# (App ID and Client ID are already filled in above — no need to set them again.)
 
 # ─── Kanban Backend ──────────────────────────────────────────────────────────
 # Task-board backend:
@@ -897,6 +908,12 @@ COPILOT_CLOUD_DISABLED=true
 # Task planner status stream interval (milliseconds). Default: 1800000 (30 min)
 # DEVMODE_TASK_PLANNER_STATUS_INTERVAL_MS=1800000
 
+# ─── Trigger-Based Task System ───────────────────────────────────────────────
+# Enable configurable trigger templates (disabled by default for safety).
+# Built-in templates ship disabled: task-planner, daily-review-digest,
+# stale-task-followup. Configure/enable in bosun.config.json under triggerSystem.
+# TASK_TRIGGER_SYSTEM_ENABLED=false
+
 # ─── GitHub Issue Reconciler ─────────────────────────────────────────────────
 # Periodically reconciles open GitHub issues against open/merged PRs.
 # Hybrid close policy:

package/bosun.schema.json

@@ -88,7 +88,10 @@
                   "description": "Map internal statuses to project board column names",
                   "properties": {
                     "todo": { "type": "string", "default": "Todo" },
-                    "inprogress": { "type": "string", "default": "In Progress" },
+                    "inprogress": {
+                      "type": "string",
+                      "default": "In Progress"
+                    },
                     "inreview": { "type": "string", "default": "In Review" },
                     "done": { "type": "string", "default": "Done" },
                     "cancelled": { "type": "string", "default": "Cancelled" }
@@ -221,6 +224,81 @@
       "type": "string",
       "enum": ["codex-sdk", "kanban", "disabled"]
     },
+    "triggerSystem": {
+      "type": "object",
+      "additionalProperties": true,
+      "properties": {
+        "enabled": { "type": "boolean", "default": false },
+        "templates": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "additionalProperties": true,
+            "properties": {
+              "id": { "type": "string" },
+              "name": { "type": "string" },
+              "description": { "type": "string" },
+              "enabled": { "type": "boolean", "default": false },
+              "action": {
+                "type": "string",
+                "enum": ["task-planner", "create-task"]
+              },
+              "minIntervalMinutes": { "type": "number", "minimum": 1 },
+              "trigger": {
+                "type": "object",
+                "additionalProperties": true,
+                "properties": {
+                  "anyOf": {
+                    "type": "array",
+                    "items": {
+                      "type": "object",
+                      "additionalProperties": true,
+                      "properties": {
+                        "kind": {
+                          "type": "string",
+                          "enum": ["metric", "interval"]
+                        },
+                        "metric": { "type": "string" },
+                        "operator": {
+                          "type": "string",
+                          "enum": ["lt", "lte", "gt", "gte", "eq", "neq"]
+                        },
+                        "value": { "type": ["number", "string", "boolean"] },
+                        "minutes": { "type": "number", "minimum": 1 }
+                      }
+                    }
+                  }
+                }
+              },
+              "config": {
+                "type": "object",
+                "additionalProperties": true,
+                "properties": {
+                  "plannerMode": {
+                    "type": "string",
+                    "enum": ["codex-sdk", "kanban", "disabled"]
+                  },
+                  "defaultTaskCount": { "type": "number", "minimum": 1 },
+                  "title": { "type": "string" },
+                  "description": { "type": "string" },
+                  "priority": { "type": "string" },
+                  "executor": { "type": "string" },
+                  "model": { "type": "string" }
+                }
+              }
+            }
+          }
+        },
+        "defaults": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "executor": { "type": "string" },
+            "model": { "type": "string" }
+          }
+        }
+      }
+    },
     "activeWorkspace": {
       "type": "string",
       "description": "ID of the currently active workspace"
@@ -249,11 +327,23 @@
               "additionalProperties": true,
               "required": ["name"],
               "properties": {
-                "name": { "type": "string", "description": "Repository directory name" },
+                "name": {
+                  "type": "string",
+                  "description": "Repository directory name"
+                },
                 "url": { "type": "string", "description": "Git clone URL" },
-                "slug": { "type": "string", "description": "GitHub slug (org/repo)" },
-                "primary": { "type": "boolean", "description": "Whether this is the primary repo" },
-                "branch": { "type": "string", "description": "Default branch to track" }
+                "slug": {
+                  "type": "string",
+                  "description": "GitHub slug (org/repo)"
+                },
+                "primary": {
+                  "type": "boolean",
+                  "description": "Whether this is the primary repo"
+                },
+                "branch": {
+                  "type": "string",
+                  "description": "Default branch to track"
+                }
               }
             }
           },
@@ -399,6 +489,10 @@
         "name": { "type": "string" },
         "executor": { "type": "string" },
         "variant": { "type": "string" },
+        "models": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
         "weight": { "type": "number" },
         "role": { "type": "string" },
         "enabled": { "type": "boolean" }

package/config-doctor.mjs

@@ -340,6 +340,27 @@ export function runConfigDoctor(options = {}) {
     }
   }
 
+  if (backend === "jira") {
+    const missing = [];
+    if (!effective.JIRA_BASE_URL) missing.push("JIRA_BASE_URL");
+    if (!effective.JIRA_EMAIL) missing.push("JIRA_EMAIL");
+    if (!effective.JIRA_API_TOKEN) missing.push("JIRA_API_TOKEN");
+    const hasProjectKey = Boolean(
+      effective.JIRA_PROJECT_KEY || effective.KANBAN_PROJECT_ID,
+    );
+    if (!hasProjectKey) {
+      missing.push("JIRA_PROJECT_KEY (or KANBAN_PROJECT_ID)");
+    }
+    if (missing.length > 0) {
+      issues.errors.push({
+        code: "JIRA_BACKEND_REQUIRED",
+        message: `KANBAN_BACKEND=jira is missing required config: ${missing.join(", ")}`,
+        fix:
+          "Set required JIRA_* variables (and project key), or switch KANBAN_BACKEND=internal.",
+      });
+    }
+  }
+
   const vkNeeded = backend === "vk" || mode === "vk" || mode === "hybrid";
   if (vkNeeded) {
     const vkBaseUrl = effective.VK_BASE_URL || "";

package/config.mjs

@@ -26,6 +26,10 @@ import {
 } from "./agent-prompts.mjs";
 import { resolveAgentRepoRoot } from "./repo-root.mjs";
 import { applyAllCompatibility } from "./compat.mjs";
+import {
+  normalizeExecutorKey,
+  getModelsForExecutor,
+} from "./task-complexity.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -158,6 +162,80 @@ function loadDotEnvFile(envPath, options = {}) {
   }
 }
 
+function readEnvValueFromFile(envPath, key) {
+  if (!envPath || !existsSync(envPath)) return undefined;
+  const lines = readFileSync(envPath, "utf8").split("\n");
+  let found;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIdx = trimmed.indexOf("=");
+    if (eqIdx === -1) continue;
+    const parsedKey = trimmed.slice(0, eqIdx).trim();
+    if (parsedKey !== key) continue;
+    let value = trimmed.slice(eqIdx + 1).trim();
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1);
+    }
+    found = value;
+  }
+  return found;
+}
+
+function resolveKanbanBackendSource({ envPaths = [], configFilePath, configData }) {
+  const key = "KANBAN_BACKEND";
+  let source = "default";
+  let sourcePath = null;
+
+  if (process.env[key] != null && String(process.env[key]).trim() !== "") {
+    let envFileMatch = null;
+    for (const envPath of envPaths) {
+      const value = readEnvValueFromFile(envPath, key);
+      if (value != null && String(value).trim() !== "") {
+        envFileMatch = envPath;
+      }
+    }
+    if (envFileMatch) {
+      source = "env-file";
+      sourcePath = envFileMatch;
+    } else {
+      source = "process-env";
+    }
+  } else if (configData?.kanban?.backend != null) {
+    source = "config-file";
+    sourcePath = configFilePath || null;
+  }
+
+  return Object.freeze({
+    key,
+    rawValue:
+      process.env[key] || configData?.kanban?.backend || "internal",
+    source,
+    sourcePath,
+  });
+}
+
+function validateKanbanBackendConfig({ kanbanBackend, kanban, jira }) {
+  if (kanbanBackend !== "jira") return;
+  const missing = [];
+  if (!jira?.baseUrl) missing.push("JIRA_BASE_URL");
+  if (!jira?.email) missing.push("JIRA_EMAIL");
+  if (!jira?.apiToken) missing.push("JIRA_API_TOKEN");
+  const hasProjectKey = Boolean(jira?.projectKey || kanban?.projectId);
+  if (!hasProjectKey) {
+    missing.push("JIRA_PROJECT_KEY (or KANBAN_PROJECT_ID)");
+  }
+  if (missing.length > 0) {
+    throw new Error(
+      `[config] KANBAN_BACKEND=jira requires ${missing.join(", ")}. ` +
+        `Either configure Jira credentials/project key or switch KANBAN_BACKEND=internal.`,
+    );
+  }
+}
+
 function loadConfigFile(configDir) {
   for (const name of CONFIG_FILES) {
     const p = resolve(configDir, name);
@@ -268,6 +346,173 @@ function isEnvEnabled(value, defaultValue = false) {
   return parseEnvBoolean(value, defaultValue);
 }
 
+function parseListValue(value) {
+  if (Array.isArray(value)) {
+    return value
+      .map((item) => String(item || "").trim())
+      .filter(Boolean);
+  }
+  return String(value || "")
+    .split(/[,|]/)
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+function normalizeExecutorModels(executor, models) {
+  const normalizedExecutor = normalizeExecutorKey(executor);
+  if (!normalizedExecutor) return [];
+  const input = parseListValue(models);
+  const known = new Set(getModelsForExecutor(normalizedExecutor));
+  if (input.length === 0) {
+    return [...known];
+  }
+  return input.filter((model) => known.has(model));
+}
+
+function normalizeExecutorEntry(entry, index = 0, total = 1) {
+  if (!entry || typeof entry !== "object") return null;
+  const executorType = String(entry.executor || "").trim().toUpperCase();
+  if (!executorType) return null;
+  const variant = String(entry.variant || "DEFAULT").trim() || "DEFAULT";
+  const normalized = normalizeExecutorKey(executorType) || "codex";
+  const weight = Number(entry.weight);
+  const safeWeight = Number.isFinite(weight) ? weight : Math.floor(100 / Math.max(1, total));
+  const role =
+    String(entry.role || "").trim() ||
+    (index === 0 ? "primary" : index === 1 ? "backup" : `executor-${index + 1}`);
+  const name =
+    String(entry.name || "").trim() ||
+    `${normalized}-${String(variant || "default").toLowerCase()}`;
+  const models = normalizeExecutorModels(executorType, entry.models);
+
+  return {
+    name,
+    executor: executorType,
+    variant,
+    weight: safeWeight,
+    role,
+    enabled: entry.enabled !== false,
+    models,
+  };
+}
+
+function buildDefaultTriggerTemplates({
+  plannerMode,
+  plannerPerCapitaThreshold,
+  plannerIdleSlotThreshold,
+  plannerDedupHours,
+} = {}) {
+  return [
+    {
+      id: "task-planner",
+      name: "Task Planner",
+      description: "Create planning tasks when backlog/slot metrics indicate replenishment.",
+      enabled: false,
+      action: "task-planner",
+      trigger: {
+        anyOf: [
+          {
+            kind: "metric",
+            metric: "backlogPerCapita",
+            operator: "lt",
+            value: plannerPerCapitaThreshold,
+          },
+          {
+            kind: "metric",
+            metric: "idleSlots",
+            operator: "gte",
+            value: plannerIdleSlotThreshold,
+          },
+          {
+            kind: "metric",
+            metric: "backlogRemaining",
+            operator: "eq",
+            value: 0,
+          },
+        ],
+      },
+      minIntervalMinutes: Math.max(1, Number(plannerDedupHours || 6) * 60),
+      config: {
+        plannerMode,
+        defaultTaskCount: Number(process.env.TASK_PLANNER_DEFAULT_COUNT || "30"),
+        executor: "auto",
+        model: "auto",
+      },
+    },
+    {
+      id: "daily-review-digest",
+      name: "Daily Review Digest",
+      description: "Create a daily review task for fleet health and backlog quality.",
+      enabled: false,
+      action: "create-task",
+      trigger: {
+        anyOf: [
+          {
+            kind: "interval",
+            minutes: 24 * 60,
+          },
+        ],
+      },
+      minIntervalMinutes: 24 * 60,
+      config: {
+        title: "[m] Daily review digest",
+        description:
+          "Review active backlog, blocked tasks, and stale work. Capture next actions and priority adjustments.",
+        priority: "medium",
+        executor: "auto",
+        model: "auto",
+      },
+    },
+    {
+      id: "stale-task-followup",
+      name: "Stale Task Follow-up",
+      description: "Create a follow-up task when stale in-progress work accumulates.",
+      enabled: false,
+      action: "create-task",
+      trigger: {
+        anyOf: [
+          {
+            kind: "metric",
+            metric: "staleInProgressCount",
+            operator: "gte",
+            value: 1,
+          },
+        ],
+      },
+      minIntervalMinutes: 60,
+      config: {
+        title: "[m] Follow up stale in-progress tasks",
+        description:
+          "Audit stale in-progress tasks, unblock owners, or split work to recover flow.",
+        priority: "high",
+        staleHours: Number(process.env.STALE_TASK_AGE_HOURS || "24"),
+        executor: "auto",
+        model: "auto",
+      },
+    },
+  ];
+}
+
+function resolveTriggerSystemConfig(configData, defaults) {
+  const configTrigger =
+    configData && typeof configData.triggerSystem === "object"
+      ? configData.triggerSystem
+      : configData && typeof configData.triggers === "object"
+        ? configData.triggers
+        : {};
+  const templates = Array.isArray(configTrigger.templates)
+    ? configTrigger.templates
+    : defaults.templates;
+  return Object.freeze({
+    enabled: isEnvEnabled(
+      process.env.TASK_TRIGGER_SYSTEM_ENABLED ?? configTrigger.enabled,
+      false,
+    ),
+    templates,
+    defaults: defaults.defaults,
+  });
+}
+
 // ── Git helpers ──────────────────────────────────────────────────────────────
 
 function detectRepoSlug(repoRoot = "") {
@@ -421,7 +666,7 @@ const DEFAULT_EXECUTORS = {
 };
 
 function parseExecutorsFromEnv() {
-  // EXECUTORS=CODEX:DEFAULT:100
+  // EXECUTORS=CODEX:DEFAULT:100:gpt-5.2-codex|gpt-5.1-codex-mini
   const raw = process.env.EXECUTORS;
   if (!raw) return null;
   const entries = raw.split(",").map((e) => e.trim());
@@ -430,13 +675,16 @@ function parseExecutorsFromEnv() {
   for (let i = 0; i < entries.length; i++) {
     const parts = entries[i].split(":");
     if (parts.length < 2) continue;
+    const executorType = parts[0].toUpperCase();
+    const models = normalizeExecutorModels(executorType, parts[3] || "");
     executors.push({
       name: `${parts[0].toLowerCase()}-${parts[1].toLowerCase()}`,
-      executor: parts[0].toUpperCase(),
+      executor: executorType,
       variant: parts[1],
       weight: parts[2] ? Number(parts[2]) : Math.floor(100 / entries.length),
       role: roles[i] || `executor-${i + 1}`,
       enabled: true,
+      models,
     });
   }
   return executors.length ? executors : null;
@@ -522,8 +770,11 @@ function loadExecutorConfig(configDir, configData) {
     }
   }
 
-  const executors =
+  const baseExecutors =
     fromEnv || fromFile?.executors || DEFAULT_EXECUTORS.executors;
+  const executors = (Array.isArray(baseExecutors) ? baseExecutors : [])
+    .map((entry, index, arr) => normalizeExecutorEntry(entry, index, arr.length))
+    .filter(Boolean);
   const failover = fromFile?.failover || {
     strategy:
       process.env.FAILOVER_STRATEGY || DEFAULT_EXECUTORS.failover.strategy,
@@ -970,6 +1221,11 @@ export function loadConfig(argv = process.argv, options = {}) {
     resolve(configDir, ".env"),
     resolve(repoRoot, ".env"),
   ].filter((p, i, arr) => arr.indexOf(p) === i);
+  const kanbanSource = resolveKanbanBackendSource({
+    envPaths,
+    configFilePath: configFile.path,
+    configData,
+  });
 
   // ── Project identity ─────────────────────────────────────
   const projectName =
@@ -1284,6 +1540,7 @@ export function loadConfig(argv = process.argv, options = {}) {
         "",
     }),
   });
+  validateKanbanBackendConfig({ kanbanBackend, kanban, jira });
 
   const internalExecutorConfig = configData.internalExecutor || {};
   const projectRequirements = {
@@ -1483,6 +1740,23 @@ export function loadConfig(argv = process.argv, options = {}) {
     ? plannerDedupHours * 60 * 60 * 1000
     : 24 * 60 * 60 * 1000;
 
+  const triggerSystemDefaults = Object.freeze({
+    templates: buildDefaultTriggerTemplates({
+      plannerMode,
+      plannerPerCapitaThreshold,
+      plannerIdleSlotThreshold,
+      plannerDedupHours,
+    }),
+    defaults: Object.freeze({
+      executor: "auto",
+      model: "auto",
+    }),
+  });
+  const triggerSystem = resolveTriggerSystemConfig(
+    configData,
+    triggerSystemDefaults,
+  );
+
   // ── GitHub Reconciler ───────────────────────────────────
   const ghReconcileEnabled = isEnvEnabled(
     process.env.GH_RECONCILE_ENABLED ?? configData.ghReconcileEnabled,
@@ -1706,6 +1980,7 @@ export function loadConfig(argv = process.argv, options = {}) {
     internalExecutor,
     executorMode: internalExecutor.mode,
     kanban,
+    kanbanSource,
     githubProjectSync,
     jira,
     projectRequirements,
@@ -1749,6 +2024,7 @@ export function loadConfig(argv = process.argv, options = {}) {
     plannerIdleSlotThreshold,
     plannerDedupHours,
     plannerDedupMs,
+    triggerSystem,
 
     // GitHub Reconciler
     githubReconcile: {

package/container-runner.mjs

@@ -31,6 +31,10 @@ const containerTimeout = parseInt(
   process.env.CONTAINER_TIMEOUT_MS || "1800000",
   10,
 ); // 30 min default
+const containerRuntimeCheckTimeout = Math.max(
+  500,
+  parseInt(process.env.CONTAINER_RUNTIME_CHECK_TIMEOUT_MS || "3000", 10),
+);
 const containerMaxOutput = parseInt(
   process.env.CONTAINER_MAX_OUTPUT_SIZE || "10485760",
   10,
@@ -84,11 +88,17 @@ export function checkContainerRuntime() {
   try {
     if (containerRuntime === "container") {
       // macOS Apple Container
-      execSync("container system status", { stdio: "pipe" });
+      execSync("container system status", {
+        stdio: "pipe",
+        timeout: containerRuntimeCheckTimeout,
+      });
       return { available: true, runtime: "container", platform: "macos" };
     }
     // Docker or Podman
-    execSync(`${containerRuntime} info`, { stdio: "pipe", timeout: 10000 });
+    execSync(`${containerRuntime} info`, {
+      stdio: "pipe",
+      timeout: containerRuntimeCheckTimeout,
+    });
     return {
       available: true,
       runtime: containerRuntime,
@@ -110,7 +120,10 @@ export function ensureContainerRuntime() {
   if (containerRuntime === "container") {
     // macOS Apple Container — may need explicit start
     try {
-      execSync("container system status", { stdio: "pipe" });
+      execSync("container system status", {
+        stdio: "pipe",
+        timeout: containerRuntimeCheckTimeout,
+      });
     } catch {
       console.log("[container] Starting Apple Container system...");
       try {