talon-agent 1.40.2 → 1.42.0

package/package.json

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

package/src/backend/codex/handler/events.ts

@@ -23,7 +23,11 @@ export interface HandleEventContext {
   seenToolCallIds: Set<string>;
   codexToolMetrics: { count: number };
   onTextBlock?: (text: string) => Promise<void>;
-  onToolUse?: (toolName: string, input: Record<string, unknown>) => void;
+  onToolUse?: (
+    toolName: string,
+    input: Record<string, unknown>,
+    meta?: { failed?: boolean },
+  ) => void;
   chatId: string;
 }
 
@@ -148,7 +152,7 @@ function handleMcpToolCall(
     // flip) that assume a successful call.
     if (ctx.onToolUse) {
       try {
-        ctx.onToolUse(toolName, input);
+        ctx.onToolUse(toolName, input, { failed: true });
       } catch {
         /* non-fatal */
       }

package/src/backend/shared/handler-to-events.ts

@@ -104,14 +104,23 @@ export async function* handlerToEvents(
       // deltas restart from empty.
       lastAccumulated = "";
     },
-    onToolUse: (toolName, input) => {
+    onToolUse: (toolName, input, meta) => {
+      const id = `${toolName}-${Date.now()}-${Math.random()
+        .toString(36)
+        .slice(2, 8)}`;
+      emit({ type: "tool_call", id, name: toolName, input });
+      // Callback backends (Codex, OpenCode, Kilo, OpenAI Agents) surface a
+      // tool call only at terminal status — by the time onToolUse fires,
+      // the tool has already finished. Emit the matching `tool_result`
+      // immediately so consumers see the same call→result contract the
+      // Claude SDK backend emits. Without it, tool spinners opened on
+      // `tool_call` hang until the end-of-turn flush — on a long Codex
+      // grind that reads as "running forever" in the companion app.
       emit({
-        type: "tool_call",
-        id: `${toolName}-${Date.now()}-${Math.random()
-          .toString(36)
-          .slice(2, 8)}`,
+        type: "tool_result",
+        id,
         name: toolName,
-        input,
+        ...(meta?.failed ? { error: "tool call failed" } : {}),
       });
     },
   };

package/src/backend/shared/handler-types.ts

@@ -43,7 +43,17 @@ export type QueryParams = {
   retrievedMemory?: RetrievedMemory;
   onStreamDelta?: (accumulated: string, phase?: "thinking" | "text") => void;
   onTextBlock?: (text: string) => Promise<void>;
-  onToolUse?: (toolName: string, input: Record<string, unknown>) => void;
+  /**
+   * Callback backends report a tool call as one already-resolved unit —
+   * their SDKs surface it at (or after) terminal status, with no separate
+   * start/finish pair. `meta.failed` marks a call whose terminal status was
+   * an error, so consumers can render it as failed rather than successful.
+   */
+  onToolUse?: (
+    toolName: string,
+    input: Record<string, unknown>,
+    meta?: { failed?: boolean },
+  ) => void;
 };
 
 /** Result of a backend AI query. */

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/engine/gateway-actions/native.ts

@@ -16,6 +16,7 @@
  */
 
 import { spawn } from "node:child_process";
+import { closeSync, openSync } from "node:fs";
 import {
   glob as fsGlob,
   mkdir,
@@ -23,6 +24,7 @@ import {
   stat as fsStat,
   writeFile,
 } from "node:fs/promises";
+import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { getMeshService } from "../../mesh/index.js";
 import {
@@ -50,6 +52,23 @@ function rgBin(): string {
 }
 const DEFAULT_EXEC_TIMEOUT_MS = 60_000;
 const MAX_EXEC_TIMEOUT_MS = 300_000;
+/** Grace between SIGTERM and SIGKILL on timeout, so pipelines can flush. */
+const KILL_GRACE_MS = 2_000;
+/** How long a background launch waits to catch fast failures. */
+const BACKGROUND_SETTLE_MS = 1_200;
+/** Where background job output lands (one log file per job). */
+const BACKGROUND_LOG_DIR = join(tmpdir(), "talon-bash");
+/** Appended to a timed-out bash result so the model self-corrects. */
+const TIMEOUT_HINT =
+  "(Streaming/never-ending commands — adb logcat, tail -f, dev servers, watchers — " +
+  "will always hit this wall. Re-run with background:true to launch it detached with " +
+  "output captured to a log file, or bound the command itself: `adb logcat -d`, " +
+  "`timeout 30 …`, `head -n 200`.)";
+/** Same self-correction hint, phrased for a teleported (on-device) run. */
+const TELEPORT_TIMEOUT_HINT =
+  "(Streaming/never-ending commands can't ride a teleported foreground call — " +
+  "background it in-shell instead: `cmd > /tmp/out.log 2>&1 &`, then poll the log " +
+  "with read, or bound the command itself: `logcat -d`, `timeout 30 …`, `head -n 200`.)";
 const MAX_READ_LINES = 2_000;
 /** Caps for the pure-JS glob/search fallbacks (rg unavailable). */
 const MAX_JS_RESULTS = 2_000;
@@ -63,7 +82,7 @@ export const nativeHandlers: SharedActionHandlers = {
   teleport: (body, chatId) => teleport(chatId, body.device),
   teleport_back: (_body, chatId) => teleportBack(chatId),
   native_bash: (body, chatId) =>
-    bash(chatId, body.command, body.cwd, body.timeout_sec),
+    bash(chatId, body.command, body.cwd, body.timeout_sec, body.background),
   native_read: (body, chatId) =>
     read(chatId, body.path, body.offset, body.limit),
   native_write: (body, chatId) => write(chatId, body.path, body.content),
@@ -122,15 +141,138 @@ async function bash(
   command: unknown,
   cwd: unknown,
   timeoutSec: unknown,
+  background?: unknown,
 ): Promise<Result> {
   const cmd = typeof command === "string" ? command : "";
   if (!cmd.trim()) return { ok: false, text: "No command given." };
   const timeoutMs = clampTimeout(timeoutSec);
   const active = await getTeleport(chatId);
+  if (background === true) {
+    if (active) {
+      return {
+        ok: false,
+        text:
+          "background:true runs on the daemon host only. On a teleported device, " +
+          "background it in-shell instead: `cmd > /tmp/out.log 2>&1 &`, then poll " +
+          "the log with read.",
+      };
+    }
+    return bashBackground(cmd, typeof cwd === "string" ? cwd : undefined);
+  }
   if (active) return bashTeleported(chatId, active.deviceId, cmd, timeoutMs);
   return bashLocal(cmd, typeof cwd === "string" ? cwd : undefined, timeoutMs);
 }
 
+/**
+ * Launch a command detached from the request cycle: its own process group,
+ * stdout+stderr appended to a per-job log file, tool returns immediately.
+ * This is the sanctioned path for streaming/long-running commands (adb
+ * logcat, dev servers, watchers) that would otherwise burn the whole
+ * foreground timeout and come back "killed".
+ *
+ * A short settle window catches fast failures (typo'd binary, instant
+ * non-zero exit) so those still surface as a normal error instead of a
+ * "started" message pointing at a log with one line in it.
+ */
+async function bashBackground(
+  cmd: string,
+  cwd: string | undefined,
+): Promise<Result> {
+  // The background contract is POSIX-shaped end to end: detached process
+  // group, `kill -- -pid` to stop, survives daemon restarts. Windows has
+  // none of those (and the CI legs showed the detached writer's output not
+  // reaching the log) — refuse loudly with the native alternative instead
+  // of pretending.
+  if (process.platform === "win32") {
+    return {
+      ok: false,
+      text:
+        "background:true needs POSIX process groups and isn't supported on a Windows " +
+        "daemon host. Run it foreground with a bound command (`timeout 30 …`, `head -n 200`) " +
+        "or start it yourself: `powershell Start-Process -WindowStyle Hidden` with output redirected to a file.",
+    };
+  }
+  try {
+    await mkdir(BACKGROUND_LOG_DIR, { recursive: true });
+  } catch (err) {
+    return {
+      ok: false,
+      text: `Cannot create log dir ${BACKGROUND_LOG_DIR}: ${(err as Error).message}`,
+    };
+  }
+  const slug =
+    cmd
+      .replace(/[^a-zA-Z0-9]+/g, "-")
+      .replace(/^-+|-+$/g, "")
+      .slice(0, 40) || "job";
+  const logPath = join(BACKGROUND_LOG_DIR, `${Date.now()}-${slug}.log`);
+  let fd: number;
+  try {
+    fd = openSync(logPath, "a");
+  } catch (err) {
+    return {
+      ok: false,
+      text: `Cannot open log file ${logPath}: ${(err as Error).message}`,
+    };
+  }
+  // Always detached: the win32 guard above returned already, so this only
+  // runs on POSIX where the job gets its own process group.
+  const child = spawn("bash", ["-c", cmd], {
+    ...(cwd ? { cwd } : {}),
+    env: process.env,
+    detached: true,
+    stdio: ["ignore", fd, fd],
+  });
+  return new Promise((resolvePromise) => {
+    let settled = false;
+    const done = (r: Result) => {
+      if (settled) return;
+      settled = true;
+      try {
+        closeSync(fd);
+      } catch {
+        // parent's dup only; the child keeps its own copy either way
+      }
+      resolvePromise(r);
+    };
+    child.on("error", (err) =>
+      done({ ok: false, text: `Failed to start: ${err.message}` }),
+    );
+    // Fast failure inside the settle window → report it like a normal run.
+    child.on("close", (code) => {
+      void (async () => {
+        let logged = "";
+        try {
+          logged = await readFile(logPath, "utf8");
+        } catch {
+          // log unreadable — report the exit alone
+        }
+        done({
+          ok: (code ?? 0) === 0,
+          text:
+            `Background command exited almost immediately (exit ${code ?? 0}).\n` +
+            renderExec("local", `exit ${code ?? 0}`, logged, "") +
+            `\nFull log: ${logPath}`,
+        });
+      })();
+    });
+    setTimeout(() => {
+      if (settled) return;
+      child.unref();
+      done({
+        ok: true,
+        text: [
+          `🚀 Started in background [local] — pid ${child.pid}.`,
+          `Output (stdout+stderr) → ${logPath}`,
+          `Follow it with read/bash (e.g. \`tail -n 50 ${logPath}\`).`,
+          `Stop it with \`kill -- -${child.pid}\` (whole process group).`,
+          `Unsupervised: it keeps running until it exits or is killed — it even survives a Talon restart.`,
+        ].join("\n"),
+      });
+    }, BACKGROUND_SETTLE_MS);
+  });
+}
+
 function bashLocal(
   cmd: string,
   cwd: string | undefined,
@@ -148,32 +290,76 @@ function bashLocal(
     const stdout = createOutputCapture();
     const stderr = createOutputCapture();
     let killed = false;
-    const timer = setTimeout(() => {
-      killed = true;
+    // Timeout escalation: SIGTERM the whole process group first (lets
+    // pipelines flush + children clean up), SIGKILL any survivors after a
+    // short grace. Straight-to-SIGKILL used to eat buffered output.
+    const killTree = (signal: NodeJS.Signals) => {
       if (detached && child.pid) {
         try {
-          process.kill(-child.pid, "SIGKILL");
+          process.kill(-child.pid, signal);
           return;
         } catch {
           // group already gone — fall through to the direct kill
         }
       }
-      child.kill("SIGKILL");
+      try {
+        child.kill(signal);
+      } catch {
+        // already dead
+      }
+    };
+    let settled = false;
+    let killTimer: NodeJS.Timeout | undefined;
+    let forceTimer: NodeJS.Timeout | undefined;
+    const finish = (r: Result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (killTimer) clearTimeout(killTimer);
+      if (forceTimer) clearTimeout(forceTimer);
+      resolvePromise(r);
+    };
+    const timedOutResult = () => {
+      const body = renderExec(
+        "local",
+        `⏱️ timed out after ${timeoutMs / 1000}s — killed; partial output kept below`,
+        stdout.value(),
+        stderr.value(),
+      );
+      return { ok: false, text: `${body}\n${TIMEOUT_HINT}` };
+    };
+    const timer = setTimeout(() => {
+      killed = true;
+      killTree("SIGTERM");
+      killTimer = setTimeout(() => killTree("SIGKILL"), KILL_GRACE_MS);
+      // `close` waits for the stdio pipes to drain — a surviving grandchild
+      // that inherited stdout (Windows has no process groups; a detached
+      // POSIX grandchild can escape the group kill) would otherwise hold
+      // this promise open long past the timeout. Force-resolve with the
+      // partial output once the escalation window has passed.
+      forceTimer = setTimeout(
+        () => finish(timedOutResult()),
+        KILL_GRACE_MS + 1_000,
+      );
     }, timeoutMs);
     child.stdout.on("data", stdout.push);
     child.stderr.on("data", stderr.push);
     child.on("error", (err) => {
-      clearTimeout(timer);
-      resolvePromise({ ok: false, text: `Failed to run: ${err.message}` });
+      finish({ ok: false, text: `Failed to run: ${err.message}` });
     });
     child.on("close", (code) => {
-      clearTimeout(timer);
-      const exit = killed
-        ? `killed (timeout ${timeoutMs / 1000}s)`
-        : `exit ${code ?? 0}`;
-      resolvePromise({
-        ok: !killed && (code ?? 0) === 0,
-        text: renderExec("local", exit, stdout.value(), stderr.value()),
+      if (killed) {
+        finish(timedOutResult());
+        return;
+      }
+      finish({
+        ok: (code ?? 0) === 0,
+        text: renderExec(
+          "local",
+          `exit ${code ?? 0}`,
+          stdout.value(),
+          stderr.value(),
+        ),
       });
     });
   });
@@ -225,14 +411,19 @@ async function bashTeleported(
       text: result.message ?? `${target.name} could not run the command.`,
     };
   }
+  // The device marks a command it had to kill at its own exec budget with
+  // this stderr marker (see the companion's device_exec) — surface the same
+  // self-correction hint the local timeout path gets.
+  const timedOutOnDevice = stderr.includes("[killed: timeout]");
+  const body = renderExec(
+    `${target.name}${via}`,
+    `exit ${exitCode ?? "?"}`,
+    stdout,
+    stderr,
+  );
   return {
     ok: exitCode === 0,
-    text: renderExec(
-      `${target.name}${via}`,
-      `exit ${exitCode ?? "?"}`,
-      stdout,
-      stderr,
-    ),
+    text: timedOutOnDevice ? `${body}\n${TELEPORT_TIMEOUT_HINT}` : body,
   };
 }
 
@@ -330,7 +521,12 @@ async function edit(
   }
 
   const count = from ? content.split(from).length - 1 : 0;
-  if (count === 0) return { ok: false, text: `old_string not found in ${p}.` };
+  if (count === 0) {
+    return {
+      ok: false,
+      text: `old_string not found in ${p}.${nearMissHint(content, from)}`,
+    };
+  }
   if (count > 1 && replaceAll !== true) {
     return {
       ok: false,
@@ -536,6 +732,28 @@ async function searchJs(
   return lines;
 }
 
+/**
+ * When an edit's old_string doesn't match verbatim, the cause is almost
+ * always invisible: indentation, tabs vs spaces, or a trailing space. Point
+ * at the closest-looking line so the model re-reads that region instead of
+ * blindly retrying the same string.
+ */
+function nearMissHint(content: string, from: string): string {
+  const probe =
+    from
+      .split("\n")
+      .map((l) => l.trim())
+      .find((l) => l.length >= 8) ?? from.trim();
+  if (!probe) return "";
+  const lines = content.split("\n");
+  const idx = lines.findIndex((l) => l.trim().includes(probe));
+  if (idx === -1) return "";
+  return (
+    `\nLine ${idx + 1} looks close — whitespace/indentation must match the file byte-for-byte. ` +
+    `Re-read that region before retrying:\n${String(idx + 1).padStart(6)}\t${lines[idx]}`
+  );
+}
+
 // ── helpers ─────────────────────────────────────────────────────────────────
 
 function runLocal(

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."),

package/src/core/tools/native.ts

@@ -38,7 +38,8 @@ export const nativeTools: ToolDefinition[] = [
   {
     name: "bash",
     description:
-      "Run a shell command. Runs on the daemon host, or ON the active teleport device if one is engaged. On a teleported device, `cd` persists across calls (a real working-directory session).",
+      "Run a shell command. Runs on the daemon host, or ON the active teleport device if one is engaged. On a teleported device, `cd` persists across calls (a real working-directory session). " +
+      "Foreground runs are killed at timeout_sec — for streaming/never-ending commands (adb logcat, tail -f, dev servers, watchers) set background:true instead: the command is launched detached in its own process group with stdout+stderr captured to a log file, and the tool returns immediately with the pid + log path so you can poll the log and kill it when done.",
     schema: {
       command: z.string().describe("The shell command to run."),
       cwd: z
@@ -51,7 +52,13 @@ export const nativeTools: ToolDefinition[] = [
         .number()
         .optional()
         .describe(
-          "Max seconds before the command is killed (default 60, max 300).",
+          "Max seconds before a foreground command is killed (default 60, max 300). Ignored with background:true.",
+        ),
+      background: z
+        .boolean()
+        .optional()
+        .describe(
+          "Launch detached and return immediately with pid + log file path (local runs only). Use for streaming or long-running commands that would otherwise time out.",
         ),
     },
     execute: (params, bridge) => bridge("native_bash", params),

package/src/frontend/native/index.ts

@@ -539,9 +539,11 @@ export function createNativeFrontend(
     const turnTools = new Map<string, LiveToolEntry>();
     liveTurns.set(entry.id, turnTools);
     // Safety net: any tool the backend announced but never resolved
-    // (text-mode backends don't emit tool_result; crashes can eat one)
-    // gets a synthetic result at turn end — a spinner the app opened
-    // on phase:"call" must always see a phase:"result".
+    // (a crash can eat a tool_result; callback backends historically
+    // never emitted one — handler-to-events now pairs each tool_call
+    // with an immediate synthetic result) gets a synthetic result at
+    // turn end — a spinner the app opened on phase:"call" must always
+    // see a phase:"result".
     const flushOpenTools = () => {
       for (const [id, live] of turnTools) {
         if (live.done) continue;