talon-agent 1.40.2 → 1.41.0

package/package.json

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

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

@@ -18,6 +18,9 @@ export const meshHandlers: SharedActionHandlers = {
   get_device_history: (body) =>
     getMeshService().deviceHistory(body.device, body.hours),
   ring_device: (body) => getMeshService().ringDevice(body.device, 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),
   // Exec + filesystem surface — the substrate teleport routes through.
   device_exec: (body) =>

package/src/core/mesh/registry.ts

@@ -91,10 +91,48 @@ 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;
+    }
     await this.persistDevices();
+    if (evicted) {
+      await this.persistLocations();
+      await this.persistHistory();
+    }
     return device;
   }
 
+  /**
+   * Drop a device (and its location + history) from the registry. Returns
+   * the removed device, or undefined when the id is unknown. Note a still-
+   * connected companion re-registers on its next heartbeat — removal is for
+   * stale entries.
+   */
+  async removeDevice(deviceId: string): Promise<DeviceInfo | undefined> {
+    const device = this.devices.get(deviceId);
+    if (!device) return undefined;
+    this.devices.delete(deviceId);
+    const hadLocation = this.locations.delete(deviceId);
+    const hadHistory = this.history.delete(deviceId);
+    await this.persistDevices();
+    if (hadLocation) await this.persistLocations();
+    if (hadHistory) await this.persistHistory();
+    return toDeviceInfo(device, device.lastSeen);
+  }
+
   async storeLocation(
     body: Record<string, unknown>,
     now = Date.now(),

package/src/core/mesh/service.ts

@@ -340,6 +340,36 @@ export class MeshService {
     return { ok: true, text: this.locationSummary(target, loc) };
   }
 
+  /**
+   * `remove_device`: drop a stale device from the mesh registry (with its
+   * location + history). Destructive, so it requires an explicit target —
+   * no "default to the most recent device" like the read tools.
+   */
+  async removeDevice(query?: unknown): Promise<MeshToolResult> {
+    await this.load();
+    if (typeof query !== "string" || !query.trim()) {
+      return {
+        ok: false,
+        text: "remove_device needs an explicit device id or name — there is no default target for a destructive operation. See list_devices.",
+      };
+    }
+    const resolved = this.resolveDevice(query);
+    if ("error" in resolved) return { ok: false, text: resolved.error };
+    const target = resolved.target;
+    const removed = await this.registry.removeDevice(target.id);
+    if (!removed) {
+      return { ok: false, text: this.noSuchDevice(query).text };
+    }
+    return {
+      ok: true,
+      text:
+        `Removed ${removed.name} [id: ${removed.id}] (${removed.platform}, last seen ${age(Date.now() - removed.lastSeen)}) from the mesh registry.` +
+        (target.online
+          ? " Note: it was still online — a connected companion re-registers within ~60s, so quit the app first if it keeps coming back."
+          : ""),
+    };
+  }
+
   /** `ring_device`: make the device sound/vibrate so it can be found. */
   ringDevice(query?: unknown, message?: unknown): Promise<MeshToolResult> {
     return this.commandTool(query, "ring", {

package/src/core/tools/mesh.ts

@@ -60,6 +60,20 @@ export const meshTools: ToolDefinition[] = [
     execute: (params, bridge) => bridge("ring_device", params),
     tag: "mesh",
   },
+  {
+    name: "remove_device",
+    description:
+      "Remove a stale device from the mesh registry (with its stored location and history). Use for superseded installs and old duplicates — e.g. a reinstalled companion that re-registered under a new id, leaving the old entry as an offline ghost. Requires an explicit device id or name (no default target). Removing a still-connected device is pointless: it re-registers on its next heartbeat within ~60s.",
+    schema: {
+      device: z
+        .string()
+        .describe(
+          "Device id, exact name, or unique name fragment of the entry to remove (see list_devices). Prefer the id when duplicates share a name.",
+        ),
+    },
+    execute: (params, bridge) => bridge("remove_device", params),
+    tag: "mesh",
+  },
   {
     name: "get_device_status",
     description:
@@ -71,7 +85,7 @@ export const meshTools: ToolDefinition[] = [
   {
     name: "device_exec",
     description:
-      "Run a shell command ON a Talon companion device (e.g. the phone) and return its stdout/stderr/exit code. The device executes it in its own sandbox (Android: app UID, or elevated via Shizuku if available). Use for on-device tasks like tidying a folder. Prefer `teleport` for a sustained session.",
+      "Run a shell command ON a Talon companion device (e.g. the phone) and return its stdout/stderr/exit code. The device executes it in its own sandbox (Android: app UID, or elevated via Shizuku if available). Use for on-device tasks like tidying a folder. Prefer `teleport` for a sustained session. For persistent streams (log tailing, watchers), background with output redirected to a file — `cmd > /tmp/out.log 2>&1 &` returns immediately; poll the file with device_read_file.",
     schema: {
       device: deviceParam,
       cmd: z.string().describe("The shell command to run on the device."),