@sjawhar/opencode-legion-envoy 0.1.6 → 0.1.8

package/AGENTS.md

@@ -12,7 +12,7 @@ It is the user-facing bridge between OpenCode sessions and Envoy transport.
 
 | Task                | Location               | Notes                                                              |
 | ------------------- | ---------------------- | ------------------------------------------------------------------ |
-| Tool definitions    | `src/index.ts`         | `envoy_subscribe`, `envoy_unsubscribe`, `envoy_list`, `envoy_send` |
+| Tool definitions    | `src/index.ts`         | `envoy_subscribe`, `envoy_unsubscribe`, `envoy_list`, `envoy_send`, `envoy_publish`, `envoy_role_set`, `envoy_whoami`, `envoy_sessions` |
 | Packaging metadata  | `package.json`         | npm identity, build scripts                                        |
 | Distribution output | `dist/index.js`        | built plugin consumed by OpenCode                                  |
 | Host rollout helper | `scripts/sync-host.sh` | sync dist + shim to remote host                                    |

package/dist/index.js

@@ -14,9 +14,6 @@ var __export = (target, all) => {
     });
 };
 
-// src/index.ts
-import { readFileSync, unlinkSync, writeFileSync } from "fs";
-
 // ../../node_modules/.bun/zod@4.1.8/node_modules/zod/v4/classic/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -12332,7 +12329,7 @@ function date4(params) {
 
 // ../../node_modules/.bun/zod@4.1.8/node_modules/zod/v4/classic/external.js
 config(en_default());
-// ../../node_modules/.bun/@opencode-ai+plugin@1.2.27/node_modules/@opencode-ai/plugin/dist/tool.js
+// ../../node_modules/.bun/@opencode-ai+plugin@1.4.3/node_modules/@opencode-ai/plugin/dist/tool.js
 function tool(input) {
   return input;
 }
