talon-agent 4.2.0 → 4.3.0

package/README.md

@@ -328,7 +328,7 @@ On first boot Talon creates a venv at `~/.talon/mempalace-venv` and installs the
     "backend": "mempalace",
     "mempalace": {
       "palacePath": "~/.talon/workspace/palace",
-      "version": "3.9.0",
+      "version": "3.10.0",
       "autoUpdate": true,
       "autoProvision": true
     }

package/package.json

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

package/src/cli/setup.ts

@@ -29,14 +29,20 @@ const trimmedOrUndefined = (raw: string) => raw.trim() || undefined;
  * the unguarded remainder still needed an `as string` cast. clack only
  * ever resolves a symbol to mean "cancelled", so narrowing on `typeof`
  * here removes both.
+ *
+ * The answer type is subtracted with `Exclude` rather than inferred from a
+ * `Promise<T | symbol>` parameter: clack 1.8.1 retyped `CANCEL_SYMBOL` as a
+ * `unique symbol`, which no longer cancels out against a plain `symbol` in
+ * the target, so every caller inferred `T` as the whole `answer | symbol`
+ * union and leaked the symbol into the config.
  */
-async function askOrExit<T>(prompt: Promise<T | symbol>): Promise<T> {
+async function askOrExit<T>(prompt: Promise<T>): Promise<Exclude<T, symbol>> {
   const value = await prompt;
   if (typeof value === "symbol") {
     p.cancel("Cancelled.");
     process.exit(0);
   }
-  return value;
+  return value as Exclude<T, symbol>;
 }
 
 // ── Steps: each prompts for one section and returns its slice of the answers ──

package/src/core/engine/cross-chat-relay.ts

@@ -0,0 +1,125 @@
+/**
+ * Cross-chat relay — keeps the session that sent a message somewhere
+ * else aware of what came back.
+ *
+ * `send_via` lets a Telegram session message a WhatsApp number. The
+ * reply, though, lands in the WhatsApp chat: a different chat id, a
+ * different session, a different history. The session that started the
+ * exchange never learns how it went, so the next thing it says about
+ * it is a guess — it "sent the message" and then goes blind.
+ *
+ * So a cross-send subscribes the sending chat to the target chat for a
+ * while. Inbound messages on the target are queued for each subscriber
+ * and folded into the front of that chat's next turn, the same way a
+ * person glancing at their other phone would have seen the reply before
+ * answering you.
+ *
+ * Deliberately passive: the queued reply waits for the origin chat's
+ * next turn rather than waking it. The target chat usually has its own
+ * live session already handling that message — waking the origin too
+ * would mean two sessions independently reacting to one reply, and an
+ * unprompted Telegram message every time someone answers on WhatsApp.
+ *
+ * State is in-memory on purpose. A subscription is a fact about a
+ * conversation in flight; after a restart there is no turn waiting for
+ * the reply, and a relayed line from before the restart would arrive
+ * with no context to attach to.
+ */
+
+/** How long a cross-send keeps the sender subscribed to replies. */
+export const RELAY_TTL_MS = 6 * 60 * 60 * 1000;
+
+/** Most queued lines held for one chat — a burst can't flood a prompt. */
+export const RELAY_MAX_PENDING = 20;
+
+/** Longest single relayed message; the rest is elided. */
+export const RELAY_MAX_TEXT = 600;
+
+/** target chat id → origin chat id → time of the last cross-send. */
+const subscribers = new Map<string, Map<string, number>>();
+
+/** origin chat id → relayed lines waiting for its next turn. */
+const pending = new Map<string, string[]>();
+
+/**
+ * Record that `origin` sent into `target`, subscribing it to replies.
+ * A repeat send refreshes the window rather than adding a second entry.
+ */
+export function noteCrossSend(origin: string, target: string): void {
+  // Sending into your own chat is not a cross-send; subscribing would
+  // relay a chat's own inbound messages back into itself.
+  if (!origin || !target || origin === target) return;
+  const forTarget = subscribers.get(target) ?? new Map<string, number>();
+  forTarget.set(origin, Date.now());
+  subscribers.set(target, forTarget);
+}
+
+/**
+ * An inbound message arrived on `target`. Queue it for every chat still
+ * subscribed, and return how many were notified (0 when nobody is
+ * listening, which is the overwhelmingly common case).
+ */
+export function relayInbound(
+  target: string,
+  senderName: string,
+  text: string,
+): number {
+  const forTarget = subscribers.get(target);
+  if (!forTarget?.size) return 0;
+  const now = Date.now();
+  const body =
+    text.length > RELAY_MAX_TEXT
+      ? `${text.slice(0, RELAY_MAX_TEXT)}… (truncated)`
+      : text;
+  let notified = 0;
+  for (const [origin, at] of forTarget) {
+    // Expiry is evaluated here rather than on a timer: the map is small,
+    // and a sweep that never runs can't leak a stale subscription.
+    if (now - at > RELAY_TTL_MS) {
+      forTarget.delete(origin);
+      continue;
+    }
+    const queue = pending.get(origin) ?? [];
+    queue.push(`${senderName} (in ${target}): ${body}`);
+    if (queue.length > RELAY_MAX_PENDING) {
+      queue.splice(0, queue.length - RELAY_MAX_PENDING);
+    }
+    pending.set(origin, queue);
+    notified++;
+  }
+  if (!forTarget.size) subscribers.delete(target);
+  return notified;
+}
+
+/**
+ * Drain everything queued for `chatId`. Draining is the point: each
+ * relayed line is folded into exactly one turn, so a long conversation
+ * doesn't re-read the same reply on every subsequent prompt.
+ */
+export function takePendingRelay(chatId: string): string[] {
+  const queue = pending.get(chatId);
+  if (!queue?.length) return [];
+  pending.delete(chatId);
+  return queue;
+}
+
+/**
+ * Render drained lines as the block that goes in front of a prompt.
+ * Returns "" when there is nothing, so callers can concatenate blindly.
+ */
+export function formatRelayBlock(lines: readonly string[]): string {
+  if (!lines.length) return "";
+  return (
+    `[Cross-chat: ${lines.length} new message(s) arrived in a chat this ` +
+    `session messaged. You have not replied to these — decide whether they ` +
+    `need one.]\n` +
+    lines.map((l) => `- ${l}`).join("\n") +
+    "\n\n"
+  );
+}
+
+/** Test seam: drop all subscriptions and queued lines. */
+export function resetCrossChatRelay(): void {
+  subscribers.clear();
+  pending.clear();
+}

package/src/core/engine/dispatcher.ts

@@ -9,6 +9,7 @@
  */
 
 import type { ExecuteParams, ExecuteResult } from "../types.js";
+import { formatRelayBlock, takePendingRelay } from "./cross-chat-relay.js";
 import { log } from "../../util/log.js";
 import { taskTable, type KillOutcome } from "../tasks/index.js";
 import { initWeaver, type Weaver, type WeaverDeps } from "../weaver/index.js";
@@ -66,8 +67,16 @@ export function stopAllTurns(): number {
  * Execute an AI query with full lifecycle management.
  * Same-chat queries are serialized (FIFO) to avoid session conflicts.
  * Different-chat queries run in true parallel.
+ *
+ * Every turn for every frontend and every source funnels through here,
+ * which makes it the one place a cross-chat reply can be folded in
+ * without teaching each frontend about the relay.
  */
 export async function execute(params: ExecuteParams): Promise<ExecuteResult> {
   if (!weaver) throw new Error("Dispatcher not initialized");
-  return weaver.runTurn(params);
+  const relayed = takePendingRelay(params.chatId);
+  const prompt = relayed.length
+    ? formatRelayBlock(relayed) + params.prompt
+    : params.prompt;
+  return weaver.runTurn(relayed.length ? { ...params, prompt } : params);
 }

package/src/core/engine/gateway-actions/cross-send.ts

@@ -26,6 +26,7 @@
  */
 
 import type { FrontendActionHandler } from "../../types.js";
+import { noteCrossSend } from "../cross-chat-relay.js";
 import type { SharedActionHandlers } from "./types.js";
 
 const targets = new Map<string, FrontendActionHandler>();
@@ -188,6 +189,14 @@ export const crossSendHandlers: SharedActionHandlers = {
         error: `send_via: the ${frontend} frontend does not implement ${action}`,
       };
     }
+    // Subscribe the calling session to whatever comes back. `_chatId` is
+    // the bridge's own caller tag, and the frontend reports the canonical
+    // id it resolved — a phone number is not a chat id, so without that
+    // report there would be nothing to subscribe to.
+    if (result.ok) {
+      const origin = body._chatId ? String(body._chatId) : "";
+      noteCrossSend(origin, result.chat_id ?? target);
+    }
     return result;
   },
 };

