talon-agent 5.0.0 → 5.1.0

package/src/core/engine/gateway-actions/native/search.ts

@@ -0,0 +1,212 @@
+/**
+ * `native_glob` / `native_search` — find files by pattern, find text inside
+ * them.
+ *
+ * ripgrep is the fast path on both hosts; when it isn't installed the local
+ * runs fall back to a pure-JS walker rather than lying "no matches", and a
+ * teleported run falls back to the device's find/grep.
+ */
+
+import { glob as fsGlob, readFile, stat as fsStat } from "node:fs/promises";
+import { join } from "node:path";
+import { getTeleport } from "../../../mesh/teleport.js";
+import { bashTeleported } from "./exec-remote.js";
+import { resolvePathParam, str } from "./params.js";
+import type { Result } from "./results.js";
+import { runLocal, shellQuote } from "./shell.js";
+import type { SharedActionHandlers } from "../types.js";
+
+/**
+ * ripgrep binary, resolved from PATH (env-overridable for tests). NOT a
+ * hardcoded absolute path: /usr/bin/rg only exists on some Linux installs,
+ * and a missing binary must fall back loudly (or to the pure-JS walker),
+ * never masquerade as "no matches".
+ */
+function rgBin(): string {
+  return process.env.TALON_NATIVE_RG ?? "rg";
+}
+/** Caps for the pure-JS glob/search fallbacks (rg unavailable). */
+const MAX_JS_RESULTS = 2_000;
+const MAX_JS_FILE_BYTES = 2 * 1024 * 1024;
+const SKIP_DIRS_RE = /(^|[\\/])(node_modules|\.git)([\\/]|$)/;
+
+export const searchHandlers: SharedActionHandlers = {
+  native_glob: (body, chatId) => glob(chatId, body.pattern, body.path),
+  native_search: (body, chatId) =>
+    search(chatId, body.pattern, body.path, body.glob, body.case_insensitive),
+};
+
+async function glob(
+  chatId: number,
+  pattern: unknown,
+  path: unknown,
+): Promise<Result> {
+  const pat = str(pattern);
+  if (!pat) return { ok: false, text: "A glob pattern is required." };
+  const active = await getTeleport(chatId);
+  const root = resolvePathParam(str(path) ?? ".", active?.deviceName);
+  if (active) {
+    // Prefer rg on the device; fall back to find (basename patterns via
+    // -name, path patterns via -path). `command -v` gates the choice so a
+    // no-match rg exit (1) isn't misread as "rg missing, run find too".
+    const findExpr = pat.includes("/")
+      ? `-type f -path ${shellQuote(`*${pat}`)}`
+      : `-type f -name ${shellQuote(pat)}`;
+    const cmd =
+      `if command -v rg >/dev/null 2>&1; ` +
+      `then rg --files -g ${shellQuote(pat)} ${shellQuote(root)}; ` +
+      `else find ${shellQuote(root)} ${findExpr} 2>/dev/null; fi`;
+    return bashTeleported(chatId, active.deviceId, cmd, 30_000);
+  }
+  const res = await runLocal(rgBin(), ["--files", "-g", pat, root]);
+  let files: string[];
+  if (res.code === 127) {
+    // rg not installed — pure-JS fallback rather than lying "no matches".
+    files = await globJs(pat, root);
+  } else if (res.code > 1 && !res.stdout.trim()) {
+    // exit 2 with output = partial results (e.g. permission-denied subdirs);
+    // exit 2 with none = a real error worth surfacing.
+    return {
+      ok: false,
+      text: `glob failed: ${res.stderr.trim() || `ripgrep exit ${res.code}`}`,
+    };
+  } else {
+    files = res.stdout.trim().split("\n").filter(Boolean);
+  }
+  // rg's parallel directory walk (and the JS fallback's) emit in
+  // nondeterministic order — sort so identical calls render identically.
+  files.sort();
+  return {
+    ok: true,
+    text: files.length
+      ? `${files.length} match(es):\n${files.slice(0, 200).join("\n")}${files.length > 200 ? `\n… (${files.length - 200} more)` : ""}`
+      : `No files match ${pat} under ${root}.`,
+  };
+}
+
+async function search(
+  chatId: number,
+  pattern: unknown,
+  path: unknown,
+  globPat: unknown,
+  caseInsensitive: unknown,
+): Promise<Result> {
+  const pat = str(pattern);
+  if (!pat) return { ok: false, text: "A search pattern is required." };
+  const active = await getTeleport(chatId);
+  const root = resolvePathParam(str(path) ?? ".", active?.deviceName);
+  const g = str(globPat);
+  const ci = caseInsensitive === true;
+  // `-e` keeps a pattern that starts with "-" from being parsed as a flag
+  // (same idiom for rg and grep).
+  const flags = [
+    "-n",
+    "--color=never",
+    ...(ci ? ["-i"] : []),
+    ...(g ? ["-g", g] : []),
+  ];
+  if (active) {
+    // Prefer rg on the device, fall back to grep (Android toybox has grep
+    // but rarely rg). --include is grep's closest analogue of -g.
+    const grepFlags = [
+      "-rn",
+      ...(ci ? ["-i"] : []),
+      ...(g ? [`--include=${g}`] : []),
+    ];
+    const cmd =
+      `if command -v rg >/dev/null 2>&1; ` +
+      `then rg ${flags.map(shellQuote).join(" ")} -e ${shellQuote(pat)} ${shellQuote(root)}; ` +
+      `else grep ${grepFlags.map(shellQuote).join(" ")} -e ${shellQuote(pat)} ${shellQuote(root)} 2>/dev/null; fi`;
+    return bashTeleported(chatId, active.deviceId, cmd, 30_000);
+  }
+  const res = await runLocal(rgBin(), [...flags, "-e", pat, root]);
+  let lines: string[];
+  if (res.code === 127) {
+    // rg not installed — pure-JS fallback rather than lying "no matches".
+    try {
+      lines = await searchJs(pat, root, g, ci);
+    } catch (err) {
+      return { ok: false, text: `search failed: ${(err as Error).message}` };
+    }
+  } else if (res.code > 1 && !res.stdout.trim()) {
+    // exit 2 with output = partial results; exit 2 with none = real error.
+    return {
+      ok: false,
+      text: `search failed: ${res.stderr.trim() || `ripgrep exit ${res.code}`}`,
+    };
+  } else {
+    const out = res.stdout.trim();
+    lines = out ? out.split("\n") : [];
+  }
+  return {
+    ok: true,
+    text: lines.length
+      ? `${lines.length} match line(s):\n${lines.slice(0, 200).join("\n")}${lines.length > 200 ? `\n… (${lines.length - 200} more)` : ""}`
+      : `No matches for ${pat} under ${root}.`,
+  };
+}
+
+// ── pure-JS glob/search fallbacks (no ripgrep on the host) ──────────────────
+
+/**
+ * Glob without ripgrep, via node:fs `glob`. Mirrors rg's -g semantics for
+ * bare names (a pattern without "/" matches at any depth) and skips
+ * node_modules/.git, which rg would exclude via gitignore.
+ */
+async function globJs(pat: string, root: string): Promise<string[]> {
+  const pattern = pat.includes("/") ? pat : `**/${pat}`;
+  const out: string[] = [];
+  try {
+    for await (const entry of fsGlob(pattern, {
+      cwd: root,
+      exclude: (e: unknown) => {
+        const name =
+          typeof e === "string" ? e : ((e as { name?: string }).name ?? "");
+        return (
+          SKIP_DIRS_RE.test(name) || name === "node_modules" || name === ".git"
+        );
+      },
+    })) {
+      out.push(join(root, String(entry)));
+      if (out.length >= MAX_JS_RESULTS) break;
+    }
+  } catch {
+    // unreadable root etc. — empty result, caller reports "no matches"
+  }
+  return out;
+}
+
+/** Content search without ripgrep: walk text files and regex-match lines. */
+async function searchJs(
+  pat: string,
+  root: string,
+  globPat: string | undefined,
+  caseInsensitive: boolean,
+): Promise<string[]> {
+  const re = new RegExp(pat, caseInsensitive ? "i" : "");
+  let files: string[];
+  try {
+    const st = await fsStat(root);
+    files = st.isFile() ? [root] : await globJs(globPat ?? "**/*", root);
+  } catch {
+    return [];
+  }
+  const lines: string[] = [];
+  for (const f of files) {
+    let content: string;
+    try {
+      const st = await fsStat(f);
+      if (!st.isFile() || st.size > MAX_JS_FILE_BYTES) continue;
+      content = await readFile(f, "utf8");
+    } catch {
+      continue;
+    }
+    if (content.includes("\0")) continue; // binary
+    const fileLines = content.split("\n");
+    for (let i = 0; i < fileLines.length; i++) {
+      if (re.test(fileLines[i])) lines.push(`${f}:${i + 1}:${fileLines[i]}`);
+      if (lines.length >= MAX_JS_RESULTS) return lines;
+    }
+  }
+  return lines;
+}