@@ -12385,28 +12382,9 @@ async function call(path, init) {
   return text;
 }
 var src_default = async (input) => {
-  const registryDir = process.env.OC_REGISTRY;
   let activeSessionID = null;
-  let _activeFile = null;
+  let activeSessionTitle = null;
   let resolvedPort = null;
-  const registryFile = (sessionID) => registryDir ? `${registryDir}/${sessionID}.json` : null;
-  const update = (sessionID, patch) => {
-    const file2 = registryFile(sessionID);
-    if (!file2)
-      return;
-    try {
-      let data = {};
-      try {
-        data = JSON.parse(readFileSync(file2, "utf-8"));
-      } catch {
-        data = { pid: process.pid, dir: process.cwd(), started: new Date().toISOString() };
-      }
-      Object.assign(data, patch);
-      writeFileSync(file2, `${JSON.stringify(data)}
-`);
-      registryFiles.add(file2);
-    } catch {}
-  };
   let portWarningLogged = false;
   const refreshPort = async () => {
     const port = await resolvePort(input.serverUrl);
@@ -12421,78 +12399,71 @@ var src_default = async (input) => {
     return port;
   };
   const currentPort = () => resolvedPort;
-  const syncPort = async (sessionID) => {
+  const syncPort = async () => {
     const value = await refreshPort();
-    if (!value)
-      return false;
-    if (sessionID)
-      update(sessionID, { port: value });
-    return true;
+    return value !== null;
   };
-  const fetchSession = async (sessionID) => {
+  const fetchTitle = async (sessionID) => {
     try {
-      const res = await fetch(`${input.serverUrl}/session/${sessionID}`, {
+      const res = await fetch(`${input.serverUrl.href}session/${sessionID}`, {
         signal: AbortSignal.timeout(CALL_TIMEOUT_MS)
       });
       if (!res.ok)
         return null;
-      const session = await res.json();
-      return { id: session.id, title: session.title || "" };
+      const data = await res.json();
+      return data.title ?? null;
     } catch {
       return null;
     }
   };
-  const registryFiles = new Set;
-  if (registryDir) {
-    const timer = setInterval(() => {
-      syncPort(activeSessionID ?? undefined).then((resolved) => {
-        if (resolved)
-          clearInterval(timer);
-      });
-    }, 1000);
-    timer.unref();
-    syncPort().catch(() => {});
-    const heartbeatInterval = setInterval(() => {
-      if (!activeSessionID)
-        return;
-      const port = currentPort();
-      if (!port)
-        return;
-      call("/v1/interests/subscribe", {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          session_id: activeSessionID,
-          dir: process.cwd(),
-          topics: [`notifications.agent.${activeSessionID}`],
-          port
-        })
-      }).catch(() => {});
-    }, 2 * 60 * 1000);
-    process.on("exit", () => {
-      clearInterval(timer);
-      clearInterval(heartbeatInterval);
-      for (const f of registryFiles) {
-        try {
-          unlinkSync(f);
-        } catch {}
-      }
+  const timer = setInterval(() => {
+    syncPort().then((resolved) => {
+      if (resolved)
+        clearInterval(timer);
     });
-  }
+  }, 1000);
+  timer.unref();
+  syncPort().catch(() => {});
+  const heartbeatInterval = setInterval(() => {
+    if (!activeSessionID)
+      return;
+    const port = currentPort();
+    if (!port)
+      return;
+    call("/v1/interests/subscribe", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        session_id: activeSessionID,
+        dir: process.cwd(),
+        topics: [`notifications.agent.${activeSessionID}`],
+        port,
+        title: activeSessionTitle ?? ""
+      })
+    }).catch(() => {});
+  }, 2 * 60 * 1000);
+  process.on("exit", () => {
+    clearInterval(timer);
+    clearInterval(heartbeatInterval);
+  });
   return {
-    event: registryDir ? async ({ event }) => {
+    event: async ({
+      event
+    }) => {
       if (activeSessionID)
-        syncPort(activeSessionID).catch(() => {});
+        syncPort().catch(() => {});
       if (event.type === "session.status" && event.properties?.status?.type === "busy") {
         const sessionID = event.properties?.sessionID;
         if (sessionID && sessionID !== activeSessionID) {
           activeSessionID = sessionID;
-          _activeFile = registryFile(sessionID);
-          const session = await fetchSession(sessionID);
-          if (session)
-            update(sessionID, { session });
-          await syncPort(sessionID);
+          activeSessionTitle = null;
+          await syncPort();
           const port = currentPort();
+          const titlePromise = fetchTitle(sessionID).then((t) => {
+            if (t && activeSessionID === sessionID)
+              activeSessionTitle = t;
+            return t;
+          });
           if (port) {
             call("/v1/interests/subscribe", {
               method: "POST",
@@ -12501,27 +12472,29 @@ var src_default = async (input) => {
                 session_id: sessionID,
                 dir: process.cwd(),
                 topics: [`notifications.agent.${sessionID}`],
-                port
+                port,
+                title: activeSessionTitle ?? ""
               })
             }).catch(() => {});
+            titlePromise.then((title) => {
+              if (title && activeSessionID === sessionID) {
+                call("/v1/interests/subscribe", {
+                  method: "POST",
+                  headers: { "Content-Type": "application/json" },
+                  body: JSON.stringify({
+                    session_id: sessionID,
+                    dir: process.cwd(),
+                    topics: [`notifications.agent.${sessionID}`],
+                    port: currentPort() ?? 0,
+                    title
+                  })
+                }).catch(() => {});
+              }
+            });
           }
         }
       }
-      if (event.type === "session.updated") {
-        const info = event.properties?.info;
-        if (info && info.id === activeSessionID) {
-          update(info.id, { session: { id: info.id, title: info.title || "" } });
-        }
-      }
-      if (event.type === "session.idle") {
-        const sessionID = event.properties?.sessionID;
-        if (sessionID && sessionID === activeSessionID) {
-          const session = await fetchSession(sessionID);
-          if (session)
-            update(sessionID, { session });
-        }
-      }
-    } : undefined,
+    },
     tool: {
       envoy_subscribe: tool({
         description: "Subscribe this session to Envoy notification topics. GitHub topics are resource-scoped: notifications.github.<owner>.<repo>.pr.<number>, notifications.github.<owner>.<repo>.issue.<number>.comment, etc. Use NATS wildcards for broad subscriptions: notifications.github.<owner>.<repo>.pr.> (all PR events). Other topics: notifications.agent.<session_id>, notifications.slack.<team_id>.<channel_id>.message, notifications.slack.<team_id>.<channel_id>.mention. Use this when a session should RECEIVE future events.",
@@ -12537,7 +12510,8 @@ var src_default = async (input) => {
               session_id: ctx.sessionID,
               dir: ctx.directory,
               topics: args.topics,
-              port: currentPort() ?? 0
+              port: currentPort() ?? 0,
+              title: activeSessionTitle ?? ""
             })
           });
         }
@@ -12621,6 +12595,35 @@ var src_default = async (input) => {
             })
           });
         }
