bosun 0.34.6 → 0.34.7

package/agent-hook-bridge.mjs

@@ -2,6 +2,7 @@
 
 import { readFileSync } from "node:fs";
 import { executeBlockingHooks, executeHooks, loadHooks, registerBuiltinHooks } from "./agent-hooks.mjs";
+import { shouldRunAgentHookBridge } from "./task-context.mjs";
 
 const TAG = "[agent-hook-bridge]";
 
@@ -161,12 +162,11 @@ function mapEvents(sourceEvent, payload) {
 }
 
 async function run() {
-  // ── VE_MANAGED guard ──────────────────────────────────────────────────────
-  // Only execute hooks for sessions managed by bosun.
-  // bosun sets VE_MANAGED=1 in all spawned agent environments.
-  // If this env var is missing, we're running inside a standalone agent session
-  // that just happens to have the hook files in its config — exit silently.
-  if (!process.env.VE_MANAGED && !process.env.BOSUN_HOOKS_FORCE) {
+  // ── task-context guard ────────────────────────────────────────────────────
+  // Execute hooks only for active Bosun task sessions.
+  // This prevents globally scaffolded hook configs from affecting standalone
+  // sessions in user repos. BOSUN_HOOKS_FORCE remains an explicit override.
+  if (!shouldRunAgentHookBridge(process.env)) {
     process.exit(0);
   }
 

package/agent-pool.mjs

@@ -45,6 +45,16 @@ import { loadConfig } from "./config.mjs";
 import { resolveRepoRoot, resolveAgentRepoRoot } from "./repo-root.mjs";
 import { resolveCodexProfileRuntime } from "./codex-model-profiles.mjs";
 
+// Lazy-load MCP registry to avoid circular dependencies.
+// Cached at module scope per AGENTS.md hard rules.
+let _mcpRegistry = null;
+async function getMcpRegistry() {
+  if (!_mcpRegistry) {
+    _mcpRegistry = await import("./mcp-registry.mjs");
+  }
+  return _mcpRegistry;
+}
+
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
@@ -897,7 +907,7 @@ async function launchCodexThread(prompt, cwd, timeoutMs, extra = {}) {
  * Build CLI arguments for ephemeral Copilot agent-pool sessions.
  * Mirrors copilot-shell.mjs buildCliArgs() for feature parity.
  */
-function buildPoolCopilotCliArgs() {
+function buildPoolCopilotCliArgs(mcpConfigPath) {
   const args = [];
   if (!envFlagEnabled(process.env.COPILOT_NO_EXPERIMENTAL)) {
     args.push("--experimental");
@@ -915,9 +925,10 @@ function buildPoolCopilotCliArgs() {
   if (envFlagEnabled(process.env.COPILOT_DISABLE_BUILTIN_MCPS)) {
     args.push("--disable-builtin-mcps");
   }
-  const mcpConfigPath = process.env.COPILOT_ADDITIONAL_MCP_CONFIG;
-  if (mcpConfigPath) {
-    args.push("--additional-mcp-config", mcpConfigPath);
+  // MCP config: prefer per-launch resolved config, fall back to env var
+  const effectiveMcpConfig = mcpConfigPath || process.env.COPILOT_ADDITIONAL_MCP_CONFIG;
+  if (effectiveMcpConfig) {
+    args.push("--additional-mcp-config", effectiveMcpConfig);
   }
   return args;
 }
@@ -1024,7 +1035,17 @@ async function launchCopilotThread(prompt, cwd, timeoutMs, extra = {}) {
         clientOpts = { cliUrl, env: clientEnv };
       } else {
         // Local mode (default): stdio for full capability
-        const cliArgs = buildPoolCopilotCliArgs();
+        // Write temp MCP config if resolved MCP servers are available
+        let mcpConfigPath = null;
+        if (extra._resolvedMcpServers?.length) {
+          try {
+            const registry = await getMcpRegistry();
+            mcpConfigPath = registry.writeTempCopilotMcpConfig(cwd, extra._resolvedMcpServers);
+          } catch (mcpErr) {
+            console.warn(`${TAG} copilot MCP config write failed (non-fatal): ${mcpErr.message}`);
+          }
+        }
+        const cliArgs = buildPoolCopilotCliArgs(mcpConfigPath);
         clientOpts = {
           cwd,
           env: clientEnv,
@@ -1465,6 +1486,27 @@ async function launchClaudeThread(prompt, cwd, timeoutMs, extra = {}) {
   }
 
   // ── 4. Execute query ─────────────────────────────────────────────────────
+  // Inject MCP server config for Claude via environment variable
+  let _claudeMcpEnvCleanup = null;
+  if (extra._resolvedMcpServers?.length) {
+    try {
+      const registry = await getMcpRegistry();
+      const { envVar } = registry.buildClaudeMcpEnv(extra._resolvedMcpServers);
+      if (envVar) {
+        const prev = process.env.CLAUDE_MCP_SERVERS;
+        process.env.CLAUDE_MCP_SERVERS = envVar;
+        _claudeMcpEnvCleanup = () => {
+          if (prev === undefined) {
+            delete process.env.CLAUDE_MCP_SERVERS;
+          } else {
+            process.env.CLAUDE_MCP_SERVERS = prev;
+          }
+        };
+      }
+    } catch (mcpErr) {
+      console.warn(`${TAG} claude MCP env setup failed (non-fatal): ${mcpErr.message}`);
+    }
+  }
   try {
     const msgQueue = createMessageQueue();
 
@@ -1596,6 +1638,7 @@ async function launchClaudeThread(prompt, cwd, timeoutMs, extra = {}) {
 
     const output =
       finalResponse.trim() || "(Agent completed with no text output)";
+    if (typeof _claudeMcpEnvCleanup === "function") _claudeMcpEnvCleanup();
     return {
       success: true,
       output,
@@ -1605,6 +1648,7 @@ async function launchClaudeThread(prompt, cwd, timeoutMs, extra = {}) {
       threadId: activeClaudeSessionId,
     };
   } catch (err) {
+    if (typeof _claudeMcpEnvCleanup === "function") _claudeMcpEnvCleanup();
     clearAbortScope();
     if (hardTimer) clearTimeout(hardTimer);
     if (steerKey) unregisterActiveSession(steerKey);
@@ -1714,6 +1758,32 @@ export async function launchEphemeralThread(
   timeoutMs = DEFAULT_TIMEOUT_MS,
   extra = {},
 ) {
+  // ── Resolve MCP servers for this launch ──────────────────────────────────
+  try {
+    if (!extra._mcpResolved) {
+      const cfg = loadConfig();
+      const mcpCfg = cfg.mcpServers || {};
+      if (mcpCfg.enabled !== false) {
+        const requestedIds = extra.mcpServers || [];
+        const defaultIds = mcpCfg.defaultServers || [];
+        if (requestedIds.length || defaultIds.length) {
+          const registry = await getMcpRegistry();
+          const resolved = await registry.resolveMcpServersForAgent(
+            cwd,
+            requestedIds,
+            { defaultServers: defaultIds, catalogOverrides: mcpCfg.catalogOverrides || {} },
+          );
+          if (resolved.length) {
+            extra._resolvedMcpServers = resolved;
+          }
+        }
+      }
+      extra._mcpResolved = true;
+    }
+  } catch (mcpErr) {
+    console.warn(`${TAG} MCP server resolution failed (non-fatal): ${mcpErr.message}`);
+  }
+
   // Determine the primary SDK to try
   const requestedSdk = extra.sdk
     ? String(extra.sdk).trim().toLowerCase()

package/bosun.schema.json

@@ -606,6 +606,37 @@
       "type": "object",
       "description": "Hook definitions loaded by agent-hooks.mjs (event -> hook list).",
       "additionalProperties": true
+    },
+    "mcpServers": {
+      "type": "object",
+      "description": "MCP (Model Context Protocol) server management. Controls which MCP servers are available to agents.",
+      "additionalProperties": false,
+      "properties": {
+        "enabled": {
+          "type": "boolean",
+          "default": true,
+          "description": "Enable MCP server integration for agent launches"
+        },
+        "defaultServers": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "MCP server IDs attached to every agent launch by default (e.g. [\"context7\", \"microsoft-docs\"])"
+        },
+        "catalogOverrides": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "object",
+            "description": "Per-server environment variable overrides",
+            "additionalProperties": { "type": "string" }
+          },
+          "description": "Environment variable overrides keyed by MCP server ID"
+        },
+        "autoInstallDefaults": {
+          "type": "boolean",
+          "default": true,
+          "description": "Automatically install defaultServers from catalog if not already installed"
+        }
+      }
     }
   }
 }

package/cli.mjs

@@ -1484,14 +1484,21 @@ function detectExistingMonitorLockOwner(excludePid = null) {
   return null;
 }
 
-function runMonitor() {
+function runMonitor({ restartReason = "" } = {}) {
   return new Promise((resolve, reject) => {
     const monitorPath = fileURLToPath(
       new URL("./monitor.mjs", import.meta.url),
     );
+    const childEnv = { ...process.env };
+    if (restartReason) {
+      childEnv.BOSUN_MONITOR_RESTART_REASON = restartReason;
+    } else {
+      delete childEnv.BOSUN_MONITOR_RESTART_REASON;
+    }
     monitorChild = fork(monitorPath, process.argv.slice(2), {
       stdio: "inherit",
       execArgv: ["--max-old-space-size=4096"],
+      env: childEnv,
       windowsHide: IS_DAEMON_CHILD && process.platform === "win32",
     });
     daemonCrashTracker.markStart();
@@ -1504,7 +1511,7 @@ function runMonitor() {
           "\n  \u21BB Monitor restarting with fresh modules...\n",
         );
         // Small delay to let file writes / port releases settle
-        setTimeout(() => resolve(runMonitor()), 2000);
+        setTimeout(() => resolve(runMonitor({ restartReason: "self-restart" })), 2000);
       } else {
         const exitCode = code ?? (signal ? 1 : 0);
         const existingOwner =
@@ -1572,7 +1579,15 @@ function runMonitor() {
             restartAttempt: daemonRestartCount,
             maxRestarts: IS_DAEMON_CHILD ? DAEMON_MAX_RESTARTS : 0,
           }).catch(() => {});
-          setTimeout(() => resolve(runMonitor()), delayMs);
+          setTimeout(
+            () =>
+              resolve(
+                runMonitor({
+                  restartReason: isOSKill ? "os-kill" : "crash",
+                }),
+              ),
+            delayMs,
+          );
           return;
         }
 

package/codex-config.mjs

@@ -2,12 +2,15 @@
  * codex-config.mjs — Manages the Codex CLI config (~/.codex/config.toml)
  *
  * Ensures the user's Codex CLI configuration has:
- *   1. A vibe_kanban MCP server section with the correct env vars
- *   2. Sufficient stream_idle_timeout_ms on all model providers
- *   3. Recommended defaults for long-running agentic workloads
- *   4. Feature flags for sub-agents, memory, undo, collaboration
- *   5. Sandbox permissions and shell environment policy
- *   6. Common MCP servers (context7, microsoft-docs)
+ *   1. Sufficient stream_idle_timeout_ms on all model providers
+ *   2. Recommended defaults for long-running agentic workloads
+ *   3. Feature flags for sub-agents, memory, undo, collaboration
+ *   4. Sandbox permissions and shell environment policy
+ *   5. Common MCP servers (context7, microsoft-docs)
+ *
+ * NOTE: Vibe-Kanban MCP is workspace-scoped and managed by repo-config.mjs
+ * inside each repo's `.codex/config.toml`. Global config no longer auto-adds
+ * `[mcp_servers.vibe_kanban]`.
  *
  * SCOPE: This manages the GLOBAL ~/.codex/config.toml which contains:
  *   - Model provider configs (API keys, base URLs) — MUST be global
@@ -1305,13 +1308,15 @@ export function ensureRetrySettings(toml, providerName) {
  * @param {object} opts
  * @param {string}  [opts.vkBaseUrl]
  * @param {boolean} [opts.skipVk]
+ * @param {boolean} [opts.manageVkMcp]  Explicit opt-in to manage VK MCP in global config
  * @param {boolean} [opts.dryRun]  If true, returns result without writing
  * @param {object}  [opts.env]     Environment overrides (defaults to process.env)
  * @param {string}  [opts.primarySdk]  Primary agent SDK: "codex", "copilot", or "claude"
  */
 export function ensureCodexConfig({
   vkBaseUrl = "http://127.0.0.1:54089",
-  skipVk = false,
+  skipVk = true,
+  manageVkMcp = false,
   dryRun = false,
   env = process.env,
   primarySdk,
@@ -1424,7 +1429,8 @@ export function ensureCodexConfig({
   result.featuresAdded = featureResult.added;
   toml = featureResult.toml;
 
-  if (skipVk) {
+  const shouldManageGlobalVkMcp = Boolean(manageVkMcp) && !skipVk;
+  if (!shouldManageGlobalVkMcp) {
     if (hasVibeKanbanMcp(toml)) {
       toml = removeVibeKanbanMcp(toml);
       result.vkRemoved = true;
@@ -1564,7 +1570,7 @@ export function printConfigSummary(result, log = console.log) {
   }
 
   if (result.vkRemoved) {
-    log("  🗑️  Removed Vibe-Kanban MCP server (VK backend not active)");
+    log("  🗑️  Removed Vibe-Kanban MCP server from global config (workspace-scoped only)");
   }
 
   if (result.vkEnvUpdated) {

package/copilot-shell.mjs

@@ -17,6 +17,15 @@ import { getGitHubToken } from "./github-auth-manager.mjs";
 
 const __dirname = resolve(fileURLToPath(new URL(".", import.meta.url)));
 
+// Lazy-import MCP registry — cached at module scope per AGENTS.md rules.
+let _mcpRegistry = null;
+async function getMcpRegistry() {
+  if (!_mcpRegistry) {
+    _mcpRegistry = await import("./mcp-registry.mjs");
+  }
+  return _mcpRegistry;
+}
+
 // ── Configuration ────────────────────────────────────────────────────────────
 
 const DEFAULT_TIMEOUT_MS = 60 * 60 * 1000; // 60 min for agentic tasks
@@ -174,7 +183,7 @@ function logSessionEvent(logPath, event) {
  * Enables experimental features (fleet, autopilot), auto-permissions,
  * sub-agents, and autonomy.
  */
-function buildCliArgs() {
+async function buildCliArgs() {
   const args = [];
 
   // Always enable experimental features (fleet, autopilot, persisted permissions, etc.)
@@ -218,6 +227,26 @@ function buildCliArgs() {
     args.push("--additional-mcp-config", mcpConfigPath);
   }
 
+  // Also write a temp MCP config from the library if installed servers exist
+  // (non-fatal: library MCP is a convenience, not a hard requirement)
+  if (!mcpConfigPath) {
+    try {
+      const registry = await getMcpRegistry();
+      const installed = await registry.listInstalledMcpServers(REPO_ROOT);
+      if (installed && installed.length) {
+        const ids = installed.map((e) => e.id);
+        const resolved = await registry.resolveMcpServersForAgent(REPO_ROOT, ids);
+        if (resolved && resolved.length) {
+          const tmpPath = registry.writeTempCopilotMcpConfig(REPO_ROOT, resolved);
+          args.push("--additional-mcp-config", tmpPath);
+          console.log(`[copilot-shell] injected ${resolved.length} library MCP server(s) via CLI args`);
+        }
+      }
+    } catch (err) {
+      console.warn(`[copilot-shell] failed to inject library MCP servers into CLI args: ${err.message}`);
+    }
+  }
+
   if (args.length > 0) {
     console.log(`[copilot-shell] cliArgs: ${args.join(" ")}`);
   }
@@ -399,7 +428,7 @@ async function ensureClientStarted() {
   const sessionMode = (process.env.COPILOT_SESSION_MODE || "local").trim().toLowerCase();
 
   // Build cliArgs for experimental features, permissions, and autonomy
-  const cliArgs = buildCliArgs();
+  const cliArgs = await buildCliArgs();
 
   let clientOptions;
   if (transport === "url") {
@@ -553,7 +582,46 @@ function loadMcpServers(profile = null) {
   return loadMcpServersFromFile(configPath);
 }
 
-function buildSessionConfig() {
+/**
+ * Merge installed MCP library servers into an existing mcpServers map.
+ * Called during session build to inject library-managed MCP servers into
+ * the Copilot SDK session alongside any profile/env servers.
+ *
+ * Non-fatal: if the registry is unavailable or encounters errors, the
+ * original servers map is returned unchanged.
+ *
+ * @param {Object|null} existingServers — mcpServers from profile/env/config
+ * @returns {Promise<Object|null>} — merged servers map
+ */
+async function mergeLibraryMcpServers(existingServers) {
+  try {
+    const registry = await getMcpRegistry();
+    const installed = await registry.listInstalledMcpServers(REPO_ROOT);
+    if (!installed || !installed.length) return existingServers;
+
+    // Resolve all installed servers into full configs
+    const installedIds = installed.map((e) => e.id);
+    const resolved = await registry.resolveMcpServersForAgent(REPO_ROOT, installedIds);
+    if (!resolved || !resolved.length) return existingServers;
+
+    // Convert to Copilot mcpServers format: { [id]: { command, args, env? } | { url } }
+    const copilotJson = registry.buildCopilotMcpJson(resolved);
+    const libraryServers = copilotJson?.mcpServers || {};
+    if (!Object.keys(libraryServers).length) return existingServers;
+
+    // Merge: existing servers take precedence over library ones (user overrides win)
+    const merged = { ...libraryServers, ...(existingServers || {}) };
+    console.log(
+      `[copilot-shell] Merged ${Object.keys(libraryServers).length} library MCP server(s) into session`,
+    );
+    return merged;
+  } catch (err) {
+    console.warn(`[copilot-shell] Failed to merge library MCP servers: ${err.message}`);
+    return existingServers;
+  }
+}
+
+async function buildSessionConfig() {
   const profile = resolveCopilotProfile();
   const config = {
     streaming: true,
@@ -588,7 +656,9 @@ function buildSessionConfig() {
     config.reasoningEffort = effort.toLowerCase();
   }
 
-  const mcpServers = loadMcpServers(profile);
+  // Load MCP servers from profile/env/config, then merge library-managed servers
+  const baseServers = loadMcpServers(profile);
+  const mcpServers = await mergeLibraryMcpServers(baseServers);
   if (mcpServers) config.mcpServers = mcpServers;
   return config;
 }
@@ -600,7 +670,7 @@ async function getSession() {
   const started = await ensureClientStarted();
   if (!started) throw new Error("Copilot SDK not available");
 
-  const config = buildSessionConfig();
+  const config = await buildSessionConfig();
 
   if (activeSessionId && typeof copilotClient?.resumeSession === "function") {
     try {

package/desktop/main.mjs

@@ -256,6 +256,9 @@ async function startUiServer() {
   if (uiServerStarted) return;
   const api = await loadUiServerModule();
   const server = await api.startTelegramUiServer({
+    host: "127.0.0.1",
+    publicHost: "127.0.0.1",
+    skipAutoOpen: true,
     dependencies: {
       configDir: resolveDesktopConfigDir(),
     },

package/git-commit-helpers.mjs

@@ -9,6 +9,8 @@
  * GitHub appearance: https://github.com/apps/bosun-ve
  */
 
+import { shouldAddBosunCoAuthor as shouldAddBosunCoAuthorByContext } from "./task-context.mjs";
+
 const BOSUN_BOT_TRAILER =
   "Co-authored-by: bosun-ve[bot] <262908237+bosun-ve[bot]@users.noreply.github.com>";
 
@@ -38,17 +40,25 @@ export function appendBosunCoAuthor(message) {
  * @param {string} title - commit title (first line / summary)
  * @param {string} [body] - commit body (optional extended description)
  * @param {Object} [opts]
- * @param {boolean} [opts.addBosunCredit=true] - whether to append the co-author trailer
+ * @param {boolean} [opts.addBosunCredit] - whether to append the co-author trailer
+ * @param {string} [opts.taskId] - optional task ID for task-scoped attribution mode
+ * @param {NodeJS.ProcessEnv} [opts.env] - optional environment override
  * @returns {string} full commit message
  */
-export function buildCommitMessage(title, body = "", { addBosunCredit = true } = {}) {
+export function buildCommitMessage(title, body = "", opts = {}) {
+  const { addBosunCredit, taskId, env } = opts;
   const parts = [title.trimEnd()];
   if (body && body.trim()) {
     parts.push(""); // blank line
     parts.push(body.trimEnd());
   }
   const base = parts.join("\n");
-  return addBosunCredit ? appendBosunCoAuthor(base) : base;
+
+  const withBosunCredit =
+    typeof addBosunCredit === "boolean"
+      ? addBosunCredit
+      : shouldAddBosunCoAuthor({ taskId, env });
+  return withBosunCredit ? appendBosunCoAuthor(base) : base;
 }
 
 // ── PR body helpers ───────────────────────────────────────────────────────────
@@ -81,3 +91,21 @@ export function getBosunCoAuthorTrailer() {
 export function getBosunPrCredit() {
   return BOSUN_PR_CREDIT;
 }
+
+/**
+ * Returns whether Bosun co-author credit should be applied for the current
+ * execution context.
+ *
+ * Defaults to task-scoped behavior and supports opt-in overrides via:
+ * - BOSUN_COAUTHOR_MODE=always
+ * - BOSUN_COAUTHOR_MODE=off
+ *
+ * @param {object} [options]
+ * @param {NodeJS.ProcessEnv} [options.env]
+ * @param {string} [options.taskId]
+ * @param {"task"|"always"|"off"} [options.mode]
+ * @returns {boolean}
+ */
+export function shouldAddBosunCoAuthor(options = {}) {
+  return shouldAddBosunCoAuthorByContext(options);
+}

package/library-manager.mjs

@@ -26,9 +26,10 @@ export const LIBRARY_MANIFEST = "library.json";
 export const PROMPT_DIR = ".bosun/agents";
 export const SKILL_DIR = ".bosun/skills";
 export const PROFILE_DIR = ".bosun/profiles";
+export const MCP_DIR = ".bosun/mcp-servers";
 
 /** Resource types managed by the library */
-export const RESOURCE_TYPES = Object.freeze(["prompt", "agent", "skill"]);
+export const RESOURCE_TYPES = Object.freeze(["prompt", "agent", "skill", "mcp"]);
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
@@ -140,12 +141,13 @@ function dirForType(rootDir, type) {
     case "prompt": return resolve(root, PROMPT_DIR);
     case "skill":  return resolve(root, SKILL_DIR);
     case "agent":  return resolve(root, PROFILE_DIR);
+    case "mcp":    return resolve(root, MCP_DIR);
     default: throw new Error(`Unknown library resource type: ${type}`);
   }
 }
 
 function extForType(type) {
-  return type === "agent" ? ".json" : ".md";
+  return (type === "agent" || type === "mcp") ? ".json" : ".md";
 }
 
 /**
@@ -439,9 +441,9 @@ export function detectScopes(repoRoot, opts = {}) {
 export function resolveLibraryRefs(template, rootDir, extraVars = {}) {
   if (typeof template !== "string") return "";
 
-  // First resolve namespaced refs: {{prompt:name}}, {{agent:name}}, {{skill:name}}
+  // First resolve namespaced refs: {{prompt:name}}, {{agent:name}}, {{skill:name}}, {{mcp:name}}
   let resolved = template.replace(
-    /\{\{\s*(prompt|agent|skill):([A-Za-z0-9_-]+)\s*\}\}/gi,
+    /\{\{\s*(prompt|agent|skill|mcp):([A-Za-z0-9_-]+)\s*\}\}/gi,
     (_full, type, name) => {
       const typeLower = type.toLowerCase();
       const id = slugify(name);

package/monitor.mjs

@@ -98,7 +98,10 @@ import {
   resetMergeStrategyDedup,
 } from "./merge-strategy.mjs";
 import { assessTask, quickAssess } from "./task-assessment.mjs";
-import { getBosunCoAuthorTrailer } from "./git-commit-helpers.mjs";
+import {
+  getBosunCoAuthorTrailer,
+  shouldAddBosunCoAuthor,
+} from "./git-commit-helpers.mjs";
 import {
   normalizeDedupKey,
   stripAnsi,
@@ -1611,6 +1614,21 @@ try {
 let telegramNotifierInterval = null;
 let telegramNotifierTimeout = null;
 let weeklyReportLastSentAt = null;
+const monitorRestartReason = String(
+  process.env.BOSUN_MONITOR_RESTART_REASON || "",
+)
+  .trim()
+  .toLowerCase();
+
+function getTelegramBotStartOptions() {
+  const restartReason = isSelfRestart
+    ? "self-restart"
+    : monitorRestartReason;
+  return {
+    restartReason,
+    suppressPortalAutoOpen: restartReason.length > 0,
+  };
+}
 let vkRecoveryLastAt = 0;
 let vkNonJsonNotifiedAt = 0;
 let vkNonJsonContentTypeLoggedAt = 0;
@@ -7259,15 +7277,15 @@ function extractPrNumberFromUrl(prUrl) {
 }
 
 function buildFlowGateMergeBody(taskTitle, taskId) {
-  const trailer = getBosunCoAuthorTrailer();
   const safeTitle = String(taskTitle || "Task").trim() || "Task";
   const safeId = String(taskId || "").trim();
   const lines = [
     `Merged by Bosun flow gate for: ${safeTitle}`,
     safeId ? `Task: ${safeId}` : "",
-    "",
-    trailer,
   ].filter(Boolean);
+  if (shouldAddBosunCoAuthor({ taskId: safeId })) {
+    lines.push("", getBosunCoAuthorTrailer());
+  }
   return lines.join("\n");
 }
 
@@ -13725,7 +13743,7 @@ function applyConfig(nextConfig, options = {}) {
   }
   if (prevTelegramBotEnabled !== telegramBotEnabled) {
     if (telegramBotEnabled) {
-      void startTelegramBot();
+      void startTelegramBot(getTelegramBotStartOptions());
     } else {
       stopTelegramBot();
     }
@@ -14139,17 +14157,16 @@ if (!isMonitorTestRuntime) {
     process.exit(0);
   }
 
-// ── Codex CLI config.toml: ensure VK MCP + stream timeouts ──────────────────
+// ── Codex CLI config.toml: ensure global defaults + stream timeouts ─────────
 try {
   const vkPort = config.vkRecoveryPort || "54089";
   const vkBaseUrl = config.vkEndpointUrl || `http://127.0.0.1:${vkPort}`;
-  const skipVk = !isVkRuntimeRequired();
   const allowRuntimeCodexMutation = isTruthyFlag(
     process.env.BOSUN_ALLOW_RUNTIME_GLOBAL_CODEX_MUTATION,
   );
   const tomlResult = ensureCodexConfig({
     vkBaseUrl,
-    skipVk,
+    skipVk: true,
     dryRun: !allowRuntimeCodexMutation,
   });
   if (!tomlResult.noChanges) {
@@ -15189,7 +15206,7 @@ injectMonitorFunctions({
   },
 });
 if (telegramBotEnabled) {
-  void startTelegramBot();
+  void startTelegramBot(getTelegramBotStartOptions());
 
   // Process any commands queued by telegram-sentinel while monitor was down
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bosun",
-  "version": "0.34.6",
+  "version": "0.34.7",
   "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",
@@ -185,6 +185,7 @@
     "task-assessment.mjs",
     "task-complexity.mjs",
     "task-claims.mjs",
+    "task-context.mjs",
     "task-attachments.mjs",
     "task-executor.mjs",
     "task-store.mjs",