bosun 0.37.0 → 0.37.2

package/.env.example

@@ -21,7 +21,6 @@ SHARED_STATE_STALE_THRESHOLD_MS=300000
 # Maximum retry attempts before permanently ignoring a task (default: 3)
 SHARED_STATE_MAX_RETRIES=3
 # Task claim owner staleness threshold in milliseconds (default: 600000 = 10 minutes)
-# Used by task-claims.mjs to detect stale local claims
 TASK_CLAIM_OWNER_STALE_TTL_MS=600000
 
 # ─── Project Identity ─────────────────────────────────────────────────────────
@@ -178,6 +177,10 @@ VOICE_VISION_MODEL=gpt-4.1-mini
 # Gemini provider mode (Tier 2 voice fallback + Gemini vision)
 # GEMINI_API_KEY=
 # GOOGLE_API_KEY=
+# Transcription model used for audio-to-text (default: gpt-4o-transcribe)
+# VOICE_TRANSCRIPTION_MODEL=gpt-4o-mini-transcribe
+# Enable/disable input audio transcription in realtime sessions (default: true)
+# VOICE_TRANSCRIPTION_ENABLED=true
 # Voice output persona
 VOICE_ID=alloy
 # server_vad | semantic_vad | none

package/agent-tool-config.mjs

