talon-agent 3.34.0 → 3.34.1

package/src/core/mcp-hub/child-transport.ts

@@ -0,0 +1,215 @@
+/**
+ * Hub child transport — the SDK's stdio client transport with the child
+ * process kept in view.
+ *
+ * `StdioClientTransport` spawns the process itself and hides it: its
+ * `onclose` carries no exit code or signal, and stderr is either
+ * inherited (lost in the daemon's own stderr, never in talon.log) or
+ * piped raw. When a child died during the initialize handshake —
+ * playwright-tools with its browser endpoint down, say — the hub saw
+ * only "MCP error -32000: Connection closed" and nothing about why.
+ *
+ * This transport owns the spawn so the hub can record the cause: exit
+ * code + signal, and the last few stderr lines in a bounded ring
+ * buffer. Wire behaviour matches the SDK transport exactly —
+ * newline-delimited JSON-RPC over stdin/stdout; `close()` ends stdin,
+ * then escalates SIGTERM → SIGKILL. Children still run under the
+ * supervisor wrap (the spec's command IS the supervisor), so orphan
+ * cleanup and stdout filtering are untouched.
+ */
+
+import crossSpawn from "cross-spawn";
+import type { ChildProcess } from "node:child_process";
+import {
+  ReadBuffer,
+  serializeMessage,
+} from "@modelcontextprotocol/sdk/shared/stdio.js";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import type { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
+
+/** How many trailing stderr lines a child keeps for its exit report. */
+export const STDERR_TAIL_LINES = 20;
+/** Per-line cap so one runaway stack trace can't bloat a log entry. */
+const STDERR_LINE_MAX_CHARS = 400;
+
+function clipLine(raw: string): string {
+  const line = raw.replace(/\r$/, "");
+  return line.length > STDERR_LINE_MAX_CHARS
+    ? `${line.slice(0, STDERR_LINE_MAX_CHARS)}…`
+    : line;
+}
+
+/**
+ * Bounded ring buffer over a line stream: keeps the last `capacity`
+ * non-blank lines. Chunks may split lines arbitrarily; an unterminated
+ * trailing fragment is included in snapshots so a crash mid-line (no
+ * final newline before exit) still shows its last words.
+ */
+export class StderrTail {
+  private lines: string[] = [];
+  private partial = "";
+
+  constructor(private readonly capacity = STDERR_TAIL_LINES) {}
+
+  push(chunk: string): void {
+    const parts = (this.partial + chunk).split("\n");
+    this.partial = parts.pop() ?? "";
+    for (const line of parts) {
+      if (line.trim().length === 0) continue;
+      this.lines.push(clipLine(line));
+    }
+    if (this.lines.length > this.capacity) {
+      this.lines.splice(0, this.lines.length - this.capacity);
+    }
+  }
+
+  snapshot(): string[] {
+    const tail = this.partial.trim().length > 0 ? [clipLine(this.partial)] : [];
+    return [...this.lines, ...tail].slice(-this.capacity);
+  }
+}
+
+export type ChildExit = {
+  code: number | null;
+  signal: NodeJS.Signals | null;
+};
+
+export type HubChildTransportOptions = {
+  command: string;
+  args: string[];
+  env: Record<string, string>;
+};
+
+const CLOSE_GRACE_MS = 2_000;
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms).unref());
+}
+
+export class HubChildTransport implements Transport {
+  onclose?: () => void;
+  onerror?: (error: Error) => void;
+  onmessage?: (message: JSONRPCMessage) => void;
+
+  private child: ChildProcess | null = null;
+  /** Kept past exit so the exit report can name the process. */
+  private spawnedPid: number | null = null;
+  private readonly readBuffer = new ReadBuffer();
+  private readonly stderrTail = new StderrTail();
+  private exitInfo: ChildExit | null = null;
+  private closeRequested = false;
+
+  constructor(private readonly opts: HubChildTransportOptions) {}
+
+  get pid(): number | null {
+    return this.spawnedPid;
+  }
+
+  /** Exit code + signal once the process has gone; null while alive. */
+  get exit(): ChildExit | null {
+    return this.exitInfo;
+  }
+
+  /** True when the hub itself asked for the close (reap/retire/shutdown). */
+  get closedByHub(): boolean {
+    return this.closeRequested;
+  }
+
+  /** Last stderr lines seen so far (bounded, see STDERR_TAIL_LINES). */
+  get stderrLines(): string[] {
+    return this.stderrTail.snapshot();
+  }
+
+  start(): Promise<void> {
+    if (this.child) {
+      return Promise.reject(new Error("HubChildTransport already started"));
+    }
+    return new Promise((resolve, reject) => {
+      const child = crossSpawn(this.opts.command, this.opts.args, {
+        env: this.opts.env,
+        stdio: ["pipe", "pipe", "pipe"],
+        shell: false,
+        windowsHide: process.platform === "win32",
+      });
+      this.child = child;
+      this.spawnedPid = child.pid ?? null;
+      child.once("spawn", () => resolve());
+      child.on("error", (err) => {
+        reject(err);
+        this.onerror?.(err);
+      });
+      // `close` (not `exit`) so the stderr tail is complete when the
+      // exit report is read.
+      child.on("close", (code, signal) => {
+        this.exitInfo = { code, signal };
+        this.child = null;
+        this.onclose?.();
+      });
+      child.stdin?.on("error", (err) => this.onerror?.(err));
+      child.stdout?.on("error", (err) => this.onerror?.(err));
+      child.stdout?.on("data", (chunk: Buffer) => {
+        try {
+          this.readBuffer.append(chunk);
+          this.drainMessages();
+        } catch (err) {
+          this.onerror?.(err as Error);
+          void this.close();
+        }
+      });
+      child.stderr?.setEncoding("utf-8");
+      child.stderr?.on("data", (chunk: string) => this.stderrTail.push(chunk));
+      child.stderr?.on("error", () => {});
+    });
+  }
+
+  private drainMessages(): void {
+    for (;;) {
+      let message: JSONRPCMessage | null;
+      try {
+        // readMessage consumes the line before parsing, so a malformed
+        // line is skipped rather than re-read forever.
+        message = this.readBuffer.readMessage();
+      } catch (err) {
+        this.onerror?.(err as Error);
+        continue;
+      }
+      if (message === null) return;
+      this.onmessage?.(message);
+    }
+  }
+
+  async close(): Promise<void> {
+    this.closeRequested = true;
+    const child = this.child;
+    this.child = null;
+    if (child) {
+      const closed = new Promise<void>((resolve) => {
+        child.once("close", () => resolve());
+      });
+      const alive = () => child.exitCode === null && child.signalCode === null;
+      child.stdin?.end();
+      await Promise.race([closed, delay(CLOSE_GRACE_MS)]);
+      if (alive()) {
+        child.kill("SIGTERM");
+        await Promise.race([closed, delay(CLOSE_GRACE_MS)]);
+      }
+      if (alive()) child.kill("SIGKILL");
+    }
+    this.readBuffer.clear();
+  }
+
+  send(message: JSONRPCMessage): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const stdin = this.child?.stdin;
+      if (!stdin) {
+        reject(new Error("Not connected"));
+        return;
+      }
+      if (stdin.write(serializeMessage(message))) {
+        resolve();
+      } else {
+        stdin.once("drain", resolve);
+      }
+    });
+  }
+}

