talon-agent 1.48.0 → 1.50.0

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

@@ -33,6 +33,7 @@ import {
   setTeleport,
   setTeleportCwd,
 } from "../../mesh/teleport.js";
+import { getVfs } from "../../vfs/index.js";
 import {
   clampExecOutput,
   createOutputCapture,
@@ -447,6 +448,65 @@ async function bashTeleported(
   };
 }
 
+// ── talon:// address resolution ─────────────────────────────────────────────
+
+const NAMESPACE_SCHEME = "talon://";
+
+type AddressResolution =
+  | { kind: "disk"; path: string }
+  | { kind: "virtual" }
+  | { kind: "error"; text: string };
+
+/**
+ * Native fs tools accept talon:// addresses: `Vfs.locate` maps them to the
+ * disk location the address names, and the tool then operates on the real
+ * file. Synthetic nodes (proc/, plugins/) have no disk location — reads are
+ * served straight from the namespace, mutation refuses honestly. Teleport
+ * can't cross address spaces: talon:// names daemon state, and a teleported
+ * chat's paths belong to the device, so the combination is refused rather
+ * than resolved against the wrong filesystem.
+ */
+function resolveNamespaceAddress(
+  address: string,
+  teleportedTo: string | undefined,
+): AddressResolution {
+  if (teleportedTo !== undefined) {
+    return {
+      kind: "error",
+      text:
+        `${address} names the daemon's namespace, but native tools are ` +
+        `teleported onto ${teleportedTo} — teleport_back first, or use a device path.`,
+    };
+  }
+  const located = getVfs().locate(address);
+  if (!located.ok) {
+    return {
+      kind: "error",
+      text: `Cannot resolve ${address}: ${located.error}${located.detail ? ` — ${located.detail}` : ""}`,
+    };
+  }
+  return located.value === undefined
+    ? { kind: "virtual" }
+    : { kind: "disk", path: located.value };
+}
+
+/** glob/search root: a talon:// address must name a disk-backed directory. */
+function resolveSearchRoot(
+  path: string | undefined,
+  teleportedTo: string | undefined,
+): { root: string } | { error: string } {
+  const root = path ?? ".";
+  if (!root.startsWith(NAMESPACE_SCHEME)) return { root };
+  const resolved = resolveNamespaceAddress(root, teleportedTo);
+  if (resolved.kind === "error") return { error: resolved.text };
+  if (resolved.kind === "virtual") {
+    return {
+      error: `${root} is a synthetic view with no files on disk — browse it with vfs_list instead.`,
+    };
+  }
+  return { root: resolved.path };
+}
+
 // ── read / write / edit ─────────────────────────────────────────────────────
 
 async function read(
@@ -455,15 +515,38 @@ async function read(
   offset: unknown,
   limit: unknown,
 ): Promise<Result> {
-  const p = str(path);
-  if (!p) return { ok: false, text: "A file path is required." };
+  const address = str(path);
+  if (!address) return { ok: false, text: "A file path is required." };
   const active = await getTeleport(chatId);
   const where = active ? active.deviceName : "local";
 
+  let p = address;
+  let virtualContent: string | undefined;
+  if (address.startsWith(NAMESPACE_SCHEME)) {
+    const resolved = resolveNamespaceAddress(address, active?.deviceName);
+    if (resolved.kind === "error") return { ok: false, text: resolved.text };
+    if (resolved.kind === "disk") {
+      p = resolved.path;
+    } else {
+      const served = getVfs().read(address);
+      if (!served.ok) {
+        return {
+          ok: false,
+          text: `Cannot read ${address}: ${served.error}${served.detail ? ` — ${served.detail}` : ""}`,
+        };
+      }
+      virtualContent = served.value;
+    }
+  }
+  const shown = p === address ? p : `${address} → ${p}`;
+
   // Image files: return a viewable image block, not the raw bytes decoded as
   // UTF-8. Without this, `read`ing a photo/screenshot/design hands the model
   // mojibake and it can't see the picture at all.
-  const mime = IMAGE_MIME[extname(p).toLowerCase()];
+  const mime =
+    virtualContent === undefined
+      ? IMAGE_MIME[extname(p).toLowerCase()]
+      : undefined;
   if (mime) {
     let bytes: Buffer;
     if (active) {
@@ -476,7 +559,7 @@ async function read(
       } catch (err) {
         return {
           ok: false,
-          text: `Cannot read ${p}: ${(err as Error).message}`,
+          text: `Cannot read ${shown}: ${(err as Error).message}`,
         };
       }
     }
@@ -484,14 +567,14 @@ async function read(
       return {
         ok: false,
         text:
-          `${p} [${where}] is ${(bytes.length / 1_048_576).toFixed(1)}MB — over the ` +
+          `${shown} [${where}] is ${(bytes.length / 1_048_576).toFixed(1)}MB — over the ` +
           `${MAX_IMAGE_BYTES / 1_048_576}MB image limit. Downscale it first ` +
           `(e.g. \`convert '${p}' -resize 1568x /tmp/small.jpg\`) and read that.`,
       };
     }
     return {
       ok: true,
-      text: `${p} [${where}] — image (${mime}, ${bytes.length} bytes)`,
+      text: `${shown} [${where}] — image (${mime}, ${bytes.length} bytes)`,
       image: { data: bytes.toString("base64"), mimeType: mime },
     };
   }
@@ -499,7 +582,9 @@ async function read(
   const start = num(offset) ?? 0;
   const max = Math.min(num(limit) ?? MAX_READ_LINES, MAX_READ_LINES);
   let content: string;
-  if (active) {
+  if (virtualContent !== undefined) {
+    content = virtualContent;
+  } else if (active) {
     const res = await getMeshService().readFileBytes(active.deviceId, p);
     if ("error" in res) return { ok: false, text: res.error };
     content = res.data.toString("utf8");
@@ -507,7 +592,10 @@ async function read(
     try {
       content = await readFile(p, "utf8");
     } catch (err) {
-      return { ok: false, text: `Cannot read ${p}: ${(err as Error).message}` };
+      return {
+        ok: false,
+        text: `Cannot read ${shown}: ${(err as Error).message}`,
+      };
     }
   }
   const lines = content.split("\n");
@@ -521,7 +609,7 @@ async function read(
       : "";
   return {
     ok: true,
-    text: `${p} [${where}] — ${lines.length} lines\n${numbered}${more}`,
+    text: `${shown} [${where}] — ${lines.length} lines\n${numbered}${more}`,
   };
 }
 
@@ -530,10 +618,23 @@ async function write(
   path: unknown,
   content: unknown,
 ): Promise<Result> {
-  const p = str(path);
-  if (!p) return { ok: false, text: "A file path is required." };
+  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);
+  let p = address;
+  if (address.startsWith(NAMESPACE_SCHEME)) {
+    const resolved = resolveNamespaceAddress(address, active?.deviceName);
+    if (resolved.kind === "error") return { ok: false, text: resolved.text };
+    if (resolved.kind === "virtual") {
+      return {
+        ok: false,
+        text: `${address} is a synthetic view — there is no file on disk to write. Writable mounts: vfs_list "" shows where each lives.`,
+      };
+    }
+    p = resolved.path;
+  }
+  const shown = p === address ? p : `${address} → ${p}`;
   if (active) {
     return getMeshService().writeFileToDevice(active.deviceId, p, body);
   }
@@ -541,9 +642,12 @@ async function write(
     await mkdir(dirname(p), { recursive: true });
     await writeFile(p, body);
   } catch (err) {
-    return { ok: false, text: `Cannot write ${p}: ${(err as Error).message}` };
+    return {
+      ok: false,
+      text: `Cannot write ${shown}: ${(err as Error).message}`,
+    };
   }
-  return { ok: true, text: `Wrote ${body.length} bytes to ${p} [local].` };
+  return { ok: true, text: `Wrote ${body.length} bytes to ${shown} [local].` };
 }
 
 async function edit(
@@ -553,13 +657,26 @@ async function edit(
   newString: unknown,
   replaceAll: unknown,
 ): Promise<Result> {
-  const p = str(path);
-  if (!p) return { ok: false, text: "A file path is required." };
+  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);
+  let p = address;
+  if (address.startsWith(NAMESPACE_SCHEME)) {
+    const resolved = resolveNamespaceAddress(address, active?.deviceName);
+    if (resolved.kind === "error") return { ok: false, text: resolved.text };
+    if (resolved.kind === "virtual") {
+      return {
+        ok: false,
+        text: `${address} is a synthetic view — there is no file on disk to edit. Read it with vfs_read instead.`,
+      };
+    }
+    p = resolved.path;
+  }
+  const shown = p === address ? p : `${address} → ${p}`;
   const svc = getMeshService();
 
   let content: string;
@@ -571,7 +688,10 @@ async function edit(
     try {
       content = await readFile(p, "utf8");
     } catch (err) {
-      return { ok: false, text: `Cannot read ${p}: ${(err as Error).message}` };
+      return {
+        ok: false,
+        text: `Cannot read ${shown}: ${(err as Error).message}`,
+      };
     }
   }
 
@@ -579,13 +699,13 @@ async function edit(
   if (count === 0) {
     return {
       ok: false,
-      text: `old_string not found in ${p}.${nearMissHint(content, from)}`,
+      text: `old_string not found in ${shown}.${nearMissHint(content, from)}`,
     };
   }
   if (count > 1 && replaceAll !== true) {
     return {
       ok: false,
-      text: `old_string appears ${count}× in ${p}; pass replace_all or make it unique.`,
+      text: `old_string appears ${count}× in ${shown}; pass replace_all or make it unique.`,
     };
   }
   const updated =
@@ -598,18 +718,21 @@ async function edit(
     return res.ok
       ? {
           ok: true,
-          text: `Edited ${p} [${active.deviceName}] (${count} replacement${count === 1 ? "" : "s"}).`,
+          text: `Edited ${shown} [${active.deviceName}] (${count} replacement${count === 1 ? "" : "s"}).`,
         }
       : res;
   }
   try {
     await writeFile(p, updated);
   } catch (err) {
-    return { ok: false, text: `Cannot write ${p}: ${(err as Error).message}` };
+    return {
+      ok: false,
+      text: `Cannot write ${shown}: ${(err as Error).message}`,
+    };
   }
   return {
     ok: true,
-    text: `Edited ${p} [local] (${count} replacement${count === 1 ? "" : "s"}).`,
+    text: `Edited ${shown} [local] (${count} replacement${count === 1 ? "" : "s"}).`,
   };
 }
 
@@ -622,8 +745,10 @@ async function glob(
 ): Promise<Result> {
   const pat = str(pattern);
   if (!pat) return { ok: false, text: "A glob pattern is required." };
-  const root = str(path) ?? ".";
   const active = await getTeleport(chatId);
+  const rooted = resolveSearchRoot(str(path), active?.deviceName);
+  if ("error" in rooted) return { ok: false, text: rooted.error };
+  const root = rooted.root;
   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
@@ -669,7 +794,10 @@ async function search(
 ): Promise<Result> {
   const pat = str(pattern);
   if (!pat) return { ok: false, text: "A search pattern is required." };
-  const root = str(path) ?? ".";
+  const active = await getTeleport(chatId);
+  const rooted = resolveSearchRoot(str(path), active?.deviceName);
+  if ("error" in rooted) return { ok: false, text: rooted.error };
+  const root = rooted.root;
   const g = str(globPat);
   const ci = caseInsensitive === true;
   // `-e` keeps a pattern that starts with "-" from being parsed as a flag
@@ -680,7 +808,6 @@ async function search(
     ...(ci ? ["-i"] : []),
     ...(g ? ["-g", g] : []),
   ];
-  const active = await getTeleport(chatId);
   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.

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

@@ -0,0 +1,69 @@
+/**
+ * VFS — the `talon://` namespace over the gateway: list / read / write.
+ * Formatting only; the namespace itself lives in core/vfs.
+ */
+
+import { getVfs, type VfsResult, type VfsStat } from "../../vfs/index.js";
+import { log } from "../../../util/log.js";
+import type { SharedActionHandlers } from "./types.js";
+
+function describeError(
+  path: string,
+  result: { error: string; detail?: string },
+): string {
+  return `talon://${path}: ${result.error}${result.detail ? ` — ${result.detail}` : ""}`;
+}
+
+function formatSize(entry: VfsStat): string {
+  return entry.kind === "dir" ? "-" : String(entry.size ?? "?");
+}
+
+function formatEntry(entry: VfsStat): string {
+  const kind = entry.kind === "dir" ? "d" : "-";
+  const write = entry.writable ? "w" : "-";
+  const suffix = entry.kind === "dir" ? "/" : "";
+  // Root entries (single-segment paths) show where the mount lives on
+  // disk — the bridge for OS-level tools, which can't read talon://.
+  const mapping =
+    entry.osPath !== undefined && !entry.path.includes("/")
+      ? `  → ${entry.osPath}`
+      : "";
+  return `${kind}${write} ${formatSize(entry).padStart(9)}  ${entry.name}${suffix}${mapping}`;
+}
+
+function normalize(body: Record<string, unknown>): string {
+  return String(body.path ?? "").trim();
+}
+
+export const vfsHandlers: SharedActionHandlers = {
+  vfs_list: (body) => {
+    const path = normalize(body);
+    const result = getVfs().list(path);
+    if (!result.ok) return { ok: false, error: describeError(path, result) };
+    const header = `talon://${path.replace(/\/+$/, "")}${path ? "/" : ""} (${result.value.length} entries)`;
+    const lines = result.value.map(formatEntry);
+    return {
+      ok: true,
+      text: [header, ...(lines.length > 0 ? lines : ["(empty)"])].join("\n"),
+    };
+  },
+
+  vfs_read: (body) => {
+    const path = normalize(body);
+    const result = getVfs().read(path);
+    if (!result.ok) return { ok: false, error: describeError(path, result) };
+    return { ok: true, text: result.value };
+  },
+
+  vfs_write: (body) => {
+    const path = normalize(body);
+    const content = String(body.content ?? "");
+    const result: VfsResult<VfsStat> = getVfs().write(path, content);
+    if (!result.ok) return { ok: false, error: describeError(path, result) };
+    log("gateway", `vfs_write: talon://${result.value.path}`);
+    return {
+      ok: true,
+      text: `Wrote ${result.value.size ?? content.length} bytes to talon://${result.value.path}`,
+    };
+  },
+};

package/src/core/engine/gateway.ts

@@ -27,6 +27,7 @@ import {
   HUB_PATH_PREFIX,
 } from "../mcp-hub/index.js";
 import { handlePluginAction } from "../plugin/index.js";
+import { bus } from "../bus/index.js";
 import { taskTable } from "../tasks/index.js";
 import type { FrontendActionHandler } from "../types.js";
 import { BOT_MESSAGE_ACTIONS, noteBotMessage } from "../soul/taps.js";
@@ -396,6 +397,51 @@ export class Gateway {
           return;
         }
 
+        if (req.method === "GET" && req.url?.startsWith("/events/recent")) {
+          // Bus tail — recent events, optionally after a cursor. Read by
+          // `talon events`. Same 127.0.0.1 trust boundary as /action.
+          const url = new URL(req.url, "http://gateway");
+          const since = Number(url.searchParams.get("since") ?? "0");
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(
+            JSON.stringify({
+              ok: true,
+              events: bus.recent(
+                Number.isInteger(since) && since > 0 ? since : 0,
+              ),
+            }),
+          );
+          return;
+        }
+
+        if (
+          req.method === "GET" &&
+          (req.url?.startsWith("/vfs/list") || req.url?.startsWith("/vfs/read"))
+        ) {
+          // The talon:// namespace — the transport for `talon ls` /
+          // `talon cat`, which need the daemon's live synthetic mounts
+          // (proc, plugins). Same 127.0.0.1 trust boundary as /action.
+          const url = new URL(req.url, "http://gateway");
+          const path = url.searchParams.get("path") ?? "";
+          const { getVfs } = await import("../vfs/index.js");
+          const vfs = getVfs();
+          let result: Record<string, unknown>;
+          if (url.pathname === "/vfs/list") {
+            const listed = vfs.list(path);
+            result = listed.ok
+              ? { ok: true, entries: listed.value }
+              : { ok: false, error: listed.error, detail: listed.detail };
+          } else {
+            const content = vfs.read(path);
+            result = content.ok
+              ? { ok: true, content: content.value }
+              : { ok: false, error: content.error, detail: content.detail };
+          }
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify(result));
+          return;
+        }
+
         if (req.method === "GET" && req.url === "/tasks") {
           // The task table — every live/recent unit of agent work. Read by
           // `talon ps`. Same 127.0.0.1 trust boundary as /action.

package/src/core/tasks/table.ts

@@ -12,6 +12,8 @@
  * work that no longer exists.
  */
 
+import { bus } from "../bus/index.js";
+import type { TaskSettledEvent, TaskStartedEvent } from "../bus/events.js";
 import type {
   KillOutcome,
   TaskBinding,
@@ -25,6 +27,17 @@ import type {
 /** Settled tasks kept for `list()` after they leave the live map. */
 const DEFAULT_HISTORY_LIMIT = 50;
 
+export interface TaskTableOptions {
+  /** Settled tasks kept for `list()` (default 50). */
+  readonly historyLimit?: number;
+  /**
+   * Sink for `task.*` lifecycle events — the singleton wires the bus here.
+   * Injected (rather than imported at the emit sites) so unit-constructed
+   * tables stay silent.
+   */
+  readonly publish?: (event: TaskStartedEvent | TaskSettledEvent) => void;
+}
+
 type MutableTaskRecord = {
   -readonly [K in keyof TaskRecord]: TaskRecord[K];
 };
@@ -39,10 +52,14 @@ export class TaskTable {
   private readonly live = new Map<number, LiveTask>();
   private readonly history: TaskRecord[] = [];
   private readonly historyLimit: number;
+  private readonly publish?: (
+    event: TaskStartedEvent | TaskSettledEvent,
+  ) => void;
   private nextId = 1;
 
-  constructor(historyLimit = DEFAULT_HISTORY_LIMIT) {
-    this.historyLimit = historyLimit;
+  constructor(options: TaskTableOptions = {}) {
+    this.historyLimit = options.historyLimit ?? DEFAULT_HISTORY_LIMIT;
+    if (options.publish) this.publish = options.publish;
   }
 
   /** Register a run that starts immediately. */
@@ -75,7 +92,7 @@ export class TaskTable {
       start: () => this.start(id),
       bind: (binding) => this.bind(id, binding),
       succeed: (usage) => this.settle(id, "done", undefined, usage),
-      fail: (error) => this.settle(id, "failed", error),
+      fail: (error, usage) => this.settle(id, "failed", error, usage),
     };
   }
 
@@ -122,6 +139,7 @@ export class TaskTable {
     if (!task || task.record.state !== "queued") return;
     task.record.state = "running";
     task.record.startedAt = Date.now();
+    this.publish?.({ type: "task.started", task: { ...task.record } });
   }
 
   private bind(id: number, binding: TaskBinding): void {
@@ -154,8 +172,11 @@ export class TaskTable {
     if (this.history.length > this.historyLimit) {
       this.history.splice(0, this.history.length - this.historyLimit);
     }
+    this.publish?.({ type: "task.settled", task: { ...record } });
   }
 }
 
 /** The daemon-wide table. Tests needing isolation construct their own. */
-export const taskTable = new TaskTable();
+export const taskTable = new TaskTable({
+  publish: (event) => bus.publish(event),
+});

package/src/core/tasks/types.ts

@@ -87,8 +87,12 @@ export interface TaskHandle {
   bind(binding: TaskBinding): void;
   /** Settle as `done`, optionally recording token usage. */
   succeed(usage?: TaskUsage): void;
-  /** Settle as `failed` — or `killed` when a kill was requested first. */
-  fail(error: unknown): void;
+  /**
+   * Settle as `failed` — or `killed` when a kill was requested first.
+   * Usage is recorded when the owner knows what the run burned before it
+   * died (an interrupted turn still spent real tokens).
+   */
+  fail(error: unknown, usage?: TaskUsage): void;
 }
 
 /** Result of `TaskTable.kill`. */

package/src/core/tools/index.ts

@@ -23,6 +23,7 @@ import { adminTools } from "./admin.js";
 import { modelTools } from "./models.js";
 import { meshTools } from "./mesh.js";
 import { nativeTools } from "./native.js";
+import { vfsTools } from "./vfs.js";
 
 /** All built-in tool definitions. */
 export const ALL_TOOLS: readonly ToolDefinition[] = [
@@ -41,6 +42,7 @@ export const ALL_TOOLS: readonly ToolDefinition[] = [
   ...adminTools,
   ...modelTools,
   ...meshTools,
+  ...vfsTools,
 ];
 
 /**

package/src/core/tools/native.ts

@@ -39,7 +39,8 @@ export const nativeTools: ToolDefinition[] = [
     name: "bash",
     description:
       "Run a shell command. Runs on the daemon host, or ON the active teleport device if one is engaged. On a teleported device, `cd` persists across calls (a real working-directory session). " +
-      "Foreground runs are killed at timeout_sec — for streaming/never-ending commands (adb logcat, tail -f, dev servers, watchers) set background:true instead: the command is launched detached in its own process group with stdout+stderr captured to a log file, and the tool returns immediately with the pid + log path so you can poll the log and kill it when done.",
+      "Foreground runs are killed at timeout_sec — for streaming/never-ending commands (adb logcat, tail -f, dev servers, watchers) set background:true instead: the command is launched detached in its own process group with stdout+stderr captured to a log file, and the tool returns immediately with the pid + log path so you can poll the log and kill it when done. " +
+      "talon:// addresses are not OS paths — the shell needs the disk locations the namespace root listing shows (vfs_list).",
     schema: {
       command: z.string().describe("The shell command to run."),
       cwd: z
@@ -69,7 +70,11 @@ export const nativeTools: ToolDefinition[] = [
     description:
       "Read a file (with line numbers). Runs on the daemon host or the active teleport device. Supports offset/limit for large files.",
     schema: {
-      path: z.string().describe("Absolute file path."),
+      path: z
+        .string()
+        .describe(
+          "Absolute file path, or a talon:// namespace address (resolved on the daemon host).",
+        ),
       offset: z.number().optional().describe("0-based line to start from."),
       limit: z
         .number()
@@ -84,7 +89,11 @@ export const nativeTools: ToolDefinition[] = [
     description:
       "Write (create/overwrite) a file with the given content. Runs on the daemon host or the active teleport device.",
     schema: {
-      path: z.string().describe("Absolute file path."),
+      path: z
+        .string()
+        .describe(
+          "Absolute file path, or a talon:// namespace address (resolved on the daemon host).",
+        ),
       content: z.string().describe("Full file content to write."),
     },
     execute: (params, bridge) => bridge("native_write", params),
@@ -95,7 +104,11 @@ export const nativeTools: ToolDefinition[] = [
     description:
       "Exact-string replacement in a file. old_string must be unique unless replace_all is set. Runs on the daemon host or the active teleport device.",
     schema: {
-      path: z.string().describe("Absolute file path."),
+      path: z
+        .string()
+        .describe(
+          "Absolute file path, or a talon:// namespace address (resolved on the daemon host).",
+        ),
       old_string: z.string().describe("Exact text to replace."),
       new_string: z.string().describe("Replacement text."),
       replace_all: z
@@ -115,7 +128,7 @@ export const nativeTools: ToolDefinition[] = [
       path: z
         .string()
         .optional()
-        .describe("Root directory to search (default cwd)."),
+        .describe("Root directory to search (default cwd; talon:// accepted)."),
     },
     execute: (params, bridge) => bridge("native_glob", params),
     tag: "native",
@@ -129,7 +142,7 @@ export const nativeTools: ToolDefinition[] = [
       path: z
         .string()
         .optional()
-        .describe("Root directory or file (default cwd)."),
+        .describe("Root directory or file (default cwd; talon:// accepted)."),
       glob: z
         .string()
         .optional()

package/src/core/tools/types.ts

@@ -28,7 +28,8 @@ export type ToolTag =
   | "admin"
   | "models"
   | "mesh"
-  | "native";
+  | "native"
+  | "vfs";
 
 /** The bridge caller signature — injected into execute(). */
 export type BridgeFunction = (