package/src/core/engine/gateway-actions/native/shell.ts

@@ -0,0 +1,39 @@
+/**
+ * Talking to a shell: POSIX single-quoting for a command Talon builds, and a
+ * plain local spawn that collects exit code + stdout + stderr (used for the
+ * ripgrep invocations behind glob/search).
+ */
+
+import { spawn } from "node:child_process";
+import { createOutputCapture } from "../../../../util/exec-output.js";
+
+export function shellQuote(s: string): string {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+
+export function runLocal(
+  bin: string,
+  args: string[],
+): Promise<{ code: number; stdout: string; stderr: string }> {
+  return new Promise((resolvePromise) => {
+    const child = spawn(bin, args, { env: process.env });
+    const stdout = createOutputCapture();
+    const stderr = createOutputCapture();
+    child.stdout.on("data", stdout.push);
+    child.stderr.on("data", stderr.push);
+    child.on("error", () =>
+      resolvePromise({
+        code: 127,
+        stdout: stdout.value(),
+        stderr: stderr.value(),
+      }),
+    );
+    child.on("close", (code) =>
+      resolvePromise({
+        code: code ?? 0,
+        stdout: stdout.value(),
+        stderr: stderr.value(),
+      }),
+    );
+  });
+}

package/src/core/engine/gateway-actions/native/teleport.ts

@@ -0,0 +1,55 @@
+/**
+ * Teleport control — which host the native tools in this directory target.
+ *
+ *   teleport(device)  → native tools run ON that companion device
+ *   teleport_back()   → native tools run on the daemon host again
+ */
+
+import { getMeshService } from "../../../mesh/index.js";
+import { clearTeleport, setTeleport } from "../../../mesh/teleport.js";
+import type { Result } from "./results.js";
+import type { SharedActionHandlers } from "../types.js";
+
+export const teleportHandlers: SharedActionHandlers = {
+  teleport: (body, chatId) => teleport(chatId, body.device),
+  teleport_back: (_body, chatId) => teleportBack(chatId),
+};
+
+async function teleport(chatId: number, query: unknown): Promise<Result> {
+  const svc = getMeshService();
+  await svc.list();
+  const resolved = svc.resolveDevice(query);
+  if ("error" in resolved) return { ok: false, text: resolved.error };
+  const target = resolved.target;
+  if (!target.online) {
+    return {
+      ok: false,
+      text: `${target.name} appears offline — cannot teleport onto a device that isn't connected.`,
+    };
+  }
+  if (target.capabilities && !target.capabilities.includes("exec")) {
+    return {
+      ok: false,
+      text: `${target.name} does not advertise the "exec" capability, so teleport can't run commands on it.`,
+    };
+  }
+  await setTeleport(chatId, target.id, target.name);
+  return {
+    ok: true,
+    text: [
+      `🛰️ Teleported onto ${target.name}. Native bash/read/write/edit/glob/search now run ON that device.`,
+      `Working dir starts at the device default; \`cd\` in bash persists across calls.`,
+      `Call teleport_back to return to the daemon host.`,
+    ].join(" "),
+  };
+}
+
+async function teleportBack(chatId: number): Promise<Result> {
+  const prior = await clearTeleport(chatId);
+  return {
+    ok: true,
+    text: prior
+      ? `↩️ Teleported back from ${prior.deviceName}. Native tools run on the daemon host again.`
+      : "Not teleported — native tools already run on the daemon host.",
+  };
+}

package/src/core/engine/gateway-actions/native/write.ts

@@ -0,0 +1,170 @@
+/**
+ * `native_write` / `native_edit` — the file-mutating half of the native
+ * tools, local or teleported.
+ *
+ * `edit` splices literally (never String.replace, whose `$` patterns would
+ * corrupt shell snippets and regexes), refuses binary files, and points at
+ * the closest-looking line when old_string doesn't match byte-for-byte.
+ */
+
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { getMeshService } from "../../../mesh/index.js";
+import { getTeleport } from "../../../mesh/teleport.js";
+import { resolvePathParam, str } from "./params.js";
+import type { Result } from "./results.js";
+import type { SharedActionHandlers } from "../types.js";
+
+export const writeHandlers: SharedActionHandlers = {
+  native_write: (body, chatId) => write(chatId, body.path, body.content),
+  native_edit: (body, chatId) =>
+    edit(chatId, body.path, body.old_string, body.new_string, body.replace_all),
+};
+
+async function write(
+  chatId: number,
+  path: unknown,
+  content: unknown,
+): Promise<Result> {
+  const address = str(path);
+  if (!address) return { ok: false, text: "A file path is required." };
+  const body = typeof content === "string" ? content : "";
+  const active = await getTeleport(chatId);
+  const p = resolvePathParam(address, active?.deviceName);
+  const shown = p === address ? p : `${address} → ${p}`;
+  if (active) {
+    return getMeshService().writeFileToDevice(active.deviceId, p, body);
+  }
+  try {
+    await mkdir(dirname(p), { recursive: true });
+    await writeFile(p, body);
+  } catch (err) {
+    return {
+      ok: false,
+      text: `Cannot write ${shown}: ${(err as Error).message}`,
+    };
+  }
+  return {
+    ok: true,
+    text: `Wrote ${Buffer.byteLength(body, "utf8")} bytes to ${shown} [local].`,
+  };
+}
+
+async function edit(
+  chatId: number,
+  path: unknown,
+  oldString: unknown,
+  newString: unknown,
+  replaceAll: unknown,
+): Promise<Result> {
+  const address = str(path);
+  if (!address) return { ok: false, text: "A file path is required." };
+  const from = typeof oldString === "string" ? oldString : "";
+  const to = typeof newString === "string" ? newString : "";
+  if (from === to)
+    return { ok: false, text: "old_string and new_string are identical." };
+  const active = await getTeleport(chatId);
+  const p = resolvePathParam(address, active?.deviceName);
+  const shown = p === address ? p : `${address} → ${p}`;
+  const svc = getMeshService();
+
+  let content: string;
+  if (active) {
+    const res = await svc.readFileBytes(active.deviceId, p);
+    if ("error" in res) return { ok: false, text: res.error };
+    content = res.data.toString("utf8");
+  } else {
+    try {
+      content = await readFile(p, "utf8");
+    } catch (err) {
+      return {
+        ok: false,
+        text: `Cannot read ${shown}: ${(err as Error).message}`,
+      };
+    }
+  }
+
+  // Binary guard: decoding binary as UTF-8 is lossy (invalid sequences
+  // become U+FFFD), so a read→replace→write round-trip would corrupt every
+  // non-text byte — even when old_string matches a clean region.
+  if (content.includes("\0")) {
+    return {
+      ok: false,
+      text: `${shown} looks binary — refusing a text edit that would corrupt it. Use bash for byte-level changes.`,
+    };
+  }
+
+  const count = from ? content.split(from).length - 1 : 0;
+  if (count === 0) {
+    return {
+      ok: false,
+      text: `old_string not found in ${shown}.${nearMissHint(content, from)}`,
+    };
+  }
+  if (count > 1 && replaceAll !== true) {
+    return {
+      ok: false,
+      text: `old_string appears ${count}× in ${shown}; pass replace_all or make it unique.`,
+    };
+  }
+  // Splice, not String.replace: replace() treats dollar-sign substitution
+  // patterns ($&, $', $BACKTICK, $$) in the replacement as directives, silently
+  // corrupting any new_string that contains them (shell snippets, regexes,
+  // Makefiles...). split/join and index-splice are both literal.
+  const updated =
+    replaceAll === true
+      ? content.split(from).join(to)
+      : spliceOnce(content, from, to);
+  const firstLine = content.slice(0, content.indexOf(from)).split("\n").length;
+
+  if (active) {
+    const res = await svc.writeFileToDevice(active.deviceId, p, updated);
+    return res.ok
+      ? {
+          ok: true,
+          text: `Edited ${shown} [${active.deviceName}] (${count} replacement${count === 1 ? "" : "s"}, first at line ${firstLine}).`,
+        }
+      : res;
+  }
+  try {
+    await writeFile(p, updated);
+  } catch (err) {
+    return {
+      ok: false,
+      text: `Cannot write ${shown}: ${(err as Error).message}`,
+    };
+  }
+  return {
+    ok: true,
+    text: `Edited ${shown} [local] (${count} replacement${count === 1 ? "" : "s"}, first at line ${firstLine}).`,
+  };
+}
+
+/**
+ * When an edit's old_string doesn't match verbatim, the cause is almost
+ * always invisible: indentation, tabs vs spaces, or a trailing space. Point
+ * at the closest-looking line so the model re-reads that region instead of
+ * blindly retrying the same string.
+ */
+function nearMissHint(content: string, from: string): string {
+  const probe =
+    from
+      .split("\n")
+      .map((l) => l.trim())
+      .find((l) => l.length >= 8) ?? from.trim();
+  if (!probe) return "";
+  const lines = content.split("\n");
+  const idx = lines.findIndex((l) => l.trim().includes(probe));
+  if (idx === -1) return "";
+  return (
+    `\nLine ${idx + 1} looks close — whitespace/indentation must match the file byte-for-byte. ` +
+    `Re-read that region before retrying:\n${String(idx + 1).padStart(6)}\t${lines[idx]}`
+  );
+}
+
+/** Replace the first occurrence of `from` with `to`, both taken literally. */
+function spliceOnce(content: string, from: string, to: string): string {
+  const idx = content.indexOf(from);
+  if (idx === -1) return content;
+  return content.slice(0, idx) + to + content.slice(idx + from.length);
+}

package/src/core/frontend-runtime/builtins.ts

@@ -7,7 +7,7 @@
  * imports `src/frontend/factories.ts`.
  *
  * Chat-id shapes are the long-standing conventions from
- * `util/chat-id.ts`. Priorities encode the historical resolution order
+ * `./chat-id.ts`. Priorities encode the historical resolution order
  * (terminal, native, teams, discord, telegram) — load-bearing in two
  * places: telegram's numeric matcher is a near-catch-all so it must run
  * last, and the terminal claims the legacy chat id "1" that telegram's
@@ -25,7 +25,7 @@ import {
   isTelegramChatId,
   isTerminalChatId,
   isWhatsAppChatId,
-} from "../../util/chat-id.js";
+} from "./chat-id.js";
 
 function registerBuiltinFrontends(): void {
   registerFrontend({

package/src/core/mcp-hub/children.ts

@@ -100,6 +100,16 @@ export function formatChildExit(
   return lines.length > 0 ? `${head}; stderr: ${lines.join(" | ")}` : head;
 }
 
+/**
+ * Human-readable form of a child key for log lines. Keys join server name
+ * and chat id with a NUL byte (see `childKey` in index.ts) — unambiguous
+ * as a Map key, but it renders as `\u0000` in the JSON log.
+ */
+function describeKey(key: string): string {
+  const nul = key.indexOf("\u0000");
+  return nul === -1 ? key : `${key.slice(0, nul)} chat=${key.slice(nul + 1)}`;
+}
+
 /**
  * Bookkeeping for a child process that has gone away, asked or not.
  * Wired as the transport's `onclose` BEFORE `client.connect` so the SDK
@@ -125,7 +135,7 @@ function onChildClosed(key: string, transport: HubChildTransport): void {
     : "died before registration";
   logWarn(
     "gateway",
-    `hub child ${key} ${phase} (pid ${transport.pid ?? "?"}): ${formatChildExit(record)}`,
+    `hub child ${describeKey(key)} ${phase} (pid ${transport.pid ?? "?"}): ${formatChildExit(record)}`,
   );
 }
 
@@ -199,7 +209,10 @@ async function spawnChild(key: string, spec: ChildSpec): Promise<ChildHandle> {
           try {
             await client.close();
           } catch (err) {
-            logWarn("gateway", `hub child ${key} close failed: ${String(err)}`);
+            logWarn(
+              "gateway",
+              `hub child ${describeKey(key)} close failed: ${String(err)}`,
+            );
           }
         })());
     })(),
@@ -226,7 +239,10 @@ async function spawnChild(key: string, spec: ChildSpec): Promise<ChildHandle> {
   };
 
   children.set(key, entry);
-  log("gateway", `hub child started: ${key} (pid ${transport.pid ?? "?"})`);
+  log(
+    "gateway",
+    `hub child started: ${describeKey(key)} (pid ${transport.pid ?? "?"})`,
+  );
   return entry.handle;
 }
 
@@ -327,9 +343,9 @@ function reapIdle(): void {
     if (entry.lastActivity >= cutoff) continue;
     children.delete(key);
     entry.close().catch((err) => {
-      logError("gateway", `hub reap of ${key} failed`, err);
+      logError("gateway", `hub reap of ${describeKey(key)} failed`, err);
     });
-    log("gateway", `hub child reaped (idle): ${key}`);
+    log("gateway", `hub child reaped (idle): ${describeKey(key)}`);
   }
 }
 

package/src/core/mcp-hub/index.ts

@@ -38,7 +38,7 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
 import { getPluginMcpServers } from "../plugin/index.js";
-import { wrapMcpServer } from "../../util/mcp-launcher.js";
+import { wrapMcpServer } from "./launcher.js";
 import { log, logError } from "../../util/log.js";
 import { buildTalonToolServer, VALID_TOOL_FRONTENDS } from "./talon-server.js";
 import { buildProxyServer } from "./proxy-server.js";

package/src/core/mcp-hub/talon-server.ts

@@ -16,7 +16,7 @@
 
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { composeTools } from "../tools/index.js";
-import { createBridge, textResult } from "../tools/bridge.js";
+import { createBridge, textResult } from "../tools/ops/bridge.js";
 import type { ToolFrontend, ToolTag } from "../tools/types.js";
 
 export const VALID_TOOL_FRONTENDS: ReadonlySet<string> = new Set([

package/src/core/memory/taps.ts

@@ -37,7 +37,7 @@ import {
   type MemorySource,
   type MemoryTrust,
 } from "../../storage/memory.js";
-import { chatScope } from "../../util/chat-id.js";
+import { chatScope } from "../frontend-runtime/chat-id.js";
 import { log, logWarn } from "../../util/log.js";
 
 /**

package/src/core/plugin/mcp.ts

@@ -6,7 +6,7 @@
 
 import { resolve } from "node:path";
 import { logWarn } from "../../util/log.js";
-import { wrapMcpServer } from "../../util/mcp-launcher.js";
+import { wrapMcpServer } from "../mcp-hub/launcher.js";
 import { isBunRuntime } from "../../util/runtime.js";
 import { registry, reloadState } from "./registry.js";
 import type { McpServerConfig } from "./types.js";

package/src/core/scripts/lua.ts

@@ -7,7 +7,7 @@
  * (kill/respawn, SIGTERM grace, log streaming, TALON_FIRE line scanning)
  * is built around child processes. Lua therefore runs as `talon _lua-run
  * <script>` — the same self-reinvocation shape MCP supervision uses
- * (util/mcp-launcher.ts) — so it works identically for tsx source runs,
+ * (core/mcp-hub/launcher.ts) — so it works identically for tsx source runs,
  * npm installs, and bun-compiled binaries with no source tree on disk.
  *
  * Sandbox (verified empirically, not aspirational):

package/src/core/tools/{chat.ts → chat/chat.ts}

@@ -3,7 +3,7 @@
  */
 
 import { z } from "zod";
-import type { ToolDefinition } from "./types.js";
+import type { ToolDefinition } from "../types.js";
 
 export const chatTools: ToolDefinition[] = [
   {

package/src/core/tools/{cross-send.ts → chat/cross-send.ts}

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import type { ToolDefinition } from "./types.js";
+import type { ToolDefinition } from "../types.js";
 
 /**
  * Cross-frontend send. Deliberately NOT frontend-restricted (the meshTools

package/src/core/tools/{history.ts → chat/history.ts}

@@ -3,8 +3,8 @@
  */
 
 import { z } from "zod";
-import type { ToolDefinition } from "./types.js";
-import { snowflakeOrIdSchema } from "./schemas.js";
+import type { ToolDefinition } from "../types.js";
+import { snowflakeOrIdSchema } from "../schemas.js";
 
 export const historyTools: ToolDefinition[] = [
   {

package/src/core/tools/{media.ts → chat/media.ts}

@@ -3,7 +3,7 @@
  */
 
 import { z } from "zod";
-import type { ToolDefinition } from "./types.js";
+import type { ToolDefinition } from "../types.js";
 
 export const mediaTools: ToolDefinition[] = [
   {

package/src/core/tools/{members.ts → chat/members.ts}

@@ -3,8 +3,8 @@
  */
 
 import { z } from "zod";
-import type { ToolDefinition } from "./types.js";
-import { snowflakeOrIdSchema } from "./schemas.js";
+import type { ToolDefinition } from "../types.js";
+import { snowflakeOrIdSchema } from "../schemas.js";
 
 export const memberTools: ToolDefinition[] = [
   {

package/src/core/tools/{messaging.ts → chat/messaging.ts}

@@ -4,8 +4,8 @@
  */
 
 import { z } from "zod";
-import type { ToolDefinition } from "./types.js";
-import { chatIdSchema, idSchema, snowflakeOrIdSchema } from "./schemas.js";
+import type { ToolDefinition } from "../types.js";
+import { chatIdSchema, idSchema, snowflakeOrIdSchema } from "../schemas.js";
 
 /**
  * Throw a typed Error when a bridge response reports failure