talon-agent 5.19.0 → 5.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talon-agent",
-  "version": "5.19.0",
+  "version": "5.20.0",
   "description": "Multi-frontend AI agent with full tool access, streaming, cron jobs, and plugin system",
   "author": "The Falconry",
   "license": "Apache-2.0",
@@ -101,7 +101,7 @@
     "build:fusefs": "node native/talon-fusefs/build.mjs"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.277",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.283",
     "@anthropic-ai/sdk": "^0.104.1",
     "@brave/brave-search-mcp-server": "^2.0.75",
     "@clack/prompts": "^1.2.0",

package/src/backend/claude-sdk/one-shot.ts

@@ -279,6 +279,34 @@ async function formatAndAppendMessage(
  * spawner (us) and contains the env vars Talon set when launching the SDK
  * subprocess via MCP launcher. SIGTERM with a short grace, then SIGKILL.
  */
+/**
+ * Decide whether a `/proc` entry is a run orphan this sweep may kill.
+ *
+ * Carrying the chat id is necessary but NOT sufficient. Every chat-scoped
+ * child Talon spawns inherits `TALON_CHAT_ID` — including trigger watchers
+ * (`core/background/triggers/spawn.ts` sets it alongside `TALON_TRIGGER_ID`)
+ * and their descendants, which are long-lived by design and belong to no run.
+ * Matching on the chat id alone made every orphan sweep kill that chat's
+ * triggers: the warden respawned them, the next sweep killed them again, and
+ * the only visible symptom was a trigger stuck in "errored" with no output.
+ *
+ * Two independent guards, because this function issues SIGKILL:
+ *  - refuse anything tagged `TALON_TRIGGER_ID` (a trigger, or its child);
+ *  - require the argv to actually be the `claude` SDK binary, which is the
+ *    only thing this sweep was ever meant to reap.
+ */
+export function isEvictableOrphan(
+  envEntries: string[],
+  argv: string[],
+  target: string,
+): boolean {
+  if (!envEntries.includes(target)) return false;
+  if (envEntries.some((entry) => entry.startsWith("TALON_TRIGGER_ID="))) {
+    return false;
+  }
+  return argv.some((arg) => arg === "claude" || arg.endsWith("/claude"));
+}
+
 export async function evictOrphanSubprocesses(contextLabel: string): Promise<{
   found: number;
   termed: number;
@@ -306,12 +334,14 @@ export async function evictOrphanSubprocesses(contextLabel: string): Promise<{
     if (!Number.isInteger(pid) || pid === myPid) continue;
     try {
       const environRaw = await readFile(`/proc/${pid}/environ`, "utf-8");
+      const argvRaw = await readFile(`/proc/${pid}/cmdline`, "utf-8");
       // /proc/<pid>/environ is NUL-delimited. Split on \0 and match exact
       // entries — a raw .includes() can false-positive on other vars whose
       // value happens to contain the substring. Since this code can SIGKILL,
       // err on the side of strict matching. (Copilot review on #144.)
-      const envEntries = environRaw.split("\0");
-      if (envEntries.includes(target)) {
+      if (
+        isEvictableOrphan(environRaw.split("\0"), argvRaw.split("\0"), target)
+      ) {
         matched.push(pid);
       }
     } catch {

package/src/core/agents/registry.ts

@@ -216,6 +216,22 @@ export class AgentRegistry {
     const entry = this.live.get(id);
     if (!entry || entry.record.state !== "queued") return;
     entry.abort = binding.abort;
+    // A kill can arrive while the agent is still `queued` — before any abort
+    // handle exists, so requestKill's `entry.abort?.abort()` was a no-op that
+    // only set the flag. When the handle finally binds here, honour that
+    // pending kill; otherwise the fresh, un-aborted controller lets the run
+    // proceed and the kill is silently lost. The runner checks the signal
+    // right after start() and settles the run as "killed".
+    if (entry.killRequested) {
+      try {
+        binding.abort.abort();
+      } catch (err) {
+        logWarn(
+          "agents",
+          `Abort hook threw on start agent=${id}: ${err instanceof Error ? err.message : String(err)}`,
+        );
+      }
+    }
     entry.record.model = binding.model;
     entry.record.state = "running";
     entry.record.startedAt = Date.now();

package/src/core/backup/plan.ts

@@ -75,6 +75,7 @@ export const HOME_INCLUDES: readonly string[] = [
   "google",
   "plugins",
   "mesh-devices.json",
+  "mesh-credentials.json",
   "mesh-history.json",
   "mesh-locations.json",
   "teleport-state.json",

package/src/core/engine/gateway-actions/mesh.ts

@@ -14,38 +14,50 @@ import type { SharedActionHandlers } from "./types.js";
 
 export const meshHandlers: SharedActionHandlers = {
   list_devices: () => getMeshService().describeDevices(),
-  get_device_location: (body) => getMeshService().locateDevice(body.device),
+  get_device_location: (body) =>
+    getMeshService().locateDevice(body.device ?? body.deviceId),
   get_device_history: (body) =>
-    getMeshService().deviceHistory(body.device, body.hours),
-  ring_device: (body) => getMeshService().ringDevice(body.device, body.message),
+    getMeshService().deviceHistory(body.device ?? body.deviceId, body.hours),
+  ring_device: (body) =>
+    getMeshService().ringDevice(body.device ?? body.deviceId, body.message),
   // Registry hygiene: drop a stale/superseded device entry. Requires an
   // explicit target — a destructive action must never default-pick a device.
-  remove_device: (body) => getMeshService().removeDevice(body.device),
-  get_device_status: (body) => getMeshService().getDeviceStatus(body.device),
+  remove_device: (body) =>
+    getMeshService().removeDevice(body.device ?? body.deviceId),
+  get_device_status: (body) =>
+    getMeshService().getDeviceStatus(body.device ?? body.deviceId),
   // Exec + filesystem surface — the substrate teleport routes through.
   device_exec: (body) =>
     getMeshService().execOnDevice(
-      body.device,
+      body.device ?? body.deviceId,
       body.cmd,
       body.cwd,
       body.timeout_sec,
     ),
   device_list_dir: (body) =>
-    getMeshService().listDirOnDevice(body.device, body.path),
-  device_stat: (body) => getMeshService().statOnDevice(body.device, body.path),
+    getMeshService().listDirOnDevice(body.device ?? body.deviceId, body.path),
+  device_stat: (body) =>
+    getMeshService().statOnDevice(body.device ?? body.deviceId, body.path),
   device_read_file: (body) =>
-    getMeshService().readFileFromDevice(body.device, body.path),
+    getMeshService().readFileFromDevice(
+      body.device ?? body.deviceId,
+      body.path,
+    ),
   device_write_file: (body) =>
-    getMeshService().writeFileToDevice(body.device, body.path, body.content),
+    getMeshService().writeFileToDevice(
+      body.device ?? body.deviceId,
+      body.path,
+      body.content,
+    ),
   device_pull_file: (body) =>
     getMeshService().pullFileFromDevice(
-      body.device,
+      body.device ?? body.deviceId,
       body.remote_path,
       body.local_path,
     ),
   device_push_file: (body) =>
     getMeshService().pushFileToDevice(
-      body.device,
+      body.device ?? body.deviceId,
       body.local_path,
       body.remote_path,
     ),
@@ -53,7 +65,7 @@ export const meshHandlers: SharedActionHandlers = {
   // the mesh connection across the app restart.
   update_device: (body) =>
     getMeshService().updateDeviceApp(
-      body.device,
+      body.device ?? body.deviceId,
       body.apk_path,
       body.remote_path,
     ),
@@ -63,7 +75,7 @@ export const meshHandlers: SharedActionHandlers = {
   // platform/arch itself (source build or verified release download).
   update_node: (body) =>
     getMeshService().updateNodeBinary(
-      body.device,
+      body.device ?? body.deviceId,
       body.binary_path,
       body.remote_path,
     ),

package/src/core/engine/gateway-actions/native/teleport.ts

@@ -11,7 +11,7 @@ import type { Result } from "./results.js";
 import type { SharedActionHandlers } from "../types.js";
 
 export const teleportHandlers: SharedActionHandlers = {
-  teleport: (body, chatId) => teleport(chatId, body.device),
+  teleport: (body, chatId) => teleport(chatId, body.device ?? body.deviceId),
   teleport_back: (_body, chatId) => teleportBack(chatId),
 };
 

package/src/core/mesh/devices/registry.ts

@@ -125,23 +125,7 @@ export class MeshRegistry {
       now,
     );
     this.devices.set(device.id, device);
-    // Stale-duplicate eviction. A reinstall (or an old app build) carries its
-    // own persisted device id, so the same physical machine re-registers
-    // under a fresh identity and the old entry lingers forever as an offline
-    // ghost. Same name + platform under a different id, currently OFFLINE →
-    // superseded install, drop it. An online doppelganger is kept: two live
-    // devices can legitimately share a name.
-    let evicted = false;
-    for (const [id, d] of this.devices) {
-      if (id === device.id) continue;
-      if (d.name !== device.name || d.platform !== device.platform) continue;
-      if (toDeviceInfo(d, now, PRESENCE_TIMEOUT_MS).online) continue;
-      this.devices.delete(id);
-      this.locations.delete(id);
-      this.history.delete(id);
-      evicted = true;
-    }
-    if (this.enforceDeviceCap()) evicted = true;
+    const evicted = this.enforceDeviceCap();
     await this.persistDevices();
     if (evicted) {
       await this.persistLocations();

package/src/core/mesh/devices/service.ts

@@ -877,6 +877,7 @@ export class MeshService {
       const q = raw.toLowerCase();
       const byId = devices.find((d) => d.id.toLowerCase() === q);
       if (byId) return { target: byId };
+
       const fold = (s: string): string =>
         s.toLowerCase().replace(/[^a-z0-9]+/g, "");
       const folded = fold(raw);
@@ -885,6 +886,7 @@ export class MeshService {
       ): { target: DeviceInfo } | { error: string } | undefined => {
         if (candidates.length === 1) return { target: candidates[0]! };
         if (candidates.length > 1) {
+          const exactNames = new Set(candidates.map((d) => fold(d.name)));
           const online = candidates.filter((d) => d.online);
           if (online.length === 1) return { target: online[0]! };
           return {
@@ -893,13 +895,32 @@ export class MeshService {
                 (d) =>
                   `${d.name} [id: ${d.id}, ${d.online ? "online" : "offline"}]`,
               )
-              .join(", ")}. Use the device id or full name.`,
+              .join(
+                ", ",
+              )}. Use the device id${exactNames.size > 1 ? " or full name" : ""}.`,
           };
         }
         return undefined;
       };
+
+      const exactMatch = pick(devices.filter((d) => fold(d.name) === folded));
+      if (exactMatch) return exactMatch;
+
+      if (q.length >= 6) {
+        const byPrefix = devices.filter((d) =>
+          d.id.toLowerCase().startsWith(q),
+        );
+        if (byPrefix.length === 1) return { target: byPrefix[0]! };
+        if (byPrefix.length > 1) {
+          return {
+            error: `Device id prefix "${raw}" matches ${byPrefix.length} devices: ${byPrefix
+              .map((d) => `${d.name} [id: ${d.id}]`)
+              .join(", ")}. Provide more characters of the id.`,
+          };
+        }
+      }
+
       return (
-        pick(devices.filter((d) => fold(d.name) === folded)) ??
         (folded
           ? pick(devices.filter((d) => fold(d.name).includes(folded)))
           : undefined) ?? { error: this.noSuchDevice(query).text }