talon-agent 1.34.0 → 1.35.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talon-agent",
-  "version": "1.34.0",
+  "version": "1.35.0",
   "description": "Multi-frontend AI agent with full tool access, streaming, cron jobs, and plugin system",
   "author": "Dylan Neve",
   "license": "MIT",
@@ -100,8 +100,8 @@
     "@grammyjs/transformer-throttler": "^1.2.1",
     "@kilocode/sdk": "^7.2.22",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@openai/agents": "^0.12.0",
-    "@openai/codex-sdk": "^0.142.0",
+    "@openai/agents": "^0.13.0",
+    "@openai/codex-sdk": "^0.143.0",
     "@opencode-ai/sdk": "^1.17.4",
     "@playwright/mcp": "^0.0.77",
     "@types/cross-spawn": "^6.0.6",

package/src/bootstrap.ts

@@ -28,7 +28,7 @@ import {
   initTriggers,
   resumeAfterRestart as resumeTriggersAfterRestart,
 } from "./core/background/triggers/index.js";
-import { initDream } from "./core/background/dream.js";
+import { initDream, maybeStartDream } from "./core/background/dream.js";
 import { initHeartbeat } from "./core/background/heartbeat/index.js";
 import { log, logWarn, logDebug } from "./util/log.js";
 import type { TalonConfig } from "./util/config.js";
@@ -409,6 +409,10 @@ export async function initBackendAndDispatcher(
         chatId,
       ),
     onActivity: () => resetPulseTimer(),
+    // Turn-start hook: fire-and-forget dream (background memory
+    // consolidation) check. Wired here so the Weaver stays ignorant of
+    // the dream subsystem.
+    onTurnStart: maybeStartDream,
   });
 
   initPulse();

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

@@ -16,6 +16,7 @@
  *   - `skills`    — markdown workflows
  *   - `plugins`   — plugin hot-reload
  *   - `models`    — model / backend discovery
+ *   - `mesh`      — companion device mesh (presence + location)
  */
 
 import type { ActionResult } from "../../types.js";
@@ -30,6 +31,7 @@ import { scriptHandlers } from "./scripts.js";
 import { skillHandlers } from "./skills.js";
 import { pluginHandlers } from "./plugins.js";
 import { modelHandlers } from "./models.js";
+import { meshHandlers } from "./mesh.js";
 
 // Null-prototype so a request `action` of "toString" / "constructor" / etc.
 // can't resolve an inherited Object.prototype method — `handlers[action]` only