package/src/core/mesh/device-files.ts

@@ -61,8 +61,53 @@ export interface DeviceFilesHost {
  * fallback tolerable without bloating a single SSE frame too far.
  */
 const FILE_CHUNK_BYTES = 1024 * 1024;
-/** Wall-clock budget for one streamed transfer (command dispatch → done). */
-const STREAM_TRANSFER_TIMEOUT_MS = 60 * 60 * 1000;
+/**
+ * Wall-clock budget for one streamed transfer (command dispatch → done).
+ *
+ * A device that accepts the transfer command and then goes silent answers
+ * never: a stalled body stream on a flaky mobile link delivers neither
+ * bytes nor a FIN, so the device-side `await` for the body never completes
+ * and never throws, and the command result it would have posted afterwards
+ * is never posted. The dispatch timeout is the only thing that ends that
+ * wait — and since turns serialize per chat, the whole chat's message loop
+ * queues behind it. A flat hour therefore takes a chat offline for an hour
+ * over one dropped TCP connection.
+ *
+ * So the budget is sized to the payload instead: a fixed grace for the
+ * handshake and device-side setup, plus the body at a deliberately
+ * pessimistic floor throughput, clamped at both ends. A genuinely slow
+ * link still finishes; a dead one gives up in minutes.
+ */
+const STREAM_TRANSFER_GRACE_MS = 60_000;
+const STREAM_TRANSFER_FLOOR_BYTES_PER_SEC = 32 * 1024;
+/**
+ * Ceiling, so a payload large enough to out-scale the formula still can't
+ * block a chat indefinitely. Deliberately well above what a big transfer
+ * over a slow link needs — the common wedge is a SMALL transfer that used
+ * to inherit the same budget as a huge one, and that case now resolves in
+ * about a minute.
+ */
+const STREAM_TRANSFER_MAX_MS = 30 * 60 * 1000;
+
+/**
+ * Budget for streaming `bytes` to or from a device. An unknown size — a
+ * pull whose caller has not already paid for a `stat` — takes the ceiling
+ * rather than an extra mesh round trip to size a budget with: still
+ * bounded, just less tightly. Either way the device-side idle timeout
+ * normally answers long before this fires; this is the backstop for a
+ * device that has stopped answering altogether.
+ */
+export function streamTransferTimeoutMs(bytes?: number): number {
+  if (bytes === undefined || !Number.isFinite(bytes)) {
+    return STREAM_TRANSFER_MAX_MS;
+  }
+  const forBody =
+    (Math.max(0, bytes) / STREAM_TRANSFER_FLOOR_BYTES_PER_SEC) * 1000;
+  return Math.min(
+    Math.round(STREAM_TRANSFER_GRACE_MS + forBody),
+    STREAM_TRANSFER_MAX_MS,
+  );
+}
 /** readFileBytes switches to the streaming path above this size. */
 const STREAM_READ_THRESHOLD_BYTES = 4 * 1024 * 1024;
 /**
@@ -134,13 +179,14 @@ export class DeviceFiles {
     target: DeviceInfo,
     remote: string,
     dest: string,
+    sizeHint?: number,
   ): Promise<{ bytes: number } | { error: string }> {
     const { token, done } = this.transfers.createPull(target.id, dest);
     const dispatched = await this.host.dispatchCommand(
       target.id,
       "upload_file",
       { token, path: remote },
-      STREAM_TRANSFER_TIMEOUT_MS,
+      streamTransferTimeoutMs(sizeHint),
     );
     if ("error" in dispatched) {
       this.transfers.cancel(token);
@@ -203,7 +249,7 @@ export class DeviceFiles {
       const size = await this.statSize(target.id, p);
       if (size !== undefined && size > STREAM_READ_THRESHOLD_BYTES) {
         const tmp = join(tmpdir(), `talon-pull-${randomUUID()}-${basename(p)}`);
-        const pulled = await this.pullViaStream(target, p, tmp);
+        const pulled = await this.pullViaStream(target, p, tmp, size);
         if ("error" in pulled) return { error: pulled.error };
         try {
           const data = await readFile(tmp);
@@ -338,12 +384,19 @@ export class DeviceFiles {
     const target = resolved.target;
     if (this.canStream(target, "download_file")) {
       const started = Date.now();
+      // The source is on this host, so sizing the budget costs a local stat
+      // rather than a mesh round trip. A source we cannot stat still gets a
+      // bounded (if looser) budget — this decides a timeout, not whether
+      // the transfer is allowed to start.
+      const localSize = await stat(local)
+        .then((s) => s.size)
+        .catch(() => undefined);
       const { token } = this.transfers.createPush(target.id, local);
       const dispatched = await this.host.dispatchCommand(
         target.id,
         "download_file",
         { token, path: remote },
-        STREAM_TRANSFER_TIMEOUT_MS,
+        streamTransferTimeoutMs(localSize),
       );
       if ("error" in dispatched) {
         this.transfers.cancel(token);

package/src/core/mesh/service.ts

@@ -82,6 +82,8 @@ export type MeshServiceOptions = {
   pollIntervalMs?: number;
   /** How long a device command waits for its result before timing out. */
   commandTimeoutMs?: number;
+  /** How often a long command re-checks that its device is still present. */
+  presenceWatchIntervalMs?: number;
   /** Node-binary resolver override (tests — the real one builds/downloads). */
   nodeBinaryResolver?: NodeBinaryResolver;
 };
