talon-agent 1.34.0 → 1.35.0

package/src/core/weaver/weaver.ts

@@ -1,18 +1,43 @@
+/**
+ * Weaver — the turn orchestrator. `runTurn` serializes each turn onto
+ * its chat's Thread (per-chat FIFO, cross-chat parallel) and drives the
+ * turn lifecycle by composing the weaver's single-purpose collaborators:
+ *
+ *   - `resolveWarp` (warp-resolver.ts) — model/backend binding + the
+ *     null-model guard and per-run override fallback;
+ *   - `startTypingLoop` (typing-loop.ts) — keeps the frontend's typing
+ *     indicator alive for the duration of the turn;
+ *   - `prefetchMemory` (memory-prefetch.ts) — optional fail-closed
+ *     palace pre-retrieval for live user messages;
+ *   - `carryTurnEvents` (shuttle.ts) — pumps the backend's AgentEvent
+ *     stream into the frontend sink, settles delivery acks, captures
+ *     the result and rethrows error terminators.
+ *
+ * The Weaver itself only sequences those stages and brackets them with
+ * the Thread's execution context — it holds no per-chat state (that's
+ * the Thread's) and no policy of its own beyond ordering.
+ */
+
 import { randomBytes } from "node:crypto";
-import type {
-  Backend,
-  RetrievedMemory,
-} from "../agent-runtime/capabilities.js";
-import { AgentRunError, type AgentResult } from "../agent-runtime/events.js";
+import type { Backend } from "../agent-runtime/capabilities.js";
+import type { AgentResult } from "../agent-runtime/events.js";
 import type { ModelRef } from "../agent-runtime/model-ref.js";
-import { maybeStartDream } from "../background/dream.js";
 import type { MemoryRetriever } from "../memory/retrieval.js";
 import type { ContextManager, ExecuteParams, ExecuteResult } from "../types.js";
 import { log, logDebug, logWarn } from "../../util/log.js";
 import { Loom } from "./loom.js";
+import { prefetchMemory } from "./memory-prefetch.js";
+import { carryTurnEvents } from "./shuttle.js";
 import type { Thread, ThreadSnapshot } from "./thread.js";