@@ -44,6 +46,7 @@ const handlers: SharedActionHandlers = Object.assign(Object.create(null), {
   ...skillHandlers,
   ...pluginHandlers,
   ...modelHandlers,
+  ...meshHandlers,
 });
 
 export async function handleSharedAction(

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

@@ -0,0 +1,22 @@
+/**
+ * Device mesh — read tools (list_devices, get_device_location,
+ * get_device_history) and command tools (ring, live status).
+ *
+ * Shared actions, so the model has full mesh access from every frontend
+ * (Telegram, Discord, Teams, terminal, native) — not just chats running
+ * through the native bridge. The mesh itself is daemon-wide state
+ * (core/mesh); the native bridge is merely the transport companions
+ * register through and commands travel over.
+ */
+
+import { getMeshService } from "../../mesh/index.js";
+import type { SharedActionHandlers } from "./types.js";
+
+export const meshHandlers: SharedActionHandlers = {
+  list_devices: () => getMeshService().describeDevices(),
+  get_device_location: (body) => getMeshService().locateDevice(body.device),
+  get_device_history: (body) =>
+    getMeshService().deviceHistory(body.device, body.hours),
+  ring_device: (body) => getMeshService().ringDevice(body.device, body.message),
+  get_device_status: (body) => getMeshService().getDeviceStatus(body.device),
+};

package/src/core/engine/gateway.ts

@@ -16,7 +16,7 @@ import {
 import pRetry, { AbortError } from "p-retry";
 import { classify } from "../errors.js";
 import { getActiveCount } from "./dispatcher.js";
-import { Loom, getActiveLoom } from "../weaver/index.js";
+import { Loom, getActiveLoom, type ContextRegistry } from "../weaver/index.js";
 import { getHealthStatus } from "../../util/watchdog.js";
 import { getActiveSessionCount } from "../../storage/sessions.js";
 import { log, logError, logDebug } from "../../util/log.js";
@@ -89,13 +89,14 @@ export async function withRetry<T>(fn: () => Promise<T>): Promise<T> {
 export class Gateway {
   /**
    * Per-chat live state is owned by the Weaver's Loom. The gateway holds no
-   * registry of its own — it delegates here. `getActiveLoom()` returns the
-   * Weaver's Loom once the dispatcher is wired; the standalone fallback covers
-   * unit tests and the brief startup window before init (when no turn — and so
-   * no context — can exist anyway).
+   * registry of its own — it delegates here, and only through the
+   * `ContextRegistry` face (the gateway never creates or evicts Threads).
+   * `getActiveLoom()` returns the Weaver's Loom once the dispatcher is wired;
+   * the standalone fallback covers unit tests and the brief startup window
+   * before init (when no turn — and so no context — can exist anyway).
    */
   private readonly ownLoom = new Loom();
-  private get loom(): Loom {
+  private get loom(): ContextRegistry {
     return getActiveLoom() ?? this.ownLoom;
   }
 

package/src/core/mesh/index.ts

@@ -0,0 +1,27 @@
+/**
+ * Device mesh — core module barrel.
+ *
+ * Registry (persistence) + service (policy, locate fan-out, tool surface) +
+ * canonical device/location types. Transports and gateway actions import
+ * from here.
+ */
+
+export { MeshRegistry } from "./registry.js";
+export {
+  MeshService,
+  getMeshService,
+  setMeshService,
+  type MeshTransport,
+  type MeshServiceOptions,
+  type MeshToolResult,
+} from "./service.js";
+export {
+  sanitizeCapabilities,
+  toDeviceInfo,
+  toDeviceLocation,
+  type DeviceCommand,
+  type DeviceCommandResult,
+  type DeviceInfo,
+  type DeviceLocation,
+  type DevicePlatform,
+} from "./types.js";

package/src/core/mesh/registry.ts

@@ -0,0 +1,272 @@
+/**
+ * MeshRegistry — persistent storage for companion devices, last-known
+ * locations, and a bounded per-device location/battery history.
+ *
+ * Pure state: validate, upsert, persist (0600 JSON sidecars under the Talon
+ * root). No transport and no waiting logic — that policy lives in
+ * MeshService, so the registry stays trivially testable.
+ */
+
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { dirs } from "../../util/paths.js";
+import {
+  sanitizeCapabilities,
+  toDeviceInfo,
+  toDeviceLocation,
+  type DeviceInfo,
+  type DeviceLocation,
+  type DevicePlatform,
+} from "./types.js";
+
+const PRESENCE_TIMEOUT_MS = 90_000;
+const DEVICE_FILE = resolve(dirs.root, "mesh-devices.json");
+const LOCATION_FILE = resolve(dirs.root, "mesh-locations.json");
+const HISTORY_FILE = resolve(dirs.root, "mesh-history.json");
+/** Newest fixes kept per device (~a day of 5-minute periodic reports). */
+const MAX_HISTORY_PER_DEVICE = 500;
+const PLATFORMS = new Set<DevicePlatform>([
+  "android",
+  "macos",
+  "windows",
+  "linux",
+  "ios",
+]);
+
+export class MeshRegistry {
+  private devices = new Map<string, DeviceInfo>();
+  private locations = new Map<string, DeviceLocation>();
+  private history = new Map<string, DeviceLocation[]>();
+
+  constructor(
+    private readonly files = {
+      devices: DEVICE_FILE,
+      locations: LOCATION_FILE,
+      history: HISTORY_FILE,
+    },
+  ) {}
+
+  async load(): Promise<void> {
+    this.devices = new Map(
+      (await readArray<DeviceInfo>(this.files.devices))
+        .map((d) => sanitizeDevice(d, d.lastSeen, false))
+        .filter((d): d is DeviceInfo => d !== null)
+        .map((d) => [d.id, d]),
+    );
+    this.locations = new Map(
+      (await readArray<DeviceLocation>(this.files.locations))
+        .map(sanitizeLocation)
+        .filter((l): l is DeviceLocation => l !== null)
+        .map((l) => [l.deviceId, l]),
+    );
+    this.history = new Map();
+    for (const fix of (await readArray<DeviceLocation>(this.files.history))
+      .map(sanitizeLocation)
+      .filter((l): l is DeviceLocation => l !== null)) {
+      this.appendHistory(fix);
+    }
+  }
+
+  async register(
+    body: Record<string, unknown>,
+    now = Date.now(),
+  ): Promise<DeviceInfo> {
+    const next = sanitizeDevice(body, now, true);
+    if (!next) throw new Error("Invalid device registration");
+    const prev = this.devices.get(next.id);
+    const device = toDeviceInfo(
+      {
+        ...prev,
+        ...next,
+        online: true,
+        lastSeen: now,
+      },
+      now,
+    );
+    this.devices.set(device.id, device);
+    await this.persistDevices();
+    return device;
+  }
+
+  async storeLocation(
+    body: Record<string, unknown>,
+    now = Date.now(),
+  ): Promise<DeviceLocation> {
+    const loc = sanitizeLocation(body);
+    if (!loc) throw new Error("Invalid device location");
+    this.locations.set(loc.deviceId, loc);
+    const device = this.devices.get(loc.deviceId);
+    if (device) {
+      this.devices.set(
+        loc.deviceId,
+        toDeviceInfo(
+          {
+            ...device,
+            online: true,
+            lastSeen: now,
+            ...(typeof loc.batteryPct === "number"
+              ? { battery: loc.batteryPct }
+              : {}),
+          },
+          now,
+        ),
+      );
+      await this.persistDevices();
+    }
+    this.appendHistory(loc);
+    await this.persistLocations();
+    await this.persistHistory();
+    return loc;
+  }
+
+  /** Fixes for one device since `sinceTs`, oldest first. */
+  getHistory(deviceId: string, sinceTs = 0): DeviceLocation[] {
+    return (this.history.get(deviceId) ?? [])
+      .filter((l) => l.ts >= sinceTs)
+      .map(toDeviceLocation);
+  }
+
+  /** Append one fix to the device's rolling history (dedup on timestamp,
+   *  chronological order, bounded to MAX_HISTORY_PER_DEVICE). */
+  private appendHistory(fix: DeviceLocation): void {
+    const list = this.history.get(fix.deviceId) ?? [];
+    if (list.some((l) => l.ts === fix.ts)) return;
+    list.push(toDeviceLocation(fix));
+    list.sort((a, b) => a.ts - b.ts);
+    if (list.length > MAX_HISTORY_PER_DEVICE) {
+      list.splice(0, list.length - MAX_HISTORY_PER_DEVICE);
+    }
+    this.history.set(fix.deviceId, list);
+  }
+
+  list(now = Date.now()): {
+    devices: DeviceInfo[];
+    locations: DeviceLocation[];
+  } {
+    return {
+      devices: [...this.devices.values()]
+        .map((d) => toDeviceInfo(d, now, PRESENCE_TIMEOUT_MS))
+        .sort((a, b) => b.lastSeen - a.lastSeen),
+      locations: [...this.locations.values()]
+        .map(toDeviceLocation)
+        .sort((a, b) => b.ts - a.ts),
+    };
+  }
+
+  getLocation(deviceId: string): DeviceLocation | undefined {
+    const loc = this.locations.get(deviceId);
+    return loc ? toDeviceLocation(loc) : undefined;
+  }
+
+  private async persistDevices(): Promise<void> {
+    await writePrivateJson(this.files.devices, [...this.devices.values()]);
+  }
+
+  private async persistLocations(): Promise<void> {
+    await writePrivateJson(this.files.locations, [...this.locations.values()]);
+  }
+
+  private async persistHistory(): Promise<void> {
+    await writePrivateJson(
+      this.files.history,
+      [...this.history.values()].flat(),
+    );
+  }
+}
+
+async function readArray<T>(path: string): Promise<T[]> {
+  try {
+    const raw = await readFile(path, "utf8");
+    const parsed = JSON.parse(raw) as unknown;
+    return Array.isArray(parsed) ? (parsed as T[]) : [];
+  } catch {
+    return [];
+  }
+}
+
+async function writePrivateJson(path: string, value: unknown): Promise<void> {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+}
+
+function sanitizeDevice(
+  body: Record<string, unknown>,
+  now: number,
+  requireCore: boolean,
+): DeviceInfo | null {
+  const id = stringField(body.id);
+  const name = stringField(body.name);
+  const appVersion = stringField(body.appVersion);
+  const platform = stringField(body.platform) as DevicePlatform | undefined;
+  if ((requireCore || id !== undefined) && !id) return null;
+  if ((requireCore || name !== undefined) && !name) return null;
+  if ((requireCore || appVersion !== undefined) && !appVersion) return null;
+  if (
+    (requireCore || platform !== undefined) &&
+    (!platform || !PLATFORMS.has(platform))
+  ) {
+    return null;
+  }
+  return {
+    id: id ?? "",
+    name: name ?? "",
+    platform: platform ?? "linux",
+    appVersion: appVersion ?? "",
+    online: body.online === true,
+    lastSeen: numberField(body.lastSeen) ?? now,
+    ...(numberField(body.battery) !== undefined
+      ? { battery: numberField(body.battery) }
+      : {}),
+    ...(typeof body.charging === "boolean" ? { charging: body.charging } : {}),
+    ...(sanitizeCapabilities(body.capabilities)
+      ? { capabilities: sanitizeCapabilities(body.capabilities) }
+      : {}),
+  };
+}
+
+function sanitizeLocation(
+  body: Record<string, unknown>,
+): DeviceLocation | null {
+  const deviceId = stringField(body.deviceId);
+  const lat = numberField(body.lat);
+  const lon = numberField(body.lon);
+  const ts = numberField(body.ts);
+  if (!deviceId || !Number.isFinite(lat) || !Number.isFinite(lon) || !ts) {
+    return null;
+  }
+  if (lat! < -90 || lat! > 90 || lon! < -180 || lon! > 180) return null;
+  return toDeviceLocation({
+    deviceId,
+    lat: lat!,
+    lon: lon!,
+    ...(numberField(body.accuracyM) !== undefined
+      ? { accuracyM: numberField(body.accuracyM) }
+      : {}),
+    ...(numberField(body.altitudeM) !== undefined
+      ? { altitudeM: numberField(body.altitudeM) }
+      : {}),
+    ...(numberField(body.speedMps) !== undefined
+      ? { speedMps: numberField(body.speedMps) }
+      : {}),
+    ...(numberField(body.headingDeg) !== undefined
+      ? { headingDeg: numberField(body.headingDeg) }
+      : {}),
+    ts,
+    ...(stringField(body.provider)
+      ? { provider: stringField(body.provider) }
+      : {}),
+    ...(numberField(body.batteryPct) !== undefined
+      ? { batteryPct: numberField(body.batteryPct) }
+      : {}),
+  });
+}
+
+function stringField(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function numberField(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value)
+    ? value
+    : undefined;
+}