@@ -0,0 +1,338 @@
+/**
+ * agent-tool-config.mjs — Per-Agent Tool Configuration Store
+ *
+ * Manages which tools and MCP servers are enabled for each agent profile.
+ * Persisted as `.bosun/agent-tools.json` alongside the library manifest.
+ *
+ * Schema:
+ *   {
+ *     "agents": {
+ *       "<agentId>": {
+ *         "enabledTools": ["tool1", "tool2"] | null,   // null = all tools
+ *         "enabledMcpServers": ["github", "context7"],  // enabled MCP server IDs
+ *         "disabledBuiltinTools": ["tool3"],             // explicitly disabled builtins
+ *         "updatedAt": "2026-01-01T00:00:00.000Z"
+ *       }
+ *     },
+ *     "defaults": {
+ *       "builtinTools": [...],          // default tool list for all agents
+ *       "updatedAt": "..."
+ *     }
+ *   }
+ *
+ * EXPORTS:
+ *   DEFAULT_BUILTIN_TOOLS         — list of default built-in tools for voice/agents
+ *   loadToolConfig(rootDir)       — load the full config
+ *   saveToolConfig(rootDir, cfg)  — save the full config
+ *   getAgentToolConfig(rootDir, agentId) — get config for one agent
+ *   setAgentToolConfig(rootDir, agentId, config) — update config for one agent
+ *   getEffectiveTools(rootDir, agentId)  — compute final enabled tools list
+ *   listAvailableTools(rootDir)   — list all available tools (builtin + MCP)
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+
+// ── Constants ─────────────────────────────────────────────────────────────────
+
+const TAG = "[agent-tool-config]";
+const CONFIG_FILE = "agent-tools.json";
+
+function getBosunHome() {
+  return (
+    process.env.BOSUN_HOME ||
+    process.env.BOSUN_DIR ||
+    resolve(homedir(), ".bosun")
+  );
+}
+
+/**
+ * Default built-in tools available to all voice agents and executors.
+ * Maps to common capabilities that voice/agent sessions can invoke.
+ */
+export const DEFAULT_BUILTIN_TOOLS = Object.freeze([
+  {
+    id: "search-files",
+    name: "Search Files",
+    description: "Search for files in the workspace by name or pattern",
+    category: "Built-In",
+    icon: ":search:",
+    default: true,
+  },
+  {
+    id: "read-file",
+    name: "Read File",
+    description: "Read contents of a file in the workspace",
+    category: "Built-In",
+    icon: ":file:",
+    default: true,
+  },
+  {
+    id: "edit-file",
+    name: "Edit File",
+    description: "Create or edit files in the workspace",
+    category: "Built-In",
+    icon: ":edit:",
+    default: true,
+  },
+  {
+    id: "run-command",
+    name: "Run Terminal Command",
+    description: "Execute shell commands in a terminal",
+    category: "Built-In",
+    icon: ":terminal:",
+    default: true,
+  },
+  {
+    id: "web-search",
+    name: "Web Search",
+    description: "Search the web for information",
+    category: "Built-In",
+    icon: ":globe:",
+    default: true,
+  },
+  {
+    id: "code-search",
+    name: "Semantic Code Search",
+    description: "Search codebase semantically for relevant code",
+    category: "Built-In",
+    icon: ":cpu:",
+    default: true,
+  },
+  {
+    id: "git-operations",
+    name: "Git Operations",
+    description: "Run git commands (commit, push, branch, etc.)",
+    category: "Built-In",
+    icon: ":git:",
+    default: true,
+  },
+  {
+    id: "create-task",
+    name: "Create Task",
+    description: "Create new tasks and issues",
+    category: "Built-In",
+    icon: ":check:",
+    default: true,
+  },
+  {
+    id: "delegate-task",
+    name: "Delegate to Agent",
+    description: "Delegate work to another agent executor",
+    category: "Built-In",
+    icon: ":bot:",
+    default: true,
+  },
+  {
+    id: "fetch-url",
+    name: "Fetch URL",
+    description: "Fetch content from a URL and convert for LLM usage",
+    category: "Built-In",
+    icon: ":link:",
+    default: true,
+  },
+  {
+    id: "list-directory",
+    name: "List Directory",
+    description: "List contents of a directory in the workspace",
+    category: "Built-In",
+    icon: ":folder:",
+    default: true,
+  },
+  {
+    id: "grep-search",
+    name: "Text Search (Grep)",
+    description: "Search for exact text or regex patterns in files",
+    category: "Built-In",
+    icon: ":search:",
+    default: true,
+  },
+  {
+    id: "task-management",
+    name: "Task Management",
+    description: "Track and manage todo items and task status",
+    category: "Built-In",
+    icon: ":clipboard:",
+    default: true,
+  },
+  {
+    id: "notifications",
+    name: "Send Notifications",
+    description: "Send notifications via Telegram, webhook, etc.",
+    category: "Built-In",
+    icon: ":bell:",
+    default: false,
+  },
+  {
+    id: "vision-analysis",
+    name: "Vision Analysis",
+    description: "Analyze images and screenshots",
+    category: "Built-In",
+    icon: ":eye:",
+    default: true,
+  },
+]);
+
+// ── Config File I/O ───────────────────────────────────────────────────────────
+
+function getConfigPath(rootDir) {
+  return resolve(rootDir || getBosunHome(), ".bosun", CONFIG_FILE);
+}
+
+/**
+ * Load the agent tool configuration.
+ * @param {string} [rootDir]
+ * @returns {{ agents: Object, defaults: Object }}
+ */
+export function loadToolConfig(rootDir) {
+  const configPath = getConfigPath(rootDir);
+  if (!existsSync(configPath)) {
+    return {
+      agents: {},
+      defaults: {
+        builtinTools: DEFAULT_BUILTIN_TOOLS.filter((t) => t.default).map((t) => t.id),
+        updatedAt: new Date().toISOString(),
+      },
+    };
+  }
+  try {
+    const raw = readFileSync(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return {
+      agents: parsed.agents || {},
+      defaults: parsed.defaults || {
+        builtinTools: DEFAULT_BUILTIN_TOOLS.filter((t) => t.default).map((t) => t.id),
+        updatedAt: new Date().toISOString(),
+      },
+    };
+  } catch {
+    return {
+      agents: {},
+      defaults: {
+        builtinTools: DEFAULT_BUILTIN_TOOLS.filter((t) => t.default).map((t) => t.id),
+        updatedAt: new Date().toISOString(),
+      },
+    };
+  }
+}
+
+/**
+ * Save the full tool configuration.
+ * @param {string} rootDir
+ * @param {{ agents: Object, defaults: Object }} config
+ */
+export function saveToolConfig(rootDir, config) {
+  const configPath = getConfigPath(rootDir);
+  const dir = resolve(configPath, "..");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf8");
+}
+
+/**
+ * Get tool configuration for a specific agent.
+ * @param {string} rootDir
+ * @param {string} agentId
+ * @returns {{ enabledTools: string[]|null, enabledMcpServers: string[], disabledBuiltinTools: string[] }}
+ */
+export function getAgentToolConfig(rootDir, agentId) {
+  const config = loadToolConfig(rootDir);
+  const agentConfig = config.agents[agentId];
+  if (!agentConfig) {
+    return {
+      enabledTools: null,
+      enabledMcpServers: [],
+      disabledBuiltinTools: [],
+    };
+  }
+  return {
+    enabledTools: agentConfig.enabledTools ?? null,
+    enabledMcpServers: agentConfig.enabledMcpServers || [],
+    disabledBuiltinTools: agentConfig.disabledBuiltinTools || [],
+  };
+}
+
+/**
+ * Update tool configuration for a specific agent.
+ * @param {string} rootDir
+ * @param {string} agentId
+ * @param {{ enabledTools?: string[]|null, enabledMcpServers?: string[], disabledBuiltinTools?: string[] }} update
+ * @returns {{ ok: boolean }}
+ */
+export function setAgentToolConfig(rootDir, agentId, update) {
+  const config = loadToolConfig(rootDir);
+  const existing = config.agents[agentId] || {};
+  config.agents[agentId] = {
+    ...existing,
+    enabledTools: update.enabledTools !== undefined ? update.enabledTools : (existing.enabledTools ?? null),
+    enabledMcpServers: update.enabledMcpServers !== undefined ? update.enabledMcpServers : (existing.enabledMcpServers || []),
+    disabledBuiltinTools: update.disabledBuiltinTools !== undefined ? update.disabledBuiltinTools : (existing.disabledBuiltinTools || []),
+    updatedAt: new Date().toISOString(),
+  };
+  saveToolConfig(rootDir, config);
+  return { ok: true };
+}
+
+/**
+ * Compute the effective enabled tools for an agent.
+ * Merges builtin defaults with agent-specific overrides and MCP servers.
+ *
+ * @param {string} rootDir
+ * @param {string} agentId
+ * @returns {{ builtinTools: Array<{ id: string, name: string, enabled: boolean }>, mcpServers: string[] }}
+ */
+export function getEffectiveTools(rootDir, agentId) {
+  const config = loadToolConfig(rootDir);
+  const agentConfig = config.agents[agentId] || {};
+  const disabledSet = new Set(agentConfig.disabledBuiltinTools || []);
+  const defaultIds = new Set(config.defaults?.builtinTools || DEFAULT_BUILTIN_TOOLS.filter((t) => t.default).map((t) => t.id));
+  const builtinIdSet = new Set(DEFAULT_BUILTIN_TOOLS.map((tool) => tool.id));
+  const explicitEnabled = Array.isArray(agentConfig.enabledTools)
+    ? agentConfig.enabledTools.map((id) => String(id || "").trim()).filter(Boolean)
+    : null;
+  const explicitBuiltinEnabled = explicitEnabled
+    ? explicitEnabled.filter((id) => builtinIdSet.has(id))
+    : [];
+  const useBuiltinAllowlist = explicitBuiltinEnabled.length > 0;
+  const explicitBuiltinSet = new Set(explicitBuiltinEnabled);
+
+  const builtinTools = DEFAULT_BUILTIN_TOOLS.map((tool) => ({
+    ...tool,
+    enabled: !disabledSet.has(tool.id) && (
+      useBuiltinAllowlist
+        ? explicitBuiltinSet.has(tool.id)
+        : defaultIds.has(tool.id)
+    ),
+  }));
+
+  return {
+    builtinTools,
+    mcpServers: agentConfig.enabledMcpServers || [],
+  };
+}
+
+/**
+ * List all available tools (builtin + installed MCP servers).
+ * @param {string} rootDir
+ * @returns {{ builtinTools: Array<Object>, mcpServers: Array<Object> }}
+ */
+export async function listAvailableTools(rootDir) {
+  let mcpServers = [];
+  try {
+    const { listInstalledMcpServers } = await import("./mcp-registry.mjs");
+    mcpServers = await listInstalledMcpServers(rootDir);
+  } catch {
+    // MCP registry not available
+  }
+
+  return {
+    builtinTools: [...DEFAULT_BUILTIN_TOOLS],
+    mcpServers: mcpServers.map((s) => ({
+      id: s.id,
+      name: s.name,
+      description: s.description || "",
+      tags: s.tags || [],
+      transport: s.meta?.transport || "stdio",
+    })),
+  };
+}

package/bosun-skills.mjs

@@ -16,8 +16,44 @@
  * scan quickly to decide which skill files to read.
  */
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync } from "node:fs";
-import { resolve, basename } from "node:path";
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { dirname, resolve, basename } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// ── Analytics stream path (same file task-executor writes to) ────────────────
+const _SKILL_STREAM_PATH = resolve(
+  __dirname,
+  ".cache",
+  "agent-work-logs",
+  "agent-work-stream.jsonl",
+);
+
+/**
+ * Best-effort: emit a skill_invoke event to the agent work stream so usage
+ * analytics can track which skills are loaded per task.
+ *
+ * @param {string} skillName
+ * @param {string} [skillTitle]
+ * @param {{ taskId?: string, executor?: string }} [opts]
+ */
+function emitSkillInvokeEvent(skillName, skillTitle, opts = {}) {
+  try {
+    const event = {
+      timestamp: new Date().toISOString(),
+      event_type: "skill_invoke",
+      data: { skill_name: skillName, skill_title: skillTitle || skillName },
+      ...(opts.taskId ? { task_id: String(opts.taskId) } : {}),
+      ...(opts.executor ? { executor: String(opts.executor) } : {}),
+    };
+    mkdirSync(dirname(_SKILL_STREAM_PATH), { recursive: true });
+    appendFileSync(_SKILL_STREAM_PATH, JSON.stringify(event) + "\n", "utf8");
+  } catch {
+    /* best effort — never let analytics crash skill loading */
+  }
+}
 
 // ── Built-in skill definitions ────────────────────────────────────────────────
 