+      }),
+      envoy_whoami: tool({
+        description: "Returns this session's Envoy identity: session ID, machine ID, port, and directory.",
+        args: {},
+        async execute(_args, ctx) {
+          ctx.metadata({ title: "Envoy whoami" });
+          const sessionID = ctx.sessionID;
+          const port = currentPort();
+          return JSON.stringify({
+            session_id: sessionID,
+            machine_id: process.env.HOSTNAME || "unknown",
+            port,
+            dir: ctx.directory
+          }, null, 2);
+        }
+      }),
+      envoy_sessions: tool({
+        description: "List all live sessions registered with Envoy. Returns session ID, machine ID, port, directory, title, topics, and last-seen timestamp for each. Use the optional machine filter to show only sessions on a specific host.",
+        args: {
+          machine: tool.schema.string().optional().describe("Filter to sessions on this machine ID (e.g. hostname). Omit to list all machines.")
+        },
+        async execute(args, ctx) {
+          ctx.metadata({ title: "Envoy sessions" });
+          const res = await call("/v1/sessions");
+          if (!args.machine)
+            return res;
+          const sessions = JSON.parse(res);
+          return JSON.stringify(sessions.filter((s) => s.machine_id === args.machine), null, 2);
+        }
       })
     }
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjawhar/opencode-legion-envoy",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "type": "module",
   "main": "dist/index.js",
   "repository": {

package/src/__tests__/index.test.ts

@@ -13,9 +13,7 @@ describe("envoy plugin init", () => {
   it("returns immediately without blocking on port resolution or Envoy calls", async () => {
     // Simulate NATS/Envoy being unavailable — plugin init must still complete fast
     const originalEnvoyUrl = process.env.ENVOY_URL;
-    const originalRegistry = process.env.OC_REGISTRY;
     process.env.ENVOY_URL = "http://127.0.0.1:59999"; // Non-existent
-    process.env.OC_REGISTRY = undefined;
 
     try {
       const pluginModule = await import("../index");
@@ -33,9 +31,10 @@ describe("envoy plugin init", () => {
       expect(hooks.tool.envoy_list).toBeDefined();
       expect(hooks.tool.envoy_send).toBeDefined();
       expect(hooks.tool.envoy_publish).toBeDefined();
+      expect(hooks.tool.envoy_whoami).toBeDefined();
+      expect(hooks.tool.envoy_sessions).toBeDefined();
     } finally {
       process.env.ENVOY_URL = originalEnvoyUrl;
-      process.env.OC_REGISTRY = originalRegistry;
     }
   });
 
@@ -43,9 +42,7 @@ describe("envoy plugin init", () => {
     // The call function has AbortSignal.timeout — verify it doesn't hang
     // We test this indirectly: a tool call to non-existent Envoy should reject within timeout
     const originalEnvoyUrl = process.env.ENVOY_URL;
-    const originalRegistry = process.env.OC_REGISTRY;
     process.env.ENVOY_URL = "http://127.0.0.1:59999";
-    process.env.OC_REGISTRY = undefined;
 
     try {
       const pluginModule = await import("../index");
@@ -68,7 +65,168 @@ describe("envoy plugin init", () => {
       expect(elapsed).toBeLessThan(6000);
     } finally {
       process.env.ENVOY_URL = originalEnvoyUrl;
-      process.env.OC_REGISTRY = originalRegistry;
+    }
+  });
+});
+
+describe("envoy_whoami", () => {
+  it("returns session identity when Envoy is unavailable", async () => {
+    const originalEnvoyUrl = process.env.ENVOY_URL;
+    const originalHostname = process.env.HOSTNAME;
+    process.env.ENVOY_URL = "http://127.0.0.1:59999";
+    process.env.HOSTNAME = "test-machine";
+
+    try {
+      const pluginModule = await import("../index");
+      const initPlugin = pluginModule.default;
+      const hooks = await initPlugin({
+        serverUrl: new URL("http://127.0.0.1:13381"),
+      } as never);
+
+      const result = await hooks.tool.envoy_whoami.execute({}, {
+        sessionID: "ses_test_whoami",
+        directory: "/tmp/test-workspace",
+        metadata: mock(() => {}),
+      } as never);
+
+      const parsed = JSON.parse(result);
+      expect(parsed.session_id).toBe("ses_test_whoami");
+      expect(parsed.machine_id).toBe("test-machine");
+      expect(parsed.dir).toBe("/tmp/test-workspace");
+      expect(parsed).not.toHaveProperty("topics");
+      expect(parsed.port === null || typeof parsed.port === "number").toBe(true);
+    } finally {
+      process.env.ENVOY_URL = originalEnvoyUrl;
+      if (originalHostname === undefined) {
+        delete process.env.HOSTNAME;
+      } else {
+        process.env.HOSTNAME = originalHostname;
+      }
+    }
+  });
+
+  it("uses 'unknown' for machine_id when HOSTNAME is not set", async () => {
+    const originalEnvoyUrl = process.env.ENVOY_URL;
+    const originalHostname = process.env.HOSTNAME;
+    process.env.ENVOY_URL = "http://127.0.0.1:59999";
+    delete process.env.HOSTNAME;
+
+    try {
+      const pluginModule = await import("../index");
+      const initPlugin = pluginModule.default;
+      const hooks = await initPlugin({
+        serverUrl: new URL("http://127.0.0.1:13381"),
+      } as never);
+
+      const result = await hooks.tool.envoy_whoami.execute({}, {
+        sessionID: "ses_no_hostname",
+        directory: "/tmp",
+        metadata: mock(() => {}),
+      } as never);
+
+      const parsed = JSON.parse(result);
+      expect(parsed.machine_id).toBe("unknown");
+    } finally {
+      process.env.ENVOY_URL = originalEnvoyUrl;
+      if (originalHostname === undefined) {
+        delete process.env.HOSTNAME;
+      } else {
+        process.env.HOSTNAME = originalHostname;
+      }
+    }
+  });
+});
+
+describe("envoy_sessions", () => {
+  it("rejects with error when Envoy is unavailable", async () => {
+    const originalEnvoyUrl = process.env.ENVOY_URL;
+    process.env.ENVOY_URL = "http://127.0.0.1:59999";
+
+    try {
+      const pluginModule = await import("../index");
+      const initPlugin = pluginModule.default;
+      const hooks = await initPlugin({
+        serverUrl: new URL("http://127.0.0.1:13381"),
+      } as never);
+
+      await expect(
+        hooks.tool.envoy_sessions.execute({}, {
+          sessionID: "ses_test",
+          directory: "/tmp",
+          metadata: mock(() => {}),
+        } as never)
+      ).rejects.toThrow();
+    } finally {
+      process.env.ENVOY_URL = originalEnvoyUrl;
+    }
+  });
+});
+
+describe("session title", () => {
+  it("includes title in follow-up subscribe after session activation", async () => {
+    const originalEnvoyUrl = process.env.ENVOY_URL;
+    process.env.ENVOY_URL = "http://127.0.0.1:59999";
+
+    const fetchCalls: { url: string; body?: string }[] = [];
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = (async (input: string | URL | Request, init?: RequestInit) => {
+      const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+      if (init?.body) {
+        fetchCalls.push({ url, body: init.body as string });
+      } else {
+        fetchCalls.push({ url });
+      }
+      // Serve API: return session with title
+      if (url.includes("/session/ses_title_test")) {
+        return new Response(JSON.stringify({ id: "ses_title_test", title: "Test Title" }), {
+          status: 200,
+          headers: { "Content-Type": "application/json" },
+        });
+      }
+      // Envoy subscribe calls: return success
+      if (url.includes("/v1/interests/subscribe")) {
+        return new Response(JSON.stringify({ session_id: "ses_title_test", topics: [] }), {
+          status: 200,
+          headers: { "Content-Type": "application/json" },
+        });
+      }
+      // Port resolution calls
+      if (url.includes("/session") && !url.includes("ses_title_test")) {
+        return new Response("not found", { status: 404 });
+      }
+      throw new Error("connection refused");
+    }) as typeof fetch;
+
+    try {
+      const pluginModule = await import("../index");
+      const hooks = await pluginModule.default({
+        serverUrl: new URL("http://127.0.0.1:13381/"),
+      } as never);
+
+      await hooks.event({
+        event: {
+          type: "session.status",
+          properties: {
+            sessionID: "ses_title_test",
+            status: { type: "busy" },
+          },
+        },
+      });
+
+      // Allow async title fetch and follow-up subscribe to complete
+      await new Promise((r) => setTimeout(r, 500));
+
+      const subscribeCalls = fetchCalls.filter(
+        (c) => c.url.includes("/v1/interests/subscribe") && c.body
+      );
+      const hasTitle = subscribeCalls.some((c) => {
+        const body = JSON.parse(c.body as string);
+        return body.title === "Test Title";
+      });
+      expect(hasTitle).toBe(true);
+    } finally {
+      globalThis.fetch = originalFetch;
+      process.env.ENVOY_URL = originalEnvoyUrl;
     }
   });
 });

package/src/index.ts

@@ -1,4 +1,3 @@
-import { readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { tool } from "@opencode-ai/plugin/tool";
 import { resolvePort } from "./port";
 
@@ -18,31 +17,11 @@ async function call(path: string, init?: RequestInit) {
 }
 
 export default async (input: { serverUrl: URL }) => {
-  const registryDir = process.env.OC_REGISTRY;
   let activeSessionID: string | null = null;
-  let _activeFile: string | null = null;
+  let activeSessionTitle: string | null = null;
   /** Cached port — resolved asynchronously, null until first successful resolution. */
   let resolvedPort: number | null = null;
 
-  const registryFile = (sessionID: string) =>
-    registryDir ? `${registryDir}/${sessionID}.json` : null;
-
-  const update = (sessionID: string, patch: Record<string, unknown>) => {
-    const file = registryFile(sessionID);
-    if (!file) return;
-    try {
-      let data: Record<string, unknown> = {};
-      try {
-        data = JSON.parse(readFileSync(file, "utf-8"));
-      } catch {
-        data = { pid: process.pid, dir: process.cwd(), started: new Date().toISOString() };
-      }
-      Object.assign(data, patch);
-      writeFileSync(file, `${JSON.stringify(data)}\n`);
-      registryFiles.add(file);
-    } catch {}
-  };
-
   let portWarningLogged = false;
   const refreshPort = async (): Promise<number | null> => {
     const port = await resolvePort(input.serverUrl);
@@ -62,90 +41,101 @@ export default async (input: { serverUrl: URL }) => {
   /** Return cached port synchronously — tools need a port value inline. */
   const currentPort = () => resolvedPort;
 
-  const syncPort = async (sessionID?: string): Promise<boolean> => {
+  const syncPort = async (): Promise<boolean> => {
     const value = await refreshPort();
-    if (!value) return false;
-    if (sessionID) update(sessionID, { port: value });
-    return true;
+    return value !== null;
   };
 
-  const fetchSession = async (sessionID: string) => {
+  /** Fetch session title from the OpenCode serve API. Best-effort — returns null on failure. */
+  const fetchTitle = async (sessionID: string): Promise<string | null> => {
     try {
-      const res = await fetch(`${input.serverUrl}/session/${sessionID}`, {
+      const res = await fetch(`${input.serverUrl.href}session/${sessionID}`, {
         signal: AbortSignal.timeout(CALL_TIMEOUT_MS),
       });
       if (!res.ok) return null;
-      const session = await res.json();
-      return { id: session.id, title: session.title || "" };
+      const data = (await res.json()) as { title?: string };
+      return data.title ?? null;
     } catch {
       return null;
     }
   };
 
-  // Track all registry files this process created, clean up on exit
-  const registryFiles = new Set<string>();
-
-  if (registryDir) {
-    // Defer port resolution to background — never block plugin init.
-    // The port sync loop retries every second until resolved.
-    const timer = setInterval(() => {
-      syncPort(activeSessionID ?? undefined).then((resolved) => {
-        if (resolved) clearInterval(timer);
-      });
-    }, 1000);
-    timer.unref(); // Don't prevent graceful shutdown if port never resolves
-    // Fire an immediate async attempt (non-blocking)
-    syncPort().catch(() => {});
+  // Defer port resolution to background — never block plugin init.
+  // The port sync loop retries every second until resolved.
+  const timer = setInterval(() => {
+    syncPort().then((resolved) => {
+      if (resolved) clearInterval(timer);
+    });
+  }, 1000);
+  timer.unref(); // Don't prevent graceful shutdown if port never resolves
+  // Fire an immediate async attempt (non-blocking)
+  syncPort().catch(() => {});
 
-    // Heartbeat: re-subscribe every 2 minutes to refresh envoy_sessions TTL (5-min)
-    const heartbeatInterval = setInterval(
-      () => {
-        if (!activeSessionID) return;
-        const port = currentPort();
-        if (!port) return;
-        call("/v1/interests/subscribe", {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({
-            session_id: activeSessionID,
-            dir: process.cwd(),
-            topics: [`notifications.agent.${activeSessionID}`],
-            port,
-          }),
-        }).catch(() => {});
-      },
-      2 * 60 * 1000
-    );
+  // Heartbeat: re-subscribe every 2 minutes to refresh envoy_sessions TTL (5-min)
+  const heartbeatInterval = setInterval(
+    () => {
+      if (!activeSessionID) return;
+      const port = currentPort();
+      if (!port) return;
+      call("/v1/interests/subscribe", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          session_id: activeSessionID,
+          dir: process.cwd(),
+          topics: [`notifications.agent.${activeSessionID}`],
+          port,
+          title: activeSessionTitle ?? "",
+        }),
+      }).catch(() => {});
+    },
+    2 * 60 * 1000
+  );
 
-    process.on("exit", () => {
-      clearInterval(timer);
-      clearInterval(heartbeatInterval);
-      for (const f of registryFiles) {
-        try {
-          unlinkSync(f);
-        } catch {}
-      }
-    });
-  }
+  process.on("exit", () => {
+    clearInterval(timer);
+    clearInterval(heartbeatInterval);
+  });
 
   return {
-    event: registryDir
-      ? async ({ event }: { event: { type?: string; properties?: Record<string, unknown> } }) => {
-          if (activeSessionID) syncPort(activeSessionID).catch(() => {});
+    event: async ({
+      event,
+    }: {
+      event: { type?: string; properties?: Record<string, unknown> };
+    }) => {
+      if (activeSessionID) syncPort().catch(() => {});
 
-          if (
-            event.type === "session.status" &&
-            (event.properties?.status as { type?: string } | undefined)?.type === "busy"
-          ) {
-            const sessionID = event.properties?.sessionID as string | undefined;
-            if (sessionID && sessionID !== activeSessionID) {
-              activeSessionID = sessionID;
-              _activeFile = registryFile(sessionID);
-              const session = await fetchSession(sessionID);
-              if (session) update(sessionID, { session });
-              await syncPort(sessionID);
-              const port = currentPort();
-              if (port) {
+      if (
+        event.type === "session.status" &&
+        (event.properties?.status as { type?: string } | undefined)?.type === "busy"
+      ) {
+        const sessionID = event.properties?.sessionID as string | undefined;
+        if (sessionID && sessionID !== activeSessionID) {
+          activeSessionID = sessionID;
+          activeSessionTitle = null;
+          await syncPort();
+          const port = currentPort();
+          // Fetch title — best-effort, non-blocking for initial subscribe
+          const titlePromise = fetchTitle(sessionID).then((t) => {
+            // Guard: only update if this session is still active (prevents race on fast switches)
+            if (t && activeSessionID === sessionID) activeSessionTitle = t;
+            return t;
+          });
+          if (port) {
+            call("/v1/interests/subscribe", {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({
+                session_id: sessionID,
+                dir: process.cwd(),
+                topics: [`notifications.agent.${sessionID}`],
+                port,
+                title: activeSessionTitle ?? "",
+              }),
+            }).catch(() => {});
+            // After title arrives, send one follow-up subscribe with title populated
+            titlePromise.then((title) => {
+              if (title && activeSessionID === sessionID) {
                 call("/v1/interests/subscribe", {
                   method: "POST",
                   headers: { "Content-Type": "application/json" },
@@ -153,28 +143,16 @@ export default async (input: { serverUrl: URL }) => {
                     session_id: sessionID,
                     dir: process.cwd(),
                     topics: [`notifications.agent.${sessionID}`],
-                    port,
+                    port: currentPort() ?? 0,
+                    title,
                   }),
                 }).catch(() => {});
               }
-            }
-          }
-          if (event.type === "session.updated") {
-            const info = event.properties?.info as { id?: string; title?: string } | undefined;
-            if (info && info.id === activeSessionID) {
-              update(info.id, { session: { id: info.id, title: info.title || "" } });
-            }
-          }
-
-          if (event.type === "session.idle") {
-            const sessionID = event.properties?.sessionID as string | undefined;
-            if (sessionID && sessionID === activeSessionID) {
-              const session = await fetchSession(sessionID);
-              if (session) update(sessionID, { session });
-            }
+            });
           }
         }
-      : undefined,
+      }
+    },
     tool: {
       envoy_subscribe: tool({
         description:
@@ -196,6 +174,7 @@ export default async (input: { serverUrl: URL }) => {
               dir: ctx.directory,
               topics: args.topics,
               port: currentPort() ?? 0,
+              title: activeSessionTitle ?? "",
             }),
           });
         },
@@ -298,6 +277,51 @@ export default async (input: { serverUrl: URL }) => {
           });
         },
       }),
+      envoy_whoami: tool({
+        description:
+          "Returns this session's Envoy identity: session ID, machine ID, port, and directory.",
+        args: {},
+        async execute(_args, ctx) {
+          ctx.metadata({ title: "Envoy whoami" });
+          const sessionID = ctx.sessionID;
+          const port = currentPort();
+          return JSON.stringify(
+            {
+              session_id: sessionID,
+              machine_id: process.env.HOSTNAME || "unknown",
+              port,
+              dir: ctx.directory,
+            },
+            null,
+            2
+          );
+        },
+      }),
+      envoy_sessions: tool({
+        description:
+          "List all live sessions registered with Envoy. Returns session ID, machine ID, port, directory, title, topics, and last-seen timestamp for each. Use the optional machine filter to show only sessions on a specific host.",
+        args: {
+          machine: tool.schema
+            .string()
+            .optional()
+            .describe(
+              "Filter to sessions on this machine ID (e.g. hostname). Omit to list all machines."
+            ),
+        },
+        async execute(args, ctx) {
+          ctx.metadata({ title: "Envoy sessions" });
+          const res = await call("/v1/sessions");
+          if (!args.machine) return res;
+          const sessions = JSON.parse(res) as Array<{
+            machine_id: string;
+          }>;
+          return JSON.stringify(
+            sessions.filter((s) => s.machine_id === args.machine),
+            null,
+            2
+          );
+        },
+      }),
     },
   };
 };