@@ -100,6 +102,8 @@ const MAX_HISTORY_LINES = 24;
 const DEFAULT_EXEC_TIMEOUT_MS = 60_000;
 /** Hard ceiling on a caller-requested exec timeout. */
 const MAX_EXEC_TIMEOUT_MS = 300_000;
+/** How often a long-running command re-checks that its device is still up. */
+const PRESENCE_WATCH_INTERVAL_MS = 15_000;
 export class MeshService {
   private readonly waiters = new Set<() => void>();
   private readonly transports = new Set<MeshTransport>();
@@ -126,6 +130,7 @@ export class MeshService {
   private readonly freshFixTimeoutMs: number;
   private readonly pollIntervalMs: number;
   private readonly commandTimeoutMs: number;
+  private readonly presenceWatchIntervalMs: number;
   private loading: Promise<void> | null = null;
 
   constructor(
@@ -137,6 +142,8 @@ export class MeshService {
     this.pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
     this.commandTimeoutMs =
       options.commandTimeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS;
+    this.presenceWatchIntervalMs =
+      options.presenceWatchIntervalMs ?? PRESENCE_WATCH_INTERVAL_MS;
     this.resolveNode = options.nodeBinaryResolver ?? resolveNodeBinary;
     this.files = new DeviceFiles({
       load: () => this.load(),
@@ -264,6 +271,38 @@ export class MeshService {
     return true;
   }
 
+  /**
+   * Fail a pending command early when its device stops heartbeating.
+   *
+   * A device that drops mid-command will never answer, so waiting out the
+   * remaining budget only buys silence — and on a transfer budget that
+   * silence is minutes of a tool call, and therefore a chat, wedged behind
+   * a device that is plainly gone. Presence is derived from `lastSeen`, so
+   * this reports one presence grace period after the device goes quiet
+   * rather than instantly; short budgets aren't watched at all, since their
+   * own timeout lands first. Returns a stop function.
+   */
+  private watchPresence(
+    deviceId: string,
+    timeoutMs: number,
+    onGone: (device: DeviceInfo) => void,
+  ): () => void {
+    const every = this.presenceWatchIntervalMs;
+    if (timeoutMs <= every) return () => {};
+    const timer = setInterval(() => {
+      const current = this.registry
+        .list()
+        .devices.find((d) => d.id === deviceId);
+      // Unknown device: leave it to the timeout — an entry evicted from the
+      // registry is not evidence that the device stopped answering.
+      if (!current || current.online) return;
+      clearInterval(timer);
+      onGone(current);
+    }, every);
+    timer.unref?.();
+    return () => clearInterval(timer);
+  }
+
   /**
    * Push one command to a device and await its result (or time out). The
    * low-level primitive under every command tool; exposed for tests and
@@ -282,8 +321,10 @@ export class MeshService {
       params,
     };
     return new Promise<DeviceCommandResult>((resolve) => {
+      let stopWatch: () => void = () => {};
       const timer = setTimeout(() => {
         this.pendingCommands.delete(command.id);
+        stopWatch();
         resolve({
           commandId: command.id,
           deviceId: device.id,
@@ -292,10 +333,21 @@ export class MeshService {
         });
       }, timeoutMs);
       timer.unref?.();
+      stopWatch = this.watchPresence(device.id, timeoutMs, (current) => {
+        if (!this.pendingCommands.delete(command.id)) return;
+        clearTimeout(timer);
+        resolve({
+          commandId: command.id,
+          deviceId: device.id,
+          ok: false,
+          message: `${device.name} went offline (last seen ${age(Date.now() - current.lastSeen)}) before answering "${name}".`,
+        });
+      });
       this.pendingCommands.set(command.id, {
         deviceId: device.id,
         resolve: (result) => {
           clearTimeout(timer);
+          stopWatch();
           resolve(result);
         },
       });

package/src/core/types.ts

@@ -257,6 +257,13 @@ export type ActionResult = {
    * tool calls (react/edit/delete) that target this message.
    */
   message_id?: number | string;
+  /**
+   * The canonical Talon chat id the action actually addressed. Set when
+   * a frontend resolved an explicit `target` (a phone number, a JID) to
+   * one of its chats, so the caller learns where its message landed —
+   * the cross-chat relay needs it to subscribe to the replies.
+   */
+  chat_id?: string;
   /**
    * Set by tools that return a viewable image (e.g. `read` on a photo). The
    * MCP layer turns this into an image content block so the model sees the

package/src/frontend/whatsapp/actions/index.ts

@@ -110,6 +110,12 @@ export function createWhatsAppActionHandler(
       chat,
       scheduledMessages,
     };
-    return handler(body, chatId, ctx);
+    const result = await handler(body, chatId, ctx);
+    // An explicitly targeted action resolved a chat the caller could not
+    // name itself (a phone number is not a chat id). Report where the
+    // message landed so cross-frontend callers can follow the thread.
+    return result && chat && body.target !== undefined
+      ? { ...result, chat_id: chat.chatId }
+      : result;
   };
 }

package/src/frontend/whatsapp/inbound.ts

@@ -11,6 +11,7 @@ import { execute } from "../../core/engine/dispatcher.js";
 import { toolInputToRecord } from "../../core/agent-runtime/events.js";
 import { appendDailyLog } from "../../storage/daily-log.js";
 import { pushMessage } from "../../storage/history.js";
+import { relayInbound } from "../../core/engine/cross-chat-relay.js";
 import {
   recordMessageProcessed,
   recordMessageReceived,
@@ -175,6 +176,12 @@ async function recordInbound(
     ...(replyTo ? { replyToMsgId: replyTo.msgId } : {}),
     ...(media ? { mediaType: media.type, filePath: media.filePath } : {}),
   });
+
+  // If another chat's session messaged this one via send_via, it is
+  // waiting to hear back — hand it the reply for its next turn. A no-op
+  // (and one Map miss) for every chat nobody cross-sent into.
+  relayInbound(chat.chatId, senderName, text || `[${media?.type ?? "media"}]`);
+
   return { ...admitted, chat, msgId, text, media, senderName, platformTs };
 }
 

package/src/plugins/github/provision.ts

@@ -26,7 +26,7 @@ import { dirs } from "../../util/paths.js";
  * The github-mcp-server image tag Talon runs. Bump deliberately, with
  * the canary workflow green — see .github/workflows/native-provision.yml.
  */
-export const GITHUB_MCP_PINNED_TAG = "v1.12.1";
+export const GITHUB_MCP_PINNED_TAG = "v1.12.2";
 
 const GITHUB_MCP_IMAGE = "ghcr.io/github/github-mcp-server";
 

package/src/plugins/mempalace/provision.ts

@@ -47,7 +47,7 @@ import { dirs, files } from "../../util/paths.js";
  * to. Bump deliberately, with the canary workflow green — see
  * .github/workflows/native-provision.yml.
  */
-export const MEMPALACE_PINNED_VERSION = "3.9.0";
+export const MEMPALACE_PINNED_VERSION = "3.10.0";
 
 /** Minimum python for the managed venv (matches mempalace's supported floor). */
 const PYTHON_MIN = { major: 3, minor: 10 };