@@ -911,14 +947,25 @@ export function loadSkillsIndex(bosunHome) {
  * @param {string}   [taskDescription]
  * @returns {Array<{filename:string,title:string,tags:string[],content:string}>}
  */
-export function findRelevantSkills(bosunHome, taskTitle, taskDescription = "") {
+/**
+ * Find skills relevant to a given task by matching tags against the task title
+ * and description. Also emits `skill_invoke` analytics events for each matched
+ * skill so usage analytics can track skill popularity over time.
+ *
+ * @param {string}   bosunHome
+ * @param {string}   taskTitle
+ * @param {string}   [taskDescription]
+ * @param {{ taskId?: string, executor?: string }} [opts]  - Optional task context for analytics.
+ * @returns {Array<{filename:string,title:string,tags:string[],content:string}>}
+ */
+export function findRelevantSkills(bosunHome, taskTitle, taskDescription = "", opts = {}) {
   const index = loadSkillsIndex(bosunHome);
   if (!index?.skills?.length) return [];
 
   const searchText = `${taskTitle} ${taskDescription}`.toLowerCase();
   const skillsDir = getSkillsDir(bosunHome);
 
-  return index.skills
+  const matched = index.skills
     .filter(({ tags }) =>
       tags.some((tag) => searchText.includes(tag)),
     )
@@ -930,4 +977,12 @@ export function findRelevantSkills(bosunHome, taskTitle, taskDescription = "") {
       return { filename, title, tags, content };
     })
     .filter(({ content }) => !!content);
+
+  // Emit analytics events for each loaded skill
+  for (const skill of matched) {
+    const skillName = skill.filename.replace(/\.md$/i, "");
+    emitSkillInvokeEvent(skillName, skill.title, opts);
+  }
+
+  return matched;
 }

package/bosun.schema.json

@@ -281,7 +281,7 @@
         "turnDetection": {
           "type": "string",
           "enum": ["server_vad", "semantic_vad", "none"],
-          "default": "server_vad",
+          "default": "semantic_vad",
           "description": "Turn detection mode for voice activity detection"
         },
         "instructions": {

package/desktop/launch.mjs

@@ -17,6 +17,13 @@ const chromeSandbox = resolve(
 
 process.title = "bosun-desktop-launcher";
 
+function hasGuiEnvironment() {
+  if (process.platform !== "linux") return true;
+  if (process.env.DISPLAY || process.env.WAYLAND_DISPLAY) return true;
+  if (process.env.XDG_SESSION_TYPE && process.env.XDG_SESSION_TYPE !== "tty") return true;
+  return false;
+}
+
 function shouldDisableSandbox() {
   if (process.env.BOSUN_DESKTOP_DISABLE_SANDBOX === "1") return true;
   if (process.platform !== "linux") return false;
@@ -49,6 +56,17 @@ function ensureElectronInstalled() {
 }
 
 function launch() {
+  if (!hasGuiEnvironment()) {
+    console.error(
+      [
+        "[desktop] No GUI display server detected.",
+        "Cannot launch Electron portal without DISPLAY/WAYLAND.",
+        "Run Bosun in daemon/web mode instead (for example: `bosun --daemon`).",
+      ].join(" "),
+    );
+    process.exit(1);
+  }
+
   if (!ensureElectronInstalled()) {
     process.exit(1);
   }

package/desktop/main.mjs

@@ -89,6 +89,7 @@ let shuttingDown = false;
 let uiServerStarted = false;
 let uiOrigin = null;
 let uiApi = null;
+let desktopAuthHeaderBridgeInstalled = false;
 let runtimeConfigLoaded = false;
 /** True when the app is running as a persistent background / tray resident. */
 let trayMode = false;
@@ -154,6 +155,38 @@ function isTrustedCaptureOrigin(originLike) {
   }
 }
 
+function isTrustedDesktopRequestUrl(urlLike) {
+  return isTrustedCaptureOrigin(urlLike);
+}
+
+function installDesktopAuthHeaderBridge() {
+  if (desktopAuthHeaderBridgeInstalled) return;
+  const ses = session.defaultSession;
+  if (!ses) return;
+  ses.webRequest.onBeforeSendHeaders((details, callback) => {
+    try {
+      const desktopKey = String(process.env.BOSUN_DESKTOP_API_KEY || "").trim();
+      if (!desktopKey) {
+        callback({ requestHeaders: details.requestHeaders });
+        return;
+      }
+      if (!isTrustedDesktopRequestUrl(details?.url || "")) {
+        callback({ requestHeaders: details.requestHeaders });
+        return;
+      }
+      const headers = { ...(details.requestHeaders || {}) };
+      const existingAuth = String(headers.Authorization || headers.authorization || "").trim();
+      if (!existingAuth) {
+        headers.Authorization = `Bearer ${desktopKey}`;
+      }
+      callback({ requestHeaders: headers });
+    } catch {
+      callback({ requestHeaders: details.requestHeaders });
+    }
+  });
+  desktopAuthHeaderBridgeInstalled = true;
+}
+
 function installDesktopMediaHandlers() {
   const ses = session.defaultSession;
   if (!ses) return;
@@ -583,20 +616,25 @@ async function fetchWorkspaces({ force = false } = {}) {
  * @param {string} workspaceId
  */
 async function switchWorkspace(workspaceId) {
-  if (!uiOrigin || !workspaceId) return;
+  if (!uiOrigin || !workspaceId) return { ok: false, error: "workspace unavailable" };
   const body = JSON.stringify({ workspaceId });
   const data = await uiServerRequest(`${uiOrigin}/api/workspaces/active`, {
     method: "POST",
     body,
   });
-  if (data?.ok) {
-    _cachedActiveWorkspaceId = workspaceId;
-    _workspaceCacheAt = 0; // force re-fetch next time
+  if (!data?.ok) {
+    return {
+      ok: false,
+      error: String(data?.error || "workspace switch failed"),
+    };
   }
+  _cachedActiveWorkspaceId = String(data?.activeId || workspaceId);
+  _workspaceCacheAt = 0; // force re-fetch next time
   await fetchWorkspaces({ force: true });
   Menu.setApplicationMenu(buildAppMenu());
   refreshTrayMenu();
   navigateMainWindow("/");
+  return { ok: true, activeId: _cachedActiveWorkspaceId };
 }
 
 /**
@@ -1265,14 +1303,15 @@ async function openFollowWindow(detail = {}) {
   const win = await createFollowWindow();
   const baseUiUrl = await buildUiUrl();
   const target = buildFollowWindowUrl(baseUiUrl, detail);
+  // Append a cache-buster timestamp so every Call press produces a unique URL.
+  // Without this, a second Call press with the same parameters would match
+  // followWindowLaunchSignature and skip loadURL — leaving the follow window
+  // in its previous dead state (launch params already scrubbed, voice overlay
+  // closed, useEffect([], []) already fired and won't re-run).
+  target.searchParams.set("t", String(Date.now()));
   const signature = target.toString();
-  if (!win.webContents.getURL() || followWindowLaunchSignature !== signature) {
-    followWindowLaunchSignature = signature;
-    await win.loadURL(signature);
-    anchorFollowWindow(win);
-    setWindowVisible(win);
-    return;
-  }
+  followWindowLaunchSignature = signature;
+  await win.loadURL(signature);
   anchorFollowWindow(win);
   setWindowVisible(win);
 }
@@ -1727,8 +1766,7 @@ function registerDesktopIpc() {
    */
   ipcMain.handle("bosun:workspaces:switch", async (_event, { workspaceId } = {}) => {
     if (!workspaceId) return { ok: false, error: "workspaceId required" };
-    await switchWorkspace(workspaceId);
-    return { ok: true, activeId: workspaceId };
+    return switchWorkspace(workspaceId);
   });
 }
 
@@ -1745,6 +1783,7 @@ async function bootstrap() {
       }
       callback(-3); // -3 = use Chromium default chain verification
     });
+    installDesktopAuthHeaderBridge();
     installDesktopMediaHandlers();
 
     if (process.env.ELECTRON_DISABLE_SANDBOX === "1") {

package/fleet-coordinator.mjs

@@ -36,6 +36,24 @@ import {
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
+// ── Workflow Event Bridge ────────────────────────────────────────────────────
+// Lazy-import queueWorkflowEvent from monitor.mjs — cached at module scope.
+let _queueWorkflowEvent = null;
+function emitFleetEvent(eventType, eventData = {}, opts = {}) {
+  if (!_queueWorkflowEvent) {
+    import("./monitor.mjs")
+      .then((mod) => {
+        if (typeof mod.queueWorkflowEvent === "function") {
+          _queueWorkflowEvent = mod.queueWorkflowEvent;
+          _queueWorkflowEvent(eventType, eventData, opts);
+        }
+      })
+      .catch(() => {});
+    return;
+  }
+  _queueWorkflowEvent(eventType, eventData, opts);
+}
+
 // ── Repo Fingerprinting ──────────────────────────────────────────────────────
 
 function buildGitEnv() {
@@ -434,13 +452,21 @@ export function assignTasksToWorkstations(waves, peers, taskMap = new Map()) {
     assignments.push(...waveAssignments);
   }
 
-  return {
+  const result = {
     assignments,
     totalTasks: assignments.length,
     totalPeers: peers.length,
     waveCount: waves.length,
     createdAt: new Date().toISOString(),
   };
+
+  emitFleetEvent("fleet.tasks_assigned", {
+    totalTasks: result.totalTasks,
+    totalPeers: result.totalPeers,
+    waveCount: result.waveCount,
+  }, { dedupKey: `fleet-assign-${result.createdAt}` });
+
+  return result;
 }
 
 // ── Backlog Depth Calculator ─────────────────────────────────────────────────
@@ -502,6 +528,10 @@ export function detectMaintenanceMode(status) {
 
   // Maintenance mode: nothing to do AND nothing in progress
   if (backlog === 0 && todo === 0 && running === 0 && review === 0) {
+    emitFleetEvent("fleet.maintenance_mode", {
+      isMaintenanceMode: true,
+      reason: "all tasks completed — no backlog, no active work",
+    });
     return {
       isMaintenanceMode: true,
       reason: "all tasks completed — no backlog, no active work",
@@ -722,6 +752,9 @@ export function shouldAutoGenerateTasks({
  */
 export function markAutoGenTriggered() {
   lastAutoGenTimestamp = Date.now();
+  emitFleetEvent("fleet.auto_gen_triggered", {
+    triggeredAt: new Date(lastAutoGenTimestamp).toISOString(),
+  });
 }
 
 /**