talon-agent 4.2.0 → 4.3.1

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.1",
   "description": "Multi-frontend AI agent with full tool access, streaming, cron jobs, and plugin system",
   "author": "Dylan Neve",
   "license": "MIT",

package/src/bootstrap.ts

@@ -568,9 +568,12 @@ export async function initBackendAndDispatcher(
     const { crossSendHandlers } =
       await import("./core/engine/gateway-actions/cross-send.js");
     void deliverPendingProvisionReport(async (frontend, target, text) => {
+      // Chat-free: the same "no chat" sentinels handleChatFreeAction passes.
       const result = await crossSendHandlers.send_via(
         { frontend, target, text },
         0,
+        undefined,
+        "0",
       );
       return Boolean(result && (result as { ok?: unknown }).ok === true);
     });

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/background/cron.ts

@@ -34,6 +34,7 @@ import {
 } from "../../storage/cron-store.js";
 import { appendDailyLog } from "../../storage/daily-log.js";
 import { log, logError, logWarn } from "../../util/log.js";
+import { numericChatIdFor } from "../../util/chat-id.js";
 import { runJobOneShot } from "./job-oneshot.js";
 import {
   jobAllowsRun,
@@ -464,10 +465,7 @@ const CRON_JOB_TIMEOUT_MS = 10 * 60_000; // 10-minute max per job
 export async function executeJob(job: CronJob): Promise<ExecuteJobResult> {
   if (!deps) return { status: "skipped", reason: "cron is not initialised" };
 
-  const numericChatId = Number(job.chatId);
-  if (!Number.isFinite(numericChatId)) {
-    throw new Error(`Invalid chatId for job "${job.name}": ${job.chatId}`);
-  }
+  const numericChatId = numericChatIdFor(job.chatId);
 
   if (job.type === "message") {
     await deps.sendMessage(numericChatId, job.content, job.chatId);

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/cron.ts

@@ -33,19 +33,19 @@ import type { SharedActionHandlers } from "./types.js";
  * Returns an error string, or null when valid.
  */
 async function validateCronModelOverride(
-  chatId: number,
+  chatKey: string,
   model?: string,
   provider?: string,
 ): Promise<string | null> {
-  const chatBackendId = getBackendIdForChat(String(chatId));
+  const chatBackendId = getBackendIdForChat(chatKey);
   if (!provider || provider === chatBackendId) {
     const capabilityErr = validateCronBackgroundCapability(
       chatBackendId,
-      getBackendForChat(String(chatId)),
+      getBackendForChat(chatKey),
     );
     if (capabilityErr) return capabilityErr;
     if (!model) return null;
-    return validateJobModelOverride(chatId, model);
+    return validateJobModelOverride(chatKey, model);
   }
 
   let acquired: Awaited<ReturnType<typeof acquireBackendInstance>> | null =
@@ -85,7 +85,7 @@ function validateCronBackgroundCapability(
 }
 
 export const cronHandlers: SharedActionHandlers = {
-  create_cron_job: async (body, chatId) => {
+  create_cron_job: async (body, chatId, _backend, chatKey) => {
     const parsed = parseCronSpec(body);
     if (!parsed.ok) return { ok: false, error: parsed.error };
     const spec = parsed.effective;
@@ -103,7 +103,7 @@ export const cronHandlers: SharedActionHandlers = {
     // backend is rejected here instead of silently failing at fire time.
     if (jobType === "query") {
       const modelErr = await validateCronModelOverride(
-        chatId,
+        chatKey,
         spec.model,
         spec.provider,
       );
@@ -114,7 +114,7 @@ export const cronHandlers: SharedActionHandlers = {
     addCronJob({
       ...spec,
       id,
-      chatId: String(chatId),
+      chatId: chatKey,
       enabled: true,
       createdAt: Date.now(),
       runCount: 0,
@@ -147,8 +147,8 @@ export const cronHandlers: SharedActionHandlers = {
     };
   },
 
-  list_cron_jobs: (body, chatId) => {
-    const jobs = getCronJobsForChat(String(chatId));
+  list_cron_jobs: (body, chatId, _backend, chatKey) => {
+    const jobs = getCronJobsForChat(chatKey);
     if (jobs.length === 0)
       return { ok: true, text: "No cron jobs in this chat." };
     const fmt = (ms: number) =>
@@ -191,12 +191,12 @@ export const cronHandlers: SharedActionHandlers = {
     };
   },
 
-  edit_cron_job: async (body, chatId) => {
+  edit_cron_job: async (body, chatId, _backend, chatKey) => {
     const jobId = String(body.job_id ?? "");
     if (!jobId) return { ok: false, error: "Missing job_id" };
     const job = getCronJob(jobId);
     if (!job) return { ok: false, error: `Job ${jobId} not found` };
-    if (job.chatId !== String(chatId))
+    if (job.chatId !== chatKey)
       return { ok: false, error: "Job belongs to a different chat" };
 
     const parsed = parseCronSpec(body, job);
@@ -210,7 +210,7 @@ export const cronHandlers: SharedActionHandlers = {
       ("model" in updates || "provider" in updates || "type" in updates)
     ) {
       const modelErr = await validateCronModelOverride(
-        chatId,
+        chatKey,
         effective.model,
         effective.provider,
       );
@@ -233,12 +233,12 @@ export const cronHandlers: SharedActionHandlers = {
     };
   },
 
-  run_cron_job: async (body, chatId) => {
+  run_cron_job: async (body, chatId, _backend, chatKey) => {
     const jobId = String(body.job_id ?? "");
     if (!jobId) return { ok: false, error: "Missing job_id" };
     const job = getCronJob(jobId);
     if (!job) return { ok: false, error: `Job ${jobId} not found` };
-    if (job.chatId !== String(chatId))
+    if (job.chatId !== chatKey)
       return { ok: false, error: "Job belongs to a different chat" };
     const result = await runJobNow(jobId);
     if (!result.ok) return { ok: false, error: result.error ?? "Run failed" };
@@ -246,12 +246,12 @@ export const cronHandlers: SharedActionHandlers = {
     return { ok: true, text: `Ran job "${job.name}" (${jobId}) now.` };
   },
 
-  delete_cron_job: (body, chatId) => {
+  delete_cron_job: (body, chatId, _backend, chatKey) => {
     const jobId = String(body.job_id ?? "");
     if (!jobId) return { ok: false, error: "Missing job_id" };
     const job = getCronJob(jobId);
     if (!job) return { ok: false, error: `Job ${jobId} not found` };
-    if (job.chatId !== String(chatId))
+    if (job.chatId !== chatKey)
       return { ok: false, error: "Job belongs to a different chat" };
     deleteCronJob(jobId);
     return { ok: true, text: `Deleted cron job "${job.name}" (${jobId})` };

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

@@ -26,7 +26,7 @@ import { parseDueDate } from "./shared.js";
 import type { SharedActionHandlers } from "./types.js";
 
 export const goalHandlers: SharedActionHandlers = {
-  add_goal: (body, chatId) => {
+  add_goal: (body, chatId, _backend, chatKey) => {
     const title = String(body.title ?? "").trim();
     const description = body.description ? String(body.description) : undefined;
     const priority = body.priority ?? "normal";
@@ -48,7 +48,7 @@ export const goalHandlers: SharedActionHandlers = {
         };
     }
 
-    const chatIdStr = String(chatId);
+    const chatIdStr = chatKey;
     // No open-goal cap: goals grow freely. The heartbeat re-reads every open
     // goal, so keep them tidy by closing finished ones (completed/abandoned).
 
@@ -75,10 +75,10 @@ export const goalHandlers: SharedActionHandlers = {
     };
   },
 
-  list_goals: (body, chatId) => {
+  list_goals: (body, chatId, _backend, chatKey) => {
     const includeClosed = body.include_closed === true;
     const goals = getGoalsForChat(
-      String(chatId),
+      chatKey,
       includeClosed ? GOAL_STATUSES : OPEN_GOAL_STATUSES,
     );
     if (goals.length === 0)
@@ -94,12 +94,12 @@ export const goalHandlers: SharedActionHandlers = {
     };
   },
 
-  update_goal: (body, chatId) => {
+  update_goal: (body, chatId, _backend, chatKey) => {
     const goalId = String(body.goal_id ?? "");
     if (!goalId) return { ok: false, error: "Missing goal_id" };
     const goal = getGoal(goalId);
     if (!goal) return { ok: false, error: `Goal ${goalId} not found` };
-    if (goal.chatId !== String(chatId))
+    if (goal.chatId !== chatKey)
       return { ok: false, error: "Goal belongs to a different chat" };
 
     const updates: Parameters<typeof updateGoal>[1] = {};
@@ -158,12 +158,12 @@ export const goalHandlers: SharedActionHandlers = {
     };
   },
 
-  delete_goal: (body, chatId) => {
+  delete_goal: (body, chatId, _backend, chatKey) => {
     const goalId = String(body.goal_id ?? "");
     if (!goalId) return { ok: false, error: "Missing goal_id" };
     const goal = getGoal(goalId);
     if (!goal) return { ok: false, error: `Goal ${goalId} not found` };
-    if (goal.chatId !== String(chatId))
+    if (goal.chatId !== chatKey)
       return { ok: false, error: "Goal belongs to a different chat" };
     deleteGoal(goalId);
     return { ok: true, text: `Deleted goal "${goal.title}" (${goalId})` };

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

@@ -15,9 +15,9 @@ import { formatMediaIndex } from "../../../storage/media-index.js";
 import type { SharedActionHandlers } from "./types.js";
 
 export const historyHandlers: SharedActionHandlers = {
-  read_history: (body, chatId) => {
+  read_history: (body, chatId, _backend, chatKey) => {
     const limit = Math.min(100, Number(body.limit ?? 30));
-    const cid = String(chatId);
+    const cid = chatKey;
     // The tool schema advertises `offset_id` and `before` for paging back;
     // this fallback used to ignore both and hand back the same newest
     // window no matter what the model asked, so "go further back" was a
@@ -36,7 +36,7 @@ export const historyHandlers: SharedActionHandlers = {
     return { ok: true, text: getRecentFormatted(cid, limit) };
   },
 
-  search_history: (body, chatId) => {
+  search_history: (body, chatId, _backend, chatKey) => {
     const limit = Math.min(100, Number(body.limit ?? 20));
     // Optional ISO date bounds; an unparseable one is ignored rather
     // than silently narrowing the search to nothing.
@@ -48,35 +48,28 @@ export const historyHandlers: SharedActionHandlers = {
     };
     return {
       ok: true,
-      text: searchHistory(String(chatId), String(body.query ?? ""), limit, {
+      text: searchHistory(chatKey, String(body.query ?? ""), limit, {
         after: bound(body.after),
         before: bound(body.before),
       }),
     };
   },
 
-  get_user_messages: (body, chatId) => {
+  get_user_messages: (body, chatId, _backend, chatKey) => {
     const limit = Math.min(50, Number(body.limit ?? 20));
     return {
       ok: true,
-      text: getMessagesByUser(
-        String(chatId),
-        String(body.user_name ?? ""),
-        limit,
-      ),
+      text: getMessagesByUser(chatKey, String(body.user_name ?? ""), limit),
     };
   },
 
-  list_known_users: (body, chatId) => ({
+  list_known_users: (body, chatId, _backend, chatKey) => ({
     ok: true,
-    text: getKnownUsers(String(chatId)),
+    text: getKnownUsers(chatKey),
   }),
 
-  list_media: (body, chatId) => ({
+  list_media: (body, chatId, _backend, chatKey) => ({
     ok: true,
-    text: formatMediaIndex(
-      String(chatId),
-      Math.min(20, Number(body.limit ?? 10)),
-    ),
+    text: formatMediaIndex(chatKey, Math.min(20, Number(body.limit ?? 10))),
   }),
 };

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

@@ -72,15 +72,22 @@ const chatFreeActions: ReadonlySet<string> = new Set([
   ...whatsappAccountChatFreeActions,
 ]);
 
+/**
+ * `chatKey` is the chat's canonical string id (see `SharedActionHandler`).
+ * It defaults to `String(chatId)`, which is exact for Telegram and for the
+ * numeric-only callers (tests, chat-free dispatch); the gateway passes the
+ * real string id it holds for the active turn.
+ */
 export async function handleSharedAction(
   body: Record<string, unknown>,
   chatId: number,
   backend?: Backend | null,
+  chatKey: string = String(chatId),
 ): Promise<ActionResult | null> {
   const action = body.action as string;
   const handler = handlers[action];
   if (!handler) return null; // not a shared action — delegate to frontend
-  return handler(body, chatId, backend);
+  return handler(body, chatId, backend, chatKey);
 }
 
 /**
@@ -104,5 +111,5 @@ export async function handleChatFreeAction(
   if (!isChatFreeAction(action)) return null;
   const handler = handlers[action];
   if (!handler) return null;
-  return handler(body, 0);
+  return handler(body, 0, undefined, "0");
 }

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

@@ -16,8 +16,8 @@ import {
 import type { SharedActionHandlers } from "./types.js";
 
 export const modelHandlers: SharedActionHandlers = {
-  list_models: async (body, chatId) => {
-    const chatIdStr = String(chatId);
+  list_models: async (body, chatId, _backend, chatKey) => {
+    const chatIdStr = chatKey;
     const currentId = getBackendIdForChat(chatIdStr);
     const requested = body.backend ? String(body.backend).trim() : "";
     const targetId = requested || currentId;
@@ -100,8 +100,8 @@ export const modelHandlers: SharedActionHandlers = {
 
   // Account-level, so it falls back to the pooled Claude backend when
   // another provider is serving this chat.
-  plan_usage: async (_body, chatId) => {
-    const current = getPooledBackend(getBackendIdForChat(String(chatId)));
+  plan_usage: async (_body, chatId, _backend, chatKey) => {
+    const current = getPooledBackend(getBackendIdForChat(chatKey));
     const source = current?.usage?.getPlanUsage
       ? current
       : getPooledBackend("claude");
@@ -131,8 +131,8 @@ export const modelHandlers: SharedActionHandlers = {
     };
   },
 
-  list_backends: (body, chatId) => {
-    const currentId = getBackendIdForChat(String(chatId));
+  list_backends: (body, chatId, _backend, chatKey) => {
+    const currentId = getBackendIdForChat(chatKey);
     const backends = getAvailableBackends().map((b) => ({
       id: b.id,
       label: b.label,

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

@@ -43,7 +43,7 @@ export async function performPluginReload(
 }
 
 export const pluginHandlers: SharedActionHandlers = {
-  reload_plugins: async (body, chatId, backend) => {
+  reload_plugins: async (body, chatId, backend, chatKey) => {
     try {
       const { names } = await performPluginReload(backend);
 
@@ -52,13 +52,7 @@ export const pluginHandlers: SharedActionHandlers = {
       let mcpInfo = "";
       if (backend?.tools?.refreshTools) {
         try {
-          // Prefer body._chatId (string chat ID passed by frontends that use
-          // non-numeric IDs, e.g. Teams/terminal) over the numeric context ID.
-          const refreshChatId =
-            typeof body._chatId === "string" && body._chatId.length > 0
-              ? body._chatId
-              : String(chatId);
-          const result = await backend.tools.refreshTools(refreshChatId);
+          const result = await backend.tools.refreshTools(chatKey);
           if (result) {
             const parts: string[] = [];
             if (result.added.length > 0)

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

@@ -30,15 +30,14 @@ export function parseDueDate(value: unknown): number | undefined {
  * when it isn't, or `null` when it's valid.
  */
 export async function validateJobModelOverride(
-  chatId: number,
+  chatKey: string,
   model: string,
 ): Promise<string | null> {
   try {
-    const chatIdStr = String(chatId);
     const ref = await resolveExplicitModelRef(
       model,
-      getBackendForChat(chatIdStr),
-      getBackendIdForChat(chatIdStr),
+      getBackendForChat(chatKey),
+      getBackendIdForChat(chatKey),
     );
     if (!ref) {
       return (

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

@@ -31,7 +31,7 @@ import { validateJobModelOverride } from "./shared.js";
 import type { SharedActionHandlers } from "./types.js";
 
 export const triggerHandlers: SharedActionHandlers = {
-  trigger_create: async (body, chatId) => {
+  trigger_create: async (body, chatId, _backend, chatKey) => {
     const name = String(body.name ?? "").trim();
     const language = body.language;
     const script = String(body.script ?? "");
@@ -55,14 +55,13 @@ export const triggerHandlers: SharedActionHandlers = {
     const timeoutErr = validateTimeout(timeoutSeconds);
     if (timeoutErr) return { ok: false, error: timeoutErr };
 
-    const chatIdStr = String(chatId);
-    if (getTriggerByName(chatIdStr, name)) {
+    if (getTriggerByName(chatKey, name)) {
       return {
         ok: false,
         error: `A trigger named "${name}" already exists in this chat. Cancel it first or pick a different name.`,
       };
     }
-    const active = getActiveTriggersForChat(chatIdStr);
+    const active = getActiveTriggersForChat(chatKey);
     if (active.length >= MAX_ACTIVE_PER_CHAT) {
       return {
         ok: false,
@@ -70,18 +69,10 @@ export const triggerHandlers: SharedActionHandlers = {
       };
     }
 
-    const numericChatId = Number(chatId);
-    if (!Number.isFinite(numericChatId)) {
-      return {
-        ok: false,
-        error: `Cannot derive numeric chatId from ${chatId}`,
-      };
-    }
-
     // Validate the model up front so a bad id is rejected here instead of
     // silently failing at fire time.
     if (model) {
-      const modelErr = await validateJobModelOverride(chatId, model);
+      const modelErr = await validateJobModelOverride(chatKey, model);
       if (modelErr) return { ok: false, error: modelErr };
     }
 
@@ -89,19 +80,19 @@ export const triggerHandlers: SharedActionHandlers = {
     const lang = language as TriggerLanguage;
     let scriptPath: string;
     try {
-      scriptPath = writeScriptFile(chatIdStr, id, lang, script);
+      scriptPath = writeScriptFile(chatKey, id, lang, script);
     } catch (err) {
       return {
         ok: false,
         error: `Failed to write script: ${err instanceof Error ? err.message : err}`,
       };
     }
-    const logPath = triggerLogPath(chatIdStr, id);
+    const logPath = triggerLogPath(chatKey, id);
 
     const trigger = {
       id,
-      chatId: chatIdStr,
-      numericChatId,
+      chatId: chatKey,
+      numericChatId: chatId,
       name,
       language: lang,
       scriptPath,
@@ -151,8 +142,8 @@ export const triggerHandlers: SharedActionHandlers = {
     };
   },
 
-  trigger_list: (body, chatId) => {
-    const triggers = getTriggersForChat(String(chatId));
+  trigger_list: (body, chatId, _backend, chatKey) => {
+    const triggers = getTriggersForChat(chatKey);
     if (triggers.length === 0)
       return { ok: true, text: "No triggers in this chat." };
     const lines = triggers.map((t) => {
@@ -181,12 +172,12 @@ export const triggerHandlers: SharedActionHandlers = {
     };
   },
 
-  trigger_cancel: (body, chatId) => {
+  trigger_cancel: (body, chatId, _backend, chatKey) => {
     const triggerId = String(body.trigger_id ?? "");
     if (!triggerId) return { ok: false, error: "Missing trigger_id" };
     const t = getTrigger(triggerId);
     if (!t) return { ok: false, error: `Trigger ${triggerId} not found` };
-    if (t.chatId !== String(chatId))
+    if (t.chatId !== chatKey)
       return { ok: false, error: "Trigger belongs to a different chat" };
     const wasRunning = cancelTrigger(triggerId);
     if (!wasRunning) {
@@ -201,12 +192,12 @@ export const triggerHandlers: SharedActionHandlers = {
     };
   },
 
-  trigger_logs: (body, chatId) => {
+  trigger_logs: (body, chatId, _backend, chatKey) => {
     const triggerId = String(body.trigger_id ?? "");
     if (!triggerId) return { ok: false, error: "Missing trigger_id" };
     const t = getTrigger(triggerId);
     if (!t) return { ok: false, error: `Trigger ${triggerId} not found` };
-    if (t.chatId !== String(chatId))
+    if (t.chatId !== chatKey)
       return { ok: false, error: "Trigger belongs to a different chat" };
     const lines = Math.min(500, Math.max(1, Number(body.lines ?? 80)));
     const { tail, truncated } = readTriggerLogTail(t.logPath, lines);
@@ -219,12 +210,12 @@ export const triggerHandlers: SharedActionHandlers = {
     };
   },
 
-  trigger_delete: (body, chatId) => {
+  trigger_delete: (body, chatId, _backend, chatKey) => {
     const triggerId = String(body.trigger_id ?? "");
     if (!triggerId) return { ok: false, error: "Missing trigger_id" };
     const t = getTrigger(triggerId);
     if (!t) return { ok: false, error: `Trigger ${triggerId} not found` };
-    if (t.chatId !== String(chatId))
+    if (t.chatId !== chatKey)
       return { ok: false, error: "Trigger belongs to a different chat" };
     // Cancel first if it's still running so we don't orphan a child
     cancelTrigger(triggerId);

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

@@ -9,10 +9,20 @@
 import type { ActionResult } from "../../types.js";
 import type { Backend } from "../../agent-runtime/capabilities.js";
 
+/**
+ * `chatId` is the frontend's numeric id — the only identity the HTTP bridge
+ * carries. `chatKey` is the chat's canonical string id (the dispatcher's
+ * `chatId`, which every store is keyed on): for Telegram it is just
+ * `String(chatId)`, for every other frontend it is the real id the numeric
+ * one was derived from (`d_…`, `wa_…`, `discord_…`). Handlers that persist,
+ * look up, or route by chat must use `chatKey`, never `String(chatId)` —
+ * a `d_…` chat's jobs stored under its numeric id fire into Telegram.
+ */
 type SharedActionHandler = (
   body: Record<string, unknown>,
   chatId: number,
-  backend?: Backend | null,
+  backend: Backend | null | undefined,
+  chatKey: string,
 ) => Promise<ActionResult> | ActionResult;
 
 export type SharedActionHandlers = Record<string, SharedActionHandler>;

package/src/core/engine/gateway.ts

@@ -307,6 +307,11 @@ export class Gateway {
     const action = typeof body.action === "string" ? body.action : "";
     if (!action) return { ok: false, error: "Missing action" };
     const t0 = Date.now();
+    // The canonical string id for this chat. The bridge only carries the
+    // numeric id, but the turn's Thread is keyed by the dispatcher's string
+    // chatId — hand that to the handlers so a `d_…`/`wa_…` chat's cron jobs,
+    // triggers and history land under the id the rest of the engine uses.
+    const chatKey = this.loom.stringIdForNumeric(chatId) ?? String(chatId);
 
     try {
       // Try frontend first — it has richer implementations (e.g. userbot history)
@@ -326,7 +331,7 @@ export class Gateway {
       }
 
       // Try plugin actions (loaded from external plugin packages)
-      const pluginResult = await handlePluginAction(body, String(chatId));
+      const pluginResult = await handlePluginAction(body, chatKey);
       if (pluginResult) {
         logDebug(
           "gateway",
@@ -336,7 +341,12 @@ export class Gateway {
       }
 
       // Shared actions last — provides in-memory fallbacks for history, cron, etc.
-      const shared = await handleSharedAction(body, chatId, this.backend);
+      const shared = await handleSharedAction(
+        body,
+        chatId,
+        this.backend,
+        chatKey,
+      );
       if (shared) {
         logDebug(
           "gateway",

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/core/weaver/loom.ts

@@ -22,6 +22,8 @@ export interface ContextRegistry {
   activeContextCount(): number;
   /** Resolve a string chat id to the numeric id of its active context. */
   numericForStringId(stringId: string): number | null;
+  /** Resolve a numeric id to the string chat id of its active context. */
+  stringIdForNumeric(numericChatId: number): string | null;
   /** Number of live Threads in the registry. */
   size(): number;
 }
@@ -146,6 +148,15 @@ export class Loom implements ContextRegistry {
     return thread?.contextActive ? (thread.numericChatId ?? null) : null;
   }
 
+  /**
+   * Resolve a numeric id to the string chat id of its active context — the
+   * Thread key, which is the dispatcher's `chatId` (see `acquireContext`).
+   * Null outside a turn: the numeric index only mirrors held contexts.
+   */
+  stringIdForNumeric(numericChatId: number): string | null {
+    return this.byNumeric.get(numericChatId)?.chatId ?? null;
+  }
+
   private resolve(id: number | string): Thread | undefined {
     if (typeof id === "number") return this.byNumeric.get(id);
     const direct = this.threads.get(id);

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 };

package/src/util/chat-id.ts

@@ -10,6 +10,19 @@ export function deriveNumericChatId(chatId: string): number {
   return hash.readUInt32BE(0);
 }
 
+/**
+ * The numeric id a frontend uses for a chat. Telegram ids are numeric
+ * already; every other frontend (native, WhatsApp, Discord, Teams, terminal)
+ * derives its numeric id from the string one with `deriveNumericChatId`.
+ * This is the inverse the background runtimes need to address a stored
+ * string chat id the way its frontend does.
+ */
+export function numericChatIdFor(chatId: string): number {
+  return isTelegramChatId(chatId)
+    ? Number(chatId)
+    : deriveNumericChatId(chatId);
+}
+
 /** Generate a unique terminal chat ID. */
 export function generateTerminalChatId(): string {
   return `t_${Date.now()}`;