+import { startTypingLoop } from "./typing-loop.js";
+import { resolveWarp } from "./warp-resolver.js";
 
 export type WeaverDeps = {
+  /**
+   * Read fresh per call so backend swaps (chat-role rebinds or
+   * per-chat overrides via the controller) take effect on the next
+   * query without a dispatcher re-init.
+   */
   getBackend: (chatId?: string) => Backend;
   resolveActiveModel: (chatId: string) => Promise<{
     model: string | null;
@@ -26,6 +51,14 @@ export type WeaverDeps = {
   context: ContextManager;
   sendTyping: (chatId: number, stringId?: string) => Promise<void>;
   onActivity: () => void;
+  /**
+   * Optional fire-and-forget hook invoked at the start of every turn,
+   * after the warp is bound and before the backend is called. The
+   * composition root wires background work here (e.g. dream memory
+   * consolidation) so the Weaver stays ignorant of those subsystems.
+   * Must not throw and must not block — it is called synchronously.
+   */
+  onTurnStart?: () => void;
   /**
    * Optional memory pre-retrieval (Phase B). Called for `source: "message"`
    * turns after model/backend resolution and context acquisition, before
@@ -38,6 +71,7 @@ export type WeaverDeps = {
 export class Weaver {
   readonly loom: Loom;
   private readonly deps: WeaverDeps;
+  private activeCount = 0;
 
   constructor(deps: WeaverDeps, loom = new Loom()) {
     this.deps = deps;
@@ -49,6 +83,7 @@ export class Weaver {
     return thread.enqueue(() => this.run(thread, params));
   }
 
+  /** Number of turns currently running (not queued) across all chats. */
   getActiveCount(): number {
     return this.activeCount;
   }
@@ -59,14 +94,9 @@ export class Weaver {
    * frontends. Reading is side-effect free.
    */
   snapshot(): ThreadSnapshot[] {
-    return this.loom
-      .chatIds()
-      .map((id) => this.loom.get(id)?.describe())
-      .filter((s): s is ThreadSnapshot => s !== undefined);
+    return this.loom.snapshot();
   }
 
-  private activeCount = 0;
-
   private async run(
     thread: Thread,
     params: ExecuteParams,
@@ -83,95 +113,32 @@ export class Weaver {
     thread: Thread,
     params: ExecuteParams,
   ): Promise<ExecuteResult> {
-    const {
-      getBackend,
-      resolveActiveModel,
-      resolveModelOverride,
-      context,
-      sendTyping,
-      onActivity,
-      retrieveMemory,
-    } = this.deps;
-    // Read the backend fresh per call so backend swaps (chat-role
-    // rebinds or per-chat overrides via the controller) take effect on
-    // the next query without a dispatcher re-init.
-    const backend = getBackend(params.chatId);
+    const { context, onActivity, retrieveMemory } = this.deps;
+    const backend = this.deps.getBackend(params.chatId);
     const reqId = randomBytes(4).toString("hex");
 
-    // Send-time null-model guard. When the active-model resolver
-    // returns no usable model (catalog-driven backend with no per-chat
-    // pick and no operator default), refuse to call the backend — it
-    // would either error opaquely or run on the wrong default. Reply
-    // with a clear "use /model to pick one" message routed through the
-    // same event sink the backend would use for output (as an
-    // `assistant_message` event, so the frontend delivers it normally).
-    const {
-      model: resolvedModel,
-      ref: resolvedRef,
-      backendId,
-    } = await resolveActiveModel(params.chatId);
-    if (resolvedModel === null || resolvedRef === null) {
-      const message =
-        `No model selected for backend \`${backendId}\`. ` +
-        `Use /model to pick one — or set ` +
-        `\`backendDefaults.${backendId}\` in talon.json to apply a ` +
-        `default for all chats on this backend.`;
-      logWarn(
-        "dispatcher",
-        `[${reqId}] refusing query: no model resolved (chat=${params.chatId}, backend=${backendId})`,
-      );
+    const warp = await resolveWarp(this.deps, {
+      chatId: params.chatId,
+      modelOverride: params.modelOverride,
+      source: params.source,
+      reqId,
+    });
+    if (!warp.ok) {
+      // Refusals are delivered through the same event sink the backend
+      // would use for output (as an `assistant_message` event, so the
+      // frontend delivers it normally).
       try {
-        await params.onEvent?.({ type: "assistant_message", text: message });
+        await params.onEvent?.({
+          type: "assistant_message",
+          text: warp.message,
+        });
       } catch (err) {
         logWarn(
           "dispatcher",
           `onEvent(no-model) threw: ${err instanceof Error ? err.message : String(err)}`,
         );
       }
-      return {
-        text: message,
-        durationMs: 0,
-        inputTokens: 0,
-        outputTokens: 0,
-        cacheRead: 0,
-        cacheWrite: 0,
-        bridgeMessageCount: context.getMessageCount(
-          params.numericChatId,
-          params.chatId,
-        ),
-      };
-    }
-
-    // Per-run model override (triggers/cron). Resolve against the chat's
-    // backend; on success swap the ref for this turn only, on failure fall
-    // back to the chat model so a stale override never kills the run. The
-    // override is restricted to the chat's own backend, so the session still
-    // resumes — only the model changes.
-    let runRef = resolvedRef;
-    if (params.modelOverride && resolveModelOverride) {
-      try {
-        const overrideRef = await resolveModelOverride(
-          params.chatId,
-          params.modelOverride,
-        );
-        if (overrideRef) {
-          runRef = overrideRef;
-          logDebug(
-            "dispatcher",
-            `[${reqId}] model override → ${params.modelOverride} (${params.source})`,
-          );
-        } else {
-          logWarn(
-            "dispatcher",
-            `[${reqId}] model override "${params.modelOverride}" not resolvable on backend ${backendId}; using chat model`,
-          );
-        }
-      } catch (err) {
-        logWarn(
-          "dispatcher",
-          `[${reqId}] model override resolution threw: ${err instanceof Error ? err.message : String(err)}; using chat model`,
-        );
-      }
+      return this.emptyResult(warp.message, params);
     }
 
     // Bind the warp — record the model/backend actually resolved for this turn
@@ -179,158 +146,105 @@ export class Weaver {
     // last turn (per-chat rebind, per-run override, or config drift) is logged
     // rather than passing silently.
     const { drifted, previous } = thread.bindWarp({
-      model: runRef.id,
-      backendId,
-      overridden: runRef !== resolvedRef,
+      model: warp.ref.id,
+      backendId: warp.backendId,
+      overridden: warp.overridden,
       boundAt: Date.now(),
     });
     if (drifted && previous) {
       logDebug(
         "dispatcher",
-        `[${reqId}] warp drift chat=${params.chatId}: ${previous.backendId}/${previous.model} → ${backendId}/${runRef.id}`,
+        `[${reqId}] warp drift chat=${params.chatId}: ${previous.backendId}/${previous.model} → ${warp.backendId}/${warp.ref.id}`,
       );
     }
 
-    // Dream check — fire-and-forget background memory consolidation if due
-    maybeStartDream();
+    this.deps.onTurnStart?.();
 
     logDebug(
       "dispatcher",
       `[${reqId}] ${params.source} chat=${params.chatId} started (active=${this.activeCount})`,
     );
     context.acquire(params.numericChatId, params.chatId);
-
-    let typingTimer: ReturnType<typeof setInterval> | undefined;
+    const stopTyping = startTypingLoop(
+      this.deps.sendTyping,
+      params.numericChatId,
+      params.chatId,
+    );
     try {
-      await sendTyping(params.numericChatId, params.chatId).catch(
-        (err: unknown) => {
-          logWarn(
-            "dispatcher",
-            `sendTyping failed: ${err instanceof Error ? err.message : String(err)}`,
-          );
-        },
-      );
-      typingTimer = setInterval(() => {
-        sendTyping(params.numericChatId, params.chatId).catch(
-          (err: unknown) => {
-            logWarn(
-              "dispatcher",
-              `sendTyping interval failed: ${err instanceof Error ? err.message : String(err)}`,
-            );
-          },
-        );
-      }, 4000);
-
-      // Consume the backend's native `AgentEvent` stream and forward
-      // every event straight to the frontend's `onEvent` sink (no
-      // callback bridge). Capture the `completed` event's `AgentResult`
-      // for the dispatcher's return value, and rethrow an `error`
-      // terminator as `AgentRunError` so callers' catch paths keep
-      // working. Events are awaited in stream order so a consumer that
-      // needs serial delivery gets it.
       if (!backend.chat) {
         throw new Error(
           `Backend "${backend.id}" has no chat capability — cannot run a turn.`,
         );
       }
 
-      // Phase B memory pre-retrieval: only for live user messages, only when
-      // a retriever dep is wired, and strictly fail-closed — a broken palace
-      // must never block chat delivery. The result is dynamic turn context
-      // passed through ChatRunParams; it never touches the frozen prompt.
-      let retrievedMemory: RetrievedMemory | undefined;
-      if (retrieveMemory && params.source === "message") {
-        try {
-          retrievedMemory = await retrieveMemory({
-            runKind: "chat",
-            chatId: params.chatId,
-            text: params.prompt,
-            senderName: params.senderName,
-            isGroup: params.isGroup,
-          });
-          if (retrievedMemory) {
-            logDebug(
-              "dispatcher",
-              `[${reqId}] memory pre-retrieval: ${retrievedMemory.items.length} item(s), ` +
-                `${retrievedMemory.items.reduce((n, i) => n + i.text.length, 0)} chars`,
-            );
-          }
-        } catch (err) {
-          logWarn(
-            "dispatcher",
-            `[${reqId}] memory pre-retrieval failed (running turn without it): ` +
-              (err instanceof Error ? err.message : String(err)),
-          );
-          retrievedMemory = undefined;
-        }
-      }
+      const retrievedMemory =
+        retrieveMemory && params.source === "message"
+          ? await prefetchMemory(retrieveMemory, {
+              chatId: params.chatId,
+              text: params.prompt,
+              senderName: params.senderName,
+              isGroup: params.isGroup,
+              reqId,
+            })
+          : undefined;
 
       const stream = backend.chat.runChatTurn({
         chatId: params.chatId,
-        model: runRef,
+        model: warp.ref,
         text: params.prompt,
         senderName: params.senderName,
         isGroup: params.isGroup,
         messageId: params.messageId,
         retrievedMemory,
       });
-      let agentResult: AgentResult | undefined;
-      for await (const event of stream) {
-        if (event.type === "completed") {
-          agentResult = event.result;
-        }
-
-        // The dispatcher owns `assistant_message.deliveryAck` settlement
-        // so it is ALWAYS resolved — even when no `onEvent` sink is
-        // supplied, or the sink ignores the event. Otherwise the
-        // callback-shaped backend (handler-to-events) blocks forever
-        // awaiting delivery confirmation. The frontend's job is just to
-        // deliver and throw on failure; the dispatcher maps that onto the
-        // ack (resolve on success → block delivered; reject on throw →
-        // backend retries, e.g. Codex oversized-message path).
-        if (event.type === "assistant_message" && event.deliveryAck) {
-          try {
-            await params.onEvent?.(event);
-            event.deliveryAck.resolve();
-          } catch (err) {
-            event.deliveryAck.reject(err);
-          }
-          continue;
-        }
-
-        await params.onEvent?.(event);
-        if (event.type === "error") {
-          throw new AgentRunError(event.error);
-        }
-      }
-      const result = {
-        text: agentResult?.text ?? "",
-        durationMs: agentResult?.durationMs ?? 0,
-        inputTokens: agentResult?.usage.inputTokens ?? 0,
-        outputTokens: agentResult?.usage.outputTokens ?? 0,
-        cacheRead: agentResult?.usage.cacheRead ?? 0,
-        cacheWrite: agentResult?.usage.cacheWrite ?? 0,
-      };
+      const agentResult = await carryTurnEvents(stream, params.onEvent);
 
       onActivity();
-
       logDebug(
         "dispatcher",
-        `[${reqId}] completed in ${result.durationMs}ms (in=${result.inputTokens} out=${result.outputTokens})`,
+        `[${reqId}] completed in ${agentResult?.durationMs ?? 0}ms ` +
+          `(in=${agentResult?.usage.inputTokens ?? 0} out=${agentResult?.usage.outputTokens ?? 0})`,
       );
 
-      return {
-        ...result,
-        bridgeMessageCount: context.getMessageCount(
-          params.numericChatId,
-          params.chatId,
-        ),
-      };
+      return this.toExecuteResult(agentResult, params);
     } finally {
-      clearInterval(typingTimer);
+      stopTyping();
       context.release(params.numericChatId, params.chatId);
     }
   }
+
+  private toExecuteResult(
+    result: AgentResult | undefined,
+    params: ExecuteParams,
+  ): ExecuteResult {
+    return {
+      text: result?.text ?? "",
+      durationMs: result?.durationMs ?? 0,
+      inputTokens: result?.usage.inputTokens ?? 0,
+      outputTokens: result?.usage.outputTokens ?? 0,
+      cacheRead: result?.usage.cacheRead ?? 0,
+      cacheWrite: result?.usage.cacheWrite ?? 0,
+      bridgeMessageCount: this.deps.context.getMessageCount(
+        params.numericChatId,
+        params.chatId,
+      ),
+    };
+  }
+
+  private emptyResult(text: string, params: ExecuteParams): ExecuteResult {
+    return {
+      text,
+      durationMs: 0,
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+      bridgeMessageCount: this.deps.context.getMessageCount(
+        params.numericChatId,
+        params.chatId,
+      ),
+    };
+  }
 }
 
 let weaver: Weaver | null = null;
@@ -341,11 +255,6 @@ export function initWeaver(deps: WeaverDeps): Weaver {
   return weaver;
 }
 
-export function getWeaver(): Weaver {
-  if (!weaver) throw new Error("Weaver not initialized");
-  return weaver;
-}
-
 /**
  * The active Weaver's Loom, or `null` before the dispatcher is wired. The
  * gateway delegates its per-chat context bookkeeping here so the Loom is the

package/src/frontend/native/actions.ts

@@ -52,6 +52,20 @@ function toButtons(rows: unknown): ClientButton[][] | undefined {
   return mapped.length ? mapped : undefined;
 }
 
+/** Actions this handler owns. Everything else must return null so the
+ *  gateway can try plugin + shared actions (history, web, cron, mesh…) —
+ *  failing early here would swallow actions that aren't native's to answer. */
+const NATIVE_ACTIONS = new Set([
+  "send_message",
+  "send_message_with_buttons",
+  "send_photo",
+  "react",
+  "edit_message",
+  "delete_message",
+  "get_chat_info",
+  "send_chat_action",
+]);
+
 export function createNativeActionHandler(
   deps: NativeActionDeps,
 ): FrontendActionHandler {
@@ -59,6 +73,7 @@ export function createNativeActionHandler(
 
   return async (body, chatId): Promise<ActionResult | null> => {
     const action = typeof body.action === "string" ? body.action : "";
+    if (!NATIVE_ACTIONS.has(action)) return null;
     const entry = chats.byNumeric(chatId);
     if (!entry) return { ok: false, error: "No active native chat" };
 
@@ -126,7 +141,8 @@ export function createNativeActionHandler(
         return { ok: true };
 
       default:
-        // Let the gateway try plugin + shared actions (history, web, cron…).
+        // Unreachable — NATIVE_ACTIONS gates the switch — but keeps the
+        // contract explicit if the set and the cases ever drift.
         return null;
     }
   };

package/src/frontend/native/index.ts

@@ -30,6 +30,7 @@ import { resolveActiveModelForChat } from "../../core/models/active-model.js";
 import { forceDream } from "../../core/background/dream.js";
 import { execute } from "../../core/engine/dispatcher.js";
 import { toolInputToRecord } from "../../core/agent-runtime/events.js";
+import { isDeliveryTool } from "../../core/tools/index.js";
 import {
   pushMessage,
   getRecentHistory,
@@ -65,6 +66,7 @@ import { NativeChats, DEFAULT_CHAT_TITLE, type ChatEntry } from "./chats.js";
 import { extractSessionName } from "../../backend/shared/session-name.js";
 import { BridgeServer, type BridgeServerHandlers } from "./server.js";
 import { createNativeActionHandler } from "./actions.js";
+import { getMeshService } from "../../core/mesh/index.js";
 import { removeBridgeDiscovery, writeBridgeDiscovery } from "./discovery.js";
 import { readLogEntries } from "./logs.js";
 import {
@@ -147,6 +149,13 @@ export function createNativeFrontend(
   const startedAt = new Date().toISOString();
   const botName = config.botDisplayName || "Talon";
   const chats = new NativeChats();
+  // Daemon-wide mesh service (core/mesh). This frontend is its transport:
+  // companions register/report/answer through the bridge routes below, and
+  // the SSE transport (wired in init) pushes locate requests and device
+  // commands out. The model's mesh tools are served by the shared gateway
+  // actions, so they work from every frontend.
+  const mesh = getMeshService();
+  let unregisterMeshTransport: (() => void) | null = null;
 
   // Monotonic message-id minter. Seeded from the wall clock so ids stay
   // unique and ascending across restarts (history rows persist their ids).
@@ -576,6 +585,12 @@ export function createNativeFrontend(
               broadcast({ kind: "delta", chatId: entry.id, text: event.text });
               break;
             case "tool_call": {
+              // Delivery plumbing (end_turn / send_message / react) never
+              // enters the tool timeline — its effect arrives as the
+              // `message`/reaction itself. Skipping here keeps the live
+              // stream, the mid-turn replay to late joiners, and the
+              // persisted turn meta consistent from one choke point.
+              if (isDeliveryTool(event.name)) break;
               const input = toolInputToRecord(event.name, event.input);
               turnTools.set(event.id, {
                 call: { id: event.id, name: event.name, input },
@@ -592,6 +607,7 @@ export function createNativeFrontend(
               break;
             }
             case "tool_result": {
+              if (isDeliveryTool(event.name)) break;
               const output = summarizeToolResult(event.result);
               const live = turnTools.get(event.id);
               if (live) {
@@ -724,6 +740,7 @@ export function createNativeFrontend(
     return {
       app: "talon-bridge",
       protocol: BRIDGE_PROTOCOL_VERSION,
+      capabilities: ["mesh", "mesh-commands"],
       botName,
       backend: config.backend,
       model: resolveModel(config.model)?.displayName ?? config.model,
@@ -1027,7 +1044,11 @@ export function createNativeFrontend(
           if (msg.role === "assistant") {
             const meta = getTurnMeta(id, msg.id);
             if (meta) {
-              if (meta.tools?.length) msg.tools = meta.tools;
+              // Delivery tools are excluded at record time, but metas
+              // persisted by older daemons still carry them — filter on
+              // the way out so upgraded installs get clean history too.
+              const tools = meta.tools?.filter((t) => !isDeliveryTool(t.name));
+              if (tools?.length) msg.tools = tools;
               if (meta.durationMs) msg.durationMs = meta.durationMs;
               if (meta.tokensIn) msg.tokensIn = meta.tokensIn;
               if (meta.tokensOut) msg.tokensOut = meta.tokensOut;
@@ -1149,6 +1170,12 @@ export function createNativeFrontend(
       readLogEntries(files.log, { limit: lines, minLevel, component }),
     liveTurnEvents,
     mediaPath: (id) => media.get(id) ?? null,
+    // Mesh routes are thin transport shims over the shared core service —
+    // storeLocation wakes any pending fresh-fix waiters inside the service.
+    registerDevice: (body) => mesh.register(body),
+    storeLocation: (body) => mesh.storeLocation(body),
+    listDevices: () => mesh.list(),
+    completeCommand: (body) => mesh.completeCommand(body),
   };
 
   const nativeCfg = config.native ?? { port: 19880, host: "127.0.0.1" };
@@ -1190,6 +1217,24 @@ export function createNativeFrontend(
     getBridgePort: () => gateway.getPort(),
 
     async init() {
+      await mesh.load();
+      // Plug this bridge in as the mesh's transport: locates and device
+      // commands (from ANY frontend's mesh tool calls) fan out to every
+      // connected companion client as SSE events; each client filters by
+      // its own device id.
+      unregisterMeshTransport = mesh.registerTransport({
+        locate: (deviceId) => broadcast({ kind: "locate", deviceId }),
+        command: (command) =>
+          broadcast({
+            kind: "device_command",
+            id: command.id,
+            deviceId: command.deviceId,
+            name: command.name,
+            params: command.params,
+          }),
+      });
+      // Mesh tool actions (list_devices / get_device_location) are shared
+      // gateway actions now — no native-only cases here.
       gateway.registerFrontendHandler(
         "native",
         createNativeActionHandler({
@@ -1219,6 +1264,8 @@ export function createNativeFrontend(
     },
 
     async stop() {
+      unregisterMeshTransport?.();
+      unregisterMeshTransport = null;
       await removeBridgeDiscovery();
       await server.stop();
       await gateway.stop();

package/src/frontend/native/protocol.ts

@@ -35,6 +35,11 @@ export type ClientButton = { text: string; url?: string; data?: string };
  * A tool invocation that ran during an assistant turn, persisted so history
  * shows what the model did even after a reload/restart (additive in v1 —
  * older clients simply ignore the field).
+ *
+ * Reply-delivery tools (`end_turn` / `send_message` / `react`) never appear
+ * here or in `tool` events — the daemon classifies and excludes them at the
+ * source, because their effect already reaches clients as the `message` /
+ * `reaction` itself. Clients render tool timelines as-is, no name filtering.
  */
 export type ClientToolCall = {
   id: string;
@@ -134,6 +139,8 @@ export type ClientChat = {
 export type BridgeStatus = {
   app: "talon-bridge";
   protocol: number;
+  /** Additive bridge features supported by this daemon. */
+  capabilities?: string[];
   botName: string;
   backend: string;
   /** Display name of the global default model. */
@@ -190,6 +197,18 @@ export type BackendOption = {
   label: string;
 };
 
+// Mesh device shapes are canonical in core (the mesh is daemon-wide state,
+// readable from every frontend); re-exported here so bridge clients keep
+// depending on the protocol module alone.
+export type {
+  DeviceCommand,
+  DeviceCommandResult,
+  DeviceInfo,
+  DeviceLocation,
+  DevicePlatform,
+} from "../../core/mesh/types.js";
+import type { DeviceCommand as MeshDeviceCommand } from "../../core/mesh/types.js";
+
 /**
  * Server → client events, delivered as SSE `data:` lines (one JSON object
  * each). The client switches on `kind`. Streaming text arrives as ephemeral
@@ -228,6 +247,20 @@ export type BridgeEvent =
       durationMs?: number;
       usage?: { input: number; output: number };
     }
+  | { kind: "locate"; deviceId?: string }
+  /**
+   * On-demand device command (ring, open_url, clipboard_*, status, …). The
+   * target device executes it and answers via POST /devices/command-result
+   * with the same `id` as `commandId`. Additive in v1 — app builds that
+   * predate the command channel simply ignore the event.
+   */
+  | {
+      kind: "device_command";
+      id: string;
+      deviceId: string;
+      name: string;
+      params: MeshDeviceCommand["params"];
+    }
   | { kind: "error"; chatId?: string; message: string };
 
 // ── Mappers (Talon internals → wire types) ───────────────────────────────────
@@ -251,3 +284,5 @@ export function historyToClientMessage(
     ts: m.timestamp,
   };
 }
+
+export { toDeviceInfo, toDeviceLocation } from "../../core/mesh/types.js";