package/src/core/mcp-hub/children.ts

@@ -19,12 +19,17 @@
  * connected once over stdio, and shared by every hub session that
  * proxies to it. The tools list is cached per child lifetime — plugin
  * reload restarts children, which naturally invalidates the cache.
+ *
+ * Every exit is accounted for: the child's exit code, signal and
+ * stderr tail are logged when it goes away unasked (handshake death,
+ * crash) and kept per key so a registration failure upstream can name
+ * the cause instead of just "Connection closed" (see getLastChildExit).
  */
 
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import type { CallToolResult, Tool } from "@modelcontextprotocol/sdk/types.js";
 import { log, logError, logWarn } from "../../util/log.js";
+import { HubChildTransport, type ChildExit } from "./child-transport.js";
 
 export type ChildSpec = {
   command: string;
@@ -56,12 +61,74 @@ type ChildEntry = {
    * retire grace timer, whichever comes first).
    */
   retired: boolean;
+  transport: HubChildTransport;
   close: () => Promise<void>;
 };
 
 const children = new Map<string, ChildEntry>();
 const inflight = new Map<string, Promise<ChildHandle>>();
 
+/**
+ * Most recent exit per key, whether the child died during the
+ * handshake (never registered) or later. Consulted by the backends'
+ * registration path to explain a failure that surfaced upstream as a
+ * bare "Connection closed".
+ */
+export type ChildExitRecord = ChildExit & {
+  at: number;
+  /** Last stderr lines before exit (bounded ring buffer). */
+  stderr: string[];
+};
+const lastExits = new Map<string, ChildExitRecord>();
+
+/** Last recorded exit for `key`, or null if it never exited. */
+export function getLastChildExit(key: string): ChildExitRecord | null {
+  return lastExits.get(key) ?? null;
+}
+
+/**
+ * One-line exit summary: `code=1 signal=null 3s ago; stderr: a | b`.
+ * `maxStderrLines` bounds the stderr part for compact callers.
+ */
+export function formatChildExit(
+  exit: ChildExitRecord,
+  maxStderrLines = exit.stderr.length,
+): string {
+  const age = Math.round((Date.now() - exit.at) / 1000);
+  const head = `code=${exit.code} signal=${exit.signal} ${age}s ago`;
+  const lines = exit.stderr.slice(-maxStderrLines);
+  return lines.length > 0 ? `${head}; stderr: ${lines.join(" | ")}` : head;
+}
+
+/**
+ * Bookkeeping for a child process that has gone away, asked or not.
+ * Wired as the transport's `onclose` BEFORE `client.connect` so the SDK
+ * chains it ahead of its own close handling — set afterwards it would
+ * replace the SDK's handler and every in-flight request on a dead
+ * child would hang instead of rejecting with "Connection closed".
+ */
+function onChildClosed(key: string, transport: HubChildTransport): void {
+  const exit = transport.exit ?? { code: null, signal: null };
+  const record: ChildExitRecord = {
+    ...exit,
+    at: Date.now(),
+    stderr: transport.stderrLines,
+  };
+  lastExits.set(key, record);
+  const entry = children.get(key);
+  if (entry?.transport === transport) children.delete(key);
+  // Hub-initiated closes (reap/retire/shutdown) are logged by their
+  // callers; only an unasked exit is news.
+  if (transport.closedByHub) return;
+  const phase = entry
+    ? "exited — will respawn on demand"
+    : "died before registration";
+  logWarn(
+    "gateway",
+    `hub child ${key} ${phase} (pid ${transport.pid ?? "?"}): ${formatChildExit(record)}`,
+  );
+}
+
 /**
  * Negative cache for spawn failures. A child whose backing service is down
  * (e.g. playwright-tools with its browser endpoint offline) dies at the
@@ -92,14 +159,14 @@ const REAP_INTERVAL_MS = 60_000;
 let reaper: ReturnType<typeof setInterval> | null = null;
 
 async function spawnChild(key: string, spec: ChildSpec): Promise<ChildHandle> {
-  const transport = new StdioClientTransport({
+  const transport = new HubChildTransport({
     command: spec.command,
     args: spec.args,
     // Merge over the daemon env — same visibility the SDK-spawned
     // subprocesses had (PATH, HOME, proxy vars, …).
     env: { ...(process.env as Record<string, string>), ...spec.env },
-    stderr: "inherit",
   });
+  transport.onclose = () => onChildClosed(key, transport);
   const client = new Client(
     { name: "talon-mcp-hub", version: "1.0.0" },
     { capabilities: {} },
@@ -123,6 +190,7 @@ async function spawnChild(key: string, spec: ChildSpec): Promise<ChildHandle> {
     lastActivity: Date.now(),
     pending: 0,
     retired: false,
+    transport,
     // Idempotent: retirement can race its own grace timer.
     close: (() => {
       let closing: Promise<void> | null = null;
@@ -157,17 +225,8 @@ async function spawnChild(key: string, spec: ChildSpec): Promise<ChildHandle> {
     },
   };
 
-  // If the child dies on its own (crash, plugin bug), drop the entry so
-  // the next request respawns instead of hitting a dead pipe forever.
-  transport.onclose = () => {
-    if (children.get(key) === entry) {
-      children.delete(key);
-      log("gateway", `hub child ${key} exited — will respawn on demand`);
-    }
-  };
-
   children.set(key, entry);
-  log("gateway", `hub child started: ${key}`);
+  log("gateway", `hub child started: ${key} (pid ${transport.pid ?? "?"})`);
   return entry.handle;
 }
 

package/src/core/mcp-hub/index.ts

@@ -45,6 +45,8 @@ import { buildProxyServer } from "./proxy-server.js";
 import {
   acquireChild,
   closeAllChildren,
+  formatChildExit,
+  getLastChildExit,
   retireAllChildren,
   startChildReaper,
   stopChildReaper,
@@ -115,17 +117,41 @@ export async function listHubPluginToolNames(
   chatId: string,
   bridgeUrl: string,
 ): Promise<string[]> {
-  const key =
-    serverName === "brave-search"
-      ? "brave-search"
-      : `${serverName}\u0000${chatId}`;
-  const child = await acquireChild(key, () =>
+  const child = await acquireChild(childKey(serverName, chatId), () =>
     pluginSpec(serverName, chatId, bridgeUrl),
   );
   child.touch();
   return (await child.listTools()).map((tool) => tool.name);
 }
 
+/** Stderr lines quoted in a registration-failure warning (full tail is in the exit log line). */
+const EXIT_SUMMARY_STDERR_LINES = 5;
+
+/**
+ * Why the hub child behind (serverName, chatId) last went away —
+ * `code=1 signal=null 2s ago; stderr: …` — or null if it never exited.
+ * Lets a backend's "registration failed: Connection closed" warning
+ * carry the cause.
+ */
+export function describeHubChildExit(
+  serverName: string,
+  chatId: string,
+): string | null {
+  const exit = getLastChildExit(childKey(serverName, chatId));
+  return exit ? formatChildExit(exit, EXIT_SUMMARY_STDERR_LINES) : null;
+}
+
+/**
+ * brave-search is chat-agnostic (one shared child); plugins read
+ * TALON_CHAT_ID at boot, so their children stay chat-scoped and the
+ * idle reaper bounds the fleet.
+ */
+function childKey(serverName: string, chatId: string): string {
+  return serverName === "brave-search"
+    ? "brave-search"
+    : `${serverName}\u0000${chatId}`;
+}
+
 // ── Server construction per session ─────────────────────────────────────────
 
 type HubTarget =
@@ -191,15 +217,8 @@ function buildServerFor(target: HubTarget, bridgeUrl: string) {
       includeNativeTools: hubConfig.nativeTools,
     });
   }
-  // brave-search is chat-agnostic (one shared child); plugins read
-  // TALON_CHAT_ID at boot, so their children stay chat-scoped and the
-  // idle reaper bounds the fleet.
-  const key =
-    target.serverName === "brave-search"
-      ? "brave-search"
-      : `${target.serverName}\u0000${target.chatId}`;
   return buildProxyServer(target.serverName, () =>
-    acquireChild(key, () =>
+    acquireChild(childKey(target.serverName, target.chatId), () =>
       pluginSpec(target.serverName, target.chatId, bridgeUrl),
     ),
   );

package/src/core/models/active-model.ts

@@ -150,12 +150,7 @@ async function runChain(
       if (validated) {
         return { model: override, source: "override-valid" };
       }
-      logWarn(
-        "settings",
-        `chat=${chatId} backend=${backendId}: per-chat override ` +
-          `"${override}" is not a selectable model on this backend. ` +
-          `Falling through to backend default.`,
-      );
+      warnInvalidOverrideOnce(chatId, backendId, override);
       return stepsTwoThroughFive(
         backend,
         backendId,
@@ -170,6 +165,34 @@ async function runChain(
   return stepsTwoThroughFive(backend, backendId, config, null);
 }
 
+/**
+ * chat id → the invalid override it was last warned about. A single turn
+ * resolves the active model several times (status line, send guard,
+ * menu), so an unchanged bad override warns once; picking a different
+ * value re-arms the warning for that chat.
+ */
+const warnedInvalidOverrides = new Map<string, string>();
+
+/** Test seam. */
+export function resetInvalidOverrideWarnings(): void {
+  warnedInvalidOverrides.clear();
+}
+
+function warnInvalidOverrideOnce(
+  chatId: string,
+  backendId: string,
+  override: string,
+): void {
+  if (warnedInvalidOverrides.get(chatId) === override) return;
+  warnedInvalidOverrides.set(chatId, override);
+  logWarn(
+    "settings",
+    `chat=${chatId} backend=${backendId}: per-chat override ` +
+      `"${override}" is not a selectable model on this backend. ` +
+      `Falling through to backend default.`,
+  );
+}
+
 async function stepsTwoThroughFive(
   backend: Backend | null,
   backendId: string | null,

package/src/core/weaver/shuttle.ts

@@ -26,6 +26,7 @@ import {
   type AgentEvent,
   type AgentResult,
 } from "../agent-runtime/events.js";
+import { recordTurnActivity } from "../../util/watchdog.js";
 
 export type EventSink = (event: AgentEvent) => void | Promise<void>;
 
@@ -64,6 +65,9 @@ export async function carryTurnEvents(
         }
       : onEvent;
   for await (const event of stream) {
+    // Every backend's events cross this loop exactly once, so this is the
+    // one place the watchdog learns a turn is alive (vs. wedged).
+    recordTurnActivity();
     if (timing && timing.firstEventAt === undefined) {
       timing.firstEventAt = Date.now();
     }

package/src/frontend/telegram/admin.ts

@@ -7,7 +7,8 @@ import { readFileSync } from "node:fs";
 import type { TalonConfig } from "../../util/config.js";
 import { files, dirs } from "../../util/paths.js";
 import { tailFile } from "../../util/tail-file.js";
-import { escapeHtml } from "./formatting.js";
+import { escapeHtml, splitMessage } from "./formatting.js";
+import { TELEGRAM_MAX_TEXT } from "./actions/types.js";
 import { resetSession, getAllSessions } from "../../storage/sessions.js";
 import { clearHistory } from "../../storage/history.js";
 import { todayLogDate } from "../../storage/daily-log.js";
@@ -22,6 +23,72 @@ import { getPulseStatus } from "../../core/background/pulse.js";
 import { getHealthStatus, getRecentErrors } from "../../util/watchdog.js";
 import { formatDuration, formatModelLabel } from "./helpers/index.js";
 
+/**
+ * Reply with an HTML listing, split across messages when it outgrows
+ * Telegram's 4096-char cap. The per-item listings below (chats, cron,
+ * pulse) scale with the daemon's chat count, and a single oversized
+ * `ctx.reply` fails the whole command with 400 "message is too long".
+ * Entries are `\n\n`-separated and each carries balanced tags, so the
+ * paragraph-first splitter never cuts through markup.
+ */
+async function replyHtmlChunked(ctx: Context, text: string): Promise<void> {
+  for (const chunk of splitMessage(text, TELEGRAM_MAX_TEXT)) {
+    await ctx.reply(chunk, { parse_mode: "HTML" });
+  }
+}
+
+/** `/admin chats` — every active session, newest first, titled via getChat. */
+async function replyActiveChats(
+  ctx: Context,
+  bot: Bot,
+  config: TalonConfig,
+): Promise<void> {
+  const sessions = getAllSessions();
+  if (sessions.length === 0) {
+    await ctx.reply("No active sessions.");
+    return;
+  }
+  sessions.sort((a, b) => (b.info.lastActive || 0) - (a.info.lastActive || 0));
+
+  const titles = new Map<string, string>();
+  await Promise.all(
+    sessions.map(async (s) => {
+      try {
+        const id = parseInt(s.chatId, 10);
+        if (isNaN(id)) return;
+        const chat = await bot.api.getChat(id);
+        titles.set(
+          s.chatId,
+          "title" in chat
+            ? (chat.title ?? "DM")
+            : "first_name" in chat
+              ? (chat.first_name ?? "DM")
+              : "DM",
+        );
+      } catch {
+        /* inaccessible */
+      }
+    }),
+  );
+
+  const lines = sessions.map((s) => {
+    const age = s.info.lastActive
+      ? `${Math.round((Date.now() - s.info.lastActive) / 60000)}m ago`
+      : "?";
+    const title = titles.get(s.chatId) ?? s.chatId;
+    const model = formatModelLabel(
+      getChatSettings(s.chatId).model ?? config.model,
+    );
+    // `model` is a catalog id (OpenRouter/Kilo ids are free-form), so
+    // it gets the same escaping the title already had.
+    return `<b>${escapeHtml(title)}</b> <code>${s.chatId}</code>\n  ${s.info.turns} turns | ${age} | ${escapeHtml(model)}`;
+  });
+  await replyHtmlChunked(
+    ctx,
+    `<b>Active chats (${sessions.length})</b>\n\n` + lines.join("\n\n"),
+  );
+}
+
 export async function handleAdminCommand(
   ctx: Context,
   bot: Bot,
@@ -32,52 +99,7 @@ export async function handleAdminCommand(
 
   switch (subcommand) {
     case "chats": {
-      const sessions = getAllSessions();
-      if (sessions.length === 0) {
-        await ctx.reply("No active sessions.");
-        return;
-      }
-      sessions.sort(
-        (a, b) => (b.info.lastActive || 0) - (a.info.lastActive || 0),
-      );
-
-      const titles = new Map<string, string>();
-      await Promise.all(
-        sessions.map(async (s) => {
-          try {
-            const id = parseInt(s.chatId, 10);
-            if (isNaN(id)) return;
-            const chat = await bot.api.getChat(id);
-            titles.set(
-              s.chatId,
-              "title" in chat
-                ? (chat.title ?? "DM")
-                : "first_name" in chat
-                  ? (chat.first_name ?? "DM")
-                  : "DM",
-            );
-          } catch {
-            /* inaccessible */
-          }
-        }),
-      );
-
-      const lines = sessions.map((s) => {
-        const age = s.info.lastActive
-          ? `${Math.round((Date.now() - s.info.lastActive) / 60000)}m ago`
-          : "?";
-        const title = titles.get(s.chatId) ?? s.chatId;
-        const model = formatModelLabel(
-          getChatSettings(s.chatId).model ?? config.model,
-        );
-        // `model` is a catalog id (OpenRouter/Kilo ids are free-form), so
-        // it gets the same escaping the title already had.
-        return `<b>${escapeHtml(title)}</b> <code>${s.chatId}</code>\n  ${s.info.turns} turns | ${age} | ${escapeHtml(model)}`;
-      });
-      await ctx.reply(
-        `<b>Active chats (${sessions.length})</b>\n\n` + lines.join("\n\n"),
-        { parse_mode: "HTML" },
-      );
+      await replyActiveChats(ctx, bot, config);
       return;
     }
 
@@ -189,9 +211,9 @@ export async function handleAdminCommand(
           : "?";
         return `${j.enabled ? "\u2713" : "\u2717"} <b>${escapeHtml(j.name)}</b>\n  <code>${escapeHtml(describeSchedule(j))}</code> | ${j.type} | runs: ${j.runCount} | last: ${last} | next: ${next}`;
       });
-      await ctx.reply(
+      await replyHtmlChunked(
+        ctx,
         `<b>Cron Jobs (${jobs.length})</b>\n\n` + lines.join("\n\n"),
-        { parse_mode: "HTML" },
       );
       return;
     }
@@ -217,9 +239,10 @@ export async function handleAdminCommand(
           return `${p.enabled ? "\u2713" : "\u2717"} ${escapeHtml(title)}`;
         }),
       );
-      await ctx.reply(`<b>Pulse (${chats.length})</b>\n\n` + lines.join("\n"), {
-        parse_mode: "HTML",
-      });
+      await replyHtmlChunked(
+        ctx,
+        `<b>Pulse (${chats.length})</b>\n\n` + lines.join("\n"),
+      );
       return;
     }
 

package/src/storage/trigger-store.ts

@@ -73,6 +73,14 @@ function isTrigger(value: unknown): value is Trigger {
  */
 export const RESTART_KILL_ERROR = "Talon restarted while trigger was running";
 
+/**
+ * The lastError shutdownTriggers stamps on non-persistent triggers it kills
+ * during a clean shutdown. Their terminal wake is deliberately not dispatched
+ * while the daemon is tearing down — resume.ts keys the next boot's late-wake
+ * decision on this marker, exactly as it does for RESTART_KILL_ERROR.
+ */
+export const SHUTDOWN_KILL_ERROR = "Killed by Talon shutdown";
+
 export function loadTriggers(): void {
   try {
     importLegacyJson({