talon-agent 5.4.0 → 5.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talon-agent",
-  "version": "5.4.0",
+  "version": "5.4.1",
   "description": "Multi-frontend AI agent with full tool access, streaming, cron jobs, and plugin system",
   "author": "Dylan Neve",
   "license": "MIT",

package/src/app.ts

@@ -33,6 +33,7 @@ import { startWatchdog, stopWatchdog } from "./util/watchdog.js";
 import {
   BOOT_SMOKE_FLAG,
   BOOT_SMOKE_OK,
+  setRespawnShutdown,
   spawnSuccessor,
 } from "./core/daemon/respawn.js";
 import {
@@ -342,6 +343,9 @@ async function gracefulShutdown(signal: string): Promise<void> {
 
 process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
 process.on("SIGINT", () => gracefulShutdown("SIGINT"));
+// /restart and /update come in here directly rather than through a
+// self-sent SIGTERM — see core/daemon/respawn.ts.
+setRespawnShutdown((reason) => void gracefulShutdown(`respawn (${reason})`));
 
 // Cleanup runs before the crash is reported (and the EPIPE suppression
 // is unchanged) — see core/daemon/crash.ts for why the order matters.

package/src/core/daemon/respawn.ts

@@ -13,9 +13,9 @@
  * systemd, foreman, pm2, or running under a debugger. Respawning from
  * our own `process.argv` works regardless of launch method.
  *
- * Ordering matters. `respawnSelf()` only *arms* the handoff and raises
- * SIGTERM; the successor is spawned by `spawnSuccessor()` at the tail of
- * graceful shutdown, once the frontends have stopped. Spawning up-front
+ * Ordering matters. `respawnSelf()` only *arms* the handoff and enters
+ * graceful shutdown; the successor is spawned by `spawnSuccessor()` at
+ * the tail of it, once the frontends have stopped. Spawning up-front
  * (the original behaviour) left the successor long-polling `getUpdates`
  * while the outgoing process was still draining in-flight queries — up
  * to DRAIN_TIMEOUT_MS of two live pollers. Telegram answers only one of
@@ -40,6 +40,16 @@
  *     within a bounded window, and starts the daemon the way `talon
  *     start` does if the successor never comes up. Nothing in the
  *     handoff depends on a process that is about to call process.exit().
+ *
+ * And one thing 2026-09-20 added: the shutdown is entered directly,
+ * through the function app.ts registers with `setRespawnShutdown()`,
+ * not by sending ourselves a SIGTERM. The signal round trip bought
+ * nothing, and under Bun it lost the whole restart: by the time
+ * `/restart` ran, the process had silently lost its OS-level SIGTERM
+ * handler (see ./signals.ts), so the signal terminated it on the spot —
+ * no shutdown, no successor, no pidfile cleanup, and nothing in any log
+ * after "Respawn requested". Only a process that never registered — an
+ * embedder, a test — still falls back to the signal.
  */
 
 import { spawn } from "node:child_process";
@@ -47,6 +57,18 @@ import { log, logError, openRespawnLog } from "../../util/log.js";
 import { HANDOFF_WATCH_SUBCOMMAND } from "./handoff.js";
 
 let pendingReason: string | null = null;
+let shutdown: ((reason: string) => void) | null = null;
+
+/**
+ * Register the graceful-shutdown entry a respawn should run. app.ts
+ * hands over `gracefulShutdown`; `respawnSelf()` then calls it in-process
+ * instead of round-tripping a SIGTERM through the OS. `null` clears it.
+ */
+export function setRespawnShutdown(
+  fn: ((reason: string) => void) | null,
+): void {
+  shutdown = fn;
+}
 
 /**
  * Argv flag that makes the daemon entry resolve its whole import graph
@@ -84,9 +106,8 @@ function selfInvocation(extra: string[]): { cmd: string; args: string[] } {
 }
 
 /**
- * Arm a respawn and raise SIGTERM on ourselves so the existing
- * graceful-shutdown path cleanly stops the frontends, flushes state,
- * and hands off via `spawnSuccessor()`.
+ * Arm a respawn and enter graceful shutdown, which stops the frontends,
+ * flushes state, and hands off via `spawnSuccessor()`.
  *
  * `reason` is logged for operator visibility (e.g. "telegram
  * /restart"). The function returns immediately; the successor starts
@@ -95,10 +116,13 @@ function selfInvocation(extra: string[]): { cmd: string; args: string[] } {
 export function respawnSelf(reason: string): void {
   log("shutdown", `Respawn requested (${reason})`);
   pendingReason = reason;
-  // SIGTERM triggers the graceful-shutdown handler in src/app.ts,
-  // which stops the frontends, flushes state, spawns the successor,
-  // and calls process.exit(0). Don't exit here directly — that would
-  // skip the flush and leave the PID file dangling.
+  // Don't exit here directly — that would skip the flush and leave the
+  // PID file dangling. The registered shutdown is the same path a
+  // SIGTERM takes, entered without the signal.
+  if (shutdown) {
+    shutdown(reason);
+    return;
+  }
   process.kill(process.pid, "SIGTERM");
 }
 

package/src/core/daemon/signals.ts

@@ -0,0 +1,111 @@
+/**
+ * Keep OS-level signal handlers armed under Bun.
+ *
+ * Bun (observed on 1.3.9) uninstalls the process-wide handler for a
+ * signal as soon as ANY listener for it is removed — even while other
+ * listeners remain:
+ *
+ *   process.on("SIGTERM", a);
+ *   process.on("SIGTERM", b);
+ *   process.removeListener("SIGTERM", b);
+ *   // `a` is still registered in JS, yet SigCgt in /proc/<pid>/status
+ *   // no longer lists SIGTERM: the next one terminates the process
+ *   // with the default action, running no JS at all.
+ *
+ * Node keeps the handler until the last listener goes. Adding any
+ * listener makes Bun install the handler again, which is what this
+ * guard relies on.
+ *
+ * Talon hit it through `write-file-atomic`: each call loads signal-exit,
+ * which puts its own listeners on the termination signals, and unloads
+ * it afterwards, removing them. The daemon writes its pidfile that way
+ * while booting — so from that moment every SIGTERM it sent itself
+ * (`/restart` and `/update`, before respawn.ts entered the shutdown
+ * directly) or received from outside (`talon stop`'s fallback, systemd,
+ * docker) killed it outright: no graceful shutdown, no successor, no
+ * pidfile cleanup. Every `/update` between 2026-09-18 (the move to Bun)
+ * and 2026-09-20 ended this way.
+ *
+ * The guard wraps `process.removeListener` / `process.off`. After a
+ * removal that still leaves real listeners on a signal, it re-adds a
+ * no-op sentinel listener (removing any earlier copy first), so the
+ * handler is installed again before the caller gets control back. Once
+ * the last real listener is gone the sentinel goes too, and the signal
+ * falls back to its default action exactly as it would on Node — a
+ * lingering no-op listener would otherwise make the process ignore it.
+ *
+ * Installed by the entry shim (src/index.ts) so every Talon process —
+ * daemon, MCP supervisor, handoff watcher — is covered before any
+ * library gets a chance to remove a listener. A no-op on other runtimes.
+ */
+
+import { isBunRuntime } from "../../util/runtime.js";
+
+type Listener = (...args: unknown[]) => void;
+
+/** The slice of `process` the guard touches; tests pass an EventEmitter. */
+export interface SignalEmitter {
+  on(event: string | symbol, listener: Listener): unknown;
+  removeListener(event: string | symbol, listener: Listener): unknown;
+  off?(event: string | symbol, listener: Listener): unknown;
+  listeners(event: string | symbol): readonly unknown[];
+}
+
+export interface SignalGuardOptions {
+  /** Install even off Bun (tests exercise the wrapper on Node). */
+  force?: boolean;
+}
+
+const SIGNAL_EVENT = /^SIG[A-Z0-9]+$/;
+
+const INSTALLED = Symbol.for("talon.signalListenerGuard");
+
+type Guarded = SignalEmitter & { [INSTALLED]?: () => void };
+
+/** The sentinel. Its only job is to exist, so Bun keeps the handler. */
+function talonSignalRearm(): void {}
+
+/**
+ * Wrap the emitter's listener removal so a signal never silently loses
+ * its OS handler. Idempotent: a second install returns the first one's
+ * uninstall. Production never uninstalls; tests do.
+ */
+export function installSignalListenerGuard(
+  target: SignalEmitter = process,
+  opts: SignalGuardOptions = {},
+): () => void {
+  const emitter = target as Guarded;
+  if (!opts.force && !isBunRuntime()) return () => {};
+  const existing = emitter[INSTALLED];
+  if (existing) return existing;
+
+  const originalRemove = emitter.removeListener;
+  const originalOff = emitter.off;
+
+  const guardedRemove = function (
+    this: Guarded,
+    event: string | symbol,
+    listener: Listener,
+  ): unknown {
+    const result = originalRemove.call(this, event, listener);
+    if (typeof event !== "string" || !SIGNAL_EVENT.test(event)) return result;
+    // Bun has just dropped the handler. What is left decides whether the
+    // signal should still be handled at all.
+    const remaining = this.listeners(event).filter(
+      (fn) => fn !== talonSignalRearm,
+    );
+    originalRemove.call(this, event, talonSignalRearm);
+    if (remaining.length > 0) this.on(event, talonSignalRearm);
+    return result;
+  };
+
+  emitter.removeListener = guardedRemove;
+  if (originalOff) emitter.off = guardedRemove;
+  const uninstall = (): void => {
+    emitter.removeListener = originalRemove;
+    if (originalOff) emitter.off = originalOff;
+    delete emitter[INSTALLED];
+  };
+  emitter[INSTALLED] = uninstall;
+  return uninstall;
+}

package/src/index.ts

@@ -10,6 +10,7 @@
  * backends/frontends/plugins.
  */
 
+import { installSignalListenerGuard } from "./core/daemon/signals.js";
 import {
   MCP_LAUNCH_SUBCOMMAND,
   runSupervisor,
@@ -20,6 +21,12 @@ import {
   runHandoffWatch,
 } from "./core/daemon/handoff.js";
 
+// Before anything can remove a signal listener: under Bun that would
+// silently disarm SIGTERM/SIGINT for the whole process (core/daemon/
+// signals.ts). Every Talon process passes through here, so every one
+// is covered.
+installSignalListenerGuard();
+
 if (process.argv[2] === MCP_LAUNCH_SUBCOMMAND) {
   await runSupervisor(process.argv.slice(3));
 } else if (process.argv[2] === LUA_RUN_SUBCOMMAND) {