@sjawhar/opencode-legion-envoy 7.8.0 → 8.0.0

package/dist/src/server.js

@@ -15,7 +15,7 @@ var __export = (target, all) => {
 };
 
 // src/server.ts
-import { existsSync, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
 import path3 from "path";
 import { fileURLToPath } from "url";
 
@@ -14372,36 +14372,135 @@ function zodSchemaApi(zod) {
     }
   };
 }
-// ../envoy-client/src/defaults.ts
-var DEFAULT_ENVOY_URL = "http://127.0.0.1:9020";
-var DEFAULT_HEARTBEAT_MS = 120000;
-var MIN_HEARTBEAT_MS = 25;
-function envoyDefaultsFromEnvironment(environment) {
-  const rawHeartbeatMs = Number(environment["ENVOY_HEARTBEAT_MS"]);
-  const heartbeatMs = Number.isFinite(rawHeartbeatMs) && rawHeartbeatMs > 0 ? Math.max(rawHeartbeatMs, MIN_HEARTBEAT_MS) : DEFAULT_HEARTBEAT_MS;
-  const natsUrls = environment["ENVOY_NATS_URL"]?.split(",").map((url2) => url2.trim()).filter((url2) => url2.length > 0) ?? [];
-  return {
-    envoyUrl: normalizeEnvoyUrl(environment["ENVOY_URL"] ?? DEFAULT_ENVOY_URL),
-    natsUrls,
-    heartbeatMs
-  };
+// ../envoy-client/src/dispatch-first.ts
+import { join } from "path";
+
+// ../envoy-client/src/errors.ts
+function messageFor(error48) {
+  return error48 instanceof Error ? error48.message : String(error48);
 }
-function normalizeEnvoyUrl(value) {
-  return value.replace(/\/+$/, "");
+function hasErrnoCode(error48, code) {
+  return error48 instanceof Error && "code" in error48 && error48.code === code;
 }
 
-// ../envoy-client/src/dispatch-config.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { homedir } from "os";
+// ../envoy-client/src/dispatch-first.ts
+function dispatchFirstSkillFile(skillsDirectory) {
+  return join(skillsDirectory, "dispatch-first", "SKILL.md");
+}
+
+// ../envoy-client/src/machine.ts
+import { hostname as hostname3 } from "os";
+function machineID() {
+  return process.env["ENVOY_MACHINE_ID"] || hostname3();
+}
+
+// ../envoy-client/src/envoy-config.ts
+import {
+  chmodSync,
+  closeSync,
+  existsSync,
+  lstatSync,
+  mkdtempSync,
+  openSync,
+  readFileSync as readFileSync2,
+  readlinkSync,
+  rmSync,
+  statSync
+} from "fs";
+import { homedir, tmpdir } from "os";
 import * as path from "path";
 
-// ../envoy-client/src/errors.ts
-function messageFor(error48) {
-  return error48 instanceof Error ? error48.message : String(error48);
+// ../envoy-client/src/json-position.ts
+function jsonErrorPosition(text) {
+  let at = 0;
+  const fail = () => {
+    throw new RangeError("not JSON");
+  };
+  const space = () => {
+    while (at < text.length && ` 	
+\r`.includes(text.charAt(at)))
+      at += 1;
+  };
+  const expect = (char) => {
+    if (text.charAt(at) !== char)
+      fail();
+    at += 1;
+  };
+  const string4 = () => {
+    expect('"');
+    while (at < text.length) {
+      const char = text.charAt(at);
+      if (char === '"') {
+        at += 1;
+        return;
+      }
+      if (char < " ")
+        fail();
+      at += char === "\\" ? 2 : 1;
+    }
+    fail();
+  };
+  const value = () => {
+    space();
+    const char = text.charAt(at);
+    if (char === "{" || char === "[") {
+      const close = char === "{" ? "}" : "]";
+      at += 1;
+      space();
+      if (text.charAt(at) === close) {
+        at += 1;
+        return;
+      }
+      for (;; ) {
+        if (close === "}") {
+          space();
+          string4();
+          space();
+          expect(":");
+        }
+        value();
+        space();
+        if (text.charAt(at) === ",") {
+          at += 1;
+          continue;
+        }
+        expect(close);
+        return;
+      }
+    }
+    if (char === '"') {
+      string4();
+      return;
+    }
+    for (const word of ["true", "false", "null"]) {
+      if (text.startsWith(word, at)) {
+        at += word.length;
+        return;
+      }
+    }
+    const number4 = /^-?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?/.exec(text.slice(at));
+    if (number4 === null)
+      fail();
+    at += number4?.[0].length ?? 0;
+  };
+  try {
+    value();
+    space();
+    if (at < text.length)
+      fail();
+    return;
+  } catch {
+    const before = text.slice(0, at).split(`
+`);
+    return `line ${before.length}, column ${(before.at(-1)?.length ?? 0) + 1}`;
+  }
 }
 
 // ../envoy-client/src/secret-file.ts
 import { readFileSync } from "fs";
+function sendable(value) {
+  return !/[\s\p{Cc}]/u.test(value);
+}
 function readSecretFile(variable, filePath) {
   let contents;
   try {
@@ -14412,134 +14511,578 @@ function readSecretFile(variable, filePath) {
   const value = contents.trim();
   if (value.length === 0)
     throw new Error(`${variable} names ${filePath}, which is empty`);
+  if (!sendable(value)) {
+    throw new Error(`${variable} names ${filePath}, which holds whitespace or a control character`);
+  }
   return value;
 }
 
-// ../envoy-client/src/dispatch-config.ts
-var DEFAULT_SERVER_URL = "http://localhost:8766";
-function normalizeDispatchUrl(url2) {
-  return url2.replace(/\/+$/, "");
+// ../envoy-client/src/envoy-config.ts
+var COMMAND_TIMEOUT_MS = 1e4;
+function nonEmpty(value) {
+  return value === undefined || value === "" ? undefined : value;
 }
-function parsedDispatchUrl(value, source) {
-  const url2 = normalizeDispatchUrl(value);
-  try {
-    new URL(url2);
-    return { url: url2, error: null };
-  } catch {
-    return { url: null, error: `${source} must be a valid URL` };
+function absolute(name, value) {
+  if (value !== undefined && !path.isAbsolute(value)) {
+    throw new Error(`${name} is ${value}, which is not an absolute path`);
   }
+  return value;
 }
+function neutralConfig(env) {
+  const xdgConfigHome = nonEmpty(env.XDG_CONFIG_HOME);
+  if (xdgConfigHome !== undefined && !path.isAbsolute(xdgConfigHome)) {
+    return { error: `XDG_CONFIG_HOME is ${xdgConfigHome}, which is not an absolute path` };
+  }
+  const configHome = xdgConfigHome ?? path.join(nonEmpty(env.HOME) ?? homedir(), ".config");
+  return { path: path.resolve(configHome, "legion", "envoy.json") };
+}
+var HARNESS_DIRECTORY_VARIABLE = {
+  omp: "PI_CODING_AGENT_DIR",
+  claude: "CLAUDE_CONFIG_DIR",
+  opencode: "OPENCODE_CONFIG_DIR"
+};
+var PLUGIN_HARNESSES = Object.keys(HARNESS_DIRECTORY_VARIABLE);
+function namedDirectory(harness, env) {
+  if (harness === "omp") {
+    const profile = nonEmpty(env.OMP_PROFILE);
+    if (profile === undefined || profile === "default")
+      return;
+  }
+  return nonEmpty(env[HARNESS_DIRECTORY_VARIABLE[harness]]);
+}
+function harnessDirectory(harness, env) {
+  for (const plugin of harness === "command" ? PLUGIN_HARNESSES : [harness]) {
+    if (harness === "command" && plugin === "claude" && env.CLAUDE_CODE_CHILD_SESSION !== "1") {
+      continue;
+    }
+    const directory = namedDirectory(plugin, env);
+    if (directory !== undefined)
+      return absolute(HARNESS_DIRECTORY_VARIABLE[plugin], directory);
+  }
+  return;
+}
+function handedConfigPath(env) {
+  const handed = nonEmpty(env.ENVOY_CONFIG_FILE);
+  return handed === undefined ? undefined : path.resolve(absolute("ENVOY_CONFIG_FILE", handed));
+}
+function envoyConfigPath(harness, env) {
+  const handedFirst = harness === "command" ? handedConfigPath(env) : undefined;
+  if (handedFirst !== undefined)
+    return handedFirst;
+  const directory = harnessDirectory(harness, env);
+  if (directory !== undefined)
+    return path.resolve(directory, "envoy.json");
+  const handed = handedConfigPath(env);
+  if (handed !== undefined)
+    return handed;
+  const neutral = neutralConfig(env);
+  if ("error" in neutral)
+    throw new Error(neutral.error);
+  return neutral.path;
+}
+var httpUrlSchema = exports_external.url({ protocol: /^https?$/, error: "must be an http or https URL" });
+var DispatchSectionSchema = exports_external.strictObject({
+  enabled: exports_external.boolean().optional(),
+  serverUrl: httpUrlSchema.optional(),
+  token: exports_external.string().optional()
+});
+var EnvoySectionSchema = exports_external.strictObject({
+  enabled: exports_external.boolean().optional(),
+  url: httpUrlSchema.optional(),
+  natsUrls: exports_external.array(exports_external.string().trim().min(1, "must not be empty")).optional(),
+  token: exports_external.string().optional(),
+  natsSeed: exports_external.string().optional()
+});
 var EnvoyFileSchema = exports_external.looseObject({
   $schema: exports_external.string().optional(),
-  natsUrls: exports_external.array(exports_external.string()).optional(),
-  dispatch: exports_external.strictObject({
-    enabled: exports_external.boolean().optional(),
-    serverUrl: exports_external.url().optional(),
-    token: exports_external.string().optional()
-  }).optional()
+  dispatch: DispatchSectionSchema.optional(),
+  envoy: EnvoySectionSchema.optional()
+});
+var CheckoutFileSchema = exports_external.looseObject({
+  $schema: exports_external.string().optional(),
+  dispatch: DispatchSectionSchema.optional()
 });
+function offWithNotice(notice) {
+  return { enabled: false, notice, error: null };
+}
+function offWithError(error48) {
+  return { enabled: false, notice: null, error: error48 };
+}
+function httpUrl2(value) {
+  let url2;
+  try {
+    url2 = new URL(value);
+  } catch {
+    return;
+  }
+  return url2.protocol === "http:" || url2.protocol === "https:" ? url2 : undefined;
+}
 function describeSchemaIssue(filePath, error48) {
   const issue2 = error48.issues[0];
   if (!issue2)
-    return `${filePath}: invalid dispatch config`;
+    return `${filePath}: invalid envoy.json`;
   if (issue2.code === "unrecognized_keys") {
-    const keys = issue2.keys.map((key) => `dispatch.${key}`).join(", ");
-    return `${filePath}: unrecognized dispatch key(s): ${keys}`;
+    const section = issue2.path.join(".");
+    const keys = issue2.keys.map((key) => `${section}.${key}`).join(", ");
+    return `${filePath}: unrecognized ${section} key(s): ${keys}`;
   }
   return `${filePath}: ${issue2.path.join(".")}: ${issue2.message}`;
 }
-function readEnvoyFile(filePath) {
+function danglingLink(filePath) {
+  try {
+    return lstatSync(filePath).isSymbolicLink() ? readlinkSync(filePath) : null;
+  } catch {
+    return null;
+  }
+}
+function parseFile(filePath, schema, checkout) {
   let raw;
   try {
     raw = readFileSync2(filePath, "utf-8");
-  } catch {
-    return { kind: "absent" };
+  } catch (error48) {
+    if (hasErrnoCode(error48, "ENOENT") || hasErrnoCode(error48, "ENOTDIR")) {
+      return { kind: "absent", link: danglingLink(filePath) };
+    }
+    return { kind: "invalid", reason: `${filePath}: could not be read (${messageFor(error48)})` };
   }
   let parsedJson;
   try {
     parsedJson = JSON.parse(raw);
-  } catch (err) {
-    return { kind: "invalid", reason: `${filePath}: invalid JSON (${messageFor(err)})` };
+  } catch {
+    const position = jsonErrorPosition(raw);
+    return {
+      kind: "invalid",
+      reason: `${filePath}: invalid JSON${position === undefined ? "" : ` at ${position}`}`
+    };
   }
-  const parsed = EnvoyFileSchema.safeParse(parsedJson);
+  if (typeof parsedJson === "object" && parsedJson !== null && "natsUrls" in parsedJson) {
+    return {
+      kind: "invalid",
+      reason: checkout ? `${filePath}: the top-level natsUrls is not read, and a checkout's envoy.json holds only a dispatch section` : `${filePath}: the top-level natsUrls is not read; move it to envoy.natsUrls`
+    };
+  }
+  const parsed = schema.safeParse(parsedJson);
   if (!parsed.success) {
     return { kind: "invalid", reason: describeSchemaIssue(filePath, parsed.error) };
   }
-  return { kind: "valid", settings: parsed.data.dispatch ?? null };
-}
-function resolveDispatchConfig(env, options = {}) {
-  const explicitUrl = env.DISPATCH_URL;
-  const home = options.home ?? env.HOME ?? homedir();
-  const cwd = options.cwd ?? process.cwd();
-  const userFile = readEnvoyFile(path.join(home, ".config", "opencode", "envoy.json"));
-  const repoFile = readEnvoyFile(path.join(cwd, ".opencode", "envoy.json"));
-  for (const file2 of [userFile, repoFile]) {
-    if (file2.kind === "invalid") {
-      return { enabled: false, url: null, token: null, error: file2.reason };
-    }
-  }
-  const userSettings = userFile.kind === "valid" ? userFile.settings : null;
-  const repoSettings = repoFile.kind === "valid" ? repoFile.settings : null;
-  const merged = { ...userSettings, ...repoSettings };
-  const repoURL = repoSettings?.serverUrl;
-  if (explicitUrl === undefined && merged.enabled === true && repoURL !== undefined) {
-    const token2 = repoSettings?.token ?? null;
-    if (!token2) {
+  return { kind: "valid", settings: parsed.data };
+}
+var FAILURE_KEPT_MS = 60000;
+var COMMAND_OUTCOMES = Symbol.for("legion.envoy-config.commands.v1");
+var processGlobal = globalThis;
+var commandOutcomes = processGlobal[COMMAND_OUTCOMES] ?? new Map;
+processGlobal[COMMAND_OUTCOMES] = commandOutcomes;
+function runCommand(command, env, cwd) {
+  const childEnv = {};
+  for (const [name, variable] of Object.entries(env)) {
+    if (variable !== undefined)
+      childEnv[name] = variable;
+  }
+  const directory = mkdtempSync(path.join(tmpdir(), "envoy-command-"));
+  try {
+    chmodSync(directory, 448);
+    const output = path.join(directory, "stdout");
+    const fd = openSync(output, "wx", 384);
+    let result;
+    try {
+      result = Bun.spawnSync(["/bin/sh", "-c", command], {
+        cwd,
+        env: childEnv,
+        stdin: "ignore",
+        stdout: fd,
+        stderr: "ignore",
+        timeout: COMMAND_TIMEOUT_MS,
+        detached: true
+      });
+    } catch (error48) {
+      return { failure: `could not start: ${messageFor(error48)}`, timedOut: false };
+    } finally {
+      closeSync(fd);
+    }
+    try {
+      process.kill(-result.pid, "SIGKILL");
+    } catch {}
+    if (result.exitedDueToTimeout) {
+      return {
+        failure: `did not finish within ${COMMAND_TIMEOUT_MS / 1000} s, and does not run again in this process`,
+        timedOut: true
+      };
+    }
+    if (!result.success) {
       return {
-        enabled: false,
-        url: null,
-        token: null,
-        error: "repository dispatch.serverUrl requires dispatch.token from the same .opencode/envoy.json or DISPATCH_URL with DISPATCH_TOKEN"
+        failure: `exited with ${result.signalCode ?? `status ${result.exitCode}`}`,
+        timedOut: false
       };
     }
-    const url3 = parsedDispatchUrl(repoURL, "repository dispatch.serverUrl");
-    if (url3.error !== null)
-      return { enabled: false, url: null, token: null, error: url3.error };
-    return { enabled: true, url: url3.url, token: token2, error: null };
+    const value = readFileSync2(output, "utf-8").trim();
+    if (value.length === 0)
+      return { failure: "printed nothing", timedOut: false };
+    if (!sendable(value)) {
+      return {
+        failure: "printed more than one line, or whitespace inside its value",
+        timedOut: false
+      };
+    }
+    return { value };
+  } finally {
+    rmSync(directory, { recursive: true, force: true });
+  }
+}
+function fileValue(value, field, filePath, env) {
+  if (!value.startsWith("!")) {
+    if (!sendable(value)) {
+      throw new Error(`${filePath}: ${field} holds whitespace or a control character`);
+    }
+    return value;
+  }
+  const command = value.slice(1);
+  const cwd = path.dirname(path.resolve(filePath));
+  const key = JSON.stringify([command, filePath, cwd]);
+  let outcome = commandOutcomes.get(key);
+  if (outcome === undefined || "failure" in outcome && !outcome.timedOut && Date.now() - outcome.at >= FAILURE_KEPT_MS) {
+    outcome = { ...runCommand(command, env, cwd), at: Date.now() };
+    commandOutcomes.set(key, outcome);
+  }
+  if ("failure" in outcome)
+    throw new Error(`${filePath}: ${field}'s command ${outcome.failure}`);
+  return outcome.value;
+}
+function statDevice(directory) {
+  try {
+    return statSync(directory).dev;
+  } catch {
+    return;
+  }
+}
+function moveNotice(oldFile, newFile, move, deviceOf) {
+  const oldDevice = deviceOf(path.dirname(oldFile));
+  let ancestor = path.dirname(newFile);
+  let newDevice = deviceOf(ancestor);
+  while (newDevice === undefined && path.dirname(ancestor) !== ancestor) {
+    ancestor = path.dirname(ancestor);
+    newDevice = deviceOf(ancestor);
+  }
+  if (oldDevice !== undefined && newDevice !== undefined && oldDevice !== newDevice) {
+    return `${oldFile} is not read, and is on another filesystem than ${newFile} (a mount): create ${newFile}, and move ${oldFile} on the machine that owns it`;
+  }
+  return `${oldFile} is not read: ${move}`;
+}
+function oldUserFileNotice(filePath, env, deviceOf) {
+  const home = nonEmpty(env.HOME) ?? homedir();
+  const old = path.join(home, ".config", "opencode", "envoy.json");
+  if (!existsSync(old))
+    return;
+  const selected = path.resolve(filePath);
+  const userFile = path.resolve(home, ".config", "legion", "envoy.json");
+  if (selected === userFile) {
+    return moveNotice(old, userFile, "mkdir -p ~/.config/legion && mv ~/.config/opencode/envoy.json ~/.config/legion/", deviceOf);
+  }
+  const profileFile = PLUGIN_HARNESSES.map((harness) => namedDirectory(harness, env)).some((directory) => directory !== undefined && path.isAbsolute(directory) && selected === path.resolve(directory, "envoy.json"));
+  if (profileFile) {
+    return `${old} is not read for this profile; copy or link it to ${filePath}, or write that file`;
+  }
+  const configHome = nonEmpty(env.XDG_CONFIG_HOME);
+  const neutral = neutralConfig(env);
+  if (configHome !== undefined && path.isAbsolute(configHome) && "path" in neutral && selected === neutral.path) {
+    return `${old} is not read under XDG_CONFIG_HOME=${configHome}`;
+  }
+  return;
+}
+function missingConfigNotice(filePath, missing, off) {
+  const link = missing.link === null ? "" : ` (a link to ${missing.link}, which does not exist)`;
+  const old = missing.oldUserFileNotice === undefined ? "" : `; ${missing.oldUserFileNotice}`;
+  return `no envoy.json at ${filePath}${link}: ${off}${old}`;
+}
+function readEnvoyConfig(filePath, env, options) {
+  const deviceOf = options.deviceOf ?? statDevice;
+  const chosen = parseFile(filePath, EnvoyFileSchema, false);
+  if (chosen.kind === "invalid")
+    return { kind: "failed", path: filePath, error: chosen.reason };
+  const resolvedChosen = path.resolve(filePath);
+  const checkoutPath = path.resolve(options.cwd, ".envoy", "envoy.json");
+  const checkoutFile = checkoutPath === resolvedChosen ? { kind: "absent", link: null } : parseFile(checkoutPath, CheckoutFileSchema, true);
+  const own = chosen.kind === "valid" ? chosen.settings : {};
+  let checkout = null;
+  if (checkoutFile.kind === "invalid") {
+    checkout = { kind: "invalid", path: checkoutPath, error: checkoutFile.reason };
+  } else if (checkoutFile.kind === "valid") {
+    checkout = {
+      kind: "valid",
+      path: checkoutPath,
+      dispatch: checkoutFile.settings.dispatch ?? {},
+      envoyError: Object.hasOwn(checkoutFile.settings, "envoy") ? `${checkoutPath}: envoy is not read from a checkout's envoy.json; put it in ${filePath}` : null
+    };
+  }
+  const oldCheckout = path.resolve(options.cwd, ".opencode", "envoy.json");
+  const warnings = oldCheckout !== resolvedChosen && !existsSync(checkoutPath) && existsSync(oldCheckout) ? [
+    moveNotice(oldCheckout, checkoutPath, `mkdir -p ${path.dirname(checkoutPath)} && mv ${oldCheckout} ${checkoutPath}`, deviceOf)
+  ] : [];
+  const unreadOldUserFile = chosen.kind === "absent" ? oldUserFileNotice(filePath, env, deviceOf) : undefined;
+  return {
+    kind: "read",
+    path: filePath,
+    dispatch: own.dispatch ?? {},
+    envoy: own.envoy ?? {},
+    checkout,
+    missing: chosen.kind === "absent" ? {
+      link: chosen.link,
+      ...unreadOldUserFile === undefined ? {} : { oldUserFileNotice: unreadOldUserFile }
+    } : null,
+    warnings
+  };
+}
+
+// ../envoy-client/src/bearer.ts
+function bearerSource(env, section, written) {
+  const pointer = nonEmpty(env[`${section}_TOKEN_FILE`]);
+  if (pointer !== undefined) {
+    return { kind: "variable", token: readSecretFile(`${section}_TOKEN_FILE`, pointer) };
+  }
+  const plain = nonEmpty(env[`${section}_TOKEN`]);
+  if (plain !== undefined) {
+    if (!sendable(plain)) {
+      throw new Error(`${section}_TOKEN holds whitespace or a control character`);
+    }
+    return { kind: "variable", token: plain };
+  }
+  const bearer = written();
+  return bearer === undefined ? { kind: "none" } : { kind: "file", ...bearer };
+}
+function fileBearer(bearer, url2, section, env) {
+  const named = httpUrl2(url2)?.origin;
+  const paired = httpUrl2(bearer.server)?.origin;
+  if (named !== paired) {
+    throw new Error(`${section}_URL names ${named}, but ${bearer.path}'s ${bearer.field} is for ${paired}; set ${section}_TOKEN or ${section}_TOKEN_FILE for it`);
+  }
+  if (bearer.checkout && bearer.token.startsWith("!")) {
+    throw new Error(`${bearer.path}: ${bearer.field} is a command, which a checkout's envoy.json cannot run`);
+  }
+  if (bearer.token === "") {
+    throw new Error(`${bearer.field} in ${bearer.path} must be a non-empty bearer token`);
+  }
+  return fileValue(bearer.token, bearer.field, bearer.path, env);
+}
+
+// ../envoy-client/src/dispatch-config.ts
+var DEFAULT_SERVER_URL = "http://localhost:8766";
+function checkoutPair(checkout, serverUrl) {
+  const { token } = checkout.dispatch;
+  if (token === undefined) {
+    throw new Error(`${checkout.path}: dispatch.serverUrl requires dispatch.token in the same file`);
+  }
+  return {
+    kind: "file",
+    token,
+    field: "dispatch.token",
+    path: checkout.path,
+    server: serverUrl,
+    checkout: true
+  };
+}
+function writtenToken(config2, checkout) {
+  if (checkout?.dispatch.token !== undefined) {
+    throw new Error(`${checkout.path}: dispatch.token requires dispatch.serverUrl in the same file`);
+  }
+  const own = config2.dispatch;
+  if (own.token === undefined)
+    return;
+  const server = own.serverUrl ?? DEFAULT_SERVER_URL;
+  return {
+    token: own.token,
+    field: "dispatch.token",
+    path: config2.path,
+    server,
+    checkout: false
+  };
+}
+function dispatchSettings(env, config2) {
+  if (config2.kind === "failed")
+    return offWithError(config2.error);
+  const explicitUrl = nonEmpty(env.DISPATCH_URL);
+  const checkoutFile = explicitUrl === undefined ? config2.checkout : null;
+  if (checkoutFile?.kind === "invalid")
+    return offWithError(checkoutFile.error);
+  const checkout = checkoutFile?.kind === "valid" ? checkoutFile : null;
+  const own = config2.dispatch;
+  if (own.enabled === false) {
+    return offWithNotice(`${config2.path} sets dispatch.enabled to false: Dispatch is off`);
+  }
+  if (checkout?.dispatch.enabled === false) {
+    return offWithNotice(`${checkout.path} sets dispatch.enabled to false: Dispatch is off`);
+  }
+  const checkoutServer = checkout?.dispatch.serverUrl;
+  const addressed = explicitUrl !== undefined || checkoutServer !== undefined || own.serverUrl !== undefined || own.enabled === true;
+  if (!addressed) {
+    return offWithNotice(config2.missing === null ? `${config2.path} names no Dispatch server, and DISPATCH_URL is not set: Dispatch is off` : missingConfigNotice(config2.path, config2.missing, "Dispatch is off"));
+  }
+  if (explicitUrl !== undefined && httpUrl2(explicitUrl) === undefined) {
+    return offWithError("DISPATCH_URL must be an http or https URL");
+  }
+  try {
+    const source = checkout !== null && checkoutServer !== undefined ? checkoutPair(checkout, checkoutServer) : bearerSource(env, "DISPATCH", () => writtenToken(config2, checkout));
+    if (source.kind === "none") {
+      return offWithError(explicitUrl === undefined ? `${config2.path}: dispatch is enabled and no token is: set dispatch.token, or DISPATCH_TOKEN or DISPATCH_TOKEN_FILE` : `DISPATCH_URL is set and no token is: set DISPATCH_TOKEN or DISPATCH_TOKEN_FILE, or dispatch.token in ${config2.path}`);
+    }
+    const url2 = (explicitUrl ?? (source.kind === "file" ? source.server : own.serverUrl ?? DEFAULT_SERVER_URL)).replace(/\/+$/, "");
+    const token = source.kind === "variable" ? source.token : fileBearer(source, url2, "DISPATCH", env);
+    return { enabled: true, url: url2, token };
+  } catch (error48) {
+    return offWithError(messageFor(error48));
+  }
+}
+
+// ../envoy-client/src/envoy-settings.ts
+var DEFAULT_ENVOY_URL = "http://127.0.0.1:9020";
+var DEFAULT_HEARTBEAT_MS = 120000;
+var MIN_HEARTBEAT_MS = 25;
+function natsSeedFromEnvironment(env) {
+  const { NATS_NKEY_SEED_FILE: file2, NATS_NKEY_SEED: plain } = env;
+  if (file2 !== undefined) {
+    if (file2 === "")
+      throw new Error("NATS_NKEY_SEED_FILE is set but empty");
+    return {
+      value: readSecretFile("NATS_NKEY_SEED_FILE", file2),
+      source: `NATS_NKEY_SEED_FILE (${file2})`
+    };
+  }
+  if (plain === undefined)
+    return;
+  const value = plain.trim();
+  if (value.length === 0)
+    throw new Error("NATS_NKEY_SEED is set but empty");
+  return { value, source: "NATS_NKEY_SEED" };
+}
+var NO_NATS_SERVER = "Envoy has no NATS server (envoy.natsUrls, ENVOY_NATS_URL)";
+var NO_NATS_CONNECTION = "this session opens no NATS connection";
+function natsServerKey(url2) {
+  const match = /^([a-z][a-z0-9+.-]*):\/\/([^@/]*@)?(\[[^\]]*\]|[^:/]*)(?::(\d+))?(\/.*)?$/i.exec(url2);
+  if (match === null)
+    return url2;
+  const [, scheme = "", userinfo = "", host = "", port = "4222", rest = ""] = match;
+  return `${scheme.toLowerCase()}://${userinfo}${host.toLowerCase()}:${port}${rest.replace(/\/+$/, "")}`;
+}
+function natsCredential(env, section, namedNatsUrls, filePath) {
+  const fromEnvironment = natsSeedFromEnvironment(env);
+  if (fromEnvironment !== undefined || section.natsSeed === undefined)
+    return fromEnvironment;
+  if (namedNatsUrls.length > 0) {
+    const servers = new Set((section.natsUrls ?? []).map(natsServerKey));
+    const named = new Set(namedNatsUrls.map(natsServerKey));
+    if (named.size !== servers.size || ![...named].every((server) => servers.has(server))) {
+      throw new Error(`ENVOY_NATS_URL names other servers than ${filePath}'s envoy.natsUrls; set NATS_NKEY_SEED_FILE for them`);
+    }
+  }
+  return {
+    value: fileValue(section.natsSeed, "envoy.natsSeed", filePath, env),
+    source: `envoy.natsSeed in ${filePath}`
+  };
+}
+function envoySettings(env, config2, options = {}) {
+  if (config2.kind === "failed")
+    return offWithError(config2.error);
+  const section = config2.envoy;
+  if (section.enabled === false) {
+    return offWithNotice(`${config2.path} sets envoy.enabled to false: Envoy is off`);
   }
-  const rawUrl = explicitUrl !== undefined ? { value: explicitUrl, source: "DISPATCH_URL" } : merged.enabled === true ? { value: merged.serverUrl ?? DEFAULT_SERVER_URL, source: "dispatch.serverUrl" } : null;
-  const url2 = rawUrl ? parsedDispatchUrl(rawUrl.value, rawUrl.source) : { url: null, error: null };
+  const namedUrl = nonEmpty(env.ENVOY_URL);
+  const namedNatsUrls = (env.ENVOY_NATS_URL ?? "").split(",").map((url3) => url3.trim()).filter((url3) => url3.length > 0);
+  const addressed = namedUrl !== undefined || namedNatsUrls.length > 0 || section.url !== undefined || (section.natsUrls ?? []).length > 0 || section.enabled === true;
+  if (!addressed) {
+    return offWithNotice(config2.missing === null ? `${config2.path} names no Envoy listener or NATS server, and neither ENVOY_URL nor ENVOY_NATS_URL is set: Envoy is off` : missingConfigNotice(config2.path, config2.missing, "Envoy is off"));
+  }
+  if (namedUrl !== undefined && httpUrl2(namedUrl) === undefined) {
+    return offWithError("ENVOY_URL must be an http or https URL");
+  }
+  const listener = section.url ?? DEFAULT_ENVOY_URL;
+  const url2 = namedUrl ?? listener;
   let token;
-  let tokenSource;
-  if (env.DISPATCH_TOKEN_FILE !== undefined) {
-    tokenSource = "DISPATCH_TOKEN_FILE";
+  try {
+    const source = bearerSource(env, "ENVOY", () => section.token === undefined ? undefined : {
+      token: section.token,
+      field: "envoy.token",
+      path: config2.path,
+      server: listener,
+      checkout: false
+    });
+    token = source.kind === "none" ? undefined : source.kind === "variable" ? source.token : fileBearer(source, url2, "ENVOY", env);
+  } catch (error48) {
+    return offWithError(messageFor(error48));
+  }
+  const natsUrls = namedNatsUrls.length > 0 ? namedNatsUrls : section.natsUrls ?? [];
+  let inbound;
+  if (options.nats === false)
+    inbound = { off: NO_NATS_CONNECTION };
+  else if (natsUrls.length === 0)
+    inbound = { off: NO_NATS_SERVER };
+  else {
     try {
-      token = readSecretFile(tokenSource, env.DISPATCH_TOKEN_FILE);
+      inbound = { natsUrls, natsSeed: natsCredential(env, section, namedNatsUrls, config2.path) };
     } catch (error48) {
-      return { enabled: false, url: url2.url, token: null, error: messageFor(error48) };
+      inbound = { off: messageFor(error48) };
     }
-  } else if (env.DISPATCH_TOKEN !== undefined) {
-    tokenSource = "DISPATCH_TOKEN";
-    token = env.DISPATCH_TOKEN;
-  } else {
-    tokenSource = "dispatch.token";
-    token = merged.token ?? null;
-  }
-  if (url2.error !== null)
-    return { enabled: false, url: null, token, error: url2.error };
-  if (url2.url === null)
-    return { enabled: false, url: null, token, error: null };
-  if (!token) {
-    return {
-      enabled: false,
-      url: url2.url,
-      token,
-      error: `${tokenSource} must be a non-empty bearer token`
-    };
   }
-  return { enabled: true, url: url2.url, token, error: null };
+  const rawHeartbeatMs = Number(env.ENVOY_HEARTBEAT_MS);
+  return {
+    enabled: true,
+    url: normalizeEnvoyUrl(url2),
+    token,
+    inbound,
+    heartbeatMs: Number.isFinite(rawHeartbeatMs) && rawHeartbeatMs > 0 ? Math.max(rawHeartbeatMs, MIN_HEARTBEAT_MS) : DEFAULT_HEARTBEAT_MS
+  };
 }
-
-// ../envoy-client/src/dispatch-first.ts
-import { join as join2 } from "path";
-function dispatchFirstSkillFile(skillsDirectory) {
-  return join2(skillsDirectory, "dispatch-first", "SKILL.md");
+function normalizeEnvoyUrl(value) {
+  return value.replace(/\/+$/, "");
 }
 
-// ../envoy-client/src/machine.ts
-import { hostname as hostname3 } from "os";
-function machineID() {
-  return process.env["ENVOY_MACHINE_ID"] || hostname3();
+// ../envoy-client/src/session-settings.ts
+function sessionConfigFile(harness, env) {
+  try {
+    return { path: envoyConfigPath(harness, env), error: null };
+  } catch (error48) {
+    return { path: null, error: messageFor(error48) };
+  }
+}
+function startNotice(config2, dispatch, envoy, nats) {
+  if (config2.kind === "failed")
+    return `${config2.error}: Dispatch and Envoy are off`;
+  const { missing, checkout } = config2;
+  const dispatchQuiet = !dispatch.enabled && dispatch.error === null;
+  const envoyQuiet = !envoy.enabled && envoy.error === null;
+  const parts = [];
+  if (missing !== null && dispatchQuiet && envoyQuiet) {
+    parts.push(missingConfigNotice(config2.path, missing, "Dispatch and Envoy are off"));
+  } else {
+    if (!dispatch.enabled && dispatch.error !== null)
+      parts.push(`Dispatch is off: ${dispatch.error}`);
+    else if (dispatchQuiet && missing !== null) {
+      parts.push(missingConfigNotice(config2.path, missing, "Dispatch is off"));
+    }
+    if (!envoy.enabled && envoy.error !== null)
+      parts.push(`Envoy is off: ${envoy.error}`);
+    else if (envoyQuiet && missing !== null) {
+      parts.push(missingConfigNotice(config2.path, missing, "Envoy is off"));
+    }
+  }
+  if (checkout?.kind === "valid" && checkout.envoyError !== null)
+    parts.push(checkout.envoyError);
+  if (checkout?.kind === "invalid" && (dispatch.enabled || dispatch.error !== checkout.error)) {
+    parts.push(`${checkout.error}; not read while DISPATCH_URL is set`);
+  }
+  parts.push(...config2.warnings);
+  if (envoy.enabled && nats && "off" in envoy.inbound) {
+    parts.push(`Envoy's inbound messages are off: ${envoy.inbound.off}; the Envoy tools still work`);
+  }
+  return parts.length === 0 ? null : parts.join("; ");
+}
+function sessionSettings(file2, env, options) {
+  if (file2.path === null) {
+    const off = offWithError(file2.error);
+    return { dispatch: off, envoy: off, notice: `${file2.error}: Dispatch and Envoy are off` };
+  }
+  const config2 = readEnvoyConfig(file2.path, env, options);
+  const dispatch = dispatchSettings(env, config2);
+  const envoy = envoySettings(env, config2, { nats: options.nats });
+  return { dispatch, envoy, notice: startNotice(config2, dispatch, envoy, options.nats !== false) };
 }
 
 // ../envoy-client/src/dispatch-command.ts
@@ -14736,16 +15279,10 @@ class EnvoyApiError extends Error {
     this.expected = parsed?.expected;
   }
 }
-function resolveEnvoyToken(env) {
-  const { ENVOY_TOKEN_FILE: file2, ENVOY_TOKEN: plain } = env;
-  if (file2 !== undefined && file2 !== "")
-    return readSecretFile("ENVOY_TOKEN_FILE", file2);
-  return plain || undefined;
-}
 function createEnvoyClient(config2) {
   const baseUrl = normalizeEnvoyUrl(config2.baseUrl);
   const timeoutMs = config2.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const apiToken = resolveEnvoyToken(process.env);
+  const apiToken = config2.token;
   const request = async (path2, init) => {
     const url2 = `${baseUrl}${path2}`;
     for (let attempt = 0;attempt < 2; attempt += 1) {
@@ -14876,8 +15413,8 @@ function createEnvoyClient(config2) {
   };
 }
 function waitForRetry() {
-  const { promise: promise2, resolve } = Promise.withResolvers();
-  setTimeout(resolve, RETRY_DELAY_MS);
+  const { promise: promise2, resolve: resolve2 } = Promise.withResolvers();
+  setTimeout(resolve2, RETRY_DELAY_MS);
   return promise2;
 }
 function messageMetadata(input) {
@@ -14957,12 +15494,12 @@ function portFromSsOutput(output, pid) {
 }
 
 // src/port.ts
-var defaultExec = (command, args, options) => new Promise((resolve, reject) => {
+var defaultExec = (command, args, options) => new Promise((resolve2, reject) => {
   execFile(command, args, { encoding: options.encoding }, (error48, stdout) => {
     if (error48)
       reject(error48);
     else
-      resolve(stdout);
+      resolve2(stdout);
   });
 });
 async function resolvePort(serverUrl, exec = defaultExec) {
@@ -14983,7 +15520,7 @@ var moduleDirectory = path3.dirname(fileURLToPath(import.meta.url));
 var skillsDirectory = [
   path3.resolve(moduleDirectory, "../../skills"),
   path3.resolve(moduleDirectory, "../../../skills")
-].find((dir) => existsSync(dir));
+].find((dir) => existsSync2(dir));
 var PACKAGE_NAME = "@sjawhar/opencode-legion-envoy";
 function packageRoot(from) {
   for (let directory = from;; directory = path3.dirname(directory)) {
@@ -15017,24 +15554,138 @@ var publishSpec = toolSpec("envoy_publish");
 var roleSetSpec = toolSpec("envoy_role_set");
 var whoamiSpec = toolSpec("envoy_whoami");
 var sessionsSpec = toolSpec("envoy_sessions");
+function envoyTools(client, port, title) {
+  return {
+    envoy_subscribe: tool({
+      description: subscribeSpec.description,
+      args: subscribeSpec.arguments(zodSchemaApi(tool.schema)),
+      async execute(args, ctx) {
+        ctx.metadata({ title: "Envoy subscribe" });
+        return JSON.stringify(await client.subscribe({
+          sessionID: ctx.sessionID,
+          directory: ctx.directory,
+          topics: args.topics,
+          port: port() ?? 0,
+          title: title() ?? "",
+          driving: true
+        }));
+      }
+    }),
+    envoy_unsubscribe: tool({
+      description: unsubscribeSpec.description,
+      args: unsubscribeSpec.arguments(zodSchemaApi(tool.schema)),
+      async execute(args, ctx) {
+        ctx.metadata({ title: "Envoy unsubscribe" });
+        await client.unsubscribe({
+          sessionID: ctx.sessionID,
+          topics: args.topics ?? []
+        });
+        return "ok";
+      }
+    }),
+    envoy_list: tool({
+      description: listSpec.description,
+      args: listSpec.arguments(zodSchemaApi(tool.schema)),
+      async execute(_args, ctx) {
+        ctx.metadata({ title: "Envoy list" });
+        return JSON.stringify(await client.getInterest(ctx.sessionID));
+      }
+    }),
+    envoy_send: tool({
+      description: sendSpec.description,
+      args: sendSpec.arguments(zodSchemaApi(tool.schema)),
+      async execute(args, ctx) {
+        ctx.metadata({ title: "Envoy send" });
+        return JSON.stringify(await client.send({
+          sourceSessionID: ctx.sessionID,
+          targetSessionID: args.session_id,
+          message: args.message,
+          ...toMessageMetadata(args)
+        }));
+      }
+    }),
+    envoy_publish: tool({
+      description: publishSpec.description,
+      args: publishSpec.arguments(zodSchemaApi(tool.schema)),
+      async execute(args, ctx) {
+        ctx.metadata({ title: "Envoy publish" });
+        return JSON.stringify(await client.publish({
+          sourceSessionID: ctx.sessionID,
+          topic: args.topic,
+          message: args.message,
+          ...toMessageMetadata(args)
+        }));
+      }
+    }),
+    envoy_role_set: tool({
+      description: roleSetSpec.description,
+      args: roleSetSpec.arguments(zodSchemaApi(tool.schema)),
+      async execute(args, ctx) {
+        ctx.metadata({ title: "Set Envoy role" });
+        const result = await client.setRole({
+          sessionID: ctx.sessionID,
+          role: args.role
+        });
+        if (!result.claimed)
+          throw new Error(`role ${args.role} is held by ${result.holder}`);
+        return JSON.stringify(result.interest);
+      }
+    }),
+    envoy_whoami: tool({
+      description: whoamiSpec.description,
+      args: whoamiSpec.arguments(zodSchemaApi(tool.schema)),
+      async execute(_args, ctx) {
+        ctx.metadata({ title: "Envoy whoami" });
+        return JSON.stringify({
+          session_id: ctx.sessionID,
+          machine_id: machineID(),
+          port: port(),
+          dir: ctx.directory
+        }, null, 2);
+      }
+    }),
+    envoy_sessions: tool({
+      description: sessionsSpec.description,
+      args: sessionsSpec.arguments(zodSchemaApi(tool.schema)),
+      async execute(args, ctx) {
+        ctx.metadata({ title: "Envoy sessions" });
+        const sessions = await client.listSessions({
+          ...args.dir === undefined ? {} : { directory: args.dir },
+          ...args.title === undefined ? {} : { title: args.title }
+        });
+        const machine = args.machine;
+        return JSON.stringify(machine ? sessions.filter((session) => session.machine_id === machine) : sessions, null, 2);
+      }
+    })
+  };
+}
 var server_default = async (input) => {
   const cwd = process.cwd();
-  const dispatchConfig = resolveDispatchConfig(process.env, { cwd });
-  if (!dispatchConfig.enabled) {
-    logger.warn(`envoy: Dispatch disabled \u2014 ${dispatchConfig.error ?? "no Dispatch URL configured"}`);
-  }
+  const configFile = sessionConfigFile("opencode", process.env);
+  const { dispatch, envoy, notice } = sessionSettings(configFile, process.env, {
+    cwd,
+    nats: false
+  });
+  if (notice !== null)
+    logger.warn(`envoy: ${notice}`);
   let dispatchFirst;
-  if (dispatchConfig.enabled) {
+  if (dispatch.enabled) {
     if (skillsDirectory === undefined) {
       throw new Error(`envoy: no skills directory beside ${moduleDirectory}`);
     }
     dispatchFirst = dispatchFirstSkillFile(skillsDirectory);
-    if (!existsSync(dispatchFirst)) {
+    if (!existsSync2(dispatchFirst)) {
       throw new Error(`envoy: the dispatch-first skill ${dispatchFirst} is missing`);
     }
   }
-  const envoyDefaults = envoyDefaultsFromEnvironment(process.env);
-  const envoy = createEnvoyClient({ baseUrl: envoyDefaults.envoyUrl, fetch: globalThis.fetch });
+  const envoyOn = envoy.enabled ? {
+    heartbeatMs: envoy.heartbeatMs,
+    client: createEnvoyClient({
+      baseUrl: envoy.url,
+      fetch: globalThis.fetch,
+      token: envoy.token
+    })
+  } : undefined;
   let activeSessionID = null;
   let activeSessionTitle = null;
   const trackedSessions = new Map;
@@ -15073,15 +15724,7 @@ var server_default = async (input) => {
       return null;
     }
   };
-  const timer = setInterval(() => {
-    syncPort().then((resolved) => {
-      if (resolved)
-        clearInterval(timer);
-    });
-  }, 1000);
-  timer.unref();
-  syncPort().catch(() => {});
-  const subscribeSession = (sessionID, title, port, driving) => envoy.subscribe({
+  const subscribeSession = (client, sessionID, title, port, driving) => client.subscribe({
     sessionID,
     directory: cwd,
     topics: [agentSubject(sessionID)],
@@ -15089,20 +15732,31 @@ var server_default = async (input) => {
     title: title ?? "",
     driving
   }).catch(() => {});
-  const heartbeatMs = envoyDefaults.heartbeatMs;
-  const heartbeatInterval = setInterval(() => {
-    const port = currentPort();
-    if (!port)
-      return;
-    for (const [sessionID, info] of trackedSessions) {
-      subscribeSession(sessionID, info.title, port, info.driving);
-    }
-  }, heartbeatMs);
-  heartbeatInterval.unref?.();
-  process.on("exit", () => {
-    clearInterval(timer);
-    clearInterval(heartbeatInterval);
-  });
+  let stopEnvoy = () => {};
+  if (envoyOn !== undefined) {
+    const portTimer = setInterval(() => {
+      syncPort().then((resolved) => {
+        if (resolved)
+          clearInterval(portTimer);
+      });
+    }, 1000);
+    portTimer.unref();
+    syncPort().catch(() => {});
+    const heartbeatTimer = setInterval(() => {
+      const port = currentPort();
+      if (!port)
+        return;
+      for (const [sessionID, info] of trackedSessions) {
+        subscribeSession(envoyOn.client, sessionID, info.title, port, info.driving);
+      }
+    }, envoyOn.heartbeatMs);
+    heartbeatTimer.unref?.();
+    stopEnvoy = () => {
+      clearInterval(portTimer);
+      clearInterval(heartbeatTimer);
+    };
+  }
+  process.on("exit", stopEnvoy);
   return {
     config: (cfg) => {
       if (skillsDirectory) {
@@ -15121,6 +15775,8 @@ var server_default = async (input) => {
     "shell.env": async (input2, output) => {
       output.env.PATH = `${PLUGIN_BIN}${path3.delimiter}${output.env.PATH ?? process.env.PATH ?? ""}`;
       output.env.DISPATCH_HOST = "opencode";
+      if (configFile.path !== null)
+        output.env.ENVOY_CONFIG_FILE = configFile.path;
       output.env.DISPATCH_SESSION_ID = "";
       output.env.DISPATCH_SESSION_TITLE = "";
       if (input2.sessionID) {
@@ -15133,7 +15789,7 @@ var server_default = async (input) => {
     event: async ({
       event
     }) => {
-      if (activeSessionID)
+      if (envoy.enabled && activeSessionID)
         syncPort().catch(() => {});
       if (event.type === "session.status" && event.properties?.status?.type === "busy") {
         const sessionID = event.properties?.sessionID;
@@ -15143,26 +15799,29 @@ var server_default = async (input) => {
           if (!trackedSessions.has(sessionID)) {
             trackedSessions.set(sessionID, { title: null, driving: true });
           }
-          await syncPort();
-          const port = currentPort();
-          const titlePromise = fetchTitle(sessionID).then((t) => {
-            if (t && activeSessionID === sessionID)
-              activeSessionTitle = t;
-            return t;
+          const titlePromise = fetchTitle(sessionID).then((title) => {
+            if (!title)
+              return null;
+            const tracked = trackedSessions.get(sessionID);
+            if (tracked !== undefined) {
+              trackedSessions.set(sessionID, { title, driving: tracked.driving });
+            }
+            if (activeSessionID === sessionID)
+              activeSessionTitle = title;
+            return title;
           });
-          if (port) {
-            await subscribeSession(sessionID, activeSessionTitle, port, true);
-            titlePromise.then((title) => {
-              if (!title)
-                return;
-              if (trackedSessions.has(sessionID)) {
-                const driving = trackedSessions.get(sessionID)?.driving ?? true;
-                trackedSessions.set(sessionID, { title, driving });
-                subscribeSession(sessionID, title, currentPort() ?? 0, driving);
-              }
-              if (activeSessionID === sessionID)
-                activeSessionTitle = title;
-            });
+          if (envoyOn !== undefined) {
+            await syncPort();
+            const port = currentPort();
+            if (port) {
+              await subscribeSession(envoyOn.client, sessionID, activeSessionTitle, port, true);
+              titlePromise.then((title) => {
+                const tracked = trackedSessions.get(sessionID);
+                if (title && tracked !== undefined) {
+                  subscribeSession(envoyOn.client, sessionID, title, currentPort() ?? 0, tracked.driving);
+                }
+              });
+            }
           }
         }
       }
@@ -15175,119 +15834,12 @@ var server_default = async (input) => {
             activeSessionID = null;
             activeSessionTitle = null;
           }
-          envoy.unsubscribe({ sessionID: deletedID, topics: [] }).catch(() => {});
+          envoyOn?.client.unsubscribe({ sessionID: deletedID, topics: [] }).catch(() => {});
         }
       }
     },
-    dispose: () => {
-      clearInterval(timer);
-      clearInterval(heartbeatInterval);
-    },
-    tool: {
-      envoy_subscribe: tool({
-        description: subscribeSpec.description,
-        args: subscribeSpec.arguments(zodSchemaApi(tool.schema)),
-        async execute(args, ctx) {
-          ctx.metadata({ title: "Envoy subscribe" });
-          return JSON.stringify(await envoy.subscribe({
-            sessionID: ctx.sessionID,
-            directory: ctx.directory,
-            topics: args.topics,
-            port: currentPort() ?? 0,
-            title: activeSessionTitle ?? "",
-            driving: true
-          }));
-        }
-      }),
-      envoy_unsubscribe: tool({
-        description: unsubscribeSpec.description,
-        args: unsubscribeSpec.arguments(zodSchemaApi(tool.schema)),
-        async execute(args, ctx) {
-          ctx.metadata({ title: "Envoy unsubscribe" });
-          await envoy.unsubscribe({
-            sessionID: ctx.sessionID,
-            topics: args.topics ?? []
-          });
-          return "ok";
-        }
-      }),
-      envoy_list: tool({
-        description: listSpec.description,
-        args: listSpec.arguments(zodSchemaApi(tool.schema)),
-        async execute(_args, ctx) {
-          ctx.metadata({ title: "Envoy list" });
-          return JSON.stringify(await envoy.getInterest(ctx.sessionID));
-        }
-      }),
-      envoy_send: tool({
-        description: sendSpec.description,
-        args: sendSpec.arguments(zodSchemaApi(tool.schema)),
-        async execute(args, ctx) {
-          ctx.metadata({ title: "Envoy send" });
-          return JSON.stringify(await envoy.send({
-            sourceSessionID: ctx.sessionID,
-            targetSessionID: args.session_id,
-            message: args.message,
-            ...toMessageMetadata(args)
-          }));
-        }
-      }),
-      envoy_publish: tool({
-        description: publishSpec.description,
-        args: publishSpec.arguments(zodSchemaApi(tool.schema)),
-        async execute(args, ctx) {
-          ctx.metadata({ title: "Envoy publish" });
-          return JSON.stringify(await envoy.publish({
-            sourceSessionID: ctx.sessionID,
-            topic: args.topic,
-            message: args.message,
-            ...toMessageMetadata(args)
-          }));
-        }
-      }),
-      envoy_role_set: tool({
-        description: roleSetSpec.description,
-        args: roleSetSpec.arguments(zodSchemaApi(tool.schema)),
-        async execute(args, ctx) {
-          ctx.metadata({ title: "Set Envoy role" });
-          const result = await envoy.setRole({
-            sessionID: ctx.sessionID,
-            role: args.role
-          });
-          if (!result.claimed)
-            throw new Error(`role ${args.role} is held by ${result.holder}`);
-          return JSON.stringify(result.interest);
-        }
-      }),
-      envoy_whoami: tool({
-        description: whoamiSpec.description,
-        args: whoamiSpec.arguments(zodSchemaApi(tool.schema)),
-        async execute(_args, ctx) {
-          ctx.metadata({ title: "Envoy whoami" });
-          const sessionID = ctx.sessionID;
-          const port = currentPort();
-          return JSON.stringify({
-            session_id: sessionID,
-            machine_id: machineID(),
-            port,
-            dir: ctx.directory
-          }, null, 2);
-        }
-      }),
-      envoy_sessions: tool({
-        description: sessionsSpec.description,
-        args: sessionsSpec.arguments(zodSchemaApi(tool.schema)),
-        async execute(args, ctx) {
-          ctx.metadata({ title: "Envoy sessions" });
-          const sessions = await envoy.listSessions({
-            ...args.dir === undefined ? {} : { directory: args.dir },
-            ...args.title === undefined ? {} : { title: args.title }
-          });
-          const machine = args.machine;
-          return JSON.stringify(machine ? sessions.filter((session) => session.machine_id === machine) : sessions, null, 2);
-        }
-      })
-    }
+    dispose: stopEnvoy,
+    tool: envoyOn === undefined ? {} : envoyTools(envoyOn.client, currentPort, () => activeSessionTitle)
   };
